@seafile/comment-editor 0.0.1-alpha.0

package/dist/basic-sdk/extension/plugins/sdoc-link/helpers.js

@@ -0,0 +1,291 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.unwrapLinkNode = exports.removeTempInput = exports.removeShortCutSymbol = exports.onCopySdocLinkNode = exports.isTriggeredByShortcut = exports.isMenuDisabled = exports.insertTextWhenRemoveFileNameCollector = exports.insertTempInput = exports.insertSdocFileLink = exports.getUrl = exports.getType = exports.getSdocLinkEntry = exports.getSdocFileIcon = exports.getNewFileListData = exports.getFileSearchInputEntry = exports.getBeforeText = exports.generateSdocFileNode = void 0;
+var _slate = require("@seafile/slate");
+var _slateReact = require("@seafile/slate-react");
+var _copyToClipboard = _interopRequireDefault(require("copy-to-clipboard"));
+var _slugid = _interopRequireDefault(require("slugid"));
+var _context = _interopRequireDefault(require("../../../context"));
+var _constants = require("../../constants");
+var _core = require("../../core");
+var _helpers = require("../header/helpers");
+const isMenuDisabled = (editor, readonly) => {
+  if (readonly) return true;
+  if (editor.selection == null) return true;
+  const selectedElems = (0, _core.getSelectedElems)(editor);
+  const notMatch = selectedElems.some(elem => {
+    const {
+      type
+    } = elem;
+    if (editor.isVoid(elem)) return true;
+    if ([_constants.CODE_BLOCK, _constants.CODE_LINE, _constants.LINK, _constants.TITLE, _constants.SUBTITLE, ..._constants.HEADERS].includes(type)) return true;
+    return false;
+  });
+  if (notMatch) return true; // disabled
+  return false; // enable
+};
+exports.isMenuDisabled = isMenuDisabled;
+const generateSdocFileNode = function (uuid) {
+  let text = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  const sdocFileName = text.replace(/\.sdoc$/, '');
+  const sdocFileNode = {
+    id: _slugid.default.nice(),
+    type: _constants.SDOC_LINK,
+    doc_uuid: uuid,
+    title: sdocFileName,
+    display_type: _constants.INSERT_FILE_DISPLAY_TYPE[1],
+    children: [{
+      id: _slugid.default.nice(),
+      text: sdocFileName
+    }]
+  };
+  return sdocFileNode;
+};
+exports.generateSdocFileNode = generateSdocFileNode;
+const getType = editor => {
+  const [match] = _slate.Editor.nodes(editor, {
+    match: n => (0, _core.getNodeType)(n) === _constants.LINK,
+    universal: true
+  });
+  if (!match) return _constants.PARAGRAPH;
+  const [n] = match;
+  return (0, _core.getNodeType)(n);
+};
+exports.getType = getType;
+const insertSdocFileLink = (editor, text, uuid) => {
+  if (isMenuDisabled(editor)) return;
+  // Selection folded or not
+  const {
+    selection
+  } = editor;
+  if (selection == null) return;
+  const isCollapsed = _slate.Range.isCollapsed(selection);
+
+  // Remove shortcut symbol,if trigger by shortcut
+  removeShortCutSymbol(editor);
+  const sdocFileNode = generateSdocFileNode(uuid, text);
+  if (isCollapsed) {
+    const {
+      anchor,
+      focus
+    } = editor.selection;
+    const [targetNode] = _slate.Editor.node(editor, editor.selection, {
+      depth: 2
+    }) || [];
+
+    // When the current cursor position is on a link, change the position to after the link
+    if (targetNode && targetNode.type === _constants.SDOC_LINK && anchor.path.length === 3) {
+      editor.selection = {
+        anchor: {
+          offset: anchor.offset,
+          path: [anchor.path[0], anchor.path[1] + 1]
+        },
+        focus: {
+          offset: focus.offset,
+          path: [focus.path[0], focus.path[1] + 1]
+        }
+      };
+    }
+    _slate.Transforms.insertNodes(editor, sdocFileNode);
+  } else {
+    const selectedText = _slate.Editor.string(editor, selection); // Selected text
+    if (selectedText !== text) {
+      // If the selected text is different from the typed text, delete the text and insert the link
+      editor.deleteFragment();
+      _slate.Transforms.insertNodes(editor, sdocFileNode);
+    } else {
+      // If the selected text is the same as the entered text, only the link can be wrapped
+      _slate.Transforms.wrapNodes(editor, sdocFileNode, {
+        split: true
+      });
+      _slate.Transforms.collapse(editor, {
+        edge: 'end'
+      });
+    }
+  }
+};
+exports.insertSdocFileLink = insertSdocFileLink;
+const unwrapLinkNode = (editor, element) => {
+  if (editor.selection == null) return;
+  const path = _slateReact.ReactEditor.findPath(editor, element);
+  if (path) {
+    _slate.Transforms.unwrapNodes(editor, {
+      at: path
+    });
+  }
+};
+exports.unwrapLinkNode = unwrapLinkNode;
+const getNewFileListData = (fileListData, indexId, children) => {
+  fileListData.forEach(item => {
+    if (item.indexId === indexId) {
+      item.children = children;
+    }
+    if (item !== null && item !== void 0 && item.children) {
+      getNewFileListData(item.children, indexId, children);
+    }
+  });
+  return fileListData;
+};
+exports.getNewFileListData = getNewFileListData;
+const getUrl = uuid => {
+  return _context.default.getSdocLocalFileUrl(uuid);
+};
+exports.getUrl = getUrl;
+const onCopySdocLinkNode = (editor, element) => {
+  if (editor.selection == null || _slate.Range.isExpanded(editor.selection)) return;
+  const p = _slateReact.ReactEditor.findPath(editor, element);
+  _slate.Transforms.select(editor, p);
+  const newData = editor.setFragmentData(new DataTransfer());
+  (0, _copyToClipboard.default)('copy', {
+    onCopy: clipboardData => {
+      newData.types.forEach(type => {
+        const data = newData.getData(type);
+        clipboardData.setData(type, data);
+      });
+    }
+  });
+};
+exports.onCopySdocLinkNode = onCopySdocLinkNode;
+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 [[, beforeNodePath]] = _slate.Editor.nodes(editor, {
+    match: node => _slate.Text.isText(node),
+    mode: 'lowest'
+  });
+  const beforeNodeStartPoint = _slate.Editor.start(editor, beforeNodePath); // The starting position of the text node
+  const range = {
+    anchor,
+    focus: beforeNodeStartPoint
+  };
+  const beforeText = _slate.Editor.string(editor, range) || '';
+  return {
+    beforeText,
+    range
+  };
+};
+exports.getBeforeText = getBeforeText;
+const isTriggeredByShortcut = editor => {
+  if ((0, _helpers.isSelectionInHeader)(editor)) {
+    return false;
+  }
+  const {
+    beforeText
+  } = getBeforeText(editor);
+  const fileSearchInput = getFileSearchInputEntry(editor);
+  if (fileSearchInput) return false;
+  return beforeText.endsWith('[');
+};
+
+// If insert operation is triggered by shortcut, remove the '[[' symbol
+exports.isTriggeredByShortcut = isTriggeredByShortcut;
+const removeShortCutSymbol = editor => {
+  // Check is trigger by short cut
+  const {
+    selection
+  } = editor;
+  const {
+    beforeText,
+    range: beforeRange
+  } = getBeforeText(editor);
+  const isTriggeredByShortCut = beforeText.slice(-2) === '[[';
+  isTriggeredByShortCut && _slate.Transforms.delete(editor, {
+    at: {
+      anchor: {
+        path: beforeRange.focus.path,
+        offset: beforeText.length - 2
+      },
+      focus: {
+        ...selection.focus
+      }
+    },
+    voids: true
+  });
+  (0, _core.focusEditor)(editor);
+};
+
+// Generate temp input for collecting file name
+exports.removeShortCutSymbol = removeShortCutSymbol;
+const generateFileLinkInput = () => {
+  const input = (0, _core.generateEmptyElement)(_constants.FILE_LINK_INSET_INPUT_TEMP);
+  return input;
+};
+
+// Insert temp input collecting file name
+const insertTempInput = editor => {
+  const {
+    selection
+  } = editor;
+  if (!_slate.Range.isCollapsed(selection)) return;
+  const tempInput = generateFileLinkInput();
+  const insertPoint = _slate.Editor.start(editor, selection);
+  _slate.Transforms.insertNodes(editor, tempInput, {
+    at: insertPoint
+  });
+  const path = _slate.Editor.path(editor, insertPoint);
+  const insertPath = _slate.Path.next(path);
+  const focusPoint = insertPath.concat(0);
+  (0, _core.focusEditor)(editor, focusPoint);
+};
+
+// Remove temp input collecting file name
+exports.insertTempInput = insertTempInput;
+const removeTempInput = (editor, element) => {
+  const path = _slateReact.ReactEditor.findPath(editor, element);
+  _slate.Transforms.delete(editor, {
+    at: path
+  });
+};
+exports.removeTempInput = removeTempInput;
+const getFileSearchInputEntry = editor => {
+  const [searchInputNodeEntry] = _slate.Editor.nodes(editor, {
+    match: n => n.type === _constants.FILE_LINK_INSET_INPUT_TEMP
+  });
+  return searchInputNodeEntry;
+};
+
+// Insert text when remove file name collector, such as inserting 'filename' into prevNode when close collector entered '[[filename'
+exports.getFileSearchInputEntry = getFileSearchInputEntry;
+const insertTextWhenRemoveFileNameCollector = (editor, searchInputNode) => {
+  const inputNodePath = _slateReact.ReactEditor.findPath(editor, searchInputNode);
+  if (!inputNodePath) return;
+  const prevNodeEntry = _slate.Editor.previous(editor, {
+    at: inputNodePath
+  });
+  if (!prevNodeEntry) return;
+  const searchContent = _slate.Node.string(searchInputNode);
+  const insertPoint = _slate.Editor.end(editor, prevNodeEntry[1]);
+  _slate.Transforms.insertText(editor, searchContent, {
+    at: insertPoint
+  });
+  removeTempInput(editor, searchInputNode);
+};
+exports.insertTextWhenRemoveFileNameCollector = insertTextWhenRemoveFileNameCollector;
+const getSdocFileIcon = () => {
+  const server = _context.default.getSetting('serviceUrl');
+  return `${server}/media/img/file/256/sdoc.png`;
+};
+exports.getSdocFileIcon = getSdocFileIcon;
+const getSdocLinkEntry = function (editor) {
+  let at = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : editor.selection;
+  const aboveNodeEntry = _slate.Editor.above(editor, {
+    match: n => n.type === _constants.SDOC_LINK,
+    mode: 'highest',
+    at
+  });
+  return aboveNodeEntry;
+};
+exports.getSdocLinkEntry = getSdocLinkEntry;

package/dist/basic-sdk/extension/plugins/sdoc-link/hover-menu/index.css

@@ -0,0 +1,89 @@
+.sdoc-link-hover-menu-container {
+  position: absolute;
+  height: 42px;
+  z-index: 101;
+  width: auto;
+}
+  
+.sdoc-link-hover-menu-container .hover-menu-container {
+  height: 36px;
+  padding: 7px 8px;
+  background-color: #fff;
+  display: flex;
+  justify-content: flex-start;
+  align-items: center;
+  border-radius: 3px;
+  box-shadow: 0 1px 0 rgba(0, 0, 0, 0.08);
+  border: 1px solid #e8e8e8;
+}
+
+.sdoc-link-hover-menu-container .hover-menu-container > span:not(:last-of-type) {
+  padding-right: 8px;
+  border-right: 1px solid #e5e5e5;
+}
+
+.sdoc-link-hover-menu-container .hover-menu-container .op-item {
+  position: relative;
+  font-size: 12px;
+  color: #212529;
+  padding: 0 5px;
+  border-radius: 2px;
+  min-width: 24px;
+  height: 24px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.sdoc-link-hover-menu-container .hover-menu-container .op-item:hover {
+  color: #212529;
+  text-decoration: none;
+  background: #f1f1f1;
+}
+
+.sdoc-link-hover-menu-container .op-group-item:last-child .op-item {
+  margin-left: 8px;
+}
+
+.sdoc-link-hover-menu-container .hover-menu-container .link-style-icon-active {
+  background: #f1f1f1;
+}
+
+.sdoc-link-hover-menu-container .hover-menu-container .op-tooltip:hover::after {
+  position: absolute;
+  color: #212529;
+  content: attr(op-item-tooltip);
+  top: -40px;
+  left: -20px;
+  width: 70px;
+  height: 30px;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  background-color: #fff;
+  border-radius: 3px;
+  border: 1px solid #e8e8e8;
+  font-size: 12px;
+  box-shadow: 0 0 5px #ccc;
+}
+
+.sdoc-link-hover-menu-container .hover-menu-container .icon-font {
+  font-size: 12px;
+  color: #444;
+}
+
+.sdoc-link-hover-menu-container .sdoc-file-display-style-popover {
+  position: absolute;
+  top: 37px;
+  right: -80px;
+  padding: 8px 0;
+  background-color: #fff;
+  border: 1px solid #e5e6e8;
+  border-radius: 2px;
+  box-shadow: 0 0 10px #ccc;
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  z-index: 101;
+  white-space: nowrap;
+}

package/dist/basic-sdk/extension/plugins/sdoc-link/hover-menu/index.js

@@ -0,0 +1,119 @@
+"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 _reactI18next = require("react-i18next");
+var _slate = require("@seafile/slate");
+var _slateReact = require("@seafile/slate-react");
+var _classnames = _interopRequireDefault(require("classnames"));
+var _toast = _interopRequireDefault(require("../../../../components/toast"));
+var _commons = require("../../../commons");
+var _constants = require("../../../constants");
+var _core = require("../../../core");
+var _constants2 = require("../constants");
+var _helpers = require("../helpers");
+require("./index.css");
+const SdocLinkHoverMenu = _ref => {
+  let {
+    editor,
+    menuPosition,
+    element,
+    onUnwrapFileLinkNode,
+    onHideInsertHoverMenu,
+    t,
+    url
+  } = _ref;
+  const readOnly = (0, _slateReact.useReadOnly)();
+  const [isShowDisplayStylePopover, setIsShowDisplayStylePopover] = (0, _react.useState)(false);
+  const onCopy = (0, _react.useCallback)(e => {
+    e.stopPropagation();
+    (0, _helpers.onCopySdocLinkNode)(editor, element);
+    _toast.default.success(t('Copied'), {
+      hasCloseButton: false,
+      duration: 2
+    });
+    onHideInsertHoverMenu();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  const onShowProver = (0, _react.useCallback)(e => {
+    setIsShowDisplayStylePopover(true);
+  }, []);
+  const onSelect = (0, _react.useCallback)((event, value) => {
+    event.stopPropagation();
+    const path = _slateReact.ReactEditor.findPath(editor, element);
+    if (path) {
+      _slate.Transforms.setNodes(editor, {
+        display_type: value
+      }, {
+        at: path
+      });
+    }
+    onHideInsertHoverMenu();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  const selectedType = element.display_type || _constants2.SDOC_LINK_TYPE.TEXT_LINK;
+  const id = `sdoc-link-display-type-${element.id}`;
+  const newSdocFileTypes = _constants2.SDOC_LINK_TYPES.filter(sdocLinkType => (0, _core.getCurrentNode)(editor)[0].type === _constants.TABLE_CELL ? sdocLinkType !== _constants2.SDOC_LINK_TYPE.CARD_LINK : true);
+  return /*#__PURE__*/_react.default.createElement(_commons.ElementPopover, null, /*#__PURE__*/_react.default.createElement("div", {
+    className: "sdoc-link-hover-menu-container",
+    style: menuPosition
+  }, /*#__PURE__*/_react.default.createElement("div", {
+    className: "hover-menu-container"
+  }, /*#__PURE__*/_react.default.createElement("span", {
+    className: "op-group-item"
+  }, /*#__PURE__*/_react.default.createElement("span", {
+    role: "button",
+    className: (0, _classnames.default)('op-item', {
+      'ml-0': readOnly
+    })
+  }, /*#__PURE__*/_react.default.createElement("a", {
+    href: url,
+    target: "_blank",
+    rel: "noopener noreferrer",
+    className: "link-op-menu-link"
+  }, t('Open_link')))), !readOnly && /*#__PURE__*/_react.default.createElement("span", {
+    className: "op-group-item"
+  }, /*#__PURE__*/_react.default.createElement("span", {
+    role: "button",
+    className: "op-item",
+    onClick: onCopy
+  }, /*#__PURE__*/_react.default.createElement("i", {
+    className: "sdocfont sdoc-copy icon-font"
+  })), /*#__PURE__*/_react.default.createElement("span", {
+    role: "button",
+    className: `op-item ${isShowDisplayStylePopover ? 'link-style-icon-active' : ''}`,
+    onClick: onShowProver,
+    id: id
+  }, /*#__PURE__*/_react.default.createElement("i", {
+    className: (0, _classnames.default)('icon-font mr-1', _constants2.SDOC_LINK_TYPE_CONFIG[selectedType].icon)
+  }), /*#__PURE__*/_react.default.createElement("i", {
+    className: "sdocfont sdoc-drop-down icon-font"
+  })), /*#__PURE__*/_react.default.createElement("span", {
+    role: "button",
+    className: 'op-item',
+    onClick: onUnwrapFileLinkNode
+  }, /*#__PURE__*/_react.default.createElement("i", {
+    className: "sdocfont sdoc-unlink icon-font"
+  })))), isShowDisplayStylePopover && /*#__PURE__*/_react.default.createElement("div", {
+    className: "sdoc-file-display-style-popover sdoc-dropdown-menu"
+  }, newSdocFileTypes.map(sdocLinkType => {
+    return /*#__PURE__*/_react.default.createElement("div", {
+      key: sdocLinkType,
+      "date-type": sdocLinkType,
+      className: "sdoc-dropdown-menu-item sdoc-dropdown-item-with-left-icon pr-2",
+      onClick: event => onSelect(event, sdocLinkType)
+    }, /*#__PURE__*/_react.default.createElement("div", {
+      className: "sdoc-dropdown-item-content"
+    }, /*#__PURE__*/_react.default.createElement("i", {
+      className: (0, _classnames.default)('sdoc-dropdown-item-content-icon', _constants2.SDOC_LINK_TYPE_CONFIG[sdocLinkType].icon)
+    }), /*#__PURE__*/_react.default.createElement("span", null, t(_constants2.SDOC_LINK_TYPE_CONFIG[sdocLinkType].text))), selectedType === sdocLinkType && /*#__PURE__*/_react.default.createElement("i", {
+      className: "sdocfont sdoc-check-mark sdoc-dropdown-item-right-icon"
+    }));
+  }))));
+};
+var _default = exports.default = (0, _reactI18next.withTranslation)('sdoc-editor')(SdocLinkHoverMenu);

package/dist/basic-sdk/extension/plugins/sdoc-link/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 _constants = require("../../constants");
+var _menu = _interopRequireDefault(require("./menu"));
+var _plugin = _interopRequireDefault(require("./plugin"));
+var _renderElem = _interopRequireDefault(require("./render/render-elem"));
+var _renderFileLinkTempInput = _interopRequireDefault(require("./render/render-file-link-temp-input"));
+const SdocLinkPlugin = {
+  type: _constants.SDOC_LINK,
+  editorMenus: [_menu.default],
+  editorPlugin: _plugin.default,
+  renderElements: [_renderElem.default, _renderFileLinkTempInput.default]
+};
+var _default = exports.default = SdocLinkPlugin;

package/dist/basic-sdk/extension/plugins/sdoc-link/menu/index.js

@@ -0,0 +1,38 @@
+"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 _constants = require("../../../../constants");
+var _dropdownMenuItem = _interopRequireDefault(require("../../../commons/dropdown-menu-item"));
+var _constants2 = require("../../../constants");
+var _helpers = require("../helpers");
+const SdocLinkMenu = _ref => {
+  let {
+    editor,
+    readonly,
+    toggle,
+    eventBus
+  } = _ref;
+  const disabled = (0, _helpers.isMenuDisabled)(editor, readonly);
+  const menuConfig = _constants2.MENUS_CONFIG_MAP[_constants2.SDOC_LINK];
+  const openSelectSdocFileDialog = (0, _react.useCallback)(() => {
+    eventBus.dispatch(_constants.INTERNAL_EVENT.INSERT_ELEMENT, {
+      type: _constants2.ELEMENT_TYPE.SDOC_LINK,
+      insertSdocFileLinkCallback: _helpers.insertSdocFileLink
+    });
+    toggle && toggle();
+
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [toggle, eventBus]);
+  return /*#__PURE__*/_react.default.createElement(_dropdownMenuItem.default, {
+    disabled: disabled,
+    menuConfig: menuConfig,
+    onClick: openSelectSdocFileDialog
+  });
+};
+var _default = exports.default = SdocLinkMenu;

package/dist/basic-sdk/extension/plugins/sdoc-link/plugin.js

@@ -0,0 +1,102 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("@seafile/slate");
+var _slateReact = require("@seafile/slate-react");
+var _constants = require("../../constants");
+var _elementType = require("../../constants/element-type");
+var _core = require("../../core");
+var _helpers = require("./helpers");
+const withSdocLink = editor => {
+  const {
+    isInline,
+    deleteBackward,
+    insertText,
+    onCompositionStart,
+    onHotKeyDown
+  } = editor;
+  const newEditor = editor;
+
+  // Rewrite isInline
+  newEditor.isInline = elem => {
+    const {
+      type
+    } = elem;
+    const isInlineElem = [_elementType.WIKI_LINK, _constants.SDOC_LINK, _constants.FILE_LINK_INSET_INPUT_TEMP].includes(type);
+    if (isInlineElem) return true;
+    return isInline(elem);
+  };
+  newEditor.deleteBackward = unit => {
+    const {
+      selection
+    } = newEditor;
+    if (selection === null) {
+      return deleteBackward(unit);
+    }
+
+    // Delete file link node when the input is empty
+    const selectedElems = (0, _core.getSelectedElems)(newEditor);
+    const fileLinkSearchInputNode = selectedElems.find(elem => elem.type === _constants.FILE_LINK_INSET_INPUT_TEMP);
+    if (fileLinkSearchInputNode) {
+      const path = _slateReact.ReactEditor.findPath(editor, fileLinkSearchInputNode);
+      if (_slate.Node.string(fileLinkSearchInputNode).length === 0) return _slate.Transforms.delete(newEditor, {
+        at: path
+      });
+    }
+    const nodeEntry = _slate.Editor.node(newEditor, newEditor.selection);
+    if (nodeEntry && _slate.Node.string(nodeEntry[0]).length === 0) {
+      const beforePath = nodeEntry[1];
+      beforePath.splice(-1, 1, Math.max(nodeEntry[1].at(-1) - 1, 0));
+      const beforeNodeEntry = _slate.Editor.node(newEditor, beforePath);
+      if (beforeNodeEntry && [_elementType.WIKI_LINK, _constants.SDOC_LINK, _constants.FILE_LINK_INSET_INPUT_TEMP].includes(beforeNodeEntry[0].type)) {
+        _slate.Transforms.delete(newEditor, {
+          at: beforeNodeEntry[1]
+        });
+        return;
+      }
+      return deleteBackward(unit);
+    }
+    return deleteBackward(unit);
+  };
+  newEditor.insertText = text => {
+    if (text !== '[') return insertText(text);
+    // If user press '[[', open file modal
+    if ((0, _helpers.isTriggeredByShortcut)(newEditor)) {
+      insertText(text);
+      (0, _helpers.insertTempInput)(newEditor);
+      return;
+    }
+    return insertText(text);
+  };
+  newEditor.onCompositionStart = event => {
+    const fileSearchInputNodeEntry = (0, _helpers.getFileSearchInputEntry)(newEditor);
+    if (fileSearchInputNodeEntry) {
+      event.preventDefault();
+      return true;
+    }
+    return onCompositionStart && onCompositionStart(event);
+  };
+  newEditor.onHotKeyDown = e => {
+    const sdocLinkEntry = (0, _helpers.getSdocLinkEntry)(editor);
+    if (sdocLinkEntry) {
+      if (e.key === 'ArrowLeft') {
+        const beforePointSdocLink = _slate.Editor.before(newEditor, sdocLinkEntry[1]);
+        _slate.Transforms.select(newEditor, beforePointSdocLink);
+        e.preventDefault();
+        return;
+      }
+      if (e.key === 'ArrowRight') {
+        const afterPointSdocLink = _slate.Editor.after(newEditor, sdocLinkEntry[1]);
+        _slate.Transforms.select(newEditor, afterPointSdocLink);
+        e.preventDefault();
+        return;
+      }
+    }
+    return onHotKeyDown && onHotKeyDown(e);
+  };
+  return newEditor;
+};
+var _default = exports.default = withSdocLink;