@cloudbase/js-sdk 3.3.14-beta.3 → 3.3.14-beta.4

package/node_modules/@cloudbase/realtime/dist/esm/websocket-client.js

@@ -0,0 +1,747 @@
+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 (g && (g = 0, op[0] && (_ = 0)), _) 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 };
+    }
+};
+import { VirtualWebSocketClient } from './virtual-websocket-client';
+import { genRequestId } from './message';
+import { CloseEventCode, CLOSE_EVENT_CODE_INFO, getWSCloseError, } from './ws-event';
+import { ERR_CODE, TimeoutError, RealtimeErrorMessageError, CloudSDKError } from './error';
+import { getWsClass, getRuntime } from './common';
+import { sleep } from './utils';
+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.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) {
+                        void (function () { return __awaiter(_this, void 0, void 0, function () {
+                            var timeoutId, hasResolved, hasRejected, resolve, reject, respWaitSpec, err_1, e_1;
+                            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 () {
+                                                (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 !== undefined || this.wsInitPromise !== null)) 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: ".concat(this.ws.readyState, ", can not send message")));
+                                            return [2];
+                                        }
+                                        if (opts.waitResponse) {
+                                            respWaitSpec = {
+                                                resolve: resolve,
+                                                reject: reject,
+                                                skipOnMessage: opts.skipOnMessage,
+                                            };
+                                            this.wsResponseWait.set(opts.msg.requestId, respWaitSpec);
+                                        }
+                                        _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(void 0);
+                                        }
+                                        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_1 = _a.sent();
+                                        reject(e_1);
+                                        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.initWebSocketConnection = function (reconnect, availableRetries) {
+            if (availableRetries === void 0) { availableRetries = _this.maxReconnect; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var e_2;
+                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 !== undefined && this.wsInitPromise !== null) {
+                                return [2, this.wsInitPromise];
+                            }
+                            if (reconnect) {
+                                this.pauseClients();
+                            }
+                            this.close(CloseEventCode.ReconnectWebSocket);
+                            this.wsInitPromise = new Promise(function (resolve, reject) {
+                                (function () { return __awaiter(_this, void 0, void 0, function () {
+                                    var wsSign_1, e_3, 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';
+                                                        var wsClass = getWsClass();
+                                                        _this.ws = wsClass ? new wsClass(url) : new WebSocket(url);
+                                                        success(void 0);
+                                                    })];
+                                            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_3 = _a.sent();
+                                                console.error('[realtime] initWebSocketConnection connect fail', e_3);
+                                                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_3);
+                                                if (reconnect) {
+                                                    this.closeAllClients(new CloudSDKError({
+                                                        errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_RECONNECT_WATCH_FAIL,
+                                                        errMsg: e_3,
+                                                    }));
+                                                }
+                                                _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_2 = _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 CloseEventCode.ReconnectWebSocket: {
+                        break;
+                    }
+                    case CloseEventCode.NoRealtimeListeners: {
+                        break;
+                    }
+                    case CloseEventCode.HeartbeatPingError:
+                    case CloseEventCode.HeartbeatPongTimeoutError:
+                    case CloseEventCode.NormalClosure:
+                    case CloseEventCode.AbnormalClosure: {
+                        if (_this.maxReconnect > 0) {
+                            _this.initWebSocketConnection(true, _this.maxReconnect);
+                        }
+                        else {
+                            _this.closeAllClients(getWSCloseError(closeEvent.code));
+                        }
+                        break;
+                    }
+                    case CloseEventCode.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 _a;
+                var rawMsg = ((_a = res.data) === null || _a === void 0 ? void 0 : _a.data) || res.data;
+                _this.heartbeat();
+                var msg;
+                try {
+                    msg = typeof rawMsg === 'string' ? JSON.parse(rawMsg) : rawMsg;
+                }
+                catch (e) {
+                    throw new Error("[realtime] onMessage parse res.data error: ".concat(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: ".concat(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 ".concat(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 (var _i = 0, _b = Array.from(_this.watchIdClientMap.entries()); _i < _b.length; _i++) {
+                                var _c = _b[_i], client_1 = _c[1];
+                                client_1.onMessage(msg);
+                                break;
+                            }
+                        }
+                    }
+                }
+            };
+            _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 !== null && this.wsInitPromise !== undefined) {
+                    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];
+                                    }
+                                    if (loginInfo_1.loggingInPromise !== null && loginInfo_1.loggingInPromise !== undefined) {
+                                        return [2, loginInfo_1.loggingInPromise];
+                                    }
+                                }
+                            }
+                            else {
+                                emptyEnvLoginInfo = this.logins.get('');
+                                if ((emptyEnvLoginInfo === null || emptyEnvLoginInfo === void 0 ? void 0 : emptyEnvLoginInfo.loggingInPromise) !== null && (emptyEnvLoginInfo === null || emptyEnvLoginInfo === void 0 ? void 0 : emptyEnvLoginInfo.loggingInPromise) !== undefined) {
+                                    return [2, emptyEnvLoginInfo.loggingInPromise];
+                                }
+                            }
+                        }
+                        promise = new Promise(function (resolve, reject) {
+                            (function () { 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: '',
+                                            };
+                                            loginMsg = {
+                                                watchId: undefined,
+                                                requestId: genRequestId(),
+                                                msgType: 'LOGIN',
+                                                msgData: msgData,
+                                                exMsgData: {
+                                                    runtime: getRuntime(),
+                                                    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("".concat(loginResMsg.msgData.code, " ").concat(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];
+                        }
+                        if (curLoginInfo) {
+                            if (curLoginInfo.loggedIn && curLoginInfo.loginResult) {
+                                return [2, curLoginInfo.loginResult];
+                            }
+                            if (curLoginInfo.loggingInPromise !== null && curLoginInfo.loggingInPromise !== undefined) {
+                                return [2, curLoginInfo.loggingInPromise];
+                            }
+                            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: getRuntime() })];
+                    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: ".concat(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,
+                                }];
+                        }
+                        throw new Error('[tcb-js-sdk] 获取实时数据推送登录票据失败');
+                }
+            });
+        }); };
+        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.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(CloseEventCode.NoRealtimeListeners);
+            }
+        };
+        this.maxReconnect = options.maxReconnect || DEFAULT_MAX_RECONNECT;
+        this.reconnectInterval = options.reconnectInterval || DEFAULT_WS_RECONNECT_INTERVAL;
+        this.context = options.context;
+    }
+    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 === undefined || this.wsInitPromise === null)) {
+            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;
+    };
+    RealtimeWebSocketClient.prototype.heartbeat = function (immediate) {
+        var _this = this;
+        this.clearHeartbeat();
+        this.pingTimeoutId = setTimeout(function () {
+            (function () { return __awaiter(_this, void 0, void 0, function () {
+                var e_6;
+                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 += 1;
+                                    _this.heartbeat(true);
+                                }
+                                else {
+                                    _this.initWebSocketConnection(true);
+                                }
+                            }, this.context.appConfig.realtimePongWaitTimeout);
+                            return [3, 3];
+                        case 2:
+                            e_6 = _a.sent();
+                            if (this.pingFailed < DEFAULT_PING_FAIL_TOLERANCE) {
+                                this.pingFailed += 1;
+                                this.heartbeat();
+                            }
+                            else {
+                                this.close(CloseEventCode.HeartbeatPingError);
+                            }
+                            return [3, 3];
+                        case 3: return [2];
+                    }
+                });
+            }); })();
+        }, immediate ? 0 : this.context.appConfig.realtimePingInterval);
+    };
+    return RealtimeWebSocketClient;
+}());
+export { RealtimeWebSocketClient };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"websocket-client.js","sourceRoot":"","sources":["../../src/websocket-client.ts"],"names":[],"mappings":"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","sourcesContent":["import { VirtualWebSocketClient } from './virtual-websocket-client'\nimport { genRequestId } from './message'\nimport {\n  IDatabaseServiceContext,\n} from '@cloudbase/types/database'\nimport {\n  IWatchOptions,\n  DBRealtimeListener,\n  IRequestMessage,\n  IResponseMessage,\n  IRequestMessagePingMsg,\n  IRequestMessageLoginMsg,\n  IResponseMessageLoginResMsg,\n  IRequestMessageLoginData,\n} from '@cloudbase/types/realtime'\nimport {\n  CloseEventCode,\n  CLOSE_EVENT_CODE_INFO,\n  getWSCloseError,\n} from './ws-event'\n\nimport { ERR_CODE, TimeoutError, RealtimeErrorMessageError, CloudSDKError } from './error'\nimport { getWsClass, getRuntime } from './common'\nimport { sleep } from './utils'\n\nexport interface IRealtimeWebSocketClientConstructorOptions {\n  maxReconnect?: number\n  reconnectInterval?: number\n  context: IDatabaseServiceContext\n}\n\nexport interface ISignature {\n  envId: string\n  secretVersion: number\n  signStr: string\n  wsUrl: string\n  expireTS: number\n}\n\nexport interface ILoginInfo {\n  loggedIn: boolean\n  loggingInPromise?: Promise<ILoginResult>\n  loginStartTS?: number\n  loginResult?: ILoginResult\n}\n\nexport interface ILoginResult {\n  envId: string\n}\n\nexport interface IWSSendOptions {\n  msg: IRequestMessage\n  waitResponse?: boolean\n  // when waitResponse is set to true, if skipOnMessage is true, general onMessage handler will be skipped\n  skipOnMessage?: boolean\n  timeout?: number\n}\n\nexport interface IWSWatchOptions extends IWatchOptions {\n  envId?: string\n  collectionName: string\n  query: string\n  limit?: number\n  orderBy?: Record<string, string>\n}\n\ninterface IResolveReject {\n  resolve: (value?: any | PromiseLike<any> | undefined) => void\n  reject: (reason?: any) => void\n}\n\ninterface IResponseWaitSpec extends IResolveReject {\n  skipOnMessage?: boolean\n}\n\ninterface IWsSign {\n  signStr: string,\n  wsUrl: string,\n  secretVersion: string\n  envId: string\n  expiredTs: number\n}\n\nconst WS_READY_STATE = {\n  CONNECTING: 0,\n  OPEN: 1,\n  CLOSING: 2,\n  CLOSED: 3,\n}\n\nconst MAX_RTT_OBSERVED = 3\nconst DEFAULT_EXPECTED_EVENT_WAIT_TIME = 5000\nconst DEFAULT_UNTRUSTED_RTT_THRESHOLD = 10000\nconst DEFAULT_MAX_RECONNECT = 5\nconst DEFAULT_WS_RECONNECT_INTERVAL = 10000\n// const DEFAULT_WS_RECONNECT_MAX_VALID_INTERVAL = 3 * 60 * 1000\nconst DEFAULT_PING_FAIL_TOLERANCE = 2\nconst DEFAULT_PONG_MISS_TOLERANCE = 2\nconst DEFAULT_LOGIN_TIMEOUT = 5000\n\nexport class RealtimeWebSocketClient {\n  private virtualWSClient: Set<VirtualWebSocketClient> = new Set()\n  // after listener initWatch, the listener has the queryID and can store it here\n  private queryIdClientMap: Map<string, VirtualWebSocketClient> = new Map()\n  private watchIdClientMap: Map<string, VirtualWebSocketClient> = new Map()\n  private maxReconnect: number\n  private reconnectInterval: number\n  private context: IDatabaseServiceContext\n  private ws?: any\n  private lastPingSendTS?: number\n  private pingFailed = 0\n  private pongMissed = 0\n  private pingTimeoutId?: number\n  private pongTimeoutId?: number\n  private logins: Map<string /* envId */, ILoginInfo> = new Map()\n  private wsInitPromise?: Promise<void>\n  private wsReadySubsribers: IResolveReject[] = []\n  private wsResponseWait: Map<\n  string /* requestId */,\n  IResponseWaitSpec\n  > = new Map()\n  private rttObserved: number[] = []\n  private reconnectState: boolean\n  // obtained from the first getSignature with no envId provided\n  private wsSign: IWsSign\n\n  constructor(options: IRealtimeWebSocketClientConstructorOptions) {\n    this.maxReconnect = options.maxReconnect || DEFAULT_MAX_RECONNECT\n    this.reconnectInterval = options.reconnectInterval || DEFAULT_WS_RECONNECT_INTERVAL\n    this.context = options.context\n  }\n\n  clearHeartbeat() {\n    this.pingTimeoutId && clearTimeout(this.pingTimeoutId)\n    this.pongTimeoutId && clearTimeout(this.pongTimeoutId)\n  }\n\n  send = async <T = any>(opts: IWSSendOptions): Promise<T> => new Promise<T>((_resolve, _reject) => {\n    void (async () => {\n      let timeoutId: number\n      let hasResolved = false\n      let hasRejected = false\n\n      const resolve: typeof _resolve = (value?: T | PromiseLike<T> | undefined) => {\n        hasResolved = true\n        timeoutId && clearTimeout(timeoutId)\n        _resolve(value)\n      }\n\n      const reject: typeof _reject = (error: any) => {\n        hasRejected = true\n        timeoutId && clearTimeout(timeoutId)\n        _reject(error)\n      }\n\n      if (opts.timeout) {\n        // @ts-ignore\n        timeoutId = setTimeout(() => {\n          (async () => {\n            if (!hasResolved || !hasRejected) {\n              // wait another immediate timeout to allow the success/fail callback to be invoked if ws has already got the result,\n              // this is because the timer is registered before ws.send\n              await sleep(0)\n              if (!hasResolved || !hasRejected) {\n                reject(new TimeoutError('wsclient.send timedout'))\n              }\n            }\n          })()\n        }, opts.timeout)\n      }\n\n      try {\n        if (this.wsInitPromise !== undefined || this.wsInitPromise !== null) {\n          await this.wsInitPromise\n        }\n\n        if (!this.ws) {\n          reject(new Error('invalid state: ws connection not exists, can not send message'))\n          return\n        }\n\n        if (this.ws.readyState !== WS_READY_STATE.OPEN) {\n          reject(new Error(`ws readyState invalid: ${this.ws.readyState}, can not send message`))\n          return\n        }\n\n        if (opts.waitResponse) {\n          const respWaitSpec: IResponseWaitSpec = {\n            resolve,\n            reject,\n            skipOnMessage: opts.skipOnMessage,\n          }\n          this.wsResponseWait.set(opts.msg.requestId, respWaitSpec)\n        }\n\n        // console.log('send msg:', opts.msg)\n        try {\n          await this.ws.send(JSON.stringify(opts.msg))\n          if (!opts.waitResponse) {\n            resolve(void 0)\n          }\n        } catch (err) {\n          if (err) {\n            reject(err)\n            if (opts.waitResponse) {\n              this.wsResponseWait.delete(opts.msg.requestId)\n            }\n          }\n        }\n      } catch (e) {\n        reject(e)\n      }\n    })()\n  })\n\n  close(code: CloseEventCode) {\n    this.clearHeartbeat()\n\n    if (this.ws) {\n      this.ws.close(code, CLOSE_EVENT_CODE_INFO[code].name)\n      this.ws = undefined\n    }\n  }\n\n  closeAllClients = (error: any) => {\n    this.virtualWSClient.forEach((client) => {\n      client.closeWithError(error)\n    })\n  }\n\n  pauseClients = (clients?: Set<VirtualWebSocketClient>) => {\n    (clients || this.virtualWSClient).forEach((client) => {\n      client.pause()\n    })\n  }\n\n  resumeClients = (clients?: Set<VirtualWebSocketClient>) => {\n    (clients || this.virtualWSClient).forEach((client) => {\n      client.resume()\n    })\n  }\n\n  watch(options: IWSWatchOptions): DBRealtimeListener {\n    if (!this.ws && (this.wsInitPromise === undefined || this.wsInitPromise === null)) {\n      this.initWebSocketConnection(false)\n    }\n\n    const virtualClient = new VirtualWebSocketClient({\n      ...options,\n      send: this.send,\n      login: this.webLogin,\n      isWSConnected: this.isWSConnected,\n      onceWSConnected: this.onceWSConnected,\n      getWaitExpectedTimeoutLength: this.getWaitExpectedTimeoutLength,\n      onWatchStart: this.onWatchStart,\n      onWatchClose: this.onWatchClose,\n      debug: true,\n    })\n    this.virtualWSClient.add(virtualClient)\n    this.watchIdClientMap.set(virtualClient.watchId, virtualClient)\n    return virtualClient.listener\n  }\n\n  private initWebSocketConnection = async (\n    reconnect: boolean,\n    availableRetries: number = this.maxReconnect\n  ): Promise<void> => {\n    // 当前处于正在重连中的状态\n    if (reconnect && this.reconnectState) {\n      return // 忽略\n    }\n\n    if (reconnect) {\n      this.reconnectState = true // 重连状态开始\n    }\n\n    if (this.wsInitPromise !== undefined && this.wsInitPromise !== null) {\n      // there already exists a websocket initiation, just wait for it\n      return this.wsInitPromise\n    }\n\n    if (reconnect) {\n      this.pauseClients()\n    }\n\n    this.close(CloseEventCode.ReconnectWebSocket)\n\n    this.wsInitPromise = new Promise<void>((resolve, reject) => {\n      (async () => {\n        try {\n          const wsSign = await this.getWsSign()\n\n          await new Promise((success) => {\n            const url = wsSign.wsUrl || 'wss://tcb-ws.tencentcloudapi.com'\n            const wsClass = getWsClass()\n            /* eslint-disable-next-line */\n            this.ws = wsClass ? new wsClass(url) : new WebSocket(url)\n            success(void 0)\n          })\n\n          if (this.ws.connect) {\n            await this.ws.connect()\n          }\n\n          await this.initWebSocketEvent()\n          resolve()\n\n          if (reconnect) {\n            this.resumeClients()\n            this.reconnectState = false // 重连状态结束\n          }\n        } catch (e) {\n          console.error('[realtime] initWebSocketConnection connect fail', e)\n\n          if (availableRetries > 0) {\n            // this is an optimization, in case of network offline, we don't need to stubbornly sleep for sometime,\n            // we only need to wait for the network to be back online, this ensures minimum downtime\n            // const { isConnected } = await getNetworkStatus()\n            const isConnected = true\n\n            this.wsInitPromise = undefined\n\n            if (isConnected) {\n              await sleep(this.reconnectInterval)\n              if (reconnect) {\n                this.reconnectState = false // 重连异常也算重连状态结束\n              }\n            }\n\n            resolve(this.initWebSocketConnection(reconnect, availableRetries - 1))\n          } else {\n            reject(e)\n\n            if (reconnect) {\n              this.closeAllClients(new CloudSDKError({\n                errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_RECONNECT_WATCH_FAIL as string,\n                errMsg: e,\n              }))\n            }\n          }\n        }\n      })()\n    })\n\n    try {\n      await this.wsInitPromise\n      this.wsReadySubsribers.forEach(({ resolve }) => resolve())\n    } catch (e) {\n      this.wsReadySubsribers.forEach(({ reject }) => reject())\n    } finally {\n      this.wsInitPromise = undefined\n      this.wsReadySubsribers = []\n    }\n  }\n\n  private initWebSocketEvent = () => new Promise<void>((resolve, reject) => {\n    if (!this.ws) {\n      throw new Error('can not initWebSocketEvent, ws not exists')\n    }\n\n    let wsOpened = false\n\n    this.ws.onopen = (event) => {\n      console.warn('[realtime] ws event: open', event)\n      wsOpened = true\n      resolve()\n    }\n\n    this.ws.onerror = (event) => {\n      // all logins are invalid after disconnection\n      this.logins = new Map()\n\n      // error写进file\n\n      if (!wsOpened) {\n        console.error('[realtime] ws open failed with ws event: error', event)\n        reject(event)\n      } else {\n        console.error('[realtime] ws event: error', event)\n\n        this.clearHeartbeat()\n        this.virtualWSClient.forEach(client => client.closeWithError(new CloudSDKError({\n          errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_WEBSOCKET_CONNECTION_ERROR as string,\n          errMsg: event,\n        })))\n      }\n    }\n\n    // TODO: reconnect\n    this.ws.onclose = (closeEvent) => {\n      console.warn('[realtime] ws event: close', closeEvent)\n      // all logins are invalid after disconnection\n      this.logins = new Map()\n\n      this.clearHeartbeat()\n      switch (closeEvent.code) {\n        case CloseEventCode.ReconnectWebSocket: {\n          // just ignore\n          break\n        }\n        case CloseEventCode.NoRealtimeListeners: {\n          // quit\n          break\n        }\n        case CloseEventCode.HeartbeatPingError:\n        case CloseEventCode.HeartbeatPongTimeoutError:\n        case CloseEventCode.NormalClosure:\n        case CloseEventCode.AbnormalClosure: {\n          // Normal Closure and Abnormal Closure:\n          //   expected closure, most likely dispatched by wechat client,\n          //   since this is the status code dispatched in case of network failure,\n          //   we should retry\n\n          if (this.maxReconnect > 0) {\n            this.initWebSocketConnection(true, this.maxReconnect)\n          } else {\n            this.closeAllClients(getWSCloseError(closeEvent.code))\n          }\n          break\n        }\n        case CloseEventCode.NoAuthentication: {\n          this.closeAllClients(getWSCloseError(closeEvent.code, closeEvent.reason))\n          break\n        }\n        default: {\n          // we should retry by default\n          if (this.maxReconnect > 0) {\n            this.initWebSocketConnection(true, this.maxReconnect)\n          } else {\n            this.closeAllClients(getWSCloseError(closeEvent.code))\n          }\n        }\n      }\n    }\n\n    this.ws.onmessage = (res) => {\n      // 支付宝小程序会返回res.data.data或res.message\n      // 微信小程序返回res.data\n      const rawMsg = res.data?.data || res.data\n\n      // reset & restart heartbeat\n      this.heartbeat()\n\n      let msg: IResponseMessage\n\n      try {\n        msg = typeof rawMsg === 'string' ? JSON.parse(rawMsg as string) : rawMsg\n      } catch (e) {\n        throw new Error(`[realtime] onMessage parse res.data error: ${e}`)\n      }\n\n      if (msg.msgType === 'ERROR') {\n        // 找到当前监听，并将error返回\n        let virtualWatch = null\n        this.virtualWSClient.forEach((item) => {\n          if (item.watchId === msg.watchId) {\n            virtualWatch = item\n          }\n        })\n\n        if (virtualWatch) {\n          virtualWatch.listener.onError(msg)\n        }\n      }\n\n      const responseWaitSpec = this.wsResponseWait.get(msg.requestId)\n      if (responseWaitSpec) {\n        try {\n          if (msg.msgType === 'ERROR') {\n            responseWaitSpec.reject(new RealtimeErrorMessageError(msg))\n          } else {\n            responseWaitSpec.resolve(msg)\n          }\n        } catch (e) {\n          console.error(\n            'ws onMessage responseWaitSpec.resolve(msg) errored:',\n            e\n          )\n        } finally {\n          this.wsResponseWait.delete(msg.requestId)\n        }\n        if (responseWaitSpec.skipOnMessage) {\n          return\n        }\n      }\n\n      if (msg.msgType === 'PONG') {\n        if (this.lastPingSendTS) {\n          const rtt = Date.now() - this.lastPingSendTS\n          if (rtt > DEFAULT_UNTRUSTED_RTT_THRESHOLD) {\n            console.warn(`[realtime] untrusted rtt observed: ${rtt}`)\n            return\n          }\n          if (this.rttObserved.length >= MAX_RTT_OBSERVED) {\n            this.rttObserved.splice(\n              0,\n              this.rttObserved.length - MAX_RTT_OBSERVED + 1\n            )\n          }\n          this.rttObserved.push(rtt)\n        }\n        return\n      }\n\n      let client = msg.watchId && this.watchIdClientMap.get(msg.watchId)\n      if (client) {\n        client.onMessage(msg)\n      } else {\n        console.error(\n          `[realtime] no realtime listener found responsible for watchId ${msg.watchId}: `,\n          msg\n        )\n        switch (msg.msgType) {\n          case 'INIT_EVENT':\n          case 'NEXT_EVENT':\n          case 'CHECK_EVENT': {\n            client = this.queryIdClientMap.get(msg.msgData.queryID)\n            if (client) {\n              client.onMessage(msg)\n            }\n            break\n          }\n          default: {\n            for (const [, client] of Array.from(this.watchIdClientMap.entries())) {\n              client.onMessage(msg)\n              break\n            }\n          }\n        }\n      }\n    }\n\n    this.heartbeat()\n  })\n\n  private isWSConnected = (): boolean => Boolean(this.ws && this.ws.readyState === WS_READY_STATE.OPEN)\n\n  private onceWSConnected = async (): Promise<void> => {\n    if (this.isWSConnected()) {\n      return\n    }\n\n    if (this.wsInitPromise !== null && this.wsInitPromise !== undefined) {\n      return this.wsInitPromise\n    }\n\n    return new Promise<void>((resolve, reject) => {\n      this.wsReadySubsribers.push({\n        resolve,\n        reject,\n      })\n    })\n  }\n\n  private webLogin = async (\n    envId?: string,\n    refresh?: boolean\n  ): Promise<any> => {\n    if (!refresh) {\n      if (envId) {\n        const loginInfo = this.logins.get(envId)\n        if (loginInfo) {\n          if (loginInfo.loggedIn && loginInfo.loginResult) {\n            return loginInfo.loginResult\n          } if (loginInfo.loggingInPromise !== null && loginInfo.loggingInPromise !== undefined) {\n            return loginInfo.loggingInPromise\n          }\n        }\n      } else {\n        const emptyEnvLoginInfo = this.logins.get('')\n        if (emptyEnvLoginInfo?.loggingInPromise !== null && emptyEnvLoginInfo?.loggingInPromise !== undefined) {\n          return emptyEnvLoginInfo.loggingInPromise\n        }\n      }\n    }\n\n    const promise = new Promise<ILoginResult>((resolve, reject) => {\n      (async () => {\n        try {\n          const wsSign = await this.getWsSign()\n\n          const msgData: IRequestMessageLoginData = {\n            envId: wsSign.envId || '',\n            accessToken: '', // 已废弃字段\n            referrer: 'web',\n            sdkVersion: '',\n            dataVersion: '',\n          }\n          const loginMsg: IRequestMessageLoginMsg = {\n            watchId: undefined,\n            requestId: genRequestId(),\n            msgType: 'LOGIN',\n            msgData,\n            exMsgData: {\n              runtime: getRuntime(),\n              signStr: wsSign.signStr,\n              secretVersion: wsSign.secretVersion,\n            },\n          }\n          const loginResMsg = await this.send<IResponseMessageLoginResMsg>({\n            msg: loginMsg,\n            waitResponse: true,\n            skipOnMessage: true,\n            timeout: DEFAULT_LOGIN_TIMEOUT,\n          })\n\n          if (!loginResMsg.msgData.code) {\n            // login success\n            resolve({\n              envId: wsSign.envId,\n            })\n          } else {\n            // login failed\n            reject(new Error(`${loginResMsg.msgData.code} ${loginResMsg.msgData.message}`))\n          }\n        } catch (e) {\n          reject(e)\n        }\n      })()\n    })\n\n    let loginInfo = envId && this.logins.get(envId)\n\n    const loginStartTS = Date.now()\n\n    if (loginInfo) {\n      loginInfo.loggedIn = false\n      loginInfo.loggingInPromise = promise\n      loginInfo.loginStartTS = loginStartTS\n    } else {\n      loginInfo = {\n        loggedIn: false,\n        loggingInPromise: promise,\n        loginStartTS,\n      }\n      this.logins.set(envId || '', loginInfo)\n    }\n\n    try {\n      const loginResult = await promise\n      const curLoginInfo = envId && this.logins.get(envId)\n      if (\n        curLoginInfo\n        && curLoginInfo === loginInfo\n        && curLoginInfo.loginStartTS === loginStartTS\n      ) {\n        loginInfo.loggedIn = true\n        loginInfo.loggingInPromise = undefined\n        loginInfo.loginStartTS = undefined\n        loginInfo.loginResult = loginResult\n        return loginResult\n      } if (curLoginInfo) {\n        if (curLoginInfo.loggedIn && curLoginInfo.loginResult) {\n          return curLoginInfo.loginResult\n        } if (curLoginInfo.loggingInPromise !== null && curLoginInfo.loggingInPromise !== undefined) {\n          return curLoginInfo.loggingInPromise\n        }\n        throw new Error('ws unexpected login info')\n      } else {\n        throw new Error('ws login info reset')\n      }\n    } catch (e) {\n      loginInfo.loggedIn = false\n      loginInfo.loggingInPromise = undefined\n      loginInfo.loginStartTS = undefined\n      loginInfo.loginResult = undefined\n      throw e\n    }\n  }\n\n  private getWsSign = async (): Promise<IWsSign> => {\n    if (this.wsSign && this.wsSign.expiredTs > Date.now()) {\n      return this.wsSign\n    }\n    const expiredTs = Date.now() + 60000\n    const res = await this.context.appConfig.request.send('auth.wsWebSign', { runtime: getRuntime() })\n\n    if (res.code) {\n      throw new Error(`[tcb-js-sdk] 获取实时数据推送登录票据失败: ${res.code}`)\n    }\n\n    if (res.data) {\n      const { signStr, wsUrl, secretVersion, envId } = res.data\n      return {\n        signStr,\n        wsUrl,\n        secretVersion,\n        envId,\n        expiredTs,\n      }\n    }\n    throw new Error('[tcb-js-sdk] 获取实时数据推送登录票据失败')\n  }\n\n  private getWaitExpectedTimeoutLength = () => {\n    if (!this.rttObserved.length) {\n      return DEFAULT_EXPECTED_EVENT_WAIT_TIME\n    }\n\n    // 1.5 * RTT\n    return (\n      (this.rttObserved.reduce((acc, cur) => acc + cur)\n        / this.rttObserved.length)\n      * 1.5\n    )\n  }\n\n  private heartbeat(immediate?: boolean) {\n    this.clearHeartbeat()\n    // @ts-ignore\n    this.pingTimeoutId = setTimeout(\n      () => {\n        (\n          async () => {\n            try {\n              if (!this.ws || this.ws.readyState !== WS_READY_STATE.OPEN) {\n                // no need to ping\n                return\n              }\n\n              this.lastPingSendTS = Date.now()\n              await this.ping()\n              this.pingFailed = 0\n\n              // @ts-ignore\n              this.pongTimeoutId = setTimeout(() => {\n                console.error('pong timed out')\n                if (this.pongMissed < DEFAULT_PONG_MISS_TOLERANCE) {\n                  this.pongMissed += 1\n                  this.heartbeat(true)\n                } else {\n                  // logical perceived connection lost, even though websocket did not receive error or close event\n                  this.initWebSocketConnection(true)\n                }\n              }, this.context.appConfig.realtimePongWaitTimeout)\n            } catch (e) {\n              if (this.pingFailed < DEFAULT_PING_FAIL_TOLERANCE) {\n                this.pingFailed += 1\n                this.heartbeat()\n              } else {\n                this.close(CloseEventCode.HeartbeatPingError)\n              }\n            }\n          }\n        )()\n      },\n      immediate ? 0 : this.context.appConfig.realtimePingInterval\n    )\n  }\n\n  private ping = async () => {\n    const msg: IRequestMessagePingMsg = {\n      watchId: undefined,\n      requestId: genRequestId(),\n      msgType: 'PING',\n      msgData: null,\n    }\n    await this.send({\n      msg,\n    })\n  }\n\n  private onWatchStart = (client: VirtualWebSocketClient, queryID: string) => {\n    this.queryIdClientMap.set(queryID, client)\n  }\n\n  private onWatchClose = (client: VirtualWebSocketClient, queryID: string) => {\n    if (queryID) {\n      this.queryIdClientMap.delete(queryID)\n    }\n    this.watchIdClientMap.delete(client.watchId)\n    this.virtualWSClient.delete(client)\n\n    if (!this.virtualWSClient.size) {\n      // no more existing watch, we should release the websocket connection\n      this.close(CloseEventCode.NoRealtimeListeners)\n    }\n  }\n}\n"]}