@nuxtjs/sitemap 7.4.5 → 7.4.7

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/types.d.mts

@@ -0,0 +1,5 @@
+export { default } from './module.mjs'
+
+export { type ModuleOptions } from './module.mjs'
+
+export * from '../dist/runtime/types.js'

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): Promise<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): Promise<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.mjs

@@ -0,0 +1,368 @@
+export { p as parseHtmlExtractSitemapMeta } from './shared/sitemap.DR3_6qqU.mjs';
+import 'ufo';
+import 'ultrahtml';
+
+function isValidString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function parseNumber(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "string" && value.trim()) {
+    const num = Number.parseFloat(value.trim());
+    return Number.isNaN(num) ? void 0 : num;
+  }
+  return void 0;
+}
+function parseInteger(value) {
+  if (typeof value === "number") return Math.floor(value);
+  if (typeof value === "string" && value.trim()) {
+    const num = Number.parseInt(value.trim(), 10);
+    return Number.isNaN(num) ? void 0 : num;
+  }
+  return void 0;
+}
+function extractUrlFromParsedElement(urlElement, warnings) {
+  if (!isValidString(urlElement.loc)) {
+    warnings.push({
+      type: "validation",
+      message: "URL entry missing required loc element",
+      context: { url: String(urlElement.loc || "undefined") }
+    });
+    return null;
+  }
+  const urlObj = { loc: urlElement.loc };
+  if (isValidString(urlElement.lastmod)) {
+    urlObj.lastmod = urlElement.lastmod;
+  }
+  if (isValidString(urlElement.changefreq)) {
+    const validFreqs = ["always", "hourly", "daily", "weekly", "monthly", "yearly", "never"];
+    if (validFreqs.includes(urlElement.changefreq)) {
+      urlObj.changefreq = urlElement.changefreq;
+    } else {
+      warnings.push({
+        type: "validation",
+        message: "Invalid changefreq value",
+        context: { url: urlElement.loc, field: "changefreq", value: urlElement.changefreq }
+      });
+    }
+  }
+  const priority = parseNumber(urlElement.priority);
+  if (priority !== void 0 && !Number.isNaN(priority)) {
+    if (priority < 0 || priority > 1) {
+      warnings.push({
+        type: "validation",
+        message: "Priority value should be between 0.0 and 1.0, clamping to valid range",
+        context: { url: urlElement.loc, field: "priority", value: priority }
+      });
+    }
+    urlObj.priority = Math.max(0, Math.min(1, priority));
+  } else if (urlElement.priority !== void 0) {
+    warnings.push({
+      type: "validation",
+      message: "Invalid priority value",
+      context: { url: urlElement.loc, field: "priority", value: urlElement.priority }
+    });
+  }
+  if (urlElement.image) {
+    const images = Array.isArray(urlElement.image) ? urlElement.image : [urlElement.image];
+    const validImages = images.map((img) => {
+      if (isValidString(img.loc)) {
+        return { loc: img.loc };
+      } else {
+        warnings.push({
+          type: "validation",
+          message: "Image missing required loc element",
+          context: { url: urlElement.loc, field: "image.loc" }
+        });
+        return null;
+      }
+    }).filter((img) => img !== null);
+    if (validImages.length > 0) {
+      urlObj.images = validImages;
+    }
+  }
+  if (urlElement.video) {
+    const videos = Array.isArray(urlElement.video) ? urlElement.video : [urlElement.video];
+    const validVideos = videos.map((video) => {
+      const missingFields = [];
+      if (!isValidString(video.title)) missingFields.push("title");
+      if (!isValidString(video.thumbnail_loc)) missingFields.push("thumbnail_loc");
+      if (!isValidString(video.description)) missingFields.push("description");
+      if (!isValidString(video.content_loc)) missingFields.push("content_loc");
+      if (missingFields.length > 0) {
+        warnings.push({
+          type: "validation",
+          message: `Video missing required fields: ${missingFields.join(", ")}`,
+          context: { url: urlElement.loc, field: "video" }
+        });
+        return null;
+      }
+      const videoObj = {
+        title: video.title,
+        thumbnail_loc: video.thumbnail_loc,
+        description: video.description,
+        content_loc: video.content_loc
+      };
+      if (isValidString(video.player_loc)) {
+        videoObj.player_loc = video.player_loc;
+      }
+      const duration = parseInteger(video.duration);
+      if (duration !== void 0) {
+        videoObj.duration = duration;
+      } else if (video.duration !== void 0) {
+        warnings.push({
+          type: "validation",
+          message: "Invalid video duration value",
+          context: { url: urlElement.loc, field: "video.duration", value: video.duration }
+        });
+      }
+      if (isValidString(video.expiration_date)) {
+        videoObj.expiration_date = video.expiration_date;
+      }
+      const rating = parseNumber(video.rating);
+      if (rating !== void 0) {
+        if (rating < 0 || rating > 5) {
+          warnings.push({
+            type: "validation",
+            message: "Video rating should be between 0.0 and 5.0",
+            context: { url: urlElement.loc, field: "video.rating", value: rating }
+          });
+        }
+        videoObj.rating = rating;
+      } else if (video.rating !== void 0) {
+        warnings.push({
+          type: "validation",
+          message: "Invalid video rating value",
+          context: { url: urlElement.loc, field: "video.rating", value: video.rating }
+        });
+      }
+      const viewCount = parseInteger(video.view_count);
+      if (viewCount !== void 0) {
+        videoObj.view_count = viewCount;
+      } else if (video.view_count !== void 0) {
+        warnings.push({
+          type: "validation",
+          message: "Invalid video view_count value",
+          context: { url: urlElement.loc, field: "video.view_count", value: video.view_count }
+        });
+      }
+      if (isValidString(video.publication_date)) {
+        videoObj.publication_date = video.publication_date;
+      }
+      if (isValidString(video.family_friendly)) {
+        const validValues = ["yes", "no"];
+        if (validValues.includes(video.family_friendly)) {
+          videoObj.family_friendly = video.family_friendly;
+        } else {
+          warnings.push({
+            type: "validation",
+            message: 'Invalid video family_friendly value, should be "yes" or "no"',
+            context: { url: urlElement.loc, field: "video.family_friendly", value: video.family_friendly }
+          });
+        }
+      }
+      if (isValidString(video.requires_subscription)) {
+        const validValues = ["yes", "no"];
+        if (validValues.includes(video.requires_subscription)) {
+          videoObj.requires_subscription = video.requires_subscription;
+        } else {
+          warnings.push({
+            type: "validation",
+            message: 'Invalid video requires_subscription value, should be "yes" or "no"',
+            context: { url: urlElement.loc, field: "video.requires_subscription", value: video.requires_subscription }
+          });
+        }
+      }
+      if (isValidString(video.live)) {
+        const validValues = ["yes", "no"];
+        if (validValues.includes(video.live)) {
+          videoObj.live = video.live;
+        } else {
+          warnings.push({
+            type: "validation",
+            message: 'Invalid video live value, should be "yes" or "no"',
+            context: { url: urlElement.loc, field: "video.live", value: video.live }
+          });
+        }
+      }
+      if (video.restriction && typeof video.restriction === "object") {
+        const restriction = video.restriction;
+        if (isValidString(restriction.relationship) && isValidString(restriction["#text"])) {
+          const validRelationships = ["allow", "deny"];
+          if (validRelationships.includes(restriction.relationship)) {
+            videoObj.restriction = {
+              relationship: restriction.relationship,
+              restriction: restriction["#text"]
+            };
+          } else {
+            warnings.push({
+              type: "validation",
+              message: 'Invalid video restriction relationship, should be "allow" or "deny"',
+              context: { url: urlElement.loc, field: "video.restriction.relationship", value: restriction.relationship }
+            });
+          }
+        }
+      }
+      if (video.platform && typeof video.platform === "object") {
+        const platform = video.platform;
+        if (isValidString(platform.relationship) && isValidString(platform["#text"])) {
+          const validRelationships = ["allow", "deny"];
+          if (validRelationships.includes(platform.relationship)) {
+            videoObj.platform = {
+              relationship: platform.relationship,
+              platform: platform["#text"]
+            };
+          } else {
+            warnings.push({
+              type: "validation",
+              message: 'Invalid video platform relationship, should be "allow" or "deny"',
+              context: { url: urlElement.loc, field: "video.platform.relationship", value: platform.relationship }
+            });
+          }
+        }
+      }
+      if (video.price) {
+        const prices = Array.isArray(video.price) ? video.price : [video.price];
+        const validPrices = prices.map((price) => {
+          const priceValue = price["#text"];
+          if (priceValue == null || typeof priceValue !== "string" && typeof priceValue !== "number") {
+            warnings.push({
+              type: "validation",
+              message: "Video price missing value",
+              context: { url: urlElement.loc, field: "video.price" }
+            });
+            return null;
+          }
+          const validTypes = ["rent", "purchase", "package", "subscription"];
+          if (price.type && !validTypes.includes(price.type)) {
+            warnings.push({
+              type: "validation",
+              message: `Invalid video price type "${price.type}", should be one of: ${validTypes.join(", ")}`,
+              context: { url: urlElement.loc, field: "video.price.type", value: price.type }
+            });
+          }
+          return {
+            price: String(priceValue),
+            currency: price.currency,
+            type: price.type
+          };
+        }).filter((p) => p !== null);
+        if (validPrices.length > 0) {
+          videoObj.price = validPrices;
+        }
+      }
+      if (video.uploader && typeof video.uploader === "object") {
+        const uploader = video.uploader;
+        if (isValidString(uploader.info) && isValidString(uploader["#text"])) {
+          videoObj.uploader = {
+            uploader: uploader["#text"],
+            info: uploader.info
+          };
+        } else {
+          warnings.push({
+            type: "validation",
+            message: "Video uploader missing required info or name",
+            context: { url: urlElement.loc, field: "video.uploader" }
+          });
+        }
+      }
+      if (video.tag) {
+        const tags = Array.isArray(video.tag) ? video.tag : [video.tag];
+        const validTags = tags.filter(isValidString);
+        if (validTags.length > 0) {
+          videoObj.tag = validTags;
+        }
+      }
+      return videoObj;
+    }).filter((video) => video !== null);
+    if (validVideos.length > 0) {
+      urlObj.videos = validVideos;
+    }
+  }
+  if (urlElement.link) {
+    const links = Array.isArray(urlElement.link) ? urlElement.link : [urlElement.link];
+    const alternatives = links.map((link) => {
+      if (link.rel === "alternate" && isValidString(link.hreflang) && isValidString(link.href)) {
+        return {
+          hreflang: link.hreflang,
+          href: link.href
+        };
+      } else {
+        warnings.push({
+          type: "validation",
+          message: 'Alternative link missing required rel="alternate", hreflang, or href',
+          context: { url: urlElement.loc, field: "link" }
+        });
+        return null;
+      }
+    }).filter((alt) => alt !== null);
+    if (alternatives.length > 0) {
+      urlObj.alternatives = alternatives;
+    }
+  }
+  if (urlElement.news && typeof urlElement.news === "object") {
+    const news = urlElement.news;
+    if (isValidString(news.title) && isValidString(news.publication_date) && news.publication && isValidString(news.publication.name) && isValidString(news.publication.language)) {
+      urlObj.news = {
+        title: news.title,
+        publication_date: news.publication_date,
+        publication: {
+          name: news.publication.name,
+          language: news.publication.language
+        }
+      };
+    } else {
+      warnings.push({
+        type: "validation",
+        message: "News entry missing required fields (title, publication_date, publication.name, publication.language)",
+        context: { url: urlElement.loc, field: "news" }
+      });
+    }
+  }
+  const filteredUrlObj = Object.fromEntries(
+    Object.entries(urlObj).filter(
+      ([_, value]) => value != null && (!Array.isArray(value) || value.length > 0)
+    )
+  );
+  return filteredUrlObj;
+}
+async function parseSitemapXml(xml) {
+  const warnings = [];
+  if (!xml) {
+    throw new Error("Empty XML input provided");
+  }
+  const { XMLParser } = await import('fast-xml-parser');
+  const parser = new XMLParser({
+    isArray: (tagName) => ["url", "image", "video", "link", "tag", "price"].includes(tagName),
+    removeNSPrefix: true,
+    parseAttributeValue: false,
+    ignoreAttributes: false,
+    attributeNamePrefix: "",
+    trimValues: true
+  });
+  try {
+    const parsed = parser.parse(xml);
+    if (!parsed?.urlset) {
+      throw new Error("XML does not contain a valid urlset element");
+    }
+    if (!parsed.urlset.url) {
+      throw new Error("Sitemap contains no URL entries");
+    }
+    const urls = Array.isArray(parsed.urlset.url) ? parsed.urlset.url : [parsed.urlset.url];
+    const validUrls = urls.map((url) => extractUrlFromParsedElement(url, warnings)).filter((url) => url !== null);
+    if (validUrls.length === 0 && urls.length > 0) {
+      warnings.push({
+        type: "validation",
+        message: "No valid URLs found in sitemap after validation"
+      });
+    }
+    return { urls: validUrls, warnings };
+  } catch (error) {
+    if (error instanceof Error && (error.message === "Empty XML input provided" || error.message === "XML does not contain a valid urlset element" || error.message === "Sitemap contains no URL entries")) {
+      throw error;
+    }
+    throw new Error(`Failed to parse XML: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+export { parseSitemapXml };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nuxtjs/sitemap",
   "type": "module",
-  "version": "7.4.5",
+  "version": "7.4.7",
   "description": "Powerfully flexible XML Sitemaps that integrate seamlessly, for Nuxt.",
   "author": {
     "name": "Harlan Wilton",
@@ -85,7 +85,7 @@
     "typescript": "^5.9.2",
     "vitest": "^3.2.4",
     "vue-tsc": "^3.0.7",
-    "@nuxtjs/sitemap": "7.4.5"
+    "@nuxtjs/sitemap": "7.4.7"
   },
   "scripts": {
     "lint": "eslint .",