@seafile/seafile-editor 1.0.0 → 1.0.2

package/dist/extension/plugins/link/render-elem/index.js

@@ -0,0 +1,83 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
+var _react = _interopRequireWildcard(require("react"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _slateReact = require("slate-react");
+var _linkPopover = _interopRequireDefault(require("./link-popover"));
+var _helper = require("../helper");
+var _eventBus = _interopRequireDefault(require("../../../../utils/event-bus"));
+var _eventTypes = require("../../../../constants/event-types");
+require("./style.css");
+/* eslint-disable react-hooks/rules-of-hooks */
+
+var renderLink = function renderLink(_ref, editor) {
+  var attributes = _ref.attributes,
+    children = _ref.children,
+    element = _ref.element;
+  var _useState = (0, _react.useState)(false),
+    _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+    isShowPopover = _useState2[0],
+    setIsShowPopover = _useState2[1];
+  var _useState3 = (0, _react.useState)({
+      top: 0,
+      left: 0
+    }),
+    _useState4 = (0, _slicedToArray2.default)(_useState3, 2),
+    popoverPosition = _useState4[0],
+    setPopoverPosition = _useState4[1];
+  var isReadonly = (0, _slateReact.useReadOnly)();
+  var onClosePopover = (0, _react.useCallback)(function (e) {
+    unregisterClickEvent();
+    setIsShowPopover(false);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [setPopoverPosition]);
+  var registerClickEvent = (0, _react.useCallback)(function () {
+    document.addEventListener('click', onClosePopover);
+  }, [onClosePopover]);
+  var unregisterClickEvent = (0, _react.useCallback)(function () {
+    document.removeEventListener('click', onClosePopover);
+  }, [onClosePopover]);
+  var onOpenPopover = (0, _react.useCallback)(function (e) {
+    if (isReadonly) return;
+    e.stopPropagation();
+    // Only one popover can be open at the same time, close other popover and update new popover controller function.
+    var eventBus = _eventBus.default.getInstance();
+    eventBus.dispatch(_eventTypes.INTERNAL_EVENTS.ON_CLOSE_LINK_POPOVER);
+    eventBus.subscribe(_eventTypes.INTERNAL_EVENTS.ON_CLOSE_LINK_POPOVER, function () {
+      return setIsShowPopover(false);
+    });
+    var linkInfo = (0, _helper.getLinkInfo)(editor);
+    if (!linkInfo) return;
+    var _e$target$getBounding = e.target.getBoundingClientRect(),
+      top = _e$target$getBounding.top,
+      left = _e$target$getBounding.left,
+      width = _e$target$getBounding.width;
+    var popoverTop = top - 42;
+    var popoverLeft = left - 140 / 2 + width / 2;
+    setPopoverPosition({
+      top: popoverTop,
+      left: popoverLeft
+    });
+    setIsShowPopover(true);
+    registerClickEvent();
+  }, [editor, isReadonly, registerClickEvent]);
+  return /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/_react.default.createElement("span", Object.assign({
+    onClick: onOpenPopover,
+    className: (0, _classnames.default)('sf-virtual-link', {
+      selected: isShowPopover
+    })
+  }, attributes), children), isShowPopover && /*#__PURE__*/_react.default.createElement(_linkPopover.default, {
+    popoverPosition: popoverPosition,
+    linkUrl: element.url,
+    editor: editor,
+    onClosePopover: onClosePopover
+  }));
+};
+var _default = exports.default = renderLink;

package/dist/extension/plugins/link/render-elem/link-popover.js

@@ -0,0 +1,77 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _reactDom = require("react-dom");
+var _eventBus = _interopRequireDefault(require("../../../../utils/event-bus"));
+var _helper = require("../helper");
+var _common = require("../../../../utils/common");
+var _eventTypes = require("../../../../constants/event-types");
+require("./style.css");
+var LinkPopover = function LinkPopover(_ref) {
+  var linkUrl = _ref.linkUrl,
+    onClosePopover = _ref.onClosePopover,
+    popoverPosition = _ref.popoverPosition,
+    editor = _ref.editor;
+  (0, _react.useEffect)(function () {
+    return function () {
+      // unregister click event before unmount
+      onClosePopover();
+    };
+  }, [onClosePopover]);
+  var onLinkClick = (0, _react.useCallback)(function (e) {
+    if (!(0, _common.isUrl)(linkUrl)) {
+      e.preventDefault();
+    }
+  }, [linkUrl]);
+  var onUnwrapLink = (0, _react.useCallback)(function (e) {
+    e.stopPropagation();
+    (0, _helper.unWrapLinkNode)(editor);
+  }, [editor]);
+  var onEditLink = (0, _react.useCallback)(function (e) {
+    e.stopPropagation();
+    var linkNode = (0, _helper.getLinkInfo)(editor);
+    if (!linkNode) {
+      onClosePopover();
+      return;
+    }
+    var linkTitle = linkNode.linkTitle,
+      linkUrl = linkNode.linkUrl;
+    var eventBus = _eventBus.default.getInstance();
+    eventBus.dispatch(_eventTypes.INTERNAL_EVENTS.ON_OPEN_LINK_POPOVER, {
+      linkTitle: linkTitle,
+      linkUrl: linkUrl
+    });
+  }, [editor, onClosePopover]);
+  return /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/(0, _reactDom.createPortal)( /*#__PURE__*/_react.default.createElement("div", {
+    id: "link-op-menu",
+    className: "sf-link-op-menu",
+    style: popoverPosition
+  }, /*#__PURE__*/_react.default.createElement("a", {
+    href: linkUrl,
+    onClick: onLinkClick,
+    target: "_blank",
+    rel: "noopener noreferrer",
+    className: "sf-link-op-menu-link"
+  }, linkUrl), /*#__PURE__*/_react.default.createElement("div", {
+    className: "sf-link-op-icons d-flex "
+  }, /*#__PURE__*/_react.default.createElement("span", {
+    role: "button",
+    className: "sf-link-op-icon",
+    onClick: onEditLink
+  }, /*#__PURE__*/_react.default.createElement("i", {
+    className: "iconfont icon-edit"
+  })), /*#__PURE__*/_react.default.createElement("span", {
+    role: "button",
+    className: "sf-link-op-icon",
+    onClick: onUnwrapLink
+  }, /*#__PURE__*/_react.default.createElement("i", {
+    className: "iconfont icon-delete"
+  })))), document.body));
+};
+var _default = exports.default = LinkPopover;

package/dist/extension/plugins/list/constant.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LIST_TYPES = void 0;
+var _elementTypes = require("../../constants/element-types");
+var LIST_TYPES = exports.LIST_TYPES = [_elementTypes.ORDERED_LIST, _elementTypes.UNORDERED_LIST];

package/dist/extension/plugins/list/helpers.js

@@ -0,0 +1,78 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isMenuDisabled = exports.getActiveListType = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
+var _slate = require("slate");
+var _elementTypes = require("../../constants/element-types");
+var _constant = require("./constant");
+var isMenuDisabled = exports.isMenuDisabled = function isMenuDisabled(editor, readonly) {
+  if (readonly || !editor.selection) return true;
+  // Match disable node
+  var _Editor$nodes = _slate.Editor.nodes(editor, {
+      match: function match(node) {
+        if (!_slate.Element.isElement(node)) return false;
+        var isVoidOrBlock = _slate.Editor.isVoid(editor, node) && _slate.Editor.isBlock(editor, node);
+        if (isVoidOrBlock) return true;
+        var disabledNodeTypes = [_elementTypes.CODE_LINE, _elementTypes.CODE_BLOCK, _elementTypes.TABLE, _elementTypes.CHECK_LIST_ITEM];
+        var isDisabledNode = disabledNodeTypes.includes(node.type);
+        if (isDisabledNode) return true;
+        return false;
+      }
+    }),
+    _Editor$nodes2 = (0, _slicedToArray2.default)(_Editor$nodes, 1),
+    matchedDisabledNode = _Editor$nodes2[0];
+  if (matchedDisabledNode) return true;
+  return false;
+};
+
+/**
+ * @returns {ORDERED_LIST | UNORDERED_LIST | undefined} Return the list type of the selected list
+ */
+var getActiveListType = exports.getActiveListType = function getActiveListType(editor) {
+  var selection = editor.selection;
+  if (!selection) return;
+  var selectedListNodeEntry;
+  if (_slate.Range.isCollapsed(selection)) {
+    var _Editor$nodes3 = _slate.Editor.nodes(editor, {
+        match: function match(node) {
+          return _constant.LIST_TYPES.includes(node.type);
+        },
+        mode: 'lowest'
+      }),
+      _Editor$nodes4 = (0, _slicedToArray2.default)(_Editor$nodes3, 1),
+      nodeEntry = _Editor$nodes4[0];
+    selectedListNodeEntry = nodeEntry;
+  } else {
+    var anchor = selection.anchor,
+      focus = selection.focus;
+    var commonNodeEntry = _slate.Node.common(editor, anchor.path, focus.path);
+    //  Select condition:
+    // 1. Select in one list
+    // 2. Select in one list item
+    // 3. Select in one line
+    if (_constant.LIST_TYPES.includes(commonNodeEntry[0].type)) {
+      // Select in one list
+      selectedListNodeEntry = commonNodeEntry;
+    } else if (commonNodeEntry[0].type === _elementTypes.LIST_ITEM) {
+      // Select in one list item
+      selectedListNodeEntry = _slate.Editor.parent(editor, commonNodeEntry[1]);
+    } else if (_slate.Text.isText(commonNodeEntry[0])) {
+      // Select in one line
+      var _Editor$nodes5 = _slate.Editor.nodes(editor, {
+          at: commonNodeEntry[1],
+          match: function match(node) {
+            return _constant.LIST_TYPES.includes(node.type);
+          },
+          mode: 'lowest'
+        }),
+        _Editor$nodes6 = (0, _slicedToArray2.default)(_Editor$nodes5, 1),
+        _nodeEntry = _Editor$nodes6[0];
+      selectedListNodeEntry = _nodeEntry;
+    }
+  }
+  return selectedListNodeEntry && selectedListNodeEntry[0].type;
+};

package/dist/extension/plugins/list/index.js

@@ -0,0 +1,19 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _elementTypes = require("../../constants/element-types");
+var _menu = _interopRequireDefault(require("./menu"));
+var _plugin = _interopRequireDefault(require("./plugin"));
+var _renderElem = require("./render-elem");
+var ListPlugin = {
+  type: _elementTypes.LIST_ITEM,
+  nodeType: 'element',
+  editorMenus: [_menu.default],
+  editorPlugin: _plugin.default,
+  renderElements: [_renderElem.renderList, _renderElem.renderListItem, _renderElem.renderListLic]
+};
+var _default = exports.default = ListPlugin;

package/dist/extension/plugins/list/menu/index.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _menuItem = _interopRequireDefault(require("../../../commons/menu/menu-item"));
+var _helpers = require("../helpers");
+var _constants = require("../../../constants");
+var _transforms = require("../transforms");
+var _core = require("../../../core");
+var _elementTypes = require("../../../constants/element-types");
+var ListMenu = function ListMenu(_ref) {
+  var editor = _ref.editor,
+    readonly = _ref.readonly,
+    isRichEditor = _ref.isRichEditor,
+    type = _ref.type,
+    className = _ref.className;
+  var isActive = (0, _helpers.getActiveListType)(editor, type) === type;
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  var isDisabled = (0, _react.useMemo)(function () {
+    return (0, _helpers.isMenuDisabled)(editor, readonly);
+  }, [editor.selection, readonly]);
+
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  var menuConfig = (0, _react.useMemo)(function () {
+    return _constants.MENUS_CONFIG_MAP[type];
+  }, []);
+  var onMouseDown = (0, _react.useCallback)(function (e) {
+    e.preventDefault();
+    (0, _transforms.transformsToList)(editor, type);
+    (0, _core.focusEditor)(editor);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [isActive]);
+  return /*#__PURE__*/_react.default.createElement(_menuItem.default, Object.assign({
+    isRichEditor: isRichEditor,
+    isActive: isActive,
+    disabled: isDisabled,
+    className: className,
+    onMouseDown: onMouseDown
+  }, menuConfig));
+};
+var _default = exports.default = ListMenu;

package/dist/extension/plugins/list/plugin/index.js

@@ -0,0 +1,48 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _isHotkey = _interopRequireDefault(require("is-hotkey"));
+var _helpers = require("../helpers");
+var _onTabHandle = require("./on-tab-handle");
+var _insertBreakList = require("./insert-break-list");
+var _insertFragmentList = require("./insert-fragment-list");
+var _normalizeList = require("./normalize-list");
+var _constant = require("../constant");
+var withList = function withList(editor) {
+  var insertBreak = editor.insertBreak,
+    onHotKeyDown = editor.onHotKeyDown,
+    deleteBackWord = editor.deleteBackWord;
+  var newEditor = editor;
+  newEditor.insertBreak = function () {
+    if ((0, _insertBreakList.insertBreakList)(editor)) return;
+    insertBreak();
+    return;
+  };
+  newEditor.deleteBackWord = function (unit) {
+    var selection = newEditor.selection;
+    if (selection === null) {
+      deleteBackWord(unit);
+      return;
+    }
+    // nothing todo
+    deleteBackWord(unit);
+  };
+  newEditor.onHotKeyDown = function (event) {
+    var activeListType = (0, _helpers.getActiveListType)(editor);
+    var isListActive = _constant.LIST_TYPES.includes(activeListType);
+    if (isListActive) {
+      if ((0, _isHotkey.default)(['tab', 'shift+tab'], event)) {
+        if ((0, _onTabHandle.handleTab)(newEditor, event)) return true;
+      }
+    }
+    return onHotKeyDown && onHotKeyDown(event);
+  };
+  newEditor.insertFragment = (0, _insertFragmentList.insertFragmentList)(newEditor);
+  newEditor.normalizeNode = (0, _normalizeList.normalizeList)(newEditor);
+  return newEditor;
+};
+var _default = exports.default = withList;

package/dist/extension/plugins/list/plugin/insert-break-list.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.insertBreakList = void 0;
+var _core = require("../../../core");
+var _queries = require("../queries");
+var _transforms = require("../transforms");
+var insertBreakList = exports.insertBreakList = function insertBreakList(editor) {
+  if (!editor.selection) return;
+
+  // moved | inserted
+  var moved = false;
+  var res = (0, _queries.getListItemEntry)(editor, {});
+  // If selection is in a li, and li content is empty
+  if (res) {
+    if ((0, _core.isBlockAboveEmpty)(editor)) {
+      moved = (0, _transforms.movedListItemUp)(editor, res);
+      if (moved) return true;
+    }
+  }
+  if (!moved) {
+    var inserted = (0, _transforms.insertListItem)(editor);
+    if (inserted) return true;
+  }
+  return;
+};

package/dist/extension/plugins/list/plugin/insert-fragment-list.js

@@ -0,0 +1,190 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.insertFragmentList = exports.getTextAndListItemNodes = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/toConsumableArray"));
+var _toArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/toArray"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
+var _slate = require("slate");
+var _slugid = _interopRequireDefault(require("slugid"));
+var _core = require("../../../core");
+var _constant = require("../constant");
+var _elementTypes = require("../../../constants/element-types");
+var isListRoot = function isListRoot(node) {
+  return _slate.Element.isElement(node) && _constant.LIST_TYPES.includes(node.type);
+};
+var getFirstAncestorOfType = function getFirstAncestorOfType(root, entry, _ref) {
+  var type = _ref.type;
+  var ancestor = _slate.Path.parent(entry[1]);
+  while ((0, _core.getNode)(root, ancestor).type !== type) {
+    ancestor = _slate.Path.parent(ancestor);
+  }
+  return [(0, _core.getNode)(root, ancestor), ancestor];
+};
+var findListItemsWithContent = function findListItemsWithContent(first) {
+  var prev = null;
+  var node = first;
+  while (isListRoot(node) || node.type === _elementTypes.LIST_ITEM && node.children[0].type !== _elementTypes.PARAGRAPH) {
+    prev = node;
+    var _node$children = (0, _slicedToArray2.default)(node.children, 1);
+    node = _node$children[0];
+  }
+  return prev ? prev.children : [node];
+};
+var trimList = function trimList(listRoot) {
+  if (!isListRoot(listRoot)) {
+    return [listRoot];
+  }
+  var _texts = _slate.Node.texts(listRoot);
+  var textEntries = Array.from(_texts);
+  var commonAncestorEntry = textEntries.reduce(function (commonAncestor, textEntry) {
+    return _slate.Path.isAncestor(commonAncestor[1], textEntry[1]) ? commonAncestor : (0, _core.getCommonNode)(listRoot, textEntry[1], commonAncestor[1]);
+  }, getFirstAncestorOfType(listRoot, textEntries[0], {
+    type: _elementTypes.LIST_ITEM
+  }));
+
+  // is ul/ol: return children
+  // is not ul/ol
+  var _ref2 = isListRoot(commonAncestorEntry[0]) ? commonAncestorEntry[0].children : [commonAncestorEntry[0]],
+    _ref3 = (0, _toArray2.default)(_ref2),
+    first = _ref3[0],
+    rest = _ref3.slice(1);
+  return [].concat((0, _toConsumableArray2.default)(findListItemsWithContent(first)), (0, _toConsumableArray2.default)(rest));
+};
+var wrapNodeIntoListItem = function wrapNodeIntoListItem(node) {
+  return node.type === _elementTypes.LIST_ITEM ? node : {
+    id: _slugid.default.nice(),
+    type: _elementTypes.LIST_ITEM,
+    children: [node]
+  };
+};
+var isSingleLic = function isSingleLic(fragment) {
+  var isFragmentOnlyListRoot = fragment.length === 1 && isListRoot(fragment[0]);
+  return isFragmentOnlyListRoot && (0, _toConsumableArray2.default)((0, _core.getNodes)({
+    children: fragment
+  })).filter(function (entry) {
+    return _slate.Element.isElement(entry[0]);
+  }).filter(function (_ref4) {
+    var _ref5 = (0, _slicedToArray2.default)(_ref4, 1),
+      node = _ref5[0];
+    return node.type === _elementTypes.PARAGRAPH;
+  }).length === 1;
+};
+var getTextAndListItemNodes = exports.getTextAndListItemNodes = function getTextAndListItemNodes(editor, fragment, liEntry, licEntry) {
+  var _liEntry = (0, _slicedToArray2.default)(liEntry, 2),
+    liPath = _liEntry[1];
+  var _licEntry = (0, _slicedToArray2.default)(licEntry, 2),
+    licNode = _licEntry[0],
+    licPath = _licEntry[1];
+  var isEmptyNode = !_slate.Node.string(licNode);
+  // format copied fragment
+  // first: lic, path: [...liPath, 0, 0]
+  // rest: children, path: [...liPath, 1, 0]
+  var _fragment$flatMap$map = fragment.flatMap(trimList).map(wrapNodeIntoListItem),
+    _fragment$flatMap$map2 = (0, _toArray2.default)(_fragment$flatMap$map),
+    first = _fragment$flatMap$map2[0],
+    rest = _fragment$flatMap$map2.slice(1);
+  var textNode = null;
+  var listItemNodes = [];
+  if (isListRoot(fragment[0])) {
+    if (isSingleLic(fragment)) {
+      textNode = first;
+      listItemNodes = rest;
+    } else if (isEmptyNode) {
+      var li = (0, _core.getNode)(editor, liPath);
+      var _li$children = (0, _toArray2.default)(li.children),
+        currentSubLists = _li$children.slice(1); // old
+
+      var _first$children = (0, _toArray2.default)(first.children),
+        newLic = _first$children[0],
+        newSubLists = _first$children.slice(1); // copied
+      // insert copied contents
+      _slate.Transforms.insertNodes(editor, newLic, {
+        at: _slate.Path.next(licPath),
+        select: true
+      });
+      _slate.Transforms.removeNodes(editor, {
+        at: licPath
+      });
+      if (newSubLists.length) {
+        if (currentSubLists.length) {
+          var path = [].concat((0, _toConsumableArray2.default)(liPath), [1, 0]);
+          _slate.Transforms.insertNodes(editor, newSubLists[0].children, {
+            at: path,
+            select: true
+          });
+        } else {
+          _slate.Transforms.insertNodes(editor, newSubLists, {
+            at: _slate.Path.next(licPath),
+            select: true
+          });
+        }
+      }
+      textNode = (0, _core.generateDefaultText)();
+      listItemNodes = rest;
+    } else {
+      textNode = (0, _core.generateDefaultText)();
+      listItemNodes = [first].concat((0, _toConsumableArray2.default)(rest));
+    }
+  } else {
+    textNode = first;
+    listItemNodes = rest;
+    return {
+      textNode: textNode,
+      listItemNodes: listItemNodes
+    };
+  }
+  return {
+    textNode: textNode,
+    listItemNodes: listItemNodes
+  };
+};
+var insertFragmentList = exports.insertFragmentList = function insertFragmentList(editor) {
+  var _insertFragment = editor.insertFragment;
+  return function (fragment) {
+    _slate.Editor.withoutNormalizing(editor, function () {
+      var liEntry = (0, _core.findNode)(editor, {
+        match: {
+          type: _elementTypes.LIST_ITEM
+        },
+        mode: 'lowest'
+      });
+      if (!liEntry) {
+        var nodes = isListRoot(fragment) ? [(0, _core.generateDefaultText)()].concat((0, _toConsumableArray2.default)(fragment)) : fragment;
+        return _insertFragment(nodes);
+      }
+      (0, _slate.insertFragment)(editor, [(0, _core.generateDefaultText)()]); // need ' '
+
+      liEntry = (0, _core.findNode)(editor, {
+        match: {
+          type: _elementTypes.LIST_ITEM
+        },
+        mode: 'lowest'
+      });
+      var licEntry = (0, _core.findNode)(editor, {
+        match: {
+          type: _elementTypes.PARAGRAPH
+        },
+        mode: 'lowest'
+      });
+      if (!licEntry) {
+        var _nodes = isListRoot(fragment) ? [(0, _core.generateDefaultText)()].concat((0, _toConsumableArray2.default)(fragment)) : fragment;
+        return _insertFragment(_nodes);
+      }
+      var _getTextAndListItemNo = getTextAndListItemNodes(editor, fragment, liEntry, licEntry),
+        textNode = _getTextAndListItemNo.textNode,
+        listItemNodes = _getTextAndListItemNo.listItemNodes;
+      (0, _slate.insertFragment)(editor, [textNode]);
+      var _liEntry2 = liEntry,
+        _liEntry3 = (0, _slicedToArray2.default)(_liEntry2, 2),
+        liPath = _liEntry3[1];
+      return _slate.Transforms.insertNodes(editor, listItemNodes, {
+        at: _slate.Path.next(liPath),
+        select: true
+      });
+    });
+  };
+};

package/dist/extension/plugins/list/plugin/normalize-list.js

@@ -0,0 +1,81 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.normalizeList = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
+var _slate = require("slate");
+var _transforms = require("../transforms");
+var _elementTypes = require("../../../constants/element-types");
+var _core = require("../../../core");
+var _constant = require("../constant");
+var normalizeList = exports.normalizeList = function normalizeList(editor) {
+  var normalizeNode = editor.normalizeNode;
+  return function (_ref) {
+    var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
+      node = _ref2[0],
+      path = _ref2[1];
+    if (!_slate.Element.isElement(node)) {
+      return normalizeNode([node, path]);
+    }
+
+    // root
+    if (_constant.LIST_TYPES.includes(node.type)) {
+      var children = (0, _core.getChildren)([node, path]);
+      var nonLiChild = children.find(function (_ref3) {
+        var _ref4 = (0, _slicedToArray2.default)(_ref3, 1),
+          child = _ref4[0];
+        return child.type !== _elementTypes.LIST_ITEM;
+      });
+      if (nonLiChild) {
+        var listItem = (0, _core.generateElement)(_elementTypes.LIST_ITEM, []);
+        _slate.Transforms.wrapNodes(editor, listItem, {
+          at: nonLiChild[1]
+        });
+        return;
+      }
+    }
+    if ((0, _core.match)(node, [], {
+      type: _constant.LIST_TYPES
+    })) {
+      if (!node.children.length || !node.children.find(function (item) {
+        return item.type === _elementTypes.LIST_ITEM;
+      })) {
+        _slate.Transforms.removeNodes(editor, {
+          at: path
+        });
+        return;
+      }
+      var nextPath = _slate.Path.next(path);
+      var nextNode = (0, _core.getNode)(editor, nextPath);
+      if ((nextNode === null || nextNode === void 0 ? void 0 : nextNode.type) === node.type) {
+        (0, _transforms.moveListItemsToList)(editor, {
+          fromList: [nextNode, nextPath],
+          toList: [node, path],
+          deleteFromList: true
+        });
+      }
+      var prevPath = (0, _core.getPreviousPath)(path);
+      var prevNode = (0, _core.getNode)(editor, prevPath);
+      if ((prevNode === null || prevNode === void 0 ? void 0 : prevNode.type) === node.type) {
+        editor.normalizeNode([prevNode, prevPath]);
+        return;
+      }
+      if ((0, _transforms.normalizeNestedList)(editor, {
+        nestedListItem: [node, path]
+      })) {
+        return;
+      }
+    }
+    if (node.type === _elementTypes.LIST_ITEM) {
+      if ((0, _transforms.normalizeListItem)(editor, {
+        listItem: [node, path]
+      })) {
+        return;
+      }
+    }
+    normalizeNode([node, path]);
+  };
+};