@wabot-dev/framework 0.0.14 → 0.0.17

package/dist/src/node_modules/socket.io-adapter/dist/cluster-adapter.js

@@ -1,689 +0,0 @@
-import { __exports as clusterAdapter } from '../../../_virtual/cluster-adapter.js';
-import { __require as requireInMemoryAdapter } from './in-memory-adapter.js';
-import { __require as requireSrc } from '../node_modules/debug/src/index.js';
-import require$$1 from 'crypto';
-
-var hasRequiredClusterAdapter;
-
-function requireClusterAdapter () {
-	if (hasRequiredClusterAdapter) return clusterAdapter;
-	hasRequiredClusterAdapter = 1;
-	(function (exports) {
-		var __rest = (clusterAdapter && clusterAdapter.__rest) || function (s, e) {
-		    var t = {};
-		    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-		        t[p] = s[p];
-		    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-		        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-		            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-		                t[p[i]] = s[p[i]];
-		        }
-		    return t;
-		};
-		Object.defineProperty(exports, "__esModule", { value: true });
-		exports.ClusterAdapterWithHeartbeat = exports.ClusterAdapter = exports.MessageType = void 0;
-		const in_memory_adapter_1 = requireInMemoryAdapter();
-		const debug_1 = requireSrc();
-		const crypto_1 = require$$1;
-		const debug = (0, debug_1.debug)("socket.io-adapter");
-		const EMITTER_UID = "emitter";
-		const DEFAULT_TIMEOUT = 5000;
-		function randomId() {
-		    return (0, crypto_1.randomBytes)(8).toString("hex");
-		}
-		var MessageType;
-		(function (MessageType) {
-		    MessageType[MessageType["INITIAL_HEARTBEAT"] = 1] = "INITIAL_HEARTBEAT";
-		    MessageType[MessageType["HEARTBEAT"] = 2] = "HEARTBEAT";
-		    MessageType[MessageType["BROADCAST"] = 3] = "BROADCAST";
-		    MessageType[MessageType["SOCKETS_JOIN"] = 4] = "SOCKETS_JOIN";
-		    MessageType[MessageType["SOCKETS_LEAVE"] = 5] = "SOCKETS_LEAVE";
-		    MessageType[MessageType["DISCONNECT_SOCKETS"] = 6] = "DISCONNECT_SOCKETS";
-		    MessageType[MessageType["FETCH_SOCKETS"] = 7] = "FETCH_SOCKETS";
-		    MessageType[MessageType["FETCH_SOCKETS_RESPONSE"] = 8] = "FETCH_SOCKETS_RESPONSE";
-		    MessageType[MessageType["SERVER_SIDE_EMIT"] = 9] = "SERVER_SIDE_EMIT";
-		    MessageType[MessageType["SERVER_SIDE_EMIT_RESPONSE"] = 10] = "SERVER_SIDE_EMIT_RESPONSE";
-		    MessageType[MessageType["BROADCAST_CLIENT_COUNT"] = 11] = "BROADCAST_CLIENT_COUNT";
-		    MessageType[MessageType["BROADCAST_ACK"] = 12] = "BROADCAST_ACK";
-		    MessageType[MessageType["ADAPTER_CLOSE"] = 13] = "ADAPTER_CLOSE";
-		})(MessageType = exports.MessageType || (exports.MessageType = {}));
-		function encodeOptions(opts) {
-		    return {
-		        rooms: [...opts.rooms],
-		        except: [...opts.except],
-		        flags: opts.flags,
-		    };
-		}
-		function decodeOptions(opts) {
-		    return {
-		        rooms: new Set(opts.rooms),
-		        except: new Set(opts.except),
-		        flags: opts.flags,
-		    };
-		}
-		/**
-		 * A cluster-ready adapter. Any extending class must:
-		 *
-		 * - implement {@link ClusterAdapter#doPublish} and {@link ClusterAdapter#doPublishResponse}
-		 * - call {@link ClusterAdapter#onMessage} and {@link ClusterAdapter#onResponse}
-		 */
-		class ClusterAdapter extends in_memory_adapter_1.Adapter {
-		    constructor(nsp) {
-		        super(nsp);
-		        this.requests = new Map();
-		        this.ackRequests = new Map();
-		        this.uid = randomId();
-		    }
-		    /**
-		     * Called when receiving a message from another member of the cluster.
-		     *
-		     * @param message
-		     * @param offset
-		     * @protected
-		     */
-		    onMessage(message, offset) {
-		        if (message.uid === this.uid) {
-		            return debug("[%s] ignore message from self", this.uid);
-		        }
-		        debug("[%s] new event of type %d from %s", this.uid, message.type, message.uid);
-		        switch (message.type) {
-		            case MessageType.BROADCAST: {
-		                const withAck = message.data.requestId !== undefined;
-		                if (withAck) {
-		                    super.broadcastWithAck(message.data.packet, decodeOptions(message.data.opts), (clientCount) => {
-		                        debug("[%s] waiting for %d client acknowledgements", this.uid, clientCount);
-		                        this.publishResponse(message.uid, {
-		                            type: MessageType.BROADCAST_CLIENT_COUNT,
-		                            data: {
-		                                requestId: message.data.requestId,
-		                                clientCount,
-		                            },
-		                        });
-		                    }, (arg) => {
-		                        debug("[%s] received acknowledgement with value %j", this.uid, arg);
-		                        this.publishResponse(message.uid, {
-		                            type: MessageType.BROADCAST_ACK,
-		                            data: {
-		                                requestId: message.data.requestId,
-		                                packet: arg,
-		                            },
-		                        });
-		                    });
-		                }
-		                else {
-		                    const packet = message.data.packet;
-		                    const opts = decodeOptions(message.data.opts);
-		                    this.addOffsetIfNecessary(packet, opts, offset);
-		                    super.broadcast(packet, opts);
-		                }
-		                break;
-		            }
-		            case MessageType.SOCKETS_JOIN:
-		                super.addSockets(decodeOptions(message.data.opts), message.data.rooms);
-		                break;
-		            case MessageType.SOCKETS_LEAVE:
-		                super.delSockets(decodeOptions(message.data.opts), message.data.rooms);
-		                break;
-		            case MessageType.DISCONNECT_SOCKETS:
-		                super.disconnectSockets(decodeOptions(message.data.opts), message.data.close);
-		                break;
-		            case MessageType.FETCH_SOCKETS: {
-		                debug("[%s] calling fetchSockets with opts %j", this.uid, message.data.opts);
-		                super
-		                    .fetchSockets(decodeOptions(message.data.opts))
-		                    .then((localSockets) => {
-		                    this.publishResponse(message.uid, {
-		                        type: MessageType.FETCH_SOCKETS_RESPONSE,
-		                        data: {
-		                            requestId: message.data.requestId,
-		                            sockets: localSockets.map((socket) => {
-		                                // remove sessionStore from handshake, as it may contain circular references
-		                                const _a = socket.handshake, { sessionStore } = _a, handshake = __rest(_a, ["sessionStore"]);
-		                                return {
-		                                    id: socket.id,
-		                                    handshake,
-		                                    rooms: [...socket.rooms],
-		                                    data: socket.data,
-		                                };
-		                            }),
-		                        },
-		                    });
-		                });
-		                break;
-		            }
-		            case MessageType.SERVER_SIDE_EMIT: {
-		                const packet = message.data.packet;
-		                const withAck = message.data.requestId !== undefined;
-		                if (!withAck) {
-		                    this.nsp._onServerSideEmit(packet);
-		                    return;
-		                }
-		                let called = false;
-		                const callback = (arg) => {
-		                    // only one argument is expected
-		                    if (called) {
-		                        return;
-		                    }
-		                    called = true;
-		                    debug("[%s] calling acknowledgement with %j", this.uid, arg);
-		                    this.publishResponse(message.uid, {
-		                        type: MessageType.SERVER_SIDE_EMIT_RESPONSE,
-		                        data: {
-		                            requestId: message.data.requestId,
-		                            packet: arg,
-		                        },
-		                    });
-		                };
-		                this.nsp._onServerSideEmit([...packet, callback]);
-		                break;
-		            }
-		            // @ts-ignore
-		            case MessageType.BROADCAST_CLIENT_COUNT:
-		            // @ts-ignore
-		            case MessageType.BROADCAST_ACK:
-		            // @ts-ignore
-		            case MessageType.FETCH_SOCKETS_RESPONSE:
-		            // @ts-ignore
-		            case MessageType.SERVER_SIDE_EMIT_RESPONSE:
-		                // extending classes may not make a distinction between a ClusterMessage and a ClusterResponse payload and may
-		                // always call the onMessage() method
-		                this.onResponse(message);
-		                break;
-		            default:
-		                debug("[%s] unknown message type: %s", this.uid, message.type);
-		        }
-		    }
-		    /**
-		     * Called when receiving a response from another member of the cluster.
-		     *
-		     * @param response
-		     * @protected
-		     */
-		    onResponse(response) {
-		        var _a, _b;
-		        const requestId = response.data.requestId;
-		        debug("[%s] received response %s to request %s", this.uid, response.type, requestId);
-		        switch (response.type) {
-		            case MessageType.BROADCAST_CLIENT_COUNT: {
-		                (_a = this.ackRequests
-		                    .get(requestId)) === null || _a === void 0 ? void 0 : _a.clientCountCallback(response.data.clientCount);
-		                break;
-		            }
-		            case MessageType.BROADCAST_ACK: {
-		                (_b = this.ackRequests.get(requestId)) === null || _b === void 0 ? void 0 : _b.ack(response.data.packet);
-		                break;
-		            }
-		            case MessageType.FETCH_SOCKETS_RESPONSE: {
-		                const request = this.requests.get(requestId);
-		                if (!request) {
-		                    return;
-		                }
-		                request.current++;
-		                response.data.sockets.forEach((socket) => request.responses.push(socket));
-		                if (request.current === request.expected) {
-		                    clearTimeout(request.timeout);
-		                    request.resolve(request.responses);
-		                    this.requests.delete(requestId);
-		                }
-		                break;
-		            }
-		            case MessageType.SERVER_SIDE_EMIT_RESPONSE: {
-		                const request = this.requests.get(requestId);
-		                if (!request) {
-		                    return;
-		                }
-		                request.current++;
-		                request.responses.push(response.data.packet);
-		                if (request.current === request.expected) {
-		                    clearTimeout(request.timeout);
-		                    request.resolve(null, request.responses);
-		                    this.requests.delete(requestId);
-		                }
-		                break;
-		            }
-		            default:
-		                // @ts-ignore
-		                debug("[%s] unknown response type: %s", this.uid, response.type);
-		        }
-		    }
-		    async broadcast(packet, opts) {
-		        var _a;
-		        const onlyLocal = (_a = opts.flags) === null || _a === void 0 ? void 0 : _a.local;
-		        if (!onlyLocal) {
-		            try {
-		                const offset = await this.publishAndReturnOffset({
-		                    type: MessageType.BROADCAST,
-		                    data: {
-		                        packet,
-		                        opts: encodeOptions(opts),
-		                    },
-		                });
-		                this.addOffsetIfNecessary(packet, opts, offset);
-		            }
-		            catch (e) {
-		                return debug("[%s] error while broadcasting message: %s", this.uid, e.message);
-		            }
-		        }
-		        super.broadcast(packet, opts);
-		    }
-		    /**
-		     * Adds an offset at the end of the data array in order to allow the client to receive any missed packets when it
-		     * reconnects after a temporary disconnection.
-		     *
-		     * @param packet
-		     * @param opts
-		     * @param offset
-		     * @private
-		     */
-		    addOffsetIfNecessary(packet, opts, offset) {
-		        var _a;
-		        if (!this.nsp.server.opts.connectionStateRecovery) {
-		            return;
-		        }
-		        const isEventPacket = packet.type === 2;
-		        // packets with acknowledgement are not stored because the acknowledgement function cannot be serialized and
-		        // restored on another server upon reconnection
-		        const withoutAcknowledgement = packet.id === undefined;
-		        const notVolatile = ((_a = opts.flags) === null || _a === void 0 ? void 0 : _a.volatile) === undefined;
-		        if (isEventPacket && withoutAcknowledgement && notVolatile) {
-		            packet.data.push(offset);
-		        }
-		    }
-		    broadcastWithAck(packet, opts, clientCountCallback, ack) {
-		        var _a;
-		        const onlyLocal = (_a = opts === null || opts === void 0 ? void 0 : opts.flags) === null || _a === void 0 ? void 0 : _a.local;
-		        if (!onlyLocal) {
-		            const requestId = randomId();
-		            this.ackRequests.set(requestId, {
-		                clientCountCallback,
-		                ack,
-		            });
-		            this.publish({
-		                type: MessageType.BROADCAST,
-		                data: {
-		                    packet,
-		                    requestId,
-		                    opts: encodeOptions(opts),
-		                },
-		            });
-		            // we have no way to know at this level whether the server has received an acknowledgement from each client, so we
-		            // will simply clean up the ackRequests map after the given delay
-		            setTimeout(() => {
-		                this.ackRequests.delete(requestId);
-		            }, opts.flags.timeout);
-		        }
-		        super.broadcastWithAck(packet, opts, clientCountCallback, ack);
-		    }
-		    async addSockets(opts, rooms) {
-		        var _a;
-		        const onlyLocal = (_a = opts.flags) === null || _a === void 0 ? void 0 : _a.local;
-		        if (!onlyLocal) {
-		            try {
-		                await this.publishAndReturnOffset({
-		                    type: MessageType.SOCKETS_JOIN,
-		                    data: {
-		                        opts: encodeOptions(opts),
-		                        rooms,
-		                    },
-		                });
-		            }
-		            catch (e) {
-		                debug("[%s] error while publishing message: %s", this.uid, e.message);
-		            }
-		        }
-		        super.addSockets(opts, rooms);
-		    }
-		    async delSockets(opts, rooms) {
-		        var _a;
-		        const onlyLocal = (_a = opts.flags) === null || _a === void 0 ? void 0 : _a.local;
-		        if (!onlyLocal) {
-		            try {
-		                await this.publishAndReturnOffset({
-		                    type: MessageType.SOCKETS_LEAVE,
-		                    data: {
-		                        opts: encodeOptions(opts),
-		                        rooms,
-		                    },
-		                });
-		            }
-		            catch (e) {
-		                debug("[%s] error while publishing message: %s", this.uid, e.message);
-		            }
-		        }
-		        super.delSockets(opts, rooms);
-		    }
-		    async disconnectSockets(opts, close) {
-		        var _a;
-		        const onlyLocal = (_a = opts.flags) === null || _a === void 0 ? void 0 : _a.local;
-		        if (!onlyLocal) {
-		            try {
-		                await this.publishAndReturnOffset({
-		                    type: MessageType.DISCONNECT_SOCKETS,
-		                    data: {
-		                        opts: encodeOptions(opts),
-		                        close,
-		                    },
-		                });
-		            }
-		            catch (e) {
-		                debug("[%s] error while publishing message: %s", this.uid, e.message);
-		            }
-		        }
-		        super.disconnectSockets(opts, close);
-		    }
-		    async fetchSockets(opts) {
-		        var _a;
-		        const [localSockets, serverCount] = await Promise.all([
-		            super.fetchSockets(opts),
-		            this.serverCount(),
-		        ]);
-		        const expectedResponseCount = serverCount - 1;
-		        if (((_a = opts.flags) === null || _a === void 0 ? void 0 : _a.local) || expectedResponseCount <= 0) {
-		            return localSockets;
-		        }
-		        const requestId = randomId();
-		        return new Promise((resolve, reject) => {
-		            const timeout = setTimeout(() => {
-		                const storedRequest = this.requests.get(requestId);
-		                if (storedRequest) {
-		                    reject(new Error(`timeout reached: only ${storedRequest.current} responses received out of ${storedRequest.expected}`));
-		                    this.requests.delete(requestId);
-		                }
-		            }, opts.flags.timeout || DEFAULT_TIMEOUT);
-		            const storedRequest = {
-		                type: MessageType.FETCH_SOCKETS,
-		                resolve,
-		                timeout,
-		                current: 0,
-		                expected: expectedResponseCount,
-		                responses: localSockets,
-		            };
-		            this.requests.set(requestId, storedRequest);
-		            this.publish({
-		                type: MessageType.FETCH_SOCKETS,
-		                data: {
-		                    opts: encodeOptions(opts),
-		                    requestId,
-		                },
-		            });
-		        });
-		    }
-		    async serverSideEmit(packet) {
-		        const withAck = typeof packet[packet.length - 1] === "function";
-		        if (!withAck) {
-		            return this.publish({
-		                type: MessageType.SERVER_SIDE_EMIT,
-		                data: {
-		                    packet,
-		                },
-		            });
-		        }
-		        const ack = packet.pop();
-		        const expectedResponseCount = (await this.serverCount()) - 1;
-		        debug('[%s] waiting for %d responses to "serverSideEmit" request', this.uid, expectedResponseCount);
-		        if (expectedResponseCount <= 0) {
-		            return ack(null, []);
-		        }
-		        const requestId = randomId();
-		        const timeout = setTimeout(() => {
-		            const storedRequest = this.requests.get(requestId);
-		            if (storedRequest) {
-		                ack(new Error(`timeout reached: only ${storedRequest.current} responses received out of ${storedRequest.expected}`), storedRequest.responses);
-		                this.requests.delete(requestId);
-		            }
-		        }, DEFAULT_TIMEOUT);
-		        const storedRequest = {
-		            type: MessageType.SERVER_SIDE_EMIT,
-		            resolve: ack,
-		            timeout,
-		            current: 0,
-		            expected: expectedResponseCount,
-		            responses: [],
-		        };
-		        this.requests.set(requestId, storedRequest);
-		        this.publish({
-		            type: MessageType.SERVER_SIDE_EMIT,
-		            data: {
-		                requestId,
-		                packet,
-		            },
-		        });
-		    }
-		    publish(message) {
-		        this.publishAndReturnOffset(message).catch((err) => {
-		            debug("[%s] error while publishing message: %s", this.uid, err);
-		        });
-		    }
-		    publishAndReturnOffset(message) {
-		        message.uid = this.uid;
-		        message.nsp = this.nsp.name;
-		        return this.doPublish(message);
-		    }
-		    publishResponse(requesterUid, response) {
-		        response.uid = this.uid;
-		        response.nsp = this.nsp.name;
-		        this.doPublishResponse(requesterUid, response).catch((err) => {
-		            debug("[%s] error while publishing response: %s", this.uid, err);
-		        });
-		    }
-		}
-		exports.ClusterAdapter = ClusterAdapter;
-		class ClusterAdapterWithHeartbeat extends ClusterAdapter {
-		    constructor(nsp, opts) {
-		        super(nsp);
-		        this.nodesMap = new Map(); // uid => timestamp of last message
-		        this.customRequests = new Map();
-		        this._opts = Object.assign({
-		            heartbeatInterval: 5000,
-		            heartbeatTimeout: 10000,
-		        }, opts);
-		        this.cleanupTimer = setInterval(() => {
-		            const now = Date.now();
-		            this.nodesMap.forEach((lastSeen, uid) => {
-		                const nodeSeemsDown = now - lastSeen > this._opts.heartbeatTimeout;
-		                if (nodeSeemsDown) {
-		                    debug("[%s] node %s seems down", this.uid, uid);
-		                    this.removeNode(uid);
-		                }
-		            });
-		        }, 1000);
-		    }
-		    init() {
-		        this.publish({
-		            type: MessageType.INITIAL_HEARTBEAT,
-		        });
-		    }
-		    scheduleHeartbeat() {
-		        if (this.heartbeatTimer) {
-		            this.heartbeatTimer.refresh();
-		        }
-		        else {
-		            this.heartbeatTimer = setTimeout(() => {
-		                this.publish({
-		                    type: MessageType.HEARTBEAT,
-		                });
-		            }, this._opts.heartbeatInterval);
-		        }
-		    }
-		    close() {
-		        this.publish({
-		            type: MessageType.ADAPTER_CLOSE,
-		        });
-		        clearTimeout(this.heartbeatTimer);
-		        if (this.cleanupTimer) {
-		            clearInterval(this.cleanupTimer);
-		        }
-		    }
-		    onMessage(message, offset) {
-		        if (message.uid === this.uid) {
-		            return debug("[%s] ignore message from self", this.uid);
-		        }
-		        if (message.uid && message.uid !== EMITTER_UID) {
-		            // we track the UID of each sender, in order to know how many servers there are in the cluster
-		            this.nodesMap.set(message.uid, Date.now());
-		        }
-		        debug("[%s] new event of type %d from %s", this.uid, message.type, message.uid);
-		        switch (message.type) {
-		            case MessageType.INITIAL_HEARTBEAT:
-		                this.publish({
-		                    type: MessageType.HEARTBEAT,
-		                });
-		                break;
-		            case MessageType.HEARTBEAT:
-		                // nothing to do
-		                break;
-		            case MessageType.ADAPTER_CLOSE:
-		                this.removeNode(message.uid);
-		                break;
-		            default:
-		                super.onMessage(message, offset);
-		        }
-		    }
-		    serverCount() {
-		        return Promise.resolve(1 + this.nodesMap.size);
-		    }
-		    publish(message) {
-		        this.scheduleHeartbeat();
-		        return super.publish(message);
-		    }
-		    async serverSideEmit(packet) {
-		        const withAck = typeof packet[packet.length - 1] === "function";
-		        if (!withAck) {
-		            return this.publish({
-		                type: MessageType.SERVER_SIDE_EMIT,
-		                data: {
-		                    packet,
-		                },
-		            });
-		        }
-		        const ack = packet.pop();
-		        const expectedResponseCount = this.nodesMap.size;
-		        debug('[%s] waiting for %d responses to "serverSideEmit" request', this.uid, expectedResponseCount);
-		        if (expectedResponseCount <= 0) {
-		            return ack(null, []);
-		        }
-		        const requestId = randomId();
-		        const timeout = setTimeout(() => {
-		            const storedRequest = this.customRequests.get(requestId);
-		            if (storedRequest) {
-		                ack(new Error(`timeout reached: missing ${storedRequest.missingUids.size} responses`), storedRequest.responses);
-		                this.customRequests.delete(requestId);
-		            }
-		        }, DEFAULT_TIMEOUT);
-		        const storedRequest = {
-		            type: MessageType.SERVER_SIDE_EMIT,
-		            resolve: ack,
-		            timeout,
-		            missingUids: new Set([...this.nodesMap.keys()]),
-		            responses: [],
-		        };
-		        this.customRequests.set(requestId, storedRequest);
-		        this.publish({
-		            type: MessageType.SERVER_SIDE_EMIT,
-		            data: {
-		                requestId,
-		                packet,
-		            },
-		        });
-		    }
-		    async fetchSockets(opts) {
-		        var _a;
-		        const [localSockets, serverCount] = await Promise.all([
-		            super.fetchSockets({
-		                rooms: opts.rooms,
-		                except: opts.except,
-		                flags: {
-		                    local: true,
-		                },
-		            }),
-		            this.serverCount(),
-		        ]);
-		        const expectedResponseCount = serverCount - 1;
-		        if (((_a = opts.flags) === null || _a === void 0 ? void 0 : _a.local) || expectedResponseCount <= 0) {
-		            return localSockets;
-		        }
-		        const requestId = randomId();
-		        return new Promise((resolve, reject) => {
-		            const timeout = setTimeout(() => {
-		                const storedRequest = this.customRequests.get(requestId);
-		                if (storedRequest) {
-		                    reject(new Error(`timeout reached: missing ${storedRequest.missingUids.size} responses`));
-		                    this.customRequests.delete(requestId);
-		                }
-		            }, opts.flags.timeout || DEFAULT_TIMEOUT);
-		            const storedRequest = {
-		                type: MessageType.FETCH_SOCKETS,
-		                resolve,
-		                timeout,
-		                missingUids: new Set([...this.nodesMap.keys()]),
-		                responses: localSockets,
-		            };
-		            this.customRequests.set(requestId, storedRequest);
-		            this.publish({
-		                type: MessageType.FETCH_SOCKETS,
-		                data: {
-		                    opts: encodeOptions(opts),
-		                    requestId,
-		                },
-		            });
-		        });
-		    }
-		    onResponse(response) {
-		        const requestId = response.data.requestId;
-		        debug("[%s] received response %s to request %s", this.uid, response.type, requestId);
-		        switch (response.type) {
-		            case MessageType.FETCH_SOCKETS_RESPONSE: {
-		                const request = this.customRequests.get(requestId);
-		                if (!request) {
-		                    return;
-		                }
-		                response.data.sockets.forEach((socket) => request.responses.push(socket));
-		                request.missingUids.delete(response.uid);
-		                if (request.missingUids.size === 0) {
-		                    clearTimeout(request.timeout);
-		                    request.resolve(request.responses);
-		                    this.customRequests.delete(requestId);
-		                }
-		                break;
-		            }
-		            case MessageType.SERVER_SIDE_EMIT_RESPONSE: {
-		                const request = this.customRequests.get(requestId);
-		                if (!request) {
-		                    return;
-		                }
-		                request.responses.push(response.data.packet);
-		                request.missingUids.delete(response.uid);
-		                if (request.missingUids.size === 0) {
-		                    clearTimeout(request.timeout);
-		                    request.resolve(null, request.responses);
-		                    this.customRequests.delete(requestId);
-		                }
-		                break;
-		            }
-		            default:
-		                super.onResponse(response);
-		        }
-		    }
-		    removeNode(uid) {
-		        this.customRequests.forEach((request, requestId) => {
-		            request.missingUids.delete(uid);
-		            if (request.missingUids.size === 0) {
-		                clearTimeout(request.timeout);
-		                if (request.type === MessageType.FETCH_SOCKETS) {
-		                    request.resolve(request.responses);
-		                }
-		                else if (request.type === MessageType.SERVER_SIDE_EMIT) {
-		                    request.resolve(null, request.responses);
-		                }
-		                this.customRequests.delete(requestId);
-		            }
-		        });
-		        this.nodesMap.delete(uid);
-		    }
-		}
-		exports.ClusterAdapterWithHeartbeat = ClusterAdapterWithHeartbeat; 
-	} (clusterAdapter));
-	return clusterAdapter;
-}
-
-export { requireClusterAdapter as __require };