@nuxtjs/sitemap 8.2.3 → 8.3.1

package/dist/content.mjs

@@ -7,6 +7,16 @@ if (!globalThis.__sitemapCollectionOnUrlFns)
   globalThis.__sitemapCollectionOnUrlFns = /* @__PURE__ */ new Map();
 const collectionFilters = globalThis.__sitemapCollectionFilters;
 const collectionOnUrlFns = globalThis.__sitemapCollectionOnUrlFns;
+function registerCollectionHooks(options, callerName) {
+  if (!options?.filter && !options?.onUrl)
+    return;
+  if (!options.name)
+    throw new Error(`[sitemap] \`name\` is required when using \`filter\` or \`onUrl\` in ${callerName}()`);
+  if (options.filter)
+    collectionFilters.set(options.name, options.filter);
+  if (options.onUrl)
+    collectionOnUrlFns.set(options.name, options.onUrl);
+}
 const { defineSchema, asCollection, schema } = createContentSchemaFactory({
   fieldName: "sitemap",
   label: "sitemap",
@@ -16,14 +26,7 @@ const { defineSchema, asCollection, schema } = createContentSchemaFactory({
     if ("type" in options || "source" in options)
       throw new Error("[sitemap] `defineSitemapSchema()` returns a schema field, not a collection wrapper. Use it inside your schema: `schema: z.object({ sitemap: defineSitemapSchema() })`. See https://nuxtseo.com/sitemap/guides/content");
     warnIfZodMismatch(options?.z);
-    if (options?.filter || options?.onUrl) {
-      if (!options.name)
-        throw new Error("[sitemap] `name` is required when using `filter` or `onUrl` in defineSitemapSchema()");
-      if (options.filter)
-        collectionFilters.set(options.name, options.filter);
-      if (options.onUrl)
-        collectionOnUrlFns.set(options.name, options.onUrl);
-    }
+    registerCollectionHooks(options, "defineSitemapSchema");
   }
 }, z);
 function asSitemapCollection(collection, options) {

package/dist/devtools/lib/sitemap/state.ts

@@ -35,7 +35,10 @@ export async function refreshProductionData() {
   // Try fetching the full debug endpoint from production first (proxied through local server)
   const remoteDebug = await appFetch.value('/__sitemap__/debug-production.json', {
     query: { url: productionUrl.value, mode: 'debug' },
-  }).catch(() => null) as (typeof data.value & { error?: string }) | null
+  }).catch(() => {
+    // Production debug is optional; use the public sitemap XML fallback below.
+    return null
+  }) as (typeof data.value & { error?: string }) | null
   if (remoteDebug && !remoteDebug.error && remoteDebug.sitemaps && !Array.isArray(remoteDebug.sitemaps)) {
     // Response has object sitemaps (debug.json format) rather than array (XML fallback format)
     productionRemoteDebugData.value = remoteDebug

package/dist/devtools/pages/sitemap/index.vue

@@ -137,7 +137,7 @@ const totalProductionWarnings = computed(() =>
                   target="_blank"
                   class="link-external"
                 >
-                  Learn more
+                  Learn more about large sitemaps
                 </a>
               </DevtoolsAlert>
             </template>
@@ -320,7 +320,7 @@ const totalProductionWarnings = computed(() =>
                 target="_blank"
                 class="link-external"
               >
-                Learn more
+                Learn more about large sitemaps
               </a>
             </DevtoolsAlert>
           </template>

package/dist/module.json

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

package/dist/module.mjs

@@ -1,7 +1,9 @@
-import { useNuxt, hasNuxtModule, addTypeTemplate, addTemplate, defineNuxtModule, createResolver, useLogger, getNuxtModuleVersion, hasNuxtModuleCompatibility, addServerImports, addPrerenderRoutes, addServerPlugin, resolveModule, addServerHandler } from '@nuxt/kit';
+import { useNuxt, hasNuxtModule, addTypeTemplate, addTemplate, defineNuxtModule, createResolver, getNuxtModuleVersion, hasNuxtModuleCompatibility, addServerImports, addPrerenderRoutes, addServerPlugin, resolveModule, addServerHandler } from '@nuxt/kit';
 import { defu } from 'defu';
 import { withSiteUrl, installNuxtSiteConfig } from 'nuxt-site-config/kit';
 import { isPathFile } from 'nuxt-site-config/urls';
+import { isNuxtGenerate, useModuleLogger, getNuxtModuleOptions, resolveNitroPreset, resolveNuxtContentVersion, createPagesPromise, createNitroPromise } from 'nuxtseo-shared/kit';
+import { serializeFilters } from 'nuxtseo-shared/utils';
 import { dirname, extname } from 'pathe';
 import { readPackageJSON } from 'pkg-types';
 import { withBase, withHttps, withTrailingSlash, withoutLeadingSlash, joinURL, withLeadingSlash, withoutTrailingSlash } from 'ufo';
@@ -11,7 +13,6 @@ import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { colors } from 'consola/utils';
 import { splitForLocales, createPathFilter } from '../dist/runtime/utils-pure.js';
-import { isNuxtGenerate, getNuxtModuleOptions, resolveNitroPreset, resolveNuxtContentVersion, createPagesPromise, createNitroPromise } from 'nuxtseo-shared/kit';
 import { p as parseHtmlExtractSitemapMeta } from './shared/sitemap.BoMnWHOt.mjs';
 import { normaliseDate } from '../dist/runtime/server/sitemap/urlset/normalise.js';
 import { splitPathForI18nLocales as splitPathForI18nLocales$1, expandCompactLocaleRoute, normalizeLocales, generatePathForI18nPages } from 'nuxtseo-shared/i18n';
@@ -53,6 +54,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 +105,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 };
@@ -241,6 +243,10 @@ declare module 'nuxt/app' {
 export {}
 `;
     }
+  }, {
+    nitro: true,
+    node: true,
+    nuxt: true
   });
   addTemplate({
     filename: "types/nuxt-sitemap-virtual.d.ts",
@@ -271,25 +277,6 @@ declare module '#sitemap/content-on-url' {
   });
 }
 
-function isValidFilter(filter) {
-  if (typeof filter === "string")
-    return true;
-  if (filter instanceof RegExp)
-    return true;
-  if (typeof filter === "object" && typeof filter.regex === "string")
-    return true;
-  return false;
-}
-function normalizeFilters(filters) {
-  return (filters || []).map((filter) => {
-    if (!isValidFilter(filter)) {
-      console.warn(`[@nuxtjs/sitemap] You have provided an invalid filter: ${filter}, ignoring.`);
-      return false;
-    }
-    return filter instanceof RegExp ? { regex: filter.toString() } : filter;
-  }).filter(Boolean);
-}
-
 function splitPathForI18nLocales(path, autoI18n) {
   if (typeof path !== "string")
     return path;
@@ -461,8 +448,7 @@ function generateExtraRoutesFromNuxtConfig(nuxt = useNuxt()) {
       return false;
     return !v.redirect;
   }).map(([k]) => k).filter(filterForValidPage);
-  const prerenderUrls = (nuxt.options.nitro.prerender?.routes || []).filter(filterForValidPage);
-  return { routeRules, prerenderUrls };
+  return { routeRules };
 }
 
 const module$1 = defineNuxtModule({
@@ -501,6 +487,7 @@ const module$1 = defineNuxtModule({
     // cache for 10 minutes
     minify: false,
     debug: false,
+    experimentalStreaming: false,
     defaultSitemapsChunkSize: 1e3,
     autoLastmod: false,
     discoverImages: true,
@@ -526,8 +513,7 @@ const module$1 = defineNuxtModule({
   async setup(config, nuxt) {
     const { resolve } = createResolver(import.meta.url);
     const { name, version } = await readPackageJSON(resolve("../package.json"));
-    const logger = useLogger(name);
-    logger.level = config.debug || nuxt.options.debug ? 4 : 3;
+    const logger = useModuleLogger(name, config, nuxt);
     if (config.enabled === false) {
       logger.debug("The module is disabled, skipping setup.");
       return;
@@ -767,13 +753,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();
@@ -1042,8 +1030,8 @@ ${onUrlEntries.join("\n")}`;
     }
     for (const sitemapName in sitemaps) {
       const sitemap = sitemaps[sitemapName];
-      sitemap.include = normalizeFilters(sitemap.include);
-      sitemap.exclude = normalizeFilters(sitemap.exclude);
+      sitemap.include = serializeFilters(sitemap.include || [], "@nuxtjs/sitemap");
+      sitemap.exclude = serializeFilters(sitemap.exclude || [], "@nuxtjs/sitemap");
     }
     const runtimeConfig = {
       isI18nMapped,
@@ -1051,6 +1039,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,
@@ -1148,8 +1137,8 @@ ${onUrlEntries.join("\n")}`;
         routesNameSeparator: nuxtI18nConfig.routesNameSeparator,
         normalisedLocales,
         filter: {
-          include: normalizeFilters(config.include),
-          exclude: normalizeFilters(config.exclude)
+          include: serializeFilters(config.include || [], "@nuxtjs/sitemap"),
+          exclude: serializeFilters(config.exclude || [], "@nuxtjs/sitemap")
         },
         autoI18n: !!resolvedAutoI18n
       });
@@ -1281,19 +1270,14 @@ export async function readSourcesFromFilesystem() {
 }
 `;
       }
-      if (prerenderSitemap && !nuxt.options.dev) {
-        nitroConfig.virtual["#sitemap-virtual/global-sources.mjs"] = `export const sources = []`;
-        nitroConfig.virtual[`#sitemap-virtual/child-sources.mjs`] = `export const sources = {}`;
-      } else {
-        nitroConfig.virtual["#sitemap-virtual/global-sources.mjs"] = async () => {
-          const globalSources = await generateGlobalSources();
-          return `export const sources = ${JSON.stringify(globalSources, null, 4)}`;
-        };
-        nitroConfig.virtual[`#sitemap-virtual/child-sources.mjs`] = async () => {
-          const childSources = await generateChildSources();
-          return `export const sources = ${JSON.stringify(childSources, null, 4)}`;
-        };
-      }
+      nitroConfig.virtual["#sitemap-virtual/global-sources.mjs"] = async () => {
+        const globalSources = await generateGlobalSources();
+        return `export const sources = ${JSON.stringify(globalSources, null, 4)}`;
+      };
+      nitroConfig.virtual[`#sitemap-virtual/child-sources.mjs`] = async () => {
+        const childSources = await generateChildSources();
+        return `export const sources = ${JSON.stringify(childSources, null, 4)}`;
+      };
     });
     if (config.xsl === "/__sitemap__/style.xsl") {
       addServerHandler({

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-production.d.ts

@@ -1,8 +1,8 @@
-import type { SitemapWarning } from '@nuxtjs/sitemap/utils';
+import type { SitemapIssue } from 'sitemapd/parse';
 export interface ProductionSitemapEntry {
     loc: string;
     urlCount: number;
-    warnings: SitemapWarning[];
+    warnings: SitemapIssue[];
     error?: string;
     lastmod?: string;
 }
@@ -10,7 +10,7 @@ export interface ProductionDebugResponse {
     url: string;
     isIndex: boolean;
     sitemaps: ProductionSitemapEntry[];
-    warnings: SitemapWarning[];
+    warnings: SitemapIssue[];
     error?: string;
 }
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<Record<string, any> | ProductionDebugResponse>>;

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

@@ -1,13 +1,13 @@
-import { isSitemapIndex, parseSitemapIndex, parseSitemapXml } from "@nuxtjs/sitemap/utils";
 import { defineEventHandler, getQuery } from "h3";
-async function fetchXml(url) {
+import { collectSitemap } from "sitemapd/parse";
+async function fetchSitemapBody(url) {
   const response = await fetch(url, {
-    headers: { Accept: "application/xml, text/xml" },
+    headers: { Accept: "application/xml, text/xml, application/gzip" },
     signal: AbortSignal.timeout(15e3)
   });
   if (!response.ok)
     throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-  return response.text();
+  return new Uint8Array(await response.arrayBuffer());
 }
 export default defineEventHandler(async (e) => {
   const { url, mode } = getQuery(e);
@@ -18,58 +18,74 @@ export default defineEventHandler(async (e) => {
     const response = await fetch(debugUrl, {
       headers: { Accept: "application/json" },
       signal: AbortSignal.timeout(1e4)
-    }).catch(() => null);
+    }).catch(() => {
+      return null;
+    });
     if (response?.ok) {
-      const json = await response.json().catch(() => null);
+      const json = await response.json().catch(() => {
+        return null;
+      });
       if (json?.sitemaps)
         return json;
     }
   }
   const sitemapUrl = url.endsWith("/") ? `${url}sitemap.xml` : url;
-  const xml = await fetchXml(sitemapUrl).catch((err) => {
+  const body = await fetchSitemapBody(sitemapUrl).catch((err) => {
     return err;
   });
-  if (xml instanceof Error)
-    return { url: sitemapUrl, isIndex: false, sitemaps: [], warnings: [], error: `Failed to fetch sitemap: ${xml.message}` };
-  if (isSitemapIndex(xml)) {
-    const { entries, warnings } = await parseSitemapIndex(xml);
+  if (body instanceof Error)
+    return { url: sitemapUrl, isIndex: false, sitemaps: [], warnings: [], error: `Failed to fetch sitemap: ${body.message}` };
+  const parsed = await collectSitemap(body);
+  if (parsed._tag !== "document") {
+    return {
+      url: sitemapUrl,
+      isIndex: false,
+      sitemaps: [],
+      warnings: parsed.issues,
+      error: parsed.issues.map((issue) => issue.message).join("; ") || "Invalid sitemap document"
+    };
+  }
+  if (parsed.document._tag === "index") {
+    const { entries } = parsed.document;
     const sitemaps = await Promise.all(
       entries.map(async (entry) => {
-        const childXml = await fetchXml(entry.loc).catch((err) => err);
-        if (childXml instanceof Error) {
+        const childBody = await fetchSitemapBody(entry.loc).catch((err) => err);
+        if (childBody instanceof Error) {
           return {
             loc: entry.loc,
             urlCount: 0,
             warnings: [],
-            error: childXml.message,
+            error: childBody.message,
+            lastmod: entry.lastmod
+          };
+        }
+        const result = await collectSitemap(childBody);
+        if (result._tag !== "document" || result.document._tag !== "urlset") {
+          return {
+            loc: entry.loc,
+            urlCount: 0,
+            warnings: result.issues,
+            error: result.issues.map((issue) => issue.message).join("; ") || "Child is not a URL set",
             lastmod: entry.lastmod
           };
         }
-        const result2 = await parseSitemapXml(childXml).catch((err) => ({
-          urls: [],
-          warnings: [{ type: "validation", message: err.message }]
-        }));
         return {
           loc: entry.loc,
-          urlCount: result2.urls.length,
-          warnings: result2.warnings,
+          urlCount: result.document.entries.length,
+          warnings: result.issues,
           lastmod: entry.lastmod
         };
       })
     );
-    return { url: sitemapUrl, isIndex: true, sitemaps, warnings };
+    return { url: sitemapUrl, isIndex: true, sitemaps, warnings: parsed.issues };
   }
-  const result = await parseSitemapXml(xml).catch((err) => ({
-    urls: [],
-    warnings: [{ type: "validation", message: err.message }]
-  }));
   return {
     url: sitemapUrl,
     isIndex: false,
     sitemaps: [{
       loc: sitemapUrl,
-      urlCount: result.urls.length,
-      warnings: result.warnings
+      urlCount: parsed.document.entries.length,
+      warnings: parsed.issues
     }],
     warnings: []
   };

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,67 @@
+import { withQuery } from "ufo";
+import { createChunkedXmlStream } from "../stream.js";
+import { escapeValueForXml } from "./xml.js";
+function resolveIndexXslHref(resolvers, xsl, errorInfo) {
+  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
+    });
+  }
+  return relativeBaseUrl;
+}
+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) {
+    const relativeBaseUrl = resolveIndexXslHref(resolvers, xsl, errorInfo);
+    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) {
+    const relativeBaseUrl = resolveIndexXslHref(resolvers, xsl, errorInfo);
+    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';