@socket-mesh/client 18.1.6 → 19.0.0

package/dist/client-channels.d.ts

@@ -1,14 +1,15 @@
 import { ChannelDetails, ChannelMap, Channels, ChannelsOptions } from '@socket-mesh/channels';
-import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from '@socket-mesh/core';
+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> {
+export declare class ClientChannels<TChannel extends ChannelMap, TState extends object = {}> extends Channels<TChannel> {
     protected _preparingPendingSubscriptions: boolean;
-    protected readonly _transport: ClientTransport<TIncoming, TService, TOutgoing, TPrivateOutgoing, TState>;
+    protected readonly _transport: SocketTransport<{}, {}, TState, {}, {}, ServerPrivateMap>;
     autoSubscribeOnConnect: boolean;
-    constructor(transport: ClientTransport<TIncoming, TService, TOutgoing, TPrivateOutgoing, TState>, options?: ClientChannelsOptions);
+    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;

package/dist/client-channels.js

@@ -1,4 +1,5 @@
 import { Channels } from '@socket-mesh/channels';
+import { toError } from '@socket-mesh/core';
 export class ClientChannels extends Channels {
     _preparingPendingSubscriptions;
     _transport;
@@ -111,13 +112,14 @@ export class ClientChannels extends Channels {
                 delete channel.subscribeAbort;
                 this.triggerChannelSubscribe(channel, subscriptionOptions);
             }).catch((err) => {
-                if (err.name === 'BadConnectionError') {
+                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;
@@ -140,7 +142,7 @@ export class ClientChannels extends Channels {
             // the operation on the server side.
             this._transport
                 .transmit('#unsubscribe', decoratedChannelName)
-                .catch((err) => { });
+                .catch((_) => { });
         }
     }
     unsubscribe(channelName) {

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

@@ -1,15 +1,13 @@
-import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap, SocketOptions } from '@socket-mesh/core';
+import { BaseSocketOptions } from '@socket-mesh/core';
 import ws from 'isomorphic-ws';
 import { ClientAuthEngine, LocalStorageAuthEngineOptions } from './client-auth-engine.js';
-import { ClientPrivateMap } from './maps/client-map.js';
-import { ServerPrivateMap } from './maps/server-map.js';
 export interface AutoReconnectOptions {
     initialDelay: number;
     maxDelayMs: number;
     multiplier: number;
     randomness: number;
 }
-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> {
+export interface ClientSocketOptions<TState extends object = {}> extends BaseSocketOptions<TState> {
     address: string | URL;
     authEngine?: ClientAuthEngine | LocalStorageAuthEngineOptions | null;
     autoConnect?: boolean;
@@ -24,4 +22,5 @@ export interface ConnectOptions {
     connectTimeoutMs?: number;
     wsOptions?: ws.ClientOptions;
 }
-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,3 +1,15 @@
+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 };

package/dist/client-socket.d.ts

@@ -1,15 +1,16 @@
 import { SignedAuthToken } from '@socket-mesh/auth';
 import { ChannelMap } from '@socket-mesh/channels';
-import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap, Socket } from '@socket-mesh/core';
+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<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> {
+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: boolean | Partial<AutoReconnectOptions>);
@@ -17,11 +18,55 @@ export declare class ClientSocket<TOutgoing extends PublicMethodMap = {}, TChann
     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,4 +1,4 @@
-import { Socket, wait } from '@socket-mesh/core';
+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';
@@ -7,7 +7,7 @@ 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 Socket {
+export class ClientSocket extends BaseSocket {
     _clientTransport;
     channels;
     constructor(options) {
@@ -35,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() {
@@ -67,7 +68,7 @@ export class ClientSocket extends Socket {
                 oldAuthToken = await this._clientTransport.authEngine.removeToken();
             }
             catch (err) {
-                this._clientTransport.onError(err);
+                this._clientTransport.onError(toError(err));
                 return;
             }
             if (oldAuthToken) {
@@ -79,12 +80,21 @@ export class ClientSocket extends Socket {
         }
         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;
     }
@@ -95,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;
     }

package/dist/client-transport.d.ts

@@ -1,11 +1,9 @@
 import { AuthToken } from '@socket-mesh/auth';
-import { FunctionReturnType, InvokeMethodOptions, InvokeServiceOptions, MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap, SocketStatus, SocketTransport } from '@socket-mesh/core';
+import { BaseSocketTransport, InvokeMethodOptions, InvokeServiceOptions, SocketStatus, SocketTransport } from '@socket-mesh/core';
 import ws from 'isomorphic-ws';
 import { ClientAuthEngine } from './client-auth-engine.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 ClientTransport<TIncoming extends MethodMap, TService extends ServiceMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TState extends object> extends SocketTransport<TIncoming & ClientPrivateMap, TOutgoing, TPrivateOutgoing & ServerPrivateMap, TService, TState> {
+export declare class ClientTransport<TState extends object = {}> extends BaseSocketTransport<TState> implements SocketTransport<{}, {}, TState> {
     private _autoReconnect;
     private _connectAttempts;
     private _connectTimeoutRef;
@@ -17,19 +15,14 @@ export declare class ClientTransport<TIncoming extends MethodMap, TService exten
     connectTimeoutMs: number;
     isPingTimeoutDisabled: boolean;
     type: 'client';
-    constructor(options: ClientSocketOptions<TOutgoing, TService, TIncoming, TPrivateOutgoing, TState>);
+    constructor(options: ClientSocketOptions<TState>);
     get autoReconnect(): AutoReconnectOptions | false;
     set autoReconnect(value: boolean | Partial<AutoReconnectOptions>);
     connect(options?: ConnectOptions): void;
     get connectAttempts(): number;
     disconnect(code?: number, reason?: string): void;
     private handshake;
-    invoke<TMethod extends keyof TOutgoing>(method: TMethod, arg?: Parameters<TOutgoing[TMethod]>[0]): [Promise<FunctionReturnType<TOutgoing[TMethod]>>, () => void];
-    invoke<TServiceName extends keyof TService, TMethod extends keyof TService[TServiceName]>(options: [TServiceName, TMethod, (false | number)?], arg?: Parameters<TService[TServiceName][TMethod]>[0]): [Promise<FunctionReturnType<TService[TServiceName][TMethod]>>, () => void];
-    invoke<TServiceName extends keyof TService, TMethod extends keyof TService[TServiceName]>(options: InvokeServiceOptions<TService, TServiceName, TMethod>, arg?: Parameters<TService[TServiceName][TMethod]>[0]): [Promise<FunctionReturnType<TService[TServiceName][TMethod]>>, () => void];
-    invoke<TMethod extends keyof TOutgoing>(options: InvokeMethodOptions<TOutgoing, TMethod>, arg?: Parameters<TOutgoing[TMethod]>[0]): [Promise<FunctionReturnType<TOutgoing[TMethod]>>, () => void];
-    invoke<TMethod extends keyof (TPrivateOutgoing & ServerPrivateMap)>(method: TMethod, arg: Parameters<(TPrivateOutgoing & ServerPrivateMap)[TMethod]>[0]): [Promise<FunctionReturnType<(TPrivateOutgoing & ServerPrivateMap)[TMethod]>>, () => void];
-    invoke<TMethod extends keyof (TPrivateOutgoing & ServerPrivateMap)>(options: InvokeMethodOptions<(TPrivateOutgoing & ServerPrivateMap), TMethod>, arg?: Parameters<(TPrivateOutgoing & ServerPrivateMap)[TMethod]>[0]): [Promise<FunctionReturnType<(TPrivateOutgoing & ServerPrivateMap)[TMethod]>>, () => void];
+    invoke(methodOptions: [string, string, (false | number)?] | InvokeMethodOptions | InvokeServiceOptions | string, arg?: unknown): [Promise<unknown>, () => void];
     protected onClose(code: number, reason?: Buffer): void;
     protected onOpen(): void;
     protected onPingPong(): void;
@@ -40,9 +33,7 @@ export declare class ClientTransport<TIncoming extends MethodMap, TService exten
     send(data: Buffer | string): Promise<void>;
     setAuthorization(signedAuthToken: string, authToken?: AuthToken): Promise<boolean>;
     get status(): SocketStatus;
-    transmit<TMethod extends keyof TOutgoing>(method: TMethod, arg?: Parameters<TOutgoing[TMethod]>[0]): Promise<void>;
-    transmit<TServiceName extends keyof TService, TMethod extends keyof TService[TServiceName]>(options: [TServiceName, TMethod], arg?: Parameters<TService[TServiceName][TMethod]>[0]): Promise<void>;
-    transmit<TMethod extends keyof (TPrivateOutgoing & ServerPrivateMap)>(method: TMethod, arg?: Parameters<(TPrivateOutgoing & ServerPrivateMap)[TMethod]>[0]): Promise<void>;
+    transmit(serviceAndMethod: [string, string] | string, arg?: unknown): Promise<void>;
     private tryReconnect;
     get uri(): URL;
     protected get webSocket(): null | ws.WebSocket;

package/dist/client-transport.js

@@ -1,11 +1,12 @@
-import { SocketTransport } from '@socket-mesh/core';
+import { BaseSocketTransport, toError } from '@socket-mesh/core';
 import { hydrateError, SocketClosedError, SocketProtocolErrorStatuses } from '@socket-mesh/errors';
 import ws from 'isomorphic-ws';
 import { isAuthEngine, LocalStorageAuthEngine } from './client-auth-engine.js';
-export class ClientTransport extends SocketTransport {
+import { parseAutoReconnectOptions } from './client-socket-options.js';
+export class ClientTransport extends BaseSocketTransport {
     _autoReconnect;
     _connectAttempts;
-    _connectTimeoutRef;
+    _connectTimeoutRef = null;
     _pendingReconnectTimeout;
     _pingTimeoutMs;
     _uri;
@@ -29,25 +30,14 @@ export class ClientTransport extends SocketTransport {
         }
         this._connectAttempts = 0;
         this._pendingReconnectTimeout = null;
-        this.autoReconnect = options.autoReconnect ?? false;
+        this._autoReconnect = parseAutoReconnectOptions(options.autoReconnect);
         this.isPingTimeoutDisabled = (options.isPingTimeoutDisabled === true);
     }
     get autoReconnect() {
         return this._autoReconnect;
     }
     set autoReconnect(value) {
-        if (value) {
-            this._autoReconnect = {
-                initialDelay: 10000,
-                maxDelayMs: 60000,
-                multiplier: 1.5,
-                randomness: 10000,
-                ...(value === true ? {} : value)
-            };
-        }
-        else {
-            this._autoReconnect = false;
-        }
+        this._autoReconnect = parseAutoReconnectOptions(value);
     }
     connect(options) {
         let timeoutMs = this.connectTimeoutMs;
@@ -173,11 +163,10 @@ export class ClientTransport extends SocketTransport {
             this.setReadyStatus(this.pingTimeoutMs, authError);
         })
             .catch((err) => {
-            if (err.statusCode == null) {
-                err.statusCode = 4003;
-            }
-            this.onError(err);
-            this.disconnect(err.statusCode, err.toString());
+            const error = toError(err);
+            const statusCode = (err != null && typeof err === 'object' && 'statusCode' in err) ? err.statusCode : 4003;
+            this.onError(error);
+            this.disconnect(statusCode, error.toString());
         });
     }
     onPingPong() {

package/dist/handlers/kickout.d.ts

@@ -2,6 +2,5 @@ import { ChannelMap } from '@socket-mesh/channels';
 import { RequestHandlerArgs } from '@socket-mesh/core';
 import { ClientSocket } from '../client-socket.js';
 import { ClientTransport } from '../client-transport.js';
-import { ClientPrivateMap, KickOutOptions } from '../maps/client-map.js';
-import { ServerPrivateMap } from '../maps/server-map.js';
-export declare function kickOutHandler({ options, socket }: RequestHandlerArgs<KickOutOptions, ClientPrivateMap, {}, ServerPrivateMap, {}, {}, ClientSocket<{}, ChannelMap>, ClientTransport<{}, {}, {}, {}, {}>>): Promise<void>;
+import { KickOutOptions } from '../maps/client-map.js';
+export declare function kickOutHandler({ options, socket }: RequestHandlerArgs<KickOutOptions, {}, ClientSocket<{}, {}, ChannelMap>, ClientTransport<{}>>): Promise<void>;

package/dist/handlers/publish.d.ts

@@ -2,6 +2,4 @@ import { ChannelMap, PublishOptions } from '@socket-mesh/channels';
 import { RequestHandlerArgs } from '@socket-mesh/core';
 import { ClientSocket } from '../client-socket.js';
 import { ClientTransport } from '../client-transport.js';
-import { ClientPrivateMap } from '../maps/client-map.js';
-import { ServerPrivateMap } from '../maps/server-map.js';
-export declare function publishHandler({ options, socket }: RequestHandlerArgs<PublishOptions, ClientPrivateMap, {}, ServerPrivateMap, {}, {}, ClientSocket<{}, ChannelMap>, ClientTransport<{}, {}, {}, {}, {}>>): Promise<void>;
+export declare function publishHandler({ options, socket }: RequestHandlerArgs<PublishOptions, {}, ClientSocket<{}, {}, ChannelMap>, ClientTransport<{}>>): Promise<void>;

package/dist/plugins/batching-plugin.d.ts

@@ -1,17 +1,17 @@
-import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from '@socket-mesh/core';
 import { Plugin, SendRequestPluginArgs, SendResponsePluginArgs } from '@socket-mesh/core';
-export interface BatchingPluginOptions {
+export interface BatchingPluginOptions<TType = string> {
     batchInterval?: number;
     batchOnHandshakeDuration?: false | number;
+    type: TType;
 }
-export declare abstract class BatchingPlugin<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> implements Plugin<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> {
+export declare abstract class BatchingPlugin<TType extends string> implements Plugin {
     private _batchingIntervalId;
     private _handshakeTimeoutId;
     private _isBatching;
     batchInterval: number;
     batchOnHandshakeDuration: boolean | number;
-    type: string;
-    constructor(options?: BatchingPluginOptions);
+    type: TType;
+    constructor(options: BatchingPluginOptions<TType>);
     cancelBatching(): void;
     protected abstract flush(): void;
     get isBatching(): boolean;
@@ -22,20 +22,18 @@ export declare abstract class BatchingPlugin<TIncoming extends MethodMap, TOutgo
     private stop;
     stopBatching(): void;
 }
-export declare class RequestBatchingPlugin<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> extends BatchingPlugin<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> {
+export declare class RequestBatchingPlugin extends BatchingPlugin<'requestBatching'> {
     private _continue;
     private _requests;
-    type: 'requestBatching';
-    constructor(options?: BatchingPluginOptions);
+    constructor(options?: Omit<BatchingPluginOptions, 'type'>);
     cancelBatching(): void;
     protected flush(): void;
-    sendRequest({ cont, requests }: SendRequestPluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): void;
+    sendRequest({ cont, requests }: SendRequestPluginArgs): void;
 }
-export declare class ResponseBatchingPlugin<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> extends BatchingPlugin<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> {
+export declare class ResponseBatchingPlugin extends BatchingPlugin<'responseBatching'> {
     private _continue;
     private _responses;
-    type: 'responseBatching';
-    constructor(options?: BatchingPluginOptions);
+    constructor(options?: Omit<BatchingPluginOptions, 'type'>);
     protected flush(): void;
-    sendResponse({ cont, responses }: SendResponsePluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): void;
+    sendResponse({ cont, responses }: SendResponsePluginArgs): void;
 }

package/dist/plugins/batching-plugin.js

@@ -7,8 +7,9 @@ export class BatchingPlugin {
     type;
     constructor(options) {
         this._isBatching = false;
-        this.batchInterval = options?.batchInterval || 50;
-        this.batchOnHandshakeDuration = options?.batchOnHandshakeDuration ?? false;
+        this.type = options.type;
+        this.batchInterval = options.batchInterval || 50;
+        this.batchOnHandshakeDuration = options.batchOnHandshakeDuration ?? false;
         this._batchingIntervalId = null;
         this._handshakeTimeoutId = null;
     }
@@ -67,10 +68,11 @@ export class BatchingPlugin {
 export class RequestBatchingPlugin extends BatchingPlugin {
     _continue;
     _requests;
-    type;
     constructor(options) {
-        super(options);
-        this.type = 'requestBatching';
+        super({
+            ...(options ?? {}),
+            type: 'requestBatching'
+        });
         this._requests = [];
         this._continue = null;
     }
@@ -100,10 +102,11 @@ export class RequestBatchingPlugin extends BatchingPlugin {
 export class ResponseBatchingPlugin extends BatchingPlugin {
     _continue;
     _responses;
-    type;
     constructor(options) {
-        super(options);
-        this.type = 'responseBatching';
+        super({
+            ...(options ?? {}),
+            type: 'responseBatching'
+        });
         this._responses = [];
         this._continue = null;
     }

package/dist/plugins/in-order-plugin.d.ts

@@ -1,10 +1,10 @@
-import { MessageRawPluginArgs, MethodMap, Plugin, PluginArgs, PrivateMethodMap, PublicMethodMap, ServiceMap } from '@socket-mesh/core';
+import { MessageRawPluginArgs, Plugin, PluginArgs } from '@socket-mesh/core';
 import { RawData } from 'ws';
-export declare class InOrderPlugin<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> implements Plugin<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> {
+export declare class InOrderPlugin implements Plugin {
     private readonly _inboundMessageStream;
     type: 'inOrder';
     constructor();
     handleInboundMessageStream(): void;
-    onEnd({ transport }: PluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): void;
-    onMessageRaw(options: MessageRawPluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): Promise<RawData | string>;
+    onEnd({ transport }: PluginArgs): void;
+    onMessageRaw(options: MessageRawPluginArgs): Promise<RawData | string>;
 }

package/dist/plugins/in-order-plugin.js

@@ -6,6 +6,7 @@ export class InOrderPlugin {
     constructor() {
         this._inboundMessageStream = new WritableConsumableStream();
         // this._outboundMessageStream = new WritableConsumableStream<SendRequestPluginArgs<T>>;
+        this.type = 'inOrder';
         this.handleInboundMessageStream();
         // this.handleOutboundMessageStream();
     }

package/dist/plugins/offline-plugin.d.ts

@@ -1,5 +1,5 @@
-import { MethodMap, Plugin, PrivateMethodMap, PublicMethodMap, SendRequestPluginArgs, ServiceMap } from '@socket-mesh/core';
-export declare class OfflinePlugin<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> implements Plugin<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> {
+import { Plugin, SendRequestPluginArgs } from '@socket-mesh/core';
+export declare class OfflinePlugin implements Plugin {
     private _continue;
     private _isReady;
     private _requests;
@@ -9,5 +9,5 @@ export declare class OfflinePlugin<TIncoming extends MethodMap, TOutgoing extend
     onClose(): void;
     onDisconnected(): void;
     onReady(): void;
-    sendRequest({ cont, requests }: SendRequestPluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): void;
+    sendRequest({ cont, requests }: SendRequestPluginArgs): void;
 }

package/dist/plugins/offline-plugin.js

@@ -37,10 +37,10 @@ export class OfflinePlugin {
             cont(requests);
             return;
         }
-        const systemRequests = requests.filter(item => SYSTEM_METHODS.indexOf(String(item.method)) > -1);
+        const systemRequests = requests.filter(item => SYSTEM_METHODS.indexOf(item.method) > -1);
         let otherRequests = requests;
         if (systemRequests.length) {
-            otherRequests = (systemRequests.length === requests.length) ? [] : requests.filter(item => SYSTEM_METHODS.indexOf(String(item.method)) < 0);
+            otherRequests = (systemRequests.length === requests.length) ? [] : requests.filter(item => SYSTEM_METHODS.indexOf(item.method) < 0);
         }
         if (otherRequests.length) {
             this._continue = cont;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@socket-mesh/client",
 	"description": "A TCP socket pair for easily transmitting full messages without worrying about request size limits.",
-	"version": "18.1.6",
+	"version": "19.0.0",
 	"type": "module",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",