nuxt-og-image 3.0.0-rc.66 → 3.0.0-rc.68

package/dist/runtime/nitro/util/eventHandlers.js

@@ -0,0 +1,155 @@
+import { createError, getQuery, H3Error, proxyRequest, sendRedirect, setHeader, setResponseHeader } from "h3";
+import { parseURL } from "ufo";
+import { normaliseFontInput, useOgImageRuntimeConfig } from "../../shared.js";
+import { resolveContext } from "../og-image/context.js";
+import { assets } from "../og-image/satori/font.js";
+import { html } from "../og-image/templates/html.js";
+import { useOgImageBufferCache } from "./cache.js";
+export async function fontEventHandler(e) {
+  const path = parseURL(e.path).pathname;
+  const { fonts } = useOgImageRuntimeConfig();
+  const key = path.split("/font/")[1];
+  if (key.includes(":")) {
+    const font2 = fonts.find((f) => f.key === key);
+    if (font2?.key && await assets.hasItem(font2.key)) {
+      let fontData = await assets.getItem(font2.key);
+      if (fontData instanceof Uint8Array) {
+        const decoder = new TextDecoder();
+        fontData = decoder.decode(fontData);
+      }
+      if (key.includes(".oft")) {
+        setResponseHeader(e, "Content-Type", "font/otf");
+      } else if (key.includes(".woff2")) {
+        setResponseHeader(e, "Content-Type", "font/woff2");
+      } else if (key.includes(".ttf")) {
+        setResponseHeader(e, "Content-Type", "font/ttf");
+      }
+      return Buffer.from(fontData, "base64");
+    }
+  }
+  const [_name, _weight] = key.split(".")[0].split("/");
+  if (!_name || !_weight)
+    return "Provide a font name and weight";
+  const name = _name[0].toUpperCase() + _name.slice(1);
+  const weight = Math.round(Number.parseInt(_weight) / 100) * 100;
+  const config = useOgImageRuntimeConfig();
+  const normalisedFonts = normaliseFontInput(config.fonts);
+  let font;
+  if (typeof getQuery(e).font === "string")
+    font = JSON.parse(getQuery(e).font);
+  if (!font) {
+    font = normalisedFonts.find((font2) => {
+      return font2.name.toLowerCase() === name.toLowerCase() && weight === Number(font2.weight);
+    });
+  }
+  if (!font) {
+    return createError({
+      statusCode: 404,
+      statusMessage: `[Nuxt OG Image] Font ${name}:${weight} not found`
+    });
+  }
+  const css = await globalThis.$fetch(`https://fonts.googleapis.com/css2?family=${name}:wght@${weight}`, {
+    headers: {
+      // Make sure it returns TTF.
+      "User-Agent": "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_6_8; de-at) AppleWebKit/533.21.1 (KHTML, like Gecko) Version/5.0.5 Safari/533.21.1"
+    }
+  });
+  if (!css) {
+    return createError({
+      statusCode: 500,
+      statusMessage: `[Nuxt OG Image] Invalid Google Font ${name}:${weight}`
+    });
+  }
+  const ttfResource = css.match(/src: url\((.+)\) format\('(opentype|truetype)'\)/);
+  if (ttfResource?.[1])
+    return proxyRequest(e, ttfResource[1], {});
+  const woff2Resource = css.match(/src: url\((.+)\) format\('woff2'\)/);
+  if (woff2Resource?.[1])
+    return sendRedirect(e, woff2Resource[1]);
+  return createError({
+    statusCode: 500,
+    statusMessage: `[Nuxt OG Image] Malformed Google Font CSS ${css}`
+  });
+}
+export async function imageEventHandler(e) {
+  const ctx = await resolveContext(e);
+  if (ctx instanceof H3Error)
+    return ctx;
+  const { isDebugJsonPayload, extension, options, renderer } = ctx;
+  const { debug, baseCacheKey } = useOgImageRuntimeConfig();
+  const compatibilityHints = [];
+  if (isDebugJsonPayload) {
+    const queryExtension = getQuery(e).extension || ctx.options.extension;
+    if (["jpeg", "jpg"].includes(queryExtension) && options.renderer === "satori")
+      compatibilityHints.push("Converting PNGs to JPEGs requires Sharp which only runs on Node based systems.");
+    if (options.renderer === "chromium")
+      compatibilityHints.push("Using Chromium to generate images is only supported in Node based environments. It's recommended to only use this if you're prerendering");
+    setHeader(e, "Content-Type", "application/json");
+    return {
+      siteConfig: {
+        url: e.context.siteConfig.get().url
+      },
+      compatibilityHints,
+      cacheKey: ctx.key,
+      options: ctx.options,
+      ...options.renderer === "satori" ? await renderer.debug(ctx) : void 0
+    };
+  }
+  switch (extension) {
+    case "html":
+      setHeader(e, "Content-Type", `text/html`);
+      return html(ctx);
+    case "svg":
+      if (!debug && !import.meta.dev) {
+        return createError({
+          statusCode: 404
+        });
+      }
+      if (ctx.renderer.name !== "satori") {
+        return createError({
+          statusCode: 400,
+          statusMessage: `[Nuxt OG Image] 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: `[Nuxt OG Image] 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: `[Nuxt OG Image] Invalid request for og.${extension}.`
+      });
+  }
+  const cacheApi = await useOgImageBufferCache(ctx, {
+    cacheMaxAgeSeconds: ctx.options.cacheMaxAgeSeconds,
+    baseCacheKey
+  });
+  if (typeof cacheApi === "undefined")
+    return;
+  if (cacheApi instanceof H3Error)
+    return cacheApi;
+  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/nitro/util/kit.d.ts

@@ -1,5 +1,5 @@
-import type { NitroRouteRules } from 'nitropack';
 import type { H3Event } from 'h3';
+import type { NitroRouteRules } from 'nitropack';
 import type { NuxtIslandResponse } from 'nuxt/dist/core/runtime/nitro/renderer';
 export declare function fetchIsland(e: H3Event, component: string, props: Record<string, any>): Promise<NuxtIslandResponse>;
 export declare function withoutQuery(path: string): string;

package/dist/runtime/nitro/util/kit.js

@@ -1,8 +1,8 @@
-import { createRouter as createRadixRouter, toRouteMatcher } from "radix3";
+import { useRuntimeConfig } from "#imports";
 import { defu } from "defu";
-import { withoutBase, withoutTrailingSlash } from "ufo";
 import { hash } from "ohash";
-import { useRuntimeConfig } from "#imports";
+import { createRouter as createRadixRouter, toRouteMatcher } from "radix3";
+import { withoutBase, withoutTrailingSlash } from "ufo";
 export function fetchIsland(e, component, props) {
   const hashId = hash([component, props]);
   return e.$fetch(`/__nuxt_island/${component}_${hashId}.json`, {

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

@@ -0,0 +1,2 @@
+import type { NitroApp } from 'nitropack';
+export declare function nuxtContentPlugin(nitroApp: NitroApp): void;

package/dist/runtime/nitro/util/plugins.js

@@ -0,0 +1,54 @@
+import { defu } from "defu";
+import { stringify } from "devalue";
+import { getOgImagePath, useOgImageRuntimeConfig } from "../../shared.js";
+export function nuxtContentPlugin(nitroApp) {
+  const { isNuxtContentDocumentDriven, defaults } = useOgImageRuntimeConfig();
+  nitroApp.hooks.hook("content:file:afterParse", async (content) => {
+    if (content._draft || content._extension !== "md" || content._partial || content.indexable === false || content.index === false)
+      return;
+    let path = content.path;
+    if (isNuxtContentDocumentDriven)
+      path = content._path;
+    if (path && content.ogImage) {
+      const ogImageConfig = typeof content.ogImage === "object" ? content.ogImage : {};
+      const optionsWithDefault = defu(ogImageConfig, defaults);
+      const src = getOgImagePath(path, optionsWithDefault);
+      const payload = {
+        title: content.title,
+        excerpt: content.description || content.excerpt,
+        ...content.ogImage
+      };
+      Object.entries(ogImageConfig).forEach(([key, val]) => {
+        payload[key.replace(/-([a-z])/g, (g) => g[1].toUpperCase())] = val;
+      });
+      content.head = defu({
+        script: [
+          {
+            id: "nuxt-og-image-overrides",
+            type: "application/json",
+            processTemplateParams: true,
+            innerHTML: stringify(payload),
+            // we want this to be last in our head
+            tagPosition: "bodyClose",
+            tagPriority: 30
+            // slighty higher priority
+          }
+        ],
+        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 }
+        ]
+      });
+    }
+    return content;
+  });
+}

package/dist/runtime/nuxt/components/OgImage/OgImage.d.ts

@@ -1,5 +1,3 @@
 import type { OgImageOptions } from '../../../types.js';
-declare const _default: import("vue").DefineComponent<OgImageOptions<"NuxtSeo">, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<OgImageOptions<"NuxtSeo">>, {
-    [x: string]: unknown;
-}, {}>;
+declare const _default: import("vue").DefineComponent<OgImageOptions<"NuxtSeo">, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<OgImageOptions<"NuxtSeo">> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/runtime/nuxt/components/OgImage/OgImage.js

@@ -1,5 +1,5 @@
-import { defineComponent } from "vue";
 import { defineOgImage } from "#imports";
+import { defineComponent } from "vue";
 export default defineComponent({
   name: "OgImage",
   async setup(_, { attrs }) {

package/dist/runtime/nuxt/components/OgImage/OgImageScreenshot.d.ts

@@ -1,5 +1,3 @@
 import type { OgImagePageScreenshotOptions } from '../../../types.js';
-declare const _default: import("vue").DefineComponent<OgImagePageScreenshotOptions, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<OgImagePageScreenshotOptions>, {
-    [x: string]: unknown;
-}, {}>;
+declare const _default: import("vue").DefineComponent<OgImagePageScreenshotOptions, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<OgImagePageScreenshotOptions> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/runtime/nuxt/components/OgImage/OgImageScreenshot.js

@@ -1,5 +1,5 @@
-import { defineComponent } from "vue";
 import { defineOgImageScreenshot } from "#imports";
+import { defineComponent } from "vue";
 export default defineComponent({
   name: "OgImageScreenshot",
   async setup(_, { attrs }) {

package/dist/runtime/nuxt/components/Templates/Community/NuxtSeo.vue

@@ -3,9 +3,9 @@
  * @credits Nuxt SEO <https://nuxtseo.com/>
  */
 
-import { computed, defineComponent, h, resolveComponent } from 'vue'
-import { useOgImageRuntimeConfig } from '../../../../shared'
 import { useSiteConfig } from '#imports'
+import { useOgImageRuntimeConfig } from '#nuxt-og-image-utils'
+import { computed, defineComponent, h, resolveComponent } from 'vue'
 
 // convert to typescript props
 const props = withDefaults(defineProps<{

package/dist/runtime/nuxt/components/Templates/Community/SimpleBlog.vue

@@ -3,8 +3,8 @@
  * @credits Full Stack Heroes <https://fullstackheroes.com/>
  */
 
-import { parseURL } from 'ufo'
 import { computed, useSiteConfig } from '#imports'
+import { parseURL } from 'ufo'
 
 const props = withDefaults(defineProps<{
   title?: string

package/dist/runtime/nuxt/composables/defineOgImage.js

@@ -1,9 +1,9 @@
+import { useNuxtApp, useRequestEvent, useRoute } from "#imports";
 import { defu } from "defu";
 import { appendHeader } from "h3";
+import { createNitroRouteRuleMatcher } from "../../nitro/util/kit.js";
 import { getOgImagePath, separateProps, useOgImageRuntimeConfig } from "../../shared.js";
 import { createOgImageMeta, normaliseOptions } from "../utils.js";
-import { createNitroRouteRuleMatcher } from "../../nitro/util/kit.js";
-import { useNuxtApp, useRequestEvent, useRoute } from "#imports";
 export function defineOgImage(_options = {}) {
   if (!import.meta.server)
     return;
@@ -20,12 +20,14 @@ export function defineOgImage(_options = {}) {
     nuxtApp.ssrContext._ogImageInstances = void 0;
     return;
   }
-  const options = normaliseOptions({
+  const { defaults } = useOgImageRuntimeConfig();
+  const options = normaliseOptions(defu({
     ..._options
-  });
+  }, {
+    component: defaults.component
+  }));
   if (route.query)
     options._query = route.query;
-  const { defaults } = useOgImageRuntimeConfig();
   const resolvedOptions = normaliseOptions(defu(separateProps(_options), separateProps(routeRules), defaults));
   if (resolvedOptions.url) {
     createOgImageMeta(null, options, resolvedOptions, nuxtApp.ssrContext);

package/dist/runtime/nuxt/composables/defineOgImageComponent.d.ts

@@ -1,3 +1,3 @@
-import type { ExtractComponentProps, OgImageOptions } from '../../types.js';
 import type { OgImageComponents } from '#nuxt-og-image/components';
+import type { ExtractComponentProps, OgImageOptions } from '../../types.js';
 export declare function defineOgImageComponent<T extends keyof OgImageComponents>(component: T, props?: Partial<ExtractComponentProps<OgImageComponents[T]>>, options?: OgImageOptions): void;

package/dist/runtime/nuxt/composables/mock.d.ts

@@ -1,5 +1,5 @@
-import type { DefineOgImageInput, ExtractComponentProps, OgImageOptions, OgImagePageScreenshotOptions } from '../../types.js';
 import type { OgImageComponents } from '#nuxt-og-image/components';
+import type { DefineOgImageInput, ExtractComponentProps, OgImageOptions, OgImagePageScreenshotOptions } from '../../types.js';
 export declare function defineOgImage(_options?: DefineOgImageInput): void;
 export declare function defineOgImageComponent<T extends keyof OgImageComponents>(component: T, props?: Partial<ExtractComponentProps<OgImageComponents[T]>>, options?: OgImageOptions): void;
 export declare function defineOgImageScreenshot(options?: OgImagePageScreenshotOptions): void;

package/dist/runtime/nuxt/plugins/__zero-runtime/og-image-canonical-urls.server.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

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

@@ -0,0 +1,9 @@
+import { defineNuxtPlugin } from "#imports";
+import { ogImageCanonicalUrls as setup } from "../../utils/plugins.js";
+export default defineNuxtPlugin({
+  setup(nuxtApp) {
+    if (import.meta.dev || import.meta.prerender) {
+      setup(nuxtApp);
+    }
+  }
+});

package/dist/runtime/nuxt/plugins/__zero-runtime/route-rule-og-image.server.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

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

@@ -0,0 +1,9 @@
+import { defineNuxtPlugin } from "#imports";
+import { routeRuleOgImage as setup } from "../../utils/plugins.js";
+export default defineNuxtPlugin({
+  setup(nuxtApp) {
+    if (import.meta.dev || import.meta.prerender) {
+      setup(nuxtApp);
+    }
+  }
+});

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

@@ -1,53 +1,5 @@
-import { parseURL } from "ufo";
-import { toValue } from "vue";
-import { defu } from "defu";
-import { parse, stringify } from "devalue";
-import { isInternalRoute, separateProps } from "../../pure.js";
-import { defineNuxtPlugin, useRequestEvent, withSiteUrl } from "#imports";
+import { defineNuxtPlugin } from "#imports";
+import { ogImageCanonicalUrls as setup } from "../utils/plugins.js";
 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) => {
-            const hasPrimaryPayload = ctx2.tags.some((tag) => tag.tag === "script" && tag.props.id === "nuxt-og-image-options");
-            let overrides;
-            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;
-              }
-            }
-            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.startsWith("https")) {
-                  await nuxtApp.runWithContext(() => {
-                    tag.props.content = toValue(withSiteUrl(tag.props.content, {
-                      withBase: true
-                    }));
-                  });
-                }
-              } else if (overrides && tag.tag === "script" && tag.props.id === "nuxt-og-image-options") {
-                tag.innerHTML = stringify(defu(overrides, parse(tag.innerHTML)));
-              }
-            }
-          }
-        }
-      });
-    });
-  }
+  setup
 });

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

@@ -1,37 +1,5 @@
-import { defu } from "defu";
-import { parseURL, withoutBase } from "ufo";
-import { createRouter as createRadixRouter, toRouteMatcher } from "radix3";
-import { getOgImagePath, isInternalRoute, useOgImageRuntimeConfig } from "../../shared.js";
-import { createOgImageMeta, normaliseOptions } from "../utils.js";
-import { defineNuxtPlugin, useRequestEvent } from "#imports";
-export default defineNuxtPlugin((nuxtApp) => {
-  nuxtApp.hooks.hook("app:rendered", async (ctx) => {
-    const { ssrContext } = ctx;
-    const e = useRequestEvent();
-    const path = parseURL(e.path).pathname;
-    if (isInternalRoute(path))
-      return;
-    const _routeRulesMatcher = toRouteMatcher(
-      createRadixRouter({ routes: ssrContext?.runtimeConfig?.nitro?.routeRules })
-    );
-    let routeRules = defu({}, ..._routeRulesMatcher.matchAll(
-      withoutBase(path.split("?")[0], ssrContext?.runtimeConfig?.app.baseURL)
-    ).reverse()).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;
-      return;
-    }
-    routeRules = normaliseOptions(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);
-  });
+import { defineNuxtPlugin } from "#imports";
+import { routeRuleOgImage as setup } from "../utils/plugins.js";
+export default defineNuxtPlugin({
+  setup
 });

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

@@ -0,0 +1,3 @@
+import type { NuxtApp } from 'nuxt/app';
+export declare function ogImageCanonicalUrls(nuxtApp: NuxtApp): void;
+export declare function routeRuleOgImage(nuxtApp: NuxtApp): void;

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

@@ -0,0 +1,87 @@
+import { useRequestEvent, withSiteUrl } from "#imports";
+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, normaliseOptions } from "../../nuxt/utils.js";
+import { isInternalRoute, separateProps } from "../../pure.js";
+import { getOgImagePath, useOgImageRuntimeConfig } from "../../shared.js";
+export function ogImageCanonicalUrls(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) => {
+          const hasPrimaryPayload = ctx2.tags.some((tag) => tag.tag === "script" && tag.props.id === "nuxt-og-image-options");
+          let overrides;
+          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;
+            }
+          }
+          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.startsWith("https")) {
+                await nuxtApp.runWithContext(() => {
+                  tag.props.content = toValue(withSiteUrl(tag.props.content, {
+                    withBase: true
+                  }));
+                });
+              }
+            } else if (overrides && tag.tag === "script" && tag.props.id === "nuxt-og-image-options") {
+              tag.innerHTML = stringify(defu(overrides, parse(tag.innerHTML)));
+            }
+          }
+        }
+      }
+    });
+  });
+}
+export function routeRuleOgImage(nuxtApp) {
+  nuxtApp.hooks.hook("app:rendered", async (ctx) => {
+    const { ssrContext } = ctx;
+    const e = useRequestEvent();
+    const path = parseURL(e.path).pathname;
+    if (isInternalRoute(path))
+      return;
+    const _routeRulesMatcher = toRouteMatcher(
+      createRadixRouter({ routes: ssrContext?.runtimeConfig?.nitro?.routeRules })
+    );
+    let routeRules = defu({}, ..._routeRulesMatcher.matchAll(
+      withoutBase(path.split("?")[0], ssrContext?.runtimeConfig?.app.baseURL)
+    ).reverse()).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;
+      return;
+    }
+    const { defaults } = useOgImageRuntimeConfig();
+    routeRules = normaliseOptions(defu(nuxtApp.ssrContext?.event.context._nitro?.routeRules?.ogImage, routeRules, {
+      component: defaults.component
+    }));
+    const resolvedOptions = normaliseOptions(defu(routeRules, defaults));
+    const src = getOgImagePath(ssrContext.url, resolvedOptions);
+    createOgImageMeta(src, routeRules, resolvedOptions, nuxtApp.ssrContext);
+  });
+}

package/dist/runtime/nuxt/utils.js

@@ -1,10 +1,10 @@
+import { componentNames } from "#build/nuxt-og-image/components.mjs";
+import { unref, useServerHead } from "#imports";
+import { resolveUnrefHeadInput } from "@unhead/vue";
 import { defu } from "defu";
-import { withQuery } from "ufo";
 import { stringify } from "devalue";
-import { resolveUnrefHeadInput } from "@unhead/vue";
+import { withQuery } from "ufo";
 import { getExtension, separateProps } from "../shared.js";
-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));
   let url = src || input.url || resolvedOptions.url;
@@ -74,6 +74,8 @@ export function normaliseOptions(_options) {
         break;
       }
     }
+  } else if (!options.component) {
+    options.component = componentNames[0]?.pascalName;
   }
   return options;
 }

package/dist/runtime/shared.js

@@ -1,11 +1,11 @@
-import { joinURL } from "ufo";
-import { defu } from "defu";
 import { useRuntimeConfig } from "#imports";
+import { defu } from "defu";
+import { joinURL } from "ufo";
 export * from "./pure.js";
 export function getOgImagePath(pagePath, _options) {
   const baseURL = useRuntimeConfig().app.baseURL;
   const options = defu(_options, useOgImageRuntimeConfig().defaults);
-  return joinURL("/", baseURL, "__og-image__/image", pagePath, `og.${options.extension}`);
+  return joinURL("/", baseURL, `__og-image__/${import.meta.prerender ? "static" : "image"}`, pagePath, `og.${options.extension}`);
 }
 export function useOgImageRuntimeConfig() {
   return useRuntimeConfig()["nuxt-og-image"];

package/dist/runtime/types.d.ts

@@ -1,11 +1,11 @@
-import type { html } from 'satori-html';
-import type { H3Error, H3Event } from 'h3';
+import type { OgImageComponents } from '#nuxt-og-image/components';
 import type { ResvgRenderOptions } from '@resvg/resvg-js';
-import type { SatoriOptions } from 'satori';
 import type { AllowedComponentProps, Component, ComponentCustomProps, VNodeProps } from '@vue/runtime-core';
-import type { SharpOptions } from 'sharp';
+import type { H3Error, H3Event } from 'h3';
 import type { NitroApp, NitroOptions } from 'nitropack';
-import type { OgImageComponents } from '#nuxt-og-image/components';
+import type { SatoriOptions } from 'satori';
+import type { html } from 'satori-html';
+import type { SharpOptions } from 'sharp';
 export interface OgImageRenderEventContext {
     e: H3Event;
     extension: 'png' | 'jpeg' | 'jpg' | 'svg' | 'html' | 'json';
@@ -31,6 +31,7 @@ export interface OgImageRuntimeConfig {
     hasNuxtIcon: boolean;
     colorPreference: 'light' | 'dark';
     isNuxtContentDocumentDriven: boolean;
+    zeroRuntime: boolean;
 }
 export interface OgImageComponent {
     path?: string;

package/dist/types.d.mts

@@ -4,8 +4,4 @@ declare module '@nuxt/schema' {
   interface NuxtHooks extends ModuleHooks {}
 }
 
-declare module 'nuxt/schema' {
-  interface NuxtHooks extends ModuleHooks {}
-}
-
 export { type ModuleHooks, type ModuleOptions, default } from './module.js'

package/dist/types.d.ts

@@ -4,8 +4,4 @@ declare module '@nuxt/schema' {
   interface NuxtHooks extends ModuleHooks {}
 }
 
-declare module 'nuxt/schema' {
-  interface NuxtHooks extends ModuleHooks {}
-}
-
 export { type ModuleHooks, type ModuleOptions, default } from './module'