@socket-mesh/core 1.0.2 → 1.0.4

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,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 { 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>;
 }>;

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";
+export * from './handler-map.js';
+export * from './method-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";
+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,15 @@ 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;
+};

package/dist/maps/method-map.js

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

package/dist/packet.d.ts

@@ -1,27 +1,26 @@
-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']>;
+import { MethodMap, ServiceMap } from './maps/method-map.js';
+export type AnyPacket<TIncoming extends MethodMap, TService extends ServiceMap> = MethodPacket<TIncoming> | ServicePacket<TService>;
+export type MethodPacket<TMethodMap extends MethodMap> = {
+    [TMethod in keyof TMethodMap]: MethodRequestPacket<TMethodMap, TMethod>;
+}[keyof TMethodMap];
+export interface MethodRequestPacket<TMethodMap extends MethodMap, TMethod extends keyof TMethodMap> extends RequestPacket {
+    ackTimeoutMs?: boolean | number;
+    data: Parameters<TMethodMap[TMethod]>[0];
+    method: TMethod;
+}
+interface RequestPacket {
+    cid?: number;
+}
 export type ServicePacket<TServiceMap extends ServiceMap> = {
     [TService in keyof TServiceMap]: {
         [TMethod in keyof TServiceMap[TService]]: ServiceRequestPacket<TServiceMap, TService, TMethod>;
     }[keyof TServiceMap[TService]];
 }[keyof TServiceMap];
-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;
+    ackTimeoutMs?: boolean | number;
     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;
+    service: TService;
 }
-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/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 { EmptySocketMap, SocketMap } from "../maps/socket-map.js";
-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";
-export type PluginType = 'request' | 'response' | 'handshake';
-export interface PluginArgs<T extends SocketMap = EmptySocketMap> {
-    socket: Socket<T>;
-    transport: SocketTransport<T>;
-}
-export interface DisconnectedPluginArgs<T extends SocketMap = EmptySocketMap> extends PluginArgs<T> {
-    status: SocketStatus;
+import ws from 'isomorphic-ws';
+import { HandlerMap } from '../maps/handler-map.js';
+import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from '../maps/method-map.js';
+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';
+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> {
     code: number;
     reason?: string;
+    status: SocketStatus;
 }
-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> {
+    packet: AnyPacket<TIncoming, TService> | AnyResponse<TOutgoing, TPrivateOutgoing, TService>;
     timestamp: Date;
-    packet: AnyPacket<T> | AnyResponse<T>;
 }
-export interface MessageRawPluginArgs<T extends SocketMap = EmptySocketMap> extends PluginArgs<T> {
-    timestamp: Date;
-    message: ws.RawData | string;
+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> {
+    message: string | ws.RawData;
     promise: Promise<void>;
+    timestamp: Date;
+}
+export interface Plugin<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> {
+    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<string | ws.RawData>;
+    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;
+    type: string;
 }
-export interface SendRequestPluginArgs<T extends SocketMap = EmptySocketMap> extends PluginArgs<T> {
-    requests: AnyRequest<T>[];
-    cont: (requests: AnyRequest<T>[]) => void;
+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 SendResponsePluginArgs<T extends SocketMap = EmptySocketMap> extends PluginArgs<T> {
-    responses: AnyResponse<T>[];
-    cont: (requests: AnyResponse<T>[]) => void;
+export type PluginType = 'handshake' | 'request' | 'response';
+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> {
+    cont: (requests: AnyRequest<TOutgoing, TPrivateOutgoing, TService>[]) => void;
+    requests: AnyRequest<TOutgoing, TPrivateOutgoing, TService>[];
 }
-export interface Plugin<T extends SocketMap = EmptySocketMap> {
-    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;
+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> {
+    cont: (requests: AnyResponse<TOutgoing, TPrivateOutgoing, TService>[]) => void;
+    responses: AnyResponse<TOutgoing, TPrivateOutgoing, TService>[];
 }

package/dist/request-handler.d.ts

@@ -1,24 +1,24 @@
-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';
+import { SocketTransport } from './socket-transport.js';
+import { Socket } from './socket.js';
+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>;
+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;
+    options: TOptions;
     socket: TSocket;
+    timeoutMs?: boolean | number;
     transport: TTransport;
-    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;
     requestedAt: Date;
     socket: TSocket;
-    timeoutMs?: number | boolean;
+    timeoutMs?: boolean | number;
     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>;

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,55 +1,54 @@
-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> {
-    private readonly _requests;
-    private readonly _callbacks;
-    constructor(requests: AnyRequest<T> | AnyRequest<T>[]);
-    get items(): ReadonlyArray<AnyRequest<T>>;
-    listen(cb: () => void): void;
-    isDone(): boolean;
-    [Symbol.iterator](): {
-        next(): {
-            value: AnyRequest<T>;
-            done: boolean;
-        } | {
-            done: boolean;
-            value?: undefined;
-        };
-    };
+import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from './maps/method-map.js';
+export type AnyRequest<TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap> = MethodRequest<TOutgoing> | MethodRequest<TPrivateOutgoing> | ServiceRequest<TService>;
+export interface InvokeMethodRequest<TMethodMap extends MethodMap, TMethod extends keyof TMethodMap> extends TransmitMethodRequest<TMethodMap, TMethod> {
+    ackTimeoutMs: false | number;
+    callback: ((err: Error | null, result?: TMethodMap[TMethod]) => void) | null;
+    cid: number;
+    timeoutId?: NodeJS.Timeout;
+}
+export interface InvokeServiceRequest<TServiceMap extends ServiceMap, TService extends keyof TServiceMap, TMethod extends keyof TServiceMap[TService]> extends TransmitServiceRequest<TServiceMap, TService, TMethod> {
+    ackTimeoutMs: false | number;
+    callback: ((err: Error | null, result?: TServiceMap[TService][TMethod]) => void) | null;
+    cid: number;
+    timeoutId?: NodeJS.Timeout;
 }
-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>;
+    [TMethod in keyof TMethodMap]: InvokeMethodRequest<TMethodMap, TMethod> | TransmitMethodRequest<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 type ServiceRequest<TServiceMap extends ServiceMap> = {
+    [TService in keyof TServiceMap]: {
+        [TMethod in keyof TServiceMap[TService]]: InvokeServiceRequest<TServiceMap, TService, TMethod> | TransmitServiceRequest<TServiceMap, TService, TMethod>;
+    }[keyof TServiceMap[TService]];
+}[keyof TServiceMap];
 export interface TransmitMethodRequest<TMethodMap extends MethodMap, TMethod extends keyof TMethodMap> extends Request {
-    method: TMethod;
     data?: Parameters<TMethodMap[TMethod]>[0];
+    method: TMethod;
 }
-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 TransmitServiceRequest<TServiceMap extends ServiceMap, TService extends keyof TServiceMap, TMethod extends keyof TServiceMap[TService]> extends Request {
+    data?: Parameters<TServiceMap[TService][TMethod]>[0];
+    method: TMethod;
+    service: TService;
 }
-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 abortRequest<TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap>(request: AnyRequest<TOutgoing, TPrivateOutgoing, TService>, err: Error): void;
+export declare function isRequestDone<TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap>(request: AnyRequest<TOutgoing, TPrivateOutgoing, TService>): boolean;
+export declare class RequestCollection<TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap> {
+    private readonly _callbacks;
+    private readonly _requests;
+    constructor(requests: AnyRequest<TOutgoing, TPrivateOutgoing, TService> | AnyRequest<TOutgoing, TPrivateOutgoing, TService>[]);
+    isDone(): boolean;
+    get items(): ReadonlyArray<AnyRequest<TOutgoing, TPrivateOutgoing, TService>>;
+    listen(cb: () => void): void;
+    [Symbol.iterator](): {
+        next(): {
+            done: boolean;
+            value: AnyRequest<TOutgoing, TPrivateOutgoing, TService> | undefined;
+        } | {
+            done: boolean;
+            value?: undefined;
+        };
+    };
 }
-export declare function isRequestDone<T extends SocketMap>(request: AnyRequest<T>): 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,12 +1,11 @@
-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>;
-export type ServiceDataResponse<TServiceMap extends ServiceMap> = {
-    [TService in keyof TServiceMap]: {
-        [TMethod in keyof TServiceMap[TService]]: DataResponse<ReturnType<TServiceMap[TService][TMethod]>>;
-    }[keyof TServiceMap[TService]];
-}[keyof TServiceMap];
+import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from './maps/method-map.js';
+export type AnyResponse<TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap> = ErrorResponse | MethodDataResponse<TOutgoing> | MethodDataResponse<TPrivateOutgoing> | Response | ServiceDataResponse<TService>;
+export interface DataResponse<T> extends Response {
+    data: T;
+}
+export interface ErrorResponse extends Response {
+    error: Error;
+}
 export type MethodDataResponse<TMethodMap extends MethodMap> = {
     [TMethod in keyof TMethodMap]: DataResponse<ReturnType<TMethodMap[TMethod]>>;
 }[keyof TMethodMap];
@@ -14,9 +13,9 @@ export interface Response {
     rid: number;
     timeoutAt?: Date;
 }
-export interface ErrorResponse extends Response {
-    error: Error;
-}
-export interface DataResponse<T> extends Response {
-    data: T;
-}
+export type ServiceDataResponse<TServiceMap extends ServiceMap> = {
+    [TService in keyof TServiceMap]: {
+        [TMethod in keyof TServiceMap[TService]]: DataResponse<ReturnType<TServiceMap[TService][TMethod]>>;
+    }[keyof TServiceMap[TService]];
+}[keyof TServiceMap];
+export declare function isResponsePacket<TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap>(packet?: unknown): packet is AnyResponse<TOutgoing, TPrivateOutgoing, TService>;

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 { 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>;
-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 { MethodPacket, ServicePacket } from './packet.js';
+import { AnyResponse } 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,15 @@ 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<T extends SocketMap> {
-    request: ServicePacket<T['Service']> | MethodPacket<T['Incoming']>;
+export interface RequestEvent<TIncoming extends MethodMap, TService extends ServiceMap> {
+    request: MethodPacket<TIncoming> | ServicePacket<TService>;
 }
-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>;
 }
+export type SocketEvent<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 | RequestEvent<TIncoming, TService> | ResponseEvent<TOutgoing, TPrivateOutgoing, TService>;