nuxt-og-image 5.1.13 → 6.0.0-beta.2

package/dist/runtime/app/utils/plugins.js

@@ -2,13 +2,11 @@ import { useRequestEvent } from "#app";
 import { withSiteUrl } from "#site-config/app/composables";
 import { TemplateParamsPlugin } from "@unhead/vue/plugins";
 import { defu } from "defu";
-import { parse, stringify } from "devalue";
 import { createRouter as createRadixRouter, toRouteMatcher } from "radix3";
 import { parseURL, withoutBase } from "ufo";
 import { toValue } from "vue";
-import { createOgImageMeta } from "../../app/utils.js";
-import { isInternalRoute, separateProps } from "../../shared.js";
-import { getOgImagePath } from "../utils.js";
+import { createOgImageMeta, getOgImagePath } from "../../app/utils.js";
+import { isInternalRoute } from "../../shared.js";
 export function ogImageCanonicalUrls(nuxtApp) {
   nuxtApp.hooks.hook("app:rendered", async (ctx) => {
     const { ssrContext } = ctx;
@@ -20,38 +18,33 @@ export function ogImageCanonicalUrls(nuxtApp) {
     ssrContext?.head.use({
       key: "nuxt-og-image:overrides-and-canonical-urls",
       hooks: {
-        "tags:resolve": async (ctx2) => {
-          const hasPrimaryPayload = ctx2.tags.some((tag) => tag.tag === "script" && tag.props.id === "nuxt-og-image-options");
-          let overrides;
+        "tags:afterResolve": async (ctx2) => {
+          let title = "";
+          let description = "";
           for (const tag of ctx2.tags) {
-            if (tag.tag === "script" && tag.props.id === "nuxt-og-image-overrides") {
-              if (hasPrimaryPayload) {
-                overrides = separateProps(parse(tag.innerHTML || "{}"));
-                delete ctx2.tags[ctx2.tags.indexOf(tag)];
-              } else {
-                tag.props.id = "nuxt-og-image-options";
-                tag.innerHTML = stringify(separateProps(parse(tag.innerHTML || "{}")));
-                tag._d = "script:id:nuxt-og-image-options";
-              }
-              break;
+            if (tag.tag === "title" && tag.textContent) {
+              title = tag.textContent;
+            } else if (tag.tag === "meta" && tag.props.name === "description") {
+              description = tag.props.content || "";
             }
+            if (title && description)
+              break;
           }
-          ctx2.tags = ctx2.tags.filter(Boolean);
           for (const tag of ctx2.tags) {
             if (tag.tag === "meta" && (tag.props.property === "og:image" || ["twitter:image:src", "twitter:image"].includes(tag.props.name || ""))) {
               if (!tag.props.content) {
                 tag.props = {};
                 continue;
               }
+              tag.props.content = tag.props.content.replaceAll("%title", title).replaceAll("%description", description).replaceAll(" ", "+");
               if (!tag.props.content?.startsWith("https")) {
                 await nuxtApp.runWithContext(() => {
                   tag.props.content = toValue(withSiteUrl(tag.props.content || "", {
-                    withBase: true
+                    withBase: true,
+                    canonical: !import.meta.dev
                   }));
                 });
               }
-            } else if (overrides && tag.tag === "script" && tag.props.id === "nuxt-og-image-options") {
-              tag.innerHTML = stringify(defu(overrides, parse(tag.innerHTML || "{}")));
             }
           }
         }
@@ -76,17 +69,18 @@ export function routeRuleOgImage(nuxtApp) {
     let routeRules = combinedRules?.ogImage;
     if (typeof routeRules === "undefined")
       return;
-    const ogImageInstances = nuxtApp.ssrContext._ogImageInstances || [];
     if (routeRules === false) {
-      ogImageInstances?.forEach((e2) => {
-        e2.dispose();
-      });
-      nuxtApp.ssrContext._ogImagePayload = void 0;
-      nuxtApp.ssrContext._ogImageInstances = void 0;
+      nuxtApp.ssrContext._ogImageInstance?.dispose();
+      nuxtApp.ssrContext._ogImageDevtoolsInstance?.dispose();
+      nuxtApp.ssrContext._ogImageInstance = void 0;
+      nuxtApp.ssrContext._ogImagePayloads = [];
       return;
     }
     routeRules = defu(nuxtApp.ssrContext?.event?.context._nitro?.routeRules?.ogImage, routeRules);
-    const src = getOgImagePath(ssrContext.url, routeRules);
+    const { path: src, hash } = getOgImagePath(ssrContext.url, routeRules);
+    if (hash) {
+      routeRules._hash = hash;
+    }
     createOgImageMeta(src, routeRules, nuxtApp.ssrContext);
   });
 }

package/dist/runtime/app/utils.d.ts

@@ -1,7 +1,21 @@
+import type { ActiveHeadEntry, Head } from '@unhead/vue';
 import type { NuxtSSRContext } from 'nuxt/app';
 import type { OgImageOptions, OgImagePrebuilt, OgImageRuntimeConfig } from '../types.js';
+type OgImagePayload = [string, OgImageOptions, Required<Head>['meta']];
+declare module 'nuxt/app' {
+    interface NuxtSSRContext {
+        _ogImagePayloads?: OgImagePayload[];
+        _ogImageInstance?: ActiveHeadEntry<Head>;
+        _ogImageDevtoolsInstance?: ActiveHeadEntry<Head>;
+    }
+}
 export declare function setHeadOgImagePrebuilt(input: OgImagePrebuilt): void;
 export declare function createOgImageMeta(src: string, input: OgImageOptions | OgImagePrebuilt, ssrContext: NuxtSSRContext): void;
 export declare function resolveComponentName(component: OgImageOptions['component'], fallback: string): OgImageOptions['component'];
-export declare function getOgImagePath(pagePath: string, _options?: Partial<OgImageOptions>): string;
+export interface GetOgImagePathResult {
+    path: string;
+    hash?: string;
+}
+export declare function getOgImagePath(_pagePath: string, _options?: Partial<OgImageOptions>): GetOgImagePathResult;
 export declare function useOgImageRuntimeConfig(): OgImageRuntimeConfig;
+export {};

package/dist/runtime/app/utils.js

@@ -4,7 +4,7 @@ import { defu } from "defu";
 import { stringify } from "devalue";
 import { useHead, useRuntimeConfig } from "nuxt/app";
 import { joinURL, withQuery } from "ufo";
-import { generateMeta, separateProps } from "../shared.js";
+import { buildOgImageUrl, generateMeta, separateProps } from "../shared.js";
 export function setHeadOgImagePrebuilt(input) {
   if (import.meta.client) {
     return;
@@ -20,67 +20,95 @@ export function createOgImageMeta(src, input, ssrContext) {
     return;
   }
   const { defaults } = useOgImageRuntimeConfig();
-  const _input = separateProps(defu(input, ssrContext._ogImagePayload));
-  if (input._query && Object.keys(input._query).length)
-    src = withQuery(src, { _query: input._query });
-  const meta = generateMeta(src, input);
-  ssrContext._ogImageInstances = ssrContext._ogImageInstances || [];
-  const script = [];
-  if (src) {
-    script.push({
-      id: "nuxt-og-image-options",
-      type: "application/json",
-      processTemplateParams: true,
-      innerHTML: () => {
-        const payload = resolveUnrefHeadInput(_input);
-        if (payload.props && typeof payload.props.title === "undefined")
-          payload.props.title = "%s";
-        payload.component = resolveComponentName(input.component, defaults.component || "");
-        delete payload.url;
-        if (payload._query && Object.keys(payload._query).length === 0) {
-          delete payload._query;
-        }
-        const final = {};
-        for (const k in payload) {
-          if (payload[k] !== defaults[k]) {
-            final[k] = payload[k];
-          }
-        }
-        return stringify(final);
-      },
-      // we want this to be last in our head
-      tagPosition: "bodyClose"
-    });
+  const resolvedOptions = separateProps(defu(input, defaults));
+  resolvedOptions.key = resolvedOptions.key || "og";
+  const payloads = ssrContext._ogImagePayloads || [];
+  const currentPayloadIdx = payloads.findIndex(([k]) => k === resolvedOptions.key);
+  const _input = separateProps(defu(input, currentPayloadIdx >= 0 ? payloads[currentPayloadIdx][1] : {}));
+  let url = src || input.url || resolvedOptions.url;
+  if (!url)
+    return;
+  if (input._query && Object.keys(input._query).length && url)
+    url = withQuery(url, { _query: input._query });
+  const meta = generateMeta(url, resolvedOptions);
+  if (currentPayloadIdx === -1) {
+    payloads.push([resolvedOptions.key, _input, meta]);
+  } else {
+    payloads[currentPayloadIdx] = [resolvedOptions.key, _input, meta];
   }
-  const instance = useHead({
-    script,
-    meta
+  ssrContext._ogImageInstance?.dispose();
+  ssrContext._ogImageInstance = useHead({
+    meta() {
+      const finalPayload = ssrContext._ogImagePayloads || [];
+      return finalPayload.flatMap(([_, __, meta2]) => meta2);
+    }
   }, {
-    tagPriority: "high"
+    processTemplateParams: true,
+    tagPriority: 35
   });
-  ssrContext._ogImagePayload = _input;
-  ssrContext._ogImageInstances.push(instance);
+  if (import.meta.dev || import.meta.prerender) {
+    ssrContext._ogImageDevtoolsInstance?.dispose();
+    ssrContext._ogImageDevtoolsInstance = useHead({
+      script: [{
+        id: "nuxt-og-image-options",
+        type: "application/json",
+        processTemplateParams: true,
+        innerHTML: () => {
+          const devtoolsPayload = (ssrContext._ogImagePayloads || []).map(([key, options]) => {
+            const payload = resolveUnrefHeadInput(options);
+            if (payload.props && typeof payload.props.title === "undefined")
+              payload.props.title = "%s";
+            payload.component = resolveComponentName(options.component, defaults.component || "");
+            payload.key = key;
+            delete payload.url;
+            if (payload._query && Object.keys(payload._query).length === 0) {
+              delete payload._query;
+            }
+            const final = {};
+            for (const k in payload) {
+              if (payload[k] !== defaults[k]) {
+                final[k] = payload[k];
+              }
+            }
+            return final;
+          });
+          return stringify(devtoolsPayload);
+        },
+        tagPosition: "bodyClose"
+      }]
+    });
+  }
+  ssrContext._ogImagePayloads = payloads;
 }
 export function resolveComponentName(component, fallback) {
   component = component || fallback || componentNames?.[0]?.pascalName;
   if (component && componentNames) {
     const originalName = component;
     for (const component2 of componentNames) {
-      if (component2.pascalName.endsWith(originalName) || component2.kebabName.endsWith(originalName)) {
+      const basePascalName = component2.pascalName.replace(/(Satori|Chromium|Takumi)$/, "");
+      const baseKebabName = component2.kebabName.replace(/-(satori|chromium|takumi)$/, "");
+      if (basePascalName.endsWith(originalName) || baseKebabName.endsWith(originalName)) {
         return component2.pascalName;
       }
     }
   }
   return component;
 }
-export function getOgImagePath(pagePath, _options) {
-  const baseURL = useRuntimeConfig().app.baseURL;
-  const extension = _options?.extension || useOgImageRuntimeConfig().defaults?.extension || "png";
-  const path = joinURL("/", baseURL, `__og-image__/${import.meta.prerender ? "static" : "image"}`, pagePath, `og.${extension}`);
-  if (Object.keys(_options?._query || {}).length) {
-    return withQuery(path, _options._query);
+export function getOgImagePath(_pagePath, _options) {
+  const runtimeConfig = useRuntimeConfig();
+  const baseURL = runtimeConfig.app.baseURL;
+  const { defaults } = useOgImageRuntimeConfig();
+  const extension = _options?.extension || defaults?.extension || "png";
+  const isStatic = import.meta.prerender;
+  const result = buildOgImageUrl({ ..._options, _path: _pagePath }, extension, isStatic, defaults);
+  let path = joinURL("/", baseURL, result.url);
+  if (!isStatic && runtimeConfig.app.buildId) {
+    path = withQuery(path, { _v: runtimeConfig.app.buildId });
   }
-  return path;
+  return {
+    path,
+    hash: result.hash
+  };
 }
 export function useOgImageRuntimeConfig() {
   const c = useRuntimeConfig();

package/dist/runtime/pure.d.ts

@@ -0,0 +1,7 @@
+import type { DevToolsMetaDataExtraction, OgImageOptions } from './types.js';
+export declare function extractSocialPreviewTags(html: string): [Record<string, string>, DevToolsMetaDataExtraction[]];
+export declare function toBase64Image(data: string | ArrayBuffer): string;
+export declare function isInternalRoute(path: string): boolean;
+export declare function separateProps(options: OgImageOptions | undefined, ignoreKeys?: string[]): OgImageOptions;
+export declare function withoutQuery(path: string): string | undefined;
+export declare function getExtension(path: string): string;

package/dist/runtime/pure.js

@@ -0,0 +1,105 @@
+import { defu } from "defu";
+export function extractSocialPreviewTags(html) {
+  const data = [];
+  const rootData = {};
+  const socialMetaTags = html.match(/<meta[^>]+(property|name)="(twitter|og):([^"]+)"[^>]*>/g) || [];
+  let currentArrayIdx = -1;
+  socialMetaTags.forEach((tag) => {
+    const [, , type, key] = tag.match(/(property|name)="(twitter|og):([^"]+)"/);
+    const value = tag.match(/content="([^"]+)"/)?.[1];
+    if (!value) {
+      return;
+    }
+    if (key === "title" || key === "description") {
+      rootData[`${type}:${key}`] = value;
+      return;
+    }
+    if (type === "og" && key === "image") {
+      currentArrayIdx++;
+    }
+    if (!data[currentArrayIdx])
+      data[currentArrayIdx] = {};
+    if (!data[currentArrayIdx][type])
+      data[currentArrayIdx][type] = {};
+    data[currentArrayIdx][type][key] = value;
+  });
+  data.forEach((preview) => {
+    if (preview.og?.image && preview.og?.image.includes("/_og/")) {
+      const url = withoutQuery(preview.og.image);
+      const keyMatch = url.match(/[,/]k_([^,./]+)/);
+      preview.key = keyMatch?.[1] || "og";
+    }
+  });
+  return [rootData, data];
+}
+function detectBase64MimeType(data) {
+  const signatures = {
+    "R0lGODdh": "image/gif",
+    "R0lGODlh": "image/gif",
+    "iVBORw0KGgo": "image/png",
+    "/9j/": "image/jpeg",
+    "UklGR": "image/webp",
+    "AAABAA": "image/x-icon"
+  };
+  for (const s in signatures) {
+    if (data.startsWith(s)) {
+      return signatures[s];
+    }
+  }
+  return "image/svg+xml";
+}
+export function toBase64Image(data) {
+  const base64 = typeof data === "string" ? data : Buffer.from(data).toString("base64");
+  const type = detectBase64MimeType(base64);
+  return `data:${type};base64,${base64}`;
+}
+export function isInternalRoute(path) {
+  return path.startsWith("/_") || path.startsWith("@");
+}
+function filterIsOgImageOption(key) {
+  const keys = [
+    "url",
+    "extension",
+    "width",
+    "height",
+    "alt",
+    "props",
+    "renderer",
+    // internal use only (screenshots)
+    "html",
+    "component",
+    "emojis",
+    "_query",
+    "satori",
+    "resvg",
+    "sharp",
+    "screenshot",
+    "cacheMaxAgeSeconds",
+    "key"
+  ];
+  return keys.includes(key);
+}
+export function separateProps(options, ignoreKeys = []) {
+  options = options || {};
+  const _props = defu(options.props, Object.fromEntries(
+    Object.entries({ ...options }).filter(([k]) => !filterIsOgImageOption(k) && !ignoreKeys.includes(k))
+  ));
+  const props = {};
+  Object.entries(_props).forEach(([key, val]) => {
+    props[key.replace(/-([a-z])/g, (g) => g[1].toUpperCase())] = val;
+  });
+  return {
+    ...Object.fromEntries(
+      Object.entries({ ...options }).filter(([k]) => filterIsOgImageOption(k) || ignoreKeys.includes(k))
+    ),
+    props
+  };
+}
+export function withoutQuery(path) {
+  return path.split("?")[0];
+}
+export function getExtension(path) {
+  path = withoutQuery(path);
+  const lastSegment = path.split("/").pop() || path;
+  return lastSegment.split(".").pop() || lastSegment;
+}

package/dist/runtime/server/og-image/bindings/css-inline/wasm-fs.d.ts

@@ -1,7 +1,8 @@
+import { inline } from '@css-inline/css-inline-wasm';
 declare const _default: {
-    initWasmPromise: any;
+    initWasmPromise: Promise<void>;
     cssInline: {
-        inline: any;
+        inline: typeof inline;
     };
 };
 export default _default;

package/dist/runtime/server/og-image/bindings/css-inline/wasm.d.ts

@@ -1,7 +1,8 @@
+import { inline } from '@css-inline/css-inline-wasm';
 declare const _default: {
-    initWasmPromise: any;
+    initWasmPromise: Promise<void>;
     cssInline: {
-        inline: any;
+        inline: typeof inline;
     };
 };
 export default _default;

package/dist/runtime/server/og-image/bindings/font-assets/cloudflare.d.ts

@@ -0,0 +1,3 @@
+import type { H3Event } from 'h3';
+import type { FontConfig } from '../../../../types.js';
+export declare function resolve(event: H3Event, font: FontConfig): Promise<Buffer<ArrayBuffer>>;

package/dist/runtime/server/og-image/bindings/font-assets/cloudflare.js

@@ -0,0 +1,22 @@
+import { getNitroOrigin } from "#site-config/server/composables";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { withBase } from "ufo";
+export async function resolve(event, font) {
+  const path = font.src || font.localPath;
+  const assets = event.context.cloudflare?.env?.ASSETS || event.context.ASSETS;
+  if (!assets) {
+    throw new Error("Cloudflare ASSETS binding not available");
+  }
+  const { app } = useRuntimeConfig();
+  const fullPath = withBase(path, app.baseURL);
+  const origin = getNitroOrigin(event);
+  const res = await assets.fetch(new URL(fullPath, origin).href).catch(() => null);
+  if (res?.ok) {
+    return Buffer.from(await res.arrayBuffer());
+  }
+  const publicRes = await fetch(new URL(fullPath, origin).href);
+  if (publicRes.ok) {
+    return Buffer.from(await publicRes.arrayBuffer());
+  }
+  throw new Error(`[Nuxt OG Image] Failed to resolve public assets: ${path}`);
+}

package/dist/runtime/server/og-image/bindings/font-assets/dev-prerender.d.ts

@@ -0,0 +1,3 @@
+import type { H3Event } from 'h3';
+import type { FontConfig } from '../../../../types.js';
+export declare function resolve(event: H3Event, font: FontConfig): Promise<Buffer>;

package/dist/runtime/server/og-image/bindings/font-assets/dev-prerender.js

@@ -0,0 +1,49 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { buildDir } from "#og-image-virtual/build-dir.mjs";
+import { getNitroOrigin } from "#site-config/server/composables";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { withBase } from "ufo";
+let fontUrlMapping;
+async function loadFontUrlMapping() {
+  if (fontUrlMapping)
+    return fontUrlMapping;
+  const content = await readFile(join(buildDir, "cache", "og-image", "font-urls.json"), "utf-8").catch(() => null);
+  fontUrlMapping = content ? JSON.parse(content) : {};
+  return fontUrlMapping;
+}
+function getRootDir() {
+  const idx = buildDir.indexOf("/.nuxt");
+  return idx !== -1 ? buildDir.slice(0, idx) : process.cwd();
+}
+export async function resolve(event, font) {
+  const path = font.src || font.localPath;
+  const rootDir = getRootDir();
+  if (import.meta.prerender) {
+    if (path.startsWith("/_fonts/")) {
+      const filename2 = path.slice("/_fonts/".length);
+      const cached = await readFile(join(buildDir, "cache", "fonts", filename2)).catch(() => null) || await readFile(join(rootDir, ".output", "public", "_fonts", filename2)).catch(() => null);
+      if (cached?.length)
+        return cached;
+      const mapping = await loadFontUrlMapping();
+      if (mapping[filename2]) {
+        const res = await fetch(mapping[filename2]).catch(() => null);
+        if (res?.ok)
+          return Buffer.from(await res.arrayBuffer());
+      }
+      throw new Error(`Font ${filename2} not found in mapping or cache`);
+    }
+    const filename = path.slice(1);
+    const data = await readFile(join(rootDir, "public", filename)).catch(() => null) || await readFile(join(rootDir, ".output", "public", filename)).catch(() => null);
+    if (data?.length)
+      return data;
+    throw new Error(`Font ${filename} not found in public directory`);
+  }
+  const { app } = useRuntimeConfig();
+  const fullPath = withBase(path, app.baseURL);
+  const arrayBuffer = await $fetch(fullPath, {
+    responseType: "arrayBuffer",
+    baseURL: getNitroOrigin(event)
+  });
+  return Buffer.from(arrayBuffer);
+}

package/dist/runtime/server/og-image/bindings/font-assets/node.d.ts

@@ -0,0 +1,3 @@
+import type { H3Event } from 'h3';
+import type { FontConfig } from '../../../../types.js';
+export declare function resolve(event: H3Event, font: FontConfig): Promise<Buffer<ArrayBuffer>>;

package/dist/runtime/server/og-image/bindings/font-assets/node.js

@@ -0,0 +1,14 @@
+import { getNitroOrigin } from "#site-config/server/composables";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { withBase } from "ufo";
+export async function resolve(event, font) {
+  const path = font.src || font.localPath;
+  const { app } = useRuntimeConfig();
+  const fullPath = withBase(path, app.baseURL);
+  const origin = getNitroOrigin(event);
+  const res = await fetch(new URL(fullPath, origin).href);
+  if (res.ok) {
+    return Buffer.from(await res.arrayBuffer());
+  }
+  throw new Error(`[Nuxt OG Image] Failed to resolve font: ${path}`);
+}

package/dist/runtime/server/og-image/bindings/resvg/node-dev.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    initWasmPromise: Promise<void>;
+    Resvg: typeof import("@resvg/resvg-wasm").Resvg;
+};
+export default _default;

package/dist/runtime/server/og-image/bindings/resvg/node-dev.js

@@ -0,0 +1,70 @@
+import { Worker } from "node:worker_threads";
+const workerCode = `
+const { parentPort } = require('node:worker_threads')
+const { Resvg } = require('@resvg/resvg-js')
+
+parentPort.on('message', ({ id, svg, options }) => {
+  const resvg = new Resvg(svg, options)
+  const png = resvg.render().asPng()
+  parentPort.postMessage({ id, png })
+})
+`;
+let worker = null;
+let requestId = 0;
+const pending = /* @__PURE__ */ new Map();
+function createWorker() {
+  const w = new Worker(workerCode, { eval: true });
+  w.on("message", ({ id, png }) => {
+    const p = pending.get(id);
+    if (p) {
+      pending.delete(id);
+      p.resolve(Buffer.from(png));
+    }
+  });
+  w.on("error", (err) => {
+    for (const [id, p] of pending) {
+      pending.delete(id);
+      p.reject(err);
+    }
+    worker = null;
+  });
+  w.on("exit", (code) => {
+    if (code !== 0) {
+      for (const [id, p] of pending) {
+        pending.delete(id);
+        p.reject(new Error(`Resvg worker exited with code ${code}`));
+      }
+      worker = null;
+    }
+  });
+  return w;
+}
+function renderPng(svg, options) {
+  return new Promise((resolve, reject) => {
+    if (!worker)
+      worker = createWorker();
+    const id = ++requestId;
+    pending.set(id, { resolve, reject });
+    worker.postMessage({ id, svg, options });
+  });
+}
+class ResvgWorkerProxy {
+  svg;
+  options;
+  pngPromise = null;
+  constructor(svg, options) {
+    this.svg = svg;
+    this.options = options;
+  }
+  render() {
+    if (!this.pngPromise)
+      this.pngPromise = renderPng(this.svg, this.options);
+    return {
+      asPng: () => this.pngPromise
+    };
+  }
+}
+export default {
+  initWasmPromise: Promise.resolve(),
+  Resvg: ResvgWorkerProxy
+};

package/dist/runtime/server/og-image/bindings/takumi/node.d.ts

@@ -0,0 +1,6 @@
+import { Renderer } from '@takumi-rs/core';
+declare const _default: {
+    initWasmPromise: Promise<void>;
+    Renderer: typeof Renderer;
+};
+export default _default;

package/dist/runtime/server/og-image/bindings/takumi/node.js

@@ -0,0 +1,5 @@
+import { Renderer } from "@takumi-rs/core";
+export default {
+  initWasmPromise: Promise.resolve(),
+  Renderer
+};

package/dist/runtime/server/og-image/bindings/takumi/wasm.d.ts

@@ -0,0 +1,6 @@
+import { Renderer } from '@takumi-rs/wasm';
+declare const _default: {
+    initWasmPromise: Promise<import("@takumi-rs/wasm").InitOutput>;
+    Renderer: typeof Renderer;
+};
+export default _default;

package/dist/runtime/server/og-image/bindings/takumi/wasm.js

@@ -0,0 +1,6 @@
+import init, { Renderer } from "@takumi-rs/wasm";
+const wasmBinary = import("@takumi-rs/wasm/takumi_wasm_bg.wasm?module").then((m) => m.default || m);
+export default {
+  initWasmPromise: wasmBinary.then((wasm) => init({ module_or_path: wasm })),
+  Renderer
+};

package/dist/runtime/server/og-image/cache/buildCache.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Get the component hash for a given component name
+ */
+export declare function getComponentHash(componentName: string): string;
+/**
+ * Generate a cache key that includes options, component hash, and version
+ */
+export declare function generateBuildCacheKey(options: Record<string, any>, extension: string): string;
+/**
+ * Check if an image exists in the build cache
+ */
+export declare function getBuildCachedImage(options: Record<string, any>, extension: string): Buffer | null;
+/**
+ * Save an image to the build cache
+ */
+export declare function setBuildCachedImage(options: Record<string, any>, extension: string, data: Buffer | Uint8Array, maxAgeSeconds: number): void;