nuxt-og-image 2.0.4 → 2.0.6

package/dist/runtime/cache.mjs

@@ -0,0 +1,42 @@
+import { prefixStorage } from "unstorage";
+import { getQuery, setHeader } from "h3";
+import { useRuntimeConfig, useStorage } from "#imports";
+export async function useNitroCache(e, module, options) {
+  const { runtimeCacheStorage, version } = useRuntimeConfig()[module];
+  const enabled = runtimeCacheStorage && options.cacheTtl && options.cacheTtl > 0 && options.cache;
+  const baseCacheKey = runtimeCacheStorage === "default" ? `/cache/${module}@${version}` : `/${module}@${version}`;
+  const cache = prefixStorage(useStorage(), `${baseCacheKey}/`);
+  const key = options.key;
+  let xCacheHeader = "MISS";
+  let xCacheExpires = 0;
+  const purge = typeof getQuery(e).purge !== "undefined";
+  let cachedItem = false;
+  if (enabled && await cache.hasItem(key).catch(() => false)) {
+    const { value, expiresAt } = await cache.getItem(key).catch(() => ({ value: null, expiresAt: Date.now() }));
+    if (expiresAt > Date.now()) {
+      if (purge) {
+        xCacheHeader = "PURGE";
+        await cache.removeItem(key).catch(() => {
+        });
+      } else {
+        xCacheHeader = "HIT";
+        xCacheExpires = expiresAt;
+        cachedItem = value;
+      }
+    } else {
+      await cache.removeItem(key).catch(() => {
+      });
+    }
+  }
+  if (options.headers) {
+    setHeader(e, `x-${module}-cache`, xCacheHeader);
+    setHeader(e, `x-${module}-expires`, xCacheExpires.toString());
+  }
+  return {
+    enabled,
+    cachedItem,
+    async update(item) {
+      enabled && await cache.setItem(key, { value: item, expiresAt: Date.now() + (options.cacheTtl || 0) });
+    }
+  };
+}

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

@@ -1,4 +1,4 @@
-import type { OgImageOptions } from '../../../types';
+import type { OgImageOptions } from '../../types';
 declare const _default: import("vue").DefineComponent<OgImageOptions, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<OgImageOptions>>, {
     [x: string]: any;
 }, {}>;

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

@@ -1,4 +1,4 @@
-import type { OgImageOptions } from '../../../types';
+import type { OgImageOptions } from '../../types';
 /**
  * @deprecated Use OgImageWithoutCache
  */

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

@@ -1,4 +1,4 @@
-import type { OgImageScreenshotOptions } from '../../../types';
+import type { OgImageScreenshotOptions } from '../../types';
 declare const _default: import("vue").DefineComponent<OgImageScreenshotOptions, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<OgImageScreenshotOptions>>, {
     [x: string]: any;
     [x: number]: any;

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

@@ -1,4 +1,4 @@
-import type { OgImageOptions } from '../../../types';
+import type { OgImageOptions } from '../../types';
 /**
  * @deprecated Use OgImageCached instead
  */

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

@@ -1,4 +1,4 @@
-import type { OgImageOptions } from '../../../types';
+import type { OgImageOptions } from '../../types';
 declare const _default: import("vue").DefineComponent<OgImageOptions, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<OgImageOptions>>, {
     [x: string]: any;
 }, {}>;

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

@@ -1,4 +1,4 @@
-import type { OgImageOptions } from '../../../types';
+import type { OgImageOptions } from '../../types';
 declare const _default: import("vue").DefineComponent<OgImageOptions, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<OgImageOptions>>, {
     [x: string]: any;
 }, {}>;

package/dist/runtime/composables/defineOgImage.d.ts

@@ -1,4 +1,4 @@
-import type { OgImageOptions, OgImageScreenshotOptions } from '../../types';
+import type { OgImageOptions, OgImageScreenshotOptions } from '../types';
 export declare function defineOgImageScreenshot(options?: OgImageScreenshotOptions): Promise<void>;
 /**
  * @deprecated Use `defineOgImage` or `defineOgImageCached` instead

package/dist/runtime/composables/defineOgImage.mjs

@@ -26,9 +26,9 @@ export function defineOgImageCached(options = {}) {
 }
 export function defineOgImageWithoutCache(options = {}) {
   return defineOgImage({
+    ...options,
     cache: false,
-    cacheTtl: 0,
-    ...options
+    cacheTtl: 0
   });
 }
 export function defineOgImageDynamic(options = {}) {

package/dist/runtime/composables/util.d.ts

@@ -1,2 +1,2 @@
-import type { OgImageOptions } from '../../types';
+import type { OgImageOptions } from '../types';
 export declare function normaliseOgImageOptions(_options: OgImageOptions): any;

package/dist/runtime/composables/util.mjs

@@ -11,15 +11,11 @@ export function normaliseOgImageOptions(_options) {
     options.provider = "browser";
   if (options.component && componentNames) {
     const originalName = options.component;
-    let isValid = componentNames.some((component) => component.pascalName === originalName || component.kebabName === originalName);
-    if (!isValid) {
-      for (const component of componentNames) {
-        if (component.pascalName.endsWith(originalName) || component.kebabName.endsWith(originalName)) {
-          options.component = component.pascalName;
-          options.componentHash = component.hash;
-          isValid = true;
-          break;
-        }
+    for (const component of componentNames) {
+      if (component.pascalName.endsWith(originalName) || component.kebabName.endsWith(originalName)) {
+        options.component = component.pascalName;
+        options.componentHash = component.hash;
+        break;
       }
     }
   }

package/dist/runtime/nitro/middleware/og.png.mjs

@@ -1,20 +1,20 @@
 import { Buffer } from "node:buffer";
 import { createError, defineEventHandler, sendRedirect, setHeader } from "h3";
-import { joinURL, parseURL, withoutTrailingSlash } from "ufo";
-import { prefixStorage } from "unstorage";
+import { joinURL, parseURL, withoutLeadingSlash, withoutTrailingSlash } from "ufo";
 import { hash } from "ohash";
-import { fetchOptions } from "../utils.mjs";
+import { fetchOptionsCached } from "../utils.mjs";
+import { useNitroCache } from "../../cache.mjs";
 import { useProvider } from "#nuxt-og-image/provider";
-import { useNitroOrigin, useRuntimeConfig, useStorage } from "#imports";
+import { useNitroOrigin, useRuntimeConfig } from "#imports";
 export default defineEventHandler(async (e) => {
-  const { runtimeBrowser, runtimeCacheStorage, version } = useRuntimeConfig()["nuxt-og-image"];
+  const { runtimeBrowser } = useRuntimeConfig()["nuxt-og-image"];
   const path = parseURL(e.path).pathname;
   if (!path.endsWith("__og_image__/og.png"))
     return;
   const basePath = withoutTrailingSlash(
     path.replace("__og_image__/og.png", "")
   );
-  const options = await fetchOptions(e, basePath);
+  const options = await fetchOptionsCached(e, basePath);
   if (process.env.NODE_ENV === "production" && !process.env.prerender && !runtimeBrowser && options.provider === "browser")
     return sendRedirect(e, joinURL(useNitroOrigin(e), "__nuxt_og_image__/browser-provider-not-supported.png"));
   const provider = await useProvider(options.provider);
@@ -24,27 +24,25 @@ export default defineEventHandler(async (e) => {
       statusMessage: `Provider ${options.provider} is missing.`
     });
   }
-  const useCache = runtimeCacheStorage && !process.dev && options.cacheTtl && options.cacheTtl > 0 && options.cache;
-  const baseCacheKey = runtimeCacheStorage === "default" ? `/cache/og-image${version}` : `/og-image/${version}`;
-  const cache = prefixStorage(useStorage(), `${baseCacheKey}/images`);
-  const key = [options.path === "/" || !options.path ? "index" : options.path, hash(options)].join(":");
+  const key = [
+    withoutLeadingSlash(options.path === "/" || !options.path ? "index" : options.path).replaceAll("/", "-"),
+    `og-${hash(options)}`
+  ].join(":");
+  const { enabled: cacheEnabled, cachedItem, update } = await useNitroCache(e, "nuxt-og-image", {
+    key,
+    cacheTtl: options.cacheTtl || 0,
+    cache: process.dev && options.cache,
+    headers: true
+  });
   let png;
-  if (useCache && await cache.hasItem(key)) {
-    const { value, expiresAt } = await cache.getItem(key);
-    if (expiresAt > Date.now()) {
-      setHeader(e, "Cache-Control", "public, max-age=31536000");
-      setHeader(e, "Content-Type", "image/png");
-      png = Buffer.from(value, "base64");
-    } else {
-      await cache.removeItem(key);
-    }
-  }
+  if (cachedItem)
+    png = Buffer.from(cachedItem, "base64");
   if (!png) {
     try {
       png = await provider.createPng(options);
-      if (useCache && png) {
+      if (png) {
         const base64png = Buffer.from(png).toString("base64");
-        await cache.setItem(key, { value: base64png, expiresAt: Date.now() + (options.cacheTtl || 0) });
+        await update(base64png);
       }
     } catch (err) {
       throw createError({
@@ -54,7 +52,7 @@ export default defineEventHandler(async (e) => {
     }
   }
   if (png) {
-    if (!process.dev && options.cache) {
+    if (cacheEnabled) {
       setHeader(e, "Cache-Control", "public, max-age=31536000");
     } else {
       setHeader(e, "Cache-Control", "no-cache, no-store, must-revalidate");

package/dist/runtime/nitro/middleware/playground.mjs

@@ -1,13 +1,13 @@
 import { defineEventHandler } from "h3";
 import { parseURL, withBase, withoutTrailingSlash } from "ufo";
-import { fetchOptions } from "../utils.mjs";
+import { fetchOptionsCached } from "../utils.mjs";
 import { useRuntimeConfig } from "#imports";
 export default defineEventHandler(async (e) => {
   const path = withoutTrailingSlash(parseURL(e.path).pathname);
   if (!path.endsWith("/__og_image__"))
     return;
   const basePath = withBase(path.replace("/__og_image__", ""), useRuntimeConfig().app.baseURL);
-  const options = await fetchOptions(e, basePath === "" ? "/" : basePath);
+  const options = await fetchOptionsCached(e, basePath === "" ? "/" : basePath);
   if (!options)
     return `The route ${basePath} has not been set up for og:image generation.`;
   return `

package/dist/runtime/nitro/providers/png/resvg-node.d.ts

@@ -1,4 +1,4 @@
 /// <reference types="node" />
 import type { ResvgRenderOptions } from '@resvg/resvg-js';
-import type { RuntimeOgImageOptions } from '../../../../types';
+import type { RuntimeOgImageOptions } from '../../../types';
 export default function (svg: string, options: ResvgRenderOptions & RuntimeOgImageOptions): Promise<Buffer>;

package/dist/runtime/nitro/providers/png/resvg-wasm.d.ts

@@ -1,3 +1,3 @@
 import type { ResvgRenderOptions } from '@resvg/resvg-wasm';
-import type { RuntimeOgImageOptions } from '../../../../types';
+import type { RuntimeOgImageOptions } from '../../../types';
 export default function (svg: string, options: ResvgRenderOptions & RuntimeOgImageOptions): Promise<Uint8Array>;

package/dist/runtime/nitro/providers/png/svg2png.d.ts

@@ -1,3 +1,3 @@
 import type { ConvertOptions } from 'svg2png-wasm';
-import type { RuntimeOgImageOptions } from '../../../../types';
+import type { RuntimeOgImageOptions } from '../../../types';
 export default function (svg: string, options: ConvertOptions & RuntimeOgImageOptions): Promise<Uint8Array>;

package/dist/runtime/nitro/providers/satori/yoga-wasm.d.ts

@@ -1,3 +1,3 @@
 import type { SatoriOptions } from 'satori';
-import type { RuntimeOgImageOptions } from '../../../../types';
+import type { RuntimeOgImageOptions } from '../../../types';
 export default function (nodes: string, options: SatoriOptions & RuntimeOgImageOptions): Promise<string>;

package/dist/runtime/nitro/renderers/browser.d.ts

@@ -1,3 +1,3 @@
-import type { Renderer } from '../../../types';
+import type { Renderer } from '../../types';
 declare const BrowserRenderer: Renderer;
 export default BrowserRenderer;

package/dist/runtime/nitro/renderers/satori/index.d.ts

@@ -1,3 +1,3 @@
-import type { Renderer } from '../../../../types';
+import type { Renderer } from '../../../types';
 declare const SatoriRenderer: Renderer;
 export default SatoriRenderer;

package/dist/runtime/nitro/renderers/satori/plugins/emojis.d.ts

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

package/dist/runtime/nitro/renderers/satori/plugins/encoding.d.ts

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

package/dist/runtime/nitro/renderers/satori/plugins/flex.d.ts

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

package/dist/runtime/nitro/renderers/satori/plugins/imageSrc.d.ts

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

package/dist/runtime/nitro/renderers/satori/plugins/twClasses.d.ts

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

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

@@ -1,4 +1,4 @@
-import type { FontConfig, RuntimeOgImageOptions, SatoriTransformer, VNode } from '../../../../types';
+import type { FontConfig, RuntimeOgImageOptions, SatoriTransformer, VNode } from '../../../types';
 export declare function loadFont(requestOrigin: string, font: FontConfig): Promise<any>;
 export declare function walkSatoriTree(node: VNode, plugins: (SatoriTransformer | SatoriTransformer[])[], props: RuntimeOgImageOptions): Promise<void>;
 export declare function defineSatoriTransformer(transformer: SatoriTransformer | SatoriTransformer[]): SatoriTransformer | SatoriTransformer[];

package/dist/runtime/nitro/routes/html.mjs

@@ -5,7 +5,7 @@ import { createError, defineEventHandler, getQuery, sendRedirect } from "h3";
 import { hash } from "ohash";
 import twemoji from "twemoji";
 import { defu } from "defu";
-import { fetchOptions } from "../utils.mjs";
+import { fetchOptionsCached } from "../utils.mjs";
 import { useNitroOrigin, useRuntimeConfig } from "#imports";
 import loadInlineCSS from "#nuxt-og-image/inline-css";
 export default defineEventHandler(async (e) => {
@@ -22,7 +22,7 @@ export default defineEventHandler(async (e) => {
     } catch {
     }
   }
-  let options = await fetchOptions(e, path);
+  let options = await fetchOptionsCached(e, path);
   if (queryOptions)
     options = defu(queryOptions, options);
   if (options.provider === "browser" && !options.component) {

package/dist/runtime/nitro/routes/options.d.ts

@@ -1,3 +1,3 @@
-import type { RuntimeOgImageOptions } from '../../../types';
+import type { RuntimeOgImageOptions } from '../../types';
 declare const _default: import("h3").EventHandler<false | RuntimeOgImageOptions>;
 export default _default;

package/dist/runtime/nitro/routes/options.mjs

@@ -16,21 +16,21 @@ export default defineEventHandler(async (e) => {
       statusMessage: `Failed to read the path ${path} for og-image extraction. ${err.message}.`
     });
   }
-  const extractedPayload = extractOgImageOptions(html);
-  if (!extractedPayload) {
-    throw createError({
-      statusCode: 500,
-      statusMessage: `The path ${path} is missing the og-image payload.`
-    });
-  }
   e.node.req.url = path;
   const oldRouteRules = e.context._nitro.routeRules;
   e.context._nitro.routeRules = void 0;
-  const routeRules = getRouteRules(e)?.ogImage;
+  const routeRules = getRouteRules(e)?.ogImage || {};
   e.context._nitro.routeRules = oldRouteRules;
   e.node.req.url = e.path;
   if (routeRules === false)
     return false;
+  const extractedPayload = extractOgImageOptions(html, routeRules);
+  if (!extractedPayload) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: `The path ${path} is missing the og-image payload.`
+    });
+  }
   const { defaults } = useRuntimeConfig()["nuxt-og-image"];
   return defu(
     extractedPayload,

package/dist/runtime/nitro/routes/svg.mjs

@@ -1,12 +1,12 @@
 import { createError, defineEventHandler, getQuery, setHeader } from "h3";
 import { withBase } from "ufo";
-import { fetchOptions } from "../utils.mjs";
+import { fetchOptionsCached } from "../utils.mjs";
 import { useProvider } from "#nuxt-og-image/provider";
 import { useRuntimeConfig } from "#imports";
 export default defineEventHandler(async (e) => {
   const query = getQuery(e);
   const path = withBase(query.path || "/", useRuntimeConfig().app.baseURL);
-  const options = await fetchOptions(e, path);
+  const options = await fetchOptionsCached(e, path);
   setHeader(e, "Content-Type", "image/svg+xml");
   const provider = await useProvider(options.provider);
   if (!provider) {

package/dist/runtime/nitro/routes/vnode.mjs

@@ -1,12 +1,12 @@
 import { createError, defineEventHandler, getQuery, setHeader } from "h3";
 import { withBase } from "ufo";
-import { fetchOptions } from "../utils.mjs";
+import { fetchOptionsCached } from "../utils.mjs";
 import { useProvider } from "#nuxt-og-image/provider";
 import { useRuntimeConfig } from "#imports";
 export default defineEventHandler(async (e) => {
   const query = getQuery(e);
   const path = withBase(query.path || "/", useRuntimeConfig().app.baseURL);
-  const options = await fetchOptions(e, path);
+  const options = await fetchOptionsCached(e, path);
   setHeader(e, "Content-Type", "application/json");
   const provider = await useProvider(options.provider);
   if (!provider) {

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

@@ -1,3 +1,3 @@
-import type { OgImageOptions } from '../../types';
+import type { OgImageOptions } from '../types';
 export declare function decodeHtml(html: string): string;
-export declare function extractOgImageOptions(html: string): OgImageOptions | false;
+export declare function extractOgImageOptions(html: string, routeRules: OgImageOptions): OgImageOptions | false;

package/dist/runtime/nitro/utils-pure.mjs

@@ -1,3 +1,4 @@
+import { defu } from "defu";
 export function decodeHtml(html) {
   return html.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&cent;/g, "\xA2").replace(/&pound;/g, "\xA3").replace(/&yen;/g, "\xA5").replace(/&euro;/g, "\u20AC").replace(/&copy;/g, "\xA9").replace(/&reg;/g, "\xAE").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&#x27;/g, "'").replace(/&#x2F;/g, "/").replace(/&#([0-9]+);/g, (full, int) => {
     return String.fromCharCode(Number.parseInt(int));
@@ -10,15 +11,20 @@ function decodeObjectHtmlEntities(obj) {
   });
   return obj;
 }
-export function extractOgImageOptions(html) {
+export function extractOgImageOptions(html, routeRules) {
   const htmlPayload = html.match(/<script id="nuxt-og-image-options" type="application\/json">(.+?)<\/script>/)?.[1];
   if (!htmlPayload)
     return false;
   let options;
   try {
-    options = JSON.parse(htmlPayload);
+    const payload = JSON.parse(htmlPayload);
+    Object.entries(payload).forEach(([key, value]) => {
+      if (!value)
+        delete payload[key];
+    });
+    options = defu(payload, routeRules);
   } catch (e) {
-    options = false;
+    options = routeRules;
     if (process.dev)
       console.warn("Failed to parse #nuxt-og-image-options", e, options);
   }

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

@@ -1,10 +1,11 @@
 /// <reference types="node" />
 import { Buffer } from 'node:buffer';
 import type { H3Event } from 'h3';
-import type { RuntimeOgImageOptions } from '../../types';
+import type { RuntimeOgImageOptions } from '../types';
 export declare function wasmLoader(asyncModuleLoad: Promise<any> | Buffer | string, fallback: string): {
     load(options: RuntimeOgImageOptions): Promise<any>;
 };
+export declare function fetchOptionsCached(e: H3Event, path: string): Promise<RuntimeOgImageOptions>;
 export declare function fetchOptions(e: H3Event, path: string): Promise<RuntimeOgImageOptions>;
 export declare function base64ToArrayBuffer(base64: string): ArrayBuffer;
 export declare function readPublicAsset(file: string, encoding?: BufferEncoding): Promise<string | Buffer | undefined>;

package/dist/runtime/nitro/utils.mjs

@@ -2,9 +2,11 @@ import { existsSync, promises as fsp } from "node:fs";
 import { Buffer } from "node:buffer";
 import { getQuery } from "h3";
 import { join } from "pathe";
-import { prefixStorage } from "unstorage";
 import sizeOf from "image-size";
-import { useNitroOrigin, useRuntimeConfig, useStorage } from "#imports";
+import { defu } from "defu";
+import { withoutLeadingSlash } from "ufo";
+import { useNitroCache } from "../cache.mjs";
+import { useNitroOrigin, useRuntimeConfig } from "#imports";
 export function wasmLoader(asyncModuleLoad, fallback) {
   let promise;
   let wasm;
@@ -36,40 +38,37 @@ export function wasmLoader(asyncModuleLoad, fallback) {
     }
   };
 }
+export async function fetchOptionsCached(e, path) {
+  const key = [
+    withoutLeadingSlash(path === "/" || !path ? "index" : path).replaceAll("/", "-"),
+    "options"
+  ].join(":");
+  const { cachedItem, update } = await useNitroCache(e, "nuxt-og-image", {
+    key,
+    // allow internal requests to be cached
+    cacheTtl: 5 * 1e3,
+    cache: !process.dev,
+    headers: false
+  });
+  if (cachedItem)
+    return cachedItem;
+  const options = await fetchOptions(e, path);
+  await update(options);
+  return options;
+}
 export async function fetchOptions(e, path) {
-  const { runtimeCacheStorage, version } = useRuntimeConfig()["nuxt-og-image"];
-  const baseCacheKey = runtimeCacheStorage === "default" ? `/cache/og-image${version}` : `/og-image/${version}`;
-  const cache = runtimeCacheStorage || process.env.prerender ? prefixStorage(useStorage(), `${baseCacheKey}/options`) : false;
-  const key = [path === "/" || !path ? "index" : path].join(":");
-  let options;
-  if (!process.dev && cache && await cache.hasItem(key)) {
-    const cachedValue = await cache.getItem(key);
-    if (cachedValue && cachedValue.value && cachedValue.expiresAt < Date.now())
-      options = cachedValue.value;
-    else
-      await cache.removeItem(key);
-  }
-  if (!options) {
-    options = await globalThis.$fetch("/api/og-image-options", {
-      query: {
-        path
-      },
-      responseType: "json"
-    });
-    if (cache) {
-      await cache.setItem(key, {
-        value: options,
-        // cache for 1 minute or 5 seconds, avoids subsequent internal fetches
-        expiresAt: Date.now() + (options.cache ? 60 * 1e3 : 5 * 1e3)
-      });
-    }
-  }
-  return {
-    ...options,
+  const options = await globalThis.$fetch("/api/og-image-options", {
+    query: {
+      path
+    },
+    responseType: "json"
+  });
+  return defu(
+    { requestOrigin: useNitroOrigin(e) },
+    options,
     // use query data
-    ...getQuery(e),
-    requestOrigin: useNitroOrigin(e)
-  };
+    getQuery(e)
+  );
 }
 export function base64ToArrayBuffer(base64) {
   const buffer = Buffer.from(base64, "base64");

package/dist/runtime/types.d.ts

@@ -0,0 +1,69 @@
+/// <reference types="node" />
+import type { Buffer } from 'node:buffer';
+import type { html } from 'satori-html';
+import type { ModuleOptions } from '../module';
+export interface ScreenshotOptions {
+    colorScheme?: 'dark' | 'light';
+    selector?: string;
+    mask?: string;
+    /**
+     * The width of the screenshot.
+     *
+     * @default 1200
+     */
+    width: number;
+    /**
+     * The height of the screenshot.
+     *
+     * @default 630
+     */
+    height: number;
+    /**
+     * How long to wait before taking the screenshot. Useful for waiting for animations.
+     */
+    delay?: number;
+}
+export interface OgImageOptions extends Partial<ScreenshotOptions> {
+    provider?: 'browser' | 'satori';
+    title?: string;
+    description?: string;
+    component?: string | null;
+    alt?: string;
+    cache?: boolean;
+    cacheKey?: string;
+    cacheTtl?: number;
+    /**
+     * @deprecated Use `cache` instead
+     */
+    static?: boolean;
+    [key: string]: any;
+}
+export interface RuntimeOgImageOptions extends OgImageOptions {
+    path: string;
+    requestOrigin: string;
+}
+export interface FontConfig {
+    name: string;
+    weight: number;
+    path?: string;
+}
+export type InputFontConfig = (`${string}:${number}` | FontConfig);
+export interface Renderer {
+    name: 'browser' | 'satori';
+    createSvg: (options: RuntimeOgImageOptions) => Promise<string>;
+    createPng: (options: RuntimeOgImageOptions) => Promise<Buffer>;
+    createVNode: (options: RuntimeOgImageOptions) => Promise<VNode>;
+}
+export type OgImageScreenshotOptions = Omit<OgImageOptions, 'component'>;
+export interface PlaygroundServerFunctions {
+    openInEditor(filepath: string): void;
+    getConfig(): ModuleOptions;
+}
+export interface PlaygroundClientFunctions {
+    refresh(type: string): void;
+}
+export type VNode = ReturnType<typeof html>;
+export interface SatoriTransformer {
+    filter: (node: VNode) => boolean;
+    transform: (node: VNode, props: RuntimeOgImageOptions) => Promise<void>;
+}