@cloudbase/database 0.9.17-beta → 0.9.19

package/dist/esm/realtime/websocket-client.js

@@ -1,786 +1,564 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-import { VirtualWebSocketClient } from './virtual-websocket-client';
-import { sleep } from '../utils/utils';
-import { genRequestId } from './message';
-import { CLOSE_EVENT_CODE, CLOSE_EVENT_CODE_INFO, getWSCloseError } from './ws-event';
-import { CloudSDKError, TimeoutError } from '../utils/error';
-import { RealtimeErrorMessageError } from './error';
-import { ERR_CODE } from '../config/error.config';
-import { Db } from '../';
-var WS_READY_STATE = {
-    CONNECTING: 0,
-    OPEN: 1,
-    CLOSING: 2,
-    CLOSED: 3
-};
-var MAX_RTT_OBSERVED = 3;
-var DEFAULT_EXPECTED_EVENT_WAIT_TIME = 5000;
-var DEFAULT_UNTRUSTED_RTT_THRESHOLD = 10000;
-var DEFAULT_MAX_RECONNECT = 5;
-var DEFAULT_WS_RECONNECT_INTERVAL = 10000;
-var DEFAULT_PING_FAIL_TOLERANCE = 2;
-var DEFAULT_PONG_MISS_TOLERANCE = 2;
-var DEFAULT_LOGIN_TIMEOUT = 5000;
-var RealtimeWebSocketClient = (function () {
-    function RealtimeWebSocketClient(options) {
-        var _this = this;
-        this._virtualWSClient = new Set();
-        this._queryIdClientMap = new Map();
-        this._watchIdClientMap = new Map();
-        this._pingFailed = 0;
-        this._pongMissed = 0;
-        this._logins = new Map();
-        this._wsReadySubsribers = [];
-        this._wsResponseWait = new Map();
-        this._rttObserved = [];
-        this.initWebSocketConnection = function (reconnect, availableRetries) {
-            if (availableRetries === void 0) { availableRetries = _this._maxReconnect; }
-            return __awaiter(_this, void 0, void 0, function () {
-                var e_1;
-                var _this = this;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            if (reconnect && this._reconnectState) {
-                                return [2];
-                            }
-                            if (reconnect) {
-                                this._reconnectState = true;
-                            }
-                            if (this._wsInitPromise) {
-                                return [2, this._wsInitPromise];
-                            }
-                            if (reconnect) {
-                                this.pauseClients();
-                            }
-                            this.close(CLOSE_EVENT_CODE.ReconnectWebSocket);
-                            this._wsInitPromise = new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
-                                var wsSign_1, e_2, isConnected;
-                                var _this = this;
-                                return __generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0:
-                                            _a.trys.push([0, 6, , 11]);
-                                            return [4, this.getWsSign()];
-                                        case 1:
-                                            wsSign_1 = _a.sent();
-                                            return [4, new Promise(function (success) {
-                                                    var url = wsSign_1.wsUrl || 'wss://tcb-ws.tencentcloudapi.com';
-                                                    _this._ws = Db.wsClass ? new Db.wsClass(url) : new WebSocket(url);
-                                                    success();
-                                                })];
-                                        case 2:
-                                            _a.sent();
-                                            if (!this._ws.connect) return [3, 4];
-                                            return [4, this._ws.connect()];
-                                        case 3:
-                                            _a.sent();
-                                            _a.label = 4;
-                                        case 4: return [4, this.initWebSocketEvent()];
-                                        case 5:
-                                            _a.sent();
-                                            resolve();
-                                            if (reconnect) {
-                                                this.resumeClients();
-                                                this._reconnectState = false;
-                                            }
-                                            return [3, 11];
-                                        case 6:
-                                            e_2 = _a.sent();
-                                            console.error('[realtime] initWebSocketConnection connect fail', e_2);
-                                            if (!(availableRetries > 0)) return [3, 9];
-                                            isConnected = true;
-                                            this._wsInitPromise = undefined;
-                                            if (!isConnected) return [3, 8];
-                                            return [4, sleep(this._reconnectInterval)];
-                                        case 7:
-                                            _a.sent();
-                                            if (reconnect) {
-                                                this._reconnectState = false;
-                                            }
-                                            _a.label = 8;
-                                        case 8:
-                                            resolve(this.initWebSocketConnection(reconnect, availableRetries - 1));
-                                            return [3, 10];
-                                        case 9:
-                                            reject(e_2);
-                                            if (reconnect) {
-                                                this.closeAllClients(new CloudSDKError({
-                                                    errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_RECONNECT_WATCH_FAIL,
-                                                    errMsg: e_2
-                                                }));
-                                            }
-                                            _a.label = 10;
-                                        case 10: return [3, 11];
-                                        case 11: return [2];
-                                    }
-                                });
-                            }); });
-                            _a.label = 1;
-                        case 1:
-                            _a.trys.push([1, 3, 4, 5]);
-                            return [4, this._wsInitPromise];
-                        case 2:
-                            _a.sent();
-                            this._wsReadySubsribers.forEach(function (_a) {
-                                var resolve = _a.resolve;
-                                return resolve();
-                            });
-                            return [3, 5];
-                        case 3:
-                            e_1 = _a.sent();
-                            this._wsReadySubsribers.forEach(function (_a) {
-                                var reject = _a.reject;
-                                return reject();
-                            });
-                            return [3, 5];
-                        case 4:
-                            this._wsInitPromise = undefined;
-                            this._wsReadySubsribers = [];
-                            return [7];
-                        case 5: return [2];
-                    }
-                });
-            });
-        };
-        this.initWebSocketEvent = function () {
-            return new Promise(function (resolve, reject) {
-                if (!_this._ws) {
-                    throw new Error('can not initWebSocketEvent, ws not exists');
-                }
-                var wsOpened = false;
-                _this._ws.onopen = function (event) {
-                    console.warn('[realtime] ws event: open', event);
-                    wsOpened = true;
-                    resolve();
-                };
-                _this._ws.onerror = function (event) {
-                    _this._logins = new Map();
-                    if (!wsOpened) {
-                        console.error('[realtime] ws open failed with ws event: error', event);
-                        reject(event);
-                    }
-                    else {
-                        console.error('[realtime] ws event: error', event);
-                        _this.clearHeartbeat();
-                        _this._virtualWSClient.forEach(function (client) {
-                            return client.closeWithError(new CloudSDKError({
-                                errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_WEBSOCKET_CONNECTION_ERROR,
-                                errMsg: event
-                            }));
-                        });
-                    }
-                };
-                _this._ws.onclose = function (closeEvent) {
-                    console.warn('[realtime] ws event: close', closeEvent);
-                    _this._logins = new Map();
-                    _this.clearHeartbeat();
-                    switch (closeEvent.code) {
-                        case CLOSE_EVENT_CODE.ReconnectWebSocket: {
-                            break;
-                        }
-                        case CLOSE_EVENT_CODE.NoRealtimeListeners: {
-                            break;
-                        }
-                        case CLOSE_EVENT_CODE.HeartbeatPingError:
-                        case CLOSE_EVENT_CODE.HeartbeatPongTimeoutError:
-                        case CLOSE_EVENT_CODE.NormalClosure:
-                        case CLOSE_EVENT_CODE.AbnormalClosure: {
-                            if (_this._maxReconnect > 0) {
-                                _this.initWebSocketConnection(true, _this._maxReconnect);
-                            }
-                            else {
-                                _this.closeAllClients(getWSCloseError(closeEvent.code));
-                            }
-                            break;
-                        }
-                        case CLOSE_EVENT_CODE.NoAuthentication: {
-                            _this.closeAllClients(getWSCloseError(closeEvent.code, closeEvent.reason));
-                            break;
-                        }
-                        default: {
-                            if (_this._maxReconnect > 0) {
-                                _this.initWebSocketConnection(true, _this._maxReconnect);
-                            }
-                            else {
-                                _this.closeAllClients(getWSCloseError(closeEvent.code));
-                            }
-                        }
-                    }
-                };
-                _this._ws.onmessage = function (res) {
-                    var e_3, _a;
-                    var rawMsg = res.data;
-                    _this.heartbeat();
-                    var msg;
-                    try {
-                        msg = JSON.parse(rawMsg);
-                    }
-                    catch (e) {
-                        throw new Error("[realtime] onMessage parse res.data error: " + e);
-                    }
-                    if (msg.msgType === 'ERROR') {
-                        var virtualWatch_1 = null;
-                        _this._virtualWSClient.forEach(function (item) {
-                            if (item.watchId === msg.watchId) {
-                                virtualWatch_1 = item;
-                            }
-                        });
-                        if (virtualWatch_1) {
-                            virtualWatch_1.listener.onError(msg);
-                        }
-                    }
-                    var responseWaitSpec = _this._wsResponseWait.get(msg.requestId);
-                    if (responseWaitSpec) {
-                        try {
-                            if (msg.msgType === 'ERROR') {
-                                responseWaitSpec.reject(new RealtimeErrorMessageError(msg));
-                            }
-                            else {
-                                responseWaitSpec.resolve(msg);
-                            }
-                        }
-                        catch (e) {
-                            console.error('ws onMessage responseWaitSpec.resolve(msg) errored:', e);
-                        }
-                        finally {
-                            _this._wsResponseWait.delete(msg.requestId);
-                        }
-                        if (responseWaitSpec.skipOnMessage) {
-                            return;
-                        }
-                    }
-                    if (msg.msgType === 'PONG') {
-                        if (_this._lastPingSendTS) {
-                            var rtt = Date.now() - _this._lastPingSendTS;
-                            if (rtt > DEFAULT_UNTRUSTED_RTT_THRESHOLD) {
-                                console.warn("[realtime] untrusted rtt observed: " + rtt);
-                                return;
-                            }
-                            if (_this._rttObserved.length >= MAX_RTT_OBSERVED) {
-                                _this._rttObserved.splice(0, _this._rttObserved.length - MAX_RTT_OBSERVED + 1);
-                            }
-                            _this._rttObserved.push(rtt);
-                        }
-                        return;
-                    }
-                    var client = msg.watchId && _this._watchIdClientMap.get(msg.watchId);
-                    if (client) {
-                        client.onMessage(msg);
-                    }
-                    else {
-                        console.error("[realtime] no realtime listener found responsible for watchId " + msg.watchId + ": ", msg);
-                        switch (msg.msgType) {
-                            case 'INIT_EVENT':
-                            case 'NEXT_EVENT':
-                            case 'CHECK_EVENT': {
-                                client = _this._queryIdClientMap.get(msg.msgData.queryID);
-                                if (client) {
-                                    client.onMessage(msg);
-                                }
-                                break;
-                            }
-                            default: {
-                                try {
-                                    for (var _b = __values(_this._watchIdClientMap), _c = _b.next(); !_c.done; _c = _b.next()) {
-                                        var _d = __read(_c.value, 2), client_1 = _d[1];
-                                        client_1.onMessage(msg);
-                                        break;
-                                    }
-                                }
-                                catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                                finally {
-                                    try {
-                                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                                    }
-                                    finally { if (e_3) throw e_3.error; }
-                                }
-                            }
-                        }
-                    }
-                };
-                _this.heartbeat();
-            });
-        };
-        this.isWSConnected = function () {
-            return Boolean(_this._ws && _this._ws.readyState === WS_READY_STATE.OPEN);
-        };
-        this.onceWSConnected = function () { return __awaiter(_this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                if (this.isWSConnected()) {
-                    return [2];
-                }
-                if (this._wsInitPromise) {
-                    return [2, this._wsInitPromise];
-                }
-                return [2, new Promise(function (resolve, reject) {
-                        _this._wsReadySubsribers.push({
-                            resolve: resolve,
-                            reject: reject
-                        });
-                    })];
-            });
-        }); };
-        this.webLogin = function (envId, refresh) { return __awaiter(_this, void 0, void 0, function () {
-            var loginInfo_1, emptyEnvLoginInfo, promise, loginInfo, loginStartTS, loginResult, curLoginInfo, e_4;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!refresh) {
-                            if (envId) {
-                                loginInfo_1 = this._logins.get(envId);
-                                if (loginInfo_1) {
-                                    if (loginInfo_1.loggedIn && loginInfo_1.loginResult) {
-                                        return [2, loginInfo_1.loginResult];
-                                    }
-                                    else if (loginInfo_1.loggingInPromise) {
-                                        return [2, loginInfo_1.loggingInPromise];
-                                    }
-                                }
-                            }
-                            else {
-                                emptyEnvLoginInfo = this._logins.get('');
-                                if (emptyEnvLoginInfo && emptyEnvLoginInfo.loggingInPromise) {
-                                    return [2, emptyEnvLoginInfo.loggingInPromise];
-                                }
-                            }
-                        }
-                        promise = new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
-                            var wsSign, msgData, loginMsg, loginResMsg, e_5;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0:
-                                        _a.trys.push([0, 3, , 4]);
-                                        return [4, this.getWsSign()];
-                                    case 1:
-                                        wsSign = _a.sent();
-                                        msgData = {
-                                            envId: wsSign.envId || '',
-                                            accessToken: '',
-                                            referrer: 'web',
-                                            sdkVersion: '',
-                                            dataVersion: Db.dataVersion || ''
-                                        };
-                                        loginMsg = {
-                                            watchId: undefined,
-                                            requestId: genRequestId(),
-                                            msgType: 'LOGIN',
-                                            msgData: msgData,
-                                            exMsgData: {
-                                                runtime: Db.runtime,
-                                                signStr: wsSign.signStr,
-                                                secretVersion: wsSign.secretVersion
-                                            }
-                                        };
-                                        return [4, this.send({
-                                                msg: loginMsg,
-                                                waitResponse: true,
-                                                skipOnMessage: true,
-                                                timeout: DEFAULT_LOGIN_TIMEOUT
-                                            })];
-                                    case 2:
-                                        loginResMsg = _a.sent();
-                                        if (!loginResMsg.msgData.code) {
-                                            resolve({
-                                                envId: wsSign.envId
-                                            });
-                                        }
-                                        else {
-                                            reject(new Error(loginResMsg.msgData.code + " " + loginResMsg.msgData.message));
-                                        }
-                                        return [3, 4];
-                                    case 3:
-                                        e_5 = _a.sent();
-                                        reject(e_5);
-                                        return [3, 4];
-                                    case 4: return [2];
-                                }
-                            });
-                        }); });
-                        loginInfo = envId && this._logins.get(envId);
-                        loginStartTS = Date.now();
-                        if (loginInfo) {
-                            loginInfo.loggedIn = false;
-                            loginInfo.loggingInPromise = promise;
-                            loginInfo.loginStartTS = loginStartTS;
-                        }
-                        else {
-                            loginInfo = {
-                                loggedIn: false,
-                                loggingInPromise: promise,
-                                loginStartTS: loginStartTS
-                            };
-                            this._logins.set(envId || '', loginInfo);
-                        }
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4, promise];
-                    case 2:
-                        loginResult = _a.sent();
-                        curLoginInfo = envId && this._logins.get(envId);
-                        if (curLoginInfo &&
-                            curLoginInfo === loginInfo &&
-                            curLoginInfo.loginStartTS === loginStartTS) {
-                            loginInfo.loggedIn = true;
-                            loginInfo.loggingInPromise = undefined;
-                            loginInfo.loginStartTS = undefined;
-                            loginInfo.loginResult = loginResult;
-                            return [2, loginResult];
-                        }
-                        else if (curLoginInfo) {
-                            if (curLoginInfo.loggedIn && curLoginInfo.loginResult) {
-                                return [2, curLoginInfo.loginResult];
-                            }
-                            else if (curLoginInfo.loggingInPromise) {
-                                return [2, curLoginInfo.loggingInPromise];
-                            }
-                            else {
-                                throw new Error('ws unexpected login info');
-                            }
-                        }
-                        else {
-                            throw new Error('ws login info reset');
-                        }
-                        return [3, 4];
-                    case 3:
-                        e_4 = _a.sent();
-                        loginInfo.loggedIn = false;
-                        loginInfo.loggingInPromise = undefined;
-                        loginInfo.loginStartTS = undefined;
-                        loginInfo.loginResult = undefined;
-                        throw e_4;
-                    case 4: return [2];
-                }
-            });
-        }); };
-        this.getWsSign = function () { return __awaiter(_this, void 0, void 0, function () {
-            var expiredTs, res, _a, signStr, wsUrl, secretVersion, envId;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (this._wsSign && this._wsSign.expiredTs > Date.now()) {
-                            return [2, this._wsSign];
-                        }
-                        expiredTs = Date.now() + 60000;
-                        return [4, this._context.appConfig.request.send('auth.wsWebSign', { runtime: Db.runtime })];
-                    case 1:
-                        res = _b.sent();
-                        if (res.code) {
-                            throw new Error("[tcb-js-sdk] \u83B7\u53D6\u5B9E\u65F6\u6570\u636E\u63A8\u9001\u767B\u5F55\u7968\u636E\u5931\u8D25: " + res.code);
-                        }
-                        if (res.data) {
-                            _a = res.data, signStr = _a.signStr, wsUrl = _a.wsUrl, secretVersion = _a.secretVersion, envId = _a.envId;
-                            return [2, {
-                                    signStr: signStr,
-                                    wsUrl: wsUrl,
-                                    secretVersion: secretVersion,
-                                    envId: envId,
-                                    expiredTs: expiredTs
-                                }];
-                        }
-                        else {
-                            throw new Error('[tcb-js-sdk] 获取实时数据推送登录票据失败');
-                        }
-                        return [2];
-                }
-            });
-        }); };
-        this.getWaitExpectedTimeoutLength = function () {
-            if (!_this._rttObserved.length) {
-                return DEFAULT_EXPECTED_EVENT_WAIT_TIME;
-            }
-            return ((_this._rttObserved.reduce(function (acc, cur) { return acc + cur; }) /
-                _this._rttObserved.length) *
-                1.5);
-        };
-        this.ping = function () { return __awaiter(_this, void 0, void 0, function () {
-            var msg;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        msg = {
-                            watchId: undefined,
-                            requestId: genRequestId(),
-                            msgType: 'PING',
-                            msgData: null
-                        };
-                        return [4, this.send({
-                                msg: msg
-                            })];
-                    case 1:
-                        _a.sent();
-                        return [2];
-                }
-            });
-        }); };
-        this.send = function (opts) { return __awaiter(_this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                return [2, new Promise(function (_resolve, _reject) { return __awaiter(_this, void 0, void 0, function () {
-                        var timeoutId, _hasResolved, _hasRejected, resolve, reject, err_1, e_6;
-                        var _this = this;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0:
-                                    _hasResolved = false;
-                                    _hasRejected = false;
-                                    resolve = function (value) {
-                                        _hasResolved = true;
-                                        timeoutId && clearTimeout(timeoutId);
-                                        _resolve(value);
-                                    };
-                                    reject = function (error) {
-                                        _hasRejected = true;
-                                        timeoutId && clearTimeout(timeoutId);
-                                        _reject(error);
-                                    };
-                                    if (opts.timeout) {
-                                        timeoutId = setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
-                                            return __generator(this, function (_a) {
-                                                switch (_a.label) {
-                                                    case 0:
-                                                        if (!(!_hasResolved || !_hasRejected)) return [3, 2];
-                                                        return [4, sleep(0)];
-                                                    case 1:
-                                                        _a.sent();
-                                                        if (!_hasResolved || !_hasRejected) {
-                                                            reject(new TimeoutError('wsclient.send timedout'));
-                                                        }
-                                                        _a.label = 2;
-                                                    case 2: return [2];
-                                                }
-                                            });
-                                        }); }, opts.timeout);
-                                    }
-                                    _a.label = 1;
-                                case 1:
-                                    _a.trys.push([1, 8, , 9]);
-                                    if (!this._wsInitPromise) return [3, 3];
-                                    return [4, this._wsInitPromise];
-                                case 2:
-                                    _a.sent();
-                                    _a.label = 3;
-                                case 3:
-                                    if (!this._ws) {
-                                        reject(new Error('invalid state: ws connection not exists, can not send message'));
-                                        return [2];
-                                    }
-                                    if (this._ws.readyState !== WS_READY_STATE.OPEN) {
-                                        reject(new Error("ws readyState invalid: " + this._ws.readyState + ", can not send message"));
-                                        return [2];
-                                    }
-                                    if (opts.waitResponse) {
-                                        this._wsResponseWait.set(opts.msg.requestId, {
-                                            resolve: resolve,
-                                            reject: reject,
-                                            skipOnMessage: opts.skipOnMessage
-                                        });
-                                    }
-                                    _a.label = 4;
-                                case 4:
-                                    _a.trys.push([4, 6, , 7]);
-                                    return [4, this._ws.send(JSON.stringify(opts.msg))];
-                                case 5:
-                                    _a.sent();
-                                    if (!opts.waitResponse) {
-                                        resolve();
-                                    }
-                                    return [3, 7];
-                                case 6:
-                                    err_1 = _a.sent();
-                                    if (err_1) {
-                                        reject(err_1);
-                                        if (opts.waitResponse) {
-                                            this._wsResponseWait.delete(opts.msg.requestId);
-                                        }
-                                    }
-                                    return [3, 7];
-                                case 7: return [3, 9];
-                                case 8:
-                                    e_6 = _a.sent();
-                                    reject(e_6);
-                                    return [3, 9];
-                                case 9: return [2];
-                            }
-                        });
-                    }); })];
-            });
-        }); };
-        this.closeAllClients = function (error) {
-            _this._virtualWSClient.forEach(function (client) {
-                client.closeWithError(error);
-            });
-        };
-        this.pauseClients = function (clients) {
-            ;
-            (clients || _this._virtualWSClient).forEach(function (client) {
-                client.pause();
-            });
-        };
-        this.resumeClients = function (clients) {
-            ;
-            (clients || _this._virtualWSClient).forEach(function (client) {
-                client.resume();
-            });
-        };
-        this.onWatchStart = function (client, queryID) {
-            _this._queryIdClientMap.set(queryID, client);
-        };
-        this.onWatchClose = function (client, queryID) {
-            if (queryID) {
-                _this._queryIdClientMap.delete(queryID);
-            }
-            _this._watchIdClientMap.delete(client.watchId);
-            _this._virtualWSClient.delete(client);
-            if (!_this._virtualWSClient.size) {
-                _this.close(CLOSE_EVENT_CODE.NoRealtimeListeners);
-            }
-        };
-        this._maxReconnect = options.maxReconnect || DEFAULT_MAX_RECONNECT;
-        this._reconnectInterval =
-            options.reconnectInterval || DEFAULT_WS_RECONNECT_INTERVAL;
-        this._context = options.context;
-    }
-    RealtimeWebSocketClient.prototype.heartbeat = function (immediate) {
-        var _this = this;
-        this.clearHeartbeat();
-        this._pingTimeoutId = setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
-            var e_7;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        if (!this._ws || this._ws.readyState !== WS_READY_STATE.OPEN) {
-                            return [2];
-                        }
-                        this._lastPingSendTS = Date.now();
-                        return [4, this.ping()];
-                    case 1:
-                        _a.sent();
-                        this._pingFailed = 0;
-                        this._pongTimeoutId = setTimeout(function () {
-                            console.error('pong timed out');
-                            if (_this._pongMissed < DEFAULT_PONG_MISS_TOLERANCE) {
-                                _this._pongMissed++;
-                                _this.heartbeat(true);
-                            }
-                            else {
-                                _this.initWebSocketConnection(true);
-                            }
-                        }, this._context.appConfig.realtimePongWaitTimeout);
-                        return [3, 3];
-                    case 2:
-                        e_7 = _a.sent();
-                        if (this._pingFailed < DEFAULT_PING_FAIL_TOLERANCE) {
-                            this._pingFailed++;
-                            this.heartbeat();
-                        }
-                        else {
-                            this.close(CLOSE_EVENT_CODE.HeartbeatPingError);
-                        }
-                        return [3, 3];
-                    case 3: return [2];
-                }
-            });
-        }); }, immediate ? 0 : this._context.appConfig.realtimePingInterval);
-    };
-    RealtimeWebSocketClient.prototype.clearHeartbeat = function () {
-        this._pingTimeoutId && clearTimeout(this._pingTimeoutId);
-        this._pongTimeoutId && clearTimeout(this._pongTimeoutId);
-    };
-    RealtimeWebSocketClient.prototype.close = function (code) {
-        this.clearHeartbeat();
-        if (this._ws) {
-            this._ws.close(code, CLOSE_EVENT_CODE_INFO[code].name);
-            this._ws = undefined;
-        }
-    };
-    RealtimeWebSocketClient.prototype.watch = function (options) {
-        if (!this._ws && !this._wsInitPromise) {
-            this.initWebSocketConnection(false);
-        }
-        var virtualClient = new VirtualWebSocketClient(__assign(__assign({}, options), { send: this.send, login: this.webLogin, isWSConnected: this.isWSConnected, onceWSConnected: this.onceWSConnected, getWaitExpectedTimeoutLength: this.getWaitExpectedTimeoutLength, onWatchStart: this.onWatchStart, onWatchClose: this.onWatchClose, debug: true }));
-        this._virtualWSClient.add(virtualClient);
-        this._watchIdClientMap.set(virtualClient.watchId, virtualClient);
-        return virtualClient.listener;
-    };
-    return RealtimeWebSocketClient;
-}());
-export { RealtimeWebSocketClient };
+import { VirtualWebSocketClient } from './virtual-websocket-client';
+import { sleep } from '../utils/utils';
+import { genRequestId } from './message';
+import { CLOSE_EVENT_CODE, CLOSE_EVENT_CODE_INFO, getWSCloseError } from './ws-event';
+import { CloudSDKError, TimeoutError } from '../utils/error';
+import { RealtimeErrorMessageError } from './error';
+import { ERR_CODE } from '../config/error.config';
+import { Db } from '../';
+const WS_READY_STATE = {
+    CONNECTING: 0,
+    OPEN: 1,
+    CLOSING: 2,
+    CLOSED: 3
+};
+const MAX_RTT_OBSERVED = 3;
+const DEFAULT_EXPECTED_EVENT_WAIT_TIME = 5000;
+const DEFAULT_UNTRUSTED_RTT_THRESHOLD = 10000;
+const DEFAULT_MAX_RECONNECT = 5;
+const DEFAULT_WS_RECONNECT_INTERVAL = 10000;
+const DEFAULT_PING_FAIL_TOLERANCE = 2;
+const DEFAULT_PONG_MISS_TOLERANCE = 2;
+const DEFAULT_LOGIN_TIMEOUT = 5000;
+export class RealtimeWebSocketClient {
+    constructor(options) {
+        this._virtualWSClient = new Set();
+        this._queryIdClientMap = new Map();
+        this._watchIdClientMap = new Map();
+        this._pingFailed = 0;
+        this._pongMissed = 0;
+        this._logins = new Map();
+        this._wsReadySubsribers = [];
+        this._wsResponseWait = new Map();
+        this._rttObserved = [];
+        this.initWebSocketConnection = async (reconnect, availableRetries = this._maxReconnect) => {
+            if (reconnect && this._reconnectState) {
+                return;
+            }
+            if (reconnect) {
+                this._reconnectState = true;
+            }
+            if (this._wsInitPromise) {
+                return this._wsInitPromise;
+            }
+            if (reconnect) {
+                this.pauseClients();
+            }
+            this.close(CLOSE_EVENT_CODE.ReconnectWebSocket);
+            this._wsInitPromise = new Promise(async (resolve, reject) => {
+                try {
+                    const wsSign = await this.getWsSign();
+                    await new Promise(success => {
+                        const url = wsSign.wsUrl || 'wss://tcb-ws.tencentcloudapi.com';
+                        this._ws = Db.wsClass ? new Db.wsClass(url) : new WebSocket(url);
+                        success();
+                    });
+                    if (this._ws.connect) {
+                        await this._ws.connect();
+                    }
+                    await this.initWebSocketEvent();
+                    resolve();
+                    if (reconnect) {
+                        this.resumeClients();
+                        this._reconnectState = false;
+                    }
+                }
+                catch (e) {
+                    console.error('[realtime] initWebSocketConnection connect fail', e);
+                    if (availableRetries > 0) {
+                        const isConnected = true;
+                        this._wsInitPromise = undefined;
+                        if (isConnected) {
+                            await sleep(this._reconnectInterval);
+                            if (reconnect) {
+                                this._reconnectState = false;
+                            }
+                        }
+                        resolve(this.initWebSocketConnection(reconnect, availableRetries - 1));
+                    }
+                    else {
+                        reject(e);
+                        if (reconnect) {
+                            this.closeAllClients(new CloudSDKError({
+                                errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_RECONNECT_WATCH_FAIL,
+                                errMsg: e
+                            }));
+                        }
+                    }
+                }
+            });
+            try {
+                await this._wsInitPromise;
+                this._wsReadySubsribers.forEach(({ resolve }) => resolve());
+            }
+            catch (e) {
+                this._wsReadySubsribers.forEach(({ reject }) => reject());
+            }
+            finally {
+                this._wsInitPromise = undefined;
+                this._wsReadySubsribers = [];
+            }
+        };
+        this.initWebSocketEvent = () => new Promise((resolve, reject) => {
+            if (!this._ws) {
+                throw new Error('can not initWebSocketEvent, ws not exists');
+            }
+            let wsOpened = false;
+            this._ws.onopen = event => {
+                console.warn('[realtime] ws event: open', event);
+                wsOpened = true;
+                resolve();
+            };
+            this._ws.onerror = event => {
+                this._logins = new Map();
+                if (!wsOpened) {
+                    console.error('[realtime] ws open failed with ws event: error', event);
+                    reject(event);
+                }
+                else {
+                    console.error('[realtime] ws event: error', event);
+                    this.clearHeartbeat();
+                    this._virtualWSClient.forEach(client => client.closeWithError(new CloudSDKError({
+                        errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_WEBSOCKET_CONNECTION_ERROR,
+                        errMsg: event
+                    })));
+                }
+            };
+            this._ws.onclose = closeEvent => {
+                console.warn('[realtime] ws event: close', closeEvent);
+                this._logins = new Map();
+                this.clearHeartbeat();
+                switch (closeEvent.code) {
+                    case CLOSE_EVENT_CODE.ReconnectWebSocket: {
+                        break;
+                    }
+                    case CLOSE_EVENT_CODE.NoRealtimeListeners: {
+                        break;
+                    }
+                    case CLOSE_EVENT_CODE.HeartbeatPingError:
+                    case CLOSE_EVENT_CODE.HeartbeatPongTimeoutError:
+                    case CLOSE_EVENT_CODE.NormalClosure:
+                    case CLOSE_EVENT_CODE.AbnormalClosure: {
+                        if (this._maxReconnect > 0) {
+                            this.initWebSocketConnection(true, this._maxReconnect);
+                        }
+                        else {
+                            this.closeAllClients(getWSCloseError(closeEvent.code));
+                        }
+                        break;
+                    }
+                    case CLOSE_EVENT_CODE.NoAuthentication: {
+                        this.closeAllClients(getWSCloseError(closeEvent.code, closeEvent.reason));
+                        break;
+                    }
+                    default: {
+                        if (this._maxReconnect > 0) {
+                            this.initWebSocketConnection(true, this._maxReconnect);
+                        }
+                        else {
+                            this.closeAllClients(getWSCloseError(closeEvent.code));
+                        }
+                    }
+                }
+            };
+            this._ws.onmessage = res => {
+                const rawMsg = res.data;
+                this.heartbeat();
+                let msg;
+                try {
+                    msg = JSON.parse(rawMsg);
+                }
+                catch (e) {
+                    throw new Error(`[realtime] onMessage parse res.data error: ${e}`);
+                }
+                if (msg.msgType === 'ERROR') {
+                    let virtualWatch = null;
+                    this._virtualWSClient.forEach(item => {
+                        if (item.watchId === msg.watchId) {
+                            virtualWatch = item;
+                        }
+                    });
+                    if (virtualWatch) {
+                        virtualWatch.listener.onError(msg);
+                    }
+                }
+                const responseWaitSpec = this._wsResponseWait.get(msg.requestId);
+                if (responseWaitSpec) {
+                    try {
+                        if (msg.msgType === 'ERROR') {
+                            responseWaitSpec.reject(new RealtimeErrorMessageError(msg));
+                        }
+                        else {
+                            responseWaitSpec.resolve(msg);
+                        }
+                    }
+                    catch (e) {
+                        console.error('ws onMessage responseWaitSpec.resolve(msg) errored:', e);
+                    }
+                    finally {
+                        this._wsResponseWait.delete(msg.requestId);
+                    }
+                    if (responseWaitSpec.skipOnMessage) {
+                        return;
+                    }
+                }
+                if (msg.msgType === 'PONG') {
+                    if (this._lastPingSendTS) {
+                        const rtt = Date.now() - this._lastPingSendTS;
+                        if (rtt > DEFAULT_UNTRUSTED_RTT_THRESHOLD) {
+                            console.warn(`[realtime] untrusted rtt observed: ${rtt}`);
+                            return;
+                        }
+                        if (this._rttObserved.length >= MAX_RTT_OBSERVED) {
+                            this._rttObserved.splice(0, this._rttObserved.length - MAX_RTT_OBSERVED + 1);
+                        }
+                        this._rttObserved.push(rtt);
+                    }
+                    return;
+                }
+                let client = msg.watchId && this._watchIdClientMap.get(msg.watchId);
+                if (client) {
+                    client.onMessage(msg);
+                }
+                else {
+                    console.error(`[realtime] no realtime listener found responsible for watchId ${msg.watchId}: `, msg);
+                    switch (msg.msgType) {
+                        case 'INIT_EVENT':
+                        case 'NEXT_EVENT':
+                        case 'CHECK_EVENT': {
+                            client = this._queryIdClientMap.get(msg.msgData.queryID);
+                            if (client) {
+                                client.onMessage(msg);
+                            }
+                            break;
+                        }
+                        default: {
+                            for (const [, client] of this._watchIdClientMap) {
+                                client.onMessage(msg);
+                                break;
+                            }
+                        }
+                    }
+                }
+            };
+            this.heartbeat();
+        });
+        this.isWSConnected = () => {
+            return Boolean(this._ws && this._ws.readyState === WS_READY_STATE.OPEN);
+        };
+        this.onceWSConnected = async () => {
+            if (this.isWSConnected()) {
+                return;
+            }
+            if (this._wsInitPromise) {
+                return this._wsInitPromise;
+            }
+            return new Promise((resolve, reject) => {
+                this._wsReadySubsribers.push({
+                    resolve,
+                    reject
+                });
+            });
+        };
+        this.webLogin = async (envId, refresh) => {
+            if (!refresh) {
+                if (envId) {
+                    const loginInfo = this._logins.get(envId);
+                    if (loginInfo) {
+                        if (loginInfo.loggedIn && loginInfo.loginResult) {
+                            return loginInfo.loginResult;
+                        }
+                        else if (loginInfo.loggingInPromise) {
+                            return loginInfo.loggingInPromise;
+                        }
+                    }
+                }
+                else {
+                    const emptyEnvLoginInfo = this._logins.get('');
+                    if (emptyEnvLoginInfo && emptyEnvLoginInfo.loggingInPromise) {
+                        return emptyEnvLoginInfo.loggingInPromise;
+                    }
+                }
+            }
+            const promise = new Promise(async (resolve, reject) => {
+                try {
+                    const wsSign = await this.getWsSign();
+                    const msgData = {
+                        envId: wsSign.envId || '',
+                        accessToken: '',
+                        referrer: 'web',
+                        sdkVersion: '',
+                        dataVersion: Db.dataVersion || ''
+                    };
+                    const loginMsg = {
+                        watchId: undefined,
+                        requestId: genRequestId(),
+                        msgType: 'LOGIN',
+                        msgData,
+                        exMsgData: {
+                            runtime: Db.runtime,
+                            signStr: wsSign.signStr,
+                            secretVersion: wsSign.secretVersion
+                        }
+                    };
+                    const loginResMsg = await this.send({
+                        msg: loginMsg,
+                        waitResponse: true,
+                        skipOnMessage: true,
+                        timeout: DEFAULT_LOGIN_TIMEOUT
+                    });
+                    if (!loginResMsg.msgData.code) {
+                        resolve({
+                            envId: wsSign.envId
+                        });
+                    }
+                    else {
+                        reject(new Error(`${loginResMsg.msgData.code} ${loginResMsg.msgData.message}`));
+                    }
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+            let loginInfo = envId && this._logins.get(envId);
+            const loginStartTS = Date.now();
+            if (loginInfo) {
+                loginInfo.loggedIn = false;
+                loginInfo.loggingInPromise = promise;
+                loginInfo.loginStartTS = loginStartTS;
+            }
+            else {
+                loginInfo = {
+                    loggedIn: false,
+                    loggingInPromise: promise,
+                    loginStartTS
+                };
+                this._logins.set(envId || '', loginInfo);
+            }
+            try {
+                const loginResult = await promise;
+                const curLoginInfo = envId && this._logins.get(envId);
+                if (curLoginInfo &&
+                    curLoginInfo === loginInfo &&
+                    curLoginInfo.loginStartTS === loginStartTS) {
+                    loginInfo.loggedIn = true;
+                    loginInfo.loggingInPromise = undefined;
+                    loginInfo.loginStartTS = undefined;
+                    loginInfo.loginResult = loginResult;
+                    return loginResult;
+                }
+                else if (curLoginInfo) {
+                    if (curLoginInfo.loggedIn && curLoginInfo.loginResult) {
+                        return curLoginInfo.loginResult;
+                    }
+                    else if (curLoginInfo.loggingInPromise) {
+                        return curLoginInfo.loggingInPromise;
+                    }
+                    else {
+                        throw new Error('ws unexpected login info');
+                    }
+                }
+                else {
+                    throw new Error('ws login info reset');
+                }
+            }
+            catch (e) {
+                loginInfo.loggedIn = false;
+                loginInfo.loggingInPromise = undefined;
+                loginInfo.loginStartTS = undefined;
+                loginInfo.loginResult = undefined;
+                throw e;
+            }
+        };
+        this.getWsSign = async () => {
+            if (this._wsSign && this._wsSign.expiredTs > Date.now()) {
+                return this._wsSign;
+            }
+            const expiredTs = Date.now() + 60000;
+            const res = await this._context.appConfig.request.send('auth.wsWebSign', { runtime: Db.runtime });
+            if (res.code) {
+                throw new Error(`[tcb-js-sdk] 获取实时数据推送登录票据失败: ${res.code}`);
+            }
+            if (res.data) {
+                const { signStr, wsUrl, secretVersion, envId } = res.data;
+                return {
+                    signStr,
+                    wsUrl,
+                    secretVersion,
+                    envId,
+                    expiredTs
+                };
+            }
+            else {
+                throw new Error('[tcb-js-sdk] 获取实时数据推送登录票据失败');
+            }
+        };
+        this.getWaitExpectedTimeoutLength = () => {
+            if (!this._rttObserved.length) {
+                return DEFAULT_EXPECTED_EVENT_WAIT_TIME;
+            }
+            return ((this._rttObserved.reduce((acc, cur) => acc + cur) /
+                this._rttObserved.length) *
+                1.5);
+        };
+        this.ping = async () => {
+            const msg = {
+                watchId: undefined,
+                requestId: genRequestId(),
+                msgType: 'PING',
+                msgData: null
+            };
+            await this.send({
+                msg
+            });
+        };
+        this.send = async (opts) => new Promise(async (_resolve, _reject) => {
+            let timeoutId;
+            let _hasResolved = false;
+            let _hasRejected = false;
+            const resolve = (value) => {
+                _hasResolved = true;
+                timeoutId && clearTimeout(timeoutId);
+                _resolve(value);
+            };
+            const reject = (error) => {
+                _hasRejected = true;
+                timeoutId && clearTimeout(timeoutId);
+                _reject(error);
+            };
+            if (opts.timeout) {
+                timeoutId = setTimeout(async () => {
+                    if (!_hasResolved || !_hasRejected) {
+                        await sleep(0);
+                        if (!_hasResolved || !_hasRejected) {
+                            reject(new TimeoutError('wsclient.send timedout'));
+                        }
+                    }
+                }, opts.timeout);
+            }
+            try {
+                if (this._wsInitPromise) {
+                    await this._wsInitPromise;
+                }
+                if (!this._ws) {
+                    reject(new Error('invalid state: ws connection not exists, can not send message'));
+                    return;
+                }
+                if (this._ws.readyState !== WS_READY_STATE.OPEN) {
+                    reject(new Error(`ws readyState invalid: ${this._ws.readyState}, can not send message`));
+                    return;
+                }
+                if (opts.waitResponse) {
+                    this._wsResponseWait.set(opts.msg.requestId, {
+                        resolve,
+                        reject,
+                        skipOnMessage: opts.skipOnMessage
+                    });
+                }
+                try {
+                    await this._ws.send(JSON.stringify(opts.msg));
+                    if (!opts.waitResponse) {
+                        resolve();
+                    }
+                }
+                catch (err) {
+                    if (err) {
+                        reject(err);
+                        if (opts.waitResponse) {
+                            this._wsResponseWait.delete(opts.msg.requestId);
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+        this.closeAllClients = (error) => {
+            this._virtualWSClient.forEach(client => {
+                client.closeWithError(error);
+            });
+        };
+        this.pauseClients = (clients) => {
+            ;
+            (clients || this._virtualWSClient).forEach(client => {
+                client.pause();
+            });
+        };
+        this.resumeClients = (clients) => {
+            ;
+            (clients || this._virtualWSClient).forEach(client => {
+                client.resume();
+            });
+        };
+        this.onWatchStart = (client, queryID) => {
+            this._queryIdClientMap.set(queryID, client);
+        };
+        this.onWatchClose = (client, queryID) => {
+            if (queryID) {
+                this._queryIdClientMap.delete(queryID);
+            }
+            this._watchIdClientMap.delete(client.watchId);
+            this._virtualWSClient.delete(client);
+            if (!this._virtualWSClient.size) {
+                this.close(CLOSE_EVENT_CODE.NoRealtimeListeners);
+            }
+        };
+        this._maxReconnect = options.maxReconnect || DEFAULT_MAX_RECONNECT;
+        this._reconnectInterval =
+            options.reconnectInterval || DEFAULT_WS_RECONNECT_INTERVAL;
+        this._context = options.context;
+    }
+    heartbeat(immediate) {
+        this.clearHeartbeat();
+        this._pingTimeoutId = setTimeout(async () => {
+            try {
+                if (!this._ws || this._ws.readyState !== WS_READY_STATE.OPEN) {
+                    return;
+                }
+                this._lastPingSendTS = Date.now();
+                await this.ping();
+                this._pingFailed = 0;
+                this._pongTimeoutId = setTimeout(() => {
+                    console.error('pong timed out');
+                    if (this._pongMissed < DEFAULT_PONG_MISS_TOLERANCE) {
+                        this._pongMissed++;
+                        this.heartbeat(true);
+                    }
+                    else {
+                        this.initWebSocketConnection(true);
+                    }
+                }, this._context.appConfig.realtimePongWaitTimeout);
+            }
+            catch (e) {
+                if (this._pingFailed < DEFAULT_PING_FAIL_TOLERANCE) {
+                    this._pingFailed++;
+                    this.heartbeat();
+                }
+                else {
+                    this.close(CLOSE_EVENT_CODE.HeartbeatPingError);
+                }
+            }
+        }, immediate ? 0 : this._context.appConfig.realtimePingInterval);
+    }
+    clearHeartbeat() {
+        this._pingTimeoutId && clearTimeout(this._pingTimeoutId);
+        this._pongTimeoutId && clearTimeout(this._pongTimeoutId);
+    }
+    close(code) {
+        this.clearHeartbeat();
+        if (this._ws) {
+            this._ws.close(code, CLOSE_EVENT_CODE_INFO[code].name);
+            this._ws = undefined;
+        }
+    }
+    watch(options) {
+        if (!this._ws && !this._wsInitPromise) {
+            this.initWebSocketConnection(false);
+        }
+        const virtualClient = new VirtualWebSocketClient(Object.assign(Object.assign({}, options), { send: this.send, login: this.webLogin, isWSConnected: this.isWSConnected, onceWSConnected: this.onceWSConnected, getWaitExpectedTimeoutLength: this.getWaitExpectedTimeoutLength, onWatchStart: this.onWatchStart, onWatchClose: this.onWatchClose, debug: true }));
+        this._virtualWSClient.add(virtualClient);
+        this._watchIdClientMap.set(virtualClient.watchId, virtualClient);
+        return virtualClient.listener;
+    }
+}