@nuxtjs/sitemap 7.4.5 → 7.4.8

package/dist/runtime/server/routes/sitemap_index.xml.js

@@ -0,0 +1,42 @@
+import { appendHeader, defineEventHandler, setHeader } from "h3";
+import { joinURL } from "ufo";
+import { useNitroApp } from "nitropack/runtime";
+import { useSitemapRuntimeConfig } from "../utils.js";
+import { buildSitemapIndex, urlsToIndexXml } from "../sitemap/builder/sitemap-index.js";
+import { useNitroUrlResolvers } from "../sitemap/nitro.js";
+export default defineEventHandler(async (e) => {
+  const runtimeConfig = useSitemapRuntimeConfig();
+  const nitro = useNitroApp();
+  const resolvers = useNitroUrlResolvers(e);
+  const { entries: sitemaps, failedSources } = await buildSitemapIndex(resolvers, runtimeConfig, nitro);
+  if (import.meta.prerender) {
+    appendHeader(
+      e,
+      "x-nitro-prerender",
+      sitemaps.filter((entry) => !!entry._sitemapName).map((entry) => encodeURIComponent(joinURL(runtimeConfig.sitemapsPathPrefix || "", `/${entry._sitemapName}.xml`))).join(", ")
+    );
+  }
+  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);
+  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`);
+  }
+  return ctx.sitemap;
+});

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

@@ -0,0 +1,13 @@
+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<{
+        url: string;
+        error: string;
+    }>;
+}>;

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

@@ -0,0 +1,197 @@
+import { defu } from "defu";
+import { joinURL, withQuery } from "ufo";
+import { defineCachedFunction } from "nitropack/runtime";
+import { getHeader } from "h3";
+import { normaliseDate } from "../urlset/normalise.js";
+import { globalSitemapSources, childSitemapSources, resolveSitemapSources } from "../urlset/sources.js";
+import { sortInPlace } from "../urlset/sort.js";
+import { escapeValueForXml } from "./xml.js";
+import { resolveSitemapEntries } from "./sitemap.js";
+const buildSitemapIndexCached = defineCachedFunction(
+  async (event, resolvers, runtimeConfig, nitro) => {
+    return buildSitemapIndexInternal(resolvers, runtimeConfig, nitro);
+  },
+  {
+    name: "sitemap:index",
+    group: "sitemap",
+    maxAge: 60 * 10,
+    // 10 minutes default
+    base: "sitemap",
+    // Use the sitemap storage
+    getKey: (event) => {
+      const host = getHeader(event, "host") || getHeader(event, "x-forwarded-host") || "";
+      const proto = getHeader(event, "x-forwarded-proto") || "https";
+      return `sitemap-index-${proto}-${host}`;
+    },
+    swr: true
+    // Enable stale-while-revalidate
+  }
+);
+async function buildSitemapIndexInternal(resolvers, runtimeConfig, nitro) {
+  const {
+    sitemaps,
+    // enhancing
+    autoLastmod,
+    // chunking
+    defaultSitemapsChunkSize,
+    autoI18n,
+    isI18nMapped,
+    sortEntries,
+    sitemapsPathPrefix
+  } = runtimeConfig;
+  if (!sitemaps)
+    throw new Error("Attempting to build a sitemap index without required `sitemaps` configuration.");
+  function maybeSort(urls) {
+    return sortEntries ? sortInPlace(urls) : urls;
+  }
+  const chunks = {};
+  const allFailedSources = [];
+  for (const sitemapName in sitemaps) {
+    if (sitemapName === "index" || sitemapName === "chunks") continue;
+    const sitemapConfig = sitemaps[sitemapName];
+    if (sitemapConfig.chunks || sitemapConfig._isChunking) {
+      sitemapConfig._isChunking = true;
+      sitemapConfig._chunkSize = typeof sitemapConfig.chunks === "number" ? sitemapConfig.chunks : sitemapConfig.chunkSize || defaultSitemapsChunkSize || 1e3;
+    } else {
+      chunks[sitemapName] = chunks[sitemapName] || { urls: [] };
+    }
+  }
+  if (typeof sitemaps.chunks !== "undefined") {
+    const sitemap = sitemaps.chunks;
+    let sourcesInput = await globalSitemapSources();
+    if (nitro && resolvers.event) {
+      const ctx = {
+        event: resolvers.event,
+        sitemapName: sitemap.sitemapName,
+        sources: sourcesInput
+      };
+      await nitro.hooks.callHook("sitemap:sources", ctx);
+      sourcesInput = ctx.sources;
+    }
+    const sources = await resolveSitemapSources(sourcesInput, resolvers.event);
+    const failedSources = sources.filter((source) => source.error && source._isFailure).map((source) => ({
+      url: typeof source.fetch === "string" ? source.fetch : source.fetch?.[0] || "unknown",
+      error: source.error || "Unknown error"
+    }));
+    allFailedSources.push(...failedSources);
+    const resolvedCtx = {
+      urls: sources.flatMap((s) => s.urls),
+      sitemapName: sitemap.sitemapName,
+      event: resolvers.event
+    };
+    await nitro?.hooks.callHook("sitemap:input", resolvedCtx);
+    const normalisedUrls = resolveSitemapEntries(sitemap, resolvedCtx.urls, { autoI18n, isI18nMapped }, resolvers);
+    const enhancedUrls = normalisedUrls.map((e) => defu(e, sitemap.defaults));
+    const sortedUrls = maybeSort(enhancedUrls);
+    sortedUrls.forEach((url, i) => {
+      const chunkIndex = Math.floor(i / defaultSitemapsChunkSize);
+      chunks[chunkIndex] = chunks[chunkIndex] || { urls: [] };
+      chunks[chunkIndex].urls.push(url);
+    });
+  }
+  const entries = [];
+  for (const name in chunks) {
+    const sitemap = chunks[name];
+    const entry = {
+      _sitemapName: name,
+      sitemap: resolvers.canonicalUrlResolver(joinURL(sitemapsPathPrefix || "", `/${name}.xml`))
+    };
+    let lastmod = sitemap.urls.filter((a) => !!a?.lastmod).map((a) => typeof a.lastmod === "string" ? new Date(a.lastmod) : a.lastmod).sort((a, b) => (b?.getTime() || 0) - (a?.getTime() || 0))?.[0];
+    if (!lastmod && autoLastmod)
+      lastmod = /* @__PURE__ */ new Date();
+    if (lastmod)
+      entry.lastmod = normaliseDate(lastmod);
+    entries.push(entry);
+  }
+  for (const sitemapName in sitemaps) {
+    const sitemapConfig = sitemaps[sitemapName];
+    if (sitemapName !== "index" && sitemapConfig._isChunking) {
+      const chunkSize = sitemapConfig._chunkSize || defaultSitemapsChunkSize || 1e3;
+      let sourcesInput = sitemapConfig.includeAppSources ? await globalSitemapSources() : [];
+      sourcesInput.push(...await childSitemapSources(sitemapConfig));
+      if (nitro && resolvers.event) {
+        const ctx = {
+          event: resolvers.event,
+          sitemapName: sitemapConfig.sitemapName,
+          sources: sourcesInput
+        };
+        await nitro.hooks.callHook("sitemap:sources", ctx);
+        sourcesInput = ctx.sources;
+      }
+      const sources = await resolveSitemapSources(sourcesInput, resolvers.event);
+      const failedSources = sources.filter((source) => source.error && source._isFailure).map((source) => ({
+        url: typeof source.fetch === "string" ? source.fetch : source.fetch?.[0] || "unknown",
+        error: source.error || "Unknown error"
+      }));
+      allFailedSources.push(...failedSources);
+      const resolvedCtx = {
+        urls: sources.flatMap((s) => s.urls),
+        sitemapName: sitemapConfig.sitemapName,
+        event: resolvers.event
+      };
+      await nitro?.hooks.callHook("sitemap:input", resolvedCtx);
+      const normalisedUrls = resolveSitemapEntries(sitemapConfig, resolvedCtx.urls, { autoI18n, isI18nMapped }, resolvers);
+      const totalUrls = normalisedUrls.length;
+      const chunkCount = Math.ceil(totalUrls / 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`))
+        };
+        const chunkUrls = normalisedUrls.slice(i * chunkSize, (i + 1) * chunkSize);
+        let lastmod = chunkUrls.filter((a) => !!a?.lastmod).map((a) => typeof a.lastmod === "string" ? new Date(a.lastmod) : a.lastmod).sort((a, b) => (b?.getTime() || 0) - (a?.getTime() || 0))?.[0];
+        if (!lastmod && autoLastmod)
+          lastmod = /* @__PURE__ */ new Date();
+        if (lastmod)
+          entry.lastmod = normaliseDate(lastmod);
+        entries.push(entry);
+      }
+    }
+  }
+  if (sitemaps.index) {
+    entries.push(...sitemaps.index.sitemaps.map((entry) => {
+      return typeof entry === "string" ? { sitemap: entry } : entry;
+    }));
+  }
+  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 && typeof runtimeConfig.cacheMaxAgeSeconds === "number" && runtimeConfig.cacheMaxAgeSeconds > 0 && resolvers.event) {
+    return buildSitemapIndexCached(resolvers.event, resolvers, runtimeConfig, nitro);
+  }
+  return buildSitemapIndexInternal(resolvers, runtimeConfig, nitro);
+}

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

@@ -0,0 +1,16 @@
+import type { NitroApp } from 'nitropack/types';
+import type { AutoI18nConfig, ModuleRuntimeConfig, NitroUrlResolvers, ResolvedSitemapUrl, SitemapDefinition, SitemapUrlInput } from '../../../types.js';
+export interface NormalizedI18n extends ResolvedSitemapUrl {
+    _pathWithoutPrefix: string;
+    _locale: AutoI18nConfig['locales'][number];
+    _index?: number;
+}
+export declare function resolveSitemapEntries(sitemap: SitemapDefinition, urls: SitemapUrlInput[], runtimeConfig: Pick<ModuleRuntimeConfig, 'autoI18n' | 'isI18nMapped'>, resolvers?: NitroUrlResolvers): ResolvedSitemapUrl[];
+export declare function buildSitemapUrls(sitemap: SitemapDefinition, resolvers: NitroUrlResolvers, runtimeConfig: ModuleRuntimeConfig, nitro?: NitroApp): Promise<{
+    urls: ResolvedSitemapUrl[];
+    failedSources: Array<{
+        url: string;
+        error: string;
+    }>;
+}>;
+export { urlsToXml } from './xml.js';

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

@@ -0,0 +1,243 @@
+import { resolveSitePath } from "nuxt-site-config/urls";
+import { joinURL, withHttps } from "ufo";
+import { preNormalizeEntry } from "../urlset/normalise.js";
+import { childSitemapSources, globalSitemapSources, resolveSitemapSources } from "../urlset/sources.js";
+import { sortInPlace } from "../urlset/sort.js";
+import { createPathFilter, logger, splitForLocales } from "../../../utils-pure.js";
+import { parseChunkInfo, sliceUrlsForChunk } from "../utils/chunk.js";
+export function resolveSitemapEntries(sitemap, urls, runtimeConfig, resolvers) {
+  const {
+    autoI18n,
+    isI18nMapped
+  } = runtimeConfig;
+  const filterPath = createPathFilter({
+    include: sitemap.include,
+    exclude: sitemap.exclude
+  });
+  const _urls = urls.map((_e) => {
+    const e = preNormalizeEntry(_e, resolvers);
+    if (!e.loc || !filterPath(e.loc))
+      return false;
+    return e;
+  }).filter(Boolean);
+  let validI18nUrlsForTransform = [];
+  let warnIncorrectI18nTransformUsage = false;
+  const withoutPrefixPaths = {};
+  if (autoI18n && autoI18n.strategy !== "no_prefix") {
+    const localeCodes = autoI18n.locales.map((l) => l.code);
+    validI18nUrlsForTransform = _urls.map((_e, i) => {
+      if (_e._abs)
+        return false;
+      const split = splitForLocales(_e._relativeLoc, localeCodes);
+      let localeCode = split[0];
+      const pathWithoutPrefix = split[1];
+      if (!localeCode)
+        localeCode = autoI18n.defaultLocale;
+      const e = _e;
+      e._pathWithoutPrefix = pathWithoutPrefix;
+      const locale = autoI18n.locales.find((l) => l.code === localeCode);
+      if (!locale)
+        return false;
+      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);
+    for (const e of validI18nUrlsForTransform) {
+      if (!e._i18nTransform && !e.alternatives?.length) {
+        const alternatives = withoutPrefixPaths[e._pathWithoutPrefix].map((u) => {
+          const entries = [];
+          if (u._locale.code === autoI18n.defaultLocale) {
+            entries.push({
+              href: u.loc,
+              hreflang: "x-default"
+            });
+          }
+          entries.push({
+            href: u.loc,
+            hreflang: u._locale._hreflang || autoI18n.defaultLocale
+          });
+          return entries;
+        }).flat().filter(Boolean);
+        if (alternatives.length)
+          e.alternatives = alternatives;
+      } else if (e._i18nTransform) {
+        delete e._i18nTransform;
+        if (autoI18n.strategy === "no_prefix") {
+          warnIncorrectI18nTransformUsage = true;
+        }
+        if (autoI18n.differentDomains) {
+          e.alternatives = [
+            {
+              // apply default locale domain
+              ...autoI18n.locales.find((l) => [l.code, l.language].includes(autoI18n.defaultLocale)),
+              code: "x-default"
+            },
+            ...autoI18n.locales.filter((l) => !!l.domain)
+          ].map((locale) => {
+            return {
+              hreflang: locale._hreflang,
+              href: joinURL(withHttps(locale.domain), e._pathWithoutPrefix)
+            };
+          });
+        } else {
+          for (const l of autoI18n.locales) {
+            let loc = e._pathWithoutPrefix;
+            if (autoI18n.pages) {
+              const pageKey = e._pathWithoutPrefix.replace(/^\//, "").replace(/\/index$/, "") || "index";
+              const pageMappings = autoI18n.pages[pageKey];
+              if (pageMappings && pageMappings[l.code] !== void 0) {
+                const customPath = pageMappings[l.code];
+                if (customPath === false)
+                  continue;
+                if (typeof customPath === "string")
+                  loc = customPath.startsWith("/") ? customPath : `/${customPath}`;
+              } else if (!autoI18n.differentDomains && !(["prefix_and_default", "prefix_except_default"].includes(autoI18n.strategy) && l.code === autoI18n.defaultLocale)) {
+                loc = joinURL(`/${l.code}`, e._pathWithoutPrefix);
+              }
+            } else {
+              if (!autoI18n.differentDomains && !(["prefix_and_default", "prefix_except_default"].includes(autoI18n.strategy) && l.code === autoI18n.defaultLocale))
+                loc = joinURL(`/${l.code}`, e._pathWithoutPrefix);
+            }
+            const _sitemap = isI18nMapped ? l._sitemap : void 0;
+            const newEntry = preNormalizeEntry({
+              _sitemap,
+              ...e,
+              _index: void 0,
+              _key: `${_sitemap || ""}${loc || "/"}${e._path.search}`,
+              _locale: l,
+              loc,
+              alternatives: [{ code: "x-default", _hreflang: "x-default" }, ...autoI18n.locales].map((locale) => {
+                const code = locale.code === "x-default" ? autoI18n.defaultLocale : locale.code;
+                const isDefault = locale.code === "x-default" || locale.code === autoI18n.defaultLocale;
+                let href = e._pathWithoutPrefix;
+                if (autoI18n.pages) {
+                  const pageKey = e._pathWithoutPrefix.replace(/^\//, "").replace(/\/index$/, "") || "index";
+                  const pageMappings = autoI18n.pages[pageKey];
+                  if (pageMappings && pageMappings[code] !== void 0) {
+                    const customPath = pageMappings[code];
+                    if (customPath === false)
+                      return false;
+                    if (typeof customPath === "string")
+                      href = customPath.startsWith("/") ? customPath : `/${customPath}`;
+                  } else if (autoI18n.strategy === "prefix") {
+                    href = joinURL("/", code, e._pathWithoutPrefix);
+                  } else if (["prefix_and_default", "prefix_except_default"].includes(autoI18n.strategy)) {
+                    if (!isDefault) {
+                      href = joinURL("/", code, e._pathWithoutPrefix);
+                    }
+                  }
+                } else {
+                  if (autoI18n.strategy === "prefix") {
+                    href = joinURL("/", code, e._pathWithoutPrefix);
+                  } else if (["prefix_and_default", "prefix_except_default"].includes(autoI18n.strategy)) {
+                    if (!isDefault) {
+                      href = joinURL("/", code, e._pathWithoutPrefix);
+                    }
+                  }
+                }
+                if (!filterPath(href))
+                  return false;
+                return {
+                  hreflang: locale._hreflang,
+                  href
+                };
+              }).filter(Boolean)
+            }, resolvers);
+            if (e._locale.code === newEntry._locale.code) {
+              _urls[e._index] = newEntry;
+              e._index = void 0;
+            } else {
+              _urls.push(newEntry);
+            }
+          }
+        }
+      }
+      if (isI18nMapped) {
+        e._sitemap = e._sitemap || e._locale._sitemap;
+        e._key = `${e._sitemap || ""}${e.loc || "/"}${e._path.search}`;
+      }
+      if (e._index)
+        _urls[e._index] = e;
+    }
+  }
+  if (import.meta.dev && warnIncorrectI18nTransformUsage) {
+    logger.warn("You're using _i18nTransform with the `no_prefix` strategy. This will cause issues with the sitemap. Please remove the _i18nTransform flag or change i18n strategy.");
+  }
+  return _urls;
+}
+export async function buildSitemapUrls(sitemap, resolvers, runtimeConfig, nitro) {
+  const {
+    sitemaps,
+    // enhancing
+    autoI18n,
+    isI18nMapped,
+    isMultiSitemap,
+    // sorting
+    sortEntries,
+    // chunking
+    defaultSitemapsChunkSize
+  } = runtimeConfig;
+  const chunkInfo = parseChunkInfo(sitemap.sitemapName, sitemaps, defaultSitemapsChunkSize);
+  function maybeSort(urls2) {
+    return sortEntries ? sortInPlace(urls2) : urls2;
+  }
+  function maybeSlice(urls2) {
+    return sliceUrlsForChunk(urls2, sitemap.sitemapName, sitemaps, defaultSitemapsChunkSize);
+  }
+  if (autoI18n?.differentDomains) {
+    const domain = autoI18n.locales.find((e) => [e.language, e.code].includes(sitemap.sitemapName))?.domain;
+    if (domain) {
+      const _tester = resolvers.canonicalUrlResolver;
+      resolvers.canonicalUrlResolver = (path) => resolveSitePath(path, {
+        absolute: true,
+        withBase: false,
+        siteUrl: withHttps(domain),
+        trailingSlash: _tester("/test/").endsWith("/"),
+        base: "/"
+      });
+    }
+  }
+  let effectiveSitemap = sitemap;
+  const baseSitemapName = chunkInfo.baseSitemapName;
+  if (chunkInfo.isChunked && baseSitemapName !== sitemap.sitemapName && sitemaps[baseSitemapName]) {
+    effectiveSitemap = sitemaps[baseSitemapName];
+  }
+  let sourcesInput = effectiveSitemap.includeAppSources ? await globalSitemapSources() : [];
+  sourcesInput.push(...await childSitemapSources(effectiveSitemap));
+  if (nitro && resolvers.event) {
+    const ctx = {
+      event: resolvers.event,
+      sitemapName: baseSitemapName,
+      sources: sourcesInput
+    };
+    await nitro.hooks.callHook("sitemap:sources", ctx);
+    sourcesInput = ctx.sources;
+  }
+  const sources = await resolveSitemapSources(sourcesInput, resolvers.event);
+  const failedSources = sources.filter((source) => source.error && source._isFailure).map((source) => ({
+    url: typeof source.fetch === "string" ? source.fetch : source.fetch?.[0] || "unknown",
+    error: source.error || "Unknown error"
+  }));
+  const resolvedCtx = {
+    urls: sources.flatMap((s) => s.urls),
+    sitemapName: sitemap.sitemapName,
+    event: resolvers.event
+  };
+  await nitro?.hooks.callHook("sitemap:input", resolvedCtx);
+  const enhancedUrls = resolveSitemapEntries(sitemap, resolvedCtx.urls, { autoI18n, isI18nMapped }, resolvers);
+  const filteredUrls = enhancedUrls.filter((e) => {
+    if (e._sitemap === false)
+      return false;
+    if (isMultiSitemap && e._sitemap && sitemap.sitemapName)
+      return e._sitemap === sitemap.sitemapName;
+    return true;
+  });
+  const sortedUrls = maybeSort(filteredUrls);
+  const urls = maybeSlice(sortedUrls);
+  return { urls, failedSources };
+}
+export { urlsToXml } from "./xml.js";

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

@@ -0,0 +1,6 @@
+import type { ModuleRuntimeConfig, NitroUrlResolvers, ResolvedSitemapUrl } from '../../../types.js';
+export declare function escapeValueForXml(value: boolean | string | number): 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;