@nuxtjs/sitemap 7.6.0 → 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.js

@@ -1,12 +1,12 @@
+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 { validateSitemapUrl } from "../../sitemap/urlset/normalise.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)

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.js

@@ -1,8 +1,8 @@
-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) {
@@ -25,7 +25,7 @@ export default defineEventHandler(async (e) => {
   const results = await Promise.all(contentList);
   return results.flatMap(({ collection, entries }) => {
     const onUrl = onUrlFns?.get(collection);
-    return entries.filter((c) => c.sitemap !== false && c.path).map((c) => {
+    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 : {}

package/dist/runtime/server/routes/sitemap.xsl.js

@@ -1,8 +1,8 @@
-import { defineEventHandler, getHeader, setHeader, getQuery as h3GetQuery } from "h3";
+import { getSiteConfig } from "#site-config/server/composables";
+import { createSitePathResolver } from "#site-config/server/composables/utils";
+import { defineEventHandler, getHeader, getQuery as h3GetQuery, setHeader } from "h3";
 import { getQuery, parseURL, withQuery } from "ufo";
 import { useSitemapRuntimeConfig, xmlEscape } from "../utils.js";
-import { useSiteConfig } from "#site-config/server/composables/useSiteConfig";
-import { createSitePathResolver } from "#site-config/server/composables/utils";
 export default defineEventHandler(async (e) => {
   const fixPath = createSitePathResolver(e, { absolute: false, withBase: true });
   const { sitemapName: fallbackSitemapName, cacheMaxAgeSeconds, version, xslColumns, xslTips } = useSitemapRuntimeConfig();
@@ -11,7 +11,7 @@ export default defineEventHandler(async (e) => {
     setHeader(e, "Cache-Control", `public, max-age=${cacheMaxAgeSeconds}, must-revalidate`);
   else
     setHeader(e, "Cache-Control", `no-cache, no-store`);
-  const { name: siteName, url: siteUrl } = useSiteConfig(e);
+  const { name: siteName, url: siteUrl } = getSiteConfig(e);
   const referrer = getHeader(e, "Referer") || "/";
   const referrerPath = parseURL(referrer).pathname;
   const isNotIndexButHasIndex = referrerPath !== "/sitemap.xml" && referrerPath !== "/sitemap_index.xml" && referrerPath.endsWith(".xml");

package/dist/runtime/server/sitemap/builder/sitemap-index.js

@@ -1,12 +1,12 @@
 import { defu } from "defu";
-import { joinURL, withQuery } from "ufo";
-import { defineCachedFunction } from "nitropack/runtime";
 import { getHeader } from "h3";
+import { defineCachedFunction, useRuntimeConfig } from "nitropack/runtime";
+import { joinURL, withQuery } from "ufo";
 import { normaliseDate } from "../urlset/normalise.js";
-import { globalSitemapSources, childSitemapSources, resolveSitemapSources } from "../urlset/sources.js";
 import { sortInPlace } from "../urlset/sort.js";
-import { escapeValueForXml } from "./xml.js";
+import { childSitemapSources, globalSitemapSources, resolveSitemapSources } from "../urlset/sources.js";
 import { resolveSitemapEntries } from "./sitemap.js";
+import { escapeValueForXml } from "./xml.js";
 const buildSitemapIndexCached = defineCachedFunction(
   async (event, resolvers, runtimeConfig, nitro) => {
     return buildSitemapIndexInternal(resolvers, runtimeConfig, nitro);
@@ -47,7 +47,8 @@ async function buildSitemapIndexInternal(resolvers, runtimeConfig, nitro) {
   const chunks = {};
   const allFailedSources = [];
   for (const sitemapName in sitemaps) {
-    if (sitemapName === "index" || sitemapName === "chunks") continue;
+    if (sitemapName === "index" || sitemapName === "chunks")
+      continue;
     const sitemapConfig = sitemaps[sitemapName];
     if (sitemapConfig.chunks || sitemapConfig._isChunking) {
       sitemapConfig._isChunking = true;
@@ -80,7 +81,7 @@ async function buildSitemapIndexInternal(resolvers, runtimeConfig, nitro) {
       event: resolvers.event
     };
     await nitro?.hooks.callHook("sitemap:input", resolvedCtx);
-    const normalisedUrls = resolveSitemapEntries(sitemap, resolvedCtx.urls, { autoI18n, isI18nMapped }, resolvers);
+    const normalisedUrls = resolveSitemapEntries(sitemap, resolvedCtx.urls, { autoI18n, isI18nMapped }, resolvers, useRuntimeConfig().app.baseURL);
     const enhancedUrls = normalisedUrls.map((e) => defu(e, sitemap.defaults));
     const sortedUrls = maybeSort(enhancedUrls);
     sortedUrls.forEach((url, i) => {
@@ -129,7 +130,7 @@ async function buildSitemapIndexInternal(resolvers, runtimeConfig, nitro) {
         event: resolvers.event
       };
       await nitro?.hooks.callHook("sitemap:input", resolvedCtx);
-      const normalisedUrls = resolveSitemapEntries(sitemapConfig, resolvedCtx.urls, { autoI18n, isI18nMapped }, resolvers);
+      const normalisedUrls = resolveSitemapEntries(sitemapConfig, resolvedCtx.urls, { autoI18n, isI18nMapped }, resolvers, useRuntimeConfig().app.baseURL);
       const totalUrls = normalisedUrls.length;
       const chunkCount = Math.ceil(totalUrls / chunkSize);
       sitemapConfig._chunkCount = chunkCount;

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

@@ -5,7 +5,7 @@ export interface NormalizedI18n extends ResolvedSitemapUrl {
     _locale: AutoI18nConfig['locales'][number];
     _index?: number;
 }
-export declare function resolveSitemapEntries(sitemap: SitemapDefinition, urls: SitemapUrlInput[], runtimeConfig: Pick<ModuleRuntimeConfig, 'autoI18n' | 'isI18nMapped'>, resolvers?: NitroUrlResolvers): ResolvedSitemapUrl[];
+export declare function resolveSitemapEntries(sitemap: SitemapDefinition, urls: SitemapUrlInput[], runtimeConfig: Pick<ModuleRuntimeConfig, 'autoI18n' | 'isI18nMapped'>, resolvers?: NitroUrlResolvers, baseURL?: string): ResolvedSitemapUrl[];
 export declare function buildSitemapUrls(sitemap: SitemapDefinition, resolvers: NitroUrlResolvers, runtimeConfig: ModuleRuntimeConfig, nitro?: NitroApp): Promise<{
     urls: ResolvedSitemapUrl[];
     failedSources: Array<{

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

@@ -1,11 +1,12 @@
+import { useRuntimeConfig } from "nitropack/runtime";
 import { resolveSitePath } from "nuxt-site-config/urls";
 import { joinURL, withHttps } from "ufo";
+import { applyDynamicParams, createPathFilter, findPageMapping, logger, splitForLocales } from "../../../utils-pure.js";
 import { preNormalizeEntry } from "../urlset/normalise.js";
-import { childSitemapSources, globalSitemapSources, resolveSitemapSources } from "../urlset/sources.js";
 import { sortInPlace } from "../urlset/sort.js";
-import { applyDynamicParams, createPathFilter, findPageMapping, logger, splitForLocales } from "../../../utils-pure.js";
+import { childSitemapSources, globalSitemapSources, resolveSitemapSources } from "../urlset/sources.js";
 import { parseChunkInfo, sliceUrlsForChunk } from "../utils/chunk.js";
-export function resolveSitemapEntries(sitemap, urls, runtimeConfig, resolvers) {
+export function resolveSitemapEntries(sitemap, urls, runtimeConfig, resolvers, baseURL) {
   const {
     autoI18n,
     isI18nMapped
@@ -13,7 +14,7 @@ export function resolveSitemapEntries(sitemap, urls, runtimeConfig, resolvers) {
   const filterPath = createPathFilter({
     include: sitemap.include,
     exclude: sitemap.exclude
-  });
+  }, baseURL || "/");
   const _urls = urls.map((_e) => {
     const e = preNormalizeEntry(_e, resolvers);
     if (!e.loc || !filterPath(e.loc))
@@ -220,12 +221,13 @@ export async function buildSitemapUrls(sitemap, resolvers, runtimeConfig, nitro)
     event: resolvers.event
   };
   await nitro?.hooks.callHook("sitemap:input", resolvedCtx);
-  const enhancedUrls = resolveSitemapEntries(sitemap, resolvedCtx.urls, { autoI18n, isI18nMapped }, resolvers);
+  const enhancedUrls = resolveSitemapEntries(sitemap, resolvedCtx.urls, { autoI18n, isI18nMapped }, resolvers, useRuntimeConfig().app.baseURL);
   if (isMultiSitemap) {
     const sitemapNames = Object.keys(sitemaps).filter((k) => k !== "index");
     const warnedSitemaps = nitro?._sitemapWarnedSitemaps || /* @__PURE__ */ new Set();
     for (const e of enhancedUrls) {
-      if (typeof e._sitemap === "string" && !sitemapNames.includes(e._sitemap)) {
+      const hasMatchingSitemap = typeof e._sitemap === "string" && (sitemapNames.includes(e._sitemap) || isI18nMapped && sitemapNames.some((name) => name.startsWith(`${e._sitemap}-`)));
+      if (typeof e._sitemap === "string" && !hasMatchingSitemap) {
         if (!warnedSitemaps.has(e._sitemap)) {
           warnedSitemaps.add(e._sitemap);
           logger.error(`Sitemap \`${e._sitemap}\` not found in sitemap config. Available sitemaps: ${sitemapNames.join(", ")}. Entry \`${e.loc}\` will be omitted.`);
@@ -241,8 +243,8 @@ export async function buildSitemapUrls(sitemap, resolvers, runtimeConfig, nitro)
       return false;
     if (isMultiSitemap && e._sitemap && sitemap.sitemapName) {
       if (sitemap._isChunking)
-        return sitemap.sitemapName.startsWith(e._sitemap + "-");
-      return e._sitemap === sitemap.sitemapName;
+        return e._sitemap === baseSitemapName || isI18nMapped && sitemap.sitemapName.startsWith(`${e._sitemap}-`);
+      return e._sitemap === sitemap.sitemapName || isI18nMapped && sitemap.sitemapName.startsWith(`${e._sitemap}-`);
     }
     return true;
   });

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

@@ -5,13 +5,18 @@ export function escapeValueForXml(value) {
     return value ? "yes" : "no";
   return xmlEscape(String(value));
 }
-const yesNo = (v) => v === "yes" || v === true ? "yes" : "no";
+function yesNo(v) {
+  return v === "yes" || v === true ? "yes" : "no";
+}
 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, NL, I1, I2, I3, I4) {
   let xml = `${I1}<url>${NL}`;
-  if (url.loc) xml += `${I2}<loc>${xmlEscape(url.loc)}</loc>${NL}`;
-  if (url.lastmod) xml += `${I2}<lastmod>${url.lastmod}</lastmod>${NL}`;
-  if (url.changefreq) xml += `${I2}<changefreq>${url.changefreq}</changefreq>${NL}`;
+  if (url.loc)
+    xml += `${I2}<loc>${xmlEscape(url.loc)}</loc>${NL}`;
+  if (url.lastmod)
+    xml += `${I2}<lastmod>${url.lastmod}</lastmod>${NL}`;
+  if (url.changefreq)
+    xml += `${I2}<changefreq>${url.changefreq}</changefreq>${NL}`;
   if (url.priority !== void 0) {
     const p = typeof url.priority === "number" ? url.priority : Number.parseFloat(url.priority);
     xml += `${I2}<priority>${p.toFixed(1)}</priority>${NL}`;
@@ -26,29 +31,45 @@ function buildUrlXml(url, NL, I1, I2, I3, I4) {
   if (url.images) {
     for (const img of url.images) {
       xml += `${I2}<image:image>${NL}${I3}<image:loc>${xmlEscape(img.loc)}</image:loc>${NL}`;
-      if (img.title) xml += `${I3}<image:title>${xmlEscape(img.title)}</image:title>${NL}`;
-      if (img.caption) xml += `${I3}<image:caption>${xmlEscape(img.caption)}</image:caption>${NL}`;
-      if (img.geo_location) xml += `${I3}<image:geo_location>${xmlEscape(img.geo_location)}</image:geo_location>${NL}`;
-      if (img.license) xml += `${I3}<image:license>${xmlEscape(img.license)}</image:license>${NL}`;
+      if (img.title)
+        xml += `${I3}<image:title>${xmlEscape(img.title)}</image:title>${NL}`;
+      if (img.caption)
+        xml += `${I3}<image:caption>${xmlEscape(img.caption)}</image:caption>${NL}`;
+      if (img.geo_location)
+        xml += `${I3}<image:geo_location>${xmlEscape(img.geo_location)}</image:geo_location>${NL}`;
+      if (img.license)
+        xml += `${I3}<image:license>${xmlEscape(img.license)}</image:license>${NL}`;
       xml += `${I2}</image:image>${NL}`;
     }
   }
   if (url.videos) {
     for (const video of url.videos) {
       xml += `${I2}<video:video>${NL}${I3}<video:title>${xmlEscape(video.title)}</video:title>${NL}`;
-      if (video.thumbnail_loc) xml += `${I3}<video:thumbnail_loc>${xmlEscape(video.thumbnail_loc)}</video:thumbnail_loc>${NL}`;
+      if (video.thumbnail_loc)
+        xml += `${I3}<video:thumbnail_loc>${xmlEscape(video.thumbnail_loc)}</video:thumbnail_loc>${NL}`;
       xml += `${I3}<video:description>${xmlEscape(video.description)}</video:description>${NL}`;
-      if (video.content_loc) xml += `${I3}<video:content_loc>${xmlEscape(video.content_loc)}</video:content_loc>${NL}`;
-      if (video.player_loc) xml += `${I3}<video:player_loc>${xmlEscape(video.player_loc)}</video:player_loc>${NL}`;
-      if (video.duration !== void 0) xml += `${I3}<video:duration>${video.duration}</video:duration>${NL}`;
-      if (video.expiration_date) xml += `${I3}<video:expiration_date>${video.expiration_date}</video:expiration_date>${NL}`;
-      if (video.rating !== void 0) xml += `${I3}<video:rating>${video.rating}</video:rating>${NL}`;
-      if (video.view_count !== void 0) xml += `${I3}<video:view_count>${video.view_count}</video:view_count>${NL}`;
-      if (video.publication_date) xml += `${I3}<video:publication_date>${video.publication_date}</video:publication_date>${NL}`;
-      if (video.family_friendly !== void 0) xml += `${I3}<video:family_friendly>${yesNo(video.family_friendly)}</video:family_friendly>${NL}`;
-      if (video.restriction) xml += `${I3}<video:restriction relationship="${video.restriction.relationship || "allow"}">${xmlEscape(video.restriction.restriction)}</video:restriction>${NL}`;
-      if (video.platform) xml += `${I3}<video:platform relationship="${video.platform.relationship || "allow"}">${xmlEscape(video.platform.platform)}</video:platform>${NL}`;
-      if (video.requires_subscription !== void 0) xml += `${I3}<video:requires_subscription>${yesNo(video.requires_subscription)}</video:requires_subscription>${NL}`;
+      if (video.content_loc)
+        xml += `${I3}<video:content_loc>${xmlEscape(video.content_loc)}</video:content_loc>${NL}`;
+      if (video.player_loc)
+        xml += `${I3}<video:player_loc>${xmlEscape(video.player_loc)}</video:player_loc>${NL}`;
+      if (video.duration !== void 0)
+        xml += `${I3}<video:duration>${video.duration}</video:duration>${NL}`;
+      if (video.expiration_date)
+        xml += `${I3}<video:expiration_date>${video.expiration_date}</video:expiration_date>${NL}`;
+      if (video.rating !== void 0)
+        xml += `${I3}<video:rating>${video.rating}</video:rating>${NL}`;
+      if (video.view_count !== void 0)
+        xml += `${I3}<video:view_count>${video.view_count}</video:view_count>${NL}`;
+      if (video.publication_date)
+        xml += `${I3}<video:publication_date>${video.publication_date}</video:publication_date>${NL}`;
+      if (video.family_friendly !== void 0)
+        xml += `${I3}<video:family_friendly>${yesNo(video.family_friendly)}</video:family_friendly>${NL}`;
+      if (video.restriction)
+        xml += `${I3}<video:restriction relationship="${video.restriction.relationship || "allow"}">${xmlEscape(video.restriction.restriction)}</video:restriction>${NL}`;
+      if (video.platform)
+        xml += `${I3}<video:platform relationship="${video.platform.relationship || "allow"}">${xmlEscape(video.platform.platform)}</video:platform>${NL}`;
+      if (video.requires_subscription !== void 0)
+        xml += `${I3}<video:requires_subscription>${yesNo(video.requires_subscription)}</video:requires_subscription>${NL}`;
       if (video.price) {
         for (const price of video.price) {
           const c = price.currency ? ` currency="${price.currency}"` : "";
@@ -60,13 +81,16 @@ function buildUrlXml(url, NL, I1, I2, I3, I4) {
         const info = video.uploader.info ? ` info="${xmlEscape(video.uploader.info)}"` : "";
         xml += `${I3}<video:uploader${info}>${xmlEscape(video.uploader.uploader)}</video:uploader>${NL}`;
       }
-      if (video.live !== void 0) xml += `${I3}<video:live>${yesNo(video.live)}</video:live>${NL}`;
+      if (video.live !== void 0)
+        xml += `${I3}<video:live>${yesNo(video.live)}</video:live>${NL}`;
       if (video.tag) {
         const tags = Array.isArray(video.tag) ? video.tag : [video.tag];
         for (const t of tags) xml += `${I3}<video:tag>${xmlEscape(t)}</video:tag>${NL}`;
       }
-      if (video.category) xml += `${I3}<video:category>${xmlEscape(video.category)}</video:category>${NL}`;
-      if (video.gallery_loc) xml += `${I3}<video:gallery_loc>${xmlEscape(video.gallery_loc)}</video:gallery_loc>${NL}`;
+      if (video.category)
+        xml += `${I3}<video:category>${xmlEscape(video.category)}</video:category>${NL}`;
+      if (video.gallery_loc)
+        xml += `${I3}<video:gallery_loc>${xmlEscape(video.gallery_loc)}</video:gallery_loc>${NL}`;
       xml += `${I2}</video:video>${NL}`;
     }
   }
@@ -75,8 +99,10 @@ function buildUrlXml(url, NL, I1, I2, I3, I4) {
     xml += `${I4}<news:name>${xmlEscape(url.news.publication.name)}</news:name>${NL}`;
     xml += `${I4}<news:language>${xmlEscape(url.news.publication.language)}</news:language>${NL}`;
     xml += `${I3}</news:publication>${NL}`;
-    if (url.news.title) xml += `${I3}<news:title>${xmlEscape(url.news.title)}</news:title>${NL}`;
-    if (url.news.publication_date) xml += `${I3}<news:publication_date>${url.news.publication_date}</news:publication_date>${NL}`;
+    if (url.news.title)
+      xml += `${I3}<news:title>${xmlEscape(url.news.title)}</news:title>${NL}`;
+    if (url.news.publication_date)
+      xml += `${I3}<news:publication_date>${url.news.publication_date}</news:publication_date>${NL}`;
     xml += `${I2}</news:news>${NL}`;
   }
   if (import.meta.dev && url._warnings?.length) {

package/dist/runtime/server/sitemap/event-handlers.js

@@ -1,10 +1,10 @@
 import { appendHeader, createError, getRouterParam, sendRedirect, setHeader } from "h3";
-import { joinURL, withBase, withoutLeadingSlash, withoutTrailingSlash, withLeadingSlash } from "ufo";
-import { useRuntimeConfig, useNitroApp } from "nitropack/runtime";
+import { useNitroApp, useRuntimeConfig } from "nitropack/runtime";
+import { joinURL, withBase, withLeadingSlash, withoutLeadingSlash, withoutTrailingSlash } from "ufo";
 import { useSitemapRuntimeConfig } from "../utils.js";
-import { createSitemap, useNitroUrlResolvers } from "./nitro.js";
 import { buildSitemapIndex, urlsToIndexXml } from "./builder/sitemap-index.js";
-import { parseChunkInfo, getSitemapConfig } from "./utils/chunk.js";
+import { createSitemap, useNitroUrlResolvers } from "./nitro.js";
+import { getSitemapConfig, parseChunkInfo } from "./utils/chunk.js";
 export async function sitemapXmlEventHandler(e) {
   const runtimeConfig = useSitemapRuntimeConfig();
   const { sitemaps } = runtimeConfig;

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

@@ -1,15 +1,15 @@
-import { getQuery, setHeader, createError, getHeader } from "h3";
-import { fixSlashes } from "nuxt-site-config/urls";
+import { getPathRobotConfig } from "#internal/nuxt-robots/getPathRobotConfig";
+import { getSiteConfig } from "#site-config/server/composables/getSiteConfig";
+import { createSitePathResolver } from "#site-config/server/composables/utils";
 import { defu } from "defu";
-import { useNitroApp, defineCachedFunction } from "nitropack/runtime";
+import { createError, getHeader, getQuery, setHeader } from "h3";
+import { defineCachedFunction, useNitroApp } from "nitropack/runtime";
+import { fixSlashes } from "nuxt-site-config/urls";
 import { logger, mergeOnKey, splitForLocales } from "../../utils-pure.js";
 import { createNitroRouteRuleMatcher } from "../kit.js";
 import { buildSitemapUrls, urlsToXml } from "./builder/sitemap.js";
 import { normaliseEntry, preNormalizeEntry } from "./urlset/normalise.js";
 import { sortInPlace } from "./urlset/sort.js";
-import { getPathRobotConfig } from "#internal/nuxt-robots/getPathRobotConfig";
-import { getSiteConfig } from "#site-config/server/composables/getSiteConfig";
-import { createSitePathResolver } from "#site-config/server/composables/utils";
 export function useNitroUrlResolvers(e) {
   const canonicalQuery = getQuery(e).canonical;
   const isShowingCanonical = typeof canonicalQuery !== "undefined" && canonicalQuery !== "false";

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

@@ -1,3 +1,4 @@
+import { defu } from "defu";
 import {
   encodePath,
   hasProtocol,
@@ -8,7 +9,6 @@ import {
   stringifyQuery,
   withoutTrailingSlash
 } from "ufo";
-import { defu } from "defu";
 import { mergeOnKey } from "../../../utils-pure.js";
 const VALID_CHANGEFREQ = ["always", "hourly", "daily", "weekly", "monthly", "yearly", "never"];
 export function validateSitemapUrl(url) {

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

@@ -1,8 +1,8 @@
-import { getRequestHost } from "h3";
+import { parseSitemapXml } from "@nuxtjs/sitemap/utils";
 import { defu } from "defu";
+import { getRequestHost } from "h3";
 import { parseURL } from "ufo";
 import { logger } from "../../../utils-pure.js";
-import { parseSitemapXml } from "@nuxtjs/sitemap/utils";
 export function normalizeSourceInput(source) {
   if (typeof source === "string") {
     return { context: { name: "hook" }, fetch: source };

package/dist/runtime/types.d.ts

@@ -1,7 +1,7 @@
-import type { FetchOptions } from 'ofetch';
+import type { NuxtI18nOptions } from '@nuxtjs/i18n';
 import type { H3Event } from 'h3';
+import type { FetchOptions } from 'ofetch';
 import type { ParsedURL } from 'ufo';
-import type { NuxtI18nOptions } from '@nuxtjs/i18n';
 export interface ModuleOptions extends SitemapDefinition {
     /**
      * Whether the sitemap.xml should be generated.
@@ -206,10 +206,10 @@ interface LocaleObject extends Record<string, any> {
         path: string;
         cache?: boolean;
     };
-    files?: string[] | {
+    files?: (string | {
         path: string;
         cache?: boolean;
-    }[];
+    })[];
     isCatchallLocale?: boolean;
     /**
      * @deprecated in v9, use `language` instead
@@ -490,8 +490,5 @@ export interface NitroUrlResolvers {
     relativeBaseUrlResolver: (path: string) => string;
     fixSlashes: (path: string) => string;
 }
-interface NuxtI18nMicro {
-    includeDefaultLocaleRoute?: boolean;
-}
-export type I18nIntegrationOptions = NuxtI18nOptions & NuxtI18nMicro;
+export type I18nIntegrationOptions = NuxtI18nOptions;
 export {};

package/dist/runtime/utils-pure.d.ts

@@ -1,4 +1,5 @@
 import type { FilterInput } from './types.js';
+export { createFilter, type CreateFilterOptions } from 'nuxtseo-shared/utils';
 export declare const logger: import("consola").ConsolaInstance;
 export declare function mergeOnKey<T, K extends keyof T>(arr: T[], key: K): T[];
 export declare function splitForLocales(path: string, locales: string[]): [string | null, string];
@@ -6,15 +7,13 @@ export declare function splitForLocales(path: string, locales: string[]): [strin
  * Transform a literal notation string regex to RegExp
  */
 export declare function normalizeRuntimeFilters(input?: FilterInput[]): (RegExp | string)[];
-export interface CreateFilterOptions {
+export declare function createPathFilter(options?: {
     include?: (FilterInput | string | RegExp)[];
     exclude?: (FilterInput | string | RegExp)[];
-}
-export declare function createPathFilter(options?: CreateFilterOptions): (loc: string) => boolean;
+}, baseURL?: string): (loc: string) => boolean;
 export interface PageMatch {
     mappings: Record<string, string | false>;
     paramSegments: string[];
 }
 export declare function findPageMapping(pathWithoutPrefix: string, pages: Record<string, Record<string, string | false>>): PageMatch | null;
 export declare function applyDynamicParams(customPath: string, paramSegments: string[]): string;
-export declare function createFilter(options?: CreateFilterOptions): (path: string) => boolean;