@pixldocs/canvas-renderer 0.3.18 → 0.3.19

package/dist/index.d.ts

@@ -43,6 +43,15 @@ export declare function collectFontDescriptorsFromConfig(config: TemplateConfig)
  */
 export declare function collectFontsFromConfig(config: TemplateConfig): Set<string>;
 
+/**
+ * Collect all image asset URLs from a TemplateConfig that the Fabric canvas
+ * will request during rendering. This is the canonical list — the same logic
+ * that `getExpectedImageCount` uses, but returning URLs instead of a count.
+ *
+ * Walks **all pages** and recurses into children / groups.
+ */
+export declare function collectImageUrls(config: TemplateConfig): string[];
+
 export declare interface DynamicField {
     id: string;
     label: string;
@@ -316,4 +325,53 @@ export declare interface ThemeVariables {
     [variableName: string]: string;
 }
 
+export declare interface WarmOptions {
+    /** AbortSignal to cancel in-flight prefetches (e.g. on route change). */
+    signal?: AbortSignal;
+    /** Image proxy base URL. Falls back to the value set via `setPackageApiUrl`. */
+    imageProxyUrl?: string;
+}
+
+/**
+ * Warm fonts **and** image assets for a fully-resolved `TemplateConfig`.
+ *
+ * Call this on idle / in the background before rendering so that `render()`
+ * resolves from browser caches instead of hitting the network.
+ *
+ * **Idempotent** — repeated calls for the same config are near-instant
+ * (fonts deduplicate internally; `fetch` hits HTTP cache).
+ *
+ * Does **not** mount a canvas or require React.
+ *
+ * @example
+ * ```ts
+ * import { warmResolvedTemplateForPreview } from '@pixldocs/canvas-renderer';
+ *
+ * const controller = new AbortController();
+ * await warmResolvedTemplateForPreview(resolvedConfig, { signal: controller.signal });
+ * // Later: renderer.render(resolvedConfig) — fonts & images are cached
+ * ```
+ */
+export declare function warmResolvedTemplateForPreview(config: TemplateConfig, options?: WarmOptions): Promise<void>;
+
+/**
+ * Convenience: resolve a template from the database **and** warm its assets
+ * in a single call. Combines `resolveFromForm` + `warmResolvedTemplateForPreview`.
+ *
+ * @example
+ * ```ts
+ * import { warmTemplateFromForm } from '@pixldocs/canvas-renderer';
+ *
+ * await warmTemplateFromForm({
+ *   templateId: 'dc3fbb17-...',
+ *   formSchemaId: 'b04cd362-...',
+ *   sectionState: { ... },
+ *   supabaseUrl: '...',
+ *   supabaseAnonKey: '...',
+ *   signal: controller.signal,
+ * });
+ * ```
+ */
+export declare function warmTemplateFromForm(options: ResolveFromFormOptions & WarmOptions): Promise<void>;
+
 export { }

package/dist/index.js

@@ -10923,16 +10923,95 @@ class PixldocsRenderer {
     });
   }
 }
+function collectImageUrls(config) {
+  const urls = [];
+  const walk = (nodes) => {
+    for (const node of nodes) {
+      if (!node || node.visible === false) continue;
+      const src = typeof node.src === "string" ? node.src.trim() : "";
+      const imageUrl = typeof node.imageUrl === "string" ? node.imageUrl.trim() : "";
+      if (node.type === "image") {
+        const url = src || imageUrl;
+        if (url) urls.push(url);
+      }
+      if (Array.isArray(node.children) && node.children.length > 0) {
+        walk(node.children);
+      }
+    }
+  };
+  for (const page of config.pages || []) {
+    walk(page.children || []);
+  }
+  return urls;
+}
+function normalizeAssetUrl(rawUrl, imageProxyUrl) {
+  if (!rawUrl) return null;
+  if (rawUrl.startsWith("data:") || rawUrl.startsWith("blob:")) return null;
+  try {
+    const h = new URL(rawUrl).hostname.toLowerCase();
+    if (h === "localhost" || h === "127.0.0.1" || h === "0.0.0.0" || h.endsWith(".local") || /^(10\.|192\.168\.|169\.254\.)/.test(h)) {
+      return null;
+    }
+  } catch {
+    return null;
+  }
+  const supabaseUrl = typeof globalThis.__VITE_SUPABASE_URL === "string" ? globalThis.__VITE_SUPABASE_URL : "";
+  if (supabaseUrl && rawUrl.includes(supabaseUrl)) {
+    const signedMatch = rawUrl.match(/\/storage\/v1\/object\/sign\/([^?]+)/);
+    if (signedMatch) return `${supabaseUrl}/storage/v1/object/public/${signedMatch[1]}`;
+    if (rawUrl.includes("/storage/v1/object/public/")) return rawUrl;
+  }
+  const proxyBase = imageProxyUrl ? imageProxyUrl.replace(/\/image-proxy(?:\?.*)?$/, "") : API_URL;
+  if (proxyBase) {
+    return `${proxyBase}/image-proxy?url=${encodeURIComponent(rawUrl)}`;
+  }
+  return rawUrl;
+}
+const CONCURRENCY = 6;
+async function prefetchUrls(urls, signal) {
+  const unique = [...new Set(urls)];
+  if (unique.length === 0) return;
+  let i = 0;
+  const next = async () => {
+    while (i < unique.length) {
+      if (signal == null ? void 0 : signal.aborted) return;
+      const url = unique[i++];
+      try {
+        await fetch(url, { signal, mode: "cors", credentials: "omit" });
+      } catch {
+      }
+    }
+  };
+  const workers = Array.from({ length: Math.min(CONCURRENCY, unique.length) }, () => next());
+  await Promise.all(workers);
+}
+async function warmResolvedTemplateForPreview(config, options) {
+  const { signal, imageProxyUrl } = options ?? {};
+  await ensureFontsForResolvedConfig(config);
+  if (signal == null ? void 0 : signal.aborted) return;
+  const rawUrls = collectImageUrls(config);
+  const resolvedUrls = rawUrls.map((u) => normalizeAssetUrl(u, imageProxyUrl)).filter((u) => u !== null);
+  await prefetchUrls(resolvedUrls, signal);
+}
+async function warmTemplateFromForm(options) {
+  const { signal, imageProxyUrl, ...resolveOpts } = options;
+  const resolved = await resolveFromForm(resolveOpts);
+  if (signal == null ? void 0 : signal.aborted) return;
+  await warmResolvedTemplateForPreview(resolved.config, { signal, imageProxyUrl });
+}
 export {
   PixldocsPreview,
   PixldocsRenderer,
   applyThemeToConfig,
   collectFontDescriptorsFromConfig,
   collectFontsFromConfig,
+  collectImageUrls,
   ensureFontsForResolvedConfig,
   loadGoogleFontCSS,
   normalizeFontFamily,
   resolveFromForm,
-  resolveTemplateData
+  resolveTemplateData,
+  warmResolvedTemplateForPreview,
+  warmTemplateFromForm
 };
 //# sourceMappingURL=index.js.map