@nuxtjs/sitemap 7.0.2 → 7.2.0

package/dist/runtime/server/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, resolvers) {
+export function resolveSitemapEntries(sitemap, urls, runtimeConfig, resolvers) {
   const {
     autoI18n,
     isI18nMapped
@@ -14,7 +14,7 @@ export function resolveSitemapEntries(sitemap, sources, runtimeConfig, resolvers
     include: sitemap.include,
     exclude: sitemap.exclude
   });
-  const _urls = sources.flatMap((e) => e.urls).map((_e) => {
+  const _urls = urls.map((_e) => {
     const e = preNormalizeEntry(_e, resolvers);
     if (!e.loc || !filterPath(e.loc))
       return false;
@@ -139,7 +139,7 @@ export function resolveSitemapEntries(sitemap, sources, runtimeConfig, resolvers
   }
   return _urls;
 }
-export async function buildSitemapUrls(sitemap, resolvers, runtimeConfig) {
+export async function buildSitemapUrls(sitemap, resolvers, runtimeConfig, nitro) {
   const {
     sitemaps,
     // enhancing
@@ -175,10 +175,15 @@ 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 }, resolvers);
+  const sourcesInput = sitemap.includeAppSources ? await globalSitemapSources() : [];
+  sourcesInput.push(...await childSitemapSources(sitemap));
+  const sources = await resolveSitemapSources(sourcesInput, resolvers.event);
+  const resolvedCtx = {
+    urls: sources.flatMap((s) => s.urls),
+    sitemapName: sitemap.sitemapName
+  };
+  await nitro?.hooks.callHook("sitemap:input", resolvedCtx);
+  const enhancedUrls = resolveSitemapEntries(sitemap, resolvedCtx.urls, { autoI18n, isI18nMapped }, resolvers);
   const filteredUrls = enhancedUrls.filter((e) => {
     if (isMultiSitemap && e._sitemap && sitemap.sitemapName)
       return e._sitemap === sitemap.sitemapName;

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

@@ -4,7 +4,7 @@ import { defu } from "defu";
 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";
+import { normaliseEntry, preNormalizeEntry } from "./urlset/normalise.js";
 import { sortSitemapUrls } from "./urlset/sort.js";
 import { useNitroApp, createSitePathResolver, getPathRobotConfig, useSiteConfig } from "#imports";
 export function useNitroUrlResolvers(e) {
@@ -39,7 +39,7 @@ export async function createSitemap(event, definition, runtimeConfig) {
     }
   }
   const resolvers = useNitroUrlResolvers(event);
-  let sitemapUrls = await buildSitemapUrls(definition, resolvers, runtimeConfig);
+  let sitemapUrls = await buildSitemapUrls(definition, resolvers, runtimeConfig, nitro);
   const routeRuleMatcher = createNitroRouteRuleMatcher();
   const { autoI18n } = runtimeConfig;
   sitemapUrls = sitemapUrls.map((u) => {
@@ -63,11 +63,15 @@ export async function createSitemap(event, definition, runtimeConfig) {
       return false;
     return routeRules.sitemap ? defu(u, routeRules.sitemap) : u;
   }).filter(Boolean);
+  const locSize = sitemapUrls.length;
   const resolvedCtx = {
     urls: sitemapUrls,
     sitemapName
   };
   await nitro.hooks.callHook("sitemap:resolved", resolvedCtx);
+  if (resolvedCtx.urls.length !== locSize) {
+    resolvedCtx.urls = resolvedCtx.urls.map((e) => preNormalizeEntry(e, resolvers));
+  }
   const maybeSort = (urls2) => runtimeConfig.sortEntries ? sortSitemapUrls(urls2) : urls2;
   const normalizedPreDedupe = resolvedCtx.urls.map((e) => normaliseEntry(e, definition.defaults, resolvers));
   const urls = maybeSort(mergeOnKey(normalizedPreDedupe, "_key").map((e) => normaliseEntry(e, definition.defaults, resolvers)));

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

@@ -1,5 +1,7 @@
 import { getRequestHost } from "h3";
 import { defu } from "defu";
+import { parseURL } from "ufo";
+import { extractSitemapXML } from "../utils/extractSitemapXML.js";
 export async function fetchDataSource(input, event) {
   const context = typeof input.context === "string" ? { name: input.context } : input.context || { name: "fetch" };
   context.tips = context.tips || [];
@@ -9,24 +11,25 @@ export async function fetchDataSource(input, event) {
   const timeout = options.timeout || 5e3;
   const timeoutController = new AbortController();
   const abortRequestTimeout = setTimeout(() => timeoutController.abort(), timeout);
-  let isHtmlResponse = false;
+  let isMaybeErrorResponse = false;
+  const isXmlRequest = parseURL(url).pathname.endsWith(".xml");
+  const fetchContainer = url.startsWith("/") && event ? event : globalThis;
   try {
-    const fetchContainer = url.startsWith("/") && event ? event : globalThis;
-    const urls = await fetchContainer.$fetch(url, {
+    const res = await fetchContainer.$fetch(url, {
       ...options,
-      responseType: "json",
+      responseType: isXmlRequest ? "text" : "json",
       signal: timeoutController.signal,
       headers: defu(options?.headers, {
-        Accept: "application/json"
+        Accept: isXmlRequest ? "text/xml" : "application/json"
       }, event ? { Host: getRequestHost(event, { xForwardedHost: true }) } : {}),
       // @ts-expect-error untyped
       onResponse({ response }) {
         if (typeof response._data === "string" && response._data.startsWith("<!DOCTYPE html>"))
-          isHtmlResponse = true;
+          isMaybeErrorResponse = true;
       }
     });
     const timeTakenMs = Date.now() - start;
-    if (isHtmlResponse) {
+    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,
@@ -36,6 +39,12 @@ export async function fetchDataSource(input, event) {
         error: "Received HTML response instead of JSON"
       };
     }
+    let urls = [];
+    if (typeof res === "object") {
+      urls = res.urls || res;
+    } else if (typeof res === "string" && parseURL(url).pathname.endsWith(".xml")) {
+      urls = extractSitemapXML(res);
+    }
     return {
       ...input,
       context,

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

@@ -0,0 +1,2 @@
+import type { SitemapUrlInput } from '../../../types.js';
+export declare function extractSitemapXML(xml: string): SitemapUrlInput[];

package/dist/runtime/server/sitemap/utils/extractSitemapXML.js

@@ -0,0 +1,75 @@
+export function extractSitemapXML(xml) {
+  const urls = xml.match(/<url>[\s\S]*?<\/url>/g) || [];
+  return urls.map((url) => {
+    const loc = url.match(/<loc>([^<]+)<\/loc>/)?.[1];
+    if (!loc) return null;
+    const lastmod = url.match(/<lastmod>([^<]+)<\/lastmod>/)?.[1];
+    const changefreq = url.match(/<changefreq>([^<]+)<\/changefreq>/)?.[1];
+    const priority = url.match(/<priority>([^<]+)<\/priority>/) ? Number.parseFloat(url.match(/<priority>([^<]+)<\/priority>/)[1]) : void 0;
+    const images = (url.match(/<image:image>[\s\S]*?<\/image:image>/g) || []).map((image) => {
+      const imageLoc = image.match(/<image:loc>([^<]+)<\/image:loc>/)?.[1];
+      return imageLoc ? { loc: imageLoc } : null;
+    }).filter(Boolean);
+    const videos = (url.match(/<video:video>[\s\S]*?<\/video:video>/g) || []).map((video) => {
+      const videoObj = {};
+      const title = video.match(/<video:title>([^<]+)<\/video:title>/)?.[1];
+      const thumbnail_loc = video.match(/<video:thumbnail_loc>([^<]+)<\/video:thumbnail_loc>/)?.[1];
+      const description = video.match(/<video:description>([^<]+)<\/video:description>/)?.[1];
+      const content_loc = video.match(/<video:content_loc>([^<]+)<\/video:content_loc>/)?.[1];
+      if (!title || !thumbnail_loc || !description || !content_loc) return null;
+      videoObj.title = title;
+      videoObj.thumbnail_loc = thumbnail_loc;
+      videoObj.description = description;
+      videoObj.content_loc = content_loc;
+      const player_loc = video.match(/<video:player_loc>([^<]+)<\/video:player_loc>/)?.[1];
+      if (player_loc) videoObj.player_loc = player_loc;
+      const duration = video.match(/<video:duration>([^<]+)<\/video:duration>/) ? Number.parseInt(video.match(/<video:duration>([^<]+)<\/video:duration>/)[1], 10) : void 0;
+      if (duration) videoObj.duration = duration;
+      const expiration_date = video.match(/<video:expiration_date>([^<]+)<\/video:expiration_date>/)?.[1];
+      if (expiration_date) videoObj.expiration_date = expiration_date;
+      const rating = video.match(/<video:rating>([^<]+)<\/video:rating>/) ? Number.parseFloat(video.match(/<video:rating>([^<]+)<\/video:rating>/)[1]) : void 0;
+      if (rating) videoObj.rating = rating;
+      const view_count = video.match(/<video:view_count>([^<]+)<\/video:view_count>/) ? Number.parseInt(video.match(/<video:view_count>([^<]+)<\/video:view_count>/)[1], 10) : void 0;
+      if (view_count) videoObj.view_count = view_count;
+      const publication_date = video.match(/<video:publication_date>([^<]+)<\/video:publication_date>/)?.[1];
+      if (publication_date) videoObj.publication_date = publication_date;
+      const family_friendly = video.match(/<video:family_friendly>([^<]+)<\/video:family_friendly>/)?.[1];
+      if (family_friendly) videoObj.family_friendly = family_friendly;
+      const restriction = video.match(/<video:restriction relationship="([^"]+)">([^<]+)<\/video:restriction>/);
+      if (restriction) videoObj.restriction = { relationship: restriction[1], restriction: restriction[2] };
+      const platform = video.match(/<video:platform relationship="([^"]+)">([^<]+)<\/video:platform>/);
+      if (platform) videoObj.platform = { relationship: platform[1], platform: platform[2] };
+      const price = (video.match(/<video:price [^>]+>([^<]+)<\/video:price>/g) || []).map((price2) => {
+        const priceValue = price2.match(/<video:price [^>]+>([^<]+)<\/video:price>/)?.[1];
+        const currency = price2.match(/currency="([^"]+)"/)?.[1];
+        const type = price2.match(/type="([^"]+)"/)?.[1];
+        return priceValue ? { price: priceValue, currency, type } : null;
+      }).filter(Boolean);
+      if (price.length) videoObj.price = price;
+      const requires_subscription = video.match(/<video:requires_subscription>([^<]+)<\/video:requires_subscription>/)?.[1];
+      if (requires_subscription) videoObj.requires_subscription = requires_subscription;
+      const uploader = video.match(/<video:uploader info="([^"]+)">([^<]+)<\/video:uploader>/);
+      if (uploader) videoObj.uploader = { uploader: uploader[2], info: uploader[1] };
+      const live = video.match(/<video:live>([^<]+)<\/video:live>/)?.[1];
+      if (live) videoObj.live = live;
+      const tag = (video.match(/<video:tag>([^<]+)<\/video:tag>/g) || []).map((tag2) => tag2.match(/<video:tag>([^<]+)<\/video:tag>/)?.[1]).filter(Boolean);
+      if (tag.length) videoObj.tag = tag;
+      return videoObj;
+    }).filter(Boolean);
+    const alternatives = (url.match(/<xhtml:link[\s\S]*?\/>/g) || []).map((link) => {
+      const hreflang = link.match(/hreflang="([^"]+)"/)?.[1];
+      const href = link.match(/href="([^"]+)"/)?.[1];
+      return hreflang && href ? { hreflang, href } : null;
+    }).filter(Boolean);
+    const news = url.match(/<news:news>[\s\S]*?<\/news:news>/) ? {
+      title: url.match(/<news:title>([^<]+)<\/news:title>/)?.[1],
+      publication_date: url.match(/<news:publication_date>([^<]+)<\/news:publication_date>/)?.[1],
+      publication: {
+        name: url.match(/<news:name>([^<]+)<\/news:name>/)?.[1],
+        language: url.match(/<news:language>([^<]+)<\/news:language>/)?.[1]
+      }
+    } : void 0;
+    const urlObj = { loc, lastmod, changefreq, priority, images, videos, alternatives, news };
+    return Object.fromEntries(Object.entries(urlObj).filter(([_, v]) => v != null && v.length !== 0));
+  }).filter(Boolean);
+}

package/dist/runtime/types.d.ts

@@ -45,7 +45,7 @@ export interface ModuleOptions extends SitemapDefinition {
      *
      * @default /__sitemap__/
      */
-    sitemapsPathPrefix: string;
+    sitemapsPathPrefix: string | false;
     /**
      * Sitemaps to append to the sitemap index.
      *
@@ -303,6 +303,10 @@ export interface SitemapRenderCtx {
     sitemapName: string;
     urls: ResolvedSitemapUrl[];
 }
+export interface SitemapInputCtx {
+    sitemapName: string;
+    urls: SitemapUrlInput[];
+}
 export interface SitemapOutputHookCtx {
     sitemapName: string;
     sitemap: string;

package/dist/types.d.mts

@@ -1 +1 @@
-export { type ModuleOptions, default } from './module.js'
+export { type ModuleOptions, type asSitemapCollection, default } from './module.js'

package/dist/types.d.ts

@@ -1 +1 @@
-export { type ModuleOptions, default } from './module'
+export { type ModuleOptions, type asSitemapCollection, default } from './module'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nuxtjs/sitemap",
   "type": "module",
-  "version": "7.0.2",
+  "version": "7.2.0",
   "description": "Powerfully flexible XML Sitemaps that integrate seamlessly, for Nuxt.",
   "author": {
     "name": "Harlan Wilton",
@@ -36,35 +36,35 @@
   ],
   "dependencies": {
     "@nuxt/devtools-kit": "^1.7.0",
-    "@nuxt/kit": "^3.15.1",
+    "@nuxt/kit": "^3.15.2",
     "chalk": "^5.4.1",
     "defu": "^6.1.4",
     "h3-compression": "^0.3.2",
     "nuxt-site-config": "^3.0.6",
     "ofetch": "^1.4.1",
-    "pathe": "^2.0.1",
-    "pkg-types": "^1.3.0",
+    "pathe": "^2.0.2",
+    "pkg-types": "^1.3.1",
     "radix3": "^1.1.2",
     "semver": "^7.6.3",
     "sirv": "^3.0.0",
     "ufo": "^1.5.4"
   },
   "devDependencies": {
-    "@nuxt/content": "^2.13.4",
+    "@nuxt/content": "^3.0.0",
     "@nuxt/eslint-config": "^0.7.5",
     "@nuxt/module-builder": "0.8.4",
     "@nuxt/test-utils": "^3.15.4",
-    "@nuxt/ui": "^2.20.0",
+    "@nuxt/ui": "^2.21.0",
     "@nuxtjs/i18n": "9.1.1",
-    "@nuxtjs/robots": "5.1.0",
-    "bumpp": "^9.10.0",
-    "eslint": "9.17.0",
+    "@nuxtjs/robots": "^5.1.1",
+    "bumpp": "^9.10.1",
+    "eslint": "^9.18.0",
     "eslint-plugin-n": "^17.15.1",
     "execa": "^9.5.2",
-    "nuxt": "^3.15.1",
-    "nuxt-i18n-micro": "^1.59.0",
+    "nuxt": "^3.15.2",
+    "nuxt-i18n-micro": "^1.64.0",
     "typescript": "5.6.3",
-    "vitest": "^2.1.8"
+    "vitest": "^3.0.2"
   },
   "resolutions": {
     "postcss": "8.4.47",
@@ -75,7 +75,8 @@
       "h3",
       "std-env",
       "nitropack",
-      "consola"
+      "consola",
+      "@nuxt/content"
     ]
   },
   "scripts": {