@pixldocs/canvas-renderer 0.5.134 → 0.5.136

package/dist/{index-Sc4qRn5o.js → index-BHa3ekoF.js}

@@ -14608,6 +14608,38 @@ const pdfFonts = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProp
   resolveFontWeight,
   rewriteSvgFontsForJsPDF
 }, Symbol.toStringTag, { value: "Module" }));
+const FONTSHARE_SLUGS = {
+  "Satoshi": "satoshi",
+  "Cabinet Grotesk": "cabinet-grotesk",
+  "Clash Display": "clash-display",
+  "Clash Grotesk": "clash-grotesk",
+  "General Sans": "general-sans",
+  "Switzer": "switzer",
+  "Supreme": "supreme",
+  "Author": "author",
+  "Boska": "boska",
+  "Excon": "excon",
+  "Khand": "khand",
+  "Sentient": "sentient",
+  "Synonym": "synonym",
+  "Erode": "erode",
+  "Ranade": "ranade",
+  "Tanker": "tanker",
+  "Zodiak": "zodiak",
+  "Gambarino": "gambarino",
+  "Melodrama": "melodrama",
+  "Bespoke Serif": "bespoke-serif",
+  "Bespoke Stencil": "bespoke-stencil",
+  "Panchang": "panchang",
+  "Quincy CF": "quincy-cf",
+  "Pally": "pally",
+  "Tabular": "tabular",
+  "Sharpie": "sharpie",
+  "Stardom": "stardom",
+  "Rebond Grotesque": "rebond-grotesque",
+  "Telma": "telma",
+  "Nippo": "nippo"
+};
 function normalizeFontFamily(fontStack) {
   const first = fontStack.split(",")[0].trim();
   return first.replace(/^['"]|['"]$/g, "");
@@ -14615,6 +14647,114 @@ function normalizeFontFamily(fontStack) {
 const loadedFonts = /* @__PURE__ */ new Set();
 const loadingPromises = /* @__PURE__ */ new Map();
 const registeredLocalFontFaces = /* @__PURE__ */ new Set();
+const registeredRemoteFontFaces = /* @__PURE__ */ new Set();
+const remoteFontDataUriPromises = /* @__PURE__ */ new Map();
+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));
+}
+function appendDataUriFontFaceRule(family, weight, style, dataUri) {
+  const styleEl = ensureLocalFontFaceStyle();
+  if (!styleEl) return;
+  const cssText = `@font-face{font-family:"${family}";src:url("${dataUri}") format("truetype");font-weight:${weight};font-style:${style};font-display:swap;}
+`;
+  styleEl.appendChild(document.createTextNode(cssText));
+}
+function resolveHarnessFontProxyUrl() {
+  var _a, _b;
+  try {
+    const runtimeBase = typeof window !== "undefined" && (window.__PIXLDOCS_SUPABASE_URL || ((_a = window.__CONFIG__) == null ? void 0 : _a.supabaseUrl)) || typeof globalThis !== "undefined" && (globalThis.__PIXLDOCS_SUPABASE_URL || ((_b = globalThis.__CONFIG__) == null ? void 0 : _b.supabaseUrl)) || "";
+    const base = String(runtimeBase || "").replace(/\/$/, "");
+    return base ? `${base}/functions/v1/font-proxy` : "";
+  } catch {
+    return "";
+  }
+}
+function isEmbeddableTrueType(bytes) {
+  if (bytes.length < 12) return false;
+  const signature = String.fromCharCode(bytes[0], bytes[1], bytes[2], bytes[3]);
+  return signature === "\0
\0\0" || signature === "true";
+}
+async function arrayBufferToDataUri(buf) {
+  const blob = new Blob([buf], { type: "font/ttf" });
+  return await new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(String(reader.result));
+    reader.onerror = () => reject(reader.error || new Error("Failed to read font bytes"));
+    reader.readAsDataURL(blob);
+  });
+}
+async function fetchFontProxyDataUri(family, weight, style, source) {
+  const proxyUrl = resolveHarnessFontProxyUrl();
+  if (!proxyUrl) return null;
+  const key = `${source}|${family}|${weight}|${style}`;
+  const existing = remoteFontDataUriPromises.get(key);
+  if (existing) return existing;
+  const promise = (async () => {
+    try {
+      const url = `${proxyUrl}?family=${encodeURIComponent(family)}&weight=${weight}&italic=${style === "italic" ? 1 : 0}&source=${source}`;
+      const res = await fetch(url, { credentials: "omit" });
+      if (!res.ok) return null;
+      const contentType = res.headers.get("content-type") || "";
+      if (/application\/json/i.test(contentType)) return null;
+      const buf = await res.arrayBuffer();
+      const bytes = new Uint8Array(buf);
+      if (!isEmbeddableTrueType(bytes)) return null;
+      return await arrayBufferToDataUri(buf);
+    } catch {
+      return null;
+    }
+  })();
+  remoteFontDataUriPromises.set(key, promise);
+  return promise;
+}
+async function registerRemoteFontFaceViaProxy(family, requestedWeight, styleRaw) {
+  if (typeof document === "undefined" || typeof FontFace === "undefined" || !document.fonts) return false;
+  if (!resolveHarnessFontProxyUrl()) return false;
+  const style = /italic|oblique/i.test(styleRaw || "") ? "italic" : "normal";
+  const parsed = typeof requestedWeight === "number" ? requestedWeight : Number.parseInt(String(requestedWeight || "400"), 10);
+  const resolved = Number.isFinite(parsed) ? parsed <= 350 ? 300 : parsed <= 450 ? 400 : parsed <= 550 ? 500 : parsed <= 650 ? 600 : 700 : 400;
+  const weightLadder = [resolved];
+  for (const w of [400, 500, 700, 600, 300]) if (!weightLadder.includes(w)) weightLadder.push(w);
+  const sourceOrder = FONTSHARE_SLUGS[family] ? ["fontshare", "google"] : ["google", "fontshare"];
+  for (const actualWeight of weightLadder) {
+    for (const source of sourceOrder) {
+      const faceKey = `${family}|${actualWeight}|${style}|${source}`;
+      if (registeredRemoteFontFaces.has(faceKey)) return true;
+      const dataUri = await fetchFontProxyDataUri(family, actualWeight, style, source);
+      if (!dataUri) continue;
+      try {
+        const face = new FontFace(family, `url("${dataUri}")`, {
+          weight: String(actualWeight),
+          style
+        });
+        await face.load();
+        document.fonts.add(face);
+        appendDataUriFontFaceRule(family, actualWeight, style, dataUri);
+        registeredRemoteFontFaces.add(faceKey);
+        return true;
+      } catch {
+      }
+    }
+  }
+  return false;
+}
 const LOCAL_FONT_FACE_VARIANTS = [
   { key: "regular", weight: 400, style: "normal" },
   { key: "bold", weight: 700, style: "normal" },
@@ -14644,6 +14784,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 {
     }
@@ -14808,6 +14949,9 @@ async function ensureFontsForResolvedConfig(config) {
   const descriptors = collectFontDescriptorsFromConfig(config);
   const families = new Set(descriptors.map((d) => d.family));
   await withTimeout(Promise.all([...families].map((f) => loadGoogleFontCSS(f))), 3500);
+  await withTimeout(Promise.all(
+    descriptors.map((d) => registerRemoteFontFaceViaProxy(d.family, d.weight, d.style))
+  ), 5e3);
   if (document.fonts) {
     descriptors.forEach((d) => {
       const stylePrefix = d.style === "italic" ? "italic " : "";
@@ -15795,7 +15939,7 @@ function captureFabricCanvasSvgForPdf(fabricInstance, canvasWidth, canvasHeight)
   }
   return svgString;
 }
-const PACKAGE_VERSION = "0.5.131";
+const PACKAGE_VERSION = "0.5.136";
 const roundParityValue = (value) => {
   if (typeof value !== "number") return value;
   return Number.isFinite(value) ? Number(value.toFixed(3)) : value;
@@ -16214,7 +16358,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 import("./vectorPdfExport-BA6bhLs-.js");
+      const { exportMultiPagePdf, preparePagesForExport } = await import("./vectorPdfExport-D3L64sAJ.js");
       const prepared = preparePagesForExport(
         cloned.pages,
         canvasWidth,
@@ -18117,7 +18261,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);
@@ -18135,6 +18278,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();
@@ -18306,7 +18450,7 @@ async function prepareLiveCanvasSvgForPdf(rawSvg, pageWidth, pageHeight, pageKey
     if (options == null ? void 0 : options.stripPageBackground) stripRootPageBackgroundFromSvg(svgToDraw);
     sanitizeSvgTreeForPdf(svgToDraw);
     try {
-      const { bakeTextAnchorPositionsFromLiveSvg } = await import("./vectorPdfExport-BA6bhLs-.js");
+      const { bakeTextAnchorPositionsFromLiveSvg } = await import("./vectorPdfExport-D3L64sAJ.js");
       await bakeTextAnchorPositionsFromLiveSvg(svgToDraw);
     } catch (e) {
       console.warn("[canvas-renderer][pdf-export] anchor-bake pass failed (continuing):", e);
@@ -18651,4 +18795,4 @@ export {
   collectFontDescriptorsFromConfig as y,
   collectFontsFromConfig as z
 };
-//# sourceMappingURL=index-Sc4qRn5o.js.map
+//# sourceMappingURL=index-BHa3ekoF.js.map