@turntrout/subfont 1.3.2 → 1.4.0

package/README.md

@@ -71,6 +71,7 @@ subfont path/to/index.html -i --cache
 |  `--concurrency N` |         | Max worker threads (capped by available memory, ~50 MB each) |
 |   `--chrome-flags` |         | Custom Chrome flags for `--dynamic`                          |
 |    `--source-maps` |   off   | Preserve CSS source maps (slower)                            |
+|         `--strict` |   off   | Exit non-zero if any warnings are emitted                    |
 |     `-s, --silent` |   off   | Suppress all console output                                  |
 |      `-d, --debug` |   off   | Verbose timing and font glyph detection info                 |
 |  `--relative-urls` |   off   | Emit relative URLs instead of root-relative                  |

package/lib/parseCommandLineOptions.js

@@ -132,6 +132,12 @@ module.exports = function parseCommandLineOptions(argv) {
       type: 'boolean',
       default: false,
     })
+    .options('strict', {
+      describe:
+        'Exit with a non-zero status code if any warnings are emitted during the run',
+      type: 'boolean',
+      default: false,
+    })
     .wrap(require('yargs').terminalWidth());
 
   const { _: inputFiles, ...rest } = yargs.argv;

package/lib/subfont.js

@@ -36,6 +36,7 @@ module.exports = async function subfont(
     concurrency,
     chromeFlags = [],
     cache = false,
+    strict = false,
   },
   console
 ) {
@@ -52,6 +53,16 @@ module.exports = async function subfont(
     );
   }
 
+  // Prevent postcss plugins (colormin, convert-values, etc.) invoked by
+  // cssnano from walking the filesystem for a "browserslist" config.
+  // Under pnpm, `node_modules/.bin/browserslist` is a shell shim that
+  // browserslist mis-parses as browser queries, throwing
+  // BrowserslistError and silently aborting CSS minification.
+  // Setting BROWSERSLIST short-circuits the walk entirely.
+  if (!process.env.BROWSERSLIST && !process.env.BROWSERSLIST_CONFIG) {
+    process.env.BROWSERSLIST = 'defaults';
+  }
+
   const formats = ['woff2'];
 
   function logToConsole(severity, ...args) {
@@ -164,17 +175,19 @@ module.exports = async function subfont(
     );
   }
 
+  let sawWarning = false;
+  const origEmit = assetGraph.emit;
+  assetGraph.emit = function (event, err, ...rest) {
+    if (event === 'warn') {
+      if (isExtensionlessEnoent(err)) return false;
+      sawWarning = true;
+    }
+    return origEmit.call(this, event, err, ...rest);
+  };
   if (silent) {
     assetGraph.on('warn', () => {});
   } else {
-    const origEmit = assetGraph.emit;
-    assetGraph.emit = function (event, err, ...rest) {
-      if (event === 'warn' && isExtensionlessEnoent(err)) {
-        return false;
-      }
-      return origEmit.call(this, event, err, ...rest);
-    };
-    await assetGraph.logEvents({ console });
+    await assetGraph.logEvents({ console, stopOnWarning: strict });
   }
 
   const outerTimings = {};
@@ -336,6 +349,15 @@ module.exports = async function subfont(
       `[subfont timing] post-subsetFonts processing: ${outerTimings['post-subsetFonts processing']}ms`
     );
 
+  if (strict && sawWarning) {
+    // In non-silent mode, assetgraph's logEvents normally exits earlier via
+    // stopOnWarning. This guard covers silent mode and warnings that slipped
+    // past a transform boundary.
+    throw new Error(
+      'subfont: --strict was set and one or more warnings were emitted; refusing to write output.'
+    );
+  }
+
   phaseStart = Date.now();
   if (!dryRun) {
     await assetGraph.writeAssetsToDisc(

package/lib/warnAboutMissingGlyphs.js

@@ -60,43 +60,43 @@ async function warnAboutMissingGlyphs(
         const isMissing = !characterSetLookup.has(codePoint);
 
         if (isMissing) {
-          // Find all occurrences of the missing character in the source,
-          // not just the first, so that every location is reported.
-          const locations = [];
-          const sourceText = htmlOrSvgAsset.text;
+          // Report only the first location plus a count of remaining
+          // occurrences. A character like U+200B can appear thousands of
+          // times on a page and per-occurrence lines drown the log.
+          let firstLocation;
+          let occurrences = 0;
           if (char.length > 0) {
+            const sourceText = htmlOrSvgAsset.text;
             let searchIdx = 0;
             while (true) {
               const charIdx = sourceText.indexOf(char, searchIdx);
               if (charIdx === -1) break;
-              if (!linesAndColumns) {
-                linesAndColumns = new LinesAndColumns(sourceText);
+              occurrences++;
+              if (occurrences === 1) {
+                if (!linesAndColumns) {
+                  linesAndColumns = new LinesAndColumns(sourceText);
+                }
+                const position = linesAndColumns.locationForIndex(charIdx);
+                firstLocation = `${htmlOrSvgAsset.urlOrDescription}:${
+                  position.line + 1
+                }:${position.column + 1}`;
               }
-              const position = linesAndColumns.locationForIndex(charIdx);
-              locations.push(
-                `${htmlOrSvgAsset.urlOrDescription}:${position.line + 1}:${
-                  position.column + 1
-                }`
-              );
               searchIdx = charIdx + char.length;
             }
           }
 
-          if (locations.length === 0) {
-            locations.push(
-              `${htmlOrSvgAsset.urlOrDescription} (generated content)`
-            );
+          if (!firstLocation) {
+            firstLocation = `${htmlOrSvgAsset.urlOrDescription} (generated content)`;
           }
 
-          for (const location of locations) {
-            missingGlyphsErrors.push({
-              codePoint,
-              char,
-              htmlOrSvgAsset,
-              fontUsage,
-              location,
-            });
-          }
+          missingGlyphsErrors.push({
+            codePoint,
+            char,
+            htmlOrSvgAsset,
+            fontUsage,
+            location: firstLocation,
+            occurrences,
+          });
           missedAny = true;
         }
       }
@@ -123,12 +123,14 @@ async function warnAboutMissingGlyphs(
 
   if (missingGlyphsErrors.length) {
     const errorLog = missingGlyphsErrors.map(
-      ({ char, fontUsage, location }) =>
-        `- \\u{${char.codePointAt(0).toString(16)}} (${char}) in font-family '${
+      ({ char, fontUsage, location, occurrences }) => {
+        const extra = occurrences > 1 ? ` (+${occurrences - 1} more)` : '';
+        return `- \\u{${char.codePointAt(0).toString(16)}} (${char}) in font-family '${
           fontUsage.props['font-family']
         }' (${fontUsage.props['font-weight']}/${
           fontUsage.props['font-style']
-        }) at ${location}`
+        }) at ${location}${extra}`;
+      }
     );
 
     const message = `Missing glyph fallback detected.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turntrout/subfont",
-  "version": "1.3.2",
+  "version": "1.4.0",
   "description": "Automatically subset web fonts to only the characters used on your pages. Fork of Munter/subfont with modern defaults.",
   "engines": {
     "node": ">=18.0.0"