@seafile/sdoc-editor 0.3.6 → 0.3.7

package/dist/basic-sdk/utils/event-handler.js

@@ -1,94 +1,96 @@
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
 import isHotkey from 'is-hotkey';
 import EventBus from '../utils/event-bus';
 import { getSelectedNodeByType } from '../extension/core/queries/';
 import { setOriginSdocKey } from './document-utils';
 import { ELEMENT_TYPE } from '../extension/constants';
 import { INTERNAL_EVENT } from '../constants';
-var EventProxy = /*#__PURE__*/_createClass(function EventProxy(_editor) {
-  var _this = this;
-  _classCallCheck(this, EventProxy);
-  this.onKeyDown = function (event) {
-    var editor = _this.editor;
-    if (editor.onHotKeyDown) {
-      var isHandled = editor.onHotKeyDown(event);
-      if (isHandled) return;
-    }
+class EventProxy {
+  constructor(_editor) {
+    this.onKeyDown = event => {
+      const editor = this.editor;
+      if (editor.onHotKeyDown) {
+        const isHandled = editor.onHotKeyDown(event);
+        if (isHandled) return;
+      }
 
-    // bold
-    if (isHotkey('mod+b', event)) {
-      event.preventDefault();
-      editor.toggleTextBold();
-    }
+      // bold
+      if (isHotkey('mod+b', event)) {
+        event.preventDefault();
+        editor.toggleTextBold();
+      }
 
-    // italic
-    if (isHotkey('mod+i', event)) {
-      event.preventDefault();
-      editor.toggleTextItalic();
-    }
+      // italic
+      if (isHotkey('mod+i', event)) {
+        event.preventDefault();
+        editor.toggleTextItalic();
+      }
 
-    // font scale
-    if (isHotkey('opt+.', event)) {
-      event.preventDefault();
-      editor.increaseFontSize();
-    }
-    if (isHotkey('opt+,', event)) {
-      event.preventDefault();
-      editor.reduceFontSize();
-    }
+      // font scale
+      if (isHotkey('opt+.', event)) {
+        event.preventDefault();
+        editor.increaseFontSize();
+      }
+      if (isHotkey('opt+,', event)) {
+        event.preventDefault();
+        editor.reduceFontSize();
+      }
 
-    // disable the default 'save page'
-    if (isHotkey('mod+s', event)) {
-      event.preventDefault();
-    }
+      // disable the default 'save page'
+      if (isHotkey('mod+s', event)) {
+        event.preventDefault();
+      }
 
-    // redo
-    if (isHotkey('mod+y', event)) {
-      event.preventDefault();
-      var history = editor.history;
-      if (history.redos.length === 0) {
-        return false;
+      // redo
+      if (isHotkey('mod+y', event)) {
+        event.preventDefault();
+        const {
+          history
+        } = editor;
+        if (history.redos.length === 0) {
+          return false;
+        }
+        editor.redo();
       }
-      editor.redo();
-    }
 
-    // undo
-    if (isHotkey('mod+z', event)) {
-      event.preventDefault();
-      var _history = editor.history;
-      if (_history.undos.length === 0) {
-        return false;
+      // undo
+      if (isHotkey('mod+z', event)) {
+        event.preventDefault();
+        const {
+          history
+        } = editor;
+        if (history.undos.length === 0) {
+          return false;
+        }
+        editor.undo();
+      }
+      if (isHotkey('tab', event) || isHotkey('shift+tab', event)) {
+        editor.handleTab && editor.handleTab(event);
+      }
+      const node = getSelectedNodeByType(editor, ELEMENT_TYPE.TABLE);
+      if (node) {
+        this.editor.tableOnKeyDown(event);
+      }
+      const imageNode = getSelectedNodeByType(editor, ELEMENT_TYPE.IMAGE);
+      if (imageNode) {
+        this.editor.imageOnKeyDown(event);
+      }
+      if (getSelectedNodeByType(editor, ELEMENT_TYPE.CODE_BLOCK)) {
+        this.editor.codeBlockOnKeyDown(event);
+        const eventBus = EventBus.getInstance();
+        eventBus.dispatch(INTERNAL_EVENT.HIDDEN_CODE_BLOCK_HOVER_MENU);
+      }
+    };
+    this.onCopy = event => {
+      setOriginSdocKey(event);
+    };
+    this.onCut = event => {
+      setOriginSdocKey(event);
+      if (this.editor.cut) {
+        this.editor.cut(event);
       }
-      editor.undo();
-    }
-    if (isHotkey('tab', event) || isHotkey('shift+tab', event)) {
-      editor.handleTab && editor.handleTab(event);
-    }
-    var node = getSelectedNodeByType(editor, ELEMENT_TYPE.TABLE);
-    if (node) {
-      _this.editor.tableOnKeyDown(event);
-    }
-    var imageNode = getSelectedNodeByType(editor, ELEMENT_TYPE.IMAGE);
-    if (imageNode) {
-      _this.editor.imageOnKeyDown(event);
-    }
-    if (getSelectedNodeByType(editor, ELEMENT_TYPE.CODE_BLOCK)) {
-      _this.editor.codeBlockOnKeyDown(event);
-      var eventBus = EventBus.getInstance();
-      eventBus.dispatch(INTERNAL_EVENT.HIDDEN_CODE_BLOCK_HOVER_MENU);
-    }
-  };
-  this.onCopy = function (event) {
-    setOriginSdocKey(event);
-  };
-  this.onCut = function (event) {
-    setOriginSdocKey(event);
-    if (_this.editor.cut) {
-      _this.editor.cut(event);
-    }
-  };
-  this.onPaste = function (event) {};
-  this.editor = _editor;
-});
+    };
+    this.onPaste = event => {};
+    this.editor = _editor;
+  }
+}
 export default EventProxy;

package/dist/basic-sdk/utils/mouse-event.js

@@ -1,25 +1,25 @@
-export var eventStopPropagation = function eventStopPropagation(event) {
+export const eventStopPropagation = event => {
   if (!event) return;
   event.stopPropagation();
   event.nativeEvent && event.nativeEvent.stopImmediatePropagation && event.nativeEvent.stopImmediatePropagation();
 };
-export var registerResizeEvents = function registerResizeEvents() {
-  var eventsMap = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  for (var key in eventsMap) {
+export const registerResizeEvents = function () {
+  let eventsMap = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  for (let key in eventsMap) {
     document.addEventListener(key, eventsMap[key]);
   }
 };
-export var unregisterResizeEvents = function unregisterResizeEvents() {
-  var eventsMap = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  for (var key in eventsMap) {
+export const unregisterResizeEvents = function () {
+  let eventsMap = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  for (let key in eventsMap) {
     document.removeEventListener(key, eventsMap[key]);
   }
 };
-export var getMouseDownInfo = function getMouseDownInfo(event, scrollContainer) {
-  var positionX = 0;
-  var positionY = 0;
-  var scrollLeft = 0;
-  var scrollTop = 0;
+export const getMouseDownInfo = (event, scrollContainer) => {
+  let positionX = 0;
+  let positionY = 0;
+  let scrollLeft = 0;
+  let scrollTop = 0;
   if (event) {
     positionX = event.clientX;
     positionY = event.clientY;
@@ -29,23 +29,25 @@ export var getMouseDownInfo = function getMouseDownInfo(event, scrollContainer)
     scrollTop = scrollContainer.scrollTop;
   }
   return {
-    positionX: positionX,
-    positionY: positionY,
-    scrollLeft: scrollLeft,
-    scrollTop: scrollTop
+    positionX,
+    positionY,
+    scrollLeft,
+    scrollTop
   };
 };
-export var getMouseMoveInfo = function getMouseMoveInfo(event, mouseDownInfo, scrollContainer) {
-  var displacementX = 0;
-  var displacementY = 0;
+export const getMouseMoveInfo = (event, mouseDownInfo, scrollContainer) => {
+  let displacementX = 0;
+  let displacementY = 0;
   if (!event) return {
-    displacementX: displacementX,
-    displacementY: displacementY
+    displacementX,
+    displacementY
   };
-  var currPositionX = event.clientX,
-    currPositionY = event.clientY;
-  var scrollLeft = 0;
-  var scrollTop = 0;
+  const {
+    clientX: currPositionX,
+    clientY: currPositionY
+  } = event;
+  let scrollLeft = 0;
+  let scrollTop = 0;
   if (scrollContainer) {
     scrollLeft = scrollContainer.scrollLeft || 0;
     scrollTop = scrollContainer.scrollTop || 0;
@@ -53,7 +55,7 @@ export var getMouseMoveInfo = function getMouseMoveInfo(event, mouseDownInfo, sc
   displacementX = currPositionX - mouseDownInfo.positionX + scrollLeft - (mouseDownInfo.scrollLeft || 0);
   displacementY = currPositionY - mouseDownInfo.positionY + scrollTop - (mouseDownInfo.scrollTop || 0);
   return {
-    displacementX: displacementX,
-    displacementY: displacementY
+    displacementX,
+    displacementY
   };
 };

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

@@ -1,65 +1,47 @@
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
 var _class;
-var ObjectUtils = /*#__PURE__*/function () {
-  function ObjectUtils() {
-    _classCallCheck(this, ObjectUtils);
-  }
-  _createClass(ObjectUtils, null, [{
-    key: "getDataType",
-    value: function getDataType(data) {
-      var type = typeof data;
-      if (type !== 'object') {
-        return type;
-      }
-      return Object.prototype.toString.call(data).replace(/^\[object (\S+)\]$/, '$1');
+class ObjectUtils {
+  static getDataType(data) {
+    let type = typeof data;
+    if (type !== 'object') {
+      return type;
     }
-  }, {
-    key: "iterable",
-    value: function iterable(data) {
-      return ['Object', 'Array'].includes(this.getDataType(data));
+    return Object.prototype.toString.call(data).replace(/^\[object (\S+)\]$/, '$1');
+  }
+  static iterable(data) {
+    return ['Object', 'Array'].includes(this.getDataType(data));
+  }
+  static isObjectChanged(source, comparison, notIncludeKeys) {
+    if (!this.iterable(source)) {
+      throw new Error("source should be a Object or Array , but got ".concat(this.getDataType(source)));
     }
-  }, {
-    key: "isObjectChanged",
-    value: function isObjectChanged(source, comparison, notIncludeKeys) {
-      var _this = this;
-      if (!this.iterable(source)) {
-        throw new Error("source should be a Object or Array , but got ".concat(this.getDataType(source)));
-      }
-      if (this.getDataType(source) !== this.getDataType(comparison)) {
-        return true;
-      }
-      var sourceKeys = Object.keys(source);
-      var comparisonKeys = Object.keys(_objectSpread(_objectSpread({}, source), comparison)).filter(function (key) {
-        return !notIncludeKeys.includes(key);
-      });
-      if (sourceKeys.length !== comparisonKeys.length) {
-        return true;
-      }
-      return comparisonKeys.some(function (key) {
-        if (_this.iterable(source[key])) {
-          return _this.isObjectChanged(source[key], comparison[key], notIncludeKeys);
-        } else {
-          return source[key] !== comparison[key];
-        }
-      });
+    if (this.getDataType(source) !== this.getDataType(comparison)) {
+      return true;
     }
-  }, {
-    key: "isSameObject",
-    value: function isSameObject(source, comparison) {
-      var notIncludeKeys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
-      if (!source || !comparison) return false;
-      return !this.isObjectChanged(source, comparison, notIncludeKeys);
+    const sourceKeys = Object.keys(source);
+    const comparisonKeys = Object.keys(_objectSpread(_objectSpread({}, source), comparison)).filter(key => !notIncludeKeys.includes(key));
+    if (sourceKeys.length !== comparisonKeys.length) {
+      return true;
     }
-  }]);
-  return ObjectUtils;
-}();
+    return comparisonKeys.some(key => {
+      if (this.iterable(source[key])) {
+        return this.isObjectChanged(source[key], comparison[key], notIncludeKeys);
+      } else {
+        return source[key] !== comparison[key];
+      }
+    });
+  }
+  static isSameObject(source, comparison) {
+    let notIncludeKeys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+    if (!source || !comparison) return false;
+    return !this.isObjectChanged(source, comparison, notIncludeKeys);
+  }
+}
 _class = ObjectUtils;
-ObjectUtils.isObject = function (data) {
+ObjectUtils.isObject = data => {
   return _class.getDataType(data) === 'Object';
 };
-ObjectUtils.hasProperty = function (obj, prop) {
+ObjectUtils.hasProperty = (obj, prop) => {
   if (!obj) return false;
   return Object.prototype.hasOwnProperty.call(obj, prop);
 };

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

@@ -1,53 +1,55 @@
-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) {
+export const hasConflict = content => {
   if (!Array.isArray(content) || content.length === 0) return false;
-  return content.filter(function (item) {
-    return item.rebase_type;
-  }).length !== 0;
+  return content.filter(item => 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;
+const getChanges = (masterContent, revisionContent) => {
+  const {
+    map: masterContentMap,
+    ids: masterIds
+  } = generateIdMapAndIds(masterContent.children);
+  const {
+    map: currentContentMap,
+    ids: currentIds
+  } = generateIdMapAndIds(revisionContent.children);
+  const idDiffs = getIdDiffs(masterIds, currentIds);
+  let content = [];
+  idDiffs.forEach(idDiff => {
+    const {
+      value,
+      added,
+      removed
+    } = idDiff;
     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));
+      const addedList = value.map(item => _objectSpread(_objectSpread({}, currentContentMap[item]), {}, {
+        [REBASE_MARK_KEY.MODIFY_TYPE]: MODIFY_TYPE.ADD
+      }));
+      content.push(...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));
+      const deletedList = value.map(item => _objectSpread(_objectSpread({}, masterContentMap[item]), {}, {
+        [REBASE_MARK_KEY.MODIFY_TYPE]: MODIFY_TYPE.DELETE
+      }));
+      content.push(...deletedList);
     } else {
-      value.forEach(function (elementId) {
+      value.forEach(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));
+          const oldElement = masterContentMap[elementId];
+          const currentElement = currentContentMap[elementId];
+          let newElement = _objectSpread(_objectSpread({}, currentElement), {}, {
+            [REBASE_MARK_KEY.MODIFY_TYPE]: MODIFY_TYPE.MODIFY,
+            [REBASE_MARK_KEY.OLD_ELEMENT]: oldElement
+          });
           if (currentElement.type === oldElement.type) {
-            var elementType = currentElement.type;
+            const elementType = currentElement.type;
             if ([ELEMENT_TYPE.UNORDERED_LIST, ELEMENT_TYPE.ORDERED_LIST].includes(elementType)) {
-              var listContent = getChanges(oldElement, currentElement);
+              const listContent = getChanges(oldElement, currentElement);
               newElement[REBASE_MARK_KEY.MODIFY_TYPE] = MODIFY_TYPE.CHILDREN_MODIFY;
               newElement['children'] = listContent;
             }
@@ -59,9 +61,9 @@ var getChanges = function getChanges(masterContent, revisionContent) {
   });
   return content;
 };
-var getMergeElement = function getMergeElement(diffElement, baseElement) {
-  var modifyType = diffElement[REBASE_MARK_KEY.MODIFY_TYPE];
-  var newElement = _objectSpread({}, diffElement);
+const getMergeElement = (diffElement, baseElement) => {
+  const modifyType = diffElement[REBASE_MARK_KEY.MODIFY_TYPE];
+  const 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
@@ -96,14 +98,19 @@ var getMergeElement = function getMergeElement(diffElement, baseElement) {
 
   // Elements that differ between revision and master
   if (modifyType === MODIFY_TYPE.MODIFY) {
-    var _objectSpread7, _objectSpread8;
-    var masterElement = _objectSpread({}, diffElement[REBASE_MARK_KEY.OLD_ELEMENT]);
+    const 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 (!baseElement) {
-      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))];
+      return [_objectSpread(_objectSpread({}, replaceNodeId(masterElement)), {}, {
+        [REBASE_MARK_KEY.REBASE_TYPE]: REBASE_TYPE.MODIFY_MODIFY,
+        [REBASE_MARK_KEY.OLD_ELEMENT]: masterElement,
+        [REBASE_MARK_KEY.ORIGIN]: REBASE_ORIGIN.OTHER
+      }), _objectSpread(_objectSpread({}, newElement), {}, {
+        [REBASE_MARK_KEY.REBASE_TYPE]: REBASE_TYPE.MODIFY_MODIFY,
+        [REBASE_MARK_KEY.ORIGIN]: REBASE_ORIGIN.MY
+      })];
     }
 
     // master is the same as base, indicating that revision has modified the content
@@ -113,54 +120,71 @@ var getMergeElement = function getMergeElement(diffElement, baseElement) {
     if (ObjectUtils.isSameObject(newElement, baseElement)) 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))];
+    return [_objectSpread(_objectSpread({}, replaceNodeId(masterElement)), {}, {
+      [REBASE_MARK_KEY.REBASE_TYPE]: REBASE_TYPE.MODIFY_MODIFY,
+      [REBASE_MARK_KEY.OLD_ELEMENT]: masterElement,
+      [REBASE_MARK_KEY.ORIGIN]: REBASE_ORIGIN.OTHER
+    }), _objectSpread(_objectSpread({}, newElement), {}, {
+      [REBASE_MARK_KEY.REBASE_TYPE]: REBASE_TYPE.MODIFY_MODIFY,
+      [REBASE_MARK_KEY.ORIGIN]: REBASE_ORIGIN.MY
+    })];
   }
   if (modifyType === MODIFY_TYPE.CHILDREN_MODIFY) {
-    var _masterElement = _objectSpread({}, diffElement[REBASE_MARK_KEY.OLD_ELEMENT]);
+    const 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 (!baseElement) {
-      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))];
+      return [_objectSpread(_objectSpread({}, replaceNodeId(masterElement)), {}, {
+        [REBASE_MARK_KEY.REBASE_TYPE]: REBASE_TYPE.MODIFY_MODIFY,
+        [REBASE_MARK_KEY.OLD_ELEMENT]: masterElement,
+        [REBASE_MARK_KEY.ORIGIN]: REBASE_ORIGIN.OTHER
+      }), _objectSpread(_objectSpread({}, newElement), {}, {
+        [REBASE_MARK_KEY.REBASE_TYPE]: REBASE_TYPE.MODIFY_MODIFY,
+        [REBASE_MARK_KEY.ORIGIN]: REBASE_ORIGIN.MY
+      })];
     }
-    if (ObjectUtils.isSameObject(_masterElement, baseElement)) return [newElement];
-    if (ObjectUtils.isSameObject(newElement, baseElement)) return [_masterElement];
-    if (ObjectUtils.isSameObject(_masterElement, newElement, ['type'])) {
-      if (ObjectUtils.isSameObject(_masterElement, baseElement, ['type'])) return [newElement];
-      if (ObjectUtils.isSameObject(newElement, baseElement, ['type'])) return [_masterElement];
+    if (ObjectUtils.isSameObject(masterElement, baseElement)) return [newElement];
+    if (ObjectUtils.isSameObject(newElement, baseElement)) return [masterElement];
+    if (ObjectUtils.isSameObject(masterElement, newElement, ['type'])) {
+      if (ObjectUtils.isSameObject(masterElement, baseElement, ['type'])) return [newElement];
+      if (ObjectUtils.isSameObject(newElement, baseElement, ['type'])) return [masterElement];
     }
 
     // The content of the subnode has changed and needs to be solved manually.
-    var _getMergeContent = getMergeContent(baseElement, diffElement.children),
-      childrenContent = _getMergeContent.content;
-    return [_objectSpread(_objectSpread({}, newElement), {}, _defineProperty({
-      children: childrenContent
-    }, REBASE_MARK_KEY.REBASE_TYPE, REBASE_TYPE.CHILDREN_MODIFY))];
+    const {
+      content: childrenContent
+    } = getMergeContent(baseElement, diffElement.children);
+    return [_objectSpread(_objectSpread({}, newElement), {}, {
+      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(baseContent, diffChanges) {
-  var _generateIdMapAndIds3 = generateIdMapAndIds(diffChanges),
-    diffChangesContentMap = _generateIdMapAndIds3.map,
-    diffChangesContentIds = _generateIdMapAndIds3.ids;
-  var _generateIdMapAndIds4 = generateIdMapAndIds(baseContent.children),
-    baseContentMap = _generateIdMapAndIds4.map;
-  var content = [];
-  diffChangesContentIds.forEach(function (elementId) {
-    var diffElement = diffChangesContentMap[elementId];
-    var baseElement = baseContentMap[elementId];
-    var mergeElements = getMergeElement(diffElement, baseElement);
-    content.push.apply(content, _toConsumableArray(mergeElements));
+const getMergeContent = (baseContent, diffChanges) => {
+  const {
+    map: diffChangesContentMap,
+    ids: diffChangesContentIds
+  } = generateIdMapAndIds(diffChanges);
+  const {
+    map: baseContentMap
+  } = generateIdMapAndIds(baseContent.children);
+  let content = [];
+  diffChangesContentIds.forEach(elementId => {
+    const diffElement = diffChangesContentMap[elementId];
+    const baseElement = baseContentMap[elementId];
+    const mergeElements = getMergeElement(diffElement, baseElement);
+    content.push(...mergeElements);
   });
-  var canMerge = !hasConflict(content);
+  const canMerge = !hasConflict(content);
   return {
-    content: content,
-    canMerge: canMerge
+    content,
+    canMerge
   };
 };
-export var getRebase = function getRebase(masterContent, baseContent, revisionContent) {
+export const getRebase = (masterContent, baseContent, revisionContent) => {
   // master no changes, merged directly
   if (masterContent.version === baseContent.version) {
     return {
@@ -178,12 +202,13 @@ export var getRebase = function getRebase(masterContent, baseContent, revisionCo
       value: masterContent
     };
   }
-  var diffChanges = getChanges(masterContent, revisionContent);
-  var _getMergeContent2 = getMergeContent(baseContent, diffChanges),
-    canMerge = _getMergeContent2.canMerge,
-    content = _getMergeContent2.content;
+  const diffChanges = getChanges(masterContent, revisionContent);
+  const {
+    canMerge,
+    content
+  } = getMergeContent(baseContent, diffChanges);
   return {
-    canMerge: canMerge,
+    canMerge,
     isNeedReplaceMaster: true,
     value: _objectSpread(_objectSpread({}, revisionContent), {}, {
       children: content,