@pixldocs/canvas-renderer 0.5.133 → 0.5.135

package/dist/{index-D5rY5lp8.cjs → index-BCvB875s.cjs}

@@ -14633,6 +14633,26 @@ function normalizeFontFamily(fontStack) {
 const loadedFonts = /* @__PURE__ */ new Set();
 const loadingPromises = /* @__PURE__ */ new Map();
 const registeredLocalFontFaces = /* @__PURE__ */ new Set();
+let localFontFaceStyleEl = null;
+function ensureLocalFontFaceStyle() {
+  if (typeof document === "undefined") return null;
+  if (localFontFaceStyleEl && localFontFaceStyleEl.isConnected) return localFontFaceStyleEl;
+  try {
+    localFontFaceStyleEl = document.createElement("style");
+    localFontFaceStyleEl.setAttribute("data-pixldocs-local-fontfaces", "1");
+    document.head.appendChild(localFontFaceStyleEl);
+    return localFontFaceStyleEl;
+  } catch {
+    return null;
+  }
+}
+function appendLocalFontFaceRule(family, weight, style, file) {
+  const styleEl = ensureLocalFontFaceStyle();
+  if (!styleEl) return;
+  const cssText = `@font-face{font-family:"${family}";src:url("/fonts/${file}");font-weight:${weight};font-style:${style};font-display:swap;}
+`;
+  styleEl.appendChild(document.createTextNode(cssText));
+}
 const LOCAL_FONT_FACE_VARIANTS = [
   { key: "regular", weight: 400, style: "normal" },
   { key: "bold", weight: 700, style: "normal" },
@@ -14662,6 +14682,7 @@ async function registerLocalFontFaces(fontFamily) {
         style: variant.style
       });
       document.fonts.add(face);
+      appendLocalFontFaceRule(fontFamily, variant.weight, variant.style, file);
       loads.push(face.load().catch(() => void 0));
     } catch {
     }
@@ -15813,7 +15834,7 @@ function captureFabricCanvasSvgForPdf(fabricInstance, canvasWidth, canvasHeight)
   }
   return svgString;
 }
-const PACKAGE_VERSION = "0.5.131";
+const PACKAGE_VERSION = "0.5.135";
 const roundParityValue = (value) => {
   if (typeof value !== "number") return value;
   return Number.isFinite(value) ? Number(value.toFixed(3)) : value;
@@ -16232,7 +16253,7 @@ class PixldocsRenderer {
         await this.waitForCanvasScene(container, cloned, i);
       }
       console.log(`[canvas-renderer][pdf-unified] mounted ${cloned.pages.length} page(s), handing off to client exportMultiPagePdf`);
-      const { exportMultiPagePdf, preparePagesForExport } = await Promise.resolve().then(() => require("./vectorPdfExport-DCNpWd6K.cjs"));
+      const { exportMultiPagePdf, preparePagesForExport } = await Promise.resolve().then(() => require("./vectorPdfExport-DFgDiZck.cjs"));
       const prepared = preparePagesForExport(
         cloned.pages,
         canvasWidth,
@@ -18070,7 +18091,7 @@ async function rasterizeShadowMarkers(svg) {
     if ((_a = document.fonts) == null ? void 0 : _a.ready) await document.fonts.ready;
   } catch {
   }
-  const fontFaceCss = collectDocumentFontFaceCss();
+  const fontFaceCss = await collectInlinedFontFaceCss();
   for (const marker of markers) {
     try {
       const blur = parseFloat(marker.getAttribute("data-blur") || "0");
@@ -18084,7 +18105,9 @@ async function rasterizeShadowMarkers(svg) {
         (_b = marker.parentNode) == null ? void 0 : _b.removeChild(marker);
         continue;
       }
-      const innerXml = Array.from(marker.childNodes).map((n) => n instanceof Element ? new XMLSerializer().serializeToString(n) : "").join("");
+      const innerXml = restoreSourceFontsForShadowRaster(
+        Array.from(marker.childNodes).map((n) => n instanceof Element ? new XMLSerializer().serializeToString(n) : "").join("")
+      );
       try {
         const fontSpecs = collectFontSpecsFromMarkup(innerXml);
         if (fontSpecs.length > 0 && ((_c = document.fonts) == null ? void 0 : _c.load)) {
@@ -18133,7 +18156,6 @@ function rasterSvgToPngDataUrl(svgMarkup, pxW, pxH) {
       const blob = new Blob([svgMarkup], { type: "image/svg+xml;charset=utf-8" });
       const url = URL.createObjectURL(blob);
       const img = new Image();
-      img.crossOrigin = "anonymous";
       const cleanup = () => {
         try {
           URL.revokeObjectURL(url);
@@ -18151,6 +18173,7 @@ function rasterSvgToPngDataUrl(svgMarkup, pxW, pxH) {
             resolve(null);
             return;
           }
+          ctx.clearRect(0, 0, pxW, pxH);
           ctx.drawImage(img, 0, 0, pxW, pxH);
           const dataUrl = canvas.toDataURL("image/png");
           cleanup();
@@ -18195,6 +18218,103 @@ function collectDocumentFontFaceCss() {
   cachedFontFaceCss = out.join("\n");
   return cachedFontFaceCss;
 }
+let cachedInlinedFontFaceCss = null;
+const fontUrlDataCache = /* @__PURE__ */ new Map();
+async function fetchFontAsDataUri(url) {
+  if (fontUrlDataCache.has(url)) return fontUrlDataCache.get(url) ?? null;
+  try {
+    const resp = await fetch(url, { mode: "cors", credentials: "omit" });
+    if (!resp.ok) {
+      fontUrlDataCache.set(url, null);
+      return null;
+    }
+    const blob = await resp.blob();
+    const dataUri = await new Promise((resolve, reject) => {
+      const fr = new FileReader();
+      fr.onload = () => resolve(String(fr.result));
+      fr.onerror = () => reject(fr.error);
+      fr.readAsDataURL(blob);
+    });
+    fontUrlDataCache.set(url, dataUri);
+    return dataUri;
+  } catch {
+    fontUrlDataCache.set(url, null);
+    return null;
+  }
+}
+async function inlineUrlsInCss(css) {
+  const urlRe = /url\((['"]?)([^'")]+)\1\)/gi;
+  const matches = [];
+  let m;
+  while ((m = urlRe.exec(css)) !== null) {
+    const raw = m[2].trim();
+    if (raw.startsWith("data:")) continue;
+    let abs = raw;
+    try {
+      abs = new URL(raw, document.baseURI).toString();
+    } catch {
+    }
+    matches.push({ full: m[0], url: abs });
+  }
+  if (matches.length === 0) return css;
+  const unique = Array.from(new Set(matches.map((mm) => mm.url)));
+  const results = await Promise.all(unique.map((u) => fetchFontAsDataUri(u)));
+  const map = /* @__PURE__ */ new Map();
+  unique.forEach((u, i) => map.set(u, results[i]));
+  let out = css;
+  for (const { full, url } of matches) {
+    const data = map.get(url);
+    if (!data) continue;
+    const safeFull = full.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    out = out.replace(new RegExp(safeFull, "g"), `url("${data}")`);
+  }
+  return out;
+}
+async function collectInlinedFontFaceCss() {
+  if (cachedInlinedFontFaceCss !== null) return cachedInlinedFontFaceCss;
+  const raw = collectDocumentFontFaceCss();
+  if (!raw) {
+    cachedInlinedFontFaceCss = "";
+    return "";
+  }
+  try {
+    cachedInlinedFontFaceCss = await inlineUrlsInCss(raw);
+  } catch {
+    cachedInlinedFontFaceCss = raw;
+  }
+  return cachedInlinedFontFaceCss;
+}
+function restoreSourceFontsForShadowRaster(markup) {
+  try {
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(`<svg xmlns="http://www.w3.org/2000/svg">${markup}</svg>`, "image/svg+xml");
+    if (doc.querySelector("parsererror")) return markup;
+    for (const node of Array.from(doc.querySelectorAll("text, tspan, textPath"))) {
+      const family = node.getAttribute("data-source-font-family");
+      const weight = node.getAttribute("data-source-font-weight");
+      const style = node.getAttribute("data-source-font-style");
+      if (!family && !weight && !style) continue;
+      const stylePairs = (node.getAttribute("style") || "").split(";").map((part) => part.trim()).filter(Boolean).filter((part) => !/^font-family\s*:/i.test(part) && !/^font-weight\s*:/i.test(part) && !/^font-style\s*:/i.test(part));
+      if (family) {
+        node.setAttribute("font-family", family);
+        stylePairs.push(`font-family: ${family}`);
+      }
+      if (weight) {
+        node.setAttribute("font-weight", weight);
+        stylePairs.push(`font-weight: ${weight}`);
+      }
+      if (style) {
+        node.setAttribute("font-style", style);
+        stylePairs.push(`font-style: ${style}`);
+      }
+      if (stylePairs.length > 0) node.setAttribute("style", stylePairs.join("; "));
+    }
+    const root = doc.documentElement;
+    return Array.from(root.childNodes).map((n) => n instanceof Element ? new XMLSerializer().serializeToString(n) : "").join("");
+  } catch {
+    return markup;
+  }
+}
 async function prepareLiveCanvasSvgForPdf(rawSvg, pageWidth, pageHeight, pageKey, options) {
   try {
     const parser = new DOMParser();
@@ -18225,7 +18345,7 @@ async function prepareLiveCanvasSvgForPdf(rawSvg, pageWidth, pageHeight, pageKey
     if (options == null ? void 0 : options.stripPageBackground) stripRootPageBackgroundFromSvg(svgToDraw);
     sanitizeSvgTreeForPdf(svgToDraw);
     try {
-      const { bakeTextAnchorPositionsFromLiveSvg } = await Promise.resolve().then(() => require("./vectorPdfExport-DCNpWd6K.cjs"));
+      const { bakeTextAnchorPositionsFromLiveSvg } = await Promise.resolve().then(() => require("./vectorPdfExport-DFgDiZck.cjs"));
       await bakeTextAnchorPositionsFromLiveSvg(svgToDraw);
     } catch (e) {
       console.warn("[canvas-renderer][pdf-export] anchor-bake pass failed (continuing):", e);
@@ -18567,4 +18687,4 @@ exports.setAutoShrinkDebug = setAutoShrinkDebug;
 exports.setBundledAssetPrefixes = setBundledAssetPrefixes;
 exports.warmResolvedTemplateForPreview = warmResolvedTemplateForPreview;
 exports.warmTemplateFromForm = warmTemplateFromForm;
-//# sourceMappingURL=index-D5rY5lp8.cjs.map
+//# sourceMappingURL=index-BCvB875s.cjs.map