@pixldocs/canvas-renderer 0.5.132 → 0.5.134

package/dist/{index-4IzWx9f-.cjs → index-DmqoeVsF.cjs}

@@ -5730,7 +5730,8 @@ function applyTextBackground(obj, cfg) {
         const dataAttrs = `data-blur="${blur.toFixed(3)}" data-ox="${ox.toFixed(3)}" data-oy="${oy.toFixed(3)}" data-bx="${bx.toFixed(3)}" data-by="${by.toFixed(3)}" data-bw="${bw.toFixed(3)}" data-bh="${bh.toFixed(3)}" data-color="${escapeXmlAttr(shadowColor)}"`;
         const wrapShadow = (markup) => blur <= 0 ? `<g transform="translate(${ox.toFixed(3)} ${oy.toFixed(3)})">${markup}</g>` : `<g class="__pdShadowRaster" ${dataAttrs}>${markup}</g>`;
         if (hasBg && (bg == null ? void 0 : bg.shadowAffectsBg) !== false) {
-          const shadowBgPath = `<path d="${bgD}" fill="${escapeXmlAttr(shadowColor)}" />`;
+          const shadowOpacityAttr = bgOpacity < 1 ? ` fill-opacity="${bgOpacity}"` : "";
+          const shadowBgPath = `<path d="${bgD}" fill="${escapeXmlAttr(shadowColor)}"${shadowOpacityAttr} />`;
           bgShadowMarker = wrapShadow(shadowBgPath);
         }
         if ((bg == null ? void 0 : bg.shadowAffectsText) !== false) {
@@ -14031,7 +14032,8 @@ async function fetchGoogleFontTTF(fontFamily, weight, isItalic = false) {
 async function fetchFontshareTTF(fontFamily, weight, isItalic = false) {
   const cacheKey = `fs:${fontFamily}:${weight}:${isItalic ? "i" : "n"}`;
   if (ttfCache.has(cacheKey)) return ttfCache.get(cacheKey);
-  if (fontshareNotFound.has(fontFamily)) return null;
+  const notFoundKey = remoteVariantKey(fontFamily, weight, isItalic);
+  if (fontshareNotFound.has(notFoundKey)) return null;
   const slug = fontFamily.trim().toLowerCase().replace(/\s+/g, "-");
   const proxyBytes = await fetchTtfViaProxy(fontFamily, weight, isItalic, "fontshare");
   if (proxyBytes) {
@@ -14044,13 +14046,13 @@ async function fetchFontshareTTF(fontFamily, weight, isItalic = false) {
     const cssUrl = `https://api.fontshare.com/v2/css?f[]=${slug}@${weight}${styleSuffix}&display=swap`;
     const cssRes = await fetch(cssUrl);
     if (!cssRes.ok) {
-      if (cssRes.status === 400 || cssRes.status === 404) fontshareNotFound.add(fontFamily);
+      if (cssRes.status === 400 || cssRes.status === 404) fontshareNotFound.add(notFoundKey);
       return null;
     }
     const css = await cssRes.text();
     const ttMatch = css.match(/url\(([^)]+)\)\s+format\(['"]?truetype['"]?\)/i);
     if (!ttMatch) {
-      fontshareNotFound.add(fontFamily);
+      fontshareNotFound.add(notFoundKey);
       return null;
     }
     let ttfUrl = ttMatch[1].replace(/['"]/g, "").trim();
@@ -14097,11 +14099,38 @@ async function embedFontWithGoogleFallback(pdf, fontName, weight = 400, fontBase
     if (ok) return true;
   }
   const resolved = resolveFontWeight(weight);
-  const fsB64 = await fetchFontshareTTF(fontName, resolved, isItalic);
-  if (fsB64) return registerJsPdfFont(pdf, fontName, resolved, isItalic, fsB64);
-  const b64 = await fetchGoogleFontTTF(fontName, resolved, isItalic);
-  if (b64) return registerJsPdfFont(pdf, fontName, resolved, isItalic, b64);
-  return false;
+  const weightLadder = [resolved];
+  for (const w of [400, 500, 700, 600, 300]) {
+    if (!weightLadder.includes(w)) weightLadder.push(w);
+  }
+  const tryFetch = async (w, italic) => {
+    const fs = await fetchFontshareTTF(fontName, w, italic);
+    if (fs) return fs;
+    const g = await fetchGoogleFontTTF(fontName, w, italic);
+    return g;
+  };
+  let b64 = null;
+  let usedItalic = isItalic;
+  let usedWeight = resolved;
+  for (const w of weightLadder) {
+    b64 = await tryFetch(w, isItalic);
+    if (b64) {
+      usedWeight = w;
+      break;
+    }
+  }
+  if (!b64 && isItalic) {
+    for (const w of weightLadder) {
+      b64 = await tryFetch(w, false);
+      if (b64) {
+        usedItalic = false;
+        usedWeight = w;
+        break;
+      }
+    }
+  }
+  if (!b64) return false;
+  return registerJsPdfFont(pdf, fontName, usedWeight, usedItalic, b64);
 }
 async function embedFontsForConfig(pdf, config, fontBaseUrl) {
   const fontKeys = /* @__PURE__ */ new Set();
@@ -16203,7 +16232,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-BmqYmqUF.cjs"));
+      const { exportMultiPagePdf, preparePagesForExport } = await Promise.resolve().then(() => require("./vectorPdfExport-8Q3O7Z_Q.cjs"));
       const prepared = preparePagesForExport(
         cloned.pages,
         canvasWidth,
@@ -18041,7 +18070,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");
@@ -18055,7 +18084,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)) {
@@ -18166,6 +18197,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();
@@ -18196,7 +18324,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-BmqYmqUF.cjs"));
+      const { bakeTextAnchorPositionsFromLiveSvg } = await Promise.resolve().then(() => require("./vectorPdfExport-8Q3O7Z_Q.cjs"));
       await bakeTextAnchorPositionsFromLiveSvg(svgToDraw);
     } catch (e) {
       console.warn("[canvas-renderer][pdf-export] anchor-bake pass failed (continuing):", e);
@@ -18327,7 +18455,7 @@ async function assemblePdfFromSvgs(svgResults, options = {}) {
     }
     if (shouldOutlineText) {
       try {
-        const { convertAllTextToPath } = await Promise.resolve().then(() => require("./svgTextToPath-D6xJoPO2.cjs"));
+        const { convertAllTextToPath } = await Promise.resolve().then(() => require("./svgTextToPath-GeR0CexD.cjs"));
         pageSvg = await convertAllTextToPath(pageSvg, fontBaseUrl, { mode: outlineSubMode });
         try {
           dumpSvgTextDiagnostics(pageSvg, i, PARITY_TAG, "STAGE-1b-after-text-to-path-raw");
@@ -18538,4 +18666,4 @@ exports.setAutoShrinkDebug = setAutoShrinkDebug;
 exports.setBundledAssetPrefixes = setBundledAssetPrefixes;
 exports.warmResolvedTemplateForPreview = warmResolvedTemplateForPreview;
 exports.warmTemplateFromForm = warmTemplateFromForm;
-//# sourceMappingURL=index-4IzWx9f-.cjs.map
+//# sourceMappingURL=index-DmqoeVsF.cjs.map