@nuxtjs/sitemap 7.4.11 → 7.5.1

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

@@ -0,0 +1,77 @@
+import { appendHeader, createError, getRouterParam, sendRedirect, setHeader } from "h3";
+import { joinURL, withBase, withoutLeadingSlash, withoutTrailingSlash } from "ufo";
+import { useRuntimeConfig, useNitroApp } from "nitropack/runtime";
+import { useSitemapRuntimeConfig } from "../utils.js";
+import { createSitemap, useNitroUrlResolvers } from "./nitro.js";
+import { buildSitemapIndex, urlsToIndexXml } from "./builder/sitemap-index.js";
+import { parseChunkInfo, getSitemapConfig } 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) {
+    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;
+}
+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 = withoutLeadingSlash(withoutTrailingSlash(sitemapName.replace(".xml", "").replace("__sitemap__/", "").replace(runtimeConfig.sitemapsPathPrefix || "", "")));
+  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/dist/runtime/server/sitemap/urlset/normalise.js

@@ -32,6 +32,7 @@ export function preNormalizeEntry(_e, resolvers) {
   if (typeof input.loc !== "string") {
     input.loc = "";
   }
+  const skipEncoding = input._encoded === true;
   const e = input;
   e.loc = removeTrailingSlash(e.loc);
   e._abs = hasProtocol(e.loc, { acceptRelative: false, strict: false });
@@ -43,13 +44,14 @@ export function preNormalizeEntry(_e, resolvers) {
   if (e._path) {
     const search = e._path.search;
     const qs = search && search.length > 1 ? stringifyQuery(parseQuery(search)) : "";
-    e._relativeLoc = `${encodePath(e._path.pathname)}${qs.length ? `?${qs}` : ""}`;
+    const pathname = skipEncoding ? e._path.pathname : encodePath(e._path.pathname);
+    e._relativeLoc = `${pathname}${qs.length ? `?${qs}` : ""}`;
     if (e._path.host) {
       e.loc = stringifyParsedURL(e._path);
     } else {
       e.loc = e._relativeLoc;
     }
-  } else if (!isEncoded(e.loc)) {
+  } else if (!skipEncoding && !isEncoded(e.loc)) {
     e.loc = encodeURI(e.loc);
   }
   if (e.loc === "")

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

@@ -1,6 +1,7 @@
 import type { H3Event } from 'h3';
-import type { ModuleRuntimeConfig, SitemapSourceBase, SitemapSourceResolved } from '../../../types.js';
+import type { ModuleRuntimeConfig, SitemapSourceBase, SitemapSourceInput, SitemapSourceResolved } from '../../../types.js';
+export declare function normalizeSourceInput(source: SitemapSourceInput): SitemapSourceBase | SitemapSourceResolved;
 export declare function fetchDataSource(input: SitemapSourceBase | SitemapSourceResolved, event?: H3Event): Promise<SitemapSourceResolved>;
 export declare function globalSitemapSources(): Promise<any[]>;
 export declare function childSitemapSources(definition: ModuleRuntimeConfig['sitemaps'][string]): Promise<any[]>;
-export declare function resolveSitemapSources(sources: (SitemapSourceBase | SitemapSourceResolved)[], event?: H3Event): Promise<SitemapSourceResolved[]>;
+export declare function resolveSitemapSources(sources: SitemapSourceInput[], event?: H3Event): Promise<SitemapSourceResolved[]>;

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

@@ -3,6 +3,15 @@ import { defu } from "defu";
 import { parseURL } from "ufo";
 import { logger } from "../../../utils-pure.js";
 import { parseSitemapXml } from "@nuxtjs/sitemap/utils";
+export function normalizeSourceInput(source) {
+  if (typeof source === "string") {
+    return { context: { name: "hook" }, fetch: source };
+  }
+  if (Array.isArray(source)) {
+    return { context: { name: "hook" }, fetch: source };
+  }
+  return source;
+}
 async function tryFetchWithFallback(url, options, event) {
   const isExternalUrl = !url.startsWith("/");
   if (isExternalUrl) {
@@ -143,17 +152,18 @@ export async function childSitemapSources(definition) {
 export async function resolveSitemapSources(sources, event) {
   return (await Promise.all(
     sources.map((source) => {
-      if (typeof source === "object" && "urls" in source) {
+      const normalized = normalizeSourceInput(source);
+      if ("urls" in normalized) {
         return {
           timeTakenMs: 0,
-          ...source,
-          urls: source.urls
+          ...normalized,
+          urls: normalized.urls
         };
       }
-      if (source.fetch)
-        return fetchDataSource(source, event);
+      if (normalized.fetch)
+        return fetchDataSource(normalized, event);
       return {
-        ...source,
+        ...normalized,
         error: "Invalid source"
       };
     })

package/dist/runtime/types.d.ts

@@ -153,6 +153,15 @@ export interface ModuleOptions extends SitemapDefinition {
      * @experimental Will be enabled by default in v5 (if stable)
      */
     experimentalCompression?: boolean;
+    /**
+     * When enabled, sitemap generation only runs during prerendering.
+     * The sitemap building code is tree-shaken from the runtime bundle.
+     *
+     * Requires sitemaps to be prerendered (e.g., `nuxt generate` or `nitro.prerender.routes` includes sitemap).
+     *
+     * @default false
+     */
+    zeroRuntime?: boolean;
 }
 export interface IndexSitemapRemotes {
     index?: (string | SitemapIndexEntry)[];
@@ -357,7 +366,7 @@ export interface SitemapOutputHookCtx extends NitroBaseHook {
 }
 export interface SitemapSourcesHookCtx extends NitroBaseHook {
     sitemapName: string;
-    sources: (SitemapSourceBase | SitemapSourceResolved)[];
+    sources: SitemapSourceInput[];
 }
 export type Changefreq = 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never';
 export interface SitemapUrl {
@@ -375,6 +384,21 @@ export interface SitemapUrl {
     videos?: Array<VideoEntry>;
     _i18nTransform?: boolean;
     _sitemap?: string | false;
+    /**
+     * Mark the URL as already encoded.
+     *
+     * When true, the loc will not be automatically encoded, preventing double-encoding
+     * when you've already applied encodeURIComponent() to path segments.
+     *
+     * @example
+     * ```ts
+     * {
+     *   loc: `/${encodeURIComponent('$pecial-char')}`,
+     *   _encoded: true
+     * }
+     * ```
+     */
+    _encoded?: boolean;
 }
 export type SitemapStrict = Required<SitemapUrl>;
 export interface AlternativeEntry {

package/dist/runtime/utils-pure.d.ts

@@ -11,4 +11,10 @@ export interface CreateFilterOptions {
     exclude?: (FilterInput | string | RegExp)[];
 }
 export declare function createPathFilter(options?: CreateFilterOptions): (loc: string) => boolean;
+export interface PageMatch {
+    mappings: Record<string, string | false>;
+    paramSegments: string[];
+}
+export declare function findPageMapping(pathWithoutPrefix: string, pages: Record<string, Record<string, string | false>>): PageMatch | null;
+export declare function applyDynamicParams(customPath: string, paramSegments: string[]): string;
 export declare function createFilter(options?: CreateFilterOptions): (path: string) => boolean;

package/dist/runtime/utils-pure.js

@@ -58,6 +58,26 @@ export function createPathFilter(options = {}) {
     return urlFilter(path);
   };
 }
+export function findPageMapping(pathWithoutPrefix, pages) {
+  const stripped = pathWithoutPrefix[0] === "/" ? pathWithoutPrefix.slice(1) : pathWithoutPrefix;
+  const pageKey = stripped.endsWith("/index") ? stripped.slice(0, -6) || "index" : stripped || "index";
+  if (pages[pageKey])
+    return { mappings: pages[pageKey], paramSegments: [] };
+  const sortedKeys = Object.keys(pages).sort((a, b) => b.length - a.length);
+  for (const key of sortedKeys) {
+    if (pageKey.startsWith(key + "/")) {
+      const paramPath = pageKey.slice(key.length + 1);
+      return { mappings: pages[key], paramSegments: paramPath.split("/") };
+    }
+  }
+  return null;
+}
+export function applyDynamicParams(customPath, paramSegments) {
+  if (!paramSegments.length)
+    return customPath;
+  let i = 0;
+  return customPath.replace(/\[[^\]]+\]/g, () => paramSegments[i++] || "");
+}
 export function createFilter(options = {}) {
   const include = options.include || [];
   const exclude = options.exclude || [];

package/dist/types.d.mts

@@ -1,5 +1,11 @@
+import type { ModuleHooks } from './module.mjs'
+
+declare module '@nuxt/schema' {
+  interface NuxtHooks extends ModuleHooks {}
+}
+
 export { default } from './module.mjs'
 
-export { type ModuleOptions } from './module.mjs'
+export { type ModuleHooks, type ModuleOptions } from './module.mjs'
 
 export * from '../dist/runtime/types.js'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nuxtjs/sitemap",
   "type": "module",
-  "version": "7.4.11",
+  "version": "7.5.1",
   "description": "Powerfully flexible XML Sitemaps that integrate seamlessly, for Nuxt.",
   "author": {
     "name": "Harlan Wilton",
@@ -75,13 +75,14 @@
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.2",
-    "@nuxt/content": "^3.9.0",
+    "@nuxt/content": "^3.10.0",
     "@nuxt/eslint-config": "^1.12.1",
     "@nuxt/module-builder": "^1.0.2",
-    "@nuxt/test-utils": "^3.21.0",
-    "@nuxt/ui": "^4.2.1",
+    "@nuxt/test-utils": "^3.22.0",
+    "@nuxt/ui": "^4.3.0",
     "@nuxtjs/i18n": "^10.2.1",
     "@nuxtjs/robots": "^5.6.7",
+    "@vue/test-utils": "^2.4.6",
     "better-sqlite3": "^12.5.0",
     "bumpp": "^10.3.2",
     "eslint": "^9.39.2",
@@ -89,11 +90,11 @@
     "execa": "^9.6.1",
     "happy-dom": "^20.0.11",
     "nuxt": "^4.2.2",
-    "nuxt-i18n-micro": "^2.15.2",
+    "nuxt-i18n-micro": "^2.16.3",
     "typescript": "^5.9.3",
     "vitest": "3.2.4",
-    "vue-tsc": "^3.1.8",
-    "@nuxtjs/sitemap": "7.4.11"
+    "vue-tsc": "^3.2.2",
+    "@nuxtjs/sitemap": "7.5.1"
   },
   "scripts": {
     "lint": "eslint .",