nuxt-og-image 3.0.0-beta.3 → 3.0.0-beta.30

package/dist/runtime/core/renderers/satori/plugins/imageSrc.mjs

@@ -6,8 +6,9 @@ import { toBase64Image } from "../../../env/assets.mjs";
 import { useNitroOrigin } from "#imports";
 export default defineSatoriTransformer({
   filter: (node) => node.type === "img",
-  transform: async (node, e) => {
+  transform: async (node, { e }) => {
     const src = node.props?.src;
+    const isRelative = src?.startsWith("/");
     if (src) {
       let updated = false;
       let dimensions;
@@ -21,8 +22,11 @@ export default defineSatoriTransformer({
         });
         if (valid) {
           node.props.src = toBase64Image(src, response);
-          const imageSize = sizeOf(Buffer.from(response));
-          dimensions = { width: imageSize.width, height: imageSize.height };
+          try {
+            const imageSize = sizeOf(Buffer.from(response));
+            dimensions = { width: imageSize.width, height: imageSize.height };
+          } catch (e2) {
+          }
           updated = true;
         }
       }
@@ -37,7 +41,7 @@ export default defineSatoriTransformer({
           node.props.height = dimensions.height;
         }
       }
-      if (!updated) {
+      if (!updated && isRelative) {
         node.props.src = `${withBase(src, `${useNitroOrigin(e)}`)}?${Date.now()}`;
       }
     }

package/dist/runtime/core/renderers/satori/plugins/unocss.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../../../types").SatoriTransformer | import("../../../../types").SatoriTransformer[];
+export default _default;

package/dist/runtime/core/renderers/satori/plugins/unocss.mjs

@@ -0,0 +1,38 @@
+import { createGenerator } from "@unocss/core";
+import presetWind from "@unocss/preset-wind";
+import { defineSatoriTransformer } from "../utils.mjs";
+import { theme } from "#nuxt-og-image/unocss-config.mjs";
+const uno = createGenerator({ theme }, {
+  presets: [
+    presetWind()
+  ]
+});
+export default defineSatoriTransformer({
+  filter: (node) => !!node.props?.class,
+  transform: async (node) => {
+    const classes = node.props.class || "";
+    const styles = node.props.style || {};
+    const replacedClasses = /* @__PURE__ */ new Set();
+    for (const token of classes.split(" ").filter((c) => c.trim())) {
+      const parsedToken = await uno.parseToken(token);
+      if (parsedToken) {
+        const inlineStyles = parsedToken[0][2].split(";").filter((s) => !!s?.trim());
+        const vars = {};
+        inlineStyles.filter((s) => s.startsWith("--")).forEach((s) => {
+          const [key, value] = s.split(":");
+          vars[key] = value;
+        });
+        inlineStyles.filter((s) => !s.startsWith("--")).forEach((s) => {
+          const [key, value] = s.split(":");
+          const camelCasedKey = key.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+          if (!styles[camelCasedKey])
+            styles[camelCasedKey] = value.replace(/var\((.*?)\)/g, (_, k) => vars[k.trim()]);
+        });
+        replacedClasses.add(token);
+      }
+    }
+    node.props.class = classes.split(" ").filter((c) => !replacedClasses.has(c)).join(" ");
+    node.props.tw = classes.split(" ").filter((c) => !replacedClasses.has(c)).join(" ");
+    node.props.style = styles;
+  }
+});

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 { H3EventOgImageRender, SatoriTransformer, VNode } from '../../../types';
+export declare function walkSatoriTree(e: H3EventOgImageRender, 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 { H3EventOgImageRender, VNode } from '../../../types';
+export declare function createVNodes(ctx: H3EventOgImageRender): 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 { H3EventOgImageRender } from '../../types';
+export declare function resolveRendererContext(e: H3Event): Promise<H3Error | H3EventOgImageRender>;

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

@@ -2,13 +2,14 @@ import { parseURL, withoutBase, withoutLeadingSlash, withoutTrailingSlash } from
 import { createError, getQuery } from "h3";
 import { defu } from "defu";
 import { createRouter as createRadixRouter, toRouteMatcher } from "radix3";
+import { hash } from "ohash";
 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 { useChromiumRenderer, useSatoriRenderer } from "../renderers/satori/instances.mjs";
+import { separateProps, useOgImageRuntimeConfig } from "../../utils.mjs";
+import { useRuntimeConfig, useSiteConfig } from "#imports";
 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,37 @@ 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 siteConfig = useSiteConfig(e);
+  const key = [
+    withoutLeadingSlash(basePath === "/" || !basePath ? "index" : basePath).replaceAll("/", "-"),
+    hash([
+      basePath,
+      siteConfig.url,
+      hash(queryParams)
+    ])
+  ].join(":");
   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;
+      const payload = await fetchPathHtmlAndExtractOptions(e, basePath, key);
+      if (payload instanceof Error)
+        return payload;
+      options = payload;
     }
   }
   delete queryParams.options;
@@ -41,8 +57,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 +75,25 @@ 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 {
+    e,
+    key,
     renderer,
+    isDebugJsonPayload,
     extension,
-    options: {
-      ...options,
-      extension: extension === "json" ? options.extension : extension,
-      path: basePath
-    }
+    basePath,
+    options
   };
 }

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

@@ -0,0 +1 @@
+export declare function importWasm(input: any): Promise<any>;

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

@@ -0,0 +1,10 @@
+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;
+}

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,

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,9 +1,11 @@
-import { parseURL, withoutLeadingSlash } from "ufo";
-import { getRouteRules } from "nitropack/dist/runtime/route-rules";
+import { parseURL, withoutBase, withoutLeadingSlash } 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 { prerenderCache, prerenderChromiumContext } from "../../core/cache/prerender.mjs";
-import { isInternalRoute } from "../../utilts.mjs";
-import { defineNitroPlugin } from "nitropack/dist/runtime/plugin";
+import { isInternalRoute } from "../../utils.pure.mjs";
+import { useRuntimeConfig } from "#imports";
 export default defineNitroPlugin(async (nitro) => {
   if (!import.meta.prerender)
     return;
@@ -11,7 +13,13 @@ export default defineNitroPlugin(async (nitro) => {
     const path = parseURL(e.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([

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

@@ -0,0 +1,31 @@
+import { parseURL } from "ufo";
+import { toValue } from "vue";
+import { isInternalRoute } 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:canonical-urls",
+        hooks: {
+          "tags:resolve": async ({ tags }) => {
+            for (const tag of 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));
+                  });
+                }
+              }
+            }
+          }
+        }
+      });
+    });
+  }
+});

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

@@ -2,8 +2,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 } from "../utils.mjs";
+import { defineNuxtPlugin, useRequestEvent } from "#imports";
 export default defineNuxtPlugin((nuxtApp) => {
   nuxtApp.hooks.hook("app:rendered", async (ctx) => {
     const { ssrContext } = ctx;
@@ -14,59 +15,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,2 @@
+import type { OgImageOptions, OgImagePrebuilt } from '../types';
+export declare function createOgImageMeta(src: string | null, input: OgImageOptions | OgImagePrebuilt, resolvedOptions: OgImageOptions, ssrContext: Record<string, any>): void;

package/dist/runtime/nuxt/utils.mjs

@@ -0,0 +1,53 @@
+import { defu } from "defu";
+import { separateProps } from "../utils.mjs";
+import { useServerHead } from "#imports";
+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);
+}

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

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

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

@@ -1,21 +1,17 @@
 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 { 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,
       source: siteConfig._context.url || "unknown"
     },
     componentNames,
-    runtimeConfig,
-    baseCacheKey,
-    cachedKeys: await cache.getKeys()
+    runtimeConfig
   };
 });

package/dist/runtime/server/routes/__og-image__/image.mjs

@@ -0,0 +1,87 @@
+import { H3Error, createError, defineEventHandler, getQuery, setHeader } from "h3";
+import { resolveRendererContext } from "../../../core/utils/resolveRendererContext.mjs";
+import { fetchIsland } from "../../../core/html/fetchIsland.mjs";
+import { devIframeTemplate } from "../../../core/html/devIframeTemplate.mjs";
+import { applyInlineCss } from "../../../core/html/applyInlineCss.mjs";
+import { useOgImageBufferCache } from "../../../cache.mjs";
+import { useOgImageRuntimeConfig } from "../../../utils.mjs";
+import { useSiteConfig } from "#imports";
+export default defineEventHandler(async (e) => {
+  const ctx = await resolveRendererContext(e);
+  if (ctx instanceof H3Error)
+    return ctx;
+  const { isDebugJsonPayload, extension, options, renderer } = ctx;
+  const { debug, baseCacheKey } = useOgImageRuntimeConfig();
+  const compatibility = [];
+  if (isDebugJsonPayload) {
+    const queryExtension = getQuery(e).extension || ctx.options.extension;
+    if (["jpeg", "jpg"].includes(queryExtension) && options.renderer === "satori")
+      compatibility.push("Converting PNGs to JPEGs requires Sharp which only runs on Node based systems.");
+    if (options.renderer === "chromium")
+      compatibility.push("Using Chromium to generate images is only supported in Node based environments. It's recommended to only use this if you're prerendering");
+    if (await applyInlineCss(ctx, await fetchIsland(ctx)))
+      compatibility.push("Inlining CSS is only supported in Node based environments.");
+    setHeader(e, "Content-Type", "application/json");
+    return {
+      compatibility,
+      ...ctx,
+      siteConfig: useSiteConfig(e),
+      ...options.renderer === "satori" ? await renderer.debug(ctx) : void 0
+    };
+  }
+  switch (extension) {
+    case "html":
+      setHeader(e, "Content-Type", `text/html`);
+      return devIframeTemplate(ctx);
+    case "svg":
+      if (!debug && !import.meta.dev) {
+        return createError({
+          statusCode: 404
+        });
+      }
+      if (ctx.renderer.name !== "satori") {
+        return createError({
+          statusCode: 400,
+          statusMessage: `Generating ${extension}'s with ${renderer.name} is not supported.`
+        });
+      }
+      setHeader(e, "Content-Type", `image/svg+xml`);
+      return (await ctx.renderer.debug(ctx)).svg;
+    case "png":
+    case "jpeg":
+    case "jpg":
+      if (!renderer.supportedFormats.includes(extension)) {
+        return createError({
+          statusCode: 400,
+          statusMessage: `Generating ${extension}'s with ${renderer.name} is not supported.`
+        });
+      }
+      setHeader(e, "Content-Type", `image/${extension === "jpg" ? "jpeg" : extension}`);
+      break;
+    default:
+      return createError({
+        statusCode: 400,
+        statusMessage: `Invalid request for og.${extension}.`
+      });
+  }
+  const cacheApi = await useOgImageBufferCache(ctx, {
+    cacheMaxAgeSeconds: ctx.options.cacheMaxAgeSeconds,
+    baseCacheKey
+  });
+  if (typeof cacheApi === "undefined")
+    return;
+  let image = cacheApi.cachedItem;
+  if (!image) {
+    image = await renderer.createImage(ctx);
+    if (image instanceof H3Error)
+      return image;
+    if (!image) {
+      return createError({
+        statusCode: 500,
+        statusMessage: `Failed to generate og.${extension}.`
+      });
+    }
+    await cacheApi.update(image);
+  }
+  return image;
+});