@pixldocs/canvas-renderer 0.5.92 → 0.5.94

package/dist/index.js

@@ -2593,10 +2593,10 @@ async function loadGoogleFont(fontFamily, weights) {
   if (LOCAL_FONTS.has(fontFamily)) return true;
   if (loadedGoogleFonts.has(fontFamily)) return true;
   if (failedGoogleFonts.has(fontFamily)) return false;
-  const existing = loadingPromises$1.get(fontFamily);
+  const existing = loadingPromises$1.get(`google:${fontFamily}`);
   if (existing) return existing;
-  const promise = _doLoadGoogleFont(fontFamily, weights);
-  loadingPromises$1.set(fontFamily, promise);
+  const promise = _doLoadGoogleFont(fontFamily);
+  loadingPromises$1.set(`google:${fontFamily}`, promise);
   try {
     const result = await promise;
     if (result) {
@@ -2606,38 +2606,46 @@ async function loadGoogleFont(fontFamily, weights) {
     }
     return result;
   } finally {
-    loadingPromises$1.delete(fontFamily);
+    loadingPromises$1.delete(`google:${fontFamily}`);
   }
 }
-async function _doLoadGoogleFont(fontFamily, weights) {
-  try {
-    const weightStr = (weights || [300, 400, 500, 600, 700]).join(";");
-    const encodedFamily = encodeURIComponent(fontFamily);
-    const url = `https://fonts.googleapis.com/css2?family=${encodedFamily}:ital,wght@0,${weightStr};1,${weightStr}&display=swap`;
-    const existingLink = document.querySelector(`link[href="${url}"]`);
-    if (existingLink) return true;
+function tryInjectGoogleFontsLink(url, fontFamily) {
+  if (document.querySelector(`link[href="${url}"]`)) return Promise.resolve(true);
+  return new Promise((resolve) => {
     const link = document.createElement("link");
     link.rel = "stylesheet";
     link.href = url;
-    return new Promise((resolve) => {
-      link.onload = async () => {
-        try {
-          await document.fonts.load(`16px "${fontFamily}"`);
-          await document.fonts.load(`bold 16px "${fontFamily}"`);
-        } catch {
-        }
-        resolve(true);
-      };
-      link.onerror = () => {
-        console.warn(`[GoogleFonts] Failed to load: ${fontFamily}`);
-        resolve(false);
-      };
-      document.head.appendChild(link);
-    });
-  } catch (e) {
-    console.warn(`[GoogleFonts] Error loading ${fontFamily}:`, e);
-    return false;
+    link.onload = async () => {
+      try {
+        await document.fonts.load(`16px "${fontFamily}"`);
+      } catch {
+      }
+      resolve(true);
+    };
+    link.onerror = () => resolve(false);
+    document.head.appendChild(link);
+  });
+}
+async function _doLoadGoogleFont(fontFamily, weights) {
+  const encodedFamily = encodeURIComponent(fontFamily);
+  const weightSet = [300, 400, 500, 600, 700];
+  const fullWeightStr = weightSet.join(";");
+  const coreWeightStr = "400;700";
+  const candidates = [
+    `https://fonts.googleapis.com/css2?family=${encodedFamily}:ital,wght@0,${fullWeightStr};1,${fullWeightStr}&display=swap`,
+    `https://fonts.googleapis.com/css2?family=${encodedFamily}:wght@${fullWeightStr}&display=swap`,
+    `https://fonts.googleapis.com/css2?family=${encodedFamily}:ital,wght@0,${coreWeightStr};1,${coreWeightStr}&display=swap`,
+    `https://fonts.googleapis.com/css2?family=${encodedFamily}:wght@${coreWeightStr}&display=swap`,
+    // Plainest possible URL — works for any published Google Font, even
+    // single-weight display/script families like "Frijole" or "Creepster".
+    `https://fonts.googleapis.com/css2?family=${encodedFamily}&display=swap`
+  ];
+  for (const url of candidates) {
+    const ok = await tryInjectGoogleFontsLink(url, fontFamily);
+    if (ok) return true;
   }
+  console.warn(`[GoogleFonts] Failed to load: ${fontFamily}`);
+  return false;
 }
 const getObjectId = (obj) => obj.__docuforgeId;
 const setObjectData = (obj, id) => {
@@ -5544,7 +5552,7 @@ function createText(element) {
     }
     text = result;
   }
-  const targetWidth = overflowPolicy === "auto-shrink" ? fixedWidth : Math.max(baseWidth, getMinTextWidth(element));
+  const targetWidth = fixedWidth;
   const targetScaleX = element.scaleX ?? 1;
   const targetScaleY = element.scaleY ?? 1;
   const textbox = new fabric.Textbox(text, {
@@ -11980,6 +11988,38 @@ function applyContentBoundsPagination(config) {
   if (!mutated) return config;
   return { ...config, pages: resultPages };
 }
+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, "");
@@ -12006,6 +12046,20 @@ async function loadGoogleFontCSS(rawFontFamily) {
   if (existing) return existing;
   const promise = (async () => {
     try {
+      const fontshareSlug = FONTSHARE_SLUGS[fontFamily];
+      if (fontshareSlug) {
+        const url2 = `https://api.fontshare.com/v2/css?f[]=${fontshareSlug}@300,400,500,700&display=swap`;
+        const link2 = document.createElement("link");
+        link2.rel = "stylesheet";
+        link2.href = url2;
+        await new Promise((resolve, reject) => {
+          link2.onload = () => resolve();
+          link2.onerror = () => reject(new Error(`Failed to load Fontshare font: ${fontFamily}`));
+          document.head.appendChild(link2);
+        });
+        loadedFonts.add(fontFamily);
+        return;
+      }
       const encoded = encodeURIComponent(fontFamily);
       const url = `https://fonts.googleapis.com/css?family=${encoded}:300,400,500,600,700&display=swap`;
       const link = document.createElement("link");
@@ -12160,6 +12214,7 @@ async function awaitFontsForConfig(config, maxWaitMs) {
   await ensureFontsForResolvedConfig(config);
   const descriptors = collectFontDescriptorsFromConfig(config);
   if (descriptors.length === 0) return;
+  const overallBudget = Math.max(maxWaitMs, 5e3);
   const loads = Promise.all(
     descriptors.map((d) => {
       const stylePrefix = d.style === "italic" ? "italic " : "";
@@ -12169,11 +12224,11 @@ async function awaitFontsForConfig(config, maxWaitMs) {
   ).then(() => void 0);
   await Promise.race([
     loads,
-    new Promise((resolve) => setTimeout(resolve, maxWaitMs))
+    new Promise((resolve) => setTimeout(resolve, overallBudget))
   ]);
   await Promise.race([
     document.fonts.ready.catch(() => void 0).then(() => void 0),
-    new Promise((r) => setTimeout(r, Math.min(500, maxWaitMs)))
+    new Promise((r) => setTimeout(r, 1500))
   ]);
   const checkSpecs = [];
   for (const d of descriptors) {
@@ -12181,7 +12236,7 @@ async function awaitFontsForConfig(config, maxWaitMs) {
     checkSpecs.push(`${stylePrefix}${d.weight} 16px "${d.family}"`);
   }
   const startedAt = Date.now();
-  const pollBudget = Math.min(maxWaitMs, 2500);
+  const pollBudget = 2500;
   const allReady = () => {
     for (const spec of checkSpecs) {
       try {
@@ -12245,44 +12300,19 @@ function extractSectionStateCandidate(values, sections) {
   const looksLikeSectionState = Object.keys(raw).some((key) => sectionIds.has(key) || key.startsWith("section_"));
   return looksLikeSectionState ? raw : null;
 }
-function entryIdentityTokens(entry, section) {
-  const entryNameKey = section == null ? void 0 : section.entryNameFieldKey;
-  const candidates = [
-    entry[ENTRY_NAME_KEY],
-    entryNameKey ? entry[entryNameKey] : void 0,
-    entry.section_title,
-    entry.label,
-    entry.name
-  ];
-  return Array.from(new Set(
-    candidates.filter((value) => typeof value === "string" && !!value.trim()).map((value) => value.trim().toLowerCase())
-  ));
-}
 function mergeRepeatableEntryMeta(target, metaSource, sections) {
   if (!metaSource) return target;
   let changed = false;
   const next = { ...target };
   const repeatableIds = new Set(sections.filter((section) => section.type === "repeatable").map((section) => section.id));
   const isRepeatableStateKey = (key) => repeatableIds.has(key) || Array.from(repeatableIds).some((id) => key.endsWith(`_${id}`));
-  const sectionForStateKey = (key) => sections.find((section) => section.type === "repeatable" && (section.id === key || key.endsWith(`_${section.id}`)));
   for (const [key, targetEntries] of Object.entries(target)) {
     if (!isRepeatableStateKey(key) || !Array.isArray(targetEntries)) continue;
     const sourceEntries = metaSource[key];
     if (!Array.isArray(sourceEntries)) continue;
-    const section = sectionForStateKey(key);
-    const sourceByToken = /* @__PURE__ */ new Map();
-    const duplicateTokens = /* @__PURE__ */ new Set();
-    for (const sourceEntry of sourceEntries) {
-      if (!isRecord(sourceEntry)) continue;
-      for (const token of entryIdentityTokens(sourceEntry, section)) {
-        if (sourceByToken.has(token)) duplicateTokens.add(token);
-        else sourceByToken.set(token, sourceEntry);
-      }
-    }
-    for (const token of duplicateTokens) sourceByToken.delete(token);
     const mergedEntries = targetEntries.map((entry, index) => {
       if (!isRecord(entry)) return entry;
-      const sourceEntry = entryIdentityTokens(entry, section).map((token) => sourceByToken.get(token)).find((match) => !!match) ?? sourceEntries[index];
+      const sourceEntry = sourceEntries[index];
       if (!isRecord(sourceEntry)) return entry;
       const id = sourceEntry[ENTRY_ID_KEY];
       const name = sourceEntry[ENTRY_NAME_KEY];
@@ -16311,7 +16341,7 @@ async function assemblePdfFromSvgs(svgResults, options = {}) {
     }
     if (shouldOutlineText) {
       try {
-        const { convertAllTextToPath } = await import("./svgTextToPath-BmOzWJsV.js");
+        const { convertAllTextToPath } = await import("./svgTextToPath-CpWdqc8K.js");
         pageSvg = await convertAllTextToPath(pageSvg, fontBaseUrl, { mode: outlineSubMode });
         try {
           dumpSvgTextDiagnostics(pageSvg, i, PARITY_TAG, "STAGE-1b-after-text-to-path-raw");