@nuxtjs/sitemap 5.3.5 → 6.0.0-beta.2

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

@@ -1,16 +1,144 @@
-import { defu } from "defu";
 import { resolveSitePath } from "site-config-stack/urls";
-import { parseURL, withHttps } from "ufo";
-import { normaliseSitemapUrls } from "../urlset/normalise.js";
+import { joinURL, withHttps } from "ufo";
+import { preNormalizeEntry } from "../urlset/normalise.js";
 import { childSitemapSources, globalSitemapSources, resolveSitemapSources } from "../urlset/sources.js";
-import { filterSitemapUrls } from "../urlset/filter.js";
-import { applyI18nEnhancements, normaliseI18nSources } from "../urlset/i18n.js";
 import { sortSitemapUrls } from "../urlset/sort.js";
-import { splitForLocales } from "../../utils.js";
-import { createNitroRouteRuleMatcher } from "../../kit.js";
+import { createPathFilter, logger, splitForLocales } from "../../../utils-pure.js";
 import { handleEntry, wrapSitemapXml } from "./xml.js";
-import { useNitroApp } from "#imports";
-export async function buildSitemap(sitemap, resolvers, runtimeConfig) {
+export function resolveSitemapEntries(sitemap, sources, runtimeConfig) {
+  const {
+    autoI18n,
+    isI18nMapped
+  } = runtimeConfig;
+  const filterPath = createPathFilter({
+    include: sitemap.include,
+    exclude: sitemap.exclude
+  });
+  const _urls = sources.flatMap((e) => e.urls).map((_e) => {
+    const e = preNormalizeEntry(_e);
+    if (!e.loc || !filterPath(e.loc))
+      return false;
+    return e;
+  }).filter(Boolean);
+  let validI18nUrlsForTransform = [];
+  let warnIncorrectI18nTransformUsage = false;
+  const withoutPrefixPaths = {};
+  if (autoI18n && autoI18n.strategy !== "no_prefix") {
+    const localeCodes = autoI18n.locales.map((l) => l.code);
+    validI18nUrlsForTransform = _urls.map((_e, i) => {
+      if (_e._abs)
+        return false;
+      const split = splitForLocales(_e.loc, localeCodes);
+      let localeCode = split[0];
+      const pathWithoutPrefix = split[1];
+      if (!localeCode)
+        localeCode = autoI18n.defaultLocale;
+      const e = _e;
+      e._pathWithoutPrefix = pathWithoutPrefix;
+      const locale = autoI18n.locales.find((l) => l.code === localeCode);
+      if (!locale)
+        return false;
+      e._locale = locale;
+      e._index = i;
+      withoutPrefixPaths[pathWithoutPrefix] = withoutPrefixPaths[pathWithoutPrefix] || [];
+      if (!withoutPrefixPaths[pathWithoutPrefix].some((e2) => e2._locale.code === locale.code))
+        withoutPrefixPaths[pathWithoutPrefix].push(e);
+      return e;
+    }).filter(Boolean);
+    for (const e of validI18nUrlsForTransform) {
+      if (!e._i18nTransform && !e.alternatives?.length) {
+        const alternatives = withoutPrefixPaths[e._pathWithoutPrefix].map((u) => {
+          const entries = [];
+          if (u._locale.code === autoI18n.defaultLocale) {
+            entries.push({
+              href: u.loc,
+              hreflang: "x-default"
+            });
+          }
+          entries.push({
+            href: u.loc,
+            hreflang: u._locale.code || autoI18n.defaultLocale
+          });
+          return entries;
+        }).flat().filter(Boolean);
+        if (alternatives.length)
+          e.alternatives = alternatives;
+      } else if (e._i18nTransform) {
+        delete e._i18nTransform;
+        if (autoI18n.strategy === "no_prefix") {
+          warnIncorrectI18nTransformUsage = true;
+        }
+        if (autoI18n.differentDomains) {
+          e.alternatives = [
+            {
+              // apply default locale domain
+              ...autoI18n.locales.find((l) => [l.code, l.iso].includes(autoI18n.defaultLocale)),
+              code: "x-default"
+            },
+            ...autoI18n.locales.filter((l) => !!l.domain)
+          ].map((locale) => {
+            return {
+              hreflang: locale.iso || locale.code,
+              href: joinURL(withHttps(locale.domain), e._pathWithoutPrefix)
+            };
+          });
+        } else {
+          for (const l of autoI18n.locales) {
+            let loc = joinURL(`/${l.code}`, e._pathWithoutPrefix);
+            if (autoI18n.differentDomains || ["prefix_and_default", "prefix_except_default"].includes(autoI18n.strategy) && l.code === autoI18n.defaultLocale)
+              loc = e._pathWithoutPrefix;
+            const _sitemap = isI18nMapped ? l.iso || l.code : void 0;
+            const newEntry = preNormalizeEntry({
+              _sitemap,
+              ...e,
+              _index: void 0,
+              _key: `${_sitemap || ""}${loc}`,
+              _locale: l,
+              loc,
+              alternatives: [{ code: "x-default" }, ...autoI18n.locales].map((locale) => {
+                const code = locale.code === "x-default" ? autoI18n.defaultLocale : locale.code;
+                const isDefault = locale.code === "x-default" || locale.code === autoI18n.defaultLocale;
+                let href = "";
+                if (autoI18n.strategy === "prefix") {
+                  href = joinURL("/", code, e._pathWithoutPrefix);
+                } else if (["prefix_and_default", "prefix_except_default"].includes(autoI18n.strategy)) {
+                  if (isDefault) {
+                    href = e._pathWithoutPrefix;
+                  } else {
+                    href = joinURL("/", code, e._pathWithoutPrefix);
+                  }
+                }
+                const hreflang = locale.iso || locale.code;
+                if (!filterPath(href))
+                  return false;
+                return {
+                  hreflang,
+                  href
+                };
+              }).filter(Boolean)
+            });
+            if (e._locale.code === newEntry._locale.code) {
+              _urls[e._index] = newEntry;
+              e._index = void 0;
+            } else {
+              _urls.push(newEntry);
+            }
+          }
+        }
+      }
+      if (isI18nMapped) {
+        e._sitemap = e._sitemap || e._locale.iso || e._locale.code;
+      }
+      if (e._index)
+        _urls[e._index] = e;
+    }
+  }
+  if (import.meta.dev && warnIncorrectI18nTransformUsage) {
+    logger.warn("You're using _i18nTransform with the `no_prefix` strategy. This will cause issues with the sitemap. Please remove the _i18nTransform flag or change i18n strategy.");
+  }
+  return _urls;
+}
+export async function buildSitemapUrls(sitemap, resolvers, runtimeConfig) {
   const {
     sitemaps,
     // enhancing
@@ -20,22 +148,18 @@ export async function buildSitemap(sitemap, resolvers, runtimeConfig) {
     // sorting
     sortEntries,
     // chunking
-    defaultSitemapsChunkSize,
-    // xls
-    version,
-    xsl,
-    credits
+    defaultSitemapsChunkSize
   } = runtimeConfig;
   const isChunking = typeof sitemaps.chunks !== "undefined" && !Number.isNaN(Number(sitemap.sitemapName));
-  function maybeSort(urls2) {
-    return sortEntries ? sortSitemapUrls(urls2) : urls2;
+  function maybeSort(urls) {
+    return sortEntries ? sortSitemapUrls(urls) : urls;
   }
-  function maybeSlice(urls2) {
+  function maybeSlice(urls) {
     if (isChunking && defaultSitemapsChunkSize) {
       const chunk = Number(sitemap.sitemapName);
-      return urls2.slice(chunk * defaultSitemapsChunkSize, (chunk + 1) * defaultSitemapsChunkSize);
+      return urls.slice(chunk * defaultSitemapsChunkSize, (chunk + 1) * defaultSitemapsChunkSize);
     }
-    return urls2;
+    return urls;
   }
   if (autoI18n?.differentDomains) {
     const domain = autoI18n.locales.find((e) => [e.iso, e.code].includes(sitemap.sitemapName))?.domain;
@@ -52,41 +176,17 @@ export async function buildSitemap(sitemap, resolvers, runtimeConfig) {
   }
   const sources = sitemap.includeAppSources ? await globalSitemapSources() : [];
   sources.push(...await childSitemapSources(sitemap));
-  let resolvedSources = await resolveSitemapSources(sources, resolvers.event);
-  if (autoI18n)
-    resolvedSources = normaliseI18nSources(resolvedSources, { autoI18n, isI18nMapped, ...sitemap });
-  const normalisedUrls = normaliseSitemapUrls(resolvedSources.map((e) => e.urls).flat(), resolvers);
-  const routeRuleMatcher = createNitroRouteRuleMatcher();
-  let enhancedUrls = normalisedUrls.map((e) => defu(e, sitemap.defaults)).map((e) => {
-    const path = parseURL(e.loc).pathname;
-    let routeRules = routeRuleMatcher(path);
-    if (autoI18n?.locales && autoI18n?.strategy !== "no_prefix") {
-      const match = splitForLocales(path, autoI18n.locales.map((l) => l.code));
-      const pathWithoutPrefix = match[1];
-      if (pathWithoutPrefix && pathWithoutPrefix !== path)
-        routeRules = defu(routeRules, routeRuleMatcher(pathWithoutPrefix));
-    }
-    if (routeRules.sitemap === false)
-      return false;
-    if (typeof routeRules.index !== "undefined" && !routeRules.index)
-      return false;
-    const hasRobotsDisabled = Object.entries(routeRules.headers || {}).some(([name, value]) => name.toLowerCase() === "x-robots-tag" && value.toLowerCase() === "noindex");
-    if (routeRules.redirect || hasRobotsDisabled)
-      return false;
-    return routeRules.sitemap ? defu(e, routeRules.sitemap) : e;
-  }).filter(Boolean);
-  if (autoI18n?.locales)
-    enhancedUrls = applyI18nEnhancements(enhancedUrls, { isI18nMapped, autoI18n, ...sitemap });
-  const filteredUrls = filterSitemapUrls(enhancedUrls, { event: resolvers.event, isMultiSitemap, autoI18n, ...sitemap });
+  const resolvedSources = await resolveSitemapSources(sources, resolvers.event);
+  const enhancedUrls = resolveSitemapEntries(sitemap, resolvedSources, { autoI18n, isI18nMapped });
+  const filteredUrls = enhancedUrls.filter((e) => {
+    if (isMultiSitemap && e._sitemap && sitemap.sitemapName)
+      return e._sitemap === sitemap.sitemapName;
+    return true;
+  });
   const sortedUrls = maybeSort(filteredUrls);
-  const slicedUrls = maybeSlice(sortedUrls);
-  const nitro = useNitroApp();
-  const ctx = {
-    urls: slicedUrls,
-    sitemapName: sitemap.sitemapName
-  };
-  await nitro.hooks.callHook("sitemap:resolved", ctx);
-  const urls = maybeSort(normaliseSitemapUrls(ctx.urls, resolvers));
+  return maybeSlice(sortedUrls);
+}
+export function urlsToXml(urls, resolvers, { version, xsl, credits, minify }) {
   const urlset = urls.map((e) => {
     const keys = Object.keys(e).filter((k) => !k.startsWith("_"));
     return [
@@ -99,5 +199,5 @@ export async function buildSitemap(sitemap, resolvers, runtimeConfig) {
     '<urlset xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:video="http://www.google.com/schemas/sitemap-video/1.1" xmlns:xhtml="http://www.w3.org/1999/xhtml" xmlns:image="http://www.google.com/schemas/sitemap-image/1.1" xmlns:news="http://www.google.com/schemas/sitemap-news/0.9" xsi:schemaLocation="http://www.sitemaps.org/schemas/sitemap/0.9 http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd http://www.google.com/schemas/sitemap-image/1.1 http://www.google.com/schemas/sitemap-image/1.1/sitemap-image.xsd" xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
     urlset.join("\n"),
     "</urlset>"
-  ], resolvers, { version, xsl, credits });
+  ], resolvers, { version, xsl, credits, minify });
 }

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

@@ -1,4 +1,4 @@
 import type { ModuleRuntimeConfig, NitroUrlResolvers } from '../../../types.js';
 export declare function handleEntry(k: string, e: Record<string, any> | (string | Record<string, any>)[]): string | false;
-export declare function wrapSitemapXml(input: string[], resolvers: NitroUrlResolvers, options: Pick<ModuleRuntimeConfig, 'version' | 'xsl' | 'credits'>): string;
+export declare function wrapSitemapXml(input: string[], resolvers: NitroUrlResolvers, options: Pick<ModuleRuntimeConfig, 'version' | 'xsl' | 'credits' | 'minify'>): string;
 export declare function escapeValueForXml(value: boolean | string | number): string;

package/dist/runtime/nitro/sitemap/builder/xml.js

@@ -74,6 +74,8 @@ export function wrapSitemapXml(input, resolvers, options) {
   input.unshift(`<?xml version="1.0" encoding="UTF-8"?>${xsl ? `<?xml-stylesheet type="text/xsl" href="${xsl}"?>` : ""}`);
   if (credits)
     input.push(`<!-- XML Sitemap generated by @nuxtjs/sitemap v${options.version} at ${(/* @__PURE__ */ new Date()).toISOString()} -->`);
+  if (options.minify)
+    return input.join("").replace(/(?<!<[^>]*)\s(?![^<]*>)/g, "");
   return input.join("\n");
 }
 export function escapeValueForXml(value) {

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

@@ -1,4 +1,4 @@
 import type { H3Event } from 'h3';
 import type { ModuleRuntimeConfig, NitroUrlResolvers, SitemapDefinition } from '../../types.js';
 export declare function useNitroUrlResolvers(e: H3Event): NitroUrlResolvers;
-export declare function createSitemap(e: H3Event, definition: SitemapDefinition, runtimeConfig: ModuleRuntimeConfig): Promise<string>;
+export declare function createSitemap(event: H3Event, definition: SitemapDefinition, runtimeConfig: ModuleRuntimeConfig): Promise<string>;

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

@@ -1,8 +1,13 @@
 import { getQuery, setHeader } from "h3";
 import { fixSlashes } from "site-config-stack/urls";
-import { buildSitemap } from "./builder/sitemap.js";
-import { buildSitemapIndex } from "./builder/sitemap-index.js";
-import { createSitePathResolver, useNitroApp, useSiteConfig } from "#imports";
+import { defu } from "defu";
+import { useNitroApp } from "nitropack/runtime";
+import { 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 { sortSitemapUrls } from "./urlset/sort.js";
+import { createSitePathResolver, getPathRobotConfig, useSiteConfig } from "#imports";
 export function useNitroUrlResolvers(e) {
   const canonicalQuery = getQuery(e).canonical;
   const isShowingCanonical = typeof canonicalQuery !== "undefined" && canonicalQuery !== "false";
@@ -19,18 +24,49 @@ export function useNitroUrlResolvers(e) {
     relativeBaseUrlResolver: createSitePathResolver(e, { absolute: false, withBase: true })
   };
 }
-export async function createSitemap(e, definition, runtimeConfig) {
+export async function createSitemap(event, definition, runtimeConfig) {
   const { sitemapName } = definition;
   const nitro = useNitroApp();
-  let sitemap = await (definition.sitemapName === "index" ? buildSitemapIndex(useNitroUrlResolvers(e), runtimeConfig) : buildSitemap(definition, useNitroUrlResolvers(e), runtimeConfig));
+  const resolvers = useNitroUrlResolvers(event);
+  let sitemapUrls = await buildSitemapUrls(definition, resolvers, runtimeConfig);
+  const routeRuleMatcher = createNitroRouteRuleMatcher();
+  const { autoI18n } = runtimeConfig;
+  sitemapUrls = sitemapUrls.map((u) => {
+    const path = u._path?.pathname || u.loc;
+    if (!getPathRobotConfig(event, { path, skipSiteIndexable: true }).indexable)
+      return false;
+    let routeRules = routeRuleMatcher(path);
+    if (autoI18n?.locales && autoI18n?.strategy !== "no_prefix") {
+      const match = splitForLocales(path, autoI18n.locales.map((l) => l.code));
+      const pathWithoutPrefix = match[1];
+      if (pathWithoutPrefix && pathWithoutPrefix !== path)
+        routeRules = defu(routeRules, routeRuleMatcher(pathWithoutPrefix));
+    }
+    if (routeRules.sitemap === false)
+      return false;
+    if (typeof routeRules.index !== "undefined" && !routeRules.index || typeof routeRules.robots !== "undefined" && !routeRules.robots) {
+      return false;
+    }
+    const hasRobotsDisabled = Object.entries(routeRules.headers || {}).some(([name, value]) => name.toLowerCase() === "x-robots-tag" && value.toLowerCase().includes("noindex"));
+    if (routeRules.redirect || hasRobotsDisabled)
+      return false;
+    return routeRules.sitemap ? defu(u, routeRules.sitemap) : u;
+  }).filter(Boolean);
+  const resolvedCtx = {
+    urls: sitemapUrls,
+    sitemapName
+  };
+  await nitro.hooks.callHook("sitemap:resolved", resolvedCtx);
+  const maybeSort = (urls2) => runtimeConfig.sortEntries ? sortSitemapUrls(urls2) : urls2;
+  const urls = maybeSort(mergeOnKey(resolvedCtx.urls.map((e) => normaliseEntry(e, definition.defaults, resolvers)), "_key"));
+  const sitemap = urlsToXml(urls, resolvers, runtimeConfig);
   const ctx = { sitemap, sitemapName };
   await nitro.hooks.callHook("sitemap:output", ctx);
-  sitemap = ctx.sitemap;
-  setHeader(e, "Content-Type", "text/xml; charset=UTF-8");
+  setHeader(event, "Content-Type", "text/xml; charset=UTF-8");
   if (runtimeConfig.cacheMaxAgeSeconds)
-    setHeader(e, "Cache-Control", `public, max-age=${runtimeConfig.cacheMaxAgeSeconds}, must-revalidate`);
+    setHeader(event, "Cache-Control", `public, max-age=${runtimeConfig.cacheMaxAgeSeconds}, must-revalidate`);
   else
-    setHeader(e, "Cache-Control", `no-cache, no-store`);
-  e.context._isSitemap = true;
-  return sitemap;
+    setHeader(event, "Cache-Control", `no-cache, no-store`);
+  event.context._isSitemap = true;
+  return ctx.sitemap;
 }

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

@@ -1,4 +1,5 @@
-import type { NitroUrlResolvers, ResolvedSitemapUrl, SitemapUrlInput } from '../../../types.js';
-export declare function normaliseSitemapUrls(data: SitemapUrlInput[], resolvers: NitroUrlResolvers): ResolvedSitemapUrl[];
+import type { NitroUrlResolvers, ResolvedSitemapUrl, SitemapUrl } from '../../../types.js';
+export declare function preNormalizeEntry(_e: SitemapUrl | string): ResolvedSitemapUrl;
+export declare function normaliseEntry(_e: ResolvedSitemapUrl, defaults: Omit<SitemapUrl, 'loc'>, resolvers?: NitroUrlResolvers): ResolvedSitemapUrl;
 export declare function isValidW3CDate(d: string): boolean;
 export declare function normaliseDate(date: string | Date): string;

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

@@ -1,66 +1,77 @@
-import { hasProtocol } from "ufo";
-import { fixSlashes } from "site-config-stack/urls";
+import { hasProtocol, parsePath, parseURL } from "ufo";
+import { defu } from "defu";
 import { mergeOnKey } from "../../../utils-pure.js";
 function resolve(s, resolvers) {
-  if (typeof s === "undefined")
+  if (typeof s === "undefined" || !resolvers)
     return s;
   s = typeof s === "string" ? s : s.toString();
   if (hasProtocol(s, { acceptRelative: true, strict: false }))
     return resolvers.fixSlashes(s);
   return resolvers.canonicalUrlResolver(s);
 }
-export function normaliseSitemapUrls(data, resolvers) {
-  const entries = data.map((e) => typeof e === "string" ? { loc: e } : e).map((e) => {
-    e = { ...e };
-    if (e.url) {
-      e.loc = e.url;
-      delete e.url;
-    }
-    e.loc = fixSlashes(false, e.loc);
-    return e;
-  }).filter(Boolean);
-  function normaliseEntry(e) {
-    if (e.lastmod) {
-      const date = normaliseDate(e.lastmod);
-      if (date)
-        e.lastmod = date;
-      else
-        delete e.lastmod;
-    }
-    if (!e.lastmod)
+function removeTrailingSlash(s) {
+  return s.replace(/\/(\?|#|$)/, "$1");
+}
+export function preNormalizeEntry(_e) {
+  const e = typeof _e === "string" ? { loc: _e } : { ..._e };
+  if (e.url && !e.loc) {
+    e.loc = e.url;
+    delete e.url;
+  }
+  e.loc = removeTrailingSlash(e.loc || "");
+  e._abs = hasProtocol(e.loc, { acceptRelative: false, strict: false });
+  try {
+    e._path = e._abs ? parseURL(e.loc) : parsePath(e.loc);
+  } catch (e2) {
+    e2._path = null;
+  }
+  if (e._path?.pathname === "")
+    e.loc = `${e.loc}/`;
+  if (e._path) {
+    e._key = `${e._sitemap || ""}${e._path?.pathname || "/"}${e._path.search}`;
+  } else {
+    e._key = e.loc;
+  }
+  return e;
+}
+export function normaliseEntry(_e, defaults, resolvers) {
+  const e = defu(_e, defaults);
+  if (e.lastmod) {
+    const date = normaliseDate(e.lastmod);
+    if (date)
+      e.lastmod = date;
+    else
       delete e.lastmod;
-    e.loc = resolve(e.loc, resolvers);
-    if (e.alternatives) {
-      e.alternatives = mergeOnKey(e.alternatives.map((e2) => {
-        const a = { ...e2 };
-        if (typeof a.href === "string")
-          a.href = resolve(a.href, resolvers);
-        else if (typeof a.href === "object" && a.href)
-          a.href = resolve(a.href.href, resolvers);
-        return a;
-      }), "hreflang");
-    }
-    if (e.images) {
-      e.images = mergeOnKey(e.images.map((i) => {
-        i = { ...i };
-        i.loc = resolve(i.loc, resolvers);
-        return i;
-      }), "loc");
-    }
-    if (e.videos) {
-      e.videos = e.videos.map((v) => {
-        v = { ...v };
-        if (v.content_loc)
-          v.content_loc = resolve(v.content_loc, resolvers);
-        return v;
-      });
-    }
-    return e;
   }
-  return mergeOnKey(
-    entries.map(normaliseEntry).map((e) => ({ ...e, _key: `${e._sitemap || ""}${e.loc}` })),
-    "_key"
-  );
+  if (!e.lastmod)
+    delete e.lastmod;
+  e.loc = resolve(e.loc, resolvers);
+  if (e.alternatives) {
+    e.alternatives = mergeOnKey(e.alternatives.map((e2) => {
+      const a = { ...e2 };
+      if (typeof a.href === "string")
+        a.href = resolve(a.href, resolvers);
+      else if (typeof a.href === "object" && a.href)
+        a.href = resolve(a.href.href, resolvers);
+      return a;
+    }), "hreflang");
+  }
+  if (e.images) {
+    e.images = mergeOnKey(e.images.map((i) => {
+      i = { ...i };
+      i.loc = resolve(i.loc, resolvers);
+      return i;
+    }), "loc");
+  }
+  if (e.videos) {
+    e.videos = e.videos.map((v) => {
+      v = { ...v };
+      if (v.content_loc)
+        v.content_loc = resolve(v.content_loc, resolvers);
+      return v;
+    });
+  }
+  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))/,

package/dist/runtime/types.d.ts

@@ -1,5 +1,6 @@
 import type { FetchOptions } from 'ofetch';
 import type { H3Event } from 'h3';
+import type { ParsedURL } from 'ufo';
 export interface ModuleOptions extends SitemapDefinition {
     /**
      * Whether the sitemap.xml should be generated.
@@ -13,6 +14,12 @@ export interface ModuleOptions extends SitemapDefinition {
      * @default false
      */
     debug: boolean;
+    /**
+     * Minify the sitemap xml
+     *
+     * @default false
+     */
+    minify: boolean;
     /**
      * Should lastmod be automatically added to the sitemap.
      *
@@ -39,6 +46,12 @@ export interface ModuleOptions extends SitemapDefinition {
      * @default false
      */
     sitemaps?: boolean | MultiSitemapsInput;
+    /**
+     * The path prefix for the sitemaps.
+     *
+     * @default /__sitemap__/
+     */
+    sitemapsPathPrefix: string;
     /**
      * Sitemaps to append to the sitemap index.
      *
@@ -182,18 +195,19 @@ export interface SitemapSourceResolved extends Omit<SitemapSourceBase, 'urls'> {
 }
 export type AppSourceContext = 'nuxt:pages' | 'nuxt:prerender' | 'nuxt:route-rules' | '@nuxtjs/i18n:pages' | '@nuxt/content:document-driven';
 export type SitemapSourceInput = string | [string, FetchOptions] | SitemapSourceBase | SitemapSourceResolved;
-export type NormalisedLocales = {
+export interface NormalisedLocale {
     code: string;
     iso?: string;
     domain?: string;
-}[];
+}
+export type NormalisedLocales = NormalisedLocale[];
 export interface AutoI18nConfig {
     differentDomains?: boolean;
     locales: NormalisedLocales;
     defaultLocale: string;
     strategy: 'prefix' | 'prefix_except_default' | 'prefix_and_default' | 'no_prefix';
 }
-export interface ModuleRuntimeConfig extends Pick<ModuleOptions, 'cacheMaxAgeSeconds' | 'sitemapName' | 'excludeAppSources' | 'sortEntries' | 'defaultSitemapsChunkSize' | 'xslColumns' | 'xslTips' | 'debug' | 'discoverImages' | 'discoverVideos' | 'autoLastmod' | 'xsl' | 'credits'> {
+export interface ModuleRuntimeConfig extends Pick<ModuleOptions, 'sitemapsPathPrefix' | 'cacheMaxAgeSeconds' | 'sitemapName' | 'excludeAppSources' | 'sortEntries' | 'defaultSitemapsChunkSize' | 'xslColumns' | 'xslTips' | 'debug' | 'discoverImages' | 'discoverVideos' | 'autoLastmod' | 'xsl' | 'credits' | 'minify'> {
     version: string;
     isNuxtContentDocumentDriven: boolean;
     sitemaps: {
@@ -210,11 +224,28 @@ export interface ModuleRuntimeConfig extends Pick<ModuleOptions, 'cacheMaxAgeSec
 export interface SitemapIndexEntry {
     sitemap: string;
     lastmod?: string;
+    /**
+     * @internal
+     */
+    _sitemapName?: string;
 }
 export type FilterInput = (string | RegExp | {
     regex: string;
 });
-export type ResolvedSitemapUrl = Omit<SitemapUrl, 'url'> & Required<Pick<SitemapUrl, 'loc'>>;
+export type ResolvedSitemapUrl = Omit<SitemapUrl, 'url'> & Required<Pick<SitemapUrl, 'loc'>> & {
+    /**
+     * @internal
+     */
+    _key: string;
+    /**
+     * @internal
+     */
+    _path: ParsedURL;
+    /**
+     * @internal
+     */
+    _abs: boolean;
+};
 export interface SitemapDefinition {
     /**
      * A collection include patterns for filtering which URLs end up in the sitemap.

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

@@ -1,6 +1,7 @@
 import type { FilterInput } from './types.js';
+export declare const logger: import("consola").ConsolaInstance;
 export declare function mergeOnKey<T, K extends keyof T>(arr: T[], key: K): T[];
-export declare function splitForLocales(path: string, locales: string[]): (string | null)[];
+export declare function splitForLocales(path: string, locales: string[]): [string | null, string];
 /**
  * Transform a literal notation string regex to RegExp
  */

package/dist/runtime/utils-pure.js

@@ -1,6 +1,12 @@
 import { createDefu } from "defu";
 import { parseURL, withLeadingSlash } from "ufo";
 import { createRouter, toRouteMatcher } from "radix3";
+import { createConsola } from "consola";
+export const logger = createConsola({
+  defaults: {
+    tag: "@nuxt/sitemap"
+  }
+});
 const merger = createDefu((obj, key, value) => {
   if (Array.isArray(obj[key]) && Array.isArray(value))
     obj[key] = Array.from(/* @__PURE__ */ new Set([...obj[key], ...value]));