@ethercorps/sveltekit-og 4.3.1-next.2 → 4.4.0-next.0

package/dist/helpers/to-html.js

@@ -0,0 +1,10 @@
+import { render } from "svelte/server";
+import { handleSync, ErrorCodes } from "./error-handler.js";
+/**
+ * Render a Svelte component to its SSR html parts. Shared by both engines — satori
+ * feeds body+head to satori-html, takumi passes the html string straight in. Use
+ * `<svelte:options css="injected" />` to get component styles into `head`.
+ */
+export function renderComponentToHtml(component, props = {}) {
+    return handleSync(() => render(component, { props }), ErrorCodes.VNODE_CREATION_FAILED, "Failed to render Svelte component to HTML");
+}

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, componentOptions?: ComponentOptions): VNode;
+import type { Component } from "svelte";
+import type { ComponentOptions, VNode } from "../types.js";
+export declare function createVNode(element: string | Component<any>, componentOptions?: ComponentOptions): VNode;

package/dist/helpers/toJSX.js

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

package/dist/helpers/utils.d.ts

@@ -0,0 +1,2 @@
+export declare const formatBytes: (bytes: number, decimals?: number) => string;
+export declare function importWasm(input: unknown): Promise<any>;

package/dist/helpers/utils.js

@@ -0,0 +1,25 @@
+const sizeFormats = ["Bytes", "KB", "MB", "GB"];
+const kbSize = 1024;
+export const formatBytes = (bytes, decimals = 2) => {
+    if (bytes === 0)
+        return "0 Bytes";
+    const decimalPoint = decimals < 0 ? 0 : decimals;
+    const sizeIndex = Math.min(Math.floor(Math.log(bytes) / Math.log(kbSize)), sizeFormats.length - 1);
+    return (parseFloat((bytes / Math.pow(kbSize, sizeIndex)).toFixed(decimalPoint)) +
+        " " +
+        sizeFormats[sizeIndex]);
+};
+export async function importWasm(input) {
+    // may be a nested await for some reason
+    const _input = await input;
+    const _module = _input?.default || _input;
+    // this is from rollup/wasm, it does some magic we need to recover from
+    if (typeof _module === "function") {
+        // empty input is to avoid instantiating the wasm module
+        // this will just compile it
+        const fnRes = await _module();
+        const _instance = fnRes.instance || fnRes;
+        return _instance.exports || _instance || _module;
+    }
+    return _module;
+}

package/dist/image-response.d.ts

@@ -1,5 +1,5 @@
-import type { Component, ComponentProps } from 'svelte';
-import type { ImageResponseOptions } from './types.js';
+import type { Component, ComponentProps } from "svelte";
+import type { ImageResponseOptions } from "./types.js";
 export declare class ImageResponse<T extends string | Component<any>> extends Response {
     constructor(element: T, options?: ImageResponseOptions, props?: T extends Component<any> ? ComponentProps<T> : never);
 }

package/dist/image-response.js

@@ -1,26 +1,18 @@
-import { DEFAULT_OPTIONS, DEFAULT_STATUS_CODE, DEFAULT_STATUS_TEXT } from './helpers/defaults.js';
-import { createPng, createSvg } from './helpers/create.js';
+import { DEFAULT_OPTIONS } from "./helpers/defaults.js";
+import { createImage } from "./helpers/create.js";
+import { buildImageResponse, CONTENT_TYPES } from "./helpers/response.js";
 export class ImageResponse extends Response {
     constructor(element, options, props) {
-        const extended_options = Object.assign({ ...DEFAULT_OPTIONS }, options);
-        const create_image_function = extended_options.format === 'png' ? createPng : createSvg;
-        const body = new ReadableStream({
-            async start(controller) {
-                const buffer = await create_image_function(element, extended_options, { props });
-                controller.enqueue(buffer);
-                controller.close();
-            }
-        });
-        super(body, {
-            headers: {
-                'Content-Type': `image/${extended_options.format}${extended_options.format === 'svg' ? '+xml' : ''}`,
-                'Cache-Control': extended_options.debug
-                    ? 'no-cache, no-store'
-                    : 'public, immutable, no-transform, max-age=31536000',
-                ...extended_options.headers
-            },
-            status: extended_options.status || DEFAULT_STATUS_CODE,
-            statusText: extended_options.statusText || DEFAULT_STATUS_TEXT
+        const opts = { ...DEFAULT_OPTIONS, ...options };
+        const format = opts.format ?? "png";
+        const { body, init } = buildImageResponse(() => createImage(element, { ...opts, format }, { props }), {
+            label: format.toUpperCase(),
+            contentType: CONTENT_TYPES[format],
+            debug: opts.debug ?? false,
+            headers: opts.headers,
+            status: opts.status,
+            statusText: opts.statusText,
         });
+        super(body, init);
     }
 }

package/dist/plugin.js

@@ -3,20 +3,27 @@ export function rollupWasm(options) {
     return unwasm({
         esmImport: true,
         lazy: true,
-        ...options
+        ...options,
     });
 }
 export function sveltekitOG(options) {
     return {
-        name: 'vite-plugin-sveltekit-og',
-        config() {
+        name: "vite-plugin-sveltekit-og",
+        // run after sveltekit(), whose config hook is what sets build.ssr
+        enforce: "post",
+        // SSR bundle only: the client build (e.g. the /client entry) loads its wasm
+        // through Vite's own asset handling, and unwasm would break that. Vite computes
+        // env.isSsrBuild before SvelteKit sets build.ssr, so check the merged config too.
+        config(config, { isSsrBuild }) {
+            if (!isSsrBuild && !config.build?.ssr)
+                return;
             return {
                 build: {
                     rollupOptions: {
                         plugins: [rollupWasm(options)],
                     },
-                }
+                },
             };
-        }
+        },
     };
 }

package/dist/providers/instances.d.ts

@@ -1,5 +1,5 @@
-import type _satori from 'satori';
-export declare function useResvg(): Promise<new (svg: Uint8Array | string, options?: import("@resvg/resvg-wasm").ResvgRenderOptions) => {
+import type _satori from "satori";
+export declare function useResvg(debug?: boolean): Promise<new (svg: Uint8Array | string, options?: import("@resvg/resvg-wasm").ResvgRenderOptions) => {
     free(): void;
     render(): {
         free(): void;
@@ -35,4 +35,4 @@ export declare function useResvg(): Promise<new (svg: Uint8Array | string, optio
     readonly height: number;
     readonly width: number;
 }>;
-export declare function useSatori(): Promise<typeof _satori>;
+export declare function useSatori(debug?: boolean): Promise<typeof _satori>;

package/dist/providers/instances.js

@@ -1,17 +1,45 @@
-import { isEdgeLight, isWorkerd } from 'std-env';
-// we keep instances alive to avoid re-importing them on every request, maybe not needed but
-// also helps with type inference
-// Code from vue-og-images
-const resvgInstance = { instance: undefined };
-const satoriInstance = { instance: undefined };
-export async function useResvg() {
-    const moduleImport = isEdgeLight || isWorkerd ? import(`./resvg/edge.js`) : import('./resvg/node.js');
-    resvgInstance.instance = resvgInstance.instance || await moduleImport.then(m => m.default);
-    await resvgInstance.instance.initWasmPromise;
-    return resvgInstance.instance.Resvg;
+import { isEdgeLight, isWorkerd } from "std-env";
+import { createLogger } from "../helpers/logger.js";
+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. 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 instancePromise;
+    const init = async (debug) => {
+        const log = createLogger(debug);
+        log.debug(`Initializing ${label}`);
+        const isWorkerLikeRuntime = isEdgeLight || isWorkerd;
+        log.info(`Detected runtime: ${isWorkerLikeRuntime ? "Edge Light or Workerd" : "Node.js"}`);
+        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`);
+        return loaded;
+    };
+    return (debug = false) => {
+        instancePromise ??= init(debug).catch((error) => {
+            instancePromise = undefined;
+            throw error;
+        });
+        return instancePromise;
+    };
 }
-export async function useSatori() {
-    satoriInstance.instance = satoriInstance.instance || await import(`./satori/node.js`).then(m => m.default);
-    await satoriInstance.instance.initWasmPromise;
-    return satoriInstance.instance.satori;
+const useResvgModule = createProvider("ReSVG", ErrorCodes.RESVG_INIT_FAILED, {
+    // workers take a precompiled `?module`; node takes raw wasm bytes
+    edge: () => import("./resvg/edge.js"),
+    node: () => import("./resvg/node.js"),
+});
+const useSatoriModule = createProvider("Satori", ErrorCodes.SATORI_INIT_FAILED, {
+    edge: () => import("./satori/edge.js"),
+    node: () => import("./satori/node.js"),
+});
+export async function useResvg(debug = false) {
+    return (await useResvgModule(debug)).Resvg;
+}
+export async function useSatori(debug = false) {
+    return (await useSatoriModule(debug)).satori;
 }

package/dist/providers/resvg/edge.d.ts

@@ -3,4 +3,4 @@ declare namespace _default {
     export { _Resvg as Resvg };
 }
 export default _default;
-import { Resvg as _Resvg } from '@resvg/resvg-wasm';
+import { Resvg as _Resvg } from "@resvg/resvg-wasm";

package/dist/providers/resvg/edge.js

@@ -1,8 +1,12 @@
-import { Resvg as _Resvg, initWasm } from '@resvg/resvg-wasm'
+import { Resvg as _Resvg, initWasm } from "@resvg/resvg-wasm";
 
 export default {
-	// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-ignore
-  initWasmPromise: initWasm(import('@resvg/resvg-wasm/index_bg.wasm').then(r => r.default || r)),
-  Resvg: _Resvg,
-}
+	// load resvg's wasm from the dep (it exports ./index_bg.wasm) via ?module, so we
+	// don't vendor a copy. precompiled module works on node + workers alike.
+	initWasmPromise: initWasm(
+		// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+		// @ts-ignore
+		import("@resvg/resvg-wasm/index_bg.wasm?module").then((r) => r.default || r)
+	),
+	Resvg: _Resvg,
+};

package/dist/providers/resvg/node.d.ts

@@ -3,4 +3,4 @@ declare namespace _default {
     export { _Resvg as Resvg };
 }
 export default _default;
-import { Resvg as _Resvg } from '@resvg/resvg-wasm';
+import { Resvg as _Resvg } from "@resvg/resvg-wasm";

package/dist/providers/resvg/node.js

@@ -1,13 +1,22 @@
-import { Resvg as _Resvg, initWasm } from '@resvg/resvg-wasm';
+import { Resvg as _Resvg, initWasm } from "@resvg/resvg-wasm";
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
 
-/**
- * Fetch will be called only once whenever you load this file.
- * In vercel serverless functions, fetch will run on cold start.
- * In Node.js (Stateful e.g. Linux servers), Fetch will run once when you start your server.
- * */
-const resvgWasm = fetch('https://unpkg.com/@resvg/resvg-wasm/index_bg.wasm')
+// prefer reading resvg's wasm straight from the installed dependency (no
+// network). some serverless bundlers (vercel/netlify via nft) don't trace the
+// sibling .wasm onto disk, so fall back to fetching it there. either way we hand
+// initWasm raw bytes / a Response — never a `?module` import, which node
+// serverless can't instantiate. runs once when this module first loads.
+async function loadResvgWasm() {
+	try {
+		const require = createRequire(import.meta.url);
+		return await readFile(require.resolve("@resvg/resvg-wasm/index_bg.wasm"));
+	} catch {
+		return fetch("https://unpkg.com/@resvg/resvg-wasm/index_bg.wasm");
+	}
+}
 
 export default {
-	initWasmPromise: initWasm(resvgWasm),
+	initWasmPromise: initWasm(loadResvgWasm()),
 	Resvg: _Resvg,
-}
+};

package/dist/providers/satori/edge.d.ts

@@ -0,0 +1,6 @@
+declare namespace _default {
+    export let initWasmPromise: Promise<void>;
+    export { _satori as satori };
+}
+export default _default;
+import _satori from "satori/standalone";

package/dist/providers/satori/edge.js

@@ -0,0 +1,12 @@
+import _satori, { init } from "satori/standalone";
+
+// the default satori entry compiles yoga's wasm at runtime, which workers block
+// ("Wasm code generation disallowed by embedder"). satori/standalone takes a
+// precompiled module via init(), so we hand it satori's own yoga wasm (it exports
+// ./yoga.wasm) through ?module — no vendored copy. mirrors providers/resvg.
+export default {
+	// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+	// @ts-ignore
+	initWasmPromise: init(import("satori/yoga.wasm?module").then((r) => r.default || r)),
+	satori: _satori,
+};

package/dist/providers/satori/node.d.ts

@@ -3,4 +3,4 @@ declare namespace _default {
     export { _satori as satori };
 }
 export default _default;
-import _satori from 'satori';
+import _satori from "satori";

package/dist/providers/satori/node.js

@@ -1,6 +1,6 @@
-import _satori from 'satori'
+import _satori from "satori";
 
 export default {
-  initWasmPromise: Promise.resolve(),
-  satori: _satori,
-}
+	initWasmPromise: Promise.resolve(),
+	satori: _satori,
+};

package/dist/takumi/fonts.d.ts

@@ -0,0 +1,16 @@
+import type { FontDetails } from "takumi-js/node";
+import { BaseFont } from "../fonts.js";
+import type { MayBePromise } from "../types.js";
+type ByteBuf = Uint8Array | ArrayBuffer | Buffer;
+/** Takumi-native font descriptor; data is the bytes or a lazy loader, like takumi-js wants. */
+export interface TakumiFontDescriptor {
+    name?: string;
+    data: ByteBuf | (() => MayBePromise<ByteBuf>);
+    weight?: number;
+    style?: FontDetails["style"];
+}
+/** What the takumi path accepts: our GoogleFont/CustomFont, or a raw takumi descriptor. */
+export type TakumiFontInput = BaseFont | TakumiFontDescriptor;
+/** Normalize mixed font inputs to FontDetails for registerFont, loaders run in parallel. */
+export declare function resolveTakumiFonts(fonts: TakumiFontInput[]): Promise<FontDetails[]>;
+export {};

package/dist/takumi/fonts.js

@@ -0,0 +1,15 @@
+import { BaseFont } from "../fonts.js";
+import { handleAsync, ErrorCodes } from "../helpers/error-handler.js";
+async function normalizeFont(font) {
+    if (font instanceof BaseFont) {
+        // our font classes lazily load + cache through the data getter
+        const data = (await font.data);
+        return { name: font.name, data, weight: font.weight, style: font.style };
+    }
+    const data = typeof font.data === "function" ? await font.data() : await font.data;
+    return { name: font.name, data, weight: font.weight, style: font.style };
+}
+/** Normalize mixed font inputs to FontDetails for registerFont, loaders run in parallel. */
+export async function resolveTakumiFonts(fonts) {
+    return handleAsync(() => Promise.all(fonts.map(normalizeFont)), ErrorCodes.FONT_LOAD_FAILED, "Failed to resolve fonts for Takumi");
+}

package/dist/takumi/image-response.d.ts

@@ -0,0 +1,6 @@
+import type { Component, ComponentProps } from "svelte";
+import type { TakumiImageResponseOptions } from "./types.js";
+/** OG image rendered by Takumi. Takes an HTML string or a Svelte component. */
+export declare class ImageResponse<T extends string | Component<any>> extends Response {
+    constructor(element: T, options?: TakumiImageResponseOptions, props?: T extends Component<any> ? ComponentProps<T> : never);
+}

package/dist/takumi/image-response.js

@@ -0,0 +1,27 @@
+import { createTakumiImage } from "./render.js";
+import { DEFAULT_WIDTH, DEFAULT_HEIGHT } from "../helpers/defaults.js";
+import { buildImageResponse, CONTENT_TYPES as SHARED_CONTENT_TYPES } from "../helpers/response.js";
+const DEFAULT_OPTIONS = {
+    width: DEFAULT_WIDTH,
+    height: DEFAULT_HEIGHT,
+    format: "png",
+    emoji: "twemoji",
+    debug: false,
+};
+// Verifies the shared map covers every takumi format
+const CONTENT_TYPES = SHARED_CONTENT_TYPES;
+/** OG image rendered by Takumi. Takes an HTML string or a Svelte component. */
+export class ImageResponse extends Response {
+    constructor(element, options, props) {
+        const opts = { ...DEFAULT_OPTIONS, ...options };
+        const { body, init } = buildImageResponse(() => createTakumiImage(element, opts, props), {
+            label: opts.format.toUpperCase(),
+            contentType: CONTENT_TYPES[opts.format],
+            debug: opts.debug,
+            headers: opts.headers,
+            status: opts.status,
+            statusText: opts.statusText,
+        });
+        super(body, init);
+    }
+}

package/dist/takumi/index.d.ts

@@ -0,0 +1,5 @@
+export { ImageResponse } from "./image-response.js";
+export type { TakumiImageResponseOptions, TakumiImageOptions, TakumiResponseOptions, TakumiFormat, } from "./types.js";
+export type { TakumiFontInput, TakumiFontDescriptor } from "./fonts.js";
+export { resolveTakumiFonts } from "./fonts.js";
+export { GoogleFont, CustomFont, loadGoogleFont } from "../fonts.js";

package/dist/takumi/index.js

@@ -0,0 +1,4 @@
+export { ImageResponse } from "./image-response.js";
+export { resolveTakumiFonts } from "./fonts.js";
+// re-export the font helpers so the takumi path works from one import
+export { GoogleFont, CustomFont, loadGoogleFont } from "../fonts.js";

package/dist/takumi/render.d.ts

@@ -0,0 +1,4 @@
+import type { Component } from "svelte";
+import type { TakumiImageOptions } from "./types.js";
+/** Render an HTML string or Svelte component to image bytes (or an svg string). */
+export declare function createTakumiImage(element: string | Component<any>, options: TakumiImageOptions, props?: Record<string, unknown>): Promise<Uint8Array | string>;

package/dist/takumi/render.js

@@ -0,0 +1,23 @@
+import { render as takumiRender, renderSvg } from "takumi-js";
+import { useTakumiRenderer, registerTakumiFonts } from "./renderer.js";
+import { resolveTakumiFonts } from "./fonts.js";
+import { createLogger } from "../helpers/logger.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 renderer = await useTakumiRenderer();
+    if (options.fonts?.length) {
+        const fonts = await resolveTakumiFonts(options.fonts);
+        await registerTakumiFonts(renderer, fonts);
+    }
+    const { width, height, format = "png", quality, stylesheets, emoji } = options;
+    const shared = { renderer: renderer, width, height, stylesheets, emoji };
+    log.debug(`Rendering ${format.toUpperCase()} with Takumi`);
+    if (format === "svg") {
+        return handleAsync(() => renderSvg(vNode, shared), ErrorCodes.TAKUMI_RENDER_FAILED, "Failed to render SVG with Takumi");
+    }
+    return handleAsync(() => takumiRender(vNode, { ...shared, format, quality }), ErrorCodes.TAKUMI_RENDER_FAILED, "Failed to render image with Takumi");
+}

package/dist/takumi/renderer.d.ts

@@ -0,0 +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.
+ * 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

@@ -0,0 +1,39 @@
+import autoModule, { init as initTakumiWasm, Renderer } from "takumi-js/wasm";
+import { handleAsync, ErrorCodes } from "../helpers/error-handler.js";
+// keep one renderer alive across requests, same as the satori/resvg instances.
+// fonts registered on it stick around, so we dedupe by key.
+let rendererPromise;
+const registeredFontKeys = new Set();
+async function initRenderer() {
+    await handleAsync(async () => {
+        // reuse the wasm that ships with takumi-js instead of vendoring our own.
+        // @takumi-rs/wasm/auto picks the right binary per runtime (workerd, edge,
+        // node, ?module) via export conditions. this is the same dance takumi-js
+        // does internally.
+        const resolved = typeof autoModule === "function" ? await autoModule() : await autoModule;
+        const input = resolved && typeof resolved === "object" && "default" in resolved
+            ? resolved.default
+            : resolved;
+        await initTakumiWasm(input ? { module_or_path: input } : undefined);
+    }, ErrorCodes.TAKUMI_INIT_FAILED, "Failed to initialize Takumi WASM");
+    return new Renderer();
+}
+/** 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().catch((error) => {
+        rendererPromise = undefined;
+        throw error;
+    });
+    return rendererPromise;
+}
+/** Register each font once, keyed by name/weight/style. */
+export async function registerTakumiFonts(renderer, fonts) {
+    for (const font of fonts) {
+        const key = `${font.name ?? "unnamed"}-${font.weight ?? "auto"}-${font.style ?? "normal"}`;
+        if (registeredFontKeys.has(key))
+            continue;
+        await handleAsync(() => renderer.registerFont(font), ErrorCodes.FONT_LOAD_FAILED, `Failed to register Takumi font: ${key}`);
+        registeredFontKeys.add(key);
+    }
+}

package/dist/takumi/types.d.ts

@@ -0,0 +1,64 @@
+import type { EmojiType } from "takumi-js/helpers/emoji";
+import type { OutputFormat } from "takumi-js/node";
+import type { TakumiFontInput } from "./fonts.js";
+/** Static output formats Takumi can encode, plus vector `svg`. */
+export type TakumiFormat = OutputFormat | "svg";
+export type TakumiImageOptions = {
+    /**
+     * Width of the image.
+     * @default 1200
+     * */
+    width?: number;
+    /**
+     * Height of the image.
+     * @default 630
+     * */
+    height?: number;
+    /**
+     * Output format.
+     * @default png
+     * */
+    format?: TakumiFormat;
+    /**
+     * Quality for lossy formats (jpeg, lossy webp), 0-100.
+     * */
+    quality?: number;
+    /**
+     * Fonts to register. Accepts this library's `GoogleFont`/`CustomFont`
+     * helpers or raw Takumi font descriptors. If omitted, Takumi's built-in
+     * sans-serif is used.
+     * */
+    fonts?: TakumiFontInput[];
+    /**
+     * Extra CSS stylesheets applied before rendering.
+     * */
+    stylesheets?: string[];
+    /**
+     * Emoji provider, or `"from-font"` to source emoji glyphs from loaded fonts.
+     * @default twemoji
+     * */
+    emoji?: EmojiType | "from-font";
+    /**
+     * Enable debug logging.
+     * @default false
+     * */
+    debug?: boolean;
+};
+export type TakumiResponseOptions = {
+    /**
+     * Response status code.
+     * @default 200
+     * */
+    status?: number;
+    /**
+     * Response status text.
+     * @default Success
+     * */
+    statusText?: string;
+    /**
+     * Response headers.
+     * */
+    headers?: Record<string, string>;
+};
+/** Options for the Takumi `ImageResponse`. */
+export type TakumiImageResponseOptions = TakumiImageOptions & TakumiResponseOptions;

package/dist/takumi/types.js

@@ -0,0 +1 @@
+export {};

package/dist/types.d.ts

@@ -1,9 +1,9 @@
-import type { SatoriOptions } from 'satori/wasm';
-import type { EmojiType } from './helpers/emoji.js';
-export type Font = SatoriOptions['fonts'][number];
+import type { SatoriOptions } from "satori";
+import type { EmojiType } from "./helpers/emoji.js";
+export type Font = SatoriOptions["fonts"][number];
 export type Fonts = Font[];
-export type FontStyle = Font['style'];
-export type FontWeight = Font['weight'];
+export type FontStyle = Font["style"];
+export type FontWeight = Font["weight"];
 export type FinalFontOptions = NonNullable<Fonts>;
 export type ImageOptions = {
     /**
@@ -30,7 +30,7 @@ export type ImageOptions = {
      * Tailwind config
      * @default provided by satori
      * */
-    tailwindConfig?: SatoriOptions['tailwindConfig'];
+    tailwindConfig?: SatoriOptions["tailwindConfig"];
     /**
      * Debug operations
      * @default false
@@ -40,7 +40,7 @@ export type ImageOptions = {
      * Image format
      * @default png
      * */
-    format?: 'svg' | 'png';
+    format?: "svg" | "png";
 };
 export type ResponseImageOptions = {
     /**
@@ -70,7 +70,7 @@ export type ImageResponseOptions = ImageOptions & ResponseImageOptions;
  * Svelte Component props to render the component which dynamic content
  * */
 export type ComponentOptions = {
-    props?: Record<string, any>;
+    props?: Record<string, unknown>;
 };
 /**
  * React virtual node, supported by satori as input (alternative to JSX input).
@@ -78,14 +78,10 @@ export type ComponentOptions = {
 export interface VNode {
     type: string;
     props: {
-        style?: Record<string, any>;
+        style?: Record<string, unknown>;
         children?: string | VNode | VNode[];
-        [prop: string]: any;
+        [prop: string]: unknown;
     };
 }
 /** utils types */
 export type MayBePromise<T> = T | Promise<T>;
-export type OnlyProps<T, P> = {
-    [K in keyof T as K extends P ? K : never]: T[K];
-};
-export type StringWithSuggestions<S extends string> = (string & Record<never, never>) | S;