@seafile/sdoc-editor 0.1.148 → 0.1.149-beta1

package/dist/basic-sdk/extension/render/render-element.js

@@ -1,10 +1,16 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import React, { useCallback } from 'react';
 import { useSlateStatic } from '@seafile/slate-react';
+import { Transforms } from '@seafile/slate';
+import deepCopy from 'deep-copy';
+import { useTranslation } from 'react-i18next';
 import { BLOCKQUOTE, LINK, CHECK_LIST_ITEM, HEADER1, HEADER2, HEADER3, HEADER4, HEADER5, HEADER6, LIST_ITEM, LIST_LIC, ORDERED_LIST, PARAGRAPH, UNORDERED_LIST, CODE_BLOCK, CODE_LINE, IMAGE, ELEMENT_TYPE, SDOC_LINK, TITLE, SUBTITLE } from '../constants';
 import { BlockquotePlugin, LinkPlugin, CheckListPlugin, HeaderPlugin, ListPlugin, CodeBlockPlugin, ImagePlugin, TablePlugin, SdocLinkPlugin, ParagraphPlugin } from '../plugins';
 import EventBus from '../../utils/event-bus';
-import { INTERNAL_EVENT } from '../../constants';
+import { INTERNAL_EVENT, REBASE_TYPE, REBASE_MARKS, REBASE_MARK_KEY } from '../../constants';
+import { findPath, getNode, replaceNode, generateEmptyElement, deleteNodeMark } from '../../extension/core';
 var CustomElement = function CustomElement(props) {
   var editor = useSlateStatic();
   var element = props.element,
@@ -140,6 +146,212 @@ var CustomElement = function CustomElement(props) {
   }
 };
 var RenderElement = function RenderElement(props) {
+  var editor = useSlateStatic();
+  var _useTranslation = useTranslation(),
+    t = _useTranslation.t;
+  var updateParentNodeByPath = useCallback(function (path) {
+    var parentPath = path.slice(0, -1);
+    var parentNode = getNode(editor, parentPath);
+    if (parentNode.children.filter(function (item) {
+      return item[REBASE_MARK_KEY.REBASE_TYPE];
+    }).length === 0) {
+      var newParentElement = _objectSpread({}, parentNode);
+      newParentElement[REBASE_MARK_KEY.REBASE_TYPE] && delete newParentElement[REBASE_MARK_KEY.REBASE_TYPE];
+      newParentElement[REBASE_MARK_KEY.OLD_ELEMENT] && delete newParentElement[REBASE_MARK_KEY.OLD_ELEMENT];
+      newParentElement[REBASE_MARK_KEY.ORIGIN] && delete newParentElement[REBASE_MARK_KEY.ORIGIN];
+      newParentElement['children'] = newParentElement['children'].map(function (item) {
+        item[REBASE_MARK_KEY.REBASE_TYPE] && delete item[REBASE_MARK_KEY.REBASE_TYPE];
+        item[REBASE_MARK_KEY.OLD_ELEMENT] && delete item[REBASE_MARK_KEY.OLD_ELEMENT];
+        item[REBASE_MARK_KEY.ORIGIN] && delete item[REBASE_MARK_KEY.ORIGIN];
+        return item;
+      });
+      replaceNode(editor, {
+        at: parentPath,
+        nodes: newParentElement
+      });
+    }
+
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [editor]);
+  var deleteElement = useCallback(function (element) {
+    var path = findPath(editor, element);
+    Transforms.removeNodes(editor, {
+      at: path
+    });
+    if (element.type === ELEMENT_TYPE.LIST_ITEM) {
+      updateParentNodeByPath(path);
+    }
+
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [editor]);
+  var deleteMark = useCallback(function (element) {
+    var path = findPath(editor, element);
+    deleteNodeMark(editor, path, element, REBASE_MARKS);
+    if (element.type === ELEMENT_TYPE.LIST_ITEM) {
+      updateParentNodeByPath(path);
+    }
+
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [editor]);
+  var addDeletedElement = useCallback(function (element) {
+    var path = findPath(editor, element);
+    deleteNodeMark(editor, path, element, REBASE_MARKS);
+    if (element.type !== ELEMENT_TYPE.LIST_ITEM) {
+      var emptyNode = generateEmptyElement(ELEMENT_TYPE.PARAGRAPH);
+      Transforms.insertNodes(editor, emptyNode, {
+        at: [path[0]]
+      });
+    } else {
+      var _emptyNode = generateEmptyElement(ELEMENT_TYPE.LIST_ITEM);
+      _emptyNode.children[0] = generateEmptyElement(ELEMENT_TYPE.LIST_LIC);
+      var parentPath = path.slice(0, -1);
+      var parentNode = getNode(editor, parentPath);
+      var newChildren = _toConsumableArray(parentNode.children);
+      var index = path[path.length - 1];
+      newChildren.splice(index, 0, _emptyNode);
+      replaceNode(editor, {
+        at: parentPath,
+        nodes: _objectSpread(_objectSpread({}, parentNode), {}, {
+          children: newChildren
+        })
+      });
+    }
+    if (element.type === ELEMENT_TYPE.LIST_ITEM) {
+      updateParentNodeByPath(path);
+    }
+
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [editor]);
+  var useMasterChanges = useCallback(function (element) {
+    var path = findPath(editor, element);
+    deleteNodeMark(editor, path, element[REBASE_MARK_KEY.OLD_ELEMENT], REBASE_MARKS);
+    var nextElementPath = _toConsumableArray(path);
+    nextElementPath[path.length - 1] = path[path.length - 1] + 1;
+    Transforms.removeNodes(editor, {
+      at: nextElementPath
+    });
+    if (element.type === ELEMENT_TYPE.LIST_ITEM) {
+      updateParentNodeByPath(path);
+    }
+
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [editor]);
+  var useCurrentChanges = useCallback(function (element) {
+    var path = findPath(editor, element);
+    var currentElementPath = _toConsumableArray(path);
+    currentElementPath[path.length - 1] = path[path.length - 1] + 1;
+    var currentElement = getNode(editor, currentElementPath);
+    var newCurrentElement = deepCopy(currentElement);
+    deleteNodeMark(editor, currentElementPath, newCurrentElement, REBASE_MARKS);
+    Transforms.removeNodes(editor, {
+      at: path
+    });
+    if (element.type === ELEMENT_TYPE.LIST_ITEM) {
+      updateParentNodeByPath(path);
+    }
+
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [editor]);
+  var useBothChanges = useCallback(function (element) {
+    // delete element marks
+    var path = findPath(editor, element);
+    deleteNodeMark(editor, path, element, REBASE_MARKS);
+
+    // delete next element marks
+    var nextElementPath = [].concat(_toConsumableArray(path.slice(0, -1)), [path[path.length - 1] + 1]);
+    var nextElement = getNode(editor, nextElementPath);
+    deleteNodeMark(editor, nextElementPath, nextElement, REBASE_MARKS);
+    if (element.type === ELEMENT_TYPE.LIST_ITEM) {
+      updateParentNodeByPath(path);
+    }
+
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [editor]);
+  var element = props.element;
+  var rebaseType = element[REBASE_MARK_KEY.REBASE_TYPE];
+  if (!rebaseType) {
+    return /*#__PURE__*/React.createElement(CustomElement, props);
+  }
+  if (rebaseType === REBASE_TYPE.DELETE_MODIFY) {
+    return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("div", {
+      className: "w-100 d-flex sdoc-rebase-btn-group",
+      contentEditable: false
+    }, /*#__PURE__*/React.createElement("div", {
+      className: "sdoc-rebase-btn",
+      onClick: function onClick() {
+        return deleteElement(element);
+      }
+    }, t('Keep_other_modification')), /*#__PURE__*/React.createElement("div", {
+      className: "mr-2 ml-2"
+    }, '|'), /*#__PURE__*/React.createElement("div", {
+      className: "sdoc-rebase-btn",
+      onClick: function onClick() {
+        return deleteMark(element);
+      }
+    }, t('Keep_my_modification')), /*#__PURE__*/React.createElement("div", {
+      className: "mr-2 ml-2"
+    }, '|'), /*#__PURE__*/React.createElement("div", {
+      className: "sdoc-rebase-btn",
+      onClick: function onClick() {
+        return addDeletedElement(element);
+      }
+    }, t('Keep_both_modification'))), /*#__PURE__*/React.createElement("div", {
+      className: "w-100 sdoc-rebase-current-changes-start",
+      contentEditable: false
+    }, '<<<<<<<'), /*#__PURE__*/React.createElement("div", {
+      className: "w-100",
+      contentEditable: false
+    }, '======='), /*#__PURE__*/React.createElement("div", {
+      className: "w-100 sdoc-rebase-incoming-changes",
+      contentEditable: false
+    }, /*#__PURE__*/React.createElement(CustomElement, props)), /*#__PURE__*/React.createElement("div", {
+      className: "w-100 sdoc-rebase-incoming-changes-end",
+      contentEditable: false
+    }, '>>>>>>>'));
+  }
+  if (rebaseType === REBASE_TYPE.MODIFY_MODIFY) {
+    if (element[REBASE_MARK_KEY.ORIGIN] === 'master') {
+      return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("div", {
+        className: "w-100 d-flex sdoc-rebase-btn-group",
+        contentEditable: false
+      }, /*#__PURE__*/React.createElement("div", {
+        className: "sdoc-rebase-btn",
+        onClick: function onClick() {
+          return useMasterChanges(element);
+        }
+      }, t('Keep_other_modification')), /*#__PURE__*/React.createElement("div", {
+        className: "mr-2 ml-2"
+      }, '|'), /*#__PURE__*/React.createElement("div", {
+        className: "sdoc-rebase-btn",
+        onClick: function onClick() {
+          return useCurrentChanges(element);
+        }
+      }, t('Keep_my_modification')), /*#__PURE__*/React.createElement("div", {
+        className: "mr-2 ml-2"
+      }, '|'), /*#__PURE__*/React.createElement("div", {
+        className: "sdoc-rebase-btn",
+        onClick: function onClick() {
+          return useBothChanges(element);
+        }
+      }, t('Keep_both_modification'))), /*#__PURE__*/React.createElement("div", {
+        className: "w-100 sdoc-rebase-current-changes-start",
+        contentEditable: false
+      }, '<<<<<<<'), /*#__PURE__*/React.createElement("div", {
+        className: "w-100 sdoc-rebase-current-changes",
+        contentEditable: false
+      }, /*#__PURE__*/React.createElement(CustomElement, props)));
+    }
+    return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("div", {
+      className: "w-100",
+      contentEditable: false
+    }, '======='), /*#__PURE__*/React.createElement("div", {
+      className: "w-100 sdoc-rebase-incoming-changes",
+      contentEditable: false
+    }, /*#__PURE__*/React.createElement(CustomElement, props)), /*#__PURE__*/React.createElement("div", {
+      className: "w-100 sdoc-rebase-incoming-changes-end",
+      contentEditable: false
+    }, '>>>>>>>'));
+  }
   return /*#__PURE__*/React.createElement(CustomElement, props);
 
   // const { element } = props;

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

@@ -4,6 +4,7 @@ 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;
@@ -252,6 +253,7 @@ 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-client.js

@@ -119,6 +119,38 @@ var SocketClient = /*#__PURE__*/_createClass(function SocketClient(config) {
   this.disconnectWithServer = function () {
     _this.socket.disconnect();
   };
+  this.sendPublishDocument = function (originDocUuid, originDocName, isNeedUpdateOriginDoc, callback) {
+    _this.socket.emit('publish-document', _this.getParams({
+      origin_doc_uuid: originDocUuid,
+      origin_doc_name: originDocName,
+      update_origin_doc: isNeedUpdateOriginDoc
+    }), function (result) {
+      callback && callback(result);
+    });
+  };
+  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.config = config;
   this.isReconnect = false;
   this.socket = io(config.sdocServer, {
@@ -133,6 +165,12 @@ 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);
+  this.socket.on('publish-document', this.receivePublishDocument);
+  this.socket.on('publish-document-error', this.receivePublishDocumentError);
   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,34 @@ 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, isNeedUpdateOriginDoc) {
+    _this.socketClient.sendPublishDocument(originDocUuid, originDocName, isNeedUpdateOriginDoc);
+  };
+  this.receivePublishDocument = function () {
+    _this.eventBus.dispatch(EXTERNAL_EVENT.PUBLISH_DOCUMENT);
+  };
+  this.receivePublishDocumentError = function () {
+    _this.eventBus.dispatch(EXTERNAL_EVENT.PUBLISH_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.onReceiveLocalOperations = function (operations) {
     _this.pendingOperationList.push(operations);
     if (_this.pendingOperationList.length > 5) {
@@ -34,6 +56,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 +315,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,50 @@ 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, isNeedUpdateOriginDoc) {
+    var config = options.config;
+    var socketManager = SocketManager.getInstance(newEditor, document, config);
+    socketManager.sendPublishDocument(originDocUuid, originDocName, isNeedUpdateOriginDoc);
+  };
+  newEditor.replaceDocument = function (document) {
+    var config = options.config;
+    var socketManager = SocketManager.getInstance(newEditor, document, config);
+    socketManager.sendReplaceDocument(document);
+  };
   return newEditor;
 };
 export default withSocketIO;

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

@@ -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();
 };

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

@@ -0,0 +1,181 @@
+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 } from '../constants';
+import { ELEMENT_TYPE } from '../extension/constants';
+import { replaceNodeId } from '../node-id/helpers';
+var getRevisionChanges = function getRevisionChanges(masterContent, currentContent) {
+  var _generateIdMapAndIds = generateIdMapAndIds(currentContent.children),
+    currentContentMap = _generateIdMapAndIds.map,
+    currentIds = _generateIdMapAndIds.ids;
+  var _generateIdMapAndIds2 = generateIdMapAndIds(masterContent.children),
+    masterContentMap = _generateIdMapAndIds2.map,
+    masterIds = _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 = getRevisionChanges(oldElement, currentElement);
+              newElement[REBASE_MARK_KEY.MODIFY_TYPE] = MODIFY_TYPE.CHILDREN_MODIFY;
+              newElement['children'] = listContent;
+            }
+          }
+          content.push(newElement);
+        }
+      });
+    }
+  });
+  return content;
+};
+var getMasterChanges = function getMasterChanges(masterContent, revisionChanges) {
+  var canMerge = true;
+  var _generateIdMapAndIds3 = generateIdMapAndIds(revisionChanges),
+    currentContentMap = _generateIdMapAndIds3.map,
+    currentIds = _generateIdMapAndIds3.ids;
+  var _generateIdMapAndIds4 = generateIdMapAndIds(masterContent.children),
+    masterContentMap = _generateIdMapAndIds4.map,
+    masterIds = _generateIdMapAndIds4.ids;
+  var idDiffs = getIdDiffs(masterIds, currentIds);
+  var content = [];
+  idDiffs.forEach(function (idDiff) {
+    var value = idDiff.value,
+      added = idDiff.added,
+      removed = idDiff.removed;
+    if (added) {
+      value.forEach(function (elementId) {
+        var element = currentContentMap[elementId];
+        var newElement = {
+          id: element.id,
+          children: element.children,
+          type: element.type
+        };
+        // The content has been deleted from the master, but this branch has been modified. At this time, rebase is required, and the user needs to confirm the selected content
+        // ==> delete ｜ use modification
+        if (element[REBASE_MARK_KEY.MODIFY_TYPE] === MODIFY_TYPE.MODIFY) {
+          newElement[REBASE_MARK_KEY.REBASE_TYPE] = REBASE_TYPE.DELETE_MODIFY;
+          content.push(newElement);
+          canMerge = false;
+        } else {
+          // new direct append
+          content.push(newElement);
+        }
+      });
+    } else if (removed) {
+      var deletedList = value.map(function (item) {
+        return _objectSpread({}, masterContentMap[item]);
+      });
+      content.push.apply(content, _toConsumableArray(deletedList));
+    } else {
+      value.forEach(function (elementId) {
+        var currentElement = currentContentMap[elementId];
+        var masterElement = masterContentMap[elementId];
+
+        // Unchanged
+        if (ObjectUtils.isSameObject(masterElement, currentElement)) {
+          content.push(currentElement);
+
+          // The content of the master branch is modified in the current branch, but the content of the master branch is the same as that of origin
+        } else if (ObjectUtils.isSameObject(masterElement, currentElement[REBASE_MARK_KEY.OLD_ELEMENT])) {
+          var newElement = _objectSpread({}, currentElement);
+          newElement[REBASE_MARK_KEY.OLD_ELEMENT] && delete newElement[REBASE_MARK_KEY.OLD_ELEMENT];
+          newElement[REBASE_MARK_KEY.MODIFY_TYPE] && delete newElement[REBASE_MARK_KEY.MODIFY_TYPE];
+          content.push(newElement);
+
+          // Modify at the same time
+        } else if (currentElement[REBASE_MARK_KEY.MODIFY_TYPE] === MODIFY_TYPE.MODIFY) {
+          var _objectSpread5, _objectSpread6;
+          var oldMasterElement = replaceNodeId(_objectSpread(_objectSpread({}, masterElement), {}, (_objectSpread5 = {}, _defineProperty(_objectSpread5, REBASE_MARK_KEY.REBASE_TYPE, REBASE_TYPE.MODIFY_MODIFY), _defineProperty(_objectSpread5, REBASE_MARK_KEY.ORIGIN, 'master'), _defineProperty(_objectSpread5, REBASE_MARK_KEY.OLD_ELEMENT, masterElement), _objectSpread5)));
+          content.push(oldMasterElement);
+          var _newElement = _objectSpread(_objectSpread({}, currentElement), {}, (_objectSpread6 = {}, _defineProperty(_objectSpread6, REBASE_MARK_KEY.REBASE_TYPE, REBASE_TYPE.MODIFY_MODIFY), _defineProperty(_objectSpread6, REBASE_MARK_KEY.ORIGIN, 'current'), _objectSpread6));
+          _newElement[REBASE_MARK_KEY.MODIFY_TYPE] && delete _newElement[REBASE_MARK_KEY.MODIFY_TYPE];
+          _newElement[REBASE_MARK_KEY.OLD_ELEMENT] && delete _newElement[REBASE_MARK_KEY.OLD_ELEMENT];
+          content.push(_newElement);
+          canMerge = false;
+
+          // children modify
+        } else if (currentElement[REBASE_MARK_KEY.MODIFY_TYPE] === MODIFY_TYPE.CHILDREN_MODIFY) {
+          canMerge = false;
+          if (currentElement.type === masterElement.type) {
+            var _getMasterChanges = getMasterChanges(masterElement, currentElement.children),
+              childrenContent = _getMasterChanges.content;
+            content.push(_objectSpread(_objectSpread({}, masterElement), {}, _defineProperty({
+              children: childrenContent
+            }, REBASE_MARK_KEY.REBASE_TYPE, REBASE_TYPE.CHILDREN_MODIFY)));
+          } else {
+            var _objectSpread8, _objectSpread9;
+            var _oldMasterElement = replaceNodeId(_objectSpread(_objectSpread({}, masterElement), {}, (_objectSpread8 = {}, _defineProperty(_objectSpread8, REBASE_MARK_KEY.REBASE_TYPE, REBASE_TYPE.MODIFY_MODIFY), _defineProperty(_objectSpread8, REBASE_MARK_KEY.ORIGIN, 'master'), _defineProperty(_objectSpread8, REBASE_MARK_KEY.OLD_ELEMENT, masterElement), _objectSpread8)));
+            content.push(_oldMasterElement);
+            var _newElement2 = _objectSpread(_objectSpread({}, currentElement[REBASE_MARK_KEY.OLD_ELEMENT]), {}, (_objectSpread9 = {}, _defineProperty(_objectSpread9, REBASE_MARK_KEY.REBASE_TYPE, REBASE_TYPE.MODIFY_MODIFY), _defineProperty(_objectSpread9, REBASE_MARK_KEY.ORIGIN, 'current'), _objectSpread9));
+            content.push(_newElement2);
+          }
+        } else {
+          var _newElement3 = _objectSpread({}, currentElement);
+          _newElement3[REBASE_MARK_KEY.OLD_ELEMENT] && delete _newElement3[REBASE_MARK_KEY.OLD_ELEMENT];
+          _newElement3[REBASE_MARK_KEY.MODIFY_TYPE] && delete _newElement3[REBASE_MARK_KEY.MODIFY_TYPE];
+          content.push(_newElement3);
+        }
+      });
+    }
+  });
+  return {
+    content: content,
+    canMerge: canMerge
+  };
+};
+export var getRebase = function getRebase(masterContent, revisionMasterContent, revisionCurrentContent) {
+  // master no changes, merged directly
+  if (masterContent.version === revisionMasterContent.version) {
+    return {
+      canMerge: true,
+      isNeedReplaceMaster: true,
+      value: revisionCurrentContent
+    };
+  }
+
+  // The revision content has not changed
+  if (revisionMasterContent.version === revisionCurrentContent.version) {
+    return {
+      canMerge: true,
+      isNeedReplaceMaster: false,
+      value: masterContent
+    };
+  }
+  var revisionChanges = getRevisionChanges(revisionMasterContent, revisionCurrentContent);
+  var _getMasterChanges2 = getMasterChanges(masterContent, revisionChanges),
+    canMerge = _getMasterChanges2.canMerge,
+    content = _getMasterChanges2.content;
+  return {
+    canMerge: canMerge,
+    isNeedReplaceMaster: true,
+    value: _objectSpread(_objectSpread({}, revisionCurrentContent), {}, {
+      children: content,
+      version: Math.max(masterContent.version, revisionCurrentContent.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: {