@nuxtjs/sitemap 5.3.5 → 6.0.0-beta.1

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 }) {
   const urlset = urls.map((e) => {
     const keys = Object.keys(e).filter((k) => !k.startsWith("_"));
     return [

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,12 @@
 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 { 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, useNitroApp, useSiteConfig } from "#imports";
 export function useNitroUrlResolvers(e) {
   const canonicalQuery = getQuery(e).canonical;
   const isShowingCanonical = typeof canonicalQuery !== "undefined" && canonicalQuery !== "false";
@@ -19,18 +23,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.
@@ -39,6 +40,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.
      *
@@ -193,7 +200,7 @@ export interface AutoI18nConfig {
     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'> {
     version: string;
     isNuxtContentDocumentDriven: boolean;
     sitemaps: {
@@ -210,11 +217,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]));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nuxtjs/sitemap",
   "type": "module",
-  "version": "5.3.5",
+  "version": "6.0.0-beta.1",
   "description": "Powerfully flexible XML Sitemaps that integrate seamlessly, for Nuxt.",
   "author": {
     "name": "Harlan Wilton",
@@ -64,7 +64,6 @@
     "eslint-plugin-n": "^17.9.0",
     "execa": "^9.3.0",
     "nuxt": "^3.12.3",
-    "nuxt-icon": "1.0.0-beta.7",
     "typescript": "5.4.5",
     "vitest": "^2.0.3"
   },
@@ -82,10 +81,9 @@
     "client:build": "nuxi generate client",
     "client:dev": "nuxi dev client --port 3300",
     "build": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxt-module-build build && npm run client:build",
-    "dev": "nuxi dev .playground",
-    "dev:devtool": "nuxi dev .playground-devtools",
-    "dev:build": "nuxi build .playground",
-    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare .playground",
+    "dev": "nuxi dev playground",
+    "dev:build": "nuxi build playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
     "release": "pnpm build && bumpp && pnpm -r publish",
     "test": "vitest"
   }

package/dist/client/_nuxt/BG-qYwi8.js

@@ -1,6 +0,0 @@
-import{g as m,h as d,l as b,i as k,j as h,k as p,m as x,n as S,q as v,I as N}from"./D0mw_hZ2.js";const C=Object.freeze({left:0,top:0,width:16,height:16}),I=Object.freeze({rotate:0,vFlip:!1,hFlip:!1}),y=Object.freeze({...C,...I});Object.freeze({...y,body:"",hidden:!1});function $(e,t){let s=e.indexOf("xlink:")===-1?"":' xmlns:xlink="http://www.w3.org/1999/xlink"';for(const n in t)s+=" "+n+'="'+t[n]+'"';return'<svg xmlns="http://www.w3.org/2000/svg"'+s+">"+e+"</svg>"}const z=/(-?[0-9.]*[0-9]+[0-9.]*)/g,R=/^-?[0-9.]*[0-9]+[0-9.]*$/g;function j(e,t,s){if(t===1)return e;s=s||100;const n=e.split(z);if(n===null||!n.length)return e;const a=[];let r=n.shift(),o=R.test(r);for(;;){if(o){const c=parseFloat(r);isNaN(c)?a.push(r):a.push(Math.ceil(c*t*s)/s)}else a.push(r);if(r=n.shift(),r===void 0)return a.join("");o=!o}}function q(e){return e.replace(/"/g,"'").replace(/%/g,"%25").replace(/#/g,"%23").replace(/</g,"%3C").replace(/>/g,"%3E").replace(/\s+/g," ")}function P(e){return"data:image/svg+xml,"+q(e)}function T(e){return'url("'+P(e)+'")'}function A(e){if(e.width!==e.height){const t=Math.max(e.width,e.height);return{...e,width:t,height:t,left:e.left-(t-e.width)/2,top:e.top-(t-e.height)/2}}return e}function L(e){const t={display:"inline-block",width:"1em",height:"1em"},s=e.varName;switch(e.pseudoSelector&&(t.content="''"),e.mode){case"background":s&&(t["background-image"]="var(--"+s+")"),t["background-repeat"]="no-repeat",t["background-size"]="100% 100%";break;case"mask":t["background-color"]="currentColor",s&&(t["mask-image"]=t["-webkit-mask-image"]="var(--"+s+")"),t["mask-repeat"]=t["-webkit-mask-repeat"]="no-repeat",t["mask-size"]=t["-webkit-mask-size"]="100% 100%";break}return t}function O(e,t){const s={},n=t.varName;e.width!==e.height&&(t.forceSquare?e=A(e):s.width=j("1em",e.width/e.height));const a=$(e.body.replace(/currentColor/g,t.color||"black"),{viewBox:`${e.left} ${e.top} ${e.width} ${e.height}`,width:e.width.toString(),height:e.height.toString()}),r=T(a);if(n)s["--"+n]=r;else switch(t.mode){case"background":s["background-image"]=r;break;case"mask":s["mask-image"]=s["-webkit-mask-image"]=r;break}return s}const g={selectorStart:{compressed:"{",compact:" {",expanded:" {"},selectorEnd:{compressed:"}",compact:`; }
-`,expanded:`;
-}
-`},rule:{compressed:"{key}:",compact:" {key}: ",expanded:`
-  {key}: `}};function E(e,t="expanded"){const s=[];for(let n=0;n<e.length;n++){const{selector:a,rules:r}=e[n];let c=(a instanceof Array?a.join(t==="compressed"?",":", "):a)+g.selectorStart[t],u=!0;for(const l in r)u||(c+=";"),c+=g.rule[t].replace("{key}",l)+r[l],u=!1;c+=g.selectorEnd[t],s.push(c)}return s.join(t==="compressed"?"":`
-`)}function M(e,t={}){const s=t.customise?t.customise(e.body):e.body,n=t.mode||(t.color||!s.includes("currentColor")?"background":"mask");let a=t.varName;a===void 0&&n==="mask"&&(a="svg");const r={...t,mode:n,varName:a};n==="background"&&delete r.varName;const o={...t.rules,...L(r),...O({...y,...e,body:s},r)},c=t.iconSelector||".icon";return E([{selector:c,rules:o}],r.format)}async function W(e){return await new Promise(t=>b([e],()=>t(!0))).catch(()=>null),k(e)}function w(e){const t=m().icon,s=(t.collections||[]).sort((n,a)=>a.length-n.length);return d(()=>{var o;const n=e(),a=n.startsWith(t.cssSelectorPrefix)?n.slice(t.cssSelectorPrefix.length):n,r=((o=t.aliases)==null?void 0:o[a])||a;if(!r.includes(":")){const c=s.find(u=>r.startsWith(u+"-"));return c?c+":"+r.slice(c.length+1):r}return r})}let f;function F(e){return e.replace(/([^\w-])/g,"\\$1")}function D(){if(f)return f;f=new Set;const e=s=>{if(s=s.replace(/^:where\((.*)\)$/,"$1").trim(),s.startsWith("."))return s},t=s=>{if(s!=null&&s.length)for(const n of s){n!=null&&n.cssRules&&t(n.cssRules);const a=n==null?void 0:n.selectorText;if(typeof a=="string"){const r=e(a);r&&f.add(r)}}};for(let s=0;s<document.styleSheets.length;s++){const n=document.styleSheets[s].cssRules||document.styleSheets[s].rules;t(n)}return f}const H=h({name:"NuxtIconCss",props:{name:{type:String,required:!0}},async setup(e){const t=p(),s=m().icon,n=d(()=>s.cssSelectorPrefix+e.name);function a(c){const u=k(c);if(u)return u;const l=t.payload.data[c];if(l)return v(c,l),l}const r=d(()=>"."+F(n.value));function o(c,u=!0){let l=r.value;s.cssWherePseudo&&(l=`:where(${l})`);const i=M(c,{iconSelector:l,format:"compressed"});return s.cssLayer&&u?`@layer ${s.cssLayer} { ${i} }`:i}{const c=D();async function u(l){if(c.has(r.value))return;const i=document.createElement("style");i.textContent=o(l),document.head.prepend(i),c.add(r.value)}x(()=>e.name,()=>{if(c.has(r.value))return;const l=a(e.name);l?u(l):W(e.name).then(i=>{i&&u(i)})},{immediate:!0})}return()=>S("span",{class:["iconify",n.value,s.class]})}}),U=h({name:"NuxtIconSvg",props:{name:{type:String,required:!0}},async setup(e,{slots:t}){const s=p(),n=m().icon,a=w(()=>e.name),r="i-"+a.value;{const o=s.payload.data[r];o&&v(a.value,o)}return()=>S(N,{icon:a.value,ssr:!0,class:n.class},t)}}),G=h({name:"NuxtIcon",props:{name:{type:String,required:!0},mode:{type:String,required:!1,default:null},size:{type:[Number,String],required:!1,default:null}},async setup(e,{slots:t}){const s=p(),n=m().icon,a=w(()=>e.name),r=d(()=>{var c;return((c=s.vueApp)==null?void 0:c.component(a.value))||((e.mode||n.mode)==="svg"?U:H)}),o=d(()=>{const c=e.size||n.size;return c?{fontSize:Number.isNaN(+c)?c:c+"px"}:null});return()=>S(r.value,{...n.attrs,name:a.value,class:n.class,style:o.value},t)}});export{G as default};