@abinnovision/payloadcms-wayfinder 1.0.0-beta.2

package/dist/config/link-field.mjs

@@ -0,0 +1,150 @@
+import { variantsOf } from "../pattern/define-links.mjs";
+import { relationship, text } from "payload/shared";
+//#region src/config/link-field.ts
+/** Values a variant may claim in order to replace the built-in behaviour. */ const BUILTIN_VALUES = /* @__PURE__ */ new Set([
+	"none",
+	"reference",
+	"custom",
+	"same-page"
+]);
+const DEFAULT_LABELS = {
+	label: "Label",
+	none: "None",
+	reference: "Internal link",
+	custom: "Custom",
+	samePage: "Same page",
+	newTab: "Open in new tab",
+	referenceField: "Document to link to",
+	urlField: "Custom URL",
+	samePageField: "Section identifier"
+};
+/**
+* A link that can point at a document, an arbitrary URL, or an anchor.
+*
+* The stored value is routed by `resolveLink`, which reads the collection
+* mapping — so a link authored once follows its target when that collection's
+* URL pattern changes.
+*
+* Each conditional sub-field declares itself optional and re-implements
+* required-ness inside `validate`. Payload validates hidden fields too, so a
+* plain `required: true` on a field behind a condition blocks saving whenever
+* a different link type is selected.
+*
+* @param args Link targets, extra variants and presentation overrides.
+*/ /**
+* Shows a variant's own fields only when that variant is selected.
+*
+* Spreading a member of the `Field` union widens its discriminated `admin`
+* shape to the union's, which no longer assigns back — so the result is
+* reassembled through a single narrow assertion here rather than at each of
+* the four call sites this would otherwise need.
+*
+* @param field The variant's field.
+* @param value The variant's own value.
+*/ const withVariantCondition = (field, value) => {
+	const next = { ...field };
+	const admin = next;
+	admin.admin = {
+		...admin.admin,
+		condition: (_, siblingData) => siblingData.type === value
+	};
+	return next;
+};
+const linkField = (args) => {
+	const isRequired = args.required ?? true;
+	const withLabel = args.withLabel ?? false;
+	const localizedLabel = args.localizedLabel ?? true;
+	const labels = {
+		...DEFAULT_LABELS,
+		...args.labels
+	};
+	const variants = variantsOf(args);
+	const missingRequired = (type, value, siblingData) => siblingData.type === type && !value;
+	return {
+		name: "link",
+		type: "group",
+		...args.interfaceName ? { interfaceName: args.interfaceName } : {},
+		admin: { hideGutter: true },
+		fields: [
+			{
+				name: "label",
+				type: "text",
+				required: withLabel && isRequired,
+				hidden: !withLabel,
+				localized: localizedLabel,
+				label: labels.label
+			},
+			{
+				type: "row",
+				fields: [{
+					name: "type",
+					type: "radio",
+					admin: {
+						layout: "horizontal",
+						width: "50%"
+					},
+					defaultValue: isRequired ? "reference" : "none",
+					options: [...[
+						...!isRequired ? [{
+							label: labels.none,
+							value: "none"
+						}] : [],
+						{
+							label: labels.reference,
+							value: "reference"
+						},
+						{
+							label: labels.custom,
+							value: "custom"
+						},
+						{
+							label: labels.samePage,
+							value: "same-page"
+						}
+					].map((builtin) => variants.find((it) => it.value === builtin.value) ?? builtin), ...variants.filter((it) => !BUILTIN_VALUES.has(it.value))].map((it) => ({
+						label: it.label,
+						value: it.value
+					}))
+				}, {
+					name: "newTab",
+					type: "checkbox",
+					label: labels.newTab,
+					admin: {
+						style: { alignSelf: "flex-end" },
+						width: "50%",
+						condition: (_, siblingData) => siblingData.type !== "same-page"
+					}
+				}]
+			},
+			{
+				name: "reference",
+				type: "relationship",
+				label: labels.referenceField,
+				admin: { condition: (_, siblingData) => siblingData.type === "reference" },
+				relationTo: args.relationTo,
+				hasMany: false,
+				required: false,
+				validate: (value, ctx) => missingRequired("reference", value, ctx.siblingData) ? ctx.req.t("validation:required") : relationship(value, ctx)
+			},
+			{
+				name: "url",
+				type: "text",
+				label: labels.urlField,
+				admin: { condition: (_, siblingData) => siblingData.type === "custom" },
+				required: false,
+				validate: (value, ctx) => missingRequired("custom", value, ctx.siblingData) ? ctx.req.t("validation:required") : text(value, ctx)
+			},
+			{
+				name: "samePageIdentifier",
+				type: "text",
+				label: labels.samePageField,
+				admin: { condition: (_, siblingData) => siblingData.type === "same-page" },
+				required: false,
+				validate: (value, ctx) => missingRequired("same-page", value, ctx.siblingData) ? ctx.req.t("validation:required") : text(value, ctx)
+			},
+			...variants.flatMap((variant) => (variant.fields ?? []).map((field) => withVariantCondition(field, variant.value)))
+		]
+	};
+};
+//#endregion
+export { linkField };

package/dist/config/load-mappings.d.mts

@@ -0,0 +1,38 @@
+import { PayloadCollectionMappingResolved } from "../pattern/types.mjs";
+import { Payload } from "payload";
+//#region src/config/load-mappings.d.ts
+/**
+ * Somewhere to keep compiled mappings between reads.
+ *
+ * This caches compilation, not the read: the key is derived from what the read
+ * returned, which is what makes it impossible to serve a stale mapping, and
+ * also means the read always happens. To skip the read as well, wrap the whole
+ * `loadMappings` call in your own framework cache and invalidate it from
+ * `createMappingGlobal({ onChange })`.
+ */
+interface MappingCache {
+  get: (key: string) => PayloadCollectionMappingResolved[] | undefined;
+  set: (key: string, value: PayloadCollectionMappingResolved[]) => void;
+}
+interface LoadMappingsArgs {
+  payload: Payload;
+  globalSlug?: string;
+  /** Must match what {@link createMappingGlobal} was given. */
+  localized?: boolean;
+  /** Reuses compiled patterns across reads. @see MappingCache */
+  cache?: MappingCache;
+}
+/**
+ * Reads the mapping global and compiles it.
+ *
+ * Returns an empty list rather than throwing when the global has never been
+ * saved, which is the state every project is in on its first boot. A missing
+ * row, an unregistered collection or a locale with no pattern is skipped for
+ * the same reason: routing should degrade to "nothing matches", not to a
+ * crash on the way to the admin panel where an editor would fix it.
+ *
+ * @param args The Payload instance and mapping-global settings.
+ */
+declare const loadMappings: (args: LoadMappingsArgs) => Promise<PayloadCollectionMappingResolved[]>;
+//#endregion
+export { LoadMappingsArgs, MappingCache, loadMappings };

package/dist/config/load-mappings.mjs

@@ -0,0 +1,60 @@
+import { resolveCollectionMapping } from "../pattern/resolver.mjs";
+import "./mapping-global.mjs";
+//#region src/config/load-mappings.ts
+/** Process-lifetime memo, used when no cache is supplied. */ const createMemoryCache = () => {
+	const store = /* @__PURE__ */ new Map();
+	return {
+		get: (key) => store.get(key),
+		set: (key, value) => void store.set(key, value)
+	};
+};
+const defaultCache = createMemoryCache();
+/**
+* Reads the mapping global and compiles it.
+*
+* Returns an empty list rather than throwing when the global has never been
+* saved, which is the state every project is in on its first boot. A missing
+* row, an unregistered collection or a locale with no pattern is skipped for
+* the same reason: routing should degrade to "nothing matches", not to a
+* crash on the way to the admin panel where an editor would fix it.
+*
+* @param args The Payload instance and mapping-global settings.
+*/ const loadMappings = async (args) => {
+	const localized = args.localized ?? true;
+	const cache = args.cache ?? defaultCache;
+	const global = await args.payload.findGlobal({
+		slug: args.globalSlug ?? "collections-mapping",
+		depth: 0,
+		overrideAccess: true,
+		...localized ? { locale: "all" } : {}
+	});
+	const usable = (Array.isArray(global?.collections) ? global.collections : []).flatMap((row) => {
+		const collection = row.collectionName;
+		const path = row.path;
+		if (typeof collection !== "string" || collection === "") return [];
+		if (typeof path === "string") return [{
+			collection,
+			path
+		}];
+		if (!path || typeof path !== "object") return [];
+		const patterns = Object.fromEntries(Object.entries(path).flatMap(([locale, pattern]) => typeof pattern === "string" && pattern !== "" ? [[locale, pattern]] : []));
+		return Object.keys(patterns).length > 0 ? [{
+			collection,
+			path: patterns
+		}] : [];
+	});
+	const key = JSON.stringify(usable);
+	const cached = cache.get(key);
+	if (cached) return cached;
+	const compiled = usable.flatMap((mapping) => {
+		try {
+			return [resolveCollectionMapping(mapping)];
+		} catch {
+			return [];
+		}
+	});
+	cache.set(key, compiled);
+	return compiled;
+};
+//#endregion
+export { loadMappings };

package/dist/config/mapping-global.d.mts

@@ -0,0 +1,34 @@
+import { GlobalConfig } from "payload";
+//#region src/config/mapping-global.d.ts
+/** The global the mapping is authored in, unless overridden. */
+declare const DEFAULT_MAPPING_GLOBAL_SLUG = "collections-mapping";
+interface CreateMappingGlobalArgs {
+  /** Defaults to {@link DEFAULT_MAPPING_GLOBAL_SLUG}. */
+  globalSlug?: string;
+  /**
+   * Whether path patterns differ per locale. Turn it off for a project with
+   * no `localization` block — Payload would otherwise return a scalar where
+   * a per-locale record is expected.
+   */
+  localized?: boolean;
+  /** Fallback identifier field for relationship parameters. */
+  identifierField?: string;
+  label?: GlobalConfig["label"];
+  adminGroup?: string;
+  access?: GlobalConfig["access"];
+  /** Generated-type name for the array rows. Unset by default. */
+  interfaceName?: string;
+  /** Called after the mapping changes, for cache invalidation. */
+  onChange?: () => void | Promise<void>;
+}
+/**
+ * Builds the global that maps collections onto the URL patterns they serve.
+ *
+ * Routing lives in content rather than in code, so adding a page type is an
+ * editorial act. Everything else in the package reads what this produces.
+ *
+ * @param args Slug, localization and presentation overrides.
+ */
+declare const createMappingGlobal: (args?: CreateMappingGlobalArgs) => GlobalConfig;
+//#endregion
+export { CreateMappingGlobalArgs, DEFAULT_MAPPING_GLOBAL_SLUG, createMappingGlobal };

package/dist/config/mapping-global.mjs

@@ -0,0 +1,86 @@
+import { resolveParamQueryPath } from "../pattern/param-query-path.mjs";
+import { translate } from "./translations.mjs";
+import { createCollectionStringField } from "./collection-string-field.mjs";
+import { hasDuplicates } from "./has-duplicates.mjs";
+import { pathToRegexp } from "path-to-regexp";
+import { text } from "payload/shared";
+//#region src/config/mapping-global.ts
+/** The global the mapping is authored in, unless overridden. */ const DEFAULT_MAPPING_GLOBAL_SLUG = "collections-mapping";
+/**
+* Builds the global that maps collections onto the URL patterns they serve.
+*
+* Routing lives in content rather than in code, so adding a page type is an
+* editorial act. Everything else in the package reads what this produces.
+*
+* @param args Slug, localization and presentation overrides.
+*/ const createMappingGlobal = (args = {}) => {
+	const pathField = {
+		type: "text",
+		name: "path",
+		required: true,
+		localized: args.localized ?? true,
+		admin: { description: "Path pattern, e.g. \"/:section/:slug\". Use \"/*slug\" for a collection whose identifier is a full path." },
+		validate: (value, opts) => {
+			const base = text(value, opts);
+			if (base !== true) return base;
+			const t = opts.req.t;
+			if (typeof value !== "string") return translate(t, "invalidPath");
+			let parsed;
+			try {
+				parsed = pathToRegexp(value);
+			} catch {
+				return translate(t, "pathUnparseable");
+			}
+			if (parsed.keys.length === 0) return translate(t, "pathNeedsParameter");
+			const collectionName = opts.siblingData.collectionName;
+			if (!collectionName) return translate(t, "selectCollectionFirst");
+			const collection = opts.req.payload.collections[collectionName];
+			if (!collection) return translate(t, "selectCollectionFirst");
+			for (const key of parsed.keys) {
+				const resolved = resolveParamQueryPath({
+					config: collection.config,
+					param: key.name,
+					collections: opts.req.payload.collections,
+					...args.identifierField ? { identifierField: args.identifierField } : {}
+				});
+				if ("error" in resolved) return resolved.error;
+			}
+			return true;
+		}
+	};
+	return {
+		slug: args.globalSlug ?? "collections-mapping",
+		label: args.label ?? "Collections Mapping",
+		...args.access ? { access: args.access } : {},
+		admin: {
+			group: args.adminGroup ?? "Settings",
+			description: "Maps each collection onto the URL pattern its documents are served at. The last parameter identifies the document; earlier parameters narrow the lookup."
+		},
+		...args.onChange ? { hooks: { afterChange: [() => void args.onChange()] } } : {},
+		fields: [{
+			type: "array",
+			name: "collections",
+			minRows: 0,
+			required: true,
+			...args.interfaceName ? { interfaceName: args.interfaceName } : {},
+			validate: (value, opts) => {
+				const rows = Array.isArray(value) ? value : [];
+				const t = opts.req.t;
+				if (hasDuplicates(rows.map((it) => it.collectionName))) return translate(t, "duplicateCollection");
+				const paths = rows.flatMap((it) => {
+					const path = it.path;
+					if (typeof path === "string") return [path];
+					return path && typeof path === "object" ? Object.entries(path).map(([locale, pattern]) => `${locale}:${String(pattern)}`) : [];
+				});
+				if (hasDuplicates(paths)) return translate(t, "duplicatePath");
+				return true;
+			},
+			fields: [createCollectionStringField({
+				name: "collectionName",
+				required: true
+			}), pathField]
+		}]
+	};
+};
+//#endregion
+export { DEFAULT_MAPPING_GLOBAL_SLUG, createMappingGlobal };

package/dist/config/plugin.d.mts

@@ -0,0 +1,31 @@
+import { CreateMappingGlobalArgs } from "./mapping-global.mjs";
+import { Plugin } from "payload";
+//#region src/config/plugin.d.ts
+interface WayfinderPluginArgs extends CreateMappingGlobalArgs {
+  /**
+   * Collections that can be linked to. Only used to warn about missing
+   * `defaultPopulate`; linking itself is governed by the link field.
+   */
+  linkableCollections?: string[];
+  /**
+   * Set when the project resolves references through its own index rather
+   * than a populated document. Suppresses the `defaultPopulate` warning,
+   * which would otherwise be noise for a deliberately depth-capped setup.
+   */
+  resolvesReferencesExternally?: boolean;
+  /** Silences the startup checks. */
+  quiet?: boolean;
+}
+/**
+ * Registers the mapping global and the package's admin translations.
+ *
+ * The single place the global's slug and localization are decided, so the
+ * write side and the read side cannot drift apart — `loadMappings` has to be
+ * told the same two things, and a mismatch means writing to one global and
+ * reading from another.
+ *
+ * @param args Mapping-global settings and startup-check inputs.
+ */
+declare const wayfinderPlugin: (args?: WayfinderPluginArgs) => Plugin;
+//#endregion
+export { WayfinderPluginArgs, wayfinderPlugin };

package/dist/config/plugin.mjs

@@ -0,0 +1,36 @@
+import { wayfinderTranslations } from "./translations.mjs";
+import { createMappingGlobal } from "./mapping-global.mjs";
+//#region src/config/plugin.ts
+/**
+* Registers the mapping global and the package's admin translations.
+*
+* The single place the global's slug and localization are decided, so the
+* write side and the read side cannot drift apart — `loadMappings` has to be
+* told the same two things, and a mismatch means writing to one global and
+* reading from another.
+*
+* @param args Mapping-global settings and startup-check inputs.
+*/ const wayfinderPlugin = (args = {}) => (incoming) => {
+	const config = {
+		...incoming,
+		globals: [...incoming.globals ?? [], createMappingGlobal(args)],
+		i18n: {
+			...incoming.i18n,
+			translations: {
+				...incoming.i18n?.translations,
+				...wayfinderTranslations
+			}
+		}
+	};
+	if (args.quiet) return config;
+	if (!args.resolvesReferencesExternally) {
+		const missing = (args.linkableCollections ?? []).filter((slug) => {
+			const collection = config.collections?.find((it) => it.slug === slug);
+			return collection && !collection.defaultPopulate;
+		});
+		if (missing.length > 0) console.warn(`[wayfinder] Linkable collections without \`defaultPopulate\`: ${missing.join(", ")}. Links to them break whenever the query depth runs out before the relationship is populated.`);
+	}
+	return config;
+};
+//#endregion
+export { wayfinderPlugin };

package/dist/config/translations.d.mts

@@ -0,0 +1,34 @@
+//#region src/config/translations.d.ts
+/**
+ * Admin-facing messages, keyed for Payload's translation lookup.
+ *
+ * Registered by the plugin. A project that builds the mapping global directly
+ * without the plugin still works — `req.t` returns the key's fallback — but
+ * sees these in English regardless of the admin locale.
+ */
+declare const wayfinderTranslations: {
+  readonly en: {
+    readonly wayfinder: {
+      readonly duplicateCollection: "Each collection may only be mapped once";
+      readonly duplicatePath: "Two collections may not share the same path pattern";
+      readonly invalidPath: "Path is invalid";
+      readonly pathUnparseable: "Path could not be parsed as a route pattern";
+      readonly pathNeedsParameter: "Path must contain at least one parameter";
+      readonly selectCollectionFirst: "Select a collection first";
+      readonly unknownCollection: "Unknown collection \"{{value}}\". Available: {{known}}";
+    };
+  };
+  readonly de: {
+    readonly wayfinder: {
+      readonly duplicateCollection: "Jede Collection darf nur einmal zugeordnet werden";
+      readonly duplicatePath: "Zwei Collections dürfen nicht dasselbe Pfadmuster verwenden";
+      readonly invalidPath: "Pfad ist ungültig";
+      readonly pathUnparseable: "Pfad konnte nicht als Routenmuster gelesen werden";
+      readonly pathNeedsParameter: "Pfad muss mindestens einen Parameter enthalten";
+      readonly selectCollectionFirst: "Bitte zuerst eine Collection wählen";
+      readonly unknownCollection: "Unbekannte Collection \"{{value}}\". Verfügbar: {{known}}";
+    };
+  };
+};
+//#endregion
+export { wayfinderTranslations };

package/dist/config/translations.mjs

@@ -0,0 +1,45 @@
+//#region src/config/translations.ts
+/**
+* Admin-facing messages, keyed for Payload's translation lookup.
+*
+* Registered by the plugin. A project that builds the mapping global directly
+* without the plugin still works — `req.t` returns the key's fallback — but
+* sees these in English regardless of the admin locale.
+*/ const wayfinderTranslations = {
+	en: { wayfinder: {
+		duplicateCollection: "Each collection may only be mapped once",
+		duplicatePath: "Two collections may not share the same path pattern",
+		invalidPath: "Path is invalid",
+		pathUnparseable: "Path could not be parsed as a route pattern",
+		pathNeedsParameter: "Path must contain at least one parameter",
+		selectCollectionFirst: "Select a collection first",
+		unknownCollection: "Unknown collection \"{{value}}\". Available: {{known}}"
+	} },
+	de: { wayfinder: {
+		duplicateCollection: "Jede Collection darf nur einmal zugeordnet werden",
+		duplicatePath: "Zwei Collections dürfen nicht dasselbe Pfadmuster verwenden",
+		invalidPath: "Pfad ist ungültig",
+		pathUnparseable: "Pfad konnte nicht als Routenmuster gelesen werden",
+		pathNeedsParameter: "Pfad muss mindestens einen Parameter enthalten",
+		selectCollectionFirst: "Bitte zuerst eine Collection wählen",
+		unknownCollection: "Unbekannte Collection \"{{value}}\". Verfügbar: {{known}}"
+	} }
+};
+/**
+* Translates a wayfinder key, falling back to English.
+*
+* Payload returns the key itself when nothing is registered, which would put a
+* bare `wayfinder:invalidPath` in front of an editor. This keeps the English
+* sentence in that case.
+*
+* @param t Payload's translation function, when available.
+* @param key The key within the `wayfinder` namespace.
+* @param vars Interpolation values.
+*/ const translate = (t, key, vars) => {
+	const fallback = wayfinderTranslations.en.wayfinder[key];
+	const translated = t?.(`wayfinder:${key}`, vars);
+	if (!translated || translated === `wayfinder:${key}`) return Object.entries(vars ?? {}).reduce((acc, [name, value]) => acc.replaceAll(`{{${name}}}`, value), fallback);
+	return translated;
+};
+//#endregion
+export { translate, wayfinderTranslations };

package/dist/index.d.mts

@@ -0,0 +1,16 @@
+import { BaseResolvedLink, BuiltinLinkVariant, Contributed, DEFAULT_LOCALE_KEY, DeclaredLinkVariant, FormatHref, LabelLike, LinkFieldData, PayloadCollectionMapping, PayloadCollectionMappingMatch, PayloadCollectionMappingResolved, PayloadCollectionMappingResolvers, PayloadCollectionMappingSpecificity, ResolvedLink } from "./pattern/types.mjs";
+import { AnyLinkVariantDefinition, DataOfFields, LinkDataOf, LinkDeclaration, LinkVariantDefinition, LinkVariantSource, LinkVariantSpec, ResolvedLinkOf, VariantBuilder, defineLinks, variantsOf } from "./pattern/define-links.mjs";
+import { defineMappings } from "./pattern/define-mappings.mjs";
+import { deriveLinkLabel } from "./pattern/derive-link-label.mjs";
+import { PayloadCollectionMatch, matchCollectionMappings } from "./pattern/matcher.mjs";
+import { DEFAULT_IDENTIFIER_FIELD, RegisteredCollections, ResolveParamQueryPathArgs, resolveParamQueryPath } from "./pattern/param-query-path.mjs";
+import { isRootWildcard, resolveCollectionMapping, resolversFor } from "./pattern/resolver.mjs";
+import "./pattern/index.mjs";
+import { BuildDiagnosticReason, Diagnostic, DiagnosticReason, OnDiagnostic, ResolveLinkDiagnosticReason, ResolvePathDiagnosticReason } from "./runtime/diagnostics.mjs";
+import { BuildHrefArgs, LinkableDocument, buildHref, identityFormatHref } from "./runtime/build-href.mjs";
+import { BuildPathArgs, buildPath } from "./runtime/build-path.mjs";
+import { ResolveLinkArgs, ResolveReference, isAvailableLink, resolveLink } from "./runtime/resolve-link.mjs";
+import { PayloadDocument, ResolvePathToDocumentArgs, ResolvePathWhere, ResolvedPath, resolvePathToDocument } from "./runtime/resolve-path.mjs";
+import { ResolveRelationshipSlugArgs, resolveRelationshipSlug } from "./runtime/resolve-relationship-slug.mjs";
+import "./runtime/index.mjs";
+export { type AnyLinkVariantDefinition, type BaseResolvedLink, type BuildDiagnosticReason, type BuildHrefArgs, type BuildPathArgs, type BuiltinLinkVariant, type Contributed, DEFAULT_IDENTIFIER_FIELD, DEFAULT_LOCALE_KEY, type DataOfFields, type DeclaredLinkVariant, type Diagnostic, type DiagnosticReason, type FormatHref, type LabelLike, type LinkDataOf, type LinkDeclaration, type LinkFieldData, type LinkVariantDefinition, type LinkVariantSource, type LinkVariantSpec, type LinkableDocument, type OnDiagnostic, type PayloadCollectionMapping, type PayloadCollectionMappingMatch, type PayloadCollectionMappingResolved, type PayloadCollectionMappingResolvers, type PayloadCollectionMappingSpecificity, type PayloadCollectionMatch, type PayloadDocument, type RegisteredCollections, type ResolveLinkArgs, type ResolveLinkDiagnosticReason, type ResolveParamQueryPathArgs, type ResolvePathDiagnosticReason, type ResolvePathToDocumentArgs, type ResolvePathWhere, type ResolveReference, type ResolveRelationshipSlugArgs, type ResolvedLink, type ResolvedLinkOf, type ResolvedPath, type VariantBuilder, buildHref, buildPath, defineLinks, defineMappings, deriveLinkLabel, identityFormatHref, isAvailableLink, isRootWildcard, matchCollectionMappings, resolveCollectionMapping, resolveLink, resolveParamQueryPath, resolvePathToDocument, resolveRelationshipSlug, resolversFor, variantsOf };

package/dist/index.mjs

@@ -0,0 +1,15 @@
+import { defineLinks, variantsOf } from "./pattern/define-links.mjs";
+import { DEFAULT_LOCALE_KEY } from "./pattern/types.mjs";
+import { isRootWildcard, resolveCollectionMapping, resolversFor } from "./pattern/resolver.mjs";
+import { defineMappings } from "./pattern/define-mappings.mjs";
+import { deriveLinkLabel } from "./pattern/derive-link-label.mjs";
+import { matchCollectionMappings } from "./pattern/matcher.mjs";
+import { DEFAULT_IDENTIFIER_FIELD, resolveParamQueryPath } from "./pattern/param-query-path.mjs";
+import "./pattern/index.mjs";
+import { buildHref, identityFormatHref } from "./runtime/build-href.mjs";
+import { buildPath } from "./runtime/build-path.mjs";
+import { isAvailableLink, resolveLink } from "./runtime/resolve-link.mjs";
+import { resolvePathToDocument } from "./runtime/resolve-path.mjs";
+import { resolveRelationshipSlug } from "./runtime/resolve-relationship-slug.mjs";
+import "./runtime/index.mjs";
+export { DEFAULT_IDENTIFIER_FIELD, DEFAULT_LOCALE_KEY, buildHref, buildPath, defineLinks, defineMappings, deriveLinkLabel, identityFormatHref, isAvailableLink, isRootWildcard, matchCollectionMappings, resolveCollectionMapping, resolveLink, resolveParamQueryPath, resolvePathToDocument, resolveRelationshipSlug, resolversFor, variantsOf };

package/dist/lexical/index.d.mts

@@ -0,0 +1,52 @@
+import { BaseResolvedLink, LinkFieldData, ResolvedLink } from "../pattern/types.mjs";
+import { LinkDeclaration, ResolvedLinkOf } from "../pattern/define-links.mjs";
+import { LinkFieldArgs } from "../config/link-field.mjs";
+import { ResolveLinkArgs } from "../runtime/resolve-link.mjs";
+import { LinkFeature } from "@payloadcms/richtext-lexical";
+//#region src/lexical/index.d.ts
+/**
+ * Gives every created or edited link a top-level `label` derived from its
+ * destination, so the floating link editor shows a useful hover preview
+ * instead of a blank one.
+ */
+declare const linkLabelFeature: import("@payloadcms/richtext-lexical").FeatureProviderProviderServer<undefined, undefined, undefined>;
+/**
+ * Replaces Lexical's link fields with the wayfinder link field, so links
+ * written in rich text route through the collection mapping exactly like links
+ * authored in a block.
+ *
+ * @param args The same arguments as the standalone link field.
+ */
+declare const wayfinderLinkFeature: <TDeclaration extends LinkDeclaration = LinkDeclaration>(args: LinkFieldArgs<TDeclaration>) => ReturnType<typeof LinkFeature>;
+/**
+ * The two shapes a link node's fields arrive in.
+ *
+ * A node written by {@link wayfinderLinkFeature} nests the group under `link`.
+ * A node written by Lexical's stock link feature stores `linkType` and `doc`
+ * at the top level, which existing content will still hold.
+ */
+interface SerializedLinkFields {
+  link?: LinkFieldData;
+  linkType?: "custom" | "internal";
+  url?: string | null;
+  newTab?: boolean | null;
+  doc?: {
+    relationTo: string;
+    value: string | {
+      id: string;
+    };
+  } | null;
+}
+/**
+ * Resolves a rich-text link node to an href.
+ *
+ * Returns null when the node points nowhere resolvable, so a converter can
+ * render the text without an anchor rather than emitting a dead one.
+ *
+ * @param args The node's fields plus the usual link-resolution arguments.
+ */
+declare const resolveLinkNode: <TExtra = object, TDeclaration extends LinkDeclaration = LinkDeclaration>(args: Omit<ResolveLinkArgs<TExtra, TDeclaration>, "link"> & {
+  fields: SerializedLinkFields | undefined;
+}) => BaseResolvedLink | ResolvedLink<object> | ResolvedLinkOf<TDeclaration> | null;
+//#endregion
+export { linkLabelFeature, resolveLinkNode, wayfinderLinkFeature };

package/dist/lexical/index.mjs

@@ -0,0 +1,57 @@
+import { resolveLink } from "../runtime/resolve-link.mjs";
+import { linkField } from "../config/link-field.mjs";
+import { LinkFeature, createServerFeature } from "@payloadcms/richtext-lexical";
+//#region src/lexical/index.ts
+/** Where the admin bundle finds the label plugin. */ const LABEL_FEATURE_CLIENT = "@abinnovision/payloadcms-wayfinder/admin#LinkLabelFeatureClient";
+/**
+* Gives every created or edited link a top-level `label` derived from its
+* destination, so the floating link editor shows a useful hover preview
+* instead of a blank one.
+*/ const linkLabelFeature = createServerFeature({
+	key: "wayfinder-link-label",
+	feature: () => ({
+		ClientFeature: LABEL_FEATURE_CLIENT,
+		markdownTransformers: []
+	})
+});
+/**
+* Replaces Lexical's link fields with the wayfinder link field, so links
+* written in rich text route through the collection mapping exactly like links
+* authored in a block.
+*
+* @param args The same arguments as the standalone link field.
+*/ const wayfinderLinkFeature = (args) => LinkFeature({ fields: () => [linkField(args)] });
+/**
+* Normalises a link node's fields into the link field's own shape.
+*
+* @param fields The node's `fields` object.
+*/ const normaliseNodeFields = (fields) => {
+	if (!fields) return;
+	if (fields.link) return fields.link;
+	if (fields.linkType === "internal" && fields.doc) return {
+		type: "reference",
+		reference: fields.doc,
+		newTab: fields.newTab ?? null
+	};
+	if (fields.url) return {
+		type: "custom",
+		url: fields.url,
+		newTab: fields.newTab ?? null
+	};
+};
+/**
+* Resolves a rich-text link node to an href.
+*
+* Returns null when the node points nowhere resolvable, so a converter can
+* render the text without an anchor rather than emitting a dead one.
+*
+* @param args The node's fields plus the usual link-resolution arguments.
+*/ const resolveLinkNode = (args) => {
+	const link = normaliseNodeFields(args.fields);
+	return resolveLink({
+		...args,
+		link
+	});
+};
+//#endregion
+export { linkLabelFeature, resolveLinkNode, wayfinderLinkFeature };