@seafile/sea-email-editor 0.0.1

package/dist/extension/plugins/link/menu/link-modal.js

@@ -0,0 +1,169 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _reactstrap = require("reactstrap");
+var _constants = require("@/constants");
+var _components = require("../../../../components");
+var _helper = require("../helper");
+var _jsxRuntime = require("react/jsx-runtime");
+const LinkModal = _ref => {
+  let {
+    editor,
+    onCloseModal,
+    linkTitle,
+    linkUrl
+  } = _ref;
+  const [formData, setFormData] = (0, _react.useState)({
+    linkUrl: linkUrl !== null && linkUrl !== void 0 ? linkUrl : '',
+    linkTitle: linkTitle !== null && linkTitle !== void 0 ? linkTitle : ''
+  });
+  const [validatorErrorMessage, setValidatorErrorMessage] = (0, _react.useState)({
+    linkUrl: '',
+    linkTitle: ''
+  });
+  const linkAddressRef = (0, _react.useRef)(null);
+  const isSubmitDisabled = (0, _react.useMemo)(() => {
+    const isFormDataEmpty = Object.values(formData).some(value => value.length === 0);
+    if (isFormDataEmpty) return true;
+    const isValidatorErrorMessage = Object.values(validatorErrorMessage).some(value => value.length > 0);
+    if (isValidatorErrorMessage) return true;
+    return false;
+  }, [formData, validatorErrorMessage]);
+  const onOpened = (0, _react.useCallback)(() => {
+    var _linkAddressRef$curre;
+    (_linkAddressRef$curre = linkAddressRef.current) === null || _linkAddressRef$curre === void 0 ? void 0 : _linkAddressRef$curre.focus();
+  }, []);
+
+  /**
+   * @param {String} formItemName  form item name
+   * @param {String} formItemValue form item value
+   * @returns if validate passed, return Promise.resolve(); else return Promise.reject(error message);
+   */
+  const validateFormData = (0, _react.useCallback)((formItemName, formItemValue) => {
+    if (formItemName === 'linkUrl') {
+      if (formItemValue.length === 0) return Promise.reject('Link address required');
+      // When entering a URL in the dialog box, the validity is not checked.
+      // if (!isUrl(formItemValue)) return Promise.reject('Link_address_invalid');
+    }
+    if (formItemName === 'linkTitle') {
+      if (!formItemValue.length) return Promise.reject('Link title required');
+      if (!formItemValue.trim().length) return Promise.reject('Blank title not allowed');
+    }
+    return Promise.resolve();
+  }, []);
+  const preProcessBeforeOnchange = (0, _react.useCallback)((formItemName, formItemValue) => {
+    if (formItemName === 'linkUrl') {
+      return formItemValue.trim();
+    }
+    return formItemValue;
+  }, []);
+  const onFormValueChange = (0, _react.useCallback)(e => {
+    const formItemName = e.target.name;
+    let formItemValue = e.target.value;
+    // pre-process form item value
+    formItemValue = preProcessBeforeOnchange(formItemName, formItemValue);
+    validateFormData(formItemName, formItemValue).then(() => setValidatorErrorMessage({
+      ...validatorErrorMessage,
+      [formItemName]: ''
+    }), errMsg => setValidatorErrorMessage({
+      ...validatorErrorMessage,
+      [formItemName]: errMsg
+    }));
+    setFormData({
+      ...formData,
+      [formItemName]: formItemValue
+    });
+  }, [formData, preProcessBeforeOnchange, validateFormData, validatorErrorMessage]);
+  const onSubmit = (0, _react.useCallback)(e => {
+    // re-validate form data before submit
+    Object.entries(formData).forEach(_ref2 => {
+      let [key, value] = _ref2;
+      return validateFormData(key, value).catch(errMsg => setValidatorErrorMessage(prev => ({
+        ...prev,
+        [key]: errMsg
+      })));
+    });
+    if (!isSubmitDisabled) {
+      const isLinkActive = (0, _helper.isLinkType)(editor);
+      isLinkActive ? (0, _helper.updateLink)(editor, formData.linkUrl, formData.linkTitle) : (0, _helper.insertLink)({
+        editor,
+        url: formData.linkUrl,
+        title: formData.linkTitle
+      });
+      onCloseModal();
+    }
+    e.preventDefault();
+    e.stopPropagation();
+  }, [editor, formData, isSubmitDisabled, onCloseModal, validateFormData]);
+  const onKeydown = (0, _react.useCallback)(e => {
+    if (e.key === 'Enter') {
+      onSubmit(e);
+    }
+  }, [onSubmit]);
+  return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_components.Modal, {
+    isOpen: true,
+    toggle: onCloseModal,
+    onOpened: onOpened,
+    zIndex: 1100,
+    children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_components.ModalHeader, {
+      toggle: onCloseModal,
+      children: (0, _constants.gettext)('Insert link')
+    }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactstrap.ModalBody, {
+      children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactstrap.Form, {
+        onChange: onFormValueChange,
+        children: [/*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactstrap.FormGroup, {
+          children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_reactstrap.Label, {
+            for: "linkUrl",
+            children: (0, _constants.gettext)('Link address')
+          }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactstrap.Input, {
+            onKeyDown: onKeydown
+            // `onChange={() => void 0}`  to fix reactstrap error which need `onChange` when `value` setteled, (`onChange` has been listened at `<Form>` )
+            ,
+            onChange: () => void 0,
+            value: formData.linkUrl,
+            invalid: !!validatorErrorMessage.linkUrl,
+            name: "linkUrl",
+            innerRef: linkAddressRef,
+            type: "url",
+            id: "linkUrl"
+          }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactstrap.FormFeedback, {
+            children: (0, _constants.gettext)(validatorErrorMessage.linkUrl)
+          })]
+        }), /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactstrap.FormGroup, {
+          children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_reactstrap.Label, {
+            for: "linkTitle",
+            children: (0, _constants.gettext)('Link title')
+          }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactstrap.Input, {
+            onKeyDown: onKeydown
+            // `onChange={() => void 0}`  to fix reactstrap error which need `onChange` when `value` setteled, (`onChange` has been listened at `<Form>` )
+            ,
+            onChange: () => void 0,
+            value: formData.linkTitle,
+            invalid: !!validatorErrorMessage.linkTitle,
+            name: "linkTitle",
+            id: "linkTitle"
+          }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactstrap.FormFeedback, {
+            children: (0, _constants.gettext)(validatorErrorMessage.linkTitle)
+          })]
+        })]
+      })
+    }), /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactstrap.ModalFooter, {
+      children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_reactstrap.Button, {
+        onClick: onCloseModal,
+        color: "secondary",
+        children: (0, _constants.gettext)('Cancel')
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactstrap.Button, {
+        onClick: onSubmit,
+        disabled: isSubmitDisabled,
+        color: "primary",
+        children: (0, _constants.gettext)('Add link')
+      })]
+    })]
+  });
+};
+var _default = exports.default = LinkModal;

package/dist/extension/plugins/link/plugin.js

@@ -0,0 +1,172 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _slugid = _interopRequireDefault(require("slugid"));
+var _queries = require("../../core/queries");
+var _helper = require("./helper");
+var _elementTypes = require("../../constants/element-types");
+var _constants = require("../../constants");
+var _eventTypes = require("../../../constants/event-types");
+var _common = require("../../../utils/common");
+var _focusEditor = require("../../core/transforms/focus-editor");
+var _helper2 = require("../image/helper");
+var _isHotkey = _interopRequireDefault(require("is-hotkey"));
+var _eventBus = _interopRequireDefault(require("../../../utils/event-bus"));
+const withLink = editor => {
+  const {
+    isInline,
+    insertBreak,
+    deleteBackward,
+    insertText,
+    normalizeNode,
+    insertData,
+    onHotKeyDown
+  } = editor;
+  const newEditor = editor;
+
+  // Rewrite isInline
+  newEditor.isInline = elem => {
+    const {
+      type
+    } = elem;
+    if (type === _elementTypes.LINK) {
+      return true;
+    }
+    return isInline(elem);
+  };
+  newEditor.insertBreak = () => {
+    const [selectedElement, path] = _slate.Editor.parent(editor, editor.selection);
+    if (selectedElement.type === _elementTypes.LINK) {
+      const endPoint = _slate.Range.end(editor.selection);
+      const [selectedLeaf] = _slate.Editor.node(editor, endPoint);
+      if (selectedLeaf.text.length === endPoint.offset) {
+        if (_slate.Range.isExpanded(editor.selection)) {
+          _slate.Transforms.delete(editor);
+        } else {
+          _slate.Transforms.select(editor, {
+            path: _slate.Path.next(path),
+            offset: 0
+          });
+        }
+      }
+    }
+    insertBreak();
+  };
+
+  // ! bug: insertFragment will insert the same character twice in LinkNode, so we need to delete the first character
+  newEditor.insertText = text => {
+    const isCollapsed = _slate.Range.isCollapsed(editor.selection);
+    const path = _slate.Editor.path(editor, editor.selection);
+    const isLinkNode = (0, _queries.getSelectedNodeByType)(editor, _elementTypes.LINK);
+    const isFocusAtLinkEnd = _slate.Editor.isEnd(editor, editor.selection.focus, path);
+    if (isCollapsed && isLinkNode && isFocusAtLinkEnd) {
+      _slate.Editor.insertFragment(newEditor, [{
+        id: _slugid.default.nice(),
+        text: text
+      }]);
+      return;
+    }
+    return insertText(text);
+  };
+  newEditor.insertData = data => {
+    // Paste link content
+    const text = data.getData('text/plain');
+    if ((0, _common.isUrl)(text) && !(0, _common.isImage)(text)) {
+      const link = (0, _helper.generateLinkNode)(text, text);
+      _slate.Editor.insertFragment(newEditor, [link], {
+        select: true
+      });
+      return;
+    } else if ((0, _common.isUrl)(text) && (0, _common.isImage)(text)) {
+      (0, _helper2.insertImage)(newEditor, text);
+      return;
+    }
+    insertData(data);
+  };
+  newEditor.deleteBackward = unit => {
+    const {
+      selection
+    } = newEditor;
+    if (!selection) return deleteBackward(unit);
+    // Delete link node
+    const isDeletingLinkNode = (0, _helper.isLinkType)(editor);
+    if (isDeletingLinkNode) {
+      const linkNodeInfo = (0, _helper.getLinkInfo)(editor);
+      if (linkNodeInfo && linkNodeInfo.linkTitle.length === 1) {
+        const next = _slate.Editor.next(editor);
+        const nextPath = _slate.Path.next(linkNodeInfo.path);
+        const nextNode = _slate.Editor.node(editor, nextPath);
+        (0, _focusEditor.focusEditor)(editor, next[1]);
+        _slate.Transforms.select(editor, nextNode[1]);
+        _slate.Transforms.delete(newEditor, {
+          at: linkNodeInfo.path
+        });
+        return;
+      }
+    }
+    return deleteBackward(unit);
+  };
+
+  // Add 'mod+k' shortcut Key
+  newEditor.onHotKeyDown = e => {
+    if ((0, _isHotkey.default)('mod+k', e)) {
+      e.preventDefault();
+      const {
+        selection
+      } = newEditor;
+      const isCollapsed = _slate.Range.isCollapsed(selection);
+      const eventBus = _eventBus.default.getInstance();
+      if (isCollapsed) {
+        eventBus.dispatch(_eventTypes.INTERNAL_EVENTS.INSERT_ELEMENT, {
+          type: _constants.ElementTypes.LINK,
+          editor
+        });
+      } else {
+        const [firstSelectedNode, ...restNodes] = (0, _queries.getSelectedElems)(newEditor);
+        if (!firstSelectedNode) return; // If not select any node, return
+        // If firstNode has child nods, recursively check if every child node contains a text node
+        const hasTextNode = node => {
+          if (_slate.Text.isText(node)) return true;
+          if (node.children && node.children.length > 0) {
+            return node.children.some(hasTextNode);
+          }
+        };
+        const isSelectTextNodes = hasTextNode(firstSelectedNode);
+        if (!isSelectTextNodes) return;
+        const linkTitle = window.getSelection().toString();
+        eventBus.dispatch(_eventTypes.INTERNAL_EVENTS.INSERT_ELEMENT, {
+          type: _constants.ElementTypes.LINK,
+          editor: newEditor,
+          linkTitle: linkTitle
+        });
+      }
+    }
+    return onHotKeyDown && onHotKeyDown(e);
+  };
+
+  // Rewrite normalizeNode
+  newEditor.normalizeNode = _ref => {
+    let [node, path] = _ref;
+    const type = (0, _queries.getNodeType)(node);
+    if (type !== _elementTypes.LINK) {
+      // If the type is not link, perform default normalizeNode
+      return normalizeNode([node, path]);
+    }
+
+    // If the link is empty, delete it
+    const str = _slate.Node.string(node);
+    if (str === '') {
+      return _slate.Transforms.removeNodes(newEditor, {
+        at: path
+      });
+    }
+    return normalizeNode([node, path]);
+  };
+  return newEditor;
+};
+var _default = exports.default = withLink;

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

@@ -0,0 +1,12 @@
+.sea-email-virtual-link {
+  color: #eb8205;
+}
+
+.sea-email-virtual-link:hover {
+  text-decoration: underline;
+  text-underline-position: under;
+}
+
+.sea-email-virtual-link.selected {
+  background-color: #e5e5e5;
+}

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

@@ -0,0 +1,103 @@
+"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 _classnames = _interopRequireDefault(require("classnames"));
+var _slateReact = require("slate-react");
+var _linkOpMenu = _interopRequireDefault(require("./link-op-menu"));
+var _helper = require("../helper");
+var _eventBus = _interopRequireDefault(require("../../../../utils/event-bus"));
+var _eventTypes = require("../../../../constants/event-types");
+var _constants = require("../../../constants");
+require("./index.css");
+var _jsxRuntime = require("react/jsx-runtime");
+/* eslint-disable react-hooks/rules-of-hooks */
+
+const renderLink = (_ref, editor) => {
+  let {
+    attributes,
+    children,
+    element,
+    option
+  } = _ref;
+  const [isShowPopover, setIsShowPopover] = (0, _react.useState)(false);
+  const [popoverPosition, setPopoverPosition] = (0, _react.useState)({
+    top: 0,
+    left: 0
+  });
+  const isReadonly = (0, _slateReact.useReadOnly)();
+
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  const isLinkActive = (0, _react.useMemo)(() => (0, _helper.isLinkType)(editor), [editor.selection]);
+  const onClosePopover = (0, _react.useCallback)(e => {
+    unregisterClickEvent();
+    setIsShowPopover(false);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [setPopoverPosition]);
+  const registerClickEvent = (0, _react.useCallback)(() => {
+    window.addEventListener('click', onClosePopover);
+  }, [onClosePopover]);
+  const unregisterClickEvent = (0, _react.useCallback)(() => {
+    window.removeEventListener('click', onClosePopover);
+  }, [onClosePopover]);
+  const onLinkClick = (0, _react.useCallback)(e => {
+    e.stopPropagation();
+    const eventBus = _eventBus.default.getInstance();
+    if (isReadonly) {
+      eventBus.dispatch(_eventTypes.EXTERNAL_EVENTS.ON_LINK_CLICK, e, editor._id);
+      return;
+    }
+    // Only one popover can be open at the same time, close other popover and update new popover controller function.
+    eventBus.dispatch(_eventTypes.INTERNAL_EVENTS.ON_CLOSE_LINK_POPOVER);
+    eventBus.subscribe(_eventTypes.INTERNAL_EVENTS.ON_CLOSE_LINK_POPOVER, () => setIsShowPopover(false));
+    const linkInfo = (0, _helper.getLinkInfo)(editor);
+    if (!linkInfo) return;
+    const {
+      top,
+      left,
+      width
+    } = e.target.getBoundingClientRect();
+    const popoverTop = top - 42;
+    const popoverLeft = left - 140 / 2 + width / 2;
+    setPopoverPosition({
+      top: popoverTop,
+      left: popoverLeft
+    });
+    setIsShowPopover(true);
+    registerClickEvent();
+  }, [editor, isReadonly, registerClickEvent]);
+  const onHrefClick = (0, _react.useCallback)(e => {
+    e.preventDefault();
+  }, []);
+  const url = (0, _helper.getElementHref)(element);
+  return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_jsxRuntime.Fragment, {
+    children: [/*#__PURE__*/(0, _jsxRuntime.jsx)("span", {
+      onClick: onLinkClick,
+      "data-url": url,
+      ...attributes,
+      children: /*#__PURE__*/(0, _jsxRuntime.jsx)("a", {
+        href: url,
+        className: (0, _classnames.default)('sea-email-virtual-link', element.className, {
+          selected: isShowPopover
+        }),
+        style: {
+          ...(_constants.ELEMENT_DEFAULT_STYLE[element.type] || {}),
+          ...((element === null || element === void 0 ? void 0 : element.style) || {})
+        },
+        onClick: onHrefClick,
+        children: children
+      })
+    }), isLinkActive && isShowPopover && /*#__PURE__*/(0, _jsxRuntime.jsx)(_linkOpMenu.default, {
+      popoverPosition: popoverPosition,
+      linkUrl: url,
+      editor: editor,
+      onClosePopover: onClosePopover
+    })]
+  });
+};
+var _default = exports.default = renderLink;

package/dist/extension/plugins/link/render-elem/link-op-menu/index.css

@@ -0,0 +1,33 @@
+.sea-email-link-op-menu {
+  height: 36px;
+  padding: 7px 8px;
+  display: flex;
+  position: absolute;
+  background-color: #fff;
+  border: 1px solid #e5e5e5;
+  border-radius: 3px;
+  box-shadow: 0 1px 0 rgba(0, 0, 0, 0.08);
+  z-index: 1999;
+}
+
+.sea-email-link-op-menu-link {
+  font-size: 12px;
+  color: #212529;
+  padding: 0 5px;
+  line-height: 20px;
+}
+
+.sea-email-link-op-menu-link:hover {
+  color: #212529;
+  text-decoration: none;
+  background: #f1f1f1;
+  cursor: pointer;
+}
+
+.sea-email-link-op-icons {
+  margin-left: 8px;
+  border-left: 1px solid #e5e5e5;
+  display: flex;
+  gap: 8px;
+  padding-left: 8px;
+}

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

@@ -0,0 +1,89 @@
+"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 _constants = require("@/constants");
+var _eventBus = _interopRequireDefault(require("../../../../../utils/event-bus"));
+var _helper = require("../../helper");
+var _eventTypes = require("../../../../../constants/event-types");
+var _components = require("../../../../../components");
+require("./index.css");
+var _jsxRuntime = require("react/jsx-runtime");
+const LinkOpMenu = _ref => {
+  let {
+    linkUrl,
+    onClosePopover,
+    popoverPosition,
+    editor
+  } = _ref;
+  (0, _react.useEffect)(() => {
+    return () => {
+      // unregister click event before unmount
+      onClosePopover();
+    };
+  }, [onClosePopover]);
+  const onLinkClick = (0, _react.useCallback)(event => {
+    const eventBus = _eventBus.default.getInstance();
+    eventBus.dispatch(_eventTypes.EXTERNAL_EVENTS.ON_LINK_CLICK, event, editor._id);
+    onClosePopover();
+  }, [editor, onClosePopover]);
+  const onUnwrapLink = (0, _react.useCallback)(e => {
+    e.stopPropagation();
+    (0, _helper.unWrapLinkNode)(editor);
+  }, [editor]);
+  const onEditLink = (0, _react.useCallback)(e => {
+    e.stopPropagation();
+    const linkNode = (0, _helper.getLinkInfo)(editor);
+    if (!linkNode) {
+      onClosePopover();
+      return;
+    }
+    const {
+      linkTitle,
+      linkUrl
+    } = linkNode;
+    const eventBus = _eventBus.default.getInstance();
+    eventBus.dispatch(_eventTypes.INTERNAL_EVENTS.ON_OPEN_LINK_MODAL, {
+      linkTitle,
+      linkUrl
+    });
+    onClosePopover();
+  }, [editor, onClosePopover]);
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_jsxRuntime.Fragment, {
+    children: /*#__PURE__*/(0, _reactDom.createPortal)(/*#__PURE__*/(0, _jsxRuntime.jsxs)("div", {
+      id: "link-op-menu",
+      className: "sea-email-link-op-menu",
+      style: popoverPosition,
+      children: [/*#__PURE__*/(0, _jsxRuntime.jsx)("span", {
+        "data-url": linkUrl,
+        onClick: onLinkClick,
+        className: "sea-email-link-op-menu-link",
+        children: (0, _constants.gettext)('Open link')
+      }), /*#__PURE__*/(0, _jsxRuntime.jsxs)("div", {
+        className: "sea-email-link-op-icons",
+        children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_components.IconButton, {
+          icon: "rename",
+          onClick: onEditLink,
+          size: {
+            btn: 20,
+            icon: 12
+          }
+        }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_components.IconButton, {
+          icon: "unlink",
+          onClick: onUnwrapLink,
+          size: {
+            btn: 20,
+            icon: 12
+          }
+        })]
+      })]
+    }), document.body)
+  });
+};
+var _default = exports.default = LinkOpMenu;

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");
+const LIST_TYPES = exports.LIST_TYPES = [_elementTypes.ORDERED_LIST, _elementTypes.UNORDERED_LIST];

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

@@ -0,0 +1,102 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setListType = exports.isMenuDisabled = exports.getBeforeText = exports.getActiveListType = void 0;
+var _slate = require("slate");
+var _elementTypes = require("../../constants/element-types");
+var _constant = require("./constant");
+var _transforms = require("./transforms");
+const isMenuDisabled = (editor, readonly) => {
+  if (readonly || !editor.selection) return true;
+  // Match disable node
+  const [matchedDisabledNode] = _slate.Editor.nodes(editor, {
+    match: node => {
+      if (!_slate.Element.isElement(node)) return false;
+      const isVoidOrBlock = _slate.Editor.isVoid(editor, node) && _slate.Editor.isBlock(editor, node);
+      if (isVoidOrBlock) return true;
+      const disabledNodeTypes = [_elementTypes.CODE_LINE, _elementTypes.CODE_BLOCK, _elementTypes.TABLE, _elementTypes.CHECK_LIST_ITEM];
+      const isDisabledNode = disabledNodeTypes.includes(node.type);
+      if (isDisabledNode) return true;
+      return false;
+    }
+  });
+  if (matchedDisabledNode) return true;
+  return false;
+};
+
+/**
+ * @returns {ORDERED_LIST | UNORDERED_LIST | undefined} Return the list type of the selected list
+ */
+exports.isMenuDisabled = isMenuDisabled;
+const getActiveListType = editor => {
+  const {
+    selection
+  } = editor;
+  if (!selection) return;
+  let selectedListNodeEntry;
+  if (_slate.Range.isCollapsed(selection)) {
+    const [nodeEntry] = _slate.Editor.nodes(editor, {
+      match: node => _constant.LIST_TYPES.includes(node.type),
+      mode: 'lowest'
+    });
+    selectedListNodeEntry = nodeEntry;
+  } else {
+    const {
+      anchor,
+      focus
+    } = selection;
+    const 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
+      const [nodeEntry] = _slate.Editor.nodes(editor, {
+        at: commonNodeEntry[1],
+        match: node => _constant.LIST_TYPES.includes(node.type),
+        mode: 'lowest'
+      });
+      selectedListNodeEntry = nodeEntry;
+    }
+  }
+  return selectedListNodeEntry && selectedListNodeEntry[0].type;
+};
+exports.getActiveListType = getActiveListType;
+const setListType = (editor, type) => {
+  (0, _transforms.transformsToList)(editor, type);
+};
+exports.setListType = setListType;
+const getBeforeText = editor => {
+  const {
+    selection
+  } = editor;
+  if (selection == null) return {
+    beforeText: '',
+    range: null
+  };
+  const {
+    anchor
+  } = selection;
+  // Find the near text node above the current text
+  const [, aboveNodePath] = _slate.Editor.above(editor);
+  const aboveNodeStartPoint = _slate.Editor.start(editor, aboveNodePath); // The starting position of the text node
+  const range = {
+    anchor,
+    focus: aboveNodeStartPoint
+  };
+  const beforeText = _slate.Editor.string(editor, range) || '';
+  return {
+    beforeText,
+    range
+  };
+};
+exports.getBeforeText = getBeforeText;