@socket-mesh/core 1.0.2 → 1.0.3

package/dist/maps/handler-map.d.ts

@@ -1,5 +1,5 @@
 import { RequestHandler } from "../request-handler.js";
-import { SocketMap } from "./socket-map.js";
-export type HandlerMap<T extends SocketMap> = Partial<{
-    [K in keyof T['Incoming']]: RequestHandler<Parameters<T['Incoming'][K]>[0], ReturnType<T['Incoming'][K]>, T>;
+import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from "./method-map.js";
+export type HandlerMap<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> = Partial<{
+    [K in keyof TIncoming]: RequestHandler<Parameters<TIncoming[K]>[0], ReturnType<TIncoming[K]>, TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>;
 }>;

package/dist/maps/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./handler-map.js";
 export * from "./method-map.js";
-export * from "./socket-map.js";

package/dist/maps/index.js

@@ -1,3 +1,2 @@
 export * from "./handler-map.js";
 export * from "./method-map.js";
-export * from "./socket-map.js";

package/dist/packet.d.ts

@@ -1,6 +1,5 @@
 import { MethodMap, ServiceMap } from "./maps/method-map.js";
-import { SocketMap } from "./maps/socket-map.js";
-export type AnyPacket<T extends SocketMap> = ServicePacket<T['Service']> | MethodPacket<T['Incoming']>;
+export type AnyPacket<TIncoming extends MethodMap, TService extends ServiceMap> = ServicePacket<TService> | MethodPacket<TIncoming>;
 export type ServicePacket<TServiceMap extends ServiceMap> = {
     [TService in keyof TServiceMap]: {
         [TMethod in keyof TServiceMap[TService]]: ServiceRequestPacket<TServiceMap, TService, TMethod>;
@@ -23,5 +22,5 @@ export interface MethodRequestPacket<TMethodMap extends MethodMap, TMethod exten
     data: Parameters<TMethodMap[TMethod]>[0];
     ackTimeoutMs?: number | boolean;
 }
-export declare function isRequestPacket<T extends SocketMap>(packet: unknown): packet is AnyPacket<T>;
+export declare function isRequestPacket<TIncoming extends MethodMap, TService extends ServiceMap>(packet: unknown): packet is AnyPacket<TIncoming, TService>;
 export {};

package/dist/plugins/plugin.d.ts

@@ -1,4 +1,3 @@
-import { EmptySocketMap, SocketMap } from "../maps/socket-map.js";
 import { AnyPacket } from "../packet.js";
 import { AnyRequest } from "../request.js";
 import { AnyResponse } from "../response.js";
@@ -6,45 +5,46 @@ import { SocketTransport } from "../socket-transport.js";
 import { Socket, SocketStatus } from "../socket.js";
 import ws from "isomorphic-ws";
 import { HandlerMap } from "../maps/handler-map.js";
+import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from "../maps/method-map.js";
 export type PluginType = 'request' | 'response' | 'handshake';
-export interface PluginArgs<T extends SocketMap = EmptySocketMap> {
-    socket: Socket<T>;
-    transport: SocketTransport<T>;
+export interface PluginArgs<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> {
+    socket: Socket<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>;
+    transport: SocketTransport<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>;
 }
-export interface DisconnectedPluginArgs<T extends SocketMap = EmptySocketMap> extends PluginArgs<T> {
+export interface DisconnectedPluginArgs<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> extends PluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> {
     status: SocketStatus;
     code: number;
     reason?: string;
 }
-export interface MessagePluginArgs<T extends SocketMap = EmptySocketMap> extends PluginArgs<T> {
+export interface MessagePluginArgs<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> extends PluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> {
     timestamp: Date;
-    packet: AnyPacket<T> | AnyResponse<T>;
+    packet: AnyPacket<TIncoming, TService> | AnyResponse<TOutgoing, TPrivateOutgoing, TService>;
 }
-export interface MessageRawPluginArgs<T extends SocketMap = EmptySocketMap> extends PluginArgs<T> {
+export interface MessageRawPluginArgs<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> extends PluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> {
     timestamp: Date;
     message: ws.RawData | string;
     promise: Promise<void>;
 }
-export interface SendRequestPluginArgs<T extends SocketMap = EmptySocketMap> extends PluginArgs<T> {
-    requests: AnyRequest<T>[];
-    cont: (requests: AnyRequest<T>[]) => void;
+export interface SendRequestPluginArgs<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> extends PluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> {
+    requests: AnyRequest<TOutgoing, TPrivateOutgoing, TService>[];
+    cont: (requests: AnyRequest<TOutgoing, TPrivateOutgoing, TService>[]) => void;
 }
-export interface SendResponsePluginArgs<T extends SocketMap = EmptySocketMap> extends PluginArgs<T> {
-    responses: AnyResponse<T>[];
-    cont: (requests: AnyResponse<T>[]) => void;
+export interface SendResponsePluginArgs<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> extends PluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> {
+    responses: AnyResponse<TOutgoing, TPrivateOutgoing, TService>[];
+    cont: (requests: AnyResponse<TOutgoing, TPrivateOutgoing, TService>[]) => void;
 }
-export interface Plugin<T extends SocketMap = EmptySocketMap> {
+export interface Plugin<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> {
     type: string;
-    handlers?: HandlerMap<T>;
-    onAuthenticated?(options: PluginArgs<T>): void;
-    onClose?(options: PluginArgs<T>): void;
-    onDeauthenticate?(options: PluginArgs<T>): void;
-    onDisconnected?(options: DisconnectedPluginArgs<T>): void;
-    onEnd?(options: PluginArgs<T>): void;
-    onMessage?(options: MessagePluginArgs<T>): Promise<AnyPacket<T> | AnyResponse<T>>;
-    onMessageRaw?(options: MessageRawPluginArgs<T>): Promise<ws.RawData | string>;
-    onOpen?(options: PluginArgs<T>): void;
-    onReady?(options: PluginArgs<T>): void;
-    sendRequest?(options: SendRequestPluginArgs<T>): void;
-    sendResponse?(options: SendResponsePluginArgs<T>): void;
+    handlers?: HandlerMap<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>;
+    onAuthenticated?(options: PluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): void;
+    onClose?(options: PluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): void;
+    onDeauthenticate?(options: PluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): void;
+    onDisconnected?(options: DisconnectedPluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): void;
+    onEnd?(options: PluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): void;
+    onMessage?(options: MessagePluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): Promise<AnyPacket<TIncoming, TService> | AnyResponse<TOutgoing, TPrivateOutgoing, TService>>;
+    onMessageRaw?(options: MessageRawPluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): Promise<ws.RawData | string>;
+    onOpen?(options: PluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): void;
+    onReady?(options: PluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): void;
+    sendRequest?(options: SendRequestPluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): void;
+    sendResponse?(options: SendResponsePluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): void;
 }

package/dist/request-handler.d.ts

@@ -1,7 +1,7 @@
 import { Socket } from "./socket.js";
 import { SocketTransport } from "./socket-transport.js";
-import { EmptySocketMap, SocketMap } from "./maps/socket-map.js";
-export interface RequestHandlerArgsOptions<TOptions, T extends SocketMap, TSocket extends Socket<T> = Socket<T>, TTransport extends SocketTransport<T> = SocketTransport<T>> {
+import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from "./maps/method-map.js";
+export interface RequestHandlerArgsOptions<TOptions, TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object, TSocket extends Socket<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> = Socket<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>, TTransport extends SocketTransport<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> = SocketTransport<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>> {
     isRpc: boolean;
     method: string;
     socket: TSocket;
@@ -9,7 +9,7 @@ export interface RequestHandlerArgsOptions<TOptions, T extends SocketMap, TSocke
     timeoutMs?: number | boolean;
     options?: TOptions;
 }
-export declare class RequestHandlerArgs<TOptions, T extends SocketMap = EmptySocketMap, TSocket extends Socket<T> = Socket<T>, TTransport extends SocketTransport<T> = SocketTransport<T>> {
+export declare class RequestHandlerArgs<TOptions, TIncoming extends MethodMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TService extends ServiceMap = {}, TState extends object = {}, TSocket extends Socket<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> = Socket<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>, TTransport extends SocketTransport<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> = SocketTransport<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>> {
     isRpc: boolean;
     method: string;
     options: TOptions;
@@ -17,8 +17,8 @@ export declare class RequestHandlerArgs<TOptions, T extends SocketMap = EmptySoc
     socket: TSocket;
     timeoutMs?: number | boolean;
     transport: TTransport;
-    constructor(options: RequestHandlerArgsOptions<TOptions, T, TSocket, TTransport>);
+    constructor(options: RequestHandlerArgsOptions<TOptions, TIncoming, TOutgoing, TPrivateOutgoing, TService, TState, TSocket, TTransport>);
     checkTimeout(timeLeftMs?: number): void;
     getRemainingTimeMs(): number;
 }
-export type RequestHandler<TOptions, U, T extends SocketMap, TSocket extends Socket<T> = Socket<T>, TTransport extends SocketTransport<T> = SocketTransport<T>> = (args: RequestHandlerArgs<TOptions, T, TSocket, TTransport>) => Promise<U>;
+export type RequestHandler<TOptions, U, TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object, TSocket extends Socket<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> = Socket<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>, TTransport extends SocketTransport<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> = SocketTransport<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>> = (args: RequestHandlerArgs<TOptions, TIncoming, TOutgoing, TPrivateOutgoing, TService, TState, TSocket, TTransport>) => Promise<U>;

package/dist/request.d.ts

@@ -1,17 +1,16 @@
-import { MethodMap, ServiceMap } from "./maps/method-map.js";
-import { SocketMap } from "./maps/socket-map.js";
-export type AnyRequest<T extends SocketMap> = ServiceRequest<T['Service']> | MethodRequest<T['PrivateOutgoing']> | MethodRequest<T['Outgoing']>;
-export declare function abortRequest<T extends SocketMap>(request: AnyRequest<T>, err: Error): void;
-export declare class RequestCollection<T extends SocketMap> {
+import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from "./maps/method-map.js";
+export type AnyRequest<TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap> = ServiceRequest<TService> | MethodRequest<TPrivateOutgoing> | MethodRequest<TOutgoing>;
+export declare function abortRequest<TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap>(request: AnyRequest<TOutgoing, TPrivateOutgoing, TService>, err: Error): void;
+export declare class RequestCollection<TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap> {
     private readonly _requests;
     private readonly _callbacks;
-    constructor(requests: AnyRequest<T> | AnyRequest<T>[]);
-    get items(): ReadonlyArray<AnyRequest<T>>;
+    constructor(requests: AnyRequest<TOutgoing, TPrivateOutgoing, TService> | AnyRequest<TOutgoing, TPrivateOutgoing, TService>[]);
+    get items(): ReadonlyArray<AnyRequest<TOutgoing, TPrivateOutgoing, TService>>;
     listen(cb: () => void): void;
     isDone(): boolean;
     [Symbol.iterator](): {
         next(): {
-            value: AnyRequest<T>;
+            value: AnyRequest<TOutgoing, TPrivateOutgoing, TService>;
             done: boolean;
         } | {
             done: boolean;
@@ -52,4 +51,4 @@ export interface InvokeMethodRequest<TMethodMap extends MethodMap, TMethod exten
     timeoutId?: NodeJS.Timeout;
     callback: (err: Error, result?: TMethodMap[TMethod]) => void | null;
 }
-export declare function isRequestDone<T extends SocketMap>(request: AnyRequest<T>): boolean;
+export declare function isRequestDone<TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap>(request: AnyRequest<TOutgoing, TPrivateOutgoing, TService>): boolean;

package/dist/response.d.ts

@@ -1,7 +1,6 @@
-import { MethodMap, ServiceMap } from "./maps/method-map.js";
-import { SocketMap } from "./maps/socket-map.js";
-export type AnyResponse<T extends SocketMap> = Response | ErrorResponse | ServiceDataResponse<T['Service']> | MethodDataResponse<T['PrivateOutgoing']> | MethodDataResponse<T['Outgoing']>;
-export declare function isResponsePacket<T extends SocketMap>(packet?: unknown): packet is AnyResponse<T>;
+import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from "./maps/method-map.js";
+export type AnyResponse<TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap> = Response | ErrorResponse | ServiceDataResponse<TService> | MethodDataResponse<TPrivateOutgoing> | MethodDataResponse<TOutgoing>;
+export declare function isResponsePacket<TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap>(packet?: unknown): packet is AnyResponse<TOutgoing, TPrivateOutgoing, TService>;
 export type ServiceDataResponse<TServiceMap extends ServiceMap> = {
     [TService in keyof TServiceMap]: {
         [TMethod in keyof TServiceMap[TService]]: DataResponse<ReturnType<TServiceMap[TService][TMethod]>>;

package/dist/socket-event.d.ts

@@ -2,8 +2,8 @@ import ws from "isomorphic-ws";
 import { MethodPacket, ServicePacket } from "./packet.js";
 import { AuthToken, SignedAuthToken } from "@socket-mesh/auth";
 import { AnyResponse } from "./response.js";
-import { SocketMap } from "./maps/socket-map.js";
-export type SocketEvent<T extends SocketMap> = AuthStateChangeEvent | RemoveAuthTokenEvent | AuthenticateEvent | BadAuthTokenEvent | CloseEvent | ConnectEvent | ConnectingEvent | DeauthenticateEvent | DisconnectEvent | ErrorEvent | MessageEvent | PingEvent | PongEvent | RequestEvent<T> | ResponseEvent<T>;
+import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from "./maps/method-map.js";
+export type SocketEvent<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap> = AuthStateChangeEvent | RemoveAuthTokenEvent | AuthenticateEvent | BadAuthTokenEvent | CloseEvent | ConnectEvent | ConnectingEvent | DeauthenticateEvent | DisconnectEvent | ErrorEvent | MessageEvent | PingEvent | PongEvent | RequestEvent<TIncoming, TService> | ResponseEvent<TOutgoing, TPrivateOutgoing, TService>;
 export type AuthStateChangeEvent = AuthenticatedChangeEvent | DeauthenticatedChangeEvent;
 export interface AuthenticatedChangeEvent {
     isAuthenticated: true;
@@ -58,9 +58,9 @@ export interface PongEvent {
 export interface RemoveAuthTokenEvent {
     oldAuthToken: SignedAuthToken;
 }
-export interface RequestEvent<T extends SocketMap> {
-    request: ServicePacket<T['Service']> | MethodPacket<T['Incoming']>;
+export interface RequestEvent<TIncoming extends MethodMap, TService extends ServiceMap> {
+    request: ServicePacket<TService> | MethodPacket<TIncoming>;
 }
-export interface ResponseEvent<T extends SocketMap> {
-    response: AnyResponse<T>;
+export interface ResponseEvent<TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap> {
+    response: AnyResponse<TOutgoing, TPrivateOutgoing, TService>;
 }

package/dist/socket-transport.d.ts

@@ -3,11 +3,10 @@ import ws from "isomorphic-ws";
 import { Plugin } from "./plugins/plugin.js";
 import { AnyRequest, InvokeMethodRequest, InvokeServiceRequest, TransmitMethodRequest, TransmitServiceRequest } from "./request.js";
 import { AnyPacket } from "./packet.js";
-import { FunctionReturnType, MethodMap, ServiceMap } from "./maps/method-map.js";
+import { FunctionReturnType, MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from "./maps/method-map.js";
 import { AnyResponse } from "./response.js";
 import { AuthToken, SignedAuthToken } from "@socket-mesh/auth";
 import { Socket, SocketOptions, SocketStatus, StreamCleanupMode } from "./socket.js";
-import { SocketMap } from "./maps/socket-map.js";
 export type CallIdGenerator = () => number;
 export interface InvokeMethodOptions<TMethodMap extends MethodMap, TMethod extends keyof TMethodMap> {
     method: TMethod;
@@ -18,11 +17,11 @@ export interface InvokeServiceOptions<TServiceMap extends ServiceMap, TService e
     method: TMethod;
     ackTimeoutMs?: number | false;
 }
-export interface InboundMessage<T extends SocketMap> {
+export interface InboundMessage<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap> {
     timestamp: Date;
-    packet: (AnyPacket<T> | AnyResponse<T>) | (AnyPacket<T> | AnyResponse<T>)[];
+    packet: (AnyPacket<TIncoming, TService> | AnyResponse<TOutgoing, TPrivateOutgoing, TService>) | (AnyPacket<TIncoming, TService> | AnyResponse<TOutgoing, TPrivateOutgoing, TService>)[];
 }
-export declare class SocketTransport<T extends SocketMap> {
+export declare class SocketTransport<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> {
     private _socket;
     private _webSocket;
     private _inboundProcessedMessageCount;
@@ -37,12 +36,12 @@ export declare class SocketTransport<T extends SocketMap> {
     private readonly _handlers;
     private _onUnhandledRequest;
     readonly codecEngine: CodecEngine;
-    readonly plugins: Plugin<T>[];
+    readonly plugins: Plugin<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>[];
     streamCleanupMode: StreamCleanupMode;
     id: string | null;
     ackTimeoutMs: number;
     private _pingTimeoutRef;
-    protected constructor(options?: SocketOptions<T>);
+    protected constructor(options?: SocketOptions<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>);
     protected abortAllPendingCallbacksDueToBadConnection(status: SocketStatus): void;
     get authToken(): AuthToken;
     changeToUnauthenticatedState(): Promise<boolean>;
@@ -51,44 +50,44 @@ export declare class SocketTransport<T extends SocketMap> {
     getBackpressure(): number;
     getInboundBackpressure(): number;
     getOutboundBackpressure(): number;
-    protected handleInboudMessage({ packet, timestamp }: InboundMessage<T>): Promise<void>;
+    protected handleInboudMessage({ packet, timestamp }: InboundMessage<TIncoming, TOutgoing, TPrivateOutgoing, TService>): Promise<void>;
     protected onClose(code: number, reason?: Buffer | string): void;
     protected onDisconnect(status: SocketStatus, code: number, reason?: string): void;
     onError(error: Error): void;
-    protected onInvoke<TService extends keyof T['Service'], TServiceMethod extends keyof T['Service'][TService], TMethod extends keyof T['Outgoing'], TPrivateMethod extends keyof T['PrivateOutgoing']>(request: InvokeMethodRequest<T["Outgoing"], TMethod> | InvokeMethodRequest<T["PrivateOutgoing"], TPrivateMethod> | InvokeServiceRequest<T["Service"], TService, TServiceMethod>): void;
+    protected onInvoke<TServiceName extends keyof TService, TServiceMethod extends keyof TService[TServiceName], TMethod extends keyof TOutgoing, TPrivateMethod extends keyof TPrivateOutgoing>(request: InvokeMethodRequest<TOutgoing, TMethod> | InvokeMethodRequest<TPrivateOutgoing, TPrivateMethod> | InvokeServiceRequest<TService, TServiceName, TServiceMethod>): void;
     protected onMessage(data: ws.Data, isBinary: boolean): void;
     protected onOpen(): void;
     protected onPingPong(): void;
-    protected onRequest(packet: AnyPacket<T>, timestamp: Date, pluginError?: Error): Promise<boolean>;
-    protected onResponse(response: AnyResponse<T>, pluginError?: Error): void;
+    protected onRequest(packet: AnyPacket<TIncoming, TService>, timestamp: Date, pluginError?: Error): Promise<boolean>;
+    protected onResponse(response: AnyResponse<TOutgoing, TPrivateOutgoing, TService>, pluginError?: Error): void;
     private onSocketClose;
     private onSocketError;
     private onSocketMessage;
-    protected onTransmit<TService extends keyof T['Service'], TServiceMethod extends keyof T['Service'][TService], TMethod extends keyof T['Outgoing']>(request: TransmitMethodRequest<T['Outgoing'], TMethod> | TransmitServiceRequest<T['Service'], TService, TServiceMethod>): void;
-    protected onUnhandledRequest(packet: AnyPacket<T>): boolean;
+    protected onTransmit<TServiceName extends keyof TService, TServiceMethod extends keyof TService[TServiceName], TMethod extends keyof TOutgoing>(request: TransmitMethodRequest<TOutgoing, TMethod> | TransmitServiceRequest<TService, TServiceName, TServiceMethod>): void;
+    protected onUnhandledRequest(packet: AnyPacket<TIncoming, TService>): boolean;
     protected resetPingTimeout(timeoutMs: number | false, code: number): void;
     send(data: Buffer | string): Promise<void>;
-    protected sendRequest(requests: (AnyRequest<T>)[]): void;
-    protected sendRequest(index: number, requests: (AnyRequest<T>)[]): void;
-    protected sendResponse(responses: (AnyResponse<T>)[]): void;
-    protected sendResponse(index: number, responses: (AnyResponse<T>)[]): void;
+    protected sendRequest(requests: (AnyRequest<TOutgoing, TPrivateOutgoing, TService>)[]): void;
+    protected sendRequest(index: number, requests: (AnyRequest<TOutgoing, TPrivateOutgoing, TService>)[]): void;
+    protected sendResponse(responses: (AnyResponse<TOutgoing, TPrivateOutgoing, TService>)[]): void;
+    protected sendResponse(index: number, responses: (AnyResponse<TOutgoing, TPrivateOutgoing, TService>)[]): void;
     setAuthorization(authToken: AuthToken): Promise<boolean>;
     setAuthorization(signedAuthToken: SignedAuthToken, authToken?: AuthToken): Promise<boolean>;
     setReadyStatus(pingTimeoutMs: number, authError?: Error): void;
     get signedAuthToken(): SignedAuthToken;
-    get socket(): Socket<T>;
-    set socket(value: Socket<T>);
+    get socket(): Socket<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>;
+    set socket(value: Socket<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>);
     get status(): SocketStatus;
     triggerAuthenticationEvents(wasSigned: boolean, wasAuthenticated: boolean): void;
-    transmit<TMethod extends keyof T['Outgoing']>(method: TMethod, arg?: Parameters<T['Outgoing'][TMethod]>[0]): Promise<void>;
-    transmit<TService extends keyof T['Service'], TMethod extends keyof T['Service'][TService]>(options: [TService, TMethod], arg?: Parameters<T['Service'][TService][TMethod]>[0]): Promise<void>;
-    transmit<TMethod extends keyof T['PrivateOutgoing']>(method: TMethod, arg?: Parameters<T['PrivateOutgoing'][TMethod]>[0]): Promise<void>;
-    invoke<TMethod extends keyof T['Outgoing']>(method: TMethod, arg?: Parameters<T['Outgoing'][TMethod]>[0]): [Promise<FunctionReturnType<T['Outgoing'][TMethod]>>, () => void];
-    invoke<TService extends keyof T['Service'], TMethod extends keyof T['Service'][TService]>(options: [TService, TMethod, (number | false)?], arg?: Parameters<T['Service'][TService][TMethod]>[0]): [Promise<FunctionReturnType<T['Service'][TService][TMethod]>>, () => void];
-    invoke<TService extends keyof T['Service'], TMethod extends keyof T['Service'][TService]>(options: InvokeServiceOptions<T['Service'], TService, TMethod>, arg?: Parameters<T['Service'][TService][TMethod]>[0]): [Promise<FunctionReturnType<T['Service'][TService][TMethod]>>, () => void];
-    invoke<TMethod extends keyof T['Outgoing']>(options: InvokeMethodOptions<T['Outgoing'], TMethod>, arg?: Parameters<T['Outgoing'][TMethod]>[0]): [Promise<FunctionReturnType<T['Outgoing'][TMethod]>>, () => void];
-    invoke<TMethod extends keyof T['PrivateOutgoing']>(method: TMethod, arg: Parameters<T['PrivateOutgoing'][TMethod]>[0]): [Promise<FunctionReturnType<T['PrivateOutgoing'][TMethod]>>, () => void];
-    invoke<TMethod extends keyof T['PrivateOutgoing']>(options: InvokeMethodOptions<T['PrivateOutgoing'], TMethod>, arg?: Parameters<T['PrivateOutgoing'][TMethod]>[0]): [Promise<FunctionReturnType<T['PrivateOutgoing'][TMethod]>>, () => void];
+    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>(method: TMethod, arg?: Parameters<TPrivateOutgoing[TMethod]>[0]): Promise<void>;
+    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, (number | false)?], 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>(method: TMethod, arg: Parameters<TPrivateOutgoing[TMethod]>[0]): [Promise<FunctionReturnType<TPrivateOutgoing[TMethod]>>, () => void];
+    invoke<TMethod extends keyof TPrivateOutgoing>(options: InvokeMethodOptions<TPrivateOutgoing, TMethod>, arg?: Parameters<TPrivateOutgoing[TMethod]>[0]): [Promise<FunctionReturnType<TPrivateOutgoing[TMethod]>>, () => void];
     get url(): string;
     protected get webSocket(): ws.WebSocket;
     protected set webSocket(value: ws.WebSocket | null);

package/dist/socket.d.ts

@@ -2,30 +2,29 @@ import { CodecEngine } from "@socket-mesh/formatter";
 import { AnyPacket } from "./packet.js";
 import { AsyncStreamEmitter } from "@socket-mesh/async-stream-emitter";
 import { SocketEvent, AuthenticateEvent, BadAuthTokenEvent, CloseEvent, ConnectEvent, DisconnectEvent, ErrorEvent, MessageEvent, PingEvent, PongEvent, RequestEvent, ResponseEvent, AuthStateChangeEvent, RemoveAuthTokenEvent, ConnectingEvent, DeauthenticateEvent } from "./socket-event.js";
-import { FunctionReturnType } from "./maps/method-map.js";
+import { FunctionReturnType, MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from "./maps/method-map.js";
 import { HandlerMap } from "./maps/handler-map.js";
 import { CallIdGenerator, InvokeMethodOptions, InvokeServiceOptions, SocketTransport } from "./socket-transport.js";
 import { DemuxedConsumableStream, StreamEvent } from "@socket-mesh/stream-demux";
 import { AuthToken, SignedAuthToken } from "@socket-mesh/auth";
-import { SocketMap } from "./maps/socket-map.js";
 import { Plugin } from "./plugins/plugin.js";
 export type StreamCleanupMode = 'kill' | 'close' | 'none';
-export interface SocketOptions<T extends SocketMap, TSocket extends Socket<T> = Socket<T>> {
+export interface SocketOptions<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object, TSocket extends Socket<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> = Socket<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>> {
     ackTimeoutMs?: number;
     callIdGenerator?: CallIdGenerator;
     codecEngine?: CodecEngine;
-    handlers?: HandlerMap<T>;
+    handlers?: HandlerMap<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>;
     isPingTimeoutDisabled?: boolean;
-    plugins?: Plugin<T>[];
-    onUnhandledRequest?: (socket: TSocket, packet: AnyPacket<T>) => boolean;
-    state?: T['State'];
+    plugins?: Plugin<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>[];
+    onUnhandledRequest?: (socket: TSocket, packet: AnyPacket<TIncoming, TService>) => boolean;
+    state?: Partial<TState>;
     streamCleanupMode?: StreamCleanupMode;
 }
 export type SocketStatus = 'connecting' | 'ready' | 'closing' | 'closed';
-export declare class Socket<T extends SocketMap> extends AsyncStreamEmitter<SocketEvent<T>> {
+export declare class Socket<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> extends AsyncStreamEmitter<SocketEvent<TIncoming, TOutgoing, TPrivateOutgoing, TService>> {
     private readonly _transport;
-    readonly state: Partial<T['State']>;
-    protected constructor(transport: SocketTransport<T>, options?: SocketOptions<T>);
+    readonly state: Partial<TState>;
+    protected constructor(transport: SocketTransport<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>, options?: SocketOptions<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>);
     get id(): string;
     get authToken(): AuthToken;
     get signedAuthToken(): SignedAuthToken;
@@ -49,9 +48,9 @@ export declare class Socket<T extends SocketMap> extends AsyncStreamEmitter<Sock
     emit(event: 'ping', data: PingEvent): void;
     emit(event: 'pong', data: PongEvent): void;
     emit(event: 'removeAuthToken', data: RemoveAuthTokenEvent): void;
-    emit(event: 'request', data: RequestEvent<T>): void;
-    emit(event: 'response', data: ResponseEvent<T>): void;
-    listen(): DemuxedConsumableStream<StreamEvent<SocketEvent<T>>>;
+    emit(event: 'request', data: RequestEvent<TIncoming, TService>): void;
+    emit(event: 'response', data: ResponseEvent<TOutgoing, TPrivateOutgoing, TService>): void;
+    listen(): DemuxedConsumableStream<StreamEvent<SocketEvent<TIncoming, TOutgoing, TPrivateOutgoing, TService>>>;
     listen(event: 'authStateChange'): DemuxedConsumableStream<AuthStateChangeEvent>;
     listen(event: 'authenticate'): DemuxedConsumableStream<AuthenticateEvent>;
     listen(event: 'badAuthToken'): DemuxedConsumableStream<BadAuthTokenEvent>;
@@ -67,15 +66,15 @@ export declare class Socket<T extends SocketMap> extends AsyncStreamEmitter<Sock
     listen(event: 'ping'): DemuxedConsumableStream<PingEvent>;
     listen(event: 'pong'): DemuxedConsumableStream<PongEvent>;
     listen(event: 'removeAuthToken'): DemuxedConsumableStream<RemoveAuthTokenEvent>;
-    listen(event: 'request'): DemuxedConsumableStream<RequestEvent<T>>;
-    listen(event: 'response'): DemuxedConsumableStream<ResponseEvent<T>>;
-    listen<U extends SocketEvent<T>, V = U>(event: string): DemuxedConsumableStream<V>;
+    listen(event: 'request'): DemuxedConsumableStream<RequestEvent<TIncoming, TService>>;
+    listen(event: 'response'): DemuxedConsumableStream<ResponseEvent<TOutgoing, TPrivateOutgoing, TService>>;
+    listen<U extends SocketEvent<TIncoming, TOutgoing, TPrivateOutgoing, TService>, V = U>(event: string): DemuxedConsumableStream<V>;
     get status(): SocketStatus;
     get url(): string;
-    transmit<TMethod extends keyof T['Outgoing']>(method: TMethod, arg?: Parameters<T['Outgoing'][TMethod]>[0]): Promise<void>;
-    transmit<TService extends keyof T['Service'], TMethod extends keyof T['Service'][TService]>(options: [TService, TMethod], arg?: Parameters<T['Service'][TService][TMethod]>[0]): Promise<void>;
-    invoke<TMethod extends keyof T['Outgoing']>(method: TMethod, arg?: Parameters<T['Outgoing'][TMethod]>[0]): Promise<FunctionReturnType<T['Outgoing'][TMethod]>>;
-    invoke<TService extends keyof T['Service'], TMethod extends keyof T['Service'][TService]>(options: [TService, TMethod, (number | false)?], arg?: Parameters<T['Service'][TService][TMethod]>[0]): Promise<FunctionReturnType<T['Service'][TService][TMethod]>>;
-    invoke<TService extends keyof T['Service'], TMethod extends keyof T['Service'][TService]>(options: InvokeServiceOptions<T['Service'], TService, TMethod>, arg?: Parameters<T['Service'][TService][TMethod]>[0]): Promise<FunctionReturnType<T['Service'][TService][TMethod]>>;
-    invoke<TMethod extends keyof T['Outgoing']>(options: InvokeMethodOptions<T['Outgoing'], TMethod>, arg?: Parameters<T['Outgoing'][TMethod]>[0]): Promise<FunctionReturnType<T['Outgoing'][TMethod]>>;
+    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>;
+    invoke<TMethod extends keyof TOutgoing>(method: TMethod, arg?: Parameters<TOutgoing[TMethod]>[0]): Promise<FunctionReturnType<TOutgoing[TMethod]>>;
+    invoke<TServiceName extends keyof TService, TMethod extends keyof TService[TServiceName]>(options: [TServiceName, TMethod, (number | false)?], arg?: Parameters<TService[TServiceName][TMethod]>[0]): Promise<FunctionReturnType<TService[TServiceName][TMethod]>>;
+    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]>>;
+    invoke<TMethod extends keyof TOutgoing>(options: InvokeMethodOptions<TOutgoing, TMethod>, arg?: Parameters<TOutgoing[TMethod]>[0]): Promise<FunctionReturnType<TOutgoing[TMethod]>>;
 }

package/package.json

@@ -1,31 +1,31 @@
 {
-  "name": "@socket-mesh/core",
-  "version": "1.0.2",
-  "description": "Core module for SocketMesh Server",
-  "type": "module",
-  "main": "dist/index.js",
+	"name": "@socket-mesh/core",
+	"version": "1.0.3",
+	"description": "Core module for SocketMesh Server",
+	"type": "module",
+	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"files": ["./dist"],
-  "scripts": {
-    "build": "node ../../scripts/build.mjs && tsc --project tsconfig.build.json",
-    "deploy": "npm run build && node ../../scripts/publish.mjs",
-    "test": "cross-env node --test --loader ts-node/esm test/index.spec.ts"
-  },
-  "keywords": [
-    "auth",
-    "jwt",
-    "socketMesh"
-  ],
-  "author": "Greg Kimmy",
+	"scripts": {
+		"build": "node ../../scripts/build.mjs && tsc --project tsconfig.build.json",
+		"deploy": "npm run build && node ../../scripts/publish.mjs",
+		"test": "cross-env node --test --loader ts-node/esm test/index.spec.ts"
+	},
+	"keywords": [
+		"auth",
+		"jwt",
+		"socketMesh"
+	],
+	"author": "Greg Kimmy",
 	"license": "MIT",
 	"homepage": "https://github.com/socket-mesh/main/tree/main/packages/core#README.md",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/socket-mesh/client-server.git"
-  },
-  "bugs": {
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/socket-mesh/client-server.git"
+	},
+	"bugs": {
 		"url": "https://github.com/socket-mesh/client-server/labels/core"
-  },
+	},
 	"devDependencies": {
 		"@types/base64id": "^2.0.2",
 		"@types/ws": "^8.5.11"

package/dist/maps/socket-map.d.ts

@@ -1,15 +0,0 @@
-import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from "./method-map.js";
-export interface SocketMap {
-    Incoming: MethodMap;
-    Service: ServiceMap;
-    Outgoing: PublicMethodMap;
-    PrivateOutgoing: PrivateMethodMap;
-    State: object;
-}
-export interface EmptySocketMap {
-    Incoming: {};
-    Service: {};
-    Outgoing: {};
-    PrivateOutgoing: {};
-    State: {};
-}

package/dist/maps/socket-map.js

@@ -1 +0,0 @@
-export {};