nuxt-seo-utils 7.0.15 → 7.0.17

package/dist/runtime/app/composables/polyfills.js

@@ -0,0 +1,27 @@
+import { useSiteConfig } from "#site-config/app/composables/useSiteConfig";
+import { computed, toValue } from "vue";
+export function useSchemaOrg() {
+}
+export function defineWebSite() {
+}
+export function defineWebPage() {
+}
+export function defineBreadcrumb() {
+}
+export function useI18n() {
+  const siteConfig = useSiteConfig({
+    resolveRefs: false
+  });
+  return {
+    // eslint-disable-next-line unused-imports/no-unused-vars
+    t: (_, fallback, options) => fallback,
+    te: (_) => false,
+    strategy: "no_prefix",
+    defaultLocale: computed(() => {
+      return toValue(siteConfig.defaultLocale) || "en";
+    }),
+    locale: computed(() => {
+      return toValue(siteConfig.currentLocale) || toValue(siteConfig.defaultLocale) || "en";
+    })
+  };
+}

package/dist/runtime/app/composables/useBreadcrumbItems.d.ts

@@ -0,0 +1,112 @@
+import type { NuxtLinkProps } from 'nuxt/app';
+import type { MaybeRefOrGetter } from 'vue';
+interface NuxtUIBreadcrumbItem extends NuxtLinkProps {
+    label: string;
+    labelClass?: string;
+    icon?: string;
+    iconClass?: string;
+    as?: string;
+    type?: 'button' | 'submit' | 'reset';
+    disabled?: boolean;
+    active?: boolean;
+    exact?: boolean;
+    exactQuery?: boolean;
+    exactMatch?: boolean;
+    inactiveClass?: string;
+    [key: string]: any;
+}
+export interface BreadcrumbProps {
+    /**
+     * Generate the breadcrumbs based on a different path than the current route.
+     */
+    path?: MaybeRefOrGetter<string>;
+    /**
+     * The id of the breadcrumb list. It's recommended to provide a unique
+     * id when adding multiple breadcrumb lists to the same page.
+     */
+    id?: string;
+    /**
+     * Append additional breadcrumb items to the end of the list. This is applied
+     * after the `overrides` option.
+     */
+    append?: MaybeRefOrGetter<BreadcrumbItemProps[]>;
+    /**
+     * Prepend additional breadcrumb items to the start of the list. This is applied
+     * after the `overrides` option.
+     */
+    prepend?: MaybeRefOrGetter<BreadcrumbItemProps[]>;
+    /**
+     * Override any of the breadcrumb items based on the index.
+     */
+    overrides?: MaybeRefOrGetter<(BreadcrumbItemProps | false | undefined)[]>;
+    /**
+     * Should the schema.org breadcrumb be generated.
+     * @default true
+     */
+    schemaOrg?: boolean;
+    /**
+     * The Aria Label for the breadcrumbs.
+     * You shouldn't need to change this.
+     *
+     * @default 'Breadcrumbs'
+     */
+    ariaLabel?: string;
+    /**
+     * Should the current breadcrumb item be shown.
+     *
+     * @default false
+     */
+    hideCurrent?: MaybeRefOrGetter<boolean>;
+    /**
+     * Should the root breadcrumb be shown.
+     */
+    hideRoot?: MaybeRefOrGetter<boolean>;
+    /**
+     * Should breadcrumb items with non-existing path be shown.
+     *
+     * By default, every path segments will be present in breadcrumb list even if there is no corresponding page for such segment.
+     *
+     * @default false
+     */
+    hideNonExisting?: MaybeRefOrGetter<boolean>;
+    /**
+     * The root segment of the breadcrumb list.
+     *
+     * By default, this will be `/`, unless you're using Nuxt I18n with a prefix strategy.
+     */
+    rootSegment?: string;
+}
+export type ResolvedBreadcrumbProps = {
+    [key in keyof BreadcrumbProps]: BreadcrumbProps[key] extends MaybeRefOrGetter<infer T> ? T : BreadcrumbProps[key];
+};
+export interface BreadcrumbItemProps extends NuxtUIBreadcrumbItem {
+    /** Whether the breadcrumb item represents the aria-current. */
+    current?: boolean;
+    /**
+     * The type of current location the breadcrumb item represents, if `isCurrent` is true.
+     * @default 'page'
+     */
+    ariaCurrent?: 'page' | 'step' | 'location' | 'date' | 'time' | boolean | 'true' | 'false';
+    to?: string;
+    ariaLabel?: string;
+    separator?: boolean | string;
+    class?: (string | string[] | undefined)[] | string;
+    /**
+     * @internal
+     */
+    _props?: {
+        first: boolean;
+        last: boolean;
+    };
+}
+/**
+ * Generate an automatic breadcrumb list that helps users to navigate between pages.
+ *
+ * - Integrates with [Nuxt Schema.org](/schema-org/getting-started/installation) to generate [BreadcrumbList](https://schema.org/BreadcrumbList) structured data.
+ * - Integrates with [Nuxt I18n](https://i18n.nuxtjs.org/) to generate localized breadcrumbs.
+ *
+ * @see https://github.com/harlan-zw/nuxt-seo/blob/main/src/runtime/nuxt/composables/useBreadcrumbItems.ts
+ * @docs https://nuxtseo.com/nuxt-seo/api/breadcrumbs
+ */
+export declare function useBreadcrumbItems(_options?: BreadcrumbProps): import("vue").ComputedRef<BreadcrumbItemProps[]>;
+export {};

package/dist/runtime/app/composables/useBreadcrumbItems.js

@@ -0,0 +1,193 @@
+import { defineBreadcrumb, useI18n, useSchemaOrg } from "#imports";
+import { useSiteConfig } from "#site-config/app/composables/useSiteConfig";
+import { createSitePathResolver } from "#site-config/app/composables/utils";
+import { defu } from "defu";
+import { fixSlashes } from "nuxt-site-config/urls";
+import { useNuxtApp, useRoute, useRouter, useState } from "nuxt/app";
+import { withoutTrailingSlash } from "ufo";
+import {
+  computed,
+  getCurrentInstance,
+  inject,
+  onScopeDispose,
+  onUnmounted,
+  provide,
+  ref,
+  toRaw,
+  toValue,
+  watch
+} from "vue";
+import { pathBreadcrumbSegments } from "../../shared/breadcrumbs.js";
+function withoutQuery(path) {
+  return path.split("?")[0];
+}
+function titleCase(s) {
+  return s.replaceAll("-", " ").replace(/\w\S*/g, (w) => w.charAt(0).toUpperCase() + w.substr(1).toLowerCase());
+}
+const BreadcrumbCtx = Symbol("BreadcrumbCtx");
+export function useBreadcrumbItems(_options = {}) {
+  const nuxtApp = useNuxtApp();
+  const vm = getCurrentInstance();
+  const id = `${_options.id || "breadcrumb"}`;
+  const uid = `${vm?.uid || 0}`;
+  const parentChain = [];
+  let parent = vm?.parent;
+  while (parent) {
+    parentChain.push(parent.uid || 0);
+    parent = parent.parent;
+  }
+  const pauseUpdates = ref(import.meta.client && nuxtApp.isHydrating);
+  let stateRef = null;
+  if (vm) {
+    stateRef = inject(BreadcrumbCtx, null);
+    if (!stateRef) {
+      stateRef = ref({});
+      provide(BreadcrumbCtx, stateRef);
+    }
+    const state = stateRef.value;
+    state[uid] = _options;
+    stateRef.value = state;
+    onUnmounted(() => {
+      const state2 = toRaw(stateRef.value);
+      delete state2[uid];
+      stateRef.value = state2;
+    });
+    if (import.meta.client) {
+      const _ = [];
+      _.push(nuxtApp.hooks.hook("page:start", () => {
+        pauseUpdates.value = true;
+      }));
+      _.push(nuxtApp.hooks.hook("page:finish", () => {
+        if (!nuxtApp.isHydrating) {
+          pauseUpdates.value = false;
+        }
+      }));
+      _.push(nuxtApp.hooks.hook("app:error", () => {
+        pauseUpdates.value = false;
+      }));
+      _.push(nuxtApp.hooks.hook("app:suspense:resolve", () => {
+        pauseUpdates.value = false;
+      }));
+      onScopeDispose(() => {
+        _.forEach((hook) => hook?.());
+        _.length = 0;
+      });
+    }
+  }
+  const route = useRoute();
+  const router = useRouter();
+  const i18n = useI18n();
+  const siteResolver = createSitePathResolver({
+    canonical: true,
+    absolute: true
+  });
+  const lastBreadcrumbs = useState(`nuxt-seo:breadcrumb:${id}`, () => []);
+  const siteConfig = useSiteConfig();
+  const items = computed(() => {
+    if (import.meta.client && pauseUpdates.value) {
+      return lastBreadcrumbs.value;
+    }
+    const state = toValue(stateRef) || {};
+    const optionStack = [...parentChain, uid].map((parentId) => state[parentId]).filter(Boolean);
+    const flatOptions = optionStack.reduce((acc, _cur) => {
+      const cur = {};
+      Object.entries(_cur).forEach(([key, value]) => {
+        cur[key] = toValue(value);
+      });
+      acc.hideRoot = typeof cur.hideRoot === "undefined" ? acc.hideRoot : cur.hideRoot;
+      acc.hideCurrent = typeof cur.hideCurrent === "undefined" ? acc.hideCurrent : cur.hideCurrent;
+      acc.hideNonExisting = typeof cur.hideNonExisting === "undefined" ? acc.hideNonExisting : cur.hideNonExisting;
+      acc.rootSegment = acc.rootSegment || cur.rootSegment;
+      acc.path = acc.path || cur.path;
+      acc.overrides = acc.overrides || [];
+      const overrides = toRaw(toValue(cur.overrides));
+      if (overrides) {
+        overrides.forEach((item, index) => {
+          if (item !== void 0) {
+            acc.overrides[index] = toRaw(toValue(item));
+          }
+        });
+      }
+      const prepend = toRaw(toValue(cur.prepend));
+      const append = toRaw(toValue(cur.append));
+      if (prepend && prepend.length) {
+        acc.prepend = [...acc.prepend || [], ...prepend.map((m) => toRaw(toValue(m)))].filter(Boolean);
+      }
+      if (append && append.length)
+        acc.append = [...acc.append || [], ...append.map((m) => toRaw(toValue(m)))].filter(Boolean);
+      return acc;
+    }, {});
+    let rootNode = flatOptions.rootSegment || "/";
+    if (i18n) {
+      if (i18n.strategy === "prefix" || i18n.strategy !== "no_prefix" && toValue(i18n.defaultLocale) !== toValue(i18n.locale))
+        rootNode = `${rootNode}${toValue(i18n.locale)}`;
+    }
+    const current = withoutQuery(withoutTrailingSlash(flatOptions.path || toRaw(route)?.path || rootNode)) || "";
+    const segments = pathBreadcrumbSegments(current, rootNode).map((path, index) => {
+      let item = {
+        to: path
+      };
+      const override = flatOptions.overrides?.[index];
+      if (typeof override !== "undefined") {
+        if (override === false)
+          return false;
+        item = defu(override, item);
+      }
+      return item;
+    });
+    segments.unshift(...flatOptions.prepend || []);
+    segments.push(...flatOptions.append || []);
+    return segments.filter(Boolean).map((item) => {
+      let fallbackLabel = titleCase(String((item.to || "").split("/").pop()));
+      let fallbackAriaLabel = "";
+      const route2 = item.to ? router.resolve(item.to)?.matched?.at(-1) : null;
+      if (route2) {
+        const routeMeta = route2?.meta || {};
+        if (routeMeta.breadcrumb) {
+          item = defu(item, routeMeta.breadcrumb);
+        }
+        const routeName = String(route2.name).split("___")?.[0];
+        if (routeName === "index") {
+          fallbackLabel = "Home";
+        }
+        fallbackLabel = routeMeta.breadcrumbLabel || routeMeta.breadcrumbTitle || routeMeta.title || fallbackLabel;
+        fallbackLabel = i18n.t(`breadcrumb.items.${routeName}.label`, fallbackLabel, { missingWarn: false });
+        fallbackAriaLabel = i18n.t(`breadcrumb.items.${routeName}.ariaLabel`, fallbackAriaLabel, { missingWarn: false });
+      } else if (flatOptions.hideNonExisting) {
+        return false;
+      }
+      item.label = item.label || fallbackLabel;
+      item.ariaLabel = item.ariaLabel || fallbackAriaLabel || item.label;
+      item.current = item.current || item.to === current;
+      if (flatOptions.hideCurrent && item.current)
+        return false;
+      return item;
+    }).map((m) => {
+      if (m && m.to) {
+        m.to = fixSlashes(siteConfig.trailingSlash, m.to);
+        if (m.to === rootNode && flatOptions.hideRoot)
+          return false;
+      }
+      return m;
+    }).filter(Boolean);
+  });
+  watch(items, (newItems) => {
+    if (!pauseUpdates.value) {
+      lastBreadcrumbs.value = newItems;
+    }
+  }, { immediate: true, flush: "sync" });
+  const schemaOrgEnabled = typeof _options.schemaOrg === "undefined" ? true : _options.schemaOrg;
+  if ((import.meta.dev || import.meta.server || import.meta.env?.NODE_ENV === "test") && schemaOrgEnabled) {
+    useSchemaOrg([
+      // @ts-expect-error untyped
+      defineBreadcrumb({
+        id: `#${id}`,
+        itemListElement: computed(() => items.value.map((item) => ({
+          name: item.label || item.ariaLabel,
+          item: item.to ? siteResolver(item.to) : void 0
+        })))
+      })
+    ]);
+  }
+  return items;
+}

package/dist/runtime/app/logic/applyDefaults.d.ts

@@ -0,0 +1 @@
+export declare function applyDefaults(): void;

package/dist/runtime/app/logic/applyDefaults.js

@@ -0,0 +1,78 @@
+import { injectHead, useHead, useSeoMeta } from "#imports";
+import { useSiteConfig } from "#site-config/app/composables/useSiteConfig";
+import { createSitePathResolver } from "#site-config/app/composables/utils";
+import { TemplateParamsPlugin } from "@unhead/vue/plugins";
+import { useError, useRoute, useRuntimeConfig } from "nuxt/app";
+import { stringifyQuery } from "ufo";
+import { computed, toValue } from "vue";
+export function applyDefaults() {
+  const siteConfig = useSiteConfig({
+    resolveRefs: false
+  });
+  const resolveCurrentLocale = () => toValue(siteConfig.currentLocale) || toValue(siteConfig.defaultLocale) || "en";
+  const head = injectHead();
+  head.use(TemplateParamsPlugin);
+  const { canonicalQueryWhitelist, canonicalLowercase } = useRuntimeConfig().public["seo-utils"];
+  const route = useRoute();
+  const resolveUrl = createSitePathResolver({ withBase: true, absolute: true });
+  const err = useError();
+  const canonicalUrl = computed(() => {
+    if (err.value) {
+      return false;
+    }
+    const { query } = route;
+    let url = resolveUrl(route.path || "/").value || route.path;
+    if (canonicalLowercase) {
+      try {
+        url = url.toLocaleLowerCase(resolveCurrentLocale());
+      } catch {
+        url = url.toLowerCase();
+      }
+    }
+    const filteredQuery = Object.fromEntries(
+      Object.entries(query).filter(([key]) => canonicalQueryWhitelist.includes(key)).sort(([a], [b]) => a.localeCompare(b))
+      // Sort params
+    );
+    const href = Object.keys(filteredQuery).length ? `${url}?${stringifyQuery(filteredQuery)}` : url;
+    return { rel: "canonical", href };
+  });
+  const minimalPriority = {
+    // give nuxt.config values higher priority
+    tagPriority: "low"
+  };
+  useHead({
+    htmlAttrs: { lang: resolveCurrentLocale },
+    templateParams: {
+      site: () => siteConfig,
+      siteName: () => siteConfig.name
+    },
+    titleTemplate: "%s %separator %siteName",
+    link: [() => canonicalUrl.value]
+  }, minimalPriority);
+  const seoMeta = {
+    ogType: "website",
+    ogUrl: () => {
+      const url = canonicalUrl.value;
+      return url ? url.href : false;
+    },
+    ogLocale: () => {
+      const locale = resolveCurrentLocale();
+      if (locale) {
+        const l = locale.replace("-", "_");
+        if (l.includes("_")) {
+          return l;
+        }
+      }
+      return false;
+    },
+    ogSiteName: siteConfig.name
+  };
+  if (siteConfig.description)
+    seoMeta.description = siteConfig.description;
+  if (siteConfig.twitter) {
+    const id = siteConfig.twitter.startsWith("@") ? siteConfig.twitter : `@${siteConfig.twitter}`;
+    seoMeta.twitterCreator = id;
+    seoMeta.twitterSite = id;
+  }
+  useSeoMeta(seoMeta, minimalPriority);
+}

package/dist/runtime/app/plugins/0.routeRules.d.ts

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

package/dist/runtime/app/plugins/0.routeRules.js

@@ -0,0 +1,24 @@
+import { injectHead, useSeoMeta } from "#imports";
+import { defineNuxtPlugin, getRouteRules, useRequestEvent, useState } from "nuxt/app";
+export default defineNuxtPlugin({
+  enforce: "post",
+  async setup() {
+    const head = injectHead();
+    const routeRuleState = useState("nuxt-seo-utils:routeRules", () => null);
+    if (import.meta.server) {
+      const event = useRequestEvent();
+      const routeRules = await getRouteRules(event);
+      routeRuleState.value = {
+        head: routeRules.head,
+        seoMeta: routeRules.seoMeta
+      };
+    }
+    if (routeRuleState.value) {
+      const { head: headInput, seoMeta } = routeRuleState.value;
+      if (headInput)
+        head.push(headInput);
+      if (seoMeta)
+        useSeoMeta(seoMeta);
+    }
+  }
+});

package/dist/runtime/app/plugins/1.absoluteImageUrls.server.d.ts

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

package/dist/runtime/app/plugins/1.absoluteImageUrls.server.js

@@ -0,0 +1,33 @@
+import { injectHead } from "#imports";
+import { createSitePathResolver } from "#site-config/app/composables/utils";
+import { defineNuxtPlugin } from "nuxt/app";
+import { unref } from "vue";
+export default defineNuxtPlugin({
+  enforce: "post",
+  setup() {
+    const head = injectHead();
+    if (!head)
+      return;
+    const resolver = createSitePathResolver({
+      withBase: true,
+      absolute: true,
+      canonical: true
+    });
+    head.use({
+      key: "absoluteImageUrls",
+      hooks: {
+        "tags:resolve": async ({ tags }) => {
+          for (const tag of tags) {
+            if (tag.tag !== "meta")
+              continue;
+            if (tag.props.property !== "og:image:url" && tag.props.property !== "og:image" && tag.props.name !== "twitter:image")
+              continue;
+            if (typeof tag.props.content !== "string" || !tag.props.content.trim() || tag.props.content.startsWith("http") || tag.props.content.startsWith("//"))
+              continue;
+            tag.props.content = unref(resolver(tag.props.content));
+          }
+        }
+      }
+    });
+  }
+});

package/dist/runtime/app/plugins/defaults.d.ts

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

package/dist/runtime/app/plugins/defaults.js

@@ -0,0 +1,12 @@
+import { defineNuxtPlugin } from "nuxt/app";
+import { applyDefaults } from "../logic/applyDefaults.js";
+export default defineNuxtPlugin({
+  name: "nuxt-seo:defaults",
+  order: 999,
+  env: {
+    islands: false
+  },
+  setup() {
+    applyDefaults();
+  }
+});

package/dist/runtime/app/plugins/defaultsWaitI18n.d.ts

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

package/dist/runtime/app/plugins/defaultsWaitI18n.js

@@ -0,0 +1,13 @@
+import { defineNuxtPlugin } from "nuxt/app";
+import { applyDefaults } from "../logic/applyDefaults.js";
+export default defineNuxtPlugin({
+  name: "nuxt-seo:defaults",
+  env: {
+    islands: false
+  },
+  // we need to wait for the i18n plugin to run first
+  dependsOn: ["nuxt-site-config:i18n"],
+  setup() {
+    applyDefaults();
+  }
+});

package/dist/runtime/app/plugins/inferSeoMetaPlugin.d.ts

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

package/dist/runtime/app/plugins/inferSeoMetaPlugin.js

@@ -0,0 +1,11 @@
+import { injectHead } from "#imports";
+import { InferSeoMetaPlugin } from "@unhead/addons";
+import { defineNuxtPlugin } from "nuxt/app";
+import { TemplateParamsPlugin } from "unhead/plugins";
+export default defineNuxtPlugin(() => {
+  const head = injectHead();
+  if (!head)
+    return;
+  head.use(TemplateParamsPlugin);
+  head.use(InferSeoMetaPlugin());
+});

package/dist/runtime/app/plugins/siteConfig.d.ts

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

package/dist/runtime/app/plugins/siteConfig.js

@@ -0,0 +1,33 @@
+import { injectHead } from "#imports";
+import { useSiteConfig } from "#site-config/app/composables/useSiteConfig";
+import { defineNuxtPlugin } from "nuxt/app";
+export default defineNuxtPlugin(() => {
+  const head = injectHead();
+  if (!head)
+    return;
+  const siteConfig = useSiteConfig();
+  const input = {
+    meta: [],
+    templateParams: {
+      site: siteConfig,
+      // support legacy
+      siteUrl: siteConfig.url,
+      siteName: siteConfig.name
+    }
+  };
+  if (siteConfig.separator)
+    input.templateParams.separator = siteConfig.separator;
+  if (siteConfig.titleSeparator)
+    input.templateParams.titleSeparator = siteConfig.titleSeparator;
+  if (siteConfig.description) {
+    input.templateParams.siteDescription = siteConfig.description;
+    input.meta.push(
+      {
+        name: "description",
+        content: "%site.description",
+        tagPriority: "low"
+      }
+    );
+  }
+  head.push(input);
+});

package/dist/runtime/app/plugins/titles.d.ts

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

package/dist/runtime/app/plugins/titles.js

@@ -0,0 +1,30 @@
+import { useHead } from "#imports";
+import { defineNuxtPlugin, useError, useRoute } from "nuxt/app";
+import { titleCase } from "scule";
+import { withoutTrailingSlash } from "ufo";
+import { computed } from "vue";
+export default defineNuxtPlugin({
+  name: "nuxt-seo:fallback-titles",
+  env: {
+    islands: false
+  },
+  setup() {
+    const route = useRoute();
+    const err = useError();
+    const title = computed(() => {
+      if (err.value && [404, 500].includes(err.value?.statusCode)) {
+        return `${err.value.statusCode} - ${err.value.message}`;
+      }
+      if (typeof route.meta?.title === "string")
+        return route.meta?.title;
+      const path = withoutTrailingSlash(route.path || "/");
+      const lastSegment = path.split("/").pop();
+      return lastSegment ? titleCase(lastSegment) : null;
+    });
+    const minimalPriority = {
+      // give nuxt.config values higher priority
+      tagPriority: 101
+    };
+    useHead({ title: () => title.value }, minimalPriority);
+  }
+});

package/dist/runtime/server/middleware/redirectCanonical.d.ts

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

package/dist/runtime/server/middleware/redirectCanonical.js

@@ -0,0 +1,28 @@
+import { useSiteConfig } from "#site-config/server/composables/useSiteConfig";
+import { defineEventHandler, getRequestHost, sendRedirect, setHeader } from "h3";
+import { joinURL } from "ufo";
+export default defineEventHandler((e) => {
+  if (import.meta.prerender) {
+    return;
+  }
+  const path = e.path;
+  if (path.startsWith("/_nuxt") || path.startsWith("/api")) {
+    return;
+  }
+  if (path.split("/").pop()?.includes(".")) {
+    return;
+  }
+  const siteConfig = useSiteConfig(e);
+  if (!siteConfig.url || siteConfig.env !== "production") {
+    return;
+  }
+  const siteConfigHostName = new URL(e.path, siteConfig.url).host;
+  const host = getRequestHost(e, { xForwardedHost: true });
+  if (e.headers.get("x-nuxt-seo-redirected") || host.includes("http") || host.replace("https://", "").includes(":")) {
+    return;
+  }
+  if (host.split(":")[0] !== siteConfigHostName.split(":")[0]) {
+    setHeader(e, "x-nuxt-seo-redirected", "true");
+    return sendRedirect(e, joinURL(siteConfig.url, e.path), 301);
+  }
+});

package/dist/runtime/server/middleware/resolveImagesInPagesDir.d.ts

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

package/dist/runtime/server/middleware/resolveImagesInPagesDir.js

@@ -0,0 +1,16 @@
+import fs from "node:fs";
+import { fileMapping } from "#seo-utils-virtual/pageDirImages";
+import { defineEventHandler, setHeader } from "h3";
+import { parseURL } from "ufo";
+export default defineEventHandler(async (e) => {
+  const path = parseURL(e.path).pathname;
+  if (fileMapping[path]) {
+    if (path.endsWith(".svg"))
+      setHeader(e, "Content-Type", "image/svg+xml");
+    else if (path.endsWith(".png"))
+      setHeader(e, "Content-Type", "image/png");
+    else if (path.endsWith(".jpg") || path.endsWith(".jpeg"))
+      setHeader(e, "Content-Type", "image/jpeg");
+    return fs.readFileSync(fileMapping[path]);
+  }
+});

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../../.nuxt/tsconfig.server.json"
+}

package/dist/runtime/shared/breadcrumbs.d.ts

@@ -0,0 +1 @@
+export declare function pathBreadcrumbSegments(path: string, rootNode?: string): string[];