@pixldocs/canvas-renderer 0.5.96 → 0.5.97

package/dist/index.cjs

@@ -14600,6 +14600,10 @@ function getEmbeddedJsPDFFontName(fontName, weight, isItalic = false) {
 function isFontAvailable(fontName) {
   return fontName in FONT_FILES;
 }
+const registeredFamilies = /* @__PURE__ */ new Set();
+function isFamilyEmbedded(family) {
+  return registeredFamilies.has(family);
+}
 const ttfCache = /* @__PURE__ */ new Map();
 async function fetchTTFAsBase64(url) {
   const cached = ttfCache.get(url);
@@ -14672,12 +14676,133 @@ async function embedFont(pdf, fontName, weight, fontBaseUrl, isItalic = false) {
       } catch {
       }
     }
+    registeredFamilies.add(fontName);
     return true;
   } catch (e) {
     console.warn(`[pdf-fonts] Failed to embed ${fontName} w${weight}:`, e);
     return false;
   }
 }
+const googleFontNotFound = /* @__PURE__ */ new Set();
+const fontshareNotFound = /* @__PURE__ */ new Set();
+function bytesToBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+  return btoa(binary);
+}
+async function fetchGoogleFontTTF(fontFamily, weight, isItalic = false) {
+  const cacheKey = `gf:${fontFamily}:${weight}:${isItalic ? "i" : "n"}`;
+  if (ttfCache.has(cacheKey)) return ttfCache.get(cacheKey);
+  if (googleFontNotFound.has(fontFamily)) return null;
+  try {
+    const ital = isItalic ? "1" : "0";
+    const cssUrl = `https://fonts.googleapis.com/css2?family=${encodeURIComponent(
+      fontFamily
+    )}:ital,wght@${ital},${weight}&display=swap`;
+    const cssRes = await fetch(cssUrl, {
+      headers: {
+        "User-Agent": "Mozilla/5.0 (Linux; U; Android 2.2; en-us) AppleWebKit/533.1 (KHTML, like Gecko)"
+      }
+    });
+    if (!cssRes.ok) {
+      if (cssRes.status === 400 || cssRes.status === 404) googleFontNotFound.add(fontFamily);
+      return null;
+    }
+    const css = await cssRes.text();
+    const urlMatch = css.match(/url\(([^)]+)\)\s+format\(['"]?truetype['"]?\)/i) || css.match(/url\(([^)]+)\)/);
+    if (!urlMatch) return null;
+    const ttfUrl = urlMatch[1].replace(/['"]/g, "");
+    const ttfRes = await fetch(ttfUrl);
+    if (!ttfRes.ok) return null;
+    const buf = await ttfRes.arrayBuffer();
+    const bytes = new Uint8Array(buf);
+    if (!isJsPdfEmbeddableTrueType(bytes)) {
+      console.warn(`[pdf-fonts] Google Fonts returned a non-TTF for ${fontFamily} (${weight}); skipping`);
+      return null;
+    }
+    const b64 = bytesToBase64(bytes);
+    ttfCache.set(cacheKey, b64);
+    return b64;
+  } catch (err) {
+    console.warn(`[pdf-fonts] fetchGoogleFontTTF failed for ${fontFamily} (${weight}):`, err);
+    return null;
+  }
+}
+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 slug = fontFamily.trim().toLowerCase().replace(/\s+/g, "-");
+  try {
+    const styleSuffix = isItalic ? "i" : "";
+    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);
+      return null;
+    }
+    const css = await cssRes.text();
+    const ttMatch = css.match(/url\(([^)]+)\)\s+format\(['"]?truetype['"]?\)/i);
+    if (!ttMatch) {
+      fontshareNotFound.add(fontFamily);
+      return null;
+    }
+    let ttfUrl = ttMatch[1].replace(/['"]/g, "").trim();
+    if (ttfUrl.startsWith("//")) ttfUrl = `https:${ttfUrl}`;
+    const ttfRes = await fetch(ttfUrl);
+    if (!ttfRes.ok) return null;
+    const buf = await ttfRes.arrayBuffer();
+    const bytes = new Uint8Array(buf);
+    if (!isJsPdfEmbeddableTrueType(bytes)) return null;
+    const b64 = bytesToBase64(bytes);
+    ttfCache.set(cacheKey, b64);
+    return b64;
+  } catch (err) {
+    console.warn(`[pdf-fonts] fetchFontshareTTF failed for ${fontFamily} (${weight}):`, err);
+    return null;
+  }
+}
+function registerJsPdfFont(pdf, fontName, resolvedWeight, isItalic, base64) {
+  const label = FONT_WEIGHT_LABELS[resolvedWeight];
+  const italicSuffix = isItalic ? "Italic" : "";
+  const jsPdfFontName = getEmbeddedJsPDFFontName(fontName, resolvedWeight, isItalic);
+  const fileName = `${getJsPDFFontName(fontName)}-${label}${italicSuffix}.ttf`;
+  try {
+    pdf.addFileToVFS(fileName, base64);
+    pdf.addFont(fileName, jsPdfFontName, "normal");
+    if (fontName !== jsPdfFontName) {
+      try {
+        pdf.addFont(fileName, fontName, "normal");
+      } catch {
+      }
+    }
+    registeredFamilies.add(fontName);
+    return true;
+  } catch (err) {
+    console.warn(`[pdf-fonts] registerJsPdfFont failed for ${fontName}:`, err);
+    return false;
+  }
+}
+async function embedFontWithGoogleFallback(pdf, fontName, weight = 400, fontBaseUrl, isItalic = false) {
+  if (FONT_FILES[fontName]) {
+    const ok = await embedFont(pdf, fontName, weight, fontBaseUrl, isItalic);
+    if (ok) return true;
+  }
+  const resolved = resolveFontWeight(weight);
+  const fsB64 = await fetchFontshareTTF(fontName, resolved, isItalic);
+  if (fsB64) return registerJsPdfFont(pdf, fontName, resolved, isItalic, fsB64);
+  if (isItalic) {
+    const fsUpright = await fetchFontshareTTF(fontName, resolved, false);
+    if (fsUpright) return registerJsPdfFont(pdf, fontName, resolved, isItalic, fsUpright);
+  }
+  const b64 = await fetchGoogleFontTTF(fontName, resolved, isItalic);
+  if (b64) return registerJsPdfFont(pdf, fontName, resolved, isItalic, b64);
+  if (isItalic) {
+    const uprightB64 = await fetchGoogleFontTTF(fontName, resolved, false);
+    if (uprightB64) return registerJsPdfFont(pdf, fontName, resolved, isItalic, uprightB64);
+  }
+  return false;
+}
 async function embedFontsForConfig(pdf, config, fontBaseUrl) {
   const fontKeys = /* @__PURE__ */ new Set();
   const SEP = "";
@@ -14836,7 +14961,7 @@ function rewriteSvgFontsForJsPDF(svgStr) {
     const rawFf = resolveInheritedValue(el, "font-family");
     if (!rawFf) continue;
     const clean = (_a = rawFf.split(",")[0]) == null ? void 0 : _a.replace(/['"]/g, "").trim();
-    if (!isFontAvailable(clean)) continue;
+    if (!isFontAvailable(clean) && !isFamilyEmbedded(clean)) continue;
     const weightRaw = resolveInheritedValue(el, "font-weight") || "400";
     const styleRaw = resolveInheritedValue(el, "font-style") || "normal";
     const weight = resolveWeightNum(weightRaw);
@@ -14919,14 +15044,19 @@ async function embedFontsInPdf(pdf, fontFamilies, fontBaseUrl) {
   fontFamilies.add(FONT_FALLBACK_SYMBOLS);
   fontFamilies.add(FONT_FALLBACK_DEVANAGARI);
   for (const family of fontFamilies) {
-    if (!isFontAvailable(family)) {
-      console.warn(`[pdf-fonts] No TTF mapping for "${family}" — will use Helvetica fallback`);
-      continue;
-    }
-    for (const w of weights) {
+    if (isFontAvailable(family)) {
+      for (const w of weights) {
+        tasks.push(
+          embedFont(pdf, family, w, fontBaseUrl).then((ok) => {
+            if (ok) embedded.add(`${family}${w}`);
+          })
+        );
+      }
+    } else {
       tasks.push(
-        embedFont(pdf, family, w, fontBaseUrl).then((ok) => {
-          if (ok) embedded.add(`${family}${w}`);
+        embedFontWithGoogleFallback(pdf, family, 400, fontBaseUrl, false).then((ok) => {
+          if (ok) embedded.add(`${family}400`);
+          else console.warn(`[pdf-fonts] No TTF (local/Google/Fontshare) for "${family}" — will use Helvetica fallback`);
         })
       );
     }
@@ -14942,6 +15072,7 @@ const pdfFonts = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProp
   FONT_FILES,
   FONT_WEIGHT_LABELS,
   embedFont,
+  embedFontWithGoogleFallback,
   embedFontsForConfig,
   embedFontsInPdf,
   extractFontFamiliesFromSvgs,