@seafile/sdoc-editor 1.0.54 → 1.0.55

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

@@ -1,4 +1,10 @@
-export const getDomHeight = dom => {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSelectionRange = exports.getDomMarginTop = exports.getDomHeight = exports.getCursorPosition = void 0;
+const getDomHeight = dom => {
   const styles = window.getComputedStyle(dom);
   const rect = dom.getBoundingClientRect();
   const marginTop = styles['marginTop'];
@@ -9,12 +15,14 @@ export const getDomHeight = dom => {
   } = rect;
   return height + parseInt(marginTop);
 };
-export const getDomMarginTop = dom => {
+exports.getDomHeight = getDomHeight;
+const getDomMarginTop = dom => {
   const styles = window.getComputedStyle(dom);
   const marginTop = styles['marginTop'];
   return parseInt(marginTop);
 };
-export const getSelectionRange = () => {
+exports.getDomMarginTop = getDomMarginTop;
+const getSelectionRange = () => {
   if (window.getSelection) {
     const sel = window.getSelection();
     if (sel.getRangeAt && sel.rangeCount) {
@@ -25,7 +33,8 @@ export const getSelectionRange = () => {
   }
   return null;
 };
-export const getCursorPosition = function () {
+exports.getSelectionRange = getSelectionRange;
+const getCursorPosition = function () {
   let isScrollUp = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
   let x = 0;
   let y = 0;
@@ -44,4 +53,5 @@ export const getCursorPosition = function () {
     x: x,
     y: y
   };
-};
+};
+exports.getCursorPosition = getCursorPosition;

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

@@ -1,3 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
 class EventBus {
   constructor() {
     this.instance = null;
@@ -31,4 +37,4 @@ class EventBus {
     }
   }
 }
-export default EventBus;
+var _default = exports.default = EventBus;

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

@@ -1,13 +1,20 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-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';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/defineProperty"));
+var _isHotkey = _interopRequireDefault(require("is-hotkey"));
+var _eventBus = _interopRequireDefault(require("../utils/event-bus"));
+var _queries = require("../extension/core/queries/");
+var _documentUtils = require("./document-utils");
+var _constants = require("../extension/constants");
+var _constants2 = require("../constants");
 class EventProxy {
   constructor(_editor) {
-    _defineProperty(this, "onKeyDown", event => {
+    (0, _defineProperty2.default)(this, "onKeyDown", event => {
       const editor = this.editor;
       if (editor.onHotKeyDown) {
         const isHandled = editor.onHotKeyDown(event);
@@ -15,34 +22,34 @@ class EventProxy {
       }
 
       // bold
-      if (isHotkey('mod+b', event)) {
+      if ((0, _isHotkey.default)('mod+b', event)) {
         event.preventDefault();
         editor.toggleTextBold();
       }
 
       // italic
-      if (isHotkey('mod+i', event)) {
+      if ((0, _isHotkey.default)('mod+i', event)) {
         event.preventDefault();
         editor.toggleTextItalic();
       }
 
       // font scale
-      if (isHotkey('opt+.', event)) {
+      if ((0, _isHotkey.default)('opt+.', event)) {
         event.preventDefault();
         editor.increaseFontSize();
       }
-      if (isHotkey('opt+,', event)) {
+      if ((0, _isHotkey.default)('opt+,', event)) {
         event.preventDefault();
         editor.reduceFontSize();
       }
 
       // disable the default 'save page'
-      if (isHotkey('mod+s', event)) {
+      if ((0, _isHotkey.default)('mod+s', event)) {
         event.preventDefault();
       }
 
       // redo
-      if (isHotkey('mod+y', event)) {
+      if ((0, _isHotkey.default)('mod+y', event)) {
         event.preventDefault();
         const {
           history
@@ -54,7 +61,7 @@ class EventProxy {
       }
 
       // undo
-      if (isHotkey('mod+z', event)) {
+      if ((0, _isHotkey.default)('mod+z', event)) {
         event.preventDefault();
         const {
           history
@@ -64,54 +71,54 @@ class EventProxy {
         }
         editor.undo();
       }
-      if (isHotkey('tab', event) || isHotkey('shift+tab', event)) {
+      if ((0, _isHotkey.default)('tab', event) || (0, _isHotkey.default)('shift+tab', event)) {
         editor.handleTab && editor.handleTab(event);
       }
-      if (isHotkey('mod+p', event)) {
+      if ((0, _isHotkey.default)('mod+p', event)) {
         event.preventDefault();
-        const eventBus = EventBus.getInstance();
-        eventBus.dispatch(INTERNAL_EVENT.ON_PRINT);
+        const eventBus = _eventBus.default.getInstance();
+        eventBus.dispatch(_constants2.INTERNAL_EVENT.ON_PRINT);
       }
-      const node = getSelectedNodeByType(editor, ELEMENT_TYPE.TABLE);
+      const node = (0, _queries.getSelectedNodeByType)(editor, _constants.ELEMENT_TYPE.TABLE);
       if (node) {
         this.editor.tableOnKeyDown(event);
       }
-      const imageNode = getSelectedNodeByType(editor, ELEMENT_TYPE.IMAGE);
+      const imageNode = (0, _queries.getSelectedNodeByType)(editor, _constants.ELEMENT_TYPE.IMAGE);
       if (imageNode) {
         this.editor.imageOnKeyDown(event);
       }
-      if (getSelectedNodeByType(editor, ELEMENT_TYPE.CODE_BLOCK)) {
+      if ((0, _queries.getSelectedNodeByType)(editor, _constants.ELEMENT_TYPE.CODE_BLOCK)) {
         this.editor.codeBlockOnKeyDown(event);
-        const eventBus = EventBus.getInstance();
-        eventBus.dispatch(INTERNAL_EVENT.HIDDEN_CODE_BLOCK_HOVER_MENU);
+        const eventBus = _eventBus.default.getInstance();
+        eventBus.dispatch(_constants2.INTERNAL_EVENT.HIDDEN_CODE_BLOCK_HOVER_MENU);
       }
     });
-    _defineProperty(this, "onCopy", event => {
+    (0, _defineProperty2.default)(this, "onCopy", event => {
       if (this.editor.onCopy) this.editor.onCopy(event);
-      setOriginSdocKey(event);
+      (0, _documentUtils.setOriginSdocKey)(event);
     });
-    _defineProperty(this, "onCut", event => {
-      setOriginSdocKey(event);
+    (0, _defineProperty2.default)(this, "onCut", event => {
+      (0, _documentUtils.setOriginSdocKey)(event);
       if (this.editor.cut) {
         this.editor.cut(event);
       }
     });
-    _defineProperty(this, "onPaste", event => {});
-    _defineProperty(this, "onCompositionStart", event => {
+    (0, _defineProperty2.default)(this, "onPaste", event => {});
+    (0, _defineProperty2.default)(this, "onCompositionStart", event => {
       const editor = this.editor;
       if (editor.onCompositionStart) {
         const isHandled = editor.onCompositionStart(event);
         if (isHandled) return;
       }
     });
-    _defineProperty(this, "onCompositionUpdate", event => {
+    (0, _defineProperty2.default)(this, "onCompositionUpdate", event => {
       const editor = this.editor;
       if (editor.onCompositionUpdate) {
         const isHandled = editor.onCompositionUpdate(event);
         if (isHandled) return;
       }
     });
-    _defineProperty(this, "onCompositionEnd", event => {
+    (0, _defineProperty2.default)(this, "onCompositionEnd", event => {
       const editor = this.editor;
       if (editor.onCompositionUpdate) {
         const isHandled = editor.onCompositionEnd(event);
@@ -121,4 +128,4 @@ class EventProxy {
     this.editor = _editor;
   }
 }
-export default EventProxy;
+var _default = exports.default = EventProxy;

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

@@ -1,21 +1,30 @@
-export const eventStopPropagation = event => {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.unregisterResizeEvents = exports.registerResizeEvents = exports.getMouseMoveInfo = exports.getMouseDownInfo = exports.eventStopPropagation = exports.createObjectWithProperties = void 0;
+const eventStopPropagation = event => {
   if (!event) return;
   event.stopPropagation();
   event.nativeEvent && event.nativeEvent.stopImmediatePropagation && event.nativeEvent.stopImmediatePropagation();
 };
-export const registerResizeEvents = function () {
+exports.eventStopPropagation = eventStopPropagation;
+const registerResizeEvents = function () {
   let eventsMap = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   for (let key in eventsMap) {
     document.addEventListener(key, eventsMap[key]);
   }
 };
-export const unregisterResizeEvents = function () {
+exports.registerResizeEvents = registerResizeEvents;
+const unregisterResizeEvents = function () {
   let eventsMap = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   for (let key in eventsMap) {
     document.removeEventListener(key, eventsMap[key]);
   }
 };
-export const getMouseDownInfo = (event, scrollContainer) => {
+exports.unregisterResizeEvents = unregisterResizeEvents;
+const getMouseDownInfo = (event, scrollContainer) => {
   let positionX = 0;
   let positionY = 0;
   let scrollLeft = 0;
@@ -35,7 +44,8 @@ export const getMouseDownInfo = (event, scrollContainer) => {
     scrollTop
   };
 };
-export const getMouseMoveInfo = (event, mouseDownInfo, scrollContainer) => {
+exports.getMouseDownInfo = getMouseDownInfo;
+const getMouseMoveInfo = (event, mouseDownInfo, scrollContainer) => {
   let displacementX = 0;
   let displacementY = 0;
   if (!event) return {
@@ -59,11 +69,13 @@ export const getMouseMoveInfo = (event, mouseDownInfo, scrollContainer) => {
     displacementY
   };
 };
-export const createObjectWithProperties = (originalObj, properties) => {
+exports.getMouseMoveInfo = getMouseMoveInfo;
+const createObjectWithProperties = (originalObj, properties) => {
   return properties.reduce((result, property) => {
     if (property in originalObj) {
       result[property] = originalObj[property];
     }
     return result;
   }, {});
-};
+};
+exports.createObjectWithProperties = createObjectWithProperties;

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

@@ -1,5 +1,12 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-var _class;
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/defineProperty"));
+var _ObjectUtils;
 class ObjectUtils {
   static getDataType(data) {
     let type = typeof data;
@@ -13,7 +20,7 @@ class ObjectUtils {
   }
   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)));
+      throw new Error(`source should be a Object or Array , but got ${this.getDataType(source)}`);
     }
     if (this.getDataType(source) !== this.getDataType(comparison)) {
       return true;
@@ -40,12 +47,12 @@ class ObjectUtils {
     return !this.isObjectChanged(source, comparison, notIncludeKeys);
   }
 }
-_class = ObjectUtils;
-_defineProperty(ObjectUtils, "isObject", data => {
-  return _class.getDataType(data) === 'Object';
+_ObjectUtils = ObjectUtils;
+(0, _defineProperty2.default)(ObjectUtils, "isObject", data => {
+  return _ObjectUtils.getDataType(data) === 'Object';
 });
-_defineProperty(ObjectUtils, "hasProperty", (obj, prop) => {
+(0, _defineProperty2.default)(ObjectUtils, "hasProperty", (obj, prop) => {
   if (!obj) return false;
   return Object.prototype.hasOwnProperty.call(obj, prop);
 });
-export default ObjectUtils;
+var _default = exports.default = ObjectUtils;

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

@@ -1,9 +1,16 @@
-import { generateIdMapAndIds, getIdDiffs } from './diff';
-import ObjectUtils from './object-utils';
-import { MODIFY_TYPE, REBASE_TYPE, REBASE_MARK_KEY, REBASE_ORIGIN, REBASE_TYPES } from '../constants';
-import { ELEMENT_TYPE } from '../extension/constants';
-import { replaceNodeId } from '../node-id/helpers';
-export const hasConflict = content => {
+"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 _diff = require("./diff");
+var _objectUtils = _interopRequireDefault(require("./object-utils"));
+var _constants = require("../constants");
+var _constants2 = require("../extension/constants");
+var _helpers = require("../node-id/helpers");
+const hasConflict = content => {
   if (!Array.isArray(content) || content.length === 0) return false;
   let flag = false;
   for (let i = 0; i < content.length; i++) {
@@ -12,7 +19,7 @@ export const hasConflict = content => {
       rebase_type,
       children
     } = element;
-    if (REBASE_TYPES.includes(rebase_type)) {
+    if (_constants.REBASE_TYPES.includes(rebase_type)) {
       flag = true;
       break;
     } else {
@@ -24,16 +31,17 @@ export const hasConflict = content => {
   }
   return flag;
 };
+exports.hasConflict = hasConflict;
 const getChanges = (masterContent, revisionContent) => {
   const {
     map: masterContentMap,
     ids: masterIds
-  } = generateIdMapAndIds(masterContent.children);
+  } = (0, _diff.generateIdMapAndIds)(masterContent.children);
   const {
     map: currentContentMap,
     ids: currentIds
-  } = generateIdMapAndIds(revisionContent.children);
-  const idDiffs = getIdDiffs(masterIds, currentIds);
+  } = (0, _diff.generateIdMapAndIds)(revisionContent.children);
+  const idDiffs = (0, _diff.getIdDiffs)(masterIds, currentIds);
   let content = [];
   idDiffs.forEach(idDiff => {
     const {
@@ -44,32 +52,32 @@ const getChanges = (masterContent, revisionContent) => {
     if (added) {
       const addedList = value.map(item => ({
         ...currentContentMap[item],
-        [REBASE_MARK_KEY.MODIFY_TYPE]: MODIFY_TYPE.ADD
+        [_constants.REBASE_MARK_KEY.MODIFY_TYPE]: _constants.MODIFY_TYPE.ADD
       }));
       content.push(...addedList);
     } else if (removed) {
       const deletedList = value.map(item => ({
         ...masterContentMap[item],
-        [REBASE_MARK_KEY.MODIFY_TYPE]: MODIFY_TYPE.DELETE
+        [_constants.REBASE_MARK_KEY.MODIFY_TYPE]: _constants.MODIFY_TYPE.DELETE
       }));
       content.push(...deletedList);
     } else {
       value.forEach(elementId => {
-        if (ObjectUtils.isSameObject(masterContentMap[elementId], currentContentMap[elementId])) {
+        if (_objectUtils.default.isSameObject(masterContentMap[elementId], currentContentMap[elementId])) {
           content.push(currentContentMap[elementId]);
         } else {
           const oldElement = masterContentMap[elementId];
           const currentElement = currentContentMap[elementId];
           let newElement = {
             ...currentElement,
-            [REBASE_MARK_KEY.MODIFY_TYPE]: MODIFY_TYPE.MODIFY,
-            [REBASE_MARK_KEY.OLD_ELEMENT]: oldElement
+            [_constants.REBASE_MARK_KEY.MODIFY_TYPE]: _constants.MODIFY_TYPE.MODIFY,
+            [_constants.REBASE_MARK_KEY.OLD_ELEMENT]: oldElement
           };
           if (currentElement.type === oldElement.type) {
             const elementType = currentElement.type;
-            if ([ELEMENT_TYPE.UNORDERED_LIST, ELEMENT_TYPE.ORDERED_LIST].includes(elementType)) {
+            if ([_constants2.ELEMENT_TYPE.UNORDERED_LIST, _constants2.ELEMENT_TYPE.ORDERED_LIST].includes(elementType)) {
               const listContent = getChanges(oldElement, currentElement);
-              newElement[REBASE_MARK_KEY.MODIFY_TYPE] = MODIFY_TYPE.CHILDREN_MODIFY;
+              newElement[_constants.REBASE_MARK_KEY.MODIFY_TYPE] = _constants.MODIFY_TYPE.CHILDREN_MODIFY;
               newElement['children'] = listContent;
             }
           }
@@ -81,20 +89,20 @@ const getChanges = (masterContent, revisionContent) => {
   return content;
 };
 const getMergeElement = (diffElement, baseElement) => {
-  const modifyType = diffElement[REBASE_MARK_KEY.MODIFY_TYPE];
+  const modifyType = diffElement[_constants.REBASE_MARK_KEY.MODIFY_TYPE];
   const newElement = {
     ...diffElement
   };
-  newElement[REBASE_MARK_KEY.MODIFY_TYPE] && delete newElement[REBASE_MARK_KEY.MODIFY_TYPE];
+  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 === MODIFY_TYPE.DELETE) {
+  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 [newElement];
 
     // base content has this element, master modified it, indicating that revision deleted it, and the user manually selected the conflict
-    if (!ObjectUtils.isSameObject(baseElement, diffElement, [REBASE_MARK_KEY.MODIFY_TYPE])) {
-      newElement[REBASE_MARK_KEY.REBASE_TYPE] = REBASE_TYPE.MODIFY_DELETE;
+    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];
     }
 
@@ -103,13 +111,13 @@ const getMergeElement = (diffElement, baseElement) => {
   }
 
   // revision has this element, master does not have this element
-  if (modifyType === MODIFY_TYPE.ADD) {
+  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 [newElement];
 
     // master deleted it, revision modified it, and the user manually selected the conflict
-    if (!ObjectUtils.isSameObject(baseElement, diffElement, [REBASE_MARK_KEY.MODIFY_TYPE])) {
-      newElement[REBASE_MARK_KEY.REBASE_TYPE] = REBASE_TYPE.DELETE_MODIFY;
+    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];
     }
 
@@ -118,68 +126,68 @@ const getMergeElement = (diffElement, baseElement) => {
   }
 
   // Elements that differ between revision and master
-  if (modifyType === MODIFY_TYPE.MODIFY) {
+  if (modifyType === _constants.MODIFY_TYPE.MODIFY) {
     const masterElement = {
-      ...diffElement[REBASE_MARK_KEY.OLD_ELEMENT]
+      ...diffElement[_constants.REBASE_MARK_KEY.OLD_ELEMENT]
     };
-    delete newElement[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 [{
-        ...replaceNodeId(masterElement),
-        [REBASE_MARK_KEY.REBASE_TYPE]: REBASE_TYPE.MODIFY_MODIFY,
-        [REBASE_MARK_KEY.OLD_ELEMENT]: masterElement,
-        [REBASE_MARK_KEY.ORIGIN]: REBASE_ORIGIN.OTHER
+        ...(0, _helpers.replaceNodeId)(masterElement),
+        [_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
       }, {
         ...newElement,
-        [REBASE_MARK_KEY.REBASE_TYPE]: REBASE_TYPE.MODIFY_MODIFY,
-        [REBASE_MARK_KEY.ORIGIN]: REBASE_ORIGIN.MY
+        [_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.isSameObject(masterElement, baseElement)) return [newElement];
+    if (_objectUtils.default.isSameObject(masterElement, baseElement)) return [newElement];
 
     // revision is the same as base, indicating that master has modified the content
-    if (ObjectUtils.isSameObject(newElement, baseElement)) return [masterElement];
+    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 [{
-      ...replaceNodeId(masterElement),
-      [REBASE_MARK_KEY.REBASE_TYPE]: REBASE_TYPE.MODIFY_MODIFY,
-      [REBASE_MARK_KEY.OLD_ELEMENT]: masterElement,
-      [REBASE_MARK_KEY.ORIGIN]: REBASE_ORIGIN.OTHER
+      ...(0, _helpers.replaceNodeId)(masterElement),
+      [_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
     }, {
       ...newElement,
-      [REBASE_MARK_KEY.REBASE_TYPE]: REBASE_TYPE.MODIFY_MODIFY,
-      [REBASE_MARK_KEY.ORIGIN]: REBASE_ORIGIN.MY
+      [_constants.REBASE_MARK_KEY.REBASE_TYPE]: _constants.REBASE_TYPE.MODIFY_MODIFY,
+      [_constants.REBASE_MARK_KEY.ORIGIN]: _constants.REBASE_ORIGIN.MY
     }];
   }
-  if (modifyType === MODIFY_TYPE.CHILDREN_MODIFY) {
+  if (modifyType === _constants.MODIFY_TYPE.CHILDREN_MODIFY) {
     const masterElement = {
-      ...diffElement[REBASE_MARK_KEY.OLD_ELEMENT]
+      ...diffElement[_constants.REBASE_MARK_KEY.OLD_ELEMENT]
     };
-    delete newElement[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 [{
-        ...replaceNodeId(masterElement),
-        [REBASE_MARK_KEY.REBASE_TYPE]: REBASE_TYPE.MODIFY_MODIFY,
-        [REBASE_MARK_KEY.OLD_ELEMENT]: masterElement,
-        [REBASE_MARK_KEY.ORIGIN]: REBASE_ORIGIN.OTHER
+        ...(0, _helpers.replaceNodeId)(masterElement),
+        [_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
       }, {
         ...newElement,
-        [REBASE_MARK_KEY.REBASE_TYPE]: REBASE_TYPE.MODIFY_MODIFY,
-        [REBASE_MARK_KEY.ORIGIN]: REBASE_ORIGIN.MY
+        [_constants.REBASE_MARK_KEY.REBASE_TYPE]: _constants.REBASE_TYPE.MODIFY_MODIFY,
+        [_constants.REBASE_MARK_KEY.ORIGIN]: _constants.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.default.isSameObject(masterElement, baseElement)) return [newElement];
+    if (_objectUtils.default.isSameObject(newElement, baseElement)) return [masterElement];
+    if (_objectUtils.default.isSameObject(masterElement, newElement, ['type'])) {
+      if (_objectUtils.default.isSameObject(masterElement, baseElement, ['type'])) return [newElement];
+      if (_objectUtils.default.isSameObject(newElement, baseElement, ['type'])) return [masterElement];
     }
 
     // The content of the subnode has changed and needs to be solved manually.
@@ -189,17 +197,17 @@ const getMergeElement = (diffElement, baseElement) => {
       children: childrenContent
     }];
   }
-  newElement[REBASE_MARK_KEY.OLD_ELEMENT] && delete newElement[REBASE_MARK_KEY.OLD_ELEMENT];
+  newElement[_constants.REBASE_MARK_KEY.OLD_ELEMENT] && delete newElement[_constants.REBASE_MARK_KEY.OLD_ELEMENT];
   return [newElement];
 };
 const getMergeContent = (baseContent, diffChanges) => {
   const {
     map: diffChangesContentMap,
     ids: diffChangesContentIds
-  } = generateIdMapAndIds(diffChanges);
+  } = (0, _diff.generateIdMapAndIds)(diffChanges);
   const {
     map: baseContentMap
-  } = generateIdMapAndIds(baseContent.children);
+  } = (0, _diff.generateIdMapAndIds)(baseContent.children);
   let content = [];
   diffChangesContentIds.forEach(elementId => {
     const diffElement = diffChangesContentMap[elementId];
@@ -209,12 +217,12 @@ const getMergeContent = (baseContent, diffChanges) => {
   });
   return content;
 };
-export const canMerge = (content, reference) => {
+const canMerge = (content, reference) => {
   if (hasConflict(content)) return false;
   if (!Array.isArray(reference) || reference.length === 0) return true;
   const {
     map: referenceMap
-  } = generateIdMapAndIds(reference);
+  } = (0, _diff.generateIdMapAndIds)(reference);
   let flag = true;
   for (let i = 0; i < content.length; i++) {
     const element = content[i];
@@ -230,7 +238,8 @@ export const canMerge = (content, reference) => {
   }
   return flag;
 };
-export const getRebase = (masterContent, baseContent, revisionContent) => {
+exports.canMerge = canMerge;
+const getRebase = (masterContent, baseContent, revisionContent) => {
   // master no changes, merged directly
   if (masterContent.version === baseContent.version) {
     return {
@@ -259,4 +268,5 @@ export const getRebase = (masterContent, baseContent, revisionContent) => {
       version: Math.max(masterContent.version, revisionContent.version) + 1
     }
   };
-};
+};
+exports.getRebase = getRebase;

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

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