@json-to-office/core-docx 0.28.0 → 0.30.0

package/dist/index.js

@@ -7013,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
@@ -7062,7 +7063,14 @@ function visualToImageProps(props, base64DataUri) {
     ...props.alt !== void 0 && { alt: props.alt }
   };
 }
-async function rasterize(presentation, dpi, propsServerUrl, serviceConfig, baseDir) {
+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."
@@ -7108,13 +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,
-    getBaseDir()
+  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,
@@ -7176,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":
@@ -7232,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;
@@ -8015,31 +8248,39 @@ 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((resolve4) => queue.push(resolve4));
-    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(
@@ -8050,7 +8291,7 @@ 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),
@@ -8760,70 +9001,104 @@ function createBuilderImpl(state) {
     }
     return new Set(list);
   }
-  async function generate(document, options) {
-    try {
-      const preserveSet = resolvePreserveSet(options);
-      const rootIn = document;
-      const internalDocument = rootIn.props === void 0 ? { ...rootIn, props: {} } : rootIn;
-      const vOpts = {
-        ...state.validation,
-        ...options?.validation
-      };
-      if (vOpts.enabled !== false) {
-        const result = validateDocument(
-          internalDocument,
-          state.components,
-          { allowUnknownFields: vOpts.allowUnknownFields }
+  async function expandDocument(document, options) {
+    const preserveSet = resolvePreserveSet(options);
+    const rootIn = document;
+    const internalDocument = rootIn.props === void 0 ? { ...rootIn, props: {} } : rootIn;
+    const vOpts = {
+      ...state.validation,
+      ...options?.validation
+    };
+    if (vOpts.enabled !== false) {
+      const result = validateDocument(
+        internalDocument,
+        state.components,
+        { allowUnknownFields: vOpts.allowUnknownFields }
+      );
+      if (!result.valid) {
+        throw new ComponentValidationError2(
+          (result.errors ?? []).map((e) => ({
+            path: e.path ?? "",
+            message: e.message
+          })),
+          internalDocument
         );
-        if (!result.valid) {
-          throw new ComponentValidationError2(
-            (result.errors ?? []).map((e) => ({
-              path: e.path ?? "",
-              message: e.message
-            })),
-            internalDocument
-          );
-        }
       }
-      const validateEmitted = vOpts.enabled === false ? void 0 : (emitted, componentLabel) => {
-        const result = validateDocument(
-          { ...internalDocument, children: emitted },
-          state.components,
-          { allowUnknownFields: vOpts.allowUnknownFields }
+    }
+    const validateEmitted = vOpts.enabled === false ? void 0 : (emitted, componentLabel) => {
+      const result = validateDocument(
+        { ...internalDocument, children: emitted },
+        state.components,
+        { allowUnknownFields: vOpts.allowUnknownFields }
+      );
+      if (!result.valid) {
+        throw new ComponentValidationError2(
+          (result.errors ?? []).map((e) => ({
+            path: e.path ?? "",
+            message: `custom component '${componentLabel}' emitted invalid output \u2014 ${e.message}`
+          })),
+          emitted
         );
-        if (!result.valid) {
-          throw new ComponentValidationError2(
-            (result.errors ?? []).map((e) => ({
-              path: e.path ?? "",
-              message: `custom component '${componentLabel}' emitted invalid output \u2014 ${e.message}`
-            })),
-            emitted
-          );
-        }
+      }
+    };
+    const warnings = [];
+    const {
+      document: modedRoot,
+      theme: modedTheme,
+      themeName
+    } = resolveThemeContext(internalDocument, {
+      customThemes: state.customThemes,
+      fonts: state.fonts,
+      warnings,
+      resolveNamedTheme: resolveDocumentTheme
+    });
+    const processed = await processDocumentComponents(
+      modedRoot.children || [],
+      preserveSet,
+      warnings,
+      modedTheme,
+      validateEmitted
+    );
+    const processedDocument = {
+      ...modedRoot,
+      children: processed.standard
+    };
+    const [modedDoc] = normalizeDocument(processedDocument);
+    return {
+      modedRoot,
+      modedTheme,
+      themeName,
+      processed,
+      modedDoc,
+      warnings,
+      preserveSet
+    };
+  }
+  async function expandStandardDefinition(document, options) {
+    try {
+      const { modedDoc, warnings } = await expandDocument(document, options);
+      return {
+        standardDefinition: modedDoc,
+        warnings: warnings.length > 0 ? warnings : null
       };
-      const warnings = [];
+    } catch (error) {
+      if (state.debug) {
+        console.error("Document expansion error:", error);
+      }
+      throw error;
+    }
+  }
+  async function generate(document, options) {
+    try {
       const {
-        document: modedRoot,
-        theme: modedTheme,
-        themeName
-      } = resolveThemeContext(internalDocument, {
-        customThemes: state.customThemes,
-        fonts: state.fonts,
-        warnings,
-        resolveNamedTheme: resolveDocumentTheme
-      });
-      const processed = await processDocumentComponents(
-        modedRoot.children || [],
-        preserveSet,
-        warnings,
+        modedRoot,
         modedTheme,
-        validateEmitted
-      );
-      const processedDocument = {
-        ...modedRoot,
-        children: processed.standard
-      };
-      const [modedDoc] = normalizeDocument(processedDocument);
+        themeName,
+        processed,
+        modedDoc,
+        warnings,
+        preserveSet
+      } = await expandDocument(document, options);
       await resolveDocumentFonts(modedDoc, modedTheme, state.fonts, warnings);
       const packageOptions = {
         deterministic: options?.deterministic ?? state.deterministic,
@@ -8950,6 +9225,7 @@ function createBuilderImpl(state) {
     generate,
     generateBuffer,
     generateFile,
+    expandStandardDefinition,
     getComponentNames,
     validate,
     generateSchema,