@seafile/sdoc-editor 0.1.144 → 0.1.146-beta

package/dist/basic-sdk/layout/article-container.js

@@ -1,10 +1,9 @@
 import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import React, { useEffect, useRef, useState } from 'react';
+import React, { useCallback, useEffect, useRef, useState } from 'react';
 import { useScrollContext } from '../hooks/use-scroll-context';
 export default function ArticleContainer(_ref) {
   var editor = _ref.editor,
-    readOnly = _ref.readOnly,
     children = _ref.children;
   var articleRef = useRef(null);
   useEffect(function () {
@@ -16,24 +15,26 @@ export default function ArticleContainer(_ref) {
     _useState2 = _slicedToArray(_useState, 2),
     containerStyle = _useState2[0],
     setContainerStyle = _useState2[1];
+  var handleWindowResize = useCallback(function () {
+    var rect = scrollRef.current.getBoundingClientRect();
+    var articleRect = articleRef.current.getBoundingClientRect();
+    if ((rect.width - articleRect.width) / 2 < 280) {
+      setContainerStyle({
+        marginLeft: '280px'
+      });
+    } else {
+      setContainerStyle({});
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
   useEffect(function () {
-    if (readOnly) return;
-    var handleWindowResize = function handleWindowResize() {
-      var rect = scrollRef.current.getBoundingClientRect();
-      var articleRect = articleRef.current.getBoundingClientRect();
-      if ((rect.width - articleRect.width) / 2 < 280) {
-        setContainerStyle({
-          marginLeft: '280px'
-        });
-      } else {
-        setContainerStyle({});
-      }
-    };
+    handleWindowResize();
     window.addEventListener('resize', handleWindowResize);
     return function () {
       window.removeEventListener('resize', handleWindowResize);
     };
-  }, [readOnly, scrollRef]);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
   return /*#__PURE__*/React.createElement("div", {
     className: "sdoc-article-container",
     style: containerStyle
@@ -44,7 +45,4 @@ export default function ArticleContainer(_ref) {
     className: "article",
     ref: articleRef
   }, children[0]), _toConsumableArray(children.slice(1))));
-}
-ArticleContainer.defaultProps = {
-  readOnly: false
-};
+}

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,44 @@ var SocketClient = /*#__PURE__*/_createClass(function SocketClient(config) {
   this.disconnectWithServer = function () {
     _this.socket.disconnect();
   };
+  this.receiveRebaseDocument = function (document, originFileVersion) {
+    var socketManager = SocketManager.getInstance();
+    socketManager.receiveRebaseContent(document, originFileVersion);
+  };
+  this.sendRebaseDocument = function (document, originFileVersion, callback) {
+    debug('=========== send operations ==========');
+    debug('%O', document);
+    debug('======================================');
+    _this.socket.emit('rebase-document', _this.getParams({
+      document: document,
+      originFileVersion: originFileVersion
+    }), function (result) {
+      callback && callback(result);
+    });
+  };
+  this.sendPublishDocument = function (originFileURL, callback) {
+    _this.socket.emit('publish-document', _this.getParams({
+      originFileURL: originFileURL
+    }), function (result) {
+      callback && callback(result);
+    });
+  };
+  this.receivePublishDocument = function (originFileURL) {
+    var socketManager = SocketManager.getInstance();
+    socketManager.receivePublishDocument(originFileURL);
+  };
+  this.sendMergeDocument = function (document, originFileVersion, callback) {
+    _this.socket.emit('merge-document', _this.getParams({
+      document: document,
+      originFileVersion: originFileVersion
+    }), function (result) {
+      callback && callback(result);
+    });
+  };
+  this.receiveMergeDocument = function (document, originFileVersion) {
+    var socketManager = SocketManager.getInstance();
+    socketManager.receiveMergeDocument(document, originFileVersion);
+  };
   this.config = config;
   this.isReconnect = false;
   this.socket = io(config.sdocServer, {
@@ -133,6 +171,9 @@ 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);
+  this.socket.on('rebase-document', this.receiveRebaseDocument);
+  this.socket.on('merge-document', this.receiveMergeDocument);
+  this.socket.on('publish-document', this.receivePublishDocument);
   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 { 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,35 @@ 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.sendRebaseContent = function (document, originFileVersion) {
+    _this.socketClient.sendRebaseDocument(document, originFileVersion, function (result) {
+      var serverVersion = result.version;
+      _this.document['version'] = serverVersion;
+    });
+  };
+  this.sendPublishDocument = function (originFileURL) {
+    _this.socketClient.sendPublishDocument(originFileURL);
+  };
+  this.receivePublishContent = function (originFileURL) {
+    _this.eventBus.dispatch(EXTERNAL_EVENT.PUBLISH_DOCUMENT, originFileURL);
+  };
+  this.sendMergeDocument = function (document, originFileVersion) {
+    _this.socketClient.sendMergeDocument(document, originFileVersion, function (result) {
+      var serverVersion = result.version;
+      _this.document['version'] = serverVersion;
+    });
+  };
+  this.receiveMergeDocument = function (document, originFileVersion) {
+    _this.document = document;
+    _this.eventBus.dispatch(EXTERNAL_EVENT.MERGE_DOCUMENT, document, originFileVersion);
+  };
   this.onReceiveLocalOperations = function (operations) {
     _this.pendingOperationList.push(operations);
     if (_this.pendingOperationList.length > 5) {
@@ -34,6 +57,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;
@@ -285,7 +309,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 (originFileURL) {
+    var config = options.config;
+    var socketManager = SocketManager.getInstance(newEditor, document, config);
+    socketManager.sendPublishDocument(document, originFileURL);
+  };
+  newEditor.mergeDocument = function (document, originFileVersion) {
+    var config = options.config;
+    var socketManager = SocketManager.getInstance(newEditor, document, config);
+    socketManager.sendMergeDocument(document, originFileVersion);
+  };
   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,196 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { generateIdMapAndIds, getIdDiffs } from './diff';
+import ObjectUtils from './object-utils';
+import { MODIFY_TYPE, REBASE_TYPE } 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]), {}, {
+          modifyType: MODIFY_TYPE.ADD
+        });
+      });
+      content.push.apply(content, _toConsumableArray(addedList));
+    } else if (removed) {
+      var deletedList = value.map(function (item) {
+        return _objectSpread(_objectSpread({}, masterContentMap[item]), {}, {
+          modifyType: 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 oldElement = masterContentMap[elementId];
+          var currentElement = currentContentMap[elementId];
+          var newElement = _objectSpread(_objectSpread({}, currentElement), {}, {
+            modifyType: MODIFY_TYPE.MODIFY,
+            oldElement: oldElement
+          });
+          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['modifyType'] = 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.modifyType === MODIFY_TYPE.MODIFY) {
+          newElement['rebaseType'] = 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.oldElement)) {
+          var newElement = _objectSpread({}, currentElement);
+          newElement['oldElement'] && delete newElement['oldElement'];
+          newElement['modifyType'] && delete newElement['modifyType'];
+          content.push(newElement);
+
+          // Modify at the same time
+        } else if (currentElement.modifyType === MODIFY_TYPE.MODIFY) {
+          var oldMasterElement = replaceNodeId(_objectSpread(_objectSpread({}, masterElement), {}, {
+            rebaseType: REBASE_TYPE.MODIFY_MODIFY,
+            origin: 'master'
+          }));
+          content.push(oldMasterElement);
+          var _newElement = _objectSpread(_objectSpread({}, currentElement), {}, {
+            rebaseType: REBASE_TYPE.MODIFY_MODIFY,
+            origin: 'current'
+          });
+          _newElement['modifyType'] && delete _newElement['modifyType'];
+          _newElement['oldElement'] && delete _newElement['oldElement'];
+          content.push(_newElement);
+          canMerge = false;
+
+          // children modify
+        } else if (currentElement.modifyType === 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), {}, {
+              children: childrenContent,
+              rebaseType: REBASE_TYPE.CHILDREN_MODIFY
+            }));
+          } else {
+            var _oldMasterElement = replaceNodeId(_objectSpread(_objectSpread({}, masterElement), {}, {
+              rebaseType: REBASE_TYPE.MODIFY_MODIFY,
+              origin: 'master'
+            }));
+            content.push(_oldMasterElement);
+            var _newElement2 = _objectSpread(_objectSpread({}, currentElement.oldElement), {}, {
+              rebaseType: REBASE_TYPE.MODIFY_MODIFY,
+              origin: 'current'
+            });
+            content.push(_newElement2);
+          }
+        } else {
+          var _newElement3 = _objectSpread({}, currentElement);
+          _newElement3['oldElement'] && delete _newElement3['oldElement'];
+          _newElement3['modifyType'] && delete _newElement3['modifyType'];
+          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
+    })
+  };
+};

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

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

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

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

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

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

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

@@ -5,17 +5,25 @@ import ViewChanges from './view-changes';
 import MoreRevisionOperations from './more-revision-operations';
 import Revisions from './revisions';
 import ChangesCount from './changes-count';
+import { MODE } from '../../../constants';
 var RevisionOperations = function RevisionOperations(_ref) {
   var isShowChanges = _ref.isShowChanges,
     changes = _ref.changes,
-    toggleViewChanges = _ref.toggleViewChanges;
+    toggleViewChanges = _ref.toggleViewChanges,
+    publishRevision = _ref.publishRevision,
+    mode = _ref.mode,
+    abortRebase = _ref.abortRebase;
   var isSdocRevision = context.getSetting('isSdocRevision');
   var isPublished = context.getSetting('isPublished');
   return /*#__PURE__*/React.createElement(React.Fragment, null, !isSdocRevision && /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(MoreRevisionOperations, null), /*#__PURE__*/React.createElement(Revisions, null)), isSdocRevision && isShowChanges && /*#__PURE__*/React.createElement(ChangesCount, {
     changes: changes
-  }), isSdocRevision && /*#__PURE__*/React.createElement(ViewChanges, {
+  }), isSdocRevision && mode !== MODE.REBASE && /*#__PURE__*/React.createElement(ViewChanges, {
     isShowChanges: isShowChanges,
     toggleViewChanges: toggleViewChanges
-  }), isSdocRevision && !isPublished && /*#__PURE__*/React.createElement(PublishRevision, null));
+  }), isSdocRevision && !isPublished && /*#__PURE__*/React.createElement(PublishRevision, {
+    publishRevision: publishRevision,
+    mode: mode,
+    abortRebase: abortRebase
+  }));
 };
 export default RevisionOperations;

package/dist/components/doc-operations/revision-operations/publish-button.js

@@ -1,28 +1,31 @@
 import React, { useCallback } from 'react';
+import { useTranslation } from 'react-i18next';
 import { Button } from 'reactstrap';
-import { withTranslation } from 'react-i18next';
-import context from '../../../context';
-import toaster from '../../../components/toast';
+import { MODE } from '../../../constants';
 var PublishRevision = function PublishRevision(_ref) {
-  var t = _ref.t;
-  var repoID = context.getSetting('repoID');
-  var siteRoot = context.getSetting('siteRoot');
+  var mode = _ref.mode,
+    publishRevision = _ref.publishRevision,
+    abortRebase = _ref.abortRebase;
+  var _useTranslation = useTranslation(),
+    t = _useTranslation.t;
   var publish = useCallback(function (event) {
     event.stopPropagation();
     event.nativeEvent.stopImmediatePropagation();
-    context.publishSdocRevision().then(function (res) {
-      var origin_file_path = res.data.origin_file_path;
-      window.location.href = "".concat(siteRoot, "lib/").concat(repoID, "/file/").concat(origin_file_path);
-    }).catch(function (error) {
-      toaster.danger(t('Error'));
-    });
+    publishRevision();
 
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
+  if (mode === MODE.REBASE) {
+    return /*#__PURE__*/React.createElement(Button, {
+      color: "success",
+      onClick: abortRebase,
+      className: "ml-4"
+    }, t('Abort'));
+  }
   return /*#__PURE__*/React.createElement(Button, {
     color: "success",
     onClick: publish,
     className: "ml-4"
   }, t('Publish'));
 };
-export default withTranslation('sdoc-editor')(PublishRevision);
+export default PublishRevision;