html-minifier-next 6.2.10 → 7.0.0

package/src/lib/options.js

@@ -4,19 +4,39 @@ import { RE_TRAILING_SEMICOLON } from './constants.js';
 import { canCollapseWhitespace, canTrimWhitespace } from './whitespace.js';
 import { wrapCSS, unwrapCSS } from './content.js';
 import { getPreset, getPresetNames } from '../presets.js';
-import { optionDefaults } from './option-definitions.js';
+import { optionDefinitions, optionDefaults } from './option-definitions.js';
+
+/** @import { MinifierOptions, HTMLAttribute } from '../htmlminifier.js' */
 
 // Type definitions
 
 /**
- * @typedef {Record<string, any>} MinifierOptions
+ * Options object produced by `processOptions` and consumed by `minifyHTML` and
+ * the `lib/` helpers; normalization guarantees that the function-valued options
+ * below are always present (defaulting to identity/built-in functions), and
+ * minification adds writable internal state on top of the public options
+ * (set on prototype-chain forks during SVG/MathML namespace transitions)
+ *
+ * @typedef {Omit<MinifierOptions, 'preset' | 'canCollapseWhitespace' | 'canTrimWhitespace' | 'ignoreCustomComments' | 'log' | 'minifyCSS' | 'minifyJS' | 'minifyURLs' | 'minifySVG'> & {
+ *   name: (name: string) => string,
+ *   log: (message: any) => unknown,
+ *   ignoreCustomComments: RegExp[],
+ *   canCollapseWhitespace: (tag: string, attrs: HTMLAttribute[], defaultFn: (tag: string) => boolean) => boolean,
+ *   canTrimWhitespace: (tag: string, attrs: HTMLAttribute[], defaultFn: (tag: string) => boolean) => boolean,
+ *   minifyCSS: (text: string, type?: string) => string | Promise<string>,
+ *   minifyJS: (text: string, inline?: boolean, isModule?: boolean) => string | Promise<string>,
+ *   minifyURLs: (text: string) => string | Promise<string>,
+ *   minifySVG: ((svgContent: string) => string | Promise<string>) | null,
+ *   nameParent?: (name: string) => string,
+ *   nameHTML?: (name: string) => string,
+ *   insideSVG?: boolean,
+ *   insideForeignContent?: boolean
+ * }} ProcessedOptions
  */
 
-// @@ Extract a `ProcessedOptions` typedef (with `name`, `log`, `canCollapseWhitespace`, `canTrimWhitespace`,`minifyCSS`, `minifyJS`, `minifyURLs` typed as required, non-optional) to replace the current `Record<string, any>` escape hatch and eliminate the `/** @type {Function} */` casts in htmlminifier.js
-
 // Helper functions
 
-/** @param {MinifierOptions} options */
+/** @param {ProcessedOptions} options */
 function shouldMinifyInnerHTML(options) {
   return Boolean(
     options.collapseWhitespace ||
@@ -29,15 +49,23 @@ function shouldMinifyInnerHTML(options) {
   );
 }
 
+// User-facing option keys that are valid but not listed in `optionDefinitions`
+const optionKeysExtra = new Set(['preset', 'log', 'canCollapseWhitespace', 'canTrimWhitespace', 'cacheCSS', 'cacheJS', 'cacheSVG']);
+
+// Unknown option keys and preset names already warned about—warn once per
+// key per process, so repeated `minify` calls (e.g., batch runs) don’t flood STDERR
+const optionKeysWarned = new Set();
+const presetNamesWarned = new Set();
+
 // Main options processor
 
 /**
  * @param {MinifierOptions} inputOptions - User-provided options
  * @param {{getLightningCSS?: Function | undefined, getTerser?: Function | undefined, getSwc?: Function | undefined, getSvgo?: Function | undefined, cssMinifyCache?: LRU | undefined, jsMinifyCache?: LRU | undefined, svgMinifyCache?: LRU | undefined}} [deps] - Dependencies from htmlminifier.js
- * @returns {MinifierOptions} Normalized options with defaults applied
+ * @returns {ProcessedOptions} Normalized options with defaults applied
  */
 const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getSvgo, cssMinifyCache, jsMinifyCache, svgMinifyCache } = {}) => {
-  /** @type {MinifierOptions} */
+  /** @type {ProcessedOptions} */
   const options = {
     name: lowercase,
     canCollapseWhitespace,
@@ -67,6 +95,18 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
     });
   };
 
+  // Route warnings through the user-provided `log` hook so API consumers can
+  // capture or suppress them consistently; fall back to `console.warn`
+  const warn = typeof inputOptions.log === 'function' ? inputOptions.log : console.warn;
+
+  // Warn about unrecognized options—catches typos as well as options removed in earlier versions
+  Object.keys(inputOptions).forEach(function (key) {
+    if (!Object.hasOwn(optionDefinitions, key) && !optionKeysExtra.has(key) && !optionKeysWarned.has(key)) {
+      optionKeysWarned.add(key);
+      warn(`HTML Minifier Next: Ignoring unknown or deprecated option “${key}” (see README for available options)`);
+    }
+  });
+
   // Merge preset with user options so all values go through normalization
   // User options take precedence over preset values
   let effectiveInput = inputOptions;
@@ -74,17 +114,22 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
     const preset = getPreset(inputOptions.preset);
     if (preset) {
       effectiveInput = { ...preset, ...inputOptions };
-    } else {
+    } else if (!presetNamesWarned.has(inputOptions.preset)) {
+      presetNamesWarned.add(inputOptions.preset);
       const available = getPresetNames().join(', ');
-      console.warn(`HTML Minifier Next: Unknown preset “${inputOptions.preset}”. Available presets: ${available}`);
+      warn(`HTML Minifier Next: Unknown preset “${inputOptions.preset}”; available presets: ${available}`);
     }
   }
 
+  // Escape hatch for the loop below, which reads and assigns user-provided values by dynamic key
+  const optionsDynamic = /** @type {Record<string, any>} */ (options);
+
   Object.keys(effectiveInput).forEach(function (key) {
-    const option = effectiveInput[key];
+    const option = /** @type {Record<string, any>} */ (effectiveInput)[key];
 
-    // Skip preset key—it’s already been processed
-    if (key === 'preset') {
+    // Skip `preset` (already processed) and unrecognized keys (warned about above)—
+    // the latter also keeps internal keys from being overridden
+    if (key === 'preset' || (!Object.hasOwn(optionDefinitions, key) && !optionKeysExtra.has(key))) {
       return;
     }
 
@@ -106,7 +151,7 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
       const cssLoader = getLightningCSS;
       const cssCache = cssMinifyCache;
 
-      options.minifyCSS = async function (/** @type {string} */ text, /** @type {string} */ type) {
+      options.minifyCSS = async function (/** @type {string} */ text, /** @type {string | undefined} */ type) {
         // Fast path: Nothing to minify
         if (!text || !text.trim()) {
           return text;
@@ -143,7 +188,7 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
           : (inputCSS + '|' + type + '|' + cssSig);
 
         try {
-          const cached = cssCache.get(cssKey);
+          const cached = /** @type {string | Promise<string> | undefined} */ (cssCache.get(cssKey));
           if (cached !== undefined) {
             // Support both resolved values and in-flight promises
             return await cached;
@@ -236,7 +281,7 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
         cont: !!options.continueOnMinifyError
       });
 
-      options.minifyJS = async function (/** @type {string} */ text, /** @type {boolean} */ inline, /** @type {boolean} */ isModule) {
+      options.minifyJS = async function (/** @type {string} */ text, /** @type {boolean | undefined} */ inline, /** @type {boolean | undefined} */ isModule) {
         const start = text.match(/^\s*<!--.*/);
         const code = start ? text.slice(start[0].length).replace(/\n\s*-->\s*$/, '') : text;
 
@@ -258,7 +303,7 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
           jsKey = (code.length > 2048 ? (hashContent(code) + '|') : (code + '|'))
             + (inline ? '1' : '0') + '|' + (isModule ? 'm' : '') + '|' + useEngine + '|' + optsSig;
 
-          const cached = jsCache.get(jsKey);
+          const cached = /** @type {string | Promise<string> | undefined} */ (jsCache.get(jsKey));
           if (cached !== undefined) {
             return await cached;
           }
@@ -331,7 +376,7 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
         }
 
         // Check cache
-        const cached = instanceCache.get(text);
+        const cached = /** @type {string | undefined} */ (instanceCache.get(text));
         if (cached !== undefined) {
           return cached;
         }
@@ -377,7 +422,7 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
           : (svgContent + '|' + svgSig);
 
         try {
-          const cached = svgCache.get(svgKey);
+          const cached = /** @type {string | Promise<string> | undefined} */ (svgCache.get(svgKey));
           if (cached !== undefined) {
             return await cached;
           }
@@ -403,15 +448,15 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
       };
     } else if (key === 'customAttrCollapse') {
       // Single regex pattern
-      options[key] = parseRegExp(option);
+      optionsDynamic[key] = parseRegExp(option);
     } else if (key === 'customAttrSurround') {
       // Nested array of RegExp pairs: `[[openRegExp, closeRegExp], …]`
-      options[key] = parseNestedRegExpArray(option);
+      optionsDynamic[key] = parseNestedRegExpArray(option);
     } else if (['customAttrAssign', 'customEventAttributes', 'ignoreCustomComments', 'ignoreCustomFragments'].includes(key)) {
       // Array of regex patterns
-      options[key] = parseRegExpArray(option);
+      optionsDynamic[key] = parseRegExpArray(option);
     } else {
-      options[key] = option;
+      optionsDynamic[key] = option;
     }
   });
   return options;

package/src/lib/utils.js

@@ -80,7 +80,10 @@ function identity(value) {
   return value;
 }
 
-/** @param {unknown} value */
+/**
+ * @param {unknown} value
+ * @returns {value is PromiseLike<any>}
+ */
 function isThenable(value) {
   return value != null && typeof value === 'object' && typeof /** @type {any} */ (value).then === 'function';
 }

package/src/lib/whitespace.js

@@ -39,7 +39,7 @@ function collapseWhitespaceAll(str) {
     // Fast path: No no-break space, common case—just collapse to single space
     // This avoids the nested regex for the majority of cases
     if (spaces.indexOf('\xA0') === -1) return ' ';
-    // For no-break space handling, use the original regex approach
+    // For no-break space handling, use the nested regex
     return spaces.replace(RE_NBSP_LEADING_GROUP, '$1 ');
   });
 }

package/src/presets.js

@@ -14,8 +14,7 @@ export const presets = {
     conservativeCollapse: true,
     preserveLineBreaks: true,
     removeComments: true,
-    removeScriptTypeAttributes: true,
-    removeStyleLinkTypeAttributes: true,
+    removeDefaultTypeAttributes: true,
     useShortDoctype: true
   },
   comprehensive: {
@@ -30,11 +29,10 @@ export const presets = {
     minifyURLs: true,
     removeAttributeQuotes: true,
     removeComments: true,
+    removeDefaultTypeAttributes: true,
     removeEmptyAttributes: true,
     removeOptionalTags: true,
     removeRedundantAttributes: true,
-    removeScriptTypeAttributes: true,
-    removeStyleLinkTypeAttributes: true,
     useShortDoctype: true
   }
 };