@nuxtjs/sitemap 8.2.2 → 8.3.0

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>;

package/dist/runtime/server/sitemap/event-handlers.js

@@ -1,9 +1,10 @@
-import { appendHeader, createError, getRouterParam, sendRedirect, setHeader } from "h3";
+import { appendHeader, createError, getRequestURL, getRouterParam, sendRedirect, setHeader } from "h3";
 import { useNitroApp, useRuntimeConfig } from "nitropack/runtime";
 import { joinURL, withBase, withLeadingSlash, withoutLeadingSlash, withoutTrailingSlash } from "ufo";
 import { useSitemapRuntimeConfig } from "../utils.js";
-import { buildSitemapIndex, urlsToIndexXml } from "./builder/sitemap-index.js";
-import { createSitemap, useNitroUrlResolvers } from "./nitro.js";
+import { urlsToIndexXml, urlsToIndexXmlStream } from "./builder/index-xml.js";
+import { buildSitemapIndex } from "./builder/sitemap-index.js";
+import { createSitemap, renderSitemapOutput, useNitroUrlResolvers } from "./nitro.js";
 import { getSitemapConfig, parseChunkInfo } from "./utils/chunk.js";
 export async function sitemapXmlEventHandler(e) {
   const runtimeConfig = useSitemapRuntimeConfig();
@@ -27,9 +28,15 @@ export async function sitemapIndexXmlEventHandler(e) {
   const indexResolvedCtx = { sitemaps, event: e };
   await nitro.hooks.callHook("sitemap:index-resolved", indexResolvedCtx);
   const errorInfo = failedSources.length > 0 ? { messages: failedSources.map((f) => f.error), urls: failedSources.map((f) => f.url) } : void 0;
-  const output = urlsToIndexXml(indexResolvedCtx.sitemaps, resolvers, runtimeConfig, errorInfo);
-  const ctx = { sitemap: output, sitemapName: "sitemap", event: e };
-  await nitro.hooks.callHook("sitemap:output", ctx);
+  const output = await renderSitemapOutput(
+    nitro,
+    e,
+    "sitemap",
+    () => urlsToIndexXml(indexResolvedCtx.sitemaps, resolvers, runtimeConfig, errorInfo),
+    () => urlsToIndexXmlStream(indexResolvedCtx.sitemaps, resolvers, runtimeConfig, errorInfo),
+    !!runtimeConfig.experimentalStreaming && !import.meta.prerender,
+    runtimeConfig.debug
+  );
   setHeader(e, "Content-Type", "text/xml; charset=UTF-8");
   if (runtimeConfig.cacheMaxAgeSeconds) {
     setHeader(e, "Cache-Control", `public, max-age=${runtimeConfig.cacheMaxAgeSeconds}, s-maxage=${runtimeConfig.cacheMaxAgeSeconds}, stale-while-revalidate=3600`);
@@ -43,17 +50,18 @@ export async function sitemapIndexXmlEventHandler(e) {
   } else {
     setHeader(e, "Cache-Control", `no-cache, no-store`);
   }
-  return ctx.sitemap;
+  e.context._isSitemap = true;
+  return output;
 }
 export async function sitemapChildXmlEventHandler(e) {
-  if (!e.path.endsWith(".xml"))
+  const pathname = getRequestURL(e).pathname;
+  if (!pathname.endsWith(".xml"))
     return;
   const runtimeConfig = useSitemapRuntimeConfig(e);
   const { sitemaps } = runtimeConfig;
   let sitemapName = getRouterParam(e, "sitemap");
   if (!sitemapName) {
-    const path = e.path;
-    const match = path.match(/(?:\/__sitemap__\/)?(.+)\.xml$/);
+    const match = pathname.match(/(?:\/__sitemap__\/)?(.+)\.xml$/);
     if (match)
       sitemapName = match[1];
   }

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

@@ -1,4 +1,6 @@
 import type { H3Event } from 'h3';
+import type { NitroApp } from 'nitropack/types';
 import type { ModuleRuntimeConfig, NitroUrlResolvers, SitemapDefinition } from '../../types.js';
 export declare function useNitroUrlResolvers(e: H3Event): NitroUrlResolvers;
-export declare function createSitemap(event: H3Event, definition: SitemapDefinition, runtimeConfig: ModuleRuntimeConfig): Promise<string>;
+export declare function renderSitemapOutput(nitro: NitroApp, event: H3Event, sitemapName: string, renderString: () => string, renderStream: () => ReadableStream<Uint8Array>, shouldStream: boolean, debug: boolean): Promise<string | ReadableStream<Uint8Array>>;
+export declare function createSitemap(event: H3Event, definition: SitemapDefinition, runtimeConfig: ModuleRuntimeConfig): Promise<string | ReadableStream<Uint8Array<ArrayBufferLike>>>;

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

@@ -8,7 +8,8 @@ import { createSitePathResolver } from "#site-config/server/composables/utils";
 import staticConfig from "#sitemap-virtual/static-config.mjs";
 import { logger, mergeOnKey, splitForLocales } from "../../utils-pure.js";
 import { createNitroRouteRuleMatcher } from "../kit.js";
-import { buildSitemapUrls, urlsToXml } from "./builder/sitemap.js";
+import { buildSitemapUrls, urlsToXml, urlsToXmlStream } from "./builder/sitemap.js";
+import { createChunkedXmlStream } from "./stream.js";
 import { normaliseEntry, preNormalizeEntry } from "./urlset/normalise.js";
 import { sortInPlace } from "./urlset/sort.js";
 const SERVER_CACHE_MAX_AGE = staticConfig.cacheMaxAgeSeconds || 60 * 10;
@@ -28,7 +29,7 @@ export function useNitroUrlResolvers(e) {
     relativeBaseUrlResolver: createSitePathResolver(e, { absolute: false, withBase: true })
   };
 }
-async function buildSitemapXml(event, definition, resolvers, runtimeConfig) {
+async function buildSitemapRenderPlan(event, definition, resolvers, runtimeConfig) {
   const { sitemapName } = definition;
   const nitro = useNitroApp();
   if (import.meta.prerender) {
@@ -43,7 +44,8 @@ async function buildSitemapXml(event, definition, resolvers, runtimeConfig) {
       });
     }
   }
-  const { urls: sitemapUrls, failedSources } = await buildSitemapUrls(definition, resolvers, runtimeConfig, nitro);
+  const { urls: resolvedSitemapUrls, failedSources } = await buildSitemapUrls(definition, resolvers, runtimeConfig, nitro);
+  const sitemapUrls = resolvedSitemapUrls.slice();
   if (import.meta.prerender && failedSources.length) {
     throw createError({
       statusCode: 500,
@@ -52,6 +54,8 @@ async function buildSitemapXml(event, definition, resolvers, runtimeConfig) {
   }
   const routeRuleMatcher = createNitroRouteRuleMatcher();
   const { autoI18n } = runtimeConfig;
+  const localeCodes = autoI18n?.locales && autoI18n.strategy !== "no_prefix" ? new Set(autoI18n.locales.map((l) => l.code)) : void 0;
+  const sourceCount = sitemapUrls.length;
   let validCount = 0;
   for (let i = 0; i < sitemapUrls.length; i++) {
     const u = sitemapUrls[i];
@@ -59,8 +63,8 @@ async function buildSitemapXml(event, definition, resolvers, runtimeConfig) {
     if (!getPathRobotConfig(event, { path, skipSiteIndexable: true }).indexable)
       continue;
     let routeRules = routeRuleMatcher(path);
-    if (autoI18n?.locales && autoI18n?.strategy !== "no_prefix") {
-      const match = splitForLocales(path, autoI18n.locales.map((l) => l.code));
+    if (localeCodes) {
+      const match = splitForLocales(path, localeCodes);
       const pathWithoutPrefix = match[1];
       if (pathWithoutPrefix && pathWithoutPrefix !== path)
         routeRules = defu(routeRules, routeRuleMatcher(pathWithoutPrefix));
@@ -69,14 +73,23 @@ async function buildSitemapXml(event, definition, resolvers, runtimeConfig) {
       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"));
+    let hasRobotsDisabled = false;
+    const headers = routeRules.headers;
+    if (headers) {
+      for (const name in headers) {
+        if (name.toLowerCase() === "x-robots-tag" && headers[name].toLowerCase().includes("noindex")) {
+          hasRobotsDisabled = true;
+          break;
+        }
+      }
+    }
     if (routeRules.redirect || hasRobotsDisabled)
       continue;
     sitemapUrls[validCount++] = routeRules.sitemap ? defu(u, routeRules.sitemap) : u;
   }
   sitemapUrls.length = validCount;
-  if (import.meta.dev && validCount === 0 && sitemapUrls.length > 0) {
-    logger.warn(`Sitemap had ${sitemapUrls.length} that were all filtered out. This may be due to a robots rules blocking these URLs from indexing. Check your /** route rules or robots.txt configuration.`);
+  if (import.meta.dev && validCount === 0 && sourceCount > 0) {
+    logger.warn(`Sitemap had ${sourceCount} URLs that were all filtered out. This may be due to a robots rules blocking these URLs from indexing. Check your /** route rules or robots.txt configuration.`);
   }
   const locSize = sitemapUrls.length;
   const resolvedCtx = {
@@ -86,12 +99,28 @@ async function buildSitemapXml(event, definition, resolvers, runtimeConfig) {
   };
   await nitro.hooks.callHook("sitemap:resolved", resolvedCtx);
   if (resolvedCtx.urls.length !== locSize) {
-    resolvedCtx.urls = resolvedCtx.urls.map((e) => preNormalizeEntry(e, resolvers));
+    for (let i = 0; i < resolvedCtx.urls.length; i++)
+      resolvedCtx.urls[i] = preNormalizeEntry(resolvedCtx.urls[i], resolvers);
   }
   const maybeSort = (urls2) => runtimeConfig.sortEntries ? sortInPlace(urls2) : urls2;
-  const defaults = definition.defaults || {};
-  const normalizedPreDedupe = resolvedCtx.urls.map((e) => normaliseEntry(e, defaults, resolvers));
-  const urls = maybeSort(mergeOnKey(normalizedPreDedupe, "_key").map((e) => normaliseEntry(e, defaults, resolvers)));
+  const defaults = definition.defaults;
+  const normalizedPreDedupe = resolvedCtx.urls;
+  const firstLastmod = normalizedPreDedupe[0]?.lastmod ?? defaults?.lastmod;
+  let cacheLastmod = normalizedPreDedupe.length > 1 && !!firstLastmod;
+  for (let i = 1; cacheLastmod && i < Math.min(normalizedPreDedupe.length, 8); i++)
+    cacheLastmod = (normalizedPreDedupe[i].lastmod ?? defaults?.lastmod) === firstLastmod;
+  const normaliseCache = cacheLastmod ? {} : void 0;
+  for (let i = 0; i < normalizedPreDedupe.length; i++)
+    normalizedPreDedupe[i] = normaliseEntry(normalizedPreDedupe[i], defaults, resolvers, normaliseCache);
+  const duplicateKeys = /* @__PURE__ */ new Set();
+  const urls = mergeOnKey(normalizedPreDedupe, "_key", (key) => duplicateKeys.add(key));
+  if (duplicateKeys.size) {
+    for (let i = 0; i < urls.length; i++) {
+      if (duplicateKeys.has(urls[i]._key))
+        urls[i] = normaliseEntry(urls[i], defaults, resolvers, normaliseCache);
+    }
+  }
+  maybeSort(urls);
   if (definition._isChunking && definition.sitemapName.includes("-")) {
     const parts = definition.sitemapName.split("-");
     const lastPart = parts.pop();
@@ -110,11 +139,59 @@ async function buildSitemapXml(event, definition, resolvers, runtimeConfig) {
     messages: failedSources.map((f) => f.error),
     urls: failedSources.map((f) => f.url)
   } : void 0;
+  return { errorInfo, sitemapName, urls };
+}
+export async function renderSitemapOutput(nitro, event, sitemapName, renderString, renderStream, shouldStream, debug) {
+  if (!shouldStream) {
+    const ctx2 = { sitemap: renderString(), sitemapName, event };
+    await nitro.hooks.callHook("sitemap:output", ctx2);
+    return ctx2.sitemap;
+  }
+  let buffered = false;
+  let sitemap;
+  const ctx = { sitemapName, event };
+  Object.defineProperty(ctx, "sitemap", {
+    configurable: true,
+    enumerable: true,
+    get() {
+      buffered = true;
+      sitemap ??= renderString();
+      return sitemap;
+    },
+    set(value) {
+      buffered = true;
+      sitemap = value;
+    }
+  });
+  await nitro.hooks.callHook("sitemap:output", ctx);
+  if (debug)
+    setHeader(event, "X-Sitemap-Render-Mode", buffered ? "buffered-hook" : "stream");
+  return buffered ? createChunkedXmlStream([sitemap]) : renderStream();
+}
+async function buildSitemapXml(event, definition, resolvers, runtimeConfig) {
+  const { errorInfo, sitemapName, urls } = await buildSitemapRenderPlan(event, definition, resolvers, runtimeConfig);
   const sitemap = urlsToXml(urls, resolvers, runtimeConfig, errorInfo);
   const ctx = { sitemap, sitemapName, event };
-  await nitro.hooks.callHook("sitemap:output", ctx);
+  await useNitroApp().hooks.callHook("sitemap:output", ctx);
   return ctx.sitemap;
 }
+function getSitemapCacheKey(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}`;
+}
+const buildSitemapRenderPlanCached = defineCachedFunction(
+  buildSitemapRenderPlan,
+  {
+    name: "sitemap:render-plan",
+    group: "sitemap",
+    maxAge: SERVER_CACHE_MAX_AGE,
+    base: "sitemap",
+    getKey: getSitemapCacheKey,
+    swr: true
+  }
+);
 const buildSitemapXmlCached = defineCachedFunction(
   buildSitemapXml,
   {
@@ -123,20 +200,30 @@ const buildSitemapXmlCached = defineCachedFunction(
     maxAge: SERVER_CACHE_MAX_AGE,
     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}`;
-    },
+    getKey: getSitemapCacheKey,
     swr: true
     // Enable stale-while-revalidate
   }
 );
 export async function createSitemap(event, definition, runtimeConfig) {
   const resolvers = useNitroUrlResolvers(event);
+  const shouldStream = !!runtimeConfig.experimentalStreaming && !import.meta.prerender;
   const shouldCache = !import.meta.dev && !import.meta.prerender && typeof runtimeConfig.cacheMaxAgeSeconds === "number" && runtimeConfig.cacheMaxAgeSeconds > 0;
-  const xml = shouldCache ? await buildSitemapXmlCached(event, definition, resolvers, runtimeConfig) : await buildSitemapXml(event, definition, resolvers, runtimeConfig);
+  let xml;
+  if (shouldStream) {
+    const { errorInfo, sitemapName, urls } = shouldCache ? await buildSitemapRenderPlanCached(event, definition, resolvers, runtimeConfig) : await buildSitemapRenderPlan(event, definition, resolvers, runtimeConfig);
+    xml = await renderSitemapOutput(
+      useNitroApp(),
+      event,
+      sitemapName,
+      () => urlsToXml(urls, resolvers, runtimeConfig, errorInfo),
+      () => urlsToXmlStream(urls, resolvers, runtimeConfig, errorInfo),
+      true,
+      runtimeConfig.debug
+    );
+  } else {
+    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}, s-maxage=${runtimeConfig.cacheMaxAgeSeconds}, stale-while-revalidate=3600`);

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

@@ -0,0 +1,30 @@
+export declare const DEFAULT_XML_STREAM_CHUNK_SIZE: number;
+export type SitemapCompressionEncoding = 'gzip' | 'deflate';
+interface NodeResponseWritable {
+    once: (event: 'drain', listener: () => void) => unknown;
+    write: (chunk: Uint8Array) => boolean;
+}
+export interface NodeResponseStream {
+    abort: (reason?: unknown) => void;
+    on: {
+        (event: 'end', listener: () => void): NodeResponseStream;
+        (event: 'error', listener: (error: unknown) => void): NodeResponseStream;
+    };
+    pipe: (destination: NodeResponseWritable) => NodeResponseWritable;
+}
+export declare function isReadableStream(value: unknown): value is ReadableStream<Uint8Array>;
+export declare function hasNonIdentityEncoding(value: unknown): boolean;
+/**
+ * Adapt a Web stream to the small Node stream surface H3 consumes. H3 v1 writes
+ * Web streams without waiting for `drain`; this adapter keeps production Node
+ * responses pull-driven and forwards disconnects to the Web stream's `cancel()`.
+ */
+export declare function createNodeResponseStream(source: ReadableStream<Uint8Array>, onCancelError: (error: unknown) => void): NodeResponseStream;
+/**
+ * Convert synchronous XML fragments into a pull-driven byte stream. Fragments are
+ * batched so large sitemaps do not enqueue one tiny chunk per URL.
+ */
+export declare function createChunkedXmlStream(chunks: Iterable<string>, targetChunkSize?: number): ReadableStream<Uint8Array>;
+/** Select the best compression format supported by CompressionStream. */
+export declare function negotiateCompressionEncoding(acceptEncoding: string): SitemapCompressionEncoding | null;
+export {};

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

@@ -0,0 +1,144 @@
+export const DEFAULT_XML_STREAM_CHUNK_SIZE = 64 * 1024;
+export function isReadableStream(value) {
+  return !!value && typeof value === "object" && typeof value.getReader === "function";
+}
+export function hasNonIdentityEncoding(value) {
+  return (Array.isArray(value) ? value : [value]).flatMap((encoding) => String(encoding || "").split(",")).some((encoding) => encoding.trim().toLowerCase() !== "identity" && encoding.trim() !== "");
+}
+export function createNodeResponseStream(source, onCancelError) {
+  const reader = source.getReader();
+  const endListeners = /* @__PURE__ */ new Set();
+  const errorListeners = /* @__PURE__ */ new Set();
+  let aborted = false;
+  let pumping = false;
+  let releaseBackpressure;
+  const stream = {
+    abort(reason) {
+      if (aborted)
+        return;
+      aborted = true;
+      releaseBackpressure?.();
+      releaseBackpressure = void 0;
+      void reader.cancel(reason).catch(onCancelError);
+    },
+    on(event, listener) {
+      if (event === "end")
+        endListeners.add(listener);
+      else
+        errorListeners.add(listener);
+      return stream;
+    },
+    pipe(destination) {
+      if (pumping)
+        return destination;
+      pumping = true;
+      void (async () => {
+        try {
+          while (true) {
+            if (aborted)
+              break;
+            const result = await reader.read();
+            if (result.done)
+              break;
+            if (!destination.write(result.value)) {
+              await new Promise((resolve) => {
+                releaseBackpressure = resolve;
+                destination.once("drain", resolve);
+              });
+              releaseBackpressure = void 0;
+            }
+          }
+          if (!aborted) {
+            for (const listener of endListeners)
+              listener();
+          }
+        } catch (error) {
+          if (!aborted) {
+            for (const listener of errorListeners)
+              listener(error);
+          }
+        }
+      })();
+      return destination;
+    }
+  };
+  return stream;
+}
+export function createChunkedXmlStream(chunks, targetChunkSize = DEFAULT_XML_STREAM_CHUNK_SIZE) {
+  const iterator = chunks[Symbol.iterator]();
+  const encoder = new TextEncoder();
+  const chunkSize = Math.max(1, Math.floor(targetChunkSize));
+  let complete = false;
+  let pending;
+  let pendingOffset = 0;
+  return new ReadableStream({
+    pull(controller) {
+      if (complete)
+        return;
+      let output = "";
+      while (output.length < chunkSize) {
+        if (!pending) {
+          const next = iterator.next();
+          if (next.done) {
+            complete = true;
+            break;
+          }
+          pending = next.value;
+          pendingOffset = 0;
+          if (!pending)
+            continue;
+        }
+        const remaining = chunkSize - output.length;
+        let end = Math.min(pending.length, pendingOffset + remaining);
+        if (end < pending.length && end > pendingOffset && pending.charCodeAt(end - 1) >= 55296 && pending.charCodeAt(end - 1) <= 56319) {
+          end--;
+          if (end === pendingOffset) {
+            if (output)
+              break;
+            end = Math.min(pending.length, pendingOffset + 2);
+          }
+        }
+        output += pending.slice(pendingOffset, end);
+        pendingOffset = end;
+        if (pendingOffset === pending.length)
+          pending = void 0;
+      }
+      if (output)
+        controller.enqueue(encoder.encode(output));
+      if (complete)
+        controller.close();
+    },
+    cancel() {
+      complete = true;
+      iterator.return?.();
+    }
+  });
+}
+export function negotiateCompressionEncoding(acceptEncoding) {
+  if (!acceptEncoding.trim())
+    return null;
+  const explicit = /* @__PURE__ */ new Map();
+  let wildcard;
+  for (const value of acceptEncoding.split(",")) {
+    const [rawEncoding, ...parameters] = value.trim().toLowerCase().split(";");
+    if (!rawEncoding)
+      continue;
+    let quality = 1;
+    for (const parameter of parameters) {
+      const [key, rawValue] = parameter.trim().split("=");
+      if (key === "q") {
+        const parsed = Number.parseFloat(rawValue || "");
+        quality = Number.isFinite(parsed) && parsed >= 0 && parsed <= 1 ? parsed : 0;
+      }
+    }
+    if (rawEncoding === "*")
+      wildcard = quality;
+    else
+      explicit.set(rawEncoding, quality);
+  }
+  const gzipQuality = explicit.get("gzip") ?? wildcard ?? 0;
+  const deflateQuality = explicit.get("deflate") ?? wildcard ?? 0;
+  if (gzipQuality <= 0 && deflateQuality <= 0)
+    return null;
+  return gzipQuality >= deflateQuality ? "gzip" : "deflate";
+}

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

@@ -2,6 +2,11 @@ import type { NitroUrlResolvers, ResolvedSitemapUrl, SitemapUrl, SitemapUrlInput
 export declare function validateSitemapUrl(url: SitemapUrlInput): string[];
 export declare function preNormalizeEntry(_e: SitemapUrl | string, resolvers?: NitroUrlResolvers): ResolvedSitemapUrl;
 export declare function isEncoded(url: string): boolean;
-export declare function normaliseEntry(_e: ResolvedSitemapUrl, defaults: Omit<SitemapUrl, 'loc'>, resolvers?: NitroUrlResolvers): ResolvedSitemapUrl;
+interface NormaliseCache {
+    lastmodInput?: string | Date;
+    lastmodOutput?: string | false;
+}
+export declare function normaliseEntry(_e: ResolvedSitemapUrl, defaults?: Omit<SitemapUrl, 'loc'>, resolvers?: NitroUrlResolvers, cache?: NormaliseCache): ResolvedSitemapUrl;
 export declare function isValidW3CDate(d: string): boolean;
 export declare function normaliseDate(date: string | Date): string;
+export {};

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

@@ -40,7 +40,14 @@ function resolve(s, resolvers) {
   return resolvers.canonicalUrlResolver(str);
 }
 function removeTrailingSlash(s) {
-  return s.replace(/\/(\?|#|$)/, "$1");
+  let pathEnd = s.length;
+  const queryIndex = s.indexOf("?");
+  if (queryIndex !== -1)
+    pathEnd = queryIndex;
+  const hashIndex = s.indexOf("#");
+  if (hashIndex !== -1 && hashIndex < pathEnd)
+    pathEnd = hashIndex;
+  return pathEnd > 0 && s.charCodeAt(pathEnd - 1) === 47 ? s.slice(0, pathEnd - 1) + s.slice(pathEnd) : s;
 }
 export function preNormalizeEntry(_e, resolvers) {
   const input = typeof _e === "string" ? { loc: _e } : { ..._e };
@@ -86,15 +93,19 @@ export function isEncoded(url) {
     return false;
   }
 }
-export function normaliseEntry(_e, defaults, resolvers) {
-  const e = defu(_e, defaults);
+export function normaliseEntry(_e, defaults, resolvers, cache) {
+  const e = defaults ? defu(_e, defaults) : { ..._e };
   if (import.meta.dev) {
     const warnings = validateSitemapUrl(e);
     if (warnings.length)
       e._warnings = (e._warnings || []).concat(warnings);
   }
   if (e.lastmod) {
-    const date = normaliseDate(e.lastmod);
+    const date = cache?.lastmodInput === e.lastmod ? cache.lastmodOutput : normaliseDate(e.lastmod);
+    if (cache && cache.lastmodInput !== e.lastmod) {
+      cache.lastmodInput = e.lastmod;
+      cache.lastmodOutput = date;
+    }
     if (date)
       e.lastmod = date;
     else

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

@@ -1,13 +1,22 @@
+const naturalCompare = new Intl.Collator(void 0, { numeric: true }).compare;
+function countPathSegments(loc) {
+  let segments = 1;
+  for (let i = 0; i < loc.length; i++) {
+    if (loc.charCodeAt(i) === 47)
+      segments++;
+  }
+  return segments;
+}
 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;
+    const aSegments = countPathSegments(aLoc);
+    const bSegments = countPathSegments(bLoc);
     if (aSegments !== bSegments) {
       return aSegments - bSegments;
     }
-    return aLoc.localeCompare(bLoc, void 0, { numeric: true });
+    return naturalCompare(aLoc, bLoc);
   });
   return urls;
 }

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

@@ -86,7 +86,7 @@ export async function fetchDataSource(input, event) {
     let urls = [];
     if (typeof res === "object") {
       urls = res.urls || res;
-    } else if (typeof res === "string" && parseURL(url).pathname.endsWith(".xml")) {
+    } else if (typeof res === "string" && isXmlRequest) {
       const result = await parseSitemapXml(res);
       urls = result.urls;
     }
@@ -150,7 +150,7 @@ export async function childSitemapSources(definition) {
   return [...m.sources[definition.sitemapName] || []];
 }
 export async function resolveSitemapSources(sources, event) {
-  return (await Promise.all(
+  return await Promise.all(
     sources.map((source) => {
       const normalized = normalizeSourceInput(source);
       if ("urls" in normalized) {
@@ -167,5 +167,5 @@ export async function resolveSitemapSources(sources, event) {
         error: "Invalid source"
       };
     })
-  )).flat();
+  );
 }

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

@@ -1,5 +1,4 @@
 import type { H3Event } from 'h3';
 import type { ModuleRuntimeConfig } from '../types.js';
 export * from '../utils-pure.js';
-export declare function xmlEscape(str: string | number | boolean | Date): string;
 export declare function useSitemapRuntimeConfig(e?: H3Event): ModuleRuntimeConfig;

package/dist/runtime/server/utils.js

@@ -2,17 +2,17 @@ import { useRuntimeConfig } from "nitropack/runtime";
 import staticConfig from "#sitemap-virtual/static-config.mjs";
 import { normalizeRuntimeFilters } from "../utils-pure.js";
 export * from "../utils-pure.js";
-export function xmlEscape(str) {
-  return String(str).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
-}
 export function useSitemapRuntimeConfig(e) {
-  const clone = JSON.parse(JSON.stringify(staticConfig));
-  for (const k in clone.sitemaps) {
-    const sitemap = clone.sitemaps[k];
-    sitemap.include = normalizeRuntimeFilters(sitemap.include);
-    sitemap.exclude = normalizeRuntimeFilters(sitemap.exclude);
-    clone.sitemaps[k] = sitemap;
-  }
-  Object.assign(clone, useRuntimeConfig(e).sitemap);
-  return Object.freeze(clone);
+  const sitemaps = Object.fromEntries(
+    Object.entries(staticConfig.sitemaps).map(([name, sitemap]) => [name, {
+      ...sitemap,
+      include: normalizeRuntimeFilters("include" in sitemap ? sitemap.include : void 0),
+      exclude: normalizeRuntimeFilters("exclude" in sitemap ? sitemap.exclude : void 0)
+    }])
+  );
+  return Object.freeze({
+    ...staticConfig,
+    sitemaps,
+    ...useRuntimeConfig(e).sitemap
+  });
 }

package/dist/runtime/types.d.ts

@@ -148,11 +148,22 @@ export interface ModuleOptions extends SitemapDefinition {
      */
     experimentalWarmUp?: boolean;
     /**
-     * Send the Sitemap as a compressed stream supporting gzip, brolti, etc.
+     * Compress sitemap responses with gzip or deflate when supported by the client.
      *
-     * @experimental Will be enabled by default in v5 (if stable)
+     * @experimental This option may change in a future release.
      */
     experimentalCompression?: boolean;
+    /**
+     * Serialize dynamic sitemap responses as a pull-driven stream instead of building
+     * the complete XML string in memory first. Prerendered sitemaps remain buffered.
+     *
+     * Accessing `ctx.sitemap` in the `sitemap:output` hook buffers that response for
+     * backwards compatibility.
+     *
+     * @default false
+     * @experimental This option may change in a future release.
+     */
+    experimentalStreaming?: boolean;
     /**
      * When enabled, sitemap generation only runs during prerendering.
      * The sitemap building code is tree-shaken from the runtime bundle.
@@ -227,7 +238,7 @@ export interface AutoI18nConfig {
     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'> {
+export interface ModuleRuntimeConfig extends Pick<ModuleOptions, 'sitemapsPathPrefix' | 'cacheMaxAgeSeconds' | 'sitemapName' | 'excludeAppSources' | 'sortEntries' | 'defaultSitemapsChunkSize' | 'xslColumns' | 'xslTips' | 'debug' | 'discoverImages' | 'discoverVideos' | 'autoLastmod' | 'xsl' | 'credits' | 'minify' | 'experimentalStreaming'> {
     version: string;
     isNuxtContentDocumentDriven: boolean;
     sitemaps: {