@payloadcms/richtext-lexical 3.29.0-internal.d2c9ba5 → 3.29.0-internal.d74b919

package/dist/features/converters/lexicalToPlaintext/convertLexicalToPlaintext.spec.js

@@ -0,0 +1,84 @@
+import { convertLexicalToPlaintext } from './sync/index.js';
+function textNode(text, bold) {
+  return {
+    type: 'text',
+    detail: 0,
+    format: bold ? 1 : 0,
+    mode: 'normal',
+    style: '',
+    text,
+    version: 1
+  };
+}
+function linebreakNode() {
+  return {
+    type: 'linebreak',
+    version: 1
+  };
+}
+function tabNode() {
+  return {
+    type: 'tab',
+    detail: 0,
+    format: 0,
+    mode: 'normal',
+    style: '',
+    text: '',
+    version: 1
+  };
+}
+function paragraphNode(children) {
+  return {
+    type: 'paragraph',
+    children,
+    direction: 'ltr',
+    format: '',
+    indent: 0,
+    textFormat: 0,
+    version: 1
+  };
+}
+function rootNode(nodes) {
+  return {
+    root: {
+      type: 'root',
+      children: nodes,
+      direction: 'ltr',
+      format: '',
+      indent: 0,
+      version: 1
+    }
+  };
+}
+describe('convertLexicalToPlaintext', () => {
+  it('ensure paragraph with text is correctly converted', () => {
+    const data = rootNode([paragraphNode([textNode('Basic Text')])]);
+    const plaintext = convertLexicalToPlaintext({
+      data
+    });
+    console.log('plaintext', plaintext);
+    expect(plaintext).toBe('Basic Text');
+  });
+  it('ensure paragraph with multiple text nodes is correctly converted', () => {
+    const data = rootNode([paragraphNode([textNode('Basic Text'), textNode(' Bold', true), textNode(' Text')])]);
+    const plaintext = convertLexicalToPlaintext({
+      data
+    });
+    expect(plaintext).toBe('Basic Text Bold Text');
+  });
+  it('ensure linebreaks are converted correctly', () => {
+    const data = rootNode([paragraphNode([textNode('Basic Text'), linebreakNode(), textNode('Next Line')])]);
+    const plaintext = convertLexicalToPlaintext({
+      data
+    });
+    expect(plaintext).toBe('Basic Text\nNext Line');
+  });
+  it('ensure tabs are converted correctly', () => {
+    const data = rootNode([paragraphNode([textNode('Basic Text'), tabNode(), textNode('Next Line')])]);
+    const plaintext = convertLexicalToPlaintext({
+      data
+    });
+    expect(plaintext).toBe('Basic Text\tNext Line');
+  });
+});
+//# sourceMappingURL=convertLexicalToPlaintext.spec.js.map

package/dist/features/converters/lexicalToPlaintext/convertLexicalToPlaintext.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertLexicalToPlaintext.spec.js","names":["convertLexicalToPlaintext","textNode","text","bold","type","detail","format","mode","style","version","linebreakNode","tabNode","paragraphNode","children","direction","indent","textFormat","rootNode","nodes","root","describe","it","data","plaintext","console","log","expect","toBe"],"sources":["../../../../src/features/converters/lexicalToPlaintext/convertLexicalToPlaintext.spec.ts"],"sourcesContent":["import type {\n  DefaultNodeTypes,\n  DefaultTypedEditorState,\n  SerializedTabNode,\n  SerializedParagraphNode,\n  SerializedTextNode,\n  SerializedLineBreakNode,\n} from '../../../nodeTypes.js'\nimport { convertLexicalToPlaintext } from './sync/index.js'\n\nfunction textNode(text: string, bold?: boolean): SerializedTextNode {\n  return {\n    type: 'text',\n    detail: 0,\n    format: bold ? 1 : 0,\n    mode: 'normal',\n    style: '',\n    text,\n    version: 1,\n  }\n}\n\nfunction linebreakNode(): SerializedLineBreakNode {\n  return {\n    type: 'linebreak',\n    version: 1,\n  }\n}\n\nfunction tabNode(): SerializedTabNode {\n  return {\n    type: 'tab',\n    detail: 0,\n    format: 0,\n    mode: 'normal',\n    style: '',\n    text: '',\n    version: 1,\n  }\n}\n\nfunction paragraphNode(children: DefaultNodeTypes[]): SerializedParagraphNode {\n  return {\n    type: 'paragraph',\n    children,\n    direction: 'ltr',\n    format: '',\n    indent: 0,\n    textFormat: 0,\n    version: 1,\n  }\n}\n\nfunction rootNode(nodes: DefaultNodeTypes[]): DefaultTypedEditorState {\n  return {\n    root: {\n      type: 'root',\n      children: nodes,\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      version: 1,\n    },\n  }\n}\n\ndescribe('convertLexicalToPlaintext', () => {\n  it('ensure paragraph with text is correctly converted', () => {\n    const data: DefaultTypedEditorState = rootNode([paragraphNode([textNode('Basic Text')])])\n\n    const plaintext = convertLexicalToPlaintext({\n      data,\n    })\n\n    console.log('plaintext', plaintext)\n    expect(plaintext).toBe('Basic Text')\n  })\n\n  it('ensure paragraph with multiple text nodes is correctly converted', () => {\n    const data: DefaultTypedEditorState = rootNode([\n      paragraphNode([textNode('Basic Text'), textNode(' Bold', true), textNode(' Text')]),\n    ])\n\n    const plaintext = convertLexicalToPlaintext({\n      data,\n    })\n\n    expect(plaintext).toBe('Basic Text Bold Text')\n  })\n\n  it('ensure linebreaks are converted correctly', () => {\n    const data: DefaultTypedEditorState = rootNode([\n      paragraphNode([textNode('Basic Text'), linebreakNode(), textNode('Next Line')]),\n    ])\n\n    const plaintext = convertLexicalToPlaintext({\n      data,\n    })\n\n    expect(plaintext).toBe('Basic Text\\nNext Line')\n  })\n\n  it('ensure tabs are converted correctly', () => {\n    const data: DefaultTypedEditorState = rootNode([\n      paragraphNode([textNode('Basic Text'), tabNode(), textNode('Next Line')]),\n    ])\n\n    const plaintext = convertLexicalToPlaintext({\n      data,\n    })\n\n    expect(plaintext).toBe('Basic Text\\tNext Line')\n  })\n})\n"],"mappings":"AAQA,SAASA,yBAAyB,QAAQ;AAE1C,SAASC,SAASC,IAAY,EAAEC,IAAc;EAC5C,OAAO;IACLC,IAAA,EAAM;IACNC,MAAA,EAAQ;IACRC,MAAA,EAAQH,IAAA,GAAO,IAAI;IACnBI,IAAA,EAAM;IACNC,KAAA,EAAO;IACPN,IAAA;IACAO,OAAA,EAAS;EACX;AACF;AAEA,SAASC,cAAA;EACP,OAAO;IACLN,IAAA,EAAM;IACNK,OAAA,EAAS;EACX;AACF;AAEA,SAASE,QAAA;EACP,OAAO;IACLP,IAAA,EAAM;IACNC,MAAA,EAAQ;IACRC,MAAA,EAAQ;IACRC,IAAA,EAAM;IACNC,KAAA,EAAO;IACPN,IAAA,EAAM;IACNO,OAAA,EAAS;EACX;AACF;AAEA,SAASG,cAAcC,QAA4B;EACjD,OAAO;IACLT,IAAA,EAAM;IACNS,QAAA;IACAC,SAAA,EAAW;IACXR,MAAA,EAAQ;IACRS,MAAA,EAAQ;IACRC,UAAA,EAAY;IACZP,OAAA,EAAS;EACX;AACF;AAEA,SAASQ,SAASC,KAAyB;EACzC,OAAO;IACLC,IAAA,EAAM;MACJf,IAAA,EAAM;MACNS,QAAA,EAAUK,KAAA;MACVJ,SAAA,EAAW;MACXR,MAAA,EAAQ;MACRS,MAAA,EAAQ;MACRN,OAAA,EAAS;IACX;EACF;AACF;AAEAW,QAAA,CAAS,6BAA6B;EACpCC,EAAA,CAAG,qDAAqD;IACtD,MAAMC,IAAA,GAAgCL,QAAA,CAAS,CAACL,aAAA,CAAc,CAACX,QAAA,CAAS,cAAc,EAAE;IAExF,MAAMsB,SAAA,GAAYvB,yBAAA,CAA0B;MAC1CsB;IACF;IAEAE,OAAA,CAAQC,GAAG,CAAC,aAAaF,SAAA;IACzBG,MAAA,CAAOH,SAAA,EAAWI,IAAI,CAAC;EACzB;EAEAN,EAAA,CAAG,oEAAoE;IACrE,MAAMC,IAAA,GAAgCL,QAAA,CAAS,CAC7CL,aAAA,CAAc,CAACX,QAAA,CAAS,eAAeA,QAAA,CAAS,SAAS,OAAOA,QAAA,CAAS,SAAS,EACnF;IAED,MAAMsB,SAAA,GAAYvB,yBAAA,CAA0B;MAC1CsB;IACF;IAEAI,MAAA,CAAOH,SAAA,EAAWI,IAAI,CAAC;EACzB;EAEAN,EAAA,CAAG,6CAA6C;IAC9C,MAAMC,IAAA,GAAgCL,QAAA,CAAS,CAC7CL,aAAA,CAAc,CAACX,QAAA,CAAS,eAAeS,aAAA,IAAiBT,QAAA,CAAS,aAAa,EAC/E;IAED,MAAMsB,SAAA,GAAYvB,yBAAA,CAA0B;MAC1CsB;IACF;IAEAI,MAAA,CAAOH,SAAA,EAAWI,IAAI,CAAC;EACzB;EAEAN,EAAA,CAAG,uCAAuC;IACxC,MAAMC,IAAA,GAAgCL,QAAA,CAAS,CAC7CL,aAAA,CAAc,CAACX,QAAA,CAAS,eAAeU,OAAA,IAAWV,QAAA,CAAS,aAAa,EACzE;IAED,MAAMsB,SAAA,GAAYvB,yBAAA,CAA0B;MAC1CsB;IACF;IAEAI,MAAA,CAAOH,SAAA,EAAWI,IAAI,CAAC;EACzB;AACF","ignoreList":[]}

package/dist/features/converters/lexicalToPlaintext/shared/findConverterForNode.d.ts

@@ -0,0 +1,7 @@
+import type { SerializedLexicalNode } from 'lexical';
+import type { PlaintextConverter, PlaintextConverters } from '../sync/types.js';
+export declare function findConverterForNode<TConverters extends PlaintextConverters, TConverter extends PlaintextConverter<any>>({ converters, node, }: {
+    converters: TConverters;
+    node: SerializedLexicalNode;
+}): TConverter | undefined;
+//# sourceMappingURL=findConverterForNode.d.ts.map

package/dist/features/converters/lexicalToPlaintext/shared/findConverterForNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findConverterForNode.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/lexicalToPlaintext/shared/findConverterForNode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAGpD,OAAO,KAAK,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAE/E,wBAAgB,oBAAoB,CAClC,WAAW,SAAS,mBAAmB,EACvC,UAAU,SAAS,kBAAkB,CAAC,GAAG,CAAC,EAC1C,EACA,UAAU,EAEV,IAAI,GACL,EAAE;IACD,UAAU,EAAE,WAAW,CAAA;IACvB,IAAI,EAAE,qBAAqB,CAAA;CAC5B,GAAG,UAAU,GAAG,SAAS,CAezB"}

package/dist/features/converters/lexicalToPlaintext/shared/findConverterForNode.js

@@ -0,0 +1,15 @@
+export function findConverterForNode({
+  converters,
+  node
+}) {
+  let converterForNode;
+  if (node.type === 'block') {
+    converterForNode = converters?.blocks?.[node?.fields?.blockType];
+  } else if (node.type === 'inlineBlock') {
+    converterForNode = converters?.inlineBlocks?.[node?.fields?.blockType];
+  } else {
+    converterForNode = converters[node.type];
+  }
+  return converterForNode;
+}
+//# sourceMappingURL=findConverterForNode.js.map

package/dist/features/converters/lexicalToPlaintext/shared/findConverterForNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"findConverterForNode.js","names":["findConverterForNode","converters","node","converterForNode","type","blocks","fields","blockType","inlineBlocks"],"sources":["../../../../../src/features/converters/lexicalToPlaintext/shared/findConverterForNode.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nimport type { SerializedBlockNode, SerializedInlineBlockNode } from '../../../../nodeTypes.js'\nimport type { PlaintextConverter, PlaintextConverters } from '../sync/types.js'\n\nexport function findConverterForNode<\n  TConverters extends PlaintextConverters,\n  TConverter extends PlaintextConverter<any>,\n>({\n  converters,\n\n  node,\n}: {\n  converters: TConverters\n  node: SerializedLexicalNode\n}): TConverter | undefined {\n  let converterForNode: TConverter | undefined\n  if (node.type === 'block') {\n    converterForNode = converters?.blocks?.[\n      (node as SerializedBlockNode)?.fields?.blockType\n    ] as TConverter\n  } else if (node.type === 'inlineBlock') {\n    converterForNode = converters?.inlineBlocks?.[\n      (node as SerializedInlineBlockNode)?.fields?.blockType\n    ] as TConverter\n  } else {\n    converterForNode = converters[node.type] as TConverter\n  }\n\n  return converterForNode\n}\n"],"mappings":"AAKA,OAAO,SAASA,qBAGd;EACAC,UAAU;EAEVC;AAAI,CAIL;EACC,IAAIC,gBAAA;EACJ,IAAID,IAAA,CAAKE,IAAI,KAAK,SAAS;IACzBD,gBAAA,GAAmBF,UAAA,EAAYI,MAAA,GAC5BH,IAAA,EAA8BI,MAAA,EAAQC,SAAA,CACxC;EACH,OAAO,IAAIL,IAAA,CAAKE,IAAI,KAAK,eAAe;IACtCD,gBAAA,GAAmBF,UAAA,EAAYO,YAAA,GAC5BN,IAAA,EAAoCI,MAAA,EAAQC,SAAA,CAC9C;EACH,OAAO;IACLJ,gBAAA,GAAmBF,UAAU,CAACC,IAAA,CAAKE,IAAI,CAAC;EAC1C;EAEA,OAAOD,gBAAA;AACT","ignoreList":[]}

package/dist/features/converters/lexicalToPlaintext/shared/types.d.ts

@@ -0,0 +1,5 @@
+import type { SerializedLexicalNode } from 'lexical';
+export type SerializedLexicalNodeWithParent = {
+    parent?: SerializedLexicalNode;
+} & SerializedLexicalNode;
+//# sourceMappingURL=types.d.ts.map

package/dist/features/converters/lexicalToPlaintext/shared/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/lexicalToPlaintext/shared/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACpD,MAAM,MAAM,+BAA+B,GAAG;IAC5C,MAAM,CAAC,EAAE,qBAAqB,CAAA;CAC/B,GAAG,qBAAqB,CAAA"}

package/dist/features/converters/lexicalToPlaintext/shared/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/features/converters/lexicalToPlaintext/shared/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../../../../src/features/converters/lexicalToPlaintext/shared/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\nexport type SerializedLexicalNodeWithParent = {\n  parent?: SerializedLexicalNode\n} & SerializedLexicalNode\n"],"mappings":"AACA","ignoreList":[]}

package/dist/features/converters/lexicalToPlaintext/sync/index.d.ts

@@ -0,0 +1,22 @@
+import type { SerializedEditorState, SerializedLexicalNode } from 'lexical';
+import type { SerializedLexicalNodeWithParent } from '../shared/types.js';
+import type { PlaintextConverters } from './types.js';
+export type ConvertLexicalToPlaintextArgs = {
+    /**
+     * A map of node types to their corresponding plaintext converter functions.
+     * This is optional - if not provided, the following heuristic will be used:
+     *
+     * - If the node has a `text` property, it will be used as the plaintext.
+     * - If the node has a `children` property, the children will be recursively converted to plaintext.
+     * - If the node has neither, it will be ignored.
+     **/
+    converters?: PlaintextConverters;
+    data: SerializedEditorState;
+};
+export declare function convertLexicalToPlaintext({ converters, data, }: ConvertLexicalToPlaintextArgs): string;
+export declare function convertLexicalNodesToPlaintext({ converters, nodes, parent, }: {
+    converters: PlaintextConverters;
+    nodes: SerializedLexicalNode[];
+    parent: SerializedLexicalNodeWithParent;
+}): string[];
+//# sourceMappingURL=index.d.ts.map

package/dist/features/converters/lexicalToPlaintext/sync/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/lexicalToPlaintext/sync/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAE3E,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,oBAAoB,CAAA;AACzE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA;AAKrD,MAAM,MAAM,6BAA6B,GAAG;IAC1C;;;;;;;QAOI;IACJ,UAAU,CAAC,EAAE,mBAAmB,CAAA;IAChC,IAAI,EAAE,qBAAqB,CAAA;CAC5B,CAAA;AAED,wBAAgB,yBAAyB,CAAC,EACxC,UAAU,EACV,IAAI,GACL,EAAE,6BAA6B,GAAG,MAAM,CAWxC;AAED,wBAAgB,8BAA8B,CAAC,EAC7C,UAAU,EACV,KAAK,EACL,MAAM,GACP,EAAE;IACD,UAAU,EAAE,mBAAmB,CAAA;IAC/B,KAAK,EAAE,qBAAqB,EAAE,CAAA;IAC9B,MAAM,EAAE,+BAA+B,CAAA;CACxC,GAAG,MAAM,EAAE,CAoEX"}

package/dist/features/converters/lexicalToPlaintext/sync/index.js

@@ -0,0 +1,79 @@
+/* eslint-disable no-console */import { hasText } from '../../../../validate/hasText.js';
+import { findConverterForNode } from '../shared/findConverterForNode.js';
+export function convertLexicalToPlaintext({
+  converters,
+  data
+}) {
+  if (hasText(data)) {
+    const plaintext = convertLexicalNodesToPlaintext({
+      converters: converters ?? {},
+      nodes: data?.root?.children,
+      parent: data?.root
+    }).join('');
+    return plaintext;
+  }
+  return '';
+}
+export function convertLexicalNodesToPlaintext({
+  converters,
+  nodes,
+  parent
+}) {
+  const plainTextArray = [];
+  let i = -1;
+  for (const node of nodes) {
+    i++;
+    const converter = findConverterForNode({
+      converters,
+      node
+    });
+    if (converter) {
+      try {
+        const converted = typeof converter === 'function' ? converter({
+          childIndex: i,
+          converters,
+          node,
+          nodesToPlaintext: args => {
+            return convertLexicalNodesToPlaintext({
+              converters: args.converters ?? converters,
+              nodes: args.nodes,
+              parent: args.parent ?? {
+                ...node,
+                parent
+              }
+            });
+          },
+          parent
+        }) : converter;
+        if (converted && typeof converted === 'string') {
+          plainTextArray.push(converted);
+        }
+      } catch (error) {
+        console.error('Error converting lexical node to plaintext:', error, 'node:', node);
+      }
+    } else {
+      // Default plaintext converter heuristic
+      if (node.type === 'paragraph') {
+        if (plainTextArray?.length) {
+          // Only add a new line if there is already text in the array
+          plainTextArray.push('\n\n');
+        }
+      } else if (node.type === 'linebreak') {
+        plainTextArray.push('\n');
+      } else if (node.type === 'tab') {
+        plainTextArray.push('\t');
+      } else if ('text' in node && node.text) {
+        plainTextArray.push(node.text);
+      }
+      if ('children' in node && node.children) {
+        plainTextArray.push(...convertLexicalNodesToPlaintext({
+          converters,
+          nodes: node.children,
+          parent: node
+        }));
+      }
+    }
+  }
+  return plainTextArray.filter(Boolean);
+}
+//# sourceMappingURL=index.js.map

package/dist/features/converters/lexicalToPlaintext/sync/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["hasText","findConverterForNode","convertLexicalToPlaintext","converters","data","plaintext","convertLexicalNodesToPlaintext","nodes","root","children","parent","join","plainTextArray","i","node","converter","converted","childIndex","nodesToPlaintext","args","push","error","console","type","length","text","filter","Boolean"],"sources":["../../../../../src/features/converters/lexicalToPlaintext/sync/index.ts"],"sourcesContent":["/* eslint-disable no-console */\nimport type { SerializedEditorState, SerializedLexicalNode } from 'lexical'\n\nimport type { SerializedLexicalNodeWithParent } from '../shared/types.js'\nimport type { PlaintextConverters } from './types.js'\n\nimport { hasText } from '../../../../validate/hasText.js'\nimport { findConverterForNode } from '../shared/findConverterForNode.js'\n\nexport type ConvertLexicalToPlaintextArgs = {\n  /**\n   * A map of node types to their corresponding plaintext converter functions.\n   * This is optional - if not provided, the following heuristic will be used:\n   *\n   * - If the node has a `text` property, it will be used as the plaintext.\n   * - If the node has a `children` property, the children will be recursively converted to plaintext.\n   * - If the node has neither, it will be ignored.\n   **/\n  converters?: PlaintextConverters\n  data: SerializedEditorState\n}\n\nexport function convertLexicalToPlaintext({\n  converters,\n  data,\n}: ConvertLexicalToPlaintextArgs): string {\n  if (hasText(data)) {\n    const plaintext = convertLexicalNodesToPlaintext({\n      converters: converters ?? {},\n      nodes: data?.root?.children,\n      parent: data?.root,\n    }).join('')\n\n    return plaintext\n  }\n  return ''\n}\n\nexport function convertLexicalNodesToPlaintext({\n  converters,\n  nodes,\n  parent,\n}: {\n  converters: PlaintextConverters\n  nodes: SerializedLexicalNode[]\n  parent: SerializedLexicalNodeWithParent\n}): string[] {\n  const plainTextArray: string[] = []\n\n  let i = -1\n  for (const node of nodes) {\n    i++\n\n    const converter = findConverterForNode({\n      converters,\n      node,\n    })\n\n    if (converter) {\n      try {\n        const converted =\n          typeof converter === 'function'\n            ? converter({\n                childIndex: i,\n                converters,\n                node,\n                nodesToPlaintext: (args) => {\n                  return convertLexicalNodesToPlaintext({\n                    converters: args.converters ?? converters,\n                    nodes: args.nodes,\n                    parent: args.parent ?? {\n                      ...node,\n                      parent,\n                    },\n                  })\n                },\n                parent,\n              })\n            : converter\n\n        if (converted && typeof converted === 'string') {\n          plainTextArray.push(converted)\n        }\n      } catch (error) {\n        console.error('Error converting lexical node to plaintext:', error, 'node:', node)\n      }\n    } else {\n      // Default plaintext converter heuristic\n      if (node.type === 'paragraph') {\n        if (plainTextArray?.length) {\n          // Only add a new line if there is already text in the array\n          plainTextArray.push('\\n\\n')\n        }\n      } else if (node.type === 'linebreak') {\n        plainTextArray.push('\\n')\n      } else if (node.type === 'tab') {\n        plainTextArray.push('\\t')\n      } else if ('text' in node && node.text) {\n        plainTextArray.push(node.text as string)\n      }\n\n      if ('children' in node && node.children) {\n        plainTextArray.push(\n          ...convertLexicalNodesToPlaintext({\n            converters,\n            nodes: node.children as SerializedLexicalNode[],\n            parent: node,\n          }),\n        )\n      }\n    }\n  }\n\n  return plainTextArray.filter(Boolean)\n}\n"],"mappings":"AAAA,+BAMA,SAASA,OAAO,QAAQ;AACxB,SAASC,oBAAoB,QAAQ;AAerC,OAAO,SAASC,0BAA0B;EACxCC,UAAU;EACVC;AAAI,CAC0B;EAC9B,IAAIJ,OAAA,CAAQI,IAAA,GAAO;IACjB,MAAMC,SAAA,GAAYC,8BAAA,CAA+B;MAC/CH,UAAA,EAAYA,UAAA,IAAc,CAAC;MAC3BI,KAAA,EAAOH,IAAA,EAAMI,IAAA,EAAMC,QAAA;MACnBC,MAAA,EAAQN,IAAA,EAAMI;IAChB,GAAGG,IAAI,CAAC;IAER,OAAON,SAAA;EACT;EACA,OAAO;AACT;AAEA,OAAO,SAASC,+BAA+B;EAC7CH,UAAU;EACVI,KAAK;EACLG;AAAM,CAKP;EACC,MAAME,cAAA,GAA2B,EAAE;EAEnC,IAAIC,CAAA,GAAI,CAAC;EACT,KAAK,MAAMC,IAAA,IAAQP,KAAA,EAAO;IACxBM,CAAA;IAEA,MAAME,SAAA,GAAYd,oBAAA,CAAqB;MACrCE,UAAA;MACAW;IACF;IAEA,IAAIC,SAAA,EAAW;MACb,IAAI;QACF,MAAMC,SAAA,GACJ,OAAOD,SAAA,KAAc,aACjBA,SAAA,CAAU;UACRE,UAAA,EAAYJ,CAAA;UACZV,UAAA;UACAW,IAAA;UACAI,gBAAA,EAAmBC,IAAA;YACjB,OAAOb,8BAAA,CAA+B;cACpCH,UAAA,EAAYgB,IAAA,CAAKhB,UAAU,IAAIA,UAAA;cAC/BI,KAAA,EAAOY,IAAA,CAAKZ,KAAK;cACjBG,MAAA,EAAQS,IAAA,CAAKT,MAAM,IAAI;gBACrB,GAAGI,IAAI;gBACPJ;cACF;YACF;UACF;UACAA;QACF,KACAK,SAAA;QAEN,IAAIC,SAAA,IAAa,OAAOA,SAAA,KAAc,UAAU;UAC9CJ,cAAA,CAAeQ,IAAI,CAACJ,SAAA;QACtB;MACF,EAAE,OAAOK,KAAA,EAAO;QACdC,OAAA,CAAQD,KAAK,CAAC,+CAA+CA,KAAA,EAAO,SAASP,IAAA;MAC/E;IACF,OAAO;MACL;MACA,IAAIA,IAAA,CAAKS,IAAI,KAAK,aAAa;QAC7B,IAAIX,cAAA,EAAgBY,MAAA,EAAQ;UAC1B;UACAZ,cAAA,CAAeQ,IAAI,CAAC;QACtB;MACF,OAAO,IAAIN,IAAA,CAAKS,IAAI,KAAK,aAAa;QACpCX,cAAA,CAAeQ,IAAI,CAAC;MACtB,OAAO,IAAIN,IAAA,CAAKS,IAAI,KAAK,OAAO;QAC9BX,cAAA,CAAeQ,IAAI,CAAC;MACtB,OAAO,IAAI,UAAUN,IAAA,IAAQA,IAAA,CAAKW,IAAI,EAAE;QACtCb,cAAA,CAAeQ,IAAI,CAACN,IAAA,CAAKW,IAAI;MAC/B;MAEA,IAAI,cAAcX,IAAA,IAAQA,IAAA,CAAKL,QAAQ,EAAE;QACvCG,cAAA,CAAeQ,IAAI,IACdd,8BAAA,CAA+B;UAChCH,UAAA;UACAI,KAAA,EAAOO,IAAA,CAAKL,QAAQ;UACpBC,MAAA,EAAQI;QACV;MAEJ;IACF;EACF;EAEA,OAAOF,cAAA,CAAec,MAAM,CAACC,OAAA;AAC/B","ignoreList":[]}

package/dist/features/converters/lexicalToPlaintext/sync/types.d.ts

@@ -0,0 +1,60 @@
+import type { SerializedLexicalNode } from 'lexical';
+import type { DefaultNodeTypes, SerializedBlockNode, SerializedInlineBlockNode } from '../../../../nodeTypes.js';
+import type { SerializedLexicalNodeWithParent } from '../shared/types.js';
+export type PlaintextConverter<T extends {
+    [key: string]: any;
+    type?: string;
+} = SerializedLexicalNode> = ((args: {
+    childIndex: number;
+    converters: PlaintextConverters;
+    node: T;
+    nodesToPlaintext: (args: {
+        converters?: PlaintextConverters;
+        nodes: SerializedLexicalNode[];
+        parent?: SerializedLexicalNodeWithParent;
+    }) => string[];
+    parent: SerializedLexicalNodeWithParent;
+}) => string) | string;
+export type DefaultPlaintextNodeTypes = DefaultNodeTypes | SerializedBlockNode<{
+    blockName?: null | string;
+    blockType: string;
+}> | SerializedInlineBlockNode<{
+    blockName?: null | string;
+    blockType: string;
+}>;
+export type PlaintextConverters<T extends {
+    [key: string]: any;
+    type?: string;
+} = DefaultPlaintextNodeTypes> = {
+    [key: string]: {
+        [blockSlug: string]: PlaintextConverter<any>;
+    } | PlaintextConverter<any> | undefined;
+} & {
+    [nodeType in Exclude<NonNullable<T['type']>, 'block' | 'inlineBlock'>]?: PlaintextConverter<Extract<T, {
+        type: nodeType;
+    }>>;
+} & {
+    blocks?: {
+        [K in Extract<Extract<T, {
+            type: 'block';
+        }> extends SerializedBlockNode<infer B> ? B extends {
+            blockType: string;
+        } ? B['blockType'] : never : never, string>]?: PlaintextConverter<Extract<T, {
+            type: 'block';
+        }> extends SerializedBlockNode<infer B> ? SerializedBlockNode<Extract<B, {
+            blockType: K;
+        }>> : SerializedBlockNode>;
+    };
+    inlineBlocks?: {
+        [K in Extract<Extract<T, {
+            type: 'inlineBlock';
+        }> extends SerializedInlineBlockNode<infer B> ? B extends {
+            blockType: string;
+        } ? B['blockType'] : never : never, string>]?: PlaintextConverter<Extract<T, {
+            type: 'inlineBlock';
+        }> extends SerializedInlineBlockNode<infer B> ? SerializedInlineBlockNode<Extract<B, {
+            blockType: K;
+        }>> : SerializedInlineBlockNode>;
+    };
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/features/converters/lexicalToPlaintext/sync/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/lexicalToPlaintext/sync/types.ts"],"names":[],"mappings":"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"}

package/dist/features/converters/lexicalToPlaintext/sync/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/features/converters/lexicalToPlaintext/sync/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../../../../src/features/converters/lexicalToPlaintext/sync/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nimport type {\n  DefaultNodeTypes,\n  SerializedBlockNode,\n  SerializedInlineBlockNode,\n} from '../../../../nodeTypes.js'\nimport type { SerializedLexicalNodeWithParent } from '../shared/types.js'\n\nexport type PlaintextConverter<\n  T extends { [key: string]: any; type?: string } = SerializedLexicalNode,\n> =\n  | ((args: {\n      childIndex: number\n      converters: PlaintextConverters\n      node: T\n      nodesToPlaintext: (args: {\n        converters?: PlaintextConverters\n        nodes: SerializedLexicalNode[]\n        parent?: SerializedLexicalNodeWithParent\n      }) => string[]\n      parent: SerializedLexicalNodeWithParent\n    }) => string)\n  | string\n\nexport type DefaultPlaintextNodeTypes =\n  | DefaultNodeTypes\n  | SerializedBlockNode<{ blockName?: null | string; blockType: string }> // need these to ensure types for blocks and inlineBlocks work if no generics are provided\n  | SerializedInlineBlockNode<{ blockName?: null | string; blockType: string }>\n\nexport type PlaintextConverters<\n  T extends { [key: string]: any; type?: string } = DefaultPlaintextNodeTypes,\n> = {\n  [key: string]:\n    | {\n        [blockSlug: string]: PlaintextConverter<any>\n      }\n    | PlaintextConverter<any>\n    | undefined\n} & {\n  [nodeType in Exclude<NonNullable<T['type']>, 'block' | 'inlineBlock'>]?: PlaintextConverter<\n    Extract<T, { type: nodeType }>\n  >\n} & {\n  blocks?: {\n    [K in Extract<\n      Extract<T, { type: 'block' }> extends SerializedBlockNode<infer B>\n        ? B extends { blockType: string }\n          ? B['blockType']\n          : never\n        : never,\n      string\n    >]?: PlaintextConverter<\n      Extract<T, { type: 'block' }> extends SerializedBlockNode<infer B>\n        ? SerializedBlockNode<Extract<B, { blockType: K }>>\n        : SerializedBlockNode\n    >\n  }\n  inlineBlocks?: {\n    [K in Extract<\n      Extract<T, { type: 'inlineBlock' }> extends SerializedInlineBlockNode<infer B>\n        ? B extends { blockType: string }\n          ? B['blockType']\n          : never\n        : never,\n      string\n    >]?: PlaintextConverter<\n      Extract<T, { type: 'inlineBlock' }> extends SerializedInlineBlockNode<infer B>\n        ? SerializedInlineBlockNode<Extract<B, { blockType: K }>>\n        : SerializedInlineBlockNode\n    >\n  }\n}\n"],"mappings":"AA8BA","ignoreList":[]}

package/dist/features/converters/markdownToLexical/index.d.ts

@@ -0,0 +1,8 @@
+import type { SerializedLexicalNode } from 'lexical';
+import type { SanitizedServerEditorConfig } from '../../../lexical/config/types.js';
+import type { DefaultNodeTypes, TypedEditorState } from '../../../nodeTypes.js';
+export declare const convertMarkdownToLexical: <TNodeTypes extends SerializedLexicalNode = DefaultNodeTypes>({ editorConfig, markdown, }: {
+    editorConfig: SanitizedServerEditorConfig;
+    markdown: string;
+}) => TypedEditorState<TNodeTypes>;
+//# sourceMappingURL=index.d.ts.map

package/dist/features/converters/markdownToLexical/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/features/converters/markdownToLexical/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAIpD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,kCAAkC,CAAA;AACnF,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAK/E,eAAO,MAAM,wBAAwB,GACnC,UAAU,SAAS,qBAAqB,kDAIvC;IACD,YAAY,EAAE,2BAA2B,CAAA;IACzC,QAAQ,EAAE,MAAM,CAAA;CACjB,KAAG,gBAAgB,CAAC,UAAU,CAiB9B,CAAA"}

package/dist/features/converters/markdownToLexical/index.js

@@ -0,0 +1,21 @@
+import { createHeadlessEditor } from '@lexical/headless';
+import { getEnabledNodes } from '../../../lexical/nodes/index.js';
+import { $convertFromMarkdownString } from '../../../packages/@lexical/markdown/index.js';
+export const convertMarkdownToLexical = ({
+  editorConfig,
+  markdown
+}) => {
+  const headlessEditor = createHeadlessEditor({
+    nodes: getEnabledNodes({
+      editorConfig
+    })
+  });
+  headlessEditor.update(() => {
+    $convertFromMarkdownString(markdown, editorConfig.features.markdownTransformers);
+  }, {
+    discrete: true
+  });
+  const editorJSON = headlessEditor.getEditorState().toJSON();
+  return editorJSON;
+};
+//# sourceMappingURL=index.js.map

package/dist/features/converters/markdownToLexical/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["createHeadlessEditor","getEnabledNodes","$convertFromMarkdownString","convertMarkdownToLexical","editorConfig","markdown","headlessEditor","nodes","update","features","markdownTransformers","discrete","editorJSON","getEditorState","toJSON"],"sources":["../../../../src/features/converters/markdownToLexical/index.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nimport { createHeadlessEditor } from '@lexical/headless'\n\nimport type { SanitizedServerEditorConfig } from '../../../lexical/config/types.js'\nimport type { DefaultNodeTypes, TypedEditorState } from '../../../nodeTypes.js'\n\nimport { getEnabledNodes } from '../../../lexical/nodes/index.js'\nimport { $convertFromMarkdownString } from '../../../packages/@lexical/markdown/index.js'\n\nexport const convertMarkdownToLexical = <\n  TNodeTypes extends SerializedLexicalNode = DefaultNodeTypes,\n>({\n  editorConfig,\n  markdown,\n}: {\n  editorConfig: SanitizedServerEditorConfig\n  markdown: string\n}): TypedEditorState<TNodeTypes> => {\n  const headlessEditor = createHeadlessEditor({\n    nodes: getEnabledNodes({\n      editorConfig,\n    }),\n  })\n\n  headlessEditor.update(\n    () => {\n      $convertFromMarkdownString(markdown, editorConfig.features.markdownTransformers)\n    },\n    { discrete: true },\n  )\n\n  const editorJSON = headlessEditor.getEditorState().toJSON()\n\n  return editorJSON as TypedEditorState<TNodeTypes>\n}\n"],"mappings":"AAEA,SAASA,oBAAoB,QAAQ;AAKrC,SAASC,eAAe,QAAQ;AAChC,SAASC,0BAA0B,QAAQ;AAE3C,OAAO,MAAMC,wBAAA,GAA2BA,CAEtC;EACAC,YAAY;EACZC;AAAQ,CAIT;EACC,MAAMC,cAAA,GAAiBN,oBAAA,CAAqB;IAC1CO,KAAA,EAAON,eAAA,CAAgB;MACrBG;IACF;EACF;EAEAE,cAAA,CAAeE,MAAM,CACnB;IACEN,0BAAA,CAA2BG,QAAA,EAAUD,YAAA,CAAaK,QAAQ,CAACC,oBAAoB;EACjF,GACA;IAAEC,QAAA,EAAU;EAAK;EAGnB,MAAMC,UAAA,GAAaN,cAAA,CAAeO,cAAc,GAAGC,MAAM;EAEzD,OAAOF,UAAA;AACT","ignoreList":[]}

package/dist/features/converters/utilities/payloadPopulateFn.d.ts

@@ -1,5 +1,5 @@
 import { type Payload, type PayloadRequest, type TypedLocale } from 'payload';
-import type { HTMLPopulateFn } from '../html/async/types.js';
+import type { HTMLPopulateFn } from '../lexicalToHtml/async/types.js';
 export declare const getPayloadPopulateFn: (args: {
     currentDepth: number;
     depth: number;

package/dist/features/converters/utilities/payloadPopulateFn.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"payloadPopulateFn.d.ts","sourceRoot":"","sources":["../../../../src/features/converters/utilities/payloadPopulateFn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAA;AAE7F,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAI5D,eAAO,MAAM,oBAAoB,EAAE,CACjC,IAAI,EAAE;IACJ,YAAY,EAAE,MAAM,CAAA;IACpB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,MAAM,CAAC,EAAE,WAAW,CAAA;IAEpB,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B,GAAG,CACA;IACE;;OAEG;IACH,OAAO,EAAE,OAAO,CAAA;IAChB;;;OAGG;IACH,GAAG,CAAC,EAAE,KAAK,CAAA;CACZ,GACD;IACE;;OAEG;IACH,OAAO,CAAC,EAAE,KAAK,CAAA;IACf;;;OAGG;IACH,GAAG,EAAE,cAAc,CAAA;CACpB,CACJ,KACE,OAAO,CAAC,cAAc,CAyC1B,CAAA"}
+{"version":3,"file":"payloadPopulateFn.d.ts","sourceRoot":"","sources":["../../../../src/features/converters/utilities/payloadPopulateFn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAA;AAE7F,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAA;AAIrE,eAAO,MAAM,oBAAoB,EAAE,CACjC,IAAI,EAAE;IACJ,YAAY,EAAE,MAAM,CAAA;IACpB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,MAAM,CAAC,EAAE,WAAW,CAAA;IAEpB,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B,GAAG,CACA;IACE;;OAEG;IACH,OAAO,EAAE,OAAO,CAAA;IAChB;;;OAGG;IACH,GAAG,CAAC,EAAE,KAAK,CAAA;CACZ,GACD;IACE;;OAEG;IACH,OAAO,CAAC,EAAE,KAAK,CAAA;IACf;;;OAGG;IACH,GAAG,EAAE,cAAc,CAAA;CACpB,CACJ,KACE,OAAO,CAAC,cAAc,CAyC1B,CAAA"}

package/dist/features/converters/utilities/payloadPopulateFn.js.map

@@ -1 +1 @@
-{"version":3,"file":"payloadPopulateFn.js","names":["createLocalReq","populate","getPayloadPopulateFn","currentDepth","depth","draft","overrideAccess","payload","req","showHiddenFields","reqToUse","undefined","Error","populateFn","id","collectionSlug","select","dataContainer","data","key","value"],"sources":["../../../../src/features/converters/utilities/payloadPopulateFn.ts"],"sourcesContent":["import { createLocalReq, type Payload, type PayloadRequest, type TypedLocale } from 'payload'\n\nimport type { HTMLPopulateFn } from '../html/async/types.js'\n\nimport { populate } from '../../../populateGraphQL/populate.js'\n\nexport const getPayloadPopulateFn: (\n  args: {\n    currentDepth: number\n    depth: number\n    draft?: boolean\n    locale?: TypedLocale\n\n    overrideAccess?: boolean\n    showHiddenFields?: boolean\n  } & (\n    | {\n        /**\n         * This payload property will only be used if req is undefined. If localization is enabled, you must pass `req` instead.\n         */\n        payload: Payload\n        /**\n         * When the converter is called, req CAN be passed in depending on where it's run.\n         * If this is undefined and config is passed through, lexical will create a new req object for you.\n         */\n        req?: never\n      }\n    | {\n        /**\n         * This payload property will only be used if req is undefined. If localization is enabled, you must pass `req` instead.\n         */\n        payload?: never\n        /**\n         * When the converter is called, req CAN be passed in depending on where it's run.\n         * If this is undefined and config is passed through, lexical will create a new req object for you.\n         */\n        req: PayloadRequest\n      }\n  ),\n) => Promise<HTMLPopulateFn> = async ({\n  currentDepth,\n  depth,\n  draft,\n  overrideAccess,\n  payload,\n  req,\n  showHiddenFields,\n}) => {\n  let reqToUse: PayloadRequest | undefined = req\n  if (req === undefined && payload) {\n    reqToUse = await createLocalReq({}, payload)\n  }\n\n  if (!reqToUse) {\n    throw new Error('No req or payload provided')\n  }\n\n  const populateFn: HTMLPopulateFn = async ({ id, collectionSlug, select }) => {\n    const dataContainer: {\n      value?: any\n    } = {}\n\n    await populate({\n      id,\n      collectionSlug,\n      currentDepth,\n      data: dataContainer,\n      depth,\n      draft: draft ?? false,\n      key: 'value',\n      overrideAccess: overrideAccess ?? true,\n      req: reqToUse,\n      select,\n      showHiddenFields: showHiddenFields ?? false,\n    })\n\n    return dataContainer.value\n  }\n\n  return populateFn\n}\n"],"mappings":"AAAA,SAASA,cAAc,QAA6D;AAIpF,SAASC,QAAQ,QAAQ;AAEzB,OAAO,MAAMC,oBAAA,GAiCkB,MAAAA,CAAO;EACpCC,YAAY;EACZC,KAAK;EACLC,KAAK;EACLC,cAAc;EACdC,OAAO;EACPC,GAAG;EACHC;AAAgB,CACjB;EACC,IAAIC,QAAA,GAAuCF,GAAA;EAC3C,IAAIA,GAAA,KAAQG,SAAA,IAAaJ,OAAA,EAAS;IAChCG,QAAA,GAAW,MAAMV,cAAA,CAAe,CAAC,GAAGO,OAAA;EACtC;EAEA,IAAI,CAACG,QAAA,EAAU;IACb,MAAM,IAAIE,KAAA,CAAM;EAClB;EAEA,MAAMC,UAAA,GAA6B,MAAAA,CAAO;IAAEC,EAAE;IAAEC,cAAc;IAAEC;EAAM,CAAE;IACtE,MAAMC,aAAA,GAEF,CAAC;IAEL,MAAMhB,QAAA,CAAS;MACba,EAAA;MACAC,cAAA;MACAZ,YAAA;MACAe,IAAA,EAAMD,aAAA;MACNb,KAAA;MACAC,KAAA,EAAOA,KAAA,IAAS;MAChBc,GAAA,EAAK;MACLb,cAAA,EAAgBA,cAAA,IAAkB;MAClCE,GAAA,EAAKE,QAAA;MACLM,MAAA;MACAP,gBAAA,EAAkBA,gBAAA,IAAoB;IACxC;IAEA,OAAOQ,aAAA,CAAcG,KAAK;EAC5B;EAEA,OAAOP,UAAA;AACT","ignoreList":[]}
+{"version":3,"file":"payloadPopulateFn.js","names":["createLocalReq","populate","getPayloadPopulateFn","currentDepth","depth","draft","overrideAccess","payload","req","showHiddenFields","reqToUse","undefined","Error","populateFn","id","collectionSlug","select","dataContainer","data","key","value"],"sources":["../../../../src/features/converters/utilities/payloadPopulateFn.ts"],"sourcesContent":["import { createLocalReq, type Payload, type PayloadRequest, type TypedLocale } from 'payload'\n\nimport type { HTMLPopulateFn } from '../lexicalToHtml/async/types.js'\n\nimport { populate } from '../../../populateGraphQL/populate.js'\n\nexport const getPayloadPopulateFn: (\n  args: {\n    currentDepth: number\n    depth: number\n    draft?: boolean\n    locale?: TypedLocale\n\n    overrideAccess?: boolean\n    showHiddenFields?: boolean\n  } & (\n    | {\n        /**\n         * This payload property will only be used if req is undefined. If localization is enabled, you must pass `req` instead.\n         */\n        payload: Payload\n        /**\n         * When the converter is called, req CAN be passed in depending on where it's run.\n         * If this is undefined and config is passed through, lexical will create a new req object for you.\n         */\n        req?: never\n      }\n    | {\n        /**\n         * This payload property will only be used if req is undefined. If localization is enabled, you must pass `req` instead.\n         */\n        payload?: never\n        /**\n         * When the converter is called, req CAN be passed in depending on where it's run.\n         * If this is undefined and config is passed through, lexical will create a new req object for you.\n         */\n        req: PayloadRequest\n      }\n  ),\n) => Promise<HTMLPopulateFn> = async ({\n  currentDepth,\n  depth,\n  draft,\n  overrideAccess,\n  payload,\n  req,\n  showHiddenFields,\n}) => {\n  let reqToUse: PayloadRequest | undefined = req\n  if (req === undefined && payload) {\n    reqToUse = await createLocalReq({}, payload)\n  }\n\n  if (!reqToUse) {\n    throw new Error('No req or payload provided')\n  }\n\n  const populateFn: HTMLPopulateFn = async ({ id, collectionSlug, select }) => {\n    const dataContainer: {\n      value?: any\n    } = {}\n\n    await populate({\n      id,\n      collectionSlug,\n      currentDepth,\n      data: dataContainer,\n      depth,\n      draft: draft ?? false,\n      key: 'value',\n      overrideAccess: overrideAccess ?? true,\n      req: reqToUse,\n      select,\n      showHiddenFields: showHiddenFields ?? false,\n    })\n\n    return dataContainer.value\n  }\n\n  return populateFn\n}\n"],"mappings":"AAAA,SAASA,cAAc,QAA6D;AAIpF,SAASC,QAAQ,QAAQ;AAEzB,OAAO,MAAMC,oBAAA,GAiCkB,MAAAA,CAAO;EACpCC,YAAY;EACZC,KAAK;EACLC,KAAK;EACLC,cAAc;EACdC,OAAO;EACPC,GAAG;EACHC;AAAgB,CACjB;EACC,IAAIC,QAAA,GAAuCF,GAAA;EAC3C,IAAIA,GAAA,KAAQG,SAAA,IAAaJ,OAAA,EAAS;IAChCG,QAAA,GAAW,MAAMV,cAAA,CAAe,CAAC,GAAGO,OAAA;EACtC;EAEA,IAAI,CAACG,QAAA,EAAU;IACb,MAAM,IAAIE,KAAA,CAAM;EAClB;EAEA,MAAMC,UAAA,GAA6B,MAAAA,CAAO;IAAEC,EAAE;IAAEC,cAAc;IAAEC;EAAM,CAAE;IACtE,MAAMC,aAAA,GAEF,CAAC;IAEL,MAAMhB,QAAA,CAAS;MACba,EAAA;MACAC,cAAA;MACAZ,YAAA;MACAe,IAAA,EAAMD,aAAA;MACNb,KAAA;MACAC,KAAA,EAAOA,KAAA,IAAS;MAChBc,GAAA,EAAK;MACLb,cAAA,EAAgBA,cAAA,IAAkB;MAClCE,GAAA,EAAKE,QAAA;MACLM,MAAA;MACAP,gBAAA,EAAkBA,gBAAA,IAAoB;IACxC;IAEA,OAAOQ,aAAA,CAAcG,KAAK;EAC5B;EAEA,OAAOP,UAAA;AACT","ignoreList":[]}

package/dist/features/converters/utilities/restPopulateFn.d.ts

@@ -1,4 +1,4 @@
-import type { HTMLPopulateFn } from '../html/async/types.js';
+import type { HTMLPopulateFn } from '../lexicalToHtml/async/types.js';
 export declare const getRestPopulateFn: (args: {
     /**
      * E.g. `http://localhost:3000/api`

package/dist/features/converters/utilities/restPopulateFn.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"restPopulateFn.d.ts","sourceRoot":"","sources":["../../../../src/features/converters/utilities/restPopulateFn.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAE5D,eAAO,MAAM,iBAAiB,EAAE,CAAC,IAAI,EAAE;IACrC;;OAEG;IACH,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,KAAK,cAoBL,CAAA"}
+{"version":3,"file":"restPopulateFn.d.ts","sourceRoot":"","sources":["../../../../src/features/converters/utilities/restPopulateFn.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAA;AAErE,eAAO,MAAM,iBAAiB,EAAE,CAAC,IAAI,EAAE;IACrC;;OAEG;IACH,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,KAAK,cAoBL,CAAA"}

package/dist/features/converters/utilities/restPopulateFn.js.map

@@ -1 +1 @@
-{"version":3,"file":"restPopulateFn.js","names":["stringify","getRestPopulateFn","apiURL","depth","draft","locale","populateFn","id","collectionSlug","select","query","addQueryPrefix","res","fetch","credentials","headers","Accept","method","then","json"],"sources":["../../../../src/features/converters/utilities/restPopulateFn.ts"],"sourcesContent":["import { stringify } from 'qs-esm'\n\nimport type { HTMLPopulateFn } from '../html/async/types.js'\n\nexport const getRestPopulateFn: (args: {\n  /**\n   * E.g. `http://localhost:3000/api`\n   */\n  apiURL: string\n  depth?: number\n  draft?: boolean\n  locale?: string\n}) => HTMLPopulateFn = ({ apiURL, depth, draft, locale }) => {\n  const populateFn: HTMLPopulateFn = async ({ id, collectionSlug, select }) => {\n    const query = stringify(\n      { depth: depth ?? 0, draft: draft ?? false, locale, select },\n      { addQueryPrefix: true },\n    )\n\n    const res = await fetch(`${apiURL}/${collectionSlug}/${id}${query}`, {\n      credentials: 'include',\n      headers: {\n        Accept: 'application/json',\n        'Content-Type': 'application/json',\n      },\n      method: 'GET',\n    }).then((res) => res.json())\n\n    return res\n  }\n\n  return populateFn\n}\n"],"mappings":"AAAA,SAASA,SAAS,QAAQ;AAI1B,OAAO,MAAMC,iBAAA,GAQUA,CAAC;EAAEC,MAAM;EAAEC,KAAK;EAAEC,KAAK;EAAEC;AAAM,CAAE;EACtD,MAAMC,UAAA,GAA6B,MAAAA,CAAO;IAAEC,EAAE;IAAEC,cAAc;IAAEC;EAAM,CAAE;IACtE,MAAMC,KAAA,GAAQV,SAAA,CACZ;MAAEG,KAAA,EAAOA,KAAA,IAAS;MAAGC,KAAA,EAAOA,KAAA,IAAS;MAAOC,MAAA;MAAQI;IAAO,GAC3D;MAAEE,cAAA,EAAgB;IAAK;IAGzB,MAAMC,GAAA,GAAM,MAAMC,KAAA,CAAM,GAAGX,MAAA,IAAUM,cAAA,IAAkBD,EAAA,GAAKG,KAAA,EAAO,EAAE;MACnEI,WAAA,EAAa;MACbC,OAAA,EAAS;QACPC,MAAA,EAAQ;QACR,gBAAgB;MAClB;MACAC,MAAA,EAAQ;IACV,GAAGC,IAAI,CAAEN,GAAA,IAAQA,GAAA,CAAIO,IAAI;IAEzB,OAAOP,GAAA;EACT;EAEA,OAAON,UAAA;AACT","ignoreList":[]}
+{"version":3,"file":"restPopulateFn.js","names":["stringify","getRestPopulateFn","apiURL","depth","draft","locale","populateFn","id","collectionSlug","select","query","addQueryPrefix","res","fetch","credentials","headers","Accept","method","then","json"],"sources":["../../../../src/features/converters/utilities/restPopulateFn.ts"],"sourcesContent":["import { stringify } from 'qs-esm'\n\nimport type { HTMLPopulateFn } from '../lexicalToHtml/async/types.js'\n\nexport const getRestPopulateFn: (args: {\n  /**\n   * E.g. `http://localhost:3000/api`\n   */\n  apiURL: string\n  depth?: number\n  draft?: boolean\n  locale?: string\n}) => HTMLPopulateFn = ({ apiURL, depth, draft, locale }) => {\n  const populateFn: HTMLPopulateFn = async ({ id, collectionSlug, select }) => {\n    const query = stringify(\n      { depth: depth ?? 0, draft: draft ?? false, locale, select },\n      { addQueryPrefix: true },\n    )\n\n    const res = await fetch(`${apiURL}/${collectionSlug}/${id}${query}`, {\n      credentials: 'include',\n      headers: {\n        Accept: 'application/json',\n        'Content-Type': 'application/json',\n      },\n      method: 'GET',\n    }).then((res) => res.json())\n\n    return res\n  }\n\n  return populateFn\n}\n"],"mappings":"AAAA,SAASA,SAAS,QAAQ;AAI1B,OAAO,MAAMC,iBAAA,GAQUA,CAAC;EAAEC,MAAM;EAAEC,KAAK;EAAEC,KAAK;EAAEC;AAAM,CAAE;EACtD,MAAMC,UAAA,GAA6B,MAAAA,CAAO;IAAEC,EAAE;IAAEC,cAAc;IAAEC;EAAM,CAAE;IACtE,MAAMC,KAAA,GAAQV,SAAA,CACZ;MAAEG,KAAA,EAAOA,KAAA,IAAS;MAAGC,KAAA,EAAOA,KAAA,IAAS;MAAOC,MAAA;MAAQI;IAAO,GAC3D;MAAEE,cAAA,EAAgB;IAAK;IAGzB,MAAMC,GAAA,GAAM,MAAMC,KAAA,CAAM,GAAGX,MAAA,IAAUM,cAAA,IAAkBD,EAAA,GAAKG,KAAA,EAAO,EAAE;MACnEI,WAAA,EAAa;MACbC,OAAA,EAAS;QACPC,MAAA,EAAQ;QACR,gBAAgB;MAClB;MACAC,MAAA,EAAQ;IACV,GAAGC,IAAI,CAAEN,GAAA,IAAQA,GAAA,CAAIO,IAAI;IAEzB,OAAOP,GAAA;EACT;EAEA,OAAON,UAAA;AACT","ignoreList":[]}

package/dist/features/experimental_table/client/plugins/TableActionMenuPlugin/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/features/experimental_table/client/plugins/TableActionMenuPlugin/index.tsx"],"names":[],"mappings":"AA8CA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAA;AAE3E,OAAO,cAAc,CAAA;AAovBrB,eAAO,MAAM,qBAAqB,EAAE,yBAQnC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/features/experimental_table/client/plugins/TableActionMenuPlugin/index.tsx"],"names":[],"mappings":"AA+CA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAA;AAE3E,OAAO,cAAc,CAAA;AAmvBrB,eAAO,MAAM,qBAAqB,EAAE,yBAQnC,CAAA"}

package/dist/features/experimental_table/client/plugins/TableActionMenuPlugin/index.js

@@ -7,7 +7,7 @@ import { useLexicalEditable } from '@lexical/react/useLexicalEditable';
 import { $computeTableMapSkipCellCheck, $deleteTableColumn__EXPERIMENTAL, $deleteTableRow__EXPERIMENTAL, $getNodeTriplet, $getTableCellNodeFromLexicalNode, $getTableColumnIndexFromTableCellNode, $getTableNodeFromLexicalNodeOrThrow, $getTableRowIndexFromTableCellNode, $insertTableColumn__EXPERIMENTAL, $insertTableRow__EXPERIMENTAL, $isTableCellNode, $isTableSelection, $unmergeCell, getTableElement, getTableObserverFromTableElement, TableCellHeaderStates, TableCellNode } from '@lexical/table';
 import { mergeRegister } from '@lexical/utils';
 import { useScrollInfo } from '@payloadcms/ui';
-import { $createParagraphNode, $getRoot, $getSelection, $isElementNode, $isParagraphNode, $isRangeSelection, $isTextNode, COMMAND_PRIORITY_CRITICAL, getDOMSelection, isDOMNode, SELECTION_CHANGE_COMMAND } from 'lexical';
+import { $createParagraphNode, $getSelection, $isElementNode, $isParagraphNode, $isRangeSelection, $isTextNode, $setSelection, COMMAND_PRIORITY_CRITICAL, getDOMSelection, isDOMNode, SELECTION_CHANGE_COMMAND } from 'lexical';
 import * as React from 'react';
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { createPortal } from 'react-dom';
@@ -139,8 +139,7 @@ function TableActionMenu({
         tableNode.markDirty();
         updateTableCellNode(tableCellNode.getLatest());
       }
-      const rootNode = $getRoot();
-      rootNode.selectStart();
+      $setSelection(null);
     });
   }, [editor, tableCellNode]);
   const mergeTableCellsAtSelection = () => {
@@ -557,7 +556,7 @@ function TableCellActionMenuContainer({
   }, [editor, anchorElem]);
   useEffect(() => {
     // We call the $moveMenu callback every time the selection changes,
-    // once up front, and once after each mouseUp
+    // once up front, and once after each pointerup
     let timeoutId = undefined;
     const callback = () => {
       timeoutId = undefined;
@@ -571,10 +570,10 @@ function TableCellActionMenuContainer({
     };
     return mergeRegister(editor.registerUpdateListener(delayedCallback), editor.registerCommand(SELECTION_CHANGE_COMMAND, delayedCallback, COMMAND_PRIORITY_CRITICAL), editor.registerRootListener((rootElement_0, prevRootElement) => {
       if (prevRootElement) {
-        prevRootElement.removeEventListener('mouseup', delayedCallback);
+        prevRootElement.removeEventListener('pointerup', delayedCallback);
       }
       if (rootElement_0) {
-        rootElement_0.addEventListener('mouseup', delayedCallback);
+        rootElement_0.addEventListener('pointerup', delayedCallback);
         delayedCallback();
       }
     }), () => clearTimeout(timeoutId));