@json-to-office/core-docx 0.27.0 → 0.29.0

package/dist/index.js

@@ -1924,6 +1924,7 @@ var init_docxImagePositioning = __esm({
 
 // src/core/generator.ts
 import { writeFileSync } from "fs";
+import { dirname, resolve as resolve3 } from "path";
 
 // src/types/index.ts
 import {
@@ -2698,9 +2699,34 @@ import {
 } from "docx";
 
 // src/utils/imageUtils.ts
-init_widthUtils();
 import { readFileSync } from "fs";
 import probe from "probe-image-size";
+
+// src/utils/generationContext.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { isAbsolute, resolve } from "path";
+var generationDateStorage = new AsyncLocalStorage();
+function runWithGenerationDate(date, callback) {
+  return generationDateStorage.run(date, callback);
+}
+function getGenerationDate() {
+  return generationDateStorage.getStore() ?? /* @__PURE__ */ new Date();
+}
+var baseDirStorage = new AsyncLocalStorage();
+function runWithBaseDir(baseDir, callback) {
+  return baseDir === void 0 ? callback() : baseDirStorage.run(resolve(baseDir), callback);
+}
+function getBaseDir() {
+  return baseDirStorage.getStore();
+}
+function resolveFromBaseDir(filePath) {
+  const base = baseDirStorage.getStore();
+  if (!base || isAbsolute(filePath)) return filePath;
+  return resolve(base, filePath);
+}
+
+// src/utils/imageUtils.ts
+init_widthUtils();
 import { ImageRun } from "docx";
 function parseWidthValue(width, availableWidthPx) {
   if (typeof width === "number") {
@@ -2876,7 +2902,7 @@ async function getImageBuffer(imagePath) {
   if (isValidUrl(imagePath)) {
     return await downloadImageFromUrl(imagePath);
   }
-  return { buffer: readFileSync(imagePath) };
+  return { buffer: readFileSync(resolveFromBaseDir(imagePath)) };
 }
 async function getImageDimensions(imagePath) {
   try {
@@ -3948,16 +3974,6 @@ function parseTextWithHyperlinks(text, baseStyle = {}, options = {}) {
   return runs;
 }
 
-// src/utils/generationContext.ts
-import { AsyncLocalStorage } from "async_hooks";
-var generationDateStorage = new AsyncLocalStorage();
-function runWithGenerationDate(date, callback) {
-  return generationDateStorage.run(date, callback);
-}
-function getGenerationDate() {
-  return generationDateStorage.getStore() ?? /* @__PURE__ */ new Date();
-}
-
 // src/utils/placeholderProcessor.ts
 function styledPlaceholderText(text, context) {
   return new TextRun2({
@@ -4312,8 +4328,9 @@ async function renderComponentWithCache(component, theme, themeName, context, by
   const themeHash = createThemeHash(theme);
   const contextKey = context?.section ? `${context.section.currentLayout}:${context.section.columnCount}` : "no-section";
   const generationDateKey = getGenerationDate().toISOString();
+  const baseDirKey = getBaseDir() ?? "";
   const childrenKey = "children" in component && component.children ? `:children:${JSON.stringify(component.children)}` : "";
-  const cacheKey = `component:${component.name}:${themeHash}:${contextKey}:${generationDateKey}:${componentProps}${childrenKey}`;
+  const cacheKey = `component:${component.name}:${themeHash}:${contextKey}:${generationDateKey}:${baseDirKey}:${componentProps}${childrenKey}`;
   const cached = await componentCache.get(cacheKey);
   if (cached) {
     return cached.result;
@@ -6996,6 +7013,7 @@ async function renderHighchartsComponent(component, theme, themeName, context) {
 }
 
 // src/components/visual.ts
+import { createHash as createHash4 } from "crypto";
 import {
   clampVisualDpi,
   DEFAULT_VISUAL_DPI
@@ -7045,14 +7063,21 @@ function visualToImageProps(props, base64DataUri) {
     ...props.alt !== void 0 && { alt: props.alt }
   };
 }
-async function rasterize(presentation, dpi, propsServerUrl, serviceConfig) {
+function visualRasterKey(presentation, dpi, serverUrl) {
+  return createHash4("sha256").update(JSON.stringify({ p: presentation, d: dpi, u: serverUrl ?? null })).digest("hex");
+}
+function effectiveVisualServerUrl(props, serviceConfig) {
+  if (serviceConfig?.render) return void 0;
+  return props.serverUrl;
+}
+async function rasterizeVisualSlide(presentation, dpi, propsServerUrl, serviceConfig, baseDir) {
   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 });
+    return serviceConfig.render({ presentation, dpi, baseDir });
   }
   const serverUrl = resolveServiceUrl(
     propsServerUrl,
@@ -7062,7 +7087,7 @@ async function rasterize(presentation, dpi, propsServerUrl, serviceConfig) {
   const response = await postJsonToService({
     url: serverUrl,
     path: "/rasterize",
-    body: { presentation, dpi },
+    body: { presentation, dpi, ...baseDir !== void 0 && { baseDir } },
     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\`.
@@ -7091,12 +7116,26 @@ async function renderVisualComponent(component, theme, themeName, context) {
   const dpi = clampVisualDpi(
     props.dpi ?? serviceConfig?.dpi ?? DEFAULT_VISUAL_DPI
   );
-  const result = await rasterize(
-    presentation,
-    dpi,
-    props.serverUrl,
-    serviceConfig
+  const preRasterized = context?.visualRasterResults?.get(
+    visualRasterKey(
+      presentation,
+      dpi,
+      effectiveVisualServerUrl(props, serviceConfig)
+    )
   );
+  let result;
+  if (preRasterized) {
+    if (!preRasterized.ok) throw new Error(preRasterized.error);
+    result = preRasterized;
+  } else {
+    result = await rasterizeVisualSlide(
+      presentation,
+      dpi,
+      props.serverUrl,
+      serviceConfig,
+      getBaseDir()
+    );
+  }
   return await createImage(
     result.base64DataUri,
     theme,
@@ -7158,6 +7197,203 @@ var textSpaceAfterComponent = createComponent({
 
 // src/core/render.ts
 init_docxImagePositioning();
+
+// src/core/prerasterizeVisuals.ts
+import {
+  clampVisualDpi as clampVisualDpi2,
+  DEFAULT_VISUAL_DPI as DEFAULT_VISUAL_DPI2,
+  MAX_RASTERIZE_BATCH_SLIDES
+} from "@json-to-office/shared";
+
+// src/utils/promiseLimiter.ts
+function createLimiter(max) {
+  let active = 0;
+  const queue = [];
+  const release = () => {
+    active--;
+    queue.shift()?.();
+  };
+  return async function limit(fn) {
+    while (active >= max)
+      await new Promise((resolve4) => queue.push(resolve4));
+    active++;
+    try {
+      return await fn();
+    } finally {
+      release();
+    }
+  };
+}
+
+// src/core/prerasterizeVisuals.ts
+var DEFAULT_FALLBACK_CONCURRENCY = 4;
+var BATCH_TIMEOUT_BASE_MS = 3e4;
+var BATCH_TIMEOUT_PER_SLIDE_MS = 1e4;
+function collectVisualProps(root) {
+  const found = [];
+  const seen = /* @__PURE__ */ new WeakSet();
+  const visit = (node) => {
+    if (!node || typeof node !== "object") return;
+    if (seen.has(node)) return;
+    seen.add(node);
+    if (Array.isArray(node)) {
+      for (const item of node) visit(item);
+      return;
+    }
+    const obj = node;
+    if (typeof obj.name === "string" && obj.enabled === false) return;
+    if (obj.name === "visual" && obj.props && typeof obj.props === "object") {
+      found.push(obj.props);
+      return;
+    }
+    for (const value of Object.values(obj)) visit(value);
+  };
+  visit(root);
+  return found;
+}
+function toErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function* chunksOf(items, size) {
+  for (let i = 0; i < items.length; i += size) yield items.slice(i, i + size);
+}
+function applyBatchResponse(chunk, response, map) {
+  const results = response?.results;
+  if (!Array.isArray(results) || results.length !== chunk.length) return false;
+  const entries = [];
+  for (let i = 0; i < chunk.length; i++) {
+    const item = results[i];
+    if (item && item.ok === true && typeof item.base64DataUri === "string" && item.base64DataUri.length > 0 && typeof item.width === "number" && typeof item.height === "number") {
+      entries.push([
+        chunk[i].key,
+        {
+          ok: true,
+          base64DataUri: item.base64DataUri,
+          width: item.width,
+          height: item.height
+        }
+      ]);
+    } else if (item && item.ok === false && typeof item.error === "string") {
+      entries.push([chunk[i].key, { ok: false, error: item.error }]);
+    } else {
+      return false;
+    }
+  }
+  for (const [key, value] of entries) map.set(key, value);
+  return true;
+}
+async function prerasterizeVisuals(root, serviceConfig, options = {}) {
+  const map = /* @__PURE__ */ new Map();
+  if (!isNodeEnvironment() && !serviceConfig?.renderBatch && !serviceConfig?.render) {
+    return map;
+  }
+  const visuals = collectVisualProps(root);
+  if (visuals.length === 0) return map;
+  const targets = /* @__PURE__ */ new Map();
+  for (const props of visuals) {
+    try {
+      const serverUrl2 = effectiveVisualServerUrl(props, serviceConfig);
+      if (serverUrl2 !== void 0) continue;
+      const presentation = buildVisualPresentation(props);
+      const dpi = clampVisualDpi2(
+        props.dpi ?? serviceConfig?.dpi ?? DEFAULT_VISUAL_DPI2
+      );
+      const key = visualRasterKey(presentation, dpi, serverUrl2);
+      if (!targets.has(key)) targets.set(key, { key, presentation, dpi });
+    } catch {
+      continue;
+    }
+  }
+  if (targets.size === 0) return map;
+  const unique = [...targets.values()];
+  const limit = createLimiter(
+    Math.max(1, options.concurrency ?? DEFAULT_FALLBACK_CONCURRENCY)
+  );
+  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) });
+          }
+        })
+      )
+    );
+  };
+  if (serviceConfig?.renderBatch) {
+    for (const chunk of chunksOf(unique, MAX_RASTERIZE_BATCH_SLIDES)) {
+      try {
+        const response = await serviceConfig.renderBatch({
+          slides: chunk.map((target) => ({
+            presentation: target.presentation,
+            dpi: target.dpi
+          })),
+          ...options.baseDir !== void 0 && { baseDir: options.baseDir }
+        });
+        if (!applyBatchResponse(chunk, response, map)) {
+          throw new Error(
+            "batch rasterizer returned a malformed result (expected index-aligned results[])"
+          );
+        }
+      } catch (error) {
+        if (serviceConfig.render || serviceConfig.serverUrl) {
+          await rasterizeIndividually(chunk);
+        } else {
+          const message = toErrorMessage(error);
+          for (const target of chunk) {
+            map.set(target.key, { ok: false, error: message });
+          }
+        }
+      }
+    }
+    return map;
+  }
+  if (serviceConfig?.render) {
+    await rasterizeIndividually(unique);
+    return map;
+  }
+  const serverUrl = resolveServiceUrl(
+    void 0,
+    serviceConfig?.serverUrl,
+    DEFAULT_RASTERIZE_SERVER_URL
+  );
+  for (const chunk of chunksOf(unique, MAX_RASTERIZE_BATCH_SLIDES)) {
+    let applied = false;
+    try {
+      const response = await postJsonToService({
+        url: serverUrl,
+        path: "/rasterize/batch",
+        body: {
+          slides: chunk.map((target) => ({
+            presentation: target.presentation,
+            dpi: target.dpi
+          })),
+          ...options.baseDir !== void 0 && { baseDir: options.baseDir }
+        },
+        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 {
+      applied = false;
+    }
+    if (!applied) await rasterizeIndividually(chunk);
+  }
+  return map;
+}
+
+// src/core/render.ts
 function getAlignment3(alignment) {
   switch (alignment) {
     case "center":
@@ -7189,10 +7425,13 @@ function coreProperties(metadata) {
 async function renderDocument(structure, layout, options) {
   return runWithGenerationDate(
     structure.metadata.date,
-    () => globalBookmarkRegistry.runScoped(
-      () => globalRevisionIdRegistry.runScoped(
-        () => globalNumberingRegistry.runScoped(
-          () => renderDocumentScoped(structure, layout, options)
+    () => runWithBaseDir(
+      options?.baseDir,
+      () => globalBookmarkRegistry.runScoped(
+        () => globalRevisionIdRegistry.runScoped(
+          () => globalNumberingRegistry.runScoped(
+            () => renderDocumentScoped(structure, layout, options)
+          )
         )
       )
     )
@@ -7211,6 +7450,21 @@ async function renderDocumentScoped(structure, layout, options) {
     structure.themeName
   );
   context.services = options?.services;
+  try {
+    const visualRasterResults = await prerasterizeVisuals(
+      layout.sections,
+      options?.services?.pptx,
+      { baseDir: getBaseDir() }
+    );
+    if (visualRasterResults.size > 0) {
+      context.visualRasterResults = visualRasterResults;
+    }
+  } catch (error) {
+    console.warn(
+      "[core-docx] Visual pre-rasterization failed; falling back to per-visual rasterization:",
+      error instanceof Error ? error.message : error
+    );
+  }
   let sectionBookmarkCounter = 0;
   let previousHeader = void 0;
   let previousFooter = void 0;
@@ -7787,10 +8041,10 @@ function normalizeDocument(document) {
 
 // src/json/filesystem.ts
 import { promises as fs3 } from "fs";
-import { join, resolve, isAbsolute } from "path";
+import { join, resolve as resolve2, isAbsolute as isAbsolute2 } from "path";
 async function loadJsonDefinition(filePath) {
   try {
-    const absolutePath = isAbsolute(filePath) ? filePath : resolve(filePath);
+    const absolutePath = isAbsolute2(filePath) ? filePath : resolve2(filePath);
     await fs3.access(absolutePath);
     const fileContent = await fs3.readFile(absolutePath, "utf-8");
     return parseJsonWithLineNumbers(fileContent);
@@ -7865,7 +8119,8 @@ async function generateDocument(document, options) {
     options?.services,
     options?.fonts,
     options?.warnings,
-    resolveGenerationDate(options)
+    resolveGenerationDate(options),
+    options?.baseDir
   );
 }
 async function generateFromConfig(props, components, options) {
@@ -7876,7 +8131,7 @@ async function generateFromConfig(props, components, options) {
   };
   return await generateDocument(reportComponent, options);
 }
-async function generateDocumentWithCustomThemes(documentIn, customThemes, services, fonts, warnings, generationDate) {
+async function generateDocumentWithCustomThemes(documentIn, customThemes, services, fonts, warnings, generationDate, baseDir) {
   const { document, theme, themeName } = resolveThemeContext(documentIn, {
     customThemes,
     fonts,
@@ -7892,7 +8147,8 @@ async function generateDocumentWithCustomThemes(documentIn, customThemes, servic
   const layout = applyLayout(structure.sections, theme, themeName);
   const renderedDocument = await renderDocument(structure, layout, {
     bypassCache: false,
-    services
+    services,
+    baseDir
   });
   return renderedDocument;
 }
@@ -7937,7 +8193,8 @@ async function generateDocumentFromJson(jsonConfig, options) {
     options?.services,
     options?.fonts,
     options?.warnings,
-    resolveGenerationDate(options)
+    resolveGenerationDate(options),
+    options?.baseDir
   );
 }
 function validateJsonSchema(jsonConfig) {
@@ -7953,7 +8210,10 @@ async function generateAndSaveFromJson(jsonConfig, filename, options) {
 }
 async function generateDocumentFromFile(filePath, options) {
   const jsonDefinition = await loadJsonDefinition(filePath);
-  return await generateDocumentFromJson(jsonDefinition, options);
+  return await generateDocumentFromJson(jsonDefinition, {
+    baseDir: dirname(resolve3(filePath)),
+    ...options
+  });
 }
 async function generateBufferFromFile(filePath, options) {
   const document = await generateDocumentFromFile(filePath, options);
@@ -7988,32 +8248,41 @@ var DocumentGenerator = {
 
 // src/core/flattenVisuals.ts
 import {
-  clampVisualDpi as clampVisualDpi2,
-  DEFAULT_VISUAL_DPI as DEFAULT_VISUAL_DPI2
+  clampVisualDpi as clampVisualDpi3,
+  DEFAULT_VISUAL_DPI as DEFAULT_VISUAL_DPI3
 } from "@json-to-office/shared";
 var DEFAULT_CONCURRENCY = 4;
-function createLimiter(max) {
-  let active = 0;
-  const queue = [];
-  const release = () => {
-    active--;
-    queue.shift()?.();
-  };
-  return async function limit(fn) {
-    if (active >= max)
-      await new Promise((resolve2) => queue.push(resolve2));
-    active++;
-    try {
-      return await fn();
-    } finally {
-      release();
-    }
-  };
-}
 async function flattenVisuals(doc, options) {
+  let rasterize = options.rasterize;
+  if (options.rasterizeBatch) {
+    const preRasterized = await prerasterizeVisuals(
+      doc,
+      {
+        render: options.rasterize,
+        renderBatch: options.rasterizeBatch,
+        dpi: options.dpi
+      },
+      { baseDir: options.baseDir, concurrency: options.concurrency }
+    ).catch(() => /* @__PURE__ */ new Map());
+    rasterize = async (request) => {
+      const hit = preRasterized.get(
+        visualRasterKey(request.presentation, request.dpi)
+      );
+      if (hit) {
+        if (!hit.ok) throw new Error(hit.error);
+        return {
+          base64DataUri: hit.base64DataUri,
+          width: hit.width,
+          height: hit.height
+        };
+      }
+      return options.rasterize(request);
+    };
+  }
   const ctx = {
-    rasterize: options.rasterize,
+    rasterize,
     dpi: options.dpi,
+    baseDir: options.baseDir,
     limit: createLimiter(
       Math.max(1, options.concurrency ?? DEFAULT_CONCURRENCY)
     )
@@ -8022,9 +8291,13 @@ async function flattenVisuals(doc, options) {
 }
 async function rasterizeVisual(obj, ctx) {
   const props = obj.props;
-  const dpi = clampVisualDpi2(props.dpi ?? ctx.dpi ?? DEFAULT_VISUAL_DPI2);
+  const dpi = clampVisualDpi3(props.dpi ?? ctx.dpi ?? DEFAULT_VISUAL_DPI3);
   const result = await ctx.limit(
-    () => ctx.rasterize({ presentation: buildVisualPresentation(props), dpi })
+    () => ctx.rasterize({
+      presentation: buildVisualPresentation(props),
+      dpi,
+      baseDir: ctx.baseDir
+    })
   );
   const image = {
     name: "image",
@@ -8706,7 +8979,8 @@ function createBuilderImpl(state) {
       fonts: state.fonts,
       validation: state.validation,
       deterministic: state.deterministic,
-      generatedAt: state.generatedAt
+      generatedAt: state.generatedAt,
+      baseDir: state.baseDir
     };
     return createBuilderImpl(
       newState
@@ -8805,7 +9079,8 @@ function createBuilderImpl(state) {
       const layout = applyLayout(structure.sections, modedTheme, themeName);
       const generatedDocument = await renderDocument(structure, layout, {
         services: state.services,
-        bypassCache: !state.enableCache
+        bypassCache: !state.enableCache,
+        baseDir: options?.baseDir ?? state.baseDir
       });
       const preservedDefinition = preserveSet ? {
         ...modedRoot,
@@ -8935,7 +9210,8 @@ function createDocumentGenerator(options) {
     fonts: options.fonts,
     validation: options.validation,
     deterministic: options.deterministic ?? true,
-    generatedAt: options.generatedAt
+    generatedAt: options.generatedAt,
+    baseDir: options.baseDir
   };
   return createBuilderImpl(initialState);
 }