@whatworks/payload-sitemap 0.1.0

package/dist/index.js

@@ -0,0 +1,281 @@
+import { C as createNextTagsCache, S as createMemoryCache, T as sitemapCacheTag, _ as getSitemapConfig, a as generateRobotsTxt, b as siteUrlFromRequest, c as getChunkEntries, d as finalizeEntries, f as formatLoc, g as ROUTES_GROUP, i as buildRobotsData, l as getIndexItems, m as getSitemapEntries, n as buildUrlsetXml, o as renderRobotsTxt, p as getGroupEntries, r as escapeXml, s as chunkFileName, t as buildSitemapIndexXml, u as matchChunkFile, v as resolveSitemapConfig, w as noopCache, x as SITEMAP_CACHE_TAG, y as resolveSiteUrl } from "./xml-DSOM2moN.js";
+
+//#region src/core/invalidate.ts
+/** Groups already scheduled for invalidation within one request (bulk-operation dedupe). */
+const scheduledPerRequest = /* @__PURE__ */ new WeakMap();
+/**
+* Runs `fn` after the current request settles. `afterChange` hooks execute inside
+* the operation's transaction — invalidating immediately could regenerate from a
+* pre-commit snapshot. Next's `after()` fires post-response (post-commit); outside
+* a Next request scope we fall back to a macrotask, which the local API's awaited
+* operation has committed by.
+*/
+const runAfterRequest = (fn) => {
+	import("next/server").then((mod) => {
+		try {
+			if (mod.after) {
+				mod.after(fn);
+				return;
+			}
+		} catch {}
+		setTimeout(fn, 0);
+	}, () => setTimeout(fn, 0));
+};
+const scheduleInvalidation = (req, config, group) => {
+	let scheduled = scheduledPerRequest.get(req);
+	if (!scheduled) {
+		scheduled = /* @__PURE__ */ new Set();
+		scheduledPerRequest.set(req, scheduled);
+	}
+	if (scheduled.has(group)) return;
+	scheduled.add(group);
+	const logger = req.payload.logger;
+	runAfterRequest(() => {
+		Promise.resolve(config.cache.invalidate([group])).catch((err) => {
+			logger.error({ err }, `[payload-sitemap] Failed to invalidate group "${group}"`);
+		});
+	});
+};
+const defaultShouldInvalidate = (doc, previousDoc) => {
+	const status = doc._status;
+	if (typeof status !== "string") return true;
+	return status === "published" || previousDoc?._status === "published";
+};
+const createAfterChangeHook = (slug, collConfig, config) => {
+	return ({ doc, operation, previousDoc, req }) => {
+		if (collConfig.shouldInvalidate ? collConfig.shouldInvalidate({
+			doc,
+			operation,
+			previousDoc
+		}) : defaultShouldInvalidate(doc, previousDoc)) scheduleInvalidation(req, config, slug);
+		return doc;
+	};
+};
+const createAfterDeleteHook = (slug, config) => {
+	return ({ doc, req }) => {
+		scheduleInvalidation(req, config, slug);
+		return doc;
+	};
+};
+/**
+* Manually invalidate cached sitemap groups — e.g. from a hook on a global that
+* feeds the `routes` option. Invalidates every group when none are given.
+*/
+const invalidateSitemap = async (payload, groups) => {
+	const config = getSitemapConfig(payload.config);
+	await config.cache.invalidate(groups ?? config.groups);
+};
+
+//#endregion
+//#region src/endpoints/createEndpoints.ts
+const checkAccess = async (req, access) => access ? await access({ req }) : true;
+const forbidden = () => new Response("Forbidden", { status: 403 });
+const xmlResponse = (xml, cacheControl) => new Response(xml, { headers: {
+	"Cache-Control": cacheControl,
+	"Content-Type": "application/xml; charset=utf-8"
+} });
+/**
+* The origin the index uses to reference its own chunk files. These endpoints live
+* on the CMS origin (which may differ from `siteUrl` in decoupled setups), so it
+* is derived from the request unless explicitly configured.
+*/
+const endpointOrigin = (req, endpoints) => endpoints.origin ?? new URL(req.url ?? "http://localhost").origin;
+const createSitemapEndpoints = (config) => {
+	const endpoints = config.endpoints;
+	if (!endpoints) return [];
+	const built = [{
+		handler: async (req) => {
+			if (!await checkAccess(req, endpoints.access)) return forbidden();
+			const base = `${endpointOrigin(req, endpoints)}${req.payload.config.routes.api}${endpoints.path}`;
+			return xmlResponse(buildSitemapIndexXml(await getIndexItems({
+				chunkUrl: (file) => `${base}/${file}`,
+				config,
+				payload: req.payload,
+				req
+			})), endpoints.cacheControl);
+		},
+		method: "get",
+		path: `${endpoints.path}/index.xml`
+	}];
+	if (endpoints.json) {
+		const jsonAccess = endpoints.json.access;
+		built.push({
+			handler: async (req) => {
+				if (!await checkAccess(req, jsonAccess)) return forbidden();
+				const entries = await getSitemapEntries(req.payload, { req });
+				return Response.json({ entries }, { headers: { "Cache-Control": endpoints.cacheControl } });
+			},
+			method: "get",
+			path: `${endpoints.path}/entries.json`
+		});
+	}
+	built.push({
+		handler: async (req) => {
+			if (!await checkAccess(req, endpoints.access)) return forbidden();
+			const file = req.routeParams?.file;
+			if (typeof file !== "string") return new Response("Not found", { status: 404 });
+			const chunk = await getChunkEntries({
+				config,
+				file,
+				payload: req.payload,
+				req
+			});
+			if (!chunk) return new Response("Not found", { status: 404 });
+			const collConfig = config.collections[chunk.group];
+			return xmlResponse(buildUrlsetXml(finalizeEntries(chunk.entries, {
+				siteUrl: config.siteUrl({ request: req }),
+				trailingSlash: config.trailingSlash
+			}), {
+				changeFreq: collConfig?.changeFreq,
+				priority: collConfig?.priority
+			}), endpoints.cacheControl);
+		},
+		method: "get",
+		path: `${endpoints.path}/:file`
+	});
+	return built;
+};
+
+//#endregion
+//#region src/plugin.ts
+/** Sidebar positioning only applies at the collection root; nested fields render inline. */
+const excludeFromSitemapField = (nested) => ({
+	name: "excludeFromSitemap",
+	type: "checkbox",
+	...nested ? {} : { admin: { position: "sidebar" } },
+	label: "Exclude from sitemap"
+});
+/** Missing path segments become nested group fields, with `injected` innermost. */
+const buildGroupChain = (segments, injected) => {
+	const [head, ...rest] = segments;
+	return {
+		name: head,
+		type: "group",
+		fields: rest.length ? [buildGroupChain(rest, injected)] : injected
+	};
+};
+/**
+* Appends `injected` to the container at `segments` — each segment a group
+* field or named tab. Descends into layout-only containers (rows, collapsibles,
+* unnamed groups and tabs) since they don't affect the data path, but only
+* follows named groups/tabs when they match the next segment — a match inside
+* any other named container would live at a different query path than the
+* `<group>.excludeFromSitemap` filter used at generation time. Once a segment
+* matches, missing deeper segments are created inside it as group fields.
+*/
+const injectAtPath = (fields, segments, injected, collectionSlug) => {
+	const [segment, ...rest] = segments;
+	let found = false;
+	/** Children of a matched container: inject directly, descend, or create the missing tail. */
+	const withInjected = (children) => {
+		if (!rest.length) return [...children, ...injected];
+		const result = injectAtPath(children, rest, injected, collectionSlug);
+		return result.injected ? result.fields : [...children, buildGroupChain(rest, injected)];
+	};
+	return {
+		fields: fields.map((field) => {
+			if (found) return field;
+			if ("name" in field && field.name === segment) {
+				if (field.type !== "group") throw new Error(`[payload-sitemap] adminFields.group segment "${segment}" matches a "${field.type}" field on collection "${collectionSlug}" — each segment must be a group field or a named tab.`);
+				found = true;
+				return {
+					...field,
+					fields: withInjected(field.fields)
+				};
+			}
+			if (field.type === "tabs") {
+				const tabs = field.tabs.map((tab) => {
+					if (found) return tab;
+					if ("name" in tab && tab.name === segment) {
+						found = true;
+						return {
+							...tab,
+							fields: withInjected(tab.fields)
+						};
+					}
+					if (!("name" in tab)) {
+						const result = injectAtPath(tab.fields, segments, injected, collectionSlug);
+						if (result.injected) {
+							found = true;
+							return {
+								...tab,
+								fields: result.fields
+							};
+						}
+					}
+					return tab;
+				});
+				return found ? {
+					...field,
+					tabs
+				} : field;
+			}
+			if (field.type === "row" || field.type === "collapsible" || field.type === "group" && !("name" in field)) {
+				const result = injectAtPath(field.fields, segments, injected, collectionSlug);
+				if (result.injected) {
+					found = true;
+					return {
+						...field,
+						fields: result.fields
+					};
+				}
+			}
+			return field;
+		}),
+		injected: found
+	};
+};
+const sitemapPlugin = (pluginConfig) => (config) => {
+	const slugs = Object.keys(pluginConfig.collections);
+	/**
+	* Fields are injected even when the plugin is disabled so the database schema
+	* stays consistent for migrations.
+	*/
+	if (pluginConfig.adminFields?.exclude !== false) {
+		const groupPath = pluginConfig.adminFields?.group;
+		const segments = groupPath ? groupPath.split(".") : [];
+		if (segments.some((segment) => !segment)) throw new Error(`[payload-sitemap] adminFields.group "${groupPath}" is not a valid field path.`);
+		const injected = [excludeFromSitemapField(segments.length > 0)];
+		config.collections = (config.collections ?? []).map((collection) => {
+			if (!slugs.includes(collection.slug)) return collection;
+			if (!segments.length) return {
+				...collection,
+				fields: [...collection.fields, ...injected]
+			};
+			const result = injectAtPath(collection.fields, segments, injected, collection.slug);
+			if (result.injected) return {
+				...collection,
+				fields: result.fields
+			};
+			return {
+				...collection,
+				fields: [...collection.fields, buildGroupChain(segments, injected)]
+			};
+		});
+	}
+	if (pluginConfig.disabled) return config;
+	for (const slug of slugs) if (!config.collections?.some((collection) => collection.slug === slug)) console.warn(`[payload-sitemap] Collection "${slug}" is configured for the sitemap but does not exist.`);
+	const resolved = resolveSitemapConfig(pluginConfig);
+	config.custom = {
+		...config.custom,
+		sitemap: resolved
+	};
+	config.collections = (config.collections ?? []).map((collection) => {
+		const collConfig = resolved.collections[collection.slug];
+		if (!collConfig) return collection;
+		return {
+			...collection,
+			hooks: {
+				...collection.hooks,
+				afterChange: [...collection.hooks?.afterChange ?? [], createAfterChangeHook(collection.slug, collConfig, resolved)],
+				afterDelete: [...collection.hooks?.afterDelete ?? [], createAfterDeleteHook(collection.slug, resolved)]
+			}
+		};
+	});
+	if (resolved.endpoints) config.endpoints = [...config.endpoints ?? [], ...createSitemapEndpoints(resolved)];
+	return config;
+};
+
+//#endregion
+export { ROUTES_GROUP, SITEMAP_CACHE_TAG, buildRobotsData, buildSitemapIndexXml, buildUrlsetXml, chunkFileName, createMemoryCache, createNextTagsCache, escapeXml, finalizeEntries, formatLoc, generateRobotsTxt, getChunkEntries, getGroupEntries, getIndexItems, getSitemapConfig, getSitemapEntries, invalidateSitemap, matchChunkFile, noopCache, renderRobotsTxt, resolveSiteUrl, siteUrlFromRequest, sitemapCacheTag, sitemapPlugin };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["built: Endpoint[]","injected: Field[]"],"sources":["../src/core/invalidate.ts","../src/endpoints/createEndpoints.ts","../src/plugin.ts"],"sourcesContent":["import type {\n  CollectionAfterChangeHook,\n  CollectionAfterDeleteHook,\n  JsonObject,\n  Payload,\n  PayloadRequest,\n} from 'payload'\n\nimport type { InternalSitemapCollectionConfig, ResolvedSitemapConfig } from '../types.js'\n\nimport { getSitemapConfig } from './resolved.js'\n\n/** Groups already scheduled for invalidation within one request (bulk-operation dedupe). */\nconst scheduledPerRequest = new WeakMap<PayloadRequest, Set<string>>()\n\ntype NextServerModule = { after?: (fn: () => void) => void }\n\n/**\n * Runs `fn` after the current request settles. `afterChange` hooks execute inside\n * the operation's transaction — invalidating immediately could regenerate from a\n * pre-commit snapshot. Next's `after()` fires post-response (post-commit); outside\n * a Next request scope we fall back to a macrotask, which the local API's awaited\n * operation has committed by.\n */\nconst runAfterRequest = (fn: () => void): void => {\n  void import('next/server').then(\n    (mod: NextServerModule) => {\n      try {\n        if (mod.after) {\n          mod.after(fn)\n          return\n        }\n      } catch {\n        // `after()` throws outside a Next request scope (scripts, workers).\n      }\n      setTimeout(fn, 0)\n    },\n    () => setTimeout(fn, 0),\n  )\n}\n\nexport const scheduleInvalidation = (\n  req: PayloadRequest,\n  config: ResolvedSitemapConfig,\n  group: string,\n): void => {\n  let scheduled = scheduledPerRequest.get(req)\n  if (!scheduled) {\n    scheduled = new Set()\n    scheduledPerRequest.set(req, scheduled)\n  }\n  if (scheduled.has(group)) {\n    return\n  }\n  scheduled.add(group)\n\n  const logger = req.payload.logger\n  runAfterRequest(() => {\n    Promise.resolve(config.cache.invalidate([group])).catch((err: unknown) => {\n      logger.error({ err }, `[payload-sitemap] Failed to invalidate group \"${group}\"`)\n    })\n  })\n}\n\nconst defaultShouldInvalidate = (doc: JsonObject, previousDoc?: JsonObject): boolean => {\n  const status = doc._status\n  // No drafts on this collection — every change is live.\n  if (typeof status !== 'string') {\n    return true\n  }\n  // Skip draft saves unless they transition a published doc (unpublish).\n  return status === 'published' || previousDoc?._status === 'published'\n}\n\nexport const createAfterChangeHook = (\n  slug: string,\n  collConfig: InternalSitemapCollectionConfig,\n  config: ResolvedSitemapConfig,\n): CollectionAfterChangeHook => {\n  return ({ doc, operation, previousDoc, req }) => {\n    const shouldInvalidate = collConfig.shouldInvalidate\n      ? collConfig.shouldInvalidate({ doc, operation, previousDoc })\n      : defaultShouldInvalidate(doc, previousDoc)\n    if (shouldInvalidate) {\n      scheduleInvalidation(req, config, slug)\n    }\n    return doc\n  }\n}\n\nexport const createAfterDeleteHook = (\n  slug: string,\n  config: ResolvedSitemapConfig,\n): CollectionAfterDeleteHook => {\n  return ({ doc, req }) => {\n    scheduleInvalidation(req, config, slug)\n    return doc\n  }\n}\n\n/**\n * Manually invalidate cached sitemap groups — e.g. from a hook on a global that\n * feeds the `routes` option. Invalidates every group when none are given.\n */\nexport const invalidateSitemap = async (payload: Payload, groups?: string[]): Promise<void> => {\n  const config = getSitemapConfig(payload.config)\n  await config.cache.invalidate(groups ?? config.groups)\n}\n","import type { Endpoint, PayloadRequest } from 'payload'\n\nimport type {\n  ResolvedSitemapConfig,\n  ResolvedSitemapEndpoints,\n  SitemapEndpointAccess,\n} from '../types.js'\n\nimport { getChunkEntries, getIndexItems } from '../core/chunks.js'\nimport { finalizeEntries, getSitemapEntries } from '../core/entries.js'\nimport { buildSitemapIndexXml, buildUrlsetXml } from '../core/xml.js'\n\nconst checkAccess = async (\n  req: PayloadRequest,\n  access: SitemapEndpointAccess | undefined,\n): Promise<boolean> => (access ? await access({ req }) : true)\n\nconst forbidden = (): Response => new Response('Forbidden', { status: 403 })\n\nconst xmlResponse = (xml: string, cacheControl: string): Response =>\n  new Response(xml, {\n    headers: {\n      'Cache-Control': cacheControl,\n      'Content-Type': 'application/xml; charset=utf-8',\n    },\n  })\n\n/**\n * The origin the index uses to reference its own chunk files. These endpoints live\n * on the CMS origin (which may differ from `siteUrl` in decoupled setups), so it\n * is derived from the request unless explicitly configured.\n */\nconst endpointOrigin = (req: PayloadRequest, endpoints: ResolvedSitemapEndpoints): string =>\n  endpoints.origin ?? new URL(req.url ?? 'http://localhost').origin\n\nexport const createSitemapEndpoints = (config: ResolvedSitemapConfig): Endpoint[] => {\n  const endpoints = config.endpoints\n  if (!endpoints) {\n    return []\n  }\n\n  const built: Endpoint[] = [\n    {\n      handler: async (req) => {\n        if (!(await checkAccess(req, endpoints.access))) {\n          return forbidden()\n        }\n        const base = `${endpointOrigin(req, endpoints)}${req.payload.config.routes.api}${endpoints.path}`\n        const items = await getIndexItems({\n          chunkUrl: (file) => `${base}/${file}`,\n          config,\n          payload: req.payload,\n          req,\n        })\n        return xmlResponse(buildSitemapIndexXml(items), endpoints.cacheControl)\n      },\n      method: 'get',\n      path: `${endpoints.path}/index.xml`,\n    },\n  ]\n\n  if (endpoints.json) {\n    const jsonAccess = endpoints.json.access\n    built.push({\n      handler: async (req) => {\n        if (!(await checkAccess(req, jsonAccess))) {\n          return forbidden()\n        }\n        const entries = await getSitemapEntries(req.payload, { req })\n        return Response.json({ entries }, { headers: { 'Cache-Control': endpoints.cacheControl } })\n      },\n      method: 'get',\n      path: `${endpoints.path}/entries.json`,\n    })\n  }\n\n  // The `:file` catch-all must be registered last — Payload matches endpoints in\n  // order, so it would otherwise swallow `entries.json` (and `index.xml`).\n  built.push({\n    handler: async (req) => {\n      if (!(await checkAccess(req, endpoints.access))) {\n        return forbidden()\n      }\n      const file = req.routeParams?.file\n      if (typeof file !== 'string') {\n        return new Response('Not found', { status: 404 })\n      }\n      const chunk = await getChunkEntries({ config, file, payload: req.payload, req })\n      if (!chunk) {\n        return new Response('Not found', { status: 404 })\n      }\n      const collConfig = config.collections[chunk.group]\n      const entries = finalizeEntries(chunk.entries, {\n        siteUrl: config.siteUrl({ request: req }),\n        trailingSlash: config.trailingSlash,\n      })\n      const xml = buildUrlsetXml(entries, {\n        changeFreq: collConfig?.changeFreq,\n        priority: collConfig?.priority,\n      })\n      return xmlResponse(xml, endpoints.cacheControl)\n    },\n    method: 'get',\n    path: `${endpoints.path}/:file`,\n  })\n\n  return built\n}\n","import type { CheckboxField, Config, Field, Plugin } from 'payload'\n\nimport type { SitemapPluginConfig } from './types.js'\n\nimport { createAfterChangeHook, createAfterDeleteHook } from './core/invalidate.js'\nimport { resolveSitemapConfig } from './core/resolved.js'\nimport { createSitemapEndpoints } from './endpoints/createEndpoints.js'\n\n/** Sidebar positioning only applies at the collection root; nested fields render inline. */\nconst excludeFromSitemapField = (nested: boolean): CheckboxField => ({\n  name: 'excludeFromSitemap',\n  type: 'checkbox',\n  ...(nested ? {} : { admin: { position: 'sidebar' } }),\n  label: 'Exclude from sitemap',\n})\n\ntype InjectResult = { fields: Field[]; injected: boolean }\n\n/** Missing path segments become nested group fields, with `injected` innermost. */\nconst buildGroupChain = (segments: string[], injected: Field[]): Field => {\n  const [head, ...rest] = segments\n  return {\n    name: head,\n    type: 'group',\n    fields: rest.length ? [buildGroupChain(rest, injected)] : injected,\n  }\n}\n\n/**\n * Appends `injected` to the container at `segments` — each segment a group\n * field or named tab. Descends into layout-only containers (rows, collapsibles,\n * unnamed groups and tabs) since they don't affect the data path, but only\n * follows named groups/tabs when they match the next segment — a match inside\n * any other named container would live at a different query path than the\n * `<group>.excludeFromSitemap` filter used at generation time. Once a segment\n * matches, missing deeper segments are created inside it as group fields.\n */\nconst injectAtPath = (\n  fields: Field[],\n  segments: string[],\n  injected: Field[],\n  collectionSlug: string,\n): InjectResult => {\n  const [segment, ...rest] = segments\n  let found = false\n\n  /** Children of a matched container: inject directly, descend, or create the missing tail. */\n  const withInjected = (children: Field[]): Field[] => {\n    if (!rest.length) {\n      return [...children, ...injected]\n    }\n    const result = injectAtPath(children, rest, injected, collectionSlug)\n    return result.injected ? result.fields : [...children, buildGroupChain(rest, injected)]\n  }\n\n  const mapped = fields.map((field): Field => {\n    if (found) {\n      return field\n    }\n\n    if ('name' in field && field.name === segment) {\n      if (field.type !== 'group') {\n        throw new Error(\n          `[payload-sitemap] adminFields.group segment \"${segment}\" matches a \"${field.type}\" field on collection \"${collectionSlug}\" — each segment must be a group field or a named tab.`,\n        )\n      }\n      found = true\n      return { ...field, fields: withInjected(field.fields) }\n    }\n\n    if (field.type === 'tabs') {\n      const tabs = field.tabs.map((tab) => {\n        if (found) {\n          return tab\n        }\n        if ('name' in tab && tab.name === segment) {\n          found = true\n          return { ...tab, fields: withInjected(tab.fields) }\n        }\n        if (!('name' in tab)) {\n          const result = injectAtPath(tab.fields, segments, injected, collectionSlug)\n          if (result.injected) {\n            found = true\n            return { ...tab, fields: result.fields }\n          }\n        }\n        return tab\n      })\n      return found ? { ...field, tabs } : field\n    }\n\n    if (\n      field.type === 'row' ||\n      field.type === 'collapsible' ||\n      (field.type === 'group' && !('name' in field))\n    ) {\n      const result = injectAtPath(field.fields, segments, injected, collectionSlug)\n      if (result.injected) {\n        found = true\n        return { ...field, fields: result.fields }\n      }\n    }\n\n    return field\n  })\n\n  return { fields: mapped, injected: found }\n}\n\nexport const sitemapPlugin =\n  (pluginConfig: SitemapPluginConfig): Plugin =>\n  (config: Config): Config => {\n    const slugs = Object.keys(pluginConfig.collections)\n\n    /**\n     * Fields are injected even when the plugin is disabled so the database schema\n     * stays consistent for migrations.\n     */\n    if (pluginConfig.adminFields?.exclude !== false) {\n      const groupPath = pluginConfig.adminFields?.group\n      const segments = groupPath ? groupPath.split('.') : []\n      if (segments.some((segment) => !segment)) {\n        throw new Error(\n          `[payload-sitemap] adminFields.group \"${groupPath}\" is not a valid field path.`,\n        )\n      }\n      const injected: Field[] = [excludeFromSitemapField(segments.length > 0)]\n\n      config.collections = (config.collections ?? []).map((collection) => {\n        if (!slugs.includes(collection.slug)) {\n          return collection\n        }\n        if (!segments.length) {\n          return { ...collection, fields: [...collection.fields, ...injected] }\n        }\n        const result = injectAtPath(collection.fields, segments, injected, collection.slug)\n        if (result.injected) {\n          return { ...collection, fields: result.fields }\n        }\n        // No matching container on this collection — create the chain, so the exclude\n        // flag lives at the same `<group>.excludeFromSitemap` path on every configured\n        // collection.\n        return {\n          ...collection,\n          fields: [...collection.fields, buildGroupChain(segments, injected)],\n        }\n      })\n    }\n\n    if (pluginConfig.disabled) {\n      return config\n    }\n\n    for (const slug of slugs) {\n      if (!config.collections?.some((collection) => collection.slug === slug)) {\n        // eslint-disable-next-line no-console\n        console.warn(\n          `[payload-sitemap] Collection \"${slug}\" is configured for the sitemap but does not exist.`,\n        )\n      }\n    }\n\n    const resolved = resolveSitemapConfig(pluginConfig)\n    config.custom = { ...config.custom, sitemap: resolved }\n\n    config.collections = (config.collections ?? []).map((collection) => {\n      const collConfig = resolved.collections[collection.slug]\n      if (!collConfig) {\n        return collection\n      }\n      return {\n        ...collection,\n        hooks: {\n          ...collection.hooks,\n          afterChange: [\n            ...(collection.hooks?.afterChange ?? []),\n            createAfterChangeHook(collection.slug, collConfig, resolved),\n          ],\n          afterDelete: [\n            ...(collection.hooks?.afterDelete ?? []),\n            createAfterDeleteHook(collection.slug, resolved),\n          ],\n        },\n      }\n    })\n\n    if (resolved.endpoints) {\n      config.endpoints = [...(config.endpoints ?? []), ...createSitemapEndpoints(resolved)]\n    }\n\n    return config\n  }\n"],"mappings":";;;;AAaA,MAAM,sCAAsB,IAAI,SAAsC;;;;;;;;AAWtE,MAAM,mBAAmB,OAAyB;AAChD,CAAK,OAAO,eAAe,MACxB,QAA0B;AACzB,MAAI;AACF,OAAI,IAAI,OAAO;AACb,QAAI,MAAM,GAAG;AACb;;UAEI;AAGR,aAAW,IAAI,EAAE;UAEb,WAAW,IAAI,EAAE,CACxB;;AAGH,MAAa,wBACX,KACA,QACA,UACS;CACT,IAAI,YAAY,oBAAoB,IAAI,IAAI;AAC5C,KAAI,CAAC,WAAW;AACd,8BAAY,IAAI,KAAK;AACrB,sBAAoB,IAAI,KAAK,UAAU;;AAEzC,KAAI,UAAU,IAAI,MAAM,CACtB;AAEF,WAAU,IAAI,MAAM;CAEpB,MAAM,SAAS,IAAI,QAAQ;AAC3B,uBAAsB;AACpB,UAAQ,QAAQ,OAAO,MAAM,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,QAAiB;AACxE,UAAO,MAAM,EAAE,KAAK,EAAE,iDAAiD,MAAM,GAAG;IAChF;GACF;;AAGJ,MAAM,2BAA2B,KAAiB,gBAAsC;CACtF,MAAM,SAAS,IAAI;AAEnB,KAAI,OAAO,WAAW,SACpB,QAAO;AAGT,QAAO,WAAW,eAAe,aAAa,YAAY;;AAG5D,MAAa,yBACX,MACA,YACA,WAC8B;AAC9B,SAAQ,EAAE,KAAK,WAAW,aAAa,UAAU;AAI/C,MAHyB,WAAW,mBAChC,WAAW,iBAAiB;GAAE;GAAK;GAAW;GAAa,CAAC,GAC5D,wBAAwB,KAAK,YAAY,CAE3C,sBAAqB,KAAK,QAAQ,KAAK;AAEzC,SAAO;;;AAIX,MAAa,yBACX,MACA,WAC8B;AAC9B,SAAQ,EAAE,KAAK,UAAU;AACvB,uBAAqB,KAAK,QAAQ,KAAK;AACvC,SAAO;;;;;;;AAQX,MAAa,oBAAoB,OAAO,SAAkB,WAAqC;CAC7F,MAAM,SAAS,iBAAiB,QAAQ,OAAO;AAC/C,OAAM,OAAO,MAAM,WAAW,UAAU,OAAO,OAAO;;;;;AC9FxD,MAAM,cAAc,OAClB,KACA,WACsB,SAAS,MAAM,OAAO,EAAE,KAAK,CAAC,GAAG;AAEzD,MAAM,kBAA4B,IAAI,SAAS,aAAa,EAAE,QAAQ,KAAK,CAAC;AAE5E,MAAM,eAAe,KAAa,iBAChC,IAAI,SAAS,KAAK,EAChB,SAAS;CACP,iBAAiB;CACjB,gBAAgB;CACjB,EACF,CAAC;;;;;;AAOJ,MAAM,kBAAkB,KAAqB,cAC3C,UAAU,UAAU,IAAI,IAAI,IAAI,OAAO,mBAAmB,CAAC;AAE7D,MAAa,0BAA0B,WAA8C;CACnF,MAAM,YAAY,OAAO;AACzB,KAAI,CAAC,UACH,QAAO,EAAE;CAGX,MAAMA,QAAoB,CACxB;EACE,SAAS,OAAO,QAAQ;AACtB,OAAI,CAAE,MAAM,YAAY,KAAK,UAAU,OAAO,CAC5C,QAAO,WAAW;GAEpB,MAAM,OAAO,GAAG,eAAe,KAAK,UAAU,GAAG,IAAI,QAAQ,OAAO,OAAO,MAAM,UAAU;AAO3F,UAAO,YAAY,qBANL,MAAM,cAAc;IAChC,WAAW,SAAS,GAAG,KAAK,GAAG;IAC/B;IACA,SAAS,IAAI;IACb;IACD,CAAC,CAC4C,EAAE,UAAU,aAAa;;EAEzE,QAAQ;EACR,MAAM,GAAG,UAAU,KAAK;EACzB,CACF;AAED,KAAI,UAAU,MAAM;EAClB,MAAM,aAAa,UAAU,KAAK;AAClC,QAAM,KAAK;GACT,SAAS,OAAO,QAAQ;AACtB,QAAI,CAAE,MAAM,YAAY,KAAK,WAAW,CACtC,QAAO,WAAW;IAEpB,MAAM,UAAU,MAAM,kBAAkB,IAAI,SAAS,EAAE,KAAK,CAAC;AAC7D,WAAO,SAAS,KAAK,EAAE,SAAS,EAAE,EAAE,SAAS,EAAE,iBAAiB,UAAU,cAAc,EAAE,CAAC;;GAE7F,QAAQ;GACR,MAAM,GAAG,UAAU,KAAK;GACzB,CAAC;;AAKJ,OAAM,KAAK;EACT,SAAS,OAAO,QAAQ;AACtB,OAAI,CAAE,MAAM,YAAY,KAAK,UAAU,OAAO,CAC5C,QAAO,WAAW;GAEpB,MAAM,OAAO,IAAI,aAAa;AAC9B,OAAI,OAAO,SAAS,SAClB,QAAO,IAAI,SAAS,aAAa,EAAE,QAAQ,KAAK,CAAC;GAEnD,MAAM,QAAQ,MAAM,gBAAgB;IAAE;IAAQ;IAAM,SAAS,IAAI;IAAS;IAAK,CAAC;AAChF,OAAI,CAAC,MACH,QAAO,IAAI,SAAS,aAAa,EAAE,QAAQ,KAAK,CAAC;GAEnD,MAAM,aAAa,OAAO,YAAY,MAAM;AAS5C,UAAO,YAJK,eAJI,gBAAgB,MAAM,SAAS;IAC7C,SAAS,OAAO,QAAQ,EAAE,SAAS,KAAK,CAAC;IACzC,eAAe,OAAO;IACvB,CAAC,EACkC;IAClC,YAAY,YAAY;IACxB,UAAU,YAAY;IACvB,CAAC,EACsB,UAAU,aAAa;;EAEjD,QAAQ;EACR,MAAM,GAAG,UAAU,KAAK;EACzB,CAAC;AAEF,QAAO;;;;;;ACjGT,MAAM,2BAA2B,YAAoC;CACnE,MAAM;CACN,MAAM;CACN,GAAI,SAAS,EAAE,GAAG,EAAE,OAAO,EAAE,UAAU,WAAW,EAAE;CACpD,OAAO;CACR;;AAKD,MAAM,mBAAmB,UAAoB,aAA6B;CACxE,MAAM,CAAC,MAAM,GAAG,QAAQ;AACxB,QAAO;EACL,MAAM;EACN,MAAM;EACN,QAAQ,KAAK,SAAS,CAAC,gBAAgB,MAAM,SAAS,CAAC,GAAG;EAC3D;;;;;;;;;;;AAYH,MAAM,gBACJ,QACA,UACA,UACA,mBACiB;CACjB,MAAM,CAAC,SAAS,GAAG,QAAQ;CAC3B,IAAI,QAAQ;;CAGZ,MAAM,gBAAgB,aAA+B;AACnD,MAAI,CAAC,KAAK,OACR,QAAO,CAAC,GAAG,UAAU,GAAG,SAAS;EAEnC,MAAM,SAAS,aAAa,UAAU,MAAM,UAAU,eAAe;AACrE,SAAO,OAAO,WAAW,OAAO,SAAS,CAAC,GAAG,UAAU,gBAAgB,MAAM,SAAS,CAAC;;AAsDzF,QAAO;EAAE,QAnDM,OAAO,KAAK,UAAiB;AAC1C,OAAI,MACF,QAAO;AAGT,OAAI,UAAU,SAAS,MAAM,SAAS,SAAS;AAC7C,QAAI,MAAM,SAAS,QACjB,OAAM,IAAI,MACR,gDAAgD,QAAQ,eAAe,MAAM,KAAK,yBAAyB,eAAe,wDAC3H;AAEH,YAAQ;AACR,WAAO;KAAE,GAAG;KAAO,QAAQ,aAAa,MAAM,OAAO;KAAE;;AAGzD,OAAI,MAAM,SAAS,QAAQ;IACzB,MAAM,OAAO,MAAM,KAAK,KAAK,QAAQ;AACnC,SAAI,MACF,QAAO;AAET,SAAI,UAAU,OAAO,IAAI,SAAS,SAAS;AACzC,cAAQ;AACR,aAAO;OAAE,GAAG;OAAK,QAAQ,aAAa,IAAI,OAAO;OAAE;;AAErD,SAAI,EAAE,UAAU,MAAM;MACpB,MAAM,SAAS,aAAa,IAAI,QAAQ,UAAU,UAAU,eAAe;AAC3E,UAAI,OAAO,UAAU;AACnB,eAAQ;AACR,cAAO;QAAE,GAAG;QAAK,QAAQ,OAAO;QAAQ;;;AAG5C,YAAO;MACP;AACF,WAAO,QAAQ;KAAE,GAAG;KAAO;KAAM,GAAG;;AAGtC,OACE,MAAM,SAAS,SACf,MAAM,SAAS,iBACd,MAAM,SAAS,WAAW,EAAE,UAAU,QACvC;IACA,MAAM,SAAS,aAAa,MAAM,QAAQ,UAAU,UAAU,eAAe;AAC7E,QAAI,OAAO,UAAU;AACnB,aAAQ;AACR,YAAO;MAAE,GAAG;MAAO,QAAQ,OAAO;MAAQ;;;AAI9C,UAAO;IACP;EAEuB,UAAU;EAAO;;AAG5C,MAAa,iBACV,kBACA,WAA2B;CAC1B,MAAM,QAAQ,OAAO,KAAK,aAAa,YAAY;;;;;AAMnD,KAAI,aAAa,aAAa,YAAY,OAAO;EAC/C,MAAM,YAAY,aAAa,aAAa;EAC5C,MAAM,WAAW,YAAY,UAAU,MAAM,IAAI,GAAG,EAAE;AACtD,MAAI,SAAS,MAAM,YAAY,CAAC,QAAQ,CACtC,OAAM,IAAI,MACR,wCAAwC,UAAU,8BACnD;EAEH,MAAMC,WAAoB,CAAC,wBAAwB,SAAS,SAAS,EAAE,CAAC;AAExE,SAAO,eAAe,OAAO,eAAe,EAAE,EAAE,KAAK,eAAe;AAClE,OAAI,CAAC,MAAM,SAAS,WAAW,KAAK,CAClC,QAAO;AAET,OAAI,CAAC,SAAS,OACZ,QAAO;IAAE,GAAG;IAAY,QAAQ,CAAC,GAAG,WAAW,QAAQ,GAAG,SAAS;IAAE;GAEvE,MAAM,SAAS,aAAa,WAAW,QAAQ,UAAU,UAAU,WAAW,KAAK;AACnF,OAAI,OAAO,SACT,QAAO;IAAE,GAAG;IAAY,QAAQ,OAAO;IAAQ;AAKjD,UAAO;IACL,GAAG;IACH,QAAQ,CAAC,GAAG,WAAW,QAAQ,gBAAgB,UAAU,SAAS,CAAC;IACpE;IACD;;AAGJ,KAAI,aAAa,SACf,QAAO;AAGT,MAAK,MAAM,QAAQ,MACjB,KAAI,CAAC,OAAO,aAAa,MAAM,eAAe,WAAW,SAAS,KAAK,CAErE,SAAQ,KACN,iCAAiC,KAAK,qDACvC;CAIL,MAAM,WAAW,qBAAqB,aAAa;AACnD,QAAO,SAAS;EAAE,GAAG,OAAO;EAAQ,SAAS;EAAU;AAEvD,QAAO,eAAe,OAAO,eAAe,EAAE,EAAE,KAAK,eAAe;EAClE,MAAM,aAAa,SAAS,YAAY,WAAW;AACnD,MAAI,CAAC,WACH,QAAO;AAET,SAAO;GACL,GAAG;GACH,OAAO;IACL,GAAG,WAAW;IACd,aAAa,CACX,GAAI,WAAW,OAAO,eAAe,EAAE,EACvC,sBAAsB,WAAW,MAAM,YAAY,SAAS,CAC7D;IACD,aAAa,CACX,GAAI,WAAW,OAAO,eAAe,EAAE,EACvC,sBAAsB,WAAW,MAAM,SAAS,CACjD;IACF;GACF;GACD;AAEF,KAAI,SAAS,UACX,QAAO,YAAY,CAAC,GAAI,OAAO,aAAa,EAAE,EAAG,GAAG,uBAAuB,SAAS,CAAC;AAGvF,QAAO"}

package/dist/types-j8T8euN5.d.ts

@@ -0,0 +1,271 @@
+import { CollectionSlug, DataFromCollectionSlug, JsonObject, Payload, PayloadRequest, SelectType, Where } from "payload";
+
+//#region src/core/siteUrl.d.ts
+
+/**
+ * Context a site URL can be derived from when nothing is configured. `request`
+ * structurally accepts a Fetch `Request`, a `PayloadRequest`, or — in contexts
+ * without a request object (e.g. Next metadata routes) — a bare
+ * `{ headers: await headers() }`.
+ */
+type SiteUrlContext = {
+  /** The incoming request. */
+  request?: {
+    headers?: Headers;
+    url?: null | string;
+  };
+};
+/**
+ * Origin of the incoming request: proxy headers first (they carry the public host
+ * when the server sits behind one), then the request URL. Host headers are
+ * client-controlled: responses built from them must never be written to a shared
+ * cache (entries are cached as site-relative paths for this reason).
+ */
+declare const siteUrlFromRequest: (ctx: SiteUrlContext) => string | undefined;
+/**
+ * Resolves the canonical frontend origin: explicit option → SITE_URL →
+ * NEXT_PUBLIC_SERVER_URL → VERCEL_PROJECT_PRODUCTION_URL → the incoming
+ * request, when available.
+ */
+declare const resolveSiteUrl: (configured?: ((ctx: SiteUrlContext) => string) | string, ctx?: SiteUrlContext) => string;
+//#endregion
+//#region src/types.d.ts
+/** A single sitemap URL entry. */
+type SitemapEntry = {
+  /** Per-entry change frequency. Ignored by Google; opt-in. */
+  changefreq?: ChangeFrequency;
+  /** W3C datetime string. Google uses this; keep it accurate. */
+  lastmod?: string;
+  /** Absolute URL of the page. */
+  loc: string;
+  /** Per-entry priority (0.0–1.0). Ignored by Google; opt-in. */
+  priority?: number;
+};
+type ChangeFrequency = 'always' | 'daily' | 'hourly' | 'monthly' | 'never' | 'weekly' | 'yearly';
+type SitemapPathArgs<TSlug extends CollectionSlug = CollectionSlug> = {
+  doc: DataFromCollectionSlug<TSlug>;
+  /** Present when generation runs inside a Payload request (REST endpoints). */
+  req?: PayloadRequest;
+};
+type SitemapInvalidateArgs<TSlug extends CollectionSlug = CollectionSlug> = {
+  doc: DataFromCollectionSlug<TSlug>;
+  operation: 'create' | 'update';
+  previousDoc?: DataFromCollectionSlug<TSlug>;
+};
+type SitemapCollectionConfig<TSlug extends CollectionSlug = CollectionSlug> = {
+  /** Fixed `<changefreq>` for every entry in this collection. Ignored by Google; opt-in. */
+  changeFreq?: ChangeFrequency;
+  /** Per-collection override of the plugin-level `chunkSize`. */
+  chunkSize?: number;
+  /**
+   * Source for `<lastmod>`: a field name, a function of the doc, or `false` to omit.
+   * @default 'updatedAt'
+   */
+  lastMod?: ((doc: DataFromCollectionSlug<TSlug>) => Date | null | string | undefined) | false | string;
+  /**
+   * Return the document's path (`/about/team`) — it is joined onto `siteUrl`.
+   * An absolute `http(s)://` return value is used verbatim (multi-domain escape hatch).
+   * Return `null`/`undefined` to omit the document from the sitemap.
+   */
+  path: (args: SitemapPathArgs<TSlug>) => null | Promise<null | string | undefined> | string | undefined;
+  /** Fixed `<priority>` for every entry in this collection. Ignored by Google; opt-in. */
+  priority?: number;
+  /**
+   * Fields fetched for `path` (and `lastMod` when it is a function).
+   * `id`, `updatedAt`, and a string `lastMod` field are always included.
+   * @default { slug: true }
+   */
+  select?: SelectType;
+  /**
+   * Override the default cache-invalidation heuristic for this collection.
+   * Default: invalidate on any change except a draft save with no published transition.
+   */
+  shouldInvalidate?: (args: SitemapInvalidateArgs<TSlug>) => boolean;
+  /** Extra query constraints AND-ed into the sitemap query. */
+  where?: Where;
+};
+/** Loosely-typed view of a collection config used internally. */
+type InternalSitemapCollectionConfig = {
+  changeFreq?: ChangeFrequency;
+  chunkSize?: number;
+  lastMod?: ((doc: JsonObject) => Date | null | string | undefined) | false | string;
+  path: (args: {
+    doc: JsonObject;
+    req?: PayloadRequest;
+  }) => null | Promise<null | string | undefined> | string | undefined;
+  priority?: number;
+  select?: SelectType;
+  shouldInvalidate?: (args: {
+    doc: JsonObject;
+    operation: 'create' | 'update';
+    previousDoc?: JsonObject;
+  }) => boolean;
+  where?: Where;
+};
+/** A non-collection route to include in the sitemap (static pages, home from a global, …). */
+type SitemapRoute = {
+  changeFreq?: ChangeFrequency;
+  lastMod?: Date | string;
+  /** Path (`/search`) joined onto `siteUrl`, or an absolute URL used verbatim. */
+  path: string;
+  priority?: number;
+};
+type SitemapRoutesFn = (args: {
+  payload: Payload;
+  req?: PayloadRequest;
+}) => Promise<SitemapRoute[]> | SitemapRoute[];
+type SitemapEndpointAccess = (args: {
+  req: PayloadRequest;
+}) => boolean | Promise<boolean>;
+type SitemapEndpointsConfig = {
+  /**
+   * Access control for the XML endpoints.
+   * @default public — sitemaps exist to be crawled once you opt in
+   */
+  access?: SitemapEndpointAccess;
+  /** `Cache-Control` header for endpoint responses. */
+  cacheControl?: string;
+  /**
+   * Also expose raw entries at `<path>/entries.json` for SSG frontends.
+   * @default false — when `true`, access defaults to authenticated users only
+   */
+  json?: {
+    access?: SitemapEndpointAccess;
+  } | boolean;
+  /**
+   * Public origin used when the index references its chunk files.
+   * @default derived from the incoming request URL
+   */
+  origin?: string;
+  /**
+   * Base path under the Payload API route.
+   * @default '/sitemap' → `/api/sitemap/index.xml`, `/api/sitemap/:file`
+   */
+  path?: string;
+};
+type ResolvedSitemapEndpoints = {
+  access?: SitemapEndpointAccess;
+  cacheControl: string;
+  json: {
+    access: SitemapEndpointAccess;
+  } | false;
+  origin?: string;
+  path: string;
+};
+/**
+ * Cache for generated entries, keyed by group (collection slug or the routes group).
+ * `wrap` returns cached entries or runs `fn` and stores the result;
+ * `invalidate` marks groups dirty so the next request regenerates.
+ * Cached `loc` values are site-relative paths (unless `path()` returned an absolute
+ * URL) — they are joined onto the resolved `siteUrl` per request, so cached data is
+ * never influenced by a request's Host header.
+ */
+interface SitemapCache {
+  invalidate: (keys: string[]) => Promise<void> | void;
+  wrap: (key: string, fn: () => Promise<SitemapEntry[]>) => Promise<SitemapEntry[]>;
+}
+type RobotsRule = {
+  allow?: string | string[];
+  crawlDelay?: number;
+  disallow?: string | string[];
+  userAgent: string | string[];
+};
+type RobotsData = {
+  host?: string;
+  rules: RobotsRule[];
+  sitemaps: string[];
+};
+type RobotsOptions = {
+  /** Extra disallow paths appended to the default rule. Ignored when `rules` is set. */
+  disallow?: string[];
+  /**
+   * Force production behavior. Non-production output disallows everything.
+   * @default VERCEL_ENV === 'production', falling back to NODE_ENV === 'production'
+   */
+  isProduction?: boolean;
+  /** Replace the default rules entirely (default: allow all, disallow admin + API routes). */
+  rules?: RobotsRule[];
+  /** Sitemap URL(s). @default `${siteUrl}/sitemap.xml` */
+  sitemaps?: string[];
+  /** Final say over the computed output — receives the built data, returns what ships. */
+  transform?: (robots: RobotsData) => RobotsData;
+};
+type SitemapCollections = { [K in CollectionSlug]?: SitemapCollectionConfig<K> };
+interface SitemapPluginConfig {
+  /** Control the admin fields injected into configured collections. */
+  adminFields?: {
+    /** Inject an `excludeFromSitemap` sidebar checkbox. @default true */
+    exclude?: boolean;
+    /**
+     * Nest the injected fields inside the group field (or named tab) with this
+     * name — e.g. an existing `metadata` group — instead of the collection
+     * root. Dot notation reaches nested containers (`'seo.metadata'` = a
+     * `metadata` group inside a named `seo` tab or group). Missing segments
+     * are created as group fields on each configured collection, so the
+     * exclude flag always lives at `<group>.excludeFromSitemap` — changing
+     * this on a live project moves the data path (migration required).
+     */
+    group?: string;
+  };
+  /**
+   * Entry cache strategy. `'auto'` uses Next.js tag-based caching when `next/cache`
+   * is importable and falls back to an in-memory cache otherwise.
+   * @default 'auto'
+   */
+  cache?: 'auto' | 'memory' | 'none' | SitemapCache;
+  /** Max URLs per sitemap file (protocol limit is 50,000). @default 25000 */
+  chunkSize?: number;
+  /** Collections to include, keyed by slug. */
+  collections: SitemapCollections;
+  /**
+   * Disables generation, hooks, and endpoints while keeping injected fields so the
+   * database schema stays consistent for migrations.
+   * @default false
+   */
+  disabled?: boolean;
+  /**
+   * REST endpoints under the Payload API route.
+   * @default false — Next.js route handlers (`@whatworks/payload-sitemap/next`) are
+   * the primary delivery; enable these for decoupled frontends or proxy setups.
+   */
+  endpoints?: boolean | SitemapEndpointsConfig;
+  /** Defaults for `generateRobotsTxt` / `createRobots`. */
+  robots?: RobotsOptions;
+  /** Extra routes to include (static pages, home page from a global, …). */
+  routes?: SitemapRoute[] | SitemapRoutesFn;
+  /**
+   * Canonical origin of the site frontend, e.g. `https://example.com`, or a
+   * function with full control (it receives the incoming request's headers when
+   * one is available).
+   * @default SITE_URL → NEXT_PUBLIC_SERVER_URL → https://$VERCEL_PROJECT_PRODUCTION_URL
+   * → derived from the incoming request's `x-forwarded-proto`/`x-forwarded-host`/`host`
+   * headers. Env vars win over headers so deployments reachable via non-canonical
+   * aliases still emit the canonical domain.
+   */
+  siteUrl?: ((ctx: SiteUrlContext) => string) | string;
+  /** Append a trailing slash to generated paths. @default false */
+  trailingSlash?: boolean;
+}
+type ResolvedSitemapConfig = {
+  cache: SitemapCache;
+  chunkSize: number;
+  collections: Record<string, InternalSitemapCollectionConfig>;
+  endpoints: false | ResolvedSitemapEndpoints;
+  /**
+   * Query path of the exclude checkbox (`excludeFromSitemap`, prefixed with
+   * `adminFields.group` when set), or `undefined` when the field is disabled.
+   */
+  excludeFieldPath?: string;
+  groups: string[];
+  robots: RobotsOptions;
+  routes?: SitemapRoute[] | SitemapRoutesFn;
+  /**
+   * Resolves the site origin. Static sources (option, env) are memoized;
+   * otherwise it derives from the request headers passed in `ctx`.
+   */
+  siteUrl: (ctx?: SiteUrlContext) => string;
+  trailingSlash: boolean;
+};
+//#endregion
+export { SitemapRoute as _, RobotsData as a, resolveSiteUrl as b, SitemapCache as c, SitemapEndpointAccess as d, SitemapEndpointsConfig as f, SitemapPluginConfig as g, SitemapPathArgs as h, ResolvedSitemapEndpoints as i, SitemapCollectionConfig as l, SitemapInvalidateArgs as m, InternalSitemapCollectionConfig as n, RobotsOptions as o, SitemapEntry as p, ResolvedSitemapConfig as r, RobotsRule as s, ChangeFrequency as t, SitemapCollections as u, SitemapRoutesFn as v, siteUrlFromRequest as x, SiteUrlContext as y };
+//# sourceMappingURL=types-j8T8euN5.d.ts.map