zalo-toolkit 1.0.2 → 1.0.4

package/dist/cjs/apis/listen.cjs

@@ -0,0 +1,822 @@
+'use strict';
+
+var stream = require('stream');
+var DeliveredMessage = require('../models/DeliveredMessage.cjs');
+var FriendEvent = require('../models/FriendEvent.cjs');
+var GroupEvent = require('../models/GroupEvent.cjs');
+var Listen = require('../models/Listen.cjs');
+var Message = require('../models/Message.cjs');
+var Reaction = require('../models/Reaction.cjs');
+var SeenMessage = require('../models/SeenMessage.cjs');
+var Typing = require('../models/Typing.cjs');
+var Undo = require('../models/Undo.cjs');
+var utils = require('../utils.cjs');
+var configSocket = require('../socket/config-socket.cjs');
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+var WebSocket = require('ws');
+var lodash = require('lodash');
+
+class Listener extends stream.EventEmitter {
+    constructor(api) {
+        super();
+        this.api = api;
+        this.id = 0;
+        this.retries = {};
+        this.retriesRound2 = {};
+        this.rotateCount = 0;
+        this.listUrlSocket = [];
+        this.pingHttp = {};
+        this.fibonacciRetry = new utils.FibonacciRetry();
+        this.configChanged = false;
+        this._onClose = (event) => {
+            console.log('Is closed now ', this.ctx.uid, event.code);
+            this.afterClose();
+            if (!event || event.code === null) {
+                this.handleError(Listen.ConnectionErrorCode.Unknown);
+                return;
+            }
+            if (event.code === Listen.CloseReason.AbnormalClosure) {
+                this.retry(Listen.NetworkErrorCode.CannotReachServerNum);
+                return;
+            }
+            if (event.code === Listen.CloseReason.NormalClosure) {
+                return;
+            }
+            if (event.code > 1000 && event.code <= 1015) {
+                this.retry(Listen.NetworkErrorCode.Internal);
+                return;
+            }
+            return this.handleError(event.code);
+        };
+        this.shouldCloseAndReconnect = (errorCode) => {
+            var _a, _b;
+            return !!((_b = (_a = this.settingSocket) === null || _a === void 0 ? void 0 : _a.close_and_retry_codes) === null || _b === void 0 ? void 0 : _b.includes(errorCode));
+        };
+        this.genNextReqId = () => {
+            return 'req_' + this.id++;
+        };
+        this.ctx = api.getContext();
+        if (!this.ctx.cookie)
+            throw new Error('Cookie is not available');
+        if (!this.ctx.userAgent)
+            throw new Error('User agent is not available');
+        this.listUrlSocket = api.wsUrls;
+        this.url = this.getSocketUrl(false, true);
+        this.cookie = this.ctx.cookie.getCookieStringSync('https://chat.zalo.me');
+        this.userAgent = this.ctx.userAgent;
+        this.selfListen = this.ctx.options.selfListen;
+        this.settingSocket = this.ctx.settings.features.socket;
+        this.onlineConfigs = this.ctx.settings.features.online_configs;
+        this.retries = this.ctx.settings.features.socket.retries;
+        this._configRetriesRound2();
+        this.ws = null;
+        this.onConnectedCallback = () => { };
+        this.onClosedCallback = () => { };
+        this.onErrorCallback = () => { };
+        this.onMessageCallback = () => { };
+        this.onGroupEventCallback = () => { };
+        this.onMuteCallback = () => { };
+        this.onReactionCallback = () => { };
+        this.onOldMessageCallback = () => { };
+        this.onUndoMessageCallback = () => { };
+        this.onUpdateQueueStatusCallback = () => { };
+        this.onLabelEventCallback = () => { };
+        this.onFriendEventCallback = () => { };
+    }
+    onConnected(cb) {
+        this.onConnectedCallback = cb;
+    }
+    onClosed(cb) {
+        this.onClosedCallback = cb;
+    }
+    onError(cb) {
+        this.onErrorCallback = cb;
+    }
+    onMessage(cb) {
+        this.onMessageCallback = cb;
+    }
+    onOldMessage(cb) {
+        this.onOldMessageCallback = cb;
+    }
+    onGroupEvent(cb) {
+        this.onGroupEventCallback = cb;
+    }
+    onMute(cb) {
+        this.onMuteCallback = cb;
+    }
+    onReaction(cb) {
+        this.onReactionCallback = cb;
+    }
+    onUndo(cb) {
+        this.onUndoMessageCallback = cb;
+    }
+    onUpdateQueueStatus(cb) {
+        this.onUpdateQueueStatusCallback = cb;
+    }
+    onLabelEvent(cb) {
+        this.onLabelEventCallback = cb;
+    }
+    onFriendEvent(cb) {
+        this.onFriendEventCallback = cb;
+    }
+    start() {
+        if (this.ws)
+            throw new ZaloApiError.ZaloApiError('Already started');
+        const ws = new WebSocket(this.url, {
+            headers: {
+                'accept-encoding': 'gzip, deflate, br, zstd',
+                'accept-language': 'en-US,en;q=0.9',
+                'cache-control': 'no-cache',
+                connection: 'Upgrade',
+                host: new URL(this.url).host,
+                origin: 'https://chat.zalo.me',
+                prgama: 'no-cache',
+                'sec-websocket-extensions': 'permessage-deflate; client_max_window_bits',
+                'sec-websocket-version': '13',
+                upgrade: 'websocket',
+                'user-agent': this.userAgent,
+                cookie: this.cookie,
+            },
+        });
+        this.ws = ws;
+        this.configSocket = new configSocket.ConfigSocket(ws, this.ctx.settings.features, this.ctx, this);
+        ws.onopen = () => {
+            this.onConnectedCallback();
+            this.emit('connected');
+        };
+        ws.onclose = this._onClose;
+        ws.onerror = (event) => {
+            // console.log('event error: ', this.ctx.uid, event);
+        };
+        ws.onmessage = async (event) => {
+            var _a, _b, _c;
+            const { data } = event;
+            if (!(data instanceof Buffer))
+                return;
+            const encodedHeader = data.subarray(0, 4);
+            const [version, cmd, subCmd] = getHeader(encodedHeader);
+            try {
+                const dataToDecode = data.subarray(4);
+                const decodedData = new TextDecoder('utf-8').decode(dataToDecode);
+                if (decodedData.length == 0)
+                    return;
+                const parsed = JSON.parse(decodedData);
+                if (cmd === Listen.MessageCommand.Ping) {
+                    if (subCmd === Listen.KeepAliveCommand.KeepConnection || this.onlineConfigs.send_active_to_keep_live) {
+                        if ((_a = this.settingSocket.debug) === null || _a === void 0 ? void 0 : _a.skip_ping) {
+                            return;
+                        }
+                        this.pong(parsed);
+                    }
+                    if (parsed && !isNaN(parsed.status)) {
+                        this.emit(Listen.SocketEvent.ON_PING_ACTIVE_KEEP_ALIVE, parsed);
+                    }
+                }
+                if (version == 1 && cmd == 1 && subCmd == 1 && parsed.hasOwnProperty('key')) {
+                    this.cipherKey = parsed.key;
+                    this.emit('cipher_key', parsed.key);
+                    this.clearPingTimer();
+                    this.createPingTimerServer();
+                    if (this.pingInterval)
+                        clearInterval(this.pingInterval);
+                    this.pingInterval = setInterval(() => {
+                        this.ping();
+                    }, 3 * 60 * 1000);
+                }
+                if (version == 1 && cmd == 501 && subCmd == 0) {
+                    const parsedData = (await utils.decodeEventData(parsed, this.cipherKey)).data;
+                    const { msgs, queueStatus } = parsedData;
+                    const listUndo = [];
+                    const listMessages = [];
+                    for (const msg of msgs) {
+                        if (typeof msg.content == 'object' && msg.content.hasOwnProperty('deleteMsg')) {
+                            const undoObject = new Undo.Undo(this.ctx.uid, msg, false);
+                            if (undoObject.isSelf && !this.selfListen)
+                                continue;
+                            listUndo.push(undoObject);
+                            this.emit('undo', undoObject);
+                        }
+                        else {
+                            const messageObject = new Message.UserMessage(this.ctx.uid, msg, queueStatus);
+                            if (messageObject.isSelf && !this.selfListen)
+                                continue;
+                            listMessages.push(messageObject);
+                            this.emit('message', messageObject);
+                        }
+                    }
+                    const lastMsg = lodash.last(msgs);
+                    const timestamp = lastMsg ? Number(lastMsg.ts) : Date.now();
+                    this.onUndoMessageCallback(listUndo);
+                    this.onMessageCallback(listMessages);
+                    this.onUpdateQueueStatusCallback(queueStatus, timestamp);
+                }
+                if (version == 1 && cmd == 521 && subCmd == 0) {
+                    const parsedData = (await utils.decodeEventData(parsed, this.cipherKey)).data;
+                    const { groupMsgs, queueStatus } = parsedData;
+                    const listUndo = [];
+                    const listMessages = [];
+                    for (const msg of groupMsgs) {
+                        if (typeof msg.content == 'object' && msg.content.hasOwnProperty('deleteMsg')) {
+                            const undoObject = new Undo.Undo(this.ctx.uid, msg, true);
+                            if (undoObject.isSelf && !this.selfListen)
+                                continue;
+                            listUndo.push(undoObject);
+                            this.emit('undo', undoObject);
+                        }
+                        else {
+                            const messageObject = new Message.GroupMessage(this.ctx.uid, msg, queueStatus);
+                            if (messageObject.isSelf && !this.selfListen)
+                                continue;
+                            listMessages.push(messageObject);
+                            this.emit('message', messageObject);
+                        }
+                    }
+                    const lastMsg = lodash.last(groupMsgs);
+                    const timestamp = lastMsg ? Number(lastMsg.ts) : Date.now();
+                    this.onUndoMessageCallback(listUndo);
+                    this.onMessageCallback(listMessages);
+                    this.onUpdateQueueStatusCallback(queueStatus, timestamp);
+                }
+                if ([510, 511, 610, 611, 603, 604].includes(cmd)) {
+                    const parsedData = (await utils.decodeEventData(parsed, this.cipherKey)).data;
+                    this.configSocket.onGotOffline(cmd, subCmd, { data: parsedData });
+                }
+                if (version == 1 && [601, 603, 604].includes(cmd)) {
+                    const parsedData = (await utils.decodeEventData(parsed, this.cipherKey)).data;
+                    const { controls, queueStatus } = parsedData;
+                    const listGroupEvents = [];
+                    const listMuteEvents = [];
+                    const listFriendEvents = [];
+                    let hasLabelEvent = false;
+                    for (const control of controls) {
+                        if (control.content.act_type == 'file_done') {
+                            const data = {
+                                fileUrl: control.content.data.url,
+                                fileId: control.content.fileId,
+                            };
+                            const callbackId = `${this.ctx.uid}_${control.content.fileId}`;
+                            (_c = (_b = this.api).uploadCompleted) === null || _c === void 0 ? void 0 : _c.call(_b, { callbackId, data });
+                            this.emit('upload_attachment', data);
+                        }
+                        else if (control.content.act_type == 'group') {
+                            // 31/08/2024
+                            // for some reason, Zalo send both join and join_reject event when admin approve join requests
+                            // Zalo itself doesn't seem to handle this properly either, so we gonna ignore the join_reject event
+                            if (control.content.act == 'join_reject')
+                                continue;
+                            const groupEventData = typeof control.content.data == 'string' ? JSON.parse(control.content.data) : control.content.data;
+                            const groupEvent = GroupEvent.initializeGroupEvent(this.ctx.uid, groupEventData, utils.getGroupEventType(control.content.act), control.content.act);
+                            const { data } = groupEvent;
+                            if (groupEvent.isSelf && !this.selfListen)
+                                continue;
+                            const timestamp = parseInt(data['time']) || Date.now();
+                            this.onUpdateQueueStatusCallback(queueStatus, timestamp);
+                            listGroupEvents.push(groupEvent);
+                            this.emit('group_event', groupEvent);
+                        }
+                        else if (control.content.act_type == 'fr') {
+                            // 28/02/2025
+                            // Zalo send both req and req_v2 event when user send friend request
+                            // Zalo itself doesn't seem to handle this properly either, so we gonna ignore the req event
+                            if (control.content.act == 'req' || control.content.act == 'seen_fr_req')
+                                continue;
+                            const friendEventData = typeof control.content.data === 'string' && utils.looksLikeJson(control.content.data) ? JSON.parse(control.content.data) : control.content.data;
+                            // Handles the case when act is "pin_create" and params is a string
+                            if (typeof friendEventData == 'object' && 'topic' in friendEventData && typeof friendEventData.topic == 'object' && 'params' in friendEventData.topic) {
+                                friendEventData.topic.params = JSON.parse(`${friendEventData.topic.params}`);
+                            }
+                            const friendEvent = FriendEvent.initializeFriendEvent(this.ctx.uid, friendEventData, utils.getFriendEventType(control.content.act));
+                            if (friendEvent.isSelf && !this.selfListen)
+                                continue;
+                            listFriendEvents.push(friendEvent);
+                        }
+                        else if (control.content.act_type == 'mute') {
+                            const muteData = typeof control.content.data == 'string' && utils.looksLikeJson(control.content.data) ? JSON.parse(control.content.data) : control.content.data;
+                            const { systemTime } = muteData;
+                            listMuteEvents.push({ data: muteData, act: control.content.act });
+                            if (systemTime) {
+                                this.onUpdateQueueStatusCallback(queueStatus, systemTime);
+                            }
+                        }
+                        else if (control.content.act_type == 'label_convers') {
+                            hasLabelEvent = true;
+                        }
+                    }
+                    this.onGroupEventCallback(listGroupEvents);
+                    this.onMuteCallback(listMuteEvents);
+                    this.onFriendEventCallback(listFriendEvents);
+                    if (hasLabelEvent) {
+                        this.onLabelEventCallback();
+                    }
+                }
+                if ([610, 611, 612].includes(cmd)) {
+                    const parsedData = (await utils.decodeEventData(parsed, this.cipherKey)).data;
+                    const { reacts, reactGroups, queueStatus } = parsedData;
+                    const listReactions = [];
+                    for (const react of reacts) {
+                        react.content = JSON.parse(react.content);
+                        const reactionObject = new Reaction.Reaction(this.ctx.uid, react, false);
+                        if (reactionObject.isSelf && !this.selfListen)
+                            continue;
+                        listReactions.push(reactionObject);
+                        this.emit('reaction', reactionObject);
+                    }
+                    for (const reactGroup of reactGroups) {
+                        reactGroup.content = JSON.parse(reactGroup.content);
+                        const reactionObject = new Reaction.Reaction(this.ctx.uid, reactGroup, true);
+                        if (reactionObject.isSelf && !this.selfListen)
+                            continue;
+                        listReactions.push(reactionObject);
+                        this.emit('reaction', reactionObject);
+                    }
+                    const lastMsg = reacts.length > 0 ? lodash.last(reacts) : reactGroups.length > 0 ? lodash.last(reactGroups) : null;
+                    const timestamp = lastMsg ? Number(lastMsg.ts) : Date.now();
+                    this.onReactionCallback(listReactions);
+                    this.onUpdateQueueStatusCallback(queueStatus, timestamp);
+                }
+                if (cmd == 510) {
+                    const parsedData = (await utils.decodeEventData(parsed, this.cipherKey)).data;
+                    const { msgs, queueStatus } = parsedData;
+                    const responseUndos = [];
+                    const responseMsgs = [];
+                    msgs.forEach((msg) => {
+                        if (typeof msg.content == 'object' && msg.content.hasOwnProperty('deleteMsg')) {
+                            const undoObject = new Undo.Undo(this.ctx.uid, msg, false);
+                            responseUndos.push(undoObject);
+                        }
+                        else {
+                            const messageObject = new Message.UserMessage(this.ctx.uid, msg, queueStatus);
+                            responseMsgs.push(messageObject);
+                        }
+                    });
+                    const lastMsg = lodash.last(msgs);
+                    const timestamp = lastMsg ? Number(lastMsg.ts) : Date.now();
+                    this.onUpdateQueueStatusCallback(queueStatus, timestamp);
+                    this.onOldMessageCallback(responseMsgs);
+                    this.onUndoMessageCallback(responseUndos);
+                    this.emit('old_messages', responseMsgs);
+                }
+                if (cmd == 511) {
+                    const parsedData = (await utils.decodeEventData(parsed, this.cipherKey)).data;
+                    const { groupMsgs, queueStatus } = parsedData;
+                    const responseUndos = [];
+                    const responseMsgs = [];
+                    for (const msg of groupMsgs) {
+                        if (typeof msg.content == 'object' && msg.content.hasOwnProperty('deleteMsg')) {
+                            const undoObject = new Undo.Undo(this.ctx.uid, msg, true);
+                            responseUndos.push(undoObject);
+                        }
+                        else {
+                            const messageObject = new Message.GroupMessage(this.ctx.uid, msg, queueStatus);
+                            responseMsgs.push(messageObject);
+                        }
+                    }
+                    const lastMsg = lodash.last(groupMsgs);
+                    const timestamp = lastMsg ? Number(lastMsg.ts) : Date.now();
+                    this.onUpdateQueueStatusCallback(queueStatus, timestamp);
+                    this.onOldMessageCallback(responseMsgs);
+                    this.onUndoMessageCallback(responseUndos);
+                    this.emit('old_messages', responseMsgs);
+                }
+                if (cmd == 518) {
+                    const parsedData = (await utils.decodeEventData(parsed, this.cipherKey)).data;
+                    const { msgs, groupMsgs, queueStatus } = parsedData;
+                    const parseMsgs = msgs.map((msg) => new Message.UserMessage(this.ctx.uid, msg, queueStatus));
+                    const parseGroupMsgs = groupMsgs.map((msg) => new Message.GroupMessage(this.ctx.uid, msg, queueStatus));
+                    const listMessage = [...parseMsgs, ...parseGroupMsgs];
+                    const lastMsg = lodash.last(listMessage);
+                    const timestamp = lastMsg ? Number(lastMsg.ts) : Date.now();
+                    this.onUpdateQueueStatusCallback(queueStatus, timestamp);
+                    this.onOldMessageCallback(listMessage);
+                    this.emit('old_messages', listMessage);
+                }
+                if (cmd == 602 && subCmd == 0) {
+                    const parsedData = (await utils.decodeEventData(parsed, this.cipherKey)).data;
+                    const { actions } = parsedData;
+                    for (const action of actions) {
+                        const data = JSON.parse(`{${action.data}}`);
+                        if (action.act_type == 'typing') {
+                            if (action.act == 'typing') {
+                                const typingObject = new Typing.UserTyping(data);
+                                this.emit('typing', typingObject);
+                            }
+                            else if (action.act == 'gtyping') {
+                                // 26/02/2025
+                                // For a group with only two people, Zalo doesn't send a typing event.
+                                const typingObject = new Typing.GroupTyping(data);
+                                this.emit('typing', typingObject);
+                            }
+                        }
+                    }
+                }
+                if (cmd == 502 && subCmd == 0) {
+                    const parsedData = (await utils.decodeEventData(parsed, this.cipherKey)).data;
+                    const { delivereds: deliveredMsgs, seens: seenMsgs } = parsedData;
+                    if (Array.isArray(deliveredMsgs) && deliveredMsgs.length > 0) {
+                        const deliveredObjects = deliveredMsgs.map((delivered) => new DeliveredMessage.UserDeliveredMessage(delivered));
+                        this.emit('delivered_messages', deliveredObjects);
+                    }
+                    if (Array.isArray(seenMsgs) && seenMsgs.length > 0) {
+                        const seenObjects = seenMsgs.map((seen) => new SeenMessage.UserSeenMessage(seen));
+                        this.emit('seen_messages', seenObjects);
+                    }
+                }
+                if (cmd == 522 && subCmd == 0) {
+                    const parsedData = (await utils.decodeEventData(parsed, this.cipherKey)).data;
+                    const { delivereds: deliveredMsgs, groupSeens: groupSeenMsgs } = parsedData;
+                    if (Array.isArray(deliveredMsgs) && deliveredMsgs.length > 0) {
+                        let deliveredObjects = deliveredMsgs.map((delivered) => new DeliveredMessage.GroupDeliveredMessage(this.ctx.uid, delivered));
+                        if (!this.selfListen)
+                            deliveredObjects = deliveredObjects.filter((delivered) => !delivered.isSelf);
+                        this.emit('delivered_messages', deliveredObjects);
+                    }
+                    if (Array.isArray(groupSeenMsgs) && groupSeenMsgs.length > 0) {
+                        let seenObjects = groupSeenMsgs.map((seen) => new SeenMessage.GroupSeenMessage(this.ctx.uid, seen));
+                        if (!this.selfListen)
+                            seenObjects = seenObjects.filter((seen) => !seen.isSelf);
+                        this.emit('seen_messages', seenObjects);
+                    }
+                }
+                if (version == 1 && cmd == 3000 && subCmd == 0) {
+                    console.log();
+                    utils.logger(this.ctx).error('Another connection is opened, closing this one');
+                    console.log();
+                    if (ws.readyState !== WebSocket.CLOSED)
+                        ws.close(Listen.CloseReason.NotAuthenticated);
+                }
+            }
+            catch (error) {
+                this.onErrorCallback(error);
+            }
+        };
+    }
+    stop() {
+        if (this.ws) {
+            this.ws.close(Listen.CloseReason.NormalClosure);
+            this.reset();
+        }
+    }
+    getSocketUrl(shouldRotate = false, forceFirstEndpoint = false) {
+        if (!this.listUrlSocket.length)
+            return '';
+        let index = 0;
+        if (shouldRotate) {
+            index = (this.rotateCount + 1) % this.listUrlSocket.length;
+        }
+        if (forceFirstEndpoint) {
+            index = 0;
+        }
+        return utils.makeURL(this.ctx, this.listUrlSocket[index], { t: Date.now() });
+    }
+    sendWs(payload, requireId = true) {
+        if (this.ws && this.getSocketState() === WebSocket.OPEN) {
+            if (requireId)
+                payload.data['req_id'] = `req_${this.id++}`;
+            const encodedData = new TextEncoder().encode(JSON.stringify(payload.data));
+            const dataLength = encodedData.length;
+            const data = new DataView(Buffer.alloc(4 + dataLength).buffer);
+            data.setUint8(0, payload.version);
+            data.setInt32(1, payload.cmd, true);
+            data.setInt8(3, payload.subCmd);
+            encodedData.forEach((e, i) => {
+                data.setUint8(4 + i, e);
+            });
+            this.ws.send(data);
+        }
+    }
+    shouldPingHttp() {
+        var _a;
+        const pingHttpLevel = ((_a = this.settingSocket) === null || _a === void 0 ? void 0 : _a.ping_http_level) || 0;
+        if (pingHttpLevel === 1) {
+            return Object.values(this.pingHttp).length === 0;
+        }
+        if (pingHttpLevel === 2) {
+            return !this.pingHttp[this.url];
+        }
+        return false;
+    }
+    ping(shouldTimeout = true) {
+        const currentTimestamp = Date.now();
+        const isPingAvailable = !this.pingTimer && this.getSocketState() === WebSocket.OPEN;
+        if (!isPingAvailable)
+            return;
+        this.sendWs({
+            version: 1,
+            cmd: Listen.MessageCommand.Ping,
+            subCmd: Listen.KeepAliveCommand.KeepConnection,
+            data: { eventId: currentTimestamp },
+        }, false);
+        if (shouldTimeout) {
+            this.pingTimer = setTimeout(() => {
+                if (!(!this.ws || this.getSocketState() === WebSocket.CLOSED)) {
+                    this.handleError(Listen.ConnectionErrorCode.PingTimeout);
+                }
+                this.pingTimer = null;
+            }, 5000);
+        }
+        this.lastPing = currentTimestamp;
+    }
+    pingActive() {
+        this.sendWs({
+            version: 1,
+            cmd: Listen.MessageCommand.PingActive,
+            subCmd: Listen.KeepAliveCommand.KeepConnection,
+            data: { at: 2, reqId: 'cmd_4' },
+        });
+    }
+    pong(data) {
+        if (data.eventId === this.lastPing && this.pingTimer) {
+            this._resetCountRetry([Listen.ConnectionErrorCode.PingTimeout, Listen.ConnectionErrorCode.PingPong]);
+            clearTimeout(this.pingTimer);
+            this.pingTimer = null;
+            this.lastPong = Date.now();
+        }
+    }
+    handleError(errorCode) {
+        console.log('socket got error', errorCode, this.ctx.uid);
+        if (this.shouldCloseAndReconnect(errorCode)) {
+            this.retryAfterClose = errorCode;
+            this.close(Listen.CloseReason.NormalClosure);
+            return;
+        }
+        switch (errorCode) {
+            case Listen.CloseReason.NotFoundWorker:
+                this.retry(Listen.CloseReason.NotFoundWorker);
+                break;
+            case Listen.ConnectionErrorCode.InvalidConfig:
+                this.stopRetry(Listen.ConnectionErrorCode.InvalidConfig);
+                break;
+            case Listen.ConnectionErrorCode.EstablishTimeout:
+                this.retryAfterClose = Listen.ConnectionErrorCode.EstablishTimeout;
+                this.close(Listen.CloseReason.NormalClosure);
+                break;
+            case Listen.ConnectionErrorCode.PingTimeout:
+                const retryDelay = this._nextRetry(Listen.ConnectionErrorCode.PingPong);
+                if (retryDelay == null) {
+                    this.retryAfterClose = Listen.ConnectionErrorCode.PingTimeout;
+                    this.close(Listen.CloseReason.NormalClosure);
+                }
+                else {
+                    setTimeout(() => {
+                        this.ping();
+                    }, retryDelay);
+                }
+                break;
+            default:
+                console.log('Unhandled error code', errorCode);
+                break;
+        }
+    }
+    getSocketState() {
+        return this.ws ? this.ws.readyState : -1;
+    }
+    reset() {
+        if (this.ws) {
+            this.ws.removeEventListener('error', (event) => { });
+            this.ws.removeEventListener('open', (event) => { });
+            this.ws.removeEventListener('message', (event) => { });
+            this.ws.removeEventListener('close', (event) => { });
+            this.ws.close();
+            this.ws = null;
+        }
+        this.cipherKey = undefined;
+        if (this.pingInterval)
+            clearInterval(this.pingInterval);
+    }
+    afterClose() {
+        this.reset();
+        if (this.retryAfterClose) {
+            this.retry(this.retryAfterClose);
+            this.retryAfterClose = undefined;
+        }
+    }
+    isEnableCloseTimeout() {
+        return this.settingSocket && (this.settingSocket.close_timeout || 0) > 0;
+    }
+    close(code = Listen.CloseReason.NormalClosure) {
+        var _a;
+        if (this.isEnableCloseTimeout()) {
+            return this.closeV2();
+        }
+        if (!this.ws) {
+            this.afterClose();
+            return;
+        }
+        const socketState = this.getSocketState();
+        if (socketState === WebSocket.OPEN || socketState === WebSocket.CONNECTING) {
+            (_a = this.ws) === null || _a === void 0 ? void 0 : _a.close(code);
+        }
+        else {
+            this.afterClose();
+        }
+    }
+    closeV2(code = Listen.CloseReason.NormalClosure) {
+        if (!this.ws) {
+            this.reset();
+            return this.afterClose();
+        }
+        if (this.getSocketState() === WebSocket.CLOSED) {
+            return this.afterClose();
+        }
+        if (!this.closeTimer) {
+            const socketRef = this.ws;
+            this.closeTimer = setTimeout(() => {
+                this.closeTimer = null;
+                this._onClose({ code: code, target: socketRef });
+            }, this.settingSocket.close_timeout);
+        }
+        this.ws.close(code);
+    }
+    shouldRetry() {
+        if (this.retryTimer) {
+            return false;
+        }
+        if (this.processingRetry) {
+            return false;
+        }
+        return true;
+    }
+    _nextRetry(errorCode) {
+        var _a;
+        if (errorCode == null) {
+            return Listen.DEFAULT_RETRY_DELAYS[Listen.DEFAULT_RETRY_DELAYS.length - 1];
+        }
+        const retryConfig = this.retries[errorCode];
+        if (retryConfig) {
+            let { times, count, max } = retryConfig;
+            if (max != null && count >= max) {
+                return null;
+            }
+            this.retries[errorCode].count = ((_a = this.retries[errorCode].count) !== null && _a !== void 0 ? _a : 0) + 1;
+            if (typeof times === 'number') {
+                return times;
+            }
+            if (!Array.isArray(times)) {
+                times = Listen.DEFAULT_RETRY_DELAYS;
+            }
+            return count < times.length ? times[count] : times[times.length - 1];
+        }
+        return Listen.DEFAULT_RETRY_DELAYS[Listen.DEFAULT_RETRY_DELAYS.length - 1];
+    }
+    shouldRotateEndPoint(errorCode) {
+        var _a;
+        const totalEndpoints = this.listUrlSocket.length;
+        const rotateErrorCodes = ((_a = this.settingSocket) === null || _a === void 0 ? void 0 : _a.rotate_error_codes) || [];
+        const shouldRotate = rotateErrorCodes.includes(errorCode) || rotateErrorCodes.includes(String(errorCode));
+        if (!shouldRotate) {
+            return false;
+        }
+        if (this.rotateCount < totalEndpoints - 1) {
+            this.rotateCount++;
+            return true;
+        }
+        return false;
+    }
+    rotateEndpoint() {
+        var _a, _b;
+        const newEndpoint = this.getSocketUrl(true);
+        this.url = newEndpoint;
+        const shouldResetEndpoint = (_a = this.settingSocket) === null || _a === void 0 ? void 0 : _a.reset_endpoint;
+        if (shouldResetEndpoint && !this.resetEndPointTime) {
+            this.resetEndPointTime = setTimeout(() => {
+                const originEndpoint = this.getSocketUrl(false, true);
+                this.url = originEndpoint;
+                this.handleError(Listen.NetworkErrorCode.SwapEndpointNum);
+                this.rotateCount = 0;
+                this.resetEndPointTime = null;
+            }, (_b = this.settingSocket) === null || _b === void 0 ? void 0 : _b.reset_endpoint);
+        }
+    }
+    _resetCountRetry(retryKeys) {
+        if (!retryKeys)
+            return;
+        retryKeys.forEach((key) => {
+            if (this.retries[key]) {
+                this.retries[key].count = 0;
+            }
+            if (this.retriesRound2[key]) {
+                this.retriesRound2[key].count = 0;
+            }
+        });
+    }
+    stopRetry(errorCode) {
+        var _a;
+        if ((_a = this.settingSocket) === null || _a === void 0 ? void 0 : _a.enable_fallback_lp) {
+            this.retries = {};
+            this.close();
+        }
+    }
+    retry(e) {
+        var _a;
+        if ((_a = this.settingSocket) === null || _a === void 0 ? void 0 : _a.disable_lp) {
+            this._retryV2(e);
+            return;
+        }
+        if (!this.shouldRetry())
+            return;
+        let retryDelay = this._nextRetry(e);
+        if (retryDelay == null && this.shouldRotateEndPoint(e)) {
+            this.rotateEndpoint();
+            this._resetCountRetry([e]);
+            retryDelay = this._nextRetry(e);
+        }
+        if (retryDelay == null) {
+            this.stopRetry(e);
+            return;
+        }
+        this.retryTimer = setTimeout(() => {
+            this.reset();
+            this.start();
+            this.retryTimer = null;
+        }, retryDelay);
+    }
+    getRetriesRound2Key(errorCode) {
+        let retryKey = errorCode;
+        if (!retryKey || !this.retriesRound2[retryKey]) {
+            retryKey = 'default';
+        }
+        return retryKey;
+    }
+    nextRetryRound2(errorCode) {
+        var _a, _b;
+        const t = this.getRetriesRound2Key(errorCode);
+        this.retriesRound2[t].count = ((_b = (_a = this.retriesRound2[t]) === null || _a === void 0 ? void 0 : _a.count) !== null && _b !== void 0 ? _b : 0) + 1;
+        const { multiple: a, count: n, max: s } = this.retriesRound2[t];
+        return this.fibonacciRetry.getNextRetry(n, a, s);
+    }
+    isRound2NotStartYet(errorCode) {
+        const retryRound2Key = this.getRetriesRound2Key(errorCode);
+        const retryInfo = this.retriesRound2[retryRound2Key];
+        return !retryInfo || retryInfo.count === 0;
+    }
+    _retryV2(errorCode) {
+        if (!this.shouldRetry())
+            return;
+        this.processingRetry = true;
+        let retryDelayMs = this._nextRetry(errorCode);
+        if (retryDelayMs == null && this.shouldRotateEndPoint(errorCode)) {
+            this.rotateEndpoint();
+            if (this.isRound2NotStartYet(errorCode)) {
+                this._resetCountRetry([errorCode]);
+                retryDelayMs = this._nextRetry(errorCode);
+            }
+        }
+        const scheduleRetryCallback = () => {
+            this.retryTimer = setTimeout(() => {
+                this.reset();
+                this.start();
+                this.retryTimer = null;
+            }, retryDelayMs || 0);
+        };
+        if (retryDelayMs == null) {
+            {
+                this.stopRetry(errorCode);
+            }
+        }
+        else {
+            scheduleRetryCallback();
+        }
+        this.processingRetry = false;
+    }
+    _configRetriesRound2() {
+        const retriesConfig = this.settingSocket.retries_round_2;
+        if (typeof retriesConfig !== 'object' || retriesConfig === null) {
+            return;
+        }
+        console.log('retriesConfig: ', this.ctx.uid, retriesConfig);
+        Object.entries(retriesConfig).forEach(([key, config]) => {
+            const { multiple, max } = config;
+            if (typeof multiple === 'number') {
+                this.retriesRound2[key] = {
+                    multiple,
+                    count: 0,
+                    max,
+                };
+            }
+        });
+    }
+    createPingTimerServer() {
+        if (this.pingTimerToServer || !this.onlineConfigs.enable_active_deactive_v2)
+            return;
+        this.configChanged = false;
+        this.pingTimerToServer = setInterval(() => {
+            this.pingActive();
+            if (this.configChanged) {
+                this.clearPingTimer();
+                this.createPingTimerServer();
+            }
+        }, this.onlineConfigs.update_action_interval);
+    }
+    clearPingTimer() {
+        clearInterval(this.pingTimerToServer);
+        this.pingTimerToServer = null;
+    }
+}
+function getHeader(buffer) {
+    if (buffer.byteLength < 4) {
+        throw new Error('Invalid header');
+    }
+    return [buffer[0], buffer.readUInt16LE(1), buffer[3]];
+}
+
+exports.Listener = Listener;