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

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

@@ -0,0 +1,960 @@
+"use strict";
+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 };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VirtualWebSocketClient = void 0;
+var set_1 = __importDefault(require("lodash/set"));
+var unset_1 = __importDefault(require("lodash/unset"));
+var cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
+var message_1 = require("./message");
+var listener_1 = require("./listener");
+var snapshot_1 = require("./snapshot");
+var error_1 = require("./error");
+var utils_1 = require("./utils");
+var WatchStatus;
+(function (WatchStatus) {
+    WatchStatus["LOGGINGIN"] = "LOGGINGIN";
+    WatchStatus["INITING"] = "INITING";
+    WatchStatus["REBUILDING"] = "REBUILDING";
+    WatchStatus["ACTIVE"] = "ACTIVE";
+    WatchStatus["ERRORED"] = "ERRORED";
+    WatchStatus["CLOSING"] = "CLOSING";
+    WatchStatus["CLOSED"] = "CLOSED";
+    WatchStatus["PAUSED"] = "PAUSED";
+    WatchStatus["RESUMING"] = "RESUMING";
+})(WatchStatus || (WatchStatus = {}));
+var DEFAULT_WAIT_TIME_ON_UNKNOWN_ERROR = 100;
+var DEFAULT_MAX_AUTO_RETRY_ON_ERROR = 2;
+var DEFAULT_MAX_SEND_ACK_AUTO_RETRY_ON_ERROR = 2;
+var DEFAULT_SEND_ACK_DEBOUNCE_TIMEOUT = 10 * 1000;
+var DEFAULT_INIT_WATCH_TIMEOUT = 10 * 1000;
+var DEFAULT_REBUILD_WATCH_TIMEOUT = 10 * 1000;
+var VirtualWebSocketClient = (function () {
+    function VirtualWebSocketClient(options) {
+        var _this = this;
+        this.watchStatus = WatchStatus.INITING;
+        this.wsLogin = function (envId, refresh) { return __awaiter(_this, void 0, void 0, function () {
+            var loginResult;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.watchStatus = WatchStatus.LOGGINGIN;
+                        return [4, this.login(envId, refresh)];
+                    case 1:
+                        loginResult = _a.sent();
+                        if (!this.envId) {
+                            this.envId = loginResult.envId;
+                        }
+                        return [2, loginResult];
+                }
+            });
+        }); };
+        this.initWatch = function (forceRefreshLogin) { return __awaiter(_this, void 0, void 0, function () {
+            var success;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.initWatchPromise !== null && this.initWatchPromise !== undefined) {
+                            return [2, this.initWatchPromise];
+                        }
+                        this.initWatchPromise = new Promise(function (resolve, reject) {
+                            void (function () { return __awaiter(_this, void 0, void 0, function () {
+                                var envId, initWatchMsg, initEventMsg, _a, events, currEvent, _i, events_1, e, snapshot, e_1;
+                                return __generator(this, function (_b) {
+                                    switch (_b.label) {
+                                        case 0:
+                                            _b.trys.push([0, 3, , 4]);
+                                            if (this.watchStatus === WatchStatus.PAUSED) {
+                                                console.log('[realtime] initWatch cancelled on pause');
+                                                return [2, resolve()];
+                                            }
+                                            return [4, this.wsLogin(this.envId, forceRefreshLogin)];
+                                        case 1:
+                                            envId = (_b.sent()).envId;
+                                            if (this.watchStatus === WatchStatus.PAUSED) {
+                                                console.log('[realtime] initWatch cancelled on pause');
+                                                return [2, resolve()];
+                                            }
+                                            this.watchStatus = WatchStatus.INITING;
+                                            initWatchMsg = {
+                                                watchId: this.watchId,
+                                                requestId: (0, message_1.genRequestId)(),
+                                                msgType: 'INIT_WATCH',
+                                                msgData: {
+                                                    envId: envId,
+                                                    collName: this.collectionName,
+                                                    query: this.query,
+                                                    limit: this.limit,
+                                                    orderBy: this.orderBy,
+                                                },
+                                            };
+                                            return [4, this.send({
+                                                    msg: initWatchMsg,
+                                                    waitResponse: true,
+                                                    skipOnMessage: true,
+                                                    timeout: DEFAULT_INIT_WATCH_TIMEOUT,
+                                                })];
+                                        case 2:
+                                            initEventMsg = _b.sent();
+                                            _a = initEventMsg.msgData, events = _a.events, currEvent = _a.currEvent;
+                                            this.sessionInfo = {
+                                                queryID: initEventMsg.msgData.queryID,
+                                                currentEventId: currEvent - 1,
+                                                currentDocs: [],
+                                            };
+                                            if (events.length > 0) {
+                                                for (_i = 0, events_1 = events; _i < events_1.length; _i++) {
+                                                    e = events_1[_i];
+                                                    e.ID = currEvent;
+                                                }
+                                                this.handleServerEvents(initEventMsg);
+                                            }
+                                            else {
+                                                this.sessionInfo.currentEventId = currEvent;
+                                                snapshot = new snapshot_1.Snapshot({
+                                                    id: currEvent,
+                                                    docChanges: [],
+                                                    docs: [],
+                                                    type: 'init',
+                                                });
+                                                this.listener.onChange(snapshot);
+                                                this.scheduleSendACK();
+                                            }
+                                            this.onWatchStart(this, this.sessionInfo.queryID);
+                                            this.watchStatus = WatchStatus.ACTIVE;
+                                            this.availableRetries.INIT_WATCH = DEFAULT_MAX_AUTO_RETRY_ON_ERROR;
+                                            resolve();
+                                            return [3, 4];
+                                        case 3:
+                                            e_1 = _b.sent();
+                                            this.handleWatchEstablishmentError(e_1, {
+                                                operationName: 'INIT_WATCH',
+                                                resolve: resolve,
+                                                reject: reject,
+                                            });
+                                            return [3, 4];
+                                        case 4: return [2];
+                                    }
+                                });
+                            }); })();
+                        });
+                        success = false;
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, , 3, 4]);
+                        return [4, this.initWatchPromise];
+                    case 2:
+                        _a.sent();
+                        success = true;
+                        return [3, 4];
+                    case 3:
+                        this.initWatchPromise = undefined;
+                        return [7];
+                    case 4:
+                        console.log("[realtime] initWatch ".concat(success ? 'success' : 'fail'));
+                        return [2];
+                }
+            });
+        }); };
+        this.rebuildWatch = function (forceRefreshLogin) { return __awaiter(_this, void 0, void 0, function () {
+            var success;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.rebuildWatchPromise !== null && this.rebuildWatchPromise !== undefined) {
+                            return [2, this.rebuildWatchPromise];
+                        }
+                        this.rebuildWatchPromise = new Promise(function (resolve, reject) {
+                            void (function () { return __awaiter(_this, void 0, void 0, function () {
+                                var envId, rebuildWatchMsg, nextEventMsg, e_2;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            _a.trys.push([0, 3, , 4]);
+                                            if (this.watchStatus === WatchStatus.PAUSED) {
+                                                console.log('[realtime] rebuildWatch cancelled on pause');
+                                                return [2, resolve()];
+                                            }
+                                            return [4, this.wsLogin(this.envId, forceRefreshLogin)];
+                                        case 1:
+                                            envId = (_a.sent()).envId;
+                                            if (!this.sessionInfo) {
+                                                throw new Error('can not rebuildWatch without a successful initWatch (lack of sessionInfo)');
+                                            }
+                                            if (this.watchStatus === WatchStatus.PAUSED) {
+                                                console.log('[realtime] rebuildWatch cancelled on pause');
+                                                return [2, resolve()];
+                                            }
+                                            this.watchStatus = WatchStatus.REBUILDING;
+                                            rebuildWatchMsg = {
+                                                watchId: this.watchId,
+                                                requestId: (0, message_1.genRequestId)(),
+                                                msgType: 'REBUILD_WATCH',
+                                                msgData: {
+                                                    envId: envId,
+                                                    collName: this.collectionName,
+                                                    queryID: this.sessionInfo.queryID,
+                                                    eventID: this.sessionInfo.currentEventId,
+                                                },
+                                            };
+                                            return [4, this.send({
+                                                    msg: rebuildWatchMsg,
+                                                    waitResponse: true,
+                                                    skipOnMessage: false,
+                                                    timeout: DEFAULT_REBUILD_WATCH_TIMEOUT,
+                                                })];
+                                        case 2:
+                                            nextEventMsg = _a.sent();
+                                            this.handleServerEvents(nextEventMsg);
+                                            this.watchStatus = WatchStatus.ACTIVE;
+                                            this.availableRetries.REBUILD_WATCH = DEFAULT_MAX_AUTO_RETRY_ON_ERROR;
+                                            resolve();
+                                            return [3, 4];
+                                        case 3:
+                                            e_2 = _a.sent();
+                                            this.handleWatchEstablishmentError(e_2, {
+                                                operationName: 'REBUILD_WATCH',
+                                                resolve: resolve,
+                                                reject: reject,
+                                            });
+                                            return [3, 4];
+                                        case 4: return [2];
+                                    }
+                                });
+                            }); })();
+                        });
+                        success = false;
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, , 3, 4]);
+                        return [4, this.rebuildWatchPromise];
+                    case 2:
+                        _a.sent();
+                        success = true;
+                        return [3, 4];
+                    case 3:
+                        this.rebuildWatchPromise = undefined;
+                        return [7];
+                    case 4:
+                        console.log("[realtime] rebuildWatch ".concat(success ? 'success' : 'fail'));
+                        return [2];
+                }
+            });
+        }); };
+        this.handleWatchEstablishmentError = function (e, options) { return __awaiter(_this, void 0, void 0, function () {
+            var isInitWatch, abortWatch, retry;
+            var _this = this;
+            return __generator(this, function (_a) {
+                isInitWatch = options.operationName === 'INIT_WATCH';
+                abortWatch = function () {
+                    _this.closeWithError(new error_1.CloudSDKError({
+                        errCode: isInitWatch
+                            ? error_1.ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_INIT_WATCH_FAIL
+                            : error_1.ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_REBUILD_WATCH_FAIL,
+                        errMsg: e,
+                    }));
+                    options.reject(e);
+                };
+                retry = function (refreshLogin) {
+                    if (_this.useRetryTicket(options.operationName)) {
+                        if (isInitWatch) {
+                            _this.initWatchPromise = undefined;
+                            options.resolve(_this.initWatch(refreshLogin));
+                        }
+                        else {
+                            _this.rebuildWatchPromise = undefined;
+                            options.resolve(_this.rebuildWatch(refreshLogin));
+                        }
+                    }
+                    else {
+                        abortWatch();
+                    }
+                };
+                this.handleCommonError(e, {
+                    onSignError: function () { return retry(true); },
+                    onTimeoutError: function () { return retry(false); },
+                    onNotRetryableError: abortWatch,
+                    onCancelledError: options.reject,
+                    onUnknownError: function () {
+                        (function () { return __awaiter(_this, void 0, void 0, function () {
+                            var onWSDisconnected, e_3;
+                            var _this = this;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        _a.trys.push([0, 8, , 9]);
+                                        onWSDisconnected = function () { return __awaiter(_this, void 0, void 0, function () {
+                                            return __generator(this, function (_a) {
+                                                switch (_a.label) {
+                                                    case 0:
+                                                        this.pause();
+                                                        return [4, this.onceWSConnected()];
+                                                    case 1:
+                                                        _a.sent();
+                                                        retry(true);
+                                                        return [2];
+                                                }
+                                            });
+                                        }); };
+                                        if (!!this.isWSConnected()) return [3, 2];
+                                        return [4, onWSDisconnected()];
+                                    case 1:
+                                        _a.sent();
+                                        return [3, 7];
+                                    case 2: return [4, (0, utils_1.sleep)(DEFAULT_WAIT_TIME_ON_UNKNOWN_ERROR)];
+                                    case 3:
+                                        _a.sent();
+                                        if (!(this.watchStatus === WatchStatus.PAUSED)) return [3, 4];
+                                        options.reject(new error_1.CancelledError("".concat(options.operationName, " cancelled due to pause after unknownError")));
+                                        return [3, 7];
+                                    case 4:
+                                        if (!!this.isWSConnected()) return [3, 6];
+                                        return [4, onWSDisconnected()];
+                                    case 5:
+                                        _a.sent();
+                                        return [3, 7];
+                                    case 6:
+                                        retry(false);
+                                        _a.label = 7;
+                                    case 7: return [3, 9];
+                                    case 8:
+                                        e_3 = _a.sent();
+                                        retry(true);
+                                        return [3, 9];
+                                    case 9: return [2];
+                                }
+                            });
+                        }); })();
+                    },
+                });
+                return [2];
+            });
+        }); };
+        this.closeWatch = function () { return __awaiter(_this, void 0, void 0, function () {
+            var queryId, closeWatchMsg, e_4;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        queryId = this.sessionInfo ? this.sessionInfo.queryID : '';
+                        if (this.watchStatus !== WatchStatus.ACTIVE) {
+                            this.watchStatus = WatchStatus.CLOSED;
+                            this.onWatchClose(this, queryId);
+                            return [2];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, 4, 5]);
+                        this.watchStatus = WatchStatus.CLOSING;
+                        closeWatchMsg = {
+                            watchId: this.watchId,
+                            requestId: (0, message_1.genRequestId)(),
+                            msgType: 'CLOSE_WATCH',
+                            msgData: null,
+                        };
+                        return [4, this.send({
+                                msg: closeWatchMsg,
+                            })];
+                    case 2:
+                        _a.sent();
+                        this.sessionInfo = undefined;
+                        this.watchStatus = WatchStatus.CLOSED;
+                        return [3, 5];
+                    case 3:
+                        e_4 = _a.sent();
+                        this.closeWithError(new error_1.CloudSDKError({
+                            errCode: error_1.ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_CLOSE_WATCH_FAIL,
+                            errMsg: e_4,
+                        }));
+                        return [3, 5];
+                    case 4:
+                        this.onWatchClose(this, queryId);
+                        return [7];
+                    case 5: return [2];
+                }
+            });
+        }); };
+        this.scheduleSendACK = function () {
+            _this.clearACKSchedule();
+            _this.ackTimeoutId = setTimeout(function () {
+                if (_this.waitExpectedTimeoutId) {
+                    _this.scheduleSendACK();
+                }
+                else {
+                    _this.sendACK();
+                }
+            }, DEFAULT_SEND_ACK_DEBOUNCE_TIMEOUT);
+        };
+        this.clearACKSchedule = function () {
+            if (_this.ackTimeoutId) {
+                clearTimeout(_this.ackTimeoutId);
+            }
+        };
+        this.sendACK = function () { return __awaiter(_this, void 0, void 0, function () {
+            var ackMsg, e_5, msg;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        if (this.watchStatus !== WatchStatus.ACTIVE) {
+                            this.scheduleSendACK();
+                            return [2];
+                        }
+                        if (!this.sessionInfo) {
+                            console.warn('[realtime listener] can not send ack without a successful initWatch (lack of sessionInfo)');
+                            return [2];
+                        }
+                        ackMsg = {
+                            watchId: this.watchId,
+                            requestId: (0, message_1.genRequestId)(),
+                            msgType: 'CHECK_LAST',
+                            msgData: {
+                                queryID: this.sessionInfo.queryID,
+                                eventID: this.sessionInfo.currentEventId,
+                            },
+                        };
+                        return [4, this.send({
+                                msg: ackMsg,
+                            })];
+                    case 1:
+                        _a.sent();
+                        this.scheduleSendACK();
+                        return [3, 3];
+                    case 2:
+                        e_5 = _a.sent();
+                        if ((0, error_1.isRealtimeErrorMessageError)(e_5)) {
+                            msg = e_5.payload;
+                            switch (msg.msgData.code) {
+                                case 'CHECK_LOGIN_FAILED':
+                                case 'SIGN_EXPIRED_ERROR':
+                                case 'SIGN_INVALID_ERROR':
+                                case 'SIGN_PARAM_INVALID': {
+                                    this.rebuildWatch();
+                                    return [2];
+                                }
+                                case 'QUERYID_INVALID_ERROR':
+                                case 'SYS_ERR':
+                                case 'INVALIID_ENV':
+                                case 'COLLECTION_PERMISSION_DENIED': {
+                                    this.closeWithError(new error_1.CloudSDKError({
+                                        errCode: error_1.ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_CHECK_LAST_FAIL,
+                                        errMsg: msg.msgData.code,
+                                    }));
+                                    return [2];
+                                }
+                                default: {
+                                    break;
+                                }
+                            }
+                        }
+                        if (this.availableRetries.CHECK_LAST
+                            && this.availableRetries.CHECK_LAST > 0) {
+                            this.availableRetries.CHECK_LAST -= 1;
+                            this.scheduleSendACK();
+                        }
+                        else {
+                            this.closeWithError(new error_1.CloudSDKError({
+                                errCode: error_1.ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_CHECK_LAST_FAIL,
+                                errMsg: e_5,
+                            }));
+                        }
+                        return [3, 3];
+                    case 3: return [2];
+                }
+            });
+        }); };
+        this.handleCommonError = function (e, options) {
+            if ((0, error_1.isRealtimeErrorMessageError)(e)) {
+                var msg = e.payload;
+                switch (msg.msgData.code) {
+                    case 'CHECK_LOGIN_FAILED':
+                    case 'SIGN_EXPIRED_ERROR':
+                    case 'SIGN_INVALID_ERROR':
+                    case 'SIGN_PARAM_INVALID': {
+                        options.onSignError(e);
+                        return;
+                    }
+                    case 'QUERYID_INVALID_ERROR':
+                    case 'SYS_ERR':
+                    case 'INVALIID_ENV':
+                    case 'COLLECTION_PERMISSION_DENIED': {
+                        options.onNotRetryableError(e);
+                        return;
+                    }
+                    default: {
+                        options.onNotRetryableError(e);
+                        return;
+                    }
+                }
+            }
+            else if ((0, error_1.isTimeoutError)(e)) {
+                options.onTimeoutError(e);
+                return;
+            }
+            else if ((0, error_1.isCancelledError)(e)) {
+                options.onCancelledError(e);
+                return;
+            }
+            options.onUnknownError(e);
+        };
+        this.watchId = "watchid_".concat(+new Date(), "_").concat(Math.random());
+        this.envId = options.envId;
+        this.collectionName = options.collectionName;
+        this.query = options.query;
+        this.limit = options.limit;
+        this.orderBy = options.orderBy;
+        this.send = options.send;
+        this.login = options.login;
+        this.isWSConnected = options.isWSConnected;
+        this.onceWSConnected = options.onceWSConnected;
+        this.getWaitExpectedTimeoutLength = options.getWaitExpectedTimeoutLength;
+        this.onWatchStart = options.onWatchStart;
+        this.onWatchClose = options.onWatchClose;
+        this.debug = options.debug;
+        this.availableRetries = {
+            INIT_WATCH: DEFAULT_MAX_AUTO_RETRY_ON_ERROR,
+            REBUILD_WATCH: DEFAULT_MAX_AUTO_RETRY_ON_ERROR,
+            CHECK_LAST: DEFAULT_MAX_SEND_ACK_AUTO_RETRY_ON_ERROR,
+        };
+        this.listener = new listener_1.RealtimeListener({
+            close: function () {
+                _this.closeWatch();
+            },
+            onChange: options.onChange,
+            onError: options.onError,
+            debug: this.debug,
+            virtualClient: this,
+        });
+        this.initWatch();
+    }
+    VirtualWebSocketClient.prototype.onMessage = function (msg) {
+        var _this = this;
+        switch (this.watchStatus) {
+            case WatchStatus.PAUSED: {
+                if (msg.msgType !== 'ERROR') {
+                    return;
+                }
+                break;
+            }
+            case WatchStatus.LOGGINGIN:
+            case WatchStatus.INITING:
+            case WatchStatus.REBUILDING: {
+                console.warn("[realtime listener] internal non-fatal error: unexpected message received while ".concat(this.watchStatus));
+                return;
+            }
+            case WatchStatus.CLOSED: {
+                console.warn('[realtime listener] internal non-fatal error: unexpected message received when the watch has closed');
+                return;
+            }
+            case WatchStatus.ERRORED: {
+                console.warn('[realtime listener] internal non-fatal error: unexpected message received when the watch has ended with error');
+                return;
+            }
+        }
+        if (!this.sessionInfo) {
+            console.warn('[realtime listener] internal non-fatal error: sessionInfo not found while message is received.');
+            return;
+        }
+        this.scheduleSendACK();
+        switch (msg.msgType) {
+            case 'NEXT_EVENT': {
+                console.warn("nextevent ".concat(msg.msgData.currEvent, " ignored"), msg);
+                this.handleServerEvents(msg);
+                break;
+            }
+            case 'CHECK_EVENT': {
+                if (this.sessionInfo.currentEventId < msg.msgData.currEvent) {
+                    this.sessionInfo.expectEventId = msg.msgData.currEvent;
+                    this.clearWaitExpectedEvent();
+                    this.waitExpectedTimeoutId = setTimeout(function () {
+                        _this.rebuildWatch();
+                    }, this.getWaitExpectedTimeoutLength());
+                    console.log("[realtime] waitExpectedTimeoutLength ".concat(this.getWaitExpectedTimeoutLength()));
+                }
+                break;
+            }
+            case 'ERROR': {
+                this.closeWithError(new error_1.CloudSDKError({
+                    errCode: error_1.ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_SERVER_ERROR_MSG,
+                    errMsg: "".concat(msg.msgData.code, " - ").concat(msg.msgData.message),
+                }));
+                break;
+            }
+            default: {
+                console.warn("[realtime listener] virtual client receive unexpected msg ".concat(msg.msgType, ": "), msg);
+                break;
+            }
+        }
+    };
+    VirtualWebSocketClient.prototype.closeWithError = function (error) {
+        var _a;
+        this.watchStatus = WatchStatus.ERRORED;
+        this.clearACKSchedule();
+        this.listener.onError(error);
+        this.onWatchClose(this, ((_a = this.sessionInfo) === null || _a === void 0 ? void 0 : _a.queryID) || '');
+        console.log("[realtime] client closed (".concat(this.collectionName, " ").concat(this.query, ") (watchId ").concat(this.watchId, ")"));
+    };
+    VirtualWebSocketClient.prototype.pause = function () {
+        this.watchStatus = WatchStatus.PAUSED;
+        console.log("[realtime] client paused (".concat(this.collectionName, " ").concat(this.query, ") (watchId ").concat(this.watchId, ")"));
+    };
+    VirtualWebSocketClient.prototype.resume = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var e_6;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.watchStatus = WatchStatus.RESUMING;
+                        console.log("[realtime] client resuming with ".concat(this.sessionInfo ? 'REBUILD_WATCH' : 'INIT_WATCH', " (").concat(this.collectionName, " ").concat(this.query, ") (").concat(this.watchId, ")"));
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4, (this.sessionInfo ? this.rebuildWatch() : this.initWatch())];
+                    case 2:
+                        _a.sent();
+                        console.log("[realtime] client successfully resumed (".concat(this.collectionName, " ").concat(this.query, ") (").concat(this.watchId, ")"));
+                        return [3, 4];
+                    case 3:
+                        e_6 = _a.sent();
+                        console.error("[realtime] client resume failed (".concat(this.collectionName, " ").concat(this.query, ") (").concat(this.watchId, ")"), e_6);
+                        return [3, 4];
+                    case 4: return [2];
+                }
+            });
+        });
+    };
+    VirtualWebSocketClient.prototype.useRetryTicket = function (operationName) {
+        if (this.availableRetries[operationName]
+            && this.availableRetries[operationName] > 0) {
+            this.availableRetries[operationName] -= 1;
+            console.log("[realtime] ".concat(operationName, " use a retry ticket, now only ").concat(this.availableRetries[operationName], " retry left"));
+            return true;
+        }
+        return false;
+    };
+    VirtualWebSocketClient.prototype.handleServerEvents = function (msg) {
+        return __awaiter(this, void 0, void 0, function () {
+            var e_7;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        this.scheduleSendACK();
+                        return [4, this.handleServerEventsInternel(msg)];
+                    case 1:
+                        _a.sent();
+                        this.postHandleServerEventsValidityCheck(msg);
+                        return [3, 3];
+                    case 2:
+                        e_7 = _a.sent();
+                        console.error('[realtime listener] internal non-fatal error: handle server events failed with error: ', e_7);
+                        throw e_7;
+                    case 3: return [2];
+                }
+            });
+        });
+    };
+    VirtualWebSocketClient.prototype.handleServerEventsInternel = function (msg) {
+        return __awaiter(this, void 0, void 0, function () {
+            var requestId, events, msgType, sessionInfo, allChangeEvents, docs, initEncountered, _loop_1, this_1, i, len, state_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        requestId = msg.requestId;
+                        events = msg.msgData.events;
+                        msgType = msg.msgType;
+                        if (!events.length || !this.sessionInfo) {
+                            return [2];
+                        }
+                        sessionInfo = this.sessionInfo;
+                        try {
+                            allChangeEvents = events.map(getPublicEvent);
+                        }
+                        catch (e) {
+                            this.closeWithError(new error_1.CloudSDKError({
+                                errCode: error_1.ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_RECEIVE_INVALID_SERVER_DATA,
+                                errMsg: e,
+                            }));
+                            return [2];
+                        }
+                        docs = __spreadArray([], sessionInfo.currentDocs, true);
+                        initEncountered = false;
+                        _loop_1 = function (i, len) {
+                            var change, localDoc, doc_1, _i, _b, fieldPath, err, err, doc, doc, err, ind, ind, docsSnapshot, docChanges, snapshot;
+                            return __generator(this, function (_c) {
+                                switch (_c.label) {
+                                    case 0:
+                                        change = allChangeEvents[i];
+                                        if (!(sessionInfo.currentEventId >= change.id)) return [3, 1];
+                                        if (!allChangeEvents[i - 1] || change.id > allChangeEvents[i - 1].id) {
+                                            console.warn("[realtime] duplicate event received, cur ".concat(sessionInfo.currentEventId, " but got ").concat(change.id));
+                                        }
+                                        else {
+                                            console.error("[realtime listener] server non-fatal error: events out of order (the latter event's id is smaller than that of the former) (requestId ".concat(requestId, ")"));
+                                        }
+                                        return [2, "continue"];
+                                    case 1:
+                                        if (!(sessionInfo.currentEventId === change.id - 1)) return [3, 2];
+                                        switch (change.dataType) {
+                                            case 'update': {
+                                                if (!change.doc) {
+                                                    switch (change.queueType) {
+                                                        case 'update':
+                                                        case 'dequeue': {
+                                                            localDoc = docs.find(function (doc) { return doc._id === change.docId; });
+                                                            if (localDoc) {
+                                                                doc_1 = (0, cloneDeep_1.default)(localDoc);
+                                                                if (change.updatedFields) {
+                                                                    Object.keys(change.updatedFields).forEach(function (fieldPath) {
+                                                                        (0, set_1.default)(doc_1, fieldPath, change.updatedFields[fieldPath]);
+                                                                    });
+                                                                }
+                                                                if (change.removedFields) {
+                                                                    for (_i = 0, _b = change.removedFields; _i < _b.length; _i++) {
+                                                                        fieldPath = _b[_i];
+                                                                        (0, unset_1.default)(doc_1, fieldPath);
+                                                                    }
+                                                                }
+                                                                change.doc = doc_1;
+                                                            }
+                                                            else {
+                                                                console.error('[realtime listener] internal non-fatal server error: unexpected update dataType event where no doc is associated.');
+                                                            }
+                                                            break;
+                                                        }
+                                                        case 'enqueue': {
+                                                            err = new error_1.CloudSDKError({
+                                                                errCode: error_1.ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_UNEXPECTED_FATAL_ERROR,
+                                                                errMsg: "HandleServerEvents: full doc is not provided with dataType=\"update\" and queueType=\"enqueue\" (requestId ".concat(msg.requestId, ")"),
+                                                            });
+                                                            this_1.closeWithError(err);
+                                                            throw err;
+                                                        }
+                                                        default: {
+                                                            break;
+                                                        }
+                                                    }
+                                                }
+                                                break;
+                                            }
+                                            case 'replace': {
+                                                if (!change.doc) {
+                                                    err = new error_1.CloudSDKError({
+                                                        errCode: error_1.ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_UNEXPECTED_FATAL_ERROR,
+                                                        errMsg: "HandleServerEvents: full doc is not provided with dataType=\"replace\" (requestId ".concat(msg.requestId, ")"),
+                                                    });
+                                                    this_1.closeWithError(err);
+                                                    throw err;
+                                                }
+                                                break;
+                                            }
+                                            case 'remove': {
+                                                doc = docs.find(function (doc) { return doc._id === change.docId; });
+                                                if (doc) {
+                                                    change.doc = doc;
+                                                }
+                                                else {
+                                                    console.error('[realtime listener] internal non-fatal server error: unexpected remove event where no doc is associated.');
+                                                }
+                                                break;
+                                            }
+                                            case 'limit': {
+                                                if (!change.doc) {
+                                                    switch (change.queueType) {
+                                                        case 'dequeue': {
+                                                            doc = docs.find(function (doc) { return doc._id === change.docId; });
+                                                            if (doc) {
+                                                                change.doc = doc;
+                                                            }
+                                                            else {
+                                                                console.error('[realtime listener] internal non-fatal server error: unexpected limit dataType event where no doc is associated.');
+                                                            }
+                                                            break;
+                                                        }
+                                                        case 'enqueue': {
+                                                            err = new error_1.CloudSDKError({
+                                                                errCode: error_1.ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_UNEXPECTED_FATAL_ERROR,
+                                                                errMsg: "HandleServerEvents: full doc is not provided with dataType=\"limit\" and queueType=\"enqueue\" (requestId ".concat(msg.requestId, ")"),
+                                                            });
+                                                            this_1.closeWithError(err);
+                                                            throw err;
+                                                        }
+                                                        default: {
+                                                            break;
+                                                        }
+                                                    }
+                                                }
+                                                break;
+                                            }
+                                        }
+                                        switch (change.queueType) {
+                                            case 'init': {
+                                                if (!initEncountered) {
+                                                    initEncountered = true;
+                                                    docs = [change.doc];
+                                                }
+                                                else {
+                                                    docs.push(change.doc);
+                                                }
+                                                break;
+                                            }
+                                            case 'enqueue': {
+                                                docs.push(change.doc);
+                                                break;
+                                            }
+                                            case 'dequeue': {
+                                                ind = docs.findIndex(function (doc) { return doc._id === change.docId; });
+                                                if (ind > -1) {
+                                                    docs.splice(ind, 1);
+                                                }
+                                                else {
+                                                    console.error('[realtime listener] internal non-fatal server error: unexpected dequeue event where no doc is associated.');
+                                                }
+                                                break;
+                                            }
+                                            case 'update': {
+                                                ind = docs.findIndex(function (doc) { return doc._id === change.docId; });
+                                                if (ind > -1) {
+                                                    docs[ind] = change.doc;
+                                                }
+                                                else {
+                                                    console.error('[realtime listener] internal non-fatal server error: unexpected queueType update event where no doc is associated.');
+                                                }
+                                                break;
+                                            }
+                                        }
+                                        if (i === len - 1
+                                            || (allChangeEvents[i + 1] && allChangeEvents[i + 1].id !== change.id)) {
+                                            docsSnapshot = __spreadArray([], docs, true);
+                                            docChanges = allChangeEvents
+                                                .slice(0, i + 1)
+                                                .filter(function (c) { return c.id === change.id; });
+                                            this_1.sessionInfo.currentEventId = change.id;
+                                            this_1.sessionInfo.currentDocs = docs;
+                                            snapshot = new snapshot_1.Snapshot({
+                                                id: change.id,
+                                                docChanges: docChanges,
+                                                docs: docsSnapshot,
+                                                msgType: msgType,
+                                            });
+                                            this_1.listener.onChange(snapshot);
+                                        }
+                                        return [3, 4];
+                                    case 2:
+                                        console.warn("[realtime listener] event received is out of order, cur ".concat(this_1.sessionInfo.currentEventId, " but got ").concat(change.id));
+                                        return [4, this_1.rebuildWatch()];
+                                    case 3:
+                                        _c.sent();
+                                        return [2, { value: void 0 }];
+                                    case 4: return [2];
+                                }
+                            });
+                        };
+                        this_1 = this;
+                        i = 0, len = allChangeEvents.length;
+                        _a.label = 1;
+                    case 1:
+                        if (!(i < len)) return [3, 4];
+                        return [5, _loop_1(i, len)];
+                    case 2:
+                        state_1 = _a.sent();
+                        if (typeof state_1 === "object")
+                            return [2, state_1.value];
+                        _a.label = 3;
+                    case 3:
+                        i++;
+                        return [3, 1];
+                    case 4: return [2];
+                }
+            });
+        });
+    };
+    VirtualWebSocketClient.prototype.postHandleServerEventsValidityCheck = function (msg) {
+        if (!this.sessionInfo) {
+            console.error('[realtime listener] internal non-fatal error: sessionInfo lost after server event handling, this should never occur');
+            return;
+        }
+        if (this.sessionInfo.expectEventId
+            && this.sessionInfo.currentEventId >= this.sessionInfo.expectEventId) {
+            this.clearWaitExpectedEvent();
+        }
+        if (this.sessionInfo.currentEventId < msg.msgData.currEvent) {
+            console.warn('[realtime listener] internal non-fatal error: client eventId does not match with server event id after server event handling');
+            return;
+        }
+    };
+    VirtualWebSocketClient.prototype.clearWaitExpectedEvent = function () {
+        if (this.waitExpectedTimeoutId) {
+            clearTimeout(this.waitExpectedTimeoutId);
+            this.waitExpectedTimeoutId = undefined;
+        }
+    };
+    return VirtualWebSocketClient;
+}());
+exports.VirtualWebSocketClient = VirtualWebSocketClient;
+function getPublicEvent(event) {
+    var e = {
+        id: event.ID,
+        dataType: event.DataType,
+        queueType: event.QueueType,
+        docId: event.DocID,
+        doc: event.Doc && event.Doc !== '{}' ? JSON.parse(event.Doc) : undefined,
+    };
+    if (event.DataType === 'update') {
+        if (event.UpdatedFields) {
+            e.updatedFields = JSON.parse(event.UpdatedFields);
+        }
+        if (event.removedFields || event.RemovedFields) {
+            e.removedFields = JSON.parse(event.removedFields);
+        }
+    }
+    return e;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"virtual-websocket-client.js","sourceRoot":"","sources":["../../src/virtual-websocket-client.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,mDAA4B;AAC5B,uDAAgC;AAChC,+DAAwC;AACxC,qCAAwC;AAgBxC,uCAA6C;AAC7C,uCAAqC;AAErC,iCASgB;AAChB,iCAA+B;AAyC/B,IAAK,WAUJ;AAVD,WAAK,WAAW;IACd,sCAAuB,CAAA;IACvB,kCAAmB,CAAA;IACnB,wCAAyB,CAAA;IACzB,gCAAiB,CAAA;IACjB,kCAAmB,CAAA;IACnB,kCAAmB,CAAA;IACnB,gCAAiB,CAAA;IACjB,gCAAiB,CAAA;IACjB,oCAAqB,CAAA;AACvB,CAAC,EAVI,WAAW,KAAX,WAAW,QAUf;AAED,IAAM,kCAAkC,GAAG,GAAG,CAAA;AAC9C,IAAM,+BAA+B,GAAG,CAAC,CAAA;AACzC,IAAM,wCAAwC,GAAG,CAAC,CAAA;AAClD,IAAM,iCAAiC,GAAG,EAAE,GAAG,IAAI,CAAA;AACnD,IAAM,0BAA0B,GAAG,EAAE,GAAG,IAAI,CAAA;AAC5C,IAAM,6BAA6B,GAAG,EAAE,GAAG,IAAI,CAAA;AAE/C;IAqCE,gCAAY,OAAkD;QAA9D,iBAiCC;QA7CO,gBAAW,GAAgB,WAAW,CAAC,OAAO,CAAA;QAsK9C,YAAO,GAAG,UAChB,KAAc,EACd,OAAiB;;;;;wBAEjB,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC,SAAS,CAAA;wBACpB,WAAM,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,OAAO,CAAC,EAAA;;wBAA9C,WAAW,GAAG,SAAgC;wBACpD,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE;4BACf,IAAI,CAAC,KAAK,GAAG,WAAW,CAAC,KAAK,CAAA;yBAC/B;wBACD,WAAO,WAAW,EAAA;;;aACnB,CAAA;QAEO,cAAS,GAAG,UAAO,iBAA2B;;;;;;wBACpD,IAAI,IAAI,CAAC,gBAAgB,KAAK,IAAI,IAAI,IAAI,CAAC,gBAAgB,KAAK,SAAS,EAAE;4BACzE,WAAO,IAAI,CAAC,gBAAgB,EAAA;yBAC7B;wBAED,IAAI,CAAC,gBAAgB,GAAG,IAAI,OAAO,CAAO,UAAC,OAAO,EAAE,MAAM;4BACxD,KAAK,CAAC;;;;;;4CAEF,IAAI,IAAI,CAAC,WAAW,KAAK,WAAW,CAAC,MAAM,EAAE;gDAC3C,OAAO,CAAC,GAAG,CAAC,yCAAyC,CAAC,CAAA;gDACtD,WAAO,OAAO,EAAE,EAAA;6CACjB;4CAEiB,WAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,EAAE,iBAAiB,CAAC,EAAA;;4CAA3D,KAAK,GAAK,CAAA,SAAiD,CAAA,MAAtD;4CACb,IAAK,IAAI,CAAC,WAA2B,KAAK,WAAW,CAAC,MAAM,EAAE;gDAC5D,OAAO,CAAC,GAAG,CAAC,yCAAyC,CAAC,CAAA;gDACtD,WAAO,OAAO,EAAE,EAAA;6CACjB;4CAED,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC,OAAO,CAAA;4CAEhC,YAAY,GAAgC;gDAChD,OAAO,EAAE,IAAI,CAAC,OAAO;gDACrB,SAAS,EAAE,IAAA,sBAAY,GAAE;gDACzB,OAAO,EAAE,YAAY;gDACrB,OAAO,EAAE;oDACP,KAAK,OAAA;oDACL,QAAQ,EAAE,IAAI,CAAC,cAAc;oDAC7B,KAAK,EAAE,IAAI,CAAC,KAAK;oDACjB,KAAK,EAAE,IAAI,CAAC,KAAK;oDACjB,OAAO,EAAE,IAAI,CAAC,OAAO;iDACtB;6CACF,CAAA;4CAEoB,WAAM,IAAI,CAAC,IAAI,CAA+B;oDACjE,GAAG,EAAE,YAAY;oDACjB,YAAY,EAAE,IAAI;oDAClB,aAAa,EAAE,IAAI;oDACnB,OAAO,EAAE,0BAA0B;iDACpC,CAAC,EAAA;;4CALI,YAAY,GAAG,SAKnB;4CAEI,KAAwB,YAAY,CAAC,OAAO,EAA1C,MAAM,YAAA,EAAE,SAAS,eAAA,CAAyB;4CAElD,IAAI,CAAC,WAAW,GAAG;gDACjB,OAAO,EAAE,YAAY,CAAC,OAAO,CAAC,OAAO;gDACrC,cAAc,EAAE,SAAS,GAAG,CAAC;gDAC7B,WAAW,EAAE,EAAE;6CAChB,CAAA;4CAGD,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;gDACrB,WAAsB,EAAN,iBAAM,EAAN,oBAAM,EAAN,IAAM,EAAE;oDAAb,CAAC;oDACV,CAAC,CAAC,EAAE,GAAG,SAAS,CAAA;iDACjB;gDACD,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC,CAAA;6CACtC;iDAAM;gDACL,IAAI,CAAC,WAAW,CAAC,cAAc,GAAG,SAAS,CAAA;gDACrC,QAAQ,GAAG,IAAI,mBAAQ,CAAC;oDAC5B,EAAE,EAAE,SAAS;oDACb,UAAU,EAAE,EAAE;oDACd,IAAI,EAAE,EAAE;oDACR,IAAI,EAAE,MAAM;iDACb,CAAC,CAAA;gDACF,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAA;gDAChC,IAAI,CAAC,eAAe,EAAE,CAAA;6CACvB;4CACD,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAA;4CACjD,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC,MAAM,CAAA;4CACrC,IAAI,CAAC,gBAAgB,CAAC,UAAU,GAAG,+BAA+B,CAAA;4CAClE,OAAO,EAAE,CAAA;;;;4CAET,IAAI,CAAC,6BAA6B,CAAC,GAAC,EAAE;gDACpC,aAAa,EAAE,YAAY;gDAC3B,OAAO,SAAA;gDACP,MAAM,QAAA;6CACP,CAAC,CAAA;;;;;iCAEL,CAAC,EAAE,CAAA;wBACN,CAAC,CAAC,CAAA;wBAEE,OAAO,GAAG,KAAK,CAAA;;;;wBAGjB,WAAM,IAAI,CAAC,gBAAgB,EAAA;;wBAA3B,SAA2B,CAAA;wBAC3B,OAAO,GAAG,IAAI,CAAA;;;wBAEd,IAAI,CAAC,gBAAgB,GAAG,SAAS,CAAA;;;wBAEnC,OAAO,CAAC,GAAG,CAAC,+BAAwB,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAE,CAAC,CAAA;;;;aACpE,CAAA;QAEO,iBAAY,GAAG,UAAO,iBAA2B;;;;;;wBACvD,IAAI,IAAI,CAAC,mBAAmB,KAAK,IAAI,IAAI,IAAI,CAAC,mBAAmB,KAAK,SAAS,EAAE;4BAC/E,WAAO,IAAI,CAAC,mBAAmB,EAAA;yBAChC;wBAED,IAAI,CAAC,mBAAmB,GAAG,IAAI,OAAO,CAAO,UAAC,OAAO,EAAE,MAAM;4BAC3D,KAAK,CAAC;;;;;;4CAEF,IAAI,IAAI,CAAC,WAAW,KAAK,WAAW,CAAC,MAAM,EAAE;gDAC3C,OAAO,CAAC,GAAG,CAAC,4CAA4C,CAAC,CAAA;gDACzD,WAAO,OAAO,EAAE,EAAA;6CACjB;4CACiB,WAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,EAAE,iBAAiB,CAAC,EAAA;;4CAA3D,KAAK,GAAK,CAAA,SAAiD,CAAA,MAAtD;4CAEb,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;gDACrB,MAAM,IAAI,KAAK,CAAC,2EAA2E,CAAC,CAAA;6CAC7F;4CAED,IAAK,IAAI,CAAC,WAA2B,KAAK,WAAW,CAAC,MAAM,EAAE;gDAC5D,OAAO,CAAC,GAAG,CAAC,4CAA4C,CAAC,CAAA;gDACzD,WAAO,OAAO,EAAE,EAAA;6CACjB;4CAED,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC,UAAU,CAAA;4CAEnC,eAAe,GAAmC;gDACtD,OAAO,EAAE,IAAI,CAAC,OAAO;gDACrB,SAAS,EAAE,IAAA,sBAAY,GAAE;gDACzB,OAAO,EAAE,eAAe;gDACxB,OAAO,EAAE;oDACP,KAAK,OAAA;oDACL,QAAQ,EAAE,IAAI,CAAC,cAAc;oDAC7B,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC,OAAO;oDACjC,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC,cAAc;iDACzC;6CACF,CAAA;4CAEoB,WAAM,IAAI,CAAC,IAAI,CAA+B;oDACjE,GAAG,EAAE,eAAe;oDACpB,YAAY,EAAE,IAAI;oDAClB,aAAa,EAAE,KAAK;oDACpB,OAAO,EAAE,6BAA6B;iDACvC,CAAC,EAAA;;4CALI,YAAY,GAAG,SAKnB;4CAEF,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC,CAAA;4CAErC,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC,MAAM,CAAA;4CACrC,IAAI,CAAC,gBAAgB,CAAC,aAAa,GAAG,+BAA+B,CAAA;4CACrE,OAAO,EAAE,CAAA;;;;4CAET,IAAI,CAAC,6BAA6B,CAAC,GAAC,EAAE;gDACpC,aAAa,EAAE,eAAe;gDAC9B,OAAO,SAAA;gDACP,MAAM,QAAA;6CACP,CAAC,CAAA;;;;;iCAEL,CAAC,EAAE,CAAA;wBACN,CAAC,CAAC,CAAA;wBAEE,OAAO,GAAG,KAAK,CAAA;;;;wBAGjB,WAAM,IAAI,CAAC,mBAAmB,EAAA;;wBAA9B,SAA8B,CAAA;wBAC9B,OAAO,GAAG,IAAI,CAAA;;;wBAEd,IAAI,CAAC,mBAAmB,GAAG,SAAS,CAAA;;;wBAGtC,OAAO,CAAC,GAAG,CAAC,kCAA2B,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAE,CAAC,CAAA;;;;aACvE,CAAA;QAEO,kCAA6B,GAAG,UACtC,CAAM,EACN,OAA8C;;;;gBAExC,WAAW,GAAG,OAAO,CAAC,aAAa,KAAK,YAAY,CAAA;gBAEpD,UAAU,GAAG;oBAEjB,KAAI,CAAC,cAAc,CAAC,IAAI,qBAAa,CAAC;wBACpC,OAAO,EAAE,WAAW;4BAClB,CAAC,CAAE,gBAAQ,CAAC,8CAAyD;4BACrE,CAAC,CAAE,gBAAQ,CAAC,iDAA4D;wBAC1E,MAAM,EAAE,CAAC;qBACV,CAAC,CAAC,CAAA;oBACH,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;gBACnB,CAAC,CAAA;gBAEK,KAAK,GAAG,UAAC,YAAsB;oBACnC,IAAI,KAAI,CAAC,cAAc,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE;wBAC9C,IAAI,WAAW,EAAE;4BACf,KAAI,CAAC,gBAAgB,GAAG,SAAS,CAAA;4BACjC,OAAO,CAAC,OAAO,CAAC,KAAI,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC,CAAA;yBAC9C;6BAAM;4BACL,KAAI,CAAC,mBAAmB,GAAG,SAAS,CAAA;4BACpC,OAAO,CAAC,OAAO,CAAC,KAAI,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC,CAAA;yBACjD;qBACF;yBAAM;wBACL,UAAU,EAAE,CAAA;qBACb;gBACH,CAAC,CAAA;gBAED,IAAI,CAAC,iBAAiB,CAAC,CAAC,EAAE;oBACxB,WAAW,EAAE,cAAM,OAAA,KAAK,CAAC,IAAI,CAAC,EAAX,CAAW;oBAC9B,cAAc,EAAE,cAAM,OAAA,KAAK,CAAC,KAAK,CAAC,EAAZ,CAAY;oBAClC,mBAAmB,EAAE,UAAU;oBAC/B,gBAAgB,EAAE,OAAO,CAAC,MAAM;oBAChC,cAAc,EAAE;wBACd,CAAC;;;;;;;wCAES,gBAAgB,GAAG;;;;wDACvB,IAAI,CAAC,KAAK,EAAE,CAAA;wDACZ,WAAM,IAAI,CAAC,eAAe,EAAE,EAAA;;wDAA5B,SAA4B,CAAA;wDAC5B,KAAK,CAAC,IAAI,CAAC,CAAA;;;;6CACZ,CAAA;6CAEG,CAAC,IAAI,CAAC,aAAa,EAAE,EAArB,cAAqB;wCACvB,WAAM,gBAAgB,EAAE,EAAA;;wCAAxB,SAAwB,CAAA;;4CAExB,WAAM,IAAA,aAAK,EAAC,kCAAkC,CAAC,EAAA;;wCAA/C,SAA+C,CAAA;6CAC3C,CAAA,IAAI,CAAC,WAAW,KAAK,WAAW,CAAC,MAAM,CAAA,EAAvC,cAAuC;wCAEzC,OAAO,CAAC,MAAM,CAAC,IAAI,sBAAc,CAAC,UAAG,OAAO,CAAC,aAAa,+CAA4C,CAAC,CAAC,CAAA;;;6CAC/F,CAAC,IAAI,CAAC,aAAa,EAAE,EAArB,cAAqB;wCAC9B,WAAM,gBAAgB,EAAE,EAAA;;wCAAxB,SAAwB,CAAA;;;wCAExB,KAAK,CAAC,KAAK,CAAC,CAAA;;;;;wCAKhB,KAAK,CAAC,IAAI,CAAC,CAAA;;;;;6BAEd,CAAC,EAAE,CAAA;oBACN,CAAC;iBACF,CAAC,CAAA;;;aACH,CAAA;QAEO,eAAU,GAAG;;;;;wBACb,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAA;wBAEhE,IAAI,IAAI,CAAC,WAAW,KAAK,WAAW,CAAC,MAAM,EAAE;4BAC3C,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC,MAAM,CAAA;4BACrC,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,OAAO,CAAC,CAAA;4BAChC,WAAM;yBACP;;;;wBAGC,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC,OAAO,CAAA;wBAEhC,aAAa,GAAiC;4BAClD,OAAO,EAAE,IAAI,CAAC,OAAO;4BACrB,SAAS,EAAE,IAAA,sBAAY,GAAE;4BACzB,OAAO,EAAE,aAAa;4BACtB,OAAO,EAAE,IAAI;yBACd,CAAA;wBAED,WAAM,IAAI,CAAC,IAAI,CAAC;gCACd,GAAG,EAAE,aAAa;6BACnB,CAAC,EAAA;;wBAFF,SAEE,CAAA;wBAEF,IAAI,CAAC,WAAW,GAAG,SAAS,CAAA;wBAC5B,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC,MAAM,CAAA;;;;wBAErC,IAAI,CAAC,cAAc,CAAC,IAAI,qBAAa,CAAC;4BACpC,OAAO,EAAE,gBAAQ,CAAC,+CAAyD;4BAC3E,MAAM,EAAE,GAAC;yBACV,CAAC,CAAC,CAAA;;;wBAEH,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,OAAO,CAAC,CAAA;;;;;aAEnC,CAAA;QAEO,oBAAe,GAAG;YACxB,KAAI,CAAC,gBAAgB,EAAE,CAAA;YAIvB,KAAI,CAAC,YAAY,GAAG,UAAU,CAAC;gBAC7B,IAAI,KAAI,CAAC,qBAAqB,EAAE;oBAC9B,KAAI,CAAC,eAAe,EAAE,CAAA;iBACvB;qBAAM;oBACL,KAAI,CAAC,OAAO,EAAE,CAAA;iBACf;YACH,CAAC,EAAE,iCAAiC,CAAC,CAAA;QACvC,CAAC,CAAA;QAEO,qBAAgB,GAAG;YACzB,IAAI,KAAI,CAAC,YAAY,EAAE;gBACrB,YAAY,CAAC,KAAI,CAAC,YAAY,CAAC,CAAA;aAChC;QACH,CAAC,CAAA;QAEO,YAAO,GAAG;;;;;;wBAEd,IAAI,IAAI,CAAC,WAAW,KAAK,WAAW,CAAC,MAAM,EAAE;4BAC3C,IAAI,CAAC,eAAe,EAAE,CAAA;4BACtB,WAAM;yBACP;wBAED,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;4BACrB,OAAO,CAAC,IAAI,CAAC,2FAA2F,CAAC,CAAA;4BACzG,WAAM;yBACP;wBAEK,MAAM,GAAgC;4BAC1C,OAAO,EAAE,IAAI,CAAC,OAAO;4BACrB,SAAS,EAAE,IAAA,sBAAY,GAAE;4BACzB,OAAO,EAAE,YAAY;4BACrB,OAAO,EAAE;gCACP,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC,OAAO;gCACjC,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC,cAAc;6BACzC;yBACF,CAAA;wBAED,WAAM,IAAI,CAAC,IAAI,CAAC;gCACd,GAAG,EAAE,MAAM;6BACZ,CAAC,EAAA;;wBAFF,SAEE,CAAA;wBAEF,IAAI,CAAC,eAAe,EAAE,CAAA;;;;wBAGtB,IAAI,IAAA,mCAA2B,EAAC,GAAC,CAAC,EAAE;4BAC5B,GAAG,GAAG,GAAC,CAAC,OAAO,CAAA;4BACrB,QAAQ,GAAG,CAAC,OAAO,CAAC,IAAI,EAAE;gCAExB,KAAK,oBAAoB,CAAC;gCAC1B,KAAK,oBAAoB,CAAC;gCAC1B,KAAK,oBAAoB,CAAC;gCAC1B,KAAK,oBAAoB,CAAC,CAAC;oCACzB,IAAI,CAAC,YAAY,EAAE,CAAA;oCACnB,WAAM;iCACP;gCAED,KAAK,uBAAuB,CAAC;gCAC7B,KAAK,SAAS,CAAC;gCACf,KAAK,cAAc,CAAC;gCACpB,KAAK,8BAA8B,CAAC,CAAC;oCAEnC,IAAI,CAAC,cAAc,CAAC,IAAI,qBAAa,CAAC;wCACpC,OAAO,EAAE,gBAAQ,CAAC,8CAAwD;wCAC1E,MAAM,EAAE,GAAG,CAAC,OAAO,CAAC,IAAI;qCACzB,CAAC,CAAC,CAAA;oCACH,WAAM;iCACP;gCACD,OAAO,CAAC,CAAC;oCACP,MAAK;iCACN;6BACF;yBACF;wBAGD,IACE,IAAI,CAAC,gBAAgB,CAAC,UAAU;+BAC7B,IAAI,CAAC,gBAAgB,CAAC,UAAU,GAAG,CAAC,EACvC;4BACA,IAAI,CAAC,gBAAgB,CAAC,UAAU,IAAI,CAAC,CAAA;4BACrC,IAAI,CAAC,eAAe,EAAE,CAAA;yBACvB;6BAAM;4BACL,IAAI,CAAC,cAAc,CAAC,IAAI,qBAAa,CAAC;gCACpC,OAAO,EAAE,gBAAQ,CAAC,8CAAwD;gCAC1E,MAAM,EAAE,GAAC;6BACV,CAAC,CAAC,CAAA;yBACJ;;;;;aAEJ,CAAA;QAEO,sBAAiB,GAAG,UAC1B,CAAM,EACN,OAAkC;YAElC,IAAI,IAAA,mCAA2B,EAAC,CAAC,CAAC,EAAE;gBAClC,IAAM,GAAG,GAAG,CAAC,CAAC,OAAO,CAAA;gBACrB,QAAQ,GAAG,CAAC,OAAO,CAAC,IAAI,EAAE;oBAExB,KAAK,oBAAoB,CAAC;oBAC1B,KAAK,oBAAoB,CAAC;oBAC1B,KAAK,oBAAoB,CAAC;oBAC1B,KAAK,oBAAoB,CAAC,CAAC;wBACzB,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAA;wBACtB,OAAM;qBACP;oBAED,KAAK,uBAAuB,CAAC;oBAC7B,KAAK,SAAS,CAAC;oBACf,KAAK,cAAc,CAAC;oBACpB,KAAK,8BAA8B,CAAC,CAAC;wBACnC,OAAO,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAA;wBAC9B,OAAM;qBACP;oBACD,OAAO,CAAC,CAAC;wBACP,OAAO,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAA;wBAC9B,OAAM;qBACP;iBACF;aACF;iBAAM,IAAI,IAAA,sBAAc,EAAC,CAAC,CAAC,EAAE;gBAE5B,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAA;gBACzB,OAAM;aACP;iBAAM,IAAI,IAAA,wBAAgB,EAAC,CAAC,CAAC,EAAE;gBAE9B,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAA;gBAC3B,OAAM;aACP;YAGD,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAA;QAC3B,CAAC,CAAA;QAnjBC,IAAI,CAAC,OAAO,GAAG,kBAAW,CAAC,IAAI,IAAI,EAAE,cAAI,IAAI,CAAC,MAAM,EAAE,CAAE,CAAA;QACxD,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAA;QAC1B,IAAI,CAAC,cAAc,GAAG,OAAO,CAAC,cAAc,CAAA;QAC5C,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAA;QAC1B,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAA;QAC1B,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,OAAO,CAAA;QAC9B,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAA;QACxB,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAA;QAC1B,IAAI,CAAC,aAAa,GAAG,OAAO,CAAC,aAAa,CAAA;QAC1C,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC,eAAe,CAAA;QAC9C,IAAI,CAAC,4BAA4B,GAAG,OAAO,CAAC,4BAA4B,CAAA;QACxE,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC,YAAY,CAAA;QACxC,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC,YAAY,CAAA;QACxC,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAA;QAE1B,IAAI,CAAC,gBAAgB,GAAG;YACtB,UAAU,EAAE,+BAA+B;YAC3C,aAAa,EAAE,+BAA+B;YAC9C,UAAU,EAAE,wCAAwC;SACrD,CAAA;QAED,IAAI,CAAC,QAAQ,GAAG,IAAI,2BAAgB,CAAC;YACnC,KAAK,EAAE;gBACL,KAAI,CAAC,UAAU,EAAE,CAAA;YACnB,CAAC;YACD,QAAQ,EAAE,OAAO,CAAC,QAAQ;YAC1B,OAAO,EAAE,OAAO,CAAC,OAAO;YACxB,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,aAAa,EAAE,IAAI;SACpB,CAAC,CAAA;QAEF,IAAI,CAAC,SAAS,EAAE,CAAA;IAClB,CAAC;IAED,0CAAS,GAAT,UAAU,GAAqB;QAA/B,iBAgFC;QA9EC,QAAQ,IAAI,CAAC,WAAW,EAAE;YACxB,KAAK,WAAW,CAAC,MAAM,CAAC,CAAC;gBAEvB,IAAI,GAAG,CAAC,OAAO,KAAK,OAAO,EAAE;oBAC3B,OAAM;iBACP;gBACD,MAAK;aACN;YACD,KAAK,WAAW,CAAC,SAAS,CAAC;YAC3B,KAAK,WAAW,CAAC,OAAO,CAAC;YACzB,KAAK,WAAW,CAAC,UAAU,CAAC,CAAC;gBAC3B,OAAO,CAAC,IAAI,CAAC,0FAAmF,IAAI,CAAC,WAAW,CAAE,CAAC,CAAA;gBACnH,OAAM;aACP;YACD,KAAK,WAAW,CAAC,MAAM,CAAC,CAAC;gBACvB,OAAO,CAAC,IAAI,CAAC,qGAAqG,CAAC,CAAA;gBACnH,OAAM;aACP;YACD,KAAK,WAAW,CAAC,OAAO,CAAC,CAAC;gBACxB,OAAO,CAAC,IAAI,CAAC,+GAA+G,CAAC,CAAA;gBAC7H,OAAM;aACP;SACF;QAED,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YACrB,OAAO,CAAC,IAAI,CAAC,gGAAgG,CAAC,CAAA;YAC9G,OAAM;SACP;QAED,IAAI,CAAC,eAAe,EAAE,CAAA;QAEtB,QAAQ,GAAG,CAAC,OAAO,EAAE;YACnB,KAAK,YAAY,CAAC,CAAC;gBAIjB,OAAO,CAAC,IAAI,CAAC,oBAAa,GAAG,CAAC,OAAO,CAAC,SAAS,aAAU,EAAE,GAAG,CAAC,CAAA;gBAO/D,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAA;gBAC5B,MAAK;aACN;YACD,KAAK,aAAa,CAAC,CAAC;gBAClB,IAAI,IAAI,CAAC,WAAW,CAAC,cAAc,GAAG,GAAG,CAAC,OAAO,CAAC,SAAS,EAAE;oBAG3D,IAAI,CAAC,WAAW,CAAC,aAAa,GAAG,GAAG,CAAC,OAAO,CAAC,SAAS,CAAA;oBACtD,IAAI,CAAC,sBAAsB,EAAE,CAAA;oBAE7B,IAAI,CAAC,qBAAqB,GAAG,UAAU,CAAC;wBAEtC,KAAI,CAAC,YAAY,EAAE,CAAA;oBACrB,CAAC,EAAE,IAAI,CAAC,4BAA4B,EAAE,CAAC,CAAA;oBAEvC,OAAO,CAAC,GAAG,CAAC,+CAAwC,IAAI,CAAC,4BAA4B,EAAE,CAAE,CAAC,CAAA;iBAC3F;gBACD,MAAK;aACN;YACD,KAAK,OAAO,CAAC,CAAC;gBAEZ,IAAI,CAAC,cAAc,CAAC,IAAI,qBAAa,CAAC;oBACpC,OAAO,EAAE,gBAAQ,CAAC,+CAAyD;oBAC3E,MAAM,EAAE,UAAG,GAAG,CAAC,OAAO,CAAC,IAAI,gBAAM,GAAG,CAAC,OAAO,CAAC,OAAO,CAAE;iBACvD,CAAC,CAAC,CAAA;gBACH,MAAK;aACN;YACD,OAAO,CAAC,CAAC;gBACP,OAAO,CAAC,IAAI,CACV,oEAA6D,GAAG,CAAC,OAAO,OAAI,EAC5E,GAAG,CACJ,CAAA;gBACD,MAAK;aACN;SACF;IACH,CAAC;IAED,+CAAc,GAAd,UAAe,KAAU;;QACvB,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC,OAAO,CAAA;QACtC,IAAI,CAAC,gBAAgB,EAAE,CAAA;QACvB,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;QAC5B,IAAI,CAAC,YAAY,CACf,IAAI,EACJ,CAAC,MAAA,IAAI,CAAC,WAAW,0CAAE,OAAO,CAAC,IAAI,EAAE,CAClC,CAAA;QAED,OAAO,CAAC,GAAG,CAAC,oCAA6B,IAAI,CAAC,cAAc,cAAI,IAAI,CAAC,KAAK,wBAAc,IAAI,CAAC,OAAO,MAAG,CAAC,CAAA;IAC1G,CAAC;IAED,sCAAK,GAAL;QACE,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC,MAAM,CAAA;QACrC,OAAO,CAAC,GAAG,CAAC,oCAA6B,IAAI,CAAC,cAAc,cAAI,IAAI,CAAC,KAAK,wBAAc,IAAI,CAAC,OAAO,MAAG,CAAC,CAAA;IAC1G,CAAC;IAGK,uCAAM,GAAZ;;;;;;wBACE,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC,QAAQ,CAAA;wBAEvC,OAAO,CAAC,GAAG,CAAC,0CACV,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,YAAY,eAC9C,IAAI,CAAC,cAAc,cAAI,IAAI,CAAC,KAAK,gBAAM,IAAI,CAAC,OAAO,MAAG,CAAC,CAAA;;;;wBAG1D,WAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,EAAA;;wBAAjE,SAAiE,CAAA;wBAEjE,OAAO,CAAC,GAAG,CAAC,kDAA2C,IAAI,CAAC,cAAc,cAAI,IAAI,CAAC,KAAK,gBAAM,IAAI,CAAC,OAAO,MAAG,CAAC,CAAA;;;;wBAE9G,OAAO,CAAC,KAAK,CACX,2CAAoC,IAAI,CAAC,cAAc,cAAI,IAAI,CAAC,KAAK,gBAAM,IAAI,CAAC,OAAO,MAAG,EAC1F,GAAC,CACF,CAAA;;;;;;KAEJ;IA+ZO,+CAAc,GAAtB,UAAuB,aAA8B;QACnD,IACE,IAAI,CAAC,gBAAgB,CAAC,aAAa,CAAC;eACjC,IAAI,CAAC,gBAAgB,CAAC,aAAa,CAAE,GAAG,CAAC,EAC5C;YACA,IAAI,CAAC,gBAAgB,CAAC,aAAa,CAAE,IAAI,CAAC,CAAA;YAC1C,OAAO,CAAC,GAAG,CAAC,qBAAc,aAAa,2CAAiC,IAAI,CAAC,gBAAgB,CAAC,aAAa,CAAC,gBAAa,CAAC,CAAA;YAE1H,OAAO,IAAI,CAAA;SACZ;QACD,OAAO,KAAK,CAAA;IACd,CAAC;IAEa,mDAAkB,GAAhC,UAAiC,GAAgE;;;;;;;wBAE7F,IAAI,CAAC,eAAe,EAAE,CAAA;wBACtB,WAAM,IAAI,CAAC,0BAA0B,CAAC,GAAG,CAAC,EAAA;;wBAA1C,SAA0C,CAAA;wBAC1C,IAAI,CAAC,mCAAmC,CAAC,GAAG,CAAC,CAAA;;;;wBAG7C,OAAO,CAAC,KAAK,CACX,wFAAwF,EACxF,GAAC,CACF,CAAA;wBACD,MAAM,GAAC,CAAA;;;;;KAEV;IAEa,2DAA0B,GAAxC,UAAyC,GAAgE;;;;;;wBAC/F,SAAS,GAAK,GAAG,UAAR,CAAQ;wBAEjB,MAAM,GAAK,GAAG,CAAC,OAAO,OAAhB,CAAgB;wBACtB,OAAO,GAAK,GAAG,QAAR,CAAQ;wBAEvB,IAAI,CAAC,MAAM,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;4BACvC,WAAM;yBACP;wBAEO,WAAW,GAAK,IAAI,YAAT,CAAS;wBAG5B,IAAI;4BACF,eAAe,GAAG,MAAM,CAAC,GAAG,CAAC,cAAc,CAAC,CAAA;yBAC7C;wBAAC,OAAO,CAAC,EAAE;4BACV,IAAI,CAAC,cAAc,CAAC,IAAI,qBAAa,CAAC;gCACpC,OAAO,EAAE,gBAAQ,CAAC,0DAAoE;gCACtF,MAAM,EAAE,CAAC;6BACV,CAAC,CAAC,CAAA;4BACH,WAAM;yBACP;wBAGG,IAAI,qBAAO,WAAW,CAAC,WAAW,OAAC,CAAA;wBACnC,eAAe,GAAG,KAAK,CAAA;4CAClB,CAAC,EAAM,GAAG;;;;;wCACX,MAAM,GAAG,eAAe,CAAC,CAAC,CAAC,CAAA;6CAE7B,CAAA,WAAW,CAAC,cAAc,IAAI,MAAM,CAAC,EAAE,CAAA,EAAvC,cAAuC;wCACzC,IAAI,CAAC,eAAe,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,MAAM,CAAC,EAAE,GAAG,eAAe,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;4CAIpE,OAAO,CAAC,IAAI,CAAC,mDAA4C,WAAW,CAAC,cAAc,sBAAY,MAAM,CAAC,EAAE,CAAE,CAAC,CAAA;yCAE5G;6CAAM;4CAEL,OAAO,CAAC,KAAK,CAAC,gJAAyI,SAAS,MAAG,CAAC,CAAA;yCACrK;;;6CAEQ,CAAA,WAAW,CAAC,cAAc,KAAK,MAAM,CAAC,EAAE,GAAG,CAAC,CAAA,EAA5C,cAA4C;wCAMrD,QAAQ,MAAM,CAAC,QAAQ,EAAE;4CACvB,KAAK,QAAQ,CAAC,CAAC;gDAEb,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE;oDACf,QAAQ,MAAM,CAAC,SAAS,EAAE;wDACxB,KAAK,QAAQ,CAAC;wDACd,KAAK,SAAS,CAAC,CAAC;4DACR,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,UAAA,GAAG,IAAI,OAAA,GAAG,CAAC,GAAG,KAAK,MAAM,CAAC,KAAK,EAAxB,CAAwB,CAAC,CAAA;4DAC3D,IAAI,QAAQ,EAAE;gEAEN,QAAM,IAAA,mBAAS,EAAC,QAAQ,CAAC,CAAA;gEAE/B,IAAI,MAAM,CAAC,aAAa,EAAE;oEACxB,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,OAAO,CAAC,UAAC,SAAS;wEAClD,IAAA,aAAG,EAAC,KAAG,EAAE,SAAS,EAAE,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAA;oEACtD,CAAC,CAAC,CAAA;iEACH;gEAED,IAAI,MAAM,CAAC,aAAa,EAAE;oEACxB,WAA4C,EAApB,KAAA,MAAM,CAAC,aAAa,EAApB,cAAoB,EAApB,IAAoB,EAAE;wEAAnC,SAAS;wEAClB,IAAA,eAAK,EAAC,KAAG,EAAE,SAAS,CAAC,CAAA;qEACtB;iEACF;gEAED,MAAM,CAAC,GAAG,GAAG,KAAG,CAAA;6DACjB;iEAAM;gEAEL,OAAO,CAAC,KAAK,CAAC,mHAAmH,CAAC,CAAA;6DACnI;4DACD,MAAK;yDACN;wDACD,KAAK,SAAS,CAAC,CAAC;4DAER,GAAG,GAAG,IAAI,qBAAa,CAAC;gEAC5B,OAAO,EAAE,gBAAQ,CAAC,qDAA+D;gEACjF,MAAM,EAAE,qHAA0G,GAAG,CAAC,SAAS,MAAG;6DACnI,CAAC,CAAA;4DACF,OAAK,cAAc,CAAC,GAAG,CAAC,CAAA;4DACxB,MAAM,GAAG,CAAA;yDACV;wDACD,OAAO,CAAC,CAAC;4DACP,MAAK;yDACN;qDACF;iDACF;gDACD,MAAK;6CACN;4CACD,KAAK,SAAS,CAAC,CAAC;gDAEd,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE;oDAET,GAAG,GAAG,IAAI,qBAAa,CAAC;wDAC5B,OAAO,EAAE,gBAAQ,CAAC,qDAA+D;wDACjF,MAAM,EAAE,4FAAmF,GAAG,CAAC,SAAS,MAAG;qDAC5G,CAAC,CAAA;oDACF,OAAK,cAAc,CAAC,GAAG,CAAC,CAAA;oDACxB,MAAM,GAAG,CAAA;iDACV;gDACD,MAAK;6CACN;4CACD,KAAK,QAAQ,CAAC,CAAC;gDACP,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,UAAA,GAAG,IAAI,OAAA,GAAG,CAAC,GAAG,KAAK,MAAM,CAAC,KAAK,EAAxB,CAAwB,CAAC,CAAA;gDACtD,IAAI,GAAG,EAAE;oDACP,MAAM,CAAC,GAAG,GAAG,GAAG,CAAA;iDACjB;qDAAM;oDAEL,OAAO,CAAC,KAAK,CAAC,0GAA0G,CAAC,CAAA;iDAC1H;gDACD,MAAK;6CACN;4CACD,KAAK,OAAO,CAAC,CAAC;gDACZ,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE;oDACf,QAAQ,MAAM,CAAC,SAAS,EAAE;wDACxB,KAAK,SAAS,CAAC,CAAC;4DACR,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,UAAA,GAAG,IAAI,OAAA,GAAG,CAAC,GAAG,KAAK,MAAM,CAAC,KAAK,EAAxB,CAAwB,CAAC,CAAA;4DACtD,IAAI,GAAG,EAAE;gEACP,MAAM,CAAC,GAAG,GAAG,GAAG,CAAA;6DACjB;iEAAM;gEACL,OAAO,CAAC,KAAK,CAAC,kHAAkH,CAAC,CAAA;6DAClI;4DACD,MAAK;yDACN;wDACD,KAAK,SAAS,CAAC,CAAC;4DAER,GAAG,GAAG,IAAI,qBAAa,CAAC;gEAC5B,OAAO,EAAE,gBAAQ,CAAC,qDAA+D;gEACjF,MAAM,EAAE,oHAAyG,GAAG,CAAC,SAAS,MAAG;6DAClI,CAAC,CAAA;4DACF,OAAK,cAAc,CAAC,GAAG,CAAC,CAAA;4DACxB,MAAM,GAAG,CAAA;yDACV;wDACD,OAAO,CAAC,CAAC;4DACP,MAAK;yDACN;qDACF;iDACF;gDACD,MAAK;6CACN;yCACF;wCAED,QAAQ,MAAM,CAAC,SAAS,EAAE;4CACxB,KAAK,MAAM,CAAC,CAAC;gDACX,IAAI,CAAC,eAAe,EAAE;oDACpB,eAAe,GAAG,IAAI,CAAA;oDACtB,IAAI,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;iDACpB;qDAAM;oDACL,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;iDACtB;gDACD,MAAK;6CACN;4CACD,KAAK,SAAS,CAAC,CAAC;gDACd,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;gDACrB,MAAK;6CACN;4CACD,KAAK,SAAS,CAAC,CAAC;gDACR,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,UAAA,GAAG,IAAI,OAAA,GAAG,CAAC,GAAG,KAAK,MAAM,CAAC,KAAK,EAAxB,CAAwB,CAAC,CAAA;gDAC3D,IAAI,GAAG,GAAG,CAAC,CAAC,EAAE;oDACZ,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,CAAA;iDACpB;qDAAM;oDAEL,OAAO,CAAC,KAAK,CAAC,2GAA2G,CAAC,CAAA;iDAC3H;gDACD,MAAK;6CACN;4CACD,KAAK,QAAQ,CAAC,CAAC;gDACP,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,UAAA,GAAG,IAAI,OAAA,GAAG,CAAC,GAAG,KAAK,MAAM,CAAC,KAAK,EAAxB,CAAwB,CAAC,CAAA;gDAC3D,IAAI,GAAG,GAAG,CAAC,CAAC,EAAE;oDACZ,IAAI,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,GAAG,CAAA;iDACvB;qDAAM;oDAEL,OAAO,CAAC,KAAK,CAAC,oHAAoH,CAAC,CAAA;iDACpI;gDACD,MAAK;6CACN;yCACF;wCAED,IACE,CAAC,KAAK,GAAG,GAAG,CAAC;+CACV,CAAC,eAAe,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,eAAe,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,KAAK,MAAM,CAAC,EAAE,CAAC,EACtE;4CAEM,YAAY,qBAAO,IAAI,OAAC,CAAA;4CAGxB,UAAU,GAAG,eAAe;iDAC/B,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;iDACf,MAAM,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,EAAE,KAAK,MAAM,CAAC,EAAE,EAAlB,CAAkB,CAAC,CAAA;4CAGlC,OAAK,WAAW,CAAC,cAAc,GAAG,MAAM,CAAC,EAAE,CAAA;4CAC3C,OAAK,WAAW,CAAC,WAAW,GAAG,IAAI,CAAA;4CAE7B,QAAQ,GAAG,IAAI,mBAAQ,CAAC;gDAC5B,EAAE,EAAE,MAAM,CAAC,EAAE;gDACb,UAAU,YAAA;gDACV,IAAI,EAAE,YAAY;gDAClB,OAAO,SAAA;6CACR,CAAC,CAAA;4CAEF,OAAK,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAA;yCACjC;;;wCAKD,OAAO,CAAC,IAAI,CAAC,kEAA2D,OAAK,WAAW,CAAC,cAAc,sBAAY,MAAM,CAAC,EAAE,CAAE,CAAC,CAAA;wCAG/H,WAAM,OAAK,YAAY,EAAE,EAAA;;wCAAzB,SAAyB,CAAA;;;;;;;wBA7LpB,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,eAAe,CAAC,MAAM;;;6BAAE,CAAA,CAAC,GAAG,GAAG,CAAA;2CAA5C,CAAC,EAAM,GAAG;;;;;;;wBAAoC,CAAC,EAAE,CAAA;;;;;;KAiM3D;IAEO,oEAAmC,GAA3C,UAA4C,GAAgE;QAC1G,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YACrB,OAAO,CAAC,KAAK,CAAC,qHAAqH,CAAC,CAAA;YACpI,OAAM;SACP;QAED,IACE,IAAI,CAAC,WAAW,CAAC,aAAa;eAC3B,IAAI,CAAC,WAAW,CAAC,cAAc,IAAI,IAAI,CAAC,WAAW,CAAC,aAAa,EACpE;YACA,IAAI,CAAC,sBAAsB,EAAE,CAAA;SAC9B;QAED,IAAI,IAAI,CAAC,WAAW,CAAC,cAAc,GAAG,GAAG,CAAC,OAAO,CAAC,SAAS,EAAE;YAC3D,OAAO,CAAC,IAAI,CAAC,8HAA8H,CAAC,CAAA;YAC5I,OAAM;SACP;IACH,CAAC;IAEO,uDAAsB,GAA9B;QACE,IAAI,IAAI,CAAC,qBAAqB,EAAE;YAC9B,YAAY,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAA;YACxC,IAAI,CAAC,qBAAqB,GAAG,SAAS,CAAA;SACvC;IACH,CAAC;IACH,6BAAC;AAAD,CAAC,AA92BD,IA82BC;AA92BY,wDAAsB;AAg3BnC,SAAS,cAAc,CAAC,KAAe;IACrC,IAAM,CAAC,GAAmB;QACxB,EAAE,EAAE,KAAK,CAAC,EAAE;QACZ,QAAQ,EAAE,KAAK,CAAC,QAAQ;QACxB,SAAS,EAAE,KAAK,CAAC,SAAS;QAC1B,KAAK,EAAE,KAAK,CAAC,KAAK;QAClB,GAAG,EAAE,KAAK,CAAC,GAAG,IAAI,KAAK,CAAC,GAAG,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS;KACzE,CAAA;IAED,IAAI,KAAK,CAAC,QAAQ,KAAK,QAAQ,EAAE;QAE/B,IAAI,KAAK,CAAC,aAAa,EAAE;YACvB,CAAC,CAAC,aAAa,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,aAAa,CAAC,CAAA;SAClD;QAGD,IAAI,KAAK,CAAC,aAAa,IAAI,KAAK,CAAC,aAAa,EAAE;YAK9C,CAAC,CAAC,aAAa,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,aAAa,CAAC,CAAA;SAClD;KACF;IAED,OAAO,CAAC,CAAA;AACV,CAAC","sourcesContent":["import set from 'lodash/set'\nimport unset from 'lodash/unset'\nimport cloneDeep from 'lodash/cloneDeep'\nimport { genRequestId } from './message'\nimport {\n  IResponseMessage,\n  IRequestMessageInitWatchMsg,\n  IResponseMessageInitEventMsg,\n  IDBEvent,\n  IRequestMessageRebuildWatchMsg,\n  IRequestMessageCloseWatchMsg,\n  IRequestMsgType,\n  IResponseMessageNextEventMsg,\n  IRequestMessageCheckLastMsg,\n  IWatchOptions,\n} from '@cloudbase/types/realtime'\nimport {\n  ISingleDBEvent,\n} from '@cloudbase/types/database'\nimport { RealtimeListener } from './listener'\nimport { Snapshot } from './snapshot'\nimport { IWSSendOptions, ILoginResult } from './websocket-client'\nimport {\n  ERR_CODE,\n  CloudSDKError,\n  isTimeoutError,\n  CancelledError,\n  isCancelledError,\n  isRealtimeErrorMessageError,\n  RealtimeErrorMessageError,\n  TimeoutError,\n} from './error'\nimport { sleep } from './utils'\n\n// =============== Realtime Virtual WebSocket Client (Internal) ====================\n\ninterface IVirtualWebSocketClientConstructorOptions extends IWatchOptions {\n  envId?: string\n  collectionName: string\n  query: string\n  limit?: number\n  orderBy?: Record<string, string>\n  send: <T = any>(opts: IWSSendOptions) => Promise<T>\n  login: (envId?: string, refresh?: boolean) => Promise<any>\n  isWSConnected: () => boolean\n  onceWSConnected: () => Promise<void>\n  getWaitExpectedTimeoutLength: () => number\n  onWatchStart: (client: VirtualWebSocketClient, queryID: string) => void\n  onWatchClose: (client: VirtualWebSocketClient, queryID: string) => void\n  debug?: boolean\n}\n\ninterface IWatchSessionInfo {\n  queryID: string\n  currentEventId: number\n  currentDocs: Record<string, any>[]\n  expectEventId?: number\n}\n\ninterface IHandleCommonErrorOptions {\n  onSignError: (e: RealtimeErrorMessageError) => void\n  onTimeoutError: (e: TimeoutError) => void\n  onCancelledError: (e: CancelledError) => void\n  onNotRetryableError: (e: RealtimeErrorMessageError) => void\n  onUnknownError: (e: any) => void\n}\n\ninterface IHandleWatchEstablishmentErrorOptions {\n  operationName: 'INIT_WATCH' | 'REBUILD_WATCH'\n  resolve: (value?: PromiseLike<void> | undefined) => void\n  reject: (e: any) => void\n}\n\nenum WatchStatus {\n  LOGGINGIN = 'LOGGINGIN',\n  INITING = 'INITING',\n  REBUILDING = 'REBUILDING',\n  ACTIVE = 'ACTIVE',\n  ERRORED = 'ERRORED',\n  CLOSING = 'CLOSING',\n  CLOSED = 'CLOSED',\n  PAUSED = 'PAUSED',\n  RESUMING = 'RESUMING'\n}\n\nconst DEFAULT_WAIT_TIME_ON_UNKNOWN_ERROR = 100\nconst DEFAULT_MAX_AUTO_RETRY_ON_ERROR = 2\nconst DEFAULT_MAX_SEND_ACK_AUTO_RETRY_ON_ERROR = 2\nconst DEFAULT_SEND_ACK_DEBOUNCE_TIMEOUT = 10 * 1000\nconst DEFAULT_INIT_WATCH_TIMEOUT = 10 * 1000\nconst DEFAULT_REBUILD_WATCH_TIMEOUT = 10 * 1000\n\nexport class VirtualWebSocketClient {\n  // passed over\n  watchId: string\n  // own\n  listener: RealtimeListener\n  private envId?: string\n  private collectionName: string\n  private query: string\n  private limit: number\n  private orderBy: Record<string, string>\n  private send: <T = any>(opts: IWSSendOptions) => Promise<T>\n  private login: (envId?: string, refresh?: boolean) => Promise<any>\n  private isWSConnected: () => boolean\n  private onceWSConnected: () => Promise<void>\n  private getWaitExpectedTimeoutLength: () => number\n  private onWatchStart: (\n    client: VirtualWebSocketClient,\n    queryID: string\n  ) => void\n  private onWatchClose: (\n    client: VirtualWebSocketClient,\n    queryID: string\n  ) => void\n  private debug?: boolean\n\n  private watchStatus: WatchStatus = WatchStatus.INITING\n  private availableRetries: Partial<Record<IRequestMsgType, number>>\n  private ackTimeoutId?: number\n  private initWatchPromise?: Promise<void>\n  private rebuildWatchPromise?: Promise<void>\n\n  // obtained\n  private sessionInfo?: IWatchSessionInfo\n\n  // internal\n  private waitExpectedTimeoutId?: number\n\n  constructor(options: IVirtualWebSocketClientConstructorOptions) {\n    this.watchId = `watchid_${+new Date()}_${Math.random()}`\n    this.envId = options.envId\n    this.collectionName = options.collectionName\n    this.query = options.query\n    this.limit = options.limit\n    this.orderBy = options.orderBy\n    this.send = options.send\n    this.login = options.login\n    this.isWSConnected = options.isWSConnected\n    this.onceWSConnected = options.onceWSConnected\n    this.getWaitExpectedTimeoutLength = options.getWaitExpectedTimeoutLength\n    this.onWatchStart = options.onWatchStart\n    this.onWatchClose = options.onWatchClose\n    this.debug = options.debug\n\n    this.availableRetries = {\n      INIT_WATCH: DEFAULT_MAX_AUTO_RETRY_ON_ERROR,\n      REBUILD_WATCH: DEFAULT_MAX_AUTO_RETRY_ON_ERROR,\n      CHECK_LAST: DEFAULT_MAX_SEND_ACK_AUTO_RETRY_ON_ERROR,\n    }\n\n    this.listener = new RealtimeListener({\n      close: () => {\n        this.closeWatch()\n      },\n      onChange: options.onChange,\n      onError: options.onError,\n      debug: this.debug,\n      virtualClient: this,\n    })\n\n    this.initWatch()\n  }\n\n  onMessage(msg: IResponseMessage) {\n    // watchStatus sanity check\n    switch (this.watchStatus) {\n      case WatchStatus.PAUSED: {\n        // ignore all but error message\n        if (msg.msgType !== 'ERROR') {\n          return\n        }\n        break\n      }\n      case WatchStatus.LOGGINGIN:\n      case WatchStatus.INITING:\n      case WatchStatus.REBUILDING: {\n        console.warn(`[realtime listener] internal non-fatal error: unexpected message received while ${this.watchStatus}`)\n        return\n      }\n      case WatchStatus.CLOSED: {\n        console.warn('[realtime listener] internal non-fatal error: unexpected message received when the watch has closed')\n        return\n      }\n      case WatchStatus.ERRORED: {\n        console.warn('[realtime listener] internal non-fatal error: unexpected message received when the watch has ended with error')\n        return\n      }\n    }\n\n    if (!this.sessionInfo) {\n      console.warn('[realtime listener] internal non-fatal error: sessionInfo not found while message is received.')\n      return\n    }\n\n    this.scheduleSendACK()\n\n    switch (msg.msgType) {\n      case 'NEXT_EVENT': {\n        // if (process.env.DEBUG) {\n        // @ts-ignore\n        // if (wx._ignore) {\n        console.warn(`nextevent ${msg.msgData.currEvent} ignored`, msg)\n        // @ts-ignore\n        // wx._ignore = false\n        // return\n        // }\n        // }\n\n        this.handleServerEvents(msg)\n        break\n      }\n      case 'CHECK_EVENT': {\n        if (this.sessionInfo.currentEventId < msg.msgData.currEvent) {\n          // client eventID < server eventID:\n          // there might be one or more pending events not yet received but sent by the server\n          this.sessionInfo.expectEventId = msg.msgData.currEvent\n          this.clearWaitExpectedEvent()\n          // @ts-ignore\n          this.waitExpectedTimeoutId = setTimeout(() => {\n            // must rebuild watch\n            this.rebuildWatch()\n          }, this.getWaitExpectedTimeoutLength())\n\n          console.log(`[realtime] waitExpectedTimeoutLength ${this.getWaitExpectedTimeoutLength()}`)\n        }\n        break\n      }\n      case 'ERROR': {\n        // receive server error\n        this.closeWithError(new CloudSDKError({\n          errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_SERVER_ERROR_MSG as string,\n          errMsg: `${msg.msgData.code} - ${msg.msgData.message}`,\n        }))\n        break\n      }\n      default: {\n        console.warn(\n          `[realtime listener] virtual client receive unexpected msg ${msg.msgType}: `,\n          msg\n        )\n        break\n      }\n    }\n  }\n\n  closeWithError(error: any) {\n    this.watchStatus = WatchStatus.ERRORED\n    this.clearACKSchedule()\n    this.listener.onError(error)\n    this.onWatchClose(\n      this,\n      (this.sessionInfo?.queryID) || ''\n    )\n\n    console.log(`[realtime] client closed (${this.collectionName} ${this.query}) (watchId ${this.watchId})`)\n  }\n\n  pause() {\n    this.watchStatus = WatchStatus.PAUSED\n    console.log(`[realtime] client paused (${this.collectionName} ${this.query}) (watchId ${this.watchId})`)\n  }\n\n\n  async resume(): Promise<void> {\n    this.watchStatus = WatchStatus.RESUMING\n\n    console.log(`[realtime] client resuming with ${\n      this.sessionInfo ? 'REBUILD_WATCH' : 'INIT_WATCH'\n    } (${this.collectionName} ${this.query}) (${this.watchId})`)\n\n    try {\n      await (this.sessionInfo ? this.rebuildWatch() : this.initWatch())\n\n      console.log(`[realtime] client successfully resumed (${this.collectionName} ${this.query}) (${this.watchId})`)\n    } catch (e) {\n      console.error(\n        `[realtime] client resume failed (${this.collectionName} ${this.query}) (${this.watchId})`,\n        e\n      )\n    }\n  }\n\n  private wsLogin = async (\n    envId?: string,\n    refresh?: boolean\n  ): Promise<ILoginResult> => {\n    this.watchStatus = WatchStatus.LOGGINGIN\n    const loginResult = await this.login(envId, refresh)\n    if (!this.envId) {\n      this.envId = loginResult.envId\n    }\n    return loginResult\n  }\n\n  private initWatch = async (forceRefreshLogin?: boolean): Promise<void> => {\n    if (this.initWatchPromise !== null && this.initWatchPromise !== undefined) {\n      return this.initWatchPromise\n    }\n\n    this.initWatchPromise = new Promise<void>((resolve, reject) => {\n      void (async () => {\n        try {\n          if (this.watchStatus === WatchStatus.PAUSED) {\n            console.log('[realtime] initWatch cancelled on pause')\n            return resolve()\n          }\n\n          const { envId } = await this.wsLogin(this.envId, forceRefreshLogin)\n          if ((this.watchStatus as WatchStatus) === WatchStatus.PAUSED) {\n            console.log('[realtime] initWatch cancelled on pause')\n            return resolve()\n          }\n\n          this.watchStatus = WatchStatus.INITING\n\n          const initWatchMsg: IRequestMessageInitWatchMsg = {\n            watchId: this.watchId,\n            requestId: genRequestId(),\n            msgType: 'INIT_WATCH',\n            msgData: {\n              envId,\n              collName: this.collectionName,\n              query: this.query,\n              limit: this.limit,\n              orderBy: this.orderBy,\n            },\n          }\n\n          const initEventMsg = await this.send<IResponseMessageInitEventMsg>({\n            msg: initWatchMsg,\n            waitResponse: true,\n            skipOnMessage: true,\n            timeout: DEFAULT_INIT_WATCH_TIMEOUT,\n          })\n\n          const { events, currEvent } = initEventMsg.msgData\n\n          this.sessionInfo = {\n            queryID: initEventMsg.msgData.queryID,\n            currentEventId: currEvent - 1,\n            currentDocs: [],\n          }\n\n          // FIX: in initEvent message, all events have id 0, which is inconsistent with currEvent\n          if (events.length > 0) {\n            for (const e of events) {\n              e.ID = currEvent\n            }\n            this.handleServerEvents(initEventMsg)\n          } else {\n            this.sessionInfo.currentEventId = currEvent\n            const snapshot = new Snapshot({\n              id: currEvent,\n              docChanges: [],\n              docs: [],\n              type: 'init',\n            })\n            this.listener.onChange(snapshot)\n            this.scheduleSendACK()\n          }\n          this.onWatchStart(this, this.sessionInfo.queryID)\n          this.watchStatus = WatchStatus.ACTIVE\n          this.availableRetries.INIT_WATCH = DEFAULT_MAX_AUTO_RETRY_ON_ERROR\n          resolve()\n        } catch (e) {\n          this.handleWatchEstablishmentError(e, {\n            operationName: 'INIT_WATCH',\n            resolve,\n            reject,\n          })\n        }\n      })()\n    })\n\n    let success = false\n\n    try {\n      await this.initWatchPromise\n      success = true\n    } finally {\n      this.initWatchPromise = undefined\n    }\n    console.log(`[realtime] initWatch ${success ? 'success' : 'fail'}`)\n  }\n\n  private rebuildWatch = async (forceRefreshLogin?: boolean): Promise<void> => {\n    if (this.rebuildWatchPromise !== null && this.rebuildWatchPromise !== undefined) {\n      return this.rebuildWatchPromise\n    }\n\n    this.rebuildWatchPromise = new Promise<void>((resolve, reject) => {\n      void (async () => {\n        try {\n          if (this.watchStatus === WatchStatus.PAUSED) {\n            console.log('[realtime] rebuildWatch cancelled on pause')\n            return resolve()\n          }\n          const { envId } = await this.wsLogin(this.envId, forceRefreshLogin)\n\n          if (!this.sessionInfo) {\n            throw new Error('can not rebuildWatch without a successful initWatch (lack of sessionInfo)')\n          }\n\n          if ((this.watchStatus as WatchStatus) === WatchStatus.PAUSED) {\n            console.log('[realtime] rebuildWatch cancelled on pause')\n            return resolve()\n          }\n\n          this.watchStatus = WatchStatus.REBUILDING\n\n          const rebuildWatchMsg: IRequestMessageRebuildWatchMsg = {\n            watchId: this.watchId,\n            requestId: genRequestId(),\n            msgType: 'REBUILD_WATCH',\n            msgData: {\n              envId,\n              collName: this.collectionName,\n              queryID: this.sessionInfo.queryID,\n              eventID: this.sessionInfo.currentEventId,\n            },\n          }\n\n          const nextEventMsg = await this.send<IResponseMessageNextEventMsg>({\n            msg: rebuildWatchMsg,\n            waitResponse: true,\n            skipOnMessage: false,\n            timeout: DEFAULT_REBUILD_WATCH_TIMEOUT,\n          })\n\n          this.handleServerEvents(nextEventMsg)\n\n          this.watchStatus = WatchStatus.ACTIVE\n          this.availableRetries.REBUILD_WATCH = DEFAULT_MAX_AUTO_RETRY_ON_ERROR\n          resolve()\n        } catch (e) {\n          this.handleWatchEstablishmentError(e, {\n            operationName: 'REBUILD_WATCH',\n            resolve,\n            reject,\n          })\n        }\n      })()\n    })\n\n    let success = false\n\n    try {\n      await this.rebuildWatchPromise\n      success = true\n    } finally {\n      this.rebuildWatchPromise = undefined\n    }\n\n    console.log(`[realtime] rebuildWatch ${success ? 'success' : 'fail'}`)\n  }\n\n  private handleWatchEstablishmentError = async (\n    e: any,\n    options: IHandleWatchEstablishmentErrorOptions\n  ) => {\n    const isInitWatch = options.operationName === 'INIT_WATCH'\n\n    const abortWatch = () => {\n      // mock temp comment\n      this.closeWithError(new CloudSDKError({\n        errCode: isInitWatch\n          ? (ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_INIT_WATCH_FAIL as string)\n          : (ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_REBUILD_WATCH_FAIL as string),\n        errMsg: e,\n      }))\n      options.reject(e)\n    }\n\n    const retry = (refreshLogin?: boolean) => {\n      if (this.useRetryTicket(options.operationName)) {\n        if (isInitWatch) {\n          this.initWatchPromise = undefined\n          options.resolve(this.initWatch(refreshLogin))\n        } else {\n          this.rebuildWatchPromise = undefined\n          options.resolve(this.rebuildWatch(refreshLogin))\n        }\n      } else {\n        abortWatch()\n      }\n    }\n\n    this.handleCommonError(e, {\n      onSignError: () => retry(true),\n      onTimeoutError: () => retry(false),\n      onNotRetryableError: abortWatch,\n      onCancelledError: options.reject,\n      onUnknownError: () => {\n        (async () => {\n          try {\n            const onWSDisconnected = async () => {\n              this.pause()\n              await this.onceWSConnected()\n              retry(true)\n            }\n\n            if (!this.isWSConnected()) {\n              await onWSDisconnected()\n            } else {\n              await sleep(DEFAULT_WAIT_TIME_ON_UNKNOWN_ERROR)\n              if (this.watchStatus === WatchStatus.PAUSED) {\n                // cancel\n                options.reject(new CancelledError(`${options.operationName} cancelled due to pause after unknownError`))\n              } else if (!this.isWSConnected()) {\n                await onWSDisconnected()\n              } else {\n                retry(false)\n              }\n            }\n          } catch (e) {\n            // unexpected error while handling error, in order to provide maximum effort on SEAMINGLESS FAULT TOLERANCE, just retry\n            retry(true)\n          }\n        })()\n      },\n    })\n  }\n\n  private closeWatch = async () => {\n    const queryId = this.sessionInfo ? this.sessionInfo.queryID : ''\n\n    if (this.watchStatus !== WatchStatus.ACTIVE) {\n      this.watchStatus = WatchStatus.CLOSED\n      this.onWatchClose(this, queryId)\n      return\n    }\n\n    try {\n      this.watchStatus = WatchStatus.CLOSING\n\n      const closeWatchMsg: IRequestMessageCloseWatchMsg = {\n        watchId: this.watchId,\n        requestId: genRequestId(),\n        msgType: 'CLOSE_WATCH',\n        msgData: null,\n      }\n\n      await this.send({\n        msg: closeWatchMsg,\n      })\n\n      this.sessionInfo = undefined\n      this.watchStatus = WatchStatus.CLOSED\n    } catch (e) {\n      this.closeWithError(new CloudSDKError({\n        errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_CLOSE_WATCH_FAIL as string,\n        errMsg: e,\n      }))\n    } finally {\n      this.onWatchClose(this, queryId)\n    }\n  }\n\n  private scheduleSendACK = () => {\n    this.clearACKSchedule()\n\n    // TODO: should we check status after timeout\n    // @ts-ignore\n    this.ackTimeoutId = setTimeout(() => {\n      if (this.waitExpectedTimeoutId) {\n        this.scheduleSendACK()\n      } else {\n        this.sendACK()\n      }\n    }, DEFAULT_SEND_ACK_DEBOUNCE_TIMEOUT)\n  }\n\n  private clearACKSchedule = () => {\n    if (this.ackTimeoutId) {\n      clearTimeout(this.ackTimeoutId)\n    }\n  }\n\n  private sendACK = async (): Promise<void> => {\n    try {\n      if (this.watchStatus !== WatchStatus.ACTIVE) {\n        this.scheduleSendACK()\n        return\n      }\n\n      if (!this.sessionInfo) {\n        console.warn('[realtime listener] can not send ack without a successful initWatch (lack of sessionInfo)')\n        return\n      }\n\n      const ackMsg: IRequestMessageCheckLastMsg = {\n        watchId: this.watchId,\n        requestId: genRequestId(),\n        msgType: 'CHECK_LAST',\n        msgData: {\n          queryID: this.sessionInfo.queryID,\n          eventID: this.sessionInfo.currentEventId,\n        },\n      }\n\n      await this.send({\n        msg: ackMsg,\n      })\n\n      this.scheduleSendACK()\n    } catch (e) {\n      // TODO: refactor\n      if (isRealtimeErrorMessageError(e)) {\n        const msg = e.payload\n        switch (msg.msgData.code) {\n          // signature error -> retry with refreshed signature\n          case 'CHECK_LOGIN_FAILED':\n          case 'SIGN_EXPIRED_ERROR':\n          case 'SIGN_INVALID_ERROR':\n          case 'SIGN_PARAM_INVALID': {\n            this.rebuildWatch()\n            return\n          }\n          // other -> throw\n          case 'QUERYID_INVALID_ERROR':\n          case 'SYS_ERR':\n          case 'INVALIID_ENV':\n          case 'COLLECTION_PERMISSION_DENIED': {\n            // must throw\n            this.closeWithError(new CloudSDKError({\n              errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_CHECK_LAST_FAIL as string,\n              errMsg: msg.msgData.code,\n            }))\n            return\n          }\n          default: {\n            break\n          }\n        }\n      }\n\n      // maybe retryable\n      if (\n        this.availableRetries.CHECK_LAST\n        && this.availableRetries.CHECK_LAST > 0\n      ) {\n        this.availableRetries.CHECK_LAST -= 1\n        this.scheduleSendACK()\n      } else {\n        this.closeWithError(new CloudSDKError({\n          errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_CHECK_LAST_FAIL as string,\n          errMsg: e,\n        }))\n      }\n    }\n  }\n\n  private handleCommonError = (\n    e: any,\n    options: IHandleCommonErrorOptions\n  ): void => {\n    if (isRealtimeErrorMessageError(e)) {\n      const msg = e.payload\n      switch (msg.msgData.code) {\n        // signature error -> retry with refreshed signature\n        case 'CHECK_LOGIN_FAILED':\n        case 'SIGN_EXPIRED_ERROR':\n        case 'SIGN_INVALID_ERROR':\n        case 'SIGN_PARAM_INVALID': {\n          options.onSignError(e)\n          return\n        }\n        // not-retryable error -> throw\n        case 'QUERYID_INVALID_ERROR':\n        case 'SYS_ERR':\n        case 'INVALIID_ENV':\n        case 'COLLECTION_PERMISSION_DENIED': {\n          options.onNotRetryableError(e)\n          return\n        }\n        default: {\n          options.onNotRetryableError(e)\n          return\n        }\n      }\n    } else if (isTimeoutError(e)) {\n      // timeout error\n      options.onTimeoutError(e)\n      return\n    } else if (isCancelledError(e)) {\n      // cancelled error\n      options.onCancelledError(e)\n      return\n    }\n\n    // unknown error\n    options.onUnknownError(e)\n  }\n\n  // credit a retry chance from availableRetries\n  private useRetryTicket(operationName: IRequestMsgType): boolean {\n    if (\n      this.availableRetries[operationName]\n      && this.availableRetries[operationName]! > 0\n    ) {\n      this.availableRetries[operationName]! -= 1\n      console.log(`[realtime] ${operationName} use a retry ticket, now only ${this.availableRetries[operationName]} retry left`)\n\n      return true\n    }\n    return false\n  }\n\n  private async handleServerEvents(msg: IResponseMessageInitEventMsg | IResponseMessageNextEventMsg) {\n    try {\n      this.scheduleSendACK()\n      await this.handleServerEventsInternel(msg)\n      this.postHandleServerEventsValidityCheck(msg)\n    } catch (e) {\n      // TODO: report\n      console.error(\n        '[realtime listener] internal non-fatal error: handle server events failed with error: ',\n        e\n      )\n      throw e\n    }\n  }\n\n  private async handleServerEventsInternel(msg: IResponseMessageInitEventMsg | IResponseMessageNextEventMsg) {\n    const { requestId } = msg\n\n    const { events } = msg.msgData\n    const { msgType } = msg\n\n    if (!events.length || !this.sessionInfo) {\n      return\n    }\n\n    const { sessionInfo } = this\n\n    let allChangeEvents: ISingleDBEvent[]\n    try {\n      allChangeEvents = events.map(getPublicEvent)\n    } catch (e) {\n      this.closeWithError(new CloudSDKError({\n        errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_RECEIVE_INVALID_SERVER_DATA as string,\n        errMsg: e,\n      }))\n      return\n    }\n\n    // aggregate docs\n    let docs = [...sessionInfo.currentDocs]\n    let initEncountered = false\n    for (let i = 0, len = allChangeEvents.length; i < len; i++) {\n      const change = allChangeEvents[i]\n\n      if (sessionInfo.currentEventId >= change.id) {\n        if (!allChangeEvents[i - 1] || change.id > allChangeEvents[i - 1].id) {\n          // duplicate event, dropable\n          // TODO: report\n          // if (process.env.DEBUG) {\n          console.warn(`[realtime] duplicate event received, cur ${sessionInfo.currentEventId} but got ${change.id}`)\n          // }\n        } else {\n          // allChangeEvents should be in ascending order according to eventId, this should never happens, must report a non-fatal error\n          console.error(`[realtime listener] server non-fatal error: events out of order (the latter event's id is smaller than that of the former) (requestId ${requestId})`)\n        }\n        continue\n      } else if (sessionInfo.currentEventId === change.id - 1) {\n        // correct sequence\n        // first handle dataType then queueType:\n        // 1. dataType: we ONLY populate change.doc if neccessary\n        // 2. queueType: we build the data snapshot\n\n        switch (change.dataType) {\n          case 'update': {\n            // only need to populate change.doc when it is not provided\n            if (!change.doc) {\n              switch (change.queueType) {\n                case 'update':\n                case 'dequeue': {\n                  const localDoc = docs.find(doc => doc._id === change.docId)\n                  if (localDoc) {\n                    // a partial update\n                    const doc = cloneDeep(localDoc)\n\n                    if (change.updatedFields) {\n                      Object.keys(change.updatedFields).forEach((fieldPath) => {\n                        set(doc, fieldPath, change.updatedFields[fieldPath])\n                      })\n                    }\n\n                    if (change.removedFields) {\n                      for (const fieldPath of change.removedFields) {\n                        unset(doc, fieldPath)\n                      }\n                    }\n\n                    change.doc = doc\n                  } else {\n                    // TODO report\n                    console.error('[realtime listener] internal non-fatal server error: unexpected update dataType event where no doc is associated.')\n                  }\n                  break\n                }\n                case 'enqueue': {\n                  // doc is provided by server, this should never occur\n                  const err = new CloudSDKError({\n                    errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_UNEXPECTED_FATAL_ERROR as string,\n                    errMsg: `HandleServerEvents: full doc is not provided with dataType=\"update\" and queueType=\"enqueue\" (requestId ${msg.requestId})`,\n                  })\n                  this.closeWithError(err)\n                  throw err\n                }\n                default: {\n                  break\n                }\n              }\n            }\n            break\n          }\n          case 'replace': {\n            // validation\n            if (!change.doc) {\n              // doc is provided by server, this should never occur\n              const err = new CloudSDKError({\n                errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_UNEXPECTED_FATAL_ERROR as string,\n                errMsg: `HandleServerEvents: full doc is not provided with dataType=\"replace\" (requestId ${msg.requestId})`,\n              })\n              this.closeWithError(err)\n              throw err\n            }\n            break\n          }\n          case 'remove': {\n            const doc = docs.find(doc => doc._id === change.docId)\n            if (doc) {\n              change.doc = doc\n            } else {\n              // TODO report\n              console.error('[realtime listener] internal non-fatal server error: unexpected remove event where no doc is associated.')\n            }\n            break\n          }\n          case 'limit': {\n            if (!change.doc) {\n              switch (change.queueType) {\n                case 'dequeue': {\n                  const doc = docs.find(doc => doc._id === change.docId)\n                  if (doc) {\n                    change.doc = doc\n                  } else {\n                    console.error('[realtime listener] internal non-fatal server error: unexpected limit dataType event where no doc is associated.')\n                  }\n                  break\n                }\n                case 'enqueue': {\n                  // doc is provided by server, this should never occur\n                  const err = new CloudSDKError({\n                    errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_UNEXPECTED_FATAL_ERROR as string,\n                    errMsg: `HandleServerEvents: full doc is not provided with dataType=\"limit\" and queueType=\"enqueue\" (requestId ${msg.requestId})`,\n                  })\n                  this.closeWithError(err)\n                  throw err\n                }\n                default: {\n                  break\n                }\n              }\n            }\n            break\n          }\n        }\n\n        switch (change.queueType) {\n          case 'init': {\n            if (!initEncountered) {\n              initEncountered = true\n              docs = [change.doc]\n            } else {\n              docs.push(change.doc)\n            }\n            break\n          }\n          case 'enqueue': {\n            docs.push(change.doc)\n            break\n          }\n          case 'dequeue': {\n            const ind = docs.findIndex(doc => doc._id === change.docId)\n            if (ind > -1) {\n              docs.splice(ind, 1)\n            } else {\n              // TODO report\n              console.error('[realtime listener] internal non-fatal server error: unexpected dequeue event where no doc is associated.')\n            }\n            break\n          }\n          case 'update': {\n            const ind = docs.findIndex(doc => doc._id === change.docId)\n            if (ind > -1) {\n              docs[ind] = change.doc\n            } else {\n              // TODO report\n              console.error('[realtime listener] internal non-fatal server error: unexpected queueType update event where no doc is associated.')\n            }\n            break\n          }\n        }\n\n        if (\n          i === len - 1\n          || (allChangeEvents[i + 1] && allChangeEvents[i + 1].id !== change.id)\n        ) {\n          // a shallow slice creates a shallow snapshot\n          const docsSnapshot = [...docs]\n\n          // we slice first cause' if there're allChangeEvents that are of the same id after this change, we don't want to involve it for it is unexpected invalid order\n          const docChanges = allChangeEvents\n            .slice(0, i + 1)\n            .filter(c => c.id === change.id)\n\n          // all changes of this event has been handle, we could dispatch the event now\n          this.sessionInfo.currentEventId = change.id\n          this.sessionInfo.currentDocs = docs\n\n          const snapshot = new Snapshot({\n            id: change.id,\n            docChanges,\n            docs: docsSnapshot,\n            msgType,\n          })\n\n          this.listener.onChange(snapshot)\n        }\n      } else {\n        // out-of-order event\n        // if (process.env.DEBUG) {\n        // TODO: report\n        console.warn(`[realtime listener] event received is out of order, cur ${this.sessionInfo.currentEventId} but got ${change.id}`)\n        // }\n        // rebuild watch\n        await this.rebuildWatch()\n        return\n      }\n    }\n  }\n\n  private postHandleServerEventsValidityCheck(msg: IResponseMessageInitEventMsg | IResponseMessageNextEventMsg) {\n    if (!this.sessionInfo) {\n      console.error('[realtime listener] internal non-fatal error: sessionInfo lost after server event handling, this should never occur')\n      return\n    }\n\n    if (\n      this.sessionInfo.expectEventId\n      && this.sessionInfo.currentEventId >= this.sessionInfo.expectEventId\n    ) {\n      this.clearWaitExpectedEvent()\n    }\n\n    if (this.sessionInfo.currentEventId < msg.msgData.currEvent) {\n      console.warn('[realtime listener] internal non-fatal error: client eventId does not match with server event id after server event handling')\n      return\n    }\n  }\n\n  private clearWaitExpectedEvent() {\n    if (this.waitExpectedTimeoutId) {\n      clearTimeout(this.waitExpectedTimeoutId)\n      this.waitExpectedTimeoutId = undefined\n    }\n  }\n}\n\nfunction getPublicEvent(event: IDBEvent): ISingleDBEvent {\n  const e: ISingleDBEvent = {\n    id: event.ID,\n    dataType: event.DataType,\n    queueType: event.QueueType,\n    docId: event.DocID,\n    doc: event.Doc && event.Doc !== '{}' ? JSON.parse(event.Doc) : undefined,\n  }\n\n  if (event.DataType === 'update') {\n    // @ts-ignore\n    if (event.UpdatedFields) {\n      e.updatedFields = JSON.parse(event.UpdatedFields)\n    }\n    // TODO: wait for tcb to change removedFields to RemovedFields\n    // @ts-ignore\n    if (event.removedFields || event.RemovedFields) {\n      // @ts-ignore\n      // e.removedFields = event.removedFields\n      //   ? JSON.parse(event.removedFields)\n      //   : JSON.parse(event.RemovedFields)\n      e.removedFields = JSON.parse(event.removedFields)\n    }\n  }\n\n  return e\n}\n"]}