@payloadcms/richtext-lexical 4.0.0-internal.1f9ae9a → 4.0.0-internal.203916b

package/dist/types/jsonSchemaHelpers.js

@@ -0,0 +1,58 @@
+/** `format` property shared by every element node (Lexical `ElementFormatType`). */export const formatSchema = {
+  type: 'string',
+  description: 'How this element is aligned. Empty string means no explicit alignment.',
+  enum: ['left', 'start', 'center', 'right', 'end', 'justify', ''],
+  tsType: 'LexicalElementFormat'
+};
+/** `direction` property shared by every element node. */
+export const directionSchema = {
+  oneOf: [{
+    type: 'string',
+    enum: ['ltr', 'rtl']
+  }, {
+    type: 'null'
+  }],
+  tsType: 'LexicalElementDirection'
+};
+/** `version` property shared by every Lexical node. */
+export const versionSchema = {
+  type: 'integer',
+  description: "Lexical's internal serialization version for this node type."
+};
+/**
+ * Builds the JSON Schema for a Lexical element node - merges the shared
+ * element-base shape (children/direction/format/indent/version) with the
+ * node-specific bits a feature provides.
+ */
+export const elementNodeSchema = ({
+  nodeType,
+  nodeUnionRef,
+  properties = {},
+  required = [],
+  tsType
+}) => ({
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    type: {
+      type: 'string',
+      const: nodeType
+    },
+    children: {
+      type: 'array',
+      items: nodeUnionRef
+    },
+    direction: directionSchema,
+    format: formatSchema,
+    indent: {
+      type: 'integer'
+    },
+    version: versionSchema,
+    ...properties
+  },
+  required: ['children', 'direction', 'format', 'indent', 'type', 'version', ...required],
+  ...(tsType ? {
+    tsType
+  } : {})
+});
+//# sourceMappingURL=jsonSchemaHelpers.js.map

package/dist/types/jsonSchemaHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonSchemaHelpers.js","names":["formatSchema","type","description","enum","tsType","directionSchema","oneOf","versionSchema","elementNodeSchema","nodeType","nodeUnionRef","properties","required","additionalProperties","const","children","items","direction","format","indent","version"],"sources":["../../src/types/jsonSchemaHelpers.ts"],"sourcesContent":["import type { JSONSchema4 } from 'json-schema'\n\n/** `format` property shared by every element node (Lexical `ElementFormatType`). */\nexport const formatSchema: JSONSchema4 = {\n  type: 'string',\n  description: 'How this element is aligned. Empty string means no explicit alignment.',\n  enum: ['left', 'start', 'center', 'right', 'end', 'justify', ''],\n  tsType: 'LexicalElementFormat',\n}\n\n/** `direction` property shared by every element node. */\nexport const directionSchema: JSONSchema4 = {\n  oneOf: [{ type: 'string', enum: ['ltr', 'rtl'] }, { type: 'null' }],\n  tsType: 'LexicalElementDirection',\n}\n\n/** `version` property shared by every Lexical node. */\nexport const versionSchema: JSONSchema4 = {\n  type: 'integer',\n  description: \"Lexical's internal serialization version for this node type.\",\n}\n\ntype ElementNodeSchemaOptions = {\n  nodeType: string\n  properties?: { [k: string]: JSONSchema4 }\n  required?: string[]\n  /** TS helper-type expression — emitted verbatim by json-schema-to-typescript. */\n  tsType?: string\n}\n\n/**\n * Builds the JSON Schema for a Lexical element node - merges the shared\n * element-base shape (children/direction/format/indent/version) with the\n * node-specific bits a feature provides.\n */\nexport const elementNodeSchema = ({\n  nodeType,\n  nodeUnionRef,\n  properties = {},\n  required = [],\n  tsType,\n}: { nodeUnionRef: JSONSchema4 } & ElementNodeSchemaOptions): JSONSchema4 => ({\n  type: 'object',\n  additionalProperties: false,\n  properties: {\n    type: { type: 'string', const: nodeType },\n    children: { type: 'array', items: nodeUnionRef },\n    direction: directionSchema,\n    format: formatSchema,\n    indent: { type: 'integer' },\n    version: versionSchema,\n    ...properties,\n  },\n  required: ['children', 'direction', 'format', 'indent', 'type', 'version', ...required],\n  ...(tsType ? { tsType } : {}),\n})\n\n/**\n * `elementNodeSchema` HOC type, so that features don't have to pass `nodeUnionRef` every time.\n */\nexport type ElementNodeSchemaFn = (opts: ElementNodeSchemaOptions) => JSONSchema4\n"],"mappings":"AAEA,oFACA,OAAO,MAAMA,YAAA,GAA4B;EACvCC,IAAA,EAAM;EACNC,WAAA,EAAa;EACbC,IAAA,EAAM,CAAC,QAAQ,SAAS,UAAU,SAAS,OAAO,WAAW,GAAG;EAChEC,MAAA,EAAQ;AACV;AAEA;AACA,OAAO,MAAMC,eAAA,GAA+B;EAC1CC,KAAA,EAAO,CAAC;IAAEL,IAAA,EAAM;IAAUE,IAAA,EAAM,CAAC,OAAO;EAAO,GAAG;IAAEF,IAAA,EAAM;EAAO,EAAE;EACnEG,MAAA,EAAQ;AACV;AAEA;AACA,OAAO,MAAMG,aAAA,GAA6B;EACxCN,IAAA,EAAM;EACNC,WAAA,EAAa;AACf;AAUA;;;;;AAKA,OAAO,MAAMM,iBAAA,GAAoBA,CAAC;EAChCC,QAAQ;EACRC,YAAY;EACZC,UAAA,GAAa,CAAC,CAAC;EACfC,QAAA,GAAW,EAAE;EACbR;AAAM,CACmD,MAAmB;EAC5EH,IAAA,EAAM;EACNY,oBAAA,EAAsB;EACtBF,UAAA,EAAY;IACVV,IAAA,EAAM;MAAEA,IAAA,EAAM;MAAUa,KAAA,EAAOL;IAAS;IACxCM,QAAA,EAAU;MAAEd,IAAA,EAAM;MAASe,KAAA,EAAON;IAAa;IAC/CO,SAAA,EAAWZ,eAAA;IACXa,MAAA,EAAQlB,YAAA;IACRmB,MAAA,EAAQ;MAAElB,IAAA,EAAM;IAAU;IAC1BmB,OAAA,EAASb,aAAA;IACT,GAAGI;EACL;EACAC,QAAA,EAAU,CAAC,YAAY,aAAa,UAAU,UAAU,QAAQ,W,GAAcA,QAAA,CAAS;EACvF,IAAIR,MAAA,GAAS;IAAEA;EAAO,IAAI,CAAC,CAAC;AAC9B","ignoreList":[]}

package/dist/types/nodeTypes.d.ts

@@ -1,74 +1,128 @@
-import type { SerializedLineBreakNode as _SerializedLineBreakNode, SerializedTabNode as _SerializedTabNode, SerializedTextNode as _SerializedTextNode, SerializedEditorState, SerializedElementNode, SerializedLexicalNode } from 'lexical';
-import type { SerializedQuoteNode } from '../features/blockquote/server/index.js';
-import type { SerializedBlockNode } from '../features/blocks/server/nodes/BlocksNode.js';
-import type { SerializedInlineBlockNode } from '../features/blocks/server/nodes/InlineBlocksNode.js';
-import type { SerializedTableCellNode, SerializedTableNode, SerializedTableRowNode } from '../features/experimental_table/server/index.js';
-import type { SerializedHeadingNode } from '../features/heading/server/index.js';
-import type { SerializedHorizontalRuleNode } from '../features/horizontalRule/server/nodes/HorizontalRuleNode.js';
-import type { SerializedAutoLinkNode, SerializedLinkNode } from '../features/link/nodes/types.js';
-import type { SerializedListItemNode, SerializedListNode } from '../features/lists/plugin/index.js';
-import type { SerializedRelationshipNode } from '../features/relationship/server/nodes/RelationshipNode.js';
-import type { SerializedUploadNode } from '../features/upload/server/nodes/UploadNode.js';
+import type { SerializedLexicalNode } from 'lexical';
+import type { SerializedQuoteNode } from '../features/blockquote/server/schema.js';
+import type { SerializedBlockNode, SerializedInlineBlockNode } from '../features/blocks/server/schema.js';
+import type { SerializedTableCellNode, SerializedTableNode, SerializedTableRowNode } from '../features/experimental_table/server/schema.js';
+import type { SerializedHeadingNode } from '../features/heading/server/schema.js';
+import type { SerializedHorizontalRuleNode } from '../features/horizontalRule/server/schema.js';
+import type { SerializedAutoLinkNode, SerializedLinkNode } from '../features/link/server/schema.js';
+import type { SerializedListItemNode, SerializedListNode } from '../features/lists/shared/schema.js';
+import type { SerializedRelationshipNode } from '../features/relationship/server/schema.js';
+import type { SerializedUploadNode } from '../features/upload/server/schema.js';
+/** @internal Core Lexical types — see @payloadcms/richtext-lexical. */
+export type LexicalElementFormat = '' | 'center' | 'end' | 'justify' | 'left' | 'right' | 'start';
+export type LexicalElementDirection = ('ltr' | 'rtl') | null;
+export interface SerializedLexicalElementBase<TChildren> {
+    children: TChildren[];
+    direction: LexicalElementDirection;
+    format: LexicalElementFormat;
+    indent: number;
+    textFormat?: number;
+    textStyle?: string;
+    version: number;
+}
+export type LexicalTextMode = 'normal' | 'segmented' | 'token';
+export interface SerializedTextNode {
+    detail: number;
+    format: number;
+    mode: LexicalTextMode;
+    style: string;
+    text: string;
+    type: 'text';
+    version: number;
+}
+export interface SerializedTabNode {
+    detail: number;
+    format: number;
+    mode: LexicalTextMode;
+    style: string;
+    text: string;
+    type: 'tab';
+    version: number;
+}
+export interface SerializedLineBreakNode {
+    type: 'linebreak';
+    version: number;
+}
+export interface SerializedParagraphNode<TChildren extends SerializedLexicalNode = SerializedLexicalNode> extends SerializedLexicalElementBase<TChildren> {
+    textFormat: number;
+    textStyle: string;
+    type: 'paragraph';
+}
+/** Shape of a Lexical `richText` field. */
+export interface LexicalRichText<TNode> {
+    root: {
+        children: TNode[];
+        direction: LexicalElementDirection;
+        format: LexicalElementFormat;
+        indent: number;
+        type: 'root';
+        version: number;
+    };
+}
+export type { SerializedAutoLinkNode, SerializedBlockNode, SerializedHeadingNode, SerializedHorizontalRuleNode, SerializedInlineBlockNode, SerializedLinkNode, SerializedListItemNode, SerializedListNode, SerializedQuoteNode, SerializedRelationshipNode, SerializedTableCellNode, SerializedTableNode, SerializedTableRowNode, SerializedUploadNode, };
+/** `SerializedEditorState` with nodes narrowed by `type`. No type-casting needed. */
+export type TypedEditorState<TNode extends SerializedLexicalNode = SerializedLexicalNode> = LexicalRichText<TNode>;
 /**
- * Helper type to create strongly typed serialized nodes with flexible children types.
- * Omits 'children' and 'type' from the base node type and redeclares them with proper typing.
- *
- * @param TBase - The base Lexical node type (e.g., _SerializedHeadingNode)
- * @param TType - The node type string (e.g., 'heading')
- * @param TChildren - The type for children (defaults to SerializedLexicalNode)
+ * The node union of a generated `richText` field. Pass the field type — e.g.
+ * `RichTextNodes<Post['richText']>` — to type an individual node you build for that editor (for
+ * example a single block, or a `.map()` of nodes). To build a whole editor state, prefer passing
+ * the field type straight to {@link buildEditorState}.
  */
-export type StronglyTypedElementNode<TBase, TType extends string, TChildren extends SerializedLexicalNode = SerializedLexicalNode> = {
-    children: TChildren[];
-    type: TType;
-} & Omit<TBase, 'children' | 'type'>;
+export type RichTextNodes<TRichText> = NonNullable<TRichText> extends LexicalRichText<infer TNode> ? TNode : never;
 /**
- * Helper type to create strongly typed leaf nodes (nodes without children).
- * Omits 'children' and 'type' from the base node type and redeclares 'type' with a literal.
- *
- * @param TBase - The base Lexical node type (e.g., _SerializedTextNode)
- * @param TType - The node type string (e.g., 'text')
+ * All node types included by default in a lexical editor. Self-recursive —
+ * each element node's `children` is `DefaultNodeTypes` again, no depth limit.
+ * To compose your own union including the defaults, see {@link WithDefaultNodes}.
  */
-export type StronglyTypedLeafNode<TBase, TType extends string> = {
-    type: TType;
-} & Omit<TBase, 'children' | 'type'>;
-export type { SerializedAutoLinkNode, SerializedBlockNode, SerializedHeadingNode, SerializedHorizontalRuleNode, SerializedInlineBlockNode, SerializedLinkNode, SerializedListItemNode, SerializedListNode, SerializedQuoteNode, SerializedRelationshipNode, SerializedTableCellNode, SerializedTableNode, SerializedTableRowNode, SerializedUploadNode, };
-export type SerializedParagraphNode<T extends SerializedLexicalNode = SerializedLexicalNode> = {
-    textFormat: number;
-} & StronglyTypedElementNode<SerializedElementNode, 'paragraph', T>;
-export type SerializedTextNode = StronglyTypedLeafNode<_SerializedTextNode, 'text'>;
-export type SerializedTabNode = StronglyTypedLeafNode<_SerializedTabNode, 'tab'>;
-export type SerializedLineBreakNode = StronglyTypedLeafNode<_SerializedLineBreakNode, 'linebreak'>;
+export type DefaultNodeTypes = SerializedAutoLinkNode<DefaultNodeTypes> | SerializedHeadingNode<DefaultNodeTypes> | SerializedHorizontalRuleNode | SerializedLineBreakNode | SerializedLinkNode<DefaultNodeTypes> | SerializedListItemNode<DefaultNodeTypes> | SerializedListNode<DefaultNodeTypes> | SerializedParagraphNode<DefaultNodeTypes> | SerializedQuoteNode<DefaultNodeTypes> | SerializedRelationshipNode | SerializedTabNode | SerializedTextNode | SerializedUploadNode;
 /**
- * Recursively adds typed children to nodes up to a specified depth.
+ * The built-in lexical nodes, plus your own - with your nodes threaded into every container's
+ * `children`, not just the top level. Pass your custom node(s) as the generic:
  *
- * Key behaviors:
- * - `T extends any`: Distributive - processes each union member individually
- * - `OriginalUnion`: Preserves full union so nested children accept all node types, not just parent's type. If we just used `T`, the type would be narrowed to the parent's type and the children would only consist of the parent's type.
- * - `'children' extends keyof T`: Only adds children to container nodes; respects leaf nodes that use `Omit<_, 'children'>`
- * - `Depth`: Limits recursion to prevent infinite types (default: 4 levels)
+ * ```ts
+ * type MyNodes = WithDefaultNodes<SerializedBlockNode<MyBlockData>>
+ * ```
  *
- * @internal - this type may change or be removed in a minor release
+ * Built by flattening {@link DefaultNodeRegistry} (`Registry[keyof Registry]`); see that interface
+ * for why the node set lives in a registry instead of being written as a plain union type.
  */
-export type RecursiveNodes<T extends SerializedLexicalNode, Depth extends number = 4, OriginalUnion extends SerializedLexicalNode = T> = T extends any ? Depth extends 0 ? T : 'children' extends keyof T ? {
-    children?: RecursiveNodes<OriginalUnion, DecrementDepth<Depth>, OriginalUnion>[];
-} & T : T : never;
-/** Decrements depth: 4→3, 3→2, 2→1, 1→0, 0→0 */
-type DecrementDepth<N extends number> = [0, 0, 1, 2, 3, 4][N];
+export type WithDefaultNodes<TCustom extends SerializedLexicalNode = never> = DefaultNodeRegistry<TCustom>[keyof DefaultNodeRegistry<TCustom>];
+/** @internal Re-types an element node's `children` to the recursive node union. */
+type WithRecursiveChildren<TNode, TCustom extends SerializedLexicalNode> = {
+    children: WithDefaultNodes<TCustom>[];
+} & Omit<TNode, 'children'>;
 /**
- * Alternative type to `SerializedEditorState` that automatically types your nodes
- * more strictly, narrowing down nodes based on the `type` without having to manually
- * type-cast.
- */
-export type TypedEditorState<T extends SerializedLexicalNode = SerializedLexicalNode> = {
-    [k: string]: unknown;
-} & SerializedEditorState<RecursiveNodes<T>>;
-/**
- * All node types included by default in a lexical editor without configuration.
+ * @internal The set of default nodes, generic over the user's custom node(s). {@link WithDefaultNodes}
+ * flattens it into the node union with `Registry[keyof Registry]`.
+ *
+ * Why a registry interface instead of writing the union directly? The union has to be self-referential:
+ * every element node's `children` is the same node union (so custom nodes nest inside containers too).
+ * A generic *type alias* can't reference itself that way - `type N<T> = SerializedParagraphNode<N<T>> | ...`
+ * is a `TS2456` circular reference, because instantiating a type alias resolves its type argument
+ * eagerly. An *interface* resolves its members lazily, so the self-reference inside `children: ...[]`
+ * is allowed - the recursion is legal precisely because it lives inside this interface. Reusing the
+ * real node interfaces (re-typing only `children`) keeps each entry in sync with its node's real shape.
  */
-export type DefaultNodeTypes = SerializedAutoLinkNode | SerializedHeadingNode | SerializedHorizontalRuleNode | SerializedLineBreakNode | SerializedLinkNode | SerializedListItemNode | SerializedListNode | SerializedParagraphNode | SerializedQuoteNode | SerializedRelationshipNode | SerializedTabNode | SerializedTextNode | SerializedUploadNode;
+interface DefaultNodeRegistry<TCustom extends SerializedLexicalNode> {
+    autolink: WithRecursiveChildren<SerializedAutoLinkNode<SerializedLexicalNode>, TCustom>;
+    custom: TCustom;
+    heading: WithRecursiveChildren<SerializedHeadingNode<SerializedLexicalNode>, TCustom>;
+    horizontalrule: SerializedHorizontalRuleNode;
+    linebreak: SerializedLineBreakNode;
+    link: WithRecursiveChildren<SerializedLinkNode<SerializedLexicalNode>, TCustom>;
+    list: WithRecursiveChildren<SerializedListNode<SerializedLexicalNode>, TCustom>;
+    listitem: WithRecursiveChildren<SerializedListItemNode<SerializedLexicalNode>, TCustom>;
+    paragraph: WithRecursiveChildren<SerializedParagraphNode<SerializedLexicalNode>, TCustom>;
+    quote: WithRecursiveChildren<SerializedQuoteNode<SerializedLexicalNode>, TCustom>;
+    relationship: SerializedRelationshipNode;
+    tab: SerializedTabNode;
+    text: SerializedTextNode;
+    upload: SerializedUploadNode;
+}
 /**
- * Like `TypedEditorState` but includes all default node types.
- * You can pass *additional* node types as a generic parameter.
+ * Like `TypedEditorState`, but pre-filled with every default node type. Pass extra node types as a
+ * generic to add your own; they're threaded into every container's `children` (via
+ * {@link WithDefaultNodes}), not just allowed at the top level.
  */
-export type DefaultTypedEditorState<TAdditionalNodeTypes extends null | SerializedLexicalNode = null> = [TAdditionalNodeTypes] extends null ? TypedEditorState<DefaultNodeTypes> : TypedEditorState<DefaultNodeTypes | NonNullable<TAdditionalNodeTypes>>;
+export type DefaultTypedEditorState<TAdditionalNodeTypes extends null | SerializedLexicalNode = null> = TypedEditorState<WithDefaultNodes<NonNullable<TAdditionalNodeTypes>>>;
 //# sourceMappingURL=nodeTypes.d.ts.map

package/dist/types/nodeTypes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nodeTypes.d.ts","sourceRoot":"","sources":["../../src/types/nodeTypes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,uBAAuB,IAAI,wBAAwB,EACnD,iBAAiB,IAAI,kBAAkB,EACvC,kBAAkB,IAAI,mBAAmB,EACzC,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,EACtB,MAAM,SAAS,CAAA;AAEhB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAA;AACjF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+CAA+C,CAAA;AACxF,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qDAAqD,CAAA;AACpG,OAAO,KAAK,EACV,uBAAuB,EACvB,mBAAmB,EACnB,sBAAsB,EACvB,MAAM,gDAAgD,CAAA;AACvD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAA;AAChF,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,+DAA+D,CAAA;AACjH,OAAO,KAAK,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAA;AACjG,OAAO,KAAK,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AACnG,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,2DAA2D,CAAA;AAC3G,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+CAA+C,CAAA;AAEzF;;;;;;;GAOG;AACH,MAAM,MAAM,wBAAwB,CAClC,KAAK,EACL,KAAK,SAAS,MAAM,EACpB,SAAS,SAAS,qBAAqB,GAAG,qBAAqB,IAC7D;IACF,QAAQ,EAAE,SAAS,EAAE,CAAA;IACrB,IAAI,EAAE,KAAK,CAAA;CACZ,GAAG,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAAC,CAAA;AAEpC;;;;;;GAMG;AACH,MAAM,MAAM,qBAAqB,CAAC,KAAK,EAAE,KAAK,SAAS,MAAM,IAAI;IAC/D,IAAI,EAAE,KAAK,CAAA;CACZ,GAAG,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAAC,CAAA;AAEpC,YAAY,EACV,sBAAsB,EACtB,mBAAmB,EACnB,qBAAqB,EACrB,4BAA4B,EAC5B,yBAAyB,EACzB,kBAAkB,EAClB,sBAAsB,EACtB,kBAAkB,EAClB,mBAAmB,EACnB,0BAA0B,EAC1B,uBAAuB,EACvB,mBAAmB,EACnB,sBAAsB,EACtB,oBAAoB,GACrB,CAAA;AAED,MAAM,MAAM,uBAAuB,CAAC,CAAC,SAAS,qBAAqB,GAAG,qBAAqB,IAAI;IAC7F,UAAU,EAAE,MAAM,CAAA;CACnB,GAAG,wBAAwB,CAAC,qBAAqB,EAAE,WAAW,EAAE,CAAC,CAAC,CAAA;AAEnE,MAAM,MAAM,kBAAkB,GAAG,qBAAqB,CAAC,mBAAmB,EAAE,MAAM,CAAC,CAAA;AAEnF,MAAM,MAAM,iBAAiB,GAAG,qBAAqB,CAAC,kBAAkB,EAAE,KAAK,CAAC,CAAA;AAEhF,MAAM,MAAM,uBAAuB,GAAG,qBAAqB,CAAC,wBAAwB,EAAE,WAAW,CAAC,CAAA;AAElG;;;;;;;;;;GAUG;AACH,MAAM,MAAM,cAAc,CACxB,CAAC,SAAS,qBAAqB,EAC/B,KAAK,SAAS,MAAM,GAAG,CAAC,EACxB,aAAa,SAAS,qBAAqB,GAAG,CAAC,IAE7C,CAAC,SAAS,GAAG,GACb,KAAK,SAAS,CAAC,GACb,CAAC,GACD,UAAU,SAAS,MAAM,CAAC,GACxB;IAAE,QAAQ,CAAC,EAAE,cAAc,CAAC,aAAa,EAAE,cAAc,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC,EAAE,CAAA;CAAE,GAAG,CAAC,GACxF,CAAC,GACL,KAAK,CAAA;AAET,gDAAgD;AAChD,KAAK,cAAc,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;AAE7D;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,qBAAqB,GAAG,qBAAqB,IAAI;IACtF,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;CACrB,GAAG,qBAAqB,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAA;AAE5C;;GAEG;AACH,MAAM,MAAM,gBAAgB,GACxB,sBAAsB,GAEtB,qBAAqB,GACrB,4BAA4B,GAC5B,uBAAuB,GACvB,kBAAkB,GAClB,sBAAsB,GACtB,kBAAkB,GAClB,uBAAuB,GACvB,mBAAmB,GACnB,0BAA0B,GAC1B,iBAAiB,GACjB,kBAAkB,GAClB,oBAAoB,CAAA;AAExB;;;GAGG;AACH,MAAM,MAAM,uBAAuB,CACjC,oBAAoB,SAAS,IAAI,GAAG,qBAAqB,GAAG,IAAI,IAC9D,CAAC,oBAAoB,CAAC,SAAS,IAAI,GACnC,gBAAgB,CAAC,gBAAgB,CAAC,GAClC,gBAAgB,CAAC,gBAAgB,GAAG,WAAW,CAAC,oBAAoB,CAAC,CAAC,CAAA"}
+{"version":3,"file":"nodeTypes.d.ts","sourceRoot":"","sources":["../../src/types/nodeTypes.ts"],"names":[],"mappings":"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"}

package/dist/types/nodeTypes.js

@@ -1,5 +1,6 @@
 /**
- * Like `TypedEditorState` but includes all default node types.
- * You can pass *additional* node types as a generic parameter.
+ * Like `TypedEditorState`, but pre-filled with every default node type. Pass extra node types as a
+ * generic to add your own; they're threaded into every container's `children` (via
+ * {@link WithDefaultNodes}), not just allowed at the top level.
  */export {};
 //# sourceMappingURL=nodeTypes.js.map

package/dist/types/nodeTypes.js.map

@@ -1 +1 @@
-{"version":3,"file":"nodeTypes.js","names":[],"sources":["../../src/types/nodeTypes.ts"],"sourcesContent":["import type {\n  SerializedLineBreakNode as _SerializedLineBreakNode,\n  SerializedTabNode as _SerializedTabNode,\n  SerializedTextNode as _SerializedTextNode,\n  SerializedEditorState,\n  SerializedElementNode,\n  SerializedLexicalNode,\n} from 'lexical'\n\nimport type { SerializedQuoteNode } from '../features/blockquote/server/index.js'\nimport type { SerializedBlockNode } from '../features/blocks/server/nodes/BlocksNode.js'\nimport type { SerializedInlineBlockNode } from '../features/blocks/server/nodes/InlineBlocksNode.js'\nimport type {\n  SerializedTableCellNode,\n  SerializedTableNode,\n  SerializedTableRowNode,\n} from '../features/experimental_table/server/index.js'\nimport type { SerializedHeadingNode } from '../features/heading/server/index.js'\nimport type { SerializedHorizontalRuleNode } from '../features/horizontalRule/server/nodes/HorizontalRuleNode.js'\nimport type { SerializedAutoLinkNode, SerializedLinkNode } from '../features/link/nodes/types.js'\nimport type { SerializedListItemNode, SerializedListNode } from '../features/lists/plugin/index.js'\nimport type { SerializedRelationshipNode } from '../features/relationship/server/nodes/RelationshipNode.js'\nimport type { SerializedUploadNode } from '../features/upload/server/nodes/UploadNode.js'\n\n/**\n * Helper type to create strongly typed serialized nodes with flexible children types.\n * Omits 'children' and 'type' from the base node type and redeclares them with proper typing.\n *\n * @param TBase - The base Lexical node type (e.g., _SerializedHeadingNode)\n * @param TType - The node type string (e.g., 'heading')\n * @param TChildren - The type for children (defaults to SerializedLexicalNode)\n */\nexport type StronglyTypedElementNode<\n  TBase,\n  TType extends string,\n  TChildren extends SerializedLexicalNode = SerializedLexicalNode,\n> = {\n  children: TChildren[]\n  type: TType\n} & Omit<TBase, 'children' | 'type'>\n\n/**\n * Helper type to create strongly typed leaf nodes (nodes without children).\n * Omits 'children' and 'type' from the base node type and redeclares 'type' with a literal.\n *\n * @param TBase - The base Lexical node type (e.g., _SerializedTextNode)\n * @param TType - The node type string (e.g., 'text')\n */\nexport type StronglyTypedLeafNode<TBase, TType extends string> = {\n  type: TType\n} & Omit<TBase, 'children' | 'type'>\n\nexport type {\n  SerializedAutoLinkNode,\n  SerializedBlockNode,\n  SerializedHeadingNode,\n  SerializedHorizontalRuleNode,\n  SerializedInlineBlockNode,\n  SerializedLinkNode,\n  SerializedListItemNode,\n  SerializedListNode,\n  SerializedQuoteNode,\n  SerializedRelationshipNode,\n  SerializedTableCellNode,\n  SerializedTableNode,\n  SerializedTableRowNode,\n  SerializedUploadNode,\n}\n\nexport type SerializedParagraphNode<T extends SerializedLexicalNode = SerializedLexicalNode> = {\n  textFormat: number\n} & StronglyTypedElementNode<SerializedElementNode, 'paragraph', T>\n\nexport type SerializedTextNode = StronglyTypedLeafNode<_SerializedTextNode, 'text'>\n\nexport type SerializedTabNode = StronglyTypedLeafNode<_SerializedTabNode, 'tab'>\n\nexport type SerializedLineBreakNode = StronglyTypedLeafNode<_SerializedLineBreakNode, 'linebreak'>\n\n/**\n * Recursively adds typed children to nodes up to a specified depth.\n *\n * Key behaviors:\n * - `T extends any`: Distributive - processes each union member individually\n * - `OriginalUnion`: Preserves full union so nested children accept all node types, not just parent's type. If we just used `T`, the type would be narrowed to the parent's type and the children would only consist of the parent's type.\n * - `'children' extends keyof T`: Only adds children to container nodes; respects leaf nodes that use `Omit<_, 'children'>`\n * - `Depth`: Limits recursion to prevent infinite types (default: 4 levels)\n *\n * @internal - this type may change or be removed in a minor release\n */\nexport type RecursiveNodes<\n  T extends SerializedLexicalNode,\n  Depth extends number = 4,\n  OriginalUnion extends SerializedLexicalNode = T,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n> = T extends any // Make distributive over unions\n  ? Depth extends 0\n    ? T\n    : 'children' extends keyof T\n      ? { children?: RecursiveNodes<OriginalUnion, DecrementDepth<Depth>, OriginalUnion>[] } & T\n      : T // Skip leaf nodes\n  : never\n\n/** Decrements depth: 4→3, 3→2, 2→1, 1→0, 0→0 */\ntype DecrementDepth<N extends number> = [0, 0, 1, 2, 3, 4][N]\n\n/**\n * Alternative type to `SerializedEditorState` that automatically types your nodes\n * more strictly, narrowing down nodes based on the `type` without having to manually\n * type-cast.\n */\nexport type TypedEditorState<T extends SerializedLexicalNode = SerializedLexicalNode> = {\n  [k: string]: unknown\n} & SerializedEditorState<RecursiveNodes<T>>\n\n/**\n * All node types included by default in a lexical editor without configuration.\n */\nexport type DefaultNodeTypes =\n  | SerializedAutoLinkNode\n  //| SerializedBlockNode // Not included by default\n  | SerializedHeadingNode\n  | SerializedHorizontalRuleNode\n  | SerializedLineBreakNode\n  | SerializedLinkNode\n  | SerializedListItemNode\n  | SerializedListNode\n  | SerializedParagraphNode\n  | SerializedQuoteNode\n  | SerializedRelationshipNode\n  | SerializedTabNode\n  | SerializedTextNode\n  | SerializedUploadNode\n\n/**\n * Like `TypedEditorState` but includes all default node types.\n * You can pass *additional* node types as a generic parameter.\n */\nexport type DefaultTypedEditorState<\n  TAdditionalNodeTypes extends null | SerializedLexicalNode = null,\n> = [TAdditionalNodeTypes] extends null\n  ? TypedEditorState<DefaultNodeTypes>\n  : TypedEditorState<DefaultNodeTypes | NonNullable<TAdditionalNodeTypes>>\n"],"mappings":"AAsIA;;;GAIA","ignoreList":[]}
+{"version":3,"file":"nodeTypes.js","names":[],"sources":["../../src/types/nodeTypes.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nimport type { SerializedQuoteNode } from '../features/blockquote/server/schema.js'\nimport type {\n  SerializedBlockNode,\n  SerializedInlineBlockNode,\n} from '../features/blocks/server/schema.js'\nimport type {\n  SerializedTableCellNode,\n  SerializedTableNode,\n  SerializedTableRowNode,\n} from '../features/experimental_table/server/schema.js'\nimport type { SerializedHeadingNode } from '../features/heading/server/schema.js'\nimport type { SerializedHorizontalRuleNode } from '../features/horizontalRule/server/schema.js'\nimport type { SerializedAutoLinkNode, SerializedLinkNode } from '../features/link/server/schema.js'\nimport type { SerializedListItemNode, SerializedListNode } from '../features/lists/shared/schema.js'\nimport type { SerializedRelationshipNode } from '../features/relationship/server/schema.js'\nimport type { SerializedUploadNode } from '../features/upload/server/schema.js'\n\n// The declarations below must stay byte-for-byte aligned with the TS source\n// strings Payload appends to `payload-types.ts` — twins live in\n// `types/builtInNodes.ts` and per-feature `schema.ts`.\n\n/** @internal Core Lexical types — see @payloadcms/richtext-lexical. */\nexport type LexicalElementFormat = '' | 'center' | 'end' | 'justify' | 'left' | 'right' | 'start'\nexport type LexicalElementDirection = ('ltr' | 'rtl') | null\n\nexport interface SerializedLexicalElementBase<TChildren> {\n  children: TChildren[]\n  direction: LexicalElementDirection\n  format: LexicalElementFormat\n  indent: number\n  textFormat?: number\n  textStyle?: string\n  version: number\n}\n\nexport type LexicalTextMode = 'normal' | 'segmented' | 'token'\n\nexport interface SerializedTextNode {\n  detail: number\n  format: number\n  mode: LexicalTextMode\n  style: string\n  text: string\n  type: 'text'\n  version: number\n}\n\nexport interface SerializedTabNode {\n  detail: number\n  format: number\n  mode: LexicalTextMode\n  style: string\n  text: string\n  type: 'tab'\n  version: number\n}\n\nexport interface SerializedLineBreakNode {\n  type: 'linebreak'\n  version: number\n}\n\nexport interface SerializedParagraphNode<\n  TChildren extends SerializedLexicalNode = SerializedLexicalNode,\n> extends SerializedLexicalElementBase<TChildren> {\n  textFormat: number\n  textStyle: string\n  type: 'paragraph'\n}\n\n/** Shape of a Lexical `richText` field. */\nexport interface LexicalRichText<TNode> {\n  root: {\n    children: TNode[]\n    direction: LexicalElementDirection\n    format: LexicalElementFormat\n    indent: number\n    type: 'root'\n    version: number\n  }\n}\n\nexport type {\n  SerializedAutoLinkNode,\n  SerializedBlockNode,\n  SerializedHeadingNode,\n  SerializedHorizontalRuleNode,\n  SerializedInlineBlockNode,\n  SerializedLinkNode,\n  SerializedListItemNode,\n  SerializedListNode,\n  SerializedQuoteNode,\n  SerializedRelationshipNode,\n  SerializedTableCellNode,\n  SerializedTableNode,\n  SerializedTableRowNode,\n  SerializedUploadNode,\n}\n\n/** `SerializedEditorState` with nodes narrowed by `type`. No type-casting needed. */\nexport type TypedEditorState<TNode extends SerializedLexicalNode = SerializedLexicalNode> =\n  LexicalRichText<TNode>\n\n/**\n * The node union of a generated `richText` field. Pass the field type — e.g.\n * `RichTextNodes<Post['richText']>` — to type an individual node you build for that editor (for\n * example a single block, or a `.map()` of nodes). To build a whole editor state, prefer passing\n * the field type straight to {@link buildEditorState}.\n */\nexport type RichTextNodes<TRichText> =\n  NonNullable<TRichText> extends LexicalRichText<infer TNode> ? TNode : never\n\n/**\n * All node types included by default in a lexical editor. Self-recursive —\n * each element node's `children` is `DefaultNodeTypes` again, no depth limit.\n * To compose your own union including the defaults, see {@link WithDefaultNodes}.\n */\nexport type DefaultNodeTypes =\n  | SerializedAutoLinkNode<DefaultNodeTypes>\n  //| SerializedBlockNode // Not included by default\n  | SerializedHeadingNode<DefaultNodeTypes>\n  | SerializedHorizontalRuleNode\n  | SerializedLineBreakNode\n  | SerializedLinkNode<DefaultNodeTypes>\n  | SerializedListItemNode<DefaultNodeTypes>\n  | SerializedListNode<DefaultNodeTypes>\n  | SerializedParagraphNode<DefaultNodeTypes>\n  | SerializedQuoteNode<DefaultNodeTypes>\n  | SerializedRelationshipNode\n  | SerializedTabNode\n  | SerializedTextNode\n  | SerializedUploadNode\n\n/**\n * The built-in lexical nodes, plus your own - with your nodes threaded into every container's\n * `children`, not just the top level. Pass your custom node(s) as the generic:\n *\n * ```ts\n * type MyNodes = WithDefaultNodes<SerializedBlockNode<MyBlockData>>\n * ```\n *\n * Built by flattening {@link DefaultNodeRegistry} (`Registry[keyof Registry]`); see that interface\n * for why the node set lives in a registry instead of being written as a plain union type.\n */\nexport type WithDefaultNodes<TCustom extends SerializedLexicalNode = never> =\n  DefaultNodeRegistry<TCustom>[keyof DefaultNodeRegistry<TCustom>]\n\n/** @internal Re-types an element node's `children` to the recursive node union. */\ntype WithRecursiveChildren<TNode, TCustom extends SerializedLexicalNode> = {\n  children: WithDefaultNodes<TCustom>[]\n} & Omit<TNode, 'children'>\n\n/**\n * @internal The set of default nodes, generic over the user's custom node(s). {@link WithDefaultNodes}\n * flattens it into the node union with `Registry[keyof Registry]`.\n *\n * Why a registry interface instead of writing the union directly? The union has to be self-referential:\n * every element node's `children` is the same node union (so custom nodes nest inside containers too).\n * A generic *type alias* can't reference itself that way - `type N<T> = SerializedParagraphNode<N<T>> | ...`\n * is a `TS2456` circular reference, because instantiating a type alias resolves its type argument\n * eagerly. An *interface* resolves its members lazily, so the self-reference inside `children: ...[]`\n * is allowed - the recursion is legal precisely because it lives inside this interface. Reusing the\n * real node interfaces (re-typing only `children`) keeps each entry in sync with its node's real shape.\n */\ninterface DefaultNodeRegistry<TCustom extends SerializedLexicalNode> {\n  autolink: WithRecursiveChildren<SerializedAutoLinkNode<SerializedLexicalNode>, TCustom>\n  custom: TCustom\n  heading: WithRecursiveChildren<SerializedHeadingNode<SerializedLexicalNode>, TCustom>\n  horizontalrule: SerializedHorizontalRuleNode\n  linebreak: SerializedLineBreakNode\n  link: WithRecursiveChildren<SerializedLinkNode<SerializedLexicalNode>, TCustom>\n  list: WithRecursiveChildren<SerializedListNode<SerializedLexicalNode>, TCustom>\n  listitem: WithRecursiveChildren<SerializedListItemNode<SerializedLexicalNode>, TCustom>\n  paragraph: WithRecursiveChildren<SerializedParagraphNode<SerializedLexicalNode>, TCustom>\n  quote: WithRecursiveChildren<SerializedQuoteNode<SerializedLexicalNode>, TCustom>\n  relationship: SerializedRelationshipNode\n  tab: SerializedTabNode\n  text: SerializedTextNode\n  upload: SerializedUploadNode\n}\n\n/**\n * Like `TypedEditorState`, but pre-filled with every default node type. Pass extra node types as a\n * generic to add your own; they're threaded into every container's `children` (via\n * {@link WithDefaultNodes}), not just allowed at the top level.\n */\nexport type DefaultTypedEditorState<\n  TAdditionalNodeTypes extends null | SerializedLexicalNode = null,\n> = TypedEditorState<WithDefaultNodes<NonNullable<TAdditionalNodeTypes>>>\n"],"mappings":"AAuLA;;;;GAKA","ignoreList":[]}

package/dist/types/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/types/schema.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,4BAA4B,CAAA;AAC7E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAA;AAExD,eAAO,MAAM,oBAAoB,EAAE,CAAC,IAAI,EAAE;IACxC,YAAY,EAAE,2BAA2B,CAAA;CAC1C,KAAK,sBAAsB,CAAC,YAAY,CAgFxC,CAAA"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/types/schema.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,4BAA4B,CAAA;AAC7E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAA;AAqBxD,eAAO,MAAM,oBAAoB,EAAE,CAAC,IAAI,EAAE;IACxC,YAAY,EAAE,2BAA2B,CAAA;CAC1C,KAAK,sBAAsB,CAAC,YAAY,CA+FxC,CAAA"}

package/dist/types/schema.js

@@ -1,4 +1,14 @@
-import { withNullableJSONSchemaType } from 'payload';
+import { createHash } from 'crypto';
+import { CORE_LEXICAL_TYPE_STRING, lineBreakNodeJSONSchema, paragraphNodeJSONSchema, rootNodeJSONSchema, tabNodeJSONSchema, textNodeJSONSchema } from './builtInNodes.js';
+import { elementNodeSchema } from './jsonSchemaHelpers.js';
+/**
+ * The node-union name is a hash of its own schema (so identical editors dedupe).
+ * Since the schema references the union name, we use a placeholder during build
+ * and substitute the real hash once everything's assembled. Features can derive
+ * sibling names (e.g. `LexicalLinkFields_<hash>`) using the bare hash placeholder.
+ */
+const NODE_UNION_HASH_PLACEHOLDER = '__LEXICAL_NODE_UNION_HASH__';
+const NODE_UNION_NAME_PLACEHOLDER = `LexicalNodes_${NODE_UNION_HASH_PLACEHOLDER}`;
 export const getFieldToJSONSchema = ({
   editorConfig
 }) => {
@@ -8,74 +18,73 @@ export const getFieldToJSONSchema = ({
     field,
     i18n,
     interfaceNameDefinitions,
-    isRequired
+    typeStringDefinitions,
+    variant = 'output'
   }) => {
-    let jsonSchema = {
-      // This schema matches the SerializedEditorState type so far, that it's possible to cast SerializedEditorState to this schema without any errors.
-      // In the future, we should
-      // 1) allow recursive children
-      // 2) Pass in all the different types for every node added to the editorconfig. This can be done with refs in the schema.
-      type: withNullableJSONSchemaType('object', isRequired),
-      properties: {
-        root: {
-          type: 'object',
-          additionalProperties: false,
-          properties: {
-            type: {
-              type: 'string'
-            },
-            children: {
-              type: 'array',
-              items: {
-                type: 'object',
-                additionalProperties: true,
-                properties: {
-                  type: {
-                    type: 'string',
-                    tsType: 'any'
-                  },
-                  version: {
-                    type: 'integer'
-                  }
-                },
-                required: ['type', 'version']
-              }
-            },
-            direction: {
-              oneOf: [{
-                enum: ['ltr', 'rtl']
-              }, {
-                type: 'null'
-              }]
-            },
-            format: {
-              type: 'string',
-              enum: ['left', 'start', 'center', 'right', 'end', 'justify', '']
-            },
-            indent: {
-              type: 'integer'
-            },
-            version: {
-              type: 'integer'
-            }
-          },
-          required: ['children', 'direction', 'format', 'indent', 'type', 'version']
+    // Step 1: build the schema for every node type allowed in this field.
+    typeStringDefinitions.add(CORE_LEXICAL_TYPE_STRING);
+    const nodeJsonSchemaArgs = {
+      collectionIDFieldTypes,
+      config,
+      // Each element node needs its children typed using the union node type recursively
+      elementNodeSchema: args => elementNodeSchema({
+        ...args,
+        nodeUnionRef: {
+          $ref: `#/$defs/${NODE_UNION_NAME_PLACEHOLDER}`
         }
-      },
-      required: ['root']
+      }),
+      field,
+      i18n,
+      interfaceNameDefinitions,
+      nodeUnionName: NODE_UNION_NAME_PLACEHOLDER,
+      typeStringDefinitions,
+      variant
     };
-    for (const modifyJSONSchema of editorConfig.features.generatedTypes.modifyJSONSchemas) {
-      jsonSchema = modifyJSONSchema({
-        collectionIDFieldTypes,
-        config,
-        currentSchema: jsonSchema,
-        field,
-        i18n,
-        interfaceNameDefinitions,
-        isRequired
-      });
+    const nodeSchemas = [
+    // Add built-in node schemas
+    textNodeJSONSchema(nodeJsonSchemaArgs), tabNodeJSONSchema(nodeJsonSchemaArgs), lineBreakNodeJSONSchema(nodeJsonSchemaArgs), paragraphNodeJSONSchema(nodeJsonSchemaArgs),
+    // Add feature node schemas
+    ...editorConfig.features.nodes.filter(node => node.jsonSchema).map(node => node.jsonSchema(nodeJsonSchemaArgs))];
+    const rootSchemaWithPlaceholder = rootNodeJSONSchema(nodeJsonSchemaArgs);
+    // Step 2: get the final node union name, then replace the placeholder
+    // in both the union members and the root node.
+    //
+    // See JSDocs for `NODE_UNION_NAME_PLACEHOLDER` for why we use a placeholder and hashing.
+    const nodeUnionJson = JSON.stringify({
+      oneOf: nodeSchemas
+    });
+    // Features can register per-editor definitions during node-schema build (e.g. a link node's
+    // custom `LexicalLinkFields_<hash>`), keyed by the not-yet-resolved hash placeholder. The node
+    // union only `$ref`s them, so their content isn't in `nodeUnionJson` - two editors with the same
+    // nodes but different feature config (e.g. different custom link fields) would otherwise hash
+    // identically and overwrite each other's definition. To avoid that, include that content into the hash too.
+    const pendingDefinitions = [...interfaceNameDefinitions.entries()].filter(([key]) => key.includes(NODE_UNION_HASH_PLACEHOLDER)).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+    const hashInput = pendingDefinitions.length ? JSON.stringify({
+      definitions: pendingDefinitions,
+      oneOf: nodeSchemas
+    }) : nodeUnionJson;
+    const hash = createHash('sha256').update(hashInput).digest('hex').slice(0, 8).toUpperCase();
+    // Distinguish an input node union from an output one with an `_Input` suffix - unless an
+    // identical output union already exists (a relationship-free editor whose input == output), in
+    // which case share it. The content hash means differing unions split and identical ones merge.
+    const sharesOutputUnion = variant === 'input' && interfaceNameDefinitions.has(`LexicalNodes_${hash}`);
+    const resolvedHash = variant === 'input' && !sharesOutputUnion ? `${hash}_Input` : hash;
+    const nodeUnionName = `LexicalNodes_${resolvedHash}`;
+    // Replacing the hash resolves the union name and any feature-derived
+    // sibling names in one pass.
+    const replacePlaceholder = schemaString => JSON.parse(schemaString.replaceAll(NODE_UNION_HASH_PLACEHOLDER, resolvedHash));
+    // Resolve placeholders left in feature-registered definitions so Map keys
+    // and `$ref` targets line up.
+    for (const [oldKey, schema] of [...interfaceNameDefinitions.entries()]) {
+      const newKey = oldKey.replaceAll(NODE_UNION_HASH_PLACEHOLDER, resolvedHash);
+      const resolvedSchema = replacePlaceholder(JSON.stringify(schema));
+      if (newKey !== oldKey) {
+        interfaceNameDefinitions.delete(oldKey);
+      }
+      interfaceNameDefinitions.set(newKey, resolvedSchema);
     }
-    return jsonSchema;
+    interfaceNameDefinitions.set(nodeUnionName, replacePlaceholder(nodeUnionJson));
+    return replacePlaceholder(JSON.stringify(rootSchemaWithPlaceholder));
   };
 };
 //# sourceMappingURL=schema.js.map

package/dist/types/schema.js.map

@@ -1 +1 @@
-{"version":3,"file":"schema.js","names":["withNullableJSONSchemaType","getFieldToJSONSchema","editorConfig","collectionIDFieldTypes","config","field","i18n","interfaceNameDefinitions","isRequired","jsonSchema","type","properties","root","additionalProperties","children","items","tsType","version","required","direction","oneOf","enum","format","indent","modifyJSONSchema","features","generatedTypes","modifyJSONSchemas","currentSchema"],"sources":["../../src/types/schema.ts"],"sourcesContent":["import type { JSONSchema4 } from 'json-schema'\n\nimport { withNullableJSONSchemaType } from 'payload'\n\nimport type { SanitizedServerEditorConfig } from '../lexical/config/types.js'\nimport type { LexicalRichTextAdapter } from './index.js'\n\nexport const getFieldToJSONSchema: (args: {\n  editorConfig: SanitizedServerEditorConfig\n}) => LexicalRichTextAdapter['jsonSchema'] = ({ editorConfig }) => {\n  return ({\n    collectionIDFieldTypes,\n    config,\n    field,\n    i18n,\n    interfaceNameDefinitions,\n    isRequired,\n  }) => {\n    let jsonSchema: JSONSchema4 = {\n      // This schema matches the SerializedEditorState type so far, that it's possible to cast SerializedEditorState to this schema without any errors.\n      // In the future, we should\n      // 1) allow recursive children\n      // 2) Pass in all the different types for every node added to the editorconfig. This can be done with refs in the schema.\n      type: withNullableJSONSchemaType('object', isRequired),\n      properties: {\n        root: {\n          type: 'object',\n          additionalProperties: false,\n          properties: {\n            type: {\n              type: 'string',\n            },\n            children: {\n              type: 'array',\n              items: {\n                type: 'object',\n                additionalProperties: true,\n                properties: {\n                  type: {\n                    type: 'string',\n                    tsType: 'any',\n                  },\n                  version: {\n                    type: 'integer',\n                  },\n                },\n                required: ['type', 'version'],\n              },\n            },\n            direction: {\n              oneOf: [\n                {\n                  enum: ['ltr', 'rtl'],\n                },\n                {\n                  type: 'null',\n                },\n              ],\n            },\n            format: {\n              type: 'string',\n              enum: ['left', 'start', 'center', 'right', 'end', 'justify', ''], // ElementFormatType, since the root node is an element\n            },\n            indent: {\n              type: 'integer',\n            },\n            version: {\n              type: 'integer',\n            },\n          },\n          required: ['children', 'direction', 'format', 'indent', 'type', 'version'],\n        },\n      },\n      required: ['root'],\n    }\n    for (const modifyJSONSchema of editorConfig.features.generatedTypes.modifyJSONSchemas) {\n      jsonSchema = modifyJSONSchema({\n        collectionIDFieldTypes,\n        config,\n        currentSchema: jsonSchema,\n        field,\n        i18n,\n        interfaceNameDefinitions,\n        isRequired,\n      })\n    }\n\n    return jsonSchema\n  }\n}\n"],"mappings":"AAEA,SAASA,0BAA0B,QAAQ;AAK3C,OAAO,MAAMC,oBAAA,GAEgCA,CAAC;EAAEC;AAAY,CAAE;EAC5D,OAAO,CAAC;IACNC,sBAAsB;IACtBC,MAAM;IACNC,KAAK;IACLC,IAAI;IACJC,wBAAwB;IACxBC;EAAU,CACX;IACC,IAAIC,UAAA,GAA0B;MAC5B;MACA;MACA;MACA;MACAC,IAAA,EAAMV,0BAAA,CAA2B,UAAUQ,UAAA;MAC3CG,UAAA,EAAY;QACVC,IAAA,EAAM;UACJF,IAAA,EAAM;UACNG,oBAAA,EAAsB;UACtBF,UAAA,EAAY;YACVD,IAAA,EAAM;cACJA,IAAA,EAAM;YACR;YACAI,QAAA,EAAU;cACRJ,IAAA,EAAM;cACNK,KAAA,EAAO;gBACLL,IAAA,EAAM;gBACNG,oBAAA,EAAsB;gBACtBF,UAAA,EAAY;kBACVD,IAAA,EAAM;oBACJA,IAAA,EAAM;oBACNM,MAAA,EAAQ;kBACV;kBACAC,OAAA,EAAS;oBACPP,IAAA,EAAM;kBACR;gBACF;gBACAQ,QAAA,EAAU,CAAC,QAAQ;cACrB;YACF;YACAC,SAAA,EAAW;cACTC,KAAA,EAAO,CACL;gBACEC,IAAA,EAAM,CAAC,OAAO;cAChB,GACA;gBACEX,IAAA,EAAM;cACR;YAEJ;YACAY,MAAA,EAAQ;cACNZ,IAAA,EAAM;cACNW,IAAA,EAAM,CAAC,QAAQ,SAAS,UAAU,SAAS,OAAO,WAAW;YAC/D;YACAE,MAAA,EAAQ;cACNb,IAAA,EAAM;YACR;YACAO,OAAA,EAAS;cACPP,IAAA,EAAM;YACR;UACF;UACAQ,QAAA,EAAU,CAAC,YAAY,aAAa,UAAU,UAAU,QAAQ;QAClE;MACF;MACAA,QAAA,EAAU,CAAC;IACb;IACA,KAAK,MAAMM,gBAAA,IAAoBtB,YAAA,CAAauB,QAAQ,CAACC,cAAc,CAACC,iBAAiB,EAAE;MACrFlB,UAAA,GAAae,gBAAA,CAAiB;QAC5BrB,sBAAA;QACAC,MAAA;QACAwB,aAAA,EAAenB,UAAA;QACfJ,KAAA;QACAC,IAAA;QACAC,wBAAA;QACAC;MACF;IACF;IAEA,OAAOC,UAAA;EACT;AACF","ignoreList":[]}
+{"version":3,"file":"schema.js","names":["createHash","CORE_LEXICAL_TYPE_STRING","lineBreakNodeJSONSchema","paragraphNodeJSONSchema","rootNodeJSONSchema","tabNodeJSONSchema","textNodeJSONSchema","elementNodeSchema","NODE_UNION_HASH_PLACEHOLDER","NODE_UNION_NAME_PLACEHOLDER","getFieldToJSONSchema","editorConfig","collectionIDFieldTypes","config","field","i18n","interfaceNameDefinitions","typeStringDefinitions","variant","add","nodeJsonSchemaArgs","args","nodeUnionRef","$ref","nodeUnionName","nodeSchemas","features","nodes","filter","node","jsonSchema","map","rootSchemaWithPlaceholder","nodeUnionJson","JSON","stringify","oneOf","pendingDefinitions","entries","key","includes","sort","a","b","hashInput","length","definitions","hash","update","digest","slice","toUpperCase","sharesOutputUnion","has","resolvedHash","replacePlaceholder","schemaString","parse","replaceAll","oldKey","schema","newKey","resolvedSchema","delete","set"],"sources":["../../src/types/schema.ts"],"sourcesContent":["import type { JSONSchema4 } from 'json-schema'\n\nimport { createHash } from 'crypto'\n\nimport type { JSONSchemaArgs } from '../features/typesServer.js'\nimport type { SanitizedServerEditorConfig } from '../lexical/config/types.js'\nimport type { LexicalRichTextAdapter } from './index.js'\n\nimport {\n  CORE_LEXICAL_TYPE_STRING,\n  lineBreakNodeJSONSchema,\n  paragraphNodeJSONSchema,\n  rootNodeJSONSchema,\n  tabNodeJSONSchema,\n  textNodeJSONSchema,\n} from './builtInNodes.js'\nimport { elementNodeSchema } from './jsonSchemaHelpers.js'\n\n/**\n * The node-union name is a hash of its own schema (so identical editors dedupe).\n * Since the schema references the union name, we use a placeholder during build\n * and substitute the real hash once everything's assembled. Features can derive\n * sibling names (e.g. `LexicalLinkFields_<hash>`) using the bare hash placeholder.\n */\nconst NODE_UNION_HASH_PLACEHOLDER = '__LEXICAL_NODE_UNION_HASH__'\nconst NODE_UNION_NAME_PLACEHOLDER = `LexicalNodes_${NODE_UNION_HASH_PLACEHOLDER}`\n\nexport const getFieldToJSONSchema: (args: {\n  editorConfig: SanitizedServerEditorConfig\n}) => LexicalRichTextAdapter['jsonSchema'] = ({ editorConfig }) => {\n  return ({\n    collectionIDFieldTypes,\n    config,\n    field,\n    i18n,\n    interfaceNameDefinitions,\n    typeStringDefinitions,\n    variant = 'output',\n  }) => {\n    // Step 1: build the schema for every node type allowed in this field.\n\n    typeStringDefinitions.add(CORE_LEXICAL_TYPE_STRING)\n\n    const nodeJsonSchemaArgs: JSONSchemaArgs = {\n      collectionIDFieldTypes,\n      config,\n      // Each element node needs its children typed using the union node type recursively\n      elementNodeSchema: (args) =>\n        elementNodeSchema({\n          ...args,\n          nodeUnionRef: {\n            $ref: `#/$defs/${NODE_UNION_NAME_PLACEHOLDER}`,\n          },\n        }),\n      field,\n      i18n,\n      interfaceNameDefinitions,\n      nodeUnionName: NODE_UNION_NAME_PLACEHOLDER,\n      typeStringDefinitions,\n      variant,\n    }\n\n    const nodeSchemas: JSONSchema4[] = [\n      // Add built-in node schemas\n      textNodeJSONSchema(nodeJsonSchemaArgs),\n      tabNodeJSONSchema(nodeJsonSchemaArgs),\n      lineBreakNodeJSONSchema(nodeJsonSchemaArgs),\n      paragraphNodeJSONSchema(nodeJsonSchemaArgs),\n      // Add feature node schemas\n      ...editorConfig.features.nodes\n        .filter((node) => node.jsonSchema)\n        .map((node) => node.jsonSchema!(nodeJsonSchemaArgs)),\n    ]\n    const rootSchemaWithPlaceholder = rootNodeJSONSchema(nodeJsonSchemaArgs)\n\n    // Step 2: get the final node union name, then replace the placeholder\n    // in both the union members and the root node.\n    //\n    // See JSDocs for `NODE_UNION_NAME_PLACEHOLDER` for why we use a placeholder and hashing.\n    const nodeUnionJson = JSON.stringify({ oneOf: nodeSchemas })\n\n    // Features can register per-editor definitions during node-schema build (e.g. a link node's\n    // custom `LexicalLinkFields_<hash>`), keyed by the not-yet-resolved hash placeholder. The node\n    // union only `$ref`s them, so their content isn't in `nodeUnionJson` - two editors with the same\n    // nodes but different feature config (e.g. different custom link fields) would otherwise hash\n    // identically and overwrite each other's definition. To avoid that, include that content into the hash too.\n    const pendingDefinitions = [...interfaceNameDefinitions.entries()]\n      .filter(([key]) => key.includes(NODE_UNION_HASH_PLACEHOLDER))\n      .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))\n\n    const hashInput = pendingDefinitions.length\n      ? JSON.stringify({ definitions: pendingDefinitions, oneOf: nodeSchemas })\n      : nodeUnionJson\n\n    const hash = createHash('sha256').update(hashInput).digest('hex').slice(0, 8).toUpperCase()\n\n    // Distinguish an input node union from an output one with an `_Input` suffix - unless an\n    // identical output union already exists (a relationship-free editor whose input == output), in\n    // which case share it. The content hash means differing unions split and identical ones merge.\n    const sharesOutputUnion =\n      variant === 'input' && interfaceNameDefinitions.has(`LexicalNodes_${hash}`)\n    const resolvedHash = variant === 'input' && !sharesOutputUnion ? `${hash}_Input` : hash\n    const nodeUnionName = `LexicalNodes_${resolvedHash}`\n\n    // Replacing the hash resolves the union name and any feature-derived\n    // sibling names in one pass.\n    const replacePlaceholder = (schemaString: string) =>\n      JSON.parse(schemaString.replaceAll(NODE_UNION_HASH_PLACEHOLDER, resolvedHash)) as JSONSchema4\n\n    // Resolve placeholders left in feature-registered definitions so Map keys\n    // and `$ref` targets line up.\n    for (const [oldKey, schema] of [...interfaceNameDefinitions.entries()]) {\n      const newKey = oldKey.replaceAll(NODE_UNION_HASH_PLACEHOLDER, resolvedHash)\n      const resolvedSchema = replacePlaceholder(JSON.stringify(schema))\n      if (newKey !== oldKey) {\n        interfaceNameDefinitions.delete(oldKey)\n      }\n      interfaceNameDefinitions.set(newKey, resolvedSchema)\n    }\n\n    interfaceNameDefinitions.set(nodeUnionName, replacePlaceholder(nodeUnionJson))\n\n    return replacePlaceholder(JSON.stringify(rootSchemaWithPlaceholder))\n  }\n}\n"],"mappings":"AAEA,SAASA,UAAU,QAAQ;AAM3B,SACEC,wBAAwB,EACxBC,uBAAuB,EACvBC,uBAAuB,EACvBC,kBAAkB,EAClBC,iBAAiB,EACjBC,kBAAkB,QACb;AACP,SAASC,iBAAiB,QAAQ;AAElC;;;;;;AAMA,MAAMC,2BAAA,GAA8B;AACpC,MAAMC,2BAAA,GAA8B,gBAAgBD,2BAAA,EAA6B;AAEjF,OAAO,MAAME,oBAAA,GAEgCA,CAAC;EAAEC;AAAY,CAAE;EAC5D,OAAO,CAAC;IACNC,sBAAsB;IACtBC,MAAM;IACNC,KAAK;IACLC,IAAI;IACJC,wBAAwB;IACxBC,qBAAqB;IACrBC,OAAA,GAAU;EAAQ,CACnB;IACC;IAEAD,qBAAA,CAAsBE,GAAG,CAAClB,wBAAA;IAE1B,MAAMmB,kBAAA,GAAqC;MACzCR,sBAAA;MACAC,MAAA;MACA;MACAN,iBAAA,EAAoBc,IAAA,IAClBd,iBAAA,CAAkB;QAChB,GAAGc,IAAI;QACPC,YAAA,EAAc;UACZC,IAAA,EAAM,WAAWd,2BAAA;QACnB;MACF;MACFK,KAAA;MACAC,IAAA;MACAC,wBAAA;MACAQ,aAAA,EAAef,2BAAA;MACfQ,qBAAA;MACAC;IACF;IAEA,MAAMO,WAAA,GAA6B;IACjC;IACAnB,kBAAA,CAAmBc,kBAAA,GACnBf,iBAAA,CAAkBe,kBAAA,GAClBlB,uBAAA,CAAwBkB,kBAAA,GACxBjB,uBAAA,CAAwBiB,kBAAA;IACxB;OACGT,YAAA,CAAae,QAAQ,CAACC,KAAK,CAC3BC,MAAM,CAAEC,IAAA,IAASA,IAAA,CAAKC,UAAU,EAChCC,GAAG,CAAEF,IAAA,IAASA,IAAA,CAAKC,UAAU,CAAEV,kBAAA,GACnC;IACD,MAAMY,yBAAA,GAA4B5B,kBAAA,CAAmBgB,kBAAA;IAErD;IACA;IACA;IACA;IACA,MAAMa,aAAA,GAAgBC,IAAA,CAAKC,SAAS,CAAC;MAAEC,KAAA,EAAOX;IAAY;IAE1D;IACA;IACA;IACA;IACA;IACA,MAAMY,kBAAA,GAAqB,C,GAAIrB,wBAAA,CAAyBsB,OAAO,GAAG,CAC/DV,MAAM,CAAC,CAAC,CAACW,GAAA,CAAI,KAAKA,GAAA,CAAIC,QAAQ,CAAChC,2BAAA,GAC/BiC,IAAI,CAAC,CAAC,CAACC,CAAA,CAAE,EAAE,CAACC,CAAA,CAAE,KAAMD,CAAA,GAAIC,CAAA,GAAI,CAAC,IAAID,CAAA,GAAIC,CAAA,GAAI,IAAI;IAEhD,MAAMC,SAAA,GAAYP,kBAAA,CAAmBQ,MAAM,GACvCX,IAAA,CAAKC,SAAS,CAAC;MAAEW,WAAA,EAAaT,kBAAA;MAAoBD,KAAA,EAAOX;IAAY,KACrEQ,aAAA;IAEJ,MAAMc,IAAA,GAAO/C,UAAA,CAAW,UAAUgD,MAAM,CAACJ,SAAA,EAAWK,MAAM,CAAC,OAAOC,KAAK,CAAC,GAAG,GAAGC,WAAW;IAEzF;IACA;IACA;IACA,MAAMC,iBAAA,GACJlC,OAAA,KAAY,WAAWF,wBAAA,CAAyBqC,GAAG,CAAC,gBAAgBN,IAAA,EAAM;IAC5E,MAAMO,YAAA,GAAepC,OAAA,KAAY,WAAW,CAACkC,iBAAA,GAAoB,GAAGL,IAAA,QAAY,GAAGA,IAAA;IACnF,MAAMvB,aAAA,GAAgB,gBAAgB8B,YAAA,EAAc;IAEpD;IACA;IACA,MAAMC,kBAAA,GAAsBC,YAAA,IAC1BtB,IAAA,CAAKuB,KAAK,CAACD,YAAA,CAAaE,UAAU,CAAClD,2BAAA,EAA6B8C,YAAA;IAElE;IACA;IACA,KAAK,MAAM,CAACK,MAAA,EAAQC,MAAA,CAAO,IAAI,C,GAAI5C,wBAAA,CAAyBsB,OAAO,GAAG,EAAE;MACtE,MAAMuB,MAAA,GAASF,MAAA,CAAOD,UAAU,CAAClD,2BAAA,EAA6B8C,YAAA;MAC9D,MAAMQ,cAAA,GAAiBP,kBAAA,CAAmBrB,IAAA,CAAKC,SAAS,CAACyB,MAAA;MACzD,IAAIC,MAAA,KAAWF,MAAA,EAAQ;QACrB3C,wBAAA,CAAyB+C,MAAM,CAACJ,MAAA;MAClC;MACA3C,wBAAA,CAAyBgD,GAAG,CAACH,MAAA,EAAQC,cAAA;IACvC;IAEA9C,wBAAA,CAAyBgD,GAAG,CAACxC,aAAA,EAAe+B,kBAAA,CAAmBtB,aAAA;IAE/D,OAAOsB,kBAAA,CAAmBrB,IAAA,CAAKC,SAAS,CAACH,yBAAA;EAC3C;AACF","ignoreList":[]}

package/dist/utilities/applyBaseFilterToFields.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"applyBaseFilterToFields.d.ts","sourceRoot":"","sources":["../../src/utilities/applyBaseFilterToFields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAS,KAAK,EAAE,eAAe,EAAa,MAAM,SAAS,CAAA;AAIvE;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,eAAe,GAAG,KAAK,EAAE,CAiGzF"}
+{"version":3,"file":"applyBaseFilterToFields.d.ts","sourceRoot":"","sources":["../../src/utilities/applyBaseFilterToFields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,eAAe,EAAQ,MAAM,SAAS,CAAA;AAI3D;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,eAAe,GAAG,KAAK,EAAE,CAgGzF"}

package/dist/utilities/applyBaseFilterToFields.js

@@ -77,10 +77,9 @@ export function applyBaseFilterToFields(fields, config) {
     }
     // Handle blocks
     if (field.type === 'blocks') {
-      const blocks = field.blockReferences ?? field.blocks ?? [];
       return {
         ...field,
-        blocks: blocks.map(block => {
+        blocks: field.blocks.map(block => {
           if (typeof block === 'string') {
             return block;
           }