@payloadcms/richtext-lexical 3.70.0 → 3.71.0-internal-debug.80dab4c

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

@@ -1,134 +1,129 @@
-/* eslint-disable no-console */import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
-import React from 'react';
+import { jsxDEV as _jsxDEV, Fragment as _Fragment } from "react/jsx-dev-runtime";
+/* eslint-disable no-console */ 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__*/_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 convertLexicalToJSX({ converters, data, disableIndent, disableTextAlign }) {
+    if (hasText(data)) {
+        return convertLexicalNodesToJSX({
+            converters,
+            disableIndent,
+            disableTextAlign,
+            nodes: data?.root?.children,
+            parent: data?.root
+        });
     }
-    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;
-          }
-        }
-      }
-      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 /*#__PURE__*/ _jsxDEV(_Fragment, {}, void 0, false);
+}
+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];
         }
-      }
-      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
-          });
+        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;
         }
-        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);
+    });
+    return jsxArray.filter(Boolean);
 }
+
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"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":[]}
+{"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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"}

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

@@ -1,2 +1,5 @@
-export {};
+// 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 { };
+
 //# sourceMappingURL=types.js.map

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

@@ -1 +1 @@
-{"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":[]}
+{"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"}

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

@@ -1,24 +1,22 @@
 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,"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":[]}
+{"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"}