@seafile/sea-email-editor 0.0.1

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

@@ -0,0 +1,154 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _core = require("../../core");
+var _elementTypes = require("../../constants/element-types");
+var _helpers = require("./helpers");
+var _constant = require("../list/constant");
+const getCurrentLineEntry = editor => {
+  // blockquote > paragraph
+  // blockquote > check_list_item
+  // blockquote > list > list_item > paragraph
+  const [currentLineEntry] = _slate.Editor.nodes(editor, {
+    match: n => _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n),
+    mode: 'lowest'
+  });
+  if (!currentLineEntry) return null;
+  const type = currentLineEntry[0].type;
+  if (type === _elementTypes.PARAGRAPH) {
+    const parentPath = _slate.Path.parent(currentLineEntry[1]);
+    if (parentPath.length === 1) return currentLineEntry; // top level element
+    const [listEntry] = _slate.Editor.nodes(editor, {
+      match: n => _slate.Element.isElement(n) && _constant.LIST_TYPES.includes(n.type),
+      mode: 'highest'
+    });
+    return listEntry;
+  }
+  return currentLineEntry;
+};
+const withBlockquote = editor => {
+  const {
+    insertBreak,
+    deleteBackward,
+    insertFragment
+  } = editor;
+  const newEditor = editor;
+  newEditor.insertBreak = () => {
+    const {
+      selection
+    } = editor;
+    if (selection == null) return insertBreak();
+    const [blockquoteEntry] = _slate.Editor.nodes(editor, {
+      match: n => _slate.Element.isElement(n) && n.type === _elementTypes.BLOCKQUOTE,
+      universal: true
+    });
+    if (!blockquoteEntry) return insertBreak();
+
+    // blockquote > paragraph
+    // blockquote > check_list_item
+    // blockquote > list > list_item
+    const currentLineEntry = getCurrentLineEntry(newEditor);
+    if (!currentLineEntry) return insertBreak();
+
+    // handle this case by list plugin
+    const currentLineType = currentLineEntry[0].type;
+    if (_constant.LIST_TYPES.includes(currentLineType) || currentLineType === _elementTypes.CHECK_LIST_ITEM) {
+      insertBreak();
+      return;
+    }
+    const isEmptyLine = _slate.Node.string(currentLineEntry[0]).length === 0;
+    const isFirst = (0, _core.isFirstChild)(blockquoteEntry, currentLineEntry[1]);
+    if (isEmptyLine && isFirst && blockquoteEntry[0].children.length === 1) {
+      _slate.Transforms.unwrapNodes(editor, {
+        mode: 'highest',
+        match: n => _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n)
+      });
+      return;
+    }
+    const isLast = (0, _core.isLastChild)(blockquoteEntry, currentLineEntry[1]);
+    if (isEmptyLine && isLast) {
+      const nextPath = _slate.Path.next(blockquoteEntry[1]);
+      _slate.Transforms.moveNodes(newEditor, {
+        at: currentLineEntry[1],
+        to: nextPath
+      });
+      return;
+    }
+
+    // In other cases, insert a newline
+    _slate.Transforms.insertNodes(newEditor, (0, _core.generateDefaultParagraph)(), {
+      at: newEditor.selection,
+      select: true
+    });
+  };
+  newEditor.deleteBackward = unit => {
+    const {
+      selection
+    } = newEditor;
+    if (selection === null) {
+      deleteBackward(unit);
+      return;
+    }
+    const [blockquoteEntry] = _slate.Editor.nodes(editor, {
+      match: n => _slate.Element.isElement(n) && n.type === _elementTypes.BLOCKQUOTE,
+      universal: true
+    });
+    if (!blockquoteEntry) return deleteBackward(unit);
+
+    // blockquote > paragraph
+    // blockquote > check_list_item
+    // blockquote > list > list_item
+    const currentLineEntry = getCurrentLineEntry(editor);
+    if (!currentLineEntry) return deleteBackward(unit);
+
+    // handle this case by list plugin
+    const currentLineType = currentLineEntry[0].type;
+    if (_constant.LIST_TYPES.includes(currentLineType) || currentLineType === _elementTypes.CHECK_LIST_ITEM) {
+      deleteBackward(unit);
+      return;
+    }
+    const isEmptyLine = _slate.Node.string(currentLineEntry[0]).length === 0;
+    const isFirst = (0, _core.isFirstChild)(blockquoteEntry, currentLineEntry[1]);
+    if (isEmptyLine && isFirst && blockquoteEntry[0].children.length === 1) {
+      (0, _helpers.setBlockQuoteType)(editor, _elementTypes.PARAGRAPH);
+      return;
+    }
+    deleteBackward(unit);
+  };
+  newEditor.insertFragment = fragment => {
+    const {
+      selection
+    } = editor;
+    if (selection == null) return insertFragment(fragment);
+    const [blockquoteEntry] = _slate.Editor.nodes(editor, {
+      match: n => _slate.Element.isElement(n) && n.type === _elementTypes.BLOCKQUOTE,
+      universal: true
+    });
+    if (!blockquoteEntry) return insertFragment(fragment);
+    const firstChild = fragment[0];
+    if (fragment.length === 1 && firstChild.type === _elementTypes.TABLE) {
+      // const nodeEntry = Editor.nodes(newEditor, { mode: 'highest' });
+      const nextPath = _slate.Path.next(blockquoteEntry[1]);
+      _slate.Transforms.insertNodes(newEditor, fragment, {
+        at: nextPath
+      });
+      return;
+    }
+    const insertData = fragment.map(node => {
+      if (node.type === _elementTypes.TABLE) {
+        const text = _slate.Node.string(node);
+        return (0, _core.generateElement)(_elementTypes.PARAGRAPH, {
+          childrenOrText: text
+        });
+      }
+      return node;
+    });
+    return insertFragment(insertData);
+  };
+  return newEditor;
+};
+var _default = exports.default = withBlockquote;

package/dist/extension/plugins/blockquote/render-elem.js

@@ -0,0 +1,29 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _constants = require("../../constants");
+var _jsxRuntime = require("react/jsx-runtime");
+const renderBlockquote = props => {
+  const {
+    attributes,
+    children,
+    element
+  } = props;
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)("blockquote", {
+    "data-id": element.id,
+    "data-root": "true",
+    className: element.className,
+    ...attributes,
+    style: {
+      ...(_constants.ELEMENT_DEFAULT_STYLE[element.type] || {}),
+      ...((element === null || element === void 0 ? void 0 : element.style) || {})
+    },
+    children: children
+  });
+};
+var _default = exports.default = renderBlockquote;

package/dist/extension/plugins/check-list/helper.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformToCheckList = exports.isMenuDisabled = exports.getCheckListEntryList = void 0;
+var _slate = require("slate");
+var _elementTypes = require("../../constants/element-types");
+var _core = require("../../core");
+const isMenuDisabled = (editor, isReadonly) => {
+  if (isReadonly || !editor.selection) return true;
+  const disabledElementTypes = [_elementTypes.CODE_LINE, _elementTypes.CODE_BLOCK, _elementTypes.LIST_ITEM, _elementTypes.TABLE, _elementTypes.TABLE_ROW, _elementTypes.TABLE_CELL];
+  const isSelectedDisableElement = !!(0, _core.getSelectedElems)(editor).find(elem => disabledElementTypes.includes(elem.type));
+  if (isSelectedDisableElement) return true;
+  return false;
+};
+exports.isMenuDisabled = isMenuDisabled;
+const getCheckListEntryList = editor => {
+  const checkListEntries = _slate.Editor.nodes(editor, {
+    match: node => node.type === _elementTypes.CHECK_LIST_ITEM,
+    universal: true
+  });
+  const checkListEntryList = Array.from(checkListEntries);
+  return checkListEntryList;
+};
+exports.getCheckListEntryList = getCheckListEntryList;
+const transformToCheckList = editor => {
+  if (!editor.selection) return;
+  _slate.Transforms.setNodes(editor, {
+    type: _elementTypes.CHECK_LIST_ITEM
+  });
+  (0, _core.focusEditor)(editor);
+};
+exports.transformToCheckList = transformToCheckList;

package/dist/extension/plugins/check-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 = _interopRequireDefault(require("./render-elem"));
+const CheckListPlugin = {
+  type: _elementTypes.CHECK_LIST_ITEM,
+  nodeType: 'element',
+  editorMenus: [_menu.default],
+  editorPlugin: _plugin.default,
+  renderElements: [_renderElem.default]
+};
+var _default = exports.default = CheckListPlugin;

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

@@ -0,0 +1,39 @@
+"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 _constants = require("../../../constants");
+var _elementTypes = require("../../../constants/element-types");
+var _components = require("../../../../components");
+var _helper = require("../helper");
+var _helper2 = require("../../paragraph/helper");
+var _core = require("../../../core");
+var _jsxRuntime = require("react/jsx-runtime");
+const menuConfig = _constants.MENUS_CONFIG_MAP[_elementTypes.CHECK_LIST_ITEM];
+const CheckListMenu = _ref => {
+  let {
+    editor,
+    readonly,
+    className
+  } = _ref;
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  const isDisabled = (0, _react.useMemo)(() => (0, _helper.isMenuDisabled)(editor), [editor.selection, readonly]);
+  const isActive = !!(0, _core.getSelectedNodeByType)(editor, _elementTypes.CHECK_LIST_ITEM);
+  const onClick = (0, _react.useCallback)(e => {
+    e.preventDefault();
+    isActive ? (0, _helper2.transformToParagraph)(editor) : (0, _helper.transformToCheckList)(editor);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [isActive]);
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_components.ToolbarItem, {
+    className: className,
+    disabled: isDisabled,
+    isActive: isActive,
+    onClick: onClick,
+    ...menuConfig
+  });
+};
+var _default = exports.default = CheckListMenu;

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

@@ -0,0 +1,92 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _core = require("../../core");
+var _elementTypes = require("../../constants/element-types");
+var _helper = require("../paragraph/helper");
+var _constants = require("../../constants");
+const withCheckList = editor => {
+  const {
+    insertBreak,
+    deleteBackward,
+    insertFragment
+  } = editor;
+  const newEditor = editor;
+  newEditor.insertBreak = () => {
+    if (!newEditor.selection) {
+      insertBreak();
+      return;
+    }
+    const checkListNode = (0, _core.getSelectedNodeByType)(newEditor, _elementTypes.CHECK_LIST_ITEM);
+    if (!checkListNode) {
+      insertBreak();
+      return;
+    }
+    const nodeText = _slate.Node.string(checkListNode);
+    if (nodeText.length === 0) {
+      (0, _helper.transformToParagraph)(newEditor);
+    } else {
+      _slate.Transforms.splitNodes(newEditor, {
+        always: true
+      });
+    }
+  };
+  newEditor.deleteBackward = unit => {
+    const {
+      selection
+    } = newEditor;
+    if (selection && _slate.Range.isCollapsed(selection)) {
+      const selectedCheckListNode = (0, _core.getSelectedNodeByType)(newEditor, _elementTypes.CHECK_LIST_ITEM);
+      if (selectedCheckListNode && (0, _core.isSelectionAtBlockStart)(editor)) {
+        (0, _helper.transformToParagraph)(newEditor);
+        return;
+      }
+    }
+    deleteBackward(unit);
+  };
+  newEditor.insertFragment = fragment => {
+    const match = {
+      type: [_elementTypes.CHECK_LIST_ITEM]
+    };
+    const [checkListEntry] = (0, _core.getNodeEntries)(newEditor, {
+      match
+    });
+    if (!checkListEntry) return insertFragment(fragment);
+    const firstChild = fragment[0];
+    if (fragment.length === 1 && _constants.LIST_TYPE_ARRAY.includes(firstChild.type)) {
+      // insert text
+      if (firstChild.children.length === 1) {
+        const text = _slate.Node.string(fragment[0]);
+        (0, _slate.insertText)(text);
+        return;
+      }
+
+      // insert list at current path
+      if ((0, _core.isSelectionAtBlockStart)(editor)) {
+        _slate.Transforms.insertNodes(newEditor, fragment);
+        return;
+      }
+
+      // insert list at next path
+      const nextPath = _slate.Path.next(checkListEntry[1]);
+      _slate.Transforms.insertNodes(newEditor, fragment, {
+        at: nextPath
+      });
+      return;
+    }
+    if (fragment.length === 1 && firstChild.type === _elementTypes.TABLE) {
+      const nextPath = _slate.Path.next(checkListEntry[1]);
+      _slate.Transforms.insertNodes(newEditor, fragment, {
+        at: nextPath
+      });
+      return;
+    }
+    return insertFragment(fragment);
+  };
+  return newEditor;
+};
+var _default = exports.default = withCheckList;

package/dist/extension/plugins/check-list/render-elem.js

@@ -0,0 +1,61 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _slate = require("slate");
+var _slateReact = require("slate-react");
+var _constants = require("../../constants");
+var _jsxRuntime = require("react/jsx-runtime");
+/* eslint-disable react-hooks/rules-of-hooks */
+
+const renderCheckListItem = (_ref, editor) => {
+  let {
+    attributes,
+    children,
+    element
+  } = _ref;
+  const isReadonly = (0, _slateReact.useReadOnly)();
+  const {
+    id,
+    checked = false
+  } = element || {};
+  const onChange = event => {
+    const checked = event.target.checked;
+    const path = _slateReact.ReactEditor.findPath(editor, element);
+    _slate.Transforms.setNodes(editor, {
+      checked
+    }, {
+      at: path
+    });
+  };
+  return /*#__PURE__*/(0, _jsxRuntime.jsxs)("div", {
+    "data-id": id,
+    "data-root": "true",
+    className: element.className,
+    ...attributes,
+    style: {
+      ...(_constants.ELEMENT_DEFAULT_STYLE[element.type] || {}),
+      ...((element === null || element === void 0 ? void 0 : element.style) || {})
+    },
+    children: [/*#__PURE__*/(0, _jsxRuntime.jsx)("span", {
+      contentEditable: false,
+      style: {
+        marginRight: 6
+      },
+      children: /*#__PURE__*/(0, _jsxRuntime.jsx)("input", {
+        type: "checkbox",
+        style: {
+          verticalAlign: -2
+        },
+        onChange: onChange,
+        checked: checked,
+        disabled: isReadonly
+      })
+    }), children]
+  });
+};
+var _default = exports.default = renderCheckListItem;

package/dist/extension/plugins/clear-format/helpers.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isMenuDisabled = exports.clearStyles = void 0;
+var _slate = require("slate");
+var _elementTypes = require("../../constants/element-types");
+var _core = require("../../core");
+const isMenuDisabled = function (editor) {
+  let readonly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  if (readonly) return true;
+  if (editor.selection == null) return true;
+  const [match] = _slate.Editor.nodes(editor, {
+    match: n => {
+      const type = (0, _core.getNodeType)(n);
+      if ([_elementTypes.CODE_BLOCK, _elementTypes.CODE_LINE].includes(type)) return true; // code-block
+      if (_slate.Editor.isVoid(editor, n)) return true; // void node
+
+      return false;
+    },
+    universal: true
+  });
+  if (match) return true;
+  return false;
+};
+exports.isMenuDisabled = isMenuDisabled;
+const removeMarks = (editor, textNode) => {
+  // Iterate text node properties, clearing styles
+  const keys = Object.keys(textNode);
+  keys.forEach(key => {
+    if (key === 'text') {
+      // Keep only the text attribute （Text attributes are necessary）
+      return;
+    }
+    // All other attributes are deleted
+    _slate.Editor.removeMark(editor, key);
+  });
+};
+const clearStyles = editor => {
+  const nodeEntries = _slate.Editor.nodes(editor, {
+    match: n => _slate.Text.isText(n),
+    universal: true
+  });
+  for (const nodeEntry of nodeEntries) {
+    // single text node
+    const n = nodeEntry[0];
+    removeMarks(editor, n);
+  }
+};
+exports.clearStyles = clearStyles;

package/dist/extension/plugins/clear-format/menu/index.js

@@ -0,0 +1,35 @@
+"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 _constants = require("../../../constants");
+var _components = require("../../../../components");
+var _helpers = require("../helpers");
+var _jsxRuntime = require("react/jsx-runtime");
+const menuConfig = _constants.MENUS_CONFIG_MAP[_constants.CLEAR_FORMAT];
+const ClearFormatMenu = _ref => {
+  let {
+    className,
+    editor,
+    readonly
+  } = _ref;
+  const onClick = (0, _react.useCallback)(() => {
+    (0, _helpers.clearStyles)(editor);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [editor]);
+  const props = {
+    className,
+    ...menuConfig,
+    disabled: (0, _helpers.isMenuDisabled)(editor, readonly),
+    isActive: false,
+    onClick: onClick
+  };
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_components.ToolbarItem, {
+    ...props
+  });
+};
+var _default = exports.default = ClearFormatMenu;

package/dist/extension/plugins/code-block/helpers.js

@@ -0,0 +1,140 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.unwrapCodeBlock = exports.transformToCodeBlock = exports.setCodeBlockLanguage = exports.isMenuDisabled = exports.isInCodeBlock = exports.getCodeBlockNodeEntry = void 0;
+var _slate = require("slate");
+var _elementTypes = require("../../constants/element-types");
+var _core = require("../../core");
+var _constant = require("./render-elem/constant");
+// eslint-disable-next-line no-unused-vars
+
+const isMenuDisabled = (editor, readonly) => {
+  if (readonly) return true;
+  const {
+    selection
+  } = editor;
+  if (!selection) return true;
+  const selectedElements = (0, _core.getSelectedElems)(editor);
+  const isSelectedVoid = selectedElements.find(node => editor.isVoid(node));
+  if (isSelectedVoid) return true;
+  // Disable the menu when selection is not in the paragraph or code block
+  const isEnable = selectedElements.every(node => [_elementTypes.CODE_BLOCK, _elementTypes.PARAGRAPH, _elementTypes.CODE_LINE].includes(node.type));
+  return !isEnable;
+};
+exports.isMenuDisabled = isMenuDisabled;
+const getCodeBlockNodeEntry = editor => {
+  if (!editor.selection) return;
+  const [codeBlock] = _slate.Editor.nodes(editor, {
+    match: node => node.type === _elementTypes.CODE_BLOCK,
+    mode: 'highest'
+  });
+  return codeBlock;
+};
+exports.getCodeBlockNodeEntry = getCodeBlockNodeEntry;
+const isInCodeBlock = editor => {
+  if (!editor.selection) return false;
+  const [codeBlock] = _slate.Editor.nodes(editor, {
+    match: node => node.type === _elementTypes.CODE_BLOCK,
+    mode: 'highest'
+  });
+  if (!codeBlock) return false;
+  const selectedElements = (0, _core.getSelectedElems)(editor);
+  const isInCodeBlock = !selectedElements.find(element => ![_elementTypes.CODE_BLOCK, _elementTypes.CODE_LINE].includes(element.type));
+  return isInCodeBlock;
+};
+exports.isInCodeBlock = isInCodeBlock;
+const transformToCodeBlock = editor => {
+  const selectedElements = (0, _core.getSelectedElems)(editor);
+  const selectedCodeBlockNum = selectedElements.reduce((codeBlockNum, node) => node.type === _elementTypes.CODE_BLOCK ? ++codeBlockNum : codeBlockNum, 0);
+  if (selectedCodeBlockNum > 0) return;
+  const originSelection = editor.selection;
+  const {
+    anchor: originAnchor,
+    focus: originFocus
+  } = originSelection;
+  const textList = [];
+  const nodeEntries = _slate.Editor.nodes(editor, {
+    match: node => editor.children.includes(node),
+    // Match the highest level node that custom selected
+    universal: true
+  });
+  for (let nodeEntry of nodeEntries) {
+    const [node] = nodeEntry;
+    if (node) {
+      textList.push(_slate.Node.string(node));
+    }
+  }
+  // Generate code block
+  const codeBlockChildren = textList.map(text => (0, _core.generateElement)(_elementTypes.CODE_LINE, {
+    childrenOrText: text
+  }));
+  const codeBlock = (0, _core.generateElement)(_elementTypes.CODE_BLOCK, {
+    childrenOrText: codeBlockChildren,
+    props: {
+      lang: _constant.EXPLAIN_TEXT
+    }
+  });
+  _slate.Editor.withoutNormalizing(editor, () => {
+    _slate.Transforms.removeNodes(editor, {
+      mode: 'highest'
+    });
+    const selectedPath = _slate.Editor.path(editor, originSelection);
+    const beginPath = _slate.Point.isBefore(originAnchor, originFocus) ? originAnchor.path : originFocus.path;
+    const insertPath = selectedPath && Object.keys(selectedPath).length ? [selectedPath[0]] : [beginPath[0]];
+    _slate.Transforms.insertNodes(editor, codeBlock, {
+      at: insertPath
+    });
+    const focusPoint = _slate.Editor.start(editor, insertPath);
+    (0, _core.focusEditor)(editor, focusPoint);
+    // const atPoint = {
+    //   anchor: { offset: 0, path: [insertPath[0], 0, 0] },
+    //   focus: { offset: 0, path: [insertPath[0], 0, 0] }
+    // };
+    // focusEditor(editor, atPoint);
+  });
+};
+exports.transformToCodeBlock = transformToCodeBlock;
+const unwrapCodeBlock = editor => {
+  const selectedCodeBlock = (0, _core.getSelectedNodeEntryByType)(editor, _elementTypes.CODE_BLOCK);
+  if (!selectedCodeBlock) return;
+  const selectedCodeBlockPath = selectedCodeBlock[1];
+  const codeLineEntries = _slate.Editor.nodes(editor, {
+    at: selectedCodeBlockPath,
+    match: node => node.type === _elementTypes.CODE_LINE
+  });
+  const paragraphNodes = [];
+  for (const codeLineEntry of codeLineEntries) {
+    const [codeLineNode] = codeLineEntry;
+    const paragraph = (0, _core.generateElement)(_elementTypes.PARAGRAPH, {
+      childrenOrText: _slate.Node.string(codeLineNode)
+    });
+    paragraphNodes.push(paragraph);
+  }
+  _slate.Transforms.removeNodes(editor, {
+    at: selectedCodeBlockPath,
+    match: node => node.type === _elementTypes.CODE_BLOCK,
+    mode: 'highest'
+  });
+  _slate.Transforms.insertNodes(editor, paragraphNodes, {
+    at: selectedCodeBlockPath
+  });
+  const focusPath = [selectedCodeBlockPath[0] + paragraphNodes.length - 1];
+  (0, _core.focusEditor)(editor, _slate.Editor.end(editor, focusPath));
+};
+
+/**
+ * @param {object} editor
+ * @param {keyof LANGUAGE_MAP} [lang = EXPLAIN_TEXT] by default is 'none'
+ */
+exports.unwrapCodeBlock = unwrapCodeBlock;
+const setCodeBlockLanguage = (editor, lang, path) => {
+  _slate.Transforms.setNodes(editor, {
+    lang
+  }, {
+    at: path
+  });
+  (0, _core.focusEditor)(editor, editor.selection || _slate.Editor.start(editor, path));
+};
+exports.setCodeBlockLanguage = setCodeBlockLanguage;

package/dist/extension/plugins/code-block/index.js

@@ -0,0 +1,20 @@
+"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 _elementTypes = require("../../constants/element-types");
+var _menu = _interopRequireDefault(require("./menu"));
+var _plugin = _interopRequireDefault(require("./plugin"));
+var _renderElem = _interopRequireWildcard(require("./render-elem"));
+const CodeBlockPlugin = {
+  type: _elementTypes.CODE_BLOCK,
+  nodeType: 'element',
+  editorMenus: [_menu.default],
+  editorPlugin: _plugin.default,
+  renderElements: [_renderElem.default, _renderElem.renderCodeLine]
+};
+var _default = exports.default = CodeBlockPlugin;