@seafile/comment-editor 0.0.1-alpha.0

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

@@ -0,0 +1,211 @@
+"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 _socket = _interopRequireDefault(require("socket.io-client"));
+var _debug = require("../utils/debug");
+var _socketManager = _interopRequireDefault(require("./socket-manager"));
+class SocketClient {
+  constructor(config) {
+    var _this = this;
+    (0, _defineProperty2.default)(this, "getParams", function () {
+      let params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      const {
+        docUuid,
+        user
+      } = _this.config;
+      return {
+        doc_uuid: docUuid,
+        user,
+        ...params
+      };
+    });
+    (0, _defineProperty2.default)(this, "onConnected", () => {
+      // join room
+      this.socket.emit('join-room', result => {
+        const 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", data => {
+      (0, _debug.clientDebug)('reconnect.');
+      this.isReconnect = true;
+      const socketManager = _socketManager.default.getInstance();
+      socketManager.dispatchConnectState('reconnect');
+    });
+    (0, _defineProperty2.default)(this, "onReconnectAttempt", attemptNumber => {
+      (0, _debug.clientDebug)('reconnect_attempt. %s', attemptNumber);
+      const socketManager = _socketManager.default.getInstance();
+      socketManager.dispatchConnectState('reconnect_attempt', attemptNumber);
+    });
+    (0, _defineProperty2.default)(this, "onReconnectError", () => {
+      (0, _debug.clientDebug)('reconnect_error.');
+      const socketManager = _socketManager.default.getInstance();
+      socketManager.dispatchConnectState('reconnect_error');
+    });
+    (0, _defineProperty2.default)(this, "onDisconnected", data => {
+      (0, _debug.clientDebug)('disconnect message: %s', data);
+      const socketManager = _socketManager.default.getInstance();
+      socketManager.dispatchConnectState('disconnect');
+    });
+    (0, _defineProperty2.default)(this, "onConnectError", e => {
+      (0, _debug.clientDebug)('connect_error.');
+      const socketManager = _socketManager.default.getInstance();
+      socketManager.dispatchConnectState('connect_error');
+    });
+    (0, _defineProperty2.default)(this, "sendOperations", (operations, version, selection, callback) => {
+      (0, _debug.clientDebug)('send operations: %O', operations);
+      this.socket.emit('update-document', this.getParams({
+        operations,
+        version,
+        selection
+      }), result => {
+        callback && callback(result);
+      });
+    });
+    (0, _defineProperty2.default)(this, "onJoinRoom", userInfo => {
+      (0, _debug.serverDebug)('%s joined room success.', userInfo.username);
+      const socketManager = _socketManager.default.getInstance();
+      socketManager.dispatchConnectState('join-room', userInfo);
+    });
+    (0, _defineProperty2.default)(this, "onLeaveRoom", username => {
+      (0, _debug.serverDebug)('%s leaved room success.', username);
+      const socketManager = _socketManager.default.getInstance();
+      socketManager.dispatchConnectState('leave-room', username);
+    });
+    /**
+     * receive remote broadcast operations
+     * @param {*} params {operations, version}
+     */
+    (0, _defineProperty2.default)(this, "onReceiveRemoteOperations", params => {
+      (0, _debug.serverDebug)('receive operations: %O', params);
+      const socketManager = _socketManager.default.getInstance();
+      socketManager.onReceiveRemoteOperations(params);
+    });
+    (0, _defineProperty2.default)(this, "getRecentOperations", () => {
+      const {
+        docUuid
+      } = this.config;
+      const socketManager = _socketManager.default.getInstance();
+      const clientVersion = socketManager.getDocumentVersion();
+      this.socket.emit('sync-document', {
+        doc_uuid: docUuid,
+        version: clientVersion
+      }, result => {
+        if (result.success) {
+          socketManager.onGetRecentOperations(result);
+        }
+      });
+    });
+    (0, _defineProperty2.default)(this, "sendCursorLocation", location => {
+      const {
+        cursorData: cursor_data
+      } = this.config;
+      this.socket.emit('update-cursor', this.getParams({
+        location,
+        cursor_data
+      }));
+    });
+    (0, _defineProperty2.default)(this, "receiveCursorLocation", params => {
+      const socketManager = _socketManager.default.getInstance();
+      socketManager.receiveCursorLocation(params);
+    });
+    (0, _defineProperty2.default)(this, "disconnectWithServer", () => {
+      this.socket.disconnect();
+    });
+    (0, _defineProperty2.default)(this, "receivePublishDocument", () => {
+      const socketManager = _socketManager.default.getInstance();
+      socketManager.receivePublishDocument();
+    });
+    (0, _defineProperty2.default)(this, "receivePublishDocumentError", () => {
+      const socketManager = _socketManager.default.getInstance();
+      socketManager.receivePublishDocumentError();
+    });
+    (0, _defineProperty2.default)(this, "receiveDocumentReplaced", () => {
+      const socketManager = _socketManager.default.getInstance();
+      socketManager.receiveDocumentReplaced();
+    });
+    (0, _defineProperty2.default)(this, "receiveDocumentReplacedError", () => {
+      const socketManager = _socketManager.default.getInstance();
+      socketManager.receiveDocumentReplacedError();
+    });
+    (0, _defineProperty2.default)(this, "receiveRemoveDocument", () => {
+      const socketManager = _socketManager.default.getInstance();
+      socketManager.receiveRemoveDocument();
+    });
+    (0, _defineProperty2.default)(this, "receiveRemoveDocumentError", () => {
+      const socketManager = _socketManager.default.getInstance();
+      socketManager.receiveRemoveDocumentError();
+    });
+    (0, _defineProperty2.default)(this, "receiveNewNotification", notification => {
+      const socketManager = _socketManager.default.getInstance();
+      socketManager.receiveNewNotification(notification);
+    });
+    (0, _defineProperty2.default)(this, "receiveParticipantAdded", uses => {
+      const socketManager = _socketManager.default.getInstance();
+      socketManager.receiveParticipantAdded(uses);
+    });
+    (0, _defineProperty2.default)(this, "receiveParticipantRemoved", email => {
+      const 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/basic-sdk/socket/socket-manager.js

@@ -0,0 +1,386 @@
+"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 _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
+const STATE = {
+  IDLE: 'idle',
+  SENDING: 'sending',
+  CONFLICT: 'conflict',
+  DISCONNECT: 'disconnect',
+  NEED_RELOAD: 'need_reload'
+};
+class SocketManager {
+  constructor(editor, _document, config) {
+    (0, _defineProperty2.default)(this, "getDocumentVersion", () => {
+      const {
+        version
+      } = this.document;
+      return version;
+    });
+    (0, _defineProperty2.default)(this, "updateDocumentVersion", document => {
+      this.document['version'] = document.version;
+    });
+    (0, _defineProperty2.default)(this, "receivePublishDocument", () => {
+      this.eventBus.dispatch(_constants.INTERNAL_EVENT.PUBLISH_DOCUMENT);
+    });
+    (0, _defineProperty2.default)(this, "receivePublishDocumentError", () => {
+      this.eventBus.dispatch(_constants.INTERNAL_EVENT.PUBLISH_DOCUMENT_ERROR);
+    });
+    (0, _defineProperty2.default)(this, "receiveRemoveDocument", () => {
+      this.eventBus.dispatch(_constants.INTERNAL_EVENT.REMOVE_DOCUMENT);
+    });
+    (0, _defineProperty2.default)(this, "receiveRemoveDocumentError", () => {
+      this.eventBus.dispatch(_constants.INTERNAL_EVENT.REMOVE_DOCUMENT_ERROR);
+    });
+    (0, _defineProperty2.default)(this, "receiveDocumentReplaced", () => {
+      this.eventBus.dispatch(_constants.INTERNAL_EVENT.DOCUMENT_REPLACED);
+    });
+    (0, _defineProperty2.default)(this, "receiveDocumentReplacedError", () => {
+      this.eventBus.dispatch(_constants.INTERNAL_EVENT.DOCUMENT_REPLACED_ERROR);
+    });
+    (0, _defineProperty2.default)(this, "receiveNewNotification", notification => {
+      this.eventBus.dispatch(_constants.INTERNAL_EVENT.NEW_NOTIFICATION, notification);
+    });
+    (0, _defineProperty2.default)(this, "onReceiveLocalOperations", operations => {
+      if (this.editor.readonly) return;
+      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();
+    });
+    (0, _defineProperty2.default)(this, "sendOperations", () => {
+      if (this.editor.readonly) return;
+      if (this.state !== STATE.IDLE) return;
+      (0, _debug.stateDebug)(`State changed: ${this.state} -> ${STATE.SENDING}`);
+      this.state = STATE.SENDING;
+      this.sendNextOperations();
+    });
+    (0, _defineProperty2.default)(this, "sendNextOperations", () => {
+      if (this.state !== STATE.SENDING) return;
+      if (this.pendingOperationList.length === 0) {
+        (0, _debug.stateDebug)(`State Changed: ${this.state} -> ${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);
+    });
+    (0, _defineProperty2.default)(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;
+      }
+
+      // Operations are execute failure
+      const {
+        error_type
+      } = result;
+      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: ${this.state} -> ${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]);
+        (0, _debug.stateDebug)(`State Changed: ${this.state} -> ${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];
+        (0, _helpers.revertOperationList)(this.editor, [dupSendingOperations]);
+
+        // 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(_ => {
+          this.editor.isRemote = false;
+          this.dispatchConnectState(error_type);
+
+          // send next operations
+          this._sendingOperations = null;
+          this.sendNextOperations();
+        });
+      }
+    });
+    (0, _defineProperty2.default)(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;
+      if (this.editor.readonly) 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
+        (0, _debug.serverDebug)('execute remote operations: %O', operations);
+        try {
+          (0, _helpers.syncRemoteOperations)(this.editor, operations);
+        } catch (error) {
+          (0, _debug.stateDebug)(`State Changed: ${this.state} -> ${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();
+      }
+    });
+    (0, _defineProperty2.default)(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;
+      }
+
+      // The version consistency indicates that there is no conflict and no processing is required
+      (0, _debug.stateDebug)(`State Changed: ${this.state} -> ${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: ${this.state} -> ${STATE.SENDING}`);
+        this.state = STATE.SENDING;
+        this.sendNextOperations();
+      }
+    });
+    (0, _defineProperty2.default)(this, "onConflictHappen", () => {
+      (0, _debug.stateDebug)(`State Changed: ${this.state} -> ${STATE.CONFLICT}`);
+      this.state = STATE.CONFLICT;
+      this.socketClient.getRecentOperations();
+    });
+    (0, _defineProperty2.default)(this, "onGetRecentOperations", result => {
+      if (this.editor.readonly) return;
+      const {
+        mode,
+        content
+      } = result;
+      (0, _debug.conflictDebug)('Start conflict resolution');
+      // sync document
+      if (mode === 'document') {
+        const {
+          version,
+          children
+        } = content;
+        // 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: ${this.state} -> ${STATE.IDLE}`);
+        this.editor.isRemote = false;
+        this.state = STATE.IDLE;
+        this._sendingOperations = null;
+
+        // 2. exec client operationList
+        const 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}, ...]
+      const loseOperations = content;
+      this.resolveConflicting(loseOperations);
+    });
+    (0, _defineProperty2.default)(this, "resolveConflicting", 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((prev, next) => prev.version - next.version);
+      (0, _debug.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
+        (0, _debug.conflictDebug)('execute lose operations: %O', operations);
+        try {
+          (0, _helpers.syncRemoteOperations)(this.editor, operations);
+        } catch (error) {
+          (0, _debug.stateDebug)(`State Changed: ${this.state} -> ${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(() => {
+          this.editor.isRemote = false;
+          (0, _debug.stateDebug)(`State Changed: ${this.state} -> ${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(() => {
+        // reset execute remote operations flag
+        this.editor.isRemote = false;
+        (0, _debug.stateDebug)(`State Changed: ${this.state} -> ${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", location => {
+      this.socketClient.sendCursorLocation(location);
+    });
+    (0, _defineProperty2.default)(this, "receiveCursorLocation", params => {
+      if (this.editor.readonly) return;
+      const {
+        user,
+        location,
+        cursor_data: cursorData
+      } = params;
+      (0, _helpers.syncRemoteCursorLocation)(this.editor, user, location, cursorData);
+      return;
+    });
+    (0, _defineProperty2.default)(this, "dispatchConnectState", (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: ${this.state} -> ${STATE.DISCONNECT}`);
+        this.state = STATE.DISCONNECT;
+      }
+      this.eventBus.dispatch(type, message);
+    });
+    (0, _defineProperty2.default)(this, "closeSocketConnect", () => {
+      this.socketClient.disconnectWithServer();
+    });
+    (0, _defineProperty2.default)(this, "receiveParticipantAdded", uses => {
+      this.eventBus.dispatch(_constants.INTERNAL_EVENT.PARTICIPANT_ADDED, uses);
+    });
+    (0, _defineProperty2.default)(this, "receiveParticipantRemoved", 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", (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", () => {
+  _SocketManager.instance = null;
+});
+var _default = exports.default = SocketManager;

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

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

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

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