@pixldocs/canvas-renderer 0.5.57 → 0.5.58

package/dist/index.d.ts

@@ -25,6 +25,19 @@ export declare function applyThemeToConfig(config: TemplateConfig, themeOverride
  */
 export declare function assemblePdfFromSvgs(svgResults: SvgRenderResult[], options?: PdfAssemblyOptions): Promise<PdfRenderResult>;
 
+/**
+ * Block until the webfonts referenced by `config` have actually loaded
+ * (or `maxWaitMs` elapses). Stronger than `ensureFontsForResolvedConfig`
+ * which only fire-and-forget queues `document.fonts.load()`.
+ *
+ * Use this BEFORE mounting `PreviewCanvas` so the synchronous
+ * `createText` auto-shrink loop measures against real font metrics
+ * instead of system fallback ones (which are typically narrower → loop
+ * decides "fits, no shrink needed" → text overflows once the real font
+ * swaps in).
+ */
+export declare function awaitFontsForConfig(config: TemplateConfig, maxWaitMs: number): Promise<void>;
+
 export declare interface CanvasNode {
     id: string;
     name?: string;
@@ -64,6 +77,16 @@ export declare function collectFontsFromConfig(config: TemplateConfig): Set<stri
  */
 export declare function collectImageUrls(config: TemplateConfig): string[];
 
+/**
+ * Returns true when any text node in `config` uses
+ * `overflowPolicy: 'auto-shrink'`. The synchronous shrink loop in
+ * `createText` measures with whatever font Fabric can resolve at mount
+ * time, so for these configs the consumer MUST block on real font load
+ * before mounting (otherwise it shrinks against fallback metrics and
+ * overflows once the real font swaps in).
+ */
+export declare function configHasAutoShrinkText(config: TemplateConfig | null | undefined): boolean;
+
 export declare interface DynamicField {
     id: string;
     label: string;

package/dist/index.js

@@ -12244,6 +12244,46 @@ async function ensureFontsForResolvedConfig(config) {
     });
   }
 }
+function configHasAutoShrinkText$1(config) {
+  var _a;
+  if (!((_a = config == null ? void 0 : config.pages) == null ? void 0 : _a.length)) return false;
+  const walk = (nodes) => {
+    for (const node of nodes || []) {
+      if (!node) continue;
+      if (node.type === "text" && node.overflowPolicy === "auto-shrink") return true;
+      if (Array.isArray(node.children) && node.children.length && walk(node.children)) return true;
+    }
+    return false;
+  };
+  for (const page of config.pages) {
+    if (walk(page.children || [])) return true;
+  }
+  return false;
+}
+async function awaitFontsForConfig(config, maxWaitMs) {
+  if (typeof document === "undefined" || !document.fonts) return;
+  void ensureFontsForResolvedConfig(config);
+  const descriptors = collectFontDescriptorsFromConfig(config);
+  if (descriptors.length === 0) return;
+  const loads = Promise.all(
+    descriptors.map((d) => {
+      const stylePrefix = d.style === "italic" ? "italic " : "";
+      const spec = `${stylePrefix}${d.weight} 16px "${d.family}"`;
+      return document.fonts.load(spec).catch(() => []);
+    })
+  ).then(() => void 0);
+  await Promise.race([
+    loads,
+    new Promise((resolve) => setTimeout(resolve, maxWaitMs))
+  ]);
+  await Promise.race([
+    document.fonts.ready.catch(() => void 0).then(() => void 0),
+    new Promise((r) => setTimeout(r, Math.min(500, maxWaitMs)))
+  ]);
+  await new Promise(
+    (resolve) => requestAnimationFrame(() => requestAnimationFrame(() => resolve()))
+  );
+}
 const PREVIEW_DEBUG_PREFIX = "[canvas-renderer][preview-debug]";
 function countUnderlinedNodes(config) {
   var _a;
@@ -12329,15 +12369,17 @@ function PixldocsPreview(props) {
           underlinedNodes: countUnderlinedNodes(resolved.config)
         });
         setResolvedConfig(resolved.config);
-        ensureFontsForResolvedConfig(resolved.config).then(() => {
+        const hasAutoShrink = configHasAutoShrinkText$1(resolved.config);
+        const waitMs = hasAutoShrink ? 4e3 : 1800;
+        awaitFontsForConfig(resolved.config, waitMs).then(() => {
           if (!cancelled) {
-            console.log(PREVIEW_DEBUG_PREFIX, "resolve-mode fonts queued");
+            console.log(PREVIEW_DEBUG_PREFIX, "resolve-mode fonts settled", { hasAutoShrink, waitMs });
             setFontsReady(true);
             setIsLoading(false);
           }
         }).catch((err) => {
           if (!cancelled) {
-            console.warn(PREVIEW_DEBUG_PREFIX, "resolve-mode fonts queue failed", err);
+            console.warn(PREVIEW_DEBUG_PREFIX, "resolve-mode font wait failed", err);
             setFontsReady(true);
             setIsLoading(false);
           }
@@ -12406,16 +12448,26 @@ function PixldocsPreview(props) {
     setFontsReady(false);
     setCanvasSettled(false);
     setStabilizationPass(0);
-    ensureFontsForResolvedConfig(config).then(() => {
-      console.log(PREVIEW_DEBUG_PREFIX, "config-mode fonts queued", {
+    let cancelled = false;
+    const hasAutoShrink = configHasAutoShrinkText$1(config);
+    const waitMs = hasAutoShrink ? 4e3 : 1800;
+    awaitFontsForConfig(config, waitMs).then(() => {
+      if (cancelled) return;
+      console.log(PREVIEW_DEBUG_PREFIX, "config-mode fonts settled", {
         pageIndex,
+        hasAutoShrink,
+        waitMs,
         underlinedNodes: countUnderlinedNodes(config)
       });
       setFontsReady(true);
     }).catch((err) => {
-      console.warn(PREVIEW_DEBUG_PREFIX, "config-mode fonts queue failed", err);
+      if (cancelled) return;
+      console.warn(PREVIEW_DEBUG_PREFIX, "config-mode font wait failed", err);
       setFontsReady(true);
     });
+    return () => {
+      cancelled = true;
+    };
   }, [isResolveMode, config]);
   const handleCanvasReady = useCallback(() => {
     if (stabilizationPass === 0) {
@@ -15624,9 +15676,11 @@ export {
   PixldocsRenderer,
   applyThemeToConfig,
   assemblePdfFromSvgs,
+  awaitFontsForConfig,
   collectFontDescriptorsFromConfig,
   collectFontsFromConfig,
   collectImageUrls,
+  configHasAutoShrinkText$1 as configHasAutoShrinkText,
   embedFont,
   embedFontsForConfig,
   embedFontsInPdf,