@nuxtjs/sitemap 2.3.2 → 5.0.0

package/dist/runtime/nitro/composables/asSitemapUrl.d.ts

@@ -0,0 +1,2 @@
+import type { SitemapUrlInput } from '../../types';
+export declare function asSitemapUrl(url: SitemapUrlInput | Record<string, any>): SitemapUrlInput;

package/dist/runtime/nitro/composables/asSitemapUrl.mjs

@@ -0,0 +1,3 @@
+export function asSitemapUrl(url) {
+  return url;
+}

package/dist/runtime/nitro/composables/defineSitemapEventHandler.d.ts

@@ -0,0 +1,3 @@
+import { type EventHandlerRequest, type EventHandlerResponse, defineEventHandler } from 'h3';
+import type { SitemapUrlInput } from '../../types';
+export declare const defineSitemapEventHandler: typeof defineEventHandler<EventHandlerRequest, EventHandlerResponse<SitemapUrlInput[]>>;

package/dist/runtime/nitro/composables/defineSitemapEventHandler.mjs

@@ -0,0 +1,2 @@
+import { defineEventHandler } from "h3";
+export const defineSitemapEventHandler = defineEventHandler;

package/dist/runtime/nitro/composables/getPathRobotConfigPolyfill.d.ts

@@ -0,0 +1,4 @@
+export declare function getPathRobotConfigPolyfill(): {
+    indexable: boolean;
+    rule: string;
+};

package/dist/runtime/nitro/composables/getPathRobotConfigPolyfill.mjs

@@ -0,0 +1,3 @@
+export function getPathRobotConfigPolyfill() {
+  return { indexable: true, rule: "index, follow" };
+}

package/dist/runtime/nitro/kit.d.ts

@@ -0,0 +1,3 @@
+import type { NitroRouteRules } from 'nitropack';
+export declare function withoutQuery(path: string): string;
+export declare function createNitroRouteRuleMatcher(): (path: string) => NitroRouteRules;

package/dist/runtime/nitro/kit.mjs

@@ -0,0 +1,23 @@
+import { createRouter as createRadixRouter, toRouteMatcher } from "radix3";
+import { defu } from "defu";
+import { withoutBase, withoutTrailingSlash } from "ufo";
+import { useRuntimeConfig } from "#imports";
+export function withoutQuery(path) {
+  return path.split("?")[0];
+}
+export function createNitroRouteRuleMatcher() {
+  const { nitro, app } = useRuntimeConfig();
+  const _routeRulesMatcher = toRouteMatcher(
+    createRadixRouter({
+      routes: Object.fromEntries(
+        Object.entries(nitro?.routeRules || {}).map(([path, rules]) => [withoutTrailingSlash(path), rules])
+      )
+    })
+  );
+  return (path) => {
+    return defu({}, ..._routeRulesMatcher.matchAll(
+      // radix3 does not support trailing slashes
+      withoutBase(withoutTrailingSlash(withoutQuery(path)), app.baseURL)
+    ).reverse());
+  };
+}

package/dist/runtime/nitro/middleware/[sitemap]-sitemap.xml.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string | import("h3").H3Error<unknown> | undefined>>;
+export default _default;

package/dist/runtime/nitro/middleware/[sitemap]-sitemap.xml.mjs

@@ -0,0 +1,23 @@
+import { createError, defineEventHandler } from "h3";
+import { parseURL } from "ufo";
+import { useSimpleSitemapRuntimeConfig } from "../utils.mjs";
+import { createSitemap } from "../sitemap/nitro.mjs";
+export default defineEventHandler(async (e) => {
+  const path = parseURL(e.path).pathname;
+  if (!path.endsWith("-sitemap.xml"))
+    return;
+  const runtimeConfig = useSimpleSitemapRuntimeConfig();
+  const { sitemaps } = runtimeConfig;
+  const sitemapName = path.replace("-sitemap.xml", "").replace("/", "");
+  const isChunking = typeof sitemaps.chunks !== "undefined" && !Number.isNaN(Number(sitemapName));
+  if (!(sitemapName in sitemaps) && !isChunking) {
+    return createError({
+      statusCode: 404,
+      message: `Sitemap "${sitemapName}" not found.`
+    });
+  }
+  return createSitemap(e, isChunking ? {
+    ...sitemaps.chunks,
+    sitemapName
+  } : sitemaps[sitemapName], runtimeConfig);
+});

package/dist/runtime/nitro/plugins/compression.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/nitro/plugins/compression.mjs

@@ -0,0 +1,8 @@
+import { useCompressionStream } from "h3-compression";
+import { defineNitroPlugin } from "#imports";
+export default defineNitroPlugin((nitro) => {
+  nitro.hooks.hook("beforeResponse", async (event, response) => {
+    if (event.context._isSitemap)
+      await useCompressionStream(event, response);
+  });
+});

package/dist/runtime/nitro/plugins/nuxt-content.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nitropack/dist/runtime/plugin").NitroAppPlugin;
+export default _default;

package/dist/runtime/nitro/plugins/nuxt-content.mjs

@@ -0,0 +1,38 @@
+import { defu } from "defu";
+import { defineNitroPlugin } from "nitropack/dist/runtime/plugin";
+import { useSimpleSitemapRuntimeConfig } from "../utils.mjs";
+export default defineNitroPlugin((nitroApp) => {
+  const { discoverImages, isNuxtContentDocumentDriven } = useSimpleSitemapRuntimeConfig();
+  nitroApp.hooks.hook("content:file:afterParse", async (content) => {
+    if (content.sitemap === false || content._draft || content._extension !== "md" || content._partial || content.indexable === false || content.index === false)
+      return;
+    let images = [];
+    if (discoverImages) {
+      images = content.body?.children?.filter(
+        (c) => c.tag && c.props?.src && ["image", "img", "nuxtimg", "nuxt-img"].includes(c.tag.toLowerCase())
+      ).map((i) => ({ loc: i.props.src })) || [];
+    }
+    const sitemapConfig = typeof content.sitemap === "object" ? content.sitemap : {};
+    const lastmod = content.modifiedAt || content.updatedAt;
+    const defaults = {};
+    if (isNuxtContentDocumentDriven)
+      defaults.loc = content._path;
+    if (content.path)
+      defaults.loc = content.path;
+    if (images.length > 0)
+      defaults.images = images;
+    if (lastmod)
+      defaults.lastmod = lastmod;
+    const definition = defu(sitemapConfig, defaults);
+    if (!definition.loc) {
+      if (content.path && content.path && content.path.startsWith("/"))
+        definition.loc = content.path;
+      if (Object.keys(sitemapConfig).length > 0 && import.meta.dev)
+        console.warn(`[@nuxtjs/content] The @nuxt/content file \`${content._path}\` is missing a sitemap \`loc\`.`);
+    }
+    content.sitemap = definition;
+    if (!definition.loc)
+      delete content.sitemap;
+    return content;
+  });
+});

package/dist/runtime/nitro/plugins/warm-up.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nitropack/dist/runtime/plugin").NitroAppPlugin;
+export default _default;

package/dist/runtime/nitro/plugins/warm-up.mjs

@@ -0,0 +1,23 @@
+import { defineNitroPlugin } from "nitropack/dist/runtime/plugin";
+import { withLeadingSlash } from "ufo";
+import { useSimpleSitemapRuntimeConfig } from "../utils.mjs";
+export default defineNitroPlugin((nitroApp) => {
+  const { sitemaps } = useSimpleSitemapRuntimeConfig();
+  const queue = [];
+  const sitemapsWithRoutes = Object.entries(sitemaps).filter(([, sitemap]) => sitemap._route);
+  for (const [, sitemap] of sitemapsWithRoutes)
+    queue.push(() => nitroApp.localFetch(withLeadingSlash(sitemap._route), {}));
+  setTimeout(
+    () => {
+      const next = async () => {
+        if (queue.length === 0)
+          return;
+        await queue.shift()();
+        setTimeout(next, 1e3);
+      };
+      next();
+    },
+    2500
+    /* https://github.com/unjs/nitro/pull/1906 */
+  );
+});

package/dist/runtime/nitro/routes/__sitemap__/debug.d.ts

@@ -0,0 +1,37 @@
+import type { SitemapDefinition } from '../../../types';
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    nitroOrigin: any;
+    sitemaps: Record<string, SitemapDefinition>;
+    runtimeConfig: {
+        version: string;
+        isNuxtContentDocumentDriven: boolean;
+        sitemaps: {
+            index?: (Pick<SitemapDefinition, "sitemapName" | "_route"> & {
+                sitemaps: import("../../../types").SitemapIndexEntry[];
+            }) | undefined;
+        } & Record<string, Omit<SitemapDefinition, "urls" | "sources"> & {
+            _hasSourceChunk?: boolean | undefined;
+        }>;
+        autoI18n?: import("../../../types").AutoI18nConfig | undefined;
+        isMultiSitemap: boolean;
+        isI18nMapped: boolean;
+        cacheMaxAgeSeconds: number | false;
+        sitemapName: string;
+        excludeAppSources: true | import("../../../types").AppSourceContext[];
+        sortEntries: boolean;
+        defaultSitemapsChunkSize: number | false;
+        xslColumns?: {
+            label: string;
+            width: `${string}%`;
+            select?: string | undefined;
+        }[] | undefined;
+        xslTips: boolean;
+        debug: boolean;
+        discoverImages: boolean;
+        autoLastmod: boolean;
+        xsl: string | false;
+        credits: boolean;
+    };
+    globalSources: import("../../../types").SitemapSourceResolved[];
+}>>;
+export default _default;

package/dist/runtime/nitro/routes/__sitemap__/debug.mjs

@@ -0,0 +1,29 @@
+import { defineEventHandler } from "h3";
+import { useSimpleSitemapRuntimeConfig } from "../../utils.mjs";
+import {
+  childSitemapSources,
+  globalSitemapSources,
+  resolveSitemapSources
+} from "../../sitemap/urlset/sources.mjs";
+import { useNitroOrigin } from "#imports";
+export default defineEventHandler(async (e) => {
+  const _runtimeConfig = useSimpleSitemapRuntimeConfig();
+  const { sitemaps: _sitemaps } = _runtimeConfig;
+  const runtimeConfig = { ..._runtimeConfig };
+  delete runtimeConfig.sitemaps;
+  const globalSources = await globalSitemapSources();
+  const nitroOrigin = useNitroOrigin(e);
+  const sitemaps = {};
+  for (const s of Object.keys(_sitemaps)) {
+    sitemaps[s] = {
+      ..._sitemaps[s],
+      sources: await resolveSitemapSources(await childSitemapSources(_sitemaps[s]))
+    };
+  }
+  return {
+    nitroOrigin,
+    sitemaps,
+    runtimeConfig,
+    globalSources: await resolveSitemapSources(globalSources)
+  };
+});

package/dist/runtime/nitro/routes/__sitemap__/nuxt-content-urls.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any[]>>;
+export default _default;

package/dist/runtime/nitro/routes/__sitemap__/nuxt-content-urls.mjs

@@ -0,0 +1,6 @@
+import { defineEventHandler } from "h3";
+import { serverQueryContent } from "#content/server";
+export default defineEventHandler(async (e) => {
+  const contentList = await serverQueryContent(e).find();
+  return contentList.map((c) => c.sitemap).filter(Boolean);
+});

package/dist/runtime/nitro/routes/sitemap.xml.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string | void>>;
+export default _default;

package/dist/runtime/nitro/routes/sitemap.xml.mjs

@@ -0,0 +1,13 @@
+import { defineEventHandler, sendRedirect } from "h3";
+import { withBase } from "ufo";
+import { useSimpleSitemapRuntimeConfig } from "../utils.mjs";
+import { createSitemap } from "../sitemap/nitro.mjs";
+import { useRuntimeConfig } from "#imports";
+export default defineEventHandler(async (e) => {
+  const runtimeConfig = useSimpleSitemapRuntimeConfig();
+  const { sitemaps } = runtimeConfig;
+  if ("index" in sitemaps) {
+    return sendRedirect(e, withBase("/sitemap_index.xml", useRuntimeConfig().app.baseURL), process.dev ? 302 : 301);
+  }
+  return createSitemap(e, Object.values(sitemaps)[0], runtimeConfig);
+});

package/dist/runtime/nitro/routes/sitemap.xsl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string>>;
+export default _default;

package/dist/runtime/nitro/routes/sitemap.xsl.mjs

@@ -0,0 +1,230 @@
+import { defineEventHandler, getHeader, setHeader } from "h3";
+import { getQuery, parseURL, withQuery } from "ufo";
+import { useSimpleSitemapRuntimeConfig } from "../utils.mjs";
+import { createSitePathResolver, useSiteConfig } from "#imports";
+export default defineEventHandler(async (e) => {
+  const fixPath = createSitePathResolver(e, { absolute: false, withBase: true });
+  const { sitemapName: fallbackSitemapName, cacheMaxAgeSeconds, version, xslColumns, xslTips } = useSimpleSitemapRuntimeConfig();
+  setHeader(e, "Content-Type", "application/xslt+xml");
+  if (cacheMaxAgeSeconds)
+    setHeader(e, "Cache-Control", `public, max-age=${cacheMaxAgeSeconds}, must-revalidate`);
+  else
+    setHeader(e, "Cache-Control", `no-cache, no-store`);
+  const svgIcon = `<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="icon" style="margin-right: 4px; font-size: 25px;" width="1em" height="1em" viewBox="0 0 32 32"><path fill="#93c5fd" d="M4 26h4v4H4zm10 0h4v4h-4zm10 0h4v4h-4zm1-10h-8v-2h-2v2H7a2.002 2.002 0 0 0-2 2v6h2v-6h8v6h2v-6h8v6h2v-6a2.002 2.002 0 0 0-2-2zM9 2v10h14V2zm2 2h2v6h-2zm10 6h-6V4h6z"></path></svg>`;
+  const creditName = `<a href="https://github.com/nuxt-modules/sitemap" style="color: black; display: flex; align-items: center; font-weight: 500;" target="_blank" rel="noopener">${svgIcon} Nuxt
+            Simple Sitemap v${version}</a>`;
+  const { name: siteName, url: siteUrl } = useSiteConfig(e);
+  const referrer = getHeader(e, "Referer") || "/";
+  const isNotIndexButHasIndex = referrer !== fixPath("/sitemap.xml") && parseURL(referrer).pathname.endsWith("-sitemap.xml");
+  const sitemapName = parseURL(referrer).pathname.split("/").pop()?.split("-sitemap")[0] || fallbackSitemapName;
+  const title = `${siteName}${sitemapName !== "sitemap.xml" ? ` - ${sitemapName === "sitemap_index.xml" ? "index" : sitemapName}` : ""}`.replace(/&/g, "&amp;");
+  const canonicalQuery = getQuery(referrer).canonical;
+  const isShowingCanonical = typeof canonicalQuery !== "undefined" && canonicalQuery !== "false";
+  const conditionalTips = [
+    'You are looking at a <a href="https://developer.mozilla.org/en-US/docs/Web/XSLT/Transforming_XML_with_XSLT/An_Overview" style="color: #398465" target="_blank">XML stylesheet</a>. Read the <a href="https://nuxtseo.com/sitemap/guides/customising-ui" style="color: #398465" target="_blank">docs</a> to learn how to customize it. View the page source to see the raw XML.',
+    `URLs missing? Check Nuxt Devtools Sitemap tab (or the <a href="${withQuery("/__sitemap__/debug.json", { sitemap: sitemapName })}" style="color: #398465" target="_blank">debug endpoint</a>).`
+  ];
+  if (!isShowingCanonical) {
+    const canonicalPreviewUrl = withQuery(referrer, { canonical: "" });
+    conditionalTips.push(`Your canonical site URL is <strong>${siteUrl}</strong>.`);
+    conditionalTips.push(`You can preview your canonical sitemap by visiting <a href="${canonicalPreviewUrl}" style="color: #398465; white-space: nowrap;">${fixPath(canonicalPreviewUrl)}?canonical</a>`);
+  } else {
+    conditionalTips.push(`You are viewing the canonical sitemap. You can switch to using the request origin: <a href="${fixPath(referrer)}" style="color: #398465; white-space: nowrap ">${fixPath(referrer)}</a>`);
+  }
+  const tips = conditionalTips.map((t) => `<li><p>${t}</p></li>`).join("\n");
+  const showTips = process.dev && xslTips !== false;
+  let columns = [...xslColumns];
+  if (!columns.length) {
+    columns = [
+      { label: "URL", width: "50%" },
+      { label: "Images", width: "25%", select: "count(image:image)" },
+      { label: "Last Updated", width: "25%", select: "concat(substring(sitemap:lastmod,0,11),concat(' ', substring(sitemap:lastmod,12,5)),concat(' ', substring(sitemap:lastmod,20,6)))" }
+    ];
+  }
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet version="2.0"
+                xmlns:html="http://www.w3.org/TR/REC-html40"
+                xmlns:image="http://www.google.com/schemas/sitemap-image/1.1"
+                xmlns:sitemap="http://www.sitemaps.org/schemas/sitemap/0.9"
+                xmlns:xhtml="http://www.w3.org/1999/xhtml"
+                xmlns:news="http://www.google.com/schemas/sitemap-news/0.9"
+                xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+  <xsl:output method="html" version="1.0" encoding="UTF-8" indent="yes"/>
+  <xsl:template match="/">
+    <html xmlns="http://www.w3.org/1999/xhtml">
+      <head>
+        <title>XML Sitemap</title>
+        <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+        <style type="text/css">
+          body {
+            font-family: Inter, Helvetica, Arial, sans-serif;
+            font-size: 14px;
+            color: #333;
+          }
+
+          table {
+            border: none;
+            border-collapse: collapse;
+          }
+
+          .bg-yellow-200 {
+            background-color: #fef9c3;
+          }
+
+          .p-5 {
+            padding: 1.25rem;
+          }
+
+          .rounded {
+            border-radius: 4px;
+            }
+
+          .shadow {
+            box-shadow: 0 1px 2px 0 rgba(0, 0, 0, 0.05);
+          }
+
+          #sitemap tr:nth-child(odd) td {
+            background-color: #f8f8f8 !important;
+          }
+
+          #sitemap tbody tr:hover td {
+            background-color: #fff;
+          }
+
+          #sitemap tbody tr:hover td, #sitemap tbody tr:hover td a {
+            color: #000;
+          }
+
+          .expl a {
+            color: #398465
+            font-weight: 600;
+          }
+
+          .expl a:visited {
+            color: #398465
+          }
+
+          a {
+            color: #000;
+            text-decoration: none;
+          }
+
+          a:visited {
+            color: #777;
+          }
+
+          a:hover {
+            text-decoration: underline;
+          }
+
+          td {
+            font-size: 12px;
+          }
+
+          .text-2xl {
+            font-size: 2rem;
+            font-weight: 600;
+            line-height: 1.25;
+          }
+
+          th {
+            text-align: left;
+            padding-right: 30px;
+            font-size: 12px;
+          }
+
+          thead th {
+            border-bottom: 1px solid #000;
+          }
+          .fixed { position: fixed; }
+          .right-2 { right: 2rem; }
+          .top-2 { top: 2rem; }
+          .w-30 { width: 30rem; }
+          p { margin: 0; }
+          li { padding-bottom: 0.5rem; line-height: 1.5; }
+          h1 { margin: 0; }
+          .mb-5 { margin-bottom: 1.25rem; }
+          .mb-3 { margin-bottom: 0.75rem; }
+        </style>
+      </head>
+      <body>
+        <div style="grid-template-columns: 1fr 1fr; display: grid; margin: 3rem;">
+            <div>
+             <div id="content">
+          <h1 class="text-2xl mb-3">XML Sitemap</h1>
+          <h2>${title}</h2>
+          ${isNotIndexButHasIndex ? `<p style="font-size: 12px; margin-bottom: 1rem;"><a href="${fixPath("/sitemap_index.xml")}">${fixPath("/sitemap_index.xml")}</a></p>` : ""}
+          <xsl:if test="count(sitemap:sitemapindex/sitemap:sitemap) &gt; 0">
+            <p class="expl" style="margin-bottom: 1rem;">
+              This XML Sitemap Index file contains
+              <xsl:value-of select="count(sitemap:sitemapindex/sitemap:sitemap)"/> sitemaps.
+            </p>
+            <table id="sitemap" cellpadding="3">
+              <thead>
+                <tr>
+                  <th width="75%">Sitemap</th>
+                  <th width="25%">Last Modified</th>
+                </tr>
+              </thead>
+              <tbody>
+                <xsl:for-each select="sitemap:sitemapindex/sitemap:sitemap">
+                  <xsl:variable name="sitemapURL">
+                    <xsl:value-of select="sitemap:loc"/>
+                  </xsl:variable>
+                  <tr>
+                    <td>
+                      <a href="{$sitemapURL}">
+                        <xsl:value-of select="sitemap:loc"/>
+                      </a>
+                    </td>
+                    <td>
+                      <xsl:value-of
+                        select="concat(substring(sitemap:lastmod,0,11),concat(' ', substring(sitemap:lastmod,12,5)),concat(' ', substring(sitemap:lastmod,20,6)))"/>
+                    </td>
+                  </tr>
+                </xsl:for-each>
+              </tbody>
+            </table>
+          </xsl:if>
+          <xsl:if test="count(sitemap:sitemapindex/sitemap:sitemap) &lt; 1">
+            <p class="expl" style="margin-bottom: 1rem;">
+              This XML Sitemap contains
+              <xsl:value-of select="count(sitemap:urlset/sitemap:url)"/> URLs.
+            </p>
+            <table id="sitemap" cellpadding="3">
+              <thead>
+                <tr>
+                  ${columns.map((c) => `<th width="${c.width}">${c.label}</th>`).join("\n")}
+                </tr>
+              </thead>
+              <tbody>
+                <xsl:variable name="lower" select="'abcdefghijklmnopqrstuvwxyz'"/>
+                <xsl:variable name="upper" select="'ABCDEFGHIJKLMNOPQRSTUVWXYZ'"/>
+                <xsl:for-each select="sitemap:urlset/sitemap:url">
+                  <tr>
+                    <td>
+                      <xsl:variable name="itemURL">
+                        <xsl:value-of select="sitemap:loc"/>
+                      </xsl:variable>
+                      <a href="{$itemURL}">
+                        <xsl:value-of select="sitemap:loc"/>
+                      </a>
+                    </td>
+                    ${columns.filter((c) => c.label !== "URL").map((c) => `<td>
+<xsl:value-of select="${c.select}"/>
+</td>`).join("\n")}
+                  </tr>
+                </xsl:for-each>
+              </tbody>
+            </table>
+          </xsl:if>
+        </div>
+        </div>
+                    ${showTips ? `<div class="w-30 top-2 shadow rounded p-5 right-2" style="margin: 0 auto;"><p><strong>Sitemap Tips (development only)</strong></p><ul style="margin: 1rem; padding: 0;">${tips}</ul><p style="margin-top: 1rem;">${creditName}</p></div>` : ""}
+        </div>
+      </body>
+    </html>
+  </xsl:template>
+</xsl:stylesheet>
+`;
+});

package/dist/runtime/nitro/routes/sitemap_index.xml.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string>>;
+export default _default;

package/dist/runtime/nitro/routes/sitemap_index.xml.mjs

@@ -0,0 +1,27 @@
+import { defineEventHandler, getQuery, setHeader } from "h3";
+import { fixSlashes } from "site-config-stack/urls";
+import { useSimpleSitemapRuntimeConfig } from "../utils.mjs";
+import { buildSitemapIndex } from "../sitemap/builder/sitemap-index.mjs";
+import { createSitePathResolver, useNitroApp, useSiteConfig } from "#imports";
+export default defineEventHandler(async (e) => {
+  const canonicalQuery = getQuery(e).canonical;
+  const isShowingCanonical = typeof canonicalQuery !== "undefined" && canonicalQuery !== "false";
+  const runtimeConfig = useSimpleSitemapRuntimeConfig();
+  const siteConfig = useSiteConfig(e);
+  let sitemap = await buildSitemapIndex({
+    event: e,
+    canonicalUrlResolver: createSitePathResolver(e, { canonical: isShowingCanonical || !import.meta.dev, absolute: true, withBase: true }),
+    relativeBaseUrlResolver: createSitePathResolver(e, { absolute: false, withBase: true }),
+    fixSlashes: (path) => fixSlashes(siteConfig.trailingSlash, path)
+  }, runtimeConfig);
+  const nitro = useNitroApp();
+  const ctx = { sitemap, sitemapName: "sitemap" };
+  await nitro.hooks.callHook("sitemap:output", ctx);
+  sitemap = ctx.sitemap;
+  setHeader(e, "Content-Type", "text/xml; charset=UTF-8");
+  if (runtimeConfig.cacheMaxAgeSeconds)
+    setHeader(e, "Cache-Control", `public, max-age=${runtimeConfig.cacheMaxAgeSeconds}, must-revalidate`);
+  else
+    setHeader(e, "Cache-Control", `no-cache, no-store`);
+  return sitemap;
+});

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

@@ -0,0 +1,2 @@
+import type { ModuleRuntimeConfig, NitroUrlResolvers } from '../../../types';
+export declare function buildSitemapIndex(resolvers: NitroUrlResolvers, runtimeConfig: ModuleRuntimeConfig): Promise<string>;

package/dist/runtime/nitro/sitemap/builder/sitemap-index.mjs

@@ -0,0 +1,86 @@
+import { defu } from "defu";
+import { appendHeader } from "h3";
+import { normaliseDate, normaliseSitemapUrls } from "../urlset/normalise.mjs";
+import { globalSitemapSources, resolveSitemapSources } from "../urlset/sources.mjs";
+import { applyI18nEnhancements } from "../urlset/i18n.mjs";
+import { filterSitemapUrls } from "../urlset/filter.mjs";
+import { sortSitemapUrls } from "../urlset/sort.mjs";
+import { escapeValueForXml, wrapSitemapXml } from "./xml.mjs";
+export async function buildSitemapIndex(resolvers, runtimeConfig) {
+  const {
+    sitemaps,
+    // enhancing
+    autoLastmod,
+    // chunking
+    defaultSitemapsChunkSize,
+    autoI18n,
+    isI18nMapped,
+    sortEntries,
+    // xls
+    version,
+    xsl,
+    credits
+  } = runtimeConfig;
+  if (!sitemaps)
+    throw new Error("Attempting to build a sitemap index without required `sitemaps` configuration.");
+  function maybeSort(urls) {
+    return sortEntries ? sortSitemapUrls(urls) : urls;
+  }
+  const isChunking = typeof sitemaps.chunks !== "undefined";
+  const chunks = {};
+  if (isChunking) {
+    const sitemap = sitemaps.chunks;
+    const sources = await resolveSitemapSources(await globalSitemapSources());
+    const normalisedUrls = normaliseSitemapUrls(sources.map((e) => e.urls).flat(), resolvers);
+    let enhancedUrls = normalisedUrls.map((e) => defu(e, sitemap.defaults));
+    if (autoI18n?.locales)
+      enhancedUrls = applyI18nEnhancements(enhancedUrls, { isI18nMapped, autoI18n, sitemapName: sitemap.sitemapName });
+    const filteredUrls = filterSitemapUrls(enhancedUrls, { ...sitemap, autoI18n, isMultiSitemap: true });
+    const sortedUrls = maybeSort(filteredUrls);
+    sortedUrls.forEach((url, i) => {
+      const chunkIndex = Math.floor(i / defaultSitemapsChunkSize);
+      chunks[chunkIndex] = chunks[chunkIndex] || { urls: [] };
+      chunks[chunkIndex].urls.push(url);
+    });
+  } else {
+    for (const sitemap in sitemaps) {
+      if (sitemap !== "index") {
+        chunks[sitemap] = chunks[sitemap] || { urls: [] };
+      }
+    }
+  }
+  if (import.meta.prerender) {
+    appendHeader(
+      resolvers.event,
+      "x-nitro-prerender",
+      Object.keys(chunks).map((name) => encodeURIComponent(`/${name}-sitemap.xml`)).join(", ")
+    );
+  }
+  const entries = [];
+  for (const name in chunks) {
+    const sitemap = chunks[name];
+    const entry = {
+      sitemap: resolvers.canonicalUrlResolver(`${name}-sitemap.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);
+  }
+  if (sitemaps.index)
+    entries.push(...sitemaps.index.sitemaps);
+  const sitemapXml = entries.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");
+  return wrapSitemapXml([
+    '<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
+    sitemapXml,
+    "</sitemapindex>"
+  ], resolvers, { version, xsl, credits });
+}

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

@@ -0,0 +1,2 @@
+import type { ModuleRuntimeConfig, NitroUrlResolvers, SitemapDefinition } from '../../../types';
+export declare function buildSitemap(sitemap: SitemapDefinition, resolvers: NitroUrlResolvers, runtimeConfig: ModuleRuntimeConfig): Promise<string>;