@nuxtjs/sitemap 7.4.4 → 7.4.5

package/dist/shared/sitemap.DR3_6qqU.mjs

@@ -1,212 +0,0 @@
-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

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

package/dist/utils.d.mts

@@ -1,28 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,368 +0,0 @@
-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 };