html-minifier-next 3.0.0 → 3.1.0

package/README.md

@@ -34,10 +34,10 @@ html-minifier-next --collapse-whitespace --remove-comments --minify-js true --in
 **Process specific file extensions:**
 
 ```bash
-# Process only HTML files (CLI method)
+# Process only HTML files
 html-minifier-next --collapse-whitespace --input-dir=src --output-dir=dist --file-ext=html
 
-# Process multiple file extensions (CLI method)
+# Process multiple file extensions
 html-minifier-next --collapse-whitespace --input-dir=src --output-dir=dist --file-ext=html,htm,php
 
 # Using configuration file that sets `fileExt` (e.g., `"fileExt": "html,htm"`)
@@ -49,6 +49,21 @@ html-minifier-next --collapse-whitespace --input-dir=src --output-dir=dist
 # Consider restricting with “--file-ext” to avoid touching binaries (e.g., images, archives).
 ```
 
+**Dry run mode (preview outcome without writing files):**
+
+```bash
+# Preview with output file
+html-minifier-next input.html -o output.html --dry --collapse-whitespace
+
+# Preview directory processing with statistics per file and total
+html-minifier-next --input-dir=src --output-dir=dist --dry --collapse-whitespace
+# Output: [DRY RUN] Would process directory: src → dist
+#   index.html: 1,234 → 892 bytes (-342, 27.7%)
+#   about.html: 2,100 → 1,654 bytes (-446, 21.2%)
+# ---
+# Total: 3,334 → 2,546 bytes (-788, 23.6%)
+```
+
 ### CLI options
 
 Use `html-minifier-next --help` to check all available options:
@@ -58,8 +73,9 @@ Use `html-minifier-next --help` to check all available options:
 | `--input-dir <dir>` | Specify an input directory | `--input-dir=src` |
 | `--output-dir <dir>` | Specify an output directory | `--output-dir=dist` |
 | `--file-ext <extensions>` | Specify file extension(s) to process (overrides config file setting) | `--file-ext=html`, `--file-ext=html,htm,php`, `--file-ext="html, htm, php"` |
-| `-o --output <file>` | Specify output file (single file mode) | `-o minified.html` |
+| `-o --output <file>` | Specify output file (reads from file arguments or STDIN) | File to file: `html-minifier-next input.html -o output.html`<br>Pipe to file: `cat input.html \| html-minifier-next -o output.html`<br>File to STDOUT: `html-minifier-next input.html` |
 | `-c --config-file <file>` | Use a configuration file | `--config-file=html-minifier.json` |
+| `-d --dry` | Dry run: Process and report statistics without writing output | `html-minifier-next input.html --dry --collapse-whitespace` |
 
 ### Configuration file
 

package/cli.js

@@ -44,6 +44,14 @@ function fatal(message) {
   process.exit(1);
 }
 
+// Handle broken pipe (e.g., when piping to `head`)
+process.stdout.on('error', (err) => {
+  if (err && err.code === 'EPIPE') {
+    process.exit(0);
+  }
+  fatal('STDOUT error\n' + (err && err.message ? err.message : String(err)));
+});
+
 /**
  * JSON does not support regexes, so, e.g., JSON.parse() will not create
  * a RegExp from the JSON value `[ "/matchString/" ]`, which is
@@ -60,7 +68,7 @@ function fatal(message) {
  * search string, the user would need to enclose the expression in a
  * second set of slashes:
  *
- *    --customAttrSrround "[\"//matchString//\"]"
+ *    --customAttrSurround "[\"//matchString//\"]"
  */
 function parseRegExp(value) {
   if (value) {
@@ -154,7 +162,8 @@ mainOptionKeys.forEach(function (key) {
     program.option('--' + paramCase(key), option);
   }
 });
-program.option('-o --output <file>', 'Specify output file (if not specified STDOUT will be used for output)');
+program.option('-o --output <file>', 'Specify output file (reads from file arguments or STDIN; outputs to STDOUT if not specified)');
+program.option('-d --dry', 'Dry run: process and report statistics without writing output');
 
 function readFile(file) {
   try {
@@ -220,32 +229,35 @@ function createOptions() {
   return options;
 }
 
-function mkdir(outputDir, callback) {
-  fs.mkdir(outputDir, { recursive: true }, function (err) {
-    if (err) {
-      fatal('Cannot create directory ' + outputDir + '\n' + err.message);
-    }
-    callback();
+async function processFile(inputFile, outputFile, isDryRun = false) {
+  const data = await fs.promises.readFile(inputFile, { encoding: 'utf8' }).catch(err => {
+    fatal('Cannot read ' + inputFile + '\n' + err.message);
   });
-}
 
-function processFile(inputFile, outputFile) {
-  fs.readFile(inputFile, { encoding: 'utf8' }, async function (err, data) {
-    if (err) {
-      fatal('Cannot read ' + inputFile + '\n' + err.message);
-    }
-    let minified;
-    try {
-      minified = await minify(data, createOptions());
-    } catch (e) {
-      fatal('Minification error on ' + inputFile + '\n' + e.message);
-    }
-    fs.writeFile(outputFile, minified, { encoding: 'utf8' }, function (err) {
-      if (err) {
-        fatal('Cannot write ' + outputFile + '\n' + err.message);
-      }
-    });
+  let minified;
+  try {
+    minified = await minify(data, createOptions());
+  } catch (e) {
+    fatal('Minification error on ' + inputFile + '\n' + e.message);
+  }
+
+  if (isDryRun) {
+    const originalSize = Buffer.byteLength(data, 'utf8');
+    const minifiedSize = Buffer.byteLength(minified, 'utf8');
+    const saved = originalSize - minifiedSize;
+    const sign = saved >= 0 ? '-' : '+';
+    const percentage = originalSize ? ((Math.abs(saved) / originalSize) * 100).toFixed(1) : '0.0';
+
+    console.error(`  ${path.relative(process.cwd(), inputFile)}: ${originalSize.toLocaleString()} → ${minifiedSize.toLocaleString()} bytes (${sign}${Math.abs(saved).toLocaleString()}, ${percentage}%)`);
+
+    return { originalSize, minifiedSize, saved };
+  }
+
+  await fs.promises.writeFile(outputFile, minified, { encoding: 'utf8' }).catch(err => {
+    fatal('Cannot write ' + outputFile + '\n' + err.message);
   });
+
+  return null;
 }
 
 function parseFileExtensions(fileExt) {
@@ -266,34 +278,57 @@ function shouldProcessFile(filename, fileExtensions) {
   return fileExtensions.includes(fileExt);
 }
 
-function processDirectory(inputDir, outputDir, extensions) {
+async function processDirectory(inputDir, outputDir, extensions, isDryRun = false, skipRootAbs) {
   // If first call provided a string, normalize once; otherwise assume pre-parsed array
   if (typeof extensions === 'string') {
     extensions = parseFileExtensions(extensions);
   }
 
-  fs.readdir(inputDir, function (err, files) {
-    if (err) {
-      fatal('Cannot read directory ' + inputDir + '\n' + err.message);
+  const files = await fs.promises.readdir(inputDir).catch(err => {
+    fatal('Cannot read directory ' + inputDir + '\n' + err.message);
+  });
+
+  const allStats = [];
+
+  for (const file of files) {
+    const inputFile = path.join(inputDir, file);
+    const outputFile = path.join(outputDir, file);
+
+    // Skip anything inside the output root to avoid reprocessing
+    if (skipRootAbs) {
+      const real = await fs.promises.realpath(inputFile).catch(() => undefined);
+      if (real && (real === skipRootAbs || real.startsWith(skipRootAbs + path.sep))) {
+        continue;
+      }
     }
 
-    files.forEach(function (file) {
-      const inputFile = path.join(inputDir, file);
-      const outputFile = path.join(outputDir, file);
-
-      fs.stat(inputFile, function (err, stat) {
-        if (err) {
-          fatal('Cannot read ' + inputFile + '\n' + err.message);
-        } else if (stat.isDirectory()) {
-          processDirectory(inputFile, outputFile, extensions);
-        } else if (shouldProcessFile(file, extensions)) {
-          mkdir(outputDir, function () {
-            processFile(inputFile, outputFile);
-          });
-        }
-      });
+    const lst = await fs.promises.lstat(inputFile).catch(err => {
+      fatal('Cannot read ' + inputFile + '\n' + err.message);
     });
-  });
+
+    if (lst.isSymbolicLink()) {
+      continue;
+    }
+
+    if (lst.isDirectory()) {
+      const dirStats = await processDirectory(inputFile, outputFile, extensions, isDryRun, skipRootAbs);
+      if (dirStats) {
+        allStats.push(...dirStats);
+      }
+    } else if (shouldProcessFile(file, extensions)) {
+      if (!isDryRun) {
+        await fs.promises.mkdir(outputDir, { recursive: true }).catch(err => {
+          fatal('Cannot create directory ' + outputDir + '\n' + err.message);
+        });
+      }
+      const fileStats = await processFile(inputFile, outputFile, isDryRun);
+      if (fileStats) {
+        allStats.push(fileStats);
+      }
+    }
+  }
+
+  return allStats;
 }
 
 const writeMinify = async () => {
@@ -306,16 +341,39 @@ const writeMinify = async () => {
     fatal('Minification error:\n' + e.message);
   }
 
-  let stream = process.stdout;
+  if (programOptions.dry) {
+    const originalSize = Buffer.byteLength(content, 'utf8');
+    const minifiedSize = Buffer.byteLength(minified, 'utf8');
+    const saved = originalSize - minifiedSize;
+    const sign = saved >= 0 ? '-' : '+';
+    const percentage = originalSize ? ((Math.abs(saved) / originalSize) * 100).toFixed(1) : '0.0';
+
+    const inputSource = program.args.length > 0 ? program.args.join(', ') : 'STDIN';
+    const outputDest = programOptions.output || 'STDOUT';
+
+    console.error(`[DRY RUN] Would minify: ${inputSource} → ${outputDest}`);
+    console.error(`  Original: ${originalSize.toLocaleString()} bytes`);
+    console.error(`  Minified: ${minifiedSize.toLocaleString()} bytes`);
+    console.error(`  Saved: ${sign}${Math.abs(saved).toLocaleString()} bytes (${percentage}%)`);
+    return;
+  }
 
   if (programOptions.output) {
-    stream = fs.createWriteStream(programOptions.output)
-      .on('error', (e) => {
-        fatal('Cannot write ' + programOptions.output + '\n' + e.message);
-      });
+    await fs.promises.mkdir(path.dirname(programOptions.output), { recursive: true }).catch((e) => {
+      fatal('Cannot create directory ' + path.dirname(programOptions.output) + '\n' + e.message);
+    });
+    await new Promise((resolve, reject) => {
+      const fileStream = fs.createWriteStream(programOptions.output)
+        .on('error', reject)
+        .on('finish', resolve);
+      fileStream.end(minified);
+      }).catch((e) => {
+      fatal('Cannot write ' + programOptions.output + '\n' + e.message);
+    });
+    return;
   }
 
-  stream.write(minified);
+  process.stdout.write(minified);
 };
 
 const { inputDir, outputDir, fileExt } = programOptions;
@@ -330,7 +388,40 @@ if (inputDir || outputDir) {
   } else if (!outputDir) {
     fatal('You need to specify where to write the output files with the option --output-dir');
   }
-  processDirectory(inputDir, outputDir, resolvedFileExt);
+
+  (async () => {
+    // Prevent traversing into the output directory when it is inside the input directory
+    let inputReal;
+    let outputReal;
+    inputReal = await fs.promises.realpath(inputDir).catch(() => undefined);
+    try {
+      outputReal = await fs.promises.realpath(outputDir);
+    } catch {
+      outputReal = path.resolve(outputDir);
+    }
+    let skipRootAbs;
+    if (inputReal && outputReal && (outputReal === inputReal || outputReal.startsWith(inputReal + path.sep))) {
+      // Instead of aborting, skip traversing into the output directory
+      skipRootAbs = outputReal;
+    }
+
+    if (programOptions.dry) {
+      console.error(`[DRY RUN] Would process directory: ${inputDir} → ${outputDir}`);
+    }
+
+    const stats = await processDirectory(inputDir, outputDir, resolvedFileExt, programOptions.dry, skipRootAbs);
+
+    if (programOptions.dry) {
+      const totalOriginal = stats.reduce((sum, s) => sum + s.originalSize, 0);
+      const totalMinified = stats.reduce((sum, s) => sum + s.minifiedSize, 0);
+      const totalSaved = totalOriginal - totalMinified;
+      const sign = totalSaved >= 0 ? '-' : '+';
+      const totalPercentage = totalOriginal ? ((Math.abs(totalSaved) / totalOriginal) * 100).toFixed(1) : '0.0';
+
+      console.error('---');
+      console.error(`Total: ${totalOriginal.toLocaleString()} → ${totalMinified.toLocaleString()} bytes (${sign}${Math.abs(totalSaved).toLocaleString()}, ${totalPercentage}%)`);
+    }
+  })();
 } else if (content) { // Minifying one or more files specified on the CMD line
   writeMinify();
 } else { // Minifying input coming from STDIN

package/package.json

@@ -15,15 +15,15 @@
   "description": "Highly configurable, well-tested, JavaScript-based HTML minifier",
   "devDependencies": {
     "@commitlint/cli": "^20.1.0",
-    "@eslint/js": "^9.36.0",
-    "@rollup/plugin-commonjs": "^28.0.6",
+    "@eslint/js": "^9.37.0",
+    "@rollup/plugin-commonjs": "^28.0.8",
     "@rollup/plugin-json": "^6.1.0",
-    "@rollup/plugin-node-resolve": "^16.0.2",
+    "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-terser": "^0.4.4",
-    "eslint": "^9.36.0",
+    "eslint": "^9.37.0",
     "rollup": "^4.52.4",
     "rollup-plugin-polyfill-node": "^0.13.0",
-    "vite": "^7.1.9"
+    "vite": "^7.1.12"
   },
   "exports": {
     ".": {
@@ -78,5 +78,5 @@
     "test:watch": "node --test --watch tests/*.spec.js"
   },
   "type": "module",
-  "version": "3.0.0"
+  "version": "3.1.0"
 }