@socket-mesh/core 1.0.0 → 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

@@ -1,10 +1,9 @@
 import ws from "isomorphic-ws";
-import { ClientRequest, IncomingMessage } from "http";
 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> | UnexpectedResponseEvent | UpgradeEvent;
+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;
@@ -53,24 +52,15 @@ export interface MessageEvent {
     isBinary: boolean;
 }
 export interface PingEvent {
-    data: Buffer;
 }
 export interface PongEvent {
-    data: Buffer;
 }
 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 UnexpectedResponseEvent {
-    request: ClientRequest;
-    response: IncomingMessage;
-}
-export interface UpgradeEvent {
-    request: IncomingMessage;
+export interface ResponseEvent<TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap> {
+    response: AnyResponse<TOutgoing, TPrivateOutgoing, TService>;
 }

package/dist/socket-transport.d.ts

@@ -3,12 +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 { ClientRequest, IncomingMessage } from "http";
-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;
@@ -19,7 +17,11 @@ export interface InvokeServiceOptions<TServiceMap extends ServiceMap, TService e
     method: TMethod;
     ackTimeoutMs?: number | false;
 }
-export declare class SocketTransport<T extends SocketMap> {
+export interface InboundMessage<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap> {
+    timestamp: Date;
+    packet: (AnyPacket<TIncoming, TService> | AnyResponse<TOutgoing, TPrivateOutgoing, TService>) | (AnyPacket<TIncoming, TService> | AnyResponse<TOutgoing, TPrivateOutgoing, TService>)[];
+}
+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;
@@ -34,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>;
@@ -48,45 +50,44 @@ export declare class SocketTransport<T extends SocketMap> {
     getBackpressure(): number;
     getInboundBackpressure(): number;
     getOutboundBackpressure(): number;
-    private handleInboudMessage;
+    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 onMessage(data: ws.RawData, isBinary: boolean): 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 onPing(data: Buffer): void;
-    protected onPong(data: Buffer): void;
-    protected onRequest(packet: AnyPacket<T>, timestamp: Date, pluginError?: Error): Promise<boolean>;
-    protected onResponse(response: AnyResponse<T>, pluginError?: Error): void;
-    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 onUnexpectedResponse(request: ClientRequest, response: IncomingMessage): void;
-    protected onUnhandledRequest(packet: AnyPacket<T>): boolean;
-    protected onUpgrade(request: IncomingMessage): void;
-    ping(): Promise<void>;
+    protected onPingPong(): 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<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-transport.js

@@ -82,8 +82,7 @@ export class SocketTransport {
     getOutboundBackpressure() {
         return this._outboundPreparedMessageCount - this._outboundSentMessageCount;
     }
-    async handleInboudMessage({ data, timestamp }) {
-        let packet = this.decode(data);
+    async handleInboudMessage({ packet, timestamp }) {
         if (packet === null) {
             return;
         }
@@ -157,8 +156,13 @@ export class SocketTransport {
         this.sendRequest([request]);
     }
     onMessage(data, isBinary) {
+        data = isBinary ? data : data.toString();
+        if (data === '') {
+            this.onPingPong();
+            return;
+        }
         const timestamp = new Date();
-        let p = Promise.resolve(isBinary ? data : data.toString());
+        let p = Promise.resolve(data);
         let resolve;
         let reject;
         const promise = new Promise((res, rej) => {
@@ -175,8 +179,9 @@ export class SocketTransport {
             }
         }
         p.then(data => {
+            const packet = this.decode(data);
             this._socket.emit('message', { data, isBinary });
-            return this.handleInboudMessage({ data, timestamp });
+            return this.handleInboudMessage({ packet, timestamp });
         })
             .then(resolve)
             .catch(err => {
@@ -196,12 +201,7 @@ export class SocketTransport {
             }
         }
     }
-    onPing(data) {
-        this._socket.emit('ping', { data });
-    }
-    onPong(data) {
-        this._socket.emit('pong', { data });
-    }
+    onPingPong() { }
     async onRequest(packet, timestamp, pluginError) {
         this._socket.emit('request', { request: packet });
         const timeoutAt = typeof packet.ackTimeoutMs === 'number' ? new Date(timestamp.valueOf() + packet.ackTimeoutMs) : null;
@@ -273,33 +273,24 @@ export class SocketTransport {
             this._socket.emit('response', { response });
         }
     }
+    onSocketClose(event) {
+        this.onClose(event.code, event.reason);
+    }
+    onSocketError(event) {
+        this.onError(event.error);
+    }
+    onSocketMessage(event) {
+        this.onMessage(event.data, false);
+    }
     onTransmit(request) {
         this.sendRequest([request]);
     }
-    onUnexpectedResponse(request, response) {
-        this._socket.emit('unexpectedResponse', { request, response });
-    }
     onUnhandledRequest(packet) {
         if (this._onUnhandledRequest) {
             return this._onUnhandledRequest(this, packet);
         }
         return false;
     }
-    onUpgrade(request) {
-        this._socket.emit('upgrade', { request });
-    }
-    ping() {
-        return new Promise((resolve, reject) => {
-            this.webSocket.ping(undefined, undefined, (err) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve();
-                }
-            });
-        });
-    }
     resetPingTimeout(timeoutMs, code) {
         if (this._pingTimeoutRef) {
             clearTimeout(this._pingTimeoutRef);
@@ -385,18 +376,24 @@ export class SocketTransport {
             const { promise, ...rest } = req;
             return rest;
         });
-        this._webSocket.send(this.codecEngine.encode(encode.length === 1 ? encode[0] : encode), (err) => {
+        let sendErr;
+        this.send(this.codecEngine.encode(encode.length === 1 ? encode[0] : encode)).catch(err => {
+            sendErr = err;
+        }).then(() => {
+            const errCode = sendErr?.code;
             for (const req of requests) {
-                if (err?.code === 'ECONNRESET') {
-                    err = new BadConnectionError(`Socket ${'callback' in req ? 'invoke' : 'transmit'} ${String(req.method)} event was aborted due to a bad connection`, 'connectAbort');
+                if (errCode === 'ECONNRESET') {
+                    sendErr = new BadConnectionError(`Socket ${'callback' in req ? 'invoke' : 'transmit'} ${String(req.method)} event was aborted due to a bad connection`, 'connectAbort');
                 }
                 if (req.sentCallback) {
-                    req.sentCallback(err);
+                    req.sentCallback(sendErr);
                 }
-                if (err && 'callback' in req) {
-                    req.callback(err);
+                if (sendErr && 'callback' in req) {
+                    req.callback(sendErr);
                 }
             }
+        }).catch(err => {
+            this.onError(err);
         });
     }
     sendResponse(index, responses) {
@@ -441,10 +438,8 @@ export class SocketTransport {
         }
         //timeoutId?: NodeJS.Timeout;
         //callback: (err: Error, result?: U) => void | null
-        this._webSocket.send(this.codecEngine.encode(responses.length === 1 ? responses[0] : responses), (err) => {
-            if (err) {
-                this.onError(err);
-            }
+        this.send(this.codecEngine.encode(responses.length === 1 ? responses[0] : responses)).catch(err => {
+            this.onError(err);
         });
     }
     async setAuthorization(signedAuthToken, authToken) {
@@ -639,33 +634,21 @@ export class SocketTransport {
     }
     set webSocket(value) {
         if (this._webSocket) {
-            this._webSocket.off('open', this.onOpen);
-            this._webSocket.off('close', this.onClose);
-            this._webSocket.off('error', this.onError);
-            this._webSocket.off('upgrade', this.onUpgrade);
-            this._webSocket.off('message', this.onMessage);
-            this._webSocket.off('ping', this.onPing);
-            this._webSocket.off('pong', this.onPong);
-            this._webSocket.off('unexpectedResponse', this.onUnexpectedResponse);
+            this._webSocket.onclose = null;
+            this._webSocket.onerror = null;
+            this._webSocket.onmessage = null;
+            this._webSocket.onopen = null;
+            delete this.onSocketClose;
+            delete this.onSocketError;
+            delete this.onSocketMessage;
             delete this.onOpen;
-            delete this.onClose;
-            delete this.onError;
-            delete this.onUpgrade;
-            delete this.onMessage;
-            delete this.onPing;
-            delete this.onPong;
-            delete this.onUnexpectedResponse;
         }
         this._webSocket = value;
         if (value) {
-            this._webSocket.on('open', this.onOpen = this.onOpen.bind(this));
-            this._webSocket.on('close', this.onClose = this.onClose.bind(this));
-            this._webSocket.on('error', this.onError = this.onError.bind(this));
-            this._webSocket.on('upgrade', this.onUpgrade = this.onUpgrade.bind(this));
-            this._webSocket.on('message', this.onMessage = this.onMessage.bind(this));
-            this._webSocket.on('ping', this.onPing = this.onPing.bind(this));
-            this._webSocket.on('pong', this.onPong = this.onPong.bind(this));
-            this._webSocket.on('unexpectedResponse', this.onUnexpectedResponse = this.onUnexpectedResponse.bind(this));
+            this._webSocket.onclose = this.onSocketClose = this.onSocketClose.bind(this);
+            this._webSocket.onopen = this.onOpen = this.onOpen.bind(this);
+            this._webSocket.onerror = this.onSocketError = this.onSocketError.bind(this);
+            this._webSocket.onmessage = this.onSocketMessage = this.onSocketMessage.bind(this);
         }
     }
 }

package/dist/socket.d.ts

@@ -1,31 +1,30 @@
 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, UnexpectedResponseEvent, UpgradeEvent, ResponseEvent, AuthStateChangeEvent, RemoveAuthTokenEvent, ConnectingEvent, DeauthenticateEvent } from "./socket-event.js";
-import { FunctionReturnType } from "./maps/method-map.js";
+import { SocketEvent, AuthenticateEvent, BadAuthTokenEvent, CloseEvent, ConnectEvent, DisconnectEvent, ErrorEvent, MessageEvent, PingEvent, PongEvent, RequestEvent, ResponseEvent, AuthStateChangeEvent, RemoveAuthTokenEvent, ConnectingEvent, DeauthenticateEvent } from "./socket-event.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,11 +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;
-    emit(event: 'unexpectedResponse', data: UnexpectedResponseEvent): void;
-    emit(event: 'upgrade', data: UpgradeEvent): 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>;
@@ -69,18 +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(event: 'unexpectedResponse'): DemuxedConsumableStream<UnexpectedResponseEvent>;
-    listen(event: 'upgrade'): DemuxedConsumableStream<UpgradeEvent>;
-    listen<U extends SocketEvent<T>, V = U>(event: string): DemuxedConsumableStream<V>;
-    ping(): Promise<void>;
+    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/dist/socket.js

@@ -36,9 +36,6 @@ export class Socket extends AsyncStreamEmitter {
     listen(event) {
         return super.listen(event);
     }
-    ping() {
-        return this._transport.ping();
-    }
     get status() {
         return this._transport.status;
     }

package/package.json

@@ -1,31 +1,31 @@
 {
-  "name": "@socket-mesh/core",
-  "version": "1.0.0",
-  "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/auth.git"
-  },
-  "bugs": {
-		"url": "https://github.com/socket-mesh/auth/issues"
-  },
+	"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 {};