@seafile/sdoc-editor 0.1.166 → 0.1.167-beta

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

@@ -1,25 +1,23 @@
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import React, { useMemo, useEffect, useState, useCallback, useImperativeHandle, forwardRef } from 'react';
 import deepCopy from 'deep-copy';
 import context from '../../context';
-import { MODE } from '../../constants';
 import CommonLoading from '../../components/common-loading';
 import { PAGE_EDIT_AREA_WIDTH } from '../constants';
 import { createDefaultEditor } from '../extension';
 import withNodeId from '../node-id';
 import { withSocketIO } from '../socket';
-import DiffViewer from '../views/diff-viewer';
 import SDocEditor from './sdoc-editor';
 import './index.css';
 var Editor = forwardRef(function (_ref, ref) {
-  var mode = _ref.mode,
-    document = _ref.document,
-    setDiffChanges = _ref.setDiffChanges;
+  var document = _ref.document,
+    _ref$isReloading = _ref.isReloading,
+    isReloading = _ref$isReloading === void 0 ? false : _ref$isReloading;
   var editor = useMemo(function () {
     var defaultEditor = createDefaultEditor();
     var editorConfig = context.getEditorConfig();
-    defaultEditor.mode = MODE.EDITOR;
     var newEditor = withNodeId(withSocketIO(defaultEditor, {
       document: document,
       config: editorConfig
@@ -35,18 +33,6 @@ var Editor = forwardRef(function (_ref, ref) {
     _useState2 = _slicedToArray(_useState, 2),
     slateValue = _useState2[0],
     _setSlateValue = _useState2[1];
-  var _useState3 = useState(false),
-    _useState4 = _slicedToArray(_useState3, 2),
-    isLoading = _useState4[0],
-    _setLoading = _useState4[1];
-  var _useState5 = useState(null),
-    _useState6 = _slicedToArray(_useState5, 2),
-    diffContent = _useState6[0],
-    _setDiffContent = _useState6[1];
-  var _useState7 = useState(null),
-    _useState8 = _slicedToArray(_useState7, 2),
-    currentContent = _useState8[0],
-    setCurrentContent = _useState8[1];
 
   // useMount: init socket connection
   useEffect(function () {
@@ -66,26 +52,10 @@ var Editor = forwardRef(function (_ref, ref) {
   // The parent component can call the method of this component through ref
   useImperativeHandle(ref, function () {
     return {
-      // set value
-      setLoading: function setLoading(isLoading) {
-        _setLoading(isLoading);
-      },
-      setDiffContent: function setDiffContent(content) {
-        setCurrentContent(deepCopy(_objectSpread(_objectSpread({}, document), {}, {
-          children: slateValue
-        })));
-        _setDiffContent(content);
-      },
-      setEditorMode: function setEditorMode(mode) {
-        editor.cursors = {};
-        editor.selection = null;
-        if (mode === MODE.EDITOR) {
-          editor.operations = [];
-        }
-        editor.mode = mode;
-      },
       setSlateValue: function setSlateValue(document) {
-        _setSlateValue(document.children);
+        _setSlateValue(_toConsumableArray(document.children));
+        // Force update of editor's child elements
+        editor.children = document.children;
       },
       updateDocumentVersion: function updateDocumentVersion(document) {
         editor.updateDocumentVersion(document);
@@ -100,21 +70,11 @@ var Editor = forwardRef(function (_ref, ref) {
       // eslint-disable-next-line react-hooks/exhaustive-deps
     };
   }, [document, editor, slateValue]);
-  if (isLoading) {
+  if (isReloading) {
     return /*#__PURE__*/React.createElement("div", {
       className: "h-100 w-100 d-flex align-items-center justify-content-center"
     }, /*#__PURE__*/React.createElement(CommonLoading, null));
   }
-  if (mode === MODE.DIFF_VIEWER) {
-    return /*#__PURE__*/React.createElement(DiffViewer, {
-      showToolbar: true,
-      showOutline: true,
-      editor: editor,
-      currentContent: currentContent,
-      lastContent: diffContent,
-      didMountCallback: setDiffChanges
-    });
-  }
   return /*#__PURE__*/React.createElement(SDocEditor, {
     slateValue: slateValue,
     editor: editor,

package/dist/basic-sdk/socket/helpers.js

@@ -4,7 +4,6 @@ import { Editor, Operation } from '@seafile/slate';
 import { getNode } from '../extension/core';
 import * as OPERATION from '../node-id/constants';
 import { setCursor } from '../cursor/helper';
-import { MODE } from '../../constants';
 export var getNodePathById = function getNodePathById(rootNode, nodeId) {
   var path = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
   if (rootNode.id === nodeId) return path;
@@ -253,7 +252,6 @@ export var reExecRevertOperationList = function reExecRevertOperationList(editor
   }
 };
 export var syncRemoteOperations = function syncRemoteOperations(editor, remoteOperations) {
-  if (editor.mode !== MODE.EDITOR) return;
   if (remoteOperations.length === 0) return;
   Editor.withoutNormalizing(editor, function () {
     for (var i = 0; i < remoteOperations.length; i++) {

package/dist/basic-sdk/socket/socket-manager.js

@@ -7,7 +7,7 @@ import { syncRemoteOperations, reExecRevertOperationList, revertOperationList, s
 import SocketClient from './socket-client';
 import { clientDebug, conflictDebug, serverDebug, stateDebug } from '../utils/debug';
 import { deleteCursor } from '../cursor/helper';
-import { EXTERNAL_EVENT, MODE } from '../../constants';
+import { EXTERNAL_EVENT } from '../../constants';
 
 //  idle --> sending --> conflict --> idle
 //       --> conflict --> idle
@@ -56,7 +56,6 @@ var SocketManager = /*#__PURE__*/_createClass(function SocketManager(editor, _do
     _this.sendOperations();
   };
   this.sendOperations = function () {
-    if (_this.editor.mode !== MODE.EDITOR) return;
     if (_this.state !== STATE.IDLE) return;
     stateDebug("State changed: ".concat(_this.state, " -> ").concat(STATE.SENDING));
     _this.state = STATE.SENDING;

package/dist/basic-sdk/socket/with-socket-io.js

@@ -1,4 +1,3 @@
-import { MODE } from '../../constants';
 import { generateCursorData } from '../cursor/helper';
 import EventBus from '../utils/event-bus';
 import SocketManager from './socket-manager';
@@ -22,7 +21,6 @@ var withSocketIO = function withSocketIO(editor, options) {
   newEditor.onChange = function () {
     var document = options.document,
       config = options.config;
-    if (newEditor.mode === MODE.DIFF_VIEWER) return;
     var operations = newEditor.operations;
     if (!newEditor.isRemote && operations.length > 0) {
       var isAllSetSelection = operations.every(function (operation) {
@@ -30,23 +28,18 @@ var withSocketIO = function withSocketIO(editor, options) {
       });
       var _socketManager = SocketManager.getInstance(newEditor, document, config);
       if (!isAllSetSelection) {
-        if (newEditor.mode === MODE.EDITOR) {
-          // get update content value operations
-          var updateOperations = operations.filter(function (operation) {
-            return operation.type !== 'set_selection';
-          });
-          _socketManager.onReceiveLocalOperations(updateOperations);
-        }
+        // get update content value operations
+        var updateOperations = operations.filter(function (operation) {
+          return operation.type !== 'set_selection';
+        });
+        _socketManager.onReceiveLocalOperations(updateOperations);
       }
-      if (newEditor.mode === MODE.EDITOR) {
-        _socketManager.sendCursorLocation(editor.selection);
-      }
-    }
-    if (newEditor.mode === MODE.EDITOR) {
-      // dispatch editor change event
-      var eventBus = EventBus.getInstance(newEditor, document, config);
-      eventBus.dispatch('change');
+      _socketManager.sendCursorLocation(editor.selection);
     }
+
+    // dispatch editor change event
+    var eventBus = EventBus.getInstance(newEditor, document, config);
+    eventBus.dispatch('change');
     onChange();
   };
   newEditor.rebaseContent = function (document, originFileVersion) {

package/dist/basic-sdk/views/index.js

@@ -1,3 +1,4 @@
-import DiffViewer from './diff-viewer';
 import SDocViewer from './sdoc-viewer';
-export { DiffViewer, SDocViewer };
+import DiffViewer from './sdoc-diff-viewer';
+import RevisionDiffViewer from './revision-diff-viewer';
+export { SDocViewer, DiffViewer, RevisionDiffViewer };

package/dist/basic-sdk/views/revision-diff-viewer.js

@@ -0,0 +1,44 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import React, { useEffect, useState } from 'react';
+import context from '../../context';
+import { getDiff } from '../utils/diff';
+import SDocViewer from './sdoc-viewer';
+import Loading from '../../components/loading';
+import '../../assets/css/diff-viewer.css';
+var RevisionDiffViewer = function RevisionDiffViewer(_ref) {
+  var revisionContent = _ref.revisionContent,
+    didMountCallback = _ref.didMountCallback;
+  var _useState = useState(true),
+    _useState2 = _slicedToArray(_useState, 2),
+    isLoading = _useState2[0],
+    setIsLoading = _useState2[1];
+  var _useState3 = useState(null),
+    _useState4 = _slicedToArray(_useState3, 2),
+    diff = _useState4[0],
+    setDiff = _useState4[1];
+  useEffect(function () {
+    setIsLoading(true);
+    context.getSeadocOriginFileContent().then(function (res) {
+      var originContentString = res.data.content;
+      var originContent = JSON.parse(originContentString);
+      var diff = getDiff(revisionContent, originContent);
+      setDiff(diff);
+      didMountCallback && didMountCallback(diff);
+      setIsLoading(false);
+    }).catch(function (error) {
+      console.log('error');
+      setIsLoading(false);
+    });
+  }, [revisionContent, didMountCallback]);
+  if (isLoading) {
+    return /*#__PURE__*/React.createElement(Loading, null);
+  }
+  return /*#__PURE__*/React.createElement(SDocViewer, {
+    showToolbar: true,
+    showOutline: true,
+    document: {
+      children: diff.value
+    }
+  });
+};
+export default RevisionDiffViewer;

package/dist/basic-sdk/views/sdoc-diff-viewer.js

@@ -0,0 +1,21 @@
+import React, { useEffect } from 'react';
+import { getDiff } from '../utils/diff';
+import SDocViewer from './sdoc-viewer';
+import '../../assets/css/diff-viewer.css';
+var DiffViewer = function DiffViewer(_ref) {
+  var currentContent = _ref.currentContent,
+    lastContent = _ref.lastContent,
+    didMountCallback = _ref.didMountCallback;
+  var diff = getDiff(currentContent, lastContent);
+  useEffect(function () {
+    didMountCallback && didMountCallback(diff);
+  }, [didMountCallback, diff]);
+  return /*#__PURE__*/React.createElement(SDocViewer, {
+    showToolbar: false,
+    showOutline: false,
+    document: {
+      children: diff.value
+    }
+  });
+};
+export default DiffViewer;

package/dist/constants/index.js

@@ -14,11 +14,6 @@ export var EXTERNAL_EVENT = {
   REMOVE_DOCUMENT: 'remove_document',
   REMOVE_DOCUMENT_ERROR: 'remove_document_error'
 };
-export var MODE = {
-  DIFF_VIEWER: 'diff_viewer',
-  VIEWER: 'viewer',
-  EDITOR: 'editor'
-};
 export var TIP_TYPE = {
   DELETE_NO_CHANGES_REVISION: 'delete_no_changes_revision',
   MERGE: 'merge',

package/dist/hooks/use-document.js

@@ -0,0 +1,80 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { useCallback, useEffect, useState } from 'react';
+import context from '../context';
+export var useDocument = function useDocument() {
+  var _useState = useState(true),
+    _useState2 = _slicedToArray(_useState, 2),
+    isFirstLoading = _useState2[0],
+    setIsFirstLoading = _useState2[1];
+  var _useState3 = useState(false),
+    _useState4 = _slicedToArray(_useState3, 2),
+    isReloading = _useState4[0],
+    setIsReloading = _useState4[1];
+  var _useState5 = useState(true),
+    _useState6 = _slicedToArray(_useState5, 2),
+    document = _useState6[0],
+    setDocument = _useState6[1];
+  var _useState7 = useState(''),
+    _useState8 = _slicedToArray(_useState7, 2),
+    errorMessage = _useState8[0],
+    setErrorMessage = _useState8[1];
+  var loadDocument = useCallback(function () {
+    return new Promise(function (resolve, reject) {
+      context.getFileContent().then(function (res) {
+        var result = res.data;
+        if (result && !result.children) {
+          result = {
+            version: 0,
+            children: result.content,
+            cursors: result.cursors || {}
+          };
+        }
+        resolve(result);
+      }).catch(function (error) {
+        // eslint-disable-next-line
+        console.log(error);
+        var errorMessage = 'Load_doc_content_error';
+        if (error && error.response) {
+          var _ref = error.response.data || {},
+            error_type = _ref.error_type;
+          if (error_type === 'content_invalid') {
+            errorMessage = 'Sdoc_format_invalid';
+          }
+        }
+        reject(errorMessage);
+      });
+    });
+  }, []);
+  var reloadDocument = useCallback(function () {
+    setIsReloading(true);
+    loadDocument().then(function (document) {
+      setDocument(document);
+      setIsReloading(false);
+    }).catch(function (errorMessage) {
+      setIsReloading(false);
+      setErrorMessage(errorMessage);
+      setDocument(null);
+      setIsReloading(false);
+    });
+  }, [loadDocument]);
+  useEffect(function () {
+    loadDocument().then(function (document) {
+      setDocument(document);
+      setIsFirstLoading(false);
+    }).catch(function (errorMessage) {
+      setErrorMessage(errorMessage);
+      setDocument(null);
+      setIsFirstLoading(false);
+    });
+
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  return {
+    isFirstLoading: isFirstLoading,
+    isReloading: isReloading,
+    errorMessage: errorMessage,
+    document: document,
+    loadDocument: loadDocument,
+    reloadDocument: reloadDocument
+  };
+};

package/dist/pages/simple-editor.js

@@ -7,14 +7,15 @@ import Loading from '../components/loading';
 import DocInfo from '../components/doc-info';
 import DocOperations from '../components/doc-operations';
 import Layout, { Header, Content } from '../layout';
-import { generateDefaultDocContent } from '../utils';
 import context from '../context';
 import ErrorBoundary from './error-boundary';
 import TipDialog from '../components/tip-dialog';
-import { EXTERNAL_EVENT, MODE, TIP_TYPE, REVISION_FIRST_LOAD_KEY, REVISION_FIRST_LOAD_VALUE } from '../constants';
+import { EXTERNAL_EVENT, TIP_TYPE, REVISION_FIRST_LOAD_KEY, REVISION_FIRST_LOAD_VALUE } from '../constants';
 import { getRebase, hasConflict } from '../basic-sdk/utils/rebase';
 import toaster from '../components/toast';
 import { EventBus, SDocEditor } from '../basic-sdk';
+import { RevisionDiffViewer } from '../basic-sdk/views';
+import { useDocument } from '../hooks/use-document';
 import '../assets/css/simple-editor.css';
 var SimpleEditor = function SimpleEditor(_ref) {
   var isStarred = _ref.isStarred,
@@ -22,56 +23,37 @@ var SimpleEditor = function SimpleEditor(_ref) {
     t = _ref.t;
   context.initApi();
   var editorRef = useRef(null);
-  var _useState = useState(true),
+  var _useState = useState(false),
     _useState2 = _slicedToArray(_useState, 2),
-    isLoadingSdoc = _useState2[0],
-    setLoadingSdoc = _useState2[1];
-  var _useState3 = useState(''),
+    isShowChanges = _useState2[0],
+    setShowChanges = _useState2[1];
+  var _useState3 = useState(null),
     _useState4 = _slicedToArray(_useState3, 2),
-    errorMessage = _useState4[0],
-    setErrorMessage = _useState4[1];
-  var _useState5 = useState(false),
+    revisionContent = _useState4[0],
+    setRevisionContent = _useState4[1];
+  var _useState5 = useState([]),
     _useState6 = _slicedToArray(_useState5, 2),
-    isShowChanges = _useState6[0],
-    setShowChanges = _useState6[1];
-  var _useState7 = useState(null),
+    changes = _useState6[0],
+    setChanges = _useState6[1];
+  var _useState7 = useState(false),
     _useState8 = _slicedToArray(_useState7, 2),
-    document = _useState8[0],
-    setDocument = _useState8[1];
-  var _useState9 = useState(MODE.EDITOR),
+    showTip = _useState8[0],
+    setShowTip = _useState8[1];
+  var _useState9 = useState(''),
     _useState10 = _slicedToArray(_useState9, 2),
-    mode = _useState10[0],
-    setMode = _useState10[1];
+    tipType = _useState10[0],
+    setTipType = _useState10[1];
   var _useState11 = useState([]),
     _useState12 = _slicedToArray(_useState11, 2),
-    changes = _useState12[0],
-    setChanges = _useState12[1];
-  var _useState13 = useState(false),
-    _useState14 = _slicedToArray(_useState13, 2),
-    showTip = _useState14[0],
-    setShowTip = _useState14[1];
-  var _useState15 = useState(''),
-    _useState16 = _slicedToArray(_useState15, 2),
-    tipType = _useState16[0],
-    setTipType = _useState16[1];
-  var _useState17 = useState([]),
-    _useState18 = _slicedToArray(_useState17, 2),
-    mergeValue = _useState18[0],
-    setMergeValue = _useState18[1];
-  useEffect(function () {
-    loadDocument(function (document) {
-      setDocument(document);
-      setLoadingSdoc(false);
-    }, function (errorMessage) {
-      setErrorMessage(errorMessage);
-      setDocument(null);
-      setLoadingSdoc(false);
-    }, function () {
-      setLoadingSdoc(true);
-    });
-
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, []);
+    mergeValue = _useState12[0],
+    setMergeValue = _useState12[1];
+  var _useDocument = useDocument(),
+    isFirstLoading = _useDocument.isFirstLoading,
+    isReloading = _useDocument.isReloading,
+    errorMessage = _useDocument.errorMessage,
+    document = _useDocument.document,
+    loadDocument = _useDocument.loadDocument,
+    reloadDocument = _useDocument.reloadDocument;
 
   // useMount: reset title
   useEffect(function () {
@@ -140,132 +122,89 @@ var SimpleEditor = function SimpleEditor(_ref) {
 
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
-  var loadDocument = useCallback(function (successCallback, errorCallback, callback) {
-    callback && callback();
-    context.getFileContent().then(function (res) {
-      var result = res.data || generateDefaultDocContent();
-      if (result && !result.children) {
-        result = {
-          version: 0,
-          children: result.content,
-          cursors: result.cursors || {}
-        };
-      }
-      successCallback && successCallback(result);
-    }).catch(function (error) {
-      // eslint-disable-next-line
-      console.log(error);
-      var errorMessage = 'Load_doc_content_error';
-      if (error && error.response) {
-        var _ref2 = error.response.data || {},
-          error_type = _ref2.error_type;
-        if (error_type === 'content_invalid') {
-          errorMessage = 'Sdoc_format_invalid';
-        }
-      }
-      errorCallback && errorCallback(errorMessage);
-    });
-  }, []);
-  var setDiffContent = useCallback(function () {
-    context.getSeadocOriginFileContent().then(function (res) {
-      var originContentString = res.data.content;
-      var originContent = JSON.parse(originContentString);
-      editorRef.current.setDiffContent(originContent);
-      editorRef.current.setLoading(false);
-    }).catch(function (error) {
-      console.log('error');
-    });
-  }, []);
   var toggleViewChanges = useCallback(function (isShowChanges) {
+    if (!isShowChanges) {
+      setShowChanges(isShowChanges);
+      reloadDocument();
+      return;
+    }
+
+    // Get the contents of the current revision
     var revisionContent = editorRef.current.getSlateValue();
-    if (isShowChanges && hasConflict(revisionContent.children)) {
+
+    // Prevent users from switching if document contains conflicting content
+    if (hasConflict(revisionContent.children)) {
       setTipType(TIP_TYPE.HAS_CONFLICT_BEFORE_VIEW_CHANGES);
       setShowTip(true);
       return;
     }
-    editorRef.current.setLoading(true);
-    setShowChanges(isShowChanges);
-    var mode = isShowChanges ? MODE.DIFF_VIEWER : MODE.EDITOR;
-    setMode(mode);
-    editorRef.current.setEditorMode(mode);
-    if (!isShowChanges) {
-      loadDocument(function (document) {
-        setDocument(document);
-        editorRef.current.setSlateValue(document);
-        editorRef.current.setLoading(false);
-      }, function (errorMessage) {
-        setErrorMessage(errorMessage);
-        editorRef.current.setLoading(false);
-      });
-      return;
-    }
-    setDiffContent();
 
+    // Record the contents of the current revision
+    setRevisionContent(revisionContent);
+    setShowChanges(isShowChanges);
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [document, editorRef.current]);
+  var setDiffChanges = useCallback(function (diff) {
+    setChanges(diff.changes);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [isShowChanges]);
   var publishRevision = useCallback( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+    var revisionPromise, baseVersionPromise, originVersionPromise;
     return _regeneratorRuntime().wrap(function _callee$(_context) {
       while (1) switch (_context.prev = _context.next) {
         case 0:
           setTipType(TIP_TYPE.CHECKING);
           setShowTip(true);
-          loadDocument(function (document) {
-            var revisionContent = document;
+          revisionPromise = loadDocument();
+          baseVersionPromise = context.getRevisionBaseVersionContent();
+          originVersionPromise = context.getSeadocOriginFileContent();
+          Promise.all([revisionPromise, baseVersionPromise, originVersionPromise]).then(function (results) {
+            var _results = _slicedToArray(results, 3),
+              revisionContent = _results[0],
+              baseRes = _results[1],
+              masterRes = _results[2];
+            var baseContent = JSON.parse(baseRes.data.content);
+            var masterContent = JSON.parse(masterRes.data.content);
             if (hasConflict(revisionContent.children)) {
               setTipType(TIP_TYPE.HAS_CONFLICT_BEFORE_PUBLISH);
               setShowTip(true);
               return;
             }
-            var baseContent;
-            var masterContent;
-            context.getRevisionBaseVersionContent().then(function (res) {
-              var baseVersionContentString = res.data.content; // commit content
-              baseContent = JSON.parse(baseVersionContentString);
-              return context.getSeadocOriginFileContent();
-            }).then(function (res) {
-              var masterContentString = res.data.content;
-              masterContent = JSON.parse(masterContentString);
-              var _getRebase = getRebase(masterContent, baseContent, revisionContent),
-                canMerge = _getRebase.canMerge,
-                isNeedReplaceMaster = _getRebase.isNeedReplaceMaster,
-                value = _getRebase.value;
-              if (canMerge && isNeedReplaceMaster) {
-                setTipType(TIP_TYPE.PUBLISHING);
-                context.publishRevision().then(function (res) {
-                  setTipType(TIP_TYPE.HAS_BEEN_PUBLISHED);
-                  setShowTip(true);
-                }).catch(function (error) {
-                  toaster.danger(t('Error'));
-                });
-                return;
-              }
-              if (canMerge && !isNeedReplaceMaster) {
-                setTipType(TIP_TYPE.DELETE_NO_CHANGES_REVISION);
+            var _getRebase = getRebase(masterContent, baseContent, revisionContent),
+              canMerge = _getRebase.canMerge,
+              isNeedReplaceMaster = _getRebase.isNeedReplaceMaster,
+              value = _getRebase.value;
+            if (canMerge && isNeedReplaceMaster) {
+              setTipType(TIP_TYPE.PUBLISHING);
+              context.publishRevision().then(function (res) {
+                setTipType(TIP_TYPE.HAS_BEEN_PUBLISHED);
                 setShowTip(true);
-                return;
-              }
-              setMergeValue(value);
-              setTipType(TIP_TYPE.MERGE);
+              }).catch(function (error) {
+                toaster.danger(t('Error'));
+              });
+              return;
+            }
+            if (canMerge && !isNeedReplaceMaster) {
+              setTipType(TIP_TYPE.DELETE_NO_CHANGES_REVISION);
               setShowTip(true);
-            }).catch(function (error) {
-              toaster.danger(t('Error'));
-            });
-          }, function (errorMessage) {
-            toaster.danger(t(errorMessage));
+              return;
+            }
+            setMergeValue(value);
+            setTipType(TIP_TYPE.MERGE);
+            setShowTip(true);
+          }).catch(function (error) {
+            if (typeof error === 'string') {
+              toaster.danger(t(error));
+              return;
+            }
+            toaster.danger(t('Error'));
           });
-
-          // eslint-disable-next-line react-hooks/exhaustive-deps
-        case 3:
+        case 6:
         case "end":
           return _context.stop();
       }
     }, _callee);
-  })), [isShowChanges, mode]);
-  var setDiffChanges = useCallback(function (diff) {
-    setChanges(diff.changes);
-
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [isShowChanges]);
+  })), [loadDocument, t]);
   var jumpToURL = useCallback(function (url) {
     window.location.href = url;
   }, []);
@@ -305,12 +244,12 @@ var SimpleEditor = function SimpleEditor(_ref) {
         context.updateSettings({
           'originFileVersion': origin_file_version
         });
-        editorRef.current.setLoading(true);
+        // if revision diff view change to sdoc editor
+        if (isShowChanges) {
+          setShowChanges(false);
+        }
         editorRef.current.setSlateValue(mergeValue);
         editorRef.current.updateDocumentVersion(mergeValue);
-        setMode(MODE.EDITOR);
-        editorRef.current.setEditorMode(MODE.EDITOR);
-        editorRef.current.setLoading(false);
         setShowTip(false);
       }).catch(function (error) {
         callback && callback(false);
@@ -322,7 +261,7 @@ var SimpleEditor = function SimpleEditor(_ref) {
 
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [tipType, mergeValue, editorRef.current, document]);
-  if (isLoadingSdoc) {
+  if (isFirstLoading) {
     return /*#__PURE__*/React.createElement(Loading, null);
   }
   if (errorMessage) {
@@ -341,11 +280,13 @@ var SimpleEditor = function SimpleEditor(_ref) {
     changes: changes,
     toggleViewChanges: toggleViewChanges,
     publishRevision: publishRevision
-  })), /*#__PURE__*/React.createElement(Content, null, /*#__PURE__*/React.createElement(SDocEditor, {
+  })), /*#__PURE__*/React.createElement(Content, null, !isShowChanges && /*#__PURE__*/React.createElement(SDocEditor, {
     ref: editorRef,
-    document: document,
-    mode: mode,
-    setDiffChanges: setDiffChanges
+    isReloading: isReloading,
+    document: document
+  }), isShowChanges && /*#__PURE__*/React.createElement(RevisionDiffViewer, {
+    revisionContent: revisionContent,
+    didMountCallback: setDiffChanges
   }))), showTip && /*#__PURE__*/React.createElement(TipDialog, {
     toggle: closeTip,
     submit: tipSubmit,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seafile/sdoc-editor",
-  "version": "0.1.166",
+  "version": "0.1.167beta",
   "private": false,
   "description": "This is a sdoc editor",
   "main": "dist/index.js",

package/dist/basic-sdk/views/diff-viewer.js

@@ -1,33 +0,0 @@
-import React, { useEffect } from 'react';
-import context from '../../context';
-import { getDiff } from '../utils/diff';
-import SDocViewer from './sdoc-viewer';
-import '../../assets/css/diff-viewer.css';
-var DiffViewer = function DiffViewer(_ref) {
-  var editor = _ref.editor,
-    currentContent = _ref.currentContent,
-    lastContent = _ref.lastContent,
-    didMountCallback = _ref.didMountCallback,
-    showToolbar = _ref.showToolbar,
-    showOutline = _ref.showOutline;
-  var diff = getDiff(currentContent, lastContent);
-  context.initSettings();
-  useEffect(function () {
-    didMountCallback && didMountCallback(diff);
-
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, []);
-  return /*#__PURE__*/React.createElement(SDocViewer, {
-    editor: editor,
-    showToolbar: showToolbar,
-    showOutline: showOutline,
-    document: {
-      children: diff.value
-    }
-  });
-};
-DiffViewer.defaultProps = {
-  showToolbar: false,
-  showOutline: false
-};
-export default DiffViewer;