├── .prettierrc.json
├── .npmignore
├── index.ts
├── .travis.yml
├── jasmine.json
├── .gitignore
├── .editorconfig
├── tsconfig.json
├── src
    ├── types
    │   └── clean-css
    │   │   └── index.d.ts
    ├── test
    │   ├── exports.spec.ts
    │   ├── strategy.spec.ts
    │   └── minifyHTMLLiterals.spec.ts
    ├── strategy.ts
    └── minifyHTMLLiterals.ts
├── LICENSE.md
├── package.json
├── CHANGELOG.md
└── README.md


/.prettierrc.json:
--------------------------------------------------------------------------------
1 | {
2 |   "singleQuote": true
3 | }
4 | 


--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
1 | **/*
2 | !**/*.js
3 | !**/*.map
4 | !**/*.d.ts
5 | !**/*.md
6 | 


--------------------------------------------------------------------------------
/index.ts:
--------------------------------------------------------------------------------
1 | export * from './src/minifyHTMLLiterals';
2 | export * from './src/strategy';
3 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: node_js
2 | node_js:
3 |   - "node"
4 | script:
5 |   - npm test
6 |   - npm run coveralls
7 | 


--------------------------------------------------------------------------------
/jasmine.json:
--------------------------------------------------------------------------------
1 | {
2 |   "spec_files": ["**/*spec.ts"],
3 |   "stopSpecOnExpectationFailure": false,
4 |   "random": true
5 | }
6 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | /node_modules
2 | /coverage
3 | /.nyc_output
4 | **/*.js
5 | **/*.map
6 | **/*.d.ts
7 | !src/types/**/*.d.ts
8 | .wireit


--------------------------------------------------------------------------------
/.editorconfig:
--------------------------------------------------------------------------------
 1 | # editorconfig.org
 2 | 
 3 | root = true
 4 | 
 5 | [*]
 6 | indent_style = space
 7 | indent_size = 2
 8 | end_of_line = lf
 9 | charset = utf-8
10 | trim_trailing_whitespace = true
11 | insert_final_newline = true
12 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "declaration": true,
 4 |     "module": "commonjs",
 5 |     "moduleResolution": "node",
 6 |     "noUnusedLocals": true,
 7 |     "noUnusedParameters": true,
 8 |     "sourceMap": true,
 9 |     "strict": true,
10 |     "target": "esnext",
11 |     "typeRoots": ["./src/types", "./node_modules/@types"]
12 |   },
13 |   "include": ["index.ts", "src/**/*.ts"]
14 | }
15 | 


--------------------------------------------------------------------------------
/src/types/clean-css/index.d.ts:
--------------------------------------------------------------------------------
 1 | declare module 'clean-css/lib/options/optimization-level' {
 2 |   import { Options, OptimizationsOptions } from 'clean-css';
 3 | 
 4 |   export interface OptimizationLevel {
 5 |     Zero: '0';
 6 |     One: '1';
 7 |     Two: '2';
 8 |   }
 9 | 
10 |   export const OptimizationLevel: OptimizationLevel;
11 | 
12 |   export interface OptimizationLevelOptions {
13 |     [OptimizationLevel.Zero]: {};
14 |     [OptimizationLevel.One]: Required<
15 |       Omit<Exclude<OptimizationsOptions['1'], undefined>, 'all'>
16 |     >;
17 |     [OptimizationLevel.Two]: Required<
18 |       Omit<Exclude<OptimizationsOptions['2'], undefined>, 'all'>
19 |     >;
20 |   }
21 | 
22 |   export function optimizationLevelFrom(
23 |     source: Options['level']
24 |   ): OptimizationLevelOptions;
25 | }
26 | 


--------------------------------------------------------------------------------
/src/test/exports.spec.ts:
--------------------------------------------------------------------------------
 1 | import { expect } from 'chai';
 2 | import * as min from '../../index.js';
 3 | import {
 4 |   defaultGenerateSourceMap,
 5 |   defaultShouldMinify,
 6 |   defaultShouldMinifyCSS,
 7 |   defaultValidation,
 8 |   minifyHTMLLiterals
 9 | } from '../minifyHTMLLiterals.js';
10 | import {
11 |   adjustMinifyCSSOptions,
12 |   defaultMinifyCSSOptions,
13 |   defaultMinifyOptions,
14 |   defaultStrategy
15 | } from '../strategy.js';
16 | 
17 | describe('exports', () => {
18 |   it('should export minifyHTMLLiterals() function and defaults', () => {
19 |     expect(min).to.deep.equal({
20 |       minifyHTMLLiterals,
21 |       defaultGenerateSourceMap,
22 |       defaultShouldMinify,
23 |       defaultShouldMinifyCSS,
24 |       defaultValidation,
25 |       defaultMinifyOptions,
26 |       defaultMinifyCSSOptions,
27 |       defaultStrategy,
28 |       adjustMinifyCSSOptions
29 |     });
30 |   });
31 | });
32 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
1 | Copyright 2018 Elizabeth Mitchell
2 | 
3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
4 | 
5 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
6 | 
7 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
8 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "name": "minify-html-literals",
  3 |   "version": "1.3.5",
  4 |   "description": "Minify HTML template literal strings",
  5 |   "main": "index.js",
  6 |   "types": "index.d.ts",
  7 |   "author": "Liz Mitchell <asyncliz@gmail.com>",
  8 |   "license": "MIT",
  9 |   "keywords": [
 10 |     "minify",
 11 |     "html",
 12 |     "literal",
 13 |     "literals",
 14 |     "template",
 15 |     "tagged",
 16 |     "lit-html"
 17 |   ],
 18 |   "repository": {
 19 |     "type": "git",
 20 |     "url": "https://github.com/asyncLiz/minify-html-literals.git"
 21 |   },
 22 |   "scripts": {
 23 |     "build:ts": "wireit",
 24 |     "test": "wireit",
 25 |     "coveralls": "cat coverage/lcov.info | coveralls",
 26 |     "lint": "prettier --write \"*.{js,ts,json,md}\" \"{src,test}/**/*\"",
 27 |     "precommit": "lint-staged",
 28 |     "release": "standard-version",
 29 |     "prepublishOnly": "npm run build"
 30 |   },
 31 |   "wireit": {
 32 |     "build:ts": {
 33 |       "command": "tsc --pretty",
 34 |       "clean": "if-file-deleted",
 35 |       "files": [
 36 |         "src/**/*.ts",
 37 |         "!src/**/*.d.ts",
 38 |         "tsconfig.json"
 39 |       ],
 40 |       "output": [
 41 |         "src/**/*.{js,d.ts,js.map}",
 42 |         "!src/types/**/*.d.ts"
 43 |       ]
 44 |     },
 45 |     "test": {
 46 |       "command": "nyc mocha -r ts-node/register -r source-map-support/register src/test/*.js",
 47 |       "dependencies": [
 48 |         "build:ts"
 49 |       ],
 50 |       "output": [
 51 |         ".nyc_output",
 52 |         "coverage"
 53 |       ]
 54 |     }
 55 |   },
 56 |   "lint-staged": {
 57 |     "*.{js,ts,json,md}": [
 58 |       "prettier --write",
 59 |       "git add"
 60 |     ]
 61 |   },
 62 |   "nyc": {
 63 |     "extension": [
 64 |       ".ts"
 65 |     ],
 66 |     "include": [
 67 |       "index.ts",
 68 |       "src/**/*.ts"
 69 |     ],
 70 |     "exclude": [
 71 |       "**/*.d.ts"
 72 |     ],
 73 |     "reporter": [
 74 |       "html",
 75 |       "lcovonly",
 76 |       "text-summary"
 77 |     ],
 78 |     "all": true
 79 |   },
 80 |   "dependencies": {
 81 |     "clean-css": "^4.2.1",
 82 |     "html-minifier-terser": "^7.2.0",
 83 |     "magic-string": "^0.25.0",
 84 |     "parse-literals": "^1.2.1"
 85 |   },
 86 |   "devDependencies": {
 87 |     "@types/chai": "^4.1.4",
 88 |     "@types/clean-css": "^4.2.0",
 89 |     "@types/html-minifier-terser": "^7.0.2",
 90 |     "@types/mocha": "^5.2.5",
 91 |     "@types/node": "^14.14.32",
 92 |     "@types/sinon": "^5.0.1",
 93 |     "chai": "^4.1.2",
 94 |     "coveralls": "^3.0.2",
 95 |     "husky": "^0.14.3",
 96 |     "lint-staged": "^7.2.0",
 97 |     "mocha": "^7.2.0",
 98 |     "nyc": "^15.0.0",
 99 |     "prettier": "^1.13.7",
100 |     "rimraf": "^2.6.2",
101 |     "sinon": "^6.1.4",
102 |     "source-map-support": "^0.5.6",
103 |     "standard-version": "^9.0.0",
104 |     "ts-node": "^7.0.0",
105 |     "typescript": "^4.2.3",
106 |     "wireit": "^0.9.5"
107 |   }
108 | }
109 | 


--------------------------------------------------------------------------------
/src/test/strategy.spec.ts:
--------------------------------------------------------------------------------
  1 | import { expect } from 'chai';
  2 | import { minify } from 'html-minifier-terser';
  3 | import { defaultMinifyOptions, defaultStrategy } from '../strategy';
  4 | import { TemplatePart } from 'parse-literals';
  5 | 
  6 | describe('strategy', () => {
  7 |   describe('default', () => {
  8 |     const parts: TemplatePart[] = [
  9 |       {
 10 |         text: '<h1>',
 11 |         start: 0,
 12 |         end: 4
 13 |       },
 14 |       {
 15 |         text: '</h1>',
 16 |         start: 4,
 17 |         end: 5
 18 |       }
 19 |     ];
 20 | 
 21 |     describe('getPlaceholder()', () => {
 22 |       it('should return a string with @ and () in it with no spaces', () => {
 23 |         const placeholder = defaultStrategy.getPlaceholder(parts);
 24 |         expect(placeholder.indexOf('@')).to.equal(0, 'should start with @');
 25 |         expect(placeholder).to.include('()', 'should contain function parens');
 26 |       });
 27 | 
 28 |       it('should append "_" if placeholder exists in templates', () => {
 29 |         const regularPlaceholder = defaultStrategy.getPlaceholder(parts);
 30 |         const oneUnderscore = defaultStrategy.getPlaceholder([
 31 |           { text: regularPlaceholder, start: 0, end: regularPlaceholder.length }
 32 |         ]);
 33 | 
 34 |         expect(oneUnderscore).not.to.equal(regularPlaceholder);
 35 |         expect(oneUnderscore).to.include('_');
 36 | 
 37 |         const twoUnderscores = defaultStrategy.getPlaceholder([
 38 |           {
 39 |             text: regularPlaceholder,
 40 |             start: 0,
 41 |             end: regularPlaceholder.length
 42 |           },
 43 |           {
 44 |             text: oneUnderscore,
 45 |             start: regularPlaceholder.length,
 46 |             end: regularPlaceholder.length + oneUnderscore.length
 47 |           }
 48 |         ]);
 49 | 
 50 |         expect(twoUnderscores).not.to.equal(regularPlaceholder);
 51 |         expect(twoUnderscores).not.to.equal(oneUnderscore);
 52 |         expect(twoUnderscores).to.include('__');
 53 |       });
 54 | 
 55 |       it('should return a value that is preserved by html-minifier when splitting', async () => {
 56 |         const placeholder = defaultStrategy.getPlaceholder(parts);
 57 |         const minHtml = await defaultStrategy.minifyHTML(
 58 |           `
 59 |           <style>
 60 |             ${placeholder}
 61 | 
 62 |             p {
 63 |               ${placeholder}
 64 |               color: ${placeholder}
 65 |             }
 66 | 
 67 |             div {
 68 |               width: ${placeholder}
 69 |             }
 70 |           </style>
 71 |           <p style="color: ${placeholder}">
 72 |             ${placeholder}
 73 |           </p>
 74 |           <div id="${placeholder}" class="with ${placeholder}"></div>
 75 |         `,
 76 |           defaultMinifyOptions
 77 |         );
 78 | 
 79 |         console.log(minHtml);
 80 | 
 81 |         // 8 placeholders, 9 parts
 82 |         expect(
 83 |           defaultStrategy.splitHTMLByPlaceholder(minHtml, placeholder)
 84 |         ).to.have.lengthOf(9);
 85 |       });
 86 |     });
 87 | 
 88 |     describe('combineHTMLStrings()', () => {
 89 |       it('should join part texts by the placeholder', () => {
 90 |         const expected = '<h1>EXP</h1>';
 91 |         expect(defaultStrategy.combineHTMLStrings(parts, 'EXP')).to.equal(
 92 |           expected
 93 |         );
 94 |       });
 95 |     });
 96 | 
 97 |     describe('minifyHTML()', () => {
 98 |       it('should call minify() with html and options', async () => {
 99 |         const placeholder = defaultStrategy.getPlaceholder(parts);
100 |         const html = `
101 |           <style>${placeholder}</style>
102 |           <h1 class="heading">${placeholder}</h1>
103 |           <ul>
104 |             <li>${placeholder}</li>
105 |           </ul>
106 |         `;
107 | 
108 |         expect(
109 |           await defaultStrategy.minifyHTML(html, defaultMinifyOptions)
110 |         ).to.equal(await minify(html, defaultMinifyOptions));
111 |       });
112 |     });
113 | 
114 |     describe('splitHTMLByPlaceholder()', () => {
115 |       it('should split string by the placeholder', () => {
116 |         const expected = ['<h1>', '</h1>'];
117 |         expect(
118 |           defaultStrategy.splitHTMLByPlaceholder('<h1>EXP</h1>', 'EXP')
119 |         ).to.deep.equal(expected);
120 |       });
121 | 
122 |       it('should handle if a placeholder is missing its semicolon', () => {
123 |         const expected = ['<h1>', '</h1><button onclick="', '"></button>'];
124 |         const html = `<h1>EXP;</h1><button onclick="EXP"></button>`;
125 |         expect(
126 |           defaultStrategy.splitHTMLByPlaceholder(html, 'EXP;')
127 |         ).to.deep.equal(expected);
128 |       });
129 |     });
130 |   });
131 | });
132 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
  1 | # Changelog
  2 | 
  3 | All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
  4 | 
  5 | ### [1.3.5](https://github.com/asyncLiz/minify-html-literals/compare/v1.3.4...v1.3.5) (2021-03-09)
  6 | 
  7 | 
  8 | ### Bug Fixes
  9 | 
 10 | * typing build error ([9571152](https://github.com/asyncLiz/minify-html-literals/commit/9571152724e542d329aea6e79bf609a67e20bec6))
 11 | 
 12 | ### [1.3.4](https://github.com/asyncLiz/minify-html-literals/compare/v1.3.3...v1.3.4) (2021-03-09)
 13 | 
 14 | 
 15 | ### Bug Fixes
 16 | 
 17 | * build errors ([ee4d596](https://github.com/asyncLiz/minify-html-literals/commit/ee4d596c2797cea335af2c43ba0368ec3d6fa518))
 18 | 
 19 | ### [1.3.3](https://github.com/asyncLiz/minify-html-literals/compare/v1.3.2...v1.3.3) (2021-03-09)
 20 | 
 21 | 
 22 | ### Bug Fixes
 23 | 
 24 | * html attribute placeholders throwing split error [#28](https://github.com/asyncLiz/minify-html-literals/issues/28) ([b1e14dc](https://github.com/asyncLiz/minify-html-literals/commit/b1e14dca1a5ed9e6599193f474992729953f885d))
 25 | * minify multiline svg elements ([9f37d2d](https://github.com/asyncLiz/minify-html-literals/commit/9f37d2d6442a6533a90c1728f80aeb78d6060d9b))
 26 | * parse errors with JS comments in HTML attributes with no quotes ([0f5a842](https://github.com/asyncLiz/minify-html-literals/commit/0f5a842c54f3514c72c79eaf6749f15770818550))
 27 | * spaces in pseudo classes (like ::part) are not removed ([85526fc](https://github.com/asyncLiz/minify-html-literals/commit/85526fcb889e288e1adbb5c7ff9feca41d45acff)), closes [#26](https://github.com/asyncLiz/minify-html-literals/issues/26)
 28 | 
 29 | ### [1.3.2](https://github.com/asyncLiz/minify-html-literals/compare/v1.3.1...v1.3.2) (2020-08-18)
 30 | 
 31 | 
 32 | ### Bug Fixes
 33 | 
 34 | * css tagged templates not respecting semicolons ([#22](https://github.com/asyncLiz/minify-html-literals/issues/22)) ([3651a0b](https://github.com/asyncLiz/minify-html-literals/commit/3651a0bc30167deccdfb21b4177827072df16cb5))
 35 | 
 36 | ### [1.3.1](https://github.com/asyncLiz/minify-html-literals/compare/v1.3.0...v1.3.1) (2020-06-10)
 37 | 
 38 | 
 39 | ### Bug Fixes
 40 | 
 41 | * don't remove attribute quotes by default. Fixes [#12](https://github.com/asyncLiz/minify-html-literals/issues/12). ([#13](https://github.com/asyncLiz/minify-html-literals/issues/13)) ([e18ae65](https://github.com/asyncLiz/minify-html-literals/commit/e18ae65e202802cb2fd793089f76de3af54fec6f))
 42 | 
 43 | ## [1.3.0](https://github.com/asyncLiz/minify-html-literals/compare/v1.2.2...v1.3.0) (2020-02-08)
 44 | 
 45 | ### Features
 46 | 
 47 | - minify svg-tagged templates [#9](https://github.com/asyncLiz/minify-html-literals/issues/9) ([62da810](https://github.com/asyncLiz/minify-html-literals/commit/62da810894a1f2c3705783ebb1a4264cf8989ee4))
 48 | 
 49 | ### Bug Fixes
 50 | 
 51 | - update to html-minifier v4.0.0 ([6ddfd10](https://github.com/asyncLiz/minify-html-literals/commit/6ddfd104307347b7a66739b3c4e418bb6686e94e))
 52 | - update to parse-literals v1.2.0 ([bba4c7d](https://github.com/asyncLiz/minify-html-literals/commit/bba4c7d12b9d92635ed1d72d00d69086a45d8edb))
 53 | 
 54 | <a name="1.2.2"></a>
 55 | 
 56 | ## [1.2.2](https://github.com/asyncLiz/minify-html-literals/compare/v1.2.1...v1.2.2) (2019-02-13)
 57 | 
 58 | ### Bug Fixes
 59 | 
 60 | - failure to minify templates prefixed with comments ([8805f69](https://github.com/asyncLiz/minify-html-literals/commit/8805f69))
 61 | 
 62 | <a name="1.2.1"></a>
 63 | 
 64 | ## [1.2.1](https://github.com/asyncLiz/minify-html-literals/compare/v1.2.0...v1.2.1) (2019-02-13)
 65 | 
 66 | ### Bug Fixes
 67 | 
 68 | - remove source files from package ([b53c052](https://github.com/asyncLiz/minify-html-literals/commit/b53c052))
 69 | 
 70 | <a name="1.2.0"></a>
 71 | 
 72 | # [1.2.0](https://github.com/asyncLiz/minify-html-literals/compare/v1.1.2...v1.2.0) (2019-02-13)
 73 | 
 74 | ### Features
 75 | 
 76 | - add ability to minify css-tagged templates ([d37a037](https://github.com/asyncLiz/minify-html-literals/commit/d37a037)), closes [#3](https://github.com/asyncLiz/minify-html-literals/issues/3)
 77 | 
 78 | <a name="1.1.2"></a>
 79 | 
 80 | ## [1.1.2](https://github.com/asyncLiz/minify-html-literals/compare/v1.1.1...v1.1.2) (2018-11-29)
 81 | 
 82 | ### Bug Fixes
 83 | 
 84 | - update to html-minifier 3.5.21 ([11a9f6b](https://github.com/asyncLiz/minify-html-literals/commit/11a9f6b))
 85 | - **strategy:** error when minifying inline CSS style placeholders [#1](https://github.com/asyncLiz/minify-html-literals/issues/1) ([2226ae2](https://github.com/asyncLiz/minify-html-literals/commit/2226ae2))
 86 | 
 87 | <a name="1.1.1"></a>
 88 | 
 89 | ## [1.1.1](https://github.com/asyncLiz/minify-html-literals/compare/v1.1.0...v1.1.1) (2018-10-25)
 90 | 
 91 | ### Bug Fixes
 92 | 
 93 | - fail to minify with <style> placeholders ([64b9b6f](https://github.com/asyncLiz/minify-html-literals/commit/64b9b6f))
 94 | 
 95 | <a name="1.1.0"></a>
 96 | 
 97 | # [1.1.0](https://github.com/asyncLiz/minify-html-literals/compare/v1.0.7...v1.1.0) (2018-10-24)
 98 | 
 99 | ### Bug Fixes
100 | 
101 | - do not fail on empty template literals ([b74973a](https://github.com/asyncLiz/minify-html-literals/commit/b74973a))
102 | - update parse-literals to 1.1.0 ([5ba1e99](https://github.com/asyncLiz/minify-html-literals/commit/5ba1e99))
103 | 
104 | ### Features
105 | 
106 | - allow partial minify options to make it easier to customize ([f007988](https://github.com/asyncLiz/minify-html-literals/commit/f007988))
107 | - do not require options or filename ([6649ac9](https://github.com/asyncLiz/minify-html-literals/commit/6649ac9))
108 | 
109 | <a name="1.0.7"></a>
110 | 
111 | ## [1.0.7](https://github.com/asyncLiz/minify-html-literals/compare/v1.0.6...v1.0.7) (2018-10-05)
112 | 
113 | ### Bug Fixes
114 | 
115 | - do not remove tag whitespace ([89f362a](https://github.com/asyncLiz/minify-html-literals/commit/89f362a))
116 | 
117 | <a name="1.0.6"></a>
118 | 
119 | ## [1.0.6](https://github.com/asyncLiz/minify-html-literals/compare/v1.0.5...v1.0.6) (2018-10-03)
120 | 
121 | ### Bug Fixes
122 | 
123 | - do not collapse boolean attributes for Polymer binding syntax ([80df154](https://github.com/asyncLiz/minify-html-literals/commit/80df154))
124 | 
125 | <a name="1.0.5"></a>
126 | 
127 | ## [1.0.5](https://github.com/asyncLiz/minify-html-literals/compare/v1.0.4...v1.0.5) (2018-09-27)
128 | 
129 | ### Bug Fixes
130 | 
131 | - update parse-literals to fix escaped character minifying ([93922c8](https://github.com/asyncLiz/minify-html-literals/commit/93922c8))
132 | 
133 | <a name="1.0.4"></a>
134 | 
135 | ## [1.0.4](https://github.com/asyncLiz/minify-html-literals/compare/v1.0.3...v1.0.4) (2018-09-19)
136 | 
137 | ### Bug Fixes
138 | 
139 | - do not sort attributes or class names ([b72a5c4](https://github.com/asyncLiz/minify-html-literals/commit/b72a5c4))
140 | 
141 | <a name="1.0.3"></a>
142 | 
143 | ## [1.0.3](https://github.com/asyncLiz/minify-html-literals/compare/v1.0.2...v1.0.3) (2018-09-19)
144 | 
145 | ### Bug Fixes
146 | 
147 | - use hires sourcemaps by default ([7f132b2](https://github.com/asyncLiz/minify-html-literals/commit/7f132b2))
148 | 
149 | <a name="1.0.2"></a>
150 | 
151 | ## [1.0.2](https://github.com/asyncLiz/minify-html-literals/compare/v1.0.1...v1.0.2) (2018-09-13)
152 | 
153 | ### Bug Fixes
154 | 
155 | - remove unused import ([e37a43a](https://github.com/asyncLiz/minify-html-literals/commit/e37a43a))
156 | 
157 | <a name="1.0.1"></a>
158 | 
159 | ## 1.0.1 (2018-07-24)
160 | 
161 | ### Bug Fixes
162 | 
163 | - option type errors ([b917607](https://github.com/asyncLiz/minify-html-literals/commit/b917607))
164 | 
165 | ### Features
166 | 
167 | - initial release ([cadf7c2](https://github.com/asyncLiz/minify-html-literals/commit/cadf7c2))
168 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # minify-html-literals
  2 | 
  3 | _Minify HTML markup inside JavaScript template literal strings._
  4 | 
  5 | [![npm](https://img.shields.io/npm/v/minify-html-literals.svg)](https://www.npmjs.com/package/minify-html-literals)
  6 | [![Build Status](https://travis-ci.com/asyncLiz/minify-html-literals.svg?branch=master)](https://travis-ci.com/asyncLiz/minify-html-literals)
  7 | [![Coverage Status](https://coveralls.io/repos/github/asyncLiz/minify-html-literals/badge.svg?branch=master)](https://coveralls.io/github/asyncLiz/minify-html-literals?branch=master)
  8 | 
  9 | ## Why?
 10 | 
 11 | Template literals are often used in JavaScript to write HTML and CSS markup (ex. [lit-html](https://www.npmjs.com/package/lit-html)). This library allows a developer to minify markup that is normally ignored by JavaScript minifiers.
 12 | 
 13 | ## Usage
 14 | 
 15 | ```js
 16 | import { minifyHTMLLiterals } from 'minify-html-literals';
 17 | // const minifyHTMLLiterals = require('minify-html-literals').minifyHTMLLiterals
 18 | 
 19 | const result = minifyHTMLLiterals(
 20 |   `function render(title, items) {
 21 |     return html\`
 22 |       <style>
 23 |         .heading {
 24 |           color: blue;
 25 |         }
 26 |       </style>
 27 |       <h1 class="heading">\${title}</h1>
 28 |       <ul>
 29 |         \${items.map(item => {
 30 |           return getHTML()\`
 31 |             <li>\${item}</li>
 32 |           \`;
 33 |         })}
 34 |       </ul>
 35 |     \`;
 36 |   }`,
 37 |   {
 38 |     fileName: 'render.js'
 39 |   }
 40 | );
 41 | 
 42 | console.log(result.code);
 43 | //  function render(title, items) {
 44 | //    return html`<style>.heading{color:#00f}</style><h1 class=heading>${title}</h1><ul>${items.map(item => {
 45 | //          return getHTML()`<li>${item}</li>`;
 46 | //        })}</ul>`;
 47 | //  }
 48 | 
 49 | console.log(result.map);
 50 | // {
 51 | //   "version": 3,
 52 | //   "file": "render.js.map",
 53 | //   "sources": ["render.js"],
 54 | //   "sourcesContent": [null],
 55 | //   "names": [],
 56 | //   "mappings": "AAAA;gBACgB,qDAMU,QAAQ,SAE1B;2BACmB,IACX,OAAO,KACb;WACC,KAEP;"
 57 | // }
 58 | ```
 59 | 
 60 | ### ES5 Transpiling Warning
 61 | 
 62 | Be sure to minify template literals _before_ transpiling to ES5. Otherwise, the API will not be able to find any template literal (`` `${}` ``) strings.
 63 | 
 64 | ## Supported Source Syntax
 65 | 
 66 | - JavaScript
 67 | - TypeScript
 68 | 
 69 | ## Options
 70 | 
 71 | ### Basic
 72 | 
 73 | The following options are common to typical use cases.
 74 | 
 75 | | Property                    | Type                                                                                         | Default                   | Description                                                                                                                                                               |
 76 | | --------------------------- | -------------------------------------------------------------------------------------------- | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 77 | | `fileName`                  | string                                                                                       |                           | _Required._ The name of the file, used for syntax parsing and source maps.                                                                                                |
 78 | | `minifyOptions?`            | [html-minifier options](https://www.npmjs.com/package/html-minifier#options-quick-reference) | `defaultMinifyOptions`    | Defaults to production-ready minification.                                                                                                                                |
 79 | | `minifyOptions?.minifyCSS?` | [clean-css options](https://www.npmjs.com/package/clean-css#constructor-options)             | `defaultMinifyCSSOptions` | Uses clean-css defaults.                                                                                                                                                  |
 80 | | `shouldMinify?`             | function                                                                                     | `defaultShouldMinify`     | A function that determines whether or not an HTML template should be minified. Defaults to minify all tagged templates whose tag name contains "html" (case insensitive). |
 81 | | `shouldMinifyCSS?`          | function                                                                                     | `defaultShouldMinifyCSS`  | A function that determines whether or not a CSS template should be minified. Defaults to minify all tagged templates whose tag name contains "css" (case insensitive).    |
 82 | 
 83 | ### Advanced
 84 | 
 85 | All aspects of the API are exposed and customizable. The following options will not typically be used unless you need to change how a certain aspect of the API handles a use case.
 86 | 
 87 | | Property                | Type                                                                      | Default                                                        | Description                                                                                                                                                |
 88 | | ----------------------- | ------------------------------------------------------------------------- | -------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
 89 | | `generateSourceMap?`    | boolean or `(ms: MagicString, fileName: string) => SourceMap | undefined` | `defaultGenerateSourceMap`                                     | Set to `false` to disable source maps, or a custom function to control how source maps are generated from a `MagicString` instance.                        |
 90 | | `strategy?`             | object                                                                    | `defaultStrategy`                                              | An object with methods defining how to minify HTML. The default strategy uses [html-minifier](https://www.npmjs.com/package/html-minifier).                |
 91 | | `validate?`             | boolean or object                                                         | `defaultValidation`                                            | Set to `false` to disable strategy validation checks, or to a custom set of validation functions. This is only useful when implementing a custom strategy. |
 92 | | `parseLiterals?`        | function                                                                  | [parse-literals](https://www.npmjs.com/package/parse-literals) | Override the function used to parse template literals from a source string.                                                                                |
 93 | | `parseLiteralsOptions?` | object                                                                    |                                                                | Additional options to pass to `parseLiterals()`                                                                                                            |
 94 | | `MagicString?`          | function                                                                  | [MagicString](https://www.npmjs.com/package/magic-string)      | Override the MagicString-like constructor to use for manipulating the source string and generating source maps.                                            |
 95 | 
 96 | ## Customization Examples
 97 | 
 98 | ### Minify non-tagged templates
 99 | 
100 | > This is particularly useful for libraries that define templates without using tags, such as Polymer's `<dom-module>`.
101 | 
102 | ```js
103 | import { minifyHTMLLiterals, defaultShouldMinify } from 'minify-html-literals';
104 | 
105 | minifyHTMLLiterals(
106 |   `
107 |     template.innerHTML = \`
108 |       <dom-module id="custom-styles">
109 |         <style>
110 |           html {
111 |             --custom-color: blue;
112 |           }
113 |         </style>
114 |       </dom-module>
115 |     \`;
116 |   `,
117 |   {
118 |     fileName: 'render.js',
119 |     shouldMinify(template) {
120 |       return (
121 |         defaultShouldMinify(template) ||
122 |         template.parts.some(part => {
123 |           return part.text.includes('<dom-module>');
124 |         })
125 |       );
126 |     }
127 |   }
128 | );
129 | ```
130 | 
131 | ### Do not minify CSS
132 | 
133 | ```js
134 | import { minifyHTMLLiterals, defaultMinifyOptions } from 'minify-html-literals';
135 | 
136 | minifyHTMLLiterals(source, {
137 |   fileName: 'render.js',
138 |   minifyOptions: {
139 |     ...defaultMinifyOptions,
140 |     minifyCSS: false
141 |   },
142 |   shouldMinifyCSS: () => false
143 | });
144 | ```
145 | 
146 | ### Modify generated SourceMap
147 | 
148 | ```js
149 | minifyHTMLLiterals(source, {
150 |   fileName: 'render.js',
151 |   generateSourceMap(ms, fileName) {
152 |     return ms.generateMap({
153 |       file: `${fileName}-converted.map`, // change file name
154 |       source: fileName,
155 |       includeContent: true // include source contents
156 |     });
157 |   }
158 | });
159 | ```
160 | 


--------------------------------------------------------------------------------
/src/strategy.ts:
--------------------------------------------------------------------------------
  1 | /// <reference types="./types/clean-css" />
  2 | // Reference needed for d.ts distribution files in rollup-plugin-minify-html-literals
  3 | import * as CleanCSS from 'clean-css';
  4 | import {
  5 |   OptimizationLevel,
  6 |   optimizationLevelFrom
  7 | } from 'clean-css/lib/options/optimization-level';
  8 | import { Options as HTMLOptions, minify } from 'html-minifier-terser';
  9 | import { TemplatePart } from 'parse-literals';
 10 | 
 11 | /**
 12 |  * A strategy on how to minify HTML and optionally CSS.
 13 |  *
 14 |  * @template O minify HTML options
 15 |  * @template C minify CSS options
 16 |  */
 17 | export interface Strategy<O = any, C = any> {
 18 |   /**
 19 |    * Retrieve a placeholder for the given array of template parts. The
 20 |    * placeholder returned should be the same if the function is invoked with the
 21 |    * same array of parts.
 22 |    *
 23 |    * The placeholder should be an HTML-compliant string that is not present in
 24 |    * any of the parts' text.
 25 |    *
 26 |    * @param parts the parts to get a placeholder for
 27 |    * @returns the placeholder
 28 |    */
 29 |   getPlaceholder(parts: TemplatePart[]): string;
 30 |   /**
 31 |    * Combines the parts' HTML text strings together into a single string using
 32 |    * the provided placeholder. The placeholder indicates where a template
 33 |    * expression occurs.
 34 |    *
 35 |    * @param parts the parts to combine
 36 |    * @param placeholder the placeholder to use between parts
 37 |    * @returns the combined parts' text strings
 38 |    */
 39 |   combineHTMLStrings(parts: TemplatePart[], placeholder: string): string;
 40 |   /**
 41 |    * Minifies the provided HTML string.
 42 |    *
 43 |    * @param html the html to minify
 44 |    * @param options html minify options
 45 |    * @returns minified HTML string
 46 |    */
 47 |   minifyHTML(html: string, options?: O): Promise<string>;
 48 |   /**
 49 |    * Minifies the provided CSS string.
 50 |    *
 51 |    * @param css the css to minfiy
 52 |    * @param options css minify options
 53 |    * @returns minified CSS string
 54 |    */
 55 |   minifyCSS?(css: string, options?: C): string;
 56 |   /**
 57 |    * Splits a minified HTML string back into an array of strings from the
 58 |    * provided placeholder. The returned array of strings should be the same
 59 |    * length as the template parts that were combined to make the HTML string.
 60 |    *
 61 |    * @param html the html string to split
 62 |    * @param placeholder the placeholder to split by
 63 |    * @returns an array of html strings
 64 |    */
 65 |   splitHTMLByPlaceholder(html: string, placeholder: string): string[];
 66 | }
 67 | 
 68 | /**
 69 |  * The default <code>clean-css</code> options, optimized for production
 70 |  * minification.
 71 |  */
 72 | export const defaultMinifyCSSOptions: CleanCSS.Options = {};
 73 | 
 74 | /**
 75 |  * The default <code>html-minifier</code> options, optimized for production
 76 |  * minification.
 77 |  */
 78 | export const defaultMinifyOptions: HTMLOptions = {
 79 |   caseSensitive: true,
 80 |   collapseWhitespace: true,
 81 |   decodeEntities: true,
 82 |   minifyCSS: defaultMinifyCSSOptions,
 83 |   minifyJS: true,
 84 |   processConditionalComments: true,
 85 |   removeAttributeQuotes: false,
 86 |   removeComments: true,
 87 |   removeEmptyAttributes: true,
 88 |   removeScriptTypeAttributes: true,
 89 |   removeStyleLinkTypeAttributes: true,
 90 |   useShortDoctype: true
 91 | };
 92 | 
 93 | /**
 94 |  * The default strategy. This uses <code>html-minifier</code> to minify HTML and
 95 |  * <code>clean-css</code> to minify CSS.
 96 |  */
 97 | export const defaultStrategy: Strategy<HTMLOptions, CleanCSS.Options> = {
 98 |   getPlaceholder(parts) {
 99 |     // Using @ and (); will cause the expression not to be removed in CSS.
100 |     // However, sometimes the semicolon can be removed (ex: inline styles).
101 |     // In those cases, we want to make sure that the HTML splitting also
102 |     // accounts for the missing semicolon.
103 |     const suffix = '();';
104 |     let placeholder = '@TEMPLATE_EXPRESSION';
105 |     while (parts.some(part => part.text.includes(placeholder + suffix))) {
106 |       placeholder += '_';
107 |     }
108 | 
109 |     return placeholder + suffix;
110 |   },
111 |   combineHTMLStrings(parts, placeholder) {
112 |     return parts.map(part => part.text).join(placeholder);
113 |   },
114 |   minifyHTML: async function(html, options = {}) {
115 |     let minifyCSSOptions: HTMLOptions['minifyCSS'];
116 |     if (options.minifyCSS) {
117 |       if (
118 |         options.minifyCSS !== true &&
119 |         typeof options.minifyCSS !== 'function'
120 |       ) {
121 |         minifyCSSOptions = { ...options.minifyCSS };
122 |       } else {
123 |         minifyCSSOptions = {};
124 |       }
125 |     } else {
126 |       minifyCSSOptions = false;
127 |     }
128 | 
129 |     let adjustedMinifyCSSOptions:
130 |       | false
131 |       | ReturnType<typeof adjustMinifyCSSOptions> = false;
132 |     if (minifyCSSOptions) {
133 |       adjustedMinifyCSSOptions = adjustMinifyCSSOptions(minifyCSSOptions);
134 |     }
135 | 
136 |     let result = await minify(html, {
137 |       ...options,
138 |       minifyCSS: adjustedMinifyCSSOptions
139 |     });
140 | 
141 |     if (options.collapseWhitespace) {
142 |       // html-minifier does not support removing newlines inside <svg>
143 |       // attributes. Support this, but be careful not to remove newlines from
144 |       // supported areas (such as within <pre> and <textarea> tags).
145 |       const matches = Array.from(result.matchAll(/<svg/g)).reverse();
146 |       for (const match of matches) {
147 |         const startTagIndex = match.index!;
148 |         const closeTagIndex = result.indexOf('</svg', startTagIndex);
149 |         if (closeTagIndex < 0) {
150 |           // Malformed SVG without a closing tag
151 |           continue;
152 |         }
153 | 
154 |         const start = result.substring(0, startTagIndex);
155 |         let svg = result.substring(startTagIndex, closeTagIndex);
156 |         const end = result.substring(closeTagIndex);
157 |         svg = svg.replace(/\r?\n/g, '');
158 |         result = start + svg + end;
159 |       }
160 |     }
161 | 
162 |     if (
163 |       adjustedMinifyCSSOptions &&
164 |       adjustedMinifyCSSOptions.level[OptimizationLevel.One].tidySelectors
165 |     ) {
166 |       // Fix https://github.com/jakubpawlowicz/clean-css/issues/996
167 |       result = fixCleanCssTidySelectors(html, result);
168 |     }
169 | 
170 |     return result;
171 |   },
172 |   minifyCSS(css, options = {}) {
173 |     const adjustedOptions = adjustMinifyCSSOptions(options);
174 |     const output = new CleanCSS(adjustedOptions).minify(css);
175 |     if (output.errors && output.errors.length) {
176 |       throw new Error(output.errors.join('\n\n'));
177 |     }
178 | 
179 |     if (adjustedOptions.level[OptimizationLevel.One].tidySelectors) {
180 |       output.styles = fixCleanCssTidySelectors(css, output.styles);
181 |     }
182 | 
183 |     return output.styles;
184 |   },
185 |   splitHTMLByPlaceholder(html, placeholder) {
186 |     const parts = html.split(placeholder);
187 |     // Make the last character (a semicolon) optional. See above.
188 |     if (placeholder.endsWith(';')) {
189 |       const withoutSemicolon = placeholder.substring(0, placeholder.length - 1);
190 |       for (let i = parts.length - 1; i >= 0; i--) {
191 |         parts.splice(i, 1, ...parts[i].split(withoutSemicolon));
192 |       }
193 |     }
194 | 
195 |     return parts;
196 |   }
197 | };
198 | 
199 | export function adjustMinifyCSSOptions(options: CleanCSS.Options = {}) {
200 |   const level = optimizationLevelFrom(options.level);
201 |   const originalTransform =
202 |     typeof options.level === 'object' &&
203 |     options.level[1] &&
204 |     options.level[1].transform;
205 |   level[OptimizationLevel.One].transform = (property, value) => {
206 |     if (value.startsWith('@TEMPLATE_EXPRESSION') && !value.endsWith(';')) {
207 |       // The CSS minifier has removed the semicolon from the placeholder
208 |       // and we need to add it back.
209 |       return (value = `${value};`);
210 |     }
211 | 
212 |     return originalTransform ? originalTransform(property, value) : value;
213 |   };
214 | 
215 |   return {
216 |     ...options,
217 |     level
218 |   };
219 | }
220 | 
221 | function fixCleanCssTidySelectors(original: string, result: string) {
222 |   const regex = /(::?.+\((.*)\))[\s\r\n]*{/gm;
223 |   let match: RegExpMatchArray | null;
224 |   while ((match = regex.exec(original)) != null) {
225 |     const pseudoClass = match[1];
226 |     const parameters = match[2];
227 |     if (!parameters.match(/\s/)) {
228 |       continue;
229 |     }
230 | 
231 |     const parametersWithoutSpaces = parameters.replace(/\s/g, '');
232 |     const resultPseudoClass = pseudoClass.replace(
233 |       parameters,
234 |       parametersWithoutSpaces
235 |     );
236 |     const resultStartIndex = result.indexOf(resultPseudoClass);
237 |     if (resultStartIndex < 0) {
238 |       continue;
239 |     }
240 | 
241 |     const resultEndIndex = resultStartIndex + resultPseudoClass.length;
242 |     // Restore the original pseudo class with spaces
243 |     result =
244 |       result.substring(0, resultStartIndex) +
245 |       pseudoClass +
246 |       result.substring(resultEndIndex);
247 |   }
248 | 
249 |   return result;
250 | }
251 | 


--------------------------------------------------------------------------------
/src/minifyHTMLLiterals.ts:
--------------------------------------------------------------------------------
  1 | import MagicString, { SourceMapOptions } from 'magic-string';
  2 | import {
  3 |   Template,
  4 |   TemplatePart,
  5 |   ParseLiteralsOptions,
  6 |   parseLiterals
  7 | } from 'parse-literals';
  8 | import { Strategy, defaultMinifyOptions, defaultStrategy } from './strategy';
  9 | 
 10 | /**
 11 |  * Options for <code>minifyHTMLLiterals()</code>.
 12 |  */
 13 | export type Options = DefaultOptions | CustomOptions<any>;
 14 | 
 15 | /**
 16 |  * Options for <code>minifyHTMLLiterals()</code>, using default html-minifier
 17 |  * strategy.
 18 |  */
 19 | export interface DefaultOptions extends BaseOptions {
 20 |   /**
 21 |    * <code>html-minifier</code> options to use. Defaults to
 22 |    * <code>defaultMinifyOptions</code>, for production-ready minification.
 23 |    */
 24 |   minifyOptions?: Partial<typeof defaultMinifyOptions>;
 25 | }
 26 | 
 27 | /**
 28 |  * Options for <code>minifyHTMLLiterals()</code>, using a custom strategy.
 29 |  */
 30 | export interface CustomOptions<S extends Strategy> extends BaseOptions {
 31 |   /**
 32 |    * HTML minification options.
 33 |    */
 34 |   minifyOptions?: S extends Strategy<infer O> ? Partial<O> : never;
 35 |   /**
 36 |    * Override the default strategy for how to minify HTML. The default is to
 37 |    * use <code>html-minifier</code>.
 38 |    */
 39 |   strategy: S;
 40 | }
 41 | 
 42 | /**
 43 |  * Options for <code>minifyHTMLLiterals()</code>.
 44 |  */
 45 | export interface BaseOptions {
 46 |   /**
 47 |    * The name of the file. This is used to determine how to parse the source
 48 |    * code and for source map filenames. It may be a base name, relative, or
 49 |    * absolute path.
 50 |    */
 51 |   fileName?: string;
 52 |   /**
 53 |    * Override how source maps are generated. Set to false to disable source map
 54 |    * generation.
 55 |    *
 56 |    * @param ms the MagicString instance with code modifications
 57 |    * @param fileName the name or path of the file
 58 |    * @returns a v3 SourceMap or undefined
 59 |    */
 60 |   generateSourceMap?:
 61 |     | ((ms: MagicStringLike, fileName: string) => SourceMap | undefined)
 62 |     | false;
 63 |   /**
 64 |    * The MagicString-like constructor to use. MagicString is used to replace
 65 |    * strings and generate source maps.
 66 |    *
 67 |    * Override if you want to set your own version of MagicString or change how
 68 |    * strings are overridden. Use <code>generateSourceMap</code> if you want to
 69 |    * change how source maps are created.
 70 |    */
 71 |   MagicString?: { new (source: string): MagicStringLike };
 72 |   /**
 73 |    * Override how template literals are parsed from a source string.
 74 |    */
 75 |   parseLiterals?: typeof parseLiterals;
 76 |   /**
 77 |    * Options for <code>parseLiterals()</code>.
 78 |    */
 79 |   parseLiteralsOptions?: Partial<ParseLiteralsOptions>;
 80 |   /**
 81 |    * Determines whether or not a template should be minified. The default is to
 82 |    * minify all tagged template whose tag name contains "html" (case
 83 |    * insensitive).
 84 |    *
 85 |    * @param template the template to check
 86 |    * @returns true if the template should be minified
 87 |    */
 88 |   shouldMinify?(template: Template): boolean;
 89 |   /**
 90 |    * Determines whether or not a CSS template should be minified. The default is
 91 |    * to minify all tagged template whose tag name contains "css" (case
 92 |    * insensitive).
 93 |    *
 94 |    * @param template the template to check
 95 |    * @returns true if the template should be minified
 96 |    */
 97 |   shouldMinifyCSS?(template: Template): boolean;
 98 |   /**
 99 |    * Override custom validation or set to false to disable validation. This is
100 |    * only useful when implementing your own strategy that may return
101 |    * unexpected results.
102 |    */
103 |   validate?: Validation | false;
104 | }
105 | 
106 | /**
107 |  * A MagicString-like instance. <code>minify-html-literals</code> only uses a
108 |  * subset of the MagicString API to overwrite the source code and generate
109 |  * source maps.
110 |  */
111 | export interface MagicStringLike {
112 |   generateMap(options?: Partial<SourceMapOptions>): SourceMap;
113 |   overwrite(start: number, end: number, content: string): any;
114 |   toString(): string;
115 | }
116 | 
117 | /**
118 |  * A v3 SourceMap.
119 |  *
120 |  * <code>magic-string> incorrectly declares the SourceMap type with a version
121 |  * string instead of a number, so <code>minify-html-literals</code> declares
122 |  * its own type.
123 |  */
124 | export interface SourceMap {
125 |   version: number | string;
126 |   file: string | null;
127 |   sources: Array<string | null>;
128 |   sourcesContent: Array<string | null>;
129 |   names: string[];
130 |   mappings: string;
131 |   toString(): string;
132 |   toUrl(): string;
133 | }
134 | 
135 | /**
136 |  * Validation that is executed when minifying HTML to ensure there are no
137 |  * unexpected errors. This is to alleviate hard-to-troubleshoot errors such as
138 |  * undefined errors.
139 |  */
140 | export interface Validation {
141 |   /**
142 |    * Throws an error if <code>strategy.getPlaceholder()</code> does not return
143 |    * a valid placeholder string.
144 |    *
145 |    * @param placeholder the placeholder to check
146 |    */
147 |   ensurePlaceholderValid(placeholder: any): void;
148 |   /**
149 |    * Throws an error if <code>strategy.splitHTMLByPlaceholder()</code> does not
150 |    * return an HTML part string for each template part.
151 |    *
152 |    * @param parts the template parts that generated the strings
153 |    * @param htmlParts the split HTML strings
154 |    */
155 |   ensureHTMLPartsValid(parts: TemplatePart[], htmlParts: string[]): void;
156 | }
157 | 
158 | /**
159 |  * The result of a call to <code>minifyHTMLLiterals()</code>.
160 |  */
161 | export interface Result {
162 |   /**
163 |    * The minified code.
164 |    */
165 |   code: string;
166 |   /**
167 |    * Optional v3 SourceMap for the code.
168 |    */
169 |   map: SourceMap | undefined;
170 | }
171 | 
172 | /**
173 |  * The default method to generate a SourceMap. It will generate the SourceMap
174 |  * from the provided MagicString instance using "fileName.map" as the file and
175 |  * "fileName" as the source.
176 |  *
177 |  * @param ms the MagicString instance with code modifications
178 |  * @param fileName the name of the source file
179 |  * @returns a v3 SourceMap
180 |  */
181 | export function defaultGenerateSourceMap(
182 |   ms: MagicStringLike,
183 |   fileName: string
184 | ) {
185 |   return ms.generateMap({
186 |     file: `${fileName}.map`,
187 |     source: fileName,
188 |     hires: true
189 |   });
190 | }
191 | 
192 | /**
193 |  * The default method to determine whether or not to minify a template. It will
194 |  * return true for all tagged templates whose tag name contains "html" (case
195 |  * insensitive).
196 |  *
197 |  * @param template the template to check
198 |  * @returns true if the template should be minified
199 |  */
200 | export function defaultShouldMinify(template: Template) {
201 |   const tag = template.tag && template.tag.toLowerCase();
202 |   return !!tag && (tag.includes('html') || tag.includes('svg'));
203 | }
204 | 
205 | /**
206 |  * The default method to determine whether or not to minify a CSS template. It
207 |  * will return true for all tagged templates whose tag name contains "css" (case
208 |  * insensitive).
209 |  *
210 |  * @param template the template to check
211 |  * @returns true if the template should be minified
212 |  */
213 | export function defaultShouldMinifyCSS(template: Template) {
214 |   return !!template.tag && template.tag.toLowerCase().includes('css');
215 | }
216 | 
217 | /**
218 |  * The default validation.
219 |  */
220 | export const defaultValidation: Validation = {
221 |   ensurePlaceholderValid(placeholder) {
222 |     if (typeof placeholder !== 'string' || !placeholder.length) {
223 |       throw new Error('getPlaceholder() must return a non-empty string');
224 |     }
225 |   },
226 |   ensureHTMLPartsValid(parts, htmlParts) {
227 |     if (parts.length !== htmlParts.length) {
228 |       throw new Error(
229 |         'splitHTMLByPlaceholder() must return same number of strings as template parts'
230 |       );
231 |     }
232 |   }
233 | };
234 | 
235 | /**
236 |  * Minifies all HTML template literals in the provided source string.
237 |  *
238 |  * @param source the source code
239 |  * @param options minification options
240 |  * @returns the minified code, or null if no minification occurred.
241 |  */
242 | export function minifyHTMLLiterals(
243 |   source: string,
244 |   options?: DefaultOptions
245 | ): Promise<Result | null>;
246 | /**
247 |  * Minifies all HTML template literals in the provided source string.
248 |  *
249 |  * @param source the source code
250 |  * @param options minification options
251 |  * @returns the minified code, or null if no minification occurred.
252 |  */
253 | export function minifyHTMLLiterals<S extends Strategy>(
254 |   source: string,
255 |   options?: CustomOptions<S>
256 | ): Promise<Result | null>;
257 | export async function minifyHTMLLiterals(
258 |   source: string,
259 |   options: Options = {}
260 | ): Promise<Result | null> {
261 |   options.minifyOptions = {
262 |     ...defaultMinifyOptions,
263 |     ...(options.minifyOptions || {})
264 |   };
265 | 
266 |   if (!options.MagicString) {
267 |     options.MagicString = MagicString;
268 |   }
269 | 
270 |   if (!options.parseLiterals) {
271 |     options.parseLiterals = parseLiterals;
272 |   }
273 | 
274 |   if (!options.shouldMinify) {
275 |     options.shouldMinify = defaultShouldMinify;
276 |   }
277 | 
278 |   if (!options.shouldMinifyCSS) {
279 |     options.shouldMinifyCSS = defaultShouldMinifyCSS;
280 |   }
281 | 
282 |   options.parseLiteralsOptions = {
283 |     ...{ fileName: options.fileName },
284 |     ...(options.parseLiteralsOptions || {})
285 |   };
286 | 
287 |   const templates = options.parseLiterals(source, options.parseLiteralsOptions);
288 |   const strategy =
289 |     <Strategy>(<CustomOptions<any>>options).strategy || defaultStrategy;
290 |   const { shouldMinify, shouldMinifyCSS } = options;
291 |   let validate: Validation | undefined;
292 |   if (options.validate !== false) {
293 |     validate = options.validate || defaultValidation;
294 |   }
295 | 
296 |   const ms = new options.MagicString(source);
297 |   for (const template of templates) {
298 |     const minifyHTML = shouldMinify(template);
299 |     const minifyCSS = !!strategy.minifyCSS && shouldMinifyCSS(template);
300 |     if (minifyHTML || minifyCSS) {
301 |       const placeholder = strategy.getPlaceholder(template.parts);
302 |       if (validate) {
303 |         validate.ensurePlaceholderValid(placeholder);
304 |       }
305 | 
306 |       const combined = strategy.combineHTMLStrings(template.parts, placeholder);
307 |       let min: string;
308 |       if (minifyCSS) {
309 |         const minifyCSSOptions = (
310 |           (options as DefaultOptions).minifyOptions || {}
311 |         ).minifyCSS;
312 |         if (typeof minifyCSSOptions === 'function') {
313 |           min = minifyCSSOptions(combined);
314 |         } else if (minifyCSSOptions === false) {
315 |           min = combined;
316 |         } else {
317 |           const cssOptions =
318 |             typeof minifyCSSOptions === 'object' ? minifyCSSOptions : undefined;
319 |           min = strategy.minifyCSS!(combined, cssOptions);
320 |         }
321 |       } else {
322 |         min = await strategy.minifyHTML(combined, options.minifyOptions);
323 |       }
324 | 
325 |       const minParts = strategy.splitHTMLByPlaceholder(min, placeholder);
326 |       if (validate) {
327 |         validate.ensureHTMLPartsValid(template.parts, minParts);
328 |       }
329 | 
330 |       template.parts.forEach((part, index) => {
331 |         if (part.start < part.end) {
332 |           // Only overwrite if the literal part has text content
333 |           ms.overwrite(part.start, part.end, minParts[index]);
334 |         }
335 |       });
336 |     }
337 |   }
338 | 
339 |   const sourceMin = ms.toString();
340 |   if (source === sourceMin) {
341 |     return null;
342 |   } else {
343 |     let map: SourceMap | undefined;
344 |     if (options.generateSourceMap !== false) {
345 |       const generateSourceMap =
346 |         options.generateSourceMap || defaultGenerateSourceMap;
347 |       map = generateSourceMap(ms, options.fileName || '');
348 |     }
349 | 
350 |     return {
351 |       map,
352 |       code: sourceMin
353 |     };
354 |   }
355 | }
356 | 


--------------------------------------------------------------------------------
/src/test/minifyHTMLLiterals.spec.ts:
--------------------------------------------------------------------------------
  1 | import { expect } from 'chai';
  2 | import MagicString, { SourceMapOptions } from 'magic-string';
  3 | import {
  4 |   ParseLiteralsOptions,
  5 |   Template,
  6 |   TemplatePart,
  7 |   parseLiterals
  8 | } from 'parse-literals';
  9 | import { SinonSpy, spy } from 'sinon';
 10 | import {
 11 |   SourceMap,
 12 |   defaultGenerateSourceMap,
 13 |   defaultShouldMinify,
 14 |   defaultShouldMinifyCSS,
 15 |   defaultValidation,
 16 |   minifyHTMLLiterals
 17 | } from '../minifyHTMLLiterals.js';
 18 | import { defaultMinifyOptions, defaultStrategy } from '../strategy.js';
 19 | 
 20 | class MagicStringLike {
 21 |   generateMap(options?: Partial<SourceMapOptions>): SourceMap {
 22 |     return {
 23 |       version: 3,
 24 |       file: (options && options.file) || null,
 25 |       sources: [(options && options.source) || null],
 26 |       sourcesContent: [],
 27 |       names: [],
 28 |       mappings: '',
 29 |       toString() {
 30 |         return '';
 31 |       },
 32 |       toUrl() {
 33 |         return '';
 34 |       }
 35 |     };
 36 |   }
 37 | 
 38 |   overwrite(_start: number, _end: number, _content: string): any {
 39 |     // noop
 40 |   }
 41 | 
 42 |   toString(): string {
 43 |     return '';
 44 |   }
 45 | }
 46 | 
 47 | describe('minifyHTMLLiterals()', () => {
 48 |   const SOURCE = `
 49 |     function render(title, items, styles) {
 50 |       return html\`
 51 |         <style>
 52 |           \${styles}
 53 |         </style>
 54 |         <h1 class="heading">\${title}</h1>
 55 |         <button onclick="\${() => eventHandler()}"></button>
 56 |         <ul>
 57 |           \${items.map(item => {
 58 |             return getHTML()\`
 59 |               <li>\${item}</li>
 60 |             \`;
 61 |           })}
 62 |         </ul>
 63 |       \`;
 64 |     }
 65 | 
 66 |     function noMinify() {
 67 |       return \`
 68 |         <div>Not tagged html</div>
 69 |       \`;
 70 |     }
 71 | 
 72 |     function taggednoMinify(extra) {
 73 |       return other\`
 74 |         <style>
 75 |           .heading {
 76 |             font-size: 24px;
 77 |           }
 78 | 
 79 |           \${extra}
 80 |         </style>
 81 |       \`;
 82 |     }
 83 | 
 84 |     function taggedCSSMinify(extra) {
 85 |       return css\`
 86 |         .heading {
 87 |           font-size: 24px;
 88 |         }
 89 | 
 90 |         \${extra}
 91 |       \`;
 92 |     }
 93 | 
 94 |     function cssProperty(property) {
 95 |       const width = '20px';
 96 |       return css\`
 97 |         .foo {
 98 |           font-size: 1rem;
 99 |           width: \${width};
100 |           color: \${property};
101 |         }
102 |       \`;
103 |     }
104 |   `;
105 | 
106 |   const SOURCE_MIN = `
107 |     function render(title, items, styles) {
108 |       return html\`<style>\${styles}</style><h1 class="heading">\${title}</h1><button onclick="\${() => eventHandler()}"></button><ul>\${items.map(item => {
109 |             return getHTML()\`<li>\${item}</li>\`;
110 |           })}</ul>\`;
111 |     }
112 | 
113 |     function noMinify() {
114 |       return \`
115 |         <div>Not tagged html</div>
116 |       \`;
117 |     }
118 | 
119 |     function taggednoMinify(extra) {
120 |       return other\`
121 |         <style>
122 |           .heading {
123 |             font-size: 24px;
124 |           }
125 | 
126 |           \${extra}
127 |         </style>
128 |       \`;
129 |     }
130 | 
131 |     function taggedCSSMinify(extra) {
132 |       return css\`.heading{font-size:24px}\${extra}\`;
133 |     }
134 | 
135 |     function cssProperty(property) {
136 |       const width = '20px';
137 |       return css\`.foo{font-size:1rem;width:\${width};color:\${property}}\`;
138 |     }
139 |   `;
140 | 
141 |   const STATIC_SOURCE = `
142 |     function render() {
143 |       const tagName = literal\`span\`
144 |       return html\`
145 |         <\${tagName}>
146 |         span content
147 |         </\${tagName}>
148 |       \`;
149 |     }
150 |   `;
151 | 
152 |   const STATIC_SOURCE_MIN = `
153 |     function render() {
154 |       const tagName = literal\`span\`
155 |       return html\`<\${tagName}>span content</\${tagName}>\`;
156 |     }
157 |   `;
158 | 
159 |   const SVG_SOURCE = `
160 |     function taggedSVGMinify() {
161 |       return svg\`
162 |         <svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24">
163 |           <path d="M6 19h12v2H6z" />
164 |           <path d="M0 0h24v24H0V0z" fill="none" />
165 |         </svg>
166 |       \`;
167 |     }
168 |   `;
169 | 
170 |   const SVG_SOURCE_MIN = `
171 |     function taggedSVGMinify() {
172 |       return svg\`<svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24"><path d="M6 19h12v2H6z"/><path d="M0 0h24v24H0V0z" fill="none"/></svg>\`;
173 |     }
174 |   `;
175 | 
176 |   const COMMENT_SOURCE = `
177 |     function minifyWithComment() {
178 |       return html\`
179 |         <div .icon=\${0/*JS Comment */}>
180 |         </div>
181 |       \`;
182 |     }
183 |   `;
184 | 
185 |   const COMMENT_SOURCE_MIN = `
186 |     function minifyWithComment() {
187 |       return html\`<div .icon="\${0/*JS Comment */}"></div>\`;
188 |     }
189 |   `;
190 | 
191 |   const SVG_MULTILINE_SOURCE = `
192 |     function multiline() {
193 |       return html\`
194 |         <pre>
195 |           Keep newlines
196 | 
197 |           within certain tags
198 |         </pre>
199 |         <svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24">
200 |           <path d="M6 19h12v2H6z" />
201 |           <path d="M0
202 |                    0h24v24H0V0z"
203 |                 fill="none" />
204 |         </svg>
205 |       \`;
206 |     }
207 |   `;
208 | 
209 |   const SVG_MULTILINE_SOURCE_MIN = `
210 |     function multiline() {
211 |       return html\`<pre>
212 |           Keep newlines
213 | 
214 |           within certain tags
215 |         </pre><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24"><path d="M6 19h12v2H6z"/><path d="M0                   0h24v24H0V0z" fill="none"/></svg>\`;
216 |     }
217 |   `;
218 | 
219 |   const SHADOW_PARTS_SOURCE = `
220 |     function parts() {
221 |       return css\`
222 |         foo-bar::part(space separated) {
223 |           color: red;
224 |         }
225 |       \`;
226 |     }
227 |   `;
228 | 
229 |   const SHADOW_PARTS_SOURCE_MIN = `
230 |     function parts() {
231 |       return css\`foo-bar::part(space separated){color:red}\`;
232 |     }
233 |   `;
234 | 
235 |   const MEMBER_EXPRESSION_LITERAL_SOURCE = `
236 |     function nested() {
237 |       return LitHtml.html\`<div id="container">
238 |         <span>Some content here</span>
239 |       </div>
240 |       \`;
241 |     }
242 |   `;
243 | 
244 |   const MEMBER_EXPRESSION_LITERAL_SOURCE_MIN = `
245 |     function nested() {
246 |       return LitHtml.html\`<div id="container"><span>Some content here</span></div>\`;
247 |     }
248 |   `;
249 | 
250 |   it('should minify "html" and "css" tagged templates', async () => {
251 |     const result = await minifyHTMLLiterals(SOURCE, { fileName: 'test.js' });
252 |     expect(result).to.be.an('object');
253 |     expect(result!.code).to.equal(SOURCE_MIN);
254 |   });
255 | 
256 |   it('should minify "svg" tagged templates', async () => {
257 |     const result = await minifyHTMLLiterals(SVG_SOURCE, {
258 |       fileName: 'test.js'
259 |     });
260 |     expect(result).to.be.an('object');
261 |     expect(result!.code).to.equal(SVG_SOURCE_MIN);
262 |   });
263 | 
264 |   it('should minify html with attribute placeholders that have no quotes and JS comments', async () => {
265 |     const result = await minifyHTMLLiterals(COMMENT_SOURCE, {
266 |       fileName: 'test.js'
267 |     });
268 |     expect(result).to.be.an('object');
269 |     expect(result!.code).to.equal(COMMENT_SOURCE_MIN);
270 |   });
271 | 
272 |   it('should minify html tagged with a member expression ending in html', async () => {
273 |     const result = await minifyHTMLLiterals(MEMBER_EXPRESSION_LITERAL_SOURCE, {
274 |       fileName: 'test.js'
275 |     });
276 |     expect(result).to.be.an('object');
277 |     expect(result!.code).to.equal(MEMBER_EXPRESSION_LITERAL_SOURCE_MIN);
278 |   });
279 | 
280 |   it('should minify multiline svg elements', async () => {
281 |     const result = await minifyHTMLLiterals(SVG_MULTILINE_SOURCE, {
282 |       fileName: 'test.js'
283 |     });
284 |     expect(result).to.be.an('object');
285 |     expect(result!.code).to.equal(SVG_MULTILINE_SOURCE_MIN);
286 |   });
287 | 
288 |   it('should not remove spaces in ::part()', async () => {
289 |     const result = await minifyHTMLLiterals(SHADOW_PARTS_SOURCE, {
290 |       fileName: 'test.js'
291 |     });
292 |     expect(result).to.be.an('object');
293 |     expect(result!.code).to.equal(SHADOW_PARTS_SOURCE_MIN);
294 |   });
295 | 
296 |   it('should return null if source is already minified', async () => {
297 |     const result = await minifyHTMLLiterals(SOURCE_MIN, {
298 |       fileName: 'test.js'
299 |     });
300 |     expect(result).to.be.null;
301 |   });
302 | 
303 |   it('should return a v3 source map', async () => {
304 |     const result = await minifyHTMLLiterals(SOURCE, { fileName: 'test.js' });
305 |     expect(result).to.be.an('object');
306 |     expect(result!.map).to.be.an('object');
307 |     expect(result!.map!.version).to.equal(3);
308 |     expect(result!.map!.mappings).to.be.a('string');
309 |   });
310 | 
311 |   it('fails to minify static html templates', async () => {
312 |     const result = await minifyHTMLLiterals(STATIC_SOURCE, {
313 |       fileName: 'test.js'
314 |     });
315 |     expect(result).to.be.an('object');
316 |     expect(result!.code).to.equal(STATIC_SOURCE_MIN);
317 |   });
318 | 
319 |   describe('options', () => {
320 |     let minifyHTMLSpy: SinonSpy;
321 | 
322 |     beforeEach(() => {
323 |       minifyHTMLSpy = spy(defaultStrategy, 'minifyHTML');
324 |     });
325 | 
326 |     afterEach(() => {
327 |       minifyHTMLSpy.restore();
328 |     });
329 | 
330 |     it('should use defaultMinifyOptions', async () => {
331 |       await minifyHTMLLiterals(SOURCE, { fileName: 'test.js' });
332 |       const parts = parseLiterals(SOURCE)[1].parts;
333 |       const html = defaultStrategy.combineHTMLStrings(
334 |         parts,
335 |         defaultStrategy.getPlaceholder(parts)
336 |       );
337 |       expect(
338 |         minifyHTMLSpy.lastCall.calledWithExactly(html, defaultMinifyOptions)
339 |       ).to.be.true;
340 |     });
341 | 
342 |     it('should allow custom partial minifyOptions', async () => {
343 |       const minifyOptions = { caseSensitive: false };
344 |       await minifyHTMLLiterals(SOURCE, { fileName: 'test.js', minifyOptions });
345 |       const parts = parseLiterals(SOURCE)[1].parts;
346 |       const html = defaultStrategy.combineHTMLStrings(
347 |         parts,
348 |         defaultStrategy.getPlaceholder(parts)
349 |       );
350 |       expect(
351 |         minifyHTMLSpy.lastCall.calledWithExactly(html, {
352 |           ...defaultMinifyOptions,
353 |           ...minifyOptions
354 |         })
355 |       ).to.be.true;
356 |     });
357 | 
358 |     it('should use MagicString constructor', async () => {
359 |       let msUsed;
360 |       await minifyHTMLLiterals(SOURCE, {
361 |         fileName: 'test.js',
362 |         generateSourceMap(ms) {
363 |           msUsed = ms;
364 |           return undefined;
365 |         }
366 |       });
367 | 
368 |       expect(msUsed).to.be.an.instanceof(MagicString);
369 |     });
370 | 
371 |     it('should allow custom MagicStringLike constructor', async () => {
372 |       let msUsed;
373 |       await minifyHTMLLiterals(SOURCE, {
374 |         fileName: 'test.js',
375 |         MagicString: MagicStringLike,
376 |         generateSourceMap(ms) {
377 |           msUsed = ms;
378 |           return undefined;
379 |         }
380 |       });
381 | 
382 |       expect(msUsed).to.be.an.instanceof(MagicStringLike);
383 |     });
384 | 
385 |     it('should allow custom parseLiterals()', async () => {
386 |       const customParseLiterals = spy(
387 |         (source: string, options?: ParseLiteralsOptions) => {
388 |           return parseLiterals(source, options);
389 |         }
390 |       );
391 | 
392 |       await minifyHTMLLiterals(SOURCE, {
393 |         fileName: 'test.js',
394 |         parseLiterals: customParseLiterals
395 |       });
396 |       expect(customParseLiterals.called).to.be.true;
397 |     });
398 | 
399 |     it('should allow custom shouldMinify()', async () => {
400 |       const customShouldMinify = spy((template: Template) => {
401 |         return defaultShouldMinify(template);
402 |       });
403 | 
404 |       await minifyHTMLLiterals(SOURCE, {
405 |         fileName: 'test.js',
406 |         shouldMinify: customShouldMinify
407 |       });
408 |       expect(customShouldMinify.called).to.be.true;
409 |     });
410 | 
411 |     it('should allow custom strategy', async () => {
412 |       const customStrategy = {
413 |         getPlaceholder: spy((parts: TemplatePart[]) => {
414 |           return defaultStrategy.getPlaceholder(parts);
415 |         }),
416 |         combineHTMLStrings: spy(
417 |           (parts: TemplatePart[], placeholder: string) => {
418 |             return defaultStrategy.combineHTMLStrings(parts, placeholder);
419 |           }
420 |         ),
421 |         minifyHTML: spy((html: string, options?: any) => {
422 |           return defaultStrategy.minifyHTML(html, options);
423 |         }),
424 |         splitHTMLByPlaceholder: spy((html: string, placeholder: string) => {
425 |           return defaultStrategy.splitHTMLByPlaceholder(html, placeholder);
426 |         })
427 |       };
428 | 
429 |       await minifyHTMLLiterals(SOURCE, {
430 |         fileName: 'test.js',
431 |         strategy: customStrategy
432 |       });
433 |       expect(customStrategy.getPlaceholder.called).to.be.true;
434 |       expect(customStrategy.combineHTMLStrings.called).to.be.true;
435 |       expect(customStrategy.minifyHTML.called).to.be.true;
436 |       expect(customStrategy.splitHTMLByPlaceholder.called).to.be.true;
437 |     });
438 | 
439 |     it('should use defaultValidation', () => {
440 |       expect(async () => {
441 |         await minifyHTMLLiterals(SOURCE, {
442 |           fileName: 'test.js',
443 |           strategy: {
444 |             getPlaceholder: () => {
445 |               return ''; // cause an error
446 |             },
447 |             combineHTMLStrings: defaultStrategy.combineHTMLStrings,
448 |             minifyHTML: defaultStrategy.minifyHTML,
449 |             splitHTMLByPlaceholder: defaultStrategy.splitHTMLByPlaceholder
450 |           }
451 |         });
452 |       }).to.throw;
453 | 
454 |       expect(async () => {
455 |         await minifyHTMLLiterals(SOURCE, {
456 |           fileName: 'test.js',
457 |           strategy: {
458 |             getPlaceholder: defaultStrategy.getPlaceholder,
459 |             combineHTMLStrings: defaultStrategy.combineHTMLStrings,
460 |             minifyHTML: defaultStrategy.minifyHTML,
461 |             splitHTMLByPlaceholder: () => {
462 |               return []; // cause an error
463 |             }
464 |           }
465 |         });
466 |       }).to.throw;
467 |     });
468 | 
469 |     it('should allow disabling validation', () => {
470 |       expect(async () => {
471 |         await minifyHTMLLiterals(SOURCE, {
472 |           fileName: 'test.js',
473 |           strategy: {
474 |             getPlaceholder: () => {
475 |               return ''; // cause an error
476 |             },
477 |             combineHTMLStrings: defaultStrategy.combineHTMLStrings,
478 |             minifyHTML: defaultStrategy.minifyHTML,
479 |             splitHTMLByPlaceholder: defaultStrategy.splitHTMLByPlaceholder
480 |           },
481 |           validate: false
482 |         });
483 |       }).not.to.throw;
484 |     });
485 | 
486 |     it('should allow custom validation', async () => {
487 |       const customValidation = {
488 |         ensurePlaceholderValid: spy((placeholder: any) => {
489 |           return defaultValidation.ensurePlaceholderValid(placeholder);
490 |         }),
491 |         ensureHTMLPartsValid: spy(
492 |           (parts: TemplatePart[], htmlParts: string[]) => {
493 |             return defaultValidation.ensureHTMLPartsValid(parts, htmlParts);
494 |           }
495 |         )
496 |       };
497 | 
498 |       await minifyHTMLLiterals(SOURCE, {
499 |         fileName: 'test.js',
500 |         validate: customValidation
501 |       });
502 |       expect(customValidation.ensurePlaceholderValid.called).to.be.true;
503 |       expect(customValidation.ensureHTMLPartsValid.called).to.be.true;
504 |     });
505 | 
506 |     it('should allow disabling generateSourceMap', async () => {
507 |       const result = await minifyHTMLLiterals(SOURCE, {
508 |         fileName: 'test.js',
509 |         generateSourceMap: false
510 |       });
511 |       expect(result).to.be.an('object');
512 |       expect(result!.map).to.be.undefined;
513 |     });
514 | 
515 |     it('should allow custom generateSourceMap()', async () => {
516 |       const customGenerateSourceMap = spy(
517 |         (ms: MagicStringLike, fileName: string) => {
518 |           return defaultGenerateSourceMap(ms, fileName);
519 |         }
520 |       );
521 | 
522 |       await minifyHTMLLiterals(SOURCE, {
523 |         fileName: 'test.js',
524 |         generateSourceMap: customGenerateSourceMap
525 |       });
526 |       expect(customGenerateSourceMap.called).to.be.true;
527 |     });
528 |   });
529 | 
530 |   describe('defaultGenerateSourceMap()', () => {
531 |     it('should call generateMap() on MagicStringLike with .map file, source name, and hires', () => {
532 |       const ms = new MagicStringLike();
533 |       const generateMapSpy = spy(ms, 'generateMap');
534 |       defaultGenerateSourceMap(ms, 'test.js');
535 |       expect(
536 |         generateMapSpy.calledWith({
537 |           file: 'test.js.map',
538 |           source: 'test.js',
539 |           hires: true
540 |         })
541 |       ).to.be.true;
542 |     });
543 |   });
544 | 
545 |   describe('defaultShouldMinify()', () => {
546 |     it('should return true if the template is tagged with any "html" text', () => {
547 |       expect(defaultShouldMinify({ tag: 'html', parts: [] })).to.be.true;
548 |       expect(defaultShouldMinify({ tag: 'HTML', parts: [] })).to.be.true;
549 |       expect(defaultShouldMinify({ tag: 'hTML', parts: [] })).to.be.true;
550 |       expect(defaultShouldMinify({ tag: 'getHTML()', parts: [] })).to.be.true;
551 |       expect(defaultShouldMinify({ tag: 'templateHtml()', parts: [] })).to.be
552 |         .true;
553 |     });
554 | 
555 |     it('should return false if the template is not tagged or does not contain "html"', () => {
556 |       expect(defaultShouldMinify({ parts: [] })).to.be.false;
557 |       expect(defaultShouldMinify({ tag: 'css', parts: [] })).to.be.false;
558 |     });
559 | 
560 |     it('should return true if the template is tagged with any "svg" text', () => {
561 |       expect(defaultShouldMinify({ tag: 'svg', parts: [] })).to.be.true;
562 |       expect(defaultShouldMinify({ tag: 'SVG', parts: [] })).to.be.true;
563 |       expect(defaultShouldMinify({ tag: 'sVg', parts: [] })).to.be.true;
564 |       expect(defaultShouldMinify({ tag: 'getSVG()', parts: [] })).to.be.true;
565 |       expect(defaultShouldMinify({ tag: 'templateSvg()', parts: [] })).to.be
566 |         .true;
567 |     });
568 |   });
569 | 
570 |   describe('defaultShouldMinifyCSS()', () => {
571 |     it('should return true if the template is tagged with any "css" text', () => {
572 |       expect(defaultShouldMinifyCSS({ tag: 'css', parts: [] })).to.be.true;
573 |       expect(defaultShouldMinifyCSS({ tag: 'CSS', parts: [] })).to.be.true;
574 |       expect(defaultShouldMinifyCSS({ tag: 'csS', parts: [] })).to.be.true;
575 |       expect(defaultShouldMinifyCSS({ tag: 'getCSS()', parts: [] })).to.be.true;
576 |       expect(defaultShouldMinifyCSS({ tag: 'templateCss()', parts: [] })).to.be
577 |         .true;
578 |     });
579 | 
580 |     it('should return false if the template is not tagged or does not contain "css"', () => {
581 |       expect(defaultShouldMinifyCSS({ parts: [] })).to.be.false;
582 |       expect(defaultShouldMinifyCSS({ tag: 'html', parts: [] })).to.be.false;
583 |     });
584 |   });
585 | 
586 |   describe('defaultValidation', () => {
587 |     describe('ensurePlaceholderValid()', () => {
588 |       it('should throw an error if the placeholder is not a string', () => {
589 |         expect(() => {
590 |           defaultValidation.ensurePlaceholderValid(undefined);
591 |         }).to.throw;
592 |         expect(() => {
593 |           defaultValidation.ensurePlaceholderValid(true);
594 |         }).to.throw;
595 |         expect(() => {
596 |           defaultValidation.ensurePlaceholderValid({});
597 |         }).to.throw;
598 |       });
599 | 
600 |       it('should throw an error if the placeholder is an empty string', () => {
601 |         expect(() => {
602 |           defaultValidation.ensurePlaceholderValid('');
603 |         }).to.throw;
604 |       });
605 | 
606 |       it('should not throw an error if the placeholder is a non-empty string', () => {
607 |         expect(() => {
608 |           defaultValidation.ensurePlaceholderValid('EXP');
609 |         }).not.to.throw;
610 |       });
611 |     });
612 |   });
613 | });
614 | 


--------------------------------------------------------------------------------