@payloadcms/richtext-lexical 3.77.0 → 3.78.0-internal-debug.f663370

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

@@ -1,134 +1,262 @@
-/* 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, {});
+/**
+ * Creates a JSX converter from a NodeMapValue
+ */ function createConverterFromNodeMapValue(viewDef) {
+    return (args)=>{
+        const converterArgs = {
+            ...args,
+            isEditor: false,
+            isJSXConverter: true
+        };
+        // If Component is provided, use it
+        if (viewDef.Component) {
+            return viewDef.Component(converterArgs);
+        }
+        // If html is provided (as a function or string), use it
+        // Note: Using span instead of div to avoid forcing block-level semantics
+        if (viewDef.html) {
+            const htmlContent = typeof viewDef.html === 'function' ? viewDef.html(converterArgs) : viewDef.html;
+            return /*#__PURE__*/ _jsxDEV("span", {
+                dangerouslySetInnerHTML: {
+                    __html: htmlContent
+                }
+            }, void 0, false, {
+                fileName: "src/features/converters/lexicalToJSX/converter/index.tsx",
+                lineNumber: 40,
+                columnNumber: 14
+            }, this);
+        }
+        return null;
+    };
 }
-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;
-          }
+/**
+ * Creates a JSX converter from a NodeMapBlockValue (for blocks/inlineBlocks)
+ * This also checks for Block FC as a fallback when Component is not defined.
+ */ function createConverterFromBlockValue(viewDef) {
+    return (args)=>{
+        // Priority: Component > Block > html
+        if (viewDef.Component) {
+            const converterArgs = {
+                ...args,
+                isEditor: false,
+                isJSXConverter: true
+            };
+            return viewDef.Component(converterArgs);
+        }
+        // Use Block FC with JSX converter props
+        if (viewDef.Block) {
+            const blockNode = args.node;
+            const blockProps = {
+                childIndex: args.childIndex,
+                converters: args.converters,
+                formData: blockNode.fields ?? {},
+                isEditor: false,
+                isJSXConverter: true,
+                node: blockNode,
+                nodesToJSX: args.nodesToJSX,
+                parent: args.parent
+            };
+            return /*#__PURE__*/ React.createElement(viewDef.Block, blockProps);
+        }
+        if (viewDef.html) {
+            const converterArgs = {
+                ...args,
+                isEditor: false,
+                isJSXConverter: true
+            };
+            const htmlContent = typeof viewDef.html === 'function' ? viewDef.html(converterArgs) : viewDef.html;
+            return /*#__PURE__*/ _jsxDEV("span", {
+                dangerouslySetInnerHTML: {
+                    __html: htmlContent
+                }
+            }, void 0, false, {
+                fileName: "src/features/converters/lexicalToJSX/converter/index.tsx",
+                lineNumber: 88,
+                columnNumber: 14
+            }, this);
+        }
+        return null;
+    };
+}
+/**
+ * Converts a LexicalEditorNodeMap into JSXConverters
+ */ function nodeMapToConverters(nodeMap) {
+    const converters = {};
+    for (const [nodeType, value] of Object.entries(nodeMap)){
+        if (!value || typeof value !== 'object') {
+            continue;
         }
-      }
-      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`;
+        // Handle special keys: blocks, inlineBlocks
+        if (nodeType === 'blocks') {
+            converters.blocks = {};
+            for (const [blockType, _viewDef] of Object.entries(value)){
+                const viewDef = _viewDef;
+                // Check for Component, Block, or html
+                if (viewDef.Component || viewDef.Block || viewDef.html) {
+                    converters.blocks[blockType] = createConverterFromBlockValue(viewDef);
+                }
+            }
+            continue;
         }
-      }
-      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
-          });
+        if (nodeType === 'inlineBlocks') {
+            converters.inlineBlocks = {};
+            for (const [blockType, _viewDef] of Object.entries(value)){
+                const viewDef = _viewDef;
+                // Check for Component, Block, or html
+                if (viewDef.Component || viewDef.Block || viewDef.html) {
+                    converters.inlineBlocks[blockType] = createConverterFromBlockValue(viewDef);
+                }
+            }
+            continue;
         }
-        return /*#__PURE__*/React.cloneElement(reactNode, {
-          key: i
+        // Handle regular node types
+        const viewDef = value;
+        if (viewDef.Component || viewDef.html) {
+            converters[nodeType] = createConverterFromNodeMapValue(viewDef);
+        }
+    }
+    return converters;
+}
+/**
+   * Serialized editor state to render.
+   */ /**
+   * If true, disables indentation globally. If an array, disables for specific node `type` values.
+   */ /**
+   * If true, disables text alignment globally. If an array, disables for specific node `type` values.
+   */ /**
+   * You can use the lexical editor node map or view map as converters. NodeMap converters will override converters passed
+   * in the `converters` prop. If a LexicalEditorViewMap is provided, the `default` view will be used.
+   */ export function convertLexicalToJSX({ converters, data, disableIndent, disableTextAlign, nodeMap }) {
+    if (hasText(data)) {
+        // Merge nodeMap converters with existing converters
+        // NodeMap converters override existing converters
+        const mergedConverters = nodeMap ? {
+            ...converters,
+            ...nodeMapToConverters(nodeMap)
+        } : converters;
+        return convertLexicalNodesToJSX({
+            converters: mergedConverters,
+            disableIndent,
+            disableTextAlign,
+            nodes: data.root.children,
+            parent: data.root
         });
-      }
-      return reactNode;
-    } catch (error) {
-      console.error('Error converting lexical node to JSX:', error, 'node:', node);
-      return null;
     }
-  });
-  return jsxArray.filter(Boolean);
+    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];
+        }
+        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: 259,
+                    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 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 {\n  LexicalEditorNodeMap,\n  NodeMapBlockValue,\n  NodeMapValue,\n  SerializedNodeBase,\n  ViewMapBlockJSXConverterProps,\n} from '../../../../types.js'\nimport type { JSXConverter, JSXConverters, SerializedLexicalNodeWithParent } from './types.js'\n\nimport { hasText } from '../../../../validate/hasText.js'\n\n/**\n * Creates a JSX converter from a NodeMapValue\n */\nfunction createConverterFromNodeMapValue(viewDef: NodeMapValue): JSXConverter {\n  return (args) => {\n    const converterArgs = {\n      ...args,\n      isEditor: false as const,\n      isJSXConverter: true as const,\n    }\n\n    // If Component is provided, use it\n    if (viewDef.Component) {\n      return viewDef.Component(converterArgs)\n    }\n\n    // If html is provided (as a function or string), use it\n    // Note: Using span instead of div to avoid forcing block-level semantics\n    if (viewDef.html) {\n      const htmlContent =\n        typeof viewDef.html === 'function' ? viewDef.html(converterArgs) : viewDef.html\n\n      return <span dangerouslySetInnerHTML={{ __html: htmlContent }} />\n    }\n\n    return null\n  }\n}\n\n/**\n * Creates a JSX converter from a NodeMapBlockValue (for blocks/inlineBlocks)\n * This also checks for Block FC as a fallback when Component is not defined.\n */\nfunction createConverterFromBlockValue(viewDef: NodeMapBlockValue<any>): JSXConverter {\n  return (args) => {\n    // Priority: Component > Block > html\n    if (viewDef.Component) {\n      const converterArgs = {\n        ...args,\n        isEditor: false as const,\n        isJSXConverter: true as const,\n      }\n      return viewDef.Component(converterArgs)\n    }\n\n    // Use Block FC with JSX converter props\n    if (viewDef.Block) {\n      const blockNode = args.node as SerializedBlockNode\n      const blockProps: ViewMapBlockJSXConverterProps<any> = {\n        childIndex: args.childIndex,\n        converters: args.converters,\n        formData: blockNode.fields ?? {},\n        isEditor: false,\n        isJSXConverter: true,\n        node: blockNode,\n        nodesToJSX: args.nodesToJSX,\n        parent: args.parent,\n      }\n      return React.createElement(viewDef.Block, blockProps)\n    }\n\n    if (viewDef.html) {\n      const converterArgs = {\n        ...args,\n        isEditor: false as const,\n        isJSXConverter: true as const,\n      }\n      const htmlContent =\n        typeof viewDef.html === 'function' ? viewDef.html(converterArgs) : viewDef.html\n\n      return <span dangerouslySetInnerHTML={{ __html: htmlContent }} />\n    }\n\n    return null\n  }\n}\n\n/**\n * Converts a LexicalEditorNodeMap into JSXConverters\n */\nfunction nodeMapToConverters<TNodes extends SerializedNodeBase = SerializedNodeBase>(\n  nodeMap: LexicalEditorNodeMap<TNodes>,\n): JSXConverters {\n  const converters: JSXConverters = {}\n\n  for (const [nodeType, value] of Object.entries(nodeMap)) {\n    if (!value || typeof value !== 'object') {\n      continue\n    }\n\n    // Handle special keys: blocks, inlineBlocks\n    if (nodeType === 'blocks') {\n      converters.blocks = {}\n      for (const [blockType, _viewDef] of Object.entries(value)) {\n        const viewDef = _viewDef as NodeMapBlockValue<any>\n        // Check for Component, Block, or html\n        if (viewDef.Component || viewDef.Block || viewDef.html) {\n          converters.blocks[blockType] = createConverterFromBlockValue(viewDef)\n        }\n      }\n      continue\n    }\n\n    if (nodeType === 'inlineBlocks') {\n      converters.inlineBlocks = {}\n      for (const [blockType, _viewDef] of Object.entries(value)) {\n        const viewDef = _viewDef as NodeMapBlockValue<any>\n        // Check for Component, Block, or html\n        if (viewDef.Component || viewDef.Block || viewDef.html) {\n          converters.inlineBlocks[blockType] = createConverterFromBlockValue(viewDef)\n        }\n      }\n      continue\n    }\n\n    // Handle regular node types\n    const viewDef = value as NodeMapValue\n\n    if (viewDef.Component || viewDef.html) {\n      converters[nodeType] = createConverterFromNodeMapValue(viewDef)\n    }\n  }\n\n  return converters\n}\n\nexport type ConvertLexicalToJSXArgs<TNodes extends SerializedNodeBase = SerializedNodeBase> = {\n  converters: JSXConverters\n  /**\n   * Serialized editor state to render.\n   */\n  data: SerializedEditorState\n  /**\n   * If true, disables indentation globally. If an array, disables for specific node `type` values.\n   */\n  disableIndent?: boolean | string[]\n  /**\n   * If true, disables text alignment globally. If an array, disables for specific node `type` values.\n   */\n  disableTextAlign?: boolean | string[]\n  /**\n   * You can use the lexical editor node map or view map as converters. NodeMap converters will override converters passed\n   * in the `converters` prop. If a LexicalEditorViewMap is provided, the `default` view will be used.\n   */\n  nodeMap?: LexicalEditorNodeMap<TNodes>\n}\n\nexport function convertLexicalToJSX<TNodes extends SerializedNodeBase = SerializedNodeBase>({\n  converters,\n  data,\n  disableIndent,\n  disableTextAlign,\n  nodeMap,\n}: ConvertLexicalToJSXArgs<TNodes>): React.ReactNode {\n  if (hasText(data)) {\n    // Merge nodeMap converters with existing converters\n    // NodeMap converters override existing converters\n    const mergedConverters = nodeMap\n      ? {\n          ...converters,\n          ...nodeMapToConverters(nodeMap),\n        }\n      : converters\n\n    return convertLexicalNodesToJSX({\n      converters: mergedConverters,\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","createConverterFromNodeMapValue","viewDef","args","converterArgs","isEditor","isJSXConverter","Component","html","htmlContent","span","dangerouslySetInnerHTML","__html","createConverterFromBlockValue","Block","blockNode","node","blockProps","childIndex","converters","formData","fields","nodesToJSX","parent","createElement","nodeMapToConverters","nodeMap","nodeType","value","Object","entries","blocks","blockType","_viewDef","inlineBlocks","convertLexicalToJSX","data","disableIndent","disableTextAlign","mergedConverters","convertLexicalNodesToJSX","nodes","root","children","unknownConverter","unknown","jsxArray","map","i","converterForNode","type","console","error","reactNode","converted","style","Array","isArray","includes","format","textAlign","indent","paddingInlineStart","Number","isValidElement","newStyle","props","cloneElement","key","filter","Boolean"],"mappings":";AAAA,6BAA6B,GAG7B,OAAOA,WAAW,QAAO;AAYzB,SAASC,OAAO,QAAQ,kCAAiC;AAEzD;;CAEC,GACD,SAASC,gCAAgCC,OAAqB;IAC5D,OAAO,CAACC;QACN,MAAMC,gBAAgB;YACpB,GAAGD,IAAI;YACPE,UAAU;YACVC,gBAAgB;QAClB;QAEA,mCAAmC;QACnC,IAAIJ,QAAQK,SAAS,EAAE;YACrB,OAAOL,QAAQK,SAAS,CAACH;QAC3B;QAEA,wDAAwD;QACxD,yEAAyE;QACzE,IAAIF,QAAQM,IAAI,EAAE;YAChB,MAAMC,cACJ,OAAOP,QAAQM,IAAI,KAAK,aAAaN,QAAQM,IAAI,CAACJ,iBAAiBF,QAAQM,IAAI;YAEjF,qBAAO,QAACE;gBAAKC,yBAAyB;oBAAEC,QAAQH;gBAAY;;;;;;QAC9D;QAEA,OAAO;IACT;AACF;AAEA;;;CAGC,GACD,SAASI,8BAA8BX,OAA+B;IACpE,OAAO,CAACC;QACN,qCAAqC;QACrC,IAAID,QAAQK,SAAS,EAAE;YACrB,MAAMH,gBAAgB;gBACpB,GAAGD,IAAI;gBACPE,UAAU;gBACVC,gBAAgB;YAClB;YACA,OAAOJ,QAAQK,SAAS,CAACH;QAC3B;QAEA,wCAAwC;QACxC,IAAIF,QAAQY,KAAK,EAAE;YACjB,MAAMC,YAAYZ,KAAKa,IAAI;YAC3B,MAAMC,aAAiD;gBACrDC,YAAYf,KAAKe,UAAU;gBAC3BC,YAAYhB,KAAKgB,UAAU;gBAC3BC,UAAUL,UAAUM,MAAM,IAAI,CAAC;gBAC/BhB,UAAU;gBACVC,gBAAgB;gBAChBU,MAAMD;gBACNO,YAAYnB,KAAKmB,UAAU;gBAC3BC,QAAQpB,KAAKoB,MAAM;YACrB;YACA,qBAAOxB,MAAMyB,aAAa,CAACtB,QAAQY,KAAK,EAAEG;QAC5C;QAEA,IAAIf,QAAQM,IAAI,EAAE;YAChB,MAAMJ,gBAAgB;gBACpB,GAAGD,IAAI;gBACPE,UAAU;gBACVC,gBAAgB;YAClB;YACA,MAAMG,cACJ,OAAOP,QAAQM,IAAI,KAAK,aAAaN,QAAQM,IAAI,CAACJ,iBAAiBF,QAAQM,IAAI;YAEjF,qBAAO,QAACE;gBAAKC,yBAAyB;oBAAEC,QAAQH;gBAAY;;;;;;QAC9D;QAEA,OAAO;IACT;AACF;AAEA;;CAEC,GACD,SAASgB,oBACPC,OAAqC;IAErC,MAAMP,aAA4B,CAAC;IAEnC,KAAK,MAAM,CAACQ,UAAUC,MAAM,IAAIC,OAAOC,OAAO,CAACJ,SAAU;QACvD,IAAI,CAACE,SAAS,OAAOA,UAAU,UAAU;YACvC;QACF;QAEA,4CAA4C;QAC5C,IAAID,aAAa,UAAU;YACzBR,WAAWY,MAAM,GAAG,CAAC;YACrB,KAAK,MAAM,CAACC,WAAWC,SAAS,IAAIJ,OAAOC,OAAO,CAACF,OAAQ;gBACzD,MAAM1B,UAAU+B;gBAChB,sCAAsC;gBACtC,IAAI/B,QAAQK,SAAS,IAAIL,QAAQY,KAAK,IAAIZ,QAAQM,IAAI,EAAE;oBACtDW,WAAWY,MAAM,CAACC,UAAU,GAAGnB,8BAA8BX;gBAC/D;YACF;YACA;QACF;QAEA,IAAIyB,aAAa,gBAAgB;YAC/BR,WAAWe,YAAY,GAAG,CAAC;YAC3B,KAAK,MAAM,CAACF,WAAWC,SAAS,IAAIJ,OAAOC,OAAO,CAACF,OAAQ;gBACzD,MAAM1B,UAAU+B;gBAChB,sCAAsC;gBACtC,IAAI/B,QAAQK,SAAS,IAAIL,QAAQY,KAAK,IAAIZ,QAAQM,IAAI,EAAE;oBACtDW,WAAWe,YAAY,CAACF,UAAU,GAAGnB,8BAA8BX;gBACrE;YACF;YACA;QACF;QAEA,4BAA4B;QAC5B,MAAMA,UAAU0B;QAEhB,IAAI1B,QAAQK,SAAS,IAAIL,QAAQM,IAAI,EAAE;YACrCW,UAAU,CAACQ,SAAS,GAAG1B,gCAAgCC;QACzD;IACF;IAEA,OAAOiB;AACT;AAIE;;GAEC,GAED;;GAEC,GAED;;GAEC,GAED;;;GAGC,GAIH,OAAO,SAASgB,oBAA4E,EAC1FhB,UAAU,EACViB,IAAI,EACJC,aAAa,EACbC,gBAAgB,EAChBZ,OAAO,EACyB;IAChC,IAAI1B,QAAQoC,OAAO;QACjB,oDAAoD;QACpD,kDAAkD;QAClD,MAAMG,mBAAmBb,UACrB;YACE,GAAGP,UAAU;YACb,GAAGM,oBAAoBC,QAAQ;QACjC,IACAP;QAEJ,OAAOqB,yBAAyB;YAC9BrB,YAAYoB;YACZF;YACAC;YACAG,OAAOL,KAAKM,IAAI,CAACC,QAAQ;YACzBpB,QAAQa,KAAKM,IAAI;QACnB;IACF;IACA,qBAAO;AACT;AAEA,OAAO,SAASF,yBAAyB,EACvCrB,UAAU,EACVkB,aAAa,EACbC,gBAAgB,EAChBG,KAAK,EACLlB,MAAM,EAOP;IACC,MAAMqB,mBAAsCzB,WAAW0B,OAAO;IAE9D,MAAMC,WAA8BL,MAAMM,GAAG,CAAC,CAAC/B,MAAMgC;QACnD,IAAIC;QACJ,IAAIjC,KAAKkC,IAAI,KAAK,SAAS;YACzBD,mBAAmB9B,YAAYY,QAAQ,CAAEf,MAA8BK,QAAQW,UAAU;YACzF,IAAI,CAACiB,oBAAoB,CAACL,kBAAkB;gBAC1CO,QAAQC,KAAK,CACX,CAAC,kDAAkD,EAAGpC,MAA8BK,QAAQW,UAAU,oCAAoC,CAAC;YAE/I;QACF,OAAO,IAAIhB,KAAKkC,IAAI,KAAK,eAAe;YACtCD,mBACE9B,YAAYe,cAAc,CAAElB,MAAoCK,QAAQW,UAAU;YACpF,IAAI,CAACiB,oBAAoB,CAACL,kBAAkB;gBAC1CO,QAAQC,KAAK,CACX,CAAC,yDAAyD,EAAGpC,MAAoCK,QAAQW,UAAU,2CAA2C,CAAC;YAEnK;QACF,OAAO;YACLiB,mBAAmB9B,UAAU,CAACH,KAAKkC,IAAI,CAAC;QAC1C;QAEA,IAAI;YACF,IAAI,CAACD,oBAAoBL,kBAAkB;gBACzCK,mBAAmBL;YACrB;YAEA,IAAIS;YACJ,IAAIJ,kBAAkB;gBACpB,MAAMK,YACJ,OAAOL,qBAAqB,aACxBA,iBAAiB;oBACf/B,YAAY8B;oBACZ7B;oBACAH;oBACAM,YAAY,CAACnB;wBACX,OAAOqC,yBAAyB;4BAC9BrB,YAAYhB,KAAKgB,UAAU,IAAIA;4BAC/BkB,eAAelC,KAAKkC,aAAa,IAAIA;4BACrCC,kBAAkBnC,KAAKmC,gBAAgB,IAAIA;4BAC3CG,OAAOtC,KAAKsC,KAAK;4BACjBlB,QAAQpB,KAAKoB,MAAM,IAAI;gCACrB,GAAGP,IAAI;gCACPO;4BACF;wBACF;oBACF;oBACAA;gBACF,KACA0B;gBACNI,YAAYC;YACd,OAAO;gBACLD,0BAAY,QAAC3C;8BAAa;mBAAHsC;;;;;YACzB;YAEA,MAAMO,QAA6B,CAAC;YAEpC,uEAAuE;YACvE,IACE,CAACjB,oBACA,CAAA,CAACkB,MAAMC,OAAO,CAACnB,qBAAqB,CAACA,kBAAkBoB,SAAS1C,KAAKkC,IAAI,CAAA,GAC1E;gBACA,IAAI,YAAYlC,QAAQA,KAAK2C,MAAM,EAAE;oBACnC,OAAQ3C,KAAK2C,MAAM;wBACjB,KAAK;4BACHJ,MAAMK,SAAS,GAAG;4BAClB;wBACF,KAAK;4BACHL,MAAMK,SAAS,GAAG;4BAClB;wBACF,KAAK;4BACHL,MAAMK,SAAS,GAAG;4BAClB;wBACF,KAAK;4BAGH;wBACF,KAAK;4BACHL,MAAMK,SAAS,GAAG;4BAClB;wBACF,KAAK;4BACHL,MAAMK,SAAS,GAAG;4BAClB;oBACJ;gBACF;YACF;YAEA,IACE,CAACvB,iBACA,CAAA,CAACmB,MAAMC,OAAO,CAACpB,kBAAkB,CAACA,eAAeqB,SAAS1C,KAAKkC,IAAI,CAAA,GACpE;gBACA,IAAI,YAAYlC,QAAQA,KAAK6C,MAAM,IAAI7C,KAAKkC,IAAI,KAAK,YAAY;oBAC/D,yEAAyE;oBACzE,wDAAwD;oBACxD,mBAAmB;oBACnB,6EAA6E;oBAC7EK,MAAMO,kBAAkB,GAAG,GAAGC,OAAO/C,KAAK6C,MAAM,IAAI,GAAG,EAAE,CAAC;gBAC5D;YACF;YAEA,kBAAI9D,MAAMiE,cAAc,CAACX,YAAY;gBACnC,8BAA8B;gBAC9B,IAAIE,MAAMK,SAAS,IAAIL,MAAMO,kBAAkB,EAAE;oBAC/C,MAAMG,WAAW;wBACf,GAAGV,KAAK;wBACR,qCAAqC;wBACrC,GAAIF,WAAWa,OAAOX,SAAS,CAAC,CAAC;oBAEnC;oBADE,oHAAoH;oBAGtH,qBAAOxD,MAAMoE,YAAY,CAACd,WAAW;wBACnCe,KAAKpB;wBACL,qCAAqC;wBACrCO,OAAOU;oBACT;gBACF;gBACA,qBAAOlE,MAAMoE,YAAY,CAACd,WAAW;oBACnCe,KAAKpB;gBACP;YACF;YAEA,OAAOK;QACT,EAAE,OAAOD,OAAO;YACdD,QAAQC,KAAK,CAAC,yCAAyCA,OAAO,SAASpC;YACvE,OAAO;QACT;IACF;IAEA,OAAO8B,SAASuB,MAAM,CAACC;AACzB"}

package/dist/features/converters/lexicalToJSX/converter/types.d.ts

@@ -1,12 +1,12 @@
 import type { SerializedLexicalNode } from 'lexical';
 import type { DefaultNodeTypes, SerializedBlockNode, SerializedInlineBlockNode } from '../../../../nodeTypes.js';
-export type JSXConverter<T extends {
+export type JSXConverterArgs<TNode extends {
     [key: string]: any;
     type?: string;
-} = SerializedLexicalNode> = ((args: {
+} = SerializedLexicalNode> = {
     childIndex: number;
     converters: JSXConverters;
-    node: T;
+    node: TNode;
     nodesToJSX: (args: {
         converters?: JSXConverters;
         disableIndent?: boolean | string[];
@@ -15,8 +15,12 @@ export type JSXConverter<T extends {
         parent?: SerializedLexicalNodeWithParent;
     }) => React.ReactNode[];
     parent: SerializedLexicalNodeWithParent;
-}) => React.ReactNode) | React.ReactNode;
-export type JSXConverters<T extends {
+};
+export type JSXConverter<TNode extends {
+    [key: string]: any;
+    type?: string;
+} = SerializedLexicalNode> = ((args: JSXConverterArgs<TNode>) => React.ReactNode) | React.ReactNode;
+export type JSXConverters<TNodes extends {
     [key: string]: any;
     type?: string;
 } = DefaultNodeTypes | SerializedBlockNode<{
@@ -30,27 +34,27 @@ export type JSXConverters<T extends {
         [blockSlug: string]: JSXConverter<any>;
     } | JSXConverter<any> | undefined;
 } & {
-    [nodeType in Exclude<NonNullable<T['type']>, 'block' | 'inlineBlock'>]?: JSXConverter<Extract<T, {
+    [nodeType in Exclude<NonNullable<TNodes['type']>, 'block' | 'inlineBlock'>]?: JSXConverter<Extract<TNodes, {
         type: nodeType;
     }>>;
 } & {
     blocks?: {
-        [K in Extract<Extract<T, {
+        [K in Extract<Extract<TNodes, {
             type: 'block';
         }> extends SerializedBlockNode<infer B> ? B extends {
             blockType: string;
-        } ? B['blockType'] : never : never, string>]?: JSXConverter<Extract<T, {
+        } ? B['blockType'] : never : never, string>]?: JSXConverter<Extract<TNodes, {
             type: 'block';
         }> extends SerializedBlockNode<infer B> ? SerializedBlockNode<Extract<B, {
             blockType: K;
         }>> : SerializedBlockNode>;
     };
     inlineBlocks?: {
-        [K in Extract<Extract<T, {
+        [K in Extract<Extract<TNodes, {
             type: 'inlineBlock';
         }> extends SerializedInlineBlockNode<infer B> ? B extends {
             blockType: string;
-        } ? B['blockType'] : never : never, string>]?: JSXConverter<Extract<T, {
+        } ? B['blockType'] : never : never, string>]?: JSXConverter<Extract<TNodes, {
             type: 'inlineBlock';
         }> extends SerializedInlineBlockNode<infer B> ? SerializedInlineBlockNode<Extract<B, {
             blockType: K;

package/dist/features/converters/lexicalToJSX/converter/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/lexicalToJSX/converter/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAEpD,OAAO,KAAK,EACV,gBAAgB,EAChB,mBAAmB,EACnB,yBAAyB,EAC1B,MAAM,0BAA0B,CAAA;AACjC,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,qBAAqB,IAC5F,CAAC,CAAC,IAAI,EAAE;IACN,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,aAAa,CAAA;IACzB,IAAI,EAAE,CAAC,CAAA;IACP,UAAU,EAAE,CAAC,IAAI,EAAE;QACjB,UAAU,CAAC,EAAE,aAAa,CAAA;QAC1B,aAAa,CAAC,EAAE,OAAO,GAAG,MAAM,EAAE,CAAA;QAClC,gBAAgB,CAAC,EAAE,OAAO,GAAG,MAAM,EAAE,CAAA;QACrC,KAAK,EAAE,qBAAqB,EAAE,CAAA;QAC9B,MAAM,CAAC,EAAE,+BAA+B,CAAA;KACzC,KAAK,KAAK,CAAC,SAAS,EAAE,CAAA;IACvB,MAAM,EAAE,+BAA+B,CAAA;CACxC,KAAK,KAAK,CAAC,SAAS,CAAC,GACtB,KAAK,CAAC,SAAS,CAAA;AAEnB,MAAM,MAAM,aAAa,CACvB,CAAC,SAAS;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAC3C,gBAAgB,GAChB,mBAAmB,CAAC;IAAE,SAAS,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,GACrE,yBAAyB,CAAC;IAAE,SAAS,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,IAC7E;IACF,CAAC,GAAG,EAAE,MAAM,GACR;QACE,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,CAAC,GAAG,CAAC,CAAA;KACvC,GACD,YAAY,CAAC,GAAG,CAAC,GACjB,SAAS,CAAA;CACd,GAAG;KACD,QAAQ,IAAI,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,aAAa,CAAC,CAAC,CAAC,EAAE,YAAY,CACnF,OAAO,CAAC,CAAC,EAAE;QAAE,IAAI,EAAE,QAAQ,CAAA;KAAE,CAAC,CAC/B;CACF,GAAG;IACF,MAAM,CAAC,EAAE;SACN,CAAC,IAAI,OAAO,CACX,OAAO,CAAC,CAAC,EAAE;YAAE,IAAI,EAAE,OAAO,CAAA;SAAE,CAAC,SAAS,mBAAmB,CAAC,MAAM,CAAC,CAAC,GAC9D,CAAC,SAAS;YAAE,SAAS,EAAE,MAAM,CAAA;SAAE,GAC7B,CAAC,CAAC,WAAW,CAAC,GACd,KAAK,GACP,KAAK,EACT,MAAM,CACP,CAAC,CAAC,EAAE,YAAY,CACf,OAAO,CAAC,CAAC,EAAE;YAAE,IAAI,EAAE,OAAO,CAAA;SAAE,CAAC,SAAS,mBAAmB,CAAC,MAAM,CAAC,CAAC,GAC9D,mBAAmB,CAAC,OAAO,CAAC,CAAC,EAAE;YAAE,SAAS,EAAE,CAAC,CAAA;SAAE,CAAC,CAAC,GACjD,mBAAmB,CACxB;KACF,CAAA;IACD,YAAY,CAAC,EAAE;SACZ,CAAC,IAAI,OAAO,CACX,OAAO,CAAC,CAAC,EAAE;YAAE,IAAI,EAAE,aAAa,CAAA;SAAE,CAAC,SAAS,yBAAyB,CAAC,MAAM,CAAC,CAAC,GAC1E,CAAC,SAAS;YAAE,SAAS,EAAE,MAAM,CAAA;SAAE,GAC7B,CAAC,CAAC,WAAW,CAAC,GACd,KAAK,GACP,KAAK,EACT,MAAM,CACP,CAAC,CAAC,EAAE,YAAY,CACf,OAAO,CAAC,CAAC,EAAE;YAAE,IAAI,EAAE,aAAa,CAAA;SAAE,CAAC,SAAS,yBAAyB,CAAC,MAAM,CAAC,CAAC,GAC1E,yBAAyB,CAAC,OAAO,CAAC,CAAC,EAAE;YAAE,SAAS,EAAE,CAAC,CAAA;SAAE,CAAC,CAAC,GACvD,yBAAyB,CAC9B;KACF,CAAA;IACD,OAAO,CAAC,EAAE,YAAY,CAAC,qBAAqB,CAAC,CAAA;CAC9C,CAAA;AACD,MAAM,MAAM,+BAA+B,GAAG;IAC5C,MAAM,CAAC,EAAE,qBAAqB,CAAA;CAC/B,GAAG,qBAAqB,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/lexicalToJSX/converter/types.ts"],"names":[],"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'\n\nexport type JSXConverterArgs<\n  TNode extends { [key: string]: any; type?: string } = SerializedLexicalNode,\n> = {\n  childIndex: number\n  converters: JSXConverters\n  node: TNode\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}\nexport type JSXConverter<\n  TNode extends { [key: string]: any; type?: string } = SerializedLexicalNode,\n> = ((args: JSXConverterArgs<TNode>) => React.ReactNode) | React.ReactNode\n\nexport type JSXConverters<\n  TNodes 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<TNodes['type']>, 'block' | 'inlineBlock'>]?: JSXConverter<\n    Extract<TNodes, { type: nodeType }>\n  >\n} & {\n  blocks?: {\n    [K in Extract<\n      Extract<TNodes, { type: 'block' }> extends SerializedBlockNode<infer B>\n        ? B extends { blockType: string }\n          ? B['blockType']\n          : never\n        : never,\n      string\n    >]?: JSXConverter<\n      Extract<TNodes, { type: 'block' }> extends SerializedBlockNode<infer B>\n        ? SerializedBlockNode<Extract<B, { blockType: K }>>\n        : SerializedBlockNode\n    >\n  }\n  inlineBlocks?: {\n    [K in Extract<\n      Extract<TNodes, { type: 'inlineBlock' }> extends SerializedInlineBlockNode<infer B>\n        ? B extends { blockType: string }\n          ? B['blockType']\n          : never\n        : never,\n      string\n    >]?: JSXConverter<\n      Extract<TNodes, { 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":"AA8B4E,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"}