@nuxtjs/sitemap 8.2.3 → 8.3.1

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

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

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

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

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

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

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

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

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

@@ -40,7 +40,14 @@ function resolve(s, resolvers) {
   return resolvers.canonicalUrlResolver(str);
 }
 function removeTrailingSlash(s) {
-  return s.replace(/\/(\?|#|$)/, "$1");
+  let pathEnd = s.length;
+  const queryIndex = s.indexOf("?");
+  if (queryIndex !== -1)
+    pathEnd = queryIndex;
+  const hashIndex = s.indexOf("#");
+  if (hashIndex !== -1 && hashIndex < pathEnd)
+    pathEnd = hashIndex;
+  return pathEnd > 0 && s.charCodeAt(pathEnd - 1) === 47 ? s.slice(0, pathEnd - 1) + s.slice(pathEnd) : s;
 }
 export function preNormalizeEntry(_e, resolvers) {
   const input = typeof _e === "string" ? { loc: _e } : { ..._e };
@@ -86,15 +93,19 @@ export function isEncoded(url) {
     return false;
   }
 }
-export function normaliseEntry(_e, defaults, resolvers) {
-  const e = defu(_e, defaults);
+export function normaliseEntry(_e, defaults, resolvers, cache) {
+  const e = defaults ? defu(_e, defaults) : { ..._e };
   if (import.meta.dev) {
     const warnings = validateSitemapUrl(e);
     if (warnings.length)
       e._warnings = (e._warnings || []).concat(warnings);
   }
   if (e.lastmod) {
-    const date = normaliseDate(e.lastmod);
+    const date = cache?.lastmodInput === e.lastmod ? cache.lastmodOutput : normaliseDate(e.lastmod);
+    if (cache && cache.lastmodInput !== e.lastmod) {
+      cache.lastmodInput = e.lastmod;
+      cache.lastmodOutput = date;
+    }
     if (date)
       e.lastmod = date;
     else
@@ -133,13 +144,22 @@ export function normaliseEntry(_e, defaults, resolvers) {
   return e;
 }
 const IS_VALID_W3C_DATE = [
-  /(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))/,
+  /^\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z)$/,
+  /^\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z)$/,
+  /^\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z)$/,
   /^\d{4}-[01]\d-[0-3]\d$/,
   /^\d{4}-[01]\d$/,
   /^\d{4}$/
 ];
 export function isValidW3CDate(d) {
-  return IS_VALID_W3C_DATE.some((r) => r.test(d));
+  if (!IS_VALID_W3C_DATE.some((r) => r.test(d)))
+    return false;
+  const [year, month, day] = d.slice(0, 10).split("-").map(Number);
+  if (month !== void 0 && (month < 1 || month > 12))
+    return false;
+  if (day !== void 0 && (day < 1 || day > new Date(year, month, 0).getDate()))
+    return false;
+  return true;
 }
 export function normaliseDate(d) {
   if (typeof d === "string") {

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

@@ -1,13 +1,22 @@
+const naturalCompare = new Intl.Collator(void 0, { numeric: true }).compare;
+function countPathSegments(loc) {
+  let segments = 1;
+  for (let i = 0; i < loc.length; i++) {
+    if (loc.charCodeAt(i) === 47)
+      segments++;
+  }
+  return segments;
+}
 export function sortInPlace(urls) {
   urls.sort((a, b) => {
     const aLoc = typeof a === "string" ? a : a.loc;
     const bLoc = typeof b === "string" ? b : b.loc;
-    const aSegments = aLoc.split("/").length;
-    const bSegments = bLoc.split("/").length;
+    const aSegments = countPathSegments(aLoc);
+    const bSegments = countPathSegments(bLoc);
     if (aSegments !== bSegments) {
       return aSegments - bSegments;
     }
-    return aLoc.localeCompare(bLoc, void 0, { numeric: true });
+    return naturalCompare(aLoc, bLoc);
   });
   return urls;
 }

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

@@ -1,8 +1,39 @@
-import { parseSitemapXml } from "@nuxtjs/sitemap/utils";
 import { defu } from "defu";
 import { getRequestHost } from "h3";
+import { collectSitemap } from "sitemapd/parse";
 import { parseURL } from "ufo";
 import { logger } from "../../../utils-pure.js";
+const changeFrequencies = /* @__PURE__ */ new Set([
+  "always",
+  "hourly",
+  "daily",
+  "weekly",
+  "monthly",
+  "yearly",
+  "never"
+]);
+function readerEntryToSitemapInput(entry) {
+  const priority = entry.priority === void 0 ? void 0 : Number.parseFloat(entry.priority);
+  const changefreq = entry.changefreq && changeFrequencies.has(entry.changefreq) ? entry.changefreq : void 0;
+  return {
+    loc: entry.loc,
+    ...entry.lastmod ? { lastmod: entry.lastmod } : {},
+    ...changefreq ? { changefreq } : {},
+    ...priority !== void 0 && Number.isFinite(priority) ? { priority } : {},
+    ...entry.extensions?.alternatives ? { alternatives: entry.extensions.alternatives.map(({ hreflang, href }) => ({ hreflang, href })) } : {},
+    ...entry.extensions?.images ? {
+      images: entry.extensions.images.map((image) => ({
+        loc: image.loc,
+        ...image.caption ? { caption: image.caption } : {},
+        ...image.geoLocation ? { geo_location: image.geoLocation } : {},
+        ...image.title ? { title: image.title } : {},
+        ...image.license ? { license: image.license } : {}
+      }))
+    } : {},
+    ...entry.extensions?.videos ? { videos: entry.extensions.videos } : {},
+    ...entry.extensions?.news ? { news: entry.extensions.news } : {}
+  };
+}
 export function normalizeSourceInput(source) {
   if (typeof source === "string") {
     return { context: { name: "hook" }, fetch: source };
@@ -48,7 +79,9 @@ export async function fetchDataSource(input, event) {
   const abortRequestTimeout = setTimeout(() => timeoutController.abort(), timeout);
   try {
     let isMaybeErrorResponse = false;
-    const isXmlRequest = parseURL(url).pathname.endsWith(".xml");
+    const pathname = parseURL(url).pathname.toLowerCase();
+    const isGzUrl = pathname.endsWith(".gz");
+    const isXmlRequest = pathname.endsWith(".xml") || isGzUrl;
     const mergedHeaders = defu(
       options?.headers,
       {
@@ -58,7 +91,10 @@ export async function fetchDataSource(input, event) {
     );
     const fetchOptions = {
       ...options,
-      responseType: isXmlRequest ? "text" : "json",
+      // Fetch XML sources as raw bytes so we can detect and decompress a gzip body
+      // (either a `.gz` URL, or a server that serves gzip without Content-Encoding)
+      // before it's mangled by a UTF-8 text decode.
+      responseType: isXmlRequest ? "arrayBuffer" : "json",
       signal: timeoutController.signal,
       headers: mergedHeaders,
       // Use ofetch's built-in retry for external sources
@@ -84,11 +120,16 @@ export async function fetchDataSource(input, event) {
       };
     }
     let urls = [];
-    if (typeof res === "object") {
+    if (isXmlRequest) {
+      const bytes = res instanceof Uint8Array ? res : new Uint8Array(res);
+      const result = await collectSitemap(bytes);
+      if (result._tag !== "document")
+        throw new Error(result.issues.map((issue) => issue.message).join("; ") || "Invalid sitemap document");
+      if (result.document._tag !== "urlset")
+        throw new Error("Sitemap URL source must be a URL set, not a sitemap index");
+      urls = result.document.entries.map(readerEntryToSitemapInput);
+    } else if (typeof res === "object") {
       urls = res.urls || res;
-    } else if (typeof res === "string" && parseURL(url).pathname.endsWith(".xml")) {
-      const result = await parseSitemapXml(res);
-      urls = result.urls;
     }
     return {
       ...input,
@@ -150,7 +191,7 @@ export async function childSitemapSources(definition) {
   return [...m.sources[definition.sitemapName] || []];
 }
 export async function resolveSitemapSources(sources, event) {
-  return (await Promise.all(
+  return await Promise.all(
     sources.map((source) => {
       const normalized = normalizeSourceInput(source);
       if ("urls" in normalized) {
@@ -167,5 +208,5 @@ export async function resolveSitemapSources(sources, event) {
         error: "Invalid source"
       };
     })
-  )).flat();
+  );
 }

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

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

package/dist/runtime/server/utils.js

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