@seafile/sdoc-editor 0.1.157 → 0.1.159-beta10

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

@@ -119,6 +119,52 @@ var SocketClient = /*#__PURE__*/_createClass(function SocketClient(config) {
   this.disconnectWithServer = function () {
     _this.socket.disconnect();
   };
+  this.sendPublishDocument = function (originDocUuid, originDocName, callback) {
+    _this.socket.emit('publish-document', _this.getParams({
+      origin_doc_uuid: originDocUuid,
+      origin_doc_name: originDocName
+    }), function (success) {
+      callback && callback(success);
+    });
+  };
+  this.receivePublishDocument = function () {
+    var socketManager = SocketManager.getInstance();
+    socketManager.receivePublishDocument();
+  };
+  this.receivePublishDocumentError = function () {
+    var socketManager = SocketManager.getInstance();
+    socketManager.receivePublishDocumentError();
+  };
+  this.sendReplaceDocument = function (document, callback) {
+    _this.socket.emit('replace-document', _this.getParams({
+      document: document
+    }), function (result) {
+      callback && callback(result);
+    });
+  };
+  this.receiveDocumentReplaced = function () {
+    var socketManager = SocketManager.getInstance();
+    socketManager.receiveDocumentReplaced();
+  };
+  this.receiveDocumentReplacedError = function () {
+    var socketManager = SocketManager.getInstance();
+    socketManager.receiveDocumentReplacedError();
+  };
+  this.sendSaveDocument = function (callback) {
+    _this.socket.emit('save-document', _this.getParams({
+      document: document
+    }), function (saveFlag) {
+      callback && callback(saveFlag);
+    });
+  };
+  this.receiveRemoveDocument = function () {
+    var socketManager = SocketManager.getInstance();
+    socketManager.receiveRemoveDocument();
+  };
+  this.receiveRemoveDocumentError = function () {
+    var socketManager = SocketManager.getInstance();
+    socketManager.receiveRemoveDocumentError();
+  };
   this.config = config;
   this.isReconnect = false;
   this.socket = io(config.sdocServer, {
@@ -133,6 +179,18 @@ var SocketClient = /*#__PURE__*/_createClass(function SocketClient(config) {
   this.socket.on('join-room', this.onJoinRoom);
   this.socket.on('leave-room', this.onLeaveRoom);
   this.socket.on('update-document', this.onReceiveRemoteOperations);
+
+  // doc replaced
+  this.socket.on('doc-replaced', this.receiveDocumentReplaced);
+  this.socket.on('doc-replaced-error', this.receiveDocumentReplacedError);
+
+  // doc published
+  this.socket.on('doc-published', this.receivePublishDocument);
+  this.socket.on('doc-published-error', this.receivePublishDocumentError);
+
+  // doc removed
+  this.socket.on('doc-removed', this.receiveRemoveDocument);
+  this.socket.on('doc-removed-error', this.receiveRemoveDocumentError);
   this.socket.on('update-cursor', this.receiveCursorLocation);
   this.socket.io.on('reconnect', this.onReconnect);
   this.socket.io.on('reconnect_attempt', this.onReconnectAttempt);

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

@@ -7,6 +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';
 
 //  idle --> sending --> conflict --> idle
 //       --> conflict --> idle
@@ -19,13 +20,43 @@ var STATE = {
   DISCONNECT: 'disconnect',
   NEED_RELOAD: 'need_reload'
 };
-var SocketManager = /*#__PURE__*/_createClass(function SocketManager(editor, document, config) {
+var SocketManager = /*#__PURE__*/_createClass(function SocketManager(editor, _document, config) {
   var _this = this;
   _classCallCheck(this, SocketManager);
   this.getDocumentVersion = function () {
     var version = _this.document.version;
     return version;
   };
+  this.sendPublishDocument = function (originDocUuid, originDocName, callback) {
+    _this.socketClient.sendPublishDocument(originDocUuid, originDocName, callback);
+  };
+  this.receivePublishDocument = function () {
+    _this.eventBus.dispatch(EXTERNAL_EVENT.PUBLISH_DOCUMENT);
+  };
+  this.receivePublishDocumentError = function () {
+    _this.eventBus.dispatch(EXTERNAL_EVENT.PUBLISH_DOCUMENT_ERROR);
+  };
+  this.receiveRemoveDocument = function () {
+    _this.eventBus.dispatch(EXTERNAL_EVENT.REMOVE_DOCUMENT);
+  };
+  this.receiveRemoveDocumentError = function () {
+    _this.eventBus.dispatch(EXTERNAL_EVENT.REMOVE_DOCUMENT_ERROR);
+  };
+  this.sendReplaceDocument = function (document) {
+    _this.socketClient.sendReplaceDocument(document, function (result) {
+      var serverVersion = result.version;
+      _this.document['version'] = serverVersion;
+    });
+  };
+  this.receiveDocumentReplaced = function () {
+    _this.eventBus.dispatch(EXTERNAL_EVENT.DOCUMENT_REPLACED);
+  };
+  this.receiveDocumentReplacedError = function () {
+    _this.eventBus.dispatch(EXTERNAL_EVENT.DOCUMENT_REPLACED_ERROR);
+  };
+  this.sendSaveDocument = function (callback) {
+    _this.socketClient.sendSaveDocument(callback);
+  };
   this.onReceiveLocalOperations = function (operations) {
     _this.pendingOperationList.push(operations);
     if (_this.pendingOperationList.length > 5) {
@@ -34,6 +65,7 @@ var SocketManager = /*#__PURE__*/_createClass(function SocketManager(editor, doc
     _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;
@@ -292,7 +324,7 @@ var SocketManager = /*#__PURE__*/_createClass(function SocketManager(editor, doc
     _this.socketClient.disconnectWithServer();
   };
   this.editor = editor;
-  this.document = document;
+  this.document = _document;
   this.socketClient = new SocketClient(config);
   this.pendingOperationList = []; // Two-dimensional arrays： [operations, operations, ...]
   this.remoteOperationsList = []; // Same with pending operations

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

@@ -1,3 +1,4 @@
+import { MODE } from '../../constants';
 import { generateCursorData } from '../cursor/helper';
 import EventBus from '../utils/event-bus';
 import SocketManager from './socket-manager';
@@ -19,28 +20,55 @@ var withSocketIO = function withSocketIO(editor, options) {
     SocketManager.destroy();
   };
   newEditor.onChange = function () {
-    if (newEditor.readonly) return;
+    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) {
         return operation.type === 'set_selection';
       });
-      var _socketManager = SocketManager.getInstance();
+      var _socketManager = SocketManager.getInstance(newEditor, document, config);
       if (!isAllSetSelection) {
-        // get update content value operations
-        var updateOperations = operations.filter(function (operation) {
-          return operation.type !== 'set_selection';
-        });
-        _socketManager.onReceiveLocalOperations(updateOperations);
+        if (newEditor.mode === MODE.EDITOR) {
+          // get update content value operations
+          var updateOperations = operations.filter(function (operation) {
+            return operation.type !== 'set_selection';
+          });
+          _socketManager.onReceiveLocalOperations(updateOperations);
+        }
       }
-      _socketManager.sendCursorLocation(editor.selection);
+      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');
     }
-
-    // dispatch editor change event
-    var eventBus = EventBus.getInstance();
-    eventBus.dispatch('change');
     onChange();
   };
+  newEditor.rebaseContent = function (document, originFileVersion) {
+    var config = options.config;
+    var socketManager = SocketManager.getInstance(newEditor, document, config);
+    socketManager.sendRebaseContent(document, originFileVersion);
+  };
+  newEditor.publishDocument = function (originDocUuid, originDocName, callback) {
+    var config = options.config;
+    var socketManager = SocketManager.getInstance(newEditor, document, config);
+    socketManager.sendPublishDocument(originDocUuid, originDocName, callback);
+  };
+  newEditor.replaceDocument = function (document) {
+    var config = options.config;
+    var socketManager = SocketManager.getInstance(newEditor, document, config);
+    socketManager.sendReplaceDocument(document);
+  };
+  newEditor.saveDocument = function (callback) {
+    var config = options.config;
+    var socketManager = SocketManager.getInstance(newEditor, document, config);
+    socketManager.sendSaveDocument(callback);
+  };
   return newEditor;
 };
 export default withSocketIO;

package/dist/basic-sdk/utils/diff.js

@@ -2,13 +2,13 @@ import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import slugid from 'slugid';
-import { ELEMENT_TYPE, ADDED_STYLE, DELETED_STYLE } from '../../basic-sdk/extension/constants';
+import { ELEMENT_TYPE, ADDED_STYLE, DELETED_STYLE, TEXT_STYLE_MAP } from '../../basic-sdk/extension/constants';
 import ObjectUtils from './object-utils';
 import DiffText from './diff-text';
 import { normalizeChildren } from './document-utils';
 
 // ignore
-var IGNORE_KEYS = ['BOLD', 'ITALIC', 'columns', 'minHeight', 'language', 'white_space'];
+var IGNORE_KEYS = ['BOLD', 'ITALIC', 'bold', 'italic', 'columns', 'minHeight', 'min_height', 'language', 'white_space'];
 var generatorDiffTextElement = function generatorDiffTextElement(textElement, diffType) {
   var style = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   if (!textElement) return null;
@@ -31,7 +31,7 @@ var generatorDiffElement = function generatorDiffElement(element, diffType) {
     return generatorDiffElement(item, diffType, style);
   })), _objectSpread3));
 };
-var generateIdMapAndIds = function generateIdMapAndIds(elements) {
+export var generateIdMapAndIds = function generateIdMapAndIds(elements) {
   var map = {};
   var ids = [];
   if (!Array.isArray(elements) || elements.length === 0) return {
@@ -54,7 +54,7 @@ var hasChildren = function hasChildren(element) {
 };
 
 // id diffs
-var getIdDiffs = function getIdDiffs(oldIds, newIds) {
+export var getIdDiffs = function getIdDiffs(oldIds, newIds) {
   var diff = new DiffText(oldIds, newIds);
   return diff.getDiffs();
 };
@@ -74,11 +74,11 @@ var getTextDiff = function getTextDiff(element, oldElement, diff) {
     };
     if (item.added) {
       diff.changes.push(id);
-      var commonChild = generatorDiffTextElement(elementItem, 'ADD', ADDED_STYLE);
+      var commonChild = generatorDiffTextElement(elementItem, TEXT_STYLE_MAP.ADD, ADDED_STYLE);
       newChildren.push(commonChild);
     } else if (item.removed) {
       diff.changes.push(id);
-      var _commonChild = generatorDiffTextElement(elementItem, 'DELETE', DELETED_STYLE);
+      var _commonChild = generatorDiffTextElement(elementItem, TEXT_STYLE_MAP.DELETE, DELETED_STYLE);
       newChildren.push(_commonChild);
     } else {
       var _commonChild2 = generatorDiffTextElement(elementItem);
@@ -99,9 +99,9 @@ var getCommonDiff = function getCommonDiff(element, oldElement, diff) {
     diff.changes.push("".concat(elementId, "_delete"));
     return [generatorDiffElement(_objectSpread(_objectSpread({}, oldElement), {}, {
       id: "".concat(elementId, "_delete")
-    }), 'DELETE', DELETED_STYLE), generatorDiffElement(_objectSpread(_objectSpread({}, element), {}, {
+    }), TEXT_STYLE_MAP.DELETE, DELETED_STYLE), generatorDiffElement(_objectSpread(_objectSpread({}, element), {}, {
       id: "".concat(elementId, "_add")
-    }), 'ADD', ADDED_STYLE)];
+    }), TEXT_STYLE_MAP.ADD, ADDED_STYLE)];
   }
 
   // Content does not change
@@ -129,10 +129,10 @@ var getCommonDiff = function getCommonDiff(element, oldElement, diff) {
       var oldChildrenElement = oldMap[id];
       if (isAdded) {
         diff.changes.push(id);
-        newChildren.push(generatorDiffElement(newChildrenElement, 'ADD', ADDED_STYLE));
+        newChildren.push(generatorDiffElement(newChildrenElement, TEXT_STYLE_MAP.ADD, ADDED_STYLE));
       } else if (isDelete) {
         diff.changes.push(id);
-        newChildren.push(generatorDiffElement(oldChildrenElement, 'DELETE', DELETED_STYLE));
+        newChildren.push(generatorDiffElement(oldChildrenElement, TEXT_STYLE_MAP.DELETE, DELETED_STYLE));
       } else {
         if (ObjectUtils.isSameObject(newChildrenElement, oldChildrenElement, IGNORE_KEYS)) {
           newChildren.push(newChildrenElement);
@@ -147,10 +147,10 @@ var getCommonDiff = function getCommonDiff(element, oldElement, diff) {
               } else {
                 newChildren.push(generatorDiffTextElement(_objectSpread(_objectSpread({}, element), {}, {
                   id: element.id + '_add'
-                }), 'ADD', ADDED_STYLE));
+                }), TEXT_STYLE_MAP.ADD, ADDED_STYLE));
                 newChildren.push(generatorDiffTextElement(_objectSpread(_objectSpread({}, oldChildrenElement), {}, {
                   id: element.id + '_delete'
-                }), 'DELETE', DELETED_STYLE));
+                }), TEXT_STYLE_MAP.DELETE, DELETED_STYLE));
               }
             } else if (newChildrenElement.type === ELEMENT_TYPE.LINK) {
               if (newChildrenElement.title !== oldChildrenElement.title) {
@@ -160,10 +160,10 @@ var getCommonDiff = function getCommonDiff(element, oldElement, diff) {
                 diff.changes.push(oldChildrenElement.id + '_delete');
                 newChildren.push(generatorDiffTextElement(_objectSpread(_objectSpread({}, oldChildrenElement), {}, {
                   id: oldChildrenElement.id + '_delete'
-                }), 'DELETE', DELETED_STYLE));
+                }), TEXT_STYLE_MAP.DELETE, DELETED_STYLE));
                 newChildren.push(generatorDiffTextElement(_objectSpread(_objectSpread({}, newChildrenElement), {}, {
                   id: newChildrenElement.id + '_add'
-                }), 'ADD', ADDED_STYLE));
+                }), TEXT_STYLE_MAP.ADD, ADDED_STYLE));
               } else {
                 newChildren.push(newChildrenElement);
               }
@@ -178,10 +178,10 @@ var getCommonDiff = function getCommonDiff(element, oldElement, diff) {
             diff.changes.push(oldChildrenElement.id + '_delete');
             newChildren.push(generatorDiffTextElement(_objectSpread(_objectSpread({}, oldChildrenElement), {}, {
               id: oldChildrenElement.id + '_delete'
-            }), 'DELETE', DELETED_STYLE));
+            }), TEXT_STYLE_MAP.DELETE, DELETED_STYLE));
             newChildren.push(generatorDiffTextElement(_objectSpread(_objectSpread({}, newChildrenElement), {}, {
               id: newChildrenElement.id + '_add'
-            }), 'ADD', ADDED_STYLE));
+            }), TEXT_STYLE_MAP.ADD, ADDED_STYLE));
           }
         }
       }
@@ -228,14 +228,14 @@ var getElementDiffValue = function getElementDiffValue(currentContent, oldConten
       elementIds.forEach(function (elementId) {
         diff.changes.push(elementId);
         var element = oldContentMap[elementId];
-        var diffElement = generatorDiffElement(element, 'DELETE', DELETED_STYLE);
+        var diffElement = generatorDiffElement(element, TEXT_STYLE_MAP.DELETE, DELETED_STYLE);
         diff.value.push(diffElement);
       });
     } else if (diffItem.added) {
       elementIds.forEach(function (elementId) {
         diff.changes.push(elementId);
         var element = currentContentMap[elementId];
-        var diffElement = generatorDiffElement(element, 'ADD', ADDED_STYLE);
+        var diffElement = generatorDiffElement(element, TEXT_STYLE_MAP.ADD, ADDED_STYLE);
         diff.value.push(diffElement);
       });
     } else {
@@ -288,4 +288,5 @@ export var getDiff = function getDiff() {
     changes: []
   };
   return getElementDiffValue(currentContent, oldContent);
-};
+};
+window.getIdDiffs = getIdDiffs;

package/dist/basic-sdk/utils/rebase.js

@@ -0,0 +1,193 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { generateIdMapAndIds, getIdDiffs } from './diff';
+import ObjectUtils from './object-utils';
+import { MODIFY_TYPE, REBASE_TYPE, REBASE_MARK_KEY, REBASE_ORIGIN } from '../constants';
+import { ELEMENT_TYPE } from '../extension/constants';
+import { replaceNodeId } from '../node-id/helpers';
+export var hasConflict = function hasConflict(content) {
+  if (!Array.isArray(content) || content.length === 0) return false;
+  return content.filter(function (item) {
+    return item.rebase_type;
+  }).length !== 0;
+};
+var getChanges = function getChanges(masterContent, revisionContent) {
+  var _generateIdMapAndIds = generateIdMapAndIds(masterContent.children),
+    masterContentMap = _generateIdMapAndIds.map,
+    masterIds = _generateIdMapAndIds.ids;
+  var _generateIdMapAndIds2 = generateIdMapAndIds(revisionContent.children),
+    currentContentMap = _generateIdMapAndIds2.map,
+    currentIds = _generateIdMapAndIds2.ids;
+  var idDiffs = getIdDiffs(masterIds, currentIds);
+  var content = [];
+  idDiffs.forEach(function (idDiff) {
+    var value = idDiff.value,
+      added = idDiff.added,
+      removed = idDiff.removed;
+    if (added) {
+      var addedList = value.map(function (item) {
+        return _objectSpread(_objectSpread({}, currentContentMap[item]), {}, _defineProperty({}, REBASE_MARK_KEY.MODIFY_TYPE, MODIFY_TYPE.ADD));
+      });
+      content.push.apply(content, _toConsumableArray(addedList));
+    } else if (removed) {
+      var deletedList = value.map(function (item) {
+        return _objectSpread(_objectSpread({}, masterContentMap[item]), {}, _defineProperty({}, REBASE_MARK_KEY.MODIFY_TYPE, MODIFY_TYPE.DELETE));
+      });
+      content.push.apply(content, _toConsumableArray(deletedList));
+    } else {
+      value.forEach(function (elementId) {
+        if (ObjectUtils.isSameObject(masterContentMap[elementId], currentContentMap[elementId])) {
+          content.push(currentContentMap[elementId]);
+        } else {
+          var _objectSpread4;
+          var oldElement = masterContentMap[elementId];
+          var currentElement = currentContentMap[elementId];
+          var newElement = _objectSpread(_objectSpread({}, currentElement), {}, (_objectSpread4 = {}, _defineProperty(_objectSpread4, REBASE_MARK_KEY.MODIFY_TYPE, MODIFY_TYPE.MODIFY), _defineProperty(_objectSpread4, REBASE_MARK_KEY.OLD_ELEMENT, oldElement), _objectSpread4));
+          if (currentElement.type === oldElement.type) {
+            var elementType = currentElement.type;
+            if ([ELEMENT_TYPE.UNORDERED_LIST, ELEMENT_TYPE.ORDERED_LIST].includes(elementType)) {
+              var listContent = getChanges(oldElement, currentElement);
+              newElement[REBASE_MARK_KEY.MODIFY_TYPE] = MODIFY_TYPE.CHILDREN_MODIFY;
+              newElement['children'] = listContent;
+            }
+          }
+          content.push(newElement);
+        }
+      });
+    }
+  });
+  return content;
+};
+var getMergeElement = function getMergeElement(diffElement, basicElement) {
+  var modifyType = diffElement[REBASE_MARK_KEY.MODIFY_TYPE];
+  var newElement = _objectSpread({}, diffElement);
+  newElement[REBASE_MARK_KEY.MODIFY_TYPE] && delete newElement[REBASE_MARK_KEY.MODIFY_TYPE];
+
+  // revision does not have this element, master has this element
+  if (modifyType === MODIFY_TYPE.DELETE) {
+    // basic content does not have this element, indicating that it is newly added by master and needs to be retained, and will not be counted as a conflict.
+    if (!basicElement) return [newElement];
+
+    // basic content has this element, master modified it, indicating that revision deleted it, and the user manually selected the conflict
+    if (!ObjectUtils.isSameObject(basicElement, diffElement, [REBASE_MARK_KEY.MODIFY_TYPE])) {
+      newElement[REBASE_MARK_KEY.REBASE_TYPE] = REBASE_TYPE.MODIFY_DELETE;
+      return [newElement];
+    }
+
+    // basic content has this element, but master has not modified it. It means that revision has deleted it and the program has deleted it. The conflict will not be counted.
+    return [];
+  }
+
+  // revision has this element, master does not have this element
+  if (modifyType === MODIFY_TYPE.ADD) {
+    // basic content does not have this element, indicating that it is newly added by revision and needs to be retained, and will not be counted as a conflict.
+    if (!basicElement) return [newElement];
+
+    // master deleted it, revision modified it, and the user manually selected the conflict
+    if (!ObjectUtils.isSameObject(basicElement, diffElement, [REBASE_MARK_KEY.MODIFY_TYPE])) {
+      newElement[REBASE_MARK_KEY.REBASE_TYPE] = REBASE_TYPE.DELETE_MODIFY;
+      return [newElement];
+    }
+
+    // master deleted it, revision did not modify it, the program deleted it, and the conflict is not counted.
+    return [];
+  }
+
+  // Elements that differ between revision and master
+  if (modifyType === MODIFY_TYPE.MODIFY) {
+    var _objectSpread7, _objectSpread8;
+    var masterElement = _objectSpread({}, diffElement[REBASE_MARK_KEY.OLD_ELEMENT]);
+    delete newElement[REBASE_MARK_KEY.OLD_ELEMENT];
+
+    // revision and master both add a new element, but the content is different. ===》 At present, this situation does not exist, it only exists in the theoretical stage.
+    if (!basicElement) {
+      var _objectSpread5, _objectSpread6;
+      return [_objectSpread(_objectSpread({}, replaceNodeId(masterElement)), {}, (_objectSpread5 = {}, _defineProperty(_objectSpread5, REBASE_MARK_KEY.REBASE_TYPE, REBASE_TYPE.MODIFY_MODIFY), _defineProperty(_objectSpread5, REBASE_MARK_KEY.OLD_ELEMENT, masterElement), _defineProperty(_objectSpread5, REBASE_MARK_KEY.ORIGIN, REBASE_ORIGIN.OTHER), _objectSpread5)), _objectSpread(_objectSpread({}, newElement), {}, (_objectSpread6 = {}, _defineProperty(_objectSpread6, REBASE_MARK_KEY.REBASE_TYPE, REBASE_TYPE.MODIFY_MODIFY), _defineProperty(_objectSpread6, REBASE_MARK_KEY.ORIGIN, REBASE_ORIGIN.MY), _objectSpread6))];
+    }
+
+    // master is the same as base, indicating that revision has modified the content
+    if (ObjectUtils.isSameObject(masterElement, basicElement)) return [newElement];
+
+    // revision is the same as base, indicating that master has modified the content
+    if (ObjectUtils.isSameObject(newElement, basicElement)) return [masterElement];
+
+    // They are all different. Revision and master were modified at the same time. If there is a conflict, the conflict needs to be resolved manually.
+    return [_objectSpread(_objectSpread({}, replaceNodeId(masterElement)), {}, (_objectSpread7 = {}, _defineProperty(_objectSpread7, REBASE_MARK_KEY.REBASE_TYPE, REBASE_TYPE.MODIFY_MODIFY), _defineProperty(_objectSpread7, REBASE_MARK_KEY.OLD_ELEMENT, masterElement), _defineProperty(_objectSpread7, REBASE_MARK_KEY.ORIGIN, REBASE_ORIGIN.OTHER), _objectSpread7)), _objectSpread(_objectSpread({}, newElement), {}, (_objectSpread8 = {}, _defineProperty(_objectSpread8, REBASE_MARK_KEY.REBASE_TYPE, REBASE_TYPE.MODIFY_MODIFY), _defineProperty(_objectSpread8, REBASE_MARK_KEY.ORIGIN, REBASE_ORIGIN.MY), _objectSpread8))];
+  }
+  if (modifyType === MODIFY_TYPE.CHILDREN_MODIFY) {
+    var _masterElement = _objectSpread({}, diffElement[REBASE_MARK_KEY.OLD_ELEMENT]);
+    delete newElement[REBASE_MARK_KEY.OLD_ELEMENT];
+
+    // revision and master both add a new element, but the content is different. ===》 At present, this situation does not exist, it only exists in the theoretical stage.
+    if (!basicElement) {
+      var _objectSpread9, _objectSpread10;
+      return [_objectSpread(_objectSpread({}, replaceNodeId(_masterElement)), {}, (_objectSpread9 = {}, _defineProperty(_objectSpread9, REBASE_MARK_KEY.REBASE_TYPE, REBASE_TYPE.MODIFY_MODIFY), _defineProperty(_objectSpread9, REBASE_MARK_KEY.OLD_ELEMENT, _masterElement), _defineProperty(_objectSpread9, REBASE_MARK_KEY.ORIGIN, REBASE_ORIGIN.OTHER), _objectSpread9)), _objectSpread(_objectSpread({}, newElement), {}, (_objectSpread10 = {}, _defineProperty(_objectSpread10, REBASE_MARK_KEY.REBASE_TYPE, REBASE_TYPE.MODIFY_MODIFY), _defineProperty(_objectSpread10, REBASE_MARK_KEY.ORIGIN, REBASE_ORIGIN.MY), _objectSpread10))];
+    }
+    if (ObjectUtils.isSameObject(_masterElement, basicElement)) return [newElement];
+    if (ObjectUtils.isSameObject(newElement, basicElement)) return [_masterElement];
+    if (ObjectUtils.isSameObject(_masterElement, newElement, ['type'])) {
+      if (ObjectUtils.isSameObject(_masterElement, basicElement, ['type'])) return [newElement];
+      if (ObjectUtils.isSameObject(newElement, basicElement, ['type'])) return [_masterElement];
+    }
+
+    // The content of the subnode has changed and needs to be solved manually.
+    var _getMergeContent = getMergeContent(basicElement, diffElement.children),
+      childrenContent = _getMergeContent.content;
+    return [_objectSpread(_objectSpread({}, newElement), {}, _defineProperty({
+      children: childrenContent
+    }, REBASE_MARK_KEY.REBASE_TYPE, REBASE_TYPE.CHILDREN_MODIFY))];
+  }
+  newElement[REBASE_MARK_KEY.OLD_ELEMENT] && delete newElement[REBASE_MARK_KEY.OLD_ELEMENT];
+  return [newElement];
+};
+var getMergeContent = function getMergeContent(basicContent, diffChanges) {
+  var _generateIdMapAndIds3 = generateIdMapAndIds(diffChanges),
+    diffChangesContentMap = _generateIdMapAndIds3.map,
+    diffChangesContentIds = _generateIdMapAndIds3.ids;
+  var _generateIdMapAndIds4 = generateIdMapAndIds(basicContent.children),
+    baseContentMap = _generateIdMapAndIds4.map;
+  var content = [];
+  diffChangesContentIds.forEach(function (elementId) {
+    var diffElement = diffChangesContentMap[elementId];
+    var basicElement = baseContentMap[elementId];
+    var mergeElements = getMergeElement(diffElement, basicElement);
+    content.push.apply(content, _toConsumableArray(mergeElements));
+  });
+  var canMerge = !hasConflict(content);
+  return {
+    content: content,
+    canMerge: canMerge
+  };
+};
+export var getRebase = function getRebase(masterContent, basicContent, revisionContent) {
+  // master no changes, merged directly
+  if (masterContent.version === basicContent.version) {
+    return {
+      canMerge: true,
+      isNeedReplaceMaster: true,
+      value: revisionContent
+    };
+  }
+
+  // The revision content has not changed
+  if (basicContent.version === revisionContent.version) {
+    return {
+      canMerge: true,
+      isNeedReplaceMaster: false,
+      value: masterContent
+    };
+  }
+  var diffChanges = getChanges(masterContent, revisionContent);
+  var _getMergeContent2 = getMergeContent(basicContent, diffChanges),
+    canMerge = _getMergeContent2.canMerge,
+    content = _getMergeContent2.content;
+  return {
+    canMerge: canMerge,
+    isNeedReplaceMaster: true,
+    value: _objectSpread(_objectSpread({}, revisionContent), {}, {
+      children: content,
+      version: Math.max(masterContent.version, revisionContent.version) + 1
+    })
+  };
+};

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

@@ -6,7 +6,8 @@ import { ELEMENT_TYPE, ADDED_STYLE, DELETED_STYLE } from '../extension/constants
 import SDocViewer from './viewer';
 import '../../assets/css/diff-viewer.css';
 var DiffViewer = function DiffViewer(_ref) {
-  var currentContent = _ref.currentContent,
+  var editor = _ref.editor,
+    currentContent = _ref.currentContent,
     lastContent = _ref.lastContent,
     didMountCallback = _ref.didMountCallback,
     showToolbar = _ref.showToolbar,
@@ -38,6 +39,7 @@ var DiffViewer = function DiffViewer(_ref) {
     return renderElement(props, editor);
   }, []);
   return /*#__PURE__*/React.createElement(SDocViewer, {
+    editor: editor,
     showToolbar: showToolbar,
     showOutline: showOutline,
     document: {

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

@@ -1,4 +1,4 @@
-import React, { Fragment, useMemo } from 'react';
+import React, { Fragment } from 'react';
 import { Editable, Slate } from '@seafile/slate-react';
 import { renderLeaf as _renderLeaf, renderElement as _renderElement, createDefaultEditor } from '../extension';
 import withNodeId from '../node-id';
@@ -8,18 +8,15 @@ import { usePipDecorate } from '../decorates';
 import { ArticleContainer, EditorContainer, EditorContent } from '../layout';
 import '../assets/css/simple-viewer.css';
 var SDocViewer = function SDocViewer(_ref) {
-  var document = _ref.document,
+  var editor = _ref.editor,
+    document = _ref.document,
     customRenderLeaf = _ref.renderLeaf,
     customRenderElement = _ref.renderElement,
     showToolbar = _ref.showToolbar,
     showOutline = _ref.showOutline;
-  var editor = useMemo(function () {
-    var defaultEditor = createDefaultEditor();
-    return withNodeId(defaultEditor);
-  }, []);
-  editor.readonly = true;
+  var validEditor = editor || withNodeId(createDefaultEditor());
   var slateValue = (document || generateDefaultDocContent()).children;
-  var decorate = usePipDecorate(editor);
+  var decorate = usePipDecorate(validEditor);
   return /*#__PURE__*/React.createElement(EditorContainer, {
     editor: editor,
     showToolbar: showToolbar,
@@ -29,19 +26,19 @@ var SDocViewer = function SDocViewer(_ref) {
     readonly: true,
     showOutline: showOutline
   }, /*#__PURE__*/React.createElement(Slate, {
-    editor: editor,
+    editor: validEditor,
     value: slateValue
   }, /*#__PURE__*/React.createElement(ArticleContainer, {
-    editor: editor,
+    editor: validEditor,
     readOnly: true
   }, /*#__PURE__*/React.createElement(Fragment, null, /*#__PURE__*/React.createElement(SetNodeToDecorations, null), /*#__PURE__*/React.createElement(Editable, {
     readOnly: true,
     placeholder: "",
     renderElement: function renderElement(props) {
-      return (customRenderElement || _renderElement)(props, editor);
+      return (customRenderElement || _renderElement)(props, validEditor);
     },
     renderLeaf: function renderLeaf(props) {
-      return (customRenderLeaf || _renderLeaf)(props, editor);
+      return (customRenderLeaf || _renderLeaf)(props, validEditor);
     },
     onDOMBeforeInput: function onDOMBeforeInput(event) {},
     decorate: decorate

package/dist/components/doc-operations/index.js

@@ -11,14 +11,16 @@ import './style.css';
 var DocOperations = function DocOperations(_ref) {
   var isShowChanges = _ref.isShowChanges,
     changes = _ref.changes,
-    toggleViewChanges = _ref.toggleViewChanges;
+    toggleViewChanges = _ref.toggleViewChanges,
+    publishRevision = _ref.publishRevision;
   var isSdocRevision = context.getSetting('isSdocRevision');
   return /*#__PURE__*/React.createElement("div", {
     className: "doc-ops"
   }, /*#__PURE__*/React.createElement(RevisionOperations, {
     isShowChanges: isShowChanges,
     changes: changes,
-    toggleViewChanges: toggleViewChanges
+    toggleViewChanges: toggleViewChanges,
+    publishRevision: publishRevision
   }), /*#__PURE__*/React.createElement(CommentsOperation, null), !isSdocRevision && /*#__PURE__*/React.createElement(ShareOperation, null), /*#__PURE__*/React.createElement(HistoryOperation, null), /*#__PURE__*/React.createElement(CollaboratorsOperation, null), !isSdocRevision && /*#__PURE__*/React.createElement(MoreOperations, null));
 };
 export default withTranslation('sdoc-editor')(DocOperations);

package/dist/components/doc-operations/revision-operations/index.js

@@ -8,7 +8,8 @@ import ChangesCount from './changes-count';
 var RevisionOperations = function RevisionOperations(_ref) {
   var isShowChanges = _ref.isShowChanges,
     changes = _ref.changes,
-    toggleViewChanges = _ref.toggleViewChanges;
+    toggleViewChanges = _ref.toggleViewChanges,
+    publishRevision = _ref.publishRevision;
   var isSdocRevision = context.getSetting('isSdocRevision');
   var isPublished = context.getSetting('isPublished');
   return /*#__PURE__*/React.createElement(React.Fragment, null, !isSdocRevision && /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(MoreRevisionOperations, null), /*#__PURE__*/React.createElement(Revisions, null)), isSdocRevision && isShowChanges && /*#__PURE__*/React.createElement(ChangesCount, {
@@ -16,6 +17,8 @@ var RevisionOperations = function RevisionOperations(_ref) {
   }), isSdocRevision && /*#__PURE__*/React.createElement(ViewChanges, {
     isShowChanges: isShowChanges,
     toggleViewChanges: toggleViewChanges
-  }), isSdocRevision && !isPublished && /*#__PURE__*/React.createElement(PublishRevision, null));
+  }), isSdocRevision && !isPublished && /*#__PURE__*/React.createElement(PublishRevision, {
+    publishRevision: publishRevision
+  }));
 };
 export default RevisionOperations;