@payloadcms/richtext-lexical 3.68.0-internal-debug.e9b66ee → 3.68.0-internal.10bf491

package/dist/features/converters/lexicalToJSX/converter/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/features/converters/lexicalToJSX/converter/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nimport type {\n  DefaultNodeTypes,\n  SerializedBlockNode,\n  SerializedInlineBlockNode,\n} from '../../../../nodeTypes.js'\nexport type JSXConverter<T extends { [key: string]: any; type?: string } = SerializedLexicalNode> =\n  | ((args: {\n      childIndex: number\n      converters: JSXConverters\n      node: T\n      nodesToJSX: (args: {\n        converters?: JSXConverters\n        disableIndent?: boolean | string[]\n        disableTextAlign?: boolean | string[]\n        nodes: SerializedLexicalNode[]\n        parent?: SerializedLexicalNodeWithParent\n      }) => React.ReactNode[]\n      parent: SerializedLexicalNodeWithParent\n    }) => React.ReactNode)\n  | React.ReactNode\n\nexport type JSXConverters<\n  T extends { [key: string]: any; type?: string } =\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 }>, // need these to ensure types for blocks and inlineBlocks work if no generics are provided\n> = {\n  [key: string]:\n    | {\n        [blockSlug: string]: JSXConverter<any>\n      }\n    | JSXConverter<any>\n    | undefined\n} & {\n  [nodeType in Exclude<NonNullable<T['type']>, 'block' | 'inlineBlock'>]?: JSXConverter<\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    >]?: JSXConverter<\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    >]?: JSXConverter<\n      Extract<T, { type: 'inlineBlock' }> extends SerializedInlineBlockNode<infer B>\n        ? SerializedInlineBlockNode<Extract<B, { blockType: K }>>\n        : SerializedInlineBlockNode\n    >\n  }\n  unknown?: JSXConverter<SerializedLexicalNode>\n}\nexport type SerializedLexicalNodeWithParent = {\n  parent?: SerializedLexicalNode\n} & SerializedLexicalNode\n"],"names":[],"mappings":"AA0B4E,0FAA0F;AACnF,0FAA0F;AA2C7K,WAEyB"}
+{"version":3,"file":"types.js","names":[],"sources":["../../../../../src/features/converters/lexicalToJSX/converter/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nimport type {\n  DefaultNodeTypes,\n  SerializedBlockNode,\n  SerializedInlineBlockNode,\n} from '../../../../nodeTypes.js'\nexport type JSXConverter<T extends { [key: string]: any; type?: string } = SerializedLexicalNode> =\n  | ((args: {\n      childIndex: number\n      converters: JSXConverters\n      node: T\n      nodesToJSX: (args: {\n        converters?: JSXConverters\n        disableIndent?: boolean | string[]\n        disableTextAlign?: boolean | string[]\n        nodes: SerializedLexicalNode[]\n        parent?: SerializedLexicalNodeWithParent\n      }) => React.ReactNode[]\n      parent: SerializedLexicalNodeWithParent\n    }) => React.ReactNode)\n  | React.ReactNode\n\nexport type JSXConverters<\n  T extends { [key: string]: any; type?: string } =\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 }>, // need these to ensure types for blocks and inlineBlocks work if no generics are provided\n> = {\n  [key: string]:\n    | {\n        [blockSlug: string]: JSXConverter<any>\n      }\n    | JSXConverter<any>\n    | undefined\n} & {\n  [nodeType in Exclude<NonNullable<T['type']>, 'block' | 'inlineBlock'>]?: JSXConverter<\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    >]?: JSXConverter<\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    >]?: JSXConverter<\n      Extract<T, { type: 'inlineBlock' }> extends SerializedInlineBlockNode<infer B>\n        ? SerializedInlineBlockNode<Extract<B, { blockType: K }>>\n        : SerializedInlineBlockNode\n    >\n  }\n  unknown?: JSXConverter<SerializedLexicalNode>\n}\nexport type SerializedLexicalNodeWithParent = {\n  parent?: SerializedLexicalNode\n} & SerializedLexicalNode\n"],"mappings":"AAsEA","ignoreList":[]}

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

@@ -1,22 +1,24 @@
 import { createHeadlessEditor } from '@lexical/headless';
 import { getEnabledNodes } from '../../../lexical/nodes/index.js';
 import { $convertToMarkdownString } from '../../../packages/@lexical/markdown/index.js';
-export const convertLexicalToMarkdown = ({ data, editorConfig })=>{
-    const headlessEditor = createHeadlessEditor({
-        nodes: getEnabledNodes({
-            editorConfig
-        })
-    });
-    headlessEditor.update(()=>{
-        headlessEditor.setEditorState(headlessEditor.parseEditorState(data));
-    }, {
-        discrete: true
-    });
-    let markdown = '';
-    headlessEditor.getEditorState().read(()=>{
-        markdown = $convertToMarkdownString(editorConfig?.features?.markdownTransformers);
-    });
-    return markdown;
+export const convertLexicalToMarkdown = ({
+  data,
+  editorConfig
+}) => {
+  const headlessEditor = createHeadlessEditor({
+    nodes: getEnabledNodes({
+      editorConfig
+    })
+  });
+  headlessEditor.update(() => {
+    headlessEditor.setEditorState(headlessEditor.parseEditorState(data));
+  }, {
+    discrete: true
+  });
+  let markdown = '';
+  headlessEditor.getEditorState().read(() => {
+    markdown = $convertToMarkdownString(editorConfig?.features?.markdownTransformers);
+  });
+  return markdown;
 };
-
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/features/converters/lexicalToMarkdown/index.ts"],"sourcesContent":["import type { SerializedEditorState } from 'lexical'\n\nimport { createHeadlessEditor } from '@lexical/headless'\n\nimport type { SanitizedServerEditorConfig } from '../../../lexical/config/types.js'\n\nimport { getEnabledNodes } from '../../../lexical/nodes/index.js'\nimport { $convertToMarkdownString } from '../../../packages/@lexical/markdown/index.js'\n\nexport const convertLexicalToMarkdown = ({\n  data,\n  editorConfig,\n}: {\n  data: SerializedEditorState\n  editorConfig: SanitizedServerEditorConfig\n}): string => {\n  const headlessEditor = createHeadlessEditor({\n    nodes: getEnabledNodes({\n      editorConfig,\n    }),\n  })\n\n  headlessEditor.update(\n    () => {\n      headlessEditor.setEditorState(headlessEditor.parseEditorState(data))\n    },\n    { discrete: true },\n  )\n\n  let markdown: string = ''\n  headlessEditor.getEditorState().read(() => {\n    markdown = $convertToMarkdownString(editorConfig?.features?.markdownTransformers)\n  })\n\n  return markdown\n}\n"],"names":["createHeadlessEditor","getEnabledNodes","$convertToMarkdownString","convertLexicalToMarkdown","data","editorConfig","headlessEditor","nodes","update","setEditorState","parseEditorState","discrete","markdown","getEditorState","read","features","markdownTransformers"],"mappings":"AAEA,SAASA,oBAAoB,QAAQ,oBAAmB;AAIxD,SAASC,eAAe,QAAQ,kCAAiC;AACjE,SAASC,wBAAwB,QAAQ,+CAA8C;AAEvF,OAAO,MAAMC,2BAA2B,CAAC,EACvCC,IAAI,EACJC,YAAY,EAIb;IACC,MAAMC,iBAAiBN,qBAAqB;QAC1CO,OAAON,gBAAgB;YACrBI;QACF;IACF;IAEAC,eAAeE,MAAM,CACnB;QACEF,eAAeG,cAAc,CAACH,eAAeI,gBAAgB,CAACN;IAChE,GACA;QAAEO,UAAU;IAAK;IAGnB,IAAIC,WAAmB;IACvBN,eAAeO,cAAc,GAAGC,IAAI,CAAC;QACnCF,WAAWV,yBAAyBG,cAAcU,UAAUC;IAC9D;IAEA,OAAOJ;AACT,EAAC"}
+{"version":3,"file":"index.js","names":["createHeadlessEditor","getEnabledNodes","$convertToMarkdownString","convertLexicalToMarkdown","data","editorConfig","headlessEditor","nodes","update","setEditorState","parseEditorState","discrete","markdown","getEditorState","read","features","markdownTransformers"],"sources":["../../../../src/features/converters/lexicalToMarkdown/index.ts"],"sourcesContent":["import type { SerializedEditorState } from 'lexical'\n\nimport { createHeadlessEditor } from '@lexical/headless'\n\nimport type { SanitizedServerEditorConfig } from '../../../lexical/config/types.js'\n\nimport { getEnabledNodes } from '../../../lexical/nodes/index.js'\nimport { $convertToMarkdownString } from '../../../packages/@lexical/markdown/index.js'\n\nexport const convertLexicalToMarkdown = ({\n  data,\n  editorConfig,\n}: {\n  data: SerializedEditorState\n  editorConfig: SanitizedServerEditorConfig\n}): string => {\n  const headlessEditor = createHeadlessEditor({\n    nodes: getEnabledNodes({\n      editorConfig,\n    }),\n  })\n\n  headlessEditor.update(\n    () => {\n      headlessEditor.setEditorState(headlessEditor.parseEditorState(data))\n    },\n    { discrete: true },\n  )\n\n  let markdown: string = ''\n  headlessEditor.getEditorState().read(() => {\n    markdown = $convertToMarkdownString(editorConfig?.features?.markdownTransformers)\n  })\n\n  return markdown\n}\n"],"mappings":"AAEA,SAASA,oBAAoB,QAAQ;AAIrC,SAASC,eAAe,QAAQ;AAChC,SAASC,wBAAwB,QAAQ;AAEzC,OAAO,MAAMC,wBAAA,GAA2BA,CAAC;EACvCC,IAAI;EACJC;AAAY,CAIb;EACC,MAAMC,cAAA,GAAiBN,oBAAA,CAAqB;IAC1CO,KAAA,EAAON,eAAA,CAAgB;MACrBI;IACF;EACF;EAEAC,cAAA,CAAeE,MAAM,CACnB;IACEF,cAAA,CAAeG,cAAc,CAACH,cAAA,CAAeI,gBAAgB,CAACN,IAAA;EAChE,GACA;IAAEO,QAAA,EAAU;EAAK;EAGnB,IAAIC,QAAA,GAAmB;EACvBN,cAAA,CAAeO,cAAc,GAAGC,IAAI,CAAC;IACnCF,QAAA,GAAWV,wBAAA,CAAyBG,YAAA,EAAcU,QAAA,EAAUC,oBAAA;EAC9D;EAEA,OAAOJ,QAAA;AACT","ignoreList":[]}

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

@@ -1,256 +1,179 @@
 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
-    };
+  return {
+    type: 'text',
+    detail: 0,
+    format: bold ? 1 : 0,
+    mode: 'normal',
+    style: '',
+    text,
+    version: 1
+  };
 }
 function linebreakNode() {
-    return {
-        type: 'linebreak',
-        version: 1
-    };
+  return {
+    type: 'linebreak',
+    version: 1
+  };
 }
 function tabNode() {
-    return {
-        type: 'tab',
-        detail: 0,
-        format: 0,
-        mode: 'normal',
-        style: '',
-        text: '',
-        version: 1
-    };
+  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
-    };
+  return {
+    type: 'paragraph',
+    children,
+    direction: 'ltr',
+    format: '',
+    indent: 0,
+    textFormat: 0,
+    version: 1
+  };
 }
 function headingNode(children) {
-    return {
-        type: 'heading',
-        children,
-        direction: 'ltr',
-        format: '',
-        indent: 0,
-        textFormat: 0,
-        tag: 'h1',
-        version: 1
-    };
+  return {
+    type: 'heading',
+    children,
+    direction: 'ltr',
+    format: '',
+    indent: 0,
+    textFormat: 0,
+    tag: 'h1',
+    version: 1
+  };
 }
 function listItemNode(children) {
-    return {
-        type: 'listitem',
-        children,
-        checked: false,
-        direction: 'ltr',
-        format: '',
-        indent: 0,
-        value: 0,
-        version: 1
-    };
+  return {
+    type: 'listitem',
+    children,
+    checked: false,
+    direction: 'ltr',
+    format: '',
+    indent: 0,
+    value: 0,
+    version: 1
+  };
 }
 function listNode(children) {
-    return {
-        type: 'list',
-        children,
-        direction: 'ltr',
-        format: '',
-        indent: 0,
-        listType: 'bullet',
-        start: 0,
-        tag: 'ul',
-        version: 1
-    };
+  return {
+    type: 'list',
+    children,
+    direction: 'ltr',
+    format: '',
+    indent: 0,
+    listType: 'bullet',
+    start: 0,
+    tag: 'ul',
+    version: 1
+  };
 }
 function tableNode(children) {
-    return {
-        type: 'table',
-        children,
-        direction: 'ltr',
-        format: '',
-        indent: 0,
-        version: 1
-    };
+  return {
+    type: 'table',
+    children,
+    direction: 'ltr',
+    format: '',
+    indent: 0,
+    version: 1
+  };
 }
 function tableRowNode(children) {
-    return {
-        type: 'tablerow',
-        children,
-        direction: 'ltr',
-        format: '',
-        indent: 0,
-        version: 1
-    };
+  return {
+    type: 'tablerow',
+    children,
+    direction: 'ltr',
+    format: '',
+    indent: 0,
+    version: 1
+  };
 }
 function tableCellNode(children) {
-    return {
-        type: 'tablecell',
-        children,
-        direction: 'ltr',
-        format: '',
-        indent: 0,
-        headerState: 0,
-        version: 1
-    };
+  return {
+    type: 'tablecell',
+    children,
+    direction: 'ltr',
+    format: '',
+    indent: 0,
+    headerState: 0,
+    version: 1
+  };
 }
 function rootNode(nodes) {
-    return {
-        root: {
-            type: 'root',
-            children: nodes,
-            direction: 'ltr',
-            format: '',
-            indent: 0,
-            version: 1
-        }
-    };
+  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
-        });
-        expect(plaintext).toBe('Basic Text');
+describe('convertLexicalToPlaintext', () => {
+  it('ensure paragraph with text is correctly converted', () => {
+    const data = rootNode([paragraphNode([textNode('Basic Text')])]);
+    const plaintext = convertLexicalToPlaintext({
+      data
     });
-    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');
+    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
     });
-    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');
+    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
     });
-    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');
+    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
     });
-    it('ensure new lines are added between paragraphs', ()=>{
-        const data = rootNode([
-            paragraphNode([
-                textNode('Basic text')
-            ]),
-            paragraphNode([
-                textNode('Next block-node')
-            ])
-        ]);
-        const plaintext = convertLexicalToPlaintext({
-            data
-        });
-        expect(plaintext).toBe('Basic text\n\nNext block-node');
+    expect(plaintext).toBe('Basic Text\tNext Line');
+  });
+  it('ensure new lines are added between paragraphs', () => {
+    const data = rootNode([paragraphNode([textNode('Basic text')]), paragraphNode([textNode('Next block-node')])]);
+    const plaintext = convertLexicalToPlaintext({
+      data
     });
-    it('ensure new lines are added between heading nodes', ()=>{
-        const data = rootNode([
-            headingNode([
-                textNode('Basic text')
-            ]),
-            headingNode([
-                textNode('Next block-node')
-            ])
-        ]);
-        const plaintext = convertLexicalToPlaintext({
-            data
-        });
-        expect(plaintext).toBe('Basic text\n\nNext block-node');
+    expect(plaintext).toBe('Basic text\n\nNext block-node');
+  });
+  it('ensure new lines are added between heading nodes', () => {
+    const data = rootNode([headingNode([textNode('Basic text')]), headingNode([textNode('Next block-node')])]);
+    const plaintext = convertLexicalToPlaintext({
+      data
     });
-    it('ensure new lines are added between list items and lists', ()=>{
-        const data = rootNode([
-            listNode([
-                listItemNode([
-                    textNode('First item')
-                ]),
-                listItemNode([
-                    textNode('Second item')
-                ])
-            ]),
-            listNode([
-                listItemNode([
-                    textNode('Next list')
-                ])
-            ])
-        ]);
-        const plaintext = convertLexicalToPlaintext({
-            data
-        });
-        expect(plaintext).toBe('First item\nSecond item\n\nNext list');
+    expect(plaintext).toBe('Basic text\n\nNext block-node');
+  });
+  it('ensure new lines are added between list items and lists', () => {
+    const data = rootNode([listNode([listItemNode([textNode('First item')]), listItemNode([textNode('Second item')])]), listNode([listItemNode([textNode('Next list')])])]);
+    const plaintext = convertLexicalToPlaintext({
+      data
     });
-    it('ensure new lines are added between tables, table rows, and table cells', ()=>{
-        const data = rootNode([
-            tableNode([
-                tableRowNode([
-                    tableCellNode([
-                        textNode('Cell 1, Row 1')
-                    ]),
-                    tableCellNode([
-                        textNode('Cell 2, Row 1')
-                    ])
-                ]),
-                tableRowNode([
-                    tableCellNode([
-                        textNode('Cell 1, Row 2')
-                    ]),
-                    tableCellNode([
-                        textNode('Cell 2, Row 2')
-                    ])
-                ])
-            ]),
-            tableNode([
-                tableRowNode([
-                    tableCellNode([
-                        textNode('Cell in Table 2')
-                    ])
-                ])
-            ])
-        ]);
-        const plaintext = convertLexicalToPlaintext({
-            data
-        });
-        expect(plaintext).toBe('Cell 1, Row 1 | Cell 2, Row 1\nCell 1, Row 2 | Cell 2, Row 2\n\nCell in Table 2');
+    expect(plaintext).toBe('First item\nSecond item\n\nNext list');
+  });
+  it('ensure new lines are added between tables, table rows, and table cells', () => {
+    const data = rootNode([tableNode([tableRowNode([tableCellNode([textNode('Cell 1, Row 1')]), tableCellNode([textNode('Cell 2, Row 1')])]), tableRowNode([tableCellNode([textNode('Cell 1, Row 2')]), tableCellNode([textNode('Cell 2, Row 2')])])]), tableNode([tableRowNode([tableCellNode([textNode('Cell in Table 2')])])])]);
+    const plaintext = convertLexicalToPlaintext({
+      data
     });
+    expect(plaintext).toBe('Cell 1, Row 1 | Cell 2, Row 1\nCell 1, Row 2 | Cell 2, Row 2\n\nCell in Table 2');
+  });
 });
-
 //# sourceMappingURL=convertLexicalToPlaintext.spec.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/features/converters/lexicalToPlaintext/convertLexicalToPlaintext.spec.ts"],"sourcesContent":["import type {\n  DefaultNodeTypes,\n  DefaultTypedEditorState,\n  SerializedTabNode,\n  SerializedParagraphNode,\n  SerializedTextNode,\n  SerializedLineBreakNode,\n  SerializedHeadingNode,\n  SerializedListItemNode,\n  SerializedListNode,\n  SerializedTableRowNode,\n  SerializedTableNode,\n  SerializedTableCellNode,\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 headingNode(children: DefaultNodeTypes[]): SerializedHeadingNode {\n  return {\n    type: 'heading',\n    children,\n    direction: 'ltr',\n    format: '',\n    indent: 0,\n    textFormat: 0,\n    tag: 'h1',\n    version: 1,\n  }\n}\n\nfunction listItemNode(children: DefaultNodeTypes[]): SerializedListItemNode {\n  return {\n    type: 'listitem',\n    children,\n    checked: false,\n    direction: 'ltr',\n    format: '',\n    indent: 0,\n    value: 0,\n    version: 1,\n  }\n}\n\nfunction listNode(children: DefaultNodeTypes[]): SerializedListNode {\n  return {\n    type: 'list',\n    children,\n    direction: 'ltr',\n    format: '',\n    indent: 0,\n    listType: 'bullet',\n    start: 0,\n    tag: 'ul',\n    version: 1,\n  }\n}\n\nfunction tableNode(children: (DefaultNodeTypes | SerializedTableRowNode)[]): SerializedTableNode {\n  return {\n    type: 'table',\n    children,\n    direction: 'ltr',\n    format: '',\n    indent: 0,\n    version: 1,\n  }\n}\n\nfunction tableRowNode(\n  children: (DefaultNodeTypes | SerializedTableCellNode)[],\n): SerializedTableRowNode {\n  return {\n    type: 'tablerow',\n    children,\n    direction: 'ltr',\n    format: '',\n    indent: 0,\n    version: 1,\n  }\n}\n\nfunction tableCellNode(children: DefaultNodeTypes[]): SerializedTableCellNode {\n  return {\n    type: 'tablecell',\n    children,\n    direction: 'ltr',\n    format: '',\n    indent: 0,\n    headerState: 0,\n    version: 1,\n  }\n}\n\nfunction rootNode(nodes: (DefaultNodeTypes | SerializedTableNode)[]): 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    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  it('ensure new lines are added between paragraphs', () => {\n    const data: DefaultTypedEditorState = rootNode([\n      paragraphNode([textNode('Basic text')]),\n      paragraphNode([textNode('Next block-node')]),\n    ])\n\n    const plaintext = convertLexicalToPlaintext({\n      data,\n    })\n\n    expect(plaintext).toBe('Basic text\\n\\nNext block-node')\n  })\n\n  it('ensure new lines are added between heading nodes', () => {\n    const data: DefaultTypedEditorState = rootNode([\n      headingNode([textNode('Basic text')]),\n      headingNode([textNode('Next block-node')]),\n    ])\n\n    const plaintext = convertLexicalToPlaintext({\n      data,\n    })\n\n    expect(plaintext).toBe('Basic text\\n\\nNext block-node')\n  })\n\n  it('ensure new lines are added between list items and lists', () => {\n    const data: DefaultTypedEditorState = rootNode([\n      listNode([listItemNode([textNode('First item')]), listItemNode([textNode('Second item')])]),\n      listNode([listItemNode([textNode('Next list')])]),\n    ])\n\n    const plaintext = convertLexicalToPlaintext({\n      data,\n    })\n\n    expect(plaintext).toBe('First item\\nSecond item\\n\\nNext list')\n  })\n\n  it('ensure new lines are added between tables, table rows, and table cells', () => {\n    const data: DefaultTypedEditorState = rootNode([\n      tableNode([\n        tableRowNode([\n          tableCellNode([textNode('Cell 1, Row 1')]),\n          tableCellNode([textNode('Cell 2, Row 1')]),\n        ]),\n        tableRowNode([\n          tableCellNode([textNode('Cell 1, Row 2')]),\n          tableCellNode([textNode('Cell 2, Row 2')]),\n        ]),\n      ]),\n      tableNode([tableRowNode([tableCellNode([textNode('Cell in Table 2')])])]),\n    ])\n\n    const plaintext = convertLexicalToPlaintext({\n      data,\n    })\n\n    expect(plaintext).toBe(\n      'Cell 1, Row 1 | Cell 2, Row 1\\nCell 1, Row 2 | Cell 2, Row 2\\n\\nCell in Table 2',\n    )\n  })\n})\n"],"names":["convertLexicalToPlaintext","textNode","text","bold","type","detail","format","mode","style","version","linebreakNode","tabNode","paragraphNode","children","direction","indent","textFormat","headingNode","tag","listItemNode","checked","value","listNode","listType","start","tableNode","tableRowNode","tableCellNode","headerState","rootNode","nodes","root","describe","it","data","plaintext","expect","toBe"],"mappings":"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"}
+{"version":3,"file":"convertLexicalToPlaintext.spec.js","names":["convertLexicalToPlaintext","textNode","text","bold","type","detail","format","mode","style","version","linebreakNode","tabNode","paragraphNode","children","direction","indent","textFormat","headingNode","tag","listItemNode","checked","value","listNode","listType","start","tableNode","tableRowNode","tableCellNode","headerState","rootNode","nodes","root","describe","it","data","plaintext","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  SerializedHeadingNode,\n  SerializedListItemNode,\n  SerializedListNode,\n  SerializedTableRowNode,\n  SerializedTableNode,\n  SerializedTableCellNode,\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 headingNode(children: DefaultNodeTypes[]): SerializedHeadingNode {\n  return {\n    type: 'heading',\n    children,\n    direction: 'ltr',\n    format: '',\n    indent: 0,\n    textFormat: 0,\n    tag: 'h1',\n    version: 1,\n  }\n}\n\nfunction listItemNode(children: DefaultNodeTypes[]): SerializedListItemNode {\n  return {\n    type: 'listitem',\n    children,\n    checked: false,\n    direction: 'ltr',\n    format: '',\n    indent: 0,\n    value: 0,\n    version: 1,\n  }\n}\n\nfunction listNode(children: DefaultNodeTypes[]): SerializedListNode {\n  return {\n    type: 'list',\n    children,\n    direction: 'ltr',\n    format: '',\n    indent: 0,\n    listType: 'bullet',\n    start: 0,\n    tag: 'ul',\n    version: 1,\n  }\n}\n\nfunction tableNode(children: (DefaultNodeTypes | SerializedTableRowNode)[]): SerializedTableNode {\n  return {\n    type: 'table',\n    children,\n    direction: 'ltr',\n    format: '',\n    indent: 0,\n    version: 1,\n  }\n}\n\nfunction tableRowNode(\n  children: (DefaultNodeTypes | SerializedTableCellNode)[],\n): SerializedTableRowNode {\n  return {\n    type: 'tablerow',\n    children,\n    direction: 'ltr',\n    format: '',\n    indent: 0,\n    version: 1,\n  }\n}\n\nfunction tableCellNode(children: DefaultNodeTypes[]): SerializedTableCellNode {\n  return {\n    type: 'tablecell',\n    children,\n    direction: 'ltr',\n    format: '',\n    indent: 0,\n    headerState: 0,\n    version: 1,\n  }\n}\n\nfunction rootNode(nodes: (DefaultNodeTypes | SerializedTableNode)[]): 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    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  it('ensure new lines are added between paragraphs', () => {\n    const data: DefaultTypedEditorState = rootNode([\n      paragraphNode([textNode('Basic text')]),\n      paragraphNode([textNode('Next block-node')]),\n    ])\n\n    const plaintext = convertLexicalToPlaintext({\n      data,\n    })\n\n    expect(plaintext).toBe('Basic text\\n\\nNext block-node')\n  })\n\n  it('ensure new lines are added between heading nodes', () => {\n    const data: DefaultTypedEditorState = rootNode([\n      headingNode([textNode('Basic text')]),\n      headingNode([textNode('Next block-node')]),\n    ])\n\n    const plaintext = convertLexicalToPlaintext({\n      data,\n    })\n\n    expect(plaintext).toBe('Basic text\\n\\nNext block-node')\n  })\n\n  it('ensure new lines are added between list items and lists', () => {\n    const data: DefaultTypedEditorState = rootNode([\n      listNode([listItemNode([textNode('First item')]), listItemNode([textNode('Second item')])]),\n      listNode([listItemNode([textNode('Next list')])]),\n    ])\n\n    const plaintext = convertLexicalToPlaintext({\n      data,\n    })\n\n    expect(plaintext).toBe('First item\\nSecond item\\n\\nNext list')\n  })\n\n  it('ensure new lines are added between tables, table rows, and table cells', () => {\n    const data: DefaultTypedEditorState = rootNode([\n      tableNode([\n        tableRowNode([\n          tableCellNode([textNode('Cell 1, Row 1')]),\n          tableCellNode([textNode('Cell 2, Row 1')]),\n        ]),\n        tableRowNode([\n          tableCellNode([textNode('Cell 1, Row 2')]),\n          tableCellNode([textNode('Cell 2, Row 2')]),\n        ]),\n      ]),\n      tableNode([tableRowNode([tableCellNode([textNode('Cell in Table 2')])])]),\n    ])\n\n    const plaintext = convertLexicalToPlaintext({\n      data,\n    })\n\n    expect(plaintext).toBe(\n      'Cell 1, Row 1 | Cell 2, Row 1\\nCell 1, Row 2 | Cell 2, Row 2\\n\\nCell in Table 2',\n    )\n  })\n})\n"],"mappings":"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","ignoreList":[]}

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

@@ -1,13 +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;
+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

@@ -1 +1 @@
-{"version":3,"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"],"names":["findConverterForNode","converters","node","converterForNode","type","blocks","fields","blockType","inlineBlocks"],"mappings":"AAKA,OAAO,SAASA,qBAGd,EACAC,UAAU,EAEVC,IAAI,EAIL;IACC,IAAIC;IACJ,IAAID,KAAKE,IAAI,KAAK,SAAS;QACzBD,mBAAmBF,YAAYI,QAAQ,CACpCH,MAA8BI,QAAQC,UACxC;IACH,OAAO,IAAIL,KAAKE,IAAI,KAAK,eAAe;QACtCD,mBAAmBF,YAAYO,cAAc,CAC1CN,MAAoCI,QAAQC,UAC9C;IACH,OAAO;QACLJ,mBAAmBF,UAAU,CAACC,KAAKE,IAAI,CAAC;IAC1C;IAEA,OAAOD;AACT"}
+{"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.js

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

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/features/converters/lexicalToPlaintext/shared/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\nexport type SerializedLexicalNodeWithParent = {\n  parent?: SerializedLexicalNode\n} & SerializedLexicalNode\n"],"names":[],"mappings":"AACA,WAEyB"}
+{"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":[]}