nuxt-og-image 3.0.0-beta.10 → 3.0.0-beta.14

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,24 @@
 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 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, [
     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,11 +2,11 @@ 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 { useRuntimeConfig, useSiteConfig } from "#imports";
 export async function resolveRendererContext(e) {
   const runtimeConfig = useRuntimeConfig()["nuxt-og-image"];
   const path = parseURL(e.path).pathname;
@@ -17,22 +17,35 @@ 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) };
+  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 +54,8 @@ 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());
+  options = defu(queryParams, routeRules.ogImage, options, runtimeConfig.defaults);
   if (!options) {
     return createError({
       statusCode: 404,
@@ -52,25 +65,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,6 @@
+export async function importWasm(input) {
+  const _input = await input;
+  const _module = _input.default || _input;
+  const _instance = typeof _module === "function" ? await _module({}).then((r) => r.instance || r) : await WebAssembly.instantiate(_module, {});
+  return _instance.exports;
+}

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

@@ -1,6 +1,6 @@
 import { defineNitroPlugin } from "nitropack/dist/runtime/plugin";
 import { defu } from "defu";
-import { getOgImagePath } from "../../utilts.mjs";
+import { getOgImagePath } from "../../utils.mjs";
 import { useRuntimeConfig } from "#imports";
 export default defineNitroPlugin((nitroApp) => {
   nitroApp.hooks.hook("content:file:afterParse", async (content) => {
@@ -10,7 +10,7 @@ export default defineNitroPlugin((nitroApp) => {
       const ogImageConfig = typeof content.ogImage === "object" ? content.ogImage : {};
       const { defaults } = useRuntimeConfig()["nuxt-og-image"];
       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.mjs

@@ -1,9 +1,9 @@
 import { parseURL, withoutLeadingSlash } from "ufo";
 import { getRouteRules } from "nitropack/dist/runtime/route-rules";
+import { defineNitroPlugin } from "nitropack/dist/runtime/plugin";
 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.mjs";
 export default defineNitroPlugin(async (nitro) => {
   if (!import.meta.prerender)
     return;

package/dist/runtime/nuxt/plugins/nuxt-content-canonical-urls.mjs

@@ -1,6 +1,6 @@
 import { parseURL } from "ufo";
 import { toValue } from "vue";
-import { isInternalRoute } from "../../utilts.mjs";
+import { isInternalRoute } from "../../utils.mjs";
 import { useRequestEvent, withSiteUrl } from "#imports";
 export default defineNuxtPlugin((nuxtApp) => {
   nuxtApp.hooks.hook("app:rendered", async (ctx) => {

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

@@ -2,7 +2,8 @@ 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 { getOgImagePath, isInternalRoute } from "../../utils.mjs";
+import { createOgImageMeta } from "../utils.mjs";
 import { defineNuxtPlugin, useRequestEvent, useRuntimeConfig } from "#imports";
 export default defineNuxtPlugin((nuxtApp) => {
   nuxtApp.hooks.hook("app:rendered", async (ctx) => {
@@ -14,59 +15,25 @@ 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._ogImageInstances = void 0;
       return;
     }
-    if (payloadIndex >= 0)
+    if (ogImageInstances.length >= 0)
       return;
-    const options = normaliseOptions(routeRules);
+    routeRules = defu(nuxtApp.ssrContext?.event.context._nitro?.routeRules?.ogImage, 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
-    });
+    const resolvedOptions = normaliseOptions(defu(routeRules, defaults));
+    const src = getOgImagePath(ssrContext.url, resolvedOptions);
+    createOgImageMeta(src, {}, 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,55 @@
+import { useServerHead } from "#imports";
+export function createOgImageMeta(src, input, resolvedOptions, ssrContext) {
+  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: () => {
+        const payload = {
+          title: "%s"
+        };
+        delete input.url;
+        Object.entries({ ...input, url: void 0 }).forEach(([key, val]) => {
+          if (typeof val !== "undefined") {
+            payload[key.replace(/-([a-z])/g, (g) => g[1].toUpperCase())] = val;
+          }
+        });
+        return payload;
+      },
+      // we want this to be last in our head
+      tagPosition: "bodyClose"
+    });
+  }
+  const instance = useServerHead({
+    script,
+    meta
+  }, {
+    tagPriority: 35
+  });
+  ssrContext._ogImageInstances.push(instance);
+}

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

@@ -5,7 +5,5 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
     };
     componentNames: any;
     runtimeConfig: any;
-    baseCacheKey: string;
-    cachedKeys: string[];
 }>>;
 export default _default;

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

@@ -1,21 +1,16 @@
 import { defineEventHandler, setHeader } from "h3";
-import { prefixStorage } from "unstorage";
-import { useRuntimeConfig, useSiteConfig, useStorage } from "#imports";
+import { useRuntimeConfig, 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 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,86 @@
+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 { useRuntimeConfig, 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 } = useRuntimeConfig()["nuxt-og-image"];
+  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;
+});

package/dist/runtime/types.d.ts

@@ -1,9 +1,19 @@
-/// <reference types="node" />
-import type { Buffer } from 'node:buffer';
 import type { html } from 'satori-html';
 import type { H3Error, H3Event } from 'h3';
 import type { ResvgRenderOptions } from '@resvg/resvg-js';
 import type { SatoriOptions } from 'satori';
+import type { AllowedComponentProps, Component, ComponentCustomProps, VNodeProps } from '@vue/runtime-core';
+import type { OgImageComponents } from '#nuxt-og-image/components';
+export interface H3EventOgImageRender {
+    e: H3Event;
+    extension: 'png' | 'jpeg' | 'jpg' | 'svg' | 'html' | 'json';
+    key: string;
+    basePath: string;
+    renderer: Renderer;
+    options: OgImageOptions;
+    isDebugJsonPayload: boolean;
+}
+export type IconifyEmojiIconSets = 'twemoji' | 'noto' | 'fluent-emoji' | 'fluent-emoji-flat' | 'fluent-emoji-high-contrast' | 'noto-v1' | 'emojione' | 'emojione-monotone' | 'emojione-v1' | 'streamline-emojis' | 'openmoji';
 export interface OgImageComponent {
     path?: string;
     pascalName: string;
@@ -33,31 +43,52 @@ export interface ScreenshotOptions {
      */
     delay?: number;
 }
-export interface OgImageOptions extends Partial<ScreenshotOptions> {
-    component?: string;
-    renderer?: 'chromium' | 'satori';
-    extension?: 'png' | 'jpeg' | 'jpg';
+export type OgImagePrebuilt = {
+    url: string;
+} & Pick<OgImageOptions, 'width' | 'height' | 'alt'>;
+export type DefineOgImageInput = OgImageOptions | OgImagePrebuilt | false;
+export interface OgImageOptions<T extends keyof OgImageComponents = 'Fallback'> {
+    /**
+     * The width of the screenshot.
+     *
+     * @default 1200
+     */
+    width?: number;
+    /**
+     * The height of the screenshot.
+     *
+     * @default 630
+     */
+    height?: number;
     /**
-     * @deprecated use renderer. Replace `browser` with `chromium`
+     * The alt text for the image.
      */
-    provider?: 'browser' | 'satori';
+    alt?: string;
+    /**
+     * Use a prebuilt image instead of generating one.
+     *
+     * Should be an absolute URL.
+     */
+    url?: string;
+    /**
+     * The name of the component to render.
+     */
+    component?: T | string;
+    /**
+     * Props to pass to the component.
+     */
+    props?: OgImageComponents[T] | Record<string, any>;
+    renderer?: 'chromium' | 'satori';
+    extension?: 'png' | 'jpeg' | 'jpg';
+    emojis?: IconifyEmojiIconSets;
     /**
      * Provide a static HTML template to render the OG Image instead of a component.
      */
     html?: string;
-    cache?: boolean;
-    cacheKey?: string;
     resvg?: ResvgRenderOptions;
     satori?: SatoriOptions;
-    /**
-     * The time to live of the cache in milliseconds.
-     */
-    cacheTtl?: number;
-    [key: string]: any;
-}
-export interface RuntimeOgImageOptions extends Omit<OgImageOptions, 'extension'> {
-    extension: 'png' | 'jpeg' | 'jpg' | 'svg' | 'json' | 'html';
-    path: string;
+    screenshot?: Partial<ScreenshotOptions>;
+    cacheMaxAgeSeconds?: number;
 }
 export interface FontConfig {
     name: string;
@@ -65,17 +96,19 @@ export interface FontConfig {
     path?: string;
 }
 export type InputFontConfig = (`${string}:${number}` | FontConfig);
-export type RendererOptions = Omit<RuntimeOgImageOptions, 'extension'> & {
-    extension: Omit<RuntimeOgImageOptions['extension'], 'html'>;
+export type RendererOptions = Omit<OgImageOptions, 'extension'> & {
+    extension: Omit<OgImageOptions['extension'], 'html'>;
 };
 export interface Renderer {
     name: 'chromium' | 'satori';
     supportedFormats: Partial<RendererOptions['extension']>[];
-    createImage: (e: H3Event, options: RendererOptions) => Promise<H3Error | Buffer>;
+    createImage: (e: H3EventOgImageRender) => Promise<H3Error | BufferSource | void>;
+    debug: (e: H3EventOgImageRender) => Promise<Record<string, any>>;
 }
-export type OgImageScreenshotOptions = Omit<OgImageOptions, 'component'>;
+export type ExtractComponentProps<T extends Component> = T extends new (...args: any) => any ? Omit<InstanceType<T>['$props'], keyof ComponentCustomProps | keyof VNodeProps | keyof AllowedComponentProps> : never;
+export type OgImagePageScreenshotOptions = Omit<OgImageOptions, 'html' | 'renderer' | 'component' | 'satori' | 'resvg' | 'sharp'>;
 export type VNode = ReturnType<typeof html>;
 export interface SatoriTransformer {
     filter: (node: VNode) => boolean;
-    transform: (node: VNode, e: H3Event) => Promise<void>;
+    transform: (node: VNode, e: H3EventOgImageRender) => Promise<void>;
 }

package/dist/runtime/utils.d.ts

@@ -0,0 +1,3 @@
+import type { OgImageOptions } from './types';
+export declare function getOgImagePath(pagePath: string, _options?: Partial<OgImageOptions>): string;
+export declare function isInternalRoute(path: string): boolean;

package/dist/runtime/utils.mjs

@@ -0,0 +1,11 @@
+import { joinURL } from "ufo";
+import { defu } from "defu";
+import { useRuntimeConfig } from "#imports";
+export function getOgImagePath(pagePath, _options) {
+  const options = defu(_options, useRuntimeConfig()["nuxt-og-image"].defaults);
+  return joinURL("/__og-image__/image", pagePath, `og.${options.extension}`);
+}
+export function isInternalRoute(path) {
+  const lastSegment = path.split("/").pop() || path;
+  return lastSegment.includes(".") || path.startsWith("/__") || path.startsWith("@");
+}