nuxt-og-image 6.7.5 → 6.7.7

package/dist/runtime/server/og-image/bindings/worker-queue.js

@@ -0,0 +1,150 @@
+function toError(reason) {
+  return reason instanceof Error ? reason : new Error(String(reason));
+}
+function parseWorkerEvent(message) {
+  if (!message || typeof message !== "object" || !("_tag" in message))
+    return;
+  if (message._tag === "ready")
+    return { _tag: "ready" };
+  if (message._tag !== "response" || !("id" in message) || typeof message.id !== "number" || !("payload" in message))
+    return;
+  return { _tag: "response", id: message.id, payload: message.payload };
+}
+export function parseWorkerTimeout(value, fallback = 3e4) {
+  const timeout = Number(value);
+  return Number.isSafeInteger(timeout) && timeout > 0 ? timeout : fallback;
+}
+export function createWorkerQueue(options) {
+  const maxAttempts = options.maxAttempts ?? 2;
+  const queue = [];
+  let active = { _tag: "idle" };
+  let workerState = { _tag: "stopped" };
+  let requestId = 0;
+  let workerGeneration = 0;
+  let stopped = false;
+  function stopWorker() {
+    if (workerState._tag === "stopped")
+      return;
+    const state = workerState;
+    workerState = { _tag: "stopped" };
+    if (state._tag === "starting")
+      clearTimeout(state.timer);
+    state.worker.removeAllListeners();
+    void state.worker.terminate().catch(() => {
+    });
+  }
+  function takeActive() {
+    if (active._tag === "idle")
+      return;
+    const state = active;
+    active = { _tag: "idle" };
+    if (state._tag === "running")
+      clearTimeout(state.timer);
+    return state.job;
+  }
+  function continueQueue() {
+    queueMicrotask(processQueue);
+  }
+  function failWorker(reason, failedWorker) {
+    if (failedWorker && (workerState._tag === "stopped" || workerState.worker !== failedWorker))
+      return;
+    stopWorker();
+    const job = takeActive();
+    if (job) {
+      if (job.attempts < maxAttempts) {
+        job.attempts++;
+        queue.unshift(job);
+      } else {
+        job.reject(toError(reason));
+      }
+    }
+    continueQueue();
+  }
+  function startWorker() {
+    let newWorker;
+    try {
+      newWorker = options.createWorker();
+    } catch (error) {
+      failWorker(error);
+      return;
+    }
+    const generation = ++workerGeneration;
+    const timer = setTimeout(() => {
+      failWorker(new Error(`${options.label} worker startup timed out after ${options.startupTimeout}ms`), newWorker);
+    }, options.startupTimeout);
+    workerState = { _tag: "starting", generation, timer, worker: newWorker };
+    newWorker.on("message", (value) => {
+      if (workerState._tag === "stopped" || workerState.worker !== newWorker)
+        return;
+      const message = parseWorkerEvent(value);
+      if (!message)
+        return;
+      if (message._tag === "ready") {
+        if (workerState._tag !== "starting")
+          return;
+        clearTimeout(workerState.timer);
+        workerState = { _tag: "ready", generation, worker: newWorker };
+        dispatchActive();
+        return;
+      }
+      if (active._tag !== "running" || active.job.id !== message.id)
+        return;
+      const job = takeActive();
+      job.resolve(message.payload);
+      processQueue();
+    });
+    newWorker.on("error", (error) => failWorker(error, newWorker));
+    newWorker.on("exit", (code) => failWorker(new Error(`${options.label} worker exited with code ${code}`), newWorker));
+    newWorker.unref();
+  }
+  function dispatchActive() {
+    if (active._tag !== "waiting" || workerState._tag !== "ready")
+      return;
+    const job = active.job;
+    const state = workerState;
+    const timer = setTimeout(() => {
+      if (active._tag !== "running" || active.job !== job)
+        return;
+      stopWorker();
+      takeActive().reject(new Error(`${options.label} render timed out after ${options.executionTimeout}ms`));
+      continueQueue();
+    }, options.executionTimeout);
+    active = { _tag: "running", job, timer };
+    try {
+      state.worker.postMessage(job.buildMessage({ id: job.id, generation: state.generation }));
+    } catch (error) {
+      stopWorker();
+      takeActive().reject(toError(error));
+      continueQueue();
+    }
+  }
+  function processQueue() {
+    if (stopped || active._tag !== "idle")
+      return;
+    const job = queue.shift();
+    if (!job)
+      return;
+    active = { _tag: "waiting", job };
+    if (workerState._tag === "stopped")
+      startWorker();
+    else if (workerState._tag === "ready")
+      dispatchActive();
+  }
+  function enqueue(buildMessage) {
+    if (stopped)
+      return Promise.reject(new Error(`${options.label} worker queue is shut down`));
+    return new Promise((resolve, reject) => {
+      queue.push({ id: ++requestId, buildMessage, resolve, reject, attempts: 1 });
+      processQueue();
+    });
+  }
+  function shutdown() {
+    stopped = true;
+    stopWorker();
+    const error = new Error(`${options.label} worker terminated`);
+    takeActive()?.reject(error);
+    for (const job of queue.splice(0))
+      job.reject(error);
+  }
+  return { enqueue, shutdown };
+}

package/dist/runtime/server/og-image/browser/renderer.js

@@ -1,4 +1,4 @@
-import { createError } from "h3";
+import { createError } from "#nuxtseo/h3";
 import { createBrowser } from "#og-image/bindings/browser";
 import { createScreenshot } from "./screenshot.js";
 const BrowserRenderer = {

package/dist/runtime/server/og-image/browser/screenshot.js

@@ -1,5 +1,6 @@
 import { withQuery } from "ufo";
 import { toValue } from "vue";
+import { fetchWithEvent } from "#nuxtseo/nitro";
 import { getNitroOrigin } from "#site-config/server/composables";
 import { buildOgImageUrl } from "../../../shared.js";
 import { getFetchTimeout } from "../../util/fetchTimeout.js";
@@ -77,7 +78,7 @@ export async function createScreenshot({ basePath, e, options, extension, timing
       logger.warn("The `html` option is deprecated and will be removed in the next major version. Use a Vue component instead.");
     }
     if (import.meta.prerender && !options.html) {
-      options.html = await timings.measure("html-fetch", () => e.$fetch(path, { timeout: getFetchTimeout(runtimeConfig) }).catch((err) => {
+      options.html = await timings.measure("html-fetch", () => fetchWithEvent(e, path, { timeout: getFetchTimeout(runtimeConfig) }).catch((err) => {
         void err;
         return void 0;
       }));

package/dist/runtime/server/og-image/context.d.ts

@@ -1,4 +1,4 @@
-import type { H3Error, H3Event } from 'h3';
+import type { H3Error, H3Event } from '#nuxtseo/h3';
 import type { OgImageRenderEventContext } from '../../types.js';
 export declare function resolvePathCacheKey(e: H3Event, path: string, resolvedOptions?: Record<string, any>): string;
 export declare function resolveContext(e: H3Event): Promise<H3Error | OgImageRenderEventContext>;

package/dist/runtime/server/og-image/context.js

@@ -1,8 +1,8 @@
 import { defu } from "defu";
-import { createError } from "h3";
-import { useNitroApp } from "nitropack/runtime";
 import { parseURL, withoutLeadingSlash, withoutTrailingSlash, withQuery } from "ufo";
 import { normalizeKey } from "unstorage";
+import { createError } from "#nuxtseo/h3";
+import { useNitroApp } from "#nuxtseo/nitro";
 import { prerenderOptionsCache } from "#og-image-cache";
 import { getSiteConfig } from "#site-config/server/composables/getSiteConfig";
 import { createSitePathResolver } from "#site-config/server/composables/utils";
@@ -202,7 +202,6 @@ export async function resolveContext(e) {
     basePath,
     options: normalised.options,
     timings,
-    // @ts-expect-error hookable v6
     _nitro: useNitroApp()
   };
   const hookTimeout = runtimeConfig.security?.renderTimeout ?? 15e3;

package/dist/runtime/server/og-image/core/plugins/imageSrc.js

@@ -1,5 +1,5 @@
-import { useStorage } from "nitropack/runtime";
 import { withBase, withoutLeadingSlash } from "ufo";
+import { useStorage } from "#nuxtseo/nitro";
 import { getNitroOrigin } from "#site-config/server/composables/getNitroOrigin";
 import { toBase64Image } from "../../../../shared.js";
 import { decodeHtml } from "../../../util/encoding.js";

package/dist/runtime/server/og-image/core/transforms/emojis/local.d.ts

@@ -1,20 +1,6 @@
-import type { OgImageRenderEventContext } from '../../../../../types.js';
-interface IconsData {
-    icons: Record<string, {
-        body: string;
-        width?: number;
-        height?: number;
-    }>;
-    width: number;
-    height: number;
-}
+import type { OgImageIconsData, OgImageRenderEventContext } from '../../../../../types.js';
 declare module '#og-image-virtual/iconify-json-icons.mjs' {
-    function loadIcons(): Promise<IconsData>;
-}
-declare module 'nitropack/types' {
-    interface NitroApp {
-        _ogImageIconsData?: IconsData;
-    }
+    function loadIcons(): Promise<OgImageIconsData>;
 }
 /**
  * Service function to get emoji SVGs from local iconify JSON files
@@ -23,4 +9,3 @@ declare module 'nitropack/types' {
  * Icons are loaded lazily on first use to avoid 24MB+ memory at startup
  */
 export declare function getEmojiSvg(ctx: OgImageRenderEventContext, emojiChar: string): Promise<string | null>;
-export {};

package/dist/runtime/server/og-image/core/transforms/emojis/local.js

@@ -1,4 +1,4 @@
-import { useNitroApp } from "nitropack/runtime";
+import { useNitroApp } from "#nuxtseo/nitro";
 import { getEmojiCodePoint, getEmojiIconNames } from "./emoji-utils.js";
 function wrapDefsElements(body) {
   const defsElements = ["linearGradient", "radialGradient", "filter", "clipPath", "mask", "pattern"];

package/dist/runtime/server/og-image/devtools.d.ts

@@ -1,4 +1,4 @@
-import type { H3Error, H3Event } from 'h3';
+import type { H3Error, H3Event } from '#nuxtseo/h3';
 import type { DevToolsMetaDataExtraction, OgImageOptionsInternal } from '../../types.js';
 export interface DevToolsExtractPayload {
     options: OgImageOptionsInternal[];

package/dist/runtime/server/og-image/devtools.js

@@ -1,5 +1,5 @@
 import { parse } from "devalue";
-import { createError } from "h3";
+import { createError } from "#nuxtseo/h3";
 import { htmlPayloadCache } from "#og-image-cache";
 import { extractSocialPreviewTags } from "../../pure.js";
 import { logger } from "../util/logger.js";

package/dist/runtime/server/og-image/font-source.d.ts

@@ -3,24 +3,15 @@ export declare function fontFormat(src: string): FontFormat;
 /**
  * Pick the src to actually load for a parsed font entry.
  *
- * - When `preferStatic` is set (takumi), prefers the full static satoriSrc over a subset WOFF2
- *   primary src. @nuxt/fonts CSS often ships only the latin subset for a family, so using the
- *   subset would hide non-latin glyphs (devanagari, CJK) the static file covers.
- * - Variable fonts (entries carrying `weightRange`) are an exception: the per-weight static
- *   `satoriSrc` would discard the wght axis, leaving the runtime to stair-step requested
- *   weights through whatever weights fontless happened to download (e.g. requested 400 maps
- *   to the closest available static, often 100 or 700, with a hard jump in the middle).
- *   Keep the variable WOFF2 primary src so takumi can vary the axis at render time.
- * - Otherwise, uses the primary src when the renderer can parse its format, falling back to
- *   satoriSrc as a static alternative when the primary format is unsupported (satori + WOFF2).
+ * Uses the primary source when the renderer supports it, preserving WOFF2
+ * subsets and variable axes for Takumi. Otherwise it uses the Satori fallback.
  *
  * Returns null when no src on this entry can be parsed by the renderer.
  */
 export declare function selectFontSource(f: {
     src: string;
     satoriSrc?: string;
-    weightRange?: [number, number];
-}, supportedFormats: Set<FontFormat>, preferStatic: boolean): {
+}, supportedFormats: Set<FontFormat>): {
     src: string;
     isStaticFallback: boolean;
 } | null;

package/dist/runtime/server/og-image/font-source.js

@@ -7,12 +7,9 @@ export function fontFormat(src) {
     return "otf";
   return "ttf";
 }
-export function selectFontSource(f, supportedFormats, preferStatic) {
+export function selectFontSource(f, supportedFormats) {
   const primarySupported = supportedFormats.has(fontFormat(f.src));
   const satoriSupported = !!(f.satoriSrc && supportedFormats.has(fontFormat(f.satoriSrc)));
-  const isVariable = !!f.weightRange;
-  if (preferStatic && !isVariable && satoriSupported && f.satoriSrc !== f.src)
-    return { src: f.satoriSrc, isStaticFallback: true };
   if (primarySupported)
     return { src: f.src, isStaticFallback: false };
   if (satoriSupported)

package/dist/runtime/server/og-image/fonts.d.ts

@@ -1,4 +1,4 @@
-import type { H3Event } from 'h3';
+import type { H3Event } from '#nuxtseo/h3';
 import type { OgImageRenderEventContext, RuntimeFontConfig } from '../../types.js';
 import type { FontFormat } from './font-source.js';
 export { buildSubsetFamilyChain, renameSubsetFonts, resolveSubsetChain } from './font-subsets.js';
@@ -16,13 +16,6 @@ export interface LoadFontsOptions {
     fontFamilyOverride?: string;
     /** Codepoints present in the template — fonts whose unicodeRange doesn't intersect are skipped */
     codepoints?: Set<number>;
-    /**
-     * Prefer the static satoriSrc (full TTF/WOFF from fontless) over the primary src
-     * (subset WOFF2 from @nuxt/fonts) when both are usable. Takumi uses this so non-Latin
-     * glyphs (devanagari, CJK, etc.) render — @nuxt/fonts CSS often only ships latin
-     * subsets for a family, but the fontless static file contains the full glyph set.
-     */
-    preferStatic?: boolean;
 }
 export declare function loadAllFontsDebug(component?: string): {
     component: string | undefined;

package/dist/runtime/server/og-image/fonts.js

@@ -97,7 +97,7 @@ export async function loadAllFonts(event, options) {
   }
   const resolved = [];
   for (const f of fonts) {
-    const selection = selectFontSource(f, options.supportedFormats, options.preferStatic ?? false);
+    const selection = selectFontSource(f, options.supportedFormats);
     if (selection)
       resolved.push({ font: f, ...selection });
   }

package/dist/runtime/server/og-image/takumi/renderer.js

@@ -187,7 +187,7 @@ async function createImage(event, format) {
   const { fontFamilyOverride, defaultFont } = getDefaultFontFamily(options);
   const nodes = await createTakumiNodes(event);
   const codepoints = extractCodepoints(nodes);
-  const fonts = await timings.measure("font-load", () => loadFontsForRenderer(event, { supportedFormats: /* @__PURE__ */ new Set(["ttf", "woff2"]), preferStatic: true, component: options.component, fontFamilyOverride: fontFamilyOverride || defaultFont, codepoints }));
+  const fonts = await timings.measure("font-load", () => loadFontsForRenderer(event, { supportedFormats: /* @__PURE__ */ new Set(["ttf", "woff2"]), component: options.component, fontFamilyOverride: fontFamilyOverride || defaultFont, codepoints }));
   const fontEntries = dedupeFontsByBinary(fonts);
   const hookTimeout = event.runtimeConfig.security?.renderTimeout ?? 15e3;
   await withTimeout(
@@ -293,7 +293,7 @@ const TakumiRenderer = {
   async debug(e) {
     const [vnodes, fonts] = await Promise.all([
       createTakumiNodes(e),
-      loadFontsForRenderer(e, { supportedFormats: /* @__PURE__ */ new Set(["ttf", "woff2"]), preferStatic: true, component: e.options.component })
+      loadFontsForRenderer(e, { supportedFormats: /* @__PURE__ */ new Set(["ttf", "woff2"]), component: e.options.component })
     ]);
     return {
       vnodes,

package/dist/runtime/server/og-image/templates/html.js

@@ -1,5 +1,5 @@
 import { createHead, renderSSRHead } from "@unhead/vue/server";
-import { createError } from "h3";
+import { createError } from "#nuxtseo/h3";
 import resolvedFonts from "#og-image/fonts";
 import { fetchIsland } from "../../util/kit.js";
 import { applyEmojis } from "../core/transforms/emojis/index.js";

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

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

package/dist/runtime/server/plugins/prerender.js

@@ -1,7 +1,7 @@
 import { parse } from "devalue";
-import { appendResponseHeader } from "h3";
-import { defineNitroPlugin } from "nitropack/runtime";
 import { parseURL } from "ufo";
+import { appendResponseHeader } from "#nuxtseo/h3";
+import { defineNitroPlugin } from "#nuxtseo/nitro";
 import { prerenderOptionsCache } from "#og-image-cache";
 import { createSitePathResolver } from "#site-config/server/composables/utils";
 import { isInternalRoute } from "../../shared.js";

package/dist/runtime/server/routes/__zero-runtime/image.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+declare const _default: any;
 export default _default;

package/dist/runtime/server/routes/__zero-runtime/image.js

@@ -1,4 +1,4 @@
-import { defineEventHandler } from "h3";
+import { defineEventHandler } from "#nuxtseo/h3";
 import { imageEventHandler } from "../../util/eventHandlers.js";
 export default defineEventHandler(async (e) => {
   if (import.meta.dev || import.meta.prerender) {

package/dist/runtime/server/routes/debug.json.d.ts

@@ -1,11 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
-    siteConfigUrl: string;
-    origin: string;
-    componentNames: any;
-    runtimeConfig: import("../../types.js").OgImageRuntimeConfig;
-    compatibility: any;
-    resolvedFonts: any;
-    availableFonts: any;
-    fontRequirements: any;
-}>>;
+declare const _default: any;
 export default _default;

package/dist/runtime/server/routes/debug.json.js

@@ -1,4 +1,4 @@
-import { defineEventHandler, setHeader } from "h3";
+import { defineEventHandler, setHeader } from "#nuxtseo/h3";
 import { componentNames } from "#og-image-virtual/component-names.mjs";
 import compatibility from "#og-image/compatibility";
 import { fontRequirements } from "#og-image/font-requirements";

package/dist/runtime/server/routes/image.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+declare const _default: any;
 export default _default;

package/dist/runtime/server/routes/image.js

@@ -1,3 +1,3 @@
-import { defineEventHandler } from "h3";
+import { defineEventHandler } from "#nuxtseo/h3";
 import { imageEventHandler } from "../util/eventHandlers.js";
 export default defineEventHandler(imageEventHandler);

package/dist/runtime/server/routes/resolve.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;
+declare const _default: any;
 export default _default;

package/dist/runtime/server/routes/resolve.js

@@ -1,5 +1,6 @@
-import { createError, defineEventHandler, getRequestHost, sendRedirect } from "h3";
 import { parseURL, withLeadingSlash, withQuery } from "ufo";
+import { createError, defineEventHandler, getRequestHost, sendRedirect } from "#nuxtseo/h3";
+import { fetchWithEvent } from "#nuxtseo/nitro";
 import { getSiteConfig } from "#site-config/server/composables/getSiteConfig";
 import { isInternalRoute } from "../../shared.js";
 import { getEventQuery } from "../util/query.js";
@@ -98,7 +99,7 @@ export default defineEventHandler(async (event) => {
       forwardQuery[k] = v;
   }
   const fetchPath = withQuery(withLeadingSlash(targetPath), forwardQuery);
-  const html = await event.$fetch(fetchPath, {
+  const html = await fetchWithEvent(event, fetchPath, {
     headers: { accept: "text/html" },
     responseType: "text"
   }).catch((err) => {

package/dist/runtime/server/util/cache.d.ts

@@ -1,10 +1,5 @@
-import type { H3Error } from 'h3';
+import type { H3Error } from '#nuxtseo/h3';
 import type { OgImageRenderEventContext } from '../../types.js';
-declare module 'nitropack/types' {
-    interface NitroApp {
-        _ogImageCacheBackendWarned?: boolean;
-    }
-}
 export declare function useOgImageBufferCache(ctx: OgImageRenderEventContext, options: {
     baseCacheKey: string | false;
     cacheMaxAgeSeconds?: number;

package/dist/runtime/server/util/cache.js

@@ -1,8 +1,8 @@
 import { fnv1a64Base36 } from "fnv1a-64";
-import { createError, handleCacheHeaders, setHeader, setHeaders } from "h3";
-import { useStorage } from "nitropack/runtime";
 import { withTrailingSlash } from "ufo";
 import { prefixStorage } from "unstorage";
+import { createError, handleCacheHeaders, setHeader, setHeaders } from "#nuxtseo/h3";
+import { useStorage } from "#nuxtseo/nitro";
 import { logger } from "../../logger.js";
 import { getEventQuery } from "./query.js";
 function safeCompare(a, b) {

package/dist/runtime/server/util/cloudflare.d.ts

@@ -1,3 +1,3 @@
-import type { H3Event } from 'h3';
+import type { H3Event } from '#nuxtseo/h3';
 export type CloudflareEnv = Record<string, unknown>;
 export declare function getCloudflareEnv(event?: H3Event): CloudflareEnv | undefined;

package/dist/runtime/server/util/cloudflareAssets.d.ts

@@ -1,4 +1,4 @@
-import type { H3Event } from 'h3';
+import type { H3Event } from '#nuxtseo/h3';
 interface AssetsBinding {
     fetch: (request: string | Request, init?: RequestInit) => Promise<Response>;
 }

package/dist/runtime/server/util/cloudflareAssets.js

@@ -1,4 +1,4 @@
-import { getRequestURL } from "h3";
+import { getRequestURL } from "#nuxtseo/h3";
 import { getCloudflareEnv } from "./cloudflare.js";
 export function getCloudflareAssets(event) {
   const assets = getCloudflareEnv(event)?.ASSETS || event.context.ASSETS;

package/dist/runtime/server/util/eventHandlers.d.ts

@@ -1,2 +1,2 @@
-import type { H3Event } from 'h3';
+import type { H3Event } from '#nuxtseo/h3';
 export declare function imageEventHandler(e: H3Event): Promise<any>;

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

@@ -1,4 +1,4 @@
-import { createError, getRequestHost, H3Error, setHeader } from "h3";
+import { createError, getRequestHost, H3Error, setHeader } from "#nuxtseo/h3";
 import { getSiteConfig } from "#site-config/server/composables/getSiteConfig";
 import { logger } from "../../logger.js";
 import { getBuildCachedImage, setBuildCachedImage } from "../og-image/cache/buildCache.js";

package/dist/runtime/server/util/fetchLocalAsset.d.ts

@@ -1,4 +1,4 @@
-import type { H3Event } from 'h3';
+import type { H3Event } from '#nuxtseo/h3';
 export interface FetchLocalAssetOptions {
     fetchTimeout: number;
     headers?: Record<string, string>;
@@ -14,7 +14,7 @@ export interface FetchLocalAssetOptions {
 /**
  * Resolve a same-origin asset path to bytes, trying (in order):
  *   1. Cloudflare Workers ASSETS binding
- *   2. Nitro localFetch (`event.$fetch`) — resolves dynamic routes too
+ *   2. Nitro localFetch through the event-aware bridge, which resolves dynamic routes too
  *   3. External `$fetch` to the Nitro origin (opt-in)
  *
  * All steps share a single `AbortSignal.timeout(fetchTimeout)` so a broken

package/dist/runtime/server/util/fetchLocalAsset.js

@@ -1,4 +1,5 @@
 import { $fetch } from "ofetch";
+import { fetchWithEvent } from "#nuxtseo/nitro";
 import { getNitroOrigin } from "#site-config/server/composables";
 import { tryCloudflareAssetsFetch } from "./cloudflareAssets.js";
 export async function fetchLocalAsset(event, path, options) {
@@ -18,7 +19,7 @@ export async function fetchLocalAsset(event, path, options) {
   }));
   if (result || expired)
     return result;
-  result = await race(event.$fetch(path, {
+  result = await race(fetchWithEvent(event, path, {
     responseType: "arrayBuffer",
     signal: deadline,
     timeout: fetchTimeout,

package/dist/runtime/server/util/kit.d.ts

@@ -1,5 +1,9 @@
-import type { H3Event } from 'h3';
-import type { NitroRouteRules } from 'nitropack';
 import type { NuxtIslandResponse } from 'nuxt/app';
+import type { H3Event } from '#nuxtseo/h3';
+import type { OgImageOptions } from '../../types.js';
+interface OgImageRouteRules {
+    ogImage?: false | OgImageOptions & Record<string, any>;
+}
 export declare function fetchIsland(e: H3Event, component: string, props: Record<string, any>, timeout?: number): Promise<NuxtIslandResponse>;
-export declare function createNitroRouteRuleMatcher(): ((path: string) => NitroRouteRules);
+export declare function createNitroRouteRuleMatcher(): ((path: string) => OgImageRouteRules);
+export {};

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

@@ -1,12 +1,10 @@
-import { defu } from "defu";
-import { useRuntimeConfig } from "nitropack/runtime";
-import { createRouter as createRadixRouter, toRouteMatcher } from "radix3";
-import { withoutBase, withoutTrailingSlash } from "ufo";
+import { createNitroRouteRuleMatcher as createRouteRuleMatcher } from "nuxtseo-shared/server";
+import { fetchWithEvent, useRuntimeConfig } from "#nuxtseo/nitro";
 import { getIslandHash } from "#og-image/island-hash";
 export function fetchIsland(e, component, props, timeout) {
   const hashId = getIslandHash({ name: component, props });
   const signal = timeout ? AbortSignal.timeout(timeout) : void 0;
-  return e.$fetch(`/__nuxt_island/${component}_${hashId}.json`, {
+  return fetchWithEvent(e, `/__nuxt_island/${component}_${hashId}.json`, {
     params: {
       props: JSON.stringify(props)
     },
@@ -15,17 +13,5 @@ export function fetchIsland(e, component, props, timeout) {
   });
 }
 export function createNitroRouteRuleMatcher() {
-  const { nitro, app } = useRuntimeConfig();
-  const _routeRulesMatcher = toRouteMatcher(
-    createRadixRouter({
-      routes: Object.fromEntries(
-        Object.entries(nitro?.routeRules || {}).map(([path, rules]) => [withoutTrailingSlash(path), rules])
-      )
-    })
-  );
-  return (path) => {
-    return defu({}, ..._routeRulesMatcher.matchAll(
-      withoutBase(withoutTrailingSlash(path.split("?")[0]), app.baseURL)
-    ).reverse());
-  };
+  return createRouteRuleMatcher(useRuntimeConfig());
 }

package/dist/runtime/server/util/options.js

@@ -1,4 +1,4 @@
-import { createError } from "h3";
+import { createError } from "#nuxtseo/h3";
 import { componentNames } from "#og-image-virtual/component-names.mjs";
 const RENDERER_SUFFIXES = ["satori", "browser", "takumi"];
 const RE_RENDERER_SUFFIX_DOT = /\.?(satori|browser|takumi)$/i;

package/dist/runtime/server/util/query.d.ts

@@ -1,4 +1,4 @@
-import type { H3Event } from 'h3';
+import type { H3Event } from '#nuxtseo/h3';
 /**
  * Parse query parameters from the event path without relying on the H3 event
  * implementation. Nitro adapters can pass an H3 v1 event to bundled H3 v2

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

@@ -1,4 +1,4 @@
-import type { H3Event } from 'h3';
+import type { H3Event } from '#nuxtseo/h3';
 import type { OgImageOptionsInternal, OgImageRuntimeConfig } from '../types.js';
 export interface GetOgImagePathResult {
     path: string;

package/dist/runtime/server/utils.js

@@ -1,5 +1,5 @@
-import { useRuntimeConfig } from "nitropack/runtime";
 import { joinURL } from "ufo";
+import { useRuntimeConfig } from "#nuxtseo/nitro";
 import { componentNames } from "#og-image-virtual/component-names.mjs";
 import { buildOgImageUrl } from "../shared.js";
 import { getCloudflareEnv } from "./util/cloudflare.js";