@nuxtjs/sitemap 7.2.10 → 7.3.1

package/dist/module.mjs

@@ -1,4 +1,4 @@
-import { useNuxt, loadNuxtModuleInstance, createResolver, addTemplate, tryUseNuxt, extendPages, defineNuxtModule, useLogger, hasNuxtModule, getNuxtModuleVersion, hasNuxtModuleCompatibility, addServerImports, addServerPlugin, resolveModule, addServerHandler, addPrerenderRoutes } from '@nuxt/kit';
+import { useNuxt, loadNuxtModuleInstance, createResolver, addTemplate, extendPages, tryUseNuxt, defineNuxtModule, useLogger, hasNuxtModule, getNuxtModuleVersion, hasNuxtModuleCompatibility, addServerImports, addServerPlugin, resolveModule, addServerHandler, addPrerenderRoutes } from '@nuxt/kit';
 import { withHttps, withBase, parseURL, joinURL, withTrailingSlash, withoutLeadingSlash, withLeadingSlash, withoutTrailingSlash } from 'ufo';
 import { withSiteUrl, installNuxtSiteConfig } from 'nuxt-site-config/kit';
 import { defu } from 'defu';
@@ -450,9 +450,9 @@ function setupPrerenderHandler(_options, nuxt = useNuxt()) {
       }), route._sitemap);
     });
     nitro.hooks.hook("prerender:done", async () => {
-      const isNuxt4 = nuxt.options._majorVersion === 4;
+      const isNuxt5 = nuxt.options._majorVersion === 5;
       let nitroModule;
-      if (isNuxt4) {
+      if (isNuxt5) {
         nitroModule = await import(String("nitro"));
       } else {
         nitroModule = await import(String("nitropack"));
@@ -740,11 +740,11 @@ const module = defineNuxtModule({
             const locale = normalisedLocales.find((l) => l.code === localeCode);
             if (!locale || !pageLocales[localeCode] || pageLocales[localeCode].includes("["))
               continue;
-            const alternatives = Object.keys(pageLocales).map((l) => ({
+            const alternatives = Object.keys(pageLocales).filter((l) => pageLocales[l] !== false).map((l) => ({
               hreflang: normalisedLocales.find((nl) => nl.code === l)?._hreflang || l,
               href: generatePathForI18nPages({ localeCode: l, pageLocales: pageLocales[l], nuxtI18nConfig, normalisedLocales })
             }));
-            if (alternatives.length && nuxtI18nConfig.defaultLocale && pageLocales[nuxtI18nConfig.defaultLocale])
+            if (alternatives.length && nuxtI18nConfig.defaultLocale && pageLocales[nuxtI18nConfig.defaultLocale] && pageLocales[nuxtI18nConfig.defaultLocale] !== false)
               alternatives.push({ hreflang: "x-default", href: generatePathForI18nPages({ normalisedLocales, localeCode: nuxtI18nConfig.defaultLocale, pageLocales: pageLocales[nuxtI18nConfig.defaultLocale], nuxtI18nConfig }) });
             i18nPagesSources.urls.push({
               _sitemap: locale._sitemap,
@@ -774,7 +774,9 @@ const module = defineNuxtModule({
           differentDomains: nuxtI18nConfig.differentDomains,
           defaultLocale: nuxtI18nConfig.defaultLocale,
           locales: normalisedLocales,
-          strategy: nuxtI18nConfig.strategy
+          strategy: nuxtI18nConfig.strategy,
+          // @ts-expect-error untyped
+          pages: nuxtI18nConfig.pages
         };
       }
       let canI18nMap = config.sitemaps !== false && nuxtI18nConfig.strategy !== "no_prefix";
@@ -831,6 +833,7 @@ declare module 'nitropack' {
     '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>
   }
 }
 declare module 'vue-router' {
@@ -840,7 +843,6 @@ declare module 'vue-router' {
 }
 `;
     });
-    const nitroPreset = resolveNitroPreset();
     const prerenderedRoutes = nuxt.options.nitro.prerender?.routes || [];
     const prerenderSitemap = isNuxtGenerate() || includesSitemapRoot(config.sitemapName, prerenderedRoutes);
     const routeRules = {};
@@ -852,17 +854,6 @@ declare module 'vue-router' {
         "X-Sitemap-Prerendered": (/* @__PURE__ */ new Date()).toISOString()
       };
     }
-    if (!nuxt.options.dev && !isNuxtGenerate() && config.cacheMaxAgeSeconds && config.runtimeCacheStorage !== false) {
-      routeRules[nitroPreset.includes("vercel") ? "isr" : "swr"] = config.cacheMaxAgeSeconds;
-      routeRules.cache = {
-        // handle multi-tenancy
-        swr: true,
-        maxAge: config.cacheMaxAgeSeconds,
-        varies: ["X-Forwarded-Host", "X-Forwarded-Proto", "Host"]
-      };
-      if (typeof config.runtimeCacheStorage === "object")
-        routeRules.cache.base = "sitemap";
-    }
     if (config.xsl) {
       nuxt.options.nitro.routeRules[config.xsl] = {
         headers: {
@@ -875,10 +866,16 @@ declare module 'vue-router' {
       nuxt.options.nitro.routeRules["/sitemap_index.xml"] = routeRules;
       if (typeof config.sitemaps === "object") {
         for (const k in config.sitemaps) {
+          if (k === "index")
+            continue;
           nuxt.options.nitro.routeRules[joinURL(config.sitemapsPathPrefix || "", `/${k}.xml`)] = routeRules;
+          const sitemapConfig = config.sitemaps[k];
+          if (sitemapConfig.chunks) {
+            nuxt.options.nitro.routeRules[joinURL(config.sitemapsPathPrefix || "", `/${k}-*.xml`)] = routeRules;
+          }
         }
       } else {
-        nuxt.options.nitro.routeRules[`/${config.sitemapName}`] = routeRules;
+        nuxt.options.nitro.routeRules[joinURL(config.sitemapsPathPrefix || "", `/[0-9]+.xml`)] = routeRules;
       }
     } else {
       nuxt.options.nitro.routeRules[`/${config.sitemapName}`] = routeRules;
@@ -988,13 +985,25 @@ declare module 'vue-router' {
           middleware: false
         });
       } else {
-        for (const sitemapName of Object.keys(config.sitemaps || {})) {
+        const sitemapNames = Object.keys(config.sitemaps || {});
+        for (const sitemapName of sitemapNames) {
+          if (sitemapName === "index")
+            continue;
+          const sitemapConfig = config.sitemaps[sitemapName];
           addServerHandler({
             route: withLeadingSlash(`${sitemapName}.xml`),
             handler: resolve("./runtime/server/routes/sitemap/[sitemap].xml"),
             lazy: true,
             middleware: false
           });
+          if (sitemapConfig.chunks) {
+            addServerHandler({
+              route: `/${sitemapName}-*.xml`,
+              handler: resolve("./runtime/server/routes/sitemap/[sitemap].xml"),
+              lazy: true,
+              middleware: false
+            });
+          }
         }
       }
       sitemaps.index = {
@@ -1008,7 +1017,7 @@ declare module 'vue-router' {
           if (sitemapName === "index")
             continue;
           const definition = config.sitemaps[sitemapName];
-          sitemaps[sitemapName] = defu(
+          const sitemapConfig = defu(
             {
               sitemapName,
               _route: withBase(joinURL(config.sitemapsPathPrefix || "", `${sitemapName}.xml`), nuxt.options.app.baseURL || "/"),
@@ -1017,6 +1026,28 @@ declare module 'vue-router' {
             { ...definition, urls: void 0, sources: void 0 },
             { include: config.include, exclude: config.exclude }
           );
+          if (definition.chunks) {
+            let chunkSize = config.defaultSitemapsChunkSize || 1e3;
+            if (typeof definition.chunks === "number") {
+              if (definition.chunks <= 0) {
+                logger.warn(`Invalid chunks value (${definition.chunks}) for sitemap "${sitemapName}". Using default.`);
+              } else {
+                chunkSize = definition.chunks;
+              }
+            }
+            if (definition.chunkSize !== void 0) {
+              if (typeof definition.chunkSize !== "number" || definition.chunkSize <= 0) {
+                logger.warn(`Invalid chunkSize value (${definition.chunkSize}) for sitemap "${sitemapName}". Using default.`);
+              } else {
+                chunkSize = definition.chunkSize;
+              }
+            }
+            sitemapConfig._isChunking = true;
+            sitemapConfig._chunkSize = chunkSize;
+            sitemapConfig.chunks = definition.chunks;
+            sitemapConfig.chunkSize = definition.chunkSize;
+          }
+          sitemaps[sitemapName] = sitemapConfig;
         }
       } else {
         sitemaps.chunks = {
@@ -1118,6 +1149,14 @@ declare module 'vue-router' {
         route: "/__sitemap__/debug.json",
         handler: resolve("./runtime/server/routes/__sitemap__/debug")
       });
+      if (usingMultiSitemaps) {
+        addServerHandler({
+          route: "/__sitemap__/**:sitemap",
+          handler: resolve("./runtime/server/routes/sitemap/[sitemap].xml"),
+          lazy: true,
+          middleware: true
+        });
+      }
       setupDevToolsUI(config, resolve);
     }
     const imports = [

package/dist/runtime/server/plugins/warm-up.js

@@ -4,20 +4,36 @@ import { useSitemapRuntimeConfig } from "../utils.js";
 export default defineNitroPlugin((nitroApp) => {
   const { sitemaps } = useSitemapRuntimeConfig();
   const queue = [];
+  const timeoutIds = [];
   const sitemapsWithRoutes = Object.entries(sitemaps).filter(([, sitemap]) => sitemap._route);
   for (const [, sitemap] of sitemapsWithRoutes)
     queue.push(() => nitroApp.localFetch(withLeadingSlash(sitemap._route), {}));
-  setTimeout(
+  const initialTimeout = setTimeout(
     () => {
       const next = async () => {
-        if (queue.length === 0)
+        if (queue.length === 0) {
+          timeoutIds.length = 0;
           return;
-        await queue.shift()();
-        setTimeout(next, 1e3);
+        }
+        try {
+          await queue.shift()();
+        } catch (error) {
+          console.error("[sitemap:warm-up] Error warming up sitemap:", error);
+        }
+        if (queue.length > 0) {
+          const nextTimeout = setTimeout(next, 1e3);
+          timeoutIds.push(nextTimeout);
+        }
       };
       next();
     },
     2500
     /* https://github.com/unjs/nitro/pull/1906 */
   );
+  timeoutIds.push(initialTimeout);
+  nitroApp.hooks.hook("close", () => {
+    timeoutIds.forEach((id) => clearTimeout(id));
+    timeoutIds.length = 0;
+    queue.length = 0;
+  });
 });

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

@@ -17,13 +17,13 @@ export default defineEventHandler(async (e) => {
   for (const s of Object.keys(_sitemaps)) {
     sitemaps[s] = {
       ..._sitemaps[s],
-      sources: await resolveSitemapSources(await childSitemapSources(_sitemaps[s]))
+      sources: await resolveSitemapSources(await childSitemapSources(_sitemaps[s]), e)
     };
   }
   return {
     nitroOrigin,
     sitemaps,
     runtimeConfig,
-    globalSources: await resolveSitemapSources(globalSources)
+    globalSources: await resolveSitemapSources(globalSources, e)
   };
 });

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

@@ -2,19 +2,49 @@ import { createError, defineEventHandler, getRouterParam } from "h3";
 import { withoutLeadingSlash, withoutTrailingSlash } from "ufo";
 import { useSitemapRuntimeConfig } from "../../utils.js";
 import { createSitemap } from "../../sitemap/nitro.js";
+import { parseChunkInfo, getSitemapConfig } from "../../sitemap/utils/chunk.js";
 export default defineEventHandler(async (e) => {
   const runtimeConfig = useSitemapRuntimeConfig(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) {
+  let sitemapName = getRouterParam(e, "sitemap");
+  if (!sitemapName) {
+    const path = e.path;
+    const match = path.match(/(?:\/__sitemap__\/)?([^/]+)\.xml$/);
+    if (match) {
+      sitemapName = match[1];
+    }
+  }
+  if (!sitemapName) {
+    return createError({
+      statusCode: 400,
+      message: "Invalid sitemap request"
+    });
+  }
+  sitemapName = withoutLeadingSlash(withoutTrailingSlash(sitemapName.replace(".xml", "").replace("__sitemap__/", "").replace(runtimeConfig.sitemapsPathPrefix || "", "")));
+  const chunkInfo = parseChunkInfo(sitemapName, sitemaps, runtimeConfig.defaultSitemapsChunkSize);
+  const isAutoChunked = typeof sitemaps.chunks !== "undefined" && !Number.isNaN(Number(sitemapName));
+  const sitemapExists = sitemapName in sitemaps || chunkInfo.baseSitemapName in sitemaps || isAutoChunked;
+  if (!sitemapExists) {
     return createError({
       statusCode: 404,
       message: `Sitemap "${sitemapName}" not found.`
     });
   }
-  return createSitemap(e, isChunking ? {
-    ...sitemaps.chunks,
-    sitemapName
-  } : sitemaps[sitemapName], runtimeConfig);
+  if (chunkInfo.isChunked && chunkInfo.chunkIndex !== void 0) {
+    const baseSitemap = sitemaps[chunkInfo.baseSitemapName];
+    if (baseSitemap && !baseSitemap.chunks && !baseSitemap._isChunking) {
+      return createError({
+        statusCode: 404,
+        message: `Sitemap "${chunkInfo.baseSitemapName}" does not support chunking.`
+      });
+    }
+    if (baseSitemap?._chunkCount !== void 0 && chunkInfo.chunkIndex >= baseSitemap._chunkCount) {
+      return createError({
+        statusCode: 404,
+        message: `Chunk ${chunkInfo.chunkIndex} does not exist for sitemap "${chunkInfo.baseSitemapName}".`
+      });
+    }
+  }
+  const sitemapConfig = getSitemapConfig(sitemapName, sitemaps, runtimeConfig.defaultSitemapsChunkSize);
+  return createSitemap(e, sitemapConfig, runtimeConfig);
 });

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

@@ -22,9 +22,17 @@ export default defineEventHandler(async (e) => {
   const ctx = { sitemap: output, sitemapName: "sitemap", event: e };
   await nitro.hooks.callHook("sitemap:output", ctx);
   setHeader(e, "Content-Type", "text/xml; charset=UTF-8");
-  if (runtimeConfig.cacheMaxAgeSeconds)
-    setHeader(e, "Cache-Control", `public, max-age=${runtimeConfig.cacheMaxAgeSeconds}, must-revalidate`);
-  else
+  if (runtimeConfig.cacheMaxAgeSeconds) {
+    setHeader(e, "Cache-Control", `public, max-age=${runtimeConfig.cacheMaxAgeSeconds}, s-maxage=${runtimeConfig.cacheMaxAgeSeconds}, stale-while-revalidate=3600`);
+    const now = /* @__PURE__ */ new Date();
+    setHeader(e, "X-Sitemap-Generated", now.toISOString());
+    setHeader(e, "X-Sitemap-Cache-Duration", `${runtimeConfig.cacheMaxAgeSeconds}s`);
+    const expiryTime = new Date(now.getTime() + runtimeConfig.cacheMaxAgeSeconds * 1e3);
+    setHeader(e, "X-Sitemap-Cache-Expires", expiryTime.toISOString());
+    const remainingSeconds = Math.floor((expiryTime.getTime() - now.getTime()) / 1e3);
+    setHeader(e, "X-Sitemap-Cache-Remaining", `${remainingSeconds}s`);
+  } else {
     setHeader(e, "Cache-Control", `no-cache, no-store`);
+  }
   return ctx.sitemap;
 });

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

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

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

@@ -1,11 +1,33 @@
 import { defu } from "defu";
 import { joinURL } from "ufo";
+import { defineCachedFunction } from "nitropack/runtime";
+import { getHeader } from "h3";
 import { normaliseDate } from "../urlset/normalise.js";
-import { globalSitemapSources, resolveSitemapSources } from "../urlset/sources.js";
-import { sortSitemapUrls } from "../urlset/sort.js";
-import { escapeValueForXml, wrapSitemapXml } from "./xml.js";
+import { globalSitemapSources, childSitemapSources, resolveSitemapSources } from "../urlset/sources.js";
+import { sortInPlace } from "../urlset/sort.js";
+import { escapeValueForXml } from "./xml.js";
 import { resolveSitemapEntries } from "./sitemap.js";
-export async function buildSitemapIndex(resolvers, runtimeConfig, nitro) {
+const buildSitemapIndexCached = defineCachedFunction(
+  async (event, resolvers, runtimeConfig, nitro) => {
+    return buildSitemapIndexInternal(resolvers, runtimeConfig, nitro);
+  },
+  {
+    name: "sitemap:index",
+    group: "sitemap",
+    maxAge: 60 * 10,
+    // 10 minutes default
+    base: "sitemap",
+    // Use the sitemap storage
+    getKey: (event) => {
+      const host = getHeader(event, "host") || getHeader(event, "x-forwarded-host") || "";
+      const proto = getHeader(event, "x-forwarded-proto") || "https";
+      return `sitemap-index-${proto}-${host}`;
+    },
+    swr: true
+    // Enable stale-while-revalidate
+  }
+);
+async function buildSitemapIndexInternal(resolvers, runtimeConfig, nitro) {
   const {
     sitemaps,
     // enhancing
@@ -20,13 +42,32 @@ export async function buildSitemapIndex(resolvers, runtimeConfig, nitro) {
   if (!sitemaps)
     throw new Error("Attempting to build a sitemap index without required `sitemaps` configuration.");
   function maybeSort(urls) {
-    return sortEntries ? sortSitemapUrls(urls) : urls;
+    return sortEntries ? sortInPlace(urls) : urls;
   }
-  const isChunking = typeof sitemaps.chunks !== "undefined";
   const chunks = {};
-  if (isChunking) {
+  for (const sitemapName in sitemaps) {
+    if (sitemapName === "index" || sitemapName === "chunks") continue;
+    const sitemapConfig = sitemaps[sitemapName];
+    if (sitemapConfig.chunks || sitemapConfig._isChunking) {
+      sitemapConfig._isChunking = true;
+      sitemapConfig._chunkSize = typeof sitemapConfig.chunks === "number" ? sitemapConfig.chunks : sitemapConfig.chunkSize || defaultSitemapsChunkSize || 1e3;
+    } else {
+      chunks[sitemapName] = chunks[sitemapName] || { urls: [] };
+    }
+  }
+  if (typeof sitemaps.chunks !== "undefined") {
     const sitemap = sitemaps.chunks;
-    const sources = await resolveSitemapSources(await globalSitemapSources());
+    let sourcesInput = await globalSitemapSources();
+    if (nitro && resolvers.event) {
+      const ctx = {
+        event: resolvers.event,
+        sitemapName: sitemap.sitemapName,
+        sources: sourcesInput
+      };
+      await nitro.hooks.callHook("sitemap:sources", ctx);
+      sourcesInput = ctx.sources;
+    }
+    const sources = await resolveSitemapSources(sourcesInput, resolvers.event);
     const resolvedCtx = {
       urls: sources.flatMap((s) => s.urls),
       sitemapName: sitemap.sitemapName,
@@ -41,12 +82,6 @@ export async function buildSitemapIndex(resolvers, runtimeConfig, nitro) {
       chunks[chunkIndex] = chunks[chunkIndex] || { urls: [] };
       chunks[chunkIndex].urls.push(url);
     });
-  } else {
-    for (const sitemap in sitemaps) {
-      if (sitemap !== "index") {
-        chunks[sitemap] = chunks[sitemap] || { urls: [] };
-      }
-    }
   }
   const entries = [];
   for (const name in chunks) {
@@ -62,6 +97,48 @@ export async function buildSitemapIndex(resolvers, runtimeConfig, nitro) {
       entry.lastmod = normaliseDate(lastmod);
     entries.push(entry);
   }
+  for (const sitemapName in sitemaps) {
+    if (sitemapName !== "index" && sitemaps[sitemapName]._isChunking) {
+      const sitemapConfig = sitemaps[sitemapName];
+      const chunkSize = sitemapConfig._chunkSize || defaultSitemapsChunkSize || 1e3;
+      let sourcesInput = sitemapConfig.includeAppSources ? await globalSitemapSources() : [];
+      sourcesInput.push(...await childSitemapSources(sitemapConfig));
+      if (nitro && resolvers.event) {
+        const ctx = {
+          event: resolvers.event,
+          sitemapName: sitemapConfig.sitemapName,
+          sources: sourcesInput
+        };
+        await nitro.hooks.callHook("sitemap:sources", ctx);
+        sourcesInput = ctx.sources;
+      }
+      const sources = await resolveSitemapSources(sourcesInput, resolvers.event);
+      const resolvedCtx = {
+        urls: sources.flatMap((s) => s.urls),
+        sitemapName: sitemapConfig.sitemapName,
+        event: resolvers.event
+      };
+      await nitro?.hooks.callHook("sitemap:input", resolvedCtx);
+      const normalisedUrls = resolveSitemapEntries(sitemapConfig, resolvedCtx.urls, { autoI18n, isI18nMapped }, resolvers);
+      const totalUrls = normalisedUrls.length;
+      const chunkCount = Math.ceil(totalUrls / chunkSize);
+      sitemapConfig._chunkCount = chunkCount;
+      for (let i = 0; i < chunkCount; i++) {
+        const chunkName = `${sitemapName}-${i}`;
+        const entry = {
+          _sitemapName: chunkName,
+          sitemap: resolvers.canonicalUrlResolver(joinURL(sitemapsPathPrefix || "", `/${chunkName}.xml`))
+        };
+        const chunkUrls = normalisedUrls.slice(i * chunkSize, (i + 1) * chunkSize);
+        let lastmod = chunkUrls.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)
+          lastmod = /* @__PURE__ */ new Date();
+        if (lastmod)
+          entry.lastmod = normaliseDate(lastmod);
+        entries.push(entry);
+      }
+    }
+  }
   if (sitemaps.index) {
     entries.push(...sitemaps.index.sitemaps.map((entry) => {
       return typeof entry === "string" ? { sitemap: entry } : entry;
@@ -77,9 +154,26 @@ export function urlsToIndexXml(sitemaps, resolvers, { version, xsl, credits, min
     e.lastmod ? `        <lastmod>${escapeValueForXml(e.lastmod)}</lastmod>` : false,
     "    </sitemap>"
   ].filter(Boolean).join("\n")).join("\n");
-  return wrapSitemapXml([
+  const xmlParts = [
+    '<?xml version="1.0" encoding="UTF-8"?>'
+  ];
+  if (xsl) {
+    const relativeBaseUrl = resolvers.relativeBaseUrlResolver?.(xsl) ?? xsl;
+    xmlParts.push(`<?xml-stylesheet type="text/xsl" href="${escapeValueForXml(relativeBaseUrl)}"?>`);
+  }
+  xmlParts.push(
     '<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
     sitemapXml,
     "</sitemapindex>"
-  ], resolvers, { version, xsl, credits, minify });
+  );
+  if (credits) {
+    xmlParts.push(`<!-- XML Sitemap Index generated by @nuxtjs/sitemap v${version} at ${(/* @__PURE__ */ new Date()).toISOString()} -->`);
+  }
+  return minify ? xmlParts.join("").replace(/(?<!<[^>]*)\s(?![^<]*>)/g, "") : xmlParts.join("\n");
+}
+export async function buildSitemapIndex(resolvers, runtimeConfig, nitro) {
+  if (!import.meta.dev && !!runtimeConfig.cacheMaxAgeSeconds && runtimeConfig.cacheMaxAgeSeconds > 0 && resolvers.event) {
+    return buildSitemapIndexCached(resolvers.event, resolvers, runtimeConfig, nitro);
+  }
+  return buildSitemapIndexInternal(resolvers, runtimeConfig, nitro);
 }

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

@@ -7,4 +7,4 @@ export interface NormalizedI18n extends ResolvedSitemapUrl {
 }
 export declare function resolveSitemapEntries(sitemap: SitemapDefinition, urls: SitemapUrlInput[], runtimeConfig: Pick<ModuleRuntimeConfig, 'autoI18n' | 'isI18nMapped'>, resolvers?: NitroUrlResolvers): ResolvedSitemapUrl[];
 export declare function buildSitemapUrls(sitemap: SitemapDefinition, resolvers: NitroUrlResolvers, runtimeConfig: ModuleRuntimeConfig, nitro?: NitroApp): Promise<ResolvedSitemapUrl[]>;
-export declare function urlsToXml(urls: ResolvedSitemapUrl[], resolvers: NitroUrlResolvers, { version, xsl, credits, minify }: Pick<ModuleRuntimeConfig, 'version' | 'xsl' | 'credits' | 'minify'>): string;
+export { urlsToXml } from './xml.js';

package/dist/runtime/server/sitemap/builder/sitemap.js

@@ -2,9 +2,9 @@ import { resolveSitePath } from "nuxt-site-config/urls";
 import { joinURL, withHttps } from "ufo";
 import { preNormalizeEntry } from "../urlset/normalise.js";
 import { childSitemapSources, globalSitemapSources, resolveSitemapSources } from "../urlset/sources.js";
-import { sortSitemapUrls } from "../urlset/sort.js";
+import { sortInPlace } from "../urlset/sort.js";
 import { createPathFilter, logger, splitForLocales } from "../../../utils-pure.js";
-import { handleEntry, wrapSitemapXml } from "./xml.js";
+import { parseChunkInfo, sliceUrlsForChunk } from "../utils/chunk.js";
 export function resolveSitemapEntries(sitemap, urls, runtimeConfig, resolvers) {
   const {
     autoI18n,
@@ -85,9 +85,23 @@ export function resolveSitemapEntries(sitemap, urls, runtimeConfig, resolvers) {
           });
         } else {
           for (const l of autoI18n.locales) {
-            let loc = joinURL(`/${l.code}`, e._pathWithoutPrefix);
-            if (autoI18n.differentDomains || ["prefix_and_default", "prefix_except_default"].includes(autoI18n.strategy) && l.code === autoI18n.defaultLocale)
-              loc = e._pathWithoutPrefix;
+            let loc = e._pathWithoutPrefix;
+            if (autoI18n.pages) {
+              const pageKey = e._pathWithoutPrefix.replace(/^\//, "").replace(/\/index$/, "") || "index";
+              const pageMappings = autoI18n.pages[pageKey];
+              if (pageMappings && pageMappings[l.code] !== void 0) {
+                const customPath = pageMappings[l.code];
+                if (customPath === false)
+                  continue;
+                if (typeof customPath === "string")
+                  loc = customPath.startsWith("/") ? customPath : `/${customPath}`;
+              } else if (!autoI18n.differentDomains && !(["prefix_and_default", "prefix_except_default"].includes(autoI18n.strategy) && l.code === autoI18n.defaultLocale)) {
+                loc = joinURL(`/${l.code}`, e._pathWithoutPrefix);
+              }
+            } else {
+              if (!autoI18n.differentDomains && !(["prefix_and_default", "prefix_except_default"].includes(autoI18n.strategy) && l.code === autoI18n.defaultLocale))
+                loc = joinURL(`/${l.code}`, e._pathWithoutPrefix);
+            }
             const _sitemap = isI18nMapped ? l._sitemap : void 0;
             const newEntry = preNormalizeEntry({
               _sitemap,
@@ -99,14 +113,30 @@ export function resolveSitemapEntries(sitemap, urls, runtimeConfig, resolvers) {
               alternatives: [{ code: "x-default", _hreflang: "x-default" }, ...autoI18n.locales].map((locale) => {
                 const code = locale.code === "x-default" ? autoI18n.defaultLocale : locale.code;
                 const isDefault = locale.code === "x-default" || locale.code === autoI18n.defaultLocale;
-                let href = "";
-                if (autoI18n.strategy === "prefix") {
-                  href = joinURL("/", code, e._pathWithoutPrefix);
-                } else if (["prefix_and_default", "prefix_except_default"].includes(autoI18n.strategy)) {
-                  if (isDefault) {
-                    href = e._pathWithoutPrefix;
-                  } else {
+                let href = e._pathWithoutPrefix;
+                if (autoI18n.pages) {
+                  const pageKey = e._pathWithoutPrefix.replace(/^\//, "").replace(/\/index$/, "") || "index";
+                  const pageMappings = autoI18n.pages[pageKey];
+                  if (pageMappings && pageMappings[code] !== void 0) {
+                    const customPath = pageMappings[code];
+                    if (customPath === false)
+                      return false;
+                    if (typeof customPath === "string")
+                      href = customPath.startsWith("/") ? customPath : `/${customPath}`;
+                  } else if (autoI18n.strategy === "prefix") {
                     href = joinURL("/", code, e._pathWithoutPrefix);
+                  } else if (["prefix_and_default", "prefix_except_default"].includes(autoI18n.strategy)) {
+                    if (!isDefault) {
+                      href = joinURL("/", code, e._pathWithoutPrefix);
+                    }
+                  }
+                } else {
+                  if (autoI18n.strategy === "prefix") {
+                    href = joinURL("/", code, e._pathWithoutPrefix);
+                  } else if (["prefix_and_default", "prefix_except_default"].includes(autoI18n.strategy)) {
+                    if (!isDefault) {
+                      href = joinURL("/", code, e._pathWithoutPrefix);
+                    }
                   }
                 }
                 if (!filterPath(href))
@@ -151,16 +181,12 @@ export async function buildSitemapUrls(sitemap, resolvers, runtimeConfig, nitro)
     // chunking
     defaultSitemapsChunkSize
   } = runtimeConfig;
-  const isChunking = typeof sitemaps.chunks !== "undefined" && !Number.isNaN(Number(sitemap.sitemapName));
+  const chunkInfo = parseChunkInfo(sitemap.sitemapName, sitemaps, defaultSitemapsChunkSize);
   function maybeSort(urls) {
-    return sortEntries ? sortSitemapUrls(urls) : urls;
+    return sortEntries ? sortInPlace(urls) : urls;
   }
   function maybeSlice(urls) {
-    if (isChunking && defaultSitemapsChunkSize) {
-      const chunk = Number(sitemap.sitemapName);
-      return urls.slice(chunk * defaultSitemapsChunkSize, (chunk + 1) * defaultSitemapsChunkSize);
-    }
-    return urls;
+    return sliceUrlsForChunk(urls, sitemap.sitemapName, sitemaps, defaultSitemapsChunkSize);
   }
   if (autoI18n?.differentDomains) {
     const domain = autoI18n.locales.find((e) => [e.language, e.code].includes(sitemap.sitemapName))?.domain;
@@ -175,8 +201,22 @@ export async function buildSitemapUrls(sitemap, resolvers, runtimeConfig, nitro)
       });
     }
   }
-  const sourcesInput = sitemap.includeAppSources ? await globalSitemapSources() : [];
-  sourcesInput.push(...await childSitemapSources(sitemap));
+  let effectiveSitemap = sitemap;
+  const baseSitemapName = chunkInfo.baseSitemapName;
+  if (chunkInfo.isChunked && baseSitemapName !== sitemap.sitemapName && sitemaps[baseSitemapName]) {
+    effectiveSitemap = sitemaps[baseSitemapName];
+  }
+  let sourcesInput = effectiveSitemap.includeAppSources ? await globalSitemapSources() : [];
+  sourcesInput.push(...await childSitemapSources(effectiveSitemap));
+  if (nitro && resolvers.event) {
+    const ctx = {
+      event: resolvers.event,
+      sitemapName: baseSitemapName,
+      sources: sourcesInput
+    };
+    await nitro.hooks.callHook("sitemap:sources", ctx);
+    sourcesInput = ctx.sources;
+  }
   const sources = await resolveSitemapSources(sourcesInput, resolvers.event);
   const resolvedCtx = {
     urls: sources.flatMap((s) => s.urls),
@@ -193,18 +233,4 @@ export async function buildSitemapUrls(sitemap, resolvers, runtimeConfig, nitro)
   const sortedUrls = maybeSort(filteredUrls);
   return maybeSlice(sortedUrls);
 }
-export function urlsToXml(urls, resolvers, { version, xsl, credits, minify }) {
-  const urlset = urls.map((e) => {
-    const keys = Object.keys(e).filter((k) => !k.startsWith("_"));
-    return [
-      "    <url>",
-      keys.map((k) => handleEntry(k, e)).filter(Boolean).join("\n"),
-      "    </url>"
-    ].join("\n");
-  });
-  return wrapSitemapXml([
-    '<urlset xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:video="http://www.google.com/schemas/sitemap-video/1.1" xmlns:xhtml="http://www.w3.org/1999/xhtml" xmlns:image="http://www.google.com/schemas/sitemap-image/1.1" xmlns:news="http://www.google.com/schemas/sitemap-news/0.9" xsi:schemaLocation="http://www.sitemaps.org/schemas/sitemap/0.9 http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd http://www.google.com/schemas/sitemap-image/1.1 http://www.google.com/schemas/sitemap-image/1.1/sitemap-image.xsd" xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
-    urlset.join("\n"),
-    "</urlset>"
-  ], resolvers, { version, xsl, credits, minify });
-}
+export { urlsToXml } from "./xml.js";

package/dist/runtime/server/sitemap/builder/xml.d.ts

@@ -1,4 +1,3 @@
-import type { ModuleRuntimeConfig, NitroUrlResolvers } from '../../../types.js';
-export declare function handleEntry(k: string, e: Record<string, any> | (string | Record<string, any>)[]): string | false;
-export declare function wrapSitemapXml(input: string[], resolvers: NitroUrlResolvers, options: Pick<ModuleRuntimeConfig, 'version' | 'xsl' | 'credits' | 'minify'>): string;
+import type { ModuleRuntimeConfig, NitroUrlResolvers, ResolvedSitemapUrl } from '../../../types.js';
 export declare function escapeValueForXml(value: boolean | string | number): string;
+export declare function urlsToXml(urls: ResolvedSitemapUrl[], resolvers: NitroUrlResolvers, { version, xsl, credits, minify }: Pick<ModuleRuntimeConfig, 'version' | 'xsl' | 'credits' | 'minify'>): string;