@lobehub/editor 1.11.0 → 1.13.0

package/es/plugins/common/plugin/index.js

@@ -34,6 +34,7 @@ import { patchBreakLine, registerBreakLineClick } from "../node/ElementDOMSlot";
 import { CursorNode, registerCursorNode } from "../node/cursor";
 import { createBlockNode } from "../utils";
 import { registerHeaderBackspace, registerLastElement, registerRichKeydown } from "./register";
+import { registerMDReader } from "./mdReader";
 patchBreakLine();
 export var CommonPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
   _inherits(CommonPlugin, _KernelPlugin);
@@ -67,7 +68,6 @@ export var CommonPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
         }
       });
     }
-    _this.registerMarkdown(kernel);
     return _this;
   }
   _createClass(CommonPlugin, [{
@@ -130,6 +130,14 @@ export var CommonPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
         intraword: false,
         tag: '_',
         type: 'text-format'
+      }, {
+        format: ['superscript'],
+        tag: '^',
+        type: 'text-format'
+      }, {
+        format: ['subscript'],
+        tag: '~',
+        type: 'text-format'
       }]);
       markdownService.registerMarkdownWriter('paragraph', function (ctx) {
         ctx.wrap('', '\n\n');
@@ -188,6 +196,8 @@ export var CommonPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
         var isItalic = node.hasFormat('italic');
         var isUnderline = node.hasFormat('underline');
         var isStrikethrough = node.hasFormat('strikethrough');
+        var isSuperscript = node.hasFormat('superscript');
+        var isSubscript = node.hasFormat('subscript');
         if (isBold) {
           ctx.appendLine('**');
         }
@@ -200,6 +210,12 @@ export var CommonPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
         if (isUnderline) {
           ctx.appendLine('<ins>');
         }
+        if (isSuperscript) {
+          ctx.appendLine('^');
+        }
+        if (isSubscript) {
+          ctx.appendLine('~');
+        }
         var textContent = node.getTextContent();
         var res = textContent.match(/\s+$/);
         var tailSpace = '';
@@ -209,6 +225,12 @@ export var CommonPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
         var append = textContent.trimEnd();
         var lastChar = append.at(-1);
         ctx.appendLine(append);
+        if (isSubscript) {
+          ctx.appendLine('~');
+        }
+        if (isSuperscript) {
+          ctx.appendLine('^');
+        }
         if (isUnderline) {
           ctx.appendLine('</ins>');
         }
@@ -233,6 +255,10 @@ export var CommonPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
         // In markdown, soft line breaks are represented as two spaces followed by a newline
         ctx.appendLine('  \n');
       });
+
+      // 注册 markdown reader
+      //
+      registerMDReader(markdownService);
     }
   }, {
     key: "onInit",
@@ -241,6 +267,7 @@ export var CommonPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
       this.registerClears(registerRichText(editor), registerDragonSupport(editor), registerHistory(editor, createEmptyHistoryState(), 300), registerHeaderBackspace(editor), registerRichKeydown(editor, this.kernel, {
         enableHotkey: (_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.enableHotkey
       }), registerCommands(editor), registerBreakLineClick(editor), registerCursorNode(editor), registerLastElement(editor));
+      this.registerMarkdown(this.kernel);
     }
   }, {
     key: "destroy",

package/es/plugins/common/plugin/mdReader.d.ts

@@ -0,0 +1,2 @@
+import type { IMarkdownShortCutService } from "../../markdown";
+export declare function registerMDReader(markdownService: IMarkdownShortCutService): void;

package/es/plugins/common/plugin/mdReader.js

@@ -0,0 +1,84 @@
+import { IS_BOLD, IS_ITALIC, IS_STRIKETHROUGH, IS_SUBSCRIPT, IS_SUPERSCRIPT, IS_UNDERLINE } from 'lexical';
+import { INodeHelper } from "../../../editor-kernel/inode/helper";
+export function registerMDReader(markdownService) {
+  markdownService.registerMarkdownReader('blockquote', function (node, children) {
+    return INodeHelper.createElementNode('quote', {
+      children: children,
+      direction: 'ltr',
+      format: '',
+      indent: 0,
+      version: 1
+    });
+  });
+
+  // strong italic del
+  markdownService.registerMarkdownReader('strong', function (node, children) {
+    return children.map(function (child) {
+      if (INodeHelper.isTextNode(child)) {
+        child.format = (child.format || 0) | IS_BOLD;
+      }
+      return child;
+    });
+  });
+
+  // strong italic del
+  markdownService.registerMarkdownReader('emphasis', function (node, children) {
+    return children.map(function (child) {
+      if (INodeHelper.isTextNode(child)) {
+        child.format = (child.format || 0) | IS_ITALIC;
+      }
+      return child;
+    });
+  });
+
+  // strong italic del
+  markdownService.registerMarkdownReader('delete', function (node, children) {
+    return children.map(function (child) {
+      if (INodeHelper.isTextNode(child)) {
+        child.format = (child.format || 0) | IS_STRIKETHROUGH;
+      }
+      return child;
+    });
+  });
+  markdownService.registerMarkdownReader('subscript', function (node, children) {
+    return children.map(function (child) {
+      if (INodeHelper.isTextNode(child)) {
+        child.format = (child.format || 0) | IS_SUBSCRIPT;
+      }
+      return child;
+    });
+  });
+  markdownService.registerMarkdownReader('superscript', function (node, children) {
+    return children.map(function (child) {
+      if (INodeHelper.isTextNode(child)) {
+        child.format = (child.format || 0) | IS_SUPERSCRIPT;
+      }
+      return child;
+    });
+  });
+  markdownService.registerMarkdownReader('html', function (node, children) {
+    if (['<ins>', '<u>'].includes(node.value.toLocaleLowerCase())) {
+      return children.map(function (child) {
+        if (INodeHelper.isTextNode(child)) {
+          child.format = (child.format || 0) | IS_UNDERLINE;
+        }
+        return child;
+      });
+    } else if (['<em>'].includes(node.value.toLocaleLowerCase())) {
+      return children.map(function (child) {
+        if (INodeHelper.isTextNode(child)) {
+          child.format = (child.format || 0) | IS_ITALIC;
+        }
+        return child;
+      });
+    } else if (['<strong>'].includes(node.value.toLocaleLowerCase())) {
+      return children.map(function (child) {
+        if (INodeHelper.isTextNode(child)) {
+          child.format = (child.format || 0) | IS_BOLD;
+        }
+        return child;
+      });
+    }
+    return false;
+  });
+}

package/es/plugins/common/react/ReactPlainText.d.ts

@@ -1,4 +1,4 @@
 /// <reference types="react" />
-import { ReactPlainTextProps } from './type';
+import type { ReactPlainTextProps } from './type';
 declare const ReactPlainText: import("react").NamedExoticComponent<ReactPlainTextProps>;
 export default ReactPlainText;

package/es/plugins/common/utils/index.d.ts

@@ -1,5 +1,5 @@
-import { ElementNode } from 'lexical';
-import { ElementTransformer } from "../../markdown/service/shortcut";
+import type { ElementNode } from 'lexical';
+import type { ElementTransformer } from "../../markdown/service/transformers";
 export declare const createBlockNode: (createNode: (match: Array<string>, parentNode: ElementNode) => ElementNode) => ElementTransformer['replace'];
 /**
  * Returns the root's text content.

package/es/plugins/hr/plugin/index.js

@@ -13,6 +13,7 @@ function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.g
 function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
 function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { INodeHelper } from "../../../editor-kernel/inode/helper";
 import { KernelPlugin } from "../../../editor-kernel/plugin";
 import { IMarkdownShortCutService } from "../../markdown";
 import { registerHorizontalRuleCommand } from "../command";
@@ -24,7 +25,6 @@ export var HRPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
   _inherits(HRPlugin, _KernelPlugin);
   var _super = _createSuper(HRPlugin);
   function HRPlugin(kernel, config) {
-    var _kernel$requireServic, _kernel$requireServic2;
     var _this;
     _classCallCheck(this, HRPlugin);
     _this = _super.call(this);
@@ -37,33 +37,37 @@ export var HRPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
     _this.registerDecorator(kernel, 'horizontalrule', function (node, editor) {
       return config !== null && config !== void 0 && config.decorator ? config.decorator(node, editor) : null;
     });
-    (_kernel$requireServic = kernel.requireService(IMarkdownShortCutService)) === null || _kernel$requireServic === void 0 || _kernel$requireServic.registerMarkdownShortCut({
-      regExp: /^(---|\*\*\*|___)$/,
-      replace: function replace(parentNode, _1, _2, isImport) {
-        var line = $createHorizontalRuleNode();
-
-        // TODO: Get rid of isImport flag
-        if (isImport || parentNode.getNextSibling()) {
-          parentNode.replace(line);
-        } else {
-          parentNode.insertBefore(line);
-        }
-        line.selectNext();
-      },
-      trigger: 'enter',
-      type: 'element'
-    });
-    (_kernel$requireServic2 = kernel.requireService(IMarkdownShortCutService)) === null || _kernel$requireServic2 === void 0 || _kernel$requireServic2.registerMarkdownWriter(HorizontalRuleNode.getType(), function (ctx, node) {
-      if ($isHorizontalRuleNode(node)) {
-        ctx.appendLine('---\n\n');
-      }
-    });
     return _this;
   }
   _createClass(HRPlugin, [{
     key: "onInit",
     value: function onInit(editor) {
+      var _this$kernel$requireS, _this$kernel$requireS2, _this$kernel$requireS3;
       this.register(registerHorizontalRuleCommand(editor));
+      (_this$kernel$requireS = this.kernel.requireService(IMarkdownShortCutService)) === null || _this$kernel$requireS === void 0 || _this$kernel$requireS.registerMarkdownShortCut({
+        regExp: /^(---|\*\*\*|___)$/,
+        replace: function replace(parentNode, _1, _2, isImport) {
+          var line = $createHorizontalRuleNode();
+
+          // TODO: Get rid of isImport flag
+          if (isImport || parentNode.getNextSibling()) {
+            parentNode.replace(line);
+          } else {
+            parentNode.insertBefore(line);
+          }
+          line.selectNext();
+        },
+        trigger: 'enter',
+        type: 'element'
+      });
+      (_this$kernel$requireS2 = this.kernel.requireService(IMarkdownShortCutService)) === null || _this$kernel$requireS2 === void 0 || _this$kernel$requireS2.registerMarkdownWriter(HorizontalRuleNode.getType(), function (ctx, node) {
+        if ($isHorizontalRuleNode(node)) {
+          ctx.appendLine('---\n\n');
+        }
+      });
+      (_this$kernel$requireS3 = this.kernel.requireService(IMarkdownShortCutService)) === null || _this$kernel$requireS3 === void 0 || _this$kernel$requireS3.registerMarkdownReader('thematicBreak', function () {
+        return INodeHelper.createElementNode('horizontalrule', {});
+      });
     }
   }]);
   return HRPlugin;

package/es/plugins/link/plugin/index.js

@@ -20,6 +20,7 @@ function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key i
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
 function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 import { $createTextNode, COMMAND_PRIORITY_NORMAL, PASTE_COMMAND } from 'lexical';
+import { INodeHelper } from "../../../editor-kernel/inode/helper";
 import { KernelPlugin } from "../../../editor-kernel/plugin";
 import { IMarkdownShortCutService } from "../../markdown";
 import { INSERT_LINK_COMMAND, registerLinkCommand } from "../command";
@@ -29,7 +30,6 @@ export var LinkPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
   _inherits(LinkPlugin, _KernelPlugin);
   var _super = _createSuper(LinkPlugin);
   function LinkPlugin(kernel, config) {
-    var _kernel$requireServic, _kernel$requireServic2;
     var _this;
     _classCallCheck(this, LinkPlugin);
     _this = _super.call(this);
@@ -44,30 +44,6 @@ export var LinkPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
     if (config !== null && config !== void 0 && config.linkRegex) {
       _this.linkRegex = config.linkRegex;
     }
-    (_kernel$requireServic = kernel.requireService(IMarkdownShortCutService)) === null || _kernel$requireServic === void 0 || _kernel$requireServic.registerMarkdownShortCut({
-      regExp: /\[([^[]+)]\(([^\s()]+)(?:\s"((?:[^"]*\\")*[^"]*)"\s*)?\)\s?$/,
-      replace: function replace(textNode, match) {
-        var _match = _slicedToArray(match, 4),
-          linkText = _match[1],
-          linkUrl = _match[2],
-          linkTitle = _match[3];
-        var linkNode = $createLinkNode(linkUrl, {
-          title: linkTitle
-        });
-        var linkTextNode = $createTextNode(linkText);
-        linkTextNode.setFormat(textNode.getFormat());
-        linkNode.append(linkTextNode);
-        textNode.replace(linkNode);
-        return linkTextNode;
-      },
-      trigger: ')',
-      type: 'text-match'
-    });
-    (_kernel$requireServic2 = kernel.requireService(IMarkdownShortCutService)) === null || _kernel$requireServic2 === void 0 || _kernel$requireServic2.registerMarkdownWriter(LinkNode.getType(), function (ctx, node) {
-      if ($isLinkNode(node)) {
-        ctx.wrap('[', "](".concat(node.getURL(), ")"));
-      }
-    });
     return _this;
   }
   _createClass(LinkPlugin, [{
@@ -76,7 +52,10 @@ export var LinkPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
       var _this$config,
         _this$config2,
         _this$config3,
-        _this2 = this;
+        _this2 = this,
+        _this$kernel$requireS,
+        _this$kernel$requireS2,
+        _this$kernel$requireS3;
       this.register(registerLinkCommand(editor));
       this.register(registerLinkCommands(editor, this.kernel, {
         attributes: (_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.attributes,
@@ -98,6 +77,43 @@ export var LinkPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
         }
         return false;
       }, COMMAND_PRIORITY_NORMAL));
+      (_this$kernel$requireS = this.kernel.requireService(IMarkdownShortCutService)) === null || _this$kernel$requireS === void 0 || _this$kernel$requireS.registerMarkdownShortCut({
+        regExp: /\[([^[]+)]\(([^\s()]+)(?:\s"((?:[^"]*\\")*[^"]*)"\s*)?\)\s?$/,
+        replace: function replace(textNode, match) {
+          var _match = _slicedToArray(match, 4),
+            linkText = _match[1],
+            linkUrl = _match[2],
+            linkTitle = _match[3];
+          var linkNode = $createLinkNode(linkUrl, {
+            title: linkTitle
+          });
+          var linkTextNode = $createTextNode(linkText);
+          linkTextNode.setFormat(textNode.getFormat());
+          linkNode.append(linkTextNode);
+          textNode.replace(linkNode);
+          return linkTextNode;
+        },
+        trigger: ')',
+        type: 'text-match'
+      });
+      (_this$kernel$requireS2 = this.kernel.requireService(IMarkdownShortCutService)) === null || _this$kernel$requireS2 === void 0 || _this$kernel$requireS2.registerMarkdownWriter(LinkNode.getType(), function (ctx, node) {
+        if ($isLinkNode(node)) {
+          ctx.wrap('[', "](".concat(node.getURL(), ")"));
+        }
+      });
+      (_this$kernel$requireS3 = this.kernel.requireService(IMarkdownShortCutService)) === null || _this$kernel$requireS3 === void 0 || _this$kernel$requireS3.registerMarkdownReader('link', function (node, children) {
+        var linkNode = INodeHelper.createElementNode('link', {
+          children: children,
+          direction: 'ltr',
+          format: '',
+          indent: 0,
+          title: node.title || undefined,
+          type: 'link',
+          url: node.url || '',
+          version: 1
+        });
+        return [linkNode];
+      });
     }
   }]);
   return LinkPlugin;

package/es/plugins/list/plugin/index.js

@@ -17,6 +17,7 @@ import { $isListItemNode, $isListNode, ListItemNode, ListNode, registerList, reg
 import { $getNearestNodeOfType } from '@lexical/utils';
 import { cx } from 'antd-style';
 import { $isRootNode } from 'lexical';
+import { INodeHelper } from "../../../editor-kernel/inode/helper";
 import { KernelPlugin } from "../../../editor-kernel/plugin";
 import { IMarkdownShortCutService } from "../../markdown";
 import { listReplace } from "../utils";
@@ -29,7 +30,6 @@ export var ListPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
   _inherits(ListPlugin, _KernelPlugin);
   var _super = _createSuper(ListPlugin);
   function ListPlugin(kernel, config) {
-    var _kernel$requireServic, _kernel$requireServic2, _kernel$requireServic3, _kernel$requireServic4, _kernel$requireServic5;
     var _this;
     _classCallCheck(this, ListPlugin);
     _this = _super.call(this);
@@ -53,68 +53,6 @@ export var ListPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
         ul: cx('editor_listUnordered', config === null || config === void 0 ? void 0 : config.theme)
       }
     });
-    (_kernel$requireServic = kernel.requireService(IMarkdownShortCutService)) === null || _kernel$requireServic === void 0 || _kernel$requireServic.registerMarkdownShortCut({
-      regExp: UNORDERED_LIST_REGEX,
-      replace: listReplace('bullet'),
-      type: 'element'
-    });
-    (_kernel$requireServic2 = kernel.requireService(IMarkdownShortCutService)) === null || _kernel$requireServic2 === void 0 || _kernel$requireServic2.registerMarkdownShortCut({
-      regExp: ORDERED_LIST_REGEX,
-      replace: listReplace('number'),
-      type: 'element'
-    });
-    (_kernel$requireServic3 = kernel.requireService(IMarkdownShortCutService)) === null || _kernel$requireServic3 === void 0 || _kernel$requireServic3.registerMarkdownShortCut({
-      regExp: CHECK_LIST_REGEX,
-      replace: listReplace('check'),
-      type: 'element'
-    });
-    (_kernel$requireServic4 = kernel.requireService(IMarkdownShortCutService)) === null || _kernel$requireServic4 === void 0 || _kernel$requireServic4.registerMarkdownWriter(ListNode.getType(), function (ctx, node) {
-      if ($isListNode(node)) {
-        ctx.wrap('', '\n');
-      }
-    });
-    var getLevel = function getLevel(node) {
-      if (!node) return 0;
-      if ($isRootNode(node.getParent())) {
-        return 0;
-      }
-      var parent = node.getParent();
-      if (!parent) {
-        return 0;
-      }
-      return getLevel($getNearestNodeOfType(parent, ListNode)) + 1;
-    };
-    (_kernel$requireServic5 = kernel.requireService(IMarkdownShortCutService)) === null || _kernel$requireServic5 === void 0 || _kernel$requireServic5.registerMarkdownWriter(ListItemNode.getType(), function (ctx, node) {
-      var parent = node.getParent();
-      if ($isListItemNode(node) && $isListNode(parent)) {
-        if ($isListNode(node.getFirstChild())) {
-          return;
-        }
-        var level = getLevel(parent);
-        var prefix = '    '.repeat(level);
-        switch (parent.getListType()) {
-          case 'bullet':
-            {
-              ctx.wrap(prefix + '- ', '\n');
-              break;
-            }
-          case 'number':
-            {
-              ctx.wrap("".concat(prefix).concat(node.getValue(), ". "), '\n');
-              break;
-            }
-          case 'check':
-            {
-              ctx.wrap("".concat(prefix, "- [").concat(node.getChecked() ? 'x' : ' ', "] "), '\n');
-              break;
-            }
-          default:
-            {
-              break;
-            }
-        }
-      }
-    });
     return _this;
   }
   _createClass(ListPlugin, [{
@@ -127,6 +65,126 @@ export var ListPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
       this.register(registerListCommands(editor, this.kernel, {
         enableHotkey: (_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.enableHotkey
       }));
+      this.registerMarkdown();
+    }
+  }, {
+    key: "registerMarkdown",
+    value: function registerMarkdown() {
+      var markdownService = this.kernel.requireService(IMarkdownShortCutService);
+      if (!markdownService) {
+        return;
+      }
+      markdownService.registerMarkdownShortCut({
+        regExp: UNORDERED_LIST_REGEX,
+        replace: listReplace('bullet'),
+        type: 'element'
+      });
+      markdownService.registerMarkdownShortCut({
+        regExp: ORDERED_LIST_REGEX,
+        replace: listReplace('number'),
+        type: 'element'
+      });
+      markdownService.registerMarkdownShortCut({
+        regExp: CHECK_LIST_REGEX,
+        replace: listReplace('check'),
+        type: 'element'
+      });
+      markdownService.registerMarkdownWriter(ListNode.getType(), function (ctx, node) {
+        if ($isListNode(node)) {
+          ctx.wrap('', '\n');
+        }
+      });
+      var getLevel = function getLevel(node) {
+        if (!node) return 0;
+        if ($isRootNode(node.getParent())) {
+          return 0;
+        }
+        var parent = node.getParent();
+        if (!parent) {
+          return 0;
+        }
+        return getLevel($getNearestNodeOfType(parent, ListNode)) + 1;
+      };
+      markdownService.registerMarkdownWriter(ListItemNode.getType(), function (ctx, node) {
+        var parent = node.getParent();
+        if ($isListItemNode(node) && $isListNode(parent)) {
+          if ($isListNode(node.getFirstChild())) {
+            return;
+          }
+          var level = getLevel(parent);
+          var prefix = '    '.repeat(level);
+          switch (parent.getListType()) {
+            case 'bullet':
+              {
+                ctx.wrap(prefix + '- ', '\n');
+                break;
+              }
+            case 'number':
+              {
+                ctx.wrap("".concat(prefix).concat(node.getValue(), ". "), '\n');
+                break;
+              }
+            case 'check':
+              {
+                ctx.wrap("".concat(prefix, "- [").concat(node.getChecked() ? 'x' : ' ', "] "), '\n');
+                break;
+              }
+            default:
+              {
+                break;
+              }
+          }
+        }
+      });
+      markdownService.registerMarkdownReader('list', function (node, children) {
+        var _node$children, _node$children2;
+        var isCheck = ((_node$children = node.children) === null || _node$children === void 0 || (_node$children = _node$children[0]) === null || _node$children === void 0 ? void 0 : _node$children.type) === 'listItem' && typeof ((_node$children2 = node.children) === null || _node$children2 === void 0 || (_node$children2 = _node$children2[0]) === null || _node$children2 === void 0 ? void 0 : _node$children2.checked) === 'boolean';
+        var start = node.start || 1;
+        return INodeHelper.createElementNode('list', {
+          children: children.map(function (v) {
+            if (v.type === 'listitem') {
+              // @ts-expect-error not error
+              v.value = start++;
+            }
+            return v;
+          }),
+          direction: 'ltr',
+          format: '',
+          indent: 0,
+          listType: isCheck ? 'check' : node.ordered ? 'number' : 'bullet',
+          start: node.start || 1,
+          tag: node.ordered ? 'ol' : 'ul',
+          version: 1
+        });
+      });
+      markdownService.registerMarkdownReader('listItem', function (node, children, index) {
+        return children.map(function (v) {
+          if (v.type === 'paragraph') {
+            return INodeHelper.createElementNode('listitem', {
+              checked: typeof node.checked === 'boolean' ? node.checked : undefined,
+              // @ts-expect-error not error
+              children: v.children,
+              direction: 'ltr',
+              format: '',
+              indent: 0,
+              type: 'listitem',
+              value: index + 1,
+              version: 1
+            });
+          } else if (v.type === 'list') {
+            return INodeHelper.createElementNode('listitem', {
+              children: [v],
+              direction: 'ltr',
+              format: '',
+              indent: 0,
+              type: 'listitem',
+              value: index + 1,
+              version: 1
+            });
+          }
+          throw new Error('ListItem node children must be paragraph or list node ' + v.type);
+        });
+      });
     }
   }]);
   return ListPlugin;

package/es/plugins/list/utils/index.d.ts

@@ -1,5 +1,5 @@
-import { ListType } from '@lexical/list';
-import { RangeSelection } from 'lexical';
-import { ElementTransformer } from "../../markdown/service/shortcut";
+import type { ListType } from '@lexical/list';
+import type { RangeSelection } from 'lexical';
+import type { ElementTransformer } from "../../markdown/service/transformers";
 export declare const listReplace: (listType: ListType) => ElementTransformer['replace'];
 export declare function $indentOverTab(selection: RangeSelection): boolean;

package/es/plugins/markdown/data-source/markdown/parse.d.ts

@@ -0,0 +1,21 @@
+import type { Html, PhrasingContent, Root, RootContent } from 'mdast';
+import type { IElementNode, INode, IRootNode, ITextNode } from "../../../../editor-kernel/inode";
+export type MarkdownReadNode = INode | ITextNode | IElementNode;
+export type MarkdownNode = Root | RootContent | PhrasingContent;
+export type MarkdownReaderFunc<K> = (node: Extract<MarkdownNode, {
+    type: K;
+}>, children: MarkdownReadNode[], index: number) => MarkdownReadNode | MarkdownReadNode[] | false;
+export type TransformerRecord = {
+    [K in MarkdownNode['type']]?: MarkdownReaderFunc<K> | Array<MarkdownReaderFunc<K>>;
+};
+export type TransfromerRecordArray = {
+    [K in MarkdownNode['type']]?: Array<MarkdownReaderFunc<K>>;
+};
+export interface IHTMLStack {
+    children: Array<MarkdownReadNode[] | MarkdownReadNode | null>;
+    index: number;
+    isEndTag: boolean;
+    node: Html;
+    tag: string;
+}
+export declare function parseMarkdownToLexical(markdown: string, markdownReaders?: TransformerRecord): IRootNode;