@nuxtjs/sitemap 5.3.5 → 6.0.0-beta.2

package/dist/module.json

@@ -5,9 +5,9 @@
     "bridge": false
   },
   "configKey": "sitemap",
-  "version": "5.3.4",
+  "version": "6.0.0-beta.1",
   "builder": {
-    "@nuxt/module-builder": "0.8.1",
+    "@nuxt/module-builder": "0.8.3",
     "unbuild": "2.0.0"
   }
 }

package/dist/module.mjs

@@ -1,18 +1,81 @@
 import { useNuxt, loadNuxtModuleInstance, createResolver, addTemplate, extendPages, defineNuxtModule, useLogger, hasNuxtModule, getNuxtModuleVersion, hasNuxtModuleCompatibility, addServerImports, addServerPlugin, addServerHandler, findPath, addPrerenderRoutes } from '@nuxt/kit';
-import { withHttps, withBase, parseURL, joinURL, withoutLeadingSlash } from 'ufo';
+import { withLeadingSlash, parseURL, withHttps, withBase, joinURL, withoutLeadingSlash, withoutTrailingSlash } from 'ufo';
 import { assertSiteConfig, installNuxtSiteConfig } from 'nuxt-site-config-kit';
-import { defu } from 'defu';
+import { createDefu, defu } from 'defu';
 import { readPackageJSON } from 'pkg-types';
 import { statSync, existsSync } from 'node:fs';
 import { extname, relative, dirname } from 'pathe';
-import { createPathFilter, splitForLocales, mergeOnKey } from '../dist/runtime/utils-pure.js';
+import { toRouteMatcher, createRouter } from 'radix3';
+import { createConsola } from 'consola';
 import { provider, env } from 'std-env';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import chalk from 'chalk';
 import { build } from 'nitropack';
 import { withSiteUrl } from 'nuxt-site-config-kit/urls';
-import { normaliseDate } from '../dist/runtime/nitro/sitemap/urlset/normalise.js';
+
+createConsola({
+  defaults: {
+    tag: "@nuxt/sitemap"
+  }
+});
+const merger = createDefu((obj, key, value) => {
+  if (Array.isArray(obj[key]) && Array.isArray(value))
+    obj[key] = Array.from(/* @__PURE__ */ new Set([...obj[key], ...value]));
+  return obj[key];
+});
+function mergeOnKey(arr, key) {
+  const res = {};
+  arr.forEach((item) => {
+    const k = item[key];
+    res[k] = merger(item, res[k] || {});
+  });
+  return Object.values(res);
+}
+function splitForLocales(path, locales) {
+  const prefix = withLeadingSlash(path).split("/")[1];
+  if (locales.includes(prefix))
+    return [prefix, path.replace(`/${prefix}`, "")];
+  return [null, path];
+}
+function createPathFilter(options = {}) {
+  const urlFilter = createFilter(options);
+  return (loc) => {
+    let path = loc;
+    try {
+      path = parseURL(loc).pathname;
+    } catch {
+      return false;
+    }
+    return urlFilter(path);
+  };
+}
+function createFilter(options = {}) {
+  const include = options.include || [];
+  const exclude = options.exclude || [];
+  if (include.length === 0 && exclude.length === 0)
+    return () => true;
+  return function(path) {
+    for (const v of [{ rules: exclude, result: false }, { rules: include, result: true }]) {
+      const regexRules = v.rules.filter((r) => r instanceof RegExp);
+      if (regexRules.some((r) => r.test(path)))
+        return v.result;
+      const stringRules = v.rules.filter((r) => typeof r === "string");
+      if (stringRules.length > 0) {
+        const routes = {};
+        for (const r of stringRules) {
+          if (r === path)
+            return v.result;
+          routes[r] = true;
+        }
+        const routeRulesMatcher = toRouteMatcher(createRouter({ routes, strictTrailingSlash: false }));
+        if (routeRulesMatcher.matchAll(path).length > 0)
+          return Boolean(v.result);
+      }
+    }
+    return include.length === 0;
+  };
+}
 
 async function resolveUrls(urls, ctx) {
   if (typeof urls === "function")
@@ -237,7 +300,7 @@ function resolveNitroPreset(nitroConfig) {
   if (nitroConfig && nitroConfig?.preset)
     preset = nitroConfig.preset;
   if (!preset)
-    preset = env.NITRO_PRESET || detectTarget() || "node-server";
+    preset = env.NITRO_PRESET || env.SERVER_PRESET || detectTarget() || "node-server";
   return preset.replace("_", "-");
 }
 
@@ -354,9 +417,14 @@ function isNuxtGenerate(nuxt = useNuxt()) {
     "github-pages"
   ].includes(resolveNitroPreset());
 }
-function setupPrerenderHandler(options, nuxt = useNuxt()) {
+function setupPrerenderHandler(_options, nuxt = useNuxt()) {
+  const { runtimeConfig: options, logger } = _options;
   const prerenderedRoutes = nuxt.options.nitro.prerender?.routes || [];
-  const prerenderSitemap = isNuxtGenerate() || includesSitemapRoot(options.sitemapName, prerenderedRoutes);
+  let prerenderSitemap = isNuxtGenerate() || includesSitemapRoot(options.sitemapName, prerenderedRoutes);
+  if (resolveNitroPreset() === "vercel-edge") {
+    logger.warn("Runtime sitemaps are not supported on Vercel Edge, falling back to prerendering sitemaps.");
+    prerenderSitemap = true;
+  }
   if (nuxt.options.nitro.prerender?.routes)
     nuxt.options.nitro.prerender.routes = nuxt.options.nitro.prerender.routes.filter((r) => r && !includesSitemapRoot(options.sitemapName, [r]));
   nuxt.hooks.hook("nitro:init", async (nitro) => {
@@ -478,6 +546,38 @@ function setupDevToolsUI(options, resolve, nuxt = useNuxt()) {
   });
 }
 
+const IS_VALID_W3C_DATE = [
+  /(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))/,
+  /^\d{4}-[01]\d-[0-3]\d$/,
+  /^\d{4}-[01]\d$/,
+  /^\d{4}$/
+];
+function isValidW3CDate(d) {
+  return IS_VALID_W3C_DATE.some((r) => r.test(d));
+}
+function normaliseDate(d) {
+  if (typeof d === "string") {
+    if (d.includes("T")) {
+      const t = d.split("T")[1];
+      if (!t.includes("+") && !t.includes("-") && !t.includes("Z")) {
+        d += "Z";
+      }
+    }
+    if (!isValidW3CDate(d))
+      return false;
+    d = new Date(d);
+    d.setMilliseconds(0);
+    if (Number.isNaN(d.getTime()))
+      return false;
+  }
+  const z = (n) => `0${n}`.slice(-2);
+  const date = `${d.getUTCFullYear()}-${z(d.getUTCMonth() + 1)}-${z(d.getUTCDate())}`;
+  if (d.getUTCHours() > 0 || d.getUTCMinutes() > 0 || d.getUTCSeconds() > 0) {
+    return `${date}T${z(d.getUTCHours())}:${z(d.getUTCMinutes())}:${z(d.getUTCSeconds())}Z`;
+  }
+  return date;
+}
+
 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("/_"))
@@ -491,6 +591,13 @@ function splitPathForI18nLocales(path, autoI18n) {
     ...locales.map((l) => `/${l.code}${path}`)
   ];
 }
+function getExcludedLocalesFromI18nConfig(nuxtI18nConfig) {
+  const onlyLocales = nuxtI18nConfig?.bundle?.onlyLocales;
+  if (!onlyLocales)
+    return [];
+  const excludedLocales = typeof onlyLocales === "string" ? [onlyLocales] : onlyLocales;
+  return excludedLocales;
+}
 function generatePathForI18nPages(ctx) {
   const { localeCode, pageLocales, nuxtI18nConfig, forcedStrategy, normalisedLocales } = ctx;
   const locale = normalisedLocales.find((l) => l.code === localeCode);
@@ -540,6 +647,7 @@ const module = defineNuxtModule({
     credits: true,
     cacheMaxAgeSeconds: 60 * 10,
     // cache for 10 minutes
+    minify: false,
     debug: false,
     defaultSitemapsChunkSize: 1e3,
     autoLastmod: false,
@@ -548,6 +656,7 @@ const module = defineNuxtModule({
     dynamicUrlsApiEndpoint: "/api/_sitemap-urls",
     urls: [],
     sortEntries: true,
+    sitemapsPathPrefix: "/__sitemap__/",
     xsl: "/__sitemap__/style.xsl",
     xslTips: true,
     strictNuxtContentPaths: false,
@@ -592,15 +701,17 @@ const module = defineNuxtModule({
     if (!nuxt.options._prepare && Object.keys(normalizedSitemaps).length) {
       const isSitemapIndexOnly = typeof normalizedSitemaps?.index !== "undefined" && Object.keys(normalizedSitemaps).length === 1;
       if (!isSitemapIndexOnly) {
-        const invalidRootKeys = [
-          "includeAppSources",
-          "sources"
-        ];
-        for (const key of invalidRootKeys) {
-          if (Object.keys(config).includes(key)) {
-            logger.warn(`You are using multiple-sitemaps but have provided \`sitemap.${key}\` in your Nuxt config. This will be ignored, please move it to the child sitemap config.`);
-            logger.warn("Learn more at: https://nuxtseo.com/sitemap/guides/multi-sitemaps");
-          }
+        const warnForIgnoredKey = (key) => {
+          logger.warn(`You are using multiple-sitemaps but have provided \`sitemap.${key}\` in your Nuxt config. This will be ignored, please move it to the child sitemap config.`);
+          logger.warn("Learn more at: https://nuxtseo.com/sitemap/guides/multi-sitemaps");
+        };
+        switch (true) {
+          case config?.sources?.length !== 0:
+            warnForIgnoredKey("sources");
+            break;
+          case config?.includeAppSources !== void 0:
+            warnForIgnoredKey("includeAppSources");
+            break;
         }
       }
     }
@@ -624,13 +735,15 @@ const module = defineNuxtModule({
     let resolvedAutoI18n = typeof config.autoI18n === "boolean" ? false : config.autoI18n || false;
     const hasDisabledAutoI18n = typeof config.autoI18n === "boolean" && !config.autoI18n;
     let normalisedLocales = [];
+    let usingI18nPages = false;
     if (hasNuxtModule("@nuxtjs/i18n")) {
       const i18nVersion = await getNuxtModuleVersion("@nuxtjs/i18n");
       if (!await hasNuxtModuleCompatibility("@nuxtjs/i18n", ">=8"))
         logger.warn(`You are using @nuxtjs/i18n v${i18nVersion}. For the best compatibility, please upgrade to @nuxtjs/i18n v8.0.0 or higher.`);
       nuxtI18nConfig = await getNuxtModuleOptions("@nuxtjs/i18n") || {};
-      normalisedLocales = mergeOnKey((nuxtI18nConfig.locales || []).map((locale) => typeof locale === "string" ? { code: locale } : locale), "code");
-      const usingI18nPages = Object.keys(nuxtI18nConfig.pages || {}).length;
+      const excludedLocales = getExcludedLocalesFromI18nConfig(nuxtI18nConfig);
+      normalisedLocales = mergeOnKey((nuxtI18nConfig.locales || []).map((locale) => typeof locale === "string" ? { code: locale } : locale), "code").filter((locale) => !excludedLocales.includes(locale.code));
+      usingI18nPages = !!Object.keys(nuxtI18nConfig.pages || {}).length;
       if (usingI18nPages && !hasDisabledAutoI18n) {
         const i18nPagesSources = {
           context: {
@@ -773,8 +886,10 @@ declare module 'vue-router' {
       nuxt.options.nitro.routeRules["/sitemap.xml"] = { redirect: "/sitemap_index.xml" };
       nuxt.options.nitro.routeRules["/sitemap_index.xml"] = routeRules;
       if (typeof config.sitemaps === "object") {
-        for (const k in config.sitemaps)
-          nuxt.options.nitro.routeRules[`/${k}-sitemap.xml`] = routeRules;
+        for (const k in config.sitemaps) {
+          nuxt.options.nitro.routeRules[joinURL(config.sitemapsPathPrefix, `/${k}.xml`)] = routeRules;
+          nuxt.options.nitro.routeRules[`/${k}-sitemap.xml`] = { redirect: joinURL(config.sitemapsPathPrefix, `${k}.xml`) };
+        }
       } else {
         nuxt.options.nitro.routeRules[`/${config.sitemapName}`] = routeRules;
       }
@@ -831,7 +946,15 @@ declare module 'vue-router' {
     if (usingMultiSitemaps) {
       addServerHandler({
         route: "/sitemap_index.xml",
-        handler: resolve("./runtime/nitro/routes/sitemap_index.xml")
+        handler: resolve("./runtime/nitro/routes/sitemap_index.xml"),
+        lazy: true,
+        middleware: false
+      });
+      addServerHandler({
+        route: joinURL(config.sitemapsPathPrefix, `/**:sitemap`),
+        handler: resolve("./runtime/nitro/routes/sitemap/[sitemap].xml"),
+        lazy: true,
+        middleware: false
       });
       sitemaps.index = {
         sitemapName: "index",
@@ -843,15 +966,11 @@ declare module 'vue-router' {
         for (const sitemapName in config.sitemaps) {
           if (sitemapName === "index")
             continue;
-          addServerHandler({
-            route: `/${sitemapName}-sitemap.xml`,
-            handler: resolve("./runtime/nitro/middleware/[sitemap]-sitemap.xml")
-          });
           const definition = config.sitemaps[sitemapName];
           sitemaps[sitemapName] = defu(
             {
               sitemapName,
-              _route: withBase(`${sitemapName}-sitemap.xml`, nuxt.options.app.baseURL || "/"),
+              _route: withBase(`sitemap/${sitemapName}.xml`, nuxt.options.app.baseURL || "/"),
               _hasSourceChunk: typeof definition.urls !== "undefined" || definition.sources?.length || !!definition.dynamicUrlsApiEndpoint
             },
             { ...definition, urls: void 0, sources: void 0 },
@@ -859,9 +978,6 @@ declare module 'vue-router' {
           );
         }
       } else {
-        addServerHandler({
-          handler: resolve("./runtime/nitro/middleware/[sitemap]-sitemap.xml")
-        });
         sitemaps.chunks = {
           sitemapName: "chunks",
           defaults: config.defaults,
@@ -881,6 +997,31 @@ declare module 'vue-router' {
         includeAppSources: true
       };
     }
+    if (resolvedAutoI18n && usingI18nPages && !hasDisabledAutoI18n) {
+      const pages = nuxtI18nConfig?.pages || {};
+      for (const sitemapName in sitemaps) {
+        let mapToI18nPages = function(path) {
+          if (typeof path !== "string")
+            return [path];
+          const withoutSlashes = withoutTrailingSlash(withoutLeadingSlash(path)).replace("/index", "");
+          if (withoutSlashes in pages) {
+            const pageLocales = pages[withoutSlashes];
+            return Object.keys(pageLocales).map((localeCode) => withLeadingSlash(generatePathForI18nPages({ localeCode, pageLocales: pageLocales[localeCode], nuxtI18nConfig, normalisedLocales })));
+          }
+          let match = [path];
+          Object.values(pages).forEach((pageLocales) => {
+            if (nuxtI18nConfig.defaultLocale in pageLocales && pageLocales[nuxtI18nConfig.defaultLocale] === path)
+              match = Object.keys(pageLocales).map((localeCode) => withLeadingSlash(generatePathForI18nPages({ localeCode, pageLocales: pageLocales[localeCode], nuxtI18nConfig, normalisedLocales })));
+          });
+          return match;
+        };
+        if (["index", "chunks"].includes(sitemapName))
+          continue;
+        const sitemap = sitemaps[sitemapName];
+        sitemap.include = (sitemap.include || []).flatMap((path) => mapToI18nPages(path));
+        sitemap.exclude = (sitemap.exclude || []).flatMap((path) => mapToI18nPages(path));
+      }
+    }
     if (resolvedAutoI18n && resolvedAutoI18n.locales && resolvedAutoI18n.strategy !== "no_prefix") {
       const i18n = resolvedAutoI18n;
       for (const sitemapName in sitemaps) {
@@ -904,11 +1045,13 @@ declare module 'vue-router' {
       cacheMaxAgeSeconds: nuxt.options.dev ? 0 : config.cacheMaxAgeSeconds,
       autoLastmod: config.autoLastmod,
       defaultSitemapsChunkSize: config.defaultSitemapsChunkSize,
+      minify: config.minify,
       sortEntries: config.sortEntries,
       debug: config.debug,
       // needed for nuxt/content integration and prerendering
       discoverImages: config.discoverImages,
       discoverVideos: config.discoverVideos,
+      sitemapsPathPrefix: config.sitemapsPathPrefix,
       /* @nuxt/content */
       isNuxtContentDocumentDriven,
       /* xsl styling */
@@ -951,8 +1094,11 @@ declare module 'vue-router' {
         const prerenderUrlsFinal = [
           ...prerenderUrls,
           ...((await nitroPromise)._prerenderedRoutes || []).filter((r) => {
-            const isExplicitFile = r.route.split("/").pop().includes(".");
-            return r.contentType?.includes("text/html") && !isExplicitFile;
+            const lastSegment = r.route.split("/").pop();
+            const isExplicitFile = !!lastSegment?.match(/\.[0-9a-z]+$/i)?.[0];
+            if (r.error || ["/200.html", "/404.html", "/index.html"].includes(r.route))
+              return false;
+            return r.contentType?.includes("text/html") || !isExplicitFile;
           }).map((r) => r._sitemap)
         ];
         const pageSource = convertNuxtPagesToSitemapEntries(await pagesPromise, {
@@ -1084,7 +1230,7 @@ declare module 'vue-router' {
       route: `/${config.sitemapName}`,
       handler: resolve("./runtime/nitro/routes/sitemap.xml")
     });
-    setupPrerenderHandler(runtimeConfig);
+    setupPrerenderHandler({ runtimeConfig, logger });
   }
 });
 

package/dist/runtime/nitro/composables/getPathRobotConfigPolyfill.d.ts

@@ -1,4 +1,5 @@
-export declare function getPathRobotConfigPolyfill(): {
+import type { H3Event } from 'h3';
+export declare function getPathRobotConfigPolyfill(e: H3Event, options: any): {
     indexable: boolean;
     rule: string;
 };

package/dist/runtime/nitro/composables/getPathRobotConfigPolyfill.js

@@ -1,3 +1,3 @@
-export function getPathRobotConfigPolyfill() {
+export function getPathRobotConfigPolyfill(e, options) {
   return { indexable: true, rule: "index, follow" };
 }

package/dist/runtime/nitro/routes/__sitemap__/debug.d.ts

@@ -6,24 +6,25 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
         version: string;
         isNuxtContentDocumentDriven: boolean;
         sitemaps: {
-            index?: (Pick<SitemapDefinition, "sitemapName" | "_route"> & {
+            index?: Pick<SitemapDefinition, "sitemapName" | "_route"> & {
                 sitemaps: import("../../../types").SitemapIndexEntry[];
-            }) | undefined;
+            };
         } & Record<string, Omit<SitemapDefinition, "urls"> & {
-            _hasSourceChunk?: boolean | undefined;
+            _hasSourceChunk?: boolean;
         }>;
-        autoI18n?: import("../../../types").AutoI18nConfig | undefined;
+        autoI18n?: import("../../../types").AutoI18nConfig;
         isMultiSitemap: boolean;
         isI18nMapped: boolean;
+        sitemapsPathPrefix: string;
         cacheMaxAgeSeconds: number | false;
         sitemapName: string;
-        excludeAppSources: true | import("../../../types").AppSourceContext[];
+        excludeAppSources: true | (import("../../../types").AppSourceContext[]);
         sortEntries: boolean;
         defaultSitemapsChunkSize: number | false;
         xslColumns?: {
             label: string;
             width: `${string}%`;
-            select?: string | undefined;
+            select?: string;
         }[] | undefined;
         xslTips: boolean;
         debug: boolean;
@@ -32,6 +33,7 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
         autoLastmod: boolean;
         xsl: string | false;
         credits: boolean;
+        minify: boolean;
     };
     globalSources: import("../../../types").SitemapSourceResolved[];
 }>>;

package/dist/runtime/nitro/{middleware/[sitemap]-sitemap.xml.d.ts → routes/sitemap/[sitemap].xml.d.ts}

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

package/dist/runtime/nitro/routes/sitemap/[sitemap].xml.js

@@ -0,0 +1,20 @@
+import { createError, defineEventHandler, getRouterParam } from "h3";
+import { withoutLeadingSlash, withoutTrailingSlash } from "ufo";
+import { useSimpleSitemapRuntimeConfig } from "../../utils.js";
+import { createSitemap } from "../../sitemap/nitro.js";
+export default defineEventHandler(async (e) => {
+  const runtimeConfig = useSimpleSitemapRuntimeConfig(e);
+  const { sitemaps } = runtimeConfig;
+  const sitemapName = withoutLeadingSlash(withoutTrailingSlash((getRouterParam(e, "sitemap") || e.path)?.replace(".xml", "").replace(runtimeConfig.sitemapsPathPrefix, "")));
+  const isChunking = typeof sitemaps.chunks !== "undefined" && !Number.isNaN(Number(sitemapName));
+  if (!sitemapName || !(sitemapName in sitemaps) && !isChunking) {
+    return createError({
+      statusCode: 404,
+      message: `Sitemap "${sitemapName}" not found.`
+    });
+  }
+  return createSitemap(e, isChunking ? {
+    ...sitemaps.chunks,
+    sitemapName
+  } : sitemaps[sitemapName], runtimeConfig);
+});

package/dist/runtime/nitro/routes/sitemap.xsl.js

@@ -14,7 +14,8 @@ export default defineEventHandler(async (e) => {
   const creditName = `<a href="https://github.com/nuxt-modules/sitemap" style="color: black; display: flex; align-items: center; font-weight: 500;" target="_blank" rel="noopener">${svgIcon} Nuxt Sitemap v${version}</a>`;
   const { name: siteName, url: siteUrl } = useSiteConfig(e);
   const referrer = getHeader(e, "Referer") || "/";
-  const isNotIndexButHasIndex = referrer !== fixPath("/sitemap.xml") && parseURL(referrer).pathname.endsWith("-sitemap.xml");
+  const referrerPath = parseURL(referrer).pathname;
+  const isNotIndexButHasIndex = referrerPath !== "/sitemap.xml" && referrerPath !== "/sitemap_index.xml" && referrerPath.endsWith(".xml");
   const sitemapName = parseURL(referrer).pathname.split("/").pop()?.split("-sitemap")[0] || fallbackSitemapName;
   const title = `${siteName}${sitemapName !== "sitemap.xml" ? ` - ${sitemapName === "sitemap_index.xml" ? "index" : sitemapName}` : ""}`.replace(/&/g, "&amp;");
   const canonicalQuery = getQuery(referrer).canonical;

package/dist/runtime/nitro/routes/sitemap_index.xml.js

@@ -1,27 +1,30 @@
-import { defineEventHandler, getQuery, setHeader } from "h3";
-import { fixSlashes } from "site-config-stack/urls";
+import { appendHeader, defineEventHandler, setHeader } from "h3";
+import { joinURL } from "ufo";
+import { useNitroApp } from "nitropack/runtime";
 import { useSimpleSitemapRuntimeConfig } from "../utils.js";
-import { buildSitemapIndex } from "../sitemap/builder/sitemap-index.js";
-import { createSitePathResolver, useNitroApp, useSiteConfig } from "#imports";
+import { buildSitemapIndex, urlsToIndexXml } from "../sitemap/builder/sitemap-index.js";
+import { useNitroUrlResolvers } from "../sitemap/nitro.js";
 export default defineEventHandler(async (e) => {
-  const canonicalQuery = getQuery(e).canonical;
-  const isShowingCanonical = typeof canonicalQuery !== "undefined" && canonicalQuery !== "false";
   const runtimeConfig = useSimpleSitemapRuntimeConfig();
-  const siteConfig = useSiteConfig(e);
-  let sitemap = await buildSitemapIndex({
-    event: e,
-    canonicalUrlResolver: createSitePathResolver(e, { canonical: isShowingCanonical || !import.meta.dev, absolute: true, withBase: true }),
-    relativeBaseUrlResolver: createSitePathResolver(e, { absolute: false, withBase: true }),
-    fixSlashes: (path) => fixSlashes(siteConfig.trailingSlash, path)
-  }, runtimeConfig);
   const nitro = useNitroApp();
-  const ctx = { sitemap, sitemapName: "sitemap" };
+  const resolvers = useNitroUrlResolvers(e);
+  const sitemaps = await buildSitemapIndex(resolvers, runtimeConfig);
+  if (import.meta.prerender) {
+    appendHeader(
+      e,
+      "x-nitro-prerender",
+      sitemaps.filter((entry) => !!entry._sitemapName).map((entry) => encodeURIComponent(joinURL(runtimeConfig.sitemapsPathPrefix, `/${entry._sitemapName}.xml`))).join(", ")
+    );
+  }
+  const indexResolvedCtx = { sitemaps };
+  await nitro.hooks.callHook("sitemap:index-resolved", indexResolvedCtx);
+  const output = urlsToIndexXml(indexResolvedCtx.sitemaps, resolvers, runtimeConfig);
+  const ctx = { sitemap: output, sitemapName: "sitemap" };
   await nitro.hooks.callHook("sitemap:output", ctx);
-  sitemap = ctx.sitemap;
   setHeader(e, "Content-Type", "text/xml; charset=UTF-8");
   if (runtimeConfig.cacheMaxAgeSeconds)
     setHeader(e, "Cache-Control", `public, max-age=${runtimeConfig.cacheMaxAgeSeconds}, must-revalidate`);
   else
     setHeader(e, "Cache-Control", `no-cache, no-store`);
-  return sitemap;
+  return ctx.sitemap;
 });

package/dist/runtime/nitro/sitemap/builder/sitemap-index.d.ts

@@ -1,2 +1,3 @@
-import type { ModuleRuntimeConfig, NitroUrlResolvers } from '../../../types.js';
-export declare function buildSitemapIndex(resolvers: NitroUrlResolvers, runtimeConfig: ModuleRuntimeConfig): Promise<string>;
+import type { ModuleRuntimeConfig, NitroUrlResolvers, SitemapIndexEntry } from '../../../types.js';
+export declare function buildSitemapIndex(resolvers: NitroUrlResolvers, runtimeConfig: ModuleRuntimeConfig): Promise<SitemapIndexEntry[]>;
+export declare function urlsToIndexXml(sitemaps: SitemapIndexEntry[], resolvers: NitroUrlResolvers, { version, xsl, credits, minify }: Pick<ModuleRuntimeConfig, 'version' | 'xsl' | 'credits' | 'minify'>): string;

package/dist/runtime/nitro/sitemap/builder/sitemap-index.js

@@ -1,12 +1,10 @@
 import { defu } from "defu";
-import { appendHeader } from "h3";
-import { normaliseDate, normaliseSitemapUrls } from "../urlset/normalise.js";
+import { joinURL } from "ufo";
+import { normaliseDate } from "../urlset/normalise.js";
 import { globalSitemapSources, resolveSitemapSources } from "../urlset/sources.js";
-import { applyI18nEnhancements } from "../urlset/i18n.js";
-import { filterSitemapUrls } from "../urlset/filter.js";
 import { sortSitemapUrls } from "../urlset/sort.js";
 import { escapeValueForXml, wrapSitemapXml } from "./xml.js";
-import { useNitroApp } from "#imports";
+import { resolveSitemapEntries } from "./sitemap.js";
 export async function buildSitemapIndex(resolvers, runtimeConfig) {
   const {
     sitemaps,
@@ -17,10 +15,7 @@ export async function buildSitemapIndex(resolvers, runtimeConfig) {
     autoI18n,
     isI18nMapped,
     sortEntries,
-    // xls
-    version,
-    xsl,
-    credits
+    sitemapsPathPrefix
   } = runtimeConfig;
   if (!sitemaps)
     throw new Error("Attempting to build a sitemap index without required `sitemaps` configuration.");
@@ -32,12 +27,9 @@ export async function buildSitemapIndex(resolvers, runtimeConfig) {
   if (isChunking) {
     const sitemap = sitemaps.chunks;
     const sources = await resolveSitemapSources(await globalSitemapSources());
-    const normalisedUrls = normaliseSitemapUrls(sources.map((e) => e.urls).flat(), resolvers);
-    let enhancedUrls = normalisedUrls.map((e) => defu(e, sitemap.defaults));
-    if (autoI18n?.locales)
-      enhancedUrls = applyI18nEnhancements(enhancedUrls, { isI18nMapped, autoI18n, sitemapName: sitemap.sitemapName });
-    const filteredUrls = filterSitemapUrls(enhancedUrls, { ...sitemap, autoI18n, isMultiSitemap: true });
-    const sortedUrls = maybeSort(filteredUrls);
+    const normalisedUrls = resolveSitemapEntries(sitemap, sources, { autoI18n, isI18nMapped });
+    const enhancedUrls = normalisedUrls.map((e) => defu(e, sitemap.defaults));
+    const sortedUrls = maybeSort(enhancedUrls);
     sortedUrls.forEach((url, i) => {
       const chunkIndex = Math.floor(i / defaultSitemapsChunkSize);
       chunks[chunkIndex] = chunks[chunkIndex] || { urls: [] };
@@ -50,18 +42,12 @@ export async function buildSitemapIndex(resolvers, runtimeConfig) {
       }
     }
   }
-  if (import.meta.prerender) {
-    appendHeader(
-      resolvers.event,
-      "x-nitro-prerender",
-      Object.keys(chunks).map((name) => encodeURIComponent(`/${name}-sitemap.xml`)).join(", ")
-    );
-  }
   const entries = [];
   for (const name in chunks) {
     const sitemap = chunks[name];
     const entry = {
-      sitemap: resolvers.canonicalUrlResolver(`${name}-sitemap.xml`)
+      _sitemapName: name,
+      sitemap: resolvers.canonicalUrlResolver(joinURL(sitemapsPathPrefix, `/${name}.xml`))
     };
     let lastmod = sitemap.urls.filter((a) => !!a?.lastmod).map((a) => typeof a.lastmod === "string" ? new Date(a.lastmod) : a.lastmod).sort((a, b) => (b?.getTime() || 0) - (a?.getTime() || 0))?.[0];
     if (!lastmod && autoLastmod)
@@ -75,10 +61,10 @@ export async function buildSitemapIndex(resolvers, runtimeConfig) {
       return typeof entry === "string" ? { sitemap: entry } : entry;
     }));
   }
-  const ctx = { sitemaps: entries };
-  const nitro = useNitroApp();
-  await nitro.hooks.callHook("sitemap:index-resolved", ctx);
-  const sitemapXml = ctx.sitemaps.map((e) => [
+  return entries;
+}
+export function urlsToIndexXml(sitemaps, resolvers, { version, xsl, credits, minify }) {
+  const sitemapXml = sitemaps.map((e) => [
     "    <sitemap>",
     `        <loc>${escapeValueForXml(e.sitemap)}</loc>`,
     // lastmod is optional
@@ -89,5 +75,5 @@ export async function buildSitemapIndex(resolvers, runtimeConfig) {
     '<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
     sitemapXml,
     "</sitemapindex>"
-  ], resolvers, { version, xsl, credits });
+  ], resolvers, { version, xsl, credits, minify });
 }

package/dist/runtime/nitro/sitemap/builder/sitemap.d.ts

@@ -1,2 +1,9 @@
-import type { ModuleRuntimeConfig, NitroUrlResolvers, SitemapDefinition } from '../../../types.js';
-export declare function buildSitemap(sitemap: SitemapDefinition, resolvers: NitroUrlResolvers, runtimeConfig: ModuleRuntimeConfig): Promise<string>;
+import type { AutoI18nConfig, ModuleRuntimeConfig, NitroUrlResolvers, ResolvedSitemapUrl, SitemapDefinition, SitemapSourceResolved } from '../../../types.js';
+export interface NormalizedI18n extends ResolvedSitemapUrl {
+    _pathWithoutPrefix: string;
+    _locale: AutoI18nConfig['locales'][number];
+    _index?: number;
+}
+export declare function resolveSitemapEntries(sitemap: SitemapDefinition, sources: SitemapSourceResolved[], runtimeConfig: Pick<ModuleRuntimeConfig, 'autoI18n' | 'isI18nMapped'>): ResolvedSitemapUrl[];
+export declare function buildSitemapUrls(sitemap: SitemapDefinition, resolvers: NitroUrlResolvers, runtimeConfig: ModuleRuntimeConfig): Promise<ResolvedSitemapUrl[]>;
+export declare function urlsToXml(urls: ResolvedSitemapUrl[], resolvers: NitroUrlResolvers, { version, xsl, credits, minify }: Pick<ModuleRuntimeConfig, 'version' | 'xsl' | 'credits' | 'minify'>): string;