@payloadcms/richtext-lexical 3.68.0-internal-debug.56c9b68 → 3.68.0-internal-debug.185cc5f

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

@@ -1,206 +1,125 @@
-/* eslint-disable no-console */import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
-import React from 'react';
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+/* eslint-disable no-console */ import React from 'react';
 import { hasText } from '../../../../validate/hasText.js';
-/**
- * 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__*/_jsx("span", {
-        dangerouslySetInnerHTML: {
-          __html: htmlContent
-        }
-      });
+export function convertLexicalToJSX({ converters, data, disableIndent, disableTextAlign }) {
+    if (hasText(data)) {
+        return convertLexicalNodesToJSX({
+            converters,
+            disableIndent,
+            disableTextAlign,
+            nodes: data?.root?.children,
+            parent: data?.root
+        });
     }
-    return null;
-  };
+    return /*#__PURE__*/ _jsx(_Fragment, {});
 }
-/**
- * Converts a LexicalEditorNodeMap into JSXConverters
- */
-function nodeMapToConverters(nodeMap) {
-  const converters = {};
-  for (const [nodeType, value] of Object.entries(nodeMap)) {
-    if (!value || typeof value !== 'object') {
-      continue;
-    }
-    // Handle special keys: blocks, inlineBlocks
-    if (nodeType === 'blocks') {
-      converters.blocks = {};
-      for (const [blockType, _viewDef] of Object.entries(value)) {
-        const viewDef = _viewDef;
-        if (viewDef.Component || viewDef.html) {
-          converters.blocks[blockType] = createConverterFromNodeMapValue(viewDef);
+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];
         }
-      }
-      continue;
-    }
-    if (nodeType === 'inlineBlocks') {
-      converters.inlineBlocks = {};
-      for (const [blockType, _viewDef] of Object.entries(value)) {
-        const viewDef = _viewDef;
-        if (viewDef.Component || viewDef.html) {
-          converters.inlineBlocks[blockType] = createConverterFromNodeMapValue(viewDef);
+        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`;
+                }
+            }
+            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;
         }
-      }
-      continue;
-    }
-    // Handle regular node types
-    const viewDef = value;
-    if (viewDef.Component || viewDef.html) {
-      converters[nodeType] = createConverterFromNodeMapValue(viewDef);
-    }
-  }
-  return converters;
-}
-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 /*#__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];
-    }
-    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`;
-        }
-      }
-      if (/*#__PURE__*/React.isValidElement(reactNode)) {
-        // Inject style into reactNode
-        if (style.textAlign || style.paddingInlineStart) {
-          const newStyle = {
-            ...style,
-            // @ts-expect-error type better later
-            ...(reactNode?.props?.style ?? {})
-          };
-          return /*#__PURE__*/React.cloneElement(reactNode, {
-            key: i,
-            // @ts-expect-error type better later
-            style: newStyle
-          });
-        }
-        return /*#__PURE__*/React.cloneElement(reactNode, {
-          key: i
-        });
-      }
-      return reactNode;
-    } catch (error) {
-      console.error('Error converting lexical node to JSX:', error, 'node:', node);
-      return null;
-    }
-  });
-  return jsxArray.filter(Boolean);
+    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","createConverterFromNodeMapValue","viewDef","args","converterArgs","isEditor","isJSXConverter","Component","html","htmlContent","dangerouslySetInnerHTML","__html","nodeMapToConverters","nodeMap","converters","nodeType","value","Object","entries","blocks","blockType","_viewDef","inlineBlocks","convertLexicalToJSX","data","disableIndent","disableTextAlign","mergedConverters","convertLexicalNodesToJSX","nodes","root","children","parent","unknownConverter","unknown","jsxArray","map","node","i","converterForNode","type","fields","console","error","reactNode","converted","childIndex","nodesToJSX","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 { LexicalEditorNodeMap, NodeMapValue } 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 * Converts a LexicalEditorNodeMap into JSXConverters\n */\nfunction nodeMapToConverters(nodeMap: LexicalEditorNodeMap): 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 NodeMapValue\n        if (viewDef.Component || viewDef.html) {\n          converters.blocks[blockType] = createConverterFromNodeMapValue(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 NodeMapValue\n        if (viewDef.Component || viewDef.html) {\n          converters.inlineBlocks[blockType] = createConverterFromNodeMapValue(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 = {\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\n}\n\nexport function convertLexicalToJSX({\n  converters,\n  data,\n  disableIndent,\n  disableTextAlign,\n  nodeMap,\n}: ConvertLexicalToJSXArgs): 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"],"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.d.ts

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