@turntrout/subfont 1.5.1 → 1.7.0

package/lib/subsetFonts.js

@@ -7,6 +7,7 @@ const compileQuery = require('assetgraph/lib/compileQuery');
 const findCustomPropertyDefinitions = require('./findCustomPropertyDefinitions');
 const extractReferencedCustomPropertyNames = require('./extractReferencedCustomPropertyNames');
 const injectSubsetDefinitions = require('./injectSubsetDefinitions');
+const { makePhaseTracker } = require('./progress');
 const cssFontParser = require('css-font-parser');
 const cssListHelpers = require('css-list-helpers');
 const unquote = require('./unquote');
@@ -15,6 +16,7 @@ const unicodeRange = require('./unicodeRange');
 const getFontInfo = require('./getFontInfo');
 const collectTextsByPage = require('./collectTextsByPage');
 
+const escapeJsStringLiteral = require('./escapeJsStringLiteral');
 const {
   maybeCssQuote,
   getFontFaceDeclarationText,
@@ -54,16 +56,14 @@ function getParents(asset, assetQuery) {
   return parents;
 }
 
-// Escape a value for safe inclusion in any JS string context (single-quoted,
-// double-quoted, or template literal). Uses JSON.stringify for robust escaping
-// of backslashes, quotes, newlines, U+2028, U+2029, etc.
-// The < escape prevents </script> from closing an inline script tag.
-function escapeJsStringLiteral(str) {
-  return JSON.stringify(str)
-    .slice(1, -1)
-    .replace(/'/g, "\\'")
-    .replace(/`/g, '\\x60')
-    .replace(/</g, '\\x3c');
+function countUniqueFontUrls(htmlOrSvgAssetTextsWithProps) {
+  const urls = new Set();
+  for (const item of htmlOrSvgAssetTextsWithProps) {
+    for (const fu of item.fontUsages) {
+      if (fu.fontUrl) urls.add(fu.fontUrl);
+    }
+  }
+  return urls.size;
 }
 
 function asyncLoadStyleRelationWithFallback(
@@ -214,8 +214,8 @@ const validFontDisplayValues = [
 
 const warnAboutMissingGlyphs = require('./warnAboutMissingGlyphs');
 
-// Extract subset CSS asset creation/caching into a standalone function
-// to reduce cyclomatic complexity of the main injection loop.
+// Create (or retrieve from disk cache) the subset CSS asset for a set of
+// fontUsages, relocating the font binary to its hashed URL under subsetUrl.
 async function getOrCreateSubsetCssAsset({
   assetGraph,
   subsetCssText,
@@ -311,7 +311,8 @@ async function getOrCreateSubsetCssAsset({
   return cssAsset;
 }
 
-// Extract subset font preload insertion to reduce injection loop complexity.
+// Insert <link rel="preload"> hints for every woff2 subset flagged as
+// preload-worthy, so the browser starts fetching them during HTML parse.
 function addSubsetFontPreloads({
   cssAsset,
   fontUsages,
@@ -362,6 +363,104 @@ function addSubsetFontPreloads({
   return insertionPoint;
 }
 
+// Skip Google Fonts populate when no Google Fonts references exist —
+// otherwise assetgraph spends ~30s network-walking for nothing on sites
+// that only self-host. Returns whether the populate ran so callers can
+// annotate their phase timing.
+async function populateGoogleFontsIfPresent(assetGraph) {
+  const hasGoogleFonts =
+    assetGraph.findRelations({
+      to: { url: { $regex: googleFontsCssUrlRegex } },
+    }).length > 0;
+  if (!hasGoogleFonts) return false;
+
+  await assetGraph.populate({
+    followRelations: {
+      $or: [
+        { to: { url: { $regex: googleFontsCssUrlRegex } } },
+        {
+          type: 'CssFontFaceSrc',
+          from: { url: { $regex: googleFontsCssUrlRegex } },
+        },
+      ],
+    },
+  });
+  return true;
+}
+
+// Strip every original @font-face rule when --no-fallbacks is set. The
+// severed assets are returned via the `potentiallyOrphanedAssets` set so
+// the final orphan sweep can remove anything left dangling.
+function removeOriginalFontFaceRules(
+  htmlOrSvgAssets,
+  fontFaceDeclarationsByHtmlOrSvgAsset,
+  potentiallyOrphanedAssets
+) {
+  for (const htmlOrSvgAsset of htmlOrSvgAssets) {
+    const accumulatedFontFaceDeclarations =
+      fontFaceDeclarationsByHtmlOrSvgAsset.get(htmlOrSvgAsset);
+    for (const { relations } of accumulatedFontFaceDeclarations) {
+      for (const relation of relations) {
+        potentiallyOrphanedAssets.add(relation.to);
+        if (relation.node.parentNode) {
+          relation.node.parentNode.removeChild(relation.node);
+        }
+        relation.remove();
+      }
+    }
+    htmlOrSvgAsset.markDirty();
+  }
+}
+
+// Rewrite CSS source-map relations to the caller's chosen hrefType so they
+// align with the rest of the emitted assets. Only invoked when sourceMaps is
+// enabled — subsetFonts normally skips source-map serialization for speed.
+async function rewriteCssSourceMaps(assetGraph, hrefType) {
+  await assetGraph.serializeSourceMaps(undefined, {
+    type: 'Css',
+    outgoingRelations: {
+      $where: (relations) =>
+        relations.some((relation) => relation.type === 'CssSourceMappingUrl'),
+    },
+  });
+  for (const relation of assetGraph.findRelations({
+    type: 'SourceMapSource',
+  })) {
+    relation.hrefType = hrefType;
+  }
+  for (const relation of assetGraph.findRelations({
+    type: 'CssSourceMappingUrl',
+    hrefType: { $in: ['relative', 'inline'] },
+  })) {
+    relation.hrefType = hrefType;
+  }
+}
+
+// Remove assets whose last incoming relation was severed during subset
+// injection (original @font-face rules, merged Google Fonts CSS, etc.) so
+// the emitted site doesn't ship with dangling files.
+function removeOrphanedAssets(assetGraph, potentiallyOrphanedAssets) {
+  for (const asset of potentiallyOrphanedAssets) {
+    if (asset.incomingRelations.length === 0) {
+      assetGraph.removeAsset(asset);
+    }
+  }
+}
+
+// Shape the per-page fontUsages into the external fontInfo report: strip
+// internal bookkeeping (subsets buffer, feature-tag scratch) and flatten
+// each page to { assetFileName, fontUsages }.
+function buildFontInfoReport(htmlOrSvgAssetTextsWithProps) {
+  return htmlOrSvgAssetTextsWithProps.map(({ fontUsages, htmlOrSvgAsset }) => ({
+    assetFileName: htmlOrSvgAsset.nonInlineAncestor.urlOrDescription,
+    fontUsages: fontUsages.map((fontUsage) =>
+      (({ subsets, hasFontFeatureSettings, fontFeatureTags, ...rest }) => rest)(
+        fontUsage
+      )
+    ),
+  }));
+}
+
 async function subsetFonts(
   assetGraph,
   {
@@ -396,50 +495,19 @@ async function subsetFonts(
   const subsetUrl = urltools.ensureTrailingSlash(assetGraph.root + subsetPath);
 
   const timings = {};
+  const trackPhase = makePhaseTracker(console, debug);
 
-  let phaseStart = Date.now();
+  const applySourceMapsPhase = trackPhase('applySourceMaps');
   if (sourceMaps) {
     await assetGraph.applySourceMaps({ type: 'Css' });
   }
-  timings.applySourceMaps = Date.now() - phaseStart;
-  if (debug && console)
-    console.log(
-      `[subfont timing] applySourceMaps: ${timings.applySourceMaps}ms`
-    );
-
-  phaseStart = Date.now();
-  // Only run Google Fonts populate if there are actually Google Fonts
-  // references in the graph. This avoids ~30s of wasted work on sites
-  // that use only self-hosted fonts.
-  const hasGoogleFonts =
-    assetGraph.findRelations({
-      to: { url: { $regex: googleFontsCssUrlRegex } },
-    }).length > 0;
+  timings.applySourceMaps = applySourceMapsPhase.end();
 
-  if (hasGoogleFonts) {
-    await assetGraph.populate({
-      followRelations: {
-        $or: [
-          {
-            to: {
-              url: { $regex: googleFontsCssUrlRegex },
-            },
-          },
-          {
-            type: 'CssFontFaceSrc',
-            from: {
-              url: { $regex: googleFontsCssUrlRegex },
-            },
-          },
-        ],
-      },
-    });
-  }
-  timings['populate (google fonts)'] = Date.now() - phaseStart;
-  if (debug && console)
-    console.log(
-      `[subfont timing] populate (google fonts): ${timings['populate (google fonts)']}ms${hasGoogleFonts ? '' : ' (skipped, no Google Fonts found)'}`
-    );
+  const googlePopulatePhase = trackPhase('populate (google fonts)');
+  const hasGoogleFonts = await populateGoogleFontsIfPresent(assetGraph);
+  timings['populate (google fonts)'] = googlePopulatePhase.end(
+    hasGoogleFonts ? null : 'skipped, no Google Fonts found'
+  );
 
   const htmlOrSvgAssets = assetGraph.findAssets({
     $or: [
@@ -453,11 +521,9 @@ async function subsetFonts(
     ],
   });
 
-  if (debug && console)
-    console.log(
-      `[subfont timing] Starting collectTextsByPage for ${htmlOrSvgAssets.length} pages`
-    );
-  const collectStart = Date.now();
+  const collectPhase = trackPhase(
+    `collectTextsByPage (${htmlOrSvgAssets.length} pages)`
+  );
   const {
     htmlOrSvgAssetTextsWithProps,
     fontFaceDeclarationsByHtmlOrSvgAsset,
@@ -470,40 +536,21 @@ async function subsetFonts(
     concurrency,
     chromeArgs,
   });
-  timings.collectTextsByPage = Date.now() - collectStart;
+  timings.collectTextsByPage = collectPhase.end();
   timings.collectTextsByPageDetails = subTimings;
-  if (debug && console)
-    console.log(
-      `[subfont timing] collectTextsByPage finished in ${timings.collectTextsByPage}ms`
-    );
-
-  phaseStart = Date.now();
 
+  const omitFallbacksPhase = trackPhase('omitFallbacks processing');
   const potentiallyOrphanedAssets = new Set();
   if (omitFallbacks) {
-    for (const htmlOrSvgAsset of htmlOrSvgAssets) {
-      const accumulatedFontFaceDeclarations =
-        fontFaceDeclarationsByHtmlOrSvgAsset.get(htmlOrSvgAsset);
-      // Remove the original @font-face rules:
-      for (const { relations } of accumulatedFontFaceDeclarations) {
-        for (const relation of relations) {
-          potentiallyOrphanedAssets.add(relation.to);
-          if (relation.node.parentNode) {
-            relation.node.parentNode.removeChild(relation.node);
-          }
-          relation.remove();
-        }
-      }
-      htmlOrSvgAsset.markDirty();
-    }
+    removeOriginalFontFaceRules(
+      htmlOrSvgAssets,
+      fontFaceDeclarationsByHtmlOrSvgAsset,
+      potentiallyOrphanedAssets
+    );
   }
+  timings['omitFallbacks processing'] = omitFallbacksPhase.end();
 
-  timings['omitFallbacks processing'] = Date.now() - phaseStart;
-  if (debug && console)
-    console.log(
-      `[subfont timing] omitFallbacks processing: ${timings['omitFallbacks processing']}ms`
-    );
-  phaseStart = Date.now();
+  const codepointPhase = trackPhase('codepoint generation');
 
   if (fontDisplay) {
     for (const htmlOrSvgAssetTextWithProps of htmlOrSvgAssetTextsWithProps) {
@@ -602,12 +649,7 @@ async function subsetFonts(
     }
   }
 
-  timings['codepoint generation'] = Date.now() - phaseStart;
-  if (debug && console)
-    console.log(
-      `[subfont timing] codepoint generation: ${timings['codepoint generation']}ms`
-    );
-  phaseStart = Date.now();
+  timings['codepoint generation'] = codepointPhase.end();
 
   if (onlyInfo) {
     return {
@@ -625,62 +667,61 @@ async function subsetFonts(
     };
   }
 
+  const variationPhase = trackPhase('variation axis usage');
   const { seenAxisValuesByFontUrlAndAxisName } = getVariationAxisUsage(
     htmlOrSvgAssetTextsWithProps,
     parseFontWeightRange,
     parseFontStretchRange
   );
-
-  timings['variation axis usage'] = Date.now() - phaseStart;
-  if (debug && console)
-    console.log(
-      `[subfont timing] variation axis usage: ${timings['variation axis usage']}ms`
-    );
-  phaseStart = Date.now();
+  timings['variation axis usage'] = variationPhase.end();
 
   // Generate subsets:
+  if (console) {
+    const uniqueFontUrls = countUniqueFontUrls(htmlOrSvgAssetTextsWithProps);
+    if (uniqueFontUrls > 0) {
+      console.log(
+        `  Subsetting ${uniqueFontUrls} unique font file${uniqueFontUrls === 1 ? '' : 's'}...`
+      );
+    }
+  }
+  const subsetPhase = trackPhase('getSubsetsForFontUsage');
   await getSubsetsForFontUsage(
     assetGraph,
     htmlOrSvgAssetTextsWithProps,
     formats,
     seenAxisValuesByFontUrlAndAxisName,
     cacheDir,
-    console
+    console,
+    debug
   );
+  timings.getSubsetsForFontUsage = subsetPhase.end();
 
-  timings.getSubsetsForFontUsage = Date.now() - phaseStart;
-  if (debug && console)
-    console.log(
-      `[subfont timing] getSubsetsForFontUsage: ${timings.getSubsetsForFontUsage}ms`
-    );
-  phaseStart = Date.now();
-
+  const warnGlyphsPhase = trackPhase('warnAboutMissingGlyphs');
   await warnAboutMissingGlyphs(htmlOrSvgAssetTextsWithProps, assetGraph);
-  timings.warnAboutMissingGlyphs = Date.now() - phaseStart;
-  if (debug && console)
-    console.log(
-      `[subfont timing] warnAboutMissingGlyphs: ${timings.warnAboutMissingGlyphs}ms`
-    );
-  phaseStart = Date.now();
+  timings.warnAboutMissingGlyphs = warnGlyphsPhase.end();
 
   // Insert subsets:
 
-  // Pre-compute which fontUrls are used (with text) on every page,
-  // so we can avoid O(pages × fontUsages) checks inside the font loop.
+  // Pre-compute which fontUrls are used (with text) on every page.
+  // Set intersection: O(pages × fonts_per_page) vs the old every+some approach.
   const fontUrlsUsedOnEveryPage = new Set();
   if (htmlOrSvgAssetTextsWithProps.length > 0) {
-    // Start with all fontUrls from the first page
     const firstPageFontUrls = new Set();
     for (const fu of htmlOrSvgAssetTextsWithProps[0].fontUsages) {
       if (fu.pageText) firstPageFontUrls.add(fu.fontUrl);
     }
     for (const fontUrl of firstPageFontUrls) {
-      if (
-        htmlOrSvgAssetTextsWithProps.every(({ fontUsages }) =>
-          fontUsages.some((fu) => fu.pageText && fu.fontUrl === fontUrl)
-        )
-      ) {
-        fontUrlsUsedOnEveryPage.add(fontUrl);
+      fontUrlsUsedOnEveryPage.add(fontUrl);
+    }
+    for (let i = 1; i < htmlOrSvgAssetTextsWithProps.length; i++) {
+      const pageFontUrls = new Set();
+      for (const fu of htmlOrSvgAssetTextsWithProps[i].fontUsages) {
+        if (fu.pageText) pageFontUrls.add(fu.fontUrl);
+      }
+      for (const fontUrl of fontUrlsUsedOnEveryPage) {
+        if (!pageFontUrls.has(fontUrl)) {
+          fontUrlsUsedOnEveryPage.delete(fontUrl);
+        }
       }
     }
   }
@@ -689,6 +730,12 @@ async function subsetFonts(
   // addAsset/minify/removeAsset cycles for pages sharing identical CSS.
   const subsetCssAssetCache = new Map();
 
+  // Cache the heavy CSS-text assembly (including base64-encoded font data)
+  // keyed by the shared accumulatedFontFaceDeclarations array. Pages grouped
+  // under the same stylesheet config produce byte-identical output, so this
+  // collapses the per-page string build from O(pages) to O(unique configs).
+  const subsetCssTextCache = new WeakMap();
+
   // Pre-index relations by source asset to avoid O(allRelations) scans
   // in the per-page injection loop below. Build indices once, then use
   // O(1) lookups per page instead of repeated assetGraph.findRelations.
@@ -711,6 +758,9 @@ async function subsetFonts(
     index.get(from).push(relation);
   }
 
+  const insertPhase = trackPhase(
+    `insert subsets loop (${htmlOrSvgAssetTextsWithProps.length} pages)`
+  );
   let numFontUsagesWithSubset = 0;
   for (const {
     htmlOrSvgAsset,
@@ -783,11 +833,19 @@ async function subsetFonts(
     }
     numFontUsagesWithSubset += subsetFontUsages.length;
 
-    let subsetCssText = getFontUsageStylesheet(subsetFontUsages);
-    const unusedVariantsCss = getUnusedVariantsStylesheet(
-      fontUsages,
-      accumulatedFontFaceDeclarations
-    );
+    let cssTextParts = subsetCssTextCache.get(accumulatedFontFaceDeclarations);
+    if (!cssTextParts) {
+      cssTextParts = {
+        subset: getFontUsageStylesheet(subsetFontUsages),
+        unused: getUnusedVariantsStylesheet(
+          fontUsages,
+          accumulatedFontFaceDeclarations
+        ),
+      };
+      subsetCssTextCache.set(accumulatedFontFaceDeclarations, cssTextParts);
+    }
+    let subsetCssText = cssTextParts.subset;
+    const unusedVariantsCss = cssTextParts.unused;
     if (!inlineCss && !omitFallbacks) {
       // This can go into the same stylesheet because we won't reload all __subset suffixed families in the JS preload fallback
       subsetCssText += unusedVariantsCss;
@@ -845,17 +903,13 @@ async function subsetFonts(
     }
   }
 
-  timings['insert subsets loop'] = Date.now() - phaseStart;
-  if (debug && console)
-    console.log(
-      `[subfont timing] insert subsets loop: ${timings['insert subsets loop']}ms`
-    );
-  phaseStart = Date.now();
+  timings['insert subsets loop'] = insertPhase.end();
 
   if (numFontUsagesWithSubset === 0) {
     return { fontInfo: [], timings };
   }
 
+  const lazyFallbackPhase = trackPhase('lazy load fallback CSS');
   const relationsToRemove = new Set();
 
   // Lazy load the original @font-face declarations of self-hosted fonts (unless omitFallbacks)
@@ -956,12 +1010,9 @@ async function subsetFonts(
     relationsToRemove.add(fallbackHtmlStyle);
   }
 
-  timings['lazy load fallback CSS'] = Date.now() - phaseStart;
-  if (debug && console)
-    console.log(
-      `[subfont timing] lazy load fallback CSS: ${timings['lazy load fallback CSS']}ms`
-    );
-  phaseStart = Date.now();
+  timings['lazy load fallback CSS'] = lazyFallbackPhase.end();
+
+  const removeFontFacePhase = trackPhase('remove original @font-face');
 
   // Remove the original @font-face blocks, and don't leave behind empty stylesheets:
   const maybeEmptyCssAssets = new Set();
@@ -984,18 +1035,20 @@ async function subsetFonts(
     }
   }
 
-  timings['remove original @font-face'] = Date.now() - phaseStart;
-  if (debug && console)
-    console.log(
-      `[subfont timing] remove original @font-face: ${timings['remove original @font-face']}ms`
-    );
-  phaseStart = Date.now();
+  timings['remove original @font-face'] = removeFontFacePhase.end();
 
-  // Async load Google Web Fonts CSS
-  const googleFontStylesheets = assetGraph.findAssets({
-    type: 'Css',
-    url: { $regex: googleFontsCssUrlRegex },
-  });
+  const googleCleanupPhase = trackPhase('Google Fonts + cleanup');
+
+  // Async load Google Web Fonts CSS.  Skip the regex findAssets scan and
+  // the surrounding loop entirely when no Google Fonts were detected up
+  // front — the final detach loop below still runs because other phases
+  // (lazy fallback CSS) populate relationsToRemove.
+  const googleFontStylesheets = hasGoogleFonts
+    ? assetGraph.findAssets({
+        type: 'Css',
+        url: { $regex: googleFontsCssUrlRegex },
+      })
+    : [];
   const selfHostedGoogleCssByUrl = new Map();
   for (const googleFontStylesheet of googleFontStylesheets) {
     const seenPages = new Set(); // Only do the work once for each font on each page
@@ -1067,16 +1120,13 @@ async function subsetFonts(
     relation.detach();
   }
 
-  timings['Google Fonts + cleanup'] = Date.now() - phaseStart;
-  if (debug && console)
-    console.log(
-      `[subfont timing] Google Fonts + cleanup: ${timings['Google Fonts + cleanup']}ms`
-    );
-  phaseStart = Date.now();
+  timings['Google Fonts + cleanup'] = googleCleanupPhase.end();
+
+  const injectPhase = trackPhase('inject subset font-family into CSS/SVG');
 
   // Use subsets in font-family:
 
-  const webfontNameMap = {};
+  const webfontNameMap = Object.create(null);
 
   for (const { fontUsages } of htmlOrSvgAssetTextsWithProps) {
     for (const { subsets, fontFamilies, props } of fontUsages) {
@@ -1090,6 +1140,7 @@ async function subsetFonts(
   }
 
   let customPropertyDefinitions; // Avoid computing this unless necessary
+  const cssAssetsDirtiedByCustomProps = new Set();
   // Inject subset font name before original webfont in SVG font-family attributes
   const svgAssets = assetGraph.findAssets({ type: 'Svg' });
   for (const svgAsset of svgAssets) {
@@ -1128,7 +1179,10 @@ async function subsetFonts(
     type: 'Css',
     isLoaded: true,
   });
-  let changesMadeToCustomPropertyDefinitions = false;
+  const parseTreeToAsset = new Map();
+  for (const cssAsset of cssAssets) {
+    parseTreeToAsset.set(cssAsset.parseTree, cssAsset);
+  }
   for (const cssAsset of cssAssets) {
     let changesMade = false;
     cssAsset.eachRuleInParseTree((cssRule) => {
@@ -1156,7 +1210,10 @@ async function subsetFonts(
             );
             if (modifiedValue !== relatedCssRule.value) {
               relatedCssRule.value = modifiedValue;
-              changesMadeToCustomPropertyDefinitions = true;
+              const ownerAsset = parseTreeToAsset.get(relatedCssRule.root());
+              if (ownerAsset) {
+                cssAssetsDirtiedByCustomProps.add(ownerAsset);
+              }
             }
           }
         }
@@ -1213,68 +1270,23 @@ async function subsetFonts(
     }
   }
 
-  // This is a bit crude, could be more efficient if we tracked the containing asset in findCustomPropertyDefinitions
-  if (changesMadeToCustomPropertyDefinitions) {
-    for (const cssAsset of cssAssets) {
-      cssAsset.markDirty();
-    }
+  for (const dirtiedAsset of cssAssetsDirtiedByCustomProps) {
+    dirtiedAsset.markDirty();
   }
 
-  timings['inject subset font-family'] = Date.now() - phaseStart;
-  if (debug && console)
-    console.log(
-      `[subfont timing] inject subset font-family into CSS/SVG: ${timings['inject subset font-family']}ms`
-    );
-  phaseStart = Date.now();
+  timings['inject subset font-family'] = injectPhase.end();
 
+  const orphanCleanupPhase = trackPhase('source maps + orphan cleanup');
   if (sourceMaps) {
-    await assetGraph.serializeSourceMaps(undefined, {
-      type: 'Css',
-      outgoingRelations: {
-        $where: (relations) =>
-          relations.some((relation) => relation.type === 'CssSourceMappingUrl'),
-      },
-    });
-    for (const relation of assetGraph.findRelations({
-      type: 'SourceMapSource',
-    })) {
-      relation.hrefType = hrefType;
-    }
-    for (const relation of assetGraph.findRelations({
-      type: 'CssSourceMappingUrl',
-      hrefType: { $in: ['relative', 'inline'] },
-    })) {
-      relation.hrefType = hrefType;
-    }
+    await rewriteCssSourceMaps(assetGraph, hrefType);
   }
+  removeOrphanedAssets(assetGraph, potentiallyOrphanedAssets);
+  timings['source maps + orphan cleanup'] = orphanCleanupPhase.end();
 
-  for (const asset of potentiallyOrphanedAssets) {
-    if (asset.incomingRelations.length === 0) {
-      assetGraph.removeAsset(asset);
-    }
-  }
-
-  timings['source maps + orphan cleanup'] = Date.now() - phaseStart;
-  if (debug && console)
-    console.log(
-      `[subfont timing] source maps + orphan cleanup: ${timings['source maps + orphan cleanup']}ms`
-    );
-
-  // Hand out some useful info about the detected subsets:
   return {
-    fontInfo: htmlOrSvgAssetTextsWithProps.map(
-      ({ fontUsages, htmlOrSvgAsset }) => ({
-        assetFileName: htmlOrSvgAsset.nonInlineAncestor.urlOrDescription,
-        fontUsages: fontUsages.map((fontUsage) =>
-          (({ subsets, hasFontFeatureSettings, fontFeatureTags, ...rest }) =>
-            rest)(fontUsage)
-        ),
-      })
-    ),
+    fontInfo: buildFontInfoReport(htmlOrSvgAssetTextsWithProps),
     timings,
   };
 }
 
 module.exports = subsetFonts;
-// Exported for testing
-module.exports._escapeJsStringLiteral = escapeJsStringLiteral;

package/lib/subsetGeneration.js

@@ -118,9 +118,11 @@ async function getSubsetsForFontUsage(
   formats,
   seenAxisValuesByFontUrlAndAxisName,
   cacheDir = null,
-  console = null
+  console = null,
+  debug = false
 ) {
   const diskCache = cacheDir ? new SubsetDiskCache(cacheDir, console) : null;
+  const cacheStats = diskCache ? { hits: 0, misses: 0 } : null;
 
   // Collect one canonical fontUsage per font URL
   const canonicalFontUsageByUrl = new Map();
@@ -240,8 +242,10 @@ async function getSubsetsForFontUsage(
           const cachedResult = diskCache ? await diskCache.get(cacheKey) : null;
 
           if (cachedResult) {
+            if (cacheStats) cacheStats.hits++;
             subsetPromiseMap.set(promiseId, Promise.resolve(cachedResult));
           } else {
+            if (cacheStats) cacheStats.misses++;
             const subsetCall = subsetFontWithGlyphs(fontBuffer, text, {
               targetFormat,
               glyphIds: featureGlyphIds,
@@ -279,6 +283,14 @@ async function getSubsetsForFontUsage(
     )
   );
 
+  if (cacheStats && debug && console) {
+    const total = cacheStats.hits + cacheStats.misses;
+    const pct = total > 0 ? Math.round((cacheStats.hits * 100) / total) : 0;
+    console.log(
+      `[subfont timing]   subset disk cache: ${cacheStats.hits} hit${cacheStats.hits === 1 ? '' : 's'}, ${cacheStats.misses} miss${cacheStats.misses === 1 ? '' : 'es'} (${pct}% hit rate)`
+    );
+  }
+
   // Assign subset results to canonical font usages
   for (const [, fontUsage] of canonicalFontUsageByUrl) {
     const info = subsetInfoByFontUrl.get(fontUsage.fontUrl);