@saasmakers/ui 1.4.38 → 1.4.40

package/server/patches/nuxt-seo/sitemap/builder/sitemap-index.js

@@ -0,0 +1,145 @@
+import { safeGetHeader } from "../../utils/h3-compat.js";
+import { defineCachedFunction } from "nitropack/runtime";
+import { joinURL, withQuery } from "ufo";
+import staticConfig from "#sitemap-virtual/static-config.mjs";
+import { normaliseDate } from "../urlset/normalise.js";
+import { getResolvedSitemapUrls } from "./sitemap.js";
+import { escapeValueForXml } from "./xml.js";
+const SERVER_CACHE_MAX_AGE = staticConfig.cacheMaxAgeSeconds || 60 * 10;
+const buildSitemapIndexCached = defineCachedFunction(
+  async (event, resolvers, runtimeConfig, nitro) => {
+    return buildSitemapIndexInternal(resolvers, runtimeConfig, nitro);
+  },
+  {
+    name: "sitemap:index",
+    group: "sitemap",
+    maxAge: SERVER_CACHE_MAX_AGE,
+    base: "sitemap",
+    // Use the sitemap storage
+    getKey: (event) => {
+      const host = safeGetHeader(event, "host") || safeGetHeader(event, "x-forwarded-host") || "";
+      const proto = safeGetHeader(event, "x-forwarded-proto") || "https";
+      return `sitemap-index-${proto}-${host}`;
+    },
+    swr: true
+    // Enable stale-while-revalidate
+  }
+);
+async function buildSitemapIndexInternal(resolvers, runtimeConfig, nitro) {
+  const {
+    sitemaps,
+    autoLastmod,
+    defaultSitemapsChunkSize,
+    sitemapsPathPrefix
+  } = runtimeConfig;
+  if (!sitemaps)
+    throw new Error("Attempting to build a sitemap index without required `sitemaps` configuration.");
+  const nonChunkedNames = [];
+  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 = sitemapConfig.chunkSize || (typeof sitemapConfig.chunks === "number" ? sitemapConfig.chunks : defaultSitemapsChunkSize || 1e3);
+    } else {
+      nonChunkedNames.push(sitemapName);
+    }
+  }
+  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 entry = {
+      _sitemapName: name,
+      sitemap: resolvers.canonicalUrlResolver(joinURL(sitemapsPathPrefix || "", `/${name}.xml`))
+    };
+    if (indexLastmod)
+      entry.lastmod = indexLastmod;
+    entries.push(entry);
+  }
+  for (const sitemapName in sitemaps) {
+    const sitemapConfig = sitemaps[sitemapName];
+    if (sitemapName !== "index" && sitemapConfig._isChunking) {
+      const chunkSize = sitemapConfig._chunkSize || defaultSitemapsChunkSize || 1e3;
+      let chunkCount;
+      if (typeof sitemapConfig.chunkCount === "number" && sitemapConfig.chunkCount > 0) {
+        chunkCount = sitemapConfig.chunkCount;
+      } else {
+        const resolved = await getResolvedSitemapUrls(sitemapConfig, sitemapName, true, resolvers, runtimeConfig, nitro);
+        allFailedSources.push(...resolved.failedSources);
+        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);
+      }
+    }
+  }
+  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 && !import.meta.prerender && typeof runtimeConfig.cacheMaxAgeSeconds === "number" && runtimeConfig.cacheMaxAgeSeconds > 0 && resolvers.event) {
+    return buildSitemapIndexCached(resolvers.event, resolvers, runtimeConfig, nitro);
+  }
+  return buildSitemapIndexInternal(resolvers, runtimeConfig, nitro);
+}

package/server/patches/nuxt-seo/sitemap/builder/sitemap.js

@@ -0,0 +1,276 @@
+import { safeGetHeader } from "../../utils/h3-compat.js";
+import { defineCachedFunction, useRuntimeConfig } from "nitropack/runtime";
+import { resolveSitePath } from "nuxt-site-config/urls";
+import { joinURL, withHttps } from "ufo";
+import staticConfig from "#sitemap-virtual/static-config.mjs";
+import { applyDynamicParams, createPathFilter, findPageMapping, logger, resolveI18nSitemapLocaleKey, splitForLocales } from "../../../utils-pure.js";
+import { preNormalizeEntry } from "../urlset/normalise.js";
+import { sortInPlace } from "../urlset/sort.js";
+import { childSitemapSources, globalSitemapSources, resolveSitemapSources } from "../urlset/sources.js";
+import { parseChunkInfo, sliceUrlsForChunk } from "../utils/chunk.js";
+const SERVER_CACHE_MAX_AGE = staticConfig.cacheMaxAgeSeconds || 60 * 10;
+export function resolveSitemapEntries(sitemap, urls, runtimeConfig, resolvers, baseURL) {
+  const {
+    autoI18n,
+    isI18nMapped
+  } = runtimeConfig;
+  const filterPath = createPathFilter({
+    include: sitemap.include,
+    exclude: sitemap.exclude
+  }, baseURL || "/");
+  const _urls = urls.map((_e) => {
+    const e = preNormalizeEntry(_e, resolvers);
+    if (!e.loc || !filterPath(e.loc))
+      return false;
+    return e;
+  }).filter(Boolean);
+  let validI18nUrlsForTransform = [];
+  const withoutPrefixPaths = {};
+  if (autoI18n && autoI18n.strategy !== "no_prefix") {
+    const localeCodes = autoI18n.locales.map((l) => l.code);
+    const localeByCode = new Map(autoI18n.locales.map((l) => [l.code, l]));
+    const isPrefixStrategy = autoI18n.strategy === "prefix";
+    const isPrefixExceptOrAndDefault = autoI18n.strategy === "prefix_and_default" || autoI18n.strategy === "prefix_except_default";
+    const xDefaultAndLocales = [{ code: "x-default", _hreflang: "x-default" }, ...autoI18n.locales];
+    const defaultLocale = autoI18n.defaultLocale;
+    const hasPages = !!autoI18n.pages;
+    const hasDifferentDomains = !!autoI18n.differentDomains;
+    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 = defaultLocale;
+      const e = _e;
+      e._pathWithoutPrefix = pathWithoutPrefix;
+      const locale = localeByCode.get(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 === defaultLocale) {
+            entries.push({
+              href: u.loc,
+              hreflang: "x-default"
+            });
+          }
+          entries.push({
+            href: u.loc,
+            hreflang: u._locale._hreflang || defaultLocale
+          });
+          return entries;
+        }).flat().filter(Boolean);
+        if (alternatives.length)
+          e.alternatives = alternatives;
+      } else if (e._i18nTransform) {
+        delete e._i18nTransform;
+        if (hasDifferentDomains) {
+          const defLocale = localeByCode.get(defaultLocale);
+          e.alternatives = [
+            {
+              ...defLocale,
+              code: "x-default"
+            },
+            ...autoI18n.locales.filter((l) => !!l.domain)
+          ].map((locale) => {
+            return {
+              hreflang: locale._hreflang,
+              href: joinURL(withHttps(locale.domain), e._pathWithoutPrefix)
+            };
+          });
+        } else {
+          const pageMatch = hasPages ? findPageMapping(e._pathWithoutPrefix, autoI18n.pages) : null;
+          const pathSearch = e._path?.search || "";
+          const pathWithoutPrefix = e._pathWithoutPrefix;
+          for (const l of autoI18n.locales) {
+            let loc = pathWithoutPrefix;
+            if (pageMatch && pageMatch.mappings[l.code] !== void 0) {
+              const customPath = pageMatch.mappings[l.code];
+              if (customPath === false)
+                continue;
+              if (typeof customPath === "string") {
+                loc = customPath[0] === "/" ? customPath : `/${customPath}`;
+                loc = applyDynamicParams(loc, pageMatch.paramSegments);
+                if (isPrefixStrategy || isPrefixExceptOrAndDefault && l.code !== defaultLocale)
+                  loc = joinURL(`/${l.code}`, loc);
+              }
+            } else if (!hasDifferentDomains && !(isPrefixExceptOrAndDefault && l.code === defaultLocale)) {
+              loc = joinURL(`/${l.code}`, pathWithoutPrefix);
+            }
+            const _sitemap = isI18nMapped ? l._sitemap : void 0;
+            const alternatives = [];
+            for (const locale of xDefaultAndLocales) {
+              const code = locale.code === "x-default" ? defaultLocale : locale.code;
+              const isDefault = locale.code === "x-default" || locale.code === defaultLocale;
+              let href = pathWithoutPrefix;
+              if (pageMatch && pageMatch.mappings[code] !== void 0) {
+                const customPath = pageMatch.mappings[code];
+                if (customPath === false)
+                  continue;
+                if (typeof customPath === "string") {
+                  href = customPath[0] === "/" ? customPath : `/${customPath}`;
+                  href = applyDynamicParams(href, pageMatch.paramSegments);
+                  if (isPrefixStrategy || isPrefixExceptOrAndDefault && !isDefault)
+                    href = joinURL("/", code, href);
+                }
+              } else if (isPrefixStrategy) {
+                href = joinURL("/", code, pathWithoutPrefix);
+              } else if (isPrefixExceptOrAndDefault && !isDefault) {
+                href = joinURL("/", code, pathWithoutPrefix);
+              }
+              if (!filterPath(href))
+                continue;
+              alternatives.push({
+                hreflang: locale._hreflang,
+                href
+              });
+            }
+            const { _index: _, ...rest } = e;
+            const newEntry = preNormalizeEntry({
+              _sitemap,
+              ...rest,
+              _key: `${_sitemap || ""}${loc || "/"}${pathSearch}`,
+              _locale: l,
+              loc,
+              alternatives
+            }, 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;
+    }
+  }
+  return _urls;
+}
+export async function buildResolvedSitemapUrls(effectiveSitemap, matchName, isChunked, resolvers, runtimeConfig, nitro) {
+  const { sitemaps, autoI18n, isI18nMapped, isMultiSitemap, sortEntries } = runtimeConfig;
+  let sourcesInput = effectiveSitemap.includeAppSources ? [...await globalSitemapSources(), ...await childSitemapSources(effectiveSitemap)] : await childSitemapSources(effectiveSitemap);
+  if (nitro && resolvers.event) {
+    const ctx = {
+      event: resolvers.event,
+      sitemapName: matchName,
+      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: matchName,
+    event: resolvers.event
+  };
+  await nitro?.hooks.callHook("sitemap:input", resolvedCtx);
+  const enhancedUrls = resolveSitemapEntries(effectiveSitemap, resolvedCtx.urls, { autoI18n, isI18nMapped }, resolvers, useRuntimeConfig().app.baseURL);
+  const localeSitemapKeys = isI18nMapped && autoI18n ? autoI18n.locales.map((l) => l._sitemap) : [];
+  if (isMultiSitemap) {
+    const sitemapNames = Object.keys(sitemaps).filter((k) => k !== "index");
+    const warnedSitemaps = nitro?._sitemapWarnedSitemaps || /* @__PURE__ */ new Set();
+    for (const e of enhancedUrls) {
+      const hasMatchingSitemap = typeof e._sitemap === "string" && (sitemapNames.includes(e._sitemap) || isI18nMapped && sitemapNames.some((name) => resolveI18nSitemapLocaleKey(name, localeSitemapKeys) === e._sitemap));
+      if (typeof e._sitemap === "string" && !hasMatchingSitemap) {
+        if (!warnedSitemaps.has(e._sitemap)) {
+          warnedSitemaps.add(e._sitemap);
+          logger.error(`Sitemap \`${e._sitemap}\` not found in sitemap config. Available sitemaps: ${sitemapNames.join(", ")}. Entry \`${e.loc}\` will be omitted.`);
+        }
+      }
+    }
+    if (nitro) {
+      nitro._sitemapWarnedSitemaps = warnedSitemaps;
+    }
+  }
+  const filteredUrls = enhancedUrls.filter((e) => {
+    if (e._sitemap === false)
+      return false;
+    if (isMultiSitemap && e._sitemap && matchName) {
+      if (isChunked)
+        return e._sitemap === matchName;
+      if (e._sitemap === matchName)
+        return true;
+      if (isI18nMapped)
+        return e._sitemap === resolveI18nSitemapLocaleKey(matchName, localeSitemapKeys);
+      return false;
+    }
+    return true;
+  });
+  const urls = sortEntries ? sortInPlace(filteredUrls) : filteredUrls;
+  return { urls, failedSources };
+}
+export const buildResolvedSitemapUrlsCached = defineCachedFunction(
+  async (_event, effectiveSitemap, matchName, isChunked, resolvers, runtimeConfig, nitro) => buildResolvedSitemapUrls(effectiveSitemap, matchName, isChunked, resolvers, runtimeConfig, nitro),
+  {
+    name: "sitemap:resolved-urls",
+    group: "sitemap",
+    base: "sitemap",
+    maxAge: SERVER_CACHE_MAX_AGE,
+    getKey: (event, _effectiveSitemap, matchName, isChunked) => {
+      const host = safeGetHeader(event, "host") || safeGetHeader(event, "x-forwarded-host") || "";
+      const proto = safeGetHeader(event, "x-forwarded-proto") || "https";
+      return `resolved-${isChunked ? "chunked-" : ""}${matchName}-${proto}-${host}`;
+    },
+    swr: true
+  }
+);
+export async function getResolvedSitemapUrls(effectiveSitemap, matchName, isChunked, resolvers, runtimeConfig, nitro) {
+  const event = resolvers.event;
+  const shouldCache = !import.meta.dev && !import.meta.prerender && typeof runtimeConfig.cacheMaxAgeSeconds === "number" && runtimeConfig.cacheMaxAgeSeconds > 0;
+  if (shouldCache && event) {
+    return buildResolvedSitemapUrlsCached(event, effectiveSitemap, matchName, isChunked, resolvers, runtimeConfig, nitro);
+  }
+  return buildResolvedSitemapUrls(effectiveSitemap, matchName, isChunked, resolvers, runtimeConfig, nitro);
+}
+export async function buildSitemapUrls(sitemap, resolvers, runtimeConfig, nitro) {
+  const { sitemaps, autoI18n, defaultSitemapsChunkSize } = runtimeConfig;
+  const chunkSize = defaultSitemapsChunkSize || void 0;
+  const chunkInfo = parseChunkInfo(sitemap.sitemapName, sitemaps, chunkSize);
+  if (autoI18n?.differentDomains) {
+    const domain = autoI18n.locales.find((e) => e.language === sitemap.sitemapName || e.code === 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];
+  }
+  const matchName = chunkInfo.isChunked ? baseSitemapName : sitemap.sitemapName;
+  const resolved = await getResolvedSitemapUrls(effectiveSitemap, matchName, chunkInfo.isChunked, resolvers, runtimeConfig, nitro);
+  const urls = sliceUrlsForChunk(resolved.urls, sitemap.sitemapName, sitemaps, chunkSize);
+  return { urls, failedSources: resolved.failedSources };
+}
+export { urlsToXml } from "./xml.js";

package/server/patches/nuxt-seo/sitemap/event-handlers.js

@@ -0,0 +1,87 @@
+import { createError, getRouterParam, sendRedirect } from "h3";
+import { safeAppendHeader, safeSetHeader } from "../utils/h3-compat.js";
+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 { getSitemapConfig, parseChunkInfo } from "./utils/chunk.js";
+export async function sitemapXmlEventHandler(e) {
+  const runtimeConfig = useSitemapRuntimeConfig();
+  const { sitemaps } = runtimeConfig;
+  if ("index" in sitemaps)
+    return sendRedirect(e, withBase("/sitemap_index.xml", useRuntimeConfig().app.baseURL), import.meta.dev ? 302 : 301);
+  return createSitemap(e, Object.values(sitemaps)[0], runtimeConfig);
+}
+export async function sitemapIndexXmlEventHandler(e) {
+  const runtimeConfig = useSitemapRuntimeConfig();
+  const nitro = useNitroApp();
+  const resolvers = useNitroUrlResolvers(e);
+  const { entries: sitemaps, failedSources } = await buildSitemapIndex(resolvers, runtimeConfig, nitro);
+  if (import.meta.prerender) {
+    safeAppendHeader(
+      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);
+  safeSetHeader(e, "Content-Type", "text/xml; charset=UTF-8");
+  if (runtimeConfig.cacheMaxAgeSeconds) {
+    safeSetHeader(e, "Cache-Control", `public, max-age=${runtimeConfig.cacheMaxAgeSeconds}, s-maxage=${runtimeConfig.cacheMaxAgeSeconds}, stale-while-revalidate=3600`);
+    const now = /* @__PURE__ */ new Date();
+    safeSetHeader(e, "X-Sitemap-Generated", now.toISOString());
+    safeSetHeader(e, "X-Sitemap-Cache-Duration", `${runtimeConfig.cacheMaxAgeSeconds}s`);
+    const expiryTime = new Date(now.getTime() + runtimeConfig.cacheMaxAgeSeconds * 1e3);
+    safeSetHeader(e, "X-Sitemap-Cache-Expires", expiryTime.toISOString());
+    const remainingSeconds = Math.floor((expiryTime.getTime() - now.getTime()) / 1e3);
+    safeSetHeader(e, "X-Sitemap-Cache-Remaining", `${remainingSeconds}s`);
+  } else {
+    safeSetHeader(e, "Cache-Control", `no-cache, no-store`);
+  }
+  return ctx.sitemap;
+}
+export async function sitemapChildXmlEventHandler(e) {
+  if (!e.path.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$/);
+    if (match)
+      sitemapName = match[1];
+  }
+  if (!sitemapName)
+    throw createError({ statusCode: 400, message: "Invalid sitemap request" });
+  sitemapName = sitemapName.replace(/\.xml$/, "");
+  sitemapName = withLeadingSlash(sitemapName);
+  if (sitemapName.startsWith("/__sitemap__/"))
+    sitemapName = sitemapName.replace("/__sitemap__/", "/");
+  if (runtimeConfig.sitemapsPathPrefix) {
+    const prefix = withLeadingSlash(runtimeConfig.sitemapsPathPrefix);
+    if (sitemapName.startsWith(prefix))
+      sitemapName = sitemapName.replace(prefix, "/");
+  }
+  sitemapName = withoutLeadingSlash(withoutTrailingSlash(sitemapName));
+  const chunkInfo = parseChunkInfo(sitemapName, sitemaps, runtimeConfig.defaultSitemapsChunkSize);
+  const isAutoChunked = typeof sitemaps.chunks !== "undefined" && !Number.isNaN(Number(sitemapName));
+  const sitemapExists = sitemapName in sitemaps || chunkInfo.baseSitemapName in sitemaps || isAutoChunked;
+  if (!sitemapExists)
+    throw createError({ statusCode: 404, message: `Sitemap "${sitemapName}" not found.` });
+  if (chunkInfo.isChunked && chunkInfo.chunkIndex !== void 0) {
+    const baseSitemap = sitemaps[chunkInfo.baseSitemapName];
+    if (baseSitemap && !baseSitemap.chunks && !baseSitemap._isChunking)
+      throw createError({ statusCode: 404, message: `Sitemap "${chunkInfo.baseSitemapName}" does not support chunking.` });
+    if (baseSitemap?._chunkCount !== void 0 && chunkInfo.chunkIndex >= baseSitemap._chunkCount)
+      throw createError({ statusCode: 404, message: `Chunk ${chunkInfo.chunkIndex} does not exist for sitemap "${chunkInfo.baseSitemapName}".` });
+  }
+  const sitemapConfig = getSitemapConfig(sitemapName, sitemaps, runtimeConfig.defaultSitemapsChunkSize || void 0);
+  return createSitemap(e, sitemapConfig, runtimeConfig);
+}

package/server/patches/nuxt-seo/sitemap/nitro.js

@@ -0,0 +1,157 @@
+import { defu } from "defu";
+import { createError } from "h3";
+import { safeGetHeader, safeGetQuery, safeSetHeader } from "../utils/h3-compat.js";
+import { defineCachedFunction, useNitroApp } from "nitropack/runtime";
+import { fixSlashes } from "nuxt-site-config/urls";
+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 } from "./builder/sitemap.js";
+import { normaliseEntry, preNormalizeEntry } from "./urlset/normalise.js";
+import { sortInPlace } from "./urlset/sort.js";
+const SERVER_CACHE_MAX_AGE = staticConfig.cacheMaxAgeSeconds || 60 * 10;
+
+export function useNitroUrlResolvers(e) {
+  const canonicalQuery = safeGetQuery(e).canonical;
+  const isShowingCanonical = typeof canonicalQuery !== "undefined" && canonicalQuery !== "false";
+  const siteConfig = getSiteConfig(e);
+  return {
+    event: e,
+    fixSlashes: (path) => fixSlashes(siteConfig.trailingSlash, path),
+    // we need these as they depend on the nitro event
+    canonicalUrlResolver: createSitePathResolver(e, {
+      canonical: isShowingCanonical || !import.meta.dev,
+      absolute: true,
+      withBase: true
+    }),
+    relativeBaseUrlResolver: createSitePathResolver(e, { absolute: false, withBase: true })
+  };
+}
+async function buildSitemapXml(event, definition, resolvers, runtimeConfig) {
+  const { sitemapName } = definition;
+  const nitro = useNitroApp();
+  if (import.meta.prerender) {
+    const config = getSiteConfig(event);
+    if (!config.url && !nitro._sitemapWarned) {
+      nitro._sitemapWarned = true;
+      logger.error("Sitemap Site URL missing!");
+      logger.info("To fix this please add `{ site: { url: 'site.com' } }` to your Nuxt config or a `NUXT_PUBLIC_SITE_URL=site.com` to your .env. Learn more at https://nuxtseo.com/site-config/getting-started/how-it-works");
+      throw createError({
+        statusMessage: "You must provide a site URL to prerender a sitemap.",
+        statusCode: 500
+      });
+    }
+  }
+  const { urls: sitemapUrls, failedSources } = await buildSitemapUrls(definition, resolvers, runtimeConfig, nitro);
+  if (import.meta.prerender && failedSources.length) {
+    throw createError({
+      statusCode: 500,
+      message: `Sitemap generation failed due to ${failedSources.length} failed sources: ${failedSources.map((s) => `"${s.url}" (${s.error})`).join(", ")}`
+    });
+  }
+  const routeRuleMatcher = createNitroRouteRuleMatcher();
+  const { autoI18n } = runtimeConfig;
+  let validCount = 0;
+  for (let i = 0; i < sitemapUrls.length; i++) {
+    const u = sitemapUrls[i];
+    const path = u._path?.pathname || u.loc;
+    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));
+      const pathWithoutPrefix = match[1];
+      if (pathWithoutPrefix && pathWithoutPrefix !== path)
+        routeRules = defu(routeRules, routeRuleMatcher(pathWithoutPrefix));
+    }
+    if (routeRules.sitemap === false)
+      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"));
+    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.`);
+  }
+  const locSize = sitemapUrls.length;
+  const resolvedCtx = {
+    urls: sitemapUrls,
+    sitemapName,
+    event
+  };
+  await nitro.hooks.callHook("sitemap:resolved", resolvedCtx);
+  if (resolvedCtx.urls.length !== locSize) {
+    resolvedCtx.urls = resolvedCtx.urls.map((e) => preNormalizeEntry(e, 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)));
+  if (definition._isChunking && definition.sitemapName.includes("-")) {
+    const parts = definition.sitemapName.split("-");
+    const lastPart = parts.pop();
+    if (!Number.isNaN(Number(lastPart))) {
+      const chunkIndex = Number(lastPart);
+      const baseSitemapName = parts.join("-");
+      if (urls.length === 0 && chunkIndex > 0) {
+        throw createError({
+          statusCode: 404,
+          message: `Sitemap chunk ${chunkIndex} for "${baseSitemapName}" does not exist.`
+        });
+      }
+    }
+  }
+  const errorInfo = failedSources.length > 0 ? {
+    messages: failedSources.map((f) => f.error),
+    urls: failedSources.map((f) => f.url)
+  } : void 0;
+  const sitemap = urlsToXml(urls, resolvers, runtimeConfig, errorInfo);
+  const ctx = { sitemap, sitemapName, event };
+  await nitro.hooks.callHook("sitemap:output", ctx);
+  return ctx.sitemap;
+}
+const buildSitemapXmlCached = defineCachedFunction(
+  buildSitemapXml,
+  {
+    name: "sitemap:xml",
+    group: "sitemap",
+    maxAge: SERVER_CACHE_MAX_AGE,
+    base: "sitemap",
+    // Use the sitemap storage
+    getKey: (event, definition) => {
+      const host = safeGetHeader(event, "host") || safeGetHeader(event, "x-forwarded-host") || "";
+      const proto = safeGetHeader(event, "x-forwarded-proto") || "https";
+      const sitemapName = definition.sitemapName || "default";
+      return `${sitemapName}-${proto}-${host}`;
+    },
+    swr: true
+    // Enable stale-while-revalidate
+  }
+);
+export async function createSitemap(event, definition, runtimeConfig) {
+  const resolvers = useNitroUrlResolvers(event);
+  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);
+  safeSetHeader(event, "Content-Type", "text/xml; charset=UTF-8");
+  if (runtimeConfig.cacheMaxAgeSeconds) {
+    safeSetHeader(event, "Cache-Control", `public, max-age=${runtimeConfig.cacheMaxAgeSeconds}, s-maxage=${runtimeConfig.cacheMaxAgeSeconds}, stale-while-revalidate=3600`);
+    const now = /* @__PURE__ */ new Date();
+    safeSetHeader(event, "X-Sitemap-Generated", now.toISOString());
+    safeSetHeader(event, "X-Sitemap-Cache-Duration", `${runtimeConfig.cacheMaxAgeSeconds}s`);
+    const expiryTime = new Date(now.getTime() + runtimeConfig.cacheMaxAgeSeconds * 1e3);
+    safeSetHeader(event, "X-Sitemap-Cache-Expires", expiryTime.toISOString());
+    const remainingSeconds = Math.floor((expiryTime.getTime() - now.getTime()) / 1e3);
+    safeSetHeader(event, "X-Sitemap-Cache-Remaining", `${remainingSeconds}s`);
+  } else {
+    safeSetHeader(event, "Cache-Control", `no-cache, no-store`);
+  }
+  event.context._isSitemap = true;
+  return xml;
+}