wasm-html-to-image 0.1.0

package/dist/worker-actions.d.ts

@@ -0,0 +1,10 @@
+import { type HtmlToImageOptions, type RenderResult } from "./core.js";
+import type { HtmlToImageModule } from "./loader.js";
+/**
+ * Shared worker action table (unified `render` only).
+ * `child-workers.ts` (Node) and `browser-workers.ts` (pre-bundled browser
+ * worker) differ only in how `getModule` resolves the WASM module.
+ */
+export declare function createRenderActions(getModule: () => Promise<HtmlToImageModule>): {
+    render(options: HtmlToImageOptions): Promise<RenderResult<Uint8Array | string>>;
+};

package/dist/worker-actions.js

@@ -0,0 +1,13 @@
+import { htmlToImage, } from "./core.js";
+/**
+ * Shared worker action table (unified `render` only).
+ * `child-workers.ts` (Node) and `browser-workers.ts` (pre-bundled browser
+ * worker) differ only in how `getModule` resolves the WASM module.
+ */
+export function createRenderActions(getModule) {
+    return {
+        async render(options) {
+            return await htmlToImage(await getModule(), options);
+        },
+    };
+}

package/dist/worker-lib-loader.d.ts

@@ -0,0 +1,19 @@
+import type * as WorkerLibTypes from "worker-lib";
+export interface WorkerLib {
+    createWorker: typeof WorkerLibTypes.createWorker;
+    initWorker: typeof WorkerLibTypes.initWorker;
+    Worker: typeof WorkerLibTypes.Worker;
+}
+/**
+ * Load worker-lib, tolerating its broken native-ESM build: the published
+ * `dist/esm/*.js` uses extensionless relative imports (`./pool`), which
+ * throw `ERR_MODULE_NOT_FOUND` under plain Node (2.2.0/2.2.1; upstream
+ * dodges this via bundler resolution). Plain Node falls back to the CJS
+ * build via `createRequire`, which resolves fine.
+ *
+ * No `@vite-ignore` on the first import so bundlers still substitute the
+ * browser build for browser targets.
+ */
+export declare function loadWorkerLib(): Promise<WorkerLib>;
+/** Drop the cached load (e.g. after a failed load) so it can be retried. */
+export declare function resetWorkerLib(): void;

package/dist/worker-lib-loader.js

@@ -0,0 +1,34 @@
+import { importNode } from "./loader.js";
+let cached;
+/**
+ * Load worker-lib, tolerating its broken native-ESM build: the published
+ * `dist/esm/*.js` uses extensionless relative imports (`./pool`), which
+ * throw `ERR_MODULE_NOT_FOUND` under plain Node (2.2.0/2.2.1; upstream
+ * dodges this via bundler resolution). Plain Node falls back to the CJS
+ * build via `createRequire`, which resolves fine.
+ *
+ * No `@vite-ignore` on the first import so bundlers still substitute the
+ * browser build for browser targets.
+ */
+export function loadWorkerLib() {
+    if (!cached) {
+        cached = (async () => {
+            try {
+                return (await import("worker-lib"));
+            }
+            catch {
+                const mod = await importNode("module");
+                return mod.createRequire(import.meta.url)("worker-lib");
+            }
+        })();
+        // A rejected load must not poison the cache; allow a later retry.
+        cached.catch(() => {
+            resetWorkerLib();
+        });
+    }
+    return cached;
+}
+/** Drop the cached load (e.g. after a failed load) so it can be retried. */
+export function resetWorkerLib() {
+    cached = undefined;
+}

package/dist/workerd.d.ts

@@ -0,0 +1,18 @@
+import { type HtmlToImageModule } from "./loader.js";
+import { type HtmlToImageOptions, type RenderResult } from "./core.js";
+export type { OutputFormat, RenderOptions, HtmlToImageOptions, RenderResult, DiagnosticMessage, FontDiagnostic, RenderDiagnostics, RenderLimits, ResolveResourceHook, ResourceDiagnostic, } from "./core.js";
+export { DIAGNOSTIC_CODES, LogLevel } from "./core.js";
+export type { HtmlToImageModule, EmscriptenModuleArg, LoadOptions, WasmInstancePtr, CreateHtmlToImageModule, } from "./loader.js";
+/**
+ * Load (and reuse) the unified module on workerd.
+ * @param wasm The compiled WASM module (defaults to the bundled one)
+ */
+export declare function getDefaultModule(wasm?: WebAssembly.Module): Promise<HtmlToImageModule>;
+/**
+ * Render HTML — or convert an image — on workerd.
+ * Returns RenderResult containing data and metadata.
+ */
+export declare function render(options: HtmlToImageOptions & {
+    format: "svg";
+}, wasm?: WebAssembly.Module): Promise<RenderResult<string>>;
+export declare function render(options: HtmlToImageOptions, wasm?: WebAssembly.Module): Promise<RenderResult<Uint8Array | string>>;

package/dist/workerd.js

@@ -0,0 +1,65 @@
+/**
+ * Cloudflare Workers (workerd) entry point.
+ *
+ * Upstream-compatible pattern (`satoru` / `wasm-image-optimization`
+ * `workerd.ts`): the `.wasm` artifact is imported as a pre-compiled
+ * `WebAssembly.Module` and instantiation is overridden via
+ * `instantiateWasm`, because workerd cannot fetch/compile WASM at runtime.
+ *
+ * Uses the regular (non-SINGLE_FILE) `dist/html-to-image.wasm`
+ * (`SINGLE_FILE` builds cannot be used on Workers).
+ *
+ * ```ts
+ * import wasm from "wasm-html-to-image/html-to-image.wasm"; // optional override
+ * import { render } from "wasm-html-to-image/workerd";
+ * const png = await render({ value: "<h1>hi</h1>", width: 800, format: "png" });
+ * ```
+ */
+// @ts-expect-error — dist/html-to-image.js is generated at build time
+import createHtmlToImageModule from "../dist/html-to-image.js";
+import htmlToImageWasm from "../dist/html-to-image.wasm";
+import { loadHtmlToImageModule, } from "./loader.js";
+import { htmlToImage, } from "./core.js";
+export { DIAGNOSTIC_CODES, LogLevel } from "./core.js";
+/** Build the Emscripten module args overriding WASM instantiation. */
+function workerdModuleArg(wasm) {
+    return {
+        instantiateWasm: (imports, successCallback) => {
+            // Cloudflare Workers requires using the pre-compiled WebAssembly.Module
+            WebAssembly.instantiate(wasm, imports)
+                .then((instance) => {
+                successCallback(instance, wasm);
+            })
+                .catch((e) => {
+                console.error("wasm-html-to-image [workerd]: Wasm instantiation failed:", e);
+            });
+            return {}; // Return empty object as emscripten expects
+        },
+    };
+}
+/** Module instances keyed by WASM binary: a second call with a different
+ * `wasm` must not silently reuse the first one (previous bug). Failed loads
+ * are evicted so a later call can retry. */
+const moduleByWasm = new Map();
+/**
+ * Load (and reuse) the unified module on workerd.
+ * @param wasm The compiled WASM module (defaults to the bundled one)
+ */
+export function getDefaultModule(wasm = htmlToImageWasm) {
+    let pending = moduleByWasm.get(wasm);
+    if (!pending) {
+        pending = loadHtmlToImageModule({
+            factory: createHtmlToImageModule,
+            moduleArg: workerdModuleArg(wasm),
+        });
+        moduleByWasm.set(wasm, pending);
+        pending.catch(() => {
+            if (moduleByWasm.get(wasm) === pending)
+                moduleByWasm.delete(wasm);
+        });
+    }
+    return pending;
+}
+export async function render(options, wasm) {
+    return htmlToImage(await getDefaultModule(wasm ?? htmlToImageWasm), options);
+}

package/dist/workers-dummy.d.ts

@@ -0,0 +1,12 @@
+/**
+ * workerd fallback for `./workers`: no thread pool on Workers, so jobs run
+ * directly on the workerd entry point instead of being pooled.
+ */
+export type { HtmlToImageWorker } from "./child-workers.js";
+export type { HtmlToImageOptions, OutputFormat, RenderOptions, } from "./core.js";
+export { render } from "./workerd.js";
+export declare const setLimit: (_limit: number) => void;
+export declare const close: () => void;
+export declare const waitAll: () => Promise<void>;
+export declare const waitReady: (_retryTime?: number) => Promise<void>;
+export declare const launchWorker: () => Promise<void>;

package/dist/workers-dummy.js

@@ -0,0 +1,6 @@
+export { render } from "./workerd.js";
+export const setLimit = (_limit) => { };
+export const close = () => { };
+export const waitAll = () => Promise.resolve();
+export const waitReady = (_retryTime) => Promise.resolve();
+export const launchWorker = () => Promise.resolve();