@json-to-office/core-docx 0.34.0 → 0.36.1

package/dist/index.js

@@ -2665,10 +2665,68 @@ function resolveFromBaseDir(filePath) {
   if (!base || isAbsolute(filePath)) return filePath;
   return resolve(base, filePath);
 }
+var warningsStorage = new AsyncLocalStorage();
+function runWithWarnings(warnings, callback) {
+  return warnings === void 0 ? callback() : warningsStorage.run(warnings, callback);
+}
+function reportWarning(component, code, message, context) {
+  const warnings = warningsStorage.getStore();
+  if (warnings) {
+    warnings.push({
+      component,
+      message,
+      severity: "warning",
+      context: { code, ...context }
+    });
+    return;
+  }
+  console.warn(`[json-to-docx] [${code}] ${message}`);
+}
 
 // src/utils/imageUtils.ts
 init_widthUtils();
 import { ImageRun } from "docx";
+var SVG_RASTER_SCALE = 3;
+var SVG_MAX_EDGE_PX = 4096;
+var SVG_MIN_EDGE_PX = 16;
+var resvgModule;
+function loadResvg() {
+  resvgModule ??= import("@resvg/resvg-js");
+  return resvgModule;
+}
+function toRasterPx(px) {
+  return Math.min(
+    SVG_MAX_EDGE_PX,
+    Math.max(SVG_MIN_EDGE_PX, Math.round(px * SVG_RASTER_SCALE))
+  );
+}
+async function rasterizeSvgFallback(svg, transformation) {
+  let Resvg;
+  try {
+    ({ Resvg } = await loadResvg());
+  } catch (error) {
+    reportWarning(
+      "image",
+      "IMAGE_SVG_RASTER_FAILED",
+      `Could not load the SVG rasterizer, so inline SVG keeps a fallback that only Word 2016+ can draw: ${String(error)}`
+    );
+    return void 0;
+  }
+  try {
+    const markup = svg.toString("utf-8");
+    const probeImage = new Resvg(markup);
+    const wide = probeImage.width / probeImage.height > transformation.width / transformation.height;
+    const fitTo = wide ? { mode: "height", value: toRasterPx(transformation.height) } : { mode: "width", value: toRasterPx(transformation.width) };
+    return Buffer.from(new Resvg(markup, { fitTo }).render().asPng());
+  } catch (error) {
+    reportWarning(
+      "image",
+      "IMAGE_SVG_RASTER_FAILED",
+      `Could not rasterize inline SVG, so its fallback only renders in Word 2016+: ${String(error)}`
+    );
+    return void 0;
+  }
+}
 function parseWidthValue(width, availableWidthPx) {
   if (typeof width === "number") {
     return width;
@@ -2778,17 +2836,18 @@ function detectImageType(imagePath, responseContentType) {
   if (typeFromExtension) return typeFromExtension;
   return "png";
 }
-function createTypedImageRun(opts) {
+async function createTypedImageRun(opts) {
   const base = {
     data: opts.data,
     transformation: opts.transformation,
     ...opts.floating && { floating: opts.floating }
   };
   if (opts.type === "svg") {
+    const raster = await rasterizeSvgFallback(opts.data, opts.transformation);
     return new ImageRun({
       type: "svg",
       ...base,
-      fallback: { type: "png", data: opts.data }
+      fallback: { type: "png", data: raster ?? opts.data }
     });
   }
   return new ImageRun({ type: opts.type, ...base });
@@ -5217,7 +5276,7 @@ async function createImage(path4, theme, themeName, options = {}) {
     const { mapFloatingOptions: mapFloatingOptions2 } = await Promise.resolve().then(() => (init_docxImagePositioning(), docxImagePositioning_exports));
     const floating = isFloating ? mapFloatingOptions2(options.floating, theme, themeName) : void 0;
     const imageType = detectImageType(imagePath, responseContentType);
-    const imageRun = createTypedImageRun({
+    const imageRun = await createTypedImageRun({
       type: imageType,
       data: imageBuffer,
       transformation: { width: dimensions.width, height: dimensions.height },
@@ -5762,7 +5821,7 @@ async function createTable(columns, tableConfig, theme, themeName, _options = {}
             // fallback height
           );
           const imgType = detectImageType(imageSource, imageResult.contentType);
-          const imageRun = createTypedImageRun({
+          const imageRun = await createTypedImageRun({
             type: imgType,
             data: imageResult.buffer,
             transformation: {
@@ -7610,14 +7669,19 @@ function effectiveVisualServerUrl(props, serviceConfig) {
   if (serviceConfig?.render) return void 0;
   return props.serverUrl;
 }
-async function rasterizeVisualSlide(presentation, dpi, propsServerUrl, serviceConfig, baseDir) {
+async function rasterizeVisualSlide(presentation, dpi, propsServerUrl, serviceConfig, baseDir, fonts) {
   if (!isNodeEnvironment()) {
     throw new Error(
       "Visual rasterization requires a Node.js environment. It is not available in browser environments."
     );
   }
   if (serviceConfig?.render) {
-    return serviceConfig.render({ presentation, dpi, baseDir });
+    return serviceConfig.render({
+      presentation,
+      dpi,
+      baseDir,
+      ...fonts?.length ? { fonts: [...fonts] } : {}
+    });
   }
   const serverUrl = resolveServiceUrl(
     propsServerUrl,
@@ -7627,7 +7691,12 @@ async function rasterizeVisualSlide(presentation, dpi, propsServerUrl, serviceCo
   const response = await postJsonToService({
     url: serverUrl,
     path: "/rasterize",
-    body: { presentation, dpi, ...baseDir !== void 0 && { baseDir } },
+    body: {
+      presentation,
+      dpi,
+      ...baseDir !== void 0 && { baseDir },
+      ...fonts?.length ? { fonts } : {}
+    },
     headers: serviceConfig?.headers,
     serviceLabel: "PPTX rasterization service",
     onUnreachable: (url, cause) => `PPTX rasterization service is not reachable at ${url}. Configure services.pptx with a \`render\` callback or a running \`serverUrl\`.
@@ -7673,7 +7742,8 @@ async function renderVisualComponent(component, theme, themeName, context) {
       dpi,
       props.serverUrl,
       serviceConfig,
-      getBaseDir()
+      getBaseDir(),
+      context?.visualFonts
     );
   }
   return await createImage(
@@ -7807,6 +7877,11 @@ function collectVisualProps(root) {
 function toErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
+var HTTP_STATUS_IN_MESSAGE = /\breturned (\d{3})\b/;
+function isSchemaRejection(error) {
+  const match = HTTP_STATUS_IN_MESSAGE.exec(toErrorMessage(error));
+  return match !== null && match[1] === "400";
+}
 function* chunksOf(items, size) {
   for (let i = 0; i < items.length; i += size) yield items.slice(i, i + size);
 }
@@ -7865,22 +7940,38 @@ async function prerasterizeVisuals(root, serviceConfig, options = {}) {
   const limit = createLimiter(
     Math.max(1, options.concurrency ?? DEFAULT_FALLBACK_CONCURRENCY)
   );
+  let fontsRejected = false;
+  const requestFonts = () => fontsRejected || !options.fonts?.length ? void 0 : options.fonts;
+  const rasterizeOne = async (target) => {
+    const fonts = requestFonts();
+    const call = (withFonts) => rasterizeVisualSlide(
+      target.presentation,
+      target.dpi,
+      void 0,
+      serviceConfig,
+      options.baseDir,
+      withFonts
+    );
+    try {
+      return { ok: true, ...await call(fonts) };
+    } catch (error) {
+      if (!fonts || !isSchemaRejection(error)) {
+        return { ok: false, error: toErrorMessage(error) };
+      }
+      try {
+        const result = await call(void 0);
+        fontsRejected = true;
+        return { ok: true, ...result };
+      } catch {
+        return { ok: false, error: toErrorMessage(error) };
+      }
+    }
+  };
   const rasterizeIndividually = async (chunk) => {
     await Promise.all(
       chunk.map(
         (target) => limit(async () => {
-          try {
-            const result = await rasterizeVisualSlide(
-              target.presentation,
-              target.dpi,
-              void 0,
-              serviceConfig,
-              options.baseDir
-            );
-            map.set(target.key, { ok: true, ...result });
-          } catch (error) {
-            map.set(target.key, { ok: false, error: toErrorMessage(error) });
-          }
+          map.set(target.key, await rasterizeOne(target));
         })
       )
     );
@@ -7893,7 +7984,8 @@ async function prerasterizeVisuals(root, serviceConfig, options = {}) {
             presentation: target.presentation,
             dpi: target.dpi
           })),
-          ...options.baseDir !== void 0 && { baseDir: options.baseDir }
+          ...options.baseDir !== void 0 && { baseDir: options.baseDir },
+          ...options.fonts?.length ? { fonts: [...options.fonts] } : {}
         });
         if (!applyBatchResponse(chunk, response, map)) {
           throw new Error(
@@ -7922,10 +8014,10 @@ async function prerasterizeVisuals(root, serviceConfig, options = {}) {
     serviceConfig?.serverUrl,
     DEFAULT_RASTERIZE_SERVER_URL
   );
-  for (const chunk of chunksOf(unique, MAX_RASTERIZE_BATCH_SLIDES)) {
-    let applied = false;
+  const postBatch = async (chunk, fonts) => {
+    let response;
     try {
-      const response = await postJsonToService({
+      response = await postJsonToService({
         url: serverUrl,
         path: "/rasterize/batch",
         body: {
@@ -7933,18 +8025,36 @@ async function prerasterizeVisuals(root, serviceConfig, options = {}) {
             presentation: target.presentation,
             dpi: target.dpi
           })),
-          ...options.baseDir !== void 0 && { baseDir: options.baseDir }
+          ...options.baseDir !== void 0 && { baseDir: options.baseDir },
+          ...fonts?.length ? { fonts } : {}
         },
         headers: serviceConfig?.headers,
         timeoutMs: BATCH_TIMEOUT_BASE_MS + BATCH_TIMEOUT_PER_SLIDE_MS * chunk.length,
         serviceLabel: "PPTX batch rasterization service",
         onUnreachable: (url, cause) => `PPTX rasterization service is not reachable at ${url}. Cause: ${cause}`
       });
-      applied = applyBatchResponse(chunk, await response.json(), map);
+    } catch (error) {
+      return { applied: false, schemaRejected: isSchemaRejection(error) };
+    }
+    try {
+      if (applyBatchResponse(chunk, await response.json(), map)) {
+        return { applied: true };
+      }
     } catch {
-      applied = false;
     }
-    if (!applied) await rasterizeIndividually(chunk);
+    return { applied: false, schemaRejected: false };
+  };
+  for (const chunk of chunksOf(unique, MAX_RASTERIZE_BATCH_SLIDES)) {
+    const fonts = requestFonts();
+    let outcome = await postBatch(chunk, fonts);
+    if (!outcome.applied && fonts && outcome.schemaRejected) {
+      const retry = await postBatch(chunk, void 0);
+      if (retry.applied) {
+        fontsRejected = true;
+        outcome = retry;
+      }
+    }
+    if (!outcome.applied) await rasterizeIndividually(chunk);
   }
   return map;
 }
@@ -8053,23 +8163,26 @@ function coreProperties(metadata) {
 async function renderDocument(structure, layout, options) {
   return runWithGenerationDate(
     structure.metadata.date,
-    () => runWithBaseDir(
-      options?.baseDir,
-      () => globalBookmarkRegistry.runScoped(
-        () => globalRevisionIdRegistry.runScoped(
-          () => globalNumberingRegistry.runScoped(
-            () => globalSectionBookmarkRegistry.runScoped(
-              () => (
-                // Comment ids are a separate OOXML namespace from w:ins/w:del,
-                // but they need the same per-render isolation: outside this nest
-                // concurrent generations would interleave counters and an anchor
-                // would point at another document's comment body.
-                globalCommentRegistry.runScoped(
-                  () => (
-                    // Footnote ids are document-scoped too: a reference resolved
-                    // against another render's counter points at the wrong body.
-                    globalNoteRegistry.runScoped(
-                      () => renderDocumentScoped(structure, layout, options)
+    () => runWithWarnings(
+      options?.warnings,
+      () => runWithBaseDir(
+        options?.baseDir,
+        () => globalBookmarkRegistry.runScoped(
+          () => globalRevisionIdRegistry.runScoped(
+            () => globalNumberingRegistry.runScoped(
+              () => globalSectionBookmarkRegistry.runScoped(
+                () => (
+                  // Comment ids are a separate OOXML namespace from w:ins/w:del,
+                  // but they need the same per-render isolation: outside this nest
+                  // concurrent generations would interleave counters and an anchor
+                  // would point at another document's comment body.
+                  globalCommentRegistry.runScoped(
+                    () => (
+                      // Footnote ids are document-scoped too: a reference resolved
+                      // against another render's counter points at the wrong body.
+                      globalNoteRegistry.runScoped(
+                        () => renderDocumentScoped(structure, layout, options)
+                      )
                     )
                   )
                 )
@@ -8094,11 +8207,12 @@ async function renderDocumentScoped(structure, layout, options) {
     structure.themeName
   );
   context.services = options?.services;
+  context.visualFonts = options?.visualFonts;
   try {
     const visualRasterResults = await prerasterizeVisuals(
       layout.sections,
       options?.services?.pptx,
-      { baseDir: getBaseDir() }
+      { baseDir: getBaseDir(), fonts: options?.visualFonts }
     );
     if (visualRasterResults.size > 0) {
       context.visualRasterResults = visualRasterResults;
@@ -8288,7 +8402,7 @@ async function renderHeaderFooterComponents(components, theme, themeName, contex
           themeName
         );
         const imageType = detectImageType(imageSource, responseContentType);
-        const imageRun = createTypedImageRun({
+        const imageRun = await createTypedImageRun({
           type: imageType,
           data: imageBuffer,
           transformation: {
@@ -8468,14 +8582,17 @@ async function renderComponent(component, theme, themeName, context) {
 import {
   collectFontNamesFromDocx,
   validateFontReferences,
-  FontRegistry
+  FontRegistry,
+  documentFontRegistry,
+  themeFontRegistry,
+  mergeFontRegistries
 } from "@json-to-office/shared";
 import {
   loadFileFontSource,
   FontDiskCache,
   fetchVariableFontSource
 } from "@json-to-office/shared/fonts/node";
-async function resolveDocumentFonts(document, theme, fonts, warnings) {
+async function resolveDocumentFonts(document, theme, fonts, warnings, forceMaterialize = false) {
   const emit = (code, message) => {
     if (warnings) {
       warnings.push({
@@ -8492,9 +8609,14 @@ async function resolveDocumentFonts(document, theme, fonts, warnings) {
   for (const n of collectFontNamesFromDocx(document)) names.add(n);
   for (const n of collectFontNamesFromDocx(theme)) names.add(n);
   if (names.size === 0) return [];
+  const registryEntries = mergeFontRegistries(
+    themeFontRegistry(theme),
+    documentFontRegistry(document),
+    fonts?.extraEntries
+  );
   const validation = validateFontReferences({
     referencedNames: names,
-    registeredEntries: fonts?.extraEntries
+    registeredEntries: registryEntries
   });
   if (validation.warnings.length > 0) {
     if (fonts?.strict) {
@@ -8507,9 +8629,11 @@ async function resolveDocumentFonts(document, theme, fonts, warnings) {
       emit(w.code, w.message);
     }
   }
-  if (!fonts?.onResolved) return [];
+  if (!fonts?.onResolved && !forceMaterialize) return [];
   const registry = new FontRegistry({
-    opts: fonts,
+    // Spread keeps baseDir/googleFonts/mode/substitution intact for
+    // materializeSource; extraEntries carries the merged registry.
+    opts: { ...fonts, extraEntries: registryEntries },
     fileLoader: loadFileFontSource,
     variableLoader: fetchVariableFontSource,
     diskCache: fonts?.googleFonts?.cacheDir ? new FontDiskCache(fonts.googleFonts.cacheDir) : void 0
@@ -8520,10 +8644,13 @@ async function resolveDocumentFonts(document, theme, fonts, warnings) {
       emit("FONT_UNRESOLVED", msg);
     }
   }
-  fonts.onResolved(resolved);
+  fonts?.onResolved?.(resolved);
   return resolved;
 }
 
+// src/core/generator.ts
+import { toRasterizeFontFaces } from "@json-to-office/shared/fonts/node";
+
 // src/utils/packageDocument.ts
 import AdmZip2 from "adm-zip";
 import { Packer } from "docx";
@@ -8783,7 +8910,15 @@ async function generateDocumentWithCustomThemes(documentIn, customThemes, servic
     fonts,
     warnings
   });
-  await resolveDocumentFonts(document, theme, fonts, warnings);
+  const hasVisual = collectVisualProps(document).length > 0;
+  const resolvedFonts = await resolveDocumentFonts(
+    document,
+    theme,
+    fonts,
+    warnings,
+    hasVisual
+  );
+  const visualFonts = hasVisual ? toRasterizeFontFaces(resolvedFonts, warnings) : [];
   const structure = await processDocument(
     document,
     theme,
@@ -8794,7 +8929,9 @@ async function generateDocumentWithCustomThemes(documentIn, customThemes, servic
   const renderedDocument = await renderDocument(structure, layout, {
     bypassCache: false,
     services,
-    baseDir
+    baseDir,
+    warnings,
+    ...visualFonts.length > 0 && { visualFonts }
   });
   return renderedDocument;
 }
@@ -8908,7 +9045,11 @@ async function flattenVisuals(doc, options) {
         renderBatch: options.rasterizeBatch,
         dpi: options.dpi
       },
-      { baseDir: options.baseDir, concurrency: options.concurrency }
+      {
+        baseDir: options.baseDir,
+        concurrency: options.concurrency,
+        fonts: options.fonts
+      }
     ).catch(() => /* @__PURE__ */ new Map());
     rasterize = async (request) => {
       const hit = preRasterized.get(
@@ -8929,6 +9070,7 @@ async function flattenVisuals(doc, options) {
     rasterize,
     dpi: options.dpi,
     baseDir: options.baseDir,
+    fonts: options.fonts,
     limit: createLimiter(
       Math.max(1, options.concurrency ?? DEFAULT_CONCURRENCY)
     )
@@ -8942,7 +9084,8 @@ async function rasterizeVisual(obj, ctx) {
     () => ctx.rasterize({
       presentation: buildVisualPresentation(props),
       dpi,
-      baseDir: ctx.baseDir
+      baseDir: ctx.baseDir,
+      ...ctx.fonts?.length ? { fonts: [...ctx.fonts] } : {}
     })
   );
   const image = {
@@ -9218,6 +9361,7 @@ async function runExample(example, options = {}) {
 
 // src/plugin/createDocumentGenerator.ts
 init_themes();
+import { toRasterizeFontFaces as toRasterizeFontFaces2 } from "@json-to-office/shared/fonts/node";
 
 // src/plugin/version-resolver.ts
 import { resolveComponentVersion } from "@json-to-office/shared/plugin";
@@ -9745,7 +9889,15 @@ function createBuilderImpl(state) {
         warnings,
         preserveSet
       } = await expandDocument(document, options);
-      await resolveDocumentFonts(modedDoc, modedTheme, state.fonts, warnings);
+      const hasVisual = collectVisualProps(modedDoc).length > 0;
+      const resolvedFonts = await resolveDocumentFonts(
+        modedDoc,
+        modedTheme,
+        state.fonts,
+        warnings,
+        hasVisual
+      );
+      const visualFonts = hasVisual ? toRasterizeFontFaces2(resolvedFonts, warnings) : [];
       const packageOptions = {
         deterministic: options?.deterministic ?? state.deterministic,
         generatedAt: options?.generatedAt ?? state.generatedAt
@@ -9760,7 +9912,9 @@ function createBuilderImpl(state) {
       const generatedDocument = await renderDocument(structure, layout, {
         services: state.services,
         bypassCache: !state.enableCache,
-        baseDir: options?.baseDir ?? state.baseDir
+        baseDir: options?.baseDir ?? state.baseDir,
+        warnings,
+        ...visualFonts.length > 0 && { visualFonts }
       });
       const preservedDefinition = preserveSet ? {
         ...modedRoot,