@payloadcms/richtext-lexical 4.0.0-canary.0 → 4.0.0-internal.183b315

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":"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"}
+{"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,CAsFxC,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,66 @@ export const getFieldToJSONSchema = ({
     field,
     i18n,
     interfaceNameDefinitions,
-    isRequired
+    typeStringDefinitions
   }) => {
-    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
     };
-    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();
+    const nodeUnionName = `LexicalNodes_${hash}`;
+    // 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, hash));
+    // 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, hash);
+      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","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","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  }) => {\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    }\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    const nodeUnionName = `LexicalNodes_${hash}`\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, hash)) 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, hash)\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":"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","ignoreList":[]}

package/dist/utilities/buildEditorState.d.ts

@@ -1,5 +1,10 @@
 import type { SerializedLexicalNode } from 'lexical';
 import type { DefaultNodeTypes, TypedEditorState } from '../types/nodeTypes.js';
+/**
+ * The node union to build with. Accepts either a node union directly (e.g. `DefaultNodeTypes`) or a
+ * generated `richText` field type (e.g. `Post['richText']`), whose nodes are extracted automatically.
+ */
+type BuildNodes<T> = NonNullable<T> extends TypedEditorState<infer TNode extends SerializedLexicalNode> ? TNode : Extract<NonNullable<T>, SerializedLexicalNode>;
 /**
  * Helper to build lexical editor state JSON from text and/or nodes.
  *
@@ -36,11 +41,19 @@ import type { DefaultNodeTypes, TypedEditorState } from '../types/nodeTypes.js';
  *   ],
  * })
  * ```
+ *
+ * @example
+ *
+ * passing a generated `richText` field type — the result is exactly that field's type:
+ *
+ * ```ts
+ * post.richText = buildEditorState<Post['richText']>({ text: 'Hello world' })
+ * ```
  */
-export declare function buildEditorState<T extends SerializedLexicalNode>({ nodes, text, }: {
-    nodes?: TypedEditorState<T>['root']['children'];
+export declare function buildEditorState<T extends null | SerializedLexicalNode | TypedEditorState<SerializedLexicalNode> | undefined = DefaultNodeTypes>({ nodes, text, }: {
+    nodes?: TypedEditorState<BuildNodes<T>>['root']['children'];
     text?: string;
-}): TypedEditorState<T>;
+}): TypedEditorState<BuildNodes<T>>;
 /**
  *
  * Alias for `buildEditorState<DefaultNodeTypes>`
@@ -49,4 +62,5 @@ export declare function buildEditorState<T extends SerializedLexicalNode>({ node
  * @internal
  */
 export declare const buildDefaultEditorState: typeof buildEditorState<DefaultNodeTypes>;
+export {};
 //# sourceMappingURL=buildEditorState.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"buildEditorState.d.ts","sourceRoot":"","sources":["../../src/utilities/buildEditorState.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAEpD,OAAO,KAAK,EACV,gBAAgB,EAEhB,gBAAgB,EACjB,MAAM,uBAAuB,CAAA;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,qBAAqB,EAAE,EAChE,KAAK,EACL,IAAI,GACL,EAAE;IACD,KAAK,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,UAAU,CAAC,CAAA;IAC/C,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAuDtB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,EAAE,OAAO,gBAAgB,CAAC,gBAAgB,CAC1C,CAAA"}
+{"version":3,"file":"buildEditorState.d.ts","sourceRoot":"","sources":["../../src/utilities/buildEditorState.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAEpD,OAAO,KAAK,EACV,gBAAgB,EAEhB,gBAAgB,EACjB,MAAM,uBAAuB,CAAA;AAE9B;;;GAGG;AACH,KAAK,UAAU,CAAC,CAAC,IACf,WAAW,CAAC,CAAC,CAAC,SAAS,gBAAgB,CAAC,MAAM,KAAK,SAAS,qBAAqB,CAAC,GAC9E,KAAK,GACL,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,qBAAqB,CAAC,CAAA;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,gBAAgB,CAC9B,CAAC,SACG,IAAI,GACJ,qBAAqB,GACrB,gBAAgB,CAAC,qBAAqB,CAAC,GACvC,SAAS,GAAG,gBAAgB,EAChC,EACA,KAAK,EACL,IAAI,GACL,EAAE;IACD,KAAK,CAAC,EAAE,gBAAgB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,UAAU,CAAC,CAAA;IAC3D,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,GAAG,gBAAgB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAuDlC;AAED;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,EAAE,OAAO,gBAAgB,CAAC,gBAAgB,CAC1C,CAAA"}

package/dist/utilities/buildEditorState.js

@@ -34,6 +34,14 @@
  *   ],
  * })
  * ```
+ *
+ * @example
+ *
+ * passing a generated `richText` field type — the result is exactly that field's type:
+ *
+ * ```ts
+ * post.richText = buildEditorState<Post['richText']>({ text: 'Hello world' })
+ * ```
  */export function buildEditorState({
   nodes,
   text

package/dist/utilities/buildEditorState.js.map

@@ -1 +1 @@
-{"version":3,"file":"buildEditorState.js","names":["buildEditorState","nodes","text","editorJSON","root","type","children","direction","format","indent","version","push","detail","mode","style","textFormat","textStyle","length","buildDefaultEditorState"],"sources":["../../src/utilities/buildEditorState.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nimport type {\n  DefaultNodeTypes,\n  DefaultTypedEditorState,\n  TypedEditorState,\n} from '../types/nodeTypes.js'\n\n/**\n * Helper to build lexical editor state JSON from text and/or nodes.\n *\n * @param nodes - The nodes to include in the editor state. If you pass the `text` argument, this will append your nodes after the first paragraph node.\n * @param text - The text content to include in the editor state. This will create a paragraph node with a text node for you and set that as the first node.\n * @returns The constructed editor state JSON.\n *\n * @example\n *\n * just passing text:\n *\n * ```ts\n * const editorState = buildEditorState<DefaultNodeTypes>({ text: 'Hello world' }) // result typed as DefaultTypedEditorState\n * ```\n *\n * @example\n *\n * passing nodes:\n *\n * ```ts\n * const editorState = // result typed as TypedEditorState<DefaultNodeTypes | SerializedBlockNode> (or TypedEditorState<SerializedBlockNode>)\n * buildEditorState<DefaultNodeTypes | SerializedBlockNode>({ // or just buildEditorState<SerializedBlockNode> if you *only* want to allow block nodes\n *   nodes: [\n *     {\n *       type: 'block',\n *        fields: {\n *          id: 'id',\n *          blockName: 'Cool block',\n *          blockType: 'myBlock',\n *        },\n *        format: 'left',\n *        version: 1,\n *      }\n *   ],\n * })\n * ```\n */\nexport function buildEditorState<T extends SerializedLexicalNode>({\n  nodes,\n  text,\n}: {\n  nodes?: TypedEditorState<T>['root']['children']\n  text?: string\n}): TypedEditorState<T> {\n  const editorJSON: DefaultTypedEditorState = {\n    root: {\n      type: 'root',\n      children: [],\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      version: 1,\n    },\n  }\n\n  if (text) {\n    editorJSON.root.children.push({\n      type: 'paragraph',\n      children: [\n        {\n          type: 'text',\n          detail: 0,\n          format: 0,\n          mode: 'normal',\n          style: '',\n          text,\n          version: 1,\n        },\n      ],\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      textFormat: 0,\n      textStyle: '',\n      version: 1,\n    })\n  }\n\n  if (nodes?.length) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    editorJSON.root.children.push(...(nodes as any))\n  }\n\n  if (editorJSON.root.children.length === 0) {\n    // An error will be thrown if the root node has no children\n    editorJSON.root.children.push({\n      type: 'paragraph',\n      children: [],\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      textFormat: 0,\n      textStyle: '',\n      version: 1,\n    })\n  }\n\n  return editorJSON as TypedEditorState<T>\n}\n\n/**\n *\n * Alias for `buildEditorState<DefaultNodeTypes>`\n *\n * @experimental this API may change or be removed in a minor release\n * @internal\n */\nexport const buildDefaultEditorState: typeof buildEditorState<DefaultNodeTypes> =\n  buildEditorState<DefaultNodeTypes>\n"],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCA,OAAO,SAASA,iBAAkD;EAChEC,KAAK;EACLC;AAAI,CAIL;EACC,MAAMC,UAAA,GAAsC;IAC1CC,IAAA,EAAM;MACJC,IAAA,EAAM;MACNC,QAAA,EAAU,EAAE;MACZC,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRC,OAAA,EAAS;IACX;EACF;EAEA,IAAIR,IAAA,EAAM;IACRC,UAAA,CAAWC,IAAI,CAACE,QAAQ,CAACK,IAAI,CAAC;MAC5BN,IAAA,EAAM;MACNC,QAAA,EAAU,CACR;QACED,IAAA,EAAM;QACNO,MAAA,EAAQ;QACRJ,MAAA,EAAQ;QACRK,IAAA,EAAM;QACNC,KAAA,EAAO;QACPZ,IAAA;QACAQ,OAAA,EAAS;MACX,EACD;MACDH,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRM,UAAA,EAAY;MACZC,SAAA,EAAW;MACXN,OAAA,EAAS;IACX;EACF;EAEA,IAAIT,KAAA,EAAOgB,MAAA,EAAQ;IACjB;IACAd,UAAA,CAAWC,IAAI,CAACE,QAAQ,CAACK,IAAI,IAAKV,KAAA;EACpC;EAEA,IAAIE,UAAA,CAAWC,IAAI,CAACE,QAAQ,CAACW,MAAM,KAAK,GAAG;IACzC;IACAd,UAAA,CAAWC,IAAI,CAACE,QAAQ,CAACK,IAAI,CAAC;MAC5BN,IAAA,EAAM;MACNC,QAAA,EAAU,EAAE;MACZC,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRM,UAAA,EAAY;MACZC,SAAA,EAAW;MACXN,OAAA,EAAS;IACX;EACF;EAEA,OAAOP,UAAA;AACT;AAEA;;;;;;;AAOA,OAAO,MAAMe,uBAAA,GACXlB,gBAAA","ignoreList":[]}
+{"version":3,"file":"buildEditorState.js","names":["buildEditorState","nodes","text","editorJSON","root","type","children","direction","format","indent","version","push","detail","mode","style","textFormat","textStyle","length","buildDefaultEditorState"],"sources":["../../src/utilities/buildEditorState.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nimport type {\n  DefaultNodeTypes,\n  DefaultTypedEditorState,\n  TypedEditorState,\n} from '../types/nodeTypes.js'\n\n/**\n * The node union to build with. Accepts either a node union directly (e.g. `DefaultNodeTypes`) or a\n * generated `richText` field type (e.g. `Post['richText']`), whose nodes are extracted automatically.\n */\ntype BuildNodes<T> =\n  NonNullable<T> extends TypedEditorState<infer TNode extends SerializedLexicalNode>\n    ? TNode\n    : Extract<NonNullable<T>, SerializedLexicalNode>\n\n/**\n * Helper to build lexical editor state JSON from text and/or nodes.\n *\n * @param nodes - The nodes to include in the editor state. If you pass the `text` argument, this will append your nodes after the first paragraph node.\n * @param text - The text content to include in the editor state. This will create a paragraph node with a text node for you and set that as the first node.\n * @returns The constructed editor state JSON.\n *\n * @example\n *\n * just passing text:\n *\n * ```ts\n * const editorState = buildEditorState<DefaultNodeTypes>({ text: 'Hello world' }) // result typed as DefaultTypedEditorState\n * ```\n *\n * @example\n *\n * passing nodes:\n *\n * ```ts\n * const editorState = // result typed as TypedEditorState<DefaultNodeTypes | SerializedBlockNode> (or TypedEditorState<SerializedBlockNode>)\n * buildEditorState<DefaultNodeTypes | SerializedBlockNode>({ // or just buildEditorState<SerializedBlockNode> if you *only* want to allow block nodes\n *   nodes: [\n *     {\n *       type: 'block',\n *        fields: {\n *          id: 'id',\n *          blockName: 'Cool block',\n *          blockType: 'myBlock',\n *        },\n *        format: 'left',\n *        version: 1,\n *      }\n *   ],\n * })\n * ```\n *\n * @example\n *\n * passing a generated `richText` field type — the result is exactly that field's type:\n *\n * ```ts\n * post.richText = buildEditorState<Post['richText']>({ text: 'Hello world' })\n * ```\n */\nexport function buildEditorState<\n  T extends\n    | null\n    | SerializedLexicalNode\n    | TypedEditorState<SerializedLexicalNode>\n    | undefined = DefaultNodeTypes,\n>({\n  nodes,\n  text,\n}: {\n  nodes?: TypedEditorState<BuildNodes<T>>['root']['children']\n  text?: string\n}): TypedEditorState<BuildNodes<T>> {\n  const editorJSON: DefaultTypedEditorState = {\n    root: {\n      type: 'root',\n      children: [],\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      version: 1,\n    },\n  }\n\n  if (text) {\n    editorJSON.root.children.push({\n      type: 'paragraph',\n      children: [\n        {\n          type: 'text',\n          detail: 0,\n          format: 0,\n          mode: 'normal',\n          style: '',\n          text,\n          version: 1,\n        },\n      ],\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      textFormat: 0,\n      textStyle: '',\n      version: 1,\n    })\n  }\n\n  if (nodes?.length) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    editorJSON.root.children.push(...(nodes as any))\n  }\n\n  if (editorJSON.root.children.length === 0) {\n    // An error will be thrown if the root node has no children\n    editorJSON.root.children.push({\n      type: 'paragraph',\n      children: [],\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      textFormat: 0,\n      textStyle: '',\n      version: 1,\n    })\n  }\n\n  return editorJSON as TypedEditorState<BuildNodes<T>>\n}\n\n/**\n *\n * Alias for `buildEditorState<DefaultNodeTypes>`\n *\n * @experimental this API may change or be removed in a minor release\n * @internal\n */\nexport const buildDefaultEditorState: typeof buildEditorState<DefaultNodeTypes> =\n  buildEditorState<DefaultNodeTypes>\n"],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CA,OAAO,SAASA,iBAMd;EACAC,KAAK;EACLC;AAAI,CAIL;EACC,MAAMC,UAAA,GAAsC;IAC1CC,IAAA,EAAM;MACJC,IAAA,EAAM;MACNC,QAAA,EAAU,EAAE;MACZC,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRC,OAAA,EAAS;IACX;EACF;EAEA,IAAIR,IAAA,EAAM;IACRC,UAAA,CAAWC,IAAI,CAACE,QAAQ,CAACK,IAAI,CAAC;MAC5BN,IAAA,EAAM;MACNC,QAAA,EAAU,CACR;QACED,IAAA,EAAM;QACNO,MAAA,EAAQ;QACRJ,MAAA,EAAQ;QACRK,IAAA,EAAM;QACNC,KAAA,EAAO;QACPZ,IAAA;QACAQ,OAAA,EAAS;MACX,EACD;MACDH,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRM,UAAA,EAAY;MACZC,SAAA,EAAW;MACXN,OAAA,EAAS;IACX;EACF;EAEA,IAAIT,KAAA,EAAOgB,MAAA,EAAQ;IACjB;IACAd,UAAA,CAAWC,IAAI,CAACE,QAAQ,CAACK,IAAI,IAAKV,KAAA;EACpC;EAEA,IAAIE,UAAA,CAAWC,IAAI,CAACE,QAAQ,CAACW,MAAM,KAAK,GAAG;IACzC;IACAd,UAAA,CAAWC,IAAI,CAACE,QAAQ,CAACK,IAAI,CAAC;MAC5BN,IAAA,EAAM;MACNC,QAAA,EAAU,EAAE;MACZC,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRM,UAAA,EAAY;MACZC,SAAA,EAAW;MACXN,OAAA,EAAS;IACX;EACF;EAEA,OAAOP,UAAA;AACT;AAEA;;;;;;;AAOA,OAAO,MAAMe,uBAAA,GACXlB,gBAAA","ignoreList":[]}

package/dist/utilities/buildInitialState.d.ts

@@ -1,5 +1,5 @@
 import type { SerializedLexicalNode } from 'lexical';
-import type { ClientFieldSchemaMap, DocumentPreferences, FieldSchemaMap, FormState, Operation, PayloadRequest, RichTextField, SanitizedFieldPermissions } from 'payload';
+import type { ClientFieldSchemaMap, ComponentRenderer, DocumentPreferences, FieldSchemaMap, FormState, Operation, PayloadRequest, RichTextField, SanitizedFieldPermissions } from 'payload';
 export type InitialLexicalFormState = {
     [nodeID: string]: {
         [key: string]: any;
@@ -19,6 +19,7 @@ type Props = {
         operation: Operation;
         permissions?: SanitizedFieldPermissions;
         preferences: DocumentPreferences;
+        renderComponent: ComponentRenderer;
         renderFieldFn: any;
         req: PayloadRequest;
     };