@socket-mesh/client 18.1.5 → 19.0.0

package/dist/client-auth-engine.d.ts

@@ -1,22 +1,22 @@
-import { SignedAuthToken } from "@socket-mesh/auth";
+import { SignedAuthToken } from '@socket-mesh/auth';
 export interface ClientAuthEngine {
+    loadToken(): Promise<null | SignedAuthToken>;
+    removeToken(): Promise<null | SignedAuthToken>;
     saveToken(token: SignedAuthToken, options?: {
         [key: string]: any;
     }): Promise<SignedAuthToken>;
-    removeToken(): Promise<SignedAuthToken>;
-    loadToken(): Promise<SignedAuthToken | null>;
 }
-export declare function isAuthEngine(auth: ClientAuthEngine | LocalStorageAuthEngineOptions): auth is ClientAuthEngine;
 export interface LocalStorageAuthEngineOptions {
     authTokenName?: string;
 }
+export declare function isAuthEngine(auth?: ClientAuthEngine | LocalStorageAuthEngineOptions | null): auth is ClientAuthEngine;
 export declare class LocalStorageAuthEngine implements ClientAuthEngine {
     private readonly _authTokenName;
     private readonly _internalStorage;
     readonly isLocalStorageEnabled: boolean;
     constructor({ authTokenName }?: LocalStorageAuthEngineOptions);
-    private _checkLocalStorageEnabled;
+    private checkLocalStorageEnabled;
+    loadToken(): Promise<null | SignedAuthToken>;
+    removeToken(): Promise<null | SignedAuthToken>;
     saveToken(token: string): Promise<SignedAuthToken>;
-    removeToken(): Promise<SignedAuthToken>;
-    loadToken(): Promise<SignedAuthToken>;
 }

package/dist/client-auth-engine.js

@@ -1,18 +1,21 @@
 export function isAuthEngine(auth) {
-    return (typeof auth === 'object' && 'saveToken' in auth && 'removeToken' in auth && 'loadToken' in auth);
+    return (!!auth && typeof auth === 'object' && 'saveToken' in auth && 'removeToken' in auth && 'loadToken' in auth);
 }
 export class LocalStorageAuthEngine {
+    _authTokenName;
+    _internalStorage;
+    isLocalStorageEnabled;
     constructor({ authTokenName } = {}) {
         this._internalStorage = {};
-        this.isLocalStorageEnabled = this._checkLocalStorageEnabled();
+        this.isLocalStorageEnabled = this.checkLocalStorageEnabled();
         this._authTokenName = authTokenName ?? 'socketmesh.authToken';
     }
-    _checkLocalStorageEnabled() {
+    checkLocalStorageEnabled() {
         let err;
         try {
             // Safari, in Private Browsing Mode, looks like it supports localStorage but all calls to setItem
             // throw QuotaExceededError. We're going to detect this and avoid hard to debug edge cases.
-            localStorage.setItem('__localStorageTest', "1");
+            localStorage.setItem('__localStorageTest', '1');
             localStorage.removeItem('__localStorageTest');
         }
         catch (e) {
@@ -20,17 +23,18 @@ export class LocalStorageAuthEngine {
         }
         return !err;
     }
-    async saveToken(token) {
+    async loadToken() {
+        let token;
         if (this.isLocalStorageEnabled) {
-            localStorage.setItem(this._authTokenName, token);
+            token = localStorage.getItem(this._authTokenName);
         }
         else {
-            this._internalStorage[this._authTokenName] = token;
+            token = this._internalStorage[this._authTokenName] || null;
         }
         return token;
     }
     async removeToken() {
-        let loadPromise = this.loadToken();
+        const loadPromise = this.loadToken();
         if (this.isLocalStorageEnabled) {
             localStorage.removeItem(this._authTokenName);
         }
@@ -39,13 +43,12 @@ export class LocalStorageAuthEngine {
         }
         return loadPromise;
     }
-    async loadToken() {
-        let token;
+    async saveToken(token) {
         if (this.isLocalStorageEnabled) {
-            token = localStorage.getItem(this._authTokenName);
+            localStorage.setItem(this._authTokenName, token);
         }
         else {
-            token = this._internalStorage[this._authTokenName] || null;
+            this._internalStorage[this._authTokenName] = token;
         }
         return token;
     }

package/dist/client-channels.d.ts

@@ -1,20 +1,21 @@
-import { ChannelDetails, ChannelMap, Channels, ChannelsOptions } from "@socket-mesh/channels";
-import { ClientTransport } from "./client-transport.js";
-import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from "@socket-mesh/core";
+import { ChannelDetails, ChannelMap, Channels, ChannelsOptions } from '@socket-mesh/channels';
+import { SocketTransport } from '@socket-mesh/core';
+import { ClientTransport } from './client-transport.js';
+import { ServerPrivateMap } from './maps/server-map.js';
 export interface ClientChannelsOptions extends ChannelsOptions {
     autoSubscribeOnConnect?: boolean;
 }
-export declare class ClientChannels<TChannel extends ChannelMap, TIncoming extends MethodMap, TService extends ServiceMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TState extends object> extends Channels<TChannel> {
-    autoSubscribeOnConnect: boolean;
-    protected readonly _transport: ClientTransport<TIncoming, TService, TOutgoing, TPrivateOutgoing, TState>;
+export declare class ClientChannels<TChannel extends ChannelMap, TState extends object = {}> extends Channels<TChannel> {
     protected _preparingPendingSubscriptions: boolean;
-    constructor(transport: ClientTransport<TIncoming, TService, TOutgoing, TPrivateOutgoing, TState>, options?: ClientChannelsOptions);
+    protected readonly _transport: SocketTransport<{}, {}, TState, {}, {}, ServerPrivateMap>;
+    autoSubscribeOnConnect: boolean;
+    constructor(transport: ClientTransport<TState>, options?: ClientChannelsOptions);
+    invokePublish<U extends keyof TChannel & string>(channelName: keyof TChannel & string, data: TChannel[U]): Promise<void>;
+    private processPendingSubscriptions;
     private suspendSubscriptions;
+    transmitPublish<U extends keyof TChannel & string>(channelName: U, data: TChannel[U]): Promise<void>;
+    private triggerChannelSubscribeFail;
     protected trySubscribe(channel: ChannelDetails): void;
-    private processPendingSubscriptions;
-    unsubscribe(channelName: keyof TChannel & string): void;
     protected tryUnsubscribe(channel: ChannelDetails): void;
-    private triggerChannelSubscribeFail;
-    transmitPublish<U extends keyof TChannel & string>(channelName: U, data: TChannel[U]): Promise<void>;
-    invokePublish<U extends keyof TChannel & string>(channelName: keyof TChannel & string, data: TChannel[U]): Promise<void>;
+    unsubscribe(channelName: keyof TChannel & string): void;
 }

package/dist/client-channels.js

@@ -1,5 +1,9 @@
-import { Channels } from "@socket-mesh/channels";
+import { Channels } from '@socket-mesh/channels';
+import { toError } from '@socket-mesh/core';
 export class ClientChannels extends Channels {
+    _preparingPendingSubscriptions;
+    _transport;
+    autoSubscribeOnConnect;
     constructor(transport, options) {
         if (!options) {
             options = {};
@@ -9,20 +13,51 @@ export class ClientChannels extends Channels {
         this._transport = transport;
         this._preparingPendingSubscriptions = false;
         this._transport.plugins.push({
-            type: 'channels',
             onAuthenticated: () => {
                 if (!this._preparingPendingSubscriptions) {
                     this.processPendingSubscriptions();
                 }
             },
+            onClose: () => {
+                this.suspendSubscriptions();
+            },
             onReady: () => {
                 if (this.autoSubscribeOnConnect) {
                     this.processPendingSubscriptions();
                 }
             },
-            onClose: () => {
-                this.suspendSubscriptions();
-            },
+            type: 'channels'
+        });
+    }
+    invokePublish(channelName, data) {
+        const pubData = {
+            channel: this.decorateChannelName(channelName),
+            data
+        };
+        return this._transport.invoke('#publish', pubData)[0];
+    }
+    processPendingSubscriptions() {
+        this._preparingPendingSubscriptions = false;
+        const pendingChannels = [];
+        Object.keys(this._channelMap).forEach((channelName) => {
+            const channel = this._channelMap[channelName];
+            if (channel.state === 'pending') {
+                pendingChannels.push(channel);
+            }
+        });
+        pendingChannels.sort((a, b) => {
+            const ap = a.options.priority || 0;
+            const bp = b.options.priority || 0;
+            if (ap > bp) {
+                return -1;
+            }
+            if (ap < bp) {
+                return 1;
+            }
+            return 0;
+        });
+        pendingChannels.forEach((channel) => {
+            this.trySubscribe(channel);
         });
     }
     suspendSubscriptions() {
@@ -30,13 +65,37 @@ export class ClientChannels extends Channels {
             this.triggerChannelUnsubscribe(this._channelMap[channel], true);
         }
     }
+    transmitPublish(channelName, data) {
+        const pubData = {
+            channel: this.decorateChannelName(channelName),
+            data
+        };
+        return this._transport.transmit('#publish', pubData);
+    }
+    triggerChannelSubscribeFail(err, channel, options) {
+        const hasAuthRequirements = !channel.options.waitForAuth || !!this._transport.signedAuthToken;
+        const hasChannel = !!this._channelMap[channel.name];
+        if (hasChannel && hasAuthRequirements) {
+            delete this._channelMap[channel.name];
+            this._channelEventDemux.write(`${channel.name}/subscribeFail`, {
+                channel: channel.name,
+                error: err,
+                options
+            });
+            this.emit('subscribeFail', {
+                channel: channel.name,
+                error: err,
+                options
+            });
+        }
+    }
     trySubscribe(channel) {
-        const meetsAuthRequirements = !channel.options.waitForAuth || !!this._transport.signedAuthToken;
+        const hasAuthRequirements = !channel.options.waitForAuth || !!this._transport.signedAuthToken;
         // We can only ever have one pending subscribe action at any given time on a channel
-        if (this._transport.status === 'ready' &&
-            !this._preparingPendingSubscriptions &&
-            !channel.subscribePromise &&
-            meetsAuthRequirements) {
+        if (this._transport.status === 'ready'
+            && !this._preparingPendingSubscriptions
+            && !channel.subscribePromise
+            && hasAuthRequirements) {
             const subscriptionOptions = {};
             if (channel.options.waitForAuth) {
                 subscriptionOptions.waitForAuth = true;
@@ -44,7 +103,7 @@ export class ClientChannels extends Channels {
             if (channel.options.data) {
                 subscriptionOptions.data = channel.options.data;
             }
-            [channel.subscribePromise, channel.subscribeAbort] = this._transport.invoke({ method: '#subscribe', ackTimeoutMs: false }, {
+            [channel.subscribePromise, channel.subscribeAbort] = this._transport.invoke({ ackTimeoutMs: false, method: '#subscribe' }, {
                 channel: this.decorateChannelName(channel.name),
                 ...subscriptionOptions
             });
@@ -52,14 +111,15 @@ export class ClientChannels extends Channels {
                 delete channel.subscribePromise;
                 delete channel.subscribeAbort;
                 this.triggerChannelSubscribe(channel, subscriptionOptions);
-            }).catch(err => {
-                if (err.name === 'BadConnectionError') {
+            }).catch((err) => {
+                const error = toError(err);
+                if (error.name === 'BadConnectionError') {
                     // In case of a failed connection, keep the subscription
                     // as pending; it will try again on reconnect.
                     return;
                 }
-                if (err.name !== 'AbortError') {
-                    this.triggerChannelSubscribeFail(err, channel, subscriptionOptions);
+                if (error.name !== 'AbortError') {
+                    this.triggerChannelSubscribeFail(error, channel, subscriptionOptions);
                 }
                 delete channel.subscribePromise;
                 delete channel.subscribeAbort;
@@ -70,36 +130,6 @@ export class ClientChannels extends Channels {
             });
         }
     }
-    processPendingSubscriptions() {
-        this._preparingPendingSubscriptions = false;
-        const pendingChannels = [];
-        Object.keys(this._channelMap).forEach((channelName) => {
-            const channel = this._channelMap[channelName];
-            if (channel.state === 'pending') {
-                pendingChannels.push(channel);
-            }
-        });
-        pendingChannels.sort((a, b) => {
-            const ap = a.options.priority || 0;
-            const bp = b.options.priority || 0;
-            if (ap > bp) {
-                return -1;
-            }
-            if (ap < bp) {
-                return 1;
-            }
-            return 0;
-        });
-        pendingChannels.forEach((channel) => {
-            this.trySubscribe(channel);
-        });
-    }
-    unsubscribe(channelName) {
-        const channel = this._channelMap[channelName];
-        if (channel) {
-            this.tryUnsubscribe(channel);
-        }
-    }
     tryUnsubscribe(channel) {
         this.triggerChannelUnsubscribe(channel);
         if (this._transport.status === 'ready') {
@@ -112,38 +142,13 @@ export class ClientChannels extends Channels {
             // the operation on the server side.
             this._transport
                 .transmit('#unsubscribe', decoratedChannelName)
-                .catch(err => { });
+                .catch((_) => { });
         }
     }
-    triggerChannelSubscribeFail(err, channel, options) {
-        const meetsAuthRequirements = !channel.options.waitForAuth || !!this._transport.signedAuthToken;
-        const hasChannel = !!this._channelMap[channel.name];
-        if (hasChannel && meetsAuthRequirements) {
-            delete this._channelMap[channel.name];
-            this._channelEventDemux.write(`${channel.name}/subscribeFail`, {
-                channel: channel.name,
-                error: err,
-                options
-            });
-            this.emit('subscribeFail', {
-                error: err,
-                channel: channel.name,
-                options
-            });
+    unsubscribe(channelName) {
+        const channel = this._channelMap[channelName];
+        if (channel) {
+            this.tryUnsubscribe(channel);
         }
     }
-    transmitPublish(channelName, data) {
-        const pubData = {
-            channel: this.decorateChannelName(channelName),
-            data
-        };
-        return this._transport.transmit('#publish', pubData);
-    }
-    invokePublish(channelName, data) {
-        const pubData = {
-            channel: this.decorateChannelName(channelName),
-            data
-        };
-        return this._transport.invoke('#publish', pubData)[0];
-    }
 }

package/dist/client-socket-options.d.ts

@@ -1,24 +1,26 @@
-import ws from "isomorphic-ws";
-import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap, SocketOptions } from "@socket-mesh/core";
-import { ClientAuthEngine, LocalStorageAuthEngineOptions } from "./client-auth-engine.js";
-import { ClientPrivateMap } from "./maps/client-map.js";
-import { ServerPrivateMap } from "./maps/server-map.js";
+import { BaseSocketOptions } from '@socket-mesh/core';
+import ws from 'isomorphic-ws';
+import { ClientAuthEngine, LocalStorageAuthEngineOptions } from './client-auth-engine.js';
 export interface AutoReconnectOptions {
     initialDelay: number;
-    randomness: number;
-    multiplier: number;
     maxDelayMs: number;
+    multiplier: number;
+    randomness: number;
+}
+export interface ClientSocketOptions<TState extends object = {}> extends BaseSocketOptions<TState> {
+    address: string | URL;
+    authEngine?: ClientAuthEngine | LocalStorageAuthEngineOptions | null;
+    autoConnect?: boolean;
+    autoReconnect?: boolean | Partial<AutoReconnectOptions>;
+    autoSubscribeOnConnect?: boolean;
+    channelPrefix?: string;
+    connectTimeoutMs?: number;
+    wsOptions?: ws.ClientOptions;
 }
 export interface ConnectOptions {
     address?: string | URL;
     connectTimeoutMs?: number;
     wsOptions?: ws.ClientOptions;
 }
-export interface ClientSocketOptions<TOutgoing extends PublicMethodMap = {}, TService extends ServiceMap = {}, TIncoming extends MethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TState extends object = {}> extends SocketOptions<TIncoming & ClientPrivateMap, TOutgoing, TPrivateOutgoing & ServerPrivateMap, TService, TState>, ConnectOptions {
-    autoConnect?: boolean;
-    authEngine?: ClientAuthEngine | LocalStorageAuthEngineOptions | null;
-    autoReconnect?: Partial<AutoReconnectOptions> | boolean;
-    autoSubscribeOnConnect?: boolean;
-    channelPrefix?: string;
-}
-export declare function parseClientOptions<TIncoming extends MethodMap, TService extends ServiceMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TState extends object>(options: ClientSocketOptions<TOutgoing, TService, TIncoming, TPrivateOutgoing, TState> | string | URL): ClientSocketOptions<TOutgoing, TService, TIncoming, TPrivateOutgoing, TState>;
+export declare function parseAutoReconnectOptions(value?: boolean | Partial<AutoReconnectOptions>): AutoReconnectOptions | false;
+export declare function parseClientOptions<TState extends object>(options: ClientSocketOptions<TState> | string | URL): ClientSocketOptions<TState>;

package/dist/client-socket-options.js

@@ -1,6 +1,18 @@
+export function parseAutoReconnectOptions(value) {
+    if (value) {
+        return {
+            initialDelay: 10000,
+            maxDelayMs: 60000,
+            multiplier: 1.5,
+            randomness: 10000,
+            ...(value === true ? {} : value)
+        };
+    }
+    return false;
+}
 export function parseClientOptions(options) {
     if (typeof options === 'string' || 'pathname' in options) {
         options = { address: options };
     }
-    return Object.assign({}, options);
+    return { ...options };
 }

package/dist/client-socket.d.ts

@@ -1,27 +1,72 @@
-import { AutoReconnectOptions, ClientSocketOptions, ConnectOptions } from "./client-socket-options.js";
-import { SignedAuthToken } from "@socket-mesh/auth";
-import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap, Socket } from "@socket-mesh/core";
-import { ClientChannels } from "./client-channels.js";
-import { ClientPrivateMap } from "./maps/client-map.js";
-import { ChannelMap } from "@socket-mesh/channels";
-import { ServerPrivateMap } from "./maps/server-map.js";
-export declare class ClientSocket<TOutgoing extends PublicMethodMap = {}, TChannel extends ChannelMap = ChannelMap, TService extends ServiceMap = {}, TState extends object = {}, TIncoming extends MethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}> extends Socket<TIncoming & ClientPrivateMap, TOutgoing, TPrivateOutgoing & ServerPrivateMap, TService, TState> {
+import { SignedAuthToken } from '@socket-mesh/auth';
+import { ChannelMap } from '@socket-mesh/channels';
+import { AuthenticateEvent, AuthStateChangeEvent, BadAuthTokenEvent, BaseSocket, CloseEvent, ConnectEvent, ConnectingEvent, DeauthenticateEvent, DisconnectEvent, ErrorEvent, FunctionReturnType, InvokeMethodOptions, InvokeServiceOptions, MessageEvent, PingEvent, PongEvent, PrivateMethodMap, PublicMethodMap, RemoveAuthTokenEvent, RequestEvent, ResponseEvent, ServiceMap, ServiceMethodName, ServiceName, Socket, TypedRequestEvent, TypedResponseEvent, TypedSocketEvent } from '@socket-mesh/core';
+import { DemuxedConsumableStream, StreamEvent } from '@socket-mesh/stream-demux';
+import { ClientChannels } from './client-channels.js';
+import { AutoReconnectOptions, ClientSocketOptions, ConnectOptions } from './client-socket-options.js';
+import { ClientPrivateMap } from './maps/client-map.js';
+import { ServerPrivateMap } from './maps/server-map.js';
+export declare class ClientSocket<TIncoming extends PublicMethodMap = {}, TOutgoing extends PublicMethodMap = {}, TChannel extends ChannelMap = ChannelMap, TService extends ServiceMap = {}, TState extends object = {}, TPrivateOutgoing extends PrivateMethodMap = {}> extends BaseSocket<TState> implements Socket<TIncoming & ClientPrivateMap, TOutgoing, TState, TService, {}, TPrivateOutgoing & ServerPrivateMap> {
     private readonly _clientTransport;
-    readonly channels: ClientChannels<TChannel, TIncoming, TService, TOutgoing, TPrivateOutgoing, TState>;
+    readonly channels: ClientChannels<TChannel, TState>;
     constructor(address: string | URL);
-    constructor(options: ClientSocketOptions<TOutgoing, TService, TIncoming, TPrivateOutgoing, TState>);
+    constructor(options: ClientSocketOptions<TState>);
     authenticate(signedAuthToken: SignedAuthToken): Promise<void>;
     get autoReconnect(): AutoReconnectOptions | false;
-    set autoReconnect(value: Partial<AutoReconnectOptions> | boolean);
+    set autoReconnect(value: boolean | Partial<AutoReconnectOptions>);
     connect(options?: ConnectOptions): void;
     get connectTimeoutMs(): number;
     set connectTimeoutMs(timeoutMs: number);
     deauthenticate(): Promise<boolean>;
+    emit(event: 'request', data: TypedRequestEvent<TIncoming & ClientPrivateMap, TService>): void;
+    emit(event: 'response', data: TypedResponseEvent<TOutgoing, TPrivateOutgoing & ServerPrivateMap, TService>): void;
+    emit(event: 'authStateChange', data: AuthStateChangeEvent): void;
+    emit(event: 'authenticate', data: AuthenticateEvent): void;
+    emit(event: 'badAuthToken', data: BadAuthTokenEvent): void;
+    emit(event: 'close', data: CloseEvent): void;
+    emit(event: 'connect', data: ConnectEvent): void;
+    emit(event: 'connectAbort', data: DisconnectEvent): void;
+    emit(event: 'connecting', data: ConnectingEvent): void;
+    emit(event: 'deauthenticate', data: DeauthenticateEvent): void;
+    emit(event: 'disconnect', data: DisconnectEvent): void;
+    emit(event: 'end'): void;
+    emit(event: 'error', data: ErrorEvent): void;
+    emit(event: 'message', data: MessageEvent): void;
+    emit(event: 'ping', data: PingEvent): void;
+    emit(event: 'pong', data: PongEvent): void;
+    emit(event: 'removeAuthToken', data: RemoveAuthTokenEvent): void;
+    emit(event: 'request', data: RequestEvent): void;
+    emit(event: 'response', data: ResponseEvent): void;
+    invoke<TMethod extends keyof TOutgoing & string>(method: TMethod, arg?: Parameters<TOutgoing[TMethod]>[0]): Promise<FunctionReturnType<TOutgoing[TMethod]>>;
+    invoke<TServiceName extends ServiceName<TService>, TMethod extends ServiceMethodName<TService, TServiceName>>(options: [TServiceName, TMethod, (false | number)?], arg?: Parameters<TService[TServiceName][TMethod]>[0]): Promise<FunctionReturnType<TService[TServiceName][TMethod]>>;
+    invoke<TServiceName extends ServiceName<TService>, TMethod extends ServiceMethodName<TService, TServiceName>>(options: InvokeServiceOptions<TService, TServiceName, TMethod>, arg?: Parameters<TService[TServiceName][TMethod]>[0]): Promise<FunctionReturnType<TService[TServiceName][TMethod]>>;
+    invoke<TMethod extends keyof TOutgoing & string>(options: InvokeMethodOptions<TOutgoing, TMethod>, arg?: Parameters<TOutgoing[TMethod]>[0]): Promise<FunctionReturnType<TOutgoing[TMethod]>>;
     get isPingTimeoutDisabled(): boolean;
     set isPingTimeoutDisabled(isDisabled: boolean);
+    listen(): DemuxedConsumableStream<StreamEvent<TypedSocketEvent<TIncoming & ClientPrivateMap, TOutgoing, TPrivateOutgoing & ServerPrivateMap, TService>>>;
+    listen(event: 'authStateChange'): DemuxedConsumableStream<AuthStateChangeEvent>;
+    listen(event: 'authenticate'): DemuxedConsumableStream<AuthenticateEvent>;
+    listen(event: 'badAuthToken'): DemuxedConsumableStream<BadAuthTokenEvent>;
+    listen(event: 'close'): DemuxedConsumableStream<CloseEvent>;
+    listen(event: 'connect'): DemuxedConsumableStream<ConnectEvent>;
+    listen(event: 'connectAbort'): DemuxedConsumableStream<DisconnectEvent>;
+    listen(event: 'connecting'): DemuxedConsumableStream<ConnectingEvent>;
+    listen(event: 'deauthenticate'): DemuxedConsumableStream<DeauthenticateEvent>;
+    listen(event: 'disconnect'): DemuxedConsumableStream<DisconnectEvent>;
+    listen(event: 'end'): DemuxedConsumableStream<void>;
+    listen(event: 'error'): DemuxedConsumableStream<ErrorEvent>;
+    listen(event: 'message'): DemuxedConsumableStream<MessageEvent>;
+    listen(event: 'ping'): DemuxedConsumableStream<PingEvent>;
+    listen(event: 'pong'): DemuxedConsumableStream<PongEvent>;
+    listen(event: 'removeAuthToken'): DemuxedConsumableStream<RemoveAuthTokenEvent>;
+    listen(event: 'request'): DemuxedConsumableStream<TypedRequestEvent<TIncoming & ClientPrivateMap, TService>>;
+    listen(event: 'response'): DemuxedConsumableStream<TypedResponseEvent<TOutgoing, TPrivateOutgoing & ServerPrivateMap, TService>>;
+    listen<U extends TypedSocketEvent<TIncoming & ClientPrivateMap, TOutgoing, TPrivateOutgoing & ServerPrivateMap, TService>, V = U>(event: string): DemuxedConsumableStream<V>;
     get pingTimeoutMs(): number;
     set pingTimeoutMs(timeoutMs: number);
     reconnect(code?: number, reason?: string): void;
+    transmit<TMethod extends keyof TOutgoing & string>(method: TMethod, arg?: Parameters<TOutgoing[TMethod]>[0]): Promise<void>;
+    transmit<TServiceName extends ServiceName<TService>, TMethod extends ServiceMethodName<TService, TServiceName>>(options: [TServiceName, TMethod], arg?: Parameters<TService[TServiceName][TMethod]>[0]): Promise<void>;
     get type(): 'client';
     get uri(): URL;
 }

package/dist/client-socket.js

@@ -1,21 +1,23 @@
-import { ClientTransport } from "./client-transport.js";
-import { parseClientOptions } from "./client-socket-options.js";
-import { setAuthTokenHandler } from "./handlers/set-auth-token.js";
-import { removeAuthTokenHandler } from "./handlers/remove-auth-token.js";
-import { hydrateError } from "@socket-mesh/errors";
-import { Socket, wait } from "@socket-mesh/core";
-import { ClientChannels } from "./client-channels.js";
-import { publishHandler } from "./handlers/publish.js";
-import { kickOutHandler } from "./handlers/kickout.js";
-export class ClientSocket extends Socket {
+import { BaseSocket, toError, wait } from '@socket-mesh/core';
+import { hydrateError } from '@socket-mesh/errors';
+import { ClientChannels } from './client-channels.js';
+import { parseClientOptions } from './client-socket-options.js';
+import { ClientTransport } from './client-transport.js';
+import { kickOutHandler } from './handlers/kickout.js';
+import { publishHandler } from './handlers/publish.js';
+import { removeAuthTokenHandler } from './handlers/remove-auth-token.js';
+import { setAuthTokenHandler } from './handlers/set-auth-token.js';
+export class ClientSocket extends BaseSocket {
+    _clientTransport;
+    channels;
     constructor(options) {
         options = parseClientOptions(options);
         options.handlers =
             Object.assign({
-                "#kickOut": kickOutHandler,
-                "#publish": publishHandler,
-                "#setAuthToken": setAuthTokenHandler,
-                "#removeAuthToken": removeAuthTokenHandler
+                '#kickOut': kickOutHandler,
+                '#publish': publishHandler,
+                '#removeAuthToken': removeAuthTokenHandler,
+                '#setAuthToken': setAuthTokenHandler
             }, options.handlers);
         const clientTransport = new ClientTransport(options);
         super(clientTransport, options);
@@ -33,14 +35,15 @@ export class ClientSocket extends Socket {
             await wait(0);
         }
         catch (err) {
-            if (err.name !== 'BadConnectionError' && err.name !== 'TimeoutError') {
+            const error = toError(err);
+            if (error.name !== 'BadConnectionError' && error.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.
                 await this._clientTransport.changeToUnauthenticatedState();
                 // In order for the events to trigger we need to wait for the next tick.
                 await wait(0);
             }
-            throw hydrateError(err);
+            throw hydrateError(error);
         }
     }
     get autoReconnect() {
@@ -65,22 +68,33 @@ export class ClientSocket extends Socket {
                 oldAuthToken = await this._clientTransport.authEngine.removeToken();
             }
             catch (err) {
-                this._clientTransport.onError(err);
+                this._clientTransport.onError(toError(err));
                 return;
             }
-            this.emit('removeAuthToken', { oldAuthToken });
+            if (oldAuthToken) {
+                this.emit('removeAuthToken', { oldAuthToken });
+            }
         })();
         if (this.status !== 'closed') {
             await this._clientTransport.transmit('#removeAuthToken');
         }
         return await super.deauthenticate();
     }
+    emit(event, data) {
+        super.emit(event, data);
+    }
+    invoke(methodOptions, arg) {
+        return super.invoke(methodOptions, arg);
+    }
     get isPingTimeoutDisabled() {
         return this._clientTransport.isPingTimeoutDisabled;
     }
     set isPingTimeoutDisabled(isDisabled) {
         this._clientTransport.isPingTimeoutDisabled = isDisabled;
     }
+    listen(event) {
+        return super.listen(event ?? '');
+    }
     get pingTimeoutMs() {
         return this._clientTransport.pingTimeoutMs;
     }
@@ -91,6 +105,9 @@ export class ClientSocket extends Socket {
         this.disconnect(code, reason);
         this.connect();
     }
+    transmit(serviceAndMethod, arg) {
+        return super.transmit(serviceAndMethod, arg);
+    }
     get type() {
         return this._clientTransport.type;
     }