@seafile/sdoc-editor 2.0.82 → 2.0.83

package/dist/utils/full-width-mode.js

@@ -0,0 +1,32 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getStyleByFullWidthMode = exports.getContentStyleByFullModeStyle = void 0;
+var _constants = require("../constants");
+var _localStorageUtils = _interopRequireDefault(require("./local-storage-utils"));
+var getStyleByFullWidthMode = exports.getStyleByFullWidthMode = function getStyleByFullWidthMode(scrollRef, editor) {
+  var sdocStorage = _localStorageUtils["default"].getItem(_constants.SDOC_STORAGE) || {};
+  var isShowOutline = sdocStorage.outlineOpen;
+  var containerStyle = {};
+  containerStyle['width'] = _constants.ARTICLE_FULL_WIDTH;
+  containerStyle['minWidth'] = _constants.ARTICLE_FULL_MIN_WIDTH;
+
+  // Has outline
+  if (isShowOutline && (editor === null || editor === void 0 ? void 0 : editor.editorType) !== _constants.WIKI_EDITOR) {
+    containerStyle['marginLeft'] = "".concat(_constants.LEFT_OUTLINE_WIDTH, "px");
+    var adjustWidth = " - ".concat(_constants.LEFT_OUTLINE_WIDTH - 50, "px"); // One side is 50
+    containerStyle['width'] = containerStyle['width'].slice(0, -1) + adjustWidth;
+  }
+  return containerStyle;
+};
+var getContentStyleByFullModeStyle = exports.getContentStyleByFullModeStyle = function getContentStyleByFullModeStyle() {
+  if (_localStorageUtils["default"].getItem(_constants.FULL_WIDTH_MODE)) {
+    return {
+      'minWidth': "".concat(Number(_constants.ARTICLE_FULL_MIN_WIDTH.slice(0, -2)), "px")
+    };
+  }
+  return {};
+};

package/dist/utils/is-punctuation-mark.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var isChPunctuation = function isChPunctuation(_char) {
+  // \u2014|\u2018|\u2019|\u201c|\u201d|
+  // \u2026|
+  // \u2039｜\u203a
+  // \u3001|\u3002|\u3008|\u3009|\u300a|\u300b|\u300c|\u300d|\u300e|\u300f
+  // \u3010|\u3011|\u3014|\u3015|\u301c|\u301d|\u301e
+  // \ufe43|\ufe44|\ufe4f
+  // \uffe5 (¥)
+  var reg = /[\u2014|\u2018|\u2019|\u201c|\u201d|\u2026|\u2039|\u203a|\u3001|\u3002|\u3008|\u3009|\u300a|\u300b|\u300c|\u300d|\u300e|\u300f|\u3010|\u3011|\u3014|\u3015|\u301c|\u301d|\u301e]/;
+  if (reg.test(_char)) {
+    return true;
+  } else {
+    return false;
+  }
+};
+function isEnHalfWidthPunctuation(_char2) {
+  // Distribution of half-width punctuation points in unicode: 0x0021~0x007e
+  // https://en.wikibooks.org/wiki/Unicode/Character_reference/0000-0FFF
+  var reg = /[\x21-\x2f\x3a-\x40\x5b-\x60\x7B-\x7F]/;
+  if (reg.test(_char2)) {
+    return true;
+  } else {
+    return false;
+  }
+}
+function isEnFullWidthPunctuation(_char3) {
+  // 0xff01~0xff5e
+  // https://en.wikibooks.org/wiki/Unicode/Character_reference/F000-FFFF
+  var reg = /[\uff01-\uff0f\uff1a-\uff1f\uff20\uff3b-\uff3f\uff40\uff5b-\uff5f]/;
+  if (reg.test(_char3)) {
+    return true;
+  } else {
+    return false;
+  }
+}
+var isLastCharPunctuation = function isLastCharPunctuation(value) {
+  if (typeof value !== 'string' || !value) return false;
+  var lastChar = value.slice(-1);
+  if (isChPunctuation(lastChar)) return true;
+  if (isEnHalfWidthPunctuation(lastChar)) return true;
+  if (isEnFullWidthPunctuation(lastChar)) return true;
+  return false;
+};
+var _default = exports["default"] = isLastCharPunctuation;

package/dist/utils/local-storage-utils.js

@@ -0,0 +1,69 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/createClass"));
+var LocalStorage = /*#__PURE__*/function () {
+  function LocalStorage() {
+    (0, _classCallCheck2["default"])(this, LocalStorage);
+  }
+  return (0, _createClass2["default"])(LocalStorage, null, [{
+    key: "setItem",
+    value: function setItem(key, value) {
+      var savedValue;
+      var valueType = typeof value;
+      if (valueType === 'string') {
+        savedValue = value;
+      } else if (valueType === 'number') {
+        savedValue = value + '';
+      } else {
+        savedValue = JSON.stringify(value);
+      }
+      return window.localStorage.setItem(key, savedValue);
+    }
+  }, {
+    key: "getItem",
+    value: function getItem(key, defaultValue) {
+      var value = window.localStorage.getItem(key);
+      try {
+        return JSON.parse(value) || defaultValue;
+      } catch (_unused) {
+        return value || defaultValue;
+      }
+    }
+  }, {
+    key: "removeItem",
+    value: function removeItem(key) {
+      return window.localStorage.removeItem(key);
+    }
+
+    // The setExpire and getExpire methods used to satisfy some cases that need to be updated regularly
+  }, {
+    key: "setExpire",
+    value: function setExpire(key, value, expire) {
+      var obj = {
+        data: value,
+        time: Date.now(),
+        expire: expire
+      };
+      this.setItem(key, JSON.stringify(obj));
+    }
+  }, {
+    key: "getExpire",
+    value: function getExpire(key) {
+      var val = this.getItem(key);
+      if (!val) return val;
+      val = JSON.parse(val);
+      if (Date.now() - val.time > val.expire) {
+        this.removeItem(key);
+        return null;
+      }
+      return val.data;
+    }
+  }]);
+}();
+var _default = exports["default"] = LocalStorage;

package/dist/utils/mouse-event.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.unregisterResizeEvents = exports.registerResizeEvents = exports.getMouseMoveInfo = exports.getMouseDownInfo = exports.eventStopPropagation = exports.createObjectWithProperties = void 0;
+var eventStopPropagation = exports.eventStopPropagation = function eventStopPropagation(event) {
+  if (!event) return;
+  event.stopPropagation();
+  event.nativeEvent && event.nativeEvent.stopImmediatePropagation && event.nativeEvent.stopImmediatePropagation();
+};
+var registerResizeEvents = exports.registerResizeEvents = function registerResizeEvents() {
+  var eventsMap = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  for (var key in eventsMap) {
+    document.addEventListener(key, eventsMap[key]);
+  }
+};
+var unregisterResizeEvents = exports.unregisterResizeEvents = function unregisterResizeEvents() {
+  var eventsMap = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  for (var key in eventsMap) {
+    document.removeEventListener(key, eventsMap[key]);
+  }
+};
+var getMouseDownInfo = exports.getMouseDownInfo = function getMouseDownInfo(event, scrollContainer) {
+  var positionX = 0;
+  var positionY = 0;
+  var scrollLeft = 0;
+  var scrollTop = 0;
+  if (event) {
+    positionX = event.clientX;
+    positionY = event.clientY;
+  }
+  if (scrollContainer) {
+    scrollLeft = scrollContainer.scrollLeft;
+    scrollTop = scrollContainer.scrollTop;
+  }
+  return {
+    positionX: positionX,
+    positionY: positionY,
+    scrollLeft: scrollLeft,
+    scrollTop: scrollTop
+  };
+};
+var getMouseMoveInfo = exports.getMouseMoveInfo = function getMouseMoveInfo(event, mouseDownInfo, scrollContainer) {
+  var displacementX = 0;
+  var displacementY = 0;
+  if (!event) return {
+    displacementX: displacementX,
+    displacementY: displacementY
+  };
+  var currPositionX = event.clientX,
+    currPositionY = event.clientY;
+  var scrollLeft = 0;
+  var scrollTop = 0;
+  if (scrollContainer) {
+    scrollLeft = scrollContainer.scrollLeft || 0;
+    scrollTop = scrollContainer.scrollTop || 0;
+  }
+  displacementX = currPositionX - mouseDownInfo.positionX + scrollLeft - (mouseDownInfo.scrollLeft || 0);
+  displacementY = currPositionY - mouseDownInfo.positionY + scrollTop - (mouseDownInfo.scrollTop || 0);
+  return {
+    displacementX: displacementX,
+    displacementY: displacementY
+  };
+};
+var createObjectWithProperties = exports.createObjectWithProperties = function createObjectWithProperties(originalObj, properties) {
+  return properties.reduce(function (result, property) {
+    if (property in originalObj) {
+      result[property] = originalObj[property];
+    }
+    return result;
+  }, {});
+};

package/dist/utils/object-utils.js

@@ -0,0 +1,73 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/defineProperty"));
+var _ObjectUtils;
+var ObjectUtils = /*#__PURE__*/function () {
+  function ObjectUtils() {
+    (0, _classCallCheck2["default"])(this, ObjectUtils);
+  }
+  return (0, _createClass2["default"])(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');
+    }
+  }, {
+    key: "iterable",
+    value: function iterable(data) {
+      return ['Object', 'Array'].includes(this.getDataType(data));
+    }
+  }, {
+    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((0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, 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];
+        }
+      });
+    }
+  }, {
+    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);
+    }
+  }]);
+}();
+_ObjectUtils = ObjectUtils;
+(0, _defineProperty2["default"])(ObjectUtils, "isObject", function (data) {
+  return _ObjectUtils.getDataType(data) === 'Object';
+});
+(0, _defineProperty2["default"])(ObjectUtils, "hasProperty", function (obj, prop) {
+  if (!obj) return false;
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+});
+var _default = exports["default"] = ObjectUtils;

package/dist/utils/rebase.js

@@ -0,0 +1,280 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hasConflict = exports.getRebase = exports.canMerge = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/toConsumableArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/defineProperty"));
+var _objectSpread9 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _constants = require("../constants");
+var _constants2 = require("../extension/constants");
+var _helpers = require("../node-id/helpers");
+var _diff = require("./diff");
+var _objectUtils = _interopRequireDefault(require("./object-utils"));
+var _hasConflict = exports.hasConflict = function hasConflict(content) {
+  if (!Array.isArray(content) || content.length === 0) return false;
+  var flag = false;
+  for (var i = 0; i < content.length; i++) {
+    var element = content[i];
+    var rebase_type = element.rebase_type,
+      children = element.children;
+    if (_constants.REBASE_TYPES.includes(rebase_type)) {
+      flag = true;
+      break;
+    } else {
+      var childrenFlag = _hasConflict(children);
+      if (!childrenFlag) continue;
+      flag = childrenFlag;
+      break;
+    }
+  }
+  return flag;
+};
+var _expandGroup = function expandGroup(content) {
+  if ([_constants2.ELEMENT_TYPE.UNORDERED_LIST, _constants2.ELEMENT_TYPE.ORDERED_LIST].includes(content.type)) {
+    return [(0, _objectSpread9["default"])((0, _objectSpread9["default"])({}, content), {}, {
+      children: content.children.map(function (item) {
+        if (item.type === _constants2.ELEMENT_TYPE.GROUP) {
+          return _expandGroup(item);
+        }
+        return item;
+      }).flat(1)
+    })];
+  }
+  return content.type === _constants2.ELEMENT_TYPE.GROUP ? content.children : [content];
+};
+var mergeChanges = function mergeChanges(changes) {
+  if (!Array.isArray(changes) || changes.length === 0) return changes;
+  var value = [];
+  var i = 0;
+  while (i < changes.length) {
+    var change = changes[i];
+    var lastChange = value[value.length - 1];
+    if (change && lastChange && change[_constants.REBASE_MARK_KEY.MODIFY_TYPE] === _constants.MODIFY_TYPE.ADD && lastChange[_constants.REBASE_MARK_KEY.MODIFY_TYPE] === _constants.MODIFY_TYPE.DELETE) {
+      value = value.slice(0, value.length - 1);
+      lastChange[_constants.REBASE_MARK_KEY.MODIFY_TYPE] && delete lastChange[_constants.REBASE_MARK_KEY.MODIFY_TYPE];
+      change[_constants.REBASE_MARK_KEY.MODIFY_TYPE] && delete change[_constants.REBASE_MARK_KEY.MODIFY_TYPE];
+      value.push((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])({
+        id: change.id.endsWith('_group') ? change.id : change.id + '_group',
+        type: _constants2.ELEMENT_TYPE.GROUP
+      }, _constants.REBASE_MARK_KEY.MODIFY_TYPE, _constants.MODIFY_TYPE.MODIFY), "children", _expandGroup(change)), _constants.REBASE_MARK_KEY.OLD_ELEMENT, {
+        id: lastChange.id.endsWith('_group') ? lastChange.id : lastChange.id + '_group',
+        type: _constants2.ELEMENT_TYPE.GROUP,
+        children: _expandGroup(lastChange)
+      }));
+    } else {
+      value.push(change);
+    }
+    i++;
+  }
+  return value;
+};
+var _getChanges = function getChanges(masterContent, revisionContent) {
+  var childrenName = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'children';
+  var _generateIdMapAndIds = (0, _diff.generateIdMapAndIds)(masterContent[childrenName]),
+    masterContentMap = _generateIdMapAndIds.map,
+    masterIds = _generateIdMapAndIds.ids;
+  var _generateIdMapAndIds2 = (0, _diff.generateIdMapAndIds)(revisionContent[childrenName]),
+    currentContentMap = _generateIdMapAndIds2.map,
+    currentIds = _generateIdMapAndIds2.ids;
+  var idDiffs = (0, _diff.getIdDiffs)(masterIds, currentIds);
+  var content = [];
+  idDiffs.forEach(function (idDiff) {
+    var value = idDiff.value,
+      added = idDiff.added,
+      removed = idDiff.removed;
+    if (added) {
+      // merge consecutive identical operations
+      content.push((0, _defineProperty2["default"])((0, _defineProperty2["default"])({
+        id: value[0] + '_group',
+        type: _constants2.ELEMENT_TYPE.GROUP
+      }, _constants.REBASE_MARK_KEY.MODIFY_TYPE, _constants.MODIFY_TYPE.ADD), "children", value.map(function (item) {
+        return currentContentMap[item];
+      })));
+    } else if (removed) {
+      // merge consecutive identical operations
+      content.push((0, _defineProperty2["default"])((0, _defineProperty2["default"])({
+        id: value[0] + '_group',
+        type: _constants2.ELEMENT_TYPE.GROUP
+      }, _constants.REBASE_MARK_KEY.MODIFY_TYPE, _constants.MODIFY_TYPE.DELETE), "children", value.map(function (item) {
+        return masterContentMap[item];
+      })));
+    } else {
+      value.forEach(function (elementId) {
+        if (_objectUtils["default"].isSameObject(masterContentMap[elementId], currentContentMap[elementId])) {
+          content.push(currentContentMap[elementId]);
+        } else {
+          var oldElement = masterContentMap[elementId];
+          var currentElement = currentContentMap[elementId];
+          var newElement = (0, _objectSpread9["default"])((0, _objectSpread9["default"])({}, currentElement), {}, (0, _defineProperty2["default"])((0, _defineProperty2["default"])({}, _constants.REBASE_MARK_KEY.MODIFY_TYPE, _constants.MODIFY_TYPE.MODIFY), _constants.REBASE_MARK_KEY.OLD_ELEMENT, oldElement));
+          if (currentElement.type === oldElement.type) {
+            var elementType = currentElement.type;
+            if ([_constants2.ELEMENT_TYPE.UNORDERED_LIST, _constants2.ELEMENT_TYPE.ORDERED_LIST].includes(elementType)) {
+              var listContent = _getChanges(oldElement, currentElement);
+              newElement[_constants.REBASE_MARK_KEY.MODIFY_TYPE] = _constants.MODIFY_TYPE.CHILDREN_MODIFY;
+              newElement['children'] = listContent;
+            }
+          }
+          content.push(newElement);
+        }
+      });
+    }
+  });
+  return mergeChanges(content);
+};
+var getMergeElement = function getMergeElement(diffElement, baseElement) {
+  var modifyType = diffElement[_constants.REBASE_MARK_KEY.MODIFY_TYPE];
+  var newElement = (0, _objectSpread9["default"])({}, diffElement);
+  newElement[_constants.REBASE_MARK_KEY.MODIFY_TYPE] && delete newElement[_constants.REBASE_MARK_KEY.MODIFY_TYPE];
+
+  // revision does not have this element, master has this element
+  if (modifyType === _constants.MODIFY_TYPE.DELETE) {
+    // base 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 (!baseElement) return _expandGroup(newElement);
+
+    // base content has this element, master modified it, indicating that revision deleted it, and the user manually selected the conflict
+    if (!_objectUtils["default"].isSameObject(baseElement, diffElement, [_constants.REBASE_MARK_KEY.MODIFY_TYPE])) {
+      newElement[_constants.REBASE_MARK_KEY.REBASE_TYPE] = _constants.REBASE_TYPE.MODIFY_DELETE;
+      return [newElement];
+    }
+
+    // base 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 === _constants.MODIFY_TYPE.ADD) {
+    // base 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 (!baseElement) return _expandGroup(newElement);
+
+    // master deleted it, revision modified it, and the user manually selected the conflict
+    if (!_objectUtils["default"].isSameObject(baseElement, diffElement, [_constants.REBASE_MARK_KEY.MODIFY_TYPE])) {
+      newElement[_constants.REBASE_MARK_KEY.REBASE_TYPE] = _constants.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 === _constants.MODIFY_TYPE.MODIFY) {
+    var masterElement = (0, _objectSpread9["default"])({}, diffElement[_constants.REBASE_MARK_KEY.OLD_ELEMENT]);
+    delete newElement[_constants.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) {
+      return [(0, _objectSpread9["default"])((0, _objectSpread9["default"])({}, (0, _helpers.replaceNodeId)(masterElement)), {}, (0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])({}, _constants.REBASE_MARK_KEY.REBASE_TYPE, _constants.REBASE_TYPE.MODIFY_MODIFY), _constants.REBASE_MARK_KEY.OLD_ELEMENT, masterElement), _constants.REBASE_MARK_KEY.ORIGIN, _constants.REBASE_ORIGIN.OTHER)), (0, _objectSpread9["default"])((0, _objectSpread9["default"])({}, newElement), {}, (0, _defineProperty2["default"])((0, _defineProperty2["default"])({}, _constants.REBASE_MARK_KEY.REBASE_TYPE, _constants.REBASE_TYPE.MODIFY_MODIFY), _constants.REBASE_MARK_KEY.ORIGIN, _constants.REBASE_ORIGIN.MY))];
+    }
+
+    // master is the same as base, indicating that revision has modified the content
+    if (_objectUtils["default"].isSameObject(masterElement, baseElement)) return [newElement];
+
+    // revision is the same as base, indicating that master has modified the content
+    if (_objectUtils["default"].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 [(0, _objectSpread9["default"])((0, _objectSpread9["default"])({}, (0, _helpers.replaceNodeId)(masterElement)), {}, (0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])({}, _constants.REBASE_MARK_KEY.REBASE_TYPE, _constants.REBASE_TYPE.MODIFY_MODIFY), _constants.REBASE_MARK_KEY.OLD_ELEMENT, masterElement), _constants.REBASE_MARK_KEY.ORIGIN, _constants.REBASE_ORIGIN.OTHER)), (0, _objectSpread9["default"])((0, _objectSpread9["default"])({}, newElement), {}, (0, _defineProperty2["default"])((0, _defineProperty2["default"])({}, _constants.REBASE_MARK_KEY.REBASE_TYPE, _constants.REBASE_TYPE.MODIFY_MODIFY), _constants.REBASE_MARK_KEY.ORIGIN, _constants.REBASE_ORIGIN.MY))];
+  }
+  if (modifyType === _constants.MODIFY_TYPE.CHILDREN_MODIFY) {
+    var _masterElement = (0, _objectSpread9["default"])({}, diffElement[_constants.REBASE_MARK_KEY.OLD_ELEMENT]);
+    delete newElement[_constants.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) {
+      return [(0, _objectSpread9["default"])((0, _objectSpread9["default"])({}, (0, _helpers.replaceNodeId)(_masterElement)), {}, (0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])({}, _constants.REBASE_MARK_KEY.REBASE_TYPE, _constants.REBASE_TYPE.MODIFY_MODIFY), _constants.REBASE_MARK_KEY.OLD_ELEMENT, _masterElement), _constants.REBASE_MARK_KEY.ORIGIN, _constants.REBASE_ORIGIN.OTHER)), (0, _objectSpread9["default"])((0, _objectSpread9["default"])({}, newElement), {}, (0, _defineProperty2["default"])((0, _defineProperty2["default"])({}, _constants.REBASE_MARK_KEY.REBASE_TYPE, _constants.REBASE_TYPE.MODIFY_MODIFY), _constants.REBASE_MARK_KEY.ORIGIN, _constants.REBASE_ORIGIN.MY))];
+    }
+    if (_objectUtils["default"].isSameObject(_masterElement, baseElement)) return _expandGroup(newElement);
+    if (_objectUtils["default"].isSameObject(newElement, baseElement)) return [_masterElement];
+    if (_objectUtils["default"].isSameObject(_masterElement, newElement, ['type'])) {
+      if (_objectUtils["default"].isSameObject(_masterElement, baseElement, ['type'])) return _expandGroup(newElement);
+      if (_objectUtils["default"].isSameObject(newElement, baseElement, ['type'])) return [_masterElement];
+    }
+
+    // The content of the subnode has changed and needs to be solved manually.
+    var childrenContent = getMergeContent(baseElement, diffElement.children);
+    return [(0, _objectSpread9["default"])((0, _objectSpread9["default"])({}, newElement), {}, {
+      children: childrenContent
+    })];
+  }
+  newElement[_constants.REBASE_MARK_KEY.OLD_ELEMENT] && delete newElement[_constants.REBASE_MARK_KEY.OLD_ELEMENT];
+  return _expandGroup(newElement);
+};
+var getMergeContent = function getMergeContent(baseContent, diffChanges) {
+  var childrenName = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'children';
+  var _generateIdMapAndIds3 = (0, _diff.generateIdMapAndIds)(diffChanges),
+    diffChangesContentMap = _generateIdMapAndIds3.map,
+    diffChangesContentIds = _generateIdMapAndIds3.ids;
+  var _generateIdMapAndIds4 = (0, _diff.generateIdMapAndIds)(baseContent[childrenName]),
+    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, (0, _toConsumableArray2["default"])(mergeElements));
+  });
+  return content;
+};
+var _canMerge = exports.canMerge = function canMerge(content, reference) {
+  if (_hasConflict(content)) return false;
+  if (!Array.isArray(reference) || reference.length === 0) return true;
+  var _generateIdMapAndIds5 = (0, _diff.generateIdMapAndIds)(reference),
+    referenceMap = _generateIdMapAndIds5.map;
+  var flag = true;
+  for (var i = 0; i < content.length; i++) {
+    var element = content[i];
+    var referenceElement = referenceMap[element.id];
+    if (!referenceElement) {
+      flag = false;
+      break;
+    }
+    flag = _canMerge(element.children, referenceElement.children);
+    if (flag === false) {
+      break;
+    }
+  }
+  return flag;
+};
+var updateContentToFormatVersion4 = function updateContentToFormatVersion4(content) {
+  if (content.format_version === 4) return;
+  content.format_version = 4;
+  content.elements = content.children;
+  delete content['children'];
+};
+
+// Only the data in baseContent needs to be formatted.
+// The data in the other two does not need to be formatted. They are directly obtained from sdoc-server.
+var getRebase = exports.getRebase = function getRebase(masterContent, baseContent, revisionContent) {
+  updateContentToFormatVersion4(baseContent);
+
+  // master no changes, merged directly
+  if (masterContent.version === baseContent.version) {
+    return {
+      canMerge: true,
+      isNeedReplaceMaster: true,
+      value: revisionContent
+    };
+  }
+
+  // The revision content has not changed
+  if (baseContent.version === revisionContent.version) {
+    return {
+      canMerge: true,
+      isNeedReplaceMaster: false,
+      value: masterContent
+    };
+  }
+  var diffChanges = _getChanges(masterContent, revisionContent, 'elements');
+  var content = getMergeContent(baseContent, diffChanges, 'elements');
+  return {
+    canMerge: _canMerge(content, revisionContent.elements),
+    isNeedReplaceMaster: true,
+    value: (0, _objectSpread9["default"])((0, _objectSpread9["default"])({}, revisionContent), {}, {
+      elements: content,
+      version: Math.max(masterContent.version, revisionContent.version) + 1
+    })
+  };
+};

package/dist/views/index.js

@@ -0,0 +1,41 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "DiffViewer", {
+  enumerable: true,
+  get: function get() {
+    return _sdocDiffViewer["default"];
+  }
+});
+Object.defineProperty(exports, "PublishedRevisionDiffViewer", {
+  enumerable: true,
+  get: function get() {
+    return _publishedRevisionDiffViewer["default"];
+  }
+});
+Object.defineProperty(exports, "RevisionDiffViewer", {
+  enumerable: true,
+  get: function get() {
+    return _revisionDiffViewer["default"];
+  }
+});
+Object.defineProperty(exports, "SDocViewer", {
+  enumerable: true,
+  get: function get() {
+    return _sdocViewer["default"];
+  }
+});
+Object.defineProperty(exports, "SDocWikiViewer", {
+  enumerable: true,
+  get: function get() {
+    return _sdocWikiViewer["default"];
+  }
+});
+var _publishedRevisionDiffViewer = _interopRequireDefault(require("./published-revision-diff-viewer"));
+var _revisionDiffViewer = _interopRequireDefault(require("./revision-diff-viewer"));
+var _sdocDiffViewer = _interopRequireDefault(require("./sdoc-diff-viewer"));
+var _sdocViewer = _interopRequireDefault(require("./sdoc-viewer"));
+var _sdocWikiViewer = _interopRequireDefault(require("./sdoc-wiki-viewer"));