@nuxtjs/sitemap 7.5.2 → 8.0.0

package/dist/module.mjs

@@ -1,275 +1,43 @@
-import { useNuxt, loadNuxtModuleInstance, extendPages, tryUseNuxt, defineNuxtModule, createResolver, useLogger, hasNuxtModule, getNuxtModuleVersion, hasNuxtModuleCompatibility, addServerImports, addTypeTemplate, addServerPlugin, resolveModule, addServerHandler, addPrerenderRoutes } from '@nuxt/kit';
-import { withHttps, withBase, joinURL, withTrailingSlash, withoutLeadingSlash, withLeadingSlash, withoutTrailingSlash } from 'ufo';
-import { withSiteUrl, installNuxtSiteConfig } from 'nuxt-site-config/kit';
+import { useNuxt, hasNuxtModule, addTypeTemplate, addTemplate, defineNuxtModule, createResolver, useLogger, getNuxtModuleVersion, hasNuxtModuleCompatibility, addServerImports, addPrerenderRoutes, addServerPlugin, resolveModule, addServerHandler } from '@nuxt/kit';
 import { defu } from 'defu';
+import { withSiteUrl, installNuxtSiteConfig } from 'nuxt-site-config/kit';
+import { isPathFile } from 'nuxt-site-config/urls';
+import { dirname, extname } from 'pathe';
 import { readPackageJSON } from 'pkg-types';
-import { extname, dirname, relative } from 'pathe';
-import { statSync, readFileSync, existsSync } from 'node:fs';
-import { createPathFilter, splitForLocales, mergeOnKey } from '../dist/runtime/utils-pure.js';
-import { provider, env } from 'std-env';
+import { withBase, withHttps, withTrailingSlash, withoutLeadingSlash, joinURL, withLeadingSlash, withoutTrailingSlash } from 'ufo';
+import { setupDevToolsUI as setupDevToolsUI$1 } from 'nuxtseo-shared/devtools';
+import { readFileSync, statSync } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import chalk from 'chalk';
-import { p as parseHtmlExtractSitemapMeta } from './shared/sitemap.Bj0OAEtK.mjs';
+import { colors } from 'consola/utils';
+import { splitForLocales, createPathFilter } from '../dist/runtime/utils-pure.js';
+import { isNuxtGenerate, resolveNitroPreset, getNuxtModuleOptions, resolveNuxtContentVersion, createPagesPromise, createNitroPromise } from 'nuxtseo-shared/kit';
+import { p as parseHtmlExtractSitemapMeta } from './shared/sitemap.B99ug6A9.mjs';
 import { normaliseDate } from '../dist/runtime/server/sitemap/urlset/normalise.js';
-import { isPathFile } from 'nuxt-site-config/urls';
+import { splitPathForI18nLocales as splitPathForI18nLocales$1, normalizeLocales, generatePathForI18nPages } from 'nuxtseo-shared/i18n';
 import 'ultrahtml';
 
-async function resolveUrls(urls, ctx) {
-  try {
-    if (typeof urls === "function")
-      urls = urls();
-    urls = await urls;
-  } catch (e) {
-    ctx.logger.error(`Failed to resolve ${typeof urls} urls.`);
-    ctx.logger.error(e);
-    return [];
-  }
-  try {
-    urls = JSON.parse(JSON.stringify(urls));
-  } catch (e) {
-    ctx.logger.error(`Failed to serialize ${typeof urls} \`${ctx.path}\`, please make sure that the urls resolve as a valid array without circular dependencies.`);
-    ctx.logger.error(e);
-    return [];
-  }
-  return urls;
-}
-function deepForEachPage(pages, callback, opts, fullpath = null, depth = 0) {
-  pages.forEach((page) => {
-    let currentPath;
-    if (page.path.startsWith("/")) {
-      currentPath = page.path;
-    } else {
-      currentPath = page.path === "" ? fullpath : `${fullpath.replace(/\/$/, "")}/${page.path}`;
-    }
-    let didCallback = false;
-    if (opts.isI18nMicro) {
-      const localePattern = /\/:locale\(([^)]+)\)/;
-      const match = localePattern.exec(currentPath || "");
-      if (match && match[1]) {
-        const locales = match[1].split("|");
-        locales.forEach((locale) => {
-          const subPage = { ...page };
-          const localizedPath = (currentPath || "").replace(localePattern, `/${locale}`);
-          subPage.name += opts.routesNameSeparator + locale;
-          subPage.path = localizedPath;
-          callback(subPage, localizedPath || "", depth);
-          didCallback = true;
-        });
-      }
-    }
-    if (!didCallback) {
-      callback(page, currentPath || "", depth);
-    }
-    if (page.children) {
-      deepForEachPage(page.children, callback, opts, currentPath, depth + 1);
-    }
-  });
-}
-function convertNuxtPagesToSitemapEntries(pages, config) {
-  const pathFilter = createPathFilter(config.filter);
-  const routesNameSeparator = config.routesNameSeparator || "___";
-  let flattenedPages = [];
-  deepForEachPage(
-    pages,
-    (page, loc, depth) => {
-      flattenedPages.push({ page, loc, depth });
-    },
-    {
-      ...config,
-      routesNameSeparator: config.routesNameSeparator || "___"
-    }
+function setupDevToolsUI(_options, resolve, nuxt = useNuxt()) {
+  setupDevToolsUI$1(
+    { route: "/__nuxt-sitemap", name: "sitemap", title: "Sitemap", icon: "carbon:load-balancer-application" },
+    resolve,
+    nuxt
   );
-  flattenedPages = flattenedPages.filter((page) => !page.loc.includes(":")).filter((page, idx, arr) => {
-    return !arr.find((p) => {
-      return p.loc === page.loc && p.depth > page.depth;
-    });
-  }).map((p) => {
-    delete p.depth;
-    return p;
-  });
-  if (config.strategy === "prefix_and_default") {
-    flattenedPages = flattenedPages.filter((p) => {
-      if (p.page?.name) {
-        const [, locale] = p.page.name.split(routesNameSeparator);
-        return locale !== config.defaultLocale || p.page.name.endsWith("__default");
-      }
-      return true;
-    });
-  }
-  const pagesWithMeta = flattenedPages.map((p) => {
-    if (config.autoLastmod && p.page.file) {
-      const stats = statSync(p.page.file, { throwIfNoEntry: false });
-      if (stats?.mtime)
-        p.lastmod = stats.mtime;
-    }
-    if (p.page?.meta?.sitemap) {
-      p = defu(p.page.meta.sitemap, p);
-    }
-    return p;
-  });
-  const localeGroups = {};
-  pagesWithMeta.reduce((acc, e) => {
-    if (e.page.name?.includes(routesNameSeparator)) {
-      const [name, locale] = e.page.name.split(routesNameSeparator);
-      if (!name)
-        return acc;
-      if (!acc[name])
-        acc[name] = [];
-      const { _sitemap } = config.normalisedLocales.find((l) => l.code === locale) || { _sitemap: locale };
-      acc[name].push({ ...e, _sitemap: config.isI18nMapped ? _sitemap : void 0, locale });
-    } else {
-      acc.default = acc.default || [];
-      acc.default.push(e);
-    }
-    return acc;
-  }, localeGroups);
-  return Object.entries(localeGroups).map(([locale, entries]) => {
-    if (locale === "default") {
-      return entries.map((e) => {
-        const [name] = (e.page?.name || "").split(routesNameSeparator);
-        if (!name)
-          return false;
-        if (localeGroups[name]?.some((a) => a.locale === config.defaultLocale))
-          return false;
-        const defaultLocale = config.normalisedLocales.find((l) => l.code === config.defaultLocale);
-        if (defaultLocale && config.isI18nMapped)
-          e._sitemap = defaultLocale._sitemap;
-        delete e.page;
-        delete e.locale;
-        return { ...e };
-      }).filter(Boolean);
-    }
-    return entries.map((entry) => {
-      const alternatives = entries.map((entry2) => {
-        const locale2 = config.normalisedLocales.find((l) => l.code === entry2.locale);
-        if (!pathFilter(entry2.loc))
-          return false;
-        const href = locale2?.domain ? withHttps(withBase(entry2.loc, locale2?.domain)) : entry2.loc;
-        return {
-          hreflang: locale2?._hreflang,
-          href
-        };
-      }).filter(Boolean);
-      const xDefault = entries.find((a) => a.locale === config.defaultLocale);
-      if (xDefault && alternatives.length && pathFilter(xDefault.loc)) {
-        const locale2 = config.normalisedLocales.find((l) => l.code === xDefault.locale);
-        const href = locale2?.domain ? withHttps(withBase(xDefault.loc, locale2?.domain)) : xDefault.loc;
-        alternatives.push({
-          hreflang: "x-default",
-          href
-        });
-      }
-      const e = { ...entry };
-      if (config.isI18nMapped) {
-        const { _sitemap } = config.normalisedLocales.find((l) => l.code === entry.locale) || { _sitemap: locale };
-        e._sitemap = _sitemap;
-      }
-      delete e.page;
-      delete e.locale;
-      return {
-        ...e,
-        alternatives
-      };
-    });
-  }).filter(Boolean).flat();
-}
-function generateExtraRoutesFromNuxtConfig(nuxt = useNuxt()) {
-  const filterForValidPage = (p) => typeof p === "string" && !!p && !extname(p) && !p.startsWith("/api/") && !p.startsWith("/_");
-  const routeRules = Object.entries(nuxt.options.routeRules || {}).filter(([k, v]) => {
-    if (k.includes("*") || k.includes(".") || k.includes(":"))
-      return false;
-    if ("robots" in v && typeof v.robots === "boolean" && !v.robots)
-      return false;
-    return !v.redirect;
-  }).map(([k]) => k).filter(filterForValidPage);
-  const prerenderUrls = (nuxt.options.nitro.prerender?.routes || []).filter(filterForValidPage);
-  return { routeRules, prerenderUrls };
-}
-
-async function getNuxtModuleOptions(module, nuxt = useNuxt()) {
-  const moduleMeta = (typeof module === "string" ? { name: module } : await module.getMeta?.()) || {};
-  const { nuxtModule } = await loadNuxtModuleInstance(module, nuxt);
-  let moduleEntry;
-  for (const m of nuxt.options.modules) {
-    if (Array.isArray(m) && m.length >= 2) {
-      const _module = m[0];
-      const _moduleEntryName = typeof _module === "string" ? _module : (await _module.getMeta?.())?.name || "";
-      if (_moduleEntryName === moduleMeta.name)
-        moduleEntry = m;
-    }
-  }
-  let inlineOptions = {};
-  if (moduleEntry)
-    inlineOptions = moduleEntry[1];
-  if (nuxtModule.getOptions)
-    return nuxtModule.getOptions(inlineOptions, nuxt);
-  return inlineOptions;
-}
-function createPagesPromise(nuxt = useNuxt()) {
-  return new Promise((resolve) => {
-    nuxt.hooks.hook("modules:done", () => {
-      if (typeof nuxt.options.pages === "boolean" && nuxt.options.pages === false || typeof nuxt.options.pages === "object" && !nuxt.options.pages.enabled) {
-        return resolve([]);
-      }
-      extendPages(resolve);
-    });
-  });
-}
-function createNitroPromise(nuxt = useNuxt()) {
-  return new Promise((resolve) => {
-    nuxt.hooks.hook("nitro:init", (nitro) => {
-      resolve(nitro);
-    });
-  });
-}
-const autodetectableProviders = {
-  azure_static: "azure",
-  cloudflare_pages: "cloudflare-pages",
-  netlify: "netlify",
-  stormkit: "stormkit",
-  vercel: "vercel",
-  cleavr: "cleavr",
-  stackblitz: "stackblitz"
-};
-const autodetectableStaticProviders = {
-  netlify: "netlify-static",
-  vercel: "vercel-static"
-};
-function detectTarget(options = {}) {
-  return options?.static ? autodetectableStaticProviders[provider] : autodetectableProviders[provider];
-}
-function resolveNitroPreset(nitroConfig) {
-  nitroConfig = nitroConfig || tryUseNuxt()?.options?.nitro;
-  if (provider === "stackblitz")
-    return "stackblitz";
-  let preset;
-  if (nitroConfig && nitroConfig?.preset)
-    preset = nitroConfig.preset;
-  if (!preset)
-    preset = env.NITRO_PRESET || env.SERVER_PRESET || detectTarget() || "node-server";
-  return preset.replace("_", "-");
 }
 
 function formatPrerenderRoute(route) {
   let str = `  \u251C\u2500 ${route.route} (${route.generateTimeMS}ms)`;
   if (route.error) {
-    const errorColor = chalk[route.error.statusCode === 404 ? "yellow" : "red"];
+    const errorColor = colors[route.error.statusCode === 404 ? "yellow" : "red"];
     const errorLead = "\u2514\u2500\u2500";
     str += `
-  \u2502 ${errorLead} ${errorColor(route.error)}`;
+  \u2502 ${errorLead} ${errorColor(route.error.message)}`;
   }
-  return chalk.gray(str);
+  return colors.gray(str);
 }
 function includesSitemapRoot(sitemapName, routes) {
   return routes.includes(`/__sitemap__/`) || routes.includes(`/sitemap.xml`) || routes.includes(`/${sitemapName}`) || routes.includes("/sitemap_index.xml");
 }
-function isNuxtGenerate(nuxt = useNuxt()) {
-  return nuxt.options.nitro.static || nuxt.options._generate || [
-    "static",
-    "github-pages"
-  ].includes(resolveNitroPreset());
-}
 const NuxtRedirectHtmlRegex = /<!DOCTYPE html><html><head><meta http-equiv="refresh" content="0; url=([^"]+)"><\/head><\/html>/;
 function setupPrerenderHandler(_options, nuxt = useNuxt()) {
   const { runtimeConfig: options, logger, generateGlobalSources, generateChildSources } = _options;
@@ -284,7 +52,7 @@ function setupPrerenderHandler(_options, nuxt = useNuxt()) {
   const shouldHookIntoPrerender = prerenderSitemap || nuxt.options.nitro.prerender.routes.length && nuxt.options.nitro.prerender.crawlLinks;
   if (isNuxtGenerate() && options.debug) {
     nuxt.options.nitro.prerender.routes.push("/__sitemap__/debug.json");
-    logger.info("Adding debug route for sitemap generation:", chalk.cyan("/__sitemap__/debug.json"));
+    logger.info("Adding debug route for sitemap generation:", colors.cyan("/__sitemap__/debug.json"));
   }
   if (!shouldHookIntoPrerender) {
     return;
@@ -312,7 +80,7 @@ export async function readSourcesFromFilesystem(filename) {
       const html = route.contents;
       if (!route.fileName?.endsWith(".html") || !html || ["/200.html", "/404.html"].includes(route.route))
         return;
-      if (html.match(NuxtRedirectHtmlRegex)) {
+      if (NuxtRedirectHtmlRegex.test(html)) {
         return;
       }
       const extractedMeta = parseHtmlExtractSitemapMeta(html, {
@@ -366,7 +134,8 @@ async function prerenderSitemapsFromEntry(nitro, entry) {
   const processed = /* @__PURE__ */ new Set();
   while (queue.length) {
     const route = queue.shift();
-    if (processed.has(route)) continue;
+    if (processed.has(route))
+      continue;
     processed.add(route);
     const { filePath, prerenderUrls } = await prerenderRoute(nitro, route);
     sitemaps.push({
@@ -407,97 +176,102 @@ async function prerenderRoute(nitro, route) {
   return { filePath, prerenderUrls };
 }
 
-const DEVTOOLS_UI_ROUTE = "/__sitemap__/devtools";
-const DEVTOOLS_UI_LOCAL_PORT = 3030;
-function setupDevToolsUI(options, resolve, nuxt = useNuxt()) {
-  const clientPath = resolve("./client");
-  const isProductionBuild = existsSync(clientPath);
-  if (isProductionBuild) {
-    nuxt.hook("vite:serverCreated", async (server) => {
-      const sirv = await import('sirv').then((r) => r.default || r);
-      server.middlewares.use(
-        DEVTOOLS_UI_ROUTE,
-        sirv(clientPath, { dev: true, single: true })
-      );
-    });
-  } else {
-    nuxt.hook("vite:extendConfig", (config) => {
-      Object.assign(config, {
-        server: {
-          ...config.server,
-          proxy: {
-            ...config.server?.proxy,
-            [DEVTOOLS_UI_ROUTE]: {
-              target: `http://localhost:${DEVTOOLS_UI_LOCAL_PORT}${DEVTOOLS_UI_ROUTE}`,
-              changeOrigin: true,
-              followRedirects: true,
-              rewrite: (path) => path.replace(DEVTOOLS_UI_ROUTE, "")
-            }
-          }
-        }
-      });
-    });
+function registerTypeTemplates() {
+  const hasRobotsModule = hasNuxtModule("@nuxtjs/robots") || hasNuxtModule("nuxt-simple-robots");
+  addTypeTemplate({
+    filename: "types/nuxt-sitemap-augments.d.ts",
+    getContents: () => {
+      const robotsType = hasRobotsModule ? "" : "    robots?: boolean\n";
+      return `// Generated by @nuxtjs/sitemap
+/// <reference path="./nuxt-sitemap-virtual.d.ts" />
+import type { SitemapUrl, SitemapItemDefaults, SitemapIndexRenderCtx, SitemapInputCtx, SitemapRenderCtx, SitemapOutputHookCtx, SitemapSourcesHookCtx } from '@nuxtjs/sitemap'
+
+declare module 'nitropack' {
+  interface PrerenderRoute {
+    _sitemap?: SitemapUrl
+  }
+  interface NitroRouteRules {
+${robotsType}    sitemap?: SitemapItemDefaults | false
+  }
+  interface NitroRouteConfig {
+${robotsType}    sitemap?: SitemapItemDefaults | false
+  }
+  interface NitroRuntimeHooks {
+    'sitemap:index-resolved': (ctx: SitemapIndexRenderCtx) => void | Promise<void>
+    'sitemap:input': (ctx: SitemapInputCtx) => void | Promise<void>
+    'sitemap:resolved': (ctx: SitemapRenderCtx) => void | Promise<void>
+    'sitemap:output': (ctx: SitemapOutputHookCtx) => void | Promise<void>
+    'sitemap:sources': (ctx: SitemapSourcesHookCtx) => void | Promise<void>
   }
-  nuxt.hook("devtools:customTabs", (tabs) => {
-    tabs.push({
-      // unique identifier
-      name: "sitemap",
-      // title to display in the tab
-      title: "Sitemap",
-      // any icon from Iconify, or a URL to an image
-      icon: "carbon:load-balancer-application",
-      // iframe view
-      view: {
-        type: "iframe",
-        src: DEVTOOLS_UI_ROUTE
-      }
-    });
-  });
 }
 
-function splitPathForI18nLocales(path, autoI18n) {
-  const locales = autoI18n.strategy === "prefix_except_default" ? autoI18n.locales.filter((l) => l.code !== autoI18n.defaultLocale) : autoI18n.locales;
-  if (typeof path !== "string" || path.startsWith("/_"))
-    return path;
-  const match = splitForLocales(path, locales.map((l) => l.code));
-  const locale = match[0];
-  if (locale)
-    return path;
-  return [
-    path,
-    ...locales.map((l) => `/${l.code}${path}`)
-  ];
+declare module 'nitropack/types' {
+  interface PrerenderRoute {
+    _sitemap?: SitemapUrl
+  }
+  interface NitroRouteRules {
+${robotsType}    sitemap?: SitemapItemDefaults | false
+  }
+  interface NitroRouteConfig {
+${robotsType}    sitemap?: SitemapItemDefaults | false
+  }
+  interface NitroRuntimeHooks {
+    'sitemap:index-resolved': (ctx: SitemapIndexRenderCtx) => void | Promise<void>
+    'sitemap:input': (ctx: SitemapInputCtx) => void | Promise<void>
+    'sitemap:resolved': (ctx: SitemapRenderCtx) => void | Promise<void>
+    'sitemap:output': (ctx: SitemapOutputHookCtx) => void | Promise<void>
+    'sitemap:sources': (ctx: SitemapSourcesHookCtx) => void | Promise<void>
+  }
+}
+
+declare module 'vue-router' {
+  interface RouteMeta {
+    sitemap?: SitemapItemDefaults | false
+  }
 }
-function generatePathForI18nPages(ctx) {
-  const { localeCode, pageLocales, nuxtI18nConfig, forcedStrategy, normalisedLocales } = ctx;
-  const locale = normalisedLocales.find((l) => l.code === localeCode);
-  let path = pageLocales;
-  switch (forcedStrategy ?? nuxtI18nConfig.strategy) {
-    case "prefix_except_default":
-    case "prefix_and_default":
-      path = localeCode === nuxtI18nConfig.defaultLocale ? pageLocales : joinURL(localeCode, pageLocales);
-      break;
-    case "prefix":
-      path = joinURL(localeCode, pageLocales);
-      break;
+
+declare module '#app' {
+  interface PageMeta {
+    sitemap?: SitemapItemDefaults | false
   }
-  return locale?.domain ? withHttps(withBase(path, locale.domain)) : path;
 }
-function normalizeLocales(nuxtI18nConfig) {
-  const rawLocales = nuxtI18nConfig.locales || [];
-  let onlyLocales = nuxtI18nConfig?.bundle?.onlyLocales || [];
-  onlyLocales = typeof onlyLocales === "string" ? [onlyLocales] : onlyLocales;
-  let locales = mergeOnKey(rawLocales.map((locale) => typeof locale === "string" ? { code: locale } : locale), "code");
-  if (onlyLocales.length) {
-    locales = locales.filter((locale) => onlyLocales.includes(locale.code));
+
+declare module 'nuxt/app' {
+  interface PageMeta {
+    sitemap?: SitemapItemDefaults | false
   }
-  return locales.map((locale) => {
-    if (typeof locale.iso === "string" && !locale.language) {
-      locale.language = locale.iso;
+}
+
+export {}
+`;
     }
-    const _hreflang = locale.language || locale.code;
-    const _sitemap = locale.language || locale.code;
-    return { ...locale, _hreflang, _sitemap };
+  });
+  addTemplate({
+    filename: "types/nuxt-sitemap-virtual.d.ts",
+    getContents: () => `declare module '#sitemap-virtual/read-sources.mjs' {
+  export function readSourcesFromFilesystem(filename: string): Promise<any | null>
+}
+
+declare module '#sitemap-virtual/global-sources.mjs' {
+  import type { SitemapSourceBase, SitemapSourceResolved } from '#sitemap/types'
+
+  export const sources: (SitemapSourceBase | SitemapSourceResolved)[]
+}
+
+declare module '#sitemap-virtual/child-sources.mjs' {
+  import type { SitemapSourceBase, SitemapSourceResolved } from '#sitemap/types'
+
+  export const sources: Record<string, (SitemapSourceBase | SitemapSourceResolved)[]>
+}
+
+declare module '#sitemap/content-filters' {
+  export const filters: Map<string, (entry: any) => boolean>
+}
+
+declare module '#sitemap/content-on-url' {
+  export const onUrlFns: Map<string, (url: Record<string, unknown>, entry: any, collection: string) => void>
+}
+`
   });
 }
 
@@ -520,6 +294,184 @@ function normalizeFilters(filters) {
   }).filter(Boolean);
 }
 
+function splitPathForI18nLocales(path, autoI18n) {
+  if (typeof path !== "string")
+    return path;
+  return splitPathForI18nLocales$1(path, autoI18n);
+}
+
+async function resolveUrls(urls, ctx) {
+  try {
+    if (typeof urls === "function")
+      urls = urls();
+    urls = await urls;
+  } catch (e) {
+    ctx.logger.error(`Failed to resolve ${typeof urls} urls.`);
+    ctx.logger.error(e);
+    return [];
+  }
+  try {
+    urls = JSON.parse(JSON.stringify(urls));
+  } catch (e) {
+    ctx.logger.error(`Failed to serialize ${typeof urls} \`${ctx.path}\`, please make sure that the urls resolve as a valid array without circular dependencies.`);
+    ctx.logger.error(e);
+    return [];
+  }
+  return urls;
+}
+function deepForEachPage(pages, callback, opts, fullpath = null, depth = 0) {
+  pages.forEach((page) => {
+    let currentPath;
+    if (page.path.startsWith("/")) {
+      currentPath = page.path;
+    } else {
+      currentPath = page.path === "" ? fullpath : `${fullpath.replace(/\/$/, "")}/${page.path}`;
+    }
+    let didCallback = false;
+    if (opts.isI18nMicro) {
+      const localePattern = /\/:locale\(([^)]+)\)/;
+      const match = localePattern.exec(currentPath || "");
+      if (match && match[1]) {
+        const locales = match[1].split("|");
+        locales.forEach((locale) => {
+          const subPage = { ...page };
+          const localizedPath = (currentPath || "").replace(localePattern, `/${locale}`);
+          subPage.name += opts.routesNameSeparator + locale;
+          subPage.path = localizedPath;
+          callback(subPage, localizedPath || "", depth);
+          didCallback = true;
+        });
+      }
+    }
+    if (!didCallback) {
+      callback(page, currentPath || "", depth);
+    }
+    if (page.children) {
+      deepForEachPage(page.children, callback, opts, currentPath, depth + 1);
+    }
+  });
+}
+function convertNuxtPagesToSitemapEntries(pages, config) {
+  const pathFilter = createPathFilter(config.filter);
+  const routesNameSeparator = config.routesNameSeparator || "___";
+  let flattenedPages = [];
+  deepForEachPage(
+    pages,
+    (page, loc, depth) => {
+      flattenedPages.push({ page, loc, depth });
+    },
+    {
+      ...config,
+      routesNameSeparator: config.routesNameSeparator || "___"
+    }
+  );
+  flattenedPages = flattenedPages.filter((page) => !page.loc.includes(":")).filter((page, idx, arr) => {
+    return !arr.some((p) => {
+      return p.loc === page.loc && p.depth > page.depth;
+    });
+  }).map((p) => {
+    delete p.depth;
+    return p;
+  });
+  if (config.strategy === "prefix_and_default") {
+    flattenedPages = flattenedPages.filter((p) => {
+      if (p.page?.name) {
+        const [, locale] = p.page.name.split(routesNameSeparator);
+        return locale !== config.defaultLocale || p.page.name.endsWith("__default");
+      }
+      return true;
+    });
+  }
+  const pagesWithMeta = flattenedPages.map((p) => {
+    if (config.autoLastmod && p.page.file) {
+      const stats = statSync(p.page.file, { throwIfNoEntry: false });
+      if (stats?.mtime)
+        p.lastmod = stats.mtime;
+    }
+    if (p.page?.meta?.sitemap) {
+      p = defu(p.page.meta.sitemap, p);
+    }
+    return p;
+  });
+  const localeGroups = {};
+  pagesWithMeta.reduce((acc, e) => {
+    if (e.page.name?.includes(routesNameSeparator)) {
+      const [name, locale] = e.page.name.split(routesNameSeparator);
+      if (!name)
+        return acc;
+      if (!acc[name])
+        acc[name] = [];
+      const { _sitemap } = config.normalisedLocales.find((l) => l.code === locale) || { _sitemap: locale };
+      acc[name].push({ ...e, _sitemap: config.isI18nMapped ? _sitemap : void 0, locale });
+    } else {
+      acc.default = acc.default || [];
+      acc.default.push(e);
+    }
+    return acc;
+  }, localeGroups);
+  return Object.entries(localeGroups).map(([locale, entries]) => {
+    if (locale === "default") {
+      return entries.map((e) => {
+        const [name] = (e.page?.name || "").split(routesNameSeparator);
+        if (!name)
+          return false;
+        if (localeGroups[name]?.some((a) => a.locale === config.defaultLocale))
+          return false;
+        const defaultLocale = config.normalisedLocales.find((l) => l.code === config.defaultLocale);
+        if (defaultLocale && config.isI18nMapped)
+          e._sitemap = defaultLocale._sitemap;
+        delete e.page;
+        delete e.locale;
+        return { ...e };
+      }).filter(Boolean);
+    }
+    return entries.map((entry) => {
+      const alternatives = entries.map((entry2) => {
+        const locale2 = config.normalisedLocales.find((l) => l.code === entry2.locale);
+        if (!pathFilter(entry2.loc))
+          return false;
+        const href = locale2?.domain ? withHttps(withBase(entry2.loc, locale2?.domain)) : entry2.loc;
+        return {
+          hreflang: locale2?._hreflang,
+          href
+        };
+      }).filter(Boolean);
+      const xDefault = entries.find((a) => a.locale === config.defaultLocale);
+      if (xDefault && alternatives.length && pathFilter(xDefault.loc)) {
+        const locale2 = config.normalisedLocales.find((l) => l.code === xDefault.locale);
+        const href = locale2?.domain ? withHttps(withBase(xDefault.loc, locale2?.domain)) : xDefault.loc;
+        alternatives.push({
+          hreflang: "x-default",
+          href
+        });
+      }
+      const e = { ...entry };
+      if (config.isI18nMapped) {
+        const { _sitemap } = config.normalisedLocales.find((l) => l.code === entry.locale) || { _sitemap: locale };
+        e._sitemap = _sitemap;
+      }
+      delete e.page;
+      delete e.locale;
+      return {
+        ...e,
+        alternatives
+      };
+    });
+  }).filter(Boolean).flat();
+}
+function generateExtraRoutesFromNuxtConfig(nuxt = useNuxt()) {
+  const filterForValidPage = (p) => typeof p === "string" && !!p && !extname(p) && !p.startsWith("/api/") && !p.startsWith("/_");
+  const routeRules = Object.entries(nuxt.options.routeRules || {}).filter(([k, v]) => {
+    if (k.includes("*") || k.includes(".") || k.includes(":"))
+      return false;
+    if ("robots" in v && typeof v.robots === "boolean" && !v.robots)
+      return false;
+    return !v.redirect;
+  }).map(([k]) => k).filter(filterForValidPage);
+  const prerenderUrls = (nuxt.options.nitro.prerender?.routes || []).filter(filterForValidPage);
+  return { routeRules, prerenderUrls };
+}
+
 const module$1 = defineNuxtModule({
   meta: {
     name: "@nuxtjs/sitemap",
@@ -538,7 +490,7 @@ const module$1 = defineNuxtModule({
       optional: true
     },
     "nuxt-site-config": {
-      version: ">=3"
+      version: ">=3.2"
     },
     "@nuxt/content": {
       version: ">=2",
@@ -591,6 +543,8 @@ const module$1 = defineNuxtModule({
     nuxt.options.alias["#sitemap"] = resolve("./runtime");
     nuxt.options.nitro.alias = nuxt.options.nitro.alias || {};
     nuxt.options.nitro.alias["#sitemap"] = resolve("./runtime");
+    nuxt.options.experimental.extraPageMetaExtractionKeys = nuxt.options.experimental.extraPageMetaExtractionKeys || [];
+    nuxt.options.experimental.extraPageMetaExtractionKeys.push("sitemap");
     config.xslColumns = config.xslColumns || [
       { label: "URL", width: "50%" },
       { label: "Images", width: "25%", select: "count(image:image)" },
@@ -649,9 +603,6 @@ const module$1 = defineNuxtModule({
       if (i18nVersion && i18nModule === "@nuxtjs/i18n" && !await hasNuxtModuleCompatibility(i18nModule, ">=8"))
         logger.warn(`You are using ${i18nModule} v${i18nVersion}. For the best compatibility, please upgrade to ${i18nModule} v8.0.0 or higher.`);
       nuxtI18nConfig = await getNuxtModuleOptions(i18nModule) || {};
-      if (typeof nuxtI18nConfig.includeDefaultLocaleRoute !== "undefined") {
-        nuxtI18nConfig.strategy = nuxtI18nConfig.includeDefaultLocaleRoute ? "prefix" : "prefix_except_default";
-      }
       normalisedLocales = normalizeLocales(nuxtI18nConfig);
       usingI18nPages = !!Object.keys(nuxtI18nConfig.pages || {}).length;
       if (usingI18nPages && !hasDisabledAutoI18n) {
@@ -710,16 +661,48 @@ const module$1 = defineNuxtModule({
           pages: nuxtI18nConfig.pages
         };
       }
-      let canI18nMap = config.sitemaps !== false && nuxtI18nConfig.strategy !== "no_prefix";
+      let canI18nMap = !hasDisabledAutoI18n && config.sitemaps !== false && nuxtI18nConfig.strategy !== "no_prefix";
       if (typeof config.sitemaps === "object") {
-        const isSitemapIndexOnly = typeof config.sitemaps.index !== "undefined" && Object.keys(config.sitemaps).length === 1;
-        if (!isSitemapIndexOnly)
+        const sitemapEntries = Object.entries(config.sitemaps).filter(([k]) => k !== "index");
+        const isSitemapIndexOnly = sitemapEntries.length === 0;
+        const hasIncludeAppSources = sitemapEntries.some(([_, v]) => v && typeof v === "object" && v.includeAppSources);
+        if (!isSitemapIndexOnly && !hasIncludeAppSources)
           canI18nMap = false;
       }
       if (canI18nMap && resolvedAutoI18n) {
-        config.sitemaps = { index: [...config.sitemaps?.index || [], ...config.appendSitemaps || []] };
-        for (const locale of resolvedAutoI18n.locales)
-          config.sitemaps[locale._sitemap] = { includeAppSources: true };
+        const existingSitemaps = typeof config.sitemaps === "object" ? config.sitemaps : {};
+        const i18nSitemaps = [];
+        const nonI18nSitemaps = {};
+        for (const [name2, cfg] of Object.entries(existingSitemaps)) {
+          if (name2 === "index")
+            continue;
+          if (cfg && typeof cfg === "object" && cfg.includeAppSources) {
+            i18nSitemaps.push({ name: name2, cfg });
+          } else {
+            nonI18nSitemaps[name2] = cfg;
+          }
+        }
+        const newSitemaps = {
+          index: [...existingSitemaps.index || [], ...config.appendSitemaps || []]
+        };
+        const hasCustomI18nSitemaps = i18nSitemaps.length > 0;
+        if (hasCustomI18nSitemaps) {
+          for (const { name: name2, cfg } of i18nSitemaps) {
+            for (const locale of resolvedAutoI18n.locales) {
+              newSitemaps[`${locale._sitemap}-${name2}`] = {
+                includeAppSources: true,
+                ...cfg.exclude?.length && { exclude: cfg.exclude },
+                ...cfg.include?.length && { include: cfg.include }
+              };
+            }
+          }
+        } else {
+          for (const locale of resolvedAutoI18n.locales) {
+            newSitemaps[locale._sitemap] = { includeAppSources: true };
+          }
+        }
+        Object.assign(newSitemaps, nonI18nSitemaps);
+        config.sitemaps = newSitemaps;
         isI18nMapped = true;
         usingMultiSitemaps = true;
       }
@@ -747,56 +730,12 @@ const module$1 = defineNuxtModule({
         }]);
       }
     });
-    addTypeTemplate({
-      filename: "module/nuxt-sitemap.d.ts",
-      getContents: (data) => {
-        const typesPath = relative(resolve(data.nuxt.options.rootDir, data.nuxt.options.buildDir, "module"), resolve("runtime/types"));
-        const types = `  interface PrerenderRoute {
-    _sitemap?: import('${typesPath}').SitemapUrl
-  }
-  interface NitroRouteRules {
-    index?: boolean
-    sitemap?: import('${typesPath}').SitemapItemDefaults
-  }
-  interface NitroRouteConfig {
-    index?: boolean
-    sitemap?: import('${typesPath}').SitemapItemDefaults
-  }
-  interface NitroRuntimeHooks {
-    'sitemap:index-resolved': (ctx: import('${typesPath}').SitemapIndexRenderCtx) => void | Promise<void>
-    'sitemap:input': (ctx: import('${typesPath}').SitemapInputCtx) => void | Promise<void>
-    'sitemap:resolved': (ctx: import('${typesPath}').SitemapRenderCtx) => void | Promise<void>
-    'sitemap:output': (ctx: import('${typesPath}').SitemapOutputHookCtx) => void | Promise<void>
-    'sitemap:sources': (ctx: import('${typesPath}').SitemapSourcesHookCtx) => void | Promise<void>
-  }`;
-        return `// Generated by @nuxtjs/sitemap
-declare module 'nitropack' {
-${types}
-}
-declare module 'nitropack/types' {
-${types}
-}
-declare module 'vue-router' {
-    interface RouteMeta {
-        sitemap?: import('${typesPath}').SitemapItemDefaults
-    }
-}
-
-export {}
-`;
-      }
-    }, {
-      node: true,
-      nitro: true,
-      nuxt: true
-    });
+    registerTypeTemplates();
     const prerenderedRoutes = nuxt.options.nitro.prerender?.routes || [];
     let prerenderSitemap = isNuxtGenerate() || includesSitemapRoot(config.sitemapName, prerenderedRoutes);
     if (config.zeroRuntime && !prerenderSitemap) {
       prerenderSitemap = true;
-      nuxt.options.nitro.prerender = nuxt.options.nitro.prerender || {};
-      nuxt.options.nitro.prerender.routes = nuxt.options.nitro.prerender.routes || [];
-      nuxt.options.nitro.prerender.routes.push("/sitemap.xml");
+      addPrerenderRoutes("/sitemap.xml");
       logger.info("`zeroRuntime` enabled - sitemap routes will be prerendered.");
     }
     const routesPath = config.zeroRuntime ? "./runtime/server/routes/__zero-runtime" : "./runtime/server/routes";
@@ -817,7 +756,7 @@ export {}
       };
     }
     if (usingMultiSitemaps) {
-      nuxt.options.nitro.routeRules["/sitemap.xml"] = { redirect: "/sitemap_index.xml" };
+      nuxt.options.nitro.routeRules["/sitemap.xml"] = { redirect: withBase("/sitemap_index.xml", nuxt.options.app.baseURL) };
       nuxt.options.nitro.routeRules["/sitemap_index.xml"] = routeRules;
       if (typeof config.sitemaps === "object") {
         for (const k in config.sitemaps) {
@@ -844,10 +783,10 @@ export {}
         addServerPlugin(resolve("./runtime/server/plugins/compression"));
     }
     const isNuxtContentDocumentDriven = !!nuxt.options.content?.documentDriven || config.strictNuxtContentPaths;
-    const usingNuxtContent = hasNuxtModule("@nuxt/content");
-    const isNuxtContentV3 = usingNuxtContent && await hasNuxtModuleCompatibility("@nuxt/content", "^3");
+    const contentVersion = await resolveNuxtContentVersion();
+    const isNuxtContentV3 = contentVersion && contentVersion.version === 3;
     const nuxtV3Collections = /* @__PURE__ */ new Set();
-    const isNuxtContentV2 = usingNuxtContent && await hasNuxtModuleCompatibility("@nuxt/content", "^2");
+    const isNuxtContentV2 = contentVersion && contentVersion.version === 2;
     if (isNuxtContentV3) {
       if (nuxt.options._installedModules.some((m) => m.meta.name === "Content")) {
         logger.warn("You have loaded `@nuxt/content` before `@nuxtjs/sitemap`, this may cause issues with the integration. Please ensure `@nuxtjs/sitemap` is loaded first.");
@@ -859,41 +798,62 @@ export {}
         nuxt.options.alias["@nuxt/content/nitro"] = resolve("./runtime/server/content-compat");
       }
       nuxt.hooks.hook("content:file:afterParse", (ctx) => {
-        const content = ctx.content;
-        nuxtV3Collections.add(ctx.collection.name);
-        if (String(ctx.content.path).includes("/.")) {
-          ctx.content.sitemap = null;
-          return;
-        }
-        if (!("sitemap" in ctx.collection.fields)) {
-          ctx.content.sitemap = null;
-          return;
-        }
-        if (typeof content.sitemap !== "undefined" && !content.sitemap) {
-          ctx.content.sitemap = null;
-          return;
+        try {
+          const content = ctx.content;
+          nuxtV3Collections.add(ctx.collection.name);
+          if (String(ctx.content.path).includes("/.")) {
+            ctx.content.sitemap = null;
+            return;
+          }
+          if (!ctx.collection.fields || !("sitemap" in ctx.collection.fields)) {
+            ctx.content.sitemap = null;
+            return;
+          }
+          if (typeof content.sitemap !== "undefined" && !content.sitemap) {
+            ctx.content.sitemap = null;
+            return;
+          }
+          if (ctx.content.robots === false) {
+            ctx.content.sitemap = null;
+            return;
+          }
+          const images = [];
+          if (config.discoverImages) {
+            images.push(
+              ...content.body?.value?.filter(
+                (c) => ["image", "img", "nuxtimg", "nuxt-img"].includes(c[0])
+              ).filter((c) => c[1]?.src).map((c) => ({ loc: c[1].src })) || []
+            );
+          }
+          const lastmod = content.seo?.articleModifiedTime || content.updatedAt;
+          const defaults = {
+            loc: content.path
+          };
+          if (images.length > 0)
+            defaults.images = images;
+          if (lastmod)
+            defaults.lastmod = lastmod;
+          ctx.content.sitemap = defu(typeof content.sitemap === "object" ? content.sitemap : {}, defaults);
+        } catch (e) {
+          logger.warn(`Failed to process sitemap data for content file (collection: ${ctx.collection?.name}, path: ${ctx.content?.path}), skipping.`, e);
         }
-        if (ctx.content.robots === false) {
-          ctx.content.sitemap = null;
-          return;
+      });
+      nuxt.hook("nitro:config", (nitroConfig) => {
+        const filterEntries = [];
+        if (globalThis.__sitemapCollectionFilters) {
+          for (const [name2, filterFn] of globalThis.__sitemapCollectionFilters.entries())
+            filterEntries.push(`filters.set(${JSON.stringify(name2)}, ${filterFn.toString()})`);
         }
-        const images = [];
-        if (config.discoverImages) {
-          images.push(
-            ...content.body?.value?.filter(
-              (c) => ["image", "img", "nuxtimg", "nuxt-img"].includes(c[0])
-            ).filter((c) => c[1]?.src).map((c) => ({ loc: c[1].src })) || []
-          );
+        const onUrlEntries = [];
+        if (globalThis.__sitemapCollectionOnUrlFns) {
+          for (const [name2, fn] of globalThis.__sitemapCollectionOnUrlFns.entries())
+            onUrlEntries.push(`onUrlFns.set(${JSON.stringify(name2)}, ${fn.toString()})`);
         }
-        const lastmod = content.seo?.articleModifiedTime || content.updatedAt;
-        const defaults = {
-          loc: content.path
-        };
-        if (images.length > 0)
-          defaults.images = images;
-        if (lastmod)
-          defaults.lastmod = lastmod;
-        ctx.content.sitemap = defu(typeof content.sitemap === "object" ? content.sitemap : {}, defaults);
+        nitroConfig.virtual = nitroConfig.virtual || {};
+        nitroConfig.virtual["#sitemap/content-filters"] = `export const filters = new Map()
+${filterEntries.join("\n")}`;
+        nitroConfig.virtual["#sitemap/content-on-url"] = `export const onUrlFns = new Map()
+${onUrlEntries.join("\n")}`;
       });
       addServerHandler({
         route: "/__sitemap__/nuxt-content-urls.json",
@@ -906,7 +866,7 @@ export {}
         context: {
           name: "@nuxt/content@v3:urls",
           description: "Generated from your markdown files.",
-          tips: [`Parsing the following collections: ${Array.from(nuxtV3Collections).join(", ")}`]
+          tips: nuxtV3Collections.size ? [`Parsing the following collections: ${Array.from(nuxtV3Collections).join(", ")}`] : ["No collections found. Make sure your content collections have a `path` field."]
         },
         fetch: "/__sitemap__/nuxt-content-urls.json"
       });
@@ -1125,6 +1085,12 @@ export {}
         route: "/__sitemap__/debug.json",
         handler: resolve("./runtime/server/routes/__sitemap__/debug")
       });
+      if (nuxt.options.dev) {
+        addServerHandler({
+          route: "/__sitemap__/debug-production.json",
+          handler: resolve("./runtime/server/routes/__sitemap__/debug-production")
+        });
+      }
       if (usingMultiSitemaps) {
         addServerHandler({
           route: "/__sitemap__/**:sitemap",
@@ -1291,7 +1257,7 @@ export async function readSourcesFromFilesystem() {
 }
 `;
       }
-      if (prerenderSitemap) {
+      if (prerenderSitemap && !nuxt.options.dev) {
         nitroConfig.virtual["#sitemap-virtual/global-sources.mjs"] = `export const sources = []`;
         nitroConfig.virtual[`#sitemap-virtual/child-sources.mjs`] = `export const sources = {}`;
       } else {