@socket-mesh/client 18.0.8 → 18.1.0

package/clientsocket.js

@@ -1,898 +0,0 @@
-import { StreamDemux, StreamDemuxWrapper } from "@socket-mesh/stream-demux";
-import { LocalStorageAuthEngine } from "./auth.js";
-import { AuthState } from "@socket-mesh/auth";
-import formatter from "@socket-mesh/formatter";
-import { Transport } from "./transport.js";
-import { List, Item } from "linked-list";
-import cloneDeep from "clone-deep";
-import { Buffer } from "buffer";
-import { wait } from "./wait.js";
-import { ChannelState, Client } from "@socket-mesh/channel";
-import { SocketState } from "./socket-state.js";
-import { hydrateError, InvalidArgumentsError, InvalidMessageError, SocketProtocolError, TimeoutError, BadConnectionError, socketProtocolIgnoreStatuses, socketProtocolErrorStatuses } from "@socket-mesh/errors";
-import { RemoteProcedure } from "./remote-procedure.js";
-class EventNode extends Item {
-    constructor() {
-        super();
-    }
-}
-export class ClientSocket extends Client {
-    constructor(socketOptions) {
-        super();
-        this.authState = AuthState.UNAUTHENTICATED;
-        this.id = null;
-        this.state = SocketState.CLOSED;
-        let opts = Object.assign({
-            path: '/socketcluster/',
-            secure: false,
-            protocolScheme: null,
-            socketPath: null,
-            autoConnect: true,
-            autoReconnect: true,
-            autoSubscribeOnConnect: true,
-            connectTimeout: 20000,
-            ackTimeout: 10000,
-            timestampRequests: false,
-            timestampParam: 't',
-            binaryType: 'arraybuffer',
-            batchOnHandshake: false,
-            batchOnHandshakeDuration: 100,
-            batchInterval: 50,
-            protocolVersion: 2,
-            wsOptions: {},
-            cloneData: false
-        }, socketOptions);
-        if (opts.authTokenName == null) {
-            const authHostString = opts.host ? `.${opts.host}` : `.${opts.hostname || 'localhost'}${opts.port ? `:${opts.port}` : ''}`;
-            opts.authTokenName = `socketcluster.authToken${authHostString}`;
-        }
-        this.version = opts.version || null;
-        this.protocolVersion = opts.protocolVersion;
-        this.signedAuthToken = null;
-        this.authToken = null;
-        this.pendingReconnect = false;
-        this.pendingReconnectTimeout = null;
-        this.preparingPendingSubscriptions = false;
-        this.clientId = opts.clientId;
-        this.wsOptions = opts.wsOptions;
-        this.connectTimeout = opts.connectTimeout;
-        this.ackTimeout = opts.ackTimeout;
-        this.channelPrefix = opts.channelPrefix || null;
-        this.authTokenName = opts.authTokenName;
-        // pingTimeout will be connectTimeout at the start, but it will
-        // be updated with values provided by the 'connect' event
-        opts.pingTimeout = opts.connectTimeout;
-        this.pingTimeout = opts.pingTimeout;
-        this.pingTimeoutDisabled = !!opts.pingTimeoutDisabled;
-        const maxTimeout = Math.pow(2, 31) - 1;
-        if (this.connectTimeout > maxTimeout) {
-            throw new InvalidArgumentsError('The connectTimeout value provided exceeded the maximum amount allowed');
-        }
-        if (this.ackTimeout > maxTimeout) {
-            throw new InvalidArgumentsError('The ackTimeout value provided exceeded the maximum amount allowed');
-        }
-        if (this.pingTimeout > maxTimeout) {
-            throw new InvalidArgumentsError('The pingTimeout value provided exceeded the maximum amount allowed');
-        }
-        this.connectAttempts = 0;
-        this.isBatching = false;
-        this.batchOnHandshake = opts.batchOnHandshake;
-        this.batchOnHandshakeDuration = opts.batchOnHandshakeDuration;
-        this._batchingIntervalId = null;
-        this._outboundBuffer = new List();
-        this._receiverDemux = new StreamDemux();
-        this.receiver = new StreamDemuxWrapper(this._receiverDemux);
-        this._procedureDemux = new StreamDemux();
-        this.procedure = new RemoteProcedure(this._procedureDemux);
-        this.options = opts;
-        this._cid = 1;
-        this.options.callIdGenerator = () => {
-            return this._cid++;
-        };
-        if (this.options.autoReconnect) {
-            if (this.options.autoReconnectOptions == null) {
-                this.options.autoReconnectOptions = {};
-            }
-            // Add properties to the this.options.autoReconnectOptions object.
-            // We assign the reference to a reconnectOptions variable to avoid repetition.
-            let reconnectOptions = this.options.autoReconnectOptions;
-            if (reconnectOptions.initialDelay == null) {
-                reconnectOptions.initialDelay = 10000;
-            }
-            if (reconnectOptions.randomness == null) {
-                reconnectOptions.randomness = 10000;
-            }
-            if (reconnectOptions.multiplier == null) {
-                reconnectOptions.multiplier = 1.5;
-            }
-            if (reconnectOptions.maxDelay == null) {
-                reconnectOptions.maxDelay = 60000;
-            }
-        }
-        if (this.options.subscriptionRetryOptions == null) {
-            this.options.subscriptionRetryOptions = {};
-        }
-        if (this.options.authEngine) {
-            this.auth = this.options.authEngine;
-        }
-        else {
-            this.auth = new LocalStorageAuthEngine();
-        }
-        if (this.options.codecEngine) {
-            this.codec = this.options.codecEngine;
-        }
-        else {
-            // Default codec engine
-            this.codec = formatter;
-        }
-        if (this.options.protocol) {
-            let protocolOptionError = new InvalidArgumentsError('The protocol option does not affect socketcluster-client - ' +
-                'If you want to utilize SSL/TLS, use the secure option instead');
-            this._onError(protocolOptionError);
-        }
-        this.options.query = opts.query || {};
-        if (this.options.autoConnect) {
-            this.connect();
-        }
-    }
-    uri() {
-        return Transport.computeUri(this.options);
-    }
-    ;
-    getBackpressure() {
-        return Math.max(this.getListenerBackpressure(), this.receiver.getBackpressure(), this.procedure.getBackpressure(), this.getChannelBackpressure());
-    }
-    _setAuthToken(data) {
-        this._changeToAuthenticatedState(data.token);
-        (async () => {
-            try {
-                await this.auth.saveToken(this.authTokenName, data.token, {});
-            }
-            catch (err) {
-                this._onError(err);
-            }
-        })();
-    }
-    _removeAuthToken() {
-        (async () => {
-            let oldAuthToken;
-            try {
-                oldAuthToken = await this.auth.removeToken(this.authTokenName);
-            }
-            catch (err) {
-                // Non-fatal error - Do not close the connection
-                this._onError(err);
-                return;
-            }
-            this.emit('removeAuthToken', { oldAuthToken });
-        })();
-        this._changeToUnauthenticatedStateAndClearTokens();
-    }
-    getState() {
-        return this.state;
-    }
-    getBytesReceived() {
-        return this.transport.getBytesReceived();
-    }
-    async deauthenticate() {
-        (async () => {
-            let oldAuthToken;
-            try {
-                oldAuthToken = await this.auth.removeToken(this.authTokenName);
-            }
-            catch (err) {
-                this._onError(err);
-                return;
-            }
-            this.emit('removeAuthToken', { oldAuthToken });
-        })();
-        if (this.state !== SocketState.CLOSED) {
-            this.transmit('#removeAuthToken');
-        }
-        this._changeToUnauthenticatedStateAndClearTokens();
-        await wait(0);
-    }
-    connect(socketOptions) {
-        if (socketOptions) {
-            if (this.state !== SocketState.CLOSED) {
-                this.disconnect(1000, 'Socket was disconnected by the client to initiate a new connection');
-            }
-            this.options = {
-                ...this.options,
-                ...socketOptions
-            };
-        }
-        if (this.state === SocketState.CLOSED) {
-            this.pendingReconnect = false;
-            this.pendingReconnectTimeout = null;
-            clearTimeout(this._reconnectTimeoutRef);
-            this.state = SocketState.CONNECTING;
-            this.emit('connecting', {});
-            if (this.transport) {
-                this.transport.clearAllListeners();
-            }
-            const transportHandlers = {
-                onOpen: (value) => {
-                    this.state = SocketState.OPEN;
-                    this._onOpen(value);
-                },
-                onOpenAbort: (value) => {
-                    if (this.state !== SocketState.CLOSED) {
-                        this.state = SocketState.CLOSED;
-                        this._destroy(value.code, value.reason, true);
-                    }
-                },
-                onClose: (value) => {
-                    if (this.state !== SocketState.CLOSED) {
-                        this.state = SocketState.CLOSED;
-                        this._destroy(value.code, value.reason);
-                    }
-                },
-                onEvent: (value) => {
-                    this.emit(value.event, value.data);
-                },
-                onError: (value) => {
-                    this._onError(value.error);
-                },
-                onInboundInvoke: (value) => {
-                    this._onInboundInvoke(value);
-                },
-                onInboundTransmit: (value) => {
-                    this._onInboundTransmit(value.event, value.data);
-                }
-            };
-            this.transport = new Transport(this.auth, this.codec, this.options, this.wsOptions, transportHandlers);
-        }
-    }
-    reconnect(code, reason) {
-        this.disconnect(code, reason);
-        this.connect();
-    }
-    disconnect(code = 1000, reason) {
-        if (typeof code !== 'number') {
-            throw new InvalidArgumentsError('If specified, the code argument must be a number');
-        }
-        let isConnecting = this.state === SocketState.CONNECTING;
-        if (isConnecting || this.state === SocketState.OPEN) {
-            this.state = SocketState.CLOSED;
-            this._destroy(code, reason, isConnecting);
-            this.transport.close(code, reason);
-        }
-        else {
-            this.pendingReconnect = false;
-            this.pendingReconnectTimeout = null;
-            clearTimeout(this._reconnectTimeoutRef);
-        }
-    }
-    _changeToUnauthenticatedStateAndClearTokens() {
-        if (this.authState !== AuthState.UNAUTHENTICATED) {
-            let oldAuthState = this.authState;
-            let oldAuthToken = this.authToken;
-            let oldSignedAuthToken = this.signedAuthToken;
-            this.authState = AuthState.UNAUTHENTICATED;
-            this.signedAuthToken = null;
-            this.authToken = null;
-            let stateChangeData = {
-                oldAuthState,
-                newAuthState: this.authState
-            };
-            this.emit('authStateChange', stateChangeData);
-            this.emit('deauthenticate', { oldSignedAuthToken, oldAuthToken });
-        }
-    }
-    _changeToAuthenticatedState(signedAuthToken) {
-        this.signedAuthToken = signedAuthToken;
-        this.authToken = this._extractAuthTokenData(signedAuthToken);
-        if (this.authState !== AuthState.AUTHENTICATED) {
-            let oldAuthState = this.authState;
-            this.authState = AuthState.AUTHENTICATED;
-            let stateChangeData = {
-                oldAuthState,
-                newAuthState: this.authState,
-                signedAuthToken: signedAuthToken,
-                authToken: this.authToken
-            };
-            if (!this.preparingPendingSubscriptions) {
-                this.processPendingSubscriptions();
-            }
-            this.emit('authStateChange', stateChangeData);
-        }
-        this.emit('authenticate', { signedAuthToken, authToken: this.authToken });
-    }
-    decodeBase64(encodedString) {
-        return Buffer.from(encodedString, 'base64').toString('utf8');
-    }
-    encodeBase64(decodedString) {
-        return Buffer.from(decodedString, 'utf8').toString('base64');
-    }
-    _extractAuthTokenData(signedAuthToken) {
-        if (typeof signedAuthToken !== 'string')
-            return null;
-        let tokenParts = signedAuthToken.split('.');
-        let encodedTokenData = tokenParts[1];
-        if (encodedTokenData != null) {
-            let tokenData = encodedTokenData;
-            try {
-                tokenData = this.decodeBase64(tokenData);
-                return JSON.parse(tokenData);
-            }
-            catch (e) {
-                return tokenData;
-            }
-        }
-        return null;
-    }
-    getAuthToken() {
-        return this.authToken;
-    }
-    getSignedAuthToken() {
-        return this.signedAuthToken;
-    }
-    // Perform client-initiated authentication by providing an encrypted token string.
-    async authenticate(signedAuthToken) {
-        let authStatus;
-        try {
-            authStatus = await this.invoke('#authenticate', signedAuthToken);
-        }
-        catch (err) {
-            if (err.name !== 'BadConnectionError' && err.name !== 'TimeoutError') {
-                // In case of a bad/closed connection or a timeout, we maintain the last
-                // known auth state since those errors don't mean that the token is invalid.
-                this._changeToUnauthenticatedStateAndClearTokens();
-            }
-            await wait(0);
-            throw err;
-        }
-        if (authStatus?.isAuthenticated != null) {
-            // If authStatus is correctly formatted (has an isAuthenticated property),
-            // then we will rehydrate the authError.
-            if (authStatus.authError) {
-                authStatus.authError = hydrateError(authStatus.authError);
-            }
-        }
-        else {
-            // Some errors like BadConnectionError and TimeoutError will not pass a valid
-            // authStatus object to the current function, so we need to create it ourselves.
-            authStatus = {
-                isAuthenticated: this.authState,
-                authError: null
-            };
-        }
-        if (authStatus.isAuthenticated) {
-            this._changeToAuthenticatedState(signedAuthToken);
-        }
-        else {
-            this._changeToUnauthenticatedStateAndClearTokens();
-        }
-        (async () => {
-            try {
-                await this.auth.saveToken(this.authTokenName, signedAuthToken, {});
-            }
-            catch (err) {
-                this._onError(err);
-            }
-        })();
-        await wait(0);
-        return authStatus;
-    }
-    _tryReconnect(initialDelay) {
-        let exponent = this.connectAttempts++;
-        let reconnectOptions = this.options.autoReconnectOptions;
-        let timeout;
-        if (initialDelay == null || exponent > 0) {
-            let initialTimeout = Math.round(reconnectOptions.initialDelay + (reconnectOptions.randomness || 0) * Math.random());
-            timeout = Math.round(initialTimeout * Math.pow(reconnectOptions.multiplier, exponent));
-        }
-        else {
-            timeout = initialDelay;
-        }
-        if (timeout > reconnectOptions.maxDelay) {
-            timeout = reconnectOptions.maxDelay;
-        }
-        clearTimeout(this._reconnectTimeoutRef);
-        this.pendingReconnect = true;
-        this.pendingReconnectTimeout = timeout;
-        this._reconnectTimeoutRef = setTimeout(() => {
-            this.connect();
-        }, timeout);
-    }
-    _onOpen(status) {
-        if (this.isBatching) {
-            this._startBatching();
-        }
-        else if (this.batchOnHandshake) {
-            this._startBatching();
-            setTimeout(() => {
-                if (!this.isBatching) {
-                    this._stopBatching();
-                }
-            }, this.batchOnHandshakeDuration);
-        }
-        this.preparingPendingSubscriptions = true;
-        if (status) {
-            this.id = status.id;
-            this.pingTimeout = status.pingTimeout;
-            if (status.isAuthenticated) {
-                this._changeToAuthenticatedState(status.authToken);
-            }
-            else {
-                this._changeToUnauthenticatedStateAndClearTokens();
-            }
-        }
-        else {
-            // This can happen if auth.loadToken (in transport.js) fails with
-            // an error - This means that the signedAuthToken cannot be loaded by
-            // the auth engine and therefore, we need to unauthenticate the client.
-            this._changeToUnauthenticatedStateAndClearTokens();
-        }
-        this.connectAttempts = 0;
-        if (this.options.autoSubscribeOnConnect) {
-            this.processPendingSubscriptions();
-        }
-        // If the user invokes the callback while in autoSubscribeOnConnect mode, it
-        // won't break anything.
-        this.emit('connect', {
-            ...status,
-            processPendingSubscriptions: () => {
-                this.processPendingSubscriptions();
-            }
-        });
-        if (this.state === SocketState.OPEN) {
-            this._flushOutboundBuffer();
-        }
-    }
-    _onError(error) {
-        this.emit('error', { error });
-    }
-    _suspendSubscriptions() {
-        Object.keys(this._channelMap).forEach((channelName) => {
-            let channel = this._channelMap[channelName];
-            this._triggerChannelUnsubscribe(channel, true);
-        });
-    }
-    _abortAllPendingEventsDueToBadConnection(failureType) {
-        let currentNode = this._outboundBuffer.head;
-        let nextNode;
-        while (currentNode) {
-            nextNode = currentNode.next;
-            let eventObject = currentNode.data;
-            clearTimeout(eventObject.timeout);
-            delete eventObject.timeout;
-            currentNode.detach();
-            currentNode = nextNode;
-            let callback = eventObject.callback;
-            if (callback) {
-                delete eventObject.callback;
-                let errorMessage = `Event ${eventObject.event} was aborted due to a bad connection`;
-                let error = new BadConnectionError(errorMessage, failureType);
-                callback.call(eventObject, error, eventObject);
-            }
-            // Cleanup any pending response callback in the transport layer too.
-            if (eventObject.cid) {
-                this.transport.cancelPendingResponse(eventObject.cid);
-            }
-        }
-    }
-    _destroy(code, reason, openAbort) {
-        this.id = null;
-        this._cancelBatching();
-        if (this.transport) {
-            this.transport.clearAllListeners();
-        }
-        this.pendingReconnect = false;
-        this.pendingReconnectTimeout = null;
-        clearTimeout(this._reconnectTimeoutRef);
-        this._suspendSubscriptions();
-        if (openAbort) {
-            this.emit('connectAbort', { code, reason });
-        }
-        else {
-            this.emit('disconnect', { code, reason });
-        }
-        this.emit('close', { code, reason });
-        if (!socketProtocolIgnoreStatuses[code]) {
-            let closeMessage;
-            if (typeof reason === 'string') {
-                closeMessage = 'Socket connection closed with status code ' + code + ' and reason: ' + reason;
-            }
-            else {
-                closeMessage = 'Socket connection closed with status code ' + code;
-            }
-            let err = new SocketProtocolError(socketProtocolErrorStatuses[code] || closeMessage, code);
-            this._onError(err);
-        }
-        this._abortAllPendingEventsDueToBadConnection(openAbort ? 'connectAbort' : 'disconnect');
-        // Try to reconnect
-        // on server ping timeout (4000)
-        // or on client pong timeout (4001)
-        // or on close without status (1005)
-        // or on handshake failure (4003)
-        // or on handshake rejection (4008)
-        // or on socket hung up (1006)
-        if (this.options.autoReconnect) {
-            if (code === 4000 || code === 4001 || code === 1005) {
-                // If there is a ping or pong timeout or socket closes without
-                // status, don't wait before trying to reconnect - These could happen
-                // if the client wakes up after a period of inactivity and in this case we
-                // want to re-establish the connection as soon as possible.
-                this._tryReconnect(0);
-                // Codes 4500 and above will be treated as permanent disconnects.
-                // Socket will not try to auto-reconnect.
-            }
-            else if (code !== 1000 && code < 4500) {
-                this._tryReconnect();
-            }
-        }
-    }
-    _onInboundTransmit(event, data) {
-        data = data || {};
-        if (event === '#publish') {
-            if (typeof data.channel !== 'string')
-                return;
-            let undecoratedChannelName = this._undecorateChannelName(data.channel);
-            let isSubscribed = this.isSubscribed(undecoratedChannelName, true);
-            if (isSubscribed) {
-                this._channelDataDemux.write(undecoratedChannelName, data.data);
-            }
-        }
-        else if (event === '#kickOut') {
-            if (typeof data.channel !== 'string')
-                return;
-            let undecoratedChannelName = this._undecorateChannelName(data.channel);
-            let channel = this._channelMap[undecoratedChannelName];
-            if (channel) {
-                this.emit('kickOut', {
-                    channel: undecoratedChannelName,
-                    message: data.message
-                });
-                this._channelEventDemux.write(`${undecoratedChannelName}/kickOut`, { message: data.message });
-                this._triggerChannelUnsubscribe(channel);
-            }
-        }
-        else if (event === '#setAuthToken') {
-            if (data) {
-                this._setAuthToken(data);
-            }
-        }
-        else if (event === '#removeAuthToken') {
-            this._removeAuthToken();
-        }
-        else {
-            this._receiverDemux.write(event, data);
-        }
-    }
-    _onInboundInvoke(request) {
-        let { procedure, data } = request;
-        if (procedure === '#setAuthToken') {
-            if (data) {
-                this._setAuthToken(data);
-                request.end();
-            }
-            else {
-                let error = new InvalidMessageError('No token data provided by #setAuthToken event');
-                delete error.stack;
-                request.error(error);
-            }
-        }
-        else if (procedure === '#removeAuthToken') {
-            this._removeAuthToken();
-            request.end();
-        }
-        else {
-            this._procedureDemux.write(procedure, request);
-        }
-    }
-    decode(message) {
-        return this.transport.decode(message);
-    }
-    encode(object) {
-        return this.transport.encode(object);
-    }
-    _flushOutboundBuffer() {
-        let currentNode = this._outboundBuffer.head;
-        let nextNode;
-        while (currentNode) {
-            nextNode = currentNode.next;
-            let eventObject = currentNode.data;
-            currentNode.detach();
-            this.transport.transmitObject(eventObject);
-            currentNode = nextNode;
-        }
-    }
-    _handleEventAckTimeout(eventObject, eventNode) {
-        if (eventNode) {
-            eventNode.detach();
-        }
-        delete eventObject.timeout;
-        let callback = eventObject.callback;
-        if (callback) {
-            delete eventObject.callback;
-            let error = new TimeoutError(`Event response for ${eventObject.event} event timed out`);
-            callback.call(eventObject, error, eventObject);
-        }
-        // Cleanup any pending response callback in the transport layer too.
-        if (eventObject.cid) {
-            this.transport.cancelPendingResponse(eventObject.cid);
-        }
-    }
-    _processOutboundEvent(event, data, options, expectResponse) {
-        options = options || {};
-        if (this.state === SocketState.CLOSED) {
-            this.connect();
-        }
-        let eventObject = {
-            event,
-            data: this.options.cloneData ? cloneDeep(data) : data
-        };
-        let promise;
-        if (expectResponse) {
-            promise = new Promise((resolve, reject) => {
-                eventObject.callback = (err, data) => {
-                    if (err) {
-                        reject(err);
-                        return;
-                    }
-                    resolve(data);
-                };
-            });
-        }
-        else {
-            promise = Promise.resolve();
-        }
-        let eventNode = new EventNode();
-        eventNode.data = eventObject;
-        let ackTimeout = options.ackTimeout == null ? this.ackTimeout : options.ackTimeout;
-        eventObject.timeout = setTimeout(() => {
-            this._handleEventAckTimeout(eventObject, eventNode);
-        }, ackTimeout);
-        this._outboundBuffer.append(eventNode);
-        if (this.state === SocketState.OPEN) {
-            this._flushOutboundBuffer();
-        }
-        return promise;
-    }
-    send(data) {
-        this.transport.send(data);
-    }
-    ;
-    transmit(event, data, options) {
-        return this._processOutboundEvent(event, data, options);
-    }
-    invoke(event, data, options) {
-        return this._processOutboundEvent(event, data, options, true);
-    }
-    transmitPublish(channelName, data) {
-        let pubData = {
-            channel: this._decorateChannelName(channelName),
-            data
-        };
-        return this.transmit('#publish', pubData);
-    }
-    invokePublish(channelName, data) {
-        let pubData = {
-            channel: this._decorateChannelName(channelName),
-            data
-        };
-        return this.invoke('#publish', pubData);
-    }
-    _triggerChannelSubscribe(channel, subscriptionOptions) {
-        let channelName = channel.name;
-        if (channel.state !== ChannelState.SUBSCRIBED) {
-            let oldChannelState = channel.state;
-            channel.state = ChannelState.SUBSCRIBED;
-            let stateChangeData = {
-                oldChannelState,
-                newChannelState: channel.state,
-                subscriptionOptions
-            };
-            this._channelEventDemux.write(`${channelName}/subscribeStateChange`, stateChangeData);
-            this._channelEventDemux.write(`${channelName}/subscribe`, {
-                subscriptionOptions
-            });
-            this.emit('subscribeStateChange', {
-                channel: channelName,
-                ...stateChangeData
-            });
-            this.emit('subscribe', {
-                channel: channelName,
-                subscriptionOptions
-            });
-        }
-    }
-    _triggerChannelSubscribeFail(err, channel, subscriptionOptions) {
-        let channelName = channel.name;
-        let meetsAuthRequirements = !channel.options.waitForAuth || this.authState === AuthState.AUTHENTICATED;
-        let hasChannel = !!this._channelMap[channelName];
-        if (hasChannel && meetsAuthRequirements) {
-            delete this._channelMap[channelName];
-            this._channelEventDemux.write(`${channelName}/subscribeFail`, {
-                error: err,
-                subscriptionOptions
-            });
-            this.emit('subscribeFail', {
-                error: err,
-                channel: channelName,
-                subscriptionOptions: subscriptionOptions
-            });
-        }
-    }
-    // Cancel any pending subscribe callback
-    _cancelPendingSubscribeCallback(channel) {
-        if (channel._pendingSubscriptionCid != null) {
-            this.transport.cancelPendingResponse(channel._pendingSubscriptionCid);
-            delete channel._pendingSubscriptionCid;
-        }
-    }
-    _decorateChannelName(channelName) {
-        if (this.channelPrefix) {
-            channelName = this.channelPrefix + channelName;
-        }
-        return channelName;
-    }
-    _undecorateChannelName(decoratedChannelName) {
-        if (this.channelPrefix && decoratedChannelName.indexOf(this.channelPrefix) === 0) {
-            return decoratedChannelName.replace(this.channelPrefix, '');
-        }
-        return decoratedChannelName;
-    }
-    startBatch() {
-        this.transport.startBatch();
-    }
-    flushBatch() {
-        this.transport.flushBatch();
-    }
-    cancelBatch() {
-        this.transport.cancelBatch();
-    }
-    _startBatching() {
-        if (this._batchingIntervalId != null) {
-            return;
-        }
-        this.startBatch();
-        this._batchingIntervalId = setInterval(() => {
-            this.flushBatch();
-            this.startBatch();
-        }, this.options.batchInterval);
-    }
-    startBatching() {
-        this.isBatching = true;
-        this._startBatching();
-    }
-    _stopBatching() {
-        if (this._batchingIntervalId != null) {
-            clearInterval(this._batchingIntervalId);
-        }
-        this._batchingIntervalId = null;
-        this.flushBatch();
-    }
-    stopBatching() {
-        this.isBatching = false;
-        this._stopBatching();
-    }
-    _cancelBatching() {
-        if (this._batchingIntervalId != null) {
-            clearInterval(this._batchingIntervalId);
-        }
-        this._batchingIntervalId = null;
-        this.cancelBatch();
-    }
-    cancelBatching() {
-        this.isBatching = false;
-        this._cancelBatching();
-    }
-    _trySubscribe(channel) {
-        let meetsAuthRequirements = !channel.options.waitForAuth || this.authState === AuthState.AUTHENTICATED;
-        // We can only ever have one pending subscribe action at any given time on a channel
-        if (this.state === SocketState.OPEN &&
-            !this.preparingPendingSubscriptions &&
-            channel._pendingSubscriptionCid == null &&
-            meetsAuthRequirements) {
-            let options = {
-                noTimeout: true
-            };
-            let subscriptionOptions = {};
-            if (channel.options.waitForAuth) {
-                subscriptionOptions.waitForAuth = true;
-            }
-            if (channel.options.data) {
-                subscriptionOptions.data = channel.options.data;
-            }
-            channel._pendingSubscriptionCid = this.transport.invokeRaw('#subscribe', {
-                channel: this._decorateChannelName(channel.name),
-                ...subscriptionOptions
-            }, options, (err) => {
-                if (err) {
-                    if (err.name === 'BadConnectionError') {
-                        // In case of a failed connection, keep the subscription
-                        // as pending; it will try again on reconnect.
-                        return;
-                    }
-                    delete channel._pendingSubscriptionCid;
-                    this._triggerChannelSubscribeFail(err, channel, subscriptionOptions);
-                }
-                else {
-                    delete channel._pendingSubscriptionCid;
-                    this._triggerChannelSubscribe(channel, subscriptionOptions);
-                }
-            });
-            this.emit('subscribeRequest', {
-                channel: channel.name,
-                subscriptionOptions
-            });
-        }
-    }
-    emit(eventName, data) {
-        super.emit(eventName, data);
-    }
-    listen(eventName) {
-        return super.listen(eventName);
-    }
-    _triggerChannelUnsubscribe(channel, setAsPending) {
-        let channelName = channel.name;
-        this._cancelPendingSubscribeCallback(channel);
-        if (channel.state === ChannelState.SUBSCRIBED) {
-            let stateChangeData = {
-                oldChannelState: channel.state,
-                newChannelState: setAsPending ? ChannelState.PENDING : ChannelState.UNSUBSCRIBED
-            };
-            this._channelEventDemux.write(`${channelName}/subscribeStateChange`, stateChangeData);
-            this._channelEventDemux.write(`${channelName}/unsubscribe`, {});
-            this.emit('subscribeStateChange', {
-                channel: channelName,
-                ...stateChangeData
-            });
-            this.emit('unsubscribe', { channel: channelName });
-        }
-        if (setAsPending) {
-            channel.state = ChannelState.PENDING;
-        }
-        else {
-            delete this._channelMap[channelName];
-        }
-    }
-    _tryUnsubscribe(channel) {
-        this._triggerChannelUnsubscribe(channel);
-        if (this.state === SocketState.OPEN) {
-            let options = {
-                noTimeout: true
-            };
-            // If there is a pending subscribe action, cancel the callback
-            this._cancelPendingSubscribeCallback(channel);
-            // This operation cannot fail because the TCP protocol guarantees delivery
-            // so long as the connection remains open. If the connection closes,
-            // the server will automatically unsubscribe the client and thus complete
-            // the operation on the server side.
-            let decoratedChannelName = this._decorateChannelName(channel.name);
-            this.transport.transmit('#unsubscribe', decoratedChannelName, options);
-        }
-    }
-    // ---- Channel logic ----
-    processPendingSubscriptions() {
-        this.preparingPendingSubscriptions = false;
-        let pendingChannels = [];
-        Object.keys(this._channelMap).forEach((channelName) => {
-            let channel = this._channelMap[channelName];
-            if (channel.state === ChannelState.PENDING) {
-                pendingChannels.push(channel);
-            }
-        });
-        pendingChannels.sort((a, b) => {
-            let ap = a.options.priority || 0;
-            let bp = b.options.priority || 0;
-            if (ap > bp) {
-                return -1;
-            }
-            if (ap < bp) {
-                return 1;
-            }
-            return 0;
-        });
-        pendingChannels.forEach((channel) => {
-            this._trySubscribe(channel);
-        });
-    }
-    get isBufferingBatch() {
-        return this.transport.isBufferingBatch;
-    }
-}
-//# sourceMappingURL=clientsocket.js.map