@seafile/sdoc-editor 1.0.54 → 1.0.56

package/dist/basic-sdk/extension/plugins/quick-insert/plugin/index.js

@@ -1,9 +1,15 @@
-import { Editor, Node, Range, Transforms } from '@seafile/slate';
-import { CODE_BLOCK, QUICK_INSERT } from '../../../constants';
-import { getBeforeText } from '../../list/helpers';
-import { genQuickInsert, getQuickInsertEntity, transformToText } from '../helper';
-import { focusEditor, getTopLevelBlockNode } from '../../../core';
-import { KeyCodes } from '../../../../../constants';
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("@seafile/slate");
+var _constants = require("../../../constants");
+var _helpers = require("../../list/helpers");
+var _helper = require("../helper");
+var _core = require("../../../core");
+var _constants2 = require("../../../../../constants");
 const withQuickInsert = editor => {
   const {
     insertText,
@@ -15,50 +21,50 @@ const withQuickInsert = editor => {
   const newEditor = editor;
   newEditor.insertText = text => {
     if (!editor.selection) return insertText(text);
-    const [blockNode] = getTopLevelBlockNode(editor);
-    if (blockNode.type === CODE_BLOCK) return insertText(text);
+    const [blockNode] = (0, _core.getTopLevelBlockNode)(editor);
+    if (blockNode.type === _constants.CODE_BLOCK) return insertText(text);
     if (text === '/') {
       // Avoid triggering quick insert when the cursor is in the quick insert
-      const isInQuickInsert = getQuickInsertEntity(editor);
+      const isInQuickInsert = (0, _helper.getQuickInsertEntity)(editor);
       if (isInQuickInsert) return insertText(text);
       const {
         beforeText
-      } = getBeforeText(editor);
+      } = (0, _helpers.getBeforeText)(editor);
       // If the previous text ends with a number, do not trigger the quick insert
       const isEndWithNumber = beforeText.match(/\d+$/);
       if (isEndWithNumber) return insertText(text);
-      const quickInsert = genQuickInsert();
-      return Transforms.insertNodes(editor, quickInsert);
+      const quickInsert = (0, _helper.genQuickInsert)();
+      return _slate.Transforms.insertNodes(editor, quickInsert);
     }
     return insertText(text);
   };
   newEditor.deleteBackward = unit => {
-    const quickInsertEntry = getQuickInsertEntity(editor);
+    const quickInsertEntry = (0, _helper.getQuickInsertEntity)(editor);
     if (quickInsertEntry) {
       const {
         selection
       } = editor;
-      if (selection && Range.isCollapsed(selection)) {
+      if (selection && _slate.Range.isCollapsed(selection)) {
         const [node, path] = quickInsertEntry;
-        const contentString = Node.string(node);
+        const contentString = _slate.Node.string(node);
         if (!contentString) {
-          return Transforms.delete(editor, {
+          return _slate.Transforms.delete(editor, {
             at: path
           });
         }
 
         // Transform to text when delete shortcut prefix
-        const isAtStart = Editor.isStart(editor, selection.focus, quickInsertEntry[1]);
+        const isAtStart = _slate.Editor.isStart(editor, selection.focus, quickInsertEntry[1]);
         if (isAtStart) {
-          const [, insertPath] = Editor.next(editor, {
+          const [, insertPath] = _slate.Editor.next(editor, {
             at: path
           });
-          const insertPoint = Editor.start(editor, insertPath);
-          const insertText = Node.string(quickInsertEntry[0]);
-          Transforms.insertText(editor, insertText, {
+          const insertPoint = _slate.Editor.start(editor, insertPath);
+          const insertText = _slate.Node.string(quickInsertEntry[0]);
+          _slate.Transforms.insertText(editor, insertText, {
             at: insertPoint
           });
-          Transforms.removeNodes(editor, {
+          _slate.Transforms.removeNodes(editor, {
             at: path
           });
           return;
@@ -68,29 +74,29 @@ const withQuickInsert = editor => {
     return deleteBackward(unit);
   };
   newEditor.deleteForward = unit => {
-    const quickInsertEntry = getQuickInsertEntity(editor);
+    const quickInsertEntry = (0, _helper.getQuickInsertEntity)(editor);
     if (quickInsertEntry) {
       const {
         selection
       } = editor;
-      const isAtEnd = Editor.isEnd(editor, selection.focus, quickInsertEntry[1]);
+      const isAtEnd = _slate.Editor.isEnd(editor, selection.focus, quickInsertEntry[1]);
       if (isAtEnd) {
         deleteForward(unit);
-        focusEditor(editor, Editor.end(newEditor, quickInsertEntry[1]));
+        (0, _core.focusEditor)(editor, _slate.Editor.end(newEditor, quickInsertEntry[1]));
         return;
       }
     }
     return deleteForward(unit);
   };
   newEditor.onHotKeyDown = event => {
-    const quickInsertEntry = getQuickInsertEntity(editor);
+    const quickInsertEntry = (0, _helper.getQuickInsertEntity)(editor);
     if (quickInsertEntry) {
       const [quickInsertNode, quickInsertPath] = quickInsertEntry;
       const {
         Esc,
         RightArrow,
         LeftArrow
-      } = KeyCodes;
+      } = _constants2.KeyCodes;
       const {
         keyCode
       } = event;
@@ -100,18 +106,18 @@ const withQuickInsert = editor => {
         } = editor;
         const focusPoint = selection.focus;
         if (!selection) return;
-        if (!Range.isCollapsed(selection)) return;
+        if (!_slate.Range.isCollapsed(selection)) return;
         if (keyCode === RightArrow) {
-          if (Editor.isEnd(editor, focusPoint, quickInsertPath)) {
-            const insertPoint = transformToText(newEditor, quickInsertNode);
-            focusEditor(newEditor, insertPoint);
+          if (_slate.Editor.isEnd(editor, focusPoint, quickInsertPath)) {
+            const insertPoint = (0, _helper.transformToText)(newEditor, quickInsertNode);
+            (0, _core.focusEditor)(newEditor, insertPoint);
             return;
           }
         }
         if (keyCode === LeftArrow) {
-          if (Editor.isStart(editor, focusPoint, quickInsertPath)) {
+          if (_slate.Editor.isStart(editor, focusPoint, quickInsertPath)) {
             event.preventDefault();
-            transformToText(newEditor, quickInsertNode);
+            (0, _helper.transformToText)(newEditor, quickInsertNode);
             return;
           }
         }
@@ -120,25 +126,25 @@ const withQuickInsert = editor => {
         // Choose the next point to focus
         // Here need offset + 1 as text not include the prefix '/'
         event.preventDefault();
-        const insertPoint = transformToText(newEditor, quickInsertNode);
-        return focusEditor(newEditor, insertPoint);
+        const insertPoint = (0, _helper.transformToText)(newEditor, quickInsertNode);
+        return (0, _core.focusEditor)(newEditor, insertPoint);
       }
     }
     return onHotKeyDown && onHotKeyDown(event);
   };
   newEditor.onCompositionStart = event => {
-    const quickInsertEntry = getQuickInsertEntity(editor);
+    const quickInsertEntry = (0, _helper.getQuickInsertEntity)(editor);
     if (quickInsertEntry) {
       event.preventDefault();
       return true;
     }
   };
   newEditor.isInline = element => {
-    if ([QUICK_INSERT].includes(element.type)) {
+    if ([_constants.QUICK_INSERT].includes(element.type)) {
       return true;
     }
     return isInline(element);
   };
   return newEditor;
 };
-export default withQuickInsert;
+var _default = exports.default = withQuickInsert;

package/dist/basic-sdk/extension/plugins/quick-insert/render-elem.js

@@ -1,14 +1,22 @@
-import React, { useCallback, useEffect, useRef, useState } from 'react';
-import InlineBugFixer from '../../commons/Inline-bug-fix-wrapper';
-import { ElementPopover } from '../../commons';
-import { getAboveBlockNode } from '../../core';
-import { ReactEditor } from '@seafile/slate-react';
-import { Node, Transforms } from '@seafile/slate';
-import { transformToText } from './helper';
-import { useScrollContext } from '../../../hooks/use-scroll-context';
-import { INSERT_POSITION } from '../../constants';
-import QuickInsertBlockMenu from '../../toolbar/insert-element-toolbar';
-import { isVoidNode } from '../../toolbar/side-toolbar/helpers';
+"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 _InlineBugFixWrapper = _interopRequireDefault(require("../../commons/Inline-bug-fix-wrapper"));
+var _commons = require("../../commons");
+var _core = require("../../core");
+var _slateReact = require("@seafile/slate-react");
+var _slate = require("@seafile/slate");
+var _helper = require("./helper");
+var _useScrollContext = require("../../../hooks/use-scroll-context");
+var _constants = require("../../constants");
+var _insertElementToolbar = _interopRequireDefault(require("../../toolbar/insert-element-toolbar"));
+var _helpers = require("../../toolbar/side-toolbar/helpers");
 const RenderQuickInsert = (_ref, editor) => {
   let {
     attributes,
@@ -16,19 +24,19 @@ const RenderQuickInsert = (_ref, editor) => {
     element,
     readonly
   } = _ref;
-  const [menuStyle, setMenuStyle] = useState({
+  const [menuStyle, setMenuStyle] = (0, _react.useState)({
     top: 0,
     left: 0
   });
-  const sideMenuRef = useRef(null);
-  const scrollRef = useScrollContext();
-  const insertElmRef = useRef(null);
-  const aboveBlockNode = getAboveBlockNode(editor);
-  const searchText = Node.string(element);
-  const isEmptyNode = isVoidNode(aboveBlockNode === null || aboveBlockNode === void 0 ? void 0 : aboveBlockNode[0]);
-  const handleClick = useCallback(e => {
+  const sideMenuRef = (0, _react.useRef)(null);
+  const scrollRef = (0, _useScrollContext.useScrollContext)();
+  const insertElmRef = (0, _react.useRef)(null);
+  const aboveBlockNode = (0, _core.getAboveBlockNode)(editor);
+  const searchText = _slate.Node.string(element);
+  const isEmptyNode = (0, _helpers.isVoidNode)(aboveBlockNode === null || aboveBlockNode === void 0 ? void 0 : aboveBlockNode[0]);
+  const handleClick = (0, _react.useCallback)(e => {
     if (!insertElmRef.current.contains(e.target)) {
-      transformToText(editor, element);
+      (0, _helper.transformToText)(editor, element);
     }
   }, [editor, element]);
   const genStyle = (top, left) => {
@@ -36,10 +44,10 @@ const RenderQuickInsert = (_ref, editor) => {
     if (overflowY > 0) {
       top = top - overflowY - 10;
     }
-    return "top: ".concat(top, "px; left: ").concat(left, "px");
+    return `top: ${top}px; left: ${left}px`;
   };
-  const handleInsertMenuStyle = useCallback(() => {
-    const currentDom = ReactEditor.toDOMNode(editor, element);
+  const handleInsertMenuStyle = (0, _react.useCallback)(() => {
+    const currentDom = _slateReact.ReactEditor.toDOMNode(editor, element);
     const {
       left,
       top
@@ -47,10 +55,10 @@ const RenderQuickInsert = (_ref, editor) => {
     const style = genStyle(top, left - 10);
     setMenuStyle(style);
   }, [editor, element]);
-  const handleScroll = useCallback(e => {
+  const handleScroll = (0, _react.useCallback)(e => {
     handleInsertMenuStyle();
   }, [handleInsertMenuStyle]);
-  useEffect(() => {
+  (0, _react.useEffect)(() => {
     const scrollDom = scrollRef.current;
     handleInsertMenuStyle();
     document.addEventListener('click', handleClick);
@@ -61,26 +69,26 @@ const RenderQuickInsert = (_ref, editor) => {
     };
   }, [editor, element, handleClick, handleInsertMenuStyle, handleScroll, scrollRef]);
   const handleInsertBlock = node => {
-    Transforms.delete(editor, {
-      at: ReactEditor.findPath(editor, element)
+    _slate.Transforms.delete(editor, {
+      at: _slateReact.ReactEditor.findPath(editor, element)
     });
   };
-  return /*#__PURE__*/React.createElement("span", {
+  return /*#__PURE__*/_react.default.createElement("span", {
     ref: insertElmRef
-  }, /*#__PURE__*/React.createElement("span", Object.assign({}, attributes, {
+  }, /*#__PURE__*/_react.default.createElement("span", Object.assign({}, attributes, {
     className: ""
-  }), /*#__PURE__*/React.createElement(InlineBugFixer, null), /*#__PURE__*/React.createElement("span", null, "/", children), /*#__PURE__*/React.createElement(InlineBugFixer, null), /*#__PURE__*/React.createElement(ElementPopover, {
+  }), /*#__PURE__*/_react.default.createElement(_InlineBugFixWrapper.default, null), /*#__PURE__*/_react.default.createElement("span", null, "/", children), /*#__PURE__*/_react.default.createElement(_InlineBugFixWrapper.default, null), /*#__PURE__*/_react.default.createElement(_commons.ElementPopover, {
     className: "sdoc-side-menu-popover",
     style: menuStyle
-  }, /*#__PURE__*/React.createElement("div", {
+  }, /*#__PURE__*/_react.default.createElement("div", {
     ref: sideMenuRef,
     className: "sdoc-side-menu sdoc-dropdown-menu"
-  }, /*#__PURE__*/React.createElement(QuickInsertBlockMenu, {
+  }, /*#__PURE__*/_react.default.createElement(_insertElementToolbar.default, {
     isEmptyNode: isEmptyNode,
-    insertPosition: isEmptyNode ? INSERT_POSITION.CURRENT : INSERT_POSITION.AFTER,
+    insertPosition: isEmptyNode ? _constants.INSERT_POSITION.CURRENT : _constants.INSERT_POSITION.AFTER,
     slateNode: aboveBlockNode === null || aboveBlockNode === void 0 ? void 0 : aboveBlockNode[0],
     searchText: searchText,
     callback: handleInsertBlock
   })))));
 };
-export default RenderQuickInsert;
+var _default = exports.default = RenderQuickInsert;

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

@@ -1,9 +1,15 @@
-export const SDOC_LINK_TYPE = {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SDOC_LINK_TYPE_CONFIG = exports.SDOC_LINK_TYPES = exports.SDOC_LINK_TYPE = void 0;
+const SDOC_LINK_TYPE = exports.SDOC_LINK_TYPE = {
   TEXT_LINK: 'text_link',
   ICON_LINK: 'icon_link',
   CARD_LINK: 'card_link'
 };
-export const SDOC_LINK_TYPE_CONFIG = {
+const SDOC_LINK_TYPE_CONFIG = exports.SDOC_LINK_TYPE_CONFIG = {
   [SDOC_LINK_TYPE.TEXT_LINK]: {
     icon: 'sdocfont sdoc-text-link',
     text: 'Text_Link'
@@ -17,4 +23,4 @@ export const SDOC_LINK_TYPE_CONFIG = {
     text: 'Card'
   }
 };
-export const SDOC_LINK_TYPES = [SDOC_LINK_TYPE.TEXT_LINK, SDOC_LINK_TYPE.ICON_LINK, SDOC_LINK_TYPE.CARD_LINK];
+const SDOC_LINK_TYPES = exports.SDOC_LINK_TYPES = [SDOC_LINK_TYPE.TEXT_LINK, SDOC_LINK_TYPE.ICON_LINK, SDOC_LINK_TYPE.CARD_LINK];

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

@@ -1,111 +1,124 @@
-import { ReactEditor } from '@seafile/slate-react';
-import { Editor, Transforms, Range, Text, Path, Node } from '@seafile/slate';
-import slugid from 'slugid';
-import copy from 'copy-to-clipboard';
-import context from '../../../../context';
-import { focusEditor, generateEmptyElement, getNodeType, getSelectedElems } from '../../core';
-import { SDOC_LINK, LINK, INSERT_FILE_DISPLAY_TYPE, CODE_BLOCK, CODE_LINE, PARAGRAPH, FILE_LINK_INSET_INPUT_TEMP } from '../../constants';
-export const isMenuDisabled = (editor, readonly) => {
+"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.getNewFileListData = exports.getFileSearchInputEntry = exports.getBeforeText = exports.generateSdocFileNode = void 0;
+var _slateReact = require("@seafile/slate-react");
+var _slate = require("@seafile/slate");
+var _slugid = _interopRequireDefault(require("slugid"));
+var _copyToClipboard = _interopRequireDefault(require("copy-to-clipboard"));
+var _context = _interopRequireDefault(require("../../../../context"));
+var _core = require("../../core");
+var _constants = require("../../constants");
+const isMenuDisabled = (editor, readonly) => {
   if (readonly) return true;
   if (editor.selection == null) return true;
-  const selectedElems = getSelectedElems(editor);
+  const selectedElems = (0, _core.getSelectedElems)(editor);
   const notMatch = selectedElems.some(elem => {
     const {
       type
     } = elem;
     if (editor.isVoid(elem)) return true;
-    if ([CODE_BLOCK, CODE_LINE, LINK].includes(type)) return true;
+    if ([_constants.CODE_BLOCK, _constants.CODE_LINE, _constants.LINK].includes(type)) return true;
     return false;
   });
   if (notMatch) return true; // disabled
   return false; // enable
 };
-
-export const generateSdocFileNode = function (uuid) {
+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.nice(),
-    type: SDOC_LINK,
+    id: _slugid.default.nice(),
+    type: _constants.SDOC_LINK,
     doc_uuid: uuid,
     title: sdocFileName,
-    display_type: INSERT_FILE_DISPLAY_TYPE[1],
+    display_type: _constants.INSERT_FILE_DISPLAY_TYPE[1],
     children: [{
-      id: slugid.nice(),
+      id: _slugid.default.nice(),
       text: sdocFileName
     }]
   };
   return sdocFileNode;
 };
-export const getType = editor => {
-  const [match] = Editor.nodes(editor, {
-    match: n => getNodeType(n) === LINK,
+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 PARAGRAPH;
+  if (!match) return _constants.PARAGRAPH;
   const [n] = match;
-  return getNodeType(n);
+  return (0, _core.getNodeType)(n);
 };
-export const insertSdocFileLink = (editor, text, uuid) => {
+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 = Range.isCollapsed(selection);
+  const isCollapsed = _slate.Range.isCollapsed(selection);
 
   // Remove shortcut symbol,if trigger by shortcut
   removeShortCutSymbol(editor);
   const sdocFileNode = generateSdocFileNode(uuid, text);
   if (isCollapsed) {
-    Transforms.insertNodes(editor, sdocFileNode);
+    _slate.Transforms.insertNodes(editor, sdocFileNode);
   } else {
-    const selectedText = Editor.string(editor, selection); // Selected text
+    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();
-      Transforms.insertNodes(editor, sdocFileNode);
+      _slate.Transforms.insertNodes(editor, sdocFileNode);
     } else {
       // If the selected text is the same as the entered text, only the link can be wrapped
-      Transforms.wrapNodes(editor, sdocFileNode, {
+      _slate.Transforms.wrapNodes(editor, sdocFileNode, {
         split: true
       });
-      Transforms.collapse(editor, {
+      _slate.Transforms.collapse(editor, {
         edge: 'end'
       });
     }
   }
 };
-export const unwrapLinkNode = (editor, element) => {
+exports.insertSdocFileLink = insertSdocFileLink;
+const unwrapLinkNode = (editor, element) => {
   if (editor.selection == null) return;
-  const path = ReactEditor.findPath(editor, element);
+  const path = _slateReact.ReactEditor.findPath(editor, element);
   if (path) {
-    Transforms.unwrapNodes(editor, {
+    _slate.Transforms.unwrapNodes(editor, {
       at: path
     });
   }
 };
-export const getNewFileListData = (fileListData, indexId, children) => {
+exports.unwrapLinkNode = unwrapLinkNode;
+const getNewFileListData = (fileListData, indexId, children) => {
   fileListData.forEach(item => {
     if (item.indexId === indexId) {
       item.children = children;
     }
-    if (item === null || item === void 0 ? void 0 : item.children) {
+    if (item !== null && item !== void 0 && item.children) {
       getNewFileListData(item.children, indexId, children);
     }
   });
   return fileListData;
 };
-export const getUrl = uuid => {
-  return context.getSdocLocalFileUrl(uuid);
+exports.getNewFileListData = getNewFileListData;
+const getUrl = uuid => {
+  return _context.default.getSdocLocalFileUrl(uuid);
 };
-export const onCopySdocLinkNode = (editor, element) => {
-  if (editor.selection == null || Range.isExpanded(editor.selection)) return;
-  const p = ReactEditor.findPath(editor, element);
-  Transforms.select(editor, p);
+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());
-  copy('copy', {
+  (0, _copyToClipboard.default)('copy', {
     onCopy: clipboardData => {
       newData.types.forEach(type => {
         const data = newData.getData(type);
@@ -114,7 +127,8 @@ export const onCopySdocLinkNode = (editor, element) => {
     }
   });
 };
-export const getBeforeText = editor => {
+exports.onCopySdocLinkNode = onCopySdocLinkNode;
+const getBeforeText = editor => {
   const {
     selection
   } = editor;
@@ -126,22 +140,23 @@ export const getBeforeText = editor => {
     anchor
   } = selection;
   // Find the near text node above the current text
-  const [[, beforeNodePath]] = Editor.nodes(editor, {
-    match: node => Text.isText(node),
+  const [[, beforeNodePath]] = _slate.Editor.nodes(editor, {
+    match: node => _slate.Text.isText(node),
     mode: 'lowest'
   });
-  const beforeNodeStartPoint = Editor.start(editor, beforeNodePath); // The starting position of the text node
+  const beforeNodeStartPoint = _slate.Editor.start(editor, beforeNodePath); // The starting position of the text node
   const range = {
     anchor,
     focus: beforeNodeStartPoint
   };
-  const beforeText = Editor.string(editor, range) || '';
+  const beforeText = _slate.Editor.string(editor, range) || '';
   return {
     beforeText,
     range
   };
 };
-export const isTriggeredByShortcut = editor => {
+exports.getBeforeText = getBeforeText;
+const isTriggeredByShortcut = editor => {
   const {
     beforeText
   } = getBeforeText(editor);
@@ -151,7 +166,8 @@ export const isTriggeredByShortcut = editor => {
 };
 
 // If insert operation is triggered by shortcut, remove the '[[' symbol
-export const removeShortCutSymbol = editor => {
+exports.isTriggeredByShortcut = isTriggeredByShortcut;
+const removeShortCutSymbol = editor => {
   // Check is trigger by short cut
   const {
     selection
@@ -161,7 +177,7 @@ export const removeShortCutSymbol = editor => {
     range: beforeRange
   } = getBeforeText(editor);
   const isTriggeredByShortCut = beforeText.slice(-2) === '[[';
-  isTriggeredByShortCut && Transforms.delete(editor, {
+  isTriggeredByShortCut && _slate.Transforms.delete(editor, {
     at: {
       anchor: {
         path: beforeRange.focus.path,
@@ -173,58 +189,63 @@ export const removeShortCutSymbol = editor => {
     },
     voids: true
   });
-  focusEditor(editor);
+  (0, _core.focusEditor)(editor);
 };
 
 // Generate temp input for collecting file name
+exports.removeShortCutSymbol = removeShortCutSymbol;
 const generateFileLinkInput = () => {
-  const input = generateEmptyElement(FILE_LINK_INSET_INPUT_TEMP);
+  const input = (0, _core.generateEmptyElement)(_constants.FILE_LINK_INSET_INPUT_TEMP);
   return input;
 };
 
 // Insert temp input collecting file name
-export const insertTempInput = editor => {
+const insertTempInput = editor => {
   const {
     selection
   } = editor;
-  if (!Range.isCollapsed(selection)) return;
+  if (!_slate.Range.isCollapsed(selection)) return;
   const tempInput = generateFileLinkInput();
-  const insertPoint = Editor.start(editor, selection);
-  Transforms.insertNodes(editor, tempInput, {
+  const insertPoint = _slate.Editor.start(editor, selection);
+  _slate.Transforms.insertNodes(editor, tempInput, {
     at: insertPoint
   });
-  const path = Editor.path(editor, insertPoint);
-  const insertPath = Path.next(path);
+  const path = _slate.Editor.path(editor, insertPoint);
+  const insertPath = _slate.Path.next(path);
   const focusPoint = insertPath.concat(0);
-  focusEditor(editor, focusPoint);
+  (0, _core.focusEditor)(editor, focusPoint);
 };
 
 // Remove temp input collecting file name
-export const removeTempInput = (editor, element) => {
-  const path = ReactEditor.findPath(editor, element);
-  Transforms.delete(editor, {
+exports.insertTempInput = insertTempInput;
+const removeTempInput = (editor, element) => {
+  const path = _slateReact.ReactEditor.findPath(editor, element);
+  _slate.Transforms.delete(editor, {
     at: path
   });
 };
-export const getFileSearchInputEntry = editor => {
-  const [searchInputNodeEntry] = Editor.nodes(editor, {
-    match: n => n.type === FILE_LINK_INSET_INPUT_TEMP
+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'
-export const insertTextWhenRemoveFileNameCollector = (editor, searchInputNode) => {
-  const inputNodePath = ReactEditor.findPath(editor, searchInputNode);
+exports.getFileSearchInputEntry = getFileSearchInputEntry;
+const insertTextWhenRemoveFileNameCollector = (editor, searchInputNode) => {
+  const inputNodePath = _slateReact.ReactEditor.findPath(editor, searchInputNode);
   if (!inputNodePath) return;
-  const prevNodeEntry = Editor.previous(editor, {
+  const prevNodeEntry = _slate.Editor.previous(editor, {
     at: inputNodePath
   });
   if (!prevNodeEntry) return;
-  const searchContent = Node.string(searchInputNode);
-  const insertPoint = Editor.end(editor, prevNodeEntry[1]);
-  Transforms.insertText(editor, searchContent, {
+  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;