@takumi-rs/image-response 1.0.0-beta.2 → 1.0.0-beta.20

package/README.md

@@ -7,7 +7,7 @@ Checkout the migration guide [From Next.js ImageResponse](https://takumi.kane.tw
 ## Installation
 
 ```bash
-npm install @takumi-rs/image-response @takumi-rs/core @takumi-rs/helpers
+npm install @takumi-rs/image-response
 ```
 
 ## Usage
@@ -27,11 +27,31 @@ export function GET(request: Request) {
 }
 ```
 
+For shared configuration and cache isolation, create your own image response factory.
+
+```tsx
+import { createImageResponse } from "@takumi-rs/image-response";
+
+const ogImage = createImageResponse({
+  fonts: [
+    {
+      data: () => fetch("/fonts/Inter-Regular.ttf").then((res) => res.arrayBuffer()),
+      key: "inter-regular",
+      name: "Inter",
+    },
+  ],
+});
+
+export function GET() {
+  return ogImage(<OgImage />);
+}
+```
+
 ### Fonts
 
-Takumi comes with full axis [Geist](https://vercel.com/font) and Geist Mono by default.
+Takumi comes with full-axis [Geist](https://vercel.com/font) and Geist Mono by default.
 
-We have global fonts cache to avoid loading the same fonts multiple times.
+We have a global fonts cache to avoid loading the same fonts multiple times.
 
 If your environment supports top-level await, you can load the fonts in global scope and reuse the fonts array.
 
@@ -48,30 +68,27 @@ const fonts = [
 new ImageResponse(<OgImage />, { fonts });
 ```
 
-If your environment doesn't support top-level await, or just want the fonts to get garbage collected after initialization, you can load the fonts like this.
+If your environment doesn't support top-level await, you can pass a lazy `data` loader instead.
 
 ```tsx
-let isFontsLoaded = false;
-
 export function GET(request: Request) {
-  const fonts = [];
-
-  if (!isFontsLoaded) {
-    isFontsLoaded = true;
-    fonts = [
+  return new ImageResponse(<OgImage />, {
+    fonts: [
       {
         name: "Inter",
-        data: await fetch("/fonts/Inter-Regular.ttf").then((res) => res.arrayBuffer()),
+        data: () => fetch("/fonts/Inter-Regular.ttf").then((res) => res.arrayBuffer()),
         style: "normal",
         weight: 400,
       },
-    ];
-  }
-
-  return new ImageResponse(<OgImage />, { fonts });
+    ],
+  });
 }
 ```
 
+The same pattern also works for `persistentImages`. Caches are scoped to each `createImageResponse()` instance.
+
+`loadDefaultFonts` is only supported by the native `@takumi-rs/core` renderer. It has no effect when using the WASM renderer.
+
 ### Bring-Your-Own-Renderer (BYOR)
 
 If you want to use your own renderer instance, you can pass it to the `ImageResponse` constructor.
@@ -89,33 +106,28 @@ new ImageResponse(<OgImage />, { renderer });
 You can pass the JSX options to the `ImageResponse` constructor.
 
 ```tsx
-new ImageResponse(<OgImage />, { 
-  jsx: { 
+new ImageResponse(<OgImage />, {
+  jsx: {
     defaultStyles: false,
-  } 
+  },
 });
 ```
 
----
+### Error Handling
 
-## WASM Usage
+`ImageResponse` exposes a `ready` promise that resolves when rendering succeeds and rejects when rendering fails.
 
-If you want to use this package in browser environment/cloudflare, you can import from the wasm entry point.
+```tsx
+const response = new ImageResponse(<OgImage />);
 
-Make sure you have the `@takumi-rs/wasm` package installed as well.
+await response.ready;
+return response;
+```
 
-Check the additional [bundler setup section](https://takumi.kane.tw/docs#additional-bundler-setup) for more setup details.
+You can also provide `onError` to render a fallback image instead of failing the response stream.
 
 ```tsx
-import { describe, expect, test } from "bun:test";
-import { ImageResponse } from "@takumi-rs/image-response/wasm";
-import module from "@takumi-rs/wasm/next";
-
-export default {
-  fetch() {
-    return new ImageResponse(<div>Hello</div>, {
-      module,
-    });
-  }
-}
+const response = new ImageResponse(<OgImage />, {
+  onError: () => <div>Failed to generate image</div>,
+});
 ```

package/dist/response.cjs

@@ -0,0 +1,291 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+
+// src/response.tsx
+var response_exports = {};
+__export(response_exports, {
+  ImageResponse: () => ImageResponse,
+  createImageResponse: () => createImageResponse,
+  default: () => response_default
+});
+module.exports = __toCommonJS(response_exports);
+var import_helpers = require("@takumi-rs/helpers"), import_emoji = require("@takumi-rs/helpers/emoji"), import_jsx = require("@takumi-rs/helpers/jsx");
+
+// src/cache.ts
+function createResourceCache() {
+  return {
+    functionDataCache: /* @__PURE__ */ new WeakMap(),
+    loadedFontKeys: /* @__PURE__ */ new Set(),
+    loadedFontObjects: /* @__PURE__ */ new WeakSet(),
+    loadedImageKeys: /* @__PURE__ */ new Set(),
+    loadedImageObjects: /* @__PURE__ */ new WeakSet(),
+    promiseDataCache: /* @__PURE__ */ new WeakMap(),
+    stringDataCache: /* @__PURE__ */ new Map()
+  };
+}
+function getOrCreateStringDataCache(cache, key, load) {
+  let cached = cache.stringDataCache.get(key);
+  if (cached)
+    return cached;
+  let pending = Promise.resolve(load()).catch((error) => {
+    throw cache.stringDataCache.delete(key), error;
+  });
+  return cache.stringDataCache.set(key, pending), pending;
+}
+function getOrCreateFunctionDataCache(cache, loader) {
+  let cached = cache.functionDataCache.get(loader);
+  if (cached)
+    return cached;
+  let pending = Promise.resolve(loader()).catch((error) => {
+    throw cache.functionDataCache.delete(loader), error;
+  });
+  return cache.functionDataCache.set(loader, pending), pending;
+}
+function getOrCreatePromiseDataCache(cache, promise) {
+  let cached = cache.promiseDataCache.get(promise);
+  if (cached)
+    return cached;
+  let pending = promise.catch((error) => {
+    throw cache.promiseDataCache.delete(promise), error;
+  });
+  return cache.promiseDataCache.set(promise, pending), pending;
+}
+function hasBinaryData(value) {
+  return value instanceof Uint8Array || value instanceof ArrayBuffer;
+}
+function createFontCacheKey(font) {
+  return hasBinaryData(font) ? font : font.key ? `font:${font.key}` : font;
+}
+function createImageCacheKey(image) {
+  return image.key ? `image:${image.key}` : image;
+}
+async function resolveData(cache, data, cacheKey) {
+  return typeof data == "function" ? cacheKey ? getOrCreateStringDataCache(cache, cacheKey, data) : getOrCreateFunctionDataCache(cache, data) : data instanceof Promise ? cacheKey ? getOrCreateStringDataCache(cache, cacheKey, () => data) : getOrCreatePromiseDataCache(cache, data) : data;
+}
+async function resolveFont(cache, font) {
+  if (hasBinaryData(font))
+    return font;
+  let cacheKey = createFontCacheKey(font);
+  return {
+    ...font,
+    data: await resolveData(cache, font.data, typeof cacheKey == "string" ? cacheKey : void 0)
+  };
+}
+async function resolvePersistentImage(cache, image) {
+  let cacheKey = createImageCacheKey(image);
+  return {
+    ...image,
+    data: await resolveData(cache, image.data, typeof cacheKey == "string" ? cacheKey : void 0)
+  };
+}
+
+// src/import.ts
+var wasm = __toESM(require("@takumi-rs/wasm"), 1), importPromise = null;
+function getImports(module2) {
+  return importPromise ??= getImportsImpl(module2), importPromise;
+}
+async function getImportsImpl(module2) {
+  if (module2)
+    return initializeWasm(module2);
+  let importedModule = await importBindings();
+  return importedModule && "Renderer" in importedModule ? importedModule : initializeWasm(importedModule);
+}
+async function initializeWasm(module2) {
+  let wasmModule = module2 !== void 0 && typeof module2 == "object" && "default" in module2 ? module2.default : module2;
+  try {
+    return await wasm.default(wasmModule ? { module_or_path: wasmModule } : void 0), wasm;
+  } catch (error) {
+    throw new Error(
+      "Couldn't automatically resolve Takumi native bindings. Please specify the module option with the WASM module.",
+      {
+        cause: error
+      }
+    );
+  }
+}
+async function importBindings() {
+  if (shouldSkipCoreImport())
+    return importWasmBindings();
+  try {
+    return await import("@takumi-rs/core");
+  } catch (error) {
+    console.warn(
+      "Unable to import @takumi-rs/core. Falling back to auto-detection of WASM bindings.",
+      {
+        cause: error
+      }
+    );
+  }
+  return importWasmBindings();
+}
+async function importWasmBindings() {
+  let nextPath = "@takumi-rs/wasm/next";
+  return typeof process < "u" && process.env.NEXT_RUNTIME ? import(
+    /* @vite-ignore */
+    nextPath
+  ) : import(
+    /* turbopackIgnore: true */
+    /* webpackIgnore: true */
+    "@takumi-rs/wasm/auto"
+  );
+}
+function shouldSkipCoreImport() {
+  if (typeof process < "u" && process.env.NEXT_RUNTIME === "edge" || typeof window < "u" || typeof navigator < "u" && navigator.userAgent === "Cloudflare-Workers" || "WebSocketPair" in globalThis || "EdgeRuntime" in globalThis)
+    return !0;
+  let maybeWorkerGlobalScope = globalThis.WorkerGlobalScope;
+  return !!(maybeWorkerGlobalScope !== void 0 && maybeWorkerGlobalScope.prototype.isPrototypeOf(globalThis));
+}
+
+// src/response.tsx
+var defaultFormat = "webp";
+function hasLoadedResource(key, loadedKeys, loadedObjects) {
+  return typeof key == "string" ? loadedKeys.has(key) : loadedObjects.has(key);
+}
+function markLoadedResource(key, loadedKeys, loadedObjects) {
+  if (typeof key == "string") {
+    loadedKeys.add(key);
+    return;
+  }
+  loadedObjects.add(key);
+}
+function mergeOptions(defaultOptions, options) {
+  if (!defaultOptions)
+    return options;
+  if (!options)
+    return defaultOptions;
+  let headers = new Headers(defaultOptions.headers);
+  return options.headers && new Headers(options.headers).forEach((value, key) => {
+    headers.set(key, value);
+  }), "renderer" in options ? {
+    ...defaultOptions,
+    ...options,
+    headers
+  } : {
+    ...defaultOptions,
+    ...options,
+    fonts: options.fonts ?? defaultOptions.fonts,
+    headers,
+    persistentImages: options.persistentImages ?? defaultOptions.persistentImages,
+    stylesheets: [...defaultOptions.stylesheets ?? [], ...options.stylesheets ?? []]
+  };
+}
+var contentTypeMap = {
+  png: "image/png",
+  jpeg: "image/jpeg",
+  webp: "image/webp",
+  raw: "application/octet-stream"
+};
+async function renderComponent(component, options, imports, renderer) {
+  let { node: originalNode, stylesheets } = await (0, import_jsx.fromJsx)(component, options?.jsx), node = options?.emoji && options.emoji !== "from-font" ? (0, import_emoji.extractEmojis)(originalNode, options.emoji) : originalNode, fetchedResources = options?.fetchedResources !== void 0 ? options.fetchedResources : await (0, import_helpers.fetchResources)(imports.extractResourceUrls(node)), renderOptions = {
+    ...options,
+    fetchedResources,
+    format: options?.format ?? defaultFormat,
+    stylesheets: [...options?.stylesheets ?? [], ...stylesheets]
+  };
+  return renderer.render(node, renderOptions, options?.signal);
+}
+function defaultErrorHandler(error) {
+  console.error("Takumi failed to render image."), console.error(error);
+}
+async function loadRendererResources(renderer, options, cache) {
+  let tasks = [];
+  if (options?.fonts && options.fonts.length > 0) {
+    let resolvedFonts = await Promise.all(
+      options.fonts.map(async (font) => ({
+        cacheKey: createFontCacheKey(font),
+        font: await resolveFont(cache, font)
+      }))
+    );
+    if ("loadFonts" in renderer) {
+      let filteredFonts = resolvedFonts.filter(({ cacheKey }) => hasLoadedResource(cacheKey, cache.loadedFontKeys, cache.loadedFontObjects) ? !1 : (markLoadedResource(cacheKey, cache.loadedFontKeys, cache.loadedFontObjects), !0));
+      filteredFonts.length > 0 && tasks.push(renderer.loadFonts(filteredFonts.map(({ font }) => font)));
+    } else
+      for (let { cacheKey, font } of resolvedFonts)
+        hasLoadedResource(cacheKey, cache.loadedFontKeys, cache.loadedFontObjects) || (markLoadedResource(cacheKey, cache.loadedFontKeys, cache.loadedFontObjects), renderer.loadFont(font));
+  }
+  if (options?.persistentImages && options.persistentImages.length > 0) {
+    let resolvedImages = await Promise.all(
+      options.persistentImages.map(async (image) => ({
+        cacheKey: createImageCacheKey(image),
+        image: await resolvePersistentImage(cache, image)
+      }))
+    );
+    for (let { cacheKey, image } of resolvedImages) {
+      if (hasLoadedResource(cacheKey, cache.loadedImageKeys, cache.loadedImageObjects))
+        continue;
+      markLoadedResource(cacheKey, cache.loadedImageKeys, cache.loadedImageObjects);
+      let maybePromise = renderer.putPersistentImage(image, options.signal);
+      maybePromise instanceof Promise && tasks.push(maybePromise);
+    }
+  }
+  tasks.length > 0 && await Promise.all(tasks);
+}
+function createImageResponse(defaultOptions) {
+  let cache = createResourceCache();
+  return function(component, options) {
+    let mergedOptions = mergeOptions(defaultOptions, options), {
+      promise: ready,
+      reject: rejectReady,
+      resolve: resolveReady
+    } = Promise.withResolvers(), module2 = mergedOptions && "module" in mergedOptions ? mergedOptions.module : void 0, stream = new ReadableStream({
+      type: "bytes",
+      async start(controller) {
+        try {
+          let imports = await getImports(module2), isExternalRenderer = mergedOptions && "renderer" in mergedOptions, renderer = isExternalRenderer ? mergedOptions.renderer : cache.renderer ??= new imports.Renderer({
+            loadDefaultFonts: mergedOptions?.loadDefaultFonts
+          });
+          isExternalRenderer || await loadRendererResources(renderer, mergedOptions, cache);
+          let image = await renderComponent(component, mergedOptions, imports, renderer);
+          controller.enqueue(image), controller.close(), resolveReady();
+        } catch (error) {
+          controller.error(error), await (mergedOptions?.onError ?? defaultErrorHandler)(error), rejectReady(error);
+        }
+      }
+    }), headers = new Headers(mergedOptions?.headers);
+    headers.get("content-type") || headers.set("content-type", contentTypeMap[mergedOptions?.format ?? defaultFormat]);
+    let response = new Response(stream, {
+      headers,
+      status: mergedOptions?.status,
+      statusText: mergedOptions?.statusText
+    });
+    return Object.defineProperty(response, "ready", {
+      enumerable: !1,
+      value: ready,
+      writable: !1
+    });
+  };
+}
+var defaultImageResponse, ImageResponse = class extends Response {
+  ready;
+  constructor(component, options) {
+    defaultImageResponse ??= createImageResponse();
+    let response = defaultImageResponse(component, options);
+    super(response.body, response), this.ready = response.ready;
+  }
+}, response_default = ImageResponse;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ImageResponse,
+  createImageResponse
+});

package/dist/response.d.cts

@@ -0,0 +1,62 @@
+import { EmojiType } from '@takumi-rs/helpers/emoji';
+import { FromJsxOptions } from '@takumi-rs/helpers/jsx';
+import { ReactNode } from 'react';
+import * as napi from '@takumi-rs/core';
+import * as wasm from '@takumi-rs/wasm';
+
+type BinaryData = Uint8Array | ArrayBuffer;
+type BinaryDataLoader = BinaryData | Promise<BinaryData> | (() => BinaryData | Promise<BinaryData>);
+type ImageResponseFont = BinaryData | {
+    data: BinaryDataLoader;
+    key?: string;
+    name?: string;
+    style?: napi.FontDetails["style"] | wasm.FontDetails["style"];
+    weight?: number;
+};
+type ImageResponsePersistentImage = {
+    data: BinaryDataLoader;
+    key?: string;
+    src: string;
+};
+
+declare module "react" {
+    interface DOMAttributes<T> {
+        tw?: string;
+    }
+}
+type RenderOptions = napi.RenderOptions | wasm.RenderOptions;
+type ManagedRendererOptions = {
+    fonts?: ImageResponseFont[];
+    /**
+     * Only supported by the native `@takumi-rs/core` renderer.
+     * This option is ignored when using the WASM renderer.
+     */
+    loadDefaultFonts?: boolean;
+    persistentImages?: ImageResponsePersistentImage[];
+    /**
+     * @description The WebAssembly module to use for the renderer. If not provided, the default resolving strategy will be used.
+     */
+    module?: wasm.InitInput | Promise<wasm.InitInput> | {
+        default: wasm.InitInput;
+    };
+};
+type ImageResponseOptionsWithRenderer = ResponseInit & RenderOptions & {
+    renderer: napi.Renderer | wasm.Renderer;
+    signal?: AbortSignal;
+    jsx?: FromJsxOptions;
+    emoji?: EmojiType | "from-font";
+    onError?: (error: unknown) => void | Promise<void>;
+};
+type ImageResponseOptionsWithoutRenderer = Omit<ImageResponseOptionsWithRenderer, "renderer"> & ManagedRendererOptions;
+type ImageResponseOptions = ImageResponseOptionsWithRenderer | ImageResponseOptionsWithoutRenderer;
+type ImageResponseResult = Response & {
+    readonly ready: Promise<void>;
+};
+type ImageResponseFactory = (component: ReactNode, options?: ImageResponseOptions) => ImageResponseResult;
+declare function createImageResponse(defaultOptions?: ImageResponseOptionsWithoutRenderer): ImageResponseFactory;
+declare class ImageResponse extends Response {
+    readonly ready: Promise<void>;
+    constructor(component: ReactNode, options?: ImageResponseOptions);
+}
+
+export { ImageResponse, type ImageResponseFactory, type ImageResponseOptions, type ImageResponseOptionsWithoutRenderer, type ImageResponseResult, createImageResponse, ImageResponse as default };

package/dist/response.d.ts

@@ -0,0 +1,62 @@
+import { EmojiType } from '@takumi-rs/helpers/emoji';
+import { FromJsxOptions } from '@takumi-rs/helpers/jsx';
+import { ReactNode } from 'react';
+import * as napi from '@takumi-rs/core';
+import * as wasm from '@takumi-rs/wasm';
+
+type BinaryData = Uint8Array | ArrayBuffer;
+type BinaryDataLoader = BinaryData | Promise<BinaryData> | (() => BinaryData | Promise<BinaryData>);
+type ImageResponseFont = BinaryData | {
+    data: BinaryDataLoader;
+    key?: string;
+    name?: string;
+    style?: napi.FontDetails["style"] | wasm.FontDetails["style"];
+    weight?: number;
+};
+type ImageResponsePersistentImage = {
+    data: BinaryDataLoader;
+    key?: string;
+    src: string;
+};
+
+declare module "react" {
+    interface DOMAttributes<T> {
+        tw?: string;
+    }
+}
+type RenderOptions = napi.RenderOptions | wasm.RenderOptions;
+type ManagedRendererOptions = {
+    fonts?: ImageResponseFont[];
+    /**
+     * Only supported by the native `@takumi-rs/core` renderer.
+     * This option is ignored when using the WASM renderer.
+     */
+    loadDefaultFonts?: boolean;
+    persistentImages?: ImageResponsePersistentImage[];
+    /**
+     * @description The WebAssembly module to use for the renderer. If not provided, the default resolving strategy will be used.
+     */
+    module?: wasm.InitInput | Promise<wasm.InitInput> | {
+        default: wasm.InitInput;
+    };
+};
+type ImageResponseOptionsWithRenderer = ResponseInit & RenderOptions & {
+    renderer: napi.Renderer | wasm.Renderer;
+    signal?: AbortSignal;
+    jsx?: FromJsxOptions;
+    emoji?: EmojiType | "from-font";
+    onError?: (error: unknown) => void | Promise<void>;
+};
+type ImageResponseOptionsWithoutRenderer = Omit<ImageResponseOptionsWithRenderer, "renderer"> & ManagedRendererOptions;
+type ImageResponseOptions = ImageResponseOptionsWithRenderer | ImageResponseOptionsWithoutRenderer;
+type ImageResponseResult = Response & {
+    readonly ready: Promise<void>;
+};
+type ImageResponseFactory = (component: ReactNode, options?: ImageResponseOptions) => ImageResponseResult;
+declare function createImageResponse(defaultOptions?: ImageResponseOptionsWithoutRenderer): ImageResponseFactory;
+declare class ImageResponse extends Response {
+    readonly ready: Promise<void>;
+    constructor(component: ReactNode, options?: ImageResponseOptions);
+}
+
+export { ImageResponse, type ImageResponseFactory, type ImageResponseOptions, type ImageResponseOptionsWithoutRenderer, type ImageResponseResult, createImageResponse, ImageResponse as default };

package/dist/response.js

@@ -0,0 +1,263 @@
+// src/response.tsx
+import { fetchResources } from "@takumi-rs/helpers";
+import { extractEmojis } from "@takumi-rs/helpers/emoji";
+import { fromJsx } from "@takumi-rs/helpers/jsx";
+
+// src/cache.ts
+function createResourceCache() {
+  return {
+    functionDataCache: /* @__PURE__ */ new WeakMap(),
+    loadedFontKeys: /* @__PURE__ */ new Set(),
+    loadedFontObjects: /* @__PURE__ */ new WeakSet(),
+    loadedImageKeys: /* @__PURE__ */ new Set(),
+    loadedImageObjects: /* @__PURE__ */ new WeakSet(),
+    promiseDataCache: /* @__PURE__ */ new WeakMap(),
+    stringDataCache: /* @__PURE__ */ new Map()
+  };
+}
+function getOrCreateStringDataCache(cache, key, load) {
+  let cached = cache.stringDataCache.get(key);
+  if (cached)
+    return cached;
+  let pending = Promise.resolve(load()).catch((error) => {
+    throw cache.stringDataCache.delete(key), error;
+  });
+  return cache.stringDataCache.set(key, pending), pending;
+}
+function getOrCreateFunctionDataCache(cache, loader) {
+  let cached = cache.functionDataCache.get(loader);
+  if (cached)
+    return cached;
+  let pending = Promise.resolve(loader()).catch((error) => {
+    throw cache.functionDataCache.delete(loader), error;
+  });
+  return cache.functionDataCache.set(loader, pending), pending;
+}
+function getOrCreatePromiseDataCache(cache, promise) {
+  let cached = cache.promiseDataCache.get(promise);
+  if (cached)
+    return cached;
+  let pending = promise.catch((error) => {
+    throw cache.promiseDataCache.delete(promise), error;
+  });
+  return cache.promiseDataCache.set(promise, pending), pending;
+}
+function hasBinaryData(value) {
+  return value instanceof Uint8Array || value instanceof ArrayBuffer;
+}
+function createFontCacheKey(font) {
+  return hasBinaryData(font) ? font : font.key ? `font:${font.key}` : font;
+}
+function createImageCacheKey(image) {
+  return image.key ? `image:${image.key}` : image;
+}
+async function resolveData(cache, data, cacheKey) {
+  return typeof data == "function" ? cacheKey ? getOrCreateStringDataCache(cache, cacheKey, data) : getOrCreateFunctionDataCache(cache, data) : data instanceof Promise ? cacheKey ? getOrCreateStringDataCache(cache, cacheKey, () => data) : getOrCreatePromiseDataCache(cache, data) : data;
+}
+async function resolveFont(cache, font) {
+  if (hasBinaryData(font))
+    return font;
+  let cacheKey = createFontCacheKey(font);
+  return {
+    ...font,
+    data: await resolveData(cache, font.data, typeof cacheKey == "string" ? cacheKey : void 0)
+  };
+}
+async function resolvePersistentImage(cache, image) {
+  let cacheKey = createImageCacheKey(image);
+  return {
+    ...image,
+    data: await resolveData(cache, image.data, typeof cacheKey == "string" ? cacheKey : void 0)
+  };
+}
+
+// src/import.ts
+import * as wasm from "@takumi-rs/wasm";
+var importPromise = null;
+function getImports(module) {
+  return importPromise ??= getImportsImpl(module), importPromise;
+}
+async function getImportsImpl(module) {
+  if (module)
+    return initializeWasm(module);
+  let importedModule = await importBindings();
+  return importedModule && "Renderer" in importedModule ? importedModule : initializeWasm(importedModule);
+}
+async function initializeWasm(module) {
+  let wasmModule = module !== void 0 && typeof module == "object" && "default" in module ? module.default : module;
+  try {
+    return await wasm.default(wasmModule ? { module_or_path: wasmModule } : void 0), wasm;
+  } catch (error) {
+    throw new Error(
+      "Couldn't automatically resolve Takumi native bindings. Please specify the module option with the WASM module.",
+      {
+        cause: error
+      }
+    );
+  }
+}
+async function importBindings() {
+  if (shouldSkipCoreImport())
+    return importWasmBindings();
+  try {
+    return await import("@takumi-rs/core");
+  } catch (error) {
+    console.warn(
+      "Unable to import @takumi-rs/core. Falling back to auto-detection of WASM bindings.",
+      {
+        cause: error
+      }
+    );
+  }
+  return importWasmBindings();
+}
+async function importWasmBindings() {
+  let nextPath = "@takumi-rs/wasm/next";
+  return typeof process < "u" && process.env.NEXT_RUNTIME ? import(
+    /* @vite-ignore */
+    nextPath
+  ) : import(
+    /* turbopackIgnore: true */
+    /* webpackIgnore: true */
+    "@takumi-rs/wasm/auto"
+  );
+}
+function shouldSkipCoreImport() {
+  if (typeof process < "u" && process.env.NEXT_RUNTIME === "edge" || typeof window < "u" || typeof navigator < "u" && navigator.userAgent === "Cloudflare-Workers" || "WebSocketPair" in globalThis || "EdgeRuntime" in globalThis)
+    return !0;
+  let maybeWorkerGlobalScope = globalThis.WorkerGlobalScope;
+  return !!(maybeWorkerGlobalScope !== void 0 && maybeWorkerGlobalScope.prototype.isPrototypeOf(globalThis));
+}
+
+// src/response.tsx
+var defaultFormat = "webp";
+function hasLoadedResource(key, loadedKeys, loadedObjects) {
+  return typeof key == "string" ? loadedKeys.has(key) : loadedObjects.has(key);
+}
+function markLoadedResource(key, loadedKeys, loadedObjects) {
+  if (typeof key == "string") {
+    loadedKeys.add(key);
+    return;
+  }
+  loadedObjects.add(key);
+}
+function mergeOptions(defaultOptions, options) {
+  if (!defaultOptions)
+    return options;
+  if (!options)
+    return defaultOptions;
+  let headers = new Headers(defaultOptions.headers);
+  return options.headers && new Headers(options.headers).forEach((value, key) => {
+    headers.set(key, value);
+  }), "renderer" in options ? {
+    ...defaultOptions,
+    ...options,
+    headers
+  } : {
+    ...defaultOptions,
+    ...options,
+    fonts: options.fonts ?? defaultOptions.fonts,
+    headers,
+    persistentImages: options.persistentImages ?? defaultOptions.persistentImages,
+    stylesheets: [...defaultOptions.stylesheets ?? [], ...options.stylesheets ?? []]
+  };
+}
+var contentTypeMap = {
+  png: "image/png",
+  jpeg: "image/jpeg",
+  webp: "image/webp",
+  raw: "application/octet-stream"
+};
+async function renderComponent(component, options, imports, renderer) {
+  let { node: originalNode, stylesheets } = await fromJsx(component, options?.jsx), node = options?.emoji && options.emoji !== "from-font" ? extractEmojis(originalNode, options.emoji) : originalNode, fetchedResources = options?.fetchedResources !== void 0 ? options.fetchedResources : await fetchResources(imports.extractResourceUrls(node)), renderOptions = {
+    ...options,
+    fetchedResources,
+    format: options?.format ?? defaultFormat,
+    stylesheets: [...options?.stylesheets ?? [], ...stylesheets]
+  };
+  return renderer.render(node, renderOptions, options?.signal);
+}
+function defaultErrorHandler(error) {
+  console.error("Takumi failed to render image."), console.error(error);
+}
+async function loadRendererResources(renderer, options, cache) {
+  let tasks = [];
+  if (options?.fonts && options.fonts.length > 0) {
+    let resolvedFonts = await Promise.all(
+      options.fonts.map(async (font) => ({
+        cacheKey: createFontCacheKey(font),
+        font: await resolveFont(cache, font)
+      }))
+    );
+    if ("loadFonts" in renderer) {
+      let filteredFonts = resolvedFonts.filter(({ cacheKey }) => hasLoadedResource(cacheKey, cache.loadedFontKeys, cache.loadedFontObjects) ? !1 : (markLoadedResource(cacheKey, cache.loadedFontKeys, cache.loadedFontObjects), !0));
+      filteredFonts.length > 0 && tasks.push(renderer.loadFonts(filteredFonts.map(({ font }) => font)));
+    } else
+      for (let { cacheKey, font } of resolvedFonts)
+        hasLoadedResource(cacheKey, cache.loadedFontKeys, cache.loadedFontObjects) || (markLoadedResource(cacheKey, cache.loadedFontKeys, cache.loadedFontObjects), renderer.loadFont(font));
+  }
+  if (options?.persistentImages && options.persistentImages.length > 0) {
+    let resolvedImages = await Promise.all(
+      options.persistentImages.map(async (image) => ({
+        cacheKey: createImageCacheKey(image),
+        image: await resolvePersistentImage(cache, image)
+      }))
+    );
+    for (let { cacheKey, image } of resolvedImages) {
+      if (hasLoadedResource(cacheKey, cache.loadedImageKeys, cache.loadedImageObjects))
+        continue;
+      markLoadedResource(cacheKey, cache.loadedImageKeys, cache.loadedImageObjects);
+      let maybePromise = renderer.putPersistentImage(image, options.signal);
+      maybePromise instanceof Promise && tasks.push(maybePromise);
+    }
+  }
+  tasks.length > 0 && await Promise.all(tasks);
+}
+function createImageResponse(defaultOptions) {
+  let cache = createResourceCache();
+  return function(component, options) {
+    let mergedOptions = mergeOptions(defaultOptions, options), {
+      promise: ready,
+      reject: rejectReady,
+      resolve: resolveReady
+    } = Promise.withResolvers(), module = mergedOptions && "module" in mergedOptions ? mergedOptions.module : void 0, stream = new ReadableStream({
+      type: "bytes",
+      async start(controller) {
+        try {
+          let imports = await getImports(module), isExternalRenderer = mergedOptions && "renderer" in mergedOptions, renderer = isExternalRenderer ? mergedOptions.renderer : cache.renderer ??= new imports.Renderer({
+            loadDefaultFonts: mergedOptions?.loadDefaultFonts
+          });
+          isExternalRenderer || await loadRendererResources(renderer, mergedOptions, cache);
+          let image = await renderComponent(component, mergedOptions, imports, renderer);
+          controller.enqueue(image), controller.close(), resolveReady();
+        } catch (error) {
+          controller.error(error), await (mergedOptions?.onError ?? defaultErrorHandler)(error), rejectReady(error);
+        }
+      }
+    }), headers = new Headers(mergedOptions?.headers);
+    headers.get("content-type") || headers.set("content-type", contentTypeMap[mergedOptions?.format ?? defaultFormat]);
+    let response = new Response(stream, {
+      headers,
+      status: mergedOptions?.status,
+      statusText: mergedOptions?.statusText
+    });
+    return Object.defineProperty(response, "ready", {
+      enumerable: !1,
+      value: ready,
+      writable: !1
+    });
+  };
+}
+var defaultImageResponse, ImageResponse = class extends Response {
+  ready;
+  constructor(component, options) {
+    defaultImageResponse ??= createImageResponse();
+    let response = defaultImageResponse(component, options);
+    super(response.body, response), this.ready = response.ready;
+  }
+}, response_default = ImageResponse;
+export {
+  ImageResponse,
+  createImageResponse,
+  response_default as default
+};

package/package.json

@@ -1,53 +1,53 @@
 {
   "name": "@takumi-rs/image-response",
-  "type": "module",
-  "version": "1.0.0-beta.2",
+  "version": "1.0.0-beta.20",
+  "license": "(MIT OR Apache-2.0)",
   "author": {
-    "email": "me@kane.tw",
     "name": "Kane Wang",
+    "email": "me@kane.tw",
     "url": "https://kane.tw"
   },
   "repository": {
     "url": "git+https://github.com/kane50613/takumi.git"
   },
-  "dependencies": {
-    "@takumi-rs/core": "1.0.0-beta.2",
-    "@takumi-rs/helpers": "1.0.0-beta.2",
-    "@takumi-rs/wasm": "1.0.0-beta.2"
-  },
-  "devDependencies": {
-    "@types/bun": "catalog:",
-    "@types/react": "catalog:",
-    "@types/react-dom": "catalog:",
-    "react": "catalog:",
-    "react-dom": "catalog:",
-    "tsup": "^8.5.1",
-    "type-fest": "^5.4.4",
-    "typescript": "catalog:"
-  },
-  "scripts": {
-    "build": "tsup-node src/backends/*.ts --clean --minify --dts --format esm,cjs --no-splitting",
-    "prepublishOnly": "jq '.dependencies[\"@takumi-rs/core\"] = .version | .dependencies[\"@takumi-rs/helpers\"] = .version | .dependencies[\"@takumi-rs/wasm\"] = .version' package.json > tmp.json && mv tmp.json package.json"
-  },
   "files": [
     "dist",
     "package.json",
     "README.md",
     "tsconfig.json"
   ],
+  "type": "module",
   "exports": {
     ".": {
-      "types": "./dist/node.d.ts",
-      "import": "./dist/node.js",
-      "require": "./dist/node.cjs",
-      "default": "./dist/node.js"
+      "types": "./dist/response.d.ts",
+      "import": "./dist/response.js",
+      "require": "./dist/response.cjs",
+      "default": "./dist/response.js"
     },
     "./wasm": {
-      "types": "./dist/wasm.d.ts",
-      "import": "./dist/wasm.js",
-      "require": "./dist/wasm.cjs",
-      "default": "./dist/wasm.js"
+      "types": "./dist/response.d.ts",
+      "import": "./dist/response.js",
+      "require": "./dist/response.cjs",
+      "default": "./dist/response.js"
     }
   },
-  "license": "(MIT OR Apache-2.0)"
+  "scripts": {
+    "build": "tsup-node src/response.tsx --clean --minify-syntax --dts --format esm,cjs --no-splitting",
+    "prepublishOnly": "jq '.dependencies[\"@takumi-rs/core\"] = .version | .dependencies[\"@takumi-rs/helpers\"] = .version | .dependencies[\"@takumi-rs/wasm\"] = .version' package.json > tmp.json && mv tmp.json package.json"
+  },
+  "dependencies": {
+    "@takumi-rs/core": "1.0.0-beta.20",
+    "@takumi-rs/helpers": "1.0.0-beta.20",
+    "@takumi-rs/wasm": "1.0.0-beta.20"
+  },
+  "devDependencies": {
+    "@types/bun": "catalog:",
+    "@types/react": "catalog:",
+    "@types/react-dom": "catalog:",
+    "react": "catalog:",
+    "react-dom": "catalog:",
+    "tsup": "^8.5.1",
+    "type-fest": "^5.5.0",
+    "typescript": "catalog:"
+  }
 }

package/dist/node.cjs

@@ -1 +0,0 @@
-"use strict";var m=Object.defineProperty;var w=Object.getOwnPropertyDescriptor;var x=Object.getOwnPropertyNames;var j=Object.prototype.hasOwnProperty;var I=(t,e)=>{for(var r in e)m(t,r,{get:e[r],enumerable:!0})},b=(t,e,r,s)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of x(e))!j.call(t,n)&&n!==r&&m(t,n,{get:()=>e[n],enumerable:!(s=w(e,n))||s.enumerable});return t};var P=t=>b(m({},"__esModule",{value:!0}),t);var J={};I(J,{ImageResponse:()=>o,default:()=>E});module.exports=P(J);var c=require("@takumi-rs/core"),d=require("@takumi-rs/helpers"),p=require("@takumi-rs/helpers/emoji"),u=require("@takumi-rs/helpers/jsx"),a,T={format:"webp"};async function A(t){if(t&&"renderer"in t)return t.renderer;if(!a)return a=new c.Renderer(t),a;let e=[],r=a;return r?(t?.fonts&&t.fonts.length>0&&e.push(r.loadFonts(t.fonts)),t?.persistentImages&&e.push(...t.persistentImages.map(s=>r.putPersistentImage(s.src,s.data))),e.length>0&&await Promise.all(e),r):a}function F(t,e){if(e?.fetchedResources)return e.fetchedResources;let r=(0,c.extractResourceUrls)(t);return(0,d.fetchResources)(r)}function N(t,e){return new ReadableStream({type:"bytes",async start(r){try{let s=(0,u.fromJsx)(t,e?.jsx).then(async({node:i,stylesheets:l})=>{e?.emoji&&e.emoji!=="from-font"&&(i=(0,p.extractEmojis)(i,e.emoji));let O=await F(i,e);return{node:i,fetchedResources:O,stylesheets:l}}),[n,{node:f,fetchedResources:R,stylesheets:g}]=await Promise.all([A(e),s]),h={width:e?.width,height:e?.height,format:e?.format,quality:e?.quality,dithering:e?.dithering,drawDebugBorder:e?.drawDebugBorder,devicePixelRatio:e?.devicePixelRatio,fetchedResources:R,stylesheets:[...e?.stylesheets??[],...g]},y=await n.render(f,h,e?.signal);r.enqueue(y),r.close()}catch(s){r.error(s)}}})}var B={webp:"image/webp",png:"image/png",jpeg:"image/jpeg",raw:"application/octet-stream"},o=class extends Response{constructor(e,r){let s=N(e,r),n=new Headers(r?.headers);n.get("content-type")||n.set("content-type",B[r?.format??T.format]),super(s,{status:r?.status,statusText:r?.statusText,headers:n})}},E=o;0&&(module.exports={ImageResponse});

package/dist/node.d.cts

@@ -1,27 +0,0 @@
-import { RenderOptions, Renderer, ConstructRendererOptions } from '@takumi-rs/core';
-import { EmojiType } from '@takumi-rs/helpers/emoji';
-import { FromJsxOptions } from '@takumi-rs/helpers/jsx';
-import { ReactNode } from 'react';
-
-declare module "react" {
-    interface DOMAttributes<T> {
-        tw?: string;
-    }
-}
-type ImageResponseOptionsWithRenderer = ResponseInit & RenderOptions & {
-    renderer: Renderer;
-    signal?: AbortSignal;
-    jsx?: FromJsxOptions;
-    emoji?: EmojiType | "from-font";
-};
-type ImageResponseOptionsWithoutRenderer = ResponseInit & RenderOptions & ConstructRendererOptions & {
-    signal?: AbortSignal;
-    jsx?: FromJsxOptions;
-    emoji?: EmojiType | "from-font";
-};
-type ImageResponseOptions = ImageResponseOptionsWithRenderer | ImageResponseOptionsWithoutRenderer;
-declare class ImageResponse extends Response {
-    constructor(component: ReactNode, options?: ImageResponseOptions);
-}
-
-export { ImageResponse, type ImageResponseOptions, ImageResponse as default };

package/dist/node.d.ts

@@ -1,27 +0,0 @@
-import { RenderOptions, Renderer, ConstructRendererOptions } from '@takumi-rs/core';
-import { EmojiType } from '@takumi-rs/helpers/emoji';
-import { FromJsxOptions } from '@takumi-rs/helpers/jsx';
-import { ReactNode } from 'react';
-
-declare module "react" {
-    interface DOMAttributes<T> {
-        tw?: string;
-    }
-}
-type ImageResponseOptionsWithRenderer = ResponseInit & RenderOptions & {
-    renderer: Renderer;
-    signal?: AbortSignal;
-    jsx?: FromJsxOptions;
-    emoji?: EmojiType | "from-font";
-};
-type ImageResponseOptionsWithoutRenderer = ResponseInit & RenderOptions & ConstructRendererOptions & {
-    signal?: AbortSignal;
-    jsx?: FromJsxOptions;
-    emoji?: EmojiType | "from-font";
-};
-type ImageResponseOptions = ImageResponseOptionsWithRenderer | ImageResponseOptionsWithoutRenderer;
-declare class ImageResponse extends Response {
-    constructor(component: ReactNode, options?: ImageResponseOptions);
-}
-
-export { ImageResponse, type ImageResponseOptions, ImageResponse as default };

package/dist/node.js

@@ -1 +0,0 @@
-import{extractResourceUrls as g,Renderer as h}from"@takumi-rs/core";import{fetchResources as y}from"@takumi-rs/helpers";import{extractEmojis as l}from"@takumi-rs/helpers/emoji";import{fromJsx as O}from"@takumi-rs/helpers/jsx";var a,w={format:"webp"};async function x(r){if(r&&"renderer"in r)return r.renderer;if(!a)return a=new h(r),a;let e=[],t=a;return t?(r?.fonts&&r.fonts.length>0&&e.push(t.loadFonts(r.fonts)),r?.persistentImages&&e.push(...r.persistentImages.map(s=>t.putPersistentImage(s.src,s.data))),e.length>0&&await Promise.all(e),t):a}function j(r,e){if(e?.fetchedResources)return e.fetchedResources;let t=g(r);return y(t)}function I(r,e){return new ReadableStream({type:"bytes",async start(t){try{let s=O(r,e?.jsx).then(async({node:i,stylesheets:f})=>{e?.emoji&&e.emoji!=="from-font"&&(i=l(i,e.emoji));let R=await j(i,e);return{node:i,fetchedResources:R,stylesheets:f}}),[n,{node:c,fetchedResources:m,stylesheets:d}]=await Promise.all([x(e),s]),p={width:e?.width,height:e?.height,format:e?.format,quality:e?.quality,dithering:e?.dithering,drawDebugBorder:e?.drawDebugBorder,devicePixelRatio:e?.devicePixelRatio,fetchedResources:m,stylesheets:[...e?.stylesheets??[],...d]},u=await n.render(c,p,e?.signal);t.enqueue(u),t.close()}catch(s){t.error(s)}}})}var b={webp:"image/webp",png:"image/png",jpeg:"image/jpeg",raw:"application/octet-stream"},o=class extends Response{constructor(e,t){let s=I(e,t),n=new Headers(t?.headers);n.get("content-type")||n.set("content-type",b[t?.format??w.format]),super(s,{status:t?.status,statusText:t?.statusText,headers:n})}},N=o;export{o as ImageResponse,N as default};

package/dist/wasm.cjs

@@ -1 +0,0 @@
-"use strict";var g=Object.create;var p=Object.defineProperty;var y=Object.getOwnPropertyDescriptor;var I=Object.getOwnPropertyNames;var O=Object.getPrototypeOf,h=Object.prototype.hasOwnProperty;var j=(e,t)=>{for(var s in t)p(e,s,{get:t[s],enumerable:!0})},f=(e,t,s,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let r of I(t))!h.call(e,r)&&r!==s&&p(e,r,{get:()=>t[r],enumerable:!(n=y(t,r))||n.enumerable});return e};var w=(e,t,s)=>(s=e!=null?g(O(e)):{},f(t||!e||!e.__esModule?p(s,"default",{value:e,enumerable:!0}):s,e)),x=e=>f(p({},"__esModule",{value:!0}),e);var E={};j(E,{ImageResponse:()=>m,default:()=>A});module.exports=x(E);var u=require("@takumi-rs/helpers"),d=require("@takumi-rs/helpers/emoji"),l=require("@takumi-rs/helpers/jsx"),a=w(require("@takumi-rs/wasm/no-bundler"),1),o;function b(e){if(e&&"renderer"in e)return e.renderer;if(!o)return o=new a.Renderer(e),o;if(e?.fonts)for(let t of e.fonts)o.loadFont(t);if(e?.persistentImages)for(let t of e.persistentImages)o.putPersistentImage(t);return o}var c=null;async function T(e){!("module"in e)||o||(c||(c=(async()=>{let t=await e.module;typeof t=="object"&&"default"in t&&(t=t.default),await(0,a.default)({module_or_path:t})})()),await c)}async function F(e,t){let s={...t},{node:n,stylesheets:r}=await(0,l.fromJsx)(e,s.jsx);if(s.stylesheets=[...s.stylesheets??[],...r],s.emoji&&s.emoji!=="from-font"&&(n=(0,d.extractEmojis)(n,s.emoji)),!s.fetchedResources){let i=(0,a.extractResourceUrls)(n);i.length>0&&(s.fetchedResources=await(0,u.fetchResources)(i))}return{node:n,options:s}}function N(e,t){return new ReadableStream({type:"bytes",async start(s){try{await T(t);let n=b(t),{node:r,options:i}=await F(e,t),R=n.render(r,i);s.enqueue(R),s.close()}catch(n){s.error(n)}}})}var P={png:"image/png",jpeg:"image/jpeg",webp:"image/webp",raw:"application/octet-stream"},W={format:"webp"},m=class extends Response{constructor(t,s){let n=N(t,s),r=new Headers(s.headers);r.get("content-type")||r.set("content-type",P[s.format??W.format]),super(n,{status:s.status,statusText:s.statusText,headers:r})}},A=m;0&&(module.exports={ImageResponse});

package/dist/wasm.d.cts

@@ -1,58 +0,0 @@
-import { EmojiType } from '@takumi-rs/helpers/emoji';
-import { FromJsxOptions } from '@takumi-rs/helpers/jsx';
-import { RenderOptions, Renderer, InitInput, Font, ImageSource } from '@takumi-rs/wasm/no-bundler';
-import { ReactNode } from 'react';
-
-declare module "react" {
-    interface DOMAttributes<T> {
-        tw?: string;
-    }
-}
-type ModuleOptions = {
-    /**
-     * @description The WebAssembly module to use for the renderer.
-     *
-     * @example
-     * For Cloudflare Workers, you can use the bundled WASM file.
-     * ```ts
-     * {
-     *   module: import("@takumi-rs/wasm/takumi_wasm_bg.wasm"),
-     * }
-     * ```
-     *
-     * For Next.js Turbopack, you can use the nextjs helper.
-     * ```ts
-     * {
-     *   module: import("@takumi-rs/wasm/next"),
-     * }
-     * ```
-     *
-     * For Vite, use `?url` suffix to get the URL of the WASM file.
-     *
-     * ```ts
-     * {
-     *   module: import("@takumi-rs/wasm/takumi_wasm_bg.wasm?url"),
-     * }
-     * ```
-     */
-    module: InitInput | Promise<InitInput> | {
-        default: InitInput;
-    };
-};
-type ImageResponseOptionsWithRenderer = ResponseInit & RenderOptions & {
-    renderer: Renderer;
-    jsx?: FromJsxOptions;
-    emoji?: EmojiType | "from-font";
-};
-type ImageResponseOptionsWithoutRenderer = ResponseInit & RenderOptions & ModuleOptions & {
-    fonts?: Font[];
-    persistentImages?: ImageSource[];
-    jsx?: FromJsxOptions;
-    emoji?: EmojiType | "from-font";
-};
-type ImageResponseOptions = ImageResponseOptionsWithRenderer | ImageResponseOptionsWithoutRenderer;
-declare class ImageResponse extends Response {
-    constructor(component: ReactNode, options: ImageResponseOptions);
-}
-
-export { ImageResponse, type ImageResponseOptions, ImageResponse as default };

package/dist/wasm.d.ts

@@ -1,58 +0,0 @@
-import { EmojiType } from '@takumi-rs/helpers/emoji';
-import { FromJsxOptions } from '@takumi-rs/helpers/jsx';
-import { RenderOptions, Renderer, InitInput, Font, ImageSource } from '@takumi-rs/wasm/no-bundler';
-import { ReactNode } from 'react';
-
-declare module "react" {
-    interface DOMAttributes<T> {
-        tw?: string;
-    }
-}
-type ModuleOptions = {
-    /**
-     * @description The WebAssembly module to use for the renderer.
-     *
-     * @example
-     * For Cloudflare Workers, you can use the bundled WASM file.
-     * ```ts
-     * {
-     *   module: import("@takumi-rs/wasm/takumi_wasm_bg.wasm"),
-     * }
-     * ```
-     *
-     * For Next.js Turbopack, you can use the nextjs helper.
-     * ```ts
-     * {
-     *   module: import("@takumi-rs/wasm/next"),
-     * }
-     * ```
-     *
-     * For Vite, use `?url` suffix to get the URL of the WASM file.
-     *
-     * ```ts
-     * {
-     *   module: import("@takumi-rs/wasm/takumi_wasm_bg.wasm?url"),
-     * }
-     * ```
-     */
-    module: InitInput | Promise<InitInput> | {
-        default: InitInput;
-    };
-};
-type ImageResponseOptionsWithRenderer = ResponseInit & RenderOptions & {
-    renderer: Renderer;
-    jsx?: FromJsxOptions;
-    emoji?: EmojiType | "from-font";
-};
-type ImageResponseOptionsWithoutRenderer = ResponseInit & RenderOptions & ModuleOptions & {
-    fonts?: Font[];
-    persistentImages?: ImageSource[];
-    jsx?: FromJsxOptions;
-    emoji?: EmojiType | "from-font";
-};
-type ImageResponseOptions = ImageResponseOptionsWithRenderer | ImageResponseOptionsWithoutRenderer;
-declare class ImageResponse extends Response {
-    constructor(component: ReactNode, options: ImageResponseOptions);
-}
-
-export { ImageResponse, type ImageResponseOptions, ImageResponse as default };

package/dist/wasm.js

@@ -1 +0,0 @@
-import{fetchResources as c}from"@takumi-rs/helpers";import{extractEmojis as f}from"@takumi-rs/helpers/emoji";import{fromJsx as u}from"@takumi-rs/helpers/jsx";import d,{extractResourceUrls as l,Renderer as R}from"@takumi-rs/wasm/no-bundler";var o;function g(s){if(s&&"renderer"in s)return s.renderer;if(!o)return o=new R(s),o;if(s?.fonts)for(let t of s.fonts)o.loadFont(t);if(s?.persistentImages)for(let t of s.persistentImages)o.putPersistentImage(t);return o}var i=null;async function y(s){!("module"in s)||o||(i||(i=(async()=>{let t=await s.module;typeof t=="object"&&"default"in t&&(t=t.default),await d({module_or_path:t})})()),await i)}async function I(s,t){let e={...t},{node:n,stylesheets:r}=await u(s,e.jsx);if(e.stylesheets=[...e.stylesheets??[],...r],e.emoji&&e.emoji!=="from-font"&&(n=f(n,e.emoji)),!e.fetchedResources){let a=l(n);a.length>0&&(e.fetchedResources=await c(a))}return{node:n,options:e}}function O(s,t){return new ReadableStream({type:"bytes",async start(e){try{await y(t);let n=g(t),{node:r,options:a}=await I(s,t),m=n.render(r,a);e.enqueue(m),e.close()}catch(n){e.error(n)}}})}var h={png:"image/png",jpeg:"image/jpeg",webp:"image/webp",raw:"application/octet-stream"},j={format:"webp"},p=class extends Response{constructor(t,e){let n=O(t,e),r=new Headers(e.headers);r.get("content-type")||r.set("content-type",h[e.format??j.format]),super(n,{status:e.status,statusText:e.statusText,headers:r})}},F=p;export{p as ImageResponse,F as default};