@nuxtjs/sitemap 7.3.1 → 7.4.1

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

@@ -1,3 +1,6 @@
 import type { ModuleRuntimeConfig, NitroUrlResolvers, ResolvedSitemapUrl } from '../../../types.js';
 export declare function escapeValueForXml(value: boolean | string | number): string;
-export declare function urlsToXml(urls: ResolvedSitemapUrl[], resolvers: NitroUrlResolvers, { version, xsl, credits, minify }: Pick<ModuleRuntimeConfig, 'version' | 'xsl' | 'credits' | 'minify'>): string;
+export declare function urlsToXml(urls: ResolvedSitemapUrl[], resolvers: NitroUrlResolvers, { version, xsl, credits, minify }: Pick<ModuleRuntimeConfig, 'version' | 'xsl' | 'credits' | 'minify'>, errorInfo?: {
+    messages: string[];
+    urls: string[];
+}): string;

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

@@ -1,7 +1,9 @@
+import { withQuery } from "ufo";
+import { xmlEscape } from "../../utils.js";
 export function escapeValueForXml(value) {
   if (value === true || value === false)
     return value ? "yes" : "no";
-  return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+  return xmlEscape(String(value));
 }
 const URLSET_OPENING_TAG = '<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">';
 function buildUrlXml(url) {
@@ -162,13 +164,20 @@ function buildUrlXml(url) {
   parts[partIndex++] = "    </url>";
   return parts.slice(0, partIndex).join("\n");
 }
-export function urlsToXml(urls, resolvers, { version, xsl, credits, minify }) {
+export function urlsToXml(urls, resolvers, { version, xsl, credits, minify }, errorInfo) {
   const estimatedSize = urls.length + 5;
   const xmlParts = Array.from({ length: estimatedSize });
   let partIndex = 0;
-  const xslHref = xsl ? resolvers.relativeBaseUrlResolver(xsl) : false;
+  let xslHref = xsl ? resolvers.relativeBaseUrlResolver(xsl) : false;
+  if (xslHref && errorInfo && errorInfo.messages.length > 0) {
+    xslHref = withQuery(xslHref, {
+      errors: "true",
+      error_messages: errorInfo.messages,
+      error_urls: errorInfo.urls
+    });
+  }
   if (xslHref) {
-    xmlParts[partIndex++] = `<?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet type="text/xsl" href="${xslHref}"?>`;
+    xmlParts[partIndex++] = `<?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet type="text/xsl" href="${escapeValueForXml(xslHref)}"?>`;
   } else {
     xmlParts[partIndex++] = '<?xml version="1.0" encoding="UTF-8"?>';
   }

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

@@ -1,36 +1,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,
@@ -43,7 +77,9 @@ export async function fetchDataSource(input, event) {
     if (typeof res === "object") {
       urls = res.urls || res;
     } else if (typeof res === "string" && parseURL(url).pathname.endsWith(".xml")) {
-      urls = extractSitemapXML(res);
+      const { parseSitemapXml } = await import("@nuxtjs/sitemap/utils");
+      const result = parseSitemapXml(res);
+      urls = result.urls;
     }
     return {
       ...input,
@@ -53,16 +89,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;
@@ -371,6 +372,7 @@ export interface SitemapUrl {
     _i18nTransform?: boolean;
     _sitemap?: string;
 }
+export type SitemapStrict = Required<SitemapUrl>;
 export interface AlternativeEntry {
     hreflang: string;
     href: string | URL;

package/dist/shared/sitemap.DR3_6qqU.mjs

@@ -0,0 +1,212 @@
+import { parseURL } from 'ufo';
+import { parse, walkSync, ELEMENT_NODE } from 'ultrahtml';
+
+function isValidUrl(url) {
+  if (!url || typeof url !== "string") return false;
+  const trimmed = url.trim();
+  if (!trimmed) return false;
+  if (trimmed.startsWith("data:") || trimmed.startsWith("blob:") || trimmed.startsWith("file:")) {
+    return false;
+  }
+  try {
+    const parsed = parseURL(trimmed);
+    return !!(parsed.protocol && parsed.host) || !!parsed.pathname;
+  } catch {
+    return false;
+  }
+}
+function isValidString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function sanitizeString(value) {
+  if (!isValidString(value)) return "";
+  return String(value).trim().replace(/[\x00-\x1F\x7F-\x9F]/g, "");
+}
+function isValidDate(dateString) {
+  if (!dateString) return false;
+  const date = new Date(dateString);
+  return !Number.isNaN(date.getTime()) && date.getFullYear() > 1900 && date.getFullYear() < 3e3;
+}
+function parseHtmlExtractSitemapMeta(html, options) {
+  options = options || { images: true, videos: true, lastmod: true, alternatives: true };
+  const payload = {};
+  const resolveUrl = options?.resolveUrl || ((s) => s);
+  let doc;
+  try {
+    doc = parse(html);
+  } catch (error) {
+    console.warn("Failed to parse HTML:", error);
+    return payload;
+  }
+  let mainElement = null;
+  const images = /* @__PURE__ */ new Set();
+  const videos = [];
+  const videoSources = /* @__PURE__ */ new Map();
+  let articleModifiedTime;
+  const alternatives = [];
+  walkSync(doc, (node) => {
+    if (node.type === ELEMENT_NODE) {
+      const element = node;
+      const attrs = element.attributes || {};
+      if (element.name === "main" && !mainElement) {
+        mainElement = element;
+      }
+      if (options?.lastmod && element.name === "meta") {
+        const property = sanitizeString(attrs.property);
+        const content = sanitizeString(attrs.content);
+        if (property === "article:modified_time" && content && isValidDate(content)) {
+          articleModifiedTime = content;
+        }
+      }
+      if (options?.alternatives && element.name === "link") {
+        const rel = sanitizeString(attrs.rel);
+        const href = sanitizeString(attrs.href);
+        const hreflang = sanitizeString(attrs.hreflang);
+        if (rel === "alternate" && href && hreflang && isValidUrl(href)) {
+          const hreflangPattern = /^[a-z]{2}(?:-[A-Z]{2})?$|^x-default$/;
+          if (hreflangPattern.test(hreflang)) {
+            try {
+              const parsed = parseURL(href);
+              if (parsed.pathname) {
+                alternatives.push({
+                  hreflang,
+                  href: parsed.pathname
+                });
+              }
+            } catch {
+            }
+          }
+        }
+      }
+    }
+  });
+  const searchScope = mainElement || doc;
+  walkSync(searchScope, (node) => {
+    if (node.type === ELEMENT_NODE) {
+      const element = node;
+      const attrs = element.attributes || {};
+      if (options?.images && element.name === "img") {
+        const src = sanitizeString(attrs.src);
+        if (src && isValidUrl(src)) {
+          const resolvedUrl = resolveUrl(src);
+          if (isValidUrl(resolvedUrl)) {
+            images.add(resolvedUrl);
+          }
+        }
+      }
+      if (options?.videos && element.name === "video") {
+        const content_loc = sanitizeString(attrs.src);
+        const thumbnail_loc = sanitizeString(attrs.poster);
+        const title = sanitizeString(attrs["data-title"]);
+        const description = sanitizeString(attrs["data-description"]);
+        if (!title || !description) {
+          return;
+        }
+        const videoObj = {
+          content_loc,
+          thumbnail_loc,
+          title,
+          description
+        };
+        const player_loc = sanitizeString(attrs["data-player-loc"]);
+        if (player_loc && isValidUrl(player_loc)) {
+          videoObj.player_loc = player_loc;
+        }
+        const duration = sanitizeString(attrs["data-duration"]);
+        if (duration) {
+          const parsedDuration = Number.parseInt(duration, 10);
+          if (!Number.isNaN(parsedDuration) && parsedDuration > 0 && parsedDuration <= 28800) {
+            videoObj.duration = parsedDuration;
+          }
+        }
+        const expiration_date = sanitizeString(attrs["data-expiration-date"]);
+        if (expiration_date && isValidDate(expiration_date)) {
+          videoObj.expiration_date = expiration_date;
+        }
+        const rating = sanitizeString(attrs["data-rating"]);
+        if (rating) {
+          const parsedRating = Number.parseFloat(rating);
+          if (!Number.isNaN(parsedRating) && parsedRating >= 0 && parsedRating <= 5) {
+            videoObj.rating = parsedRating;
+          }
+        }
+        const view_count = sanitizeString(attrs["data-view-count"]);
+        if (view_count) {
+          const parsedViewCount = Number.parseInt(view_count, 10);
+          if (!Number.isNaN(parsedViewCount) && parsedViewCount >= 0) {
+            videoObj.view_count = parsedViewCount;
+          }
+        }
+        const publication_date = sanitizeString(attrs["data-publication-date"]);
+        if (publication_date && isValidDate(publication_date)) {
+          videoObj.publication_date = publication_date;
+        }
+        const family_friendly = sanitizeString(attrs["data-family-friendly"]);
+        if (family_friendly && ["yes", "no"].includes(family_friendly.toLowerCase())) {
+          videoObj.family_friendly = family_friendly.toLowerCase();
+        }
+        const requires_subscription = sanitizeString(attrs["data-requires-subscription"]);
+        if (requires_subscription && ["yes", "no"].includes(requires_subscription.toLowerCase())) {
+          videoObj.requires_subscription = requires_subscription.toLowerCase();
+        }
+        const live = sanitizeString(attrs["data-live"]);
+        if (live && ["yes", "no"].includes(live.toLowerCase())) {
+          videoObj.live = live.toLowerCase();
+        }
+        const tag = sanitizeString(attrs["data-tag"]);
+        if (tag && tag.length <= 256) {
+          videoObj.tag = tag;
+        }
+        videos.push({ videoObj, element });
+      }
+      if (options?.videos && element.name === "source" && element.parent && element.parent.name === "video") {
+        const videoElement = element.parent;
+        const src = sanitizeString(attrs.src);
+        if (src && isValidUrl(src)) {
+          if (!videoSources.has(videoElement)) {
+            videoSources.set(videoElement, []);
+          }
+          videoSources.get(videoElement).push(src);
+        }
+      }
+    }
+  });
+  if (options?.images && images.size > 0) {
+    payload.images = [...images].map((i) => ({ loc: i }));
+  }
+  if (options?.videos) {
+    const processedVideos = [];
+    for (const { videoObj, element } of videos) {
+      const sources = videoSources.get(element) || [];
+      if (sources.length > 0) {
+        for (const source of sources) {
+          const resolvedVideoObj = { ...videoObj };
+          if (resolvedVideoObj.thumbnail_loc) {
+            resolvedVideoObj.thumbnail_loc = resolveUrl(String(resolvedVideoObj.thumbnail_loc));
+          }
+          processedVideos.push({
+            ...resolvedVideoObj,
+            content_loc: resolveUrl(source)
+          });
+        }
+      } else {
+        processedVideos.push(videoObj);
+      }
+    }
+    const validVideos = processedVideos.filter((v) => {
+      return isValidString(v.title) && isValidString(v.description) && isValidString(v.content_loc) && isValidUrl(v.content_loc) && isValidString(v.thumbnail_loc) && isValidUrl(v.thumbnail_loc) && v.title.length <= 2048 && v.description.length <= 2048;
+    });
+    if (validVideos.length > 0) {
+      payload.videos = validVideos;
+    }
+  }
+  if (options?.lastmod && articleModifiedTime) {
+    payload.lastmod = articleModifiedTime;
+  }
+  if (options?.alternatives && alternatives.length > 0 && (alternatives.length > 1 || alternatives[0].hreflang !== "x-default")) {
+    payload.alternatives = alternatives;
+  }
+  return payload;
+}
+
+export { parseHtmlExtractSitemapMeta as p };

package/dist/utils.d.mts

@@ -0,0 +1,28 @@
+import { SitemapUrlInput, SitemapUrl } from '../dist/runtime/types.js';
+export * from '../dist/runtime/types.js';
+
+interface SitemapWarning {
+    type: 'validation';
+    message: string;
+    context?: {
+        url?: string;
+        field?: string;
+        value?: unknown;
+    };
+}
+interface SitemapParseResult {
+    urls: SitemapUrlInput[];
+    warnings: SitemapWarning[];
+}
+declare function parseSitemapXml(xml: string): SitemapParseResult;
+
+declare function parseHtmlExtractSitemapMeta(html: string, options?: {
+    images?: boolean;
+    videos?: boolean;
+    lastmod?: boolean;
+    alternatives?: boolean;
+    resolveUrl?: (s: string) => string;
+}): Partial<SitemapUrl>;
+
+export { parseHtmlExtractSitemapMeta, parseSitemapXml };
+export type { SitemapParseResult, SitemapWarning };

package/dist/utils.d.ts

@@ -0,0 +1,28 @@
+import { SitemapUrlInput, SitemapUrl } from '../dist/runtime/types.js';
+export * from '../dist/runtime/types.js';
+
+interface SitemapWarning {
+    type: 'validation';
+    message: string;
+    context?: {
+        url?: string;
+        field?: string;
+        value?: unknown;
+    };
+}
+interface SitemapParseResult {
+    urls: SitemapUrlInput[];
+    warnings: SitemapWarning[];
+}
+declare function parseSitemapXml(xml: string): SitemapParseResult;
+
+declare function parseHtmlExtractSitemapMeta(html: string, options?: {
+    images?: boolean;
+    videos?: boolean;
+    lastmod?: boolean;
+    alternatives?: boolean;
+    resolveUrl?: (s: string) => string;
+}): Partial<SitemapUrl>;
+
+export { parseHtmlExtractSitemapMeta, parseSitemapXml };
+export type { SitemapParseResult, SitemapWarning };