@seafile/sdoc-editor 0.3.6 → 0.3.7

package/dist/basic-sdk/socket/socket-manager.js

@@ -1,6 +1,3 @@
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
 var _class;
 import EventBus from '../utils/event-bus';
 import { syncRemoteOperations, reExecRevertOperationList, revertOperationList, syncRemoteCursorLocation } from './helpers';
@@ -13,326 +10,348 @@ import { EXTERNAL_EVENT } from '../../constants';
 //       --> conflict --> idle
 //       --> disconnect --> conflict --> idle
 //                      --> idle
-var STATE = {
+const STATE = {
   IDLE: 'idle',
   SENDING: 'sending',
   CONFLICT: 'conflict',
   DISCONNECT: 'disconnect',
   NEED_RELOAD: 'need_reload'
 };
-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.updateDocumentVersion = function (document) {
-    _this.document['version'] = document.version;
-  };
-  this.receivePublishDocument = function () {
-    _this.eventBus.dispatch(EXTERNAL_EVENT.PUBLISH_DOCUMENT);
-  };
-  this.receivePublishDocumentError = function () {
-    _this.eventBus.dispatch(EXTERNAL_EVENT.PUBLISH_DOCUMENT_ERROR);
-  };
-  this.receiveRemoveDocument = function () {
-    _this.eventBus.dispatch(EXTERNAL_EVENT.REMOVE_DOCUMENT);
-  };
-  this.receiveRemoveDocumentError = function () {
-    _this.eventBus.dispatch(EXTERNAL_EVENT.REMOVE_DOCUMENT_ERROR);
-  };
-  this.receiveDocumentReplaced = function () {
-    _this.eventBus.dispatch(EXTERNAL_EVENT.DOCUMENT_REPLACED);
-  };
-  this.receiveDocumentReplacedError = function () {
-    _this.eventBus.dispatch(EXTERNAL_EVENT.DOCUMENT_REPLACED_ERROR);
-  };
-  this.receiveNewNotification = function (notification) {
-    _this.eventBus.dispatch(EXTERNAL_EVENT.NEW_NOTIFICATION, notification);
-  };
-  this.onReceiveLocalOperations = function (operations) {
-    _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();
-  };
-  this.sendOperations = function () {
-    if (_this.state !== STATE.IDLE) return;
-    stateDebug("State changed: ".concat(_this.state, " -> ").concat(STATE.SENDING));
-    _this.state = STATE.SENDING;
-    _this.sendNextOperations();
-  };
-  this.sendNextOperations = function () {
-    if (_this.state !== STATE.SENDING) return;
-    if (_this.pendingOperationList.length === 0) {
-      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);
-  };
-  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);
+class SocketManager {
+  constructor(editor, _document, config) {
+    this.getDocumentVersion = () => {
+      const {
+        version
+      } = this.document;
+      return version;
+    };
+    this.updateDocumentVersion = document => {
+      this.document['version'] = document.version;
+    };
+    this.receivePublishDocument = () => {
+      this.eventBus.dispatch(EXTERNAL_EVENT.PUBLISH_DOCUMENT);
+    };
+    this.receivePublishDocumentError = () => {
+      this.eventBus.dispatch(EXTERNAL_EVENT.PUBLISH_DOCUMENT_ERROR);
+    };
+    this.receiveRemoveDocument = () => {
+      this.eventBus.dispatch(EXTERNAL_EVENT.REMOVE_DOCUMENT);
+    };
+    this.receiveRemoveDocumentError = () => {
+      this.eventBus.dispatch(EXTERNAL_EVENT.REMOVE_DOCUMENT_ERROR);
+    };
+    this.receiveDocumentReplaced = () => {
+      this.eventBus.dispatch(EXTERNAL_EVENT.DOCUMENT_REPLACED);
+    };
+    this.receiveDocumentReplacedError = () => {
+      this.eventBus.dispatch(EXTERNAL_EVENT.DOCUMENT_REPLACED_ERROR);
+    };
+    this.receiveNewNotification = notification => {
+      this.eventBus.dispatch(EXTERNAL_EVENT.NEW_NOTIFICATION, notification);
+    };
+    this.onReceiveLocalOperations = operations => {
+      this.pendingOperationList.push(operations);
+      const lastOpBeginTime = new Date().getTime();
+      this.pendingOperationBeginTimeList.push(lastOpBeginTime);
+      const firstOpBeginTime = this.pendingOperationBeginTimeList[0];
+      const isExceedExecuteTime = (lastOpBeginTime - firstOpBeginTime) / 1000 > 30 ? true : false;
+      if (isExceedExecuteTime || this.pendingOperationList.length > 50) {
+        this.dispatchConnectState('pending_operations_exceed_limit');
+      }
+      this.sendOperations();
+    };
+    this.sendOperations = () => {
+      if (this.state !== STATE.IDLE) return;
+      stateDebug("State changed: ".concat(this.state, " -> ").concat(STATE.SENDING));
+      this.state = STATE.SENDING;
+      this.sendNextOperations();
+    };
+    this.sendNextOperations = () => {
+      if (this.state !== STATE.SENDING) return;
+      if (this.pendingOperationList.length === 0) {
+        stateDebug("State Changed: ".concat(this.state, " -> ").concat(STATE.IDLE));
+        this.state = STATE.IDLE;
+        return;
+      }
+      this.dispatchConnectState('is-saving');
+      const version = this.document.version;
+      const operations = this.pendingOperationList.shift();
+      const selection = this.editor.selection;
+      this._sendingOperations = operations;
+      this.socketClient.sendOperations(operations, version, selection, this.sendOperationsCallback);
+    };
+    this.sendOperationsCallback = result => {
+      if (result && result.success) {
+        const {
+          version: serverVersion
+        } = result;
+        this.document['version'] = serverVersion;
+        const 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;
-    }
+        // 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') {
-      // 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);
+      // Operations are execute failure
+      const {
+        error_type
+      } = result;
+      if (error_type === 'load_document_content_error' || error_type === 'save_operations_to_database_error') {
+        // 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
-      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(_toConsumableArray(_this._sendingOperations));
-      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 = _toConsumableArray(_this._sendingOperations);
-      revertOperationList(_this.editor, [dupSendingOperations]);
+        // reset sending control
+        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([...this._sendingOperations]);
+        stateDebug("State Changed: ".concat(this.state, " -> ").concat(STATE.CONFLICT));
+        this.state = STATE.CONFLICT;
+        const {
+          lose_operations
+        } = result;
+        this.resolveConflicting(lose_operations);
+      } else if (error_type === 'execute_client_operations_error') {
+        this.editor.isRemote = true;
+        const dupSendingOperations = [...this._sendingOperations];
+        revertOperationList(this.editor, [dupSendingOperations]);
 
-      // Update the save time after revert
-      var _lastSavedAt = new Date().getTime();
-      _this.dispatchConnectState('saved', _lastSavedAt);
+        // Update the save time after revert
+        const 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);
+        // 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(_ => {
+          this.editor.isRemote = false;
+          this.dispatchConnectState(error_type);
 
-        // send next operations
-        _this._sendingOperations = null;
-        _this.sendNextOperations();
-      });
-    }
-  };
-  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;
-    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
-      serverDebug('execute remote operations: %O', operations);
-      try {
-        syncRemoteOperations(_this.editor, operations);
-      } catch (error) {
-        stateDebug("State Changed: ".concat(_this.state, " -> ").concat(STATE.CONFLICT));
-        _this.state = STATE.CONFLICT;
-        _this.dispatchConnectState('sync_server_operations_error');
+          // send next operations
+          this._sendingOperations = null;
+          this.sendNextOperations();
+        });
+      }
+    };
+    this.onReceiveRemoteOperations = params => {
+      // if this.disconnect is true, Then the message sent by the remote end cannot be received
+      if (this.state !== STATE.IDLE) return;
+      const {
+        version: serverVersion
+      } = params;
+      const {
+        version: clientVersion
+      } = this.document;
+      if (serverVersion === clientVersion + 1) {
+        // update execute remote operations flag
+        this.editor.isRemote = true;
+        const {
+          operations
+        } = params;
+        // Update content & version
+        serverDebug('execute remote operations: %O', operations);
+        try {
+          syncRemoteOperations(this.editor, operations);
+        } catch (error) {
+          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(() => {
+          this.editor.isRemote = false;
+          this.revertOperationList = [];
+        });
+      } else {
+        // isConflict
+        this.onConflictHappen();
+      }
+    };
+    this.onReconnect = result => {
+      const {
+        version: serverVersion
+      } = result;
+      const 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;
       }
 
-      // 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();
-    }
-  };
-  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
+      stateDebug("State Changed: ".concat(this.state, " -> ").concat(STATE.IDLE));
+      this.state = STATE.IDLE;
+      if (this.pendingOperationList.length > 0) {
+        clientDebug('After reconnection, manually trigger the execution of ops.');
+        stateDebug("State Changed: ".concat(this.state, " -> ").concat(STATE.SENDING));
+        this.state = STATE.SENDING;
+        this.sendNextOperations();
+      }
+    };
+    this.onConflictHappen = () => {
+      stateDebug("State Changed: ".concat(this.state, " -> ").concat(STATE.CONFLICT));
+      this.state = STATE.CONFLICT;
+      this.socketClient.getRecentOperations();
+    };
+    this.onGetRecentOperations = result => {
+      const {
+        mode,
+        content
+      } = result;
+      conflictDebug('Start conflict resolution');
+      // sync document
+      if (mode === 'document') {
+        const {
+          version,
+          children
+        } = content;
+        // 1. update document
+        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();
+        stateDebug("State Changed: ".concat(this.state, " -> ").concat(STATE.IDLE));
+        this.editor.isRemote = false;
+        this.state = STATE.IDLE;
+        this._sendingOperations = null;
 
-    // The version consistency indicates that there is no conflict and no processing is required
-    stateDebug("State Changed: ".concat(_this.state, " -> ").concat(STATE.IDLE));
-    _this.state = STATE.IDLE;
-    if (_this.pendingOperationList.length > 0) {
-      clientDebug('After reconnection, manually trigger the execution of ops.');
-      stateDebug("State Changed: ".concat(_this.state, " -> ").concat(STATE.SENDING));
-      _this.state = STATE.SENDING;
-      _this.sendNextOperations();
-    }
-  };
-  this.onConflictHappen = function () {
-    stateDebug("State Changed: ".concat(_this.state, " -> ").concat(STATE.CONFLICT));
-    _this.state = STATE.CONFLICT;
-    _this.socketClient.getRecentOperations();
-  };
-  this.onGetRecentOperations = function (result) {
-    var mode = result.mode,
-      content = result.content;
-    conflictDebug('Start conflict resolution');
-    // sync document
-    if (mode === 'document') {
-      var version = content.version,
-        children = content.children;
-      // 1. update document
-      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();
-      stateDebug("State Changed: ".concat(_this.state, " -> ").concat(STATE.IDLE));
-      _this.editor.isRemote = false;
-      _this.state = STATE.IDLE;
-      _this._sendingOperations = null;
+        // 2. exec client operationList
+        const pendingOperationList = this.pendingOperationList.slice();
+        this.pendingOperationList = [];
 
-      // 2. exec client operationList
-      var pendingOperationList = _this.pendingOperationList.slice();
-      _this.pendingOperationList = [];
+        // need resend this operations to server
+        conflictDebug('Re-execute local unsynchronized operations: %o', pendingOperationList);
+        reExecRevertOperationList(this.editor, pendingOperationList);
+        return;
+      }
 
-      // need resend this operations to server
-      conflictDebug('Re-execute local unsynchronized operations: %o', pendingOperationList);
-      reExecRevertOperationList(_this.editor, pendingOperationList);
-      return;
-    }
+      // mode os operations: sync operations
+      // content is [{version, operations}, {version, operations}, ...]
+      const loseOperations = content;
+      this.resolveConflicting(loseOperations);
+    };
+    this.resolveConflicting = loseOperations => {
+      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 = [];
 
-    // mode os operations: sync operations
-    // content is [{version, operations}, {version, operations}, ...]
-    var loseOperations = content;
-    _this.resolveConflicting(loseOperations);
-  };
-  this.resolveConflicting = function (loseOperations) {
-    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
+        conflictDebug('revert locale operations: %O', this.revertOperationList);
+        revertOperationList(this.editor, this.revertOperationList);
+      }
+      loseOperations = loseOperations.sort((prev, next) => prev.version - next.version);
+      conflictDebug('lose operations length: %s', loseOperations.length);
+      while (loseOperations.length > 0) {
+        const operationParams = loseOperations.shift();
+        // 2. execute operations
+        const {
+          operations,
+          version: serverVersion
+        } = operationParams;
+        // 2.1 Update content & version
+        conflictDebug('execute lose operations: %O', operations);
+        try {
+          syncRemoteOperations(this.editor, operations);
+        } catch (error) {
+          stateDebug("State Changed: ".concat(this.state, " -> ").concat(STATE.CONFLICT));
+          this.state = STATE.CONFLICT;
+          this.dispatchConnectState('sync_server_operations_error');
+          return;
+        }
 
-      // 1.2 Revert operationList
-      conflictDebug('revert locale operations: %O', _this.revertOperationList);
-      revertOperationList(_this.editor, _this.revertOperationList);
-    }
-    loseOperations = loseOperations.sort(function (prev, next) {
-      return prev.version - next.version;
-    });
-    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
-      conflictDebug('execute lose operations: %O', operations);
-      try {
-        syncRemoteOperations(_this.editor, operations);
-      } catch (error) {
-        stateDebug("State Changed: ".concat(_this.state, " -> ").concat(STATE.CONFLICT));
-        _this.state = STATE.CONFLICT;
-        _this.dispatchConnectState('sync_server_operations_error');
+        // 2.2 Update document
+        this.document.version = serverVersion;
+        this.document.children = this.editor.children;
+      }
+      if (this.revertOperationList.length === 0) {
+        Promise.resolve().then(() => {
+          this.editor.isRemote = false;
+          stateDebug("State Changed: ".concat(this.state, " -> ").concat(STATE.IDLE));
+          this.state = STATE.IDLE;
+          this._sendingOperations = null;
+          this.revertOperationList = [];
+        });
         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;
-        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;
-      stateDebug("State Changed: ".concat(_this.state, " -> ").concat(STATE.IDLE));
-      _this.state = STATE.IDLE;
-      _this._sendingOperations = null;
+      // 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(() => {
+        // reset execute remote operations flag
+        this.editor.isRemote = false;
+        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
-      conflictDebug('Editor isRemote is false: %s', _this.editor.isRemote);
-      conflictDebug('Re-execute pending operations, %O', _this.revertOperationList);
-      reExecRevertOperationList(_this.editor, _this.revertOperationList);
+        // 3. Execute pending operations
+        // 3.1 Re-execute operations
+        conflictDebug('Editor isRemote is false: %s', this.editor.isRemote);
+        conflictDebug('Re-execute pending operations, %O', this.revertOperationList);
+        reExecRevertOperationList(this.editor, this.revertOperationList);
 
-      // 3.2 Clear revert operationList
-      _this.revertOperationList = [];
-      conflictDebug('Complete conflict resolution');
-    });
-  };
-  this.sendCursorLocation = function (location) {
-    _this.socketClient.sendCursorLocation(location);
-  };
-  this.receiveCursorLocation = function (params) {
-    var user = params.user,
-      location = params.location,
-      cursorData = params.cursor_data;
-    syncRemoteCursorLocation(_this.editor, user, location, cursorData);
-    return;
-  };
-  this.dispatchConnectState = function (type, message) {
-    if (type === 'leave-room') {
-      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;
+        // 3.2 Clear revert operationList
+        this.revertOperationList = [];
+        conflictDebug('Complete conflict resolution');
+      });
+    };
+    this.sendCursorLocation = location => {
+      this.socketClient.sendCursorLocation(location);
+    };
+    this.receiveCursorLocation = params => {
+      const {
+        user,
+        location,
+        cursor_data: cursorData
+      } = params;
+      syncRemoteCursorLocation(this.editor, user, location, cursorData);
+      return;
+    };
+    this.dispatchConnectState = (type, message) => {
+      if (type === 'leave-room') {
+        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;
+        }
+        stateDebug("State Changed: ".concat(this.state, " -> ").concat(STATE.DISCONNECT));
+        this.state = STATE.DISCONNECT;
       }
-      stateDebug("State Changed: ".concat(_this.state, " -> ").concat(STATE.DISCONNECT));
-      _this.state = STATE.DISCONNECT;
-    }
-    _this.eventBus.dispatch(type, message);
-  };
-  this.closeSocketConnect = function () {
-    _this.socketClient.disconnectWithServer();
-  };
-  this.editor = editor;
-  this.document = _document;
-  this.socketClient = new SocketClient(config);
-  this.pendingOperationList = []; // Two-dimensional arrays： [operations, operations, ...]
-  this.pendingOperationBeginTimeList = [];
-  this.remoteOperationsList = []; // Same with pending operations
-  this.revertOperationList = [];
-  this.eventBus = EventBus.getInstance();
-  this.state = STATE.IDLE;
-});
+      this.eventBus.dispatch(type, message);
+    };
+    this.closeSocketConnect = () => {
+      this.socketClient.disconnectWithServer();
+    };
+    this.editor = editor;
+    this.document = _document;
+    this.socketClient = new SocketClient(config);
+    this.pendingOperationList = []; // Two-dimensional arrays： [operations, operations, ...]
+    this.pendingOperationBeginTimeList = [];
+    this.remoteOperationsList = []; // Same with pending operations
+    this.revertOperationList = [];
+    this.eventBus = EventBus.getInstance();
+    this.state = STATE.IDLE;
+  }
+}
 _class = SocketManager;
-SocketManager.getInstance = function (editor, document, socketConfig) {
+SocketManager.getInstance = (editor, document, socketConfig) => {
   if (_class.instance) {
     return _class.instance;
   }
@@ -342,7 +361,7 @@ SocketManager.getInstance = function (editor, document, socketConfig) {
   _class.instance = new _class(editor, document, socketConfig);
   return _class.instance;
 };
-SocketManager.destroy = function () {
+SocketManager.destroy = () => {
   _class.instance = null;
 };
 export default SocketManager;