@seafile/sea-email-editor 0.0.1

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

@@ -0,0 +1,59 @@
+"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 _elementTypes = require("../../../constants/element-types");
+var _helpers = require("../helpers");
+var _constants = require("../../../constants");
+var _components = require("../../../../components");
+var _constants2 = require("../../../../constants");
+var _jsxRuntime = require("react/jsx-runtime");
+const menuConfig = _constants.MENUS_CONFIG_MAP[_elementTypes.CODE_BLOCK];
+const CodeBlockMenu = _ref => {
+  let {
+    readonly,
+    editor,
+    toggle
+  } = _ref;
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  const isActive = (0, _react.useMemo)(() => (0, _helpers.isInCodeBlock)(editor), [editor.selection]);
+  const onClick = (0, _react.useCallback)(e => {
+    e.preventDefault();
+    isActive ? (0, _helpers.unwrapCodeBlock)(editor) : (0, _helpers.transformToCodeBlock)(editor);
+    toggle && toggle();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [isActive]);
+  return /*#__PURE__*/(0, _jsxRuntime.jsxs)("div", {
+    className: (0, _classnames.default)('sea-email-option-editor-option', {
+      'disabled': readonly
+    }),
+    id: menuConfig.id,
+    onClick: onClick,
+    children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_components.IconButton, {
+      icon: menuConfig.icon,
+      className: "no-hover-bg sea-email-option-editor-option-icon",
+      style: {
+        marginLeft: 0,
+        marginRight: 8
+      },
+      size: 16
+    }), /*#__PURE__*/(0, _jsxRuntime.jsx)("span", {
+      className: "text-truncate",
+      title: (0, _constants2.gettext)(menuConfig.text),
+      children: (0, _constants2.gettext)(menuConfig.text)
+    }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_components.IconButton, {
+      icon: '',
+      className: "sea-email-option-editor-option-check-btn no-hover-bg",
+      style: {
+        marginLeft: 12
+      }
+    })]
+  });
+};
+var _default = exports.default = CodeBlockMenu;

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

@@ -0,0 +1,288 @@
+"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 _slate = require("slate");
+var _core = require("../../core");
+var _helpers = require("./helpers");
+var _elementTypes = require("../../constants/element-types");
+const withCodeBlock = editor => {
+  const {
+    normalizeNode,
+    insertFragment,
+    insertText,
+    insertBreak,
+    insertData,
+    insertNode,
+    onHotKeyDown
+  } = editor;
+  const newEditor = editor;
+  newEditor.insertData = data => {
+    if (data.types.includes('text/code-block') && !(0, _core.getSelectedNodeByType)(editor, _elementTypes.CODE_BLOCK)) {
+      const codeBlockNode = JSON.parse(data.getData('text/code-block'));
+      return insertNode(codeBlockNode);
+    }
+    insertData(data);
+  };
+  newEditor.insertFragment = data => {
+    // only selected code block content
+    if (data.length === 1 && data[0].type === _elementTypes.CODE_BLOCK && !(0, _core.getSelectedNodeByType)(editor, _elementTypes.CODE_BLOCK)) {
+      data.forEach((node, index) => {
+        if (node.type === _elementTypes.CODE_BLOCK) {
+          const newBlock = node.children.map(line => {
+            const text = _slate.Node.string(line);
+            const children = (0, _core.generateElement)(_elementTypes.PARAGRAPH, {
+              childrenOrText: text
+            });
+            return children;
+          });
+          data.splice(index, 1, ...newBlock);
+        }
+      });
+      return insertFragment(data);
+    } else {
+      if ((0, _core.getSelectedNodeByType)(editor, _elementTypes.CODE_BLOCK)) {
+        // Paste into code block
+
+        // Pasted data is code block split with code-line
+        data.forEach((node, index) => {
+          if (node.type === _elementTypes.CODE_BLOCK) {
+            const codeLineArr = node.children.map(line => line);
+            data.splice(index, 1, ...codeLineArr);
+            // Paste the copied content in place in code_block
+          } else if (node.type === _elementTypes.CODE_LINE) {
+            data.splice(index, 1, node);
+          }
+        });
+        const insertCodeLines = data.map(node => {
+          const text = _slate.Node.string(node);
+          const codeLine = (0, _core.generateElement)(_elementTypes.CODE_LINE, {
+            childrenOrText: text
+          });
+          return codeLine;
+        });
+
+        // Current focus code-line string not empty
+        const string = _slate.Editor.string(newEditor, newEditor.selection.focus.path);
+        // Paste the copied content in place in code_block
+        if (insertCodeLines.length === 1 && _slate.Range.isExpanded(newEditor.selection)) {
+          const text = _slate.Node.string(insertCodeLines[0]);
+          insertText(text);
+          return;
+        }
+        if (string.length !== 0 && _slate.Range.isCollapsed(newEditor.selection)) {
+          const [node, ...restNode] = insertCodeLines;
+          const text = _slate.Node.string(node);
+          insertText(text);
+          if (restNode.length !== 0) {
+            insertBreak();
+            insertFragment(restNode);
+          }
+          return;
+        }
+        return insertFragment(insertCodeLines);
+      } else {
+        // Paste into not a code block
+        return insertFragment(data);
+      }
+    }
+  };
+
+  // Rewrite normalizeNode
+  newEditor.normalizeNode = _ref => {
+    let [node, path] = _ref;
+    const type = (0, _core.getNodeType)(node);
+    if (type === _elementTypes.CODE_LINE && path.length <= 1) {
+      _slate.Transforms.setNodes(newEditor, {
+        type: _elementTypes.PARAGRAPH
+      }, {
+        at: path
+      });
+      return;
+    } else if (type === _elementTypes.CODE_LINE && node.children.length > 1) {
+      // If one code_line has more than one text nodes, merge all text nodes into a single text node
+      const mergedText = node.children.map(textNode => textNode.text).join('');
+      _slate.Transforms.removeNodes(editor, {
+        at: [...path]
+      });
+      _slate.Transforms.insertNodes(editor, {
+        type: _elementTypes.CODE_LINE,
+        children: [{
+          text: mergedText
+        }]
+      }, {
+        at: [...path]
+      });
+      return;
+    }
+    if (type === _elementTypes.CODE_BLOCK) {
+      if (node.children.length === 0) {
+        _slate.Transforms.delete(newEditor, {
+          at: path
+        });
+        return;
+      }
+
+      // code-block is the last node in the editor and needs to be followed by a p node
+      const isLast = (0, _core.isLastNode)(newEditor, node);
+      if (isLast) {
+        const paragraph = (0, _core.generateEmptyElement)(_elementTypes.PARAGRAPH);
+        _slate.Transforms.insertNodes(newEditor, paragraph, {
+          at: [path[0] + 1]
+        });
+      }
+      const isFirst = (0, _core.isFirstNode)(newEditor, node);
+      if (isFirst) {
+        const paragraph = (0, _core.generateEmptyElement)(_elementTypes.PARAGRAPH);
+        _slate.Transforms.insertNodes(newEditor, paragraph, {
+          at: [path[0]]
+        });
+      }
+
+      // Here must be a code node below code-block
+      if ((0, _core.getNodeType)(node.children[0]) !== _elementTypes.CODE_LINE) {
+        _slate.Transforms.unwrapNodes(newEditor);
+        _slate.Transforms.setNodes(newEditor, {
+          type: _elementTypes.PARAGRAPH
+        }, {
+          mode: 'highest'
+        });
+      }
+      if (node.children.length > 1) {
+        node.children.forEach((child, index) => {
+          if (child.type !== _elementTypes.CODE_LINE) {
+            _slate.Transforms.setNodes(newEditor, {
+              type: _elementTypes.CODE_LINE
+            }, {
+              at: [...path, index]
+            });
+          }
+        });
+      }
+    }
+    // Perform default behavior
+    return normalizeNode([node, path]);
+  };
+  newEditor.onHotKeyDown = event => {
+    const wrapperCodeBlock = (0, _helpers.getCodeBlockNodeEntry)(newEditor);
+    if (!wrapperCodeBlock) return onHotKeyDown && onHotKeyDown(event);
+    if ((0, _isHotkey.default)('mod+enter', event)) {
+      event.preventDefault();
+      if (newEditor.selection && !_slate.Range.isExpanded(newEditor.selection)) {
+        const path = _slate.Editor.path(newEditor, newEditor.selection);
+        const newParagraphPath = [path[0] + 1];
+        const newParagraph = (0, _core.generateEmptyElement)(_elementTypes.PARAGRAPH);
+        _slate.Transforms.insertNodes(newEditor, newParagraph, {
+          at: newParagraphPath
+        });
+        _slate.Transforms.select(newEditor, newParagraphPath);
+      }
+      return true;
+    }
+    if ((0, _isHotkey.default)('tab', event)) {
+      if (newEditor.hasMovedSelection) event.stopPropagation();
+      event.preventDefault();
+      const nodeEntries = _slate.Editor.nodes(newEditor, {
+        mode: 'lowest',
+        match: node => node.type === _elementTypes.CODE_LINE
+      });
+      const nodeEntryList = Array.from(nodeEntries);
+      for (const nodeEntry of nodeEntryList) {
+        const [, path] = nodeEntry;
+        // Insert 4 spaces for easier remove space
+        _slate.Transforms.insertText(newEditor, ' '.repeat(4), {
+          at: {
+            path: [...path, 0],
+            offset: 0
+          }
+        });
+      }
+      const firstCodeLinePath = nodeEntryList.at(0)[1].concat(0);
+      const lastCodeLinePath = nodeEntryList.at(-1)[1].concat(0);
+      const newRange = _slate.Editor.range(newEditor, firstCodeLinePath, lastCodeLinePath);
+      nodeEntryList.length > 1 ? _slate.Transforms.select(newEditor, newRange) : _slate.Transforms.select(newEditor);
+      return true;
+    }
+    if ((0, _isHotkey.default)('shift+tab', event)) {
+      if (newEditor.hasMovedSelection) event.stopPropagation();
+      event.preventDefault();
+      // Match the beginning of the line space, delete up to 4 spaces at a time
+      const originSelection = newEditor.selection;
+      const matchBeginSpace = /^\s*/;
+      const nodeEntries = _slate.Editor.nodes(newEditor, {
+        mode: 'lowest',
+        match: node => node.type === _elementTypes.CODE_LINE
+      });
+      const nodeEntryList = Array.from(nodeEntries);
+      let removedSpaceCount = 0;
+      for (const nodeEntry of nodeEntryList) {
+        const [node, path] = nodeEntry;
+        const spaceNum = _slate.Node.string(node).match(matchBeginSpace);
+        // skip empty line and no space begining line
+        if (!spaceNum || !spaceNum[0].length) continue;
+        const deleteNum = Math.min(spaceNum[0].length, 4);
+        removedSpaceCount += deleteNum;
+        for (let i = 0; i < deleteNum; i++) {
+          _slate.Transforms.select(newEditor, {
+            path: [...path, 0],
+            offset: 0
+          });
+          _slate.Editor.deleteForward(newEditor, {
+            unit: 'character'
+          });
+        }
+      }
+      // Select multiple rows when operating more then one line
+      // Keep cursor location when operating one line
+      if (nodeEntryList.length > 1) {
+        const firstCodeLinePath = nodeEntryList.at(0)[1].concat(0);
+        const lastCodeLinePath = nodeEntryList.at(-1)[1].concat(0);
+        const selectLocation = _slate.Editor.range(newEditor, firstCodeLinePath, lastCodeLinePath);
+        _slate.Transforms.select(newEditor, selectLocation);
+      } else {
+        const {
+          anchor,
+          focus
+        } = originSelection;
+        const isCollapsed = _slate.Range.isCollapsed(originSelection);
+        if (isCollapsed) {
+          const selectLocation = {
+            ...originSelection.focus,
+            offset: originSelection.focus.offset - removedSpaceCount
+          };
+          _slate.Transforms.select(newEditor, selectLocation);
+        } else {
+          const selectLocation = {
+            anchor: {
+              ...anchor,
+              offset: anchor.offset - removedSpaceCount
+            },
+            focus: {
+              ...focus,
+              offset: focus.offset - removedSpaceCount
+            }
+          };
+          _slate.Transforms.select(newEditor, selectLocation);
+        }
+      }
+      return true;
+    }
+    if ((0, _isHotkey.default)('mod+a', event)) {
+      event.preventDefault();
+      const codeBlockEntry = _slate.Editor.nodes(newEditor, {
+        mode: 'highest',
+        match: node => node.type === _elementTypes.CODE_BLOCK
+      });
+      if (!codeBlockEntry) return;
+      const codeBlockEntryList = Array.from(...codeBlockEntry);
+      _slate.Transforms.select(newEditor, codeBlockEntryList[1]);
+      return true;
+    }
+  };
+  return newEditor;
+};
+var _default = exports.default = withCodeBlock;

package/dist/extension/plugins/code-block/render-elem/constant.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LANGUAGE_MAP = exports.EXPLAIN_TEXT = void 0;
+// Default language key name
+const EXPLAIN_TEXT = exports.EXPLAIN_TEXT = 'text';
+const LANGUAGE_MAP = exports.LANGUAGE_MAP = {
+  [EXPLAIN_TEXT]: 'Text',
+  html: 'HTML',
+  css: 'CSS',
+  javascript: 'Javascript',
+  c: 'C',
+  cpp: 'C++',
+  csharp: 'C#',
+  java: 'Java',
+  python: 'Python',
+  sql: 'SQL',
+  swift: 'Swift',
+  json: 'JSON'
+};

package/dist/extension/plugins/code-block/render-elem/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.renderCodeLine = exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _slateReact = require("slate-react");
+var _languageSelector = _interopRequireDefault(require("./language-selector"));
+var _helpers = require("../helpers");
+var _constant = require("./constant");
+var _core = require("../../../core");
+var _constants = require("../../../constants");
+var _jsxRuntime = require("react/jsx-runtime");
+/* eslint-disable react-hooks/rules-of-hooks */
+
+const renderCodeBlock = (_ref, editor) => {
+  let {
+    attributes,
+    children,
+    element
+  } = _ref;
+  const [isShowLanguageSelector, setIsShowLanguageSelector] = (0, _react.useState)(true);
+  const codeBlockRef = (0, _react.useRef)(null);
+  const isReadonly = (0, _slateReact.useReadOnly)();
+  (0, _react.useEffect)(() => {
+    if (!editor.selection) return;
+    if (!(0, _helpers.isInCodeBlock)(editor)) onHideLanguageSelector();
+    if ((0, _helpers.isInCodeBlock)(editor)) registerEventHandler();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [editor, editor.selection]);
+  const onHideLanguageSelector = (0, _react.useCallback)(e => {
+    var _codeBlockRef$current;
+    if (codeBlockRef !== null && codeBlockRef !== void 0 && (_codeBlockRef$current = codeBlockRef.current) !== null && _codeBlockRef$current !== void 0 && _codeBlockRef$current.contains(e === null || e === void 0 ? void 0 : e.target) || (0, _helpers.isInCodeBlock)(editor)) return;
+    setIsShowLanguageSelector(false);
+    unregisterEventHandler();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [setIsShowLanguageSelector]);
+  const registerEventHandler = (0, _react.useCallback)(() => {
+    setIsShowLanguageSelector(true);
+    document.addEventListener('click', onHideLanguageSelector, true);
+  }, [onHideLanguageSelector]);
+  const unregisterEventHandler = (0, _react.useCallback)(() => {
+    document.removeEventListener('click', onHideLanguageSelector);
+  }, [onHideLanguageSelector]);
+  const handleLangSelectorChange = function () {
+    let lang = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _constant.EXPLAIN_TEXT;
+    const path = (0, _core.findPath)(editor, element);
+    (0, _helpers.setCodeBlockLanguage)(editor, lang, path);
+  };
+  return /*#__PURE__*/(0, _jsxRuntime.jsxs)("div", {
+    ref: codeBlockRef,
+    className: element.className,
+    style: {
+      ...(_constants.ELEMENT_DEFAULT_STYLE[element.type] || {}),
+      ...((element === null || element === void 0 ? void 0 : element.style) || {})
+    },
+    children: [/*#__PURE__*/(0, _jsxRuntime.jsx)("pre", {
+      ...attributes,
+      children: /*#__PURE__*/(0, _jsxRuntime.jsx)("code", {
+        children: children
+      })
+    }), isShowLanguageSelector && !isReadonly && /*#__PURE__*/(0, _jsxRuntime.jsx)(_languageSelector.default, {
+      lang: element.lang,
+      handleLangSelectorChange: handleLangSelectorChange
+    })]
+  });
+};
+var _default = exports.default = renderCodeBlock;
+const renderCodeLine = (props, editor) => {
+  const {
+    element,
+    attributes,
+    children
+  } = props;
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+    "data-id": element.id,
+    ...attributes,
+    className: element.className,
+    style: {
+      ...(_constants.ELEMENT_DEFAULT_STYLE[element.type] || {}),
+      ...((element === null || element === void 0 ? void 0 : element.style) || {})
+    },
+    children: children
+  });
+};
+exports.renderCodeLine = renderCodeLine;

package/dist/extension/plugins/code-block/render-elem/language-selector/index.css

@@ -0,0 +1,18 @@
+.sea-email-code-block-lang-selector {
+  position: absolute;
+  top: 0;
+  right: 0;
+  display: flex;
+  padding: 2px 5px;
+  width: max-content;
+  border: none;
+  border-radius: 3px;
+  appearance: none;
+  align-items: center;
+  line-height: 1;
+  font-size: 12px;
+  background: #eeeeee;
+  cursor: pointer;
+  transition: all 0.3s;
+  outline: none;
+}

package/dist/extension/plugins/code-block/render-elem/language-selector/index.js

@@ -0,0 +1,38 @@
+"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 _constant = require("../constant");
+require("./index.css");
+var _jsxRuntime = require("react/jsx-runtime");
+const LanguageSelector = _ref => {
+  let {
+    handleLangSelectorChange,
+    lang = _constant.EXPLAIN_TEXT
+  } = _ref;
+  const langOptions = (0, _react.useMemo)(() => {
+    const options = [];
+    for (const value in _constant.LANGUAGE_MAP) {
+      if (Object.hasOwnProperty.call(_constant.LANGUAGE_MAP, value)) {
+        const name = _constant.LANGUAGE_MAP[value];
+        options.push(/*#__PURE__*/(0, _jsxRuntime.jsx)("option", {
+          value: value,
+          children: name
+        }, value));
+      }
+    }
+    return options;
+  }, []);
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)("select", {
+    name: "language",
+    className: "sea-email-code-block-lang-selector",
+    value: lang || '',
+    onChange: e => handleLangSelectorChange(e.target.value),
+    children: langOptions
+  });
+};
+var _default = exports.default = LanguageSelector;

package/dist/extension/plugins/formula/formula.css

@@ -0,0 +1,22 @@
+/* formula */
+.sea-email-selected-formula {
+  display: block;
+  user-select: none;
+  outline: 2px solid #007bff;
+  cursor: pointer;
+}
+
+.sea-email-selected-formula .MathJax {
+  margin: 0;
+}
+
+.formula-dialog-wrapper .form-check-label {
+  margin-bottom: 4px;
+}
+
+.formula-dialog-wrapper .formula-preview {
+  padding: 10px;
+  border: 2px dashed #ebebeb;
+  min-height: 40px;
+  overflow-x: auto;
+}

package/dist/extension/plugins/formula/helper.js

@@ -0,0 +1,80 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.updateFormula = exports.isMenuDisabled = exports.isFormulaType = exports.isFormulaActive = exports.insertFormula = void 0;
+var _slate = require("slate");
+var _slugid = _interopRequireDefault(require("slugid"));
+var _queries = require("../../core/queries");
+var _focusEditor = require("../../core/transforms/focus-editor");
+var _constants = require("../../constants");
+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;
+  const {
+    selection
+  } = editor;
+  if (!selection) return false;
+  const selectedElems = (0, _queries.getSelectedElems)(editor);
+  // Check if the selected element is illegal
+  const isSelectedIllegalElement = selectedElems.some(elem => {
+    const {
+      type
+    } = elem;
+    if (editor.isVoid(elem)) return true;
+    const unSupportTypes = [_constants.ElementTypes.CODE_BLOCK, _constants.ElementTypes.CODE_LINE, _constants.ElementTypes.TABLE, _constants.ElementTypes.TABLE_CELL, _constants.ElementTypes.TABLE_ROW, _constants.ElementTypes.HEADER1, _constants.ElementTypes.HEADER2, _constants.ElementTypes.HEADER3, _constants.ElementTypes.HEADER4, _constants.ElementTypes.HEADER5, _constants.ElementTypes.HEADER6, _constants.ElementTypes.LIST_ITEM, _constants.ElementTypes.UNORDERED_LIST, _constants.ElementTypes.ORDERED_LIST];
+    if (unSupportTypes.includes(type)) return true;
+    return false;
+  });
+  if (isSelectedIllegalElement) return true;
+  return false;
+};
+exports.isMenuDisabled = isMenuDisabled;
+const isFormulaActive = editor => {
+  return isFormulaType(editor);
+};
+exports.isFormulaActive = isFormulaActive;
+const isFormulaType = editor => {
+  const [match] = _slate.Editor.nodes(editor, {
+    match: n => (0, _queries.getNodeType)(n) === _constants.ElementTypes.FORMULA,
+    universal: true
+  });
+  return !!match;
+};
+exports.isFormulaType = isFormulaType;
+const insertFormula = (editor, data) => {
+  const formula = {
+    id: _slugid.default.nice(),
+    type: _elementTypes.FORMULA,
+    data: {
+      formula: data.formula
+    },
+    children: [(0, _core.generateDefaultText)()]
+  };
+  _slate.Transforms.insertNodes(editor, formula, {
+    at: data.at,
+    void: true
+  });
+  (0, _focusEditor.focusEditor)(editor);
+};
+exports.insertFormula = insertFormula;
+const updateFormula = (editor, data) => {
+  const {
+    formula,
+    at
+  } = data;
+  _slate.Transforms.setNodes(editor, {
+    data: {
+      formula
+    }
+  }, {
+    at: at,
+    void: true
+  });
+  (0, _focusEditor.focusEditor)(editor);
+};
+exports.updateFormula = updateFormula;

package/dist/extension/plugins/formula/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 FormulaPlugin = {
+  type: _elementTypes.FORMULA,
+  nodeType: 'element',
+  editorMenus: [_menu.default],
+  editorPlugin: _plugin.default,
+  renderElements: [_renderElem.default]
+};
+var _default = exports.default = FormulaPlugin;