@socket-mesh/core 1.0.3 → 2.0.0

package/dist/index.d.ts

@@ -1,10 +1,10 @@
-export * from "./maps/index.js";
-export * from "./packet.js";
-export * from "./plugins/index.js";
-export * from "./request.js";
-export * from "./request-handler.js";
-export * from "./response.js";
-export * from "./socket.js";
-export * from "./socket-event.js";
-export * from "./socket-transport.js";
-export * from "./utils.js";
+export * from './maps/index.js';
+export * from './packet.js';
+export * from './plugins/index.js';
+export * from './request-handler.js';
+export * from './request.js';
+export * from './response.js';
+export * from './socket-event.js';
+export * from './socket-transport.js';
+export * from './socket.js';
+export * from './utils.js';

package/dist/index.js

@@ -1,10 +1,10 @@
-export * from "./maps/index.js";
-export * from "./packet.js";
-export * from "./plugins/index.js";
-export * from "./request.js";
-export * from "./request-handler.js";
-export * from "./response.js";
-export * from "./socket.js";
-export * from "./socket-event.js";
-export * from "./socket-transport.js";
-export * from "./utils.js";
+export * from './maps/index.js';
+export * from './packet.js';
+export * from './plugins/index.js';
+export * from './request-handler.js';
+export * from './request.js';
+export * from './response.js';
+export * from './socket-event.js';
+export * from './socket-transport.js';
+export * from './socket.js';
+export * from './utils.js';

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

@@ -1,5 +1,7 @@
-import { RequestHandler } from "../request-handler.js";
-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>;
+import { RequestHandler } from '../request-handler.js';
+import { BaseSocketTransport } from '../socket-transport.js';
+import { BaseSocket } from '../socket.js';
+import { MethodMap } from './method-map.js';
+export type HandlerMap<TIncoming extends MethodMap, TState extends object, TSocket extends BaseSocket<TState> = BaseSocket<TState>, TTransport extends BaseSocketTransport<TState> = BaseSocketTransport<TState>> = Partial<{
+    [K in keyof TIncoming]: RequestHandler<Parameters<TIncoming[K]>[0], ReturnType<TIncoming[K]>, TState, TSocket, TTransport>;
 }>;

package/dist/maps/index.d.ts

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

package/dist/maps/index.js

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

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

@@ -1,12 +1,5 @@
-export type RemoveIndexSignature<T> = {
-    [K in keyof T as string extends K ? never : number extends K ? never : symbol extends K ? never : K]: T[K];
-};
-export type MappedFunction = (...args: any) => any;
-export type PromiseReturnType<T> = T extends Promise<infer Return> ? Return : T;
-export type ServiceMap = {
-    [service: string]: MethodMap;
-};
 export type FunctionReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : never;
+export type MappedFunction = (...args: any) => any;
 export type MethodMap = {
     [method: string]: MappedFunction;
 };
@@ -15,8 +8,17 @@ export type PrivateMethodMap = {
 } & {
     [method: `#${string}`]: MappedFunction;
 };
+export type PromiseReturnType<T> = T extends Promise<infer Return> ? Return : T;
 export type PublicMethodMap = {
     [method: string]: MappedFunction;
 } & {
     [method: `#${string}`]: never;
 };
+export type RemoveIndexSignature<T> = {
+    [K in keyof T as string extends K ? never : number extends K ? never : symbol extends K ? never : K]: T[K];
+};
+export type ServiceMap = {
+    [service: string]: MethodMap;
+};
+export type ServiceMethodName<TService extends ServiceMap, TServiceName extends ServiceName<TService>> = string & keyof TService[TServiceName];
+export type ServiceName<TService extends ServiceMap> = string & keyof TService;

package/dist/maps/method-map.js

@@ -1 +1,2 @@
+/* eslint-disable @typescript-eslint/consistent-type-definitions */
 export {};

package/dist/packet.d.ts

@@ -1,26 +1,41 @@
-import { MethodMap, ServiceMap } from "./maps/method-map.js";
-export type AnyPacket<TIncoming extends MethodMap, TService extends ServiceMap> = ServicePacket<TService> | MethodPacket<TIncoming>;
-export type ServicePacket<TServiceMap extends ServiceMap> = {
+import { MethodMap, ServiceMap } from './maps/method-map.js';
+export type AnyPacket = MethodPacket | ServicePacket;
+export type IncomingMethodPacket<TMethodMap extends MethodMap> = {
+    [TMethod in keyof TMethodMap]: IncomingMethodRequestPacket<TMethodMap, TMethod>;
+}[keyof TMethodMap];
+export interface IncomingMethodRequestPacket<TMethodMap extends MethodMap, TMethod extends keyof TMethodMap> extends RequestPacket {
+    ackTimeoutMs?: boolean | number;
+    data: Parameters<TMethodMap[TMethod]>[0];
+    method: TMethod;
+}
+export type IncomingPacket<TIncoming extends MethodMap, TService extends ServiceMap> = IncomingMethodPacket<TIncoming> | IncomingServicePacket<TService>;
+export type IncomingServicePacket<TServiceMap extends ServiceMap> = {
     [TService in keyof TServiceMap]: {
-        [TMethod in keyof TServiceMap[TService]]: ServiceRequestPacket<TServiceMap, TService, TMethod>;
+        [TMethod in keyof TServiceMap[TService]]: IncomingServiceRequestPacket<TServiceMap, TService, TMethod>;
     }[keyof TServiceMap[TService]];
 }[keyof TServiceMap];
+export interface IncomingServiceRequestPacket<TServiceMap extends ServiceMap, TService extends keyof TServiceMap, TMethod extends keyof TServiceMap[TService]> extends RequestPacket {
+    ackTimeoutMs?: boolean | number;
+    data?: Parameters<TServiceMap[TService][TMethod]>[0];
+    method: TMethod;
+    service: TService;
+}
+export type MethodPacket = MethodRequestPacket;
+export interface MethodRequestPacket extends RequestPacket {
+    ackTimeoutMs?: boolean | number;
+    data?: unknown;
+    method: string;
+}
 interface RequestPacket {
     cid?: number;
 }
-export type MethodPacket<TMethodMap extends MethodMap> = {
-    [TMethod in keyof TMethodMap]: MethodRequestPacket<TMethodMap, TMethod>;
-}[keyof TMethodMap];
-export interface ServiceRequestPacket<TServiceMap extends ServiceMap, TService extends keyof TServiceMap, TMethod extends keyof TServiceMap[TService]> extends RequestPacket {
-    service: TService;
-    method: TMethod;
-    ackTimeoutMs?: number | boolean;
-    data?: Parameters<TServiceMap[TService][TMethod]>[0];
-}
-export interface MethodRequestPacket<TMethodMap extends MethodMap, TMethod extends keyof TMethodMap> extends RequestPacket {
-    method: TMethod;
-    data: Parameters<TMethodMap[TMethod]>[0];
-    ackTimeoutMs?: number | boolean;
+export type ServicePacket = ServiceRequestPacket;
+export interface ServiceRequestPacket extends RequestPacket {
+    ackTimeoutMs?: boolean | number;
+    data?: unknown;
+    method: string;
+    service: string;
 }
-export declare function isRequestPacket<TIncoming extends MethodMap, TService extends ServiceMap>(packet: unknown): packet is AnyPacket<TIncoming, TService>;
+export declare function isRequestPacket(packet: unknown): packet is AnyPacket;
+export declare function isRequestPacket<TIncoming extends MethodMap, TService extends ServiceMap = {}>(packet: unknown): packet is IncomingPacket<TIncoming, TService>;
 export {};

package/dist/packet.js

@@ -1,3 +1,5 @@
 export function isRequestPacket(packet) {
-    return (typeof packet === 'object') && 'method' in packet;
+    return (packet !== null
+        && typeof packet === 'object'
+        && 'method' in packet);
 }

package/dist/plugins/index.d.ts

@@ -1 +1 @@
-export * from "./plugin.js";
+export * from './plugin.js';

package/dist/plugins/index.js

@@ -1 +1 @@
-export * from "./plugin.js";
+export * from './plugin.js';

package/dist/plugins/plugin.d.ts

@@ -1,50 +1,50 @@
-import { AnyPacket } from "../packet.js";
-import { AnyRequest } from "../request.js";
-import { AnyResponse } from "../response.js";
-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<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<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> extends PluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> {
-    status: SocketStatus;
+import ws from 'isomorphic-ws';
+import { AnyPacket } from '../packet.js';
+import { LooseHandlerMap } from '../request-handler.js';
+import { AnyRequest } from '../request.js';
+import { AnyResponse } from '../response.js';
+import { BaseSocketTransport } from '../socket-transport.js';
+import { BaseSocket, SocketStatus } from '../socket.js';
+export type AnyPlugin = Plugin<any, any>;
+export interface DisconnectedPluginArgs<TSocket extends BaseSocket = BaseSocket, TTransport extends BaseSocketTransport = BaseSocketTransport> extends PluginArgs<TSocket, TTransport> {
     code: number;
     reason?: string;
+    status: SocketStatus;
 }
-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> {
+export interface MessagePluginArgs<TSocket extends BaseSocket = BaseSocket, TTransport extends BaseSocketTransport = BaseSocketTransport> extends PluginArgs<TSocket, TTransport> {
+    packet: AnyPacket | AnyResponse;
     timestamp: Date;
-    packet: AnyPacket<TIncoming, TService> | AnyResponse<TOutgoing, TPrivateOutgoing, TService>;
 }
-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;
+export interface MessageRawPluginArgs<TSocket extends BaseSocket = BaseSocket, TTransport extends BaseSocketTransport = BaseSocketTransport> extends PluginArgs<TSocket, TTransport> {
+    message: string | ws.RawData;
     promise: Promise<void>;
+    timestamp: Date;
+}
+export interface Plugin<TSocket extends BaseSocket = BaseSocket, TTransport extends BaseSocketTransport = BaseSocketTransport> {
+    handlers?: LooseHandlerMap;
+    onAuthenticated?(options: PluginArgs<TSocket, TTransport>): void;
+    onClose?(options: PluginArgs<TSocket, TTransport>): void;
+    onDeauthenticate?(options: PluginArgs<TSocket, TTransport>): void;
+    onDisconnected?(options: DisconnectedPluginArgs<TSocket, TTransport>): void;
+    onEnd?(options: PluginArgs<TSocket, TTransport>): void;
+    onMessage?(options: MessagePluginArgs<TSocket, TTransport>): Promise<AnyPacket | AnyResponse>;
+    onMessageRaw?(options: MessageRawPluginArgs<TSocket, TTransport>): Promise<string | ws.RawData>;
+    onOpen?(options: PluginArgs<TSocket, TTransport>): void;
+    onReady?(options: PluginArgs<TSocket, TTransport>): void;
+    sendRequest?(options: SendRequestPluginArgs<TSocket, TTransport>): void;
+    sendResponse?(options: SendResponsePluginArgs<TSocket, TTransport>): void;
+    type: string;
 }
-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 PluginArgs<TSocket extends BaseSocket = BaseSocket, TTransport extends BaseSocketTransport = BaseSocketTransport> {
+    socket: TSocket;
+    transport: TTransport;
 }
-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 type PluginType = 'handshake' | 'request' | 'response';
+export interface SendRequestPluginArgs<TSocket extends BaseSocket = BaseSocket, TTransport extends BaseSocketTransport = BaseSocketTransport> extends PluginArgs<TSocket, TTransport> {
+    cont: (requests: AnyRequest[]) => void;
+    requests: AnyRequest[];
 }
-export interface Plugin<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> {
-    type: string;
-    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;
+export interface SendResponsePluginArgs<TSocket extends BaseSocket = BaseSocket, TTransport extends BaseSocketTransport = BaseSocketTransport> extends PluginArgs<TSocket, TTransport> {
+    cont: (requests: AnyResponse[]) => void;
+    responses: AnyResponse[];
 }

package/dist/request-handler.d.ts

@@ -1,24 +1,26 @@
-import { Socket } from "./socket.js";
-import { SocketTransport } from "./socket-transport.js";
-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>> {
+import { BaseSocketTransport } from './socket-transport.js';
+import { BaseSocket } from './socket.js';
+export interface LooseHandlerMap {
+    [method: string]: ((args: RequestHandlerArgs<any, any, any, any>) => Promise<any>) | undefined;
+}
+export type RequestHandler<TOptions, U, TState extends object, TSocket extends BaseSocket<TState> = BaseSocket<TState>, TTransport extends BaseSocketTransport<TState> = BaseSocketTransport<TState>> = (args: RequestHandlerArgs<TOptions, TState, TSocket, TTransport>) => Promise<U>;
+export interface RequestHandlerArgsOptions<TOptions, TState extends object, TSocket extends BaseSocket<TState> = BaseSocket<TState>, TTransport extends BaseSocketTransport<TState> = BaseSocketTransport<TState>> {
     isRpc: boolean;
     method: string;
+    options: TOptions;
     socket: TSocket;
+    timeoutMs?: boolean | number;
     transport: TTransport;
-    timeoutMs?: number | boolean;
-    options?: TOptions;
 }
-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>> {
+export declare class RequestHandlerArgs<TOptions, TState extends object = {}, TSocket extends BaseSocket<TState> = BaseSocket<TState>, TTransport extends BaseSocketTransport<TState> = BaseSocketTransport<TState>> {
     isRpc: boolean;
     method: string;
     options: TOptions;
     requestedAt: Date;
     socket: TSocket;
-    timeoutMs?: number | boolean;
+    timeoutMs?: boolean | number;
     transport: TTransport;
-    constructor(options: RequestHandlerArgsOptions<TOptions, TIncoming, TOutgoing, TPrivateOutgoing, TService, TState, TSocket, TTransport>);
+    constructor(options: RequestHandlerArgsOptions<TOptions, TState, TSocket, TTransport>);
     checkTimeout(timeLeftMs?: number): void;
     getRemainingTimeMs(): number;
 }
-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-handler.js

@@ -1,5 +1,12 @@
-import { TimeoutError } from "@socket-mesh/errors";
+import { TimeoutError } from '@socket-mesh/errors';
 export class RequestHandlerArgs {
+    isRpc;
+    method;
+    options;
+    requestedAt;
+    socket;
+    timeoutMs;
+    transport;
     constructor(options) {
         this.isRpc = options.isRpc;
         this.method = options.method;
@@ -11,7 +18,7 @@ export class RequestHandlerArgs {
     }
     checkTimeout(timeLeftMs = 0) {
         if (typeof this.timeoutMs === 'number' && this.getRemainingTimeMs() <= timeLeftMs) {
-            throw new TimeoutError(`Method \'${this.method}\' timed out.`);
+            throw new TimeoutError(`Method '${this.method}' timed out.`);
         }
     }
     getRemainingTimeMs() {

package/dist/request.d.ts

@@ -1,54 +1,47 @@
-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;
+export type AnyRequest = MethodRequest | ServiceRequest;
+export interface InvokeMethodRequest extends TransmitMethodRequest {
+    ackTimeoutMs: false | number;
+    callback: ((err: Error | null, result?: unknown) => void) | null;
+    cid: number;
+    timeoutId?: NodeJS.Timeout;
+}
+export interface InvokeServiceRequest extends TransmitServiceRequest {
+    ackTimeoutMs: false | number;
+    callback: ((err: Error | null, result?: unknown) => void) | null;
+    cid: number;
+    timeoutId?: NodeJS.Timeout;
+}
+export type MethodRequest = InvokeMethodRequest | TransmitMethodRequest;
+export interface Request {
+    promise: Promise<void>;
+    sentCallback?: (err?: Error) => void;
+}
+export type ServiceRequest = InvokeServiceRequest | TransmitServiceRequest;
+export interface TransmitMethodRequest extends Request {
+    data?: unknown;
+    method: string;
+}
+export interface TransmitServiceRequest extends Request {
+    data?: unknown;
+    method: string;
+    service: string;
+}
+export declare function abortRequest(request: AnyRequest, err: Error): void;
+export declare function isRequestDone(request: AnyRequest): boolean;
+export declare class RequestCollection {
     private readonly _callbacks;
-    constructor(requests: AnyRequest<TOutgoing, TPrivateOutgoing, TService> | AnyRequest<TOutgoing, TPrivateOutgoing, TService>[]);
-    get items(): ReadonlyArray<AnyRequest<TOutgoing, TPrivateOutgoing, TService>>;
-    listen(cb: () => void): void;
+    private readonly _requests;
+    constructor(requests: AnyRequest | AnyRequest[]);
     isDone(): boolean;
+    get items(): ReadonlyArray<AnyRequest>;
+    listen(cb: () => void): void;
     [Symbol.iterator](): {
         next(): {
-            value: AnyRequest<TOutgoing, TPrivateOutgoing, TService>;
             done: boolean;
+            value: AnyRequest | undefined;
         } | {
             done: boolean;
             value?: undefined;
         };
     };
 }
-export type ServiceRequest<TServiceMap extends ServiceMap> = {
-    [TService in keyof TServiceMap]: {
-        [TMethod in keyof TServiceMap[TService]]: TransmitServiceRequest<TServiceMap, TService, TMethod> | InvokeServiceRequest<TServiceMap, TService, TMethod>;
-    }[keyof TServiceMap[TService]];
-}[keyof TServiceMap];
-export type MethodRequest<TMethodMap extends MethodMap> = {
-    [TMethod in keyof TMethodMap]: TransmitMethodRequest<TMethodMap, TMethod> | InvokeMethodRequest<TMethodMap, TMethod>;
-}[keyof TMethodMap];
-export interface Request {
-    promise: Promise<void>;
-    sentCallback?: (err?: Error) => void;
-}
-export interface TransmitServiceRequest<TServiceMap extends ServiceMap, TService extends keyof TServiceMap, TMethod extends keyof TServiceMap[TService]> extends Request {
-    service: TService;
-    method: TMethod;
-    data?: Parameters<TServiceMap[TService][TMethod]>[0];
-}
-export interface TransmitMethodRequest<TMethodMap extends MethodMap, TMethod extends keyof TMethodMap> extends Request {
-    method: TMethod;
-    data?: Parameters<TMethodMap[TMethod]>[0];
-}
-export interface InvokeServiceRequest<TServiceMap extends ServiceMap, TService extends keyof TServiceMap, TMethod extends keyof TServiceMap[TService]> extends TransmitServiceRequest<TServiceMap, TService, TMethod> {
-    cid: number;
-    ackTimeoutMs: number | false;
-    timeoutId?: NodeJS.Timeout;
-    callback: (err: Error, result?: TServiceMap[TService][TMethod]) => void | null;
-}
-export interface InvokeMethodRequest<TMethodMap extends MethodMap, TMethod extends keyof TMethodMap> extends TransmitMethodRequest<TMethodMap, TMethod> {
-    cid: number;
-    ackTimeoutMs: number | false;
-    timeoutId?: NodeJS.Timeout;
-    callback: (err: Error, result?: TMethodMap[TMethod]) => void | null;
-}
-export declare function isRequestDone<TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap>(request: AnyRequest<TOutgoing, TPrivateOutgoing, TService>): boolean;

package/dist/request.js

@@ -1,4 +1,4 @@
-import { toArray } from "./utils.js";
+import { toArray } from './utils.js';
 export function abortRequest(request, err) {
     if (request.sentCallback) {
         request.sentCallback(err);
@@ -7,11 +7,22 @@ export function abortRequest(request, err) {
         request.callback(err);
     }
 }
+export function isRequestDone(request) {
+    if ('callback' in request) {
+        return (request.callback === null);
+    }
+    return !request.sentCallback;
+}
 export class RequestCollection {
+    _callbacks;
+    _requests;
     constructor(requests) {
         this._requests = toArray(requests).filter(req => !isRequestDone(req));
         this._callbacks = [];
     }
+    isDone() {
+        return this._requests.length === 0;
+    }
     get items() {
         return this._requests;
     }
@@ -29,9 +40,6 @@ export class RequestCollection {
             });
         }
     }
-    isDone() {
-        return this._requests.length === 0;
-    }
     [Symbol.iterator]() {
         const values = this._requests;
         let index = 0;
@@ -40,7 +48,7 @@ export class RequestCollection {
                 if (index < values.length) {
                     const val = values[index];
                     index++;
-                    return { value: val, done: false };
+                    return { done: false, value: val };
                 }
                 else
                     return { done: true };
@@ -48,9 +56,3 @@ export class RequestCollection {
         };
     }
 }
-export function isRequestDone(request) {
-    if ('callback' in request) {
-        return (request.callback === null);
-    }
-    return !request.sentCallback;
-}

package/dist/response.d.ts

@@ -1,21 +1,25 @@
-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> = {
+import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from './maps/method-map.js';
+export type AnyResponse = DataResponse | ErrorResponse | Response;
+export interface DataResponse extends Response {
+    data: unknown;
+}
+export interface ErrorResponse extends Response {
+    error: Error;
+}
+export interface OutgoingDataResponse<T> extends Response {
+    data: T;
+}
+export type OutgoingMethodDataResponse<TMethodMap extends MethodMap> = {
+    [TMethod in keyof TMethodMap]: OutgoingDataResponse<ReturnType<TMethodMap[TMethod]>>;
+}[keyof TMethodMap];
+export type OutgoingResponse<TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap> = ErrorResponse | OutgoingMethodDataResponse<TOutgoing> | OutgoingMethodDataResponse<TPrivateOutgoing> | OutgoingServiceDataResponse<TService> | Response;
+export type OutgoingServiceDataResponse<TServiceMap extends ServiceMap> = {
     [TService in keyof TServiceMap]: {
-        [TMethod in keyof TServiceMap[TService]]: DataResponse<ReturnType<TServiceMap[TService][TMethod]>>;
+        [TMethod in keyof TServiceMap[TService]]: OutgoingDataResponse<ReturnType<TServiceMap[TService][TMethod]>>;
     }[keyof TServiceMap[TService]];
 }[keyof TServiceMap];
-export type MethodDataResponse<TMethodMap extends MethodMap> = {
-    [TMethod in keyof TMethodMap]: DataResponse<ReturnType<TMethodMap[TMethod]>>;
-}[keyof TMethodMap];
 export interface Response {
     rid: number;
     timeoutAt?: Date;
 }
-export interface ErrorResponse extends Response {
-    error: Error;
-}
-export interface DataResponse<T> extends Response {
-    data: T;
-}
+export declare function isResponsePacket(packet?: unknown): packet is AnyResponse;

package/dist/response.js

@@ -1,3 +1,5 @@
 export function isResponsePacket(packet) {
-    return (typeof packet === 'object') && 'rid' in packet;
+    return (packet !== null
+        && typeof packet === 'object'
+        && 'rid' in packet);
 }

package/dist/socket-event.d.ts

@@ -1,21 +1,20 @@
-import ws from "isomorphic-ws";
-import { MethodPacket, ServicePacket } from "./packet.js";
-import { AuthToken, SignedAuthToken } from "@socket-mesh/auth";
-import { AnyResponse } from "./response.js";
-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;
+import { AuthToken, SignedAuthToken } from '@socket-mesh/auth';
+import ws from 'isomorphic-ws';
+import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from './maps/method-map.js';
+import { AnyPacket, IncomingPacket } from './packet.js';
+import { AnyResponse, OutgoingResponse } from './response.js';
 export interface AuthenticatedChangeEvent {
+    authToken: AuthToken | null;
     isAuthenticated: true;
-    wasAuthenticated: boolean;
     signedAuthToken: SignedAuthToken;
-    authToken: AuthToken;
+    wasAuthenticated: boolean;
 }
 export interface AuthenticateEvent {
-    wasSigned: boolean;
+    authToken: AuthToken | null;
     signedAuthToken: SignedAuthToken;
-    authToken: AuthToken;
+    wasSigned: boolean;
 }
+export type AuthStateChangeEvent = AuthenticatedChangeEvent | DeauthenticatedChangeEvent;
 export interface BadAuthTokenEvent {
     error: Error;
     signedAuthToken: SignedAuthToken;
@@ -25,21 +24,20 @@ export interface CloseEvent {
     reason?: string;
 }
 export interface ConnectEvent {
-    id: string;
+    authError?: Error;
+    id: null | string;
     isAuthenticated: boolean;
     pingTimeoutMs: number;
-    authError?: Error;
-}
-export interface ConnectingEvent {
-}
-export interface DeauthenticateEvent {
-    signedAuthToken: SignedAuthToken;
-    authToken: AuthToken;
 }
+export type ConnectingEvent = object;
 export interface DeauthenticatedChangeEvent {
     isAuthenticated: false;
     wasAuthenticated: true;
 }
+export interface DeauthenticateEvent {
+    authToken: AuthToken | null;
+    signedAuthToken: SignedAuthToken;
+}
 export interface DisconnectEvent {
     code: number;
     reason?: string;
@@ -51,16 +49,22 @@ export interface MessageEvent {
     data: string | ws.RawData;
     isBinary: boolean;
 }
-export interface PingEvent {
-}
-export interface PongEvent {
-}
+export type PingEvent = object;
+export type PongEvent = object;
 export interface RemoveAuthTokenEvent {
     oldAuthToken: SignedAuthToken;
 }
-export interface RequestEvent<TIncoming extends MethodMap, TService extends ServiceMap> {
-    request: ServicePacket<TService> | MethodPacket<TIncoming>;
+export interface RequestEvent {
+    request: AnyPacket;
+}
+export interface ResponseEvent {
+    response: AnyResponse;
+}
+export type SocketEvent = AuthenticateEvent | AuthStateChangeEvent | BadAuthTokenEvent | CloseEvent | ConnectEvent | ConnectingEvent | DeauthenticateEvent | DisconnectEvent | ErrorEvent | MessageEvent | PingEvent | PongEvent | RemoveAuthTokenEvent | RequestEvent | ResponseEvent;
+export interface TypedRequestEvent<TIncoming extends MethodMap, TService extends ServiceMap = {}> {
+    request: IncomingPacket<TIncoming, TService>;
 }
-export interface ResponseEvent<TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap> {
-    response: AnyResponse<TOutgoing, TPrivateOutgoing, TService>;
+export interface TypedResponseEvent<TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap = {}, TService extends ServiceMap = {}> {
+    response: OutgoingResponse<TOutgoing, TPrivateOutgoing, TService>;
 }
+export type TypedSocketEvent<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap = {}, TService extends ServiceMap = {}> = AuthenticateEvent | AuthStateChangeEvent | BadAuthTokenEvent | CloseEvent | ConnectEvent | ConnectingEvent | DeauthenticateEvent | DisconnectEvent | ErrorEvent | MessageEvent | PingEvent | PongEvent | RemoveAuthTokenEvent | TypedRequestEvent<TIncoming, TService> | TypedResponseEvent<TOutgoing, TPrivateOutgoing, TService>;