nuxt-og-image 3.0.0-beta.8 → 3.0.0-rc.0

package/dist/runtime/core/renderers/satori/utils.d.ts

@@ -1,4 +1,3 @@
-import type { H3Event } from 'h3';
-import type { SatoriTransformer, VNode } from '../../../types';
-export declare function walkSatoriTree(e: H3Event, node: VNode, plugins: (SatoriTransformer | SatoriTransformer[])[]): Promise<void>;
+import type { OgImageRenderEventContext, SatoriTransformer, VNode } from '../../../types';
+export declare function walkSatoriTree(e: OgImageRenderEventContext, node: VNode, plugins: (SatoriTransformer | SatoriTransformer[])[]): Promise<void>;
 export declare function defineSatoriTransformer(transformer: SatoriTransformer | SatoriTransformer[]): SatoriTransformer | SatoriTransformer[];

package/dist/runtime/core/renderers/satori/vnodes.d.ts

@@ -1,3 +1,2 @@
-import type { H3Event } from 'h3';
-import type { RendererOptions, VNode } from '../../../types';
-export declare function createVNodes(e: H3Event, options: RendererOptions): Promise<VNode>;
+import type { OgImageRenderEventContext, VNode } from '../../../types';
+export declare function createVNodes(ctx: OgImageRenderEventContext): Promise<VNode>;

package/dist/runtime/core/renderers/satori/vnodes.mjs

@@ -1,16 +1,26 @@
 import { html as convertHtmlToSatori } from "satori-html";
-import { fetchHTML } from "../../html/fetch.mjs";
+import { fetchIsland } from "../../html/fetchIsland.mjs";
+import { applyInlineCss } from "../../html/applyInlineCss.mjs";
+import { applyEmojis } from "../../html/applyEmojis.mjs";
 import { walkSatoriTree } from "./utils.mjs";
+import unocss from "./plugins/unocss.mjs";
 import emojis from "./plugins/emojis.mjs";
 import twClasses from "./plugins/twClasses.mjs";
 import imageSrc from "./plugins/imageSrc.mjs";
 import flex from "./plugins/flex.mjs";
 import encoding from "./plugins/encoding.mjs";
-export async function createVNodes(e, options) {
-  const html = options.html || await fetchHTML(e, options);
-  const body = html.match(/<body[^>]*>([\s\S]*)<\/body>/)?.[1] || html;
-  const satoriTree = convertHtmlToSatori(body);
-  await walkSatoriTree(e, satoriTree, [
+export async function createVNodes(ctx) {
+  let html = ctx.options.html;
+  if (!html) {
+    const island = await fetchIsland(ctx);
+    await applyInlineCss(ctx, island);
+    await applyEmojis(ctx, island);
+    html = island.html;
+  }
+  const template = `<div data-v-inspector-ignore="true" style="position: relative; display: flex; margin: 0 auto; width: ${ctx.options.width}px; height: ${ctx.options.height}px; overflow: hidden;">${html}</div>`;
+  const satoriTree = convertHtmlToSatori(template);
+  await walkSatoriTree(ctx, satoriTree, [
+    unocss,
     emojis,
     twClasses,
     imageSrc,

package/dist/runtime/core/utils/resolveRendererContext.d.ts

@@ -1,7 +1,3 @@
 import type { H3Error, H3Event } from 'h3';
-import type { Renderer, RuntimeOgImageOptions } from '../../types';
-export declare function resolveRendererContext(e: H3Event): Promise<H3Error | {
-    extension: RuntimeOgImageOptions['extension'];
-    renderer: Renderer;
-    options: RuntimeOgImageOptions;
-}>;
+import type { OgImageRenderEventContext } from '../../types';
+export declare function resolveRendererContext(e: H3Event): Promise<H3Error | OgImageRenderEventContext>;

package/dist/runtime/core/utils/resolveRendererContext.mjs

@@ -1,14 +1,15 @@
-import { parseURL, withoutBase, withoutLeadingSlash, withoutTrailingSlash } from "ufo";
+import { parseURL, withoutBase, withoutTrailingSlash } from "ufo";
 import { createError, getQuery } from "h3";
 import { defu } from "defu";
 import { createRouter as createRadixRouter, toRouteMatcher } from "radix3";
 import { fetchPathHtmlAndExtractOptions } from "../options/fetch.mjs";
-import { prerenderCache } from "../cache/prerender.mjs";
-import { useRuntimeConfig } from "#imports";
-const satoriRendererInstance = { instance: void 0 };
-const chromiumRendererInstance = { instance: void 0 };
+import { prerenderOptionsCache } from "../cache/prerender.mjs";
+import { useChromiumRenderer, useSatoriRenderer } from "../renderers/satori/instances.mjs";
+import { separateProps, useOgImageRuntimeConfig } from "../../utils.mjs";
+import { resolvePathCacheKey } from "../../nitro/utils.mjs";
+import { useNitroApp, useRuntimeConfig } from "#internal/nitro";
 export async function resolveRendererContext(e) {
-  const runtimeConfig = useRuntimeConfig()["nuxt-og-image"];
+  const runtimeConfig = useOgImageRuntimeConfig();
   const path = parseURL(e.path).pathname;
   const extension = path.split(".").pop();
   if (!extension) {
@@ -17,22 +18,29 @@ export async function resolveRendererContext(e) {
       statusMessage: `Missing OG Image type.`
     });
   }
+  if (!["png", "jpeg", "jpg", "svg", "html", "json"].includes(extension)) {
+    return createError({
+      statusCode: 400,
+      statusMessage: `Unknown OG Image type ${extension}.`
+    });
+  }
   const basePath = withoutTrailingSlash(
-    path.replace("/__og-image__/image", "").replace(`/og.${extension}`, "")
+    path.replace(`/__og-image__/image`, "").replace(`/og.${extension}`, "")
   );
-  const queryParams = { ...getQuery(e) };
+  let queryParams = { ...getQuery(e) };
+  queryParams.props = JSON.parse(queryParams.props || "{}");
+  queryParams = separateProps(queryParams);
+  const isDebugJsonPayload = extension === "json" && runtimeConfig.debug;
+  const key = resolvePathCacheKey(e, basePath);
   let options = queryParams.options;
   if (!options) {
-    if (import.meta.prerender) {
-      const key = [
-        withoutLeadingSlash(basePath === "/" || !basePath ? "index" : basePath).replaceAll("/", "-")
-      ].join(":");
-      options = await prerenderCache?.getItem(key);
-    } else {
-      const payloadOptions = await fetchPathHtmlAndExtractOptions(e, basePath);
-      if (payloadOptions instanceof Error)
-        return payloadOptions;
-      options = payloadOptions;
+    if (import.meta.prerender)
+      options = await prerenderOptionsCache?.getItem(key);
+    if (!options) {
+      const payload = await fetchPathHtmlAndExtractOptions(e, basePath, key);
+      if (payload instanceof Error)
+        return payload;
+      options = payload;
     }
   }
   delete queryParams.options;
@@ -41,8 +49,15 @@ export async function resolveRendererContext(e) {
   );
   const routeRules = defu({}, ..._routeRulesMatcher.matchAll(
     withoutBase(basePath.split("?")[0], useRuntimeConfig().app.baseURL)
-  ).reverse()).ogImage;
-  options = defu(queryParams, routeRules, options, runtimeConfig.defaults);
+  ).reverse());
+  if (typeof routeRules.ogImage === "undefined" && !options) {
+    return createError({
+      statusCode: 400,
+      statusMessage: "The route is missing the Nuxt OG Image payload or route rules."
+    });
+  }
+  const ogImageRouteRules = separateProps(routeRules.ogImage);
+  options = defu(queryParams, ogImageRouteRules, options, runtimeConfig.defaults);
   if (!options) {
     return createError({
       statusCode: 404,
@@ -52,25 +67,28 @@ export async function resolveRendererContext(e) {
   let renderer;
   switch (options.renderer) {
     case "satori":
-      renderer = satoriRendererInstance.instance = satoriRendererInstance.instance || await import("#nuxt-og-image/renderers/satori").then((m) => Object.keys(m.default).length ? m.default : false);
+      renderer = await useSatoriRenderer();
       break;
     case "chromium":
-      renderer = chromiumRendererInstance.instance = chromiumRendererInstance.instance || await import("#nuxt-og-image/renderers/chromium").then((m) => Object.keys(m.default).length ? m.default : false);
+      renderer = await useChromiumRenderer();
       break;
   }
-  if (!renderer) {
+  if (!renderer || renderer.__unenv__) {
     throw createError({
       statusCode: 400,
       statusMessage: `Renderer ${options.renderer} is missing.`
     });
   }
-  return {
+  const ctx = {
+    e,
+    key,
     renderer,
+    isDebugJsonPayload,
     extension,
-    options: {
-      ...options,
-      extension: extension === "json" ? options.extension : extension,
-      path: basePath
-    }
+    basePath,
+    options,
+    _nitro: useNitroApp()
   };
+  await ctx._nitro.hooks.callHook("nuxt-og-image:context", ctx);
+  return ctx;
 }

package/dist/runtime/core/utils/wasm.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+export declare function importWasm(input: any): Promise<any>;
+export declare function readWasmFile(input: string): Promise<Buffer>;

package/dist/runtime/core/utils/wasm.mjs

@@ -0,0 +1,16 @@
+import { readFile } from "node:fs/promises";
+import { resolvePath } from "mlly";
+export async function importWasm(input) {
+  const _input = await input;
+  const _module = _input.default || _input;
+  if (typeof _module === "function") {
+    const fnRes = await _module();
+    const _instance = fnRes.instance || fnRes;
+    return _instance.exports || _instance || _module;
+  }
+  return _module;
+}
+export async function readWasmFile(input) {
+  const path = await resolvePath(input);
+  return readFile(path);
+}

package/dist/runtime/nitro/plugins/nuxt-content.mjs

@@ -1,16 +1,15 @@
 import { defineNitroPlugin } from "nitropack/dist/runtime/plugin";
 import { defu } from "defu";
-import { getOgImagePath } from "../../utilts.mjs";
-import { useRuntimeConfig } from "#imports";
+import { getOgImagePath, useOgImageRuntimeConfig } from "../../utils.mjs";
 export default defineNitroPlugin((nitroApp) => {
   nitroApp.hooks.hook("content:file:afterParse", async (content) => {
     if (content._draft || content._extension !== "md" || content._partial || content.indexable === false || content.index === false)
       return;
     if (content.path && content.ogImage) {
       const ogImageConfig = typeof content.ogImage === "object" ? content.ogImage : {};
-      const { defaults } = useRuntimeConfig()["nuxt-og-image"];
+      const { defaults } = useOgImageRuntimeConfig();
       const optionsWithDefault = defu(ogImageConfig, defaults);
-      const src = getOgImagePath(content.path, optionsWithDefault.extension);
+      const src = getOgImagePath(content.path, optionsWithDefault);
       const payload = {
         title: content.title,
         excerpt: content.description || content.excerpt,
@@ -22,12 +21,14 @@ export default defineNitroPlugin((nitroApp) => {
       content.head = defu({
         script: [
           {
-            id: "nuxt-og-image-options",
+            id: "nuxt-og-image-overrides",
             type: "application/json",
             processTemplateParams: true,
             innerHTML: payload,
             // we want this to be last in our head
-            tagPosition: "bodyClose"
+            tagPosition: "bodyClose",
+            tagPriority: 30
+            // slighty higher priority
           }
         ],
         meta: [

package/dist/runtime/nitro/plugins/prerender.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("nitropack/dist/runtime/plugin").NitroAppPlugin;
+declare const _default: import("nitropack").NitroAppPlugin;
 export default _default;

package/dist/runtime/nitro/plugins/prerender.mjs

@@ -1,17 +1,27 @@
-import { parseURL, withoutLeadingSlash } from "ufo";
-import { getRouteRules } from "nitropack/dist/runtime/route-rules";
-import { extractAndNormaliseOgImageOptions } from "../../core/options/extract.mjs";
-import { prerenderCache, prerenderChromiumContext } from "../../core/cache/prerender.mjs";
-import { isInternalRoute } from "../../utilts.mjs";
+import { parseURL, withoutBase } from "ufo";
 import { defineNitroPlugin } from "nitropack/dist/runtime/plugin";
+import { createRouter as createRadixRouter, toRouteMatcher } from "radix3";
+import { defu } from "defu";
+import { extractAndNormaliseOgImageOptions } from "../../core/options/extract.mjs";
+import { prerenderOptionsCache } from "../../core/cache/prerender.mjs";
+import { isInternalRoute } from "../../utils.pure.mjs";
+import { resolvePathCacheKey } from "../utils.mjs";
+import { useRuntimeConfig } from "#internal/nitro";
 export default defineNitroPlugin(async (nitro) => {
   if (!import.meta.prerender)
     return;
-  nitro.hooks.hook("render:html", async ({ head, bodyAppend }, e) => {
-    const path = parseURL(e.event.path).pathname;
+  nitro.hooks.hook("render:html", async (html, ctx) => {
+    const { head, bodyAppend } = html;
+    const path = parseURL(ctx.event.path).pathname;
     if (isInternalRoute(path))
       return;
-    const routeRules = getRouteRules(e)?.ogImage || {};
+    const runtimeConfig = useRuntimeConfig();
+    const _routeRulesMatcher = toRouteMatcher(
+      createRadixRouter({ routes: runtimeConfig.nitro?.routeRules })
+    );
+    const routeRules = defu({}, ..._routeRulesMatcher.matchAll(
+      withoutBase(path.split("?")[0], runtimeConfig.app.baseURL)
+    ).reverse()).ogImage;
     if (routeRules === false)
       return;
     const options = extractAndNormaliseOgImageOptions([
@@ -20,15 +30,7 @@ export default defineNitroPlugin(async (nitro) => {
     ].join("\n"));
     if (!options)
       return;
-    const key = [
-      withoutLeadingSlash(path === "/" || !path ? "index" : path).replaceAll("/", "-")
-    ].join(":");
-    await prerenderCache.setItem(key, options);
-  });
-  nitro.hooks.hook("close", () => {
-    if (prerenderChromiumContext.browser) {
-      prerenderChromiumContext.browser.close();
-      prerenderChromiumContext.browser = void 0;
-    }
+    const key = resolvePathCacheKey(ctx.event);
+    await prerenderOptionsCache.setItem(key, options);
   });
 });

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

@@ -0,0 +1,2 @@
+import type { H3Event } from 'h3';
+export declare function resolvePathCacheKey(e: H3Event, path?: string): string;

package/dist/runtime/nitro/utils.mjs

@@ -0,0 +1,17 @@
+import { withoutLeadingSlash, withoutTrailingSlash } from "ufo";
+import { hash } from "ohash";
+import { normalizeKey } from "unstorage";
+import { getQuery } from "h3";
+import { useSiteConfig } from "#imports";
+export function resolvePathCacheKey(e, path) {
+  const siteConfig = useSiteConfig(e);
+  const basePath = withoutTrailingSlash(withoutLeadingSlash(normalizeKey(path || e.path)));
+  return [
+    !basePath ? "index" : basePath,
+    hash([
+      basePath,
+      siteConfig.url,
+      hash(getQuery(e))
+    ])
+  ].join(":");
+}

package/dist/runtime/nuxt/plugins/og-image-canonical-urls.server.mjs

@@ -0,0 +1,43 @@
+import { parseURL } from "ufo";
+import { toValue } from "vue";
+import { defu } from "defu";
+import { isInternalRoute, separateProps } from "../../utils.pure.mjs";
+import { defineNuxtPlugin, useRequestEvent, withSiteUrl } from "#imports";
+export default defineNuxtPlugin({
+  setup(nuxtApp) {
+    nuxtApp.hooks.hook("app:rendered", async (ctx) => {
+      const { ssrContext } = ctx;
+      const e = useRequestEvent();
+      const path = parseURL(e.path).pathname;
+      if (isInternalRoute(path))
+        return;
+      ssrContext?.head.use({
+        key: "nuxt-og-image:overrides-and-canonical-urls",
+        hooks: {
+          "tags:resolve": async (ctx2) => {
+            let overrides;
+            for (const tag of ctx2.tags) {
+              if (tag.tag === "script" && tag.props.id === "nuxt-og-image-overrides") {
+                overrides = separateProps(JSON.parse(tag.innerHTML || "{}"));
+                delete ctx2.tags[ctx2.tags.indexOf(tag)];
+                break;
+              }
+            }
+            ctx2.tags = ctx2.tags.filter(Boolean);
+            for (const tag of ctx2.tags) {
+              if (tag.tag === "meta" && (tag.props.property === "og:image" || tag.props.name === "twitter:image:src")) {
+                if (!tag.props.content.startsWith("https")) {
+                  await nuxtApp.runWithContext(() => {
+                    tag.props.content = toValue(withSiteUrl(tag.props.content));
+                  });
+                }
+              } else if (overrides && tag.tag === "script" && tag.props.id === "nuxt-og-image-options") {
+                tag.innerHTML = JSON.stringify(defu(overrides, JSON.parse(tag.innerHTML)));
+              }
+            }
+          }
+        }
+      });
+    });
+  }
+});

package/dist/runtime/nuxt/plugins/route-rule-og-image.server.mjs

@@ -1,9 +1,9 @@
 import { defu } from "defu";
 import { parseURL, withoutBase } from "ufo";
 import { createRouter as createRadixRouter, toRouteMatcher } from "radix3";
-import { normaliseOptions } from "../../core/options/normalise.mjs";
-import { getOgImagePath, isInternalRoute } from "../../utilts.mjs";
-import { defineNuxtPlugin, useRequestEvent, useRuntimeConfig } from "#imports";
+import { getOgImagePath, isInternalRoute, useOgImageRuntimeConfig } from "../../utils.mjs";
+import { createOgImageMeta, normaliseOptions } from "../utils.mjs";
+import { defineNuxtPlugin, useRequestEvent } from "#imports";
 export default defineNuxtPlugin((nuxtApp) => {
   nuxtApp.hooks.hook("app:rendered", async (ctx) => {
     const { ssrContext } = ctx;
@@ -14,59 +14,24 @@ export default defineNuxtPlugin((nuxtApp) => {
     const _routeRulesMatcher = toRouteMatcher(
       createRadixRouter({ routes: ssrContext?.runtimeConfig?.nitro?.routeRules })
     );
-    const routeRules = defu({}, ..._routeRulesMatcher.matchAll(
+    let routeRules = defu({}, ..._routeRulesMatcher.matchAll(
       withoutBase(path.split("?")[0], ssrContext?.runtimeConfig?.app.baseURL)
     ).reverse()).ogImage;
     if (typeof routeRules === "undefined")
       return;
-    const payloadIndex = ssrContext.head.headEntries().findIndex((entry) => {
-      return entry.input?.script?.[0]?.id === "nuxt-og-image-options";
-    });
-    if (payloadIndex >= 0 && routeRules === false) {
-      ssrContext.head.headEntries().splice(payloadIndex, 1);
+    const ogImageInstances = nuxtApp.ssrContext._ogImageInstances || [];
+    if (routeRules === false) {
+      ogImageInstances?.forEach((e2) => {
+        e2.dispose();
+      });
+      nuxtApp.ssrContext._ogImagePayload = void 0;
+      nuxtApp.ssrContext._ogImageInstances = void 0;
       return;
     }
-    if (payloadIndex >= 0)
-      return;
-    const options = normaliseOptions(routeRules);
-    const { defaults } = useRuntimeConfig()["nuxt-og-image"];
-    const optionsWithDefault = normaliseOptions(defu(options, defaults));
-    const src = getOgImagePath(ssrContext.url, optionsWithDefault.extension);
-    ssrContext?.head.push({
-      script: [
-        {
-          id: "nuxt-og-image-options",
-          type: "application/json",
-          processTemplateParams: true,
-          innerHTML: () => {
-            const payload = {
-              title: "%s"
-            };
-            Object.entries(options).forEach(([key, val]) => {
-              payload[key.replace(/-([a-z])/g, (g) => g[1].toUpperCase())] = val;
-            });
-            return payload;
-          },
-          // we want this to be last in our head
-          tagPosition: "bodyClose"
-        }
-      ],
-      meta: [
-        { property: "og:image", content: src },
-        { property: "og:image:width", content: optionsWithDefault.width },
-        { property: "og:image:height", content: optionsWithDefault.height },
-        { property: "og:image:type", content: `image/${optionsWithDefault.extension}` },
-        { property: "og:image:alt", content: optionsWithDefault.alt },
-        // twitter
-        { name: "twitter:card", content: "summary_large_image" },
-        { name: "twitter:image:src", content: src },
-        { name: "twitter:image:width", content: optionsWithDefault.width },
-        { name: "twitter:image:height", content: optionsWithDefault.height },
-        { name: "twitter:image:alt", content: optionsWithDefault.alt }
-      ]
-    }, {
-      mode: "server",
-      tagPriority: 35
-    });
+    routeRules = defu(nuxtApp.ssrContext?.event.context._nitro?.routeRules?.ogImage, routeRules);
+    const { defaults } = useOgImageRuntimeConfig();
+    const resolvedOptions = normaliseOptions(defu(routeRules, defaults));
+    const src = getOgImagePath(ssrContext.url, resolvedOptions);
+    createOgImageMeta(src, routeRules, resolvedOptions, nuxtApp.ssrContext);
   });
 });

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

@@ -0,0 +1,3 @@
+import type { DefineOgImageInput, OgImageOptions, OgImagePrebuilt } from '../types';
+export declare function createOgImageMeta(src: string | null, input: OgImageOptions | OgImagePrebuilt, resolvedOptions: OgImageOptions, ssrContext: Record<string, any>): void;
+export declare function normaliseOptions(_options: DefineOgImageInput): OgImageOptions | OgImagePrebuilt;

package/dist/runtime/nuxt/utils.mjs

@@ -0,0 +1,69 @@
+import { defu } from "defu";
+import { separateProps } from "../utils.mjs";
+import { unref, useServerHead } from "#imports";
+import { componentNames } from "#build/nuxt-og-image/components.mjs";
+export function createOgImageMeta(src, input, resolvedOptions, ssrContext) {
+  const _input = separateProps(defu(input, ssrContext._ogImagePayload));
+  const url = src || input.url || resolvedOptions.url;
+  let urlExtension = (url.split("/").pop() || url).split(".").pop() || resolvedOptions.extension;
+  if (urlExtension === "jpg")
+    urlExtension = "jpeg";
+  const meta = [
+    { property: "og:image", content: url },
+    { property: "og:image:type", content: `image/${urlExtension}` },
+    { name: "twitter:card", content: "summary_large_image" },
+    { name: "twitter:image:src", content: url }
+  ];
+  if (resolvedOptions.width) {
+    meta.push({ property: "og:image:width", content: resolvedOptions.width });
+    meta.push({ name: "twitter:image:width", content: resolvedOptions.width });
+  }
+  if (resolvedOptions.height) {
+    meta.push({ property: "og:image:height", content: resolvedOptions.height });
+    meta.push({ name: "twitter:image:height", content: resolvedOptions.height });
+  }
+  if (resolvedOptions.alt) {
+    meta.push({ property: "og:image:alt", content: resolvedOptions.alt });
+    meta.push({ name: "twitter:image:alt", content: resolvedOptions.alt });
+  }
+  ssrContext._ogImageInstances = ssrContext._ogImageInstances || [];
+  const script = [];
+  if (src) {
+    script.push({
+      id: "nuxt-og-image-options",
+      type: "application/json",
+      processTemplateParams: true,
+      innerHTML: () => {
+        if (!_input.props.title)
+          _input.props.title = "%s";
+        delete _input.url;
+        return _input;
+      },
+      // we want this to be last in our head
+      tagPosition: "bodyClose"
+    });
+  }
+  const instance = useServerHead({
+    script,
+    meta
+  }, {
+    tagPriority: 35
+  });
+  ssrContext._ogImagePayload = _input;
+  ssrContext._ogImageInstances.push(instance);
+}
+export function normaliseOptions(_options) {
+  const options = { ...unref(_options) };
+  if (!options)
+    return options;
+  if (options.component && componentNames) {
+    const originalName = options.component;
+    for (const component of componentNames) {
+      if (component.pascalName.endsWith(originalName) || component.kebabName.endsWith(originalName)) {
+        options.component = component.pascalName;
+        break;
+      }
+    }
+  }
+  return options;
+}

package/dist/runtime/server/routes/__og-image__/debug.json.d.ts

@@ -4,8 +4,7 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
         source: any;
     };
     componentNames: any;
-    runtimeConfig: any;
-    baseCacheKey: string;
-    cachedKeys: string[];
+    runtimeConfig: import("../../../types").OgImageRuntimeConfig;
+    compatibility: any;
 }>>;
 export default _default;

package/dist/runtime/server/routes/__og-image__/debug.json.mjs

@@ -1,13 +1,12 @@
 import { defineEventHandler, setHeader } from "h3";
-import { prefixStorage } from "unstorage";
-import { useRuntimeConfig, useSiteConfig, useStorage } from "#imports";
+import { useOgImageRuntimeConfig } from "../../../utils.mjs";
+import { useSiteConfig } from "#imports";
+import compatibility from "#nuxt-og-image/compatibility";
 import { componentNames } from "#nuxt-og-image/component-names.mjs";
 export default defineEventHandler(async (e) => {
   setHeader(e, "Content-Type", "application/json");
-  const runtimeConfig = useRuntimeConfig()["nuxt-og-image"];
+  const runtimeConfig = useOgImageRuntimeConfig();
   const siteConfig = await useSiteConfig(e, { debug: true });
-  const baseCacheKey = runtimeConfig.runtimeCacheStorage === "default" ? `/cache/nuxt-og-image@${runtimeConfig.version}` : `/nuxt-og-image@${runtimeConfig.version}`;
-  const cache = prefixStorage(useStorage(), `${baseCacheKey}/`);
   return {
     siteConfigUrl: {
       value: siteConfig.url,
@@ -15,7 +14,6 @@ export default defineEventHandler(async (e) => {
     },
     componentNames,
     runtimeConfig,
-    baseCacheKey,
-    cachedKeys: await cache.getKeys()
+    compatibility
   };
 });