@ethercorps/sveltekit-og 4.3.0-next.13 → 4.3.0-next.15

package/dist/helpers/toJSX.d.ts

@@ -1,3 +1,3 @@
 import type { Component } from "svelte";
 import type { ComponentOptions, VNode } from "../types.js";
-export declare function createVNode(element: string | Component, componentProps?: ComponentOptions): VNode;
+export declare function createVNode(element: string | Component, componentOptions?: ComponentOptions): VNode;

package/dist/helpers/toJSX.js

@@ -1,11 +1,11 @@
 import { html } from "satori-html";
 import { handleSync, ErrorCodes } from "./error-handler.js";
 import { renderComponentToHtml } from "./to-html.js";
-export function createVNode(element, componentProps) {
+export function createVNode(element, componentOptions) {
     return handleSync(() => {
         if (typeof element === "string")
             return html(element.replaceAll("\n", "").trim());
-        const { body, head } = renderComponentToHtml(element, componentProps?.props);
+        const { body, head } = renderComponentToHtml(element, componentOptions?.props);
         return html(body + head);
     }, ErrorCodes.VNODE_CREATION_FAILED, "Failed to create VNode");
 }

package/dist/providers/instances.js

@@ -4,14 +4,13 @@ import { handleAsync, ErrorCodes } from "../helpers/error-handler.js";
 /**
  * Lazy singleton around a node/edge wasm module pair. The edge/node choice is
  * made per-runtime via std-env; both sides stay direct import() expressions so
- * the bundler can emit the wasm chunk. The instance is only cached after its
- * wasm finished initializing, so a failed init can be retried.
+ * the bundler can emit the wasm chunk. Memoizes the init promise (like
+ * takumi/renderer.ts) so concurrent first requests share one init, and clears
+ * it on rejection so a failed init can be retried.
  */
 function createProvider(label, errorCode, imports) {
-    let instance;
-    return async (debug = false) => {
-        if (instance)
-            return instance;
+    let instancePromise;
+    const init = async (debug) => {
         const log = createLogger(debug);
         log.debug(`Initializing ${label}`);
         const isWorkerLikeRuntime = isEdgeLight || isWorkerd;
@@ -19,8 +18,14 @@ function createProvider(label, errorCode, imports) {
         const moduleImport = isWorkerLikeRuntime ? imports.edge() : imports.node();
         const loaded = await handleAsync(() => moduleImport.then((m) => m.default), errorCode, `Failed to import ${label} module`);
         await handleAsync(() => loaded.initWasmPromise, errorCode, `Failed to initialize ${label} WASM`);
-        instance = loaded;
-        return instance;
+        return loaded;
+    };
+    return (debug = false) => {
+        instancePromise ??= init(debug).catch((error) => {
+            instancePromise = undefined;
+            throw error;
+        });
+        return instancePromise;
     };
 }
 const useResvgModule = createProvider("ReSVG", ErrorCodes.RESVG_INIT_FAILED, {

package/dist/takumi/render.js

@@ -1,14 +1,13 @@
 import { render as takumiRender, renderSvg } from "takumi-js";
-import { renderComponentToHtml } from "../helpers/to-html.js";
 import { useTakumiRenderer, registerTakumiFonts } from "./renderer.js";
 import { resolveTakumiFonts } from "./fonts.js";
 import { createLogger } from "../helpers/logger.js";
-import { handleAsync, handleSync, ErrorCodes } from "../helpers/error-handler.js";
+import { handleAsync, ErrorCodes, handleSync } from "../helpers/error-handler.js";
 import { createVNode } from "../helpers/toJSX.js";
 /** Render an HTML string or Svelte component to image bytes (or an svg string). */
 export async function createTakumiImage(element, options, props) {
     const log = createLogger(options.debug ?? false);
-    const vNode = handleSync(() => createVNode(element, props), ErrorCodes.VNODE_CREATION_FAILED, "Failed to create HTML for Takumi");
+    const vNode = handleSync(() => createVNode(element, { props }), ErrorCodes.VNODE_CREATION_FAILED, "Failed to create HTML for Takumi");
     const renderer = await useTakumiRenderer();
     if (options.fonts?.length) {
         const fonts = await resolveTakumiFonts(options.fonts);

package/dist/takumi/renderer.d.ts

@@ -1,6 +1,7 @@
 import type { Renderer as NodeRenderer, FontDetails } from "takumi-js/node";
 export type TakumiRenderer = NodeRenderer;
-/** Lazily creates and caches the Takumi renderer for the current runtime. */
+/** Lazily creates and caches the Takumi renderer for the current runtime.
+ * A rejected init clears the cache so the next request retries. */
 export declare function useTakumiRenderer(): Promise<TakumiRenderer>;
 /** Register each font once, keyed by name/weight/style. */
 export declare function registerTakumiFonts(renderer: TakumiRenderer, fonts: FontDetails[]): Promise<void>;

package/dist/takumi/renderer.js

@@ -18,9 +18,13 @@ async function initRenderer() {
     }, ErrorCodes.TAKUMI_INIT_FAILED, "Failed to initialize Takumi WASM");
     return new Renderer();
 }
-/** Lazily creates and caches the Takumi renderer for the current runtime. */
+/** Lazily creates and caches the Takumi renderer for the current runtime.
+ * A rejected init clears the cache so the next request retries. */
 export async function useTakumiRenderer() {
-    rendererPromise ??= initRenderer();
+    rendererPromise ??= initRenderer().catch((error) => {
+        rendererPromise = undefined;
+        throw error;
+    });
     return rendererPromise;
 }
 /** Register each font once, keyed by name/weight/style. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethercorps/sveltekit-og",
-  "version": "4.3.0-next.13",
+  "version": "4.3.0-next.15",
   "license": "MIT",
   "homepage": "https://sveltekit-og.dev",
   "repository": "github:ethercorps/sveltekit-og",