@nuxtjs/sitemap 8.2.3 → 8.3.0

package/dist/module.json

@@ -4,7 +4,7 @@
     "nuxt": ">=3.9.0"
   },
   "configKey": "sitemap",
-  "version": "8.2.3",
+  "version": "8.3.0",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -53,6 +53,7 @@ function setupPrerenderHandler(_options, nuxt = useNuxt()) {
   }
   nuxt.options.nitro.prerender.routes = nuxt.options.nitro.prerender.routes.filter((r) => r && !includesSitemapRoot(options.sitemapName, [r]));
   const runtimeAssetsPath = join(nuxt.options.rootDir, "node_modules/.cache/nuxt/sitemap");
+  const localeCodes = options.autoI18n ? new Set(options.autoI18n.locales.map((l) => l.code)) : void 0;
   nuxt.hooks.hook("nitro:config", (nitroConfig) => {
     nitroConfig.virtual = nitroConfig.virtual || {};
     nitroConfig.virtual["#sitemap-virtual/read-sources.mjs"] = `
@@ -103,7 +104,7 @@ export async function readSourcesFromFilesystem(filename) {
       });
       if (options.autoI18n && Object.keys(options.sitemaps).length > 1) {
         const path = route.route;
-        const match = splitForLocales(path, options.autoI18n.locales.map((l) => l.code));
+        const match = splitForLocales(path, localeCodes);
         const locale = match[0] || options.autoI18n.defaultLocale;
         if (options.isI18nMapped) {
           const { _sitemap } = options.autoI18n.locales.find((l) => l.code === locale) || { _sitemap: locale };
@@ -501,6 +502,7 @@ const module$1 = defineNuxtModule({
     // cache for 10 minutes
     minify: false,
     debug: false,
+    experimentalStreaming: false,
     defaultSitemapsChunkSize: 1e3,
     autoLastmod: false,
     discoverImages: true,
@@ -767,13 +769,15 @@ const module$1 = defineNuxtModule({
     } else if (hasRouteRuleContent) {
       nuxt.options.nitro.routeRules[`/${config.sitemapName}`] = routeRules;
     }
-    if (config.zeroRuntime && (config.experimentalWarmUp || config.experimentalCompression))
-      logger.warn("`experimentalWarmUp` and `experimentalCompression` are ignored in zeroRuntime mode.");
+    if (config.zeroRuntime && (config.experimentalWarmUp || config.experimentalCompression || config.experimentalStreaming))
+      logger.warn("`experimentalWarmUp`, `experimentalCompression`, and `experimentalStreaming` are ignored in zeroRuntime mode.");
     if (!config.zeroRuntime) {
       if (config.experimentalWarmUp)
         addServerPlugin(resolve("./runtime/server/plugins/warm-up"));
       if (config.experimentalCompression)
         addServerPlugin(resolve("./runtime/server/plugins/compression"));
+      if (config.experimentalStreaming || config.experimentalCompression)
+        addServerPlugin(resolve("./runtime/server/plugins/stream-transport"));
     }
     const isNuxtContentDocumentDriven = !!nuxt.options.content?.documentDriven || config.strictNuxtContentPaths;
     const contentVersion = await resolveNuxtContentVersion();
@@ -1051,6 +1055,7 @@ ${onUrlEntries.join("\n")}`;
       isMultiSitemap: usingMultiSitemaps,
       excludeAppSources: config.excludeAppSources,
       cacheMaxAgeSeconds: nuxt.options.dev ? 0 : config.cacheMaxAgeSeconds,
+      experimentalStreaming: config.experimentalStreaming,
       autoLastmod: config.autoLastmod,
       defaultSitemapsChunkSize: config.defaultSitemapsChunkSize,
       minify: config.minify,

package/dist/runtime/server/kit.js

@@ -3,9 +3,13 @@ import { useRuntimeConfig } from "nitropack/runtime";
 import { createRouter as createRadixRouter, toRouteMatcher } from "radix3";
 import { parseURL, withoutBase, withoutTrailingSlash } from "ufo";
 function withoutQuery(path) {
-  return path.split("?")[0];
+  const queryIndex = path.indexOf("?");
+  return queryIndex === -1 ? path : path.slice(0, queryIndex);
 }
+let cachedRouteRuleMatcher;
 export function createNitroRouteRuleMatcher() {
+  if (!import.meta.dev && cachedRouteRuleMatcher)
+    return cachedRouteRuleMatcher;
   const { nitro, app } = useRuntimeConfig();
   const _routeRulesMatcher = toRouteMatcher(
     createRadixRouter({
@@ -14,10 +18,13 @@ export function createNitroRouteRuleMatcher() {
       )
     })
   );
-  return (pathOrUrl) => {
+  const matcher = (pathOrUrl) => {
     const path = pathOrUrl[0] === "/" ? pathOrUrl : parseURL(pathOrUrl, app.baseURL).pathname;
     return defu({}, ..._routeRulesMatcher.matchAll(
       withoutBase(withoutTrailingSlash(withoutQuery(path)), app.baseURL)
     ).reverse());
   };
+  if (!import.meta.dev)
+    cachedRouteRuleMatcher = matcher;
+  return matcher;
 }

package/dist/runtime/server/plugins/compression.js

@@ -1,23 +1,67 @@
-import { getRequestHeader, setResponseHeader } from "h3";
+import { appendResponseHeader, getRequestHeader, getResponseHeader, removeResponseHeader, setResponseHeader } from "h3";
 import { defineNitroPlugin } from "nitropack/runtime";
-function getPreferredEncoding(event) {
-  const acceptEncoding = getRequestHeader(event, "accept-encoding") || "";
-  if (acceptEncoding.includes("gzip"))
-    return "gzip";
-  if (acceptEncoding.includes("deflate"))
-    return "deflate";
-  return null;
+import { logger } from "../../utils-pure.js";
+import { hasNonIdentityEncoding, isReadableStream, negotiateCompressionEncoding } from "../sitemap/stream.js";
+let warnedAboutCompressionStream = false;
+const NODE_COMPRESSION_INPUT_BATCH_BYTES = 512 * 1024;
+function toByteStream(body) {
+  if (isReadableStream(body))
+    return body;
+  if (body instanceof Blob)
+    return body.stream();
+  const value = typeof body === "string" || body instanceof ArrayBuffer || ArrayBuffer.isView(body) ? body : JSON.stringify(body);
+  return new Blob([value]).stream();
+}
+function createNodeCompressionInputStream(source) {
+  const reader = source.getReader();
+  let bytesRead = 0;
+  return new ReadableStream({
+    async pull(controller) {
+      if (bytesRead >= NODE_COMPRESSION_INPUT_BATCH_BYTES) {
+        bytesRead = 0;
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      }
+      const result = await reader.read();
+      if (result.done) {
+        controller.close();
+        return;
+      }
+      bytesRead += result.value.byteLength;
+      controller.enqueue(result.value);
+    },
+    cancel(reason) {
+      return reader.cancel(reason);
+    }
+  });
+}
+function addVaryAcceptEncoding(event) {
+  const vary = getResponseHeader(event, "Vary");
+  const values = (Array.isArray(vary) ? vary : [vary]).flatMap((value) => String(value || "").split(",")).map((value) => value.trim().toLowerCase());
+  if (!values.includes("*") && !values.includes("accept-encoding"))
+    appendResponseHeader(event, "Vary", "Accept-Encoding");
 }
 export default defineNitroPlugin((nitro) => {
-  nitro.hooks.hook("beforeResponse", async (event, response) => {
+  nitro.hooks.hook("beforeResponse", (event, response) => {
     if (!event.context._isSitemap || !response.body)
       return;
-    const encoding = getPreferredEncoding(event);
+    addVaryAcceptEncoding(event);
+    if (hasNonIdentityEncoding(getResponseHeader(event, "Content-Encoding")))
+      return;
+    const encoding = negotiateCompressionEncoding(getRequestHeader(event, "accept-encoding") || "");
     if (!encoding)
       return;
-    const body = typeof response.body === "string" ? response.body : JSON.stringify(response.body);
-    const stream = new Blob([body]).stream().pipeThrough(new CompressionStream(encoding));
-    response.body = Buffer.from(await new Response(stream).arrayBuffer());
+    if (typeof CompressionStream === "undefined") {
+      if (!warnedAboutCompressionStream) {
+        warnedAboutCompressionStream = true;
+        logger.warn("Sitemap compression was requested, but CompressionStream is unavailable in this runtime. Sending the uncompressed response.");
+      }
+      return;
+    }
+    const compression = new CompressionStream(encoding);
+    const source = toByteStream(response.body);
+    const compressionInput = event.node.res?.socket ? createNodeCompressionInputStream(source) : source;
+    response.body = compressionInput.pipeThrough(compression);
+    removeResponseHeader(event, "Content-Length");
     setResponseHeader(event, "Content-Encoding", encoding);
   });
 });

package/dist/runtime/server/plugins/stream-transport.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nitropack/types").NitroAppPlugin;
+export default _default;

package/dist/runtime/server/plugins/stream-transport.js

@@ -0,0 +1,16 @@
+import { removeResponseHeader } from "h3";
+import { defineNitroPlugin } from "nitropack/runtime";
+import { logger } from "../../utils-pure.js";
+import { createNodeResponseStream, isReadableStream } from "../sitemap/stream.js";
+export default defineNitroPlugin((nitro) => {
+  nitro.hooks.hook("beforeResponse", (event, response) => {
+    const nodeResponse = event.node.res;
+    if (!event.context._isSitemap || !isReadableStream(response.body) || !nodeResponse?.socket || typeof nodeResponse?.write !== "function" || typeof nodeResponse?.once !== "function") {
+      return;
+    }
+    response.body = createNodeResponseStream(response.body, (error) => {
+      logger.error("Failed to cancel sitemap response stream after the client disconnected.", error);
+    });
+    removeResponseHeader(event, "Content-Length");
+  });
+});

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

@@ -35,6 +35,7 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
         xsl: string | false;
         credits: boolean;
         minify: boolean;
+        experimentalStreaming?: boolean | undefined;
     };
     globalSources: SitemapSourceResolved[];
     siteConfig: {

package/dist/runtime/server/routes/__zero-runtime/sitemap/[sitemap].xml.d.ts

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

package/dist/runtime/server/routes/__zero-runtime/sitemap.xml.d.ts

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

package/dist/runtime/server/routes/__zero-runtime/sitemap_index.xml.d.ts

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

package/dist/runtime/server/routes/sitemap/[sitemap].xml.d.ts

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

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

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

package/dist/runtime/server/routes/sitemap_index.xml.d.ts

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

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

@@ -0,0 +1,13 @@
+import type { ModuleRuntimeConfig, NitroUrlResolvers, SitemapIndexEntry } from '../../../types.js';
+export declare function renderSitemapIndexXmlChunks(sitemaps: SitemapIndexEntry[], resolvers: NitroUrlResolvers, { version, xsl, credits, minify }: Pick<ModuleRuntimeConfig, 'version' | 'xsl' | 'credits' | 'minify'>, errorInfo?: {
+    messages: string[];
+    urls: string[];
+}): Generator<string>;
+export declare function urlsToIndexXml(sitemaps: SitemapIndexEntry[], resolvers: NitroUrlResolvers, { version, xsl, credits, minify }: Pick<ModuleRuntimeConfig, 'version' | 'xsl' | 'credits' | 'minify'>, errorInfo?: {
+    messages: string[];
+    urls: string[];
+}): string;
+export declare function urlsToIndexXmlStream(sitemaps: SitemapIndexEntry[], resolvers: NitroUrlResolvers, config: Pick<ModuleRuntimeConfig, 'version' | 'xsl' | 'credits' | 'minify'>, errorInfo?: {
+    messages: string[];
+    urls: string[];
+}): ReadableStream<Uint8Array>;

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

@@ -0,0 +1,70 @@
+import { withQuery } from "ufo";
+import { createChunkedXmlStream } from "../stream.js";
+import { escapeValueForXml } from "./xml.js";
+export function* renderSitemapIndexXmlChunks(sitemaps, resolvers, { version, xsl, credits, minify }, errorInfo) {
+  const NL = minify ? "" : "\n";
+  const I1 = minify ? "" : "    ";
+  const I2 = minify ? "" : "        ";
+  yield '<?xml version="1.0" encoding="UTF-8"?>';
+  if (xsl) {
+    let relativeBaseUrl = resolvers.relativeBaseUrlResolver?.(xsl) ?? xsl;
+    if (errorInfo && errorInfo.messages.length > 0) {
+      relativeBaseUrl = withQuery(relativeBaseUrl, {
+        errors: "true",
+        error_messages: errorInfo.messages,
+        error_urls: errorInfo.urls
+      });
+    }
+    yield `${NL}<?xml-stylesheet type="text/xsl" href="${escapeValueForXml(relativeBaseUrl)}"?>`;
+  }
+  yield `${NL}<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">${NL}`;
+  for (let i = 0; i < sitemaps.length; i++) {
+    const entry = sitemaps[i];
+    if (i > 0)
+      yield NL;
+    yield `${I1}<sitemap>${NL}${I2}<loc>${escapeValueForXml(entry.sitemap)}</loc>${NL}`;
+    if (entry.lastmod)
+      yield `${I2}<lastmod>${escapeValueForXml(entry.lastmod)}</lastmod>${NL}`;
+    yield `${I1}</sitemap>`;
+  }
+  yield `${NL}</sitemapindex>`;
+  if (credits)
+    yield `${NL}<!-- XML Sitemap Index generated by @nuxtjs/sitemap v${version} at ${(/* @__PURE__ */ new Date()).toISOString()} -->`;
+}
+export function urlsToIndexXml(sitemaps, resolvers, { version, xsl, credits, minify }, errorInfo) {
+  const NL = minify ? "" : "\n";
+  const I1 = minify ? "" : "    ";
+  const I2 = minify ? "" : "        ";
+  let sitemapXml = "";
+  for (const entry of sitemaps) {
+    if (sitemapXml)
+      sitemapXml += NL;
+    sitemapXml += `${I1}<sitemap>${NL}${I2}<loc>${escapeValueForXml(entry.sitemap)}</loc>${NL}`;
+    if (entry.lastmod)
+      sitemapXml += `${I2}<lastmod>${escapeValueForXml(entry.lastmod)}</lastmod>${NL}`;
+    sitemapXml += `${I1}</sitemap>`;
+  }
+  const xmlParts = ['<?xml version="1.0" encoding="UTF-8"?>'];
+  if (xsl) {
+    let relativeBaseUrl = resolvers.relativeBaseUrlResolver?.(xsl) ?? xsl;
+    if (errorInfo && errorInfo.messages.length > 0) {
+      relativeBaseUrl = withQuery(relativeBaseUrl, {
+        errors: "true",
+        error_messages: errorInfo.messages,
+        error_urls: errorInfo.urls
+      });
+    }
+    xmlParts.push(`<?xml-stylesheet type="text/xsl" href="${escapeValueForXml(relativeBaseUrl)}"?>`);
+  }
+  xmlParts.push(
+    '<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
+    sitemapXml,
+    "</sitemapindex>"
+  );
+  if (credits)
+    xmlParts.push(`<!-- XML Sitemap Index generated by @nuxtjs/sitemap v${version} at ${(/* @__PURE__ */ new Date()).toISOString()} -->`);
+  return xmlParts.join(NL);
+}
+export function urlsToIndexXmlStream(sitemaps, resolvers, config, errorInfo) {
+  return createChunkedXmlStream(renderSitemapIndexXmlChunks(sitemaps, resolvers, config, errorInfo));
+}

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

@@ -1,9 +1,5 @@
 import type { NitroApp } from 'nitropack/types';
 import type { ModuleRuntimeConfig, NitroUrlResolvers, SitemapIndexEntry } from '../../../types.js';
-export declare function urlsToIndexXml(sitemaps: SitemapIndexEntry[], resolvers: NitroUrlResolvers, { version, xsl, credits, minify }: Pick<ModuleRuntimeConfig, 'version' | 'xsl' | 'credits' | 'minify'>, errorInfo?: {
-    messages: string[];
-    urls: string[];
-}): string;
 export declare function buildSitemapIndex(resolvers: NitroUrlResolvers, runtimeConfig: ModuleRuntimeConfig, nitro?: NitroApp): Promise<{
     entries: SitemapIndexEntry[];
     failedSources: Array<{
@@ -11,3 +7,4 @@ export declare function buildSitemapIndex(resolvers: NitroUrlResolvers, runtimeC
         error: string;
     }>;
 }>;
+export { urlsToIndexXml, urlsToIndexXmlStream } from './index-xml.js';

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

@@ -1,10 +1,9 @@
 import { getHeader } from "h3";
 import { defineCachedFunction } from "nitropack/runtime";
-import { joinURL, withQuery } from "ufo";
+import { joinURL } from "ufo";
 import staticConfig from "#sitemap-virtual/static-config.mjs";
 import { normaliseDate } from "../urlset/normalise.js";
 import { getResolvedSitemapUrls } from "./sitemap.js";
-import { escapeValueForXml } from "./xml.js";
 const SERVER_CACHE_MAX_AGE = staticConfig.cacheMaxAgeSeconds || 60 * 10;
 const buildSitemapIndexCached = defineCachedFunction(
   async (event, resolvers, runtimeConfig, nitro) => {
@@ -105,41 +104,10 @@ async function buildSitemapIndexInternal(resolvers, runtimeConfig, nitro) {
   }
   return { entries, failedSources: allFailedSources };
 }
-export function urlsToIndexXml(sitemaps, resolvers, { version, xsl, credits, minify }, errorInfo) {
-  const sitemapXml = sitemaps.map((e) => [
-    "    <sitemap>",
-    `        <loc>${escapeValueForXml(e.sitemap)}</loc>`,
-    // lastmod is optional
-    e.lastmod ? `        <lastmod>${escapeValueForXml(e.lastmod)}</lastmod>` : false,
-    "    </sitemap>"
-  ].filter(Boolean).join("\n")).join("\n");
-  const xmlParts = [
-    '<?xml version="1.0" encoding="UTF-8"?>'
-  ];
-  if (xsl) {
-    let relativeBaseUrl = resolvers.relativeBaseUrlResolver?.(xsl) ?? xsl;
-    if (errorInfo && errorInfo.messages.length > 0) {
-      relativeBaseUrl = withQuery(relativeBaseUrl, {
-        errors: "true",
-        error_messages: errorInfo.messages,
-        error_urls: errorInfo.urls
-      });
-    }
-    xmlParts.push(`<?xml-stylesheet type="text/xsl" href="${escapeValueForXml(relativeBaseUrl)}"?>`);
-  }
-  xmlParts.push(
-    '<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
-    sitemapXml,
-    "</sitemapindex>"
-  );
-  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 && !import.meta.prerender && typeof runtimeConfig.cacheMaxAgeSeconds === "number" && runtimeConfig.cacheMaxAgeSeconds > 0 && resolvers.event) {
     return buildSitemapIndexCached(resolvers.event, resolvers, runtimeConfig, nitro);
   }
   return buildSitemapIndexInternal(resolvers, runtimeConfig, nitro);
 }
+export { urlsToIndexXml, urlsToIndexXmlStream } from "./index-xml.js";

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

@@ -18,4 +18,4 @@ export declare function buildResolvedSitemapUrls(effectiveSitemap: SitemapDefini
 export declare const buildResolvedSitemapUrlsCached: (_event: H3Event<import("h3").EventHandlerRequest>, effectiveSitemap: SitemapDefinition, matchName: string, isChunked: boolean, resolvers: NitroUrlResolvers, runtimeConfig: ModuleRuntimeConfig, nitro?: NitroApp | undefined) => Promise<ResolvedSitemapUrlsResult>;
 export declare function getResolvedSitemapUrls(effectiveSitemap: SitemapDefinition, matchName: string, isChunked: boolean, resolvers: NitroUrlResolvers, runtimeConfig: ModuleRuntimeConfig, nitro?: NitroApp): Promise<ResolvedSitemapUrlsResult>;
 export declare function buildSitemapUrls(sitemap: SitemapDefinition, resolvers: NitroUrlResolvers, runtimeConfig: ModuleRuntimeConfig, nitro?: NitroApp): Promise<ResolvedSitemapUrlsResult>;
-export { urlsToXml } from './xml.js';
+export { urlsToXml, urlsToXmlStream } from './xml.js';

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

@@ -14,30 +14,33 @@ export function resolveSitemapEntries(sitemap, urls, runtimeConfig, resolvers, b
     autoI18n,
     isI18nMapped
   } = runtimeConfig;
-  const filterPath = createPathFilter({
+  const hasFilters = !!sitemap.include?.length || !!sitemap.exclude?.length;
+  const filterPath = hasFilters ? createPathFilter({
     include: sitemap.include,
     exclude: sitemap.exclude
-  }, baseURL || "/");
-  const _urls = urls.map((_e) => {
+  }, baseURL || "/") : void 0;
+  const _urls = [];
+  for (const _e of urls) {
     const e = preNormalizeEntry(_e, resolvers);
-    if (!e.loc || !filterPath(e.loc))
-      return false;
-    return e;
-  }).filter(Boolean);
-  let validI18nUrlsForTransform = [];
+    if (e.loc && (!filterPath || filterPath(e.loc, e._path?.pathname)))
+      _urls.push(e);
+  }
   const withoutPrefixPaths = {};
   if (autoI18n && autoI18n.strategy !== "no_prefix") {
-    const localeCodes = autoI18n.locales.map((l) => l.code);
+    const localeCodes = new Set(autoI18n.locales.map((l) => l.code));
     const localeByCode = new Map(autoI18n.locales.map((l) => [l.code, l]));
     const isPrefixStrategy = autoI18n.strategy === "prefix";
     const isPrefixExceptOrAndDefault = autoI18n.strategy === "prefix_and_default" || autoI18n.strategy === "prefix_except_default";
     const xDefaultAndLocales = [{ code: "x-default", _hreflang: "x-default" }, ...autoI18n.locales];
     const defaultLocale = autoI18n.defaultLocale;
     const hasPages = !!autoI18n.pages;
+    const sortedPageKeys = hasPages ? Object.keys(autoI18n.pages).sort((a, b) => b.length - a.length) : void 0;
     const hasDifferentDomains = !!autoI18n.differentDomains;
-    validI18nUrlsForTransform = _urls.map((_e, i) => {
+    const validI18nUrlsForTransform = [];
+    for (let i = 0; i < _urls.length; i++) {
+      const _e = _urls[i];
       if (_e._abs)
-        return false;
+        continue;
       const split = splitForLocales(_e._relativeLoc, localeCodes);
       let localeCode = split[0];
       const pathWithoutPrefix = split[1];
@@ -47,31 +50,30 @@ export function resolveSitemapEntries(sitemap, urls, runtimeConfig, resolvers, b
       e._pathWithoutPrefix = pathWithoutPrefix;
       const locale = localeByCode.get(localeCode);
       if (!locale)
-        return false;
+        continue;
       e._locale = locale;
       e._index = i;
       e._key = `${e._sitemap || ""}${e._path?.pathname || "/"}${e._path?.search || ""}`;
       withoutPrefixPaths[pathWithoutPrefix] = withoutPrefixPaths[pathWithoutPrefix] || [];
       if (!withoutPrefixPaths[pathWithoutPrefix].some((e2) => e2._locale.code === locale.code))
         withoutPrefixPaths[pathWithoutPrefix].push(e);
-      return e;
-    }).filter(Boolean);
+      validI18nUrlsForTransform.push(e);
+    }
     for (const e of validI18nUrlsForTransform) {
       if (!e._i18nTransform && !e.alternatives?.length) {
-        const alternatives = (withoutPrefixPaths[e._pathWithoutPrefix] || []).map((u) => {
-          const entries = [];
+        const alternatives = [];
+        for (const u of withoutPrefixPaths[e._pathWithoutPrefix] || []) {
           if (u._locale.code === defaultLocale) {
-            entries.push({
+            alternatives.push({
               href: u.loc,
               hreflang: "x-default"
             });
           }
-          entries.push({
+          alternatives.push({
             href: u.loc,
             hreflang: u._locale._hreflang || defaultLocale
           });
-          return entries;
-        }).flat().filter(Boolean);
+        }
         if (alternatives.length)
           e.alternatives = alternatives;
       } else if (e._i18nTransform) {
@@ -91,7 +93,7 @@ export function resolveSitemapEntries(sitemap, urls, runtimeConfig, resolvers, b
             };
           });
         } else {
-          const pageMatch = hasPages ? findPageMapping(e._pathWithoutPrefix, autoI18n.pages) : null;
+          const pageMatch = hasPages ? findPageMapping(e._pathWithoutPrefix, autoI18n.pages, sortedPageKeys) : null;
           const pathSearch = e._path?.search || "";
           const pathWithoutPrefix = e._pathWithoutPrefix;
           for (const l of autoI18n.locales) {
@@ -130,7 +132,7 @@ export function resolveSitemapEntries(sitemap, urls, runtimeConfig, resolvers, b
               } else if (isPrefixExceptOrAndDefault && !isDefault) {
                 href = joinURL("/", code, pathWithoutPrefix);
               }
-              if (!filterPath(href))
+              if (filterPath && !filterPath(href))
                 continue;
               alternatives.push({
                 hreflang: locale._hreflang,
@@ -192,9 +194,17 @@ export async function buildResolvedSitemapUrls(effectiveSitemap, matchName, isCh
   const localeSitemapKeys = isI18nMapped && autoI18n ? autoI18n.locales.map((l) => l._sitemap) : [];
   if (isMultiSitemap) {
     const sitemapNames = Object.keys(sitemaps).filter((k) => k !== "index");
+    const validSitemapNames = new Set(sitemapNames);
+    if (isI18nMapped) {
+      for (const name of sitemapNames) {
+        const localeKey = resolveI18nSitemapLocaleKey(name, localeSitemapKeys);
+        if (localeKey)
+          validSitemapNames.add(localeKey);
+      }
+    }
     const warnedSitemaps = nitro?._sitemapWarnedSitemaps || /* @__PURE__ */ new Set();
     for (const e of enhancedUrls) {
-      const hasMatchingSitemap = typeof e._sitemap === "string" && (sitemapNames.includes(e._sitemap) || isI18nMapped && sitemapNames.some((name) => resolveI18nSitemapLocaleKey(name, localeSitemapKeys) === e._sitemap));
+      const hasMatchingSitemap = typeof e._sitemap === "string" && validSitemapNames.has(e._sitemap);
       if (typeof e._sitemap === "string" && !hasMatchingSitemap) {
         if (!warnedSitemaps.has(e._sitemap)) {
           warnedSitemaps.add(e._sitemap);
@@ -206,6 +216,7 @@ export async function buildResolvedSitemapUrls(effectiveSitemap, matchName, isCh
       nitro._sitemapWarnedSitemaps = warnedSitemaps;
     }
   }
+  const matchedLocaleSitemap = isI18nMapped ? resolveI18nSitemapLocaleKey(matchName, localeSitemapKeys) : null;
   const filteredUrls = enhancedUrls.filter((e) => {
     if (e._sitemap === false)
       return false;
@@ -215,7 +226,7 @@ export async function buildResolvedSitemapUrls(effectiveSitemap, matchName, isCh
       if (e._sitemap === matchName)
         return true;
       if (isI18nMapped)
-        return e._sitemap === resolveI18nSitemapLocaleKey(matchName, localeSitemapKeys);
+        return e._sitemap === matchedLocaleSitemap;
       return false;
     }
     return true;
@@ -273,4 +284,4 @@ export async function buildSitemapUrls(sitemap, resolvers, runtimeConfig, nitro)
   const urls = sliceUrlsForChunk(resolved.urls, sitemap.sitemapName, sitemaps, chunkSize);
   return { urls, failedSources: resolved.failedSources };
 }
-export { urlsToXml } from "./xml.js";
+export { urlsToXml, urlsToXmlStream } from "./xml.js";

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

@@ -1,6 +1,14 @@
 import type { ModuleRuntimeConfig, NitroUrlResolvers, ResolvedSitemapUrl } from '../../../types.js';
 export declare function escapeValueForXml(value: boolean | string | number): string;
+export declare function renderSitemapXmlChunks(urls: ResolvedSitemapUrl[], resolvers: NitroUrlResolvers, { version, xsl, credits, minify }: Pick<ModuleRuntimeConfig, 'version' | 'xsl' | 'credits' | 'minify'>, errorInfo?: {
+    messages: string[];
+    urls: string[];
+}): Generator<string>;
 export declare function urlsToXml(urls: ResolvedSitemapUrl[], resolvers: NitroUrlResolvers, { version, xsl, credits, minify }: Pick<ModuleRuntimeConfig, 'version' | 'xsl' | 'credits' | 'minify'>, errorInfo?: {
     messages: string[];
     urls: string[];
 }): string;
+export declare function urlsToXmlStream(urls: ResolvedSitemapUrl[], resolvers: NitroUrlResolvers, config: Pick<ModuleRuntimeConfig, 'version' | 'xsl' | 'credits' | 'minify'>, errorInfo?: {
+    messages: string[];
+    urls: string[];
+}): ReadableStream<Uint8Array>;

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

@@ -1,5 +1,6 @@
 import { withQuery } from "ufo";
-import { xmlEscape } from "../../utils.js";
+import { xmlEscape } from "../../../utils-pure.js";
+import { createChunkedXmlStream } from "../stream.js";
 export function escapeValueForXml(value) {
   if (value === true || value === false)
     return value ? "yes" : "no";
@@ -24,7 +25,10 @@ function buildUrlXml(url, NL, I1, I2, I3, I4) {
   if (url.alternatives) {
     for (const alt of url.alternatives) {
       let attrs = "";
-      for (const [k, v] of Object.entries(alt)) attrs += ` ${k}="${xmlEscape(String(v))}"`;
+      for (const k in alt) {
+        if (Object.hasOwn(alt, k))
+          attrs += ` ${k}="${xmlEscape(String(alt[k]))}"`;
+      }
       xml += `${I2}<xhtml:link rel="alternate"${attrs} />${NL}`;
     }
   }
@@ -112,6 +116,30 @@ function buildUrlXml(url, NL, I1, I2, I3, I4) {
   xml += `${I1}</url>`;
   return xml;
 }
+export function* renderSitemapXmlChunks(urls, resolvers, { version, xsl, credits, minify }, errorInfo) {
+  let xslHref = xsl ? resolvers.relativeBaseUrlResolver(xsl) : false;
+  if (xslHref && errorInfo?.messages.length) {
+    xslHref = withQuery(xslHref, {
+      errors: "true",
+      error_messages: errorInfo.messages,
+      error_urls: errorInfo.urls
+    });
+  }
+  const NL = minify ? "" : "\n";
+  const I1 = minify ? "" : "    ";
+  const I2 = minify ? "" : "        ";
+  const I3 = minify ? "" : "            ";
+  const I4 = minify ? "" : "                ";
+  yield xslHref ? `<?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet type="text/xsl" href="${escapeValueForXml(xslHref)}"?>${NL}` : `<?xml version="1.0" encoding="UTF-8"?>${NL}`;
+  yield URLSET_OPENING_TAG + NL;
+  for (const url of urls) {
+    yield buildUrlXml(url, NL, I1, I2, I3, I4) + NL;
+  }
+  yield "</urlset>";
+  if (credits) {
+    yield `${NL}<!-- XML Sitemap generated by @nuxtjs/sitemap v${version} at ${(/* @__PURE__ */ new Date()).toISOString()} -->`;
+  }
+}
 export function urlsToXml(urls, resolvers, { version, xsl, credits, minify }, errorInfo) {
   let xslHref = xsl ? resolvers.relativeBaseUrlResolver(xsl) : false;
   if (xslHref && errorInfo?.messages.length) {
@@ -128,12 +156,13 @@ export function urlsToXml(urls, resolvers, { version, xsl, credits, minify }, er
   const I4 = minify ? "" : "                ";
   let xml = xslHref ? `<?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet type="text/xsl" href="${escapeValueForXml(xslHref)}"?>${NL}` : `<?xml version="1.0" encoding="UTF-8"?>${NL}`;
   xml += URLSET_OPENING_TAG + NL;
-  for (const url of urls) {
+  for (const url of urls)
     xml += buildUrlXml(url, NL, I1, I2, I3, I4) + NL;
-  }
   xml += "</urlset>";
-  if (credits) {
+  if (credits)
     xml += `${NL}<!-- XML Sitemap generated by @nuxtjs/sitemap v${version} at ${(/* @__PURE__ */ new Date()).toISOString()} -->`;
-  }
   return xml;
 }
+export function urlsToXmlStream(urls, resolvers, config, errorInfo) {
+  return createChunkedXmlStream(renderSitemapXmlChunks(urls, resolvers, config, errorInfo));
+}

package/dist/runtime/server/sitemap/event-handlers.d.ts

@@ -1,4 +1,4 @@
 import type { H3Event } from 'h3';
-export declare function sitemapXmlEventHandler(e: H3Event): Promise<string | void>;
-export declare function sitemapIndexXmlEventHandler(e: H3Event): Promise<string>;
-export declare function sitemapChildXmlEventHandler(e: H3Event): Promise<string | undefined>;
+export declare function sitemapXmlEventHandler(e: H3Event): Promise<string | void | ReadableStream<Uint8Array<ArrayBufferLike>>>;
+export declare function sitemapIndexXmlEventHandler(e: H3Event): Promise<string | ReadableStream<Uint8Array<ArrayBufferLike>>>;
+export declare function sitemapChildXmlEventHandler(e: H3Event): Promise<string | ReadableStream<Uint8Array<ArrayBufferLike>> | undefined>;