@payloadcms/richtext-lexical 3.68.0-internal-debug.591ab42 → 3.68.0-internal.2b8df4a

package/dist/features/converters/lexicalToJSX/converter/index.js

@@ -1,129 +1,134 @@
-import { jsxDEV as _jsxDEV, Fragment as _Fragment } from "react/jsx-dev-runtime";
-/* eslint-disable no-console */ import React from 'react';
+/* eslint-disable no-console */import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import React from 'react';
 import { hasText } from '../../../../validate/hasText.js';
-export function convertLexicalToJSX({ converters, data, disableIndent, disableTextAlign }) {
-    if (hasText(data)) {
-        return convertLexicalNodesToJSX({
-            converters,
-            disableIndent,
-            disableTextAlign,
-            nodes: data?.root?.children,
-            parent: data?.root
-        });
-    }
-    return /*#__PURE__*/ _jsxDEV(_Fragment, {}, void 0, false);
+export function convertLexicalToJSX({
+  converters,
+  data,
+  disableIndent,
+  disableTextAlign
+}) {
+  if (hasText(data)) {
+    return convertLexicalNodesToJSX({
+      converters,
+      disableIndent,
+      disableTextAlign,
+      nodes: data?.root?.children,
+      parent: data?.root
+    });
+  }
+  return /*#__PURE__*/_jsx(_Fragment, {});
 }
-export function convertLexicalNodesToJSX({ converters, disableIndent, disableTextAlign, nodes, parent }) {
-    const unknownConverter = converters.unknown;
-    const jsxArray = nodes.map((node, i)=>{
-        let converterForNode;
-        if (node.type === 'block') {
-            converterForNode = converters?.blocks?.[node?.fields?.blockType];
-            if (!converterForNode && !unknownConverter) {
-                console.error(`Lexical => JSX converter: Blocks converter: found ${node?.fields?.blockType} block, but no converter is provided`);
-            }
-        } else if (node.type === 'inlineBlock') {
-            converterForNode = converters?.inlineBlocks?.[node?.fields?.blockType];
-            if (!converterForNode && !unknownConverter) {
-                console.error(`Lexical => JSX converter: Inline Blocks converter: found ${node?.fields?.blockType} inline block, but no converter is provided`);
-            }
-        } else {
-            converterForNode = converters[node.type];
+export function convertLexicalNodesToJSX({
+  converters,
+  disableIndent,
+  disableTextAlign,
+  nodes,
+  parent
+}) {
+  const unknownConverter = converters.unknown;
+  const jsxArray = nodes.map((node, i) => {
+    let converterForNode;
+    if (node.type === 'block') {
+      converterForNode = converters?.blocks?.[node?.fields?.blockType];
+      if (!converterForNode && !unknownConverter) {
+        console.error(`Lexical => JSX converter: Blocks converter: found ${node?.fields?.blockType} block, but no converter is provided`);
+      }
+    } else if (node.type === 'inlineBlock') {
+      converterForNode = converters?.inlineBlocks?.[node?.fields?.blockType];
+      if (!converterForNode && !unknownConverter) {
+        console.error(`Lexical => JSX converter: Inline Blocks converter: found ${node?.fields?.blockType} inline block, but no converter is provided`);
+      }
+    } else {
+      converterForNode = converters[node.type];
+    }
+    try {
+      if (!converterForNode && unknownConverter) {
+        converterForNode = unknownConverter;
+      }
+      let reactNode;
+      if (converterForNode) {
+        const converted = typeof converterForNode === 'function' ? converterForNode({
+          childIndex: i,
+          converters,
+          node,
+          nodesToJSX: args => {
+            return convertLexicalNodesToJSX({
+              converters: args.converters ?? converters,
+              disableIndent: args.disableIndent ?? disableIndent,
+              disableTextAlign: args.disableTextAlign ?? disableTextAlign,
+              nodes: args.nodes,
+              parent: args.parent ?? {
+                ...node,
+                parent
+              }
+            });
+          },
+          parent
+        }) : converterForNode;
+        reactNode = converted;
+      } else {
+        reactNode = /*#__PURE__*/_jsx("span", {
+          children: "unknown node"
+        }, i);
+      }
+      const style = {};
+      // Check if disableTextAlign is not true and does not include node type
+      if (!disableTextAlign && (!Array.isArray(disableTextAlign) || !disableTextAlign?.includes(node.type))) {
+        if ('format' in node && node.format) {
+          switch (node.format) {
+            case 'center':
+              style.textAlign = 'center';
+              break;
+            case 'end':
+              style.textAlign = 'right';
+              break;
+            case 'justify':
+              style.textAlign = 'justify';
+              break;
+            case 'left':
+              break;
+            case 'right':
+              style.textAlign = 'right';
+              break;
+            case 'start':
+              style.textAlign = 'left';
+              break;
+          }
         }
-        try {
-            if (!converterForNode && unknownConverter) {
-                converterForNode = unknownConverter;
-            }
-            let reactNode;
-            if (converterForNode) {
-                const converted = typeof converterForNode === 'function' ? converterForNode({
-                    childIndex: i,
-                    converters,
-                    node,
-                    nodesToJSX: (args)=>{
-                        return convertLexicalNodesToJSX({
-                            converters: args.converters ?? converters,
-                            disableIndent: args.disableIndent ?? disableIndent,
-                            disableTextAlign: args.disableTextAlign ?? disableTextAlign,
-                            nodes: args.nodes,
-                            parent: args.parent ?? {
-                                ...node,
-                                parent
-                            }
-                        });
-                    },
-                    parent
-                }) : converterForNode;
-                reactNode = converted;
-            } else {
-                reactNode = /*#__PURE__*/ _jsxDEV("span", {
-                    children: "unknown node"
-                }, i, false, {
-                    fileName: "src/features/converters/lexicalToJSX/converter/index.tsx",
-                    lineNumber: 102,
-                    columnNumber: 21
-                }, this);
-            }
-            const style = {};
-            // Check if disableTextAlign is not true and does not include node type
-            if (!disableTextAlign && (!Array.isArray(disableTextAlign) || !disableTextAlign?.includes(node.type))) {
-                if ('format' in node && node.format) {
-                    switch(node.format){
-                        case 'center':
-                            style.textAlign = 'center';
-                            break;
-                        case 'end':
-                            style.textAlign = 'right';
-                            break;
-                        case 'justify':
-                            style.textAlign = 'justify';
-                            break;
-                        case 'left':
-                            break;
-                        case 'right':
-                            style.textAlign = 'right';
-                            break;
-                        case 'start':
-                            style.textAlign = 'left';
-                            break;
-                    }
-                }
-            }
-            if (!disableIndent && (!Array.isArray(disableIndent) || !disableIndent?.includes(node.type))) {
-                if ('indent' in node && node.indent && node.type !== 'listitem') {
-                    // the unit should be px. Do not change it to rem, em, or something else.
-                    // The quantity should be 40px. Do not change it either.
-                    // See rationale in
-                    // https://github.com/payloadcms/payload/issues/13130#issuecomment-3058348085
-                    style.paddingInlineStart = `${Number(node.indent) * 40}px`;
-                }
-            }
-            if (/*#__PURE__*/ React.isValidElement(reactNode)) {
-                // Inject style into reactNode
-                if (style.textAlign || style.paddingInlineStart) {
-                    const newStyle = {
-                        ...style,
-                        // @ts-expect-error type better later
-                        ...reactNode?.props?.style ?? {}
-                    };
-                    // reactNode style comes after, thus a textAlign specified in the converter has priority over the one we inject here
-                    return /*#__PURE__*/ React.cloneElement(reactNode, {
-                        key: i,
-                        // @ts-expect-error type better later
-                        style: newStyle
-                    });
-                }
-                return /*#__PURE__*/ React.cloneElement(reactNode, {
-                    key: i
-                });
-            }
-            return reactNode;
-        } catch (error) {
-            console.error('Error converting lexical node to JSX:', error, 'node:', node);
-            return null;
+      }
+      if (!disableIndent && (!Array.isArray(disableIndent) || !disableIndent?.includes(node.type))) {
+        if ('indent' in node && node.indent && node.type !== 'listitem') {
+          // the unit should be px. Do not change it to rem, em, or something else.
+          // The quantity should be 40px. Do not change it either.
+          // See rationale in
+          // https://github.com/payloadcms/payload/issues/13130#issuecomment-3058348085
+          style.paddingInlineStart = `${Number(node.indent) * 40}px`;
         }
-    });
-    return jsxArray.filter(Boolean);
+      }
+      if (/*#__PURE__*/React.isValidElement(reactNode)) {
+        // Inject style into reactNode
+        if (style.textAlign || style.paddingInlineStart) {
+          const newStyle = {
+            ...style,
+            // @ts-expect-error type better later
+            ...(reactNode?.props?.style ?? {})
+          };
+          return /*#__PURE__*/React.cloneElement(reactNode, {
+            key: i,
+            // @ts-expect-error type better later
+            style: newStyle
+          });
+        }
+        return /*#__PURE__*/React.cloneElement(reactNode, {
+          key: i
+        });
+      }
+      return reactNode;
+    } catch (error) {
+      console.error('Error converting lexical node to JSX:', error, 'node:', node);
+      return null;
+    }
+  });
+  return jsxArray.filter(Boolean);
 }
-
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/features/converters/lexicalToJSX/converter/index.tsx"],"sourcesContent":["/* eslint-disable no-console */\nimport type { SerializedEditorState, SerializedLexicalNode } from 'lexical'\n\nimport React from 'react'\n\nimport type { SerializedBlockNode, SerializedInlineBlockNode } from '../../../../nodeTypes.js'\nimport type { JSXConverter, JSXConverters, SerializedLexicalNodeWithParent } from './types.js'\n\nimport { hasText } from '../../../../validate/hasText.js'\n\nexport type ConvertLexicalToJSXArgs = {\n  converters: JSXConverters\n  data: SerializedEditorState\n  disableIndent?: boolean | string[]\n  disableTextAlign?: boolean | string[]\n}\n\nexport function convertLexicalToJSX({\n  converters,\n  data,\n  disableIndent,\n  disableTextAlign,\n}: ConvertLexicalToJSXArgs): React.ReactNode {\n  if (hasText(data)) {\n    return convertLexicalNodesToJSX({\n      converters,\n      disableIndent,\n      disableTextAlign,\n      nodes: data?.root?.children,\n      parent: data?.root,\n    })\n  }\n  return <></>\n}\n\nexport function convertLexicalNodesToJSX({\n  converters,\n  disableIndent,\n  disableTextAlign,\n  nodes,\n  parent,\n}: {\n  converters: JSXConverters\n  disableIndent?: boolean | string[]\n  disableTextAlign?: boolean | string[]\n  nodes: SerializedLexicalNode[]\n  parent: SerializedLexicalNodeWithParent\n}): React.ReactNode[] {\n  const unknownConverter: JSXConverter<any> = converters.unknown as JSXConverter<any>\n\n  const jsxArray: React.ReactNode[] = nodes.map((node, i) => {\n    let converterForNode: JSXConverter<any> | undefined\n    if (node.type === 'block') {\n      converterForNode = converters?.blocks?.[(node as SerializedBlockNode)?.fields?.blockType]\n      if (!converterForNode && !unknownConverter) {\n        console.error(\n          `Lexical => JSX converter: Blocks converter: found ${(node as SerializedBlockNode)?.fields?.blockType} block, but no converter is provided`,\n        )\n      }\n    } else if (node.type === 'inlineBlock') {\n      converterForNode =\n        converters?.inlineBlocks?.[(node as SerializedInlineBlockNode)?.fields?.blockType]\n      if (!converterForNode && !unknownConverter) {\n        console.error(\n          `Lexical => JSX converter: Inline Blocks converter: found ${(node as SerializedInlineBlockNode)?.fields?.blockType} inline block, but no converter is provided`,\n        )\n      }\n    } else {\n      converterForNode = converters[node.type] as JSXConverter<any>\n    }\n\n    try {\n      if (!converterForNode && unknownConverter) {\n        converterForNode = unknownConverter\n      }\n\n      let reactNode: React.ReactNode\n      if (converterForNode) {\n        const converted =\n          typeof converterForNode === 'function'\n            ? converterForNode({\n                childIndex: i,\n                converters,\n                node,\n                nodesToJSX: (args) => {\n                  return convertLexicalNodesToJSX({\n                    converters: args.converters ?? converters,\n                    disableIndent: args.disableIndent ?? disableIndent,\n                    disableTextAlign: args.disableTextAlign ?? disableTextAlign,\n                    nodes: args.nodes,\n                    parent: args.parent ?? {\n                      ...node,\n                      parent,\n                    },\n                  })\n                },\n                parent,\n              })\n            : converterForNode\n        reactNode = converted\n      } else {\n        reactNode = <span key={i}>unknown node</span>\n      }\n\n      const style: React.CSSProperties = {}\n\n      // Check if disableTextAlign is not true and does not include node type\n      if (\n        !disableTextAlign &&\n        (!Array.isArray(disableTextAlign) || !disableTextAlign?.includes(node.type))\n      ) {\n        if ('format' in node && node.format) {\n          switch (node.format) {\n            case 'center':\n              style.textAlign = 'center'\n              break\n            case 'end':\n              style.textAlign = 'right'\n              break\n            case 'justify':\n              style.textAlign = 'justify'\n              break\n            case 'left':\n              //style.textAlign = 'left'\n              // Do nothing, as left is the default\n              break\n            case 'right':\n              style.textAlign = 'right'\n              break\n            case 'start':\n              style.textAlign = 'left'\n              break\n          }\n        }\n      }\n\n      if (\n        !disableIndent &&\n        (!Array.isArray(disableIndent) || !disableIndent?.includes(node.type))\n      ) {\n        if ('indent' in node && node.indent && node.type !== 'listitem') {\n          // the unit should be px. Do not change it to rem, em, or something else.\n          // The quantity should be 40px. Do not change it either.\n          // See rationale in\n          // https://github.com/payloadcms/payload/issues/13130#issuecomment-3058348085\n          style.paddingInlineStart = `${Number(node.indent) * 40}px`\n        }\n      }\n\n      if (React.isValidElement(reactNode)) {\n        // Inject style into reactNode\n        if (style.textAlign || style.paddingInlineStart) {\n          const newStyle = {\n            ...style,\n            // @ts-expect-error type better later\n            ...(reactNode?.props?.style ?? {}),\n            // reactNode style comes after, thus a textAlign specified in the converter has priority over the one we inject here\n          }\n\n          return React.cloneElement(reactNode, {\n            key: i,\n            // @ts-expect-error type better later\n            style: newStyle,\n          })\n        }\n        return React.cloneElement(reactNode, {\n          key: i,\n        })\n      }\n\n      return reactNode\n    } catch (error) {\n      console.error('Error converting lexical node to JSX:', error, 'node:', node)\n      return null\n    }\n  })\n\n  return jsxArray.filter(Boolean)\n}\n"],"names":["React","hasText","convertLexicalToJSX","converters","data","disableIndent","disableTextAlign","convertLexicalNodesToJSX","nodes","root","children","parent","unknownConverter","unknown","jsxArray","map","node","i","converterForNode","type","blocks","fields","blockType","console","error","inlineBlocks","reactNode","converted","childIndex","nodesToJSX","args","span","style","Array","isArray","includes","format","textAlign","indent","paddingInlineStart","Number","isValidElement","newStyle","props","cloneElement","key","filter","Boolean"],"mappings":"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"}
+{"version":3,"file":"index.js","names":["jsx","_jsx","Fragment","_Fragment","React","hasText","convertLexicalToJSX","converters","data","disableIndent","disableTextAlign","convertLexicalNodesToJSX","nodes","root","children","parent","unknownConverter","unknown","jsxArray","map","node","i","converterForNode","type","blocks","fields","blockType","console","error","inlineBlocks","reactNode","converted","childIndex","nodesToJSX","args","style","Array","isArray","includes","format","textAlign","indent","paddingInlineStart","Number","isValidElement","newStyle","props","cloneElement","key","filter","Boolean"],"sources":["../../../../../src/features/converters/lexicalToJSX/converter/index.tsx"],"sourcesContent":["/* eslint-disable no-console */\nimport type { SerializedEditorState, SerializedLexicalNode } from 'lexical'\n\nimport React from 'react'\n\nimport type { SerializedBlockNode, SerializedInlineBlockNode } from '../../../../nodeTypes.js'\nimport type { JSXConverter, JSXConverters, SerializedLexicalNodeWithParent } from './types.js'\n\nimport { hasText } from '../../../../validate/hasText.js'\n\nexport type ConvertLexicalToJSXArgs = {\n  converters: JSXConverters\n  data: SerializedEditorState\n  disableIndent?: boolean | string[]\n  disableTextAlign?: boolean | string[]\n}\n\nexport function convertLexicalToJSX({\n  converters,\n  data,\n  disableIndent,\n  disableTextAlign,\n}: ConvertLexicalToJSXArgs): React.ReactNode {\n  if (hasText(data)) {\n    return convertLexicalNodesToJSX({\n      converters,\n      disableIndent,\n      disableTextAlign,\n      nodes: data?.root?.children,\n      parent: data?.root,\n    })\n  }\n  return <></>\n}\n\nexport function convertLexicalNodesToJSX({\n  converters,\n  disableIndent,\n  disableTextAlign,\n  nodes,\n  parent,\n}: {\n  converters: JSXConverters\n  disableIndent?: boolean | string[]\n  disableTextAlign?: boolean | string[]\n  nodes: SerializedLexicalNode[]\n  parent: SerializedLexicalNodeWithParent\n}): React.ReactNode[] {\n  const unknownConverter: JSXConverter<any> = converters.unknown as JSXConverter<any>\n\n  const jsxArray: React.ReactNode[] = nodes.map((node, i) => {\n    let converterForNode: JSXConverter<any> | undefined\n    if (node.type === 'block') {\n      converterForNode = converters?.blocks?.[(node as SerializedBlockNode)?.fields?.blockType]\n      if (!converterForNode && !unknownConverter) {\n        console.error(\n          `Lexical => JSX converter: Blocks converter: found ${(node as SerializedBlockNode)?.fields?.blockType} block, but no converter is provided`,\n        )\n      }\n    } else if (node.type === 'inlineBlock') {\n      converterForNode =\n        converters?.inlineBlocks?.[(node as SerializedInlineBlockNode)?.fields?.blockType]\n      if (!converterForNode && !unknownConverter) {\n        console.error(\n          `Lexical => JSX converter: Inline Blocks converter: found ${(node as SerializedInlineBlockNode)?.fields?.blockType} inline block, but no converter is provided`,\n        )\n      }\n    } else {\n      converterForNode = converters[node.type] as JSXConverter<any>\n    }\n\n    try {\n      if (!converterForNode && unknownConverter) {\n        converterForNode = unknownConverter\n      }\n\n      let reactNode: React.ReactNode\n      if (converterForNode) {\n        const converted =\n          typeof converterForNode === 'function'\n            ? converterForNode({\n                childIndex: i,\n                converters,\n                node,\n                nodesToJSX: (args) => {\n                  return convertLexicalNodesToJSX({\n                    converters: args.converters ?? converters,\n                    disableIndent: args.disableIndent ?? disableIndent,\n                    disableTextAlign: args.disableTextAlign ?? disableTextAlign,\n                    nodes: args.nodes,\n                    parent: args.parent ?? {\n                      ...node,\n                      parent,\n                    },\n                  })\n                },\n                parent,\n              })\n            : converterForNode\n        reactNode = converted\n      } else {\n        reactNode = <span key={i}>unknown node</span>\n      }\n\n      const style: React.CSSProperties = {}\n\n      // Check if disableTextAlign is not true and does not include node type\n      if (\n        !disableTextAlign &&\n        (!Array.isArray(disableTextAlign) || !disableTextAlign?.includes(node.type))\n      ) {\n        if ('format' in node && node.format) {\n          switch (node.format) {\n            case 'center':\n              style.textAlign = 'center'\n              break\n            case 'end':\n              style.textAlign = 'right'\n              break\n            case 'justify':\n              style.textAlign = 'justify'\n              break\n            case 'left':\n              //style.textAlign = 'left'\n              // Do nothing, as left is the default\n              break\n            case 'right':\n              style.textAlign = 'right'\n              break\n            case 'start':\n              style.textAlign = 'left'\n              break\n          }\n        }\n      }\n\n      if (\n        !disableIndent &&\n        (!Array.isArray(disableIndent) || !disableIndent?.includes(node.type))\n      ) {\n        if ('indent' in node && node.indent && node.type !== 'listitem') {\n          // the unit should be px. Do not change it to rem, em, or something else.\n          // The quantity should be 40px. Do not change it either.\n          // See rationale in\n          // https://github.com/payloadcms/payload/issues/13130#issuecomment-3058348085\n          style.paddingInlineStart = `${Number(node.indent) * 40}px`\n        }\n      }\n\n      if (React.isValidElement(reactNode)) {\n        // Inject style into reactNode\n        if (style.textAlign || style.paddingInlineStart) {\n          const newStyle = {\n            ...style,\n            // @ts-expect-error type better later\n            ...(reactNode?.props?.style ?? {}),\n            // reactNode style comes after, thus a textAlign specified in the converter has priority over the one we inject here\n          }\n\n          return React.cloneElement(reactNode, {\n            key: i,\n            // @ts-expect-error type better later\n            style: newStyle,\n          })\n        }\n        return React.cloneElement(reactNode, {\n          key: i,\n        })\n      }\n\n      return reactNode\n    } catch (error) {\n      console.error('Error converting lexical node to JSX:', error, 'node:', node)\n      return null\n    }\n  })\n\n  return jsxArray.filter(Boolean)\n}\n"],"mappings":"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","ignoreList":[]}

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

@@ -1,5 +1,2 @@
-// need these to ensure types for blocks and inlineBlocks work if no generics are provided
-// need these to ensure types for blocks and inlineBlocks work if no generics are provided
-export { };
-
+export {};
 //# sourceMappingURL=types.js.map

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":[]}