@nuxtjs/sitemap 7.5.2 → 8.0.0

package/dist/runtime/server/composables/defineSitemapEventHandler.d.ts

@@ -1,4 +1,4 @@
-import { defineEventHandler } from 'h3';
 import type { EventHandlerRequest, EventHandlerResponse } from 'h3';
 import type { SitemapUrlInput } from '../../types.js';
+import { defineEventHandler } from 'h3';
 export declare const defineSitemapEventHandler: typeof defineEventHandler<EventHandlerRequest, EventHandlerResponse<SitemapUrlInput[]>>;

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

@@ -1,3 +1,2 @@
 import type { NitroRouteRules } from 'nitropack';
-export declare function withoutQuery(path: string): string | undefined;
 export declare function createNitroRouteRuleMatcher(): (pathOrUrl: string) => NitroRouteRules;

package/dist/runtime/server/kit.js

@@ -1,8 +1,8 @@
-import { createRouter as createRadixRouter, toRouteMatcher } from "radix3";
 import { defu } from "defu";
-import { parseURL, withoutBase, withoutTrailingSlash } from "ufo";
 import { useRuntimeConfig } from "nitropack/runtime";
-export function withoutQuery(path) {
+import { createRouter as createRadixRouter, toRouteMatcher } from "radix3";
+import { parseURL, withoutBase, withoutTrailingSlash } from "ufo";
+function withoutQuery(path) {
   return path.split("?")[0];
 }
 export function createNitroRouteRuleMatcher() {
@@ -10,16 +10,14 @@ export function createNitroRouteRuleMatcher() {
   const _routeRulesMatcher = toRouteMatcher(
     createRadixRouter({
       routes: Object.fromEntries(
-        Object.entries(nitro?.routeRules || {}).map(([path, rules]) => [path === "/" ? path : withoutTrailingSlash(path), rules])
+        Object.entries(nitro?.routeRules || {}).map(([path, rules]) => [withoutTrailingSlash(path), rules])
       )
     })
   );
   return (pathOrUrl) => {
     const path = pathOrUrl[0] === "/" ? pathOrUrl : parseURL(pathOrUrl, app.baseURL).pathname;
-    const pathWithoutQuery = withoutQuery(path);
     return defu({}, ..._routeRulesMatcher.matchAll(
-      // radix3 does not support trailing slashes
-      withoutBase(pathWithoutQuery === "/" ? pathWithoutQuery : withoutTrailingSlash(pathWithoutQuery), app.baseURL)
+      withoutBase(withoutTrailingSlash(withoutQuery(path)), app.baseURL)
     ).reverse());
   };
 }

package/dist/runtime/server/plugins/warm-up.js

@@ -1,5 +1,5 @@
-import { withLeadingSlash } from "ufo";
 import { defineNitroPlugin } from "nitropack/runtime";
+import { withLeadingSlash } from "ufo";
 import { useSitemapRuntimeConfig } from "../utils.js";
 export default defineNitroPlugin((nitroApp) => {
   const { sitemaps } = useSitemapRuntimeConfig();

package/dist/runtime/server/robots-polyfill/getPathRobotConfig.d.ts

@@ -1,5 +1,5 @@
 import type { H3Event } from 'h3';
-export declare function getPathRobotConfig(e: H3Event, options: any): {
+export declare function getPathRobotConfig(_e: H3Event, _options: any): {
     indexable: boolean;
     rule: string;
 };

package/dist/runtime/server/robots-polyfill/getPathRobotConfig.js

@@ -1,3 +1,3 @@
-export function getPathRobotConfig(e, options) {
+export function getPathRobotConfig(_e, _options) {
   return { indexable: true, rule: "index, follow" };
 }

package/dist/runtime/server/routes/__sitemap__/debug-production.d.ts

@@ -0,0 +1,17 @@
+import type { SitemapWarning } from '../../../../utils/parseSitemapXml.js';
+export interface ProductionSitemapEntry {
+    loc: string;
+    urlCount: number;
+    warnings: SitemapWarning[];
+    error?: string;
+    lastmod?: string;
+}
+export interface ProductionDebugResponse {
+    url: string;
+    isIndex: boolean;
+    sitemaps: ProductionSitemapEntry[];
+    warnings: SitemapWarning[];
+    error?: string;
+}
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<Record<string, any> | ProductionDebugResponse>>;
+export default _default;

package/dist/runtime/server/routes/__sitemap__/debug-production.js

@@ -0,0 +1,77 @@
+import { defineEventHandler, getQuery } from "h3";
+import { isSitemapIndex, parseSitemapIndex } from "../../../../utils/parseSitemapIndex";
+import { parseSitemapXml } from "../../../../utils/parseSitemapXml";
+async function fetchXml(url) {
+  const response = await fetch(url, {
+    headers: { Accept: "application/xml, text/xml" },
+    signal: AbortSignal.timeout(15e3)
+  });
+  if (!response.ok)
+    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+  return response.text();
+}
+export default defineEventHandler(async (e) => {
+  const { url, mode } = getQuery(e);
+  if (!url || typeof url !== "string")
+    return { url: "", isIndex: false, sitemaps: [], warnings: [], error: "Missing url query parameter" };
+  if (mode === "debug") {
+    const debugUrl = `${url.replace(/\/$/, "")}/__sitemap__/debug.json`;
+    const response = await fetch(debugUrl, {
+      headers: { Accept: "application/json" },
+      signal: AbortSignal.timeout(1e4)
+    }).catch(() => null);
+    if (response?.ok) {
+      const json = await response.json().catch(() => null);
+      if (json?.sitemaps)
+        return json;
+    }
+  }
+  const sitemapUrl = url.endsWith("/") ? `${url}sitemap.xml` : url;
+  const xml = await fetchXml(sitemapUrl).catch((err) => {
+    return err;
+  });
+  if (xml instanceof Error)
+    return { url: sitemapUrl, isIndex: false, sitemaps: [], warnings: [], error: `Failed to fetch sitemap: ${xml.message}` };
+  if (isSitemapIndex(xml)) {
+    const { entries, warnings } = parseSitemapIndex(xml);
+    const sitemaps = await Promise.all(
+      entries.map(async (entry) => {
+        const childXml = await fetchXml(entry.loc).catch((err) => err);
+        if (childXml instanceof Error) {
+          return {
+            loc: entry.loc,
+            urlCount: 0,
+            warnings: [],
+            error: childXml.message,
+            lastmod: entry.lastmod
+          };
+        }
+        const result2 = await parseSitemapXml(childXml).catch((err) => ({
+          urls: [],
+          warnings: [{ type: "validation", message: err.message }]
+        }));
+        return {
+          loc: entry.loc,
+          urlCount: result2.urls.length,
+          warnings: result2.warnings,
+          lastmod: entry.lastmod
+        };
+      })
+    );
+    return { url: sitemapUrl, isIndex: true, sitemaps, warnings };
+  }
+  const result = await parseSitemapXml(xml).catch((err) => ({
+    urls: [],
+    warnings: [{ type: "validation", message: err.message }]
+  }));
+  return {
+    url: sitemapUrl,
+    isIndex: false,
+    sitemaps: [{
+      loc: sitemapUrl,
+      urlCount: result.urls.length,
+      warnings: result.warnings
+    }],
+    warnings: []
+  };
+});

package/dist/runtime/server/routes/__sitemap__/debug.d.ts

@@ -1,4 +1,4 @@
-import type { SitemapDefinition } from '../../../types.js';
+import type { SitemapDefinition, SitemapSourceResolved } from '../../../types.js';
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
     nitroOrigin: string;
     sitemaps: Record<string, SitemapDefinition>;
@@ -35,7 +35,7 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
         credits: boolean;
         minify: boolean;
     };
-    globalSources: import("../../../types.js").SitemapSourceResolved[];
+    globalSources: SitemapSourceResolved[];
     siteConfig: {
         [x: string]: any;
         [x: number]: any;

package/dist/runtime/server/routes/__sitemap__/debug.js

@@ -1,11 +1,30 @@
+import { getNitroOrigin, getSiteConfig } from "#site-config/server/composables";
 import { defineEventHandler } from "h3";
-import { useSitemapRuntimeConfig } from "../../utils.js";
+import { validateSitemapUrl } from "../../sitemap/urlset/normalise.js";
 import {
   childSitemapSources,
   globalSitemapSources,
   resolveSitemapSources
 } from "../../sitemap/urlset/sources.js";
-import { getNitroOrigin, getSiteConfig } from "#site-config/server/composables";
+import { useSitemapRuntimeConfig } from "../../utils.js";
+function attachUrlWarnings(sources) {
+  for (const source of sources) {
+    if (!source.urls?.length)
+      continue;
+    const warnings = [];
+    for (const url of source.urls) {
+      const msgs = validateSitemapUrl(url);
+      if (msgs.length) {
+        const loc = typeof url === "string" ? url : url.loc || "";
+        for (const message of msgs)
+          warnings.push({ loc, message });
+      }
+    }
+    if (warnings.length)
+      source._urlWarnings = warnings;
+  }
+  return sources;
+}
 export default defineEventHandler(async (e) => {
   const _runtimeConfig = useSitemapRuntimeConfig();
   const siteConfig = getSiteConfig(e);
@@ -19,14 +38,14 @@ export default defineEventHandler(async (e) => {
     const sitemap = _sitemaps[s];
     sitemaps[s] = {
       ...sitemap,
-      sources: await resolveSitemapSources(await childSitemapSources(sitemap), e)
+      sources: attachUrlWarnings(await resolveSitemapSources(await childSitemapSources(sitemap), e))
     };
   }
   return {
     nitroOrigin,
     sitemaps,
     runtimeConfig,
-    globalSources: await resolveSitemapSources(globalSources, e),
+    globalSources: attachUrlWarnings(await resolveSitemapSources(globalSources, e)),
     siteConfig: { ...siteConfig }
   };
 });

package/dist/runtime/server/routes/__sitemap__/nuxt-content-urls-v2.js

@@ -1,5 +1,5 @@
-import { defineEventHandler } from "h3";
 import { serverQueryContent } from "#content/server";
+import { defineEventHandler } from "h3";
 export default defineEventHandler(async (e) => {
   const contentList = await serverQueryContent(e).find();
   return contentList.map((c) => c.sitemap).filter(Boolean);

package/dist/runtime/server/routes/__sitemap__/nuxt-content-urls-v3.d.ts

@@ -1,4 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
-    loc: string | undefined;
-}[]>>;
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<Record<string, unknown>[]>>;
 export default _default;

package/dist/runtime/server/routes/__sitemap__/nuxt-content-urls-v3.js

@@ -1,25 +1,37 @@
-import { defineEventHandler } from "h3";
-import { queryCollection } from "@nuxt/content/server";
 import manifest from "#content/manifest";
+import { filters } from "#sitemap/content-filters";
+import { onUrlFns } from "#sitemap/content-on-url";
+import { queryCollection } from "@nuxt/content/server";
+import { defineEventHandler } from "h3";
 export default defineEventHandler(async (e) => {
   const collections = [];
   for (const collection in manifest) {
-    if (manifest[collection].fields.sitemap) {
+    if (manifest[collection].fields.sitemap)
       collections.push(collection);
-    }
   }
   const contentList = [];
   for (const collection of collections) {
+    const needsAllFields = filters?.has(collection) || onUrlFns?.has(collection);
+    const query = queryCollection(e, collection).where("path", "IS NOT NULL").where("sitemap", "IS NOT NULL");
+    if (!needsAllFields)
+      query.select("path", "sitemap");
     contentList.push(
-      // @ts-expect-error dynamic collection name
-      queryCollection(e, collection).select("path", "sitemap").where("path", "IS NOT NULL").where("sitemap", "IS NOT NULL").all()
+      query.all().then((results2) => {
+        const filter = filters?.get(collection);
+        return { collection, entries: filter ? results2.filter(filter) : results2 };
+      })
     );
   }
   const results = await Promise.all(contentList);
-  return results.flatMap(
-    (entries) => entries.filter((c) => c.sitemap !== false && c.path).map((c) => ({
-      loc: c.path,
-      ...typeof c.sitemap === "object" ? c.sitemap : {}
-    }))
-  ).filter(Boolean);
+  return results.flatMap(({ collection, entries }) => {
+    const onUrl = onUrlFns?.get(collection);
+    return entries.filter((c) => c.sitemap !== false && c.path && !c.path.endsWith(".navigation")).map((c) => {
+      const url = {
+        loc: c.path,
+        ...typeof c.sitemap === "object" ? c.sitemap : {}
+      };
+      onUrl?.(url, c, collection);
+      return url;
+    });
+  }).filter(Boolean);
 });