@seafile/sdoc-editor 1.0.54 → 1.0.55

package/dist/basic-sdk/editor/editable-article.js

@@ -1,21 +1,29 @@
-import React, { useCallback, useMemo, Fragment } from 'react';
-import { Editable, ReactEditor, Slate } from '@seafile/slate-react';
-import { Editor, Node, Range, Transforms } from '@seafile/slate';
-import scrollIntoView from 'scroll-into-view-if-needed';
-import { renderLeaf, renderElement, ContextToolbar, SideToolbar } from '../extension';
-import { getAboveBlockNode, getNextNode, getPrevNode, isSelectionAtBlockEnd, isSelectionAtBlockStart, getCurrentNode, isCurrentLineEmpty, isCurrentLineHasText } from '../extension/core';
-import EventProxy from '../utils/event-handler';
-import { useCursors } from '../cursor/use-cursors';
-import { INTERNAL_EVENT } from '../constants';
-import CommentWrapper from '../comment';
-import { usePipDecorate } from '../decorates';
-import { getCursorPosition, getDomHeight, getDomMarginTop } from '../utils/dom-utils';
-import EventBus from '../utils/event-bus';
-import { ArticleContainer } from '../layout';
-import { useScrollContext } from '../hooks/use-scroll-context';
-import { SetNodeToDecorations } from '../highlight';
-import { IMAGE, IMAGE_BLOCK, CODE_LINE } from '../extension/constants';
-import { isPreventResetTableSelectedRange } from '../extension/plugins/table/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 _slateReact = require("@seafile/slate-react");
+var _slate = require("@seafile/slate");
+var _scrollIntoViewIfNeeded = _interopRequireDefault(require("scroll-into-view-if-needed"));
+var _extension = require("../extension");
+var _core = require("../extension/core");
+var _eventHandler = _interopRequireDefault(require("../utils/event-handler"));
+var _useCursors = require("../cursor/use-cursors");
+var _constants = require("../constants");
+var _comment = _interopRequireDefault(require("../comment"));
+var _decorates = require("../decorates");
+var _domUtils = require("../utils/dom-utils");
+var _eventBus = _interopRequireDefault(require("../utils/event-bus"));
+var _layout = require("../layout");
+var _useScrollContext = require("../hooks/use-scroll-context");
+var _highlight = require("../highlight");
+var _constants2 = require("../extension/constants");
+var _helpers = require("../extension/plugins/table/helpers");
 const EditableArticle = _ref => {
   let {
     showComment,
@@ -25,79 +33,79 @@ const EditableArticle = _ref => {
   } = _ref;
   const {
     cursors
-  } = useCursors(editor);
-  const decorate = usePipDecorate(editor);
+  } = (0, _useCursors.useCursors)(editor);
+  const decorate = (0, _decorates.usePipDecorate)(editor);
 
   // init eventHandler
   // eslint-disable-next-line react-hooks/exhaustive-deps
-  const eventProxy = useMemo(() => new EventProxy(editor), []);
-  const onMouseDown = useCallback(event => {
+  const eventProxy = (0, _react.useMemo)(() => new _eventHandler.default(editor), []);
+  const onMouseDown = (0, _react.useCallback)(event => {
     if (event.button === 0) {
-      const isPreventReset = isPreventResetTableSelectedRange(event);
+      const isPreventReset = (0, _helpers.isPreventResetTableSelectedRange)(event);
       if (!isPreventReset) {
         editor.reSetTableSelectedRange();
-        const eventBus = EventBus.getInstance();
-        eventBus.dispatch(INTERNAL_EVENT.CANCEL_TABLE_SELECT_RANGE);
+        const eventBus = _eventBus.default.getInstance();
+        eventBus.dispatch(_constants.INTERNAL_EVENT.CANCEL_TABLE_SELECT_RANGE);
       }
     }
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
-  const scrollRef = useScrollContext();
-  const onKeyDown = useCallback(event => {
+  const scrollRef = (0, _useScrollContext.useScrollContext)();
+  const onKeyDown = (0, _react.useCallback)(event => {
     const {
       scrollTop,
       clientHeight
     } = scrollRef.current;
     eventProxy.onKeyDown(event);
     if (event.key === 'ArrowLeft') {
-      if (!isSelectionAtBlockStart(editor)) return;
+      if (!(0, _core.isSelectionAtBlockStart)(editor)) return;
     }
     if (event.key === 'ArrowUp' || event.key === 'ArrowLeft') {
       if (scrollTop === 0) return;
-      let prevNode = getPrevNode(editor);
+      let prevNode = (0, _core.getPrevNode)(editor);
       if (!prevNode) return;
-      const domNode = ReactEditor.toDOMNode(editor, prevNode[0]);
-      const domHeight = getDomHeight(domNode);
+      const domNode = _slateReact.ReactEditor.toDOMNode(editor, prevNode[0]);
+      const domHeight = (0, _domUtils.getDomHeight)(domNode);
       const isScrollUp = true;
       const {
         y
-      } = getCursorPosition(isScrollUp);
+      } = (0, _domUtils.getCursorPosition)(isScrollUp);
       if (y >= domHeight) return;
       scrollRef.current.scroll(0, Math.max(0, scrollTop - domHeight));
       return;
     }
     if (event.key === 'ArrowRight') {
-      if (!isSelectionAtBlockEnd(editor)) return;
+      if (!(0, _core.isSelectionAtBlockEnd)(editor)) return;
     }
     if (event.key === 'ArrowDown' || event.key === 'ArrowRight') {
-      let nextNode = getNextNode(editor);
+      let nextNode = (0, _core.getNextNode)(editor);
       if (!nextNode) return;
-      const domNode = ReactEditor.toDOMNode(editor, nextNode[0]);
-      const domHeight = getDomHeight(domNode);
+      const domNode = _slateReact.ReactEditor.toDOMNode(editor, nextNode[0]);
+      const domHeight = (0, _domUtils.getDomHeight)(domNode);
       const isScrollUp = false;
       const {
         y
-      } = getCursorPosition(isScrollUp);
+      } = (0, _domUtils.getCursorPosition)(isScrollUp);
       if (clientHeight - y >= domHeight) return;
       scrollRef.current.scroll(0, Math.max(0, scrollTop + domHeight));
       return;
     }
     if (event.key === 'Backspace') {
-      const [currentNode] = getCurrentNode(editor);
+      const [currentNode] = (0, _core.getCurrentNode)(editor);
       let prevNode = null;
       let prevPath = null;
-      if (getPrevNode(editor)) {
-        [prevNode, prevPath] = getPrevNode(editor);
+      if ((0, _core.getPrevNode)(editor)) {
+        [prevNode, prevPath] = (0, _core.getPrevNode)(editor);
       }
       // If the cursor is collapsed at the beginning, and the current line is not empty, is not a CODE_LINE, and the previous line is a CODE_LINE.
-      const isCursorCollapsed = Range.isCollapsed(editor.selection);
-      if (isCursorCollapsed && prevNode && isSelectionAtBlockStart(editor) && !isCurrentLineEmpty(editor) && prevNode.type === CODE_LINE && currentNode.type !== CODE_LINE) {
-        if (!isCurrentLineHasText(currentNode)) {
-          const prevNodeText = Node.string(prevNode);
-          Transforms.removeNodes(editor, {
+      const isCursorCollapsed = _slate.Range.isCollapsed(editor.selection);
+      if (isCursorCollapsed && prevNode && (0, _core.isSelectionAtBlockStart)(editor) && !(0, _core.isCurrentLineEmpty)(editor) && prevNode.type === _constants2.CODE_LINE && currentNode.type !== _constants2.CODE_LINE) {
+        if (!(0, _core.isCurrentLineHasText)(currentNode)) {
+          const prevNodeText = _slate.Node.string(prevNode);
+          _slate.Transforms.removeNodes(editor, {
             at: prevPath
           });
-          Transforms.insertText(editor, prevNodeText);
+          _slate.Transforms.insertText(editor, prevNodeText);
           event.preventDefault();
         } else {
           const path = prevPath;
@@ -113,26 +121,26 @@ const EditableArticle = _ref => {
               offset: end
             }
           };
-          Transforms.select(editor, range);
+          _slate.Transforms.select(editor, range);
           event.preventDefault();
         }
       }
       const {
         y
-      } = getCursorPosition();
+      } = (0, _domUtils.getCursorPosition)();
 
       // above viewport
       if (y < 0) {
         const newY = Math.abs(y);
-        if (isSelectionAtBlockStart(editor)) {
-          const prevNode = getPrevNode(editor);
+        if ((0, _core.isSelectionAtBlockStart)(editor)) {
+          const prevNode = (0, _core.getPrevNode)(editor);
           if (!prevNode) return;
-          const domNode = ReactEditor.toDOMNode(editor, prevNode[0]);
-          const domHeight = getDomHeight(domNode);
-          const node = getAboveBlockNode(editor);
+          const domNode = _slateReact.ReactEditor.toDOMNode(editor, prevNode[0]);
+          const domHeight = (0, _domUtils.getDomHeight)(domNode);
+          const node = (0, _core.getAboveBlockNode)(editor);
           if (!node) return;
-          const currentDomNode = ReactEditor.toDOMNode(editor, node[0]);
-          const marginTop = getDomMarginTop(currentDomNode);
+          const currentDomNode = _slateReact.ReactEditor.toDOMNode(editor, node[0]);
+          const marginTop = (0, _domUtils.getDomMarginTop)(currentDomNode);
           scrollRef.current.scroll(0, Math.max(0, scrollTop - (newY + domHeight + marginTop)));
         } else {
           scrollRef.current.scroll(0, Math.max(0, scrollTop - newY));
@@ -142,11 +150,11 @@ const EditableArticle = _ref => {
 
       // insider viewport
       if (y >= 0 && y <= clientHeight) {
-        if (isSelectionAtBlockStart(editor)) {
-          const prevNode = getPrevNode(editor);
+        if ((0, _core.isSelectionAtBlockStart)(editor)) {
+          const prevNode = (0, _core.getPrevNode)(editor);
           if (!prevNode) return;
-          const domNode = ReactEditor.toDOMNode(editor, prevNode[0]);
-          const domHeight = getDomHeight(domNode);
+          const domNode = _slateReact.ReactEditor.toDOMNode(editor, prevNode[0]);
+          const domHeight = (0, _domUtils.getDomHeight)(domNode);
           if (y >= domHeight) return;
           // Scroll up the height of the previous block
           scrollRef.current.scroll(0, Math.max(0, scrollTop - domHeight));
@@ -156,14 +164,14 @@ const EditableArticle = _ref => {
 
       // below viewport
       if (y > clientHeight) {
-        if (isSelectionAtBlockStart(editor)) {
+        if ((0, _core.isSelectionAtBlockStart)(editor)) {
           // y: text top border
           scrollRef.current.scroll(0, Math.max(0, scrollTop + (y - clientHeight)));
         } else {
           const marginBottom = 11.2;
           const {
             y: newY
-          } = getCursorPosition(false);
+          } = (0, _domUtils.getCursorPosition)(false);
           const rectBottom = newY + marginBottom; // text bottom border
           scrollRef.current.scroll(0, Math.max(0, scrollTop + (rectBottom - clientHeight)));
         }
@@ -173,38 +181,38 @@ const EditableArticle = _ref => {
 
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [scrollRef]);
-  const handleScrollIntoView = useCallback((editor, domRange) => {
+  const handleScrollIntoView = (0, _react.useCallback)((editor, domRange) => {
     try {
       const {
         selection
       } = editor;
       // Do not scroll into view, when focus on image
-      const [imageNodeEntry] = Editor.nodes(editor, {
-        match: n => [IMAGE, IMAGE_BLOCK].includes(n.type),
+      const [imageNodeEntry] = _slate.Editor.nodes(editor, {
+        match: n => [_constants2.IMAGE, _constants2.IMAGE_BLOCK].includes(n.type),
         at: selection
       });
       if (imageNodeEntry) return;
-      const focusedNode = Node.get(editor, selection.focus.path);
-      const domNode = ReactEditor.toDOMNode(editor, focusedNode);
+      const focusedNode = _slate.Node.get(editor, selection.focus.path);
+      const domNode = _slateReact.ReactEditor.toDOMNode(editor, focusedNode);
       if (!domNode) return;
-      scrollIntoView(domNode, {
+      (0, _scrollIntoViewIfNeeded.default)(domNode, {
         'scrollMode': 'if-needed'
       });
     } catch (error) {
       //
     }
   }, []);
-  return /*#__PURE__*/React.createElement(Slate, {
+  return /*#__PURE__*/_react.default.createElement(_slateReact.Slate, {
     editor: editor,
     value: slateValue,
     onChange: updateSlateValue
-  }, /*#__PURE__*/React.createElement(ArticleContainer, {
+  }, /*#__PURE__*/_react.default.createElement(_layout.ArticleContainer, {
     editor: editor
-  }, /*#__PURE__*/React.createElement(Fragment, null, /*#__PURE__*/React.createElement(ContextToolbar, null), /*#__PURE__*/React.createElement(SetNodeToDecorations, null), /*#__PURE__*/React.createElement(Editable, {
+  }, /*#__PURE__*/_react.default.createElement(_react.Fragment, null, /*#__PURE__*/_react.default.createElement(_extension.ContextToolbar, null), /*#__PURE__*/_react.default.createElement(_highlight.SetNodeToDecorations, null), /*#__PURE__*/_react.default.createElement(_slateReact.Editable, {
     scrollSelectionIntoView: handleScrollIntoView,
     cursors: cursors,
-    renderElement: renderElement,
-    renderLeaf: renderLeaf,
+    renderElement: _extension.renderElement,
+    renderLeaf: _extension.renderLeaf,
     onKeyDown: onKeyDown,
     onMouseDown: onMouseDown,
     decorate: decorate,
@@ -212,7 +220,7 @@ const EditableArticle = _ref => {
     onCopy: eventProxy.onCopy,
     onCompositionStart: eventProxy.onCompositionStart,
     id: "sdoc-editor"
-  })), /*#__PURE__*/React.createElement(SideToolbar, null), showComment && /*#__PURE__*/React.createElement(CommentWrapper, {
+  })), /*#__PURE__*/_react.default.createElement(_extension.SideToolbar, null), showComment && /*#__PURE__*/_react.default.createElement(_comment.default, {
     editor: editor,
     type: "editor"
   })));
@@ -220,4 +228,4 @@ const EditableArticle = _ref => {
 EditableArticle.defaultProps = {
   showComment: true
 };
-export default EditableArticle;
+var _default = exports.default = EditableArticle;

package/dist/basic-sdk/editor/revision-editor.js

@@ -1,12 +1,20 @@
-import React, { useEffect, useRef, useImperativeHandle, forwardRef, useMemo } from 'react';
-import SdocEditor from './sdoc-editor';
-import { RevisionDiffViewer } from '../views';
-import context from '../../context';
-import { createDefaultEditor } from '../extension';
-import withNodeId from '../node-id';
-import { withSocketIO } from '../socket';
-import { PAGE_EDIT_AREA_WIDTH } from '../constants';
-const RevisionEditor = forwardRef((_ref, ref) => {
+"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 _sdocEditor = _interopRequireDefault(require("./sdoc-editor"));
+var _views = require("../views");
+var _context = _interopRequireDefault(require("../../context"));
+var _extension = require("../extension");
+var _nodeId = _interopRequireDefault(require("../node-id"));
+var _socket = require("../socket");
+var _constants = require("../constants");
+const RevisionEditor = /*#__PURE__*/(0, _react.forwardRef)((_ref, ref) => {
   let {
     isShowChanges,
     isReloading,
@@ -14,11 +22,11 @@ const RevisionEditor = forwardRef((_ref, ref) => {
     revisionContent,
     didMountCallback
   } = _ref;
-  const editorRef = useRef(null);
-  const editor = useMemo(() => {
-    const defaultEditor = createDefaultEditor();
-    const editorConfig = context.getEditorConfig();
-    const newEditor = withNodeId(withSocketIO(defaultEditor, {
+  const editorRef = (0, _react.useRef)(null);
+  const editor = (0, _react.useMemo)(() => {
+    const defaultEditor = (0, _extension.createDefaultEditor)();
+    const editorConfig = _context.default.getEditorConfig();
+    const newEditor = (0, _nodeId.default)((0, _socket.withSocketIO)(defaultEditor, {
       document,
       config: editorConfig
     }));
@@ -26,14 +34,14 @@ const RevisionEditor = forwardRef((_ref, ref) => {
       cursors
     } = document;
     newEditor.cursors = cursors || {};
-    newEditor.width = PAGE_EDIT_AREA_WIDTH; // default width
+    newEditor.width = _constants.PAGE_EDIT_AREA_WIDTH; // default width
     return newEditor;
 
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
   // useMount: init socket connection
-  useEffect(() => {
+  (0, _react.useEffect)(() => {
     editor.openConnection();
     return () => {
       editor.closeConnection();
@@ -43,7 +51,7 @@ const RevisionEditor = forwardRef((_ref, ref) => {
   }, []);
 
   // The parent component can call the method of this component through ref
-  useImperativeHandle(ref, () => ({
+  (0, _react.useImperativeHandle)(ref, () => ({
     setSlateValue: document => {
       return editorRef.current.setSlateValue(document);
     },
@@ -58,13 +66,13 @@ const RevisionEditor = forwardRef((_ref, ref) => {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }), [editorRef]);
   if (isShowChanges) {
-    return /*#__PURE__*/React.createElement(RevisionDiffViewer, {
+    return /*#__PURE__*/_react.default.createElement(_views.RevisionDiffViewer, {
       editor: editor,
       revisionContent: revisionContent,
       didMountCallback: didMountCallback
     });
   }
-  return /*#__PURE__*/React.createElement(SdocEditor, {
+  return /*#__PURE__*/_react.default.createElement(_sdocEditor.default, {
     ref: editorRef,
     editor: editor,
     isReloading: isReloading,
@@ -72,4 +80,4 @@ const RevisionEditor = forwardRef((_ref, ref) => {
     showComment: true
   });
 });
-export default RevisionEditor;
+var _default = exports.default = RevisionEditor;

package/dist/basic-sdk/editor/sdoc-comment-editor.js

@@ -1,21 +1,29 @@
-import React, { useEffect, useState, useImperativeHandle, forwardRef, useMemo, useCallback, useRef } from 'react';
-import { Editor } from '@seafile/slate';
-import deepCopy from 'deep-copy';
-import context from '../../context';
-import CommonLoading from '../../components/common-loading';
-import { COMMENT_EDITOR_EDIT_AREA_WIDTH } from '../constants';
-import { createCommentEditor } from '../extension';
-import withNodeId from '../node-id';
-import { withSocketIO } from '../socket';
-import { focusEditor } from '../extension/core';
-import { EditorContainer } from '../layout';
-import { CollaboratorsProvider } from '../../hooks';
-import { EventBus } from '../../basic-sdk';
-import { EXTERNAL_EVENT } from '../../constants';
-import CommentEditorToolbar from '../extension/toolbar/comment-editor-toolbar';
-import CommentArticle from './comment-article';
-import { ScrollContext } from '../hooks/use-scroll-context';
-const SdocCommentEditor = forwardRef((_ref, ref) => {
+"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 _slate = require("@seafile/slate");
+var _deepCopy = _interopRequireDefault(require("deep-copy"));
+var _context = _interopRequireDefault(require("../../context"));
+var _commonLoading = _interopRequireDefault(require("../../components/common-loading"));
+var _constants = require("../constants");
+var _extension = require("../extension");
+var _nodeId = _interopRequireDefault(require("../node-id"));
+var _socket = require("../socket");
+var _core = require("../extension/core");
+var _layout = require("../layout");
+var _hooks = require("../../hooks");
+var _basicSdk = require("../../basic-sdk");
+var _constants2 = require("../../constants");
+var _commentEditorToolbar = _interopRequireDefault(require("../extension/toolbar/comment-editor-toolbar"));
+var _commentArticle = _interopRequireDefault(require("./comment-article"));
+var _useScrollContext = require("../hooks/use-scroll-context");
+const SdocCommentEditor = /*#__PURE__*/(0, _react.forwardRef)((_ref, ref) => {
   let {
     editor: propsEditor,
     document,
@@ -25,13 +33,13 @@ const SdocCommentEditor = forwardRef((_ref, ref) => {
     submitBtnText,
     onCancel
   } = _ref;
-  const [slateValue, setSlateValue] = useState(document.children);
-  const commentEditorContainerRef = useRef(null);
-  const validEditor = useMemo(() => {
+  const [slateValue, setSlateValue] = (0, _react.useState)(document.children);
+  const commentEditorContainerRef = (0, _react.useRef)(null);
+  const validEditor = (0, _react.useMemo)(() => {
     if (propsEditor) return propsEditor;
-    const defaultEditor = createCommentEditor();
-    const editorConfig = context.getEditorConfig();
-    const newEditor = withNodeId(withSocketIO(defaultEditor, {
+    const defaultEditor = (0, _extension.createCommentEditor)();
+    const editorConfig = _context.default.getEditorConfig();
+    const newEditor = (0, _nodeId.default)((0, _socket.withSocketIO)(defaultEditor, {
       document,
       config: editorConfig
     }));
@@ -39,42 +47,42 @@ const SdocCommentEditor = forwardRef((_ref, ref) => {
       cursors
     } = document;
     newEditor.cursors = cursors || {};
-    newEditor.width = COMMENT_EDITOR_EDIT_AREA_WIDTH; // default width
+    newEditor.width = _constants.COMMENT_EDITOR_EDIT_AREA_WIDTH; // default width
 
     return newEditor;
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
   // useMount: focus editor
-  useEffect(() => {
+  (0, _react.useEffect)(() => {
     const [firstNode] = validEditor.children;
     if (firstNode) {
       const [firstNodeFirstChild] = firstNode.children;
       if (firstNodeFirstChild) {
-        const endOfFirstNode = Editor.end(validEditor, [0, 0]);
+        const endOfFirstNode = _slate.Editor.end(validEditor, [0, 0]);
         const range = {
           anchor: endOfFirstNode,
           focus: endOfFirstNode
         };
-        focusEditor(validEditor, range);
+        (0, _core.focusEditor)(validEditor, range);
       }
       // Force refresh to fix comment list
       setSlateValue([...validEditor.children]);
     }
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
-  const onRefreshDocument = useCallback(() => {
+  const onRefreshDocument = (0, _react.useCallback)(() => {
     window.location.reload();
   }, []);
 
   // useMount: refresh document
-  useEffect(() => {
-    const eventBus = EventBus.getInstance();
-    eventBus.subscribe(EXTERNAL_EVENT.REFRESH_DOCUMENT, onRefreshDocument);
+  (0, _react.useEffect)(() => {
+    const eventBus = _basicSdk.EventBus.getInstance();
+    eventBus.subscribe(_constants2.EXTERNAL_EVENT.REFRESH_DOCUMENT, onRefreshDocument);
   }, [onRefreshDocument]);
 
   // The parent component can call the method of this component through ref
-  useImperativeHandle(ref, () => ({
+  (0, _react.useImperativeHandle)(ref, () => ({
     setSlateValue: document => {
       // Force update of editor's child elements
       validEditor.children = document.children;
@@ -85,7 +93,7 @@ const SdocCommentEditor = forwardRef((_ref, ref) => {
     },
     // get value
     getSlateValue: () => {
-      return deepCopy({
+      return (0, _deepCopy.default)({
         ...document,
         children: slateValue
       });
@@ -94,38 +102,38 @@ const SdocCommentEditor = forwardRef((_ref, ref) => {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }), [document, validEditor, slateValue]);
   if (isReloading) {
-    return /*#__PURE__*/React.createElement("div", {
+    return /*#__PURE__*/_react.default.createElement("div", {
       className: "h-100 w-100 d-flex align-items-center justify-content-center"
-    }, /*#__PURE__*/React.createElement(CommonLoading, null));
+    }, /*#__PURE__*/_react.default.createElement(_commonLoading.default, null));
   }
   const handleFocusEditor = e => {
     if (e.target === commentEditorContainerRef.current) {
-      const focusPoint = Editor.end(validEditor, []);
-      focusEditor(validEditor, focusPoint);
+      const focusPoint = _slate.Editor.end(validEditor, []);
+      (0, _core.focusEditor)(validEditor, focusPoint);
     }
   };
-  return /*#__PURE__*/React.createElement(EditorContainer, {
+  return /*#__PURE__*/_react.default.createElement(_layout.EditorContainer, {
     editor: validEditor
-  }, /*#__PURE__*/React.createElement(CollaboratorsProvider, null, /*#__PURE__*/React.createElement("div", {
+  }, /*#__PURE__*/_react.default.createElement(_hooks.CollaboratorsProvider, null, /*#__PURE__*/_react.default.createElement("div", {
     className: "sdoc-comment-editor-wrapper"
-  }, /*#__PURE__*/React.createElement("div", {
+  }, /*#__PURE__*/_react.default.createElement("div", {
     ref: commentEditorContainerRef,
     className: "article sdoc-comment-editor",
     onClick: handleFocusEditor
-  }, /*#__PURE__*/React.createElement(ScrollContext.Provider, {
+  }, /*#__PURE__*/_react.default.createElement(_useScrollContext.ScrollContext.Provider, {
     value: {
       scrollRef: commentEditorContainerRef
     }
-  }, /*#__PURE__*/React.createElement(CommentArticle, {
+  }, /*#__PURE__*/_react.default.createElement(_commentArticle.default, {
     type: type,
     editor: validEditor,
     slateValue: slateValue,
     updateSlateValue: setSlateValue
-  }))), /*#__PURE__*/React.createElement(CommentEditorToolbar, {
+  }))), /*#__PURE__*/_react.default.createElement(_commentEditorToolbar.default, {
     editor: validEditor,
     onSubmit: onSubmit,
     submitBtnText: submitBtnText,
     onCancel: onCancel
   }))));
 });
-export default SdocCommentEditor;
+var _default = exports.default = SdocCommentEditor;