@nuxtjs/sitemap 7.2.10 → 7.3.1

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

@@ -1,86 +1,188 @@
-function resolveKey(k) {
-  switch (k) {
-    case "images":
-      return "image";
-    case "videos":
-      return "video";
-    // news & others?
-    case "news":
-      return "news";
-    default:
-      return k;
-  }
+export function escapeValueForXml(value) {
+  if (value === true || value === false)
+    return value ? "yes" : "no";
+  return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
-function handleObject(key, obj) {
-  return [
-    `        <${key}:${key}>`,
-    ...Object.entries(obj).map(([sk, sv]) => {
-      if (key === "video" && Array.isArray(sv)) {
-        return sv.map((v) => {
-          if (typeof v === "string") {
-            return [
-              `            `,
-              `<${key}:${sk}>`,
-              escapeValueForXml(v),
-              `</${key}:${sk}>`
-            ].join("");
+const URLSET_OPENING_TAG = '<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">';
+function buildUrlXml(url) {
+  const capacity = 50;
+  const parts = Array.from({ length: capacity });
+  let partIndex = 0;
+  parts[partIndex++] = "    <url>";
+  if (url.loc) {
+    parts[partIndex++] = `        <loc>${escapeValueForXml(url.loc)}</loc>`;
+  }
+  if (url.lastmod) {
+    parts[partIndex++] = `        <lastmod>${url.lastmod}</lastmod>`;
+  }
+  if (url.changefreq) {
+    parts[partIndex++] = `        <changefreq>${url.changefreq}</changefreq>`;
+  }
+  if (url.priority !== void 0) {
+    const priorityValue = Number.parseFloat(String(url.priority));
+    const formattedPriority = priorityValue % 1 === 0 ? String(priorityValue) : priorityValue.toFixed(1);
+    parts[partIndex++] = `        <priority>${formattedPriority}</priority>`;
+  }
+  const keys = Object.keys(url).filter((k) => !k.startsWith("_") && !["loc", "lastmod", "changefreq", "priority"].includes(k));
+  for (const key of keys) {
+    const value = url[key];
+    if (value === void 0 || value === null) continue;
+    switch (key) {
+      case "alternatives":
+        if (Array.isArray(value) && value.length > 0) {
+          for (const alt of value) {
+            const attrs = Object.entries(alt).map(([k, v]) => `${k}="${escapeValueForXml(v)}"`).join(" ");
+            parts[partIndex++] = `        <xhtml:link rel="alternate" ${attrs} />`;
           }
-          const attributes = Object.entries(v).filter(([ssk]) => ssk !== sk).map(([ssk, ssv]) => `${ssk}="${escapeValueForXml(ssv)}"`).join(" ");
-          return [
-            `            <${key}:${sk} ${attributes}>`,
-            // value is the same sk
-            v[sk],
-            `</${key}:${sk}>`
-          ].join("");
-        }).join("\n");
-      }
-      if (typeof sv === "object") {
-        if (key === "video") {
-          const attributes = Object.entries(sv).filter(([ssk]) => ssk !== sk).map(([ssk, ssv]) => `${ssk}="${escapeValueForXml(ssv)}"`).join(" ");
-          return [
-            `            <${key}:${sk} ${attributes}>`,
-            // value is the same sk
-            sv[sk],
-            `</${key}:${sk}>`
-          ].join("");
         }
-        return [
-          `            <${key}:${sk}>`,
-          ...Object.entries(sv).map(([ssk, ssv]) => `                <${key}:${ssk}>${escapeValueForXml(ssv)}</${key}:${ssk}>`),
-          `            </${key}:${sk}>`
-        ].join("\n");
-      }
-      return `            <${key}:${sk}>${escapeValueForXml(sv)}</${key}:${sk}>`;
-    }),
-    `        </${key}:${key}>`
-  ].join("\n");
-}
-function handleArray(key, arr) {
-  if (arr.length === 0)
-    return false;
-  key = resolveKey(key);
-  if (key === "alternatives") {
-    return arr.map((obj) => [
-      `        <xhtml:link rel="alternate" ${Object.entries(obj).map(([sk, sv]) => `${sk}="${escapeValueForXml(sv)}"`).join(" ")} />`
-    ].join("\n")).join("\n");
+        break;
+      case "images":
+        if (Array.isArray(value) && value.length > 0) {
+          for (const img of value) {
+            parts[partIndex++] = "        <image:image>";
+            parts[partIndex++] = `            <image:loc>${escapeValueForXml(img.loc)}</image:loc>`;
+            if (img.title) parts[partIndex++] = `            <image:title>${escapeValueForXml(img.title)}</image:title>`;
+            if (img.caption) parts[partIndex++] = `            <image:caption>${escapeValueForXml(img.caption)}</image:caption>`;
+            if (img.geo_location) parts[partIndex++] = `            <image:geo_location>${escapeValueForXml(img.geo_location)}</image:geo_location>`;
+            if (img.license) parts[partIndex++] = `            <image:license>${escapeValueForXml(img.license)}</image:license>`;
+            parts[partIndex++] = "        </image:image>";
+          }
+        }
+        break;
+      case "videos":
+        if (Array.isArray(value) && value.length > 0) {
+          for (const video of value) {
+            parts[partIndex++] = "        <video:video>";
+            parts[partIndex++] = `            <video:title>${escapeValueForXml(video.title)}</video:title>`;
+            if (video.thumbnail_loc) {
+              parts[partIndex++] = `            <video:thumbnail_loc>${escapeValueForXml(video.thumbnail_loc)}</video:thumbnail_loc>`;
+            }
+            parts[partIndex++] = `            <video:description>${escapeValueForXml(video.description)}</video:description>`;
+            if (video.content_loc) {
+              parts[partIndex++] = `            <video:content_loc>${escapeValueForXml(video.content_loc)}</video:content_loc>`;
+            }
+            if (video.player_loc) {
+              const attrs = video.player_loc.allow_embed ? ' allow_embed="yes"' : "";
+              const autoplay = video.player_loc.autoplay ? ' autoplay="yes"' : "";
+              parts[partIndex++] = `            <video:player_loc${attrs}${autoplay}>${escapeValueForXml(video.player_loc)}</video:player_loc>`;
+            }
+            if (video.duration !== void 0) {
+              parts[partIndex++] = `            <video:duration>${video.duration}</video:duration>`;
+            }
+            if (video.expiration_date) {
+              parts[partIndex++] = `            <video:expiration_date>${video.expiration_date}</video:expiration_date>`;
+            }
+            if (video.rating !== void 0) {
+              parts[partIndex++] = `            <video:rating>${video.rating}</video:rating>`;
+            }
+            if (video.view_count !== void 0) {
+              parts[partIndex++] = `            <video:view_count>${video.view_count}</video:view_count>`;
+            }
+            if (video.publication_date) {
+              parts[partIndex++] = `            <video:publication_date>${video.publication_date}</video:publication_date>`;
+            }
+            if (video.family_friendly !== void 0) {
+              parts[partIndex++] = `            <video:family_friendly>${video.family_friendly === "yes" || video.family_friendly === true ? "yes" : "no"}</video:family_friendly>`;
+            }
+            if (video.restriction) {
+              const relationship = video.restriction.relationship || "allow";
+              parts[partIndex++] = `            <video:restriction relationship="${relationship}">${escapeValueForXml(video.restriction.restriction)}</video:restriction>`;
+            }
+            if (video.platform) {
+              const relationship = video.platform.relationship || "allow";
+              parts[partIndex++] = `            <video:platform relationship="${relationship}">${escapeValueForXml(video.platform.platform)}</video:platform>`;
+            }
+            if (video.requires_subscription !== void 0) {
+              parts[partIndex++] = `            <video:requires_subscription>${video.requires_subscription === "yes" || video.requires_subscription === true ? "yes" : "no"}</video:requires_subscription>`;
+            }
+            if (video.price) {
+              const prices = Array.isArray(video.price) ? video.price : [video.price];
+              for (const price of prices) {
+                const attrs = [];
+                if (price.currency) attrs.push(`currency="${price.currency}"`);
+                if (price.type) attrs.push(`type="${price.type}"`);
+                const attrsStr = attrs.length > 0 ? " " + attrs.join(" ") : "";
+                parts[partIndex++] = `            <video:price${attrsStr}>${escapeValueForXml(price.price)}</video:price>`;
+              }
+            }
+            if (video.uploader) {
+              const info = video.uploader.info ? ` info="${escapeValueForXml(video.uploader.info)}"` : "";
+              parts[partIndex++] = `            <video:uploader${info}>${escapeValueForXml(video.uploader.uploader)}</video:uploader>`;
+            }
+            if (video.live !== void 0) {
+              parts[partIndex++] = `            <video:live>${video.live === "yes" || video.live === true ? "yes" : "no"}</video:live>`;
+            }
+            if (video.tag) {
+              const tags = Array.isArray(video.tag) ? video.tag : [video.tag];
+              for (const tag of tags) {
+                parts[partIndex++] = `            <video:tag>${escapeValueForXml(tag)}</video:tag>`;
+              }
+            }
+            if (video.category) {
+              parts[partIndex++] = `            <video:category>${escapeValueForXml(video.category)}</video:category>`;
+            }
+            if (video.gallery_loc) {
+              const title = video.gallery_loc.title ? ` title="${escapeValueForXml(video.gallery_loc.title)}"` : "";
+              parts[partIndex++] = `            <video:gallery_loc${title}>${escapeValueForXml(video.gallery_loc)}</video:gallery_loc>`;
+            }
+            parts[partIndex++] = "        </video:video>";
+          }
+        }
+        break;
+      case "news":
+        if (value) {
+          parts[partIndex++] = "        <news:news>";
+          parts[partIndex++] = "            <news:publication>";
+          parts[partIndex++] = `                <news:name>${escapeValueForXml(value.publication.name)}</news:name>`;
+          parts[partIndex++] = `                <news:language>${escapeValueForXml(value.publication.language)}</news:language>`;
+          parts[partIndex++] = "            </news:publication>";
+          if (value.title) {
+            parts[partIndex++] = `            <news:title>${escapeValueForXml(value.title)}</news:title>`;
+          }
+          if (value.publication_date) {
+            parts[partIndex++] = `            <news:publication_date>${value.publication_date}</news:publication_date>`;
+          }
+          if (value.access) {
+            parts[partIndex++] = `            <news:access>${value.access}</news:access>`;
+          }
+          if (value.genres) {
+            parts[partIndex++] = `            <news:genres>${escapeValueForXml(value.genres)}</news:genres>`;
+          }
+          if (value.keywords) {
+            parts[partIndex++] = `            <news:keywords>${escapeValueForXml(value.keywords)}</news:keywords>`;
+          }
+          if (value.stock_tickers) {
+            parts[partIndex++] = `            <news:stock_tickers>${escapeValueForXml(value.stock_tickers)}</news:stock_tickers>`;
+          }
+          parts[partIndex++] = "        </news:news>";
+        }
+        break;
+    }
   }
-  return arr.map((obj) => handleObject(key, obj)).join("\n");
-}
-export function handleEntry(k, e) {
-  return Array.isArray(e[k]) ? handleArray(k, e[k]) : typeof e[k] === "object" ? handleObject(k, e[k]) : `        <${k}>${escapeValueForXml(e[k])}</${k}>`;
+  parts[partIndex++] = "    </url>";
+  return parts.slice(0, partIndex).join("\n");
 }
-export function wrapSitemapXml(input, resolvers, options) {
-  const xsl = options.xsl ? resolvers.relativeBaseUrlResolver(options.xsl) : false;
-  const credits = options.credits;
-  input.unshift(`<?xml version="1.0" encoding="UTF-8"?>${xsl ? `<?xml-stylesheet type="text/xsl" href="${xsl}"?>` : ""}`);
-  if (credits)
-    input.push(`<!-- XML Sitemap generated by @nuxtjs/sitemap v${options.version} at ${(/* @__PURE__ */ new Date()).toISOString()} -->`);
-  if (options.minify)
-    return input.join("").replace(/(?<!<[^>]*)\s(?![^<]*>)/g, "");
-  return input.join("\n");
-}
-export function escapeValueForXml(value) {
-  if (value === true || value === false)
-    return value ? "yes" : "no";
-  return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+export function urlsToXml(urls, resolvers, { version, xsl, credits, minify }) {
+  const estimatedSize = urls.length + 5;
+  const xmlParts = Array.from({ length: estimatedSize });
+  let partIndex = 0;
+  const xslHref = xsl ? resolvers.relativeBaseUrlResolver(xsl) : false;
+  if (xslHref) {
+    xmlParts[partIndex++] = `<?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet type="text/xsl" href="${xslHref}"?>`;
+  } else {
+    xmlParts[partIndex++] = '<?xml version="1.0" encoding="UTF-8"?>';
+  }
+  xmlParts[partIndex++] = URLSET_OPENING_TAG;
+  for (const url of urls) {
+    xmlParts[partIndex++] = buildUrlXml(url);
+  }
+  xmlParts[partIndex++] = "</urlset>";
+  if (credits) {
+    xmlParts[partIndex++] = `<!-- XML Sitemap generated by @nuxtjs/sitemap v${version} at ${(/* @__PURE__ */ new Date()).toISOString()} -->`;
+  }
+  const xmlContent = xmlParts.slice(0, partIndex);
+  if (minify) {
+    return xmlContent.join("").replace(/(?<!<[^>]*)\s(?![^<]*>)/g, "");
+  }
+  return xmlContent.join("\n");
 }

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

@@ -1,12 +1,12 @@
-import { getQuery, setHeader, createError } from "h3";
+import { getQuery, setHeader, createError, getHeader } from "h3";
 import { fixSlashes } from "nuxt-site-config/urls";
 import { defu } from "defu";
-import { useNitroApp } from "nitropack/runtime";
+import { useNitroApp, defineCachedFunction } from "nitropack/runtime";
 import { logger, mergeOnKey, splitForLocales } from "../../utils-pure.js";
 import { createNitroRouteRuleMatcher } from "../kit.js";
 import { buildSitemapUrls, urlsToXml } from "./builder/sitemap.js";
 import { normaliseEntry, preNormalizeEntry } from "./urlset/normalise.js";
-import { sortSitemapUrls } from "./urlset/sort.js";
+import { sortInPlace } from "./urlset/sort.js";
 import { getPathRobotConfig } from "#imports";
 import { useSiteConfig } from "#site-config/server/composables/useSiteConfig";
 import { createSitePathResolver } from "#site-config/server/composables/utils";
@@ -26,7 +26,7 @@ export function useNitroUrlResolvers(e) {
     relativeBaseUrlResolver: createSitePathResolver(e, { absolute: false, withBase: true })
   };
 }
-export async function createSitemap(event, definition, runtimeConfig) {
+async function buildSitemapXml(event, definition, resolvers, runtimeConfig) {
   const { sitemapName } = definition;
   const nitro = useNitroApp();
   if (import.meta.prerender) {
@@ -41,14 +41,15 @@ export async function createSitemap(event, definition, runtimeConfig) {
       });
     }
   }
-  const resolvers = useNitroUrlResolvers(event);
-  let sitemapUrls = await buildSitemapUrls(definition, resolvers, runtimeConfig, nitro);
+  const sitemapUrls = await buildSitemapUrls(definition, resolvers, runtimeConfig, nitro);
   const routeRuleMatcher = createNitroRouteRuleMatcher();
   const { autoI18n } = runtimeConfig;
-  sitemapUrls = sitemapUrls.map((u) => {
+  let validCount = 0;
+  for (let i = 0; i < sitemapUrls.length; i++) {
+    const u = sitemapUrls[i];
     const path = u._path?.pathname || u.loc;
     if (!getPathRobotConfig(event, { path, skipSiteIndexable: true }).indexable)
-      return false;
+      continue;
     let routeRules = routeRuleMatcher(path);
     if (autoI18n?.locales && autoI18n?.strategy !== "no_prefix") {
       const match = splitForLocales(path, autoI18n.locales.map((l) => l.code));
@@ -57,15 +58,15 @@ export async function createSitemap(event, definition, runtimeConfig) {
         routeRules = defu(routeRules, routeRuleMatcher(pathWithoutPrefix));
     }
     if (routeRules.sitemap === false)
-      return false;
-    if (typeof routeRules.robots !== "undefined" && !routeRules.robots) {
-      return false;
-    }
+      continue;
+    if (typeof routeRules.robots !== "undefined" && !routeRules.robots)
+      continue;
     const hasRobotsDisabled = Object.entries(routeRules.headers || {}).some(([name, value]) => name.toLowerCase() === "x-robots-tag" && value.toLowerCase().includes("noindex"));
     if (routeRules.redirect || hasRobotsDisabled)
-      return false;
-    return routeRules.sitemap ? defu(u, routeRules.sitemap) : u;
-  }).filter(Boolean);
+      continue;
+    sitemapUrls[validCount++] = routeRules.sitemap ? defu(u, routeRules.sitemap) : u;
+  }
+  sitemapUrls.length = validCount;
   const locSize = sitemapUrls.length;
   const resolvedCtx = {
     urls: sitemapUrls,
@@ -76,17 +77,64 @@ export async function createSitemap(event, definition, runtimeConfig) {
   if (resolvedCtx.urls.length !== locSize) {
     resolvedCtx.urls = resolvedCtx.urls.map((e) => preNormalizeEntry(e, resolvers));
   }
-  const maybeSort = (urls2) => runtimeConfig.sortEntries ? sortSitemapUrls(urls2) : urls2;
+  const maybeSort = (urls2) => runtimeConfig.sortEntries ? sortInPlace(urls2) : urls2;
   const normalizedPreDedupe = resolvedCtx.urls.map((e) => normaliseEntry(e, definition.defaults, resolvers));
   const urls = maybeSort(mergeOnKey(normalizedPreDedupe, "_key").map((e) => normaliseEntry(e, definition.defaults, resolvers)));
+  if (definition._isChunking && definition.sitemapName.includes("-")) {
+    const parts = definition.sitemapName.split("-");
+    const lastPart = parts.pop();
+    if (!Number.isNaN(Number(lastPart))) {
+      const chunkIndex = Number(lastPart);
+      const baseSitemapName = parts.join("-");
+      if (urls.length === 0 && chunkIndex > 0) {
+        throw createError({
+          statusCode: 404,
+          message: `Sitemap chunk ${chunkIndex} for "${baseSitemapName}" does not exist.`
+        });
+      }
+    }
+  }
   const sitemap = urlsToXml(urls, resolvers, runtimeConfig);
   const ctx = { sitemap, sitemapName, event };
   await nitro.hooks.callHook("sitemap:output", ctx);
+  return ctx.sitemap;
+}
+const buildSitemapXmlCached = defineCachedFunction(
+  buildSitemapXml,
+  {
+    name: "sitemap:xml",
+    group: "sitemap",
+    maxAge: 60 * 10,
+    // Default 10 minutes
+    base: "sitemap",
+    // Use the sitemap storage
+    getKey: (event, definition) => {
+      const host = getHeader(event, "host") || getHeader(event, "x-forwarded-host") || "";
+      const proto = getHeader(event, "x-forwarded-proto") || "https";
+      const sitemapName = definition.sitemapName || "default";
+      return `${sitemapName}-${proto}-${host}`;
+    },
+    swr: true
+    // Enable stale-while-revalidate
+  }
+);
+export async function createSitemap(event, definition, runtimeConfig) {
+  const resolvers = useNitroUrlResolvers(event);
+  const shouldCache = !import.meta.dev && runtimeConfig.cacheMaxAgeSeconds > 0;
+  const xml = shouldCache ? await buildSitemapXmlCached(event, definition, resolvers, runtimeConfig) : await buildSitemapXml(event, definition, resolvers, runtimeConfig);
   setHeader(event, "Content-Type", "text/xml; charset=UTF-8");
-  if (runtimeConfig.cacheMaxAgeSeconds)
-    setHeader(event, "Cache-Control", `public, max-age=${runtimeConfig.cacheMaxAgeSeconds}, must-revalidate`);
-  else
+  if (runtimeConfig.cacheMaxAgeSeconds) {
+    setHeader(event, "Cache-Control", `public, max-age=${runtimeConfig.cacheMaxAgeSeconds}, s-maxage=${runtimeConfig.cacheMaxAgeSeconds}, stale-while-revalidate=3600`);
+    const now = /* @__PURE__ */ new Date();
+    setHeader(event, "X-Sitemap-Generated", now.toISOString());
+    setHeader(event, "X-Sitemap-Cache-Duration", `${runtimeConfig.cacheMaxAgeSeconds}s`);
+    const expiryTime = new Date(now.getTime() + runtimeConfig.cacheMaxAgeSeconds * 1e3);
+    setHeader(event, "X-Sitemap-Cache-Expires", expiryTime.toISOString());
+    const remainingSeconds = Math.floor((expiryTime.getTime() - now.getTime()) / 1e3);
+    setHeader(event, "X-Sitemap-Cache-Remaining", `${remainingSeconds}s`);
+  } else {
     setHeader(event, "Cache-Control", `no-cache, no-store`);
+  }
   event.context._isSitemap = true;
-  return ctx.sitemap;
+  return xml;
 }

package/dist/runtime/server/sitemap/urlset/normalise.js

@@ -75,29 +75,31 @@ export function normaliseEntry(_e, defaults, resolvers) {
     delete e.lastmod;
   e.loc = resolve(e.loc, resolvers);
   if (e.alternatives) {
-    e.alternatives = mergeOnKey(e.alternatives.map((e2) => {
-      const a = { ...e2 };
-      if (typeof a.href === "string")
-        a.href = resolve(a.href, resolvers);
-      else if (typeof a.href === "object" && a.href)
-        a.href = resolve(a.href.href, resolvers);
-      return a;
-    }), "hreflang");
+    const alternatives = e.alternatives;
+    for (let i = 0; i < alternatives.length; i++) {
+      const alt = alternatives[i];
+      if (typeof alt.href === "string") {
+        alt.href = resolve(alt.href, resolvers);
+      } else if (typeof alt.href === "object" && alt.href) {
+        alt.href = resolve(alt.href.href, resolvers);
+      }
+    }
+    e.alternatives = mergeOnKey(alternatives, "hreflang");
   }
   if (e.images) {
-    e.images = mergeOnKey(e.images.map((i) => {
-      i = { ...i };
-      i.loc = resolve(i.loc, resolvers);
-      return i;
-    }), "loc");
+    const images = e.images;
+    for (let i = 0; i < images.length; i++) {
+      images[i].loc = resolve(images[i].loc, resolvers);
+    }
+    e.images = mergeOnKey(images, "loc");
   }
   if (e.videos) {
-    e.videos = e.videos.map((v) => {
-      v = { ...v };
-      if (v.content_loc)
-        v.content_loc = resolve(v.content_loc, resolvers);
-      return v;
-    });
+    const videos = e.videos;
+    for (let i = 0; i < videos.length; i++) {
+      if (videos[i].content_loc) {
+        videos[i].content_loc = resolve(videos[i].content_loc, resolvers);
+      }
+    }
   }
   return e;
 }

package/dist/runtime/server/sitemap/urlset/sort.d.ts

@@ -1,2 +1,2 @@
 import type { ResolvedSitemapUrl, SitemapUrlInput } from '../../../types.js';
-export declare function sortSitemapUrls<T extends SitemapUrlInput[] | ResolvedSitemapUrl[]>(urls: T): T;
+export declare function sortInPlace<T extends SitemapUrlInput[] | ResolvedSitemapUrl[]>(urls: T): T;

package/dist/runtime/server/sitemap/urlset/sort.js

@@ -1,19 +1,13 @@
-export function sortSitemapUrls(urls) {
-  return urls.sort(
-    (a, b) => {
-      const aLoc = typeof a === "string" ? a : a.loc;
-      const bLoc = typeof b === "string" ? b : b.loc;
-      return aLoc.localeCompare(bLoc, void 0, { numeric: true });
-    }
-  ).sort((a, b) => {
-    const aLoc = (typeof a === "string" ? a : a.loc) || "";
-    const bLoc = (typeof b === "string" ? b : b.loc) || "";
+export function sortInPlace(urls) {
+  urls.sort((a, b) => {
+    const aLoc = typeof a === "string" ? a : a.loc;
+    const bLoc = typeof b === "string" ? b : b.loc;
     const aSegments = aLoc.split("/").length;
     const bSegments = bLoc.split("/").length;
-    if (aSegments > bSegments)
-      return 1;
-    if (aSegments < bSegments)
-      return -1;
-    return 0;
+    if (aSegments !== bSegments) {
+      return aSegments - bSegments;
+    }
+    return aLoc.localeCompare(bLoc, void 0, { numeric: true });
   });
+  return urls;
 }

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

@@ -0,0 +1,10 @@
+import type { ModuleRuntimeConfig, SitemapDefinition } from '../../../types.js';
+export interface ChunkInfo {
+    isChunked: boolean;
+    baseSitemapName: string;
+    chunkIndex?: number;
+    chunkSize: number;
+}
+export declare function parseChunkInfo(sitemapName: string, sitemaps: ModuleRuntimeConfig['sitemaps'], defaultChunkSize?: number): ChunkInfo;
+export declare function getSitemapConfig(sitemapName: string, sitemaps: ModuleRuntimeConfig['sitemaps'], defaultChunkSize?: number): SitemapDefinition;
+export declare function sliceUrlsForChunk<T>(urls: T[], sitemapName: string, sitemaps: ModuleRuntimeConfig['sitemaps'], defaultChunkSize?: number): T[];

package/dist/runtime/server/sitemap/utils/chunk.js

@@ -0,0 +1,66 @@
+export function parseChunkInfo(sitemapName, sitemaps, defaultChunkSize = 1e3) {
+  if (typeof sitemaps.chunks !== "undefined" && !Number.isNaN(Number(sitemapName))) {
+    return {
+      isChunked: true,
+      baseSitemapName: "sitemap",
+      chunkIndex: Number(sitemapName),
+      chunkSize: defaultChunkSize
+    };
+  }
+  if (sitemapName.includes("-")) {
+    const parts = sitemapName.split("-");
+    const lastPart = parts.pop();
+    if (!Number.isNaN(Number(lastPart))) {
+      const baseSitemapName = parts.join("-");
+      const baseSitemap = sitemaps[baseSitemapName];
+      if (baseSitemap && (baseSitemap.chunks || baseSitemap._isChunking)) {
+        const chunkSize = typeof baseSitemap.chunks === "number" ? baseSitemap.chunks : baseSitemap.chunkSize || defaultChunkSize;
+        return {
+          isChunked: true,
+          baseSitemapName,
+          chunkIndex: Number(lastPart),
+          chunkSize
+        };
+      }
+    }
+  }
+  return {
+    isChunked: false,
+    baseSitemapName: sitemapName,
+    chunkIndex: void 0,
+    chunkSize: defaultChunkSize
+  };
+}
+export function getSitemapConfig(sitemapName, sitemaps, defaultChunkSize = 1e3) {
+  const chunkInfo = parseChunkInfo(sitemapName, sitemaps, defaultChunkSize);
+  if (chunkInfo.isChunked) {
+    if (chunkInfo.baseSitemapName === "sitemap" && typeof sitemaps.chunks !== "undefined") {
+      return {
+        ...sitemaps.chunks,
+        sitemapName,
+        _isChunking: true,
+        _chunkSize: chunkInfo.chunkSize
+      };
+    }
+    const baseSitemap = sitemaps[chunkInfo.baseSitemapName];
+    if (baseSitemap) {
+      return {
+        ...baseSitemap,
+        sitemapName,
+        // Use the full name with chunk index
+        _isChunking: true,
+        _chunkSize: chunkInfo.chunkSize
+      };
+    }
+  }
+  return sitemaps[sitemapName];
+}
+export function sliceUrlsForChunk(urls, sitemapName, sitemaps, defaultChunkSize = 1e3) {
+  const chunkInfo = parseChunkInfo(sitemapName, sitemaps, defaultChunkSize);
+  if (chunkInfo.isChunked && chunkInfo.chunkIndex !== void 0) {
+    const startIndex = chunkInfo.chunkIndex * chunkInfo.chunkSize;
+    const endIndex = (chunkInfo.chunkIndex + 1) * chunkInfo.chunkSize;
+    return urls.slice(startIndex, endIndex);
+  }
+  return urls;
+}

package/dist/runtime/types.d.ts

@@ -211,6 +211,7 @@ export interface AutoI18nConfig {
     })[];
     defaultLocale: string;
     strategy: 'prefix' | 'prefix_except_default' | 'prefix_and_default' | 'no_prefix';
+    pages?: Record<string, Record<string, string | false>>;
 }
 export interface ModuleRuntimeConfig extends Pick<ModuleOptions, 'sitemapsPathPrefix' | 'cacheMaxAgeSeconds' | 'sitemapName' | 'excludeAppSources' | 'sortEntries' | 'defaultSitemapsChunkSize' | 'xslColumns' | 'xslTips' | 'debug' | 'discoverImages' | 'discoverVideos' | 'autoLastmod' | 'xsl' | 'credits' | 'minify'> {
     version: string;
@@ -291,10 +292,49 @@ export interface SitemapDefinition {
      * Additional sources of URLs to include in the sitemap.
      */
     sources?: SitemapSourceInput[];
+    /**
+     * Whether to enable chunking for this sitemap.
+     *
+     * - `true`: Enable with default chunk size from `defaultSitemapsChunkSize`
+     * - `number`: Enable with specific chunk size (must be > 0)
+     * - `false` or `undefined`: Disable chunking
+     *
+     * Note: Chunking only applies to sitemaps with sources. URLs provided directly
+     * are not chunked.
+     *
+     * @default false
+     * @example true
+     * @example 5000
+     */
+    chunks?: boolean | number;
+    /**
+     * The maximum number of URLs per chunk when chunking is enabled.
+     * Takes precedence over the `chunks` property when both are specified.
+     * Also overrides the global `defaultSitemapsChunkSize`.
+     *
+     * Must be a positive integer.
+     *
+     * @default 1000
+     * @example 500
+     * @example 10000
+     */
+    chunkSize?: number;
     /**
      * @internal
      */
     _route?: string;
+    /**
+     * @internal
+     */
+    _isChunking?: boolean;
+    /**
+     * @internal
+     */
+    _chunkSize?: number;
+    /**
+     * @internal
+     */
+    _chunkCount?: number;
 }
 interface NitroBaseHook {
     event: H3Event;
@@ -314,6 +354,10 @@ export interface SitemapOutputHookCtx extends NitroBaseHook {
     sitemapName: string;
     sitemap: string;
 }
+export interface SitemapSourcesHookCtx extends NitroBaseHook {
+    sitemapName: string;
+    sources: (SitemapSourceBase | SitemapSourceResolved)[];
+}
 export type Changefreq = 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never';
 export interface SitemapUrl {
     loc: string;