@nuxtjs/sitemap 7.3.1 → 7.4.0

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

@@ -41,7 +41,7 @@ async function buildSitemapXml(event, definition, resolvers, runtimeConfig) {
       });
     }
   }
-  const sitemapUrls = await buildSitemapUrls(definition, resolvers, runtimeConfig, nitro);
+  const { urls: sitemapUrls, failedSources } = await buildSitemapUrls(definition, resolvers, runtimeConfig, nitro);
   const routeRuleMatcher = createNitroRouteRuleMatcher();
   const { autoI18n } = runtimeConfig;
   let validCount = 0;
@@ -94,7 +94,11 @@ async function buildSitemapXml(event, definition, resolvers, runtimeConfig) {
       }
     }
   }
-  const sitemap = urlsToXml(urls, resolvers, runtimeConfig);
+  const errorInfo = failedSources.length > 0 ? {
+    messages: failedSources.map((f) => f.error),
+    urls: failedSources.map((f) => f.url)
+  } : void 0;
+  const sitemap = urlsToXml(urls, resolvers, runtimeConfig, errorInfo);
   const ctx = { sitemap, sitemapName, event };
   await nitro.hooks.callHook("sitemap:output", ctx);
   return ctx.sitemap;
@@ -120,7 +124,7 @@ const buildSitemapXmlCached = defineCachedFunction(
 );
 export async function createSitemap(event, definition, runtimeConfig) {
   const resolvers = useNitroUrlResolvers(event);
-  const shouldCache = !import.meta.dev && runtimeConfig.cacheMaxAgeSeconds > 0;
+  const shouldCache = !import.meta.dev && typeof runtimeConfig.cacheMaxAgeSeconds === "number" && runtimeConfig.cacheMaxAgeSeconds > 0;
   const xml = shouldCache ? await buildSitemapXmlCached(event, definition, resolvers, runtimeConfig) : await buildSitemapXml(event, definition, resolvers, runtimeConfig);
   setHeader(event, "Content-Type", "text/xml; charset=UTF-8");
   if (runtimeConfig.cacheMaxAgeSeconds) {

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

@@ -75,7 +75,7 @@ export function normaliseEntry(_e, defaults, resolvers) {
     delete e.lastmod;
   e.loc = resolve(e.loc, resolvers);
   if (e.alternatives) {
-    const alternatives = e.alternatives;
+    const alternatives = e.alternatives.map((a) => ({ ...a }));
     for (let i = 0; i < alternatives.length; i++) {
       const alt = alternatives[i];
       if (typeof alt.href === "string") {
@@ -87,19 +87,20 @@ export function normaliseEntry(_e, defaults, resolvers) {
     e.alternatives = mergeOnKey(alternatives, "hreflang");
   }
   if (e.images) {
-    const images = e.images;
+    const images = e.images.map((i) => ({ ...i }));
     for (let i = 0; i < images.length; i++) {
       images[i].loc = resolve(images[i].loc, resolvers);
     }
     e.images = mergeOnKey(images, "loc");
   }
   if (e.videos) {
-    const videos = e.videos;
+    const videos = e.videos.map((v) => ({ ...v }));
     for (let i = 0; i < videos.length; i++) {
       if (videos[i].content_loc) {
         videos[i].content_loc = resolve(videos[i].content_loc, resolvers);
       }
     }
+    e.videos = mergeOnKey(videos, "content_loc");
   }
   return e;
 }

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

@@ -2,35 +2,70 @@ import { getRequestHost } from "h3";
 import { defu } from "defu";
 import { parseURL } from "ufo";
 import { extractSitemapXML } from "../utils/extractSitemapXML.js";
+import { logger } from "../../../utils-pure.js";
+async function tryFetchWithFallback(url, options, event) {
+  const isExternalUrl = !url.startsWith("/");
+  if (isExternalUrl) {
+    const strategies = [
+      // Strategy 1: Use globalThis.$fetch (original approach)
+      () => globalThis.$fetch(url, options),
+      // Strategy 2: If event is available, try using event context even for external URLs
+      event ? () => event.$fetch(url, options) : null,
+      // Strategy 3: Use native fetch as last resort
+      () => $fetch(url, options)
+    ].filter(Boolean);
+    let lastError = null;
+    for (const strategy of strategies) {
+      try {
+        return await strategy();
+      } catch (error) {
+        lastError = error;
+        continue;
+      }
+    }
+    throw lastError;
+  }
+  const fetchContainer = url.startsWith("/") && event ? event : globalThis;
+  return await fetchContainer.$fetch(url, options);
+}
 export async function fetchDataSource(input, event) {
   const context = typeof input.context === "string" ? { name: input.context } : input.context || { name: "fetch" };
-  context.tips = context.tips || [];
   const url = typeof input.fetch === "string" ? input.fetch : input.fetch[0];
   const options = typeof input.fetch === "string" ? {} : input.fetch[1];
   const start = Date.now();
-  const timeout = options.timeout || 5e3;
+  const isExternalUrl = !url.startsWith("/");
+  const timeout = isExternalUrl ? 1e4 : options.timeout || 5e3;
   const timeoutController = new AbortController();
   const abortRequestTimeout = setTimeout(() => timeoutController.abort(), timeout);
-  let isMaybeErrorResponse = false;
-  const isXmlRequest = parseURL(url).pathname.endsWith(".xml");
-  const fetchContainer = url.startsWith("/") && event ? event : globalThis;
   try {
-    const res = await fetchContainer.$fetch(url, {
+    let isMaybeErrorResponse = false;
+    const isXmlRequest = parseURL(url).pathname.endsWith(".xml");
+    const mergedHeaders = defu(
+      options?.headers,
+      {
+        Accept: isXmlRequest ? "text/xml" : "application/json"
+      },
+      event ? { host: getRequestHost(event, { xForwardedHost: true }) } : {}
+    );
+    const fetchOptions = {
       ...options,
       responseType: isXmlRequest ? "text" : "json",
       signal: timeoutController.signal,
-      headers: defu(options?.headers, {
-        Accept: isXmlRequest ? "text/xml" : "application/json"
-      }, event ? { host: getRequestHost(event, { xForwardedHost: true }) } : {}),
+      headers: mergedHeaders,
+      // Use ofetch's built-in retry for external sources
+      ...isExternalUrl && {
+        retry: 2,
+        retryDelay: 200
+      },
       // @ts-expect-error untyped
       onResponse({ response }) {
         if (typeof response._data === "string" && response._data.startsWith("<!DOCTYPE html>"))
           isMaybeErrorResponse = true;
       }
-    });
+    };
+    const res = await tryFetchWithFallback(url, fetchOptions, event);
     const timeTakenMs = Date.now() - start;
     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,
         context,
@@ -53,16 +88,26 @@ export async function fetchDataSource(input, event) {
     };
   } catch (_err) {
     const error = _err;
-    if (error.message.includes("This operation was aborted"))
-      context.tips.push("The request has taken too long. Make sure app sources respond within 5 seconds or adjust the timeout fetch option.");
-    else
-      context.tips.push(`Response returned a status of ${error.response?.status || "unknown"}.`);
-    console.error("[@nuxtjs/sitemap] Failed to fetch source.", { url, error });
+    if (isExternalUrl) {
+      const errorInfo = {
+        url,
+        timeout,
+        error: error.message,
+        statusCode: error.response?.status,
+        statusText: error.response?.statusText,
+        method: options?.method || "GET"
+      };
+      logger.error("Failed to fetch external source.", errorInfo);
+    } else {
+      logger.error("Failed to fetch source.", { url, error: error.message });
+    }
     return {
       ...input,
       context,
       urls: [],
-      error: error.message
+      error: error.message,
+      _isFailure: true
+      // Mark as failure to prevent caching
     };
   } finally {
     if (abortRequestTimeout) {

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

@@ -1,4 +1,5 @@
 import type { H3Event } from 'h3';
 import type { ModuleRuntimeConfig } from '../types.js';
 export * from '../utils-pure.js';
+export declare function xmlEscape(str: string): string;
 export declare function useSitemapRuntimeConfig(e?: H3Event): ModuleRuntimeConfig;

package/dist/runtime/server/utils.js

@@ -1,6 +1,9 @@
 import { useRuntimeConfig } from "nitropack/runtime";
 import { normalizeRuntimeFilters } from "../utils-pure.js";
 export * from "../utils-pure.js";
+export function xmlEscape(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
 export function useSitemapRuntimeConfig(e) {
   const clone = JSON.parse(JSON.stringify(useRuntimeConfig(e).sitemap));
   for (const k in clone.sitemaps) {

package/dist/runtime/types.d.ts

@@ -178,6 +178,7 @@ export interface SitemapSourceResolved extends Omit<SitemapSourceBase, 'urls'> {
     urls: SitemapUrlInput[];
     error?: any;
     timeTakenMs?: number;
+    _isFailure?: boolean;
 }
 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;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nuxtjs/sitemap",
   "type": "module",
-  "version": "7.3.1",
+  "version": "7.4.0",
   "description": "Powerfully flexible XML Sitemaps that integrate seamlessly, for Nuxt.",
   "author": {
     "name": "Harlan Wilton",
@@ -44,8 +44,8 @@
     }
   },
   "dependencies": {
-    "@nuxt/devtools-kit": "^2.4.1",
-    "@nuxt/kit": "^3.17.4",
+    "@nuxt/devtools-kit": "^2.5.0",
+    "@nuxt/kit": "^3.17.5",
     "chalk": "^5.4.1",
     "defu": "^6.1.4",
     "h3-compression": "^0.3.2",
@@ -59,23 +59,24 @@
     "ufo": "^1.6.1"
   },
   "devDependencies": {
-    "@arethetypeswrong/cli": "^0.18.1",
-    "@nuxt/content": "^3.5.1",
+    "@arethetypeswrong/cli": "^0.18.2",
+    "@nuxt/content": "^3.6.0",
     "@nuxt/eslint-config": "^1.4.1",
     "@nuxt/module-builder": "^1.0.1",
     "@nuxt/test-utils": "^3.19.1",
     "@nuxt/ui": "^3.1.3",
     "@nuxtjs/i18n": "^9.5.5",
     "@nuxtjs/robots": "^5.2.10",
+    "better-sqlite3": "^11.10.0",
     "bumpp": "^10.1.1",
-    "eslint": "^9.28.0",
-    "eslint-plugin-n": "^17.19.0",
+    "eslint": "^9.29.0",
+    "eslint-plugin-n": "^17.20.0",
     "execa": "^9.6.0",
-    "happy-dom": "^17.6.1",
-    "nuxt": "^3.17.4",
+    "happy-dom": "^18.0.1",
+    "nuxt": "^3.17.5",
     "nuxt-i18n-micro": "^1.87.0",
     "typescript": "^5.8.3",
-    "vitest": "^3.2.0",
+    "vitest": "^3.2.3",
     "vue-tsc": "^2.2.10"
   },
   "scripts": {

package/dist/client/_nuxt/BIHI7g3E.js

@@ -1 +0,0 @@
-const e={};export{e as default};