@nuxtjs/sitemap 6.0.0-beta.4 → 6.0.0

package/dist/module.mjs

@@ -1,6 +1,6 @@
 import { useNuxt, loadNuxtModuleInstance, createResolver, addTemplate, extendPages, tryUseNuxt, defineNuxtModule, useLogger, hasNuxtModule, getNuxtModuleVersion, hasNuxtModuleCompatibility, addServerImports, addServerPlugin, addServerHandler, findPath, addPrerenderRoutes } from '@nuxt/kit';
 import { withHttps, withBase, parseURL, joinURL, withoutLeadingSlash, withoutTrailingSlash, withLeadingSlash } from 'ufo';
-import { assertSiteConfig, installNuxtSiteConfig } from 'nuxt-site-config-kit';
+import { installNuxtSiteConfig } from 'nuxt-site-config-kit';
 import { defu } from 'defu';
 import { readPackageJSON } from 'pkg-types';
 import { statSync, existsSync } from 'node:fs';
@@ -72,7 +72,7 @@ function convertNuxtPagesToSitemapEntries(pages, config) {
         const stats = statSync(p.page.file);
         if (stats?.mtime)
           p.lastmod = stats.mtime;
-      } catch (e) {
+      } catch {
       }
     }
     if (p.page?.meta?.sitemap) {
@@ -86,8 +86,8 @@ function convertNuxtPagesToSitemapEntries(pages, config) {
       const [name, locale] = e.page.name.split(routesNameSeparator);
       if (!acc[name])
         acc[name] = [];
-      const { iso, code } = config.normalisedLocales.find((l) => l.code === locale) || { iso: locale, code: locale };
-      acc[name].push({ ...e, _sitemap: config.isI18nMapped ? iso || code : void 0, locale });
+      const { _sitemap } = config.normalisedLocales.find((l) => l.code === locale) || { _sitemap: locale };
+      acc[name].push({ ...e, _sitemap: config.isI18nMapped ? _sitemap : void 0, locale });
     } else {
       acc.default = acc.default || [];
       acc.default.push(e);
@@ -102,7 +102,7 @@ function convertNuxtPagesToSitemapEntries(pages, config) {
           return false;
         const defaultLocale = config.normalisedLocales.find((l) => l.code === config.defaultLocale);
         if (defaultLocale && config.isI18nMapped)
-          e._sitemap = defaultLocale.iso || defaultLocale.code;
+          e._sitemap = defaultLocale._sitemap;
         delete e.page;
         delete e.locale;
         return { ...e };
@@ -111,12 +111,11 @@ function convertNuxtPagesToSitemapEntries(pages, config) {
     return entries.map((entry) => {
       const alternatives = entries.map((entry2) => {
         const locale2 = config.normalisedLocales.find((l) => l.code === entry2.locale);
-        const hreflang = locale2?.iso || entry2.locale;
         if (!pathFilter(entry2.loc))
           return false;
         const href = locale2?.domain ? withHttps(withBase(entry2.loc, locale2?.domain)) : entry2.loc;
         return {
-          hreflang,
+          hreflang: locale2?._hreflang,
           href
         };
       }).filter(Boolean);
@@ -131,8 +130,8 @@ function convertNuxtPagesToSitemapEntries(pages, config) {
       }
       const e = { ...entry };
       if (config.isI18nMapped) {
-        const { iso, code } = config.normalisedLocales.find((l) => l.code === entry.locale) || { iso: locale, code: locale };
-        e._sitemap = iso || code;
+        const { _sitemap } = config.normalisedLocales.find((l) => l.code === entry.locale) || { _sitemap: locale };
+        e._sitemap = _sitemap;
       }
       delete e.page;
       delete e.locale;
@@ -347,7 +346,7 @@ function formatPrerenderRoute(route) {
   return chalk.gray(str);
 }
 function includesSitemapRoot(sitemapName, routes) {
-  return routes.includes(`/sitemap.xml`) || routes.includes(`/${sitemapName}`) || routes.includes("/sitemap_index.xml");
+  return routes.includes(`/__sitemap__/`) || routes.includes(`/sitemap.xml`) || routes.includes(`/${sitemapName}`) || routes.includes("/sitemap_index.xml");
 }
 function isNuxtGenerate(nuxt = useNuxt()) {
   return nuxt.options._generate || [
@@ -369,13 +368,10 @@ function setupPrerenderHandler(_options, nuxt = useNuxt()) {
     let prerenderer;
     nitro.hooks.hook("prerender:init", async (_prerenderer) => {
       prerenderer = _prerenderer;
-      assertSiteConfig("@nuxtjs/sitemap", {
-        url: "Required to generate absolute canonical URLs for your sitemap."
-      }, { throwError: false });
     });
     nitro.hooks.hook("prerender:generate", async (route) => {
       const html = route.contents;
-      if (!route.fileName?.endsWith(".html") || !html)
+      if (!route.fileName?.endsWith(".html") || !html || ["/200.html", "/404.html"].includes(route.route))
         return;
       route._sitemap = defu(route._sitemap, {
         loc: route.route
@@ -385,8 +381,8 @@ function setupPrerenderHandler(_options, nuxt = useNuxt()) {
         const match = splitForLocales(path, options.autoI18n.locales.map((l) => l.code));
         const locale = match[0] || options.autoI18n.defaultLocale;
         if (options.isI18nMapped) {
-          const { code, iso } = options.autoI18n.locales.find((l) => l.code === locale) || { code: locale, iso: locale };
-          route._sitemap._sitemap = iso || code;
+          const { _sitemap } = options.autoI18n.locales.find((l) => l.code === locale) || { _sitemap: locale };
+          route._sitemap._sitemap = _sitemap;
         }
       }
       route._sitemap = defu(extractSitemapMetaFromHtml(html, {
@@ -497,13 +493,6 @@ function splitPathForI18nLocales(path, autoI18n) {
     ...locales.map((l) => `/${l.code}${path}`)
   ];
 }
-function getOnlyLocalesFromI18nConfig(nuxtI18nConfig) {
-  const onlyLocales = nuxtI18nConfig?.bundle?.onlyLocales;
-  if (!onlyLocales)
-    return [];
-  const includedLocales = typeof onlyLocales === "string" ? [onlyLocales] : onlyLocales;
-  return includedLocales;
-}
 function generatePathForI18nPages(ctx) {
   const { localeCode, pageLocales, nuxtI18nConfig, forcedStrategy, normalisedLocales } = ctx;
   const locale = normalisedLocales.find((l) => l.code === localeCode);
@@ -519,6 +508,23 @@ function generatePathForI18nPages(ctx) {
   }
   return locale?.domain ? withHttps(withBase(path, locale.domain)) : path;
 }
+function normalizeLocales(nuxtI18nConfig) {
+  let locales = nuxtI18nConfig.locales || [];
+  let onlyLocales = nuxtI18nConfig?.bundle?.onlyLocales || [];
+  onlyLocales = typeof onlyLocales === "string" ? [onlyLocales] : onlyLocales;
+  locales = mergeOnKey(locales.map((locale) => typeof locale === "string" ? { code: locale } : locale), "code");
+  if (onlyLocales.length) {
+    locales = locales.filter((locale) => onlyLocales.includes(locale.code));
+  }
+  return locales.map((locale) => {
+    if (locale.iso && !locale.language) {
+      locale.language = locale.iso;
+    }
+    locale._hreflang = locale.language || locale.code;
+    locale._sitemap = locale.language || locale.code;
+    return locale;
+  });
+}
 
 function isValidFilter(filter) {
   if (typeof filter === "string")
@@ -647,11 +653,7 @@ const module = defineNuxtModule({
       if (!await hasNuxtModuleCompatibility("@nuxtjs/i18n", ">=8"))
         logger.warn(`You are using @nuxtjs/i18n v${i18nVersion}. For the best compatibility, please upgrade to @nuxtjs/i18n v8.0.0 or higher.`);
       nuxtI18nConfig = await getNuxtModuleOptions("@nuxtjs/i18n") || {};
-      normalisedLocales = mergeOnKey((nuxtI18nConfig.locales || []).map((locale) => typeof locale === "string" ? { code: locale } : locale), "code");
-      const onlyLocales = getOnlyLocalesFromI18nConfig(nuxtI18nConfig);
-      if (onlyLocales.length) {
-        normalisedLocales = normalisedLocales.filter((locale) => onlyLocales.includes(locale.code));
-      }
+      normalisedLocales = normalizeLocales(nuxtI18nConfig);
       usingI18nPages = !!Object.keys(nuxtI18nConfig.pages || {}).length;
       if (usingI18nPages && !hasDisabledAutoI18n) {
         const i18nPagesSources = {
@@ -670,19 +672,19 @@ const module = defineNuxtModule({
             if (!locale || !pageLocales[localeCode] || pageLocales[localeCode].includes("["))
               continue;
             const alternatives = Object.keys(pageLocales).map((l) => ({
-              hreflang: normalisedLocales.find((nl) => nl.code === l)?.iso || l,
+              hreflang: normalisedLocales.find((nl) => nl.code === l)?._hreflang || l,
               href: generatePathForI18nPages({ localeCode: l, pageLocales: pageLocales[l], nuxtI18nConfig, normalisedLocales })
             }));
             if (alternatives.length && nuxtI18nConfig.defaultLocale && pageLocales[nuxtI18nConfig.defaultLocale])
               alternatives.push({ hreflang: "x-default", href: generatePathForI18nPages({ normalisedLocales, localeCode: nuxtI18nConfig.defaultLocale, pageLocales: pageLocales[nuxtI18nConfig.defaultLocale], nuxtI18nConfig }) });
             i18nPagesSources.urls.push({
-              _sitemap: locale.iso || locale.code,
+              _sitemap: locale._sitemap,
               loc: generatePathForI18nPages({ normalisedLocales, localeCode, pageLocales: pageLocales[localeCode], nuxtI18nConfig }),
               alternatives
             });
             if (nuxtI18nConfig.strategy === "prefix_and_default" && localeCode === nuxtI18nConfig.defaultLocale) {
               i18nPagesSources.urls.push({
-                _sitemap: locale.iso || locale.code,
+                _sitemap: locale._sitemap,
                 loc: generatePathForI18nPages({ normalisedLocales, localeCode, pageLocales: pageLocales[localeCode], nuxtI18nConfig, forcedStrategy: "prefix" }),
                 alternatives
               });
@@ -715,7 +717,7 @@ const module = defineNuxtModule({
       if (canI18nMap && resolvedAutoI18n) {
         config.sitemaps = { index: [...config.sitemaps?.index || [], ...config.appendSitemaps || []] };
         for (const locale of resolvedAutoI18n.locales)
-          config.sitemaps[locale.iso || locale.code] = { includeAppSources: true };
+          config.sitemaps[locale._sitemap] = { includeAppSources: true };
         isI18nMapped = true;
         usingMultiSitemaps = true;
       }
@@ -1025,14 +1027,16 @@ declare module 'vue-router' {
         if (!pageSource.length) {
           pageSource.push(nuxt.options.app.baseURL || "/");
         }
-        if (!resolvedConfigUrls) {
-          config.urls && userGlobalSources.push({
-            context: {
-              name: "sitemap:urls",
-              description: "Set with the `sitemap.urls` config."
-            },
-            urls: await resolveUrls(config.urls, { path: "sitemap:urls", logger })
-          });
+        if (!resolvedConfigUrls && config.urls) {
+          if (config.urls) {
+            userGlobalSources.push({
+              context: {
+                name: "sitemap:urls",
+                description: "Set with the `sitemap.urls` config."
+              },
+              urls: await resolveUrls(config.urls, { path: "sitemap:urls", logger })
+            });
+          }
           resolvedConfigUrls = true;
         }
         const globalSources = [
@@ -1092,23 +1096,27 @@ declare module 'vue-router' {
           sitemapSources[sitemapName] = sitemapSources[sitemapName] || [];
           const definition = config.sitemaps[sitemapName];
           if (!sitemapSources[sitemapName].length) {
-            definition.urls && sitemapSources[sitemapName].push({
-              context: {
-                name: `sitemaps:${sitemapName}:urls`,
-                description: "Set with the `sitemap.urls` config."
-              },
-              urls: await resolveUrls(definition.urls, { path: `sitemaps:${sitemapName}:urls`, logger })
-            });
-            definition.dynamicUrlsApiEndpoint && sitemapSources[sitemapName].push({
-              context: {
-                name: `${sitemapName}:dynamicUrlsApiEndpoint`,
-                description: `Generated from your ${sitemapName}:dynamicUrlsApiEndpoint config.`,
-                tips: [
-                  `You should switch to using the \`sitemaps.${sitemapName}.sources\` config which also supports fetch options.`
-                ]
-              },
-              fetch: definition.dynamicUrlsApiEndpoint
-            });
+            if (definition.urls) {
+              sitemapSources[sitemapName].push({
+                context: {
+                  name: `sitemaps:${sitemapName}:urls`,
+                  description: "Set with the `sitemap.urls` config."
+                },
+                urls: await resolveUrls(definition.urls, { path: `sitemaps:${sitemapName}:urls`, logger })
+              });
+            }
+            if (definition.dynamicUrlsApiEndpoint) {
+              sitemapSources[sitemapName].push({
+                context: {
+                  name: `${sitemapName}:dynamicUrlsApiEndpoint`,
+                  description: `Generated from your ${sitemapName}:dynamicUrlsApiEndpoint config.`,
+                  tips: [
+                    `You should switch to using the \`sitemaps.${sitemapName}.sources\` config which also supports fetch options.`
+                  ]
+                },
+                fetch: definition.dynamicUrlsApiEndpoint
+              });
+            }
             sitemapSources[sitemapName].push(
               ...(definition.sources || []).map((s) => {
                 if (typeof s === "string" || Array.isArray(s)) {

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

@@ -27,7 +27,7 @@ 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 });
+    const normalisedUrls = resolveSitemapEntries(sitemap, sources, { autoI18n, isI18nMapped }, resolvers);
     const enhancedUrls = normalisedUrls.map((e) => defu(e, sitemap.defaults));
     const sortedUrls = maybeSort(enhancedUrls);
     sortedUrls.forEach((url, i) => {

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

@@ -4,6 +4,6 @@ export interface NormalizedI18n extends ResolvedSitemapUrl {
     _locale: AutoI18nConfig['locales'][number];
     _index?: number;
 }
-export declare function resolveSitemapEntries(sitemap: SitemapDefinition, sources: SitemapSourceResolved[], runtimeConfig: Pick<ModuleRuntimeConfig, 'autoI18n' | 'isI18nMapped'>): ResolvedSitemapUrl[];
+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 urlsToXml(urls: ResolvedSitemapUrl[], resolvers: NitroUrlResolvers, { version, xsl, credits, minify }: Pick<ModuleRuntimeConfig, 'version' | 'xsl' | 'credits' | 'minify'>): string;

package/dist/runtime/nitro/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) {
+export function resolveSitemapEntries(sitemap, sources, runtimeConfig, resolvers) {
   const {
     autoI18n,
     isI18nMapped
@@ -15,7 +15,7 @@ export function resolveSitemapEntries(sitemap, sources, runtimeConfig) {
     exclude: sitemap.exclude
   });
   const _urls = sources.flatMap((e) => e.urls).map((_e) => {
-    const e = preNormalizeEntry(_e);
+    const e = preNormalizeEntry(_e, resolvers);
     if (!e.loc || !filterPath(e.loc))
       return false;
     return e;
@@ -28,7 +28,7 @@ export function resolveSitemapEntries(sitemap, sources, runtimeConfig) {
     validI18nUrlsForTransform = _urls.map((_e, i) => {
       if (_e._abs)
         return false;
-      const split = splitForLocales(_e.loc, localeCodes);
+      const split = splitForLocales(_e._relativeLoc, localeCodes);
       let localeCode = split[0];
       const pathWithoutPrefix = split[1];
       if (!localeCode)
@@ -40,6 +40,7 @@ export function resolveSitemapEntries(sitemap, sources, runtimeConfig) {
         return false;
       e._locale = locale;
       e._index = i;
+      e._key = `${e._sitemap || ""}${e._path?.pathname || "/"}${e._path.search}`;
       withoutPrefixPaths[pathWithoutPrefix] = withoutPrefixPaths[pathWithoutPrefix] || [];
       if (!withoutPrefixPaths[pathWithoutPrefix].some((e2) => e2._locale.code === locale.code))
         withoutPrefixPaths[pathWithoutPrefix].push(e);
@@ -57,7 +58,7 @@ export function resolveSitemapEntries(sitemap, sources, runtimeConfig) {
           }
           entries.push({
             href: u.loc,
-            hreflang: u._locale.code || autoI18n.defaultLocale
+            hreflang: u._locale._hreflang || autoI18n.defaultLocale
           });
           return entries;
         }).flat().filter(Boolean);
@@ -72,13 +73,13 @@ export function resolveSitemapEntries(sitemap, sources, runtimeConfig) {
           e.alternatives = [
             {
               // apply default locale domain
-              ...autoI18n.locales.find((l) => [l.code, l.iso].includes(autoI18n.defaultLocale)),
+              ...autoI18n.locales.find((l) => [l.code, l.language].includes(autoI18n.defaultLocale)),
               code: "x-default"
             },
             ...autoI18n.locales.filter((l) => !!l.domain)
           ].map((locale) => {
             return {
-              hreflang: locale.iso || locale.code,
+              hreflang: locale._hreflang,
               href: joinURL(withHttps(locale.domain), e._pathWithoutPrefix)
             };
           });
@@ -87,15 +88,15 @@ export function resolveSitemapEntries(sitemap, sources, runtimeConfig) {
             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 _sitemap = isI18nMapped ? l._sitemap : void 0;
             const newEntry = preNormalizeEntry({
               _sitemap,
               ...e,
               _index: void 0,
-              _key: `${_sitemap || ""}${loc}`,
+              _key: `${_sitemap || ""}${loc || "/"}${e._path.search}`,
               _locale: l,
               loc,
-              alternatives: [{ code: "x-default" }, ...autoI18n.locales].map((locale) => {
+              alternatives: [{ code: "x-default", _hreflang: "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 = "";
@@ -108,15 +109,14 @@ export function resolveSitemapEntries(sitemap, sources, runtimeConfig) {
                     href = joinURL("/", code, e._pathWithoutPrefix);
                   }
                 }
-                const hreflang = locale.iso || locale.code;
                 if (!filterPath(href))
                   return false;
                 return {
-                  hreflang,
+                  hreflang: locale._hreflang,
                   href
                 };
               }).filter(Boolean)
-            });
+            }, resolvers);
             if (e._locale.code === newEntry._locale.code) {
               _urls[e._index] = newEntry;
               e._index = void 0;
@@ -127,7 +127,8 @@ export function resolveSitemapEntries(sitemap, sources, runtimeConfig) {
         }
       }
       if (isI18nMapped) {
-        e._sitemap = e._sitemap || e._locale.iso || e._locale.code;
+        e._sitemap = e._sitemap || e._locale._sitemap;
+        e._key = `${e._sitemap || ""}${e.loc || "/"}${e._path.search}`;
       }
       if (e._index)
         _urls[e._index] = e;
@@ -162,14 +163,14 @@ export async function buildSitemapUrls(sitemap, resolvers, runtimeConfig) {
     return urls;
   }
   if (autoI18n?.differentDomains) {
-    const domain = autoI18n.locales.find((e) => [e.iso, e.code].includes(sitemap.sitemapName))?.domain;
+    const domain = autoI18n.locales.find((e) => [e.language, e.code].includes(sitemap.sitemapName))?.domain;
     if (domain) {
       const _tester = resolvers.canonicalUrlResolver;
       resolvers.canonicalUrlResolver = (path) => resolveSitePath(path, {
         absolute: true,
         withBase: false,
         siteUrl: withHttps(domain),
-        trailingSlash: !_tester("/test/").endsWith("/"),
+        trailingSlash: _tester("/test/").endsWith("/"),
         base: "/"
       });
     }
@@ -177,7 +178,7 @@ 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 });
+  const enhancedUrls = resolveSitemapEntries(sitemap, resolvedSources, { autoI18n, isI18nMapped }, resolvers);
   const filteredUrls = enhancedUrls.filter((e) => {
     if (isMultiSitemap && e._sitemap && sitemap.sitemapName)
       return e._sitemap === sitemap.sitemapName;

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

@@ -1,8 +1,8 @@
-import { getQuery, setHeader } from "h3";
+import { getQuery, setHeader, createError } from "h3";
 import { fixSlashes } from "site-config-stack/urls";
 import { defu } from "defu";
 import { useNitroApp } from "nitropack/runtime";
-import { mergeOnKey, splitForLocales } from "../../utils-pure.js";
+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";
@@ -27,6 +27,18 @@ export function useNitroUrlResolvers(e) {
 export async function createSitemap(event, definition, runtimeConfig) {
   const { sitemapName } = definition;
   const nitro = useNitroApp();
+  if (import.meta.prerender) {
+    const config = useSiteConfig(event);
+    if (!config.url && !nitro._sitemapWarned) {
+      nitro._sitemapWarned = true;
+      logger.error("Sitemap Site URL missing!");
+      logger.info("To fix this please add `{ site: { url: 'site.com' } }` to your Nuxt config or a `NUXT_PUBLIC_SITE_URL=site.com` to your .env. Learn more at https://nuxtseo.com/site-config/getting-started/how-it-works");
+      throw new createError({
+        statusMessage: "You must provide a site URL to prerender a sitemap.",
+        statusCode: 500
+      });
+    }
+  }
   const resolvers = useNitroUrlResolvers(event);
   let sitemapUrls = await buildSitemapUrls(definition, resolvers, runtimeConfig);
   const routeRuleMatcher = createNitroRouteRuleMatcher();
@@ -58,7 +70,8 @@ export async function createSitemap(event, definition, runtimeConfig) {
   };
   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 normalizedPreDedupe = resolvedCtx.urls.map((e) => normaliseEntry(e, definition.defaults, resolvers));
+  const urls = maybeSort(mergeOnKey(normalizedPreDedupe, "_key").map((e) => normaliseEntry(e, definition.defaults, resolvers)));
   const sitemap = urlsToXml(urls, resolvers, runtimeConfig);
   const ctx = { sitemap, sitemapName };
   await nitro.hooks.callHook("sitemap:output", ctx);

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

@@ -1,5 +1,5 @@
 import type { NitroUrlResolvers, ResolvedSitemapUrl, SitemapUrl } from '../../../types.js';
-export declare function preNormalizeEntry(_e: SitemapUrl | string): ResolvedSitemapUrl;
+export declare function preNormalizeEntry(_e: SitemapUrl | string, resolvers?: NitroUrlResolvers): 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,4 +1,13 @@
-import { hasProtocol, parsePath, parseURL } from "ufo";
+import {
+  encodePath,
+  hasProtocol,
+  parsePath,
+  parseQuery,
+  parseURL,
+  stringifyParsedURL,
+  stringifyQuery,
+  withoutTrailingSlash
+} from "ufo";
 import { defu } from "defu";
 import { mergeOnKey } from "../../../utils-pure.js";
 function resolve(s, resolvers) {
@@ -12,26 +21,38 @@ function resolve(s, resolvers) {
 function removeTrailingSlash(s) {
   return s.replace(/\/(\?|#|$)/, "$1");
 }
-export function preNormalizeEntry(_e) {
+export function preNormalizeEntry(_e, resolvers) {
   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 || "");
+  if (typeof e.loc !== "string") {
+    e.loc = "";
+  }
+  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}`;
+    const query = parseQuery(e._path.search);
+    const qs = stringifyQuery(query);
+    e._relativeLoc = `${encodePath(e._path?.pathname)}${qs.length ? `?${qs}` : ""}`;
+    if (e._path.host) {
+      e.loc = stringifyParsedURL(e._path);
+    } else {
+      e.loc = e._relativeLoc;
+    }
   } else {
-    e._key = e.loc;
+    e.loc = encodeURI(e.loc);
   }
+  if (e.loc === "")
+    e.loc = `/`;
+  e.loc = resolve(e.loc, resolvers);
+  e._key = `${e._sitemap || ""}${withoutTrailingSlash(e.loc)}`;
   return e;
 }
 export function normaliseEntry(_e, defaults, resolvers) {

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

@@ -55,7 +55,9 @@ export async function fetchDataSource(input, event) {
       error: error.message
     };
   } finally {
-    abortRequestTimeout && clearTimeout(abortRequestTimeout);
+    if (abortRequestTimeout) {
+      clearTimeout(abortRequestTimeout);
+    }
   }
 }
 export function globalSitemapSources() {

package/dist/runtime/nitro/tsconfig.json

@@ -1,3 +1,3 @@
-{
-  "extends": "../../../.nuxt/tsconfig.server.json"
-}
+{
+  "extends": "../../../.nuxt/tsconfig.server.json"
+}

package/dist/runtime/types.d.ts

@@ -195,15 +195,34 @@ 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 interface NormalisedLocale {
+interface LocaleObject extends Record<string, any> {
     code: string;
-    iso?: string;
+    name?: string;
+    dir?: 'ltr' | 'rtl' | 'auto';
     domain?: string;
+    domains?: string[];
+    defaultForDomains?: string[];
+    file?: string | {
+        path: string;
+        cache?: boolean;
+    };
+    files?: string[] | {
+        path: string;
+        cache?: boolean;
+    }[];
+    isCatchallLocale?: boolean;
+    /**
+     * @deprecated in v9, use `language` instead
+     */
+    iso?: string;
+    language?: string;
 }
-export type NormalisedLocales = NormalisedLocale[];
 export interface AutoI18nConfig {
     differentDomains?: boolean;
-    locales: NormalisedLocales;
+    locales: (LocaleObject & {
+        _sitemap: string;
+        _hreflang: string;
+    })[];
     defaultLocale: string;
     strategy: 'prefix' | 'prefix_except_default' | 'prefix_and_default' | 'no_prefix';
 }
@@ -241,6 +260,10 @@ export type ResolvedSitemapUrl = Omit<SitemapUrl, 'url'> & Required<Pick<Sitemap
      * @internal
      */
     _path: ParsedURL;
+    /**
+     * @internal
+     */
+    _relativeLoc: string;
     /**
      * @internal
      */
@@ -399,3 +422,4 @@ export interface NitroUrlResolvers {
     relativeBaseUrlResolver: (path: string) => string;
     fixSlashes: (path: string) => string;
 }
+export {};

package/dist/types.d.mts

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

package/dist/types.d.ts

@@ -1,11 +1 @@
-import type { ModuleHooks } from './module'
-
-declare module '@nuxt/schema' {
-  interface NuxtHooks extends ModuleHooks {}
-}
-
-declare module 'nuxt/schema' {
-  interface NuxtHooks extends ModuleHooks {}
-}
-
-export { type ModuleHooks, type ModuleOptions, default } from './module'
+export { type ModuleOptions, default } from './module'