@seafile/sdoc-editor 2.0.81 → 2.0.83

package/dist/socket/socket-client.js

@@ -0,0 +1,207 @@
+"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 _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/createClass"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/classCallCheck"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/defineProperty"));
+var _socket = _interopRequireDefault(require("socket.io-client"));
+var _debug = require("../utils/debug");
+var _socketManager = _interopRequireDefault(require("./socket-manager"));
+var SocketClient = /*#__PURE__*/(0, _createClass2["default"])(function SocketClient(config) {
+  var _this = this;
+  (0, _classCallCheck2["default"])(this, SocketClient);
+  (0, _defineProperty2["default"])(this, "getParams", function () {
+    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var _this$config = _this.config,
+      docUuid = _this$config.docUuid,
+      user = _this$config.user;
+    return (0, _objectSpread2["default"])({
+      doc_uuid: docUuid,
+      user: user
+    }, params);
+  });
+  (0, _defineProperty2["default"])(this, "onConnected", function () {
+    // join room
+    _this.socket.emit('join-room', function (result) {
+      var socketManager = _socketManager["default"].getInstance();
+      if (result.success) {
+        // sync operations or document
+        if (_this.isReconnect) {
+          _this.isReconnect = false;
+          // The reconnect of socketManager needs to be triggered after entering the room again
+          socketManager.onReconnect(result);
+        }
+        socketManager.dispatchConnectState('onConnected', result);
+        return;
+      }
+
+      // Disconnect the server in the client side. There will be no reconnection.
+      _this.socket.disconnect();
+      socketManager.dispatchConnectState('connect-error', result);
+    });
+  });
+  (0, _defineProperty2["default"])(this, "onReconnect", function (data) {
+    (0, _debug.clientDebug)('reconnect.');
+    _this.isReconnect = true;
+    var socketManager = _socketManager["default"].getInstance();
+    socketManager.dispatchConnectState('reconnect');
+  });
+  (0, _defineProperty2["default"])(this, "onReconnectAttempt", function (attemptNumber) {
+    (0, _debug.clientDebug)('reconnect_attempt. %s', attemptNumber);
+    var socketManager = _socketManager["default"].getInstance();
+    socketManager.dispatchConnectState('reconnect_attempt', attemptNumber);
+  });
+  (0, _defineProperty2["default"])(this, "onReconnectError", function () {
+    (0, _debug.clientDebug)('reconnect_error.');
+    var socketManager = _socketManager["default"].getInstance();
+    socketManager.dispatchConnectState('reconnect_error');
+  });
+  (0, _defineProperty2["default"])(this, "onDisconnected", function (data) {
+    (0, _debug.clientDebug)('disconnect message: %s', data);
+    var socketManager = _socketManager["default"].getInstance();
+    socketManager.dispatchConnectState('disconnect');
+  });
+  (0, _defineProperty2["default"])(this, "onConnectError", function (e) {
+    (0, _debug.clientDebug)('connect_error.');
+    var socketManager = _socketManager["default"].getInstance();
+    socketManager.dispatchConnectState('connect_error');
+  });
+  (0, _defineProperty2["default"])(this, "sendOperations", function (operations, version, selection, callback) {
+    (0, _debug.clientDebug)('send operations: %O', operations);
+    _this.socket.emit('update-document', _this.getParams({
+      operations: operations,
+      version: version,
+      selection: selection
+    }), function (result) {
+      callback && callback(result);
+    });
+  });
+  (0, _defineProperty2["default"])(this, "onJoinRoom", function (userInfo) {
+    (0, _debug.serverDebug)('%s joined room success.', userInfo.username);
+    var socketManager = _socketManager["default"].getInstance();
+    socketManager.dispatchConnectState('join-room', userInfo);
+  });
+  (0, _defineProperty2["default"])(this, "onLeaveRoom", function (username) {
+    (0, _debug.serverDebug)('%s leaved room success.', username);
+    var socketManager = _socketManager["default"].getInstance();
+    socketManager.dispatchConnectState('leave-room', username);
+  });
+  /**
+   * receive remote broadcast operations
+   * @param {*} params {operations, version}
+   */
+  (0, _defineProperty2["default"])(this, "onReceiveRemoteOperations", function (params) {
+    (0, _debug.serverDebug)('receive operations: %O', params);
+    var socketManager = _socketManager["default"].getInstance();
+    socketManager.onReceiveRemoteOperations(params);
+  });
+  (0, _defineProperty2["default"])(this, "getRecentOperations", function () {
+    var docUuid = _this.config.docUuid;
+    var socketManager = _socketManager["default"].getInstance();
+    var clientVersion = socketManager.getDocumentVersion();
+    _this.socket.emit('sync-document', {
+      doc_uuid: docUuid,
+      version: clientVersion
+    }, function (result) {
+      if (result.success) {
+        socketManager.onGetRecentOperations(result);
+      }
+    });
+  });
+  (0, _defineProperty2["default"])(this, "sendCursorLocation", function (location) {
+    var cursor_data = _this.config.cursorData;
+    _this.socket.emit('update-cursor', _this.getParams({
+      location: location,
+      cursor_data: cursor_data
+    }));
+  });
+  (0, _defineProperty2["default"])(this, "receiveCursorLocation", function (params) {
+    var socketManager = _socketManager["default"].getInstance();
+    socketManager.receiveCursorLocation(params);
+  });
+  (0, _defineProperty2["default"])(this, "disconnectWithServer", function () {
+    _this.socket.disconnect();
+  });
+  (0, _defineProperty2["default"])(this, "receivePublishDocument", function () {
+    var socketManager = _socketManager["default"].getInstance();
+    socketManager.receivePublishDocument();
+  });
+  (0, _defineProperty2["default"])(this, "receivePublishDocumentError", function () {
+    var socketManager = _socketManager["default"].getInstance();
+    socketManager.receivePublishDocumentError();
+  });
+  (0, _defineProperty2["default"])(this, "receiveDocumentReplaced", function () {
+    var socketManager = _socketManager["default"].getInstance();
+    socketManager.receiveDocumentReplaced();
+  });
+  (0, _defineProperty2["default"])(this, "receiveDocumentReplacedError", function () {
+    var socketManager = _socketManager["default"].getInstance();
+    socketManager.receiveDocumentReplacedError();
+  });
+  (0, _defineProperty2["default"])(this, "receiveRemoveDocument", function () {
+    var socketManager = _socketManager["default"].getInstance();
+    socketManager.receiveRemoveDocument();
+  });
+  (0, _defineProperty2["default"])(this, "receiveRemoveDocumentError", function () {
+    var socketManager = _socketManager["default"].getInstance();
+    socketManager.receiveRemoveDocumentError();
+  });
+  (0, _defineProperty2["default"])(this, "receiveNewNotification", function (notification) {
+    var socketManager = _socketManager["default"].getInstance();
+    socketManager.receiveNewNotification(notification);
+  });
+  (0, _defineProperty2["default"])(this, "receiveParticipantAdded", function (uses) {
+    var socketManager = _socketManager["default"].getInstance();
+    socketManager.receiveParticipantAdded(uses);
+  });
+  (0, _defineProperty2["default"])(this, "receiveParticipantRemoved", function (email) {
+    var socketManager = _socketManager["default"].getInstance();
+    socketManager.receiveParticipantRemoved(email);
+  });
+  this.config = config;
+  this.isReconnect = false;
+  this.socket = (0, _socket["default"])(config.sdocServer, {
+    reconnection: true,
+    auth: {
+      token: config.accessToken
+    },
+    query: {
+      'sdoc_uuid': config.docUuid
+    }
+  });
+  this.socket.on('connect', this.onConnected);
+  this.socket.on('disconnect', this.onDisconnected);
+  this.socket.on('connect_error', this.onConnectError);
+  this.socket.on('join-room', this.onJoinRoom);
+  this.socket.on('leave-room', this.onLeaveRoom);
+  this.socket.on('update-document', this.onReceiveRemoteOperations);
+
+  // doc replaced
+  this.socket.on('doc-replaced', this.receiveDocumentReplaced);
+  this.socket.on('doc-replaced-error', this.receiveDocumentReplacedError);
+
+  // doc published
+  this.socket.on('doc-published', this.receivePublishDocument);
+  this.socket.on('doc-published-error', this.receivePublishDocumentError);
+
+  // doc removed
+  this.socket.on('doc-removed', this.receiveRemoveDocument);
+  this.socket.on('doc-removed-error', this.receiveRemoveDocumentError);
+  this.socket.on('update-cursor', this.receiveCursorLocation);
+
+  // notification
+  this.socket.on('new-notification', this.receiveNewNotification);
+
+  // participant
+  this.socket.on('participant-added', this.receiveParticipantAdded);
+  this.socket.on('participant-removed', this.receiveParticipantRemoved);
+  this.socket.io.on('reconnect', this.onReconnect);
+  this.socket.io.on('reconnect_attempt', this.onReconnectAttempt);
+  this.socket.io.on('reconnect_error', this.onReconnectError);
+});
+var _default = exports["default"] = SocketClient;

package/dist/socket/socket-manager.js

@@ -0,0 +1,367 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/toConsumableArray"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/createClass"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/classCallCheck"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/defineProperty"));
+var _constants = require("../constants");
+var _helper = require("../cursor/helper");
+var _debug = require("../utils/debug");
+var _eventBus = _interopRequireDefault(require("../utils/event-bus"));
+var _helpers = require("./helpers");
+var _socketClient = _interopRequireDefault(require("./socket-client"));
+var _SocketManager;
+//  idle --> sending --> conflict --> idle
+//       --> conflict --> idle
+//       --> disconnect --> conflict --> idle
+//                      --> idle
+var STATE = {
+  IDLE: 'idle',
+  SENDING: 'sending',
+  CONFLICT: 'conflict',
+  DISCONNECT: 'disconnect',
+  NEED_RELOAD: 'need_reload'
+};
+var SocketManager = /*#__PURE__*/(0, _createClass2["default"])(function SocketManager(editor, _document, config) {
+  var _this = this;
+  (0, _classCallCheck2["default"])(this, SocketManager);
+  (0, _defineProperty2["default"])(this, "getDocumentVersion", function () {
+    var version = _this.document.version;
+    return version;
+  });
+  (0, _defineProperty2["default"])(this, "updateDocumentVersion", function (document) {
+    _this.document['version'] = document.version;
+  });
+  (0, _defineProperty2["default"])(this, "receivePublishDocument", function () {
+    _this.eventBus.dispatch(_constants.INTERNAL_EVENT.PUBLISH_DOCUMENT);
+  });
+  (0, _defineProperty2["default"])(this, "receivePublishDocumentError", function () {
+    _this.eventBus.dispatch(_constants.INTERNAL_EVENT.PUBLISH_DOCUMENT_ERROR);
+  });
+  (0, _defineProperty2["default"])(this, "receiveRemoveDocument", function () {
+    _this.eventBus.dispatch(_constants.INTERNAL_EVENT.REMOVE_DOCUMENT);
+  });
+  (0, _defineProperty2["default"])(this, "receiveRemoveDocumentError", function () {
+    _this.eventBus.dispatch(_constants.INTERNAL_EVENT.REMOVE_DOCUMENT_ERROR);
+  });
+  (0, _defineProperty2["default"])(this, "receiveDocumentReplaced", function () {
+    _this.eventBus.dispatch(_constants.INTERNAL_EVENT.DOCUMENT_REPLACED);
+  });
+  (0, _defineProperty2["default"])(this, "receiveDocumentReplacedError", function () {
+    _this.eventBus.dispatch(_constants.INTERNAL_EVENT.DOCUMENT_REPLACED_ERROR);
+  });
+  (0, _defineProperty2["default"])(this, "receiveNewNotification", function (notification) {
+    _this.eventBus.dispatch(_constants.INTERNAL_EVENT.NEW_NOTIFICATION, notification);
+  });
+  (0, _defineProperty2["default"])(this, "onReceiveLocalOperations", function (operations) {
+    if (_this.editor.readonly) return;
+    _this.pendingOperationList.push(operations);
+    var lastOpBeginTime = new Date().getTime();
+    _this.pendingOperationBeginTimeList.push(lastOpBeginTime);
+    var firstOpBeginTime = _this.pendingOperationBeginTimeList[0];
+    var isExceedExecuteTime = (lastOpBeginTime - firstOpBeginTime) / 1000 > 30 ? true : false;
+    if (isExceedExecuteTime || _this.pendingOperationList.length > 50) {
+      _this.dispatchConnectState('pending_operations_exceed_limit');
+    }
+    _this.sendOperations();
+  });
+  (0, _defineProperty2["default"])(this, "sendOperations", function () {
+    if (_this.editor.readonly) return;
+    if (_this.state !== STATE.IDLE) return;
+    (0, _debug.stateDebug)("State changed: ".concat(_this.state, " -> ").concat(STATE.SENDING));
+    _this.state = STATE.SENDING;
+    _this.sendNextOperations();
+  });
+  (0, _defineProperty2["default"])(this, "sendNextOperations", function () {
+    if (_this.state !== STATE.SENDING) return;
+    if (_this.pendingOperationList.length === 0) {
+      (0, _debug.stateDebug)("State Changed: ".concat(_this.state, " -> ").concat(STATE.IDLE));
+      _this.state = STATE.IDLE;
+      return;
+    }
+    _this.dispatchConnectState('is-saving');
+    var version = _this.document.version;
+    var operations = _this.pendingOperationList.shift();
+    var selection = _this.editor.selection;
+    _this._sendingOperations = operations;
+    _this.socketClient.sendOperations(operations, version, selection, _this.sendOperationsCallback);
+  });
+  (0, _defineProperty2["default"])(this, "sendOperationsCallback", function (result) {
+    if (result && result.success) {
+      var serverVersion = result.version;
+      _this.document['version'] = serverVersion;
+      var lastSavedAt = new Date().getTime();
+      _this.dispatchConnectState('saved', lastSavedAt);
+
+      // send next operations
+      _this.pendingOperationBeginTimeList.shift(); // remove current operation's begin time
+      _this._sendingOperations = null;
+      _this.sendNextOperations();
+      return;
+    }
+
+    // Operations are execute failure
+    var error_type = result.error_type;
+    if (error_type === 'load_document_content_error' || error_type === 'save_operations_to_database_error' || error_type === 'token_expired') {
+      // load_document_content_error: After a short-term reconnection, the content of the document fails to load
+      // save_operation_to_database_error: Save operation to database error
+      _this.dispatchConnectState(error_type);
+
+      // reset sending control
+      (0, _debug.stateDebug)("State Changed: ".concat(_this.state, " -> ").concat(STATE.NEED_RELOAD));
+      _this.state = STATE.NEED_RELOAD;
+      _this._sendingOperations = null;
+    } else if (error_type === 'version_behind_server') {
+      // Put the failed operation into the pending list and re-execute it
+      _this.pendingOperationList.unshift((0, _toConsumableArray2["default"])(_this._sendingOperations));
+      (0, _debug.stateDebug)("State Changed: ".concat(_this.state, " -> ").concat(STATE.CONFLICT));
+      _this.state = STATE.CONFLICT;
+      var lose_operations = result.lose_operations;
+      _this.resolveConflicting(lose_operations);
+    } else if (error_type === 'execute_client_operations_error') {
+      _this.editor.isRemote = true;
+      var dupSendingOperations = (0, _toConsumableArray2["default"])(_this._sendingOperations);
+      (0, _helpers.revertOperationList)(_this.editor, [dupSendingOperations]);
+
+      // Update the save time after revert
+      var _lastSavedAt = new Date().getTime();
+      _this.dispatchConnectState('saved', _lastSavedAt);
+
+      // Set isRemote to false must be in Promise.resolve function, make sure the modification of isRemote is later than the onChange event
+      Promise.resolve().then(function (_) {
+        _this.editor.isRemote = false;
+        _this.dispatchConnectState(error_type);
+
+        // send next operations
+        _this._sendingOperations = null;
+        _this.sendNextOperations();
+      });
+    }
+  });
+  (0, _defineProperty2["default"])(this, "onReceiveRemoteOperations", function (params) {
+    // if this.disconnect is true, Then the message sent by the remote end cannot be received
+    if (_this.state !== STATE.IDLE) return;
+    if (_this.editor.readonly) return;
+    var serverVersion = params.version;
+    var clientVersion = _this.document.version;
+    if (serverVersion === clientVersion + 1) {
+      // update execute remote operations flag
+      _this.editor.isRemote = true;
+      var operations = params.operations;
+      // Update content & version
+      (0, _debug.serverDebug)('execute remote operations: %O', operations);
+      try {
+        (0, _helpers.syncRemoteOperations)(_this.editor, operations);
+      } catch (error) {
+        (0, _debug.stateDebug)("State Changed: ".concat(_this.state, " -> ").concat(STATE.CONFLICT));
+        _this.state = STATE.CONFLICT;
+        _this.dispatchConnectState('sync_server_operations_error');
+        return;
+      }
+
+      // Update document
+      _this.document.version = serverVersion;
+      _this.document.children = _this.editor.children;
+      Promise.resolve().then(function () {
+        _this.editor.isRemote = false;
+        _this.revertOperationList = [];
+      });
+    } else {
+      // isConflict
+      _this.onConflictHappen();
+    }
+  });
+  (0, _defineProperty2["default"])(this, "onReconnect", function (result) {
+    var serverVersion = result.version;
+    var clientVersion = _this.getDocumentVersion();
+    // The client version is inconsistent with the server version, and the latest operations performed by the server need to be loaded
+    if (serverVersion !== clientVersion) {
+      _this.onConflictHappen();
+      return;
+    }
+
+    // The version consistency indicates that there is no conflict and no processing is required
+    (0, _debug.stateDebug)("State Changed: ".concat(_this.state, " -> ").concat(STATE.IDLE));
+    _this.state = STATE.IDLE;
+    if (_this.pendingOperationList.length > 0) {
+      (0, _debug.clientDebug)('After reconnection, manually trigger the execution of ops.');
+      (0, _debug.stateDebug)("State Changed: ".concat(_this.state, " -> ").concat(STATE.SENDING));
+      _this.state = STATE.SENDING;
+      _this.sendNextOperations();
+    }
+  });
+  (0, _defineProperty2["default"])(this, "onConflictHappen", function () {
+    (0, _debug.stateDebug)("State Changed: ".concat(_this.state, " -> ").concat(STATE.CONFLICT));
+    _this.state = STATE.CONFLICT;
+    _this.socketClient.getRecentOperations();
+  });
+  (0, _defineProperty2["default"])(this, "onGetRecentOperations", function (result) {
+    if (_this.editor.readonly) return;
+    var mode = result.mode,
+      content = result.content;
+    (0, _debug.conflictDebug)('Start conflict resolution');
+    // sync document
+    if (mode === 'document') {
+      var version = content.version,
+        children = content.children;
+      // 1. update document
+      (0, _debug.conflictDebug)('Update local document to remote document');
+      _this.document.children = children;
+      _this.document.version = version;
+      _this.editor.children = children;
+      _this.editor.isRemote = true;
+      _this.editor.onChange();
+      (0, _debug.stateDebug)("State Changed: ".concat(_this.state, " -> ").concat(STATE.IDLE));
+      _this.editor.isRemote = false;
+      _this.state = STATE.IDLE;
+      _this._sendingOperations = null;
+
+      // 2. exec client operationList
+      var pendingOperationList = _this.pendingOperationList.slice();
+      _this.pendingOperationList = [];
+
+      // need resend this operations to server
+      (0, _debug.conflictDebug)('Re-execute local unsynchronized operations: %o', pendingOperationList);
+      (0, _helpers.reExecRevertOperationList)(_this.editor, pendingOperationList);
+      return;
+    }
+
+    // mode os operations: sync operations
+    // content is [{version, operations}, {version, operations}, ...]
+    var loseOperations = content;
+    _this.resolveConflicting(loseOperations);
+  });
+  (0, _defineProperty2["default"])(this, "resolveConflicting", function (loseOperations) {
+    if (_this.editor.readonly) return;
+    (0, _debug.conflictDebug)('resolve conflicts');
+    _this.editor.isRemote = true;
+    if (_this.pendingOperationList.length !== 0) {
+      // 1. Revert operations
+      // 1.1 record reverted operationList & clear pendingOperationList
+      _this.revertOperationList = _this.pendingOperationList.slice();
+      _this.pendingOperationList = [];
+
+      // 1.2 Revert operationList
+      (0, _debug.conflictDebug)('revert locale operations: %O', _this.revertOperationList);
+      (0, _helpers.revertOperationList)(_this.editor, _this.revertOperationList);
+    }
+    loseOperations = loseOperations.sort(function (prev, next) {
+      return prev.version - next.version;
+    });
+    (0, _debug.conflictDebug)('lose operations length: %s', loseOperations.length);
+    while (loseOperations.length > 0) {
+      var operationParams = loseOperations.shift();
+      // 2. execute operations
+      var operations = operationParams.operations,
+        serverVersion = operationParams.version;
+      // 2.1 Update content & version
+      (0, _debug.conflictDebug)('execute lose operations: %O', operations);
+      try {
+        (0, _helpers.syncRemoteOperations)(_this.editor, operations);
+      } catch (error) {
+        (0, _debug.stateDebug)("State Changed: ".concat(_this.state, " -> ").concat(STATE.CONFLICT));
+        _this.state = STATE.CONFLICT;
+        _this.dispatchConnectState('sync_server_operations_error');
+        return;
+      }
+
+      // 2.2 Update document
+      _this.document.version = serverVersion;
+      _this.document.children = _this.editor.children;
+    }
+    if (_this.revertOperationList.length === 0) {
+      Promise.resolve().then(function () {
+        _this.editor.isRemote = false;
+        (0, _debug.stateDebug)("State Changed: ".concat(_this.state, " -> ").concat(STATE.IDLE));
+        _this.state = STATE.IDLE;
+        _this._sendingOperations = null;
+        _this.revertOperationList = [];
+      });
+      return;
+    }
+
+    // Set isRemote to false must be in Promise.resolve function, make sure the modification of isRemote is later than the onChange event
+    Promise.resolve().then(function () {
+      // reset execute remote operations flag
+      _this.editor.isRemote = false;
+      (0, _debug.stateDebug)("State Changed: ".concat(_this.state, " -> ").concat(STATE.IDLE));
+      _this.state = STATE.IDLE;
+      _this._sendingOperations = null;
+
+      // 3. Execute pending operations
+      // 3.1 Re-execute operations
+      (0, _debug.conflictDebug)('Editor isRemote is false: %s', _this.editor.isRemote);
+      (0, _debug.conflictDebug)('Re-execute pending operations, %O', _this.revertOperationList);
+      (0, _helpers.reExecRevertOperationList)(_this.editor, _this.revertOperationList);
+
+      // 3.2 Clear revert operationList
+      _this.revertOperationList = [];
+      (0, _debug.conflictDebug)('Complete conflict resolution');
+    });
+  });
+  (0, _defineProperty2["default"])(this, "sendCursorLocation", function (location) {
+    _this.socketClient.sendCursorLocation(location);
+  });
+  (0, _defineProperty2["default"])(this, "receiveCursorLocation", function (params) {
+    if (_this.editor.readonly) return;
+    var user = params.user,
+      location = params.location,
+      cursorData = params.cursor_data;
+    (0, _helpers.syncRemoteCursorLocation)(_this.editor, user, location, cursorData);
+    return;
+  });
+  (0, _defineProperty2["default"])(this, "dispatchConnectState", function (type, message) {
+    if (type === 'leave-room') {
+      (0, _helper.deleteCursor)(_this.editor, message);
+      _this.editor.onCursor && _this.editor.onCursor(_this.editor.cursors);
+    }
+    if (type === 'disconnect') {
+      // current state is sending
+      if (_this._sendingOperations) {
+        _this.pendingOperationList.unshift(_this._sendingOperations.slice());
+        _this._sendingOperations = null;
+      }
+      (0, _debug.stateDebug)("State Changed: ".concat(_this.state, " -> ").concat(STATE.DISCONNECT));
+      _this.state = STATE.DISCONNECT;
+    }
+    _this.eventBus.dispatch(type, message);
+  });
+  (0, _defineProperty2["default"])(this, "closeSocketConnect", function () {
+    _this.socketClient.disconnectWithServer();
+  });
+  (0, _defineProperty2["default"])(this, "receiveParticipantAdded", function (uses) {
+    _this.eventBus.dispatch(_constants.INTERNAL_EVENT.PARTICIPANT_ADDED, uses);
+  });
+  (0, _defineProperty2["default"])(this, "receiveParticipantRemoved", function (email) {
+    _this.eventBus.dispatch(_constants.INTERNAL_EVENT.PARTICIPANT_REMOVED, email);
+  });
+  this.editor = editor;
+  this.document = _document;
+  this.socketClient = new _socketClient["default"](config);
+  this.pendingOperationList = []; // Two-dimensional arrays： [operations, operations, ...]
+  this.pendingOperationBeginTimeList = [];
+  this.remoteOperationsList = []; // Same with pending operations
+  this.revertOperationList = [];
+  this.eventBus = _eventBus["default"].getInstance();
+  this.state = STATE.IDLE;
+});
+_SocketManager = SocketManager;
+(0, _defineProperty2["default"])(SocketManager, "getInstance", function (editor, document, socketConfig) {
+  if (_SocketManager.instance) {
+    return _SocketManager.instance;
+  }
+  if (!document || !socketConfig) {
+    throw new Error('SocketManager init params is invalid. Place check your code to fix it.');
+  }
+  _SocketManager.instance = new _SocketManager(editor, document, socketConfig);
+  return _SocketManager.instance;
+});
+(0, _defineProperty2["default"])(SocketManager, "destroy", function () {
+  _SocketManager.instance = null;
+});
+var _default = exports["default"] = SocketManager;

package/dist/socket/with-socket-io.js

@@ -0,0 +1,65 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _helper = require("../cursor/helper");
+var _eventBus = _interopRequireDefault(require("../utils/event-bus"));
+var _socketManager2 = _interopRequireDefault(require("./socket-manager"));
+var withSocketIO = function withSocketIO(editor, options) {
+  var onChange = editor.onChange;
+  var newEditor = editor;
+  var socketManager = null;
+  var user = options.config.user;
+  newEditor.user = user;
+  newEditor.openConnection = function () {
+    var document = options.document,
+      config = options.config;
+    var cursorData = (0, _helper.generateCursorData)(options.config);
+    config['cursorData'] = cursorData;
+    socketManager = _socketManager2["default"].getInstance(newEditor, document, config);
+  };
+  newEditor.closeConnection = function () {
+    socketManager && socketManager.closeSocketConnect();
+    _socketManager2["default"].destroy();
+  };
+  newEditor.onChange = function () {
+    if (newEditor.readonly) return;
+    var document = options.document,
+      config = options.config;
+    var operations = newEditor.operations;
+    if (!newEditor.isRemote && operations.length > 0) {
+      var isAllSetSelection = operations.every(function (operation) {
+        return operation.type === 'set_selection';
+      });
+      var _socketManager = _socketManager2["default"].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);
+      }
+      _socketManager.sendCursorLocation(editor.selection);
+    }
+
+    // dispatch editor change event
+    var eventBus = _eventBus["default"].getInstance(newEditor, document, config);
+    eventBus.dispatch('change');
+    onChange();
+  };
+  newEditor.rebaseContent = function (document, originFileVersion) {
+    var config = options.config;
+    var socketManager = _socketManager2["default"].getInstance(newEditor, document, config);
+    socketManager.sendRebaseContent(document, originFileVersion);
+  };
+  newEditor.updateDocumentVersion = function (document) {
+    var config = options.config;
+    var socketManager = _socketManager2["default"].getInstance(newEditor, document, config);
+    socketManager.updateDocumentVersion(document);
+  };
+  return newEditor;
+};
+var _default = exports["default"] = withSocketIO;

package/dist/utils/Kebab-to-camel.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var KebabToCamel = function KebabToCamel(str) {
+  return str.replace(/(_[a-z])/g, function (match) {
+    return "".concat(match.slice(1).toUpperCase());
+  });
+};
+var _default = exports["default"] = KebabToCamel;