@nuxtjs/sitemap 7.0.2 → 7.2.1

package/dist/module.d.cts

@@ -0,0 +1,8 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { ModuleOptions as ModuleOptions$1 } from '../dist/runtime/types.js';
+
+interface ModuleOptions extends ModuleOptions$1 {
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+export { type ModuleOptions, _default as default };

package/dist/module.json

@@ -5,7 +5,7 @@
     "bridge": false
   },
   "configKey": "sitemap",
-  "version": "7.0.1",
+  "version": "7.2.0",
   "builder": {
     "@nuxt/module-builder": "0.8.4",
     "unbuild": "2.0.0"

package/dist/module.mjs

@@ -1,10 +1,10 @@
-import { useNuxt, loadNuxtModuleInstance, createResolver, addTemplate, extendPages, tryUseNuxt, defineNuxtModule, useLogger, hasNuxtModule, getNuxtModuleVersion, hasNuxtModuleCompatibility, addServerImports, addServerPlugin, addServerHandler, addPrerenderRoutes } from '@nuxt/kit';
-import { withHttps, withBase, parseURL, joinURL, withoutLeadingSlash, withoutTrailingSlash, withLeadingSlash } from 'ufo';
+import { useNuxt, loadNuxtModuleInstance, createResolver, addTemplate, extendPages, tryUseNuxt, defineNuxtModule, useLogger, hasNuxtModule, getNuxtModuleVersion, hasNuxtModuleCompatibility, addServerImports, addServerPlugin, resolveModule, addServerHandler, addPrerenderRoutes } from '@nuxt/kit';
+import { withHttps, withBase, parseURL, joinURL, withoutLeadingSlash, withLeadingSlash, withoutTrailingSlash } from 'ufo';
 import { withSiteUrl, installNuxtSiteConfig } from 'nuxt-site-config/kit';
 import { defu } from 'defu';
 import { readPackageJSON } from 'pkg-types';
-import { statSync, existsSync } from 'node:fs';
 import { extname, relative, dirname } from 'pathe';
+import { statSync, existsSync } from 'node:fs';
 import { createPathFilter, splitForLocales, mergeOnKey } from '../dist/runtime/utils-pure.js';
 import { provider, env } from 'std-env';
 import { mkdir, writeFile } from 'node:fs/promises';
@@ -264,6 +264,22 @@ function resolveNitroPreset(nitroConfig) {
   return preset.replace("_", "-");
 }
 
+const videoRegex = /<video[^>]*>([\s\S]*?)<\/video>/g;
+const videoSrcRegex = /<video[^>]*\ssrc="([^"]+)"/;
+const videoPosterRegex = /<video[^>]*\sposter="([^"]+)"/;
+const videoTitleRegex = /<video[^>]*\sdata-title="([^"]+)"/;
+const videoDescriptionRegex = /<video[^>]*\sdata-description="([^"]+)"/;
+const videoPlayerLocRegex = /<video[^>]*\sdata-player-loc="([^"]+)"/;
+const videoDurationRegex = /<video[^>]*\sdata-duration="([^"]+)"/;
+const videoExpirationDateRegex = /<video[^>]*\sdata-expiration-date="([^"]+)"/;
+const videoRatingRegex = /<video[^>]*\sdata-rating="([^"]+)"/;
+const videoViewCountRegex = /<video[^>]*\sdata-view-count="([^"]+)"/;
+const videoPublicationDateRegex = /<video[^>]*\sdata-publication-date="([^"]+)"/;
+const videoFamilyFriendlyRegex = /<video[^>]*\sdata-family-friendly="([^"]+)"/;
+const videoRequiresSubscriptionRegex = /<video[^>]*\sdata-requires-subscription="([^"]+)"/;
+const videoLiveRegex = /<video[^>]*\sdata-live="([^"]+)"/;
+const videoTagRegex = /<video[^>]*\sdata-tag="([^"]+)"/;
+const sourceRegex = /<source[^>]*\ssrc="([^"]+)"/g;
 function extractSitemapMetaFromHtml(html, options) {
   options = options || { images: true, videos: true, lastmod: true, alternatives: true };
   const payload = {};
@@ -291,54 +307,74 @@ function extractSitemapMetaFromHtml(html, options) {
     const mainRegex = /<main[^>]*>([\s\S]*?)<\/main>/;
     const mainMatch = mainRegex.exec(html);
     if (mainMatch?.[1] && mainMatch[1].includes("<video")) {
-      const videoRegex = /<video[^>]*>([\s\S]*?)<\/video>/g;
-      const videoAttrRegex = /<video[^>]*\ssrc="([^"]+)"(?:[^>]*\sposter="([^"]+)")?/;
-      const videoPosterRegex = /<video[^>]*\sposter="([^"]+)"/;
-      const videoTitleRegex = /<video[^>]*\sdata-title="([^"]+)"/;
-      const videoDescriptionRegex = /<video[^>]*\sdata-description="([^"]+)"/;
-      const sourceRegex = /<source[^>]*\ssrc="([^"]+)"/g;
       let videoMatch;
       while ((videoMatch = videoRegex.exec(mainMatch[1])) !== null) {
         const videoContent = videoMatch[1];
         const videoTag = videoMatch[0];
-        const videoAttrMatch = videoAttrRegex.exec(videoTag);
-        const videoSrc = videoAttrMatch ? videoAttrMatch[1] : "";
-        const poster = (videoPosterRegex.exec(videoTag) || [])[1] || "";
+        const content_loc = (videoSrcRegex.exec(videoTag) || [])[1] || "";
+        const thumbnail_loc = (videoPosterRegex.exec(videoTag) || [])[1] || "";
         const title = (videoTitleRegex.exec(videoTag) || [])[1] || "";
         const description = (videoDescriptionRegex.exec(videoTag) || [])[1] || "";
+        const videoObj = {
+          content_loc,
+          thumbnail_loc,
+          title,
+          description
+        };
+        const player_loc = (videoPlayerLocRegex.exec(videoTag) || [])[1];
+        if (player_loc)
+          videoObj.player_loc = player_loc;
+        const duration = (videoDurationRegex.exec(videoTag) || [])[1];
+        if (duration)
+          videoObj.duration = Number.parseInt(duration, 10);
+        const expiration_date = (videoExpirationDateRegex.exec(videoTag) || [])[1];
+        if (expiration_date)
+          videoObj.expiration_date = expiration_date;
+        const rating = (videoRatingRegex.exec(videoTag) || [])[1];
+        if (rating)
+          videoObj.rating = Number.parseFloat(rating);
+        const view_count = (videoViewCountRegex.exec(videoTag) || [])[1];
+        if (view_count)
+          videoObj.view_count = Number.parseInt(view_count, 10);
+        const publication_date = (videoPublicationDateRegex.exec(videoTag) || [])[1];
+        if (publication_date)
+          videoObj.publication_date = publication_date;
+        const family_friendly = (videoFamilyFriendlyRegex.exec(videoTag) || [])[1];
+        if (family_friendly)
+          videoObj.family_friendly = family_friendly;
+        const requires_subscription = (videoRequiresSubscriptionRegex.exec(videoTag) || [])[1];
+        if (requires_subscription)
+          videoObj.requires_subscription = requires_subscription;
+        const live = (videoLiveRegex.exec(videoTag) || [])[1];
+        if (live)
+          videoObj.live = live;
+        const tag = (videoTagRegex.exec(videoTag) || [])[1];
+        if (tag)
+          videoObj.tag = tag;
         const sources = [];
         let sourceMatch;
         while ((sourceMatch = sourceRegex.exec(videoContent)) !== null) {
-          sources.push({
-            src: sourceMatch[1],
-            poster,
-            title,
-            description
-          });
-        }
-        if (videoSrc) {
-          videos.push({
-            src: videoSrc,
-            poster,
-            title,
-            description,
-            sources: []
-          });
+          sources.push(sourceMatch[1]);
         }
         if (sources.length > 0) {
-          videos.push(...sources);
+          videos.push(...sources.map((source) => {
+            if (source.startsWith("/"))
+              source = tryUseNuxt() ? withSiteUrl(source) : source;
+            return {
+              ...videoObj,
+              content_loc: source
+            };
+          }));
+        } else {
+          videos.push(videoObj);
         }
       }
     }
-    if (videos.length > 0) {
-      payload.videos = videos.map(
-        (video) => ({
-          content_loc: video.src,
-          thumbnail_loc: video.poster,
-          title: video.title,
-          description: video.description
-        })
-      );
+    const validVideos = videos.filter((v) => {
+      return v.content_loc && v.thumbnail_loc && v.title && v.description;
+    });
+    if (validVideos.length > 0) {
+      payload.videos = validVideos;
     }
   }
   if (options?.lastmod) {
@@ -788,6 +824,7 @@ declare module 'nitropack' {
   }
   interface NitroRuntimeHooks {
     'sitemap:index-resolved': (ctx: import('${typesPath}').SitemapIndexRenderCtx) => void | Promise<void>
+    'sitemap:input': (ctx: import('${typesPath}').SitemapInputCtx) => void | Promise<void>
     'sitemap:resolved': (ctx: import('${typesPath}').SitemapRenderCtx) => void | Promise<void>
     'sitemap:output': (ctx: import('${typesPath}').SitemapOutputHookCtx) => void | Promise<void>
   }
@@ -832,7 +869,7 @@ declare module 'vue-router' {
       nuxt.options.nitro.routeRules["/sitemap_index.xml"] = routeRules;
       if (typeof config.sitemaps === "object") {
         for (const k in config.sitemaps) {
-          nuxt.options.nitro.routeRules[joinURL(config.sitemapsPathPrefix, `/${k}.xml`)] = routeRules;
+          nuxt.options.nitro.routeRules[joinURL(config.sitemapsPathPrefix || "", `/${k}.xml`)] = routeRules;
         }
       } else {
         nuxt.options.nitro.routeRules[`/${config.sitemapName}`] = routeRules;
@@ -845,31 +882,81 @@ declare module 'vue-router' {
     if (config.experimentalCompression)
       addServerPlugin(resolve("./runtime/server/plugins/compression"));
     const isNuxtContentDocumentDriven = !!nuxt.options.content?.documentDriven || config.strictNuxtContentPaths;
-    if (hasNuxtModule("@nuxt/content")) {
-      if (await hasNuxtModuleCompatibility("@nuxt/content", "^3")) {
-        logger.warn("Nuxt Sitemap does not work with Nuxt Content v3 yet, the integration will be disabled.");
-      } else {
-        addServerPlugin(resolve("./runtime/server/plugins/nuxt-content"));
-        addServerHandler({
-          route: "/__sitemap__/nuxt-content-urls.json",
-          handler: resolve("./runtime/server/routes/__sitemap__/nuxt-content-urls")
-        });
-        const tips = [];
-        if (nuxt.options.content?.documentDriven)
-          tips.push("Enabled because you're using `@nuxt/content` with `documentDriven: true`.");
-        else if (config.strictNuxtContentPaths)
-          tips.push("Enabled because you've set `config.strictNuxtContentPaths: true`.");
-        else
-          tips.push("You can provide a `sitemap` key in your markdown frontmatter to configure specific URLs. Make sure you include a `loc`.");
-        appGlobalSources.push({
-          context: {
-            name: "@nuxt/content:urls",
-            description: "Generated from your markdown files.",
-            tips
-          },
-          fetch: "/__sitemap__/nuxt-content-urls.json"
-        });
+    const usingNuxtContent = hasNuxtModule("@nuxt/content");
+    const isNuxtContentV3 = usingNuxtContent && await hasNuxtModuleCompatibility("@nuxt/content", "^3");
+    const nuxtV3Collections = /* @__PURE__ */ new Set();
+    const isNuxtContentV2 = usingNuxtContent && await hasNuxtModuleCompatibility("@nuxt/content", "^2");
+    if (isNuxtContentV3) {
+      nuxt.options.alias["#sitemap/content-v3-nitro-path"] = resolve(dirname(resolveModule("@nuxt/content")), "runtime/nitro");
+      nuxt.hooks.hook("content:file:afterParse", (ctx) => {
+        const content = ctx.content;
+        nuxtV3Collections.add(ctx.collection.name);
+        if (!("sitemap" in ctx.collection.fields)) {
+          return;
+        }
+        const images = [];
+        if (config.discoverImages) {
+          images.push(
+            ...content.body.value?.filter(
+              (c) => ["image", "img", "nuxtimg", "nuxt-img"].includes(c[0])
+            ).filter((c) => c[1]?.src).map((c) => ({ loc: c[1].src })) || []
+          );
+        }
+        const sitemapConfig = typeof content.sitemap === "object" ? content.sitemap : {};
+        const lastmod = content.seo?.articleModifiedTime || content.updatedAt;
+        const 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;
+        }
+        content.sitemap = definition;
+        if (!definition.loc)
+          delete content.sitemap;
+        ctx.content = content;
+      });
+      addServerHandler({
+        route: "/__sitemap__/nuxt-content-urls.json",
+        handler: resolve("./runtime/server/routes/__sitemap__/nuxt-content-urls-v3")
+      });
+      if (config.strictNuxtContentPaths) {
+        logger.warn("You have set `strictNuxtContentPaths: true` but are using @nuxt/content v3. This is not required, please remove it.");
       }
+      appGlobalSources.push({
+        context: {
+          name: "@nuxt/content@v3:urls",
+          description: "Generated from your markdown files.",
+          tips: [`Parsing the following collections: ${Array.from(nuxtV3Collections).join(", ")}`]
+        },
+        fetch: "/__sitemap__/nuxt-content-urls.json"
+      });
+    } else if (isNuxtContentV2) {
+      addServerPlugin(resolve("./runtime/server/plugins/nuxt-content-v2"));
+      addServerHandler({
+        route: "/__sitemap__/nuxt-content-urls.json",
+        handler: resolve("./runtime/server/routes/__sitemap__/nuxt-content-urls-v2")
+      });
+      const tips = [];
+      if (nuxt.options.content?.documentDriven)
+        tips.push("Enabled because you're using `@nuxt/content` with `documentDriven: true`.");
+      else if (config.strictNuxtContentPaths)
+        tips.push("Enabled because you've set `config.strictNuxtContentPaths: true`.");
+      else
+        tips.push("You can provide a `sitemap` key in your markdown frontmatter to configure specific URLs. Make sure you include a `loc`.");
+      appGlobalSources.push({
+        context: {
+          name: "@nuxt/content@v2:urls",
+          description: "Generated from your markdown files.",
+          tips
+        },
+        fetch: "/__sitemap__/nuxt-content-urls.json"
+      });
     }
     const sitemaps = {};
     if (usingMultiSitemaps) {
@@ -879,12 +966,23 @@ declare module 'vue-router' {
         lazy: true,
         middleware: false
       });
-      addServerHandler({
-        route: joinURL(config.sitemapsPathPrefix, `/**:sitemap`),
-        handler: resolve("./runtime/server/routes/sitemap/[sitemap].xml"),
-        lazy: true,
-        middleware: false
-      });
+      if (config.sitemapsPathPrefix && config.sitemapsPathPrefix !== "/") {
+        addServerHandler({
+          route: joinURL(config.sitemapsPathPrefix, `/**:sitemap`),
+          handler: resolve("./runtime/server/routes/sitemap/[sitemap].xml"),
+          lazy: true,
+          middleware: false
+        });
+      } else {
+        for (const sitemapName of Object.keys(config.sitemaps || {})) {
+          addServerHandler({
+            route: withLeadingSlash(`${sitemapName}.xml`),
+            handler: resolve("./runtime/server/routes/sitemap/[sitemap].xml"),
+            lazy: true,
+            middleware: false
+          });
+        }
+      }
       sitemaps.index = {
         sitemapName: "index",
         _route: withBase("sitemap_index.xml", nuxt.options.app.baseURL || "/"),
@@ -899,7 +997,7 @@ declare module 'vue-router' {
           sitemaps[sitemapName] = defu(
             {
               sitemapName,
-              _route: withBase(joinURL(config.sitemapsPathPrefix, `${sitemapName}.xml`), nuxt.options.app.baseURL || "/"),
+              _route: withBase(joinURL(config.sitemapsPathPrefix || "", `${sitemapName}.xml`), nuxt.options.app.baseURL || "/"),
               _hasSourceChunk: typeof definition.urls !== "undefined" || definition.sources?.length
             },
             { ...definition, urls: void 0, sources: void 0 },
@@ -1030,9 +1128,9 @@ declare module 'vue-router' {
           ...((await nitroPromise)._prerenderedRoutes || []).filter((r) => {
             const lastSegment = r.route.split("/").pop();
             const isExplicitFile = !!lastSegment?.match(/\.[0-9a-z]+$/i)?.[0];
-            if (r.error || ["/200.html", "/404.html", "/index.html"].includes(r.route))
+            if (isExplicitFile || r.error || ["/200.html", "/404.html", "/index.html"].includes(r.route))
               return false;
-            return r.contentType?.includes("text/html") || !isExplicitFile;
+            return r.contentType?.includes("text/html");
           }).map((r) => r._sitemap)
         ];
         const pageSource = convertNuxtPagesToSitemapEntries(await pagesPromise, {

package/dist/runtime/server/plugins/{nuxt-content.js → nuxt-content-v2.js}

@@ -2,7 +2,7 @@ import { defu } from "defu";
 import { useSimpleSitemapRuntimeConfig } from "../utils.js";
 import { defineNitroPlugin } from "#imports";
 export default defineNitroPlugin((nitroApp) => {
-  const { discoverImages, discoverVideos, isNuxtContentDocumentDriven } = useSimpleSitemapRuntimeConfig();
+  const { discoverImages, isNuxtContentDocumentDriven } = useSimpleSitemapRuntimeConfig();
   nitroApp.hooks.hook("content:file:afterParse", async (content) => {
     const validExtensions = ["md", "mdx"];
     if (content.sitemap === false || content._draft || !validExtensions.includes(content._extension) || content._partial || content.robots === false)
@@ -13,12 +13,6 @@ export default defineNitroPlugin((nitroApp) => {
         (c) => c.tag && c.props?.src && ["image", "img", "nuxtimg", "nuxt-img"].includes(c.tag.toLowerCase())
       ).map((i) => ({ loc: i.props.src })) || [];
     }
-    let videos = [];
-    if (discoverVideos) {
-      videos = content.body?.children?.filter(
-        (c) => c.tag && c.props?.src && ["video"].includes(c.tag.toLowerCase())
-      ).map((i) => ({ content_loc: i.props.src })) || [];
-    }
     const sitemapConfig = typeof content.sitemap === "object" ? content.sitemap : {};
     const lastmod = content.modifiedAt || content.updatedAt;
     const defaults = {};
@@ -26,10 +20,8 @@ export default defineNitroPlugin((nitroApp) => {
       defaults.loc = content._path;
     if (content.path)
       defaults.loc = content.path;
-    if (images.length > 0)
+    if (images?.length)
       defaults.images = images;
-    if (videos.length > 0)
-      defaults.videos = videos;
     if (lastmod)
       defaults.lastmod = lastmod;
     const definition = defu(sitemapConfig, defaults);

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

@@ -15,7 +15,7 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
         autoI18n?: import("../../../types").AutoI18nConfig;
         isMultiSitemap: boolean;
         isI18nMapped: boolean;
-        sitemapsPathPrefix: string;
+        sitemapsPathPrefix: string | false;
         cacheMaxAgeSeconds: number | false;
         sitemapName: string;
         excludeAppSources: true | (import("../../../types").AppSourceContext[]);

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

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

package/dist/runtime/server/routes/__sitemap__/nuxt-content-urls-v3.js

@@ -0,0 +1,17 @@
+import { defineEventHandler } from "h3";
+import { queryCollectionWithEvent } from "#sitemap/content-v3-nitro-path";
+import manifest from "#content/manifest";
+export default defineEventHandler(async (e) => {
+  const collections = [];
+  for (const collection in manifest) {
+    if (manifest[collection].fields.sitemap) {
+      collections.push(collection);
+    }
+  }
+  const contentList = [];
+  for (const collection of collections) {
+    contentList.push(queryCollectionWithEvent(e, collection).select("sitemap").where("sitemap", "IS NOT NULL").all());
+  }
+  const results = await Promise.all(contentList);
+  return results.flat().map((c) => c.sitemap).filter(Boolean);
+});

package/dist/runtime/server/routes/sitemap/[sitemap].xml.js

@@ -5,7 +5,7 @@ import { createSitemap } from "../../sitemap/nitro.js";
 export default defineEventHandler(async (e) => {
   const runtimeConfig = useSimpleSitemapRuntimeConfig(e);
   const { sitemaps } = runtimeConfig;
-  const sitemapName = withoutLeadingSlash(withoutTrailingSlash((getRouterParam(e, "sitemap") || e.path)?.replace(".xml", "").replace(runtimeConfig.sitemapsPathPrefix, "")));
+  const sitemapName = withoutLeadingSlash(withoutTrailingSlash((getRouterParam(e, "sitemap") || e.path)?.replace(".xml", "").replace(runtimeConfig.sitemapsPathPrefix || "", "")));
   const isChunking = typeof sitemaps.chunks !== "undefined" && !Number.isNaN(Number(sitemapName));
   if (!sitemapName || !(sitemapName in sitemaps) && !isChunking) {
     return createError({

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

@@ -8,12 +8,12 @@ export default defineEventHandler(async (e) => {
   const runtimeConfig = useSimpleSitemapRuntimeConfig();
   const nitro = useNitroApp();
   const resolvers = useNitroUrlResolvers(e);
-  const sitemaps = await buildSitemapIndex(resolvers, runtimeConfig);
+  const sitemaps = 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(", ")
+      sitemaps.filter((entry) => !!entry._sitemapName).map((entry) => encodeURIComponent(joinURL(runtimeConfig.sitemapsPathPrefix || "", `/${entry._sitemapName}.xml`))).join(", ")
     );
   }
   const indexResolvedCtx = { sitemaps };

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

@@ -1,3 +1,4 @@
+import type { NitroApp } from 'nitropack/types';
 import type { ModuleRuntimeConfig, NitroUrlResolvers, SitemapIndexEntry } from '../../../types.js';
-export declare function buildSitemapIndex(resolvers: NitroUrlResolvers, runtimeConfig: ModuleRuntimeConfig): Promise<SitemapIndexEntry[]>;
+export declare function buildSitemapIndex(resolvers: NitroUrlResolvers, runtimeConfig: ModuleRuntimeConfig, nitro?: NitroApp): Promise<SitemapIndexEntry[]>;
 export declare function urlsToIndexXml(sitemaps: SitemapIndexEntry[], resolvers: NitroUrlResolvers, { version, xsl, credits, minify }: Pick<ModuleRuntimeConfig, 'version' | 'xsl' | 'credits' | 'minify'>): string;

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

@@ -5,7 +5,7 @@ import { globalSitemapSources, resolveSitemapSources } from "../urlset/sources.j
 import { sortSitemapUrls } from "../urlset/sort.js";
 import { escapeValueForXml, wrapSitemapXml } from "./xml.js";
 import { resolveSitemapEntries } from "./sitemap.js";
-export async function buildSitemapIndex(resolvers, runtimeConfig) {
+export async function buildSitemapIndex(resolvers, runtimeConfig, nitro) {
   const {
     sitemaps,
     // enhancing
@@ -27,7 +27,12 @@ export async function buildSitemapIndex(resolvers, runtimeConfig) {
   if (isChunking) {
     const sitemap = sitemaps.chunks;
     const sources = await resolveSitemapSources(await globalSitemapSources());
-    const normalisedUrls = resolveSitemapEntries(sitemap, sources, { autoI18n, isI18nMapped }, resolvers);
+    const resolvedCtx = {
+      urls: sources.flatMap((s) => s.urls),
+      sitemapName: sitemap.sitemapName
+    };
+    await nitro?.hooks.callHook("sitemap:input", resolvedCtx);
+    const normalisedUrls = resolveSitemapEntries(sitemap, resolvedCtx.urls, { autoI18n, isI18nMapped }, resolvers);
     const enhancedUrls = normalisedUrls.map((e) => defu(e, sitemap.defaults));
     const sortedUrls = maybeSort(enhancedUrls);
     sortedUrls.forEach((url, i) => {
@@ -47,7 +52,7 @@ export async function buildSitemapIndex(resolvers, runtimeConfig) {
     const sitemap = chunks[name];
     const entry = {
       _sitemapName: name,
-      sitemap: resolvers.canonicalUrlResolver(joinURL(sitemapsPathPrefix, `/${name}.xml`))
+      sitemap: resolvers.canonicalUrlResolver(joinURL(sitemapsPathPrefix || "", `/${name}.xml`))
     };
     let lastmod = sitemap.urls.filter((a) => !!a?.lastmod).map((a) => typeof a.lastmod === "string" ? new Date(a.lastmod) : a.lastmod).sort((a, b) => (b?.getTime() || 0) - (a?.getTime() || 0))?.[0];
     if (!lastmod && autoLastmod)

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

@@ -1,9 +1,10 @@
-import type { AutoI18nConfig, ModuleRuntimeConfig, NitroUrlResolvers, ResolvedSitemapUrl, SitemapDefinition, SitemapSourceResolved } from '../../../types.js';
+import type { NitroApp } from 'nitropack/types';
+import type { AutoI18nConfig, ModuleRuntimeConfig, NitroUrlResolvers, ResolvedSitemapUrl, SitemapDefinition, SitemapUrlInput } from '../../../types.js';
 export interface NormalizedI18n extends ResolvedSitemapUrl {
     _pathWithoutPrefix: string;
     _locale: AutoI18nConfig['locales'][number];
     _index?: number;
 }
-export declare function resolveSitemapEntries(sitemap: SitemapDefinition, sources: SitemapSourceResolved[], runtimeConfig: Pick<ModuleRuntimeConfig, 'autoI18n' | 'isI18nMapped'>, resolvers?: NitroUrlResolvers): ResolvedSitemapUrl[];
-export declare function buildSitemapUrls(sitemap: SitemapDefinition, resolvers: NitroUrlResolvers, runtimeConfig: ModuleRuntimeConfig): Promise<ResolvedSitemapUrl[]>;
+export declare function resolveSitemapEntries(sitemap: SitemapDefinition, urls: SitemapUrlInput[], runtimeConfig: Pick<ModuleRuntimeConfig, 'autoI18n' | 'isI18nMapped'>, resolvers?: NitroUrlResolvers): ResolvedSitemapUrl[];
+export declare function buildSitemapUrls(sitemap: SitemapDefinition, resolvers: NitroUrlResolvers, runtimeConfig: ModuleRuntimeConfig, nitro?: NitroApp): Promise<ResolvedSitemapUrl[]>;
 export declare function urlsToXml(urls: ResolvedSitemapUrl[], resolvers: NitroUrlResolvers, { version, xsl, credits, minify }: Pick<ModuleRuntimeConfig, 'version' | 'xsl' | 'credits' | 'minify'>): string;

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

@@ -5,7 +5,7 @@ import { childSitemapSources, globalSitemapSources, resolveSitemapSources } from
 import { sortSitemapUrls } from "../urlset/sort.js";
 import { createPathFilter, logger, splitForLocales } from "../../../utils-pure.js";
 import { handleEntry, wrapSitemapXml } from "./xml.js";
-export function resolveSitemapEntries(sitemap, sources, runtimeConfig, resolvers) {
+export function resolveSitemapEntries(sitemap, urls, runtimeConfig, resolvers) {
   const {
     autoI18n,
     isI18nMapped
@@ -14,7 +14,7 @@ export function resolveSitemapEntries(sitemap, sources, runtimeConfig, resolvers
     include: sitemap.include,
     exclude: sitemap.exclude
   });
-  const _urls = sources.flatMap((e) => e.urls).map((_e) => {
+  const _urls = urls.map((_e) => {
     const e = preNormalizeEntry(_e, resolvers);
     if (!e.loc || !filterPath(e.loc))
       return false;
@@ -139,7 +139,7 @@ export function resolveSitemapEntries(sitemap, sources, runtimeConfig, resolvers
   }
   return _urls;
 }
-export async function buildSitemapUrls(sitemap, resolvers, runtimeConfig) {
+export async function buildSitemapUrls(sitemap, resolvers, runtimeConfig, nitro) {
   const {
     sitemaps,
     // enhancing
@@ -175,10 +175,15 @@ export async function buildSitemapUrls(sitemap, resolvers, runtimeConfig) {
       });
     }
   }
-  const sources = sitemap.includeAppSources ? await globalSitemapSources() : [];
-  sources.push(...await childSitemapSources(sitemap));
-  const resolvedSources = await resolveSitemapSources(sources, resolvers.event);
-  const enhancedUrls = resolveSitemapEntries(sitemap, resolvedSources, { autoI18n, isI18nMapped }, resolvers);
+  const sourcesInput = sitemap.includeAppSources ? await globalSitemapSources() : [];
+  sourcesInput.push(...await childSitemapSources(sitemap));
+  const sources = await resolveSitemapSources(sourcesInput, resolvers.event);
+  const resolvedCtx = {
+    urls: sources.flatMap((s) => s.urls),
+    sitemapName: sitemap.sitemapName
+  };
+  await nitro?.hooks.callHook("sitemap:input", resolvedCtx);
+  const enhancedUrls = resolveSitemapEntries(sitemap, resolvedCtx.urls, { autoI18n, isI18nMapped }, resolvers);
   const filteredUrls = enhancedUrls.filter((e) => {
     if (isMultiSitemap && e._sitemap && sitemap.sitemapName)
       return e._sitemap === sitemap.sitemapName;

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

@@ -4,7 +4,7 @@ import { defu } from "defu";
 import { logger, mergeOnKey, splitForLocales } from "../../utils-pure.js";
 import { createNitroRouteRuleMatcher } from "../kit.js";
 import { buildSitemapUrls, urlsToXml } from "./builder/sitemap.js";
-import { normaliseEntry } from "./urlset/normalise.js";
+import { normaliseEntry, preNormalizeEntry } from "./urlset/normalise.js";
 import { sortSitemapUrls } from "./urlset/sort.js";
 import { useNitroApp, createSitePathResolver, getPathRobotConfig, useSiteConfig } from "#imports";
 export function useNitroUrlResolvers(e) {
@@ -39,7 +39,7 @@ export async function createSitemap(event, definition, runtimeConfig) {
     }
   }
   const resolvers = useNitroUrlResolvers(event);
-  let sitemapUrls = await buildSitemapUrls(definition, resolvers, runtimeConfig);
+  let sitemapUrls = await buildSitemapUrls(definition, resolvers, runtimeConfig, nitro);
   const routeRuleMatcher = createNitroRouteRuleMatcher();
   const { autoI18n } = runtimeConfig;
   sitemapUrls = sitemapUrls.map((u) => {
@@ -63,11 +63,15 @@ export async function createSitemap(event, definition, runtimeConfig) {
       return false;
     return routeRules.sitemap ? defu(u, routeRules.sitemap) : u;
   }).filter(Boolean);
+  const locSize = sitemapUrls.length;
   const resolvedCtx = {
     urls: sitemapUrls,
     sitemapName
   };
   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 ? sortSitemapUrls(urls2) : urls2;
   const normalizedPreDedupe = resolvedCtx.urls.map((e) => normaliseEntry(e, definition.defaults, resolvers));
   const urls = maybeSort(mergeOnKey(normalizedPreDedupe, "_key").map((e) => normaliseEntry(e, definition.defaults, resolvers)));

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

@@ -1,5 +1,7 @@
 import { getRequestHost } from "h3";
 import { defu } from "defu";
+import { parseURL } from "ufo";
+import { extractSitemapXML } from "../utils/extractSitemapXML.js";
 export async function fetchDataSource(input, event) {
   const context = typeof input.context === "string" ? { name: input.context } : input.context || { name: "fetch" };
   context.tips = context.tips || [];
@@ -9,24 +11,25 @@ export async function fetchDataSource(input, event) {
   const timeout = options.timeout || 5e3;
   const timeoutController = new AbortController();
   const abortRequestTimeout = setTimeout(() => timeoutController.abort(), timeout);
-  let isHtmlResponse = false;
+  let isMaybeErrorResponse = false;
+  const isXmlRequest = parseURL(url).pathname.endsWith(".xml");
+  const fetchContainer = url.startsWith("/") && event ? event : globalThis;
   try {
-    const fetchContainer = url.startsWith("/") && event ? event : globalThis;
-    const urls = await fetchContainer.$fetch(url, {
+    const res = await fetchContainer.$fetch(url, {
       ...options,
-      responseType: "json",
+      responseType: isXmlRequest ? "text" : "json",
       signal: timeoutController.signal,
       headers: defu(options?.headers, {
-        Accept: "application/json"
+        Accept: isXmlRequest ? "text/xml" : "application/json"
       }, event ? { Host: getRequestHost(event, { xForwardedHost: true }) } : {}),
       // @ts-expect-error untyped
       onResponse({ response }) {
         if (typeof response._data === "string" && response._data.startsWith("<!DOCTYPE html>"))
-          isHtmlResponse = true;
+          isMaybeErrorResponse = true;
       }
     });
     const timeTakenMs = Date.now() - start;
-    if (isHtmlResponse) {
+    if (isMaybeErrorResponse) {
       context.tips.push("This is usually because the URL isn't correct or is throwing an error. Please check the URL");
       return {
         ...input,
@@ -36,6 +39,12 @@ export async function fetchDataSource(input, event) {
         error: "Received HTML response instead of JSON"
       };
     }
+    let urls = [];
+    if (typeof res === "object") {
+      urls = res.urls || res;
+    } else if (typeof res === "string" && parseURL(url).pathname.endsWith(".xml")) {
+      urls = extractSitemapXML(res);
+    }
     return {
       ...input,
       context,

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

@@ -0,0 +1,2 @@
+import type { SitemapUrlInput } from '../../../types.js';
+export declare function extractSitemapXML(xml: string): SitemapUrlInput[];