@nuxtjs/sitemap 8.3.0 → 8.3.2

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.3.0",
+  "version": "8.3.2",
   "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';
@@ -242,6 +243,10 @@ declare module 'nuxt/app' {
 export {}
 `;
     }
+  }, {
+    nitro: true,
+    node: true,
+    nuxt: true
   });
   addTemplate({
     filename: "types/nuxt-sitemap-virtual.d.ts",
@@ -272,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;
@@ -462,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({
@@ -528,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;
@@ -1046,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,
@@ -1153,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
       });
@@ -1286,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/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/sitemap/builder/index-xml.js

@@ -1,20 +1,24 @@
 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) {
-    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
-      });
-    }
+    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}`;
@@ -46,14 +50,7 @@ export function urlsToIndexXml(sitemaps, resolvers, { version, xsl, credits, min
   }
   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
-      });
-    }
+    const relativeBaseUrl = resolveIndexXslHref(resolvers, xsl, errorInfo);
     xmlParts.push(`<?xml-stylesheet type="text/xsl" href="${escapeValueForXml(relativeBaseUrl)}"?>`);
   }
   xmlParts.push(

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

@@ -48,22 +48,7 @@ async function buildSitemapIndexInternal(resolvers, runtimeConfig, nitro) {
   }
   const indexLastmod = autoLastmod ? normaliseDate(/* @__PURE__ */ new Date()) : void 0;
   const entries = [];
-  if (typeof sitemaps.chunks !== "undefined") {
-    const sitemap = sitemaps.chunks;
-    const resolved = await getResolvedSitemapUrls(sitemap, "sitemap", true, resolvers, runtimeConfig, nitro);
-    allFailedSources.push(...resolved.failedSources);
-    const chunkCount = Math.ceil(resolved.urls.length / defaultSitemapsChunkSize);
-    for (let i = 0; i < chunkCount; i++) {
-      const entry = {
-        _sitemapName: String(i),
-        sitemap: resolvers.canonicalUrlResolver(joinURL(sitemapsPathPrefix || "", `/${i}.xml`))
-      };
-      if (indexLastmod)
-        entry.lastmod = indexLastmod;
-      entries.push(entry);
-    }
-  }
-  for (const name of nonChunkedNames) {
+  const pushEntry = (name) => {
     const entry = {
       _sitemapName: name,
       sitemap: resolvers.canonicalUrlResolver(joinURL(sitemapsPathPrefix || "", `/${name}.xml`))
@@ -71,7 +56,17 @@ async function buildSitemapIndexInternal(resolvers, runtimeConfig, nitro) {
     if (indexLastmod)
       entry.lastmod = indexLastmod;
     entries.push(entry);
+  };
+  if (typeof sitemaps.chunks !== "undefined") {
+    const sitemap = sitemaps.chunks;
+    const resolved = await getResolvedSitemapUrls(sitemap, "sitemap", true, resolvers, runtimeConfig, nitro);
+    allFailedSources.push(...resolved.failedSources);
+    const chunkCount = Math.ceil(resolved.urls.length / defaultSitemapsChunkSize);
+    for (let i = 0; i < chunkCount; i++)
+      pushEntry(String(i));
   }
+  for (const name of nonChunkedNames)
+    pushEntry(name);
   for (const sitemapName in sitemaps) {
     const sitemapConfig = sitemaps[sitemapName];
     if (sitemapName !== "index" && sitemapConfig._isChunking) {
@@ -85,16 +80,8 @@ async function buildSitemapIndexInternal(resolvers, runtimeConfig, nitro) {
         chunkCount = Math.ceil(resolved.urls.length / chunkSize);
       }
       sitemapConfig._chunkCount = chunkCount;
-      for (let i = 0; i < chunkCount; i++) {
-        const chunkName = `${sitemapName}-${i}`;
-        const entry = {
-          _sitemapName: chunkName,
-          sitemap: resolvers.canonicalUrlResolver(joinURL(sitemapsPathPrefix || "", `/${chunkName}.xml`))
-        };
-        if (indexLastmod)
-          entry.lastmod = indexLastmod;
-        entries.push(entry);
-      }
+      for (let i = 0; i < chunkCount; i++)
+        pushEntry(`${sitemapName}-${i}`);
     }
   }
   if (sitemaps.index) {

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

@@ -1,10 +1,10 @@
 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?: {
+export declare function renderSitemapXmlChunks(urls: ResolvedSitemapUrl[], resolvers: NitroUrlResolvers, config: 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?: {
+export declare function urlsToXml(urls: ResolvedSitemapUrl[], resolvers: NitroUrlResolvers, config: Pick<ModuleRuntimeConfig, 'version' | 'xsl' | 'credits' | 'minify'>, errorInfo?: {
     messages: string[];
     urls: string[];
 }): string;

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

@@ -116,7 +116,7 @@ function buildUrlXml(url, NL, I1, I2, I3, I4) {
   xml += `${I1}</url>`;
   return xml;
 }
-export function* renderSitemapXmlChunks(urls, resolvers, { version, xsl, credits, minify }, errorInfo) {
+function resolveXmlRenderContext(resolvers, { xsl, minify }, errorInfo) {
   let xslHref = xsl ? resolvers.relativeBaseUrlResolver(xsl) : false;
   if (xslHref && errorInfo?.messages.length) {
     xslHref = withQuery(xslHref, {
@@ -126,10 +126,18 @@ export function* renderSitemapXmlChunks(urls, resolvers, { version, xsl, credits
     });
   }
   const NL = minify ? "" : "\n";
-  const I1 = minify ? "" : "    ";
-  const I2 = minify ? "" : "        ";
-  const I3 = minify ? "" : "            ";
-  const I4 = minify ? "" : "                ";
+  return {
+    xslHref,
+    NL,
+    I1: minify ? "" : "    ",
+    I2: minify ? "" : "        ",
+    I3: minify ? "" : "            ",
+    I4: minify ? "" : "                "
+  };
+}
+export function* renderSitemapXmlChunks(urls, resolvers, config, errorInfo) {
+  const { version, credits } = config;
+  const { xslHref, NL, I1, I2, I3, I4 } = resolveXmlRenderContext(resolvers, config, errorInfo);
   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) {
@@ -140,20 +148,9 @@ export function* renderSitemapXmlChunks(urls, resolvers, { version, xsl, 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) {
-    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 ? "" : "                ";
+export function urlsToXml(urls, resolvers, config, errorInfo) {
+  const { version, credits } = config;
+  const { xslHref, NL, I1, I2, I3, I4 } = resolveXmlRenderContext(resolvers, config, errorInfo);
   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)

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

@@ -1,10 +1,10 @@
-import { appendHeader, createError, getRequestURL, getRouterParam, sendRedirect, setHeader } from "h3";
+import { appendHeader, createError, getRequestURL, getRouterParam, sendRedirect } from "h3";
 import { useNitroApp, useRuntimeConfig } from "nitropack/runtime";
 import { joinURL, withBase, withLeadingSlash, withoutLeadingSlash, withoutTrailingSlash } from "ufo";
 import { useSitemapRuntimeConfig } from "../utils.js";
 import { urlsToIndexXml, urlsToIndexXmlStream } from "./builder/index-xml.js";
 import { buildSitemapIndex } from "./builder/sitemap-index.js";
-import { createSitemap, renderSitemapOutput, useNitroUrlResolvers } from "./nitro.js";
+import { createSitemap, renderSitemapOutput, setSitemapResponseHeaders, useNitroUrlResolvers } from "./nitro.js";
 import { getSitemapConfig, parseChunkInfo } from "./utils/chunk.js";
 export async function sitemapXmlEventHandler(e) {
   const runtimeConfig = useSitemapRuntimeConfig();
@@ -37,20 +37,7 @@ export async function sitemapIndexXmlEventHandler(e) {
     !!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`);
-    const now = /* @__PURE__ */ new Date();
-    setHeader(e, "X-Sitemap-Generated", now.toISOString());
-    setHeader(e, "X-Sitemap-Cache-Duration", `${runtimeConfig.cacheMaxAgeSeconds}s`);
-    const expiryTime = new Date(now.getTime() + runtimeConfig.cacheMaxAgeSeconds * 1e3);
-    setHeader(e, "X-Sitemap-Cache-Expires", expiryTime.toISOString());
-    const remainingSeconds = Math.floor((expiryTime.getTime() - now.getTime()) / 1e3);
-    setHeader(e, "X-Sitemap-Cache-Remaining", `${remainingSeconds}s`);
-  } else {
-    setHeader(e, "Cache-Control", `no-cache, no-store`);
-  }
-  e.context._isSitemap = true;
+  setSitemapResponseHeaders(e, runtimeConfig);
   return output;
 }
 export async function sitemapChildXmlEventHandler(e) {

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

@@ -3,4 +3,5 @@ import type { NitroApp } from 'nitropack/types';
 import type { ModuleRuntimeConfig, NitroUrlResolvers, SitemapDefinition } from '../../types.js';
 export declare function useNitroUrlResolvers(e: H3Event): NitroUrlResolvers;
 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 setSitemapResponseHeaders(event: H3Event, runtimeConfig: ModuleRuntimeConfig): void;
 export declare function createSitemap(event: H3Event, definition: SitemapDefinition, runtimeConfig: ModuleRuntimeConfig): Promise<string | ReadableStream<Uint8Array<ArrayBufferLike>>>;

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

@@ -1,13 +1,13 @@
 import { defu } from "defu";
 import { createError, getHeader, getQuery, setHeader } from "h3";
-import { defineCachedFunction, useNitroApp } from "nitropack/runtime";
+import { defineCachedFunction, useNitroApp, useRuntimeConfig } from "nitropack/runtime";
 import { fixSlashes } from "nuxt-site-config/urls";
+import { createNitroRouteRuleMatcher } from "nuxtseo-shared/server";
 import { getPathRobotConfig } from "#internal/nuxt-robots/getPathRobotConfig";
 import { getSiteConfig } from "#site-config/server/composables/getSiteConfig";
 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, urlsToXmlStream } from "./builder/sitemap.js";
 import { createChunkedXmlStream } from "./stream.js";
 import { normaliseEntry, preNormalizeEntry } from "./urlset/normalise.js";
@@ -52,7 +52,7 @@ async function buildSitemapRenderPlan(event, definition, resolvers, runtimeConfi
       message: `Sitemap generation failed due to ${failedSources.length} failed sources: ${failedSources.map((s) => `"${s.url}" (${s.error})`).join(", ")}`
     });
   }
-  const routeRuleMatcher = createNitroRouteRuleMatcher();
+  const routeRuleMatcher = createNitroRouteRuleMatcher(useRuntimeConfig(event));
   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;
@@ -205,6 +205,22 @@ const buildSitemapXmlCached = defineCachedFunction(
     // Enable stale-while-revalidate
   }
 );
+export function setSitemapResponseHeaders(event, 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`);
+    const now = /* @__PURE__ */ new Date();
+    setHeader(event, "X-Sitemap-Generated", now.toISOString());
+    setHeader(event, "X-Sitemap-Cache-Duration", `${runtimeConfig.cacheMaxAgeSeconds}s`);
+    const expiryTime = new Date(now.getTime() + runtimeConfig.cacheMaxAgeSeconds * 1e3);
+    setHeader(event, "X-Sitemap-Cache-Expires", expiryTime.toISOString());
+    const remainingSeconds = Math.floor((expiryTime.getTime() - now.getTime()) / 1e3);
+    setHeader(event, "X-Sitemap-Cache-Remaining", `${remainingSeconds}s`);
+  } else {
+    setHeader(event, "Cache-Control", `no-cache, no-store`);
+  }
+  event.context._isSitemap = true;
+}
 export async function createSitemap(event, definition, runtimeConfig) {
   const resolvers = useNitroUrlResolvers(event);
   const shouldStream = !!runtimeConfig.experimentalStreaming && !import.meta.prerender;
@@ -224,19 +240,6 @@ export async function createSitemap(event, definition, runtimeConfig) {
   } 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`);
-    const now = /* @__PURE__ */ new Date();
-    setHeader(event, "X-Sitemap-Generated", now.toISOString());
-    setHeader(event, "X-Sitemap-Cache-Duration", `${runtimeConfig.cacheMaxAgeSeconds}s`);
-    const expiryTime = new Date(now.getTime() + runtimeConfig.cacheMaxAgeSeconds * 1e3);
-    setHeader(event, "X-Sitemap-Cache-Expires", expiryTime.toISOString());
-    const remainingSeconds = Math.floor((expiryTime.getTime() - now.getTime()) / 1e3);
-    setHeader(event, "X-Sitemap-Cache-Remaining", `${remainingSeconds}s`);
-  } else {
-    setHeader(event, "Cache-Control", `no-cache, no-store`);
-  }
-  event.context._isSitemap = true;
+  setSitemapResponseHeaders(event, runtimeConfig);
   return xml;
 }