@eleven-am/pondsocket 0.1.139 → 0.1.142

package/server/pondSocket.js

@@ -17,7 +17,7 @@ const http_1 = require("http");
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
 const ws_1 = require("ws");
 const middleware_1 = require("../abstracts/middleware");
-const endpoint_1 = require("../endpoint/endpoint");
+const endpointEngine_1 = require("../endpoint/endpointEngine");
 const response_1 = require("../endpoint/response");
 const matcher_1 = require("../matcher/matcher");
 class PondSocket {
@@ -62,7 +62,7 @@ class PondSocket {
      * })
      */
     createEndpoint(path, handler) {
-        const endpoint = new endpoint_1.Endpoint();
+        const endpoint = new endpointEngine_1.EndpointEngine(this);
         __classPrivateFieldGet(this, _PondSocket_middleware, "f").use((req, socket, next) => {
             const event = (0, matcher_1.parseAddress)(path, req.address);
             if (event) {
@@ -72,7 +72,7 @@ class PondSocket {
             }
             return next();
         });
-        return endpoint;
+        return new endpointEngine_1.Endpoint(endpoint);
     }
 }
 exports.PondSocket = PondSocket;
@@ -82,7 +82,7 @@ _PondSocket_server = new WeakMap(), _PondSocket_socketServer = new WeakMap(), _P
             socket.isAlive = true;
         });
     });
-    const interval = setInterval(() => {
+    return setInterval(() => {
         __classPrivateFieldGet(this, _PondSocket_socketServer, "f").clients.forEach((socket) => {
             if (socket.isAlive === false) {
                 return socket.terminate();
@@ -91,12 +91,15 @@ _PondSocket_server = new WeakMap(), _PondSocket_socketServer = new WeakMap(), _P
             socket.ping();
         });
     }, 30000);
-    __classPrivateFieldGet(this, _PondSocket_socketServer, "f").on('close', () => clearInterval(interval));
 }, _PondSocket_init = function _PondSocket_init() {
-    __classPrivateFieldGet(this, _PondSocket_instances, "m", _PondSocket_manageHeartbeat).call(this);
+    const timeout = __classPrivateFieldGet(this, _PondSocket_instances, "m", _PondSocket_manageHeartbeat).call(this);
     __classPrivateFieldGet(this, _PondSocket_server, "f").on('error', (error) => {
+        clearInterval(timeout);
         throw new Error(error.message);
     });
+    __classPrivateFieldGet(this, _PondSocket_server, "f").on('close', () => {
+        clearInterval(timeout);
+    });
     __classPrivateFieldGet(this, _PondSocket_server, "f").on('upgrade', (req, socket, head) => {
         const clientId = req.headers['sec-websocket-key'];
         const request = {

package/types.d.ts

@@ -1,16 +1,17 @@
 import { Server as HTTPServer } from 'http';
 
 import {
-    PondMessage,
-    PondPresence,
+    IncomingConnection,
+    JoinParams,
     PondAssigns,
     PondEvent,
-    PondPath,
-    JoinParams,
     PondEventMap,
-    IncomingConnection, UserData,
+    PondMessage,
+    PondPath,
+    PondPresence,
+    UserData,
 } from '@eleven-am/pondsocket-common';
-import { WebSocketServer } from 'ws';
+import { WebSocket, WebSocketServer } from 'ws';
 
 export * from '@eleven-am/pondsocket-common';
 
@@ -44,96 +45,102 @@ export declare class EventResponse<EventType extends PondEventMap = PondEventMap
     hasResponded: boolean;
 
     /**
-     * @desc Accepts the request and optionally assigns data to the client
-     * @param assigns - the data to assign to the client
+     * Assigns data to the client.
+     * @param {PondAssigns} assigns - The data to assign to the client.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    accept (assigns?: AssignType): EventResponse;
+    assign(assigns: AssignType): EventResponse<EventType, PresenceType, AssignType>;
 
     /**
-     * @desc Rejects the request and optionally assigns data to the client
-     * @param message - the error message
-     * @param errorCode - the error code
-     * @param assigns - the data to assign to the client
+     * @desc Emits a direct message to the client.
+     * @param {string} event - The event name.
+     * @param {PondMessage} payload - The payload to send.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    reject (message?: string, errorCode?: number, assigns?: AssignType): EventResponse;
+    reply<Event extends keyof EventType>(event: Event, payload: EventType[Event]): EventResponse<EventType, PresenceType, AssignType>;
 
     /**
-     * @desc Emits a direct message to the client, accepting the request
-     * @param event - the event name
-     * @param payload - the payload to send
-     * @param assigns - the data to assign to the client
+     * @desc Sends a message to all clients in the channel.
+     * @param {string} event - The event to send.
+     * @param {PondMessage} payload - The payload to send.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    send (event: string, payload: PondMessage, assigns?: AssignType): void;
+    broadcast<Event extends keyof EventType>(event: Event, payload: EventType[Event]): EventResponse<EventType, PresenceType, AssignType>;
 
     /**
-     * @desc Emits a direct message to the client without accepting the request
-     * @param event - the event name
-     * @param payload - the payload to send
-     * @param assigns - the data to assign to the client
+     * @desc Sends a message to all clients in the channel except the client making the request.
+     * @param {string} event - The event to send.
+     * @param {PondMessage} payload - The payload to send.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    sendOnly <Key extends keyof EventType> (event: Key, payload: EventType[Key], assigns?: AssignType): void;
+    broadcastFrom<UserEvent extends keyof EventType>(event: UserEvent, payload: EventType[UserEvent]): EventResponse<EventType, PresenceType, AssignType>;
 
     /**
-     * @desc Sends a message to all clients in the channel
-     * @param event - the event to send
-     * @param payload - the payload to send
+     * @desc Sends a message to a set of clients in the channel.
+     * @param {string} event - The event to send.
+     * @param {PondMessage} payload - The payload to send.
+     * @param {string | string[]} userIds - The ids of the clients to send the message to.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    broadcast <Key extends keyof EventType> (event: Key, payload: EventType[Key]): EventResponse;
+    broadcastTo<UserEvent extends keyof EventType>(event: UserEvent, payload: EventType[UserEvent], userIds: string | string[]): EventResponse<EventType, PresenceType, AssignType>;
 
     /**
-     * @desc Sends a message to all clients in the channel except the client making the request
-     * @param event - the event to send
-     * @param payload - the payload to send
+     * @desc Tracks a user's presence in the channel.
+     * @param {PondPresence} presence - The initial presence data.
+     * @param {string} userId - The id of the user to track.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    broadcastFromUser <Key extends keyof EventType> (event: Key, payload: EventType[Key]): EventResponse;
+    trackPresence(presence: PresenceType, userId?: string): EventResponse<EventType, PresenceType, AssignType>;
 
     /**
-     * @desc Sends a message to a set of clients in the channel
-     * @param event - the event to send
-     * @param payload - the payload to send
-     * @param userIds - the ids of the clients to send the message to
+     * @desc Updates a user's presence in the channel.
+     * @param {PondPresence} presence - The updated presence data.
+     * @param {string} userId - The id of the user to update.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    sendToUsers <Key extends keyof EventType> (event: Key, payload: EventType[Key], userIds: string[]): EventResponse;
+    updatePresence(presence: PresenceType, userId?: string): EventResponse;
 
     /**
-     * @desc Tracks a user's presence in the channel
-     * @param presence - the initial presence data
-     * @param userId - the id of the user to track
+     * @desc Removes a user's presence from the channel.
+     * @param {string} userId - The id of the user to remove.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    trackPresence (presence: PresenceType, userId?: string): EventResponse;
+    removePresence(userId?: string): EventResponse;
 
     /**
-     * @desc Updates a user's presence in the channel
-     * @param presence - the updated presence data
-     * @param userId - the id of the user to update
+     * @desc Subscribes the client to a channel.
+     * @param {string} channel - The channel to subscribe to.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    updatePresence (presence: PresenceType, userId?: string): EventResponse;
+    subscribeTo(channel: string): EventResponse;
 
     /**
-     * @desc Removes a user's presence from the channel
-     * @param userId - the id of the user to remove
+     * @desc Unsubscribes the client from a channel.
+     * @param {string} channel - The channel to unsubscribe from.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    unTrackPresence (userId?: string): EventResponse;
+    unsubscribeFrom(channel: string): EventResponse;
 
     /**
-     * @desc Evicts a user from the channel
-     * @param reason - the reason for the eviction
-     * @param userId - the id of the user to evict,
+     * @desc Evicts a user from the channel.
+     * @param {string} reason - The reason for the eviction.
+     * @param {string} userId - The id of the user to evict.
      */
-    evictUser (reason: string, userId?: string): void;
+    evictUser(reason: string, userId?: string): void;
 
     /**
-     * @desc Closes the channel from the server side for all clients
-     * @param reason - the reason for closing the channel
+     * @desc Closes the channel from the server side for all clients.
+     * @param {string} reason - The reason for closing the channel.
      */
-    closeChannel (reason: string): void;
+    closeChannel(reason: string): void;
 }
 
 export declare class Endpoint {
     /**
      * @desc Adds a new PondChannel to this path on this endpoint
-     * @param path - The path to add the channel to
-     * @param handler - The handler to use to authenticate the client
+     * @param {PondPath<string>} path - The path to add the channel to
+     * @param {ChannelHandler} handler - The handler to use to authenticate the client
+     * @returns {PondChannel} - The PondChannel instance for the new channel
      *
      * @example
      * const channel = endpoint.createChannel('/chat', (request, response) => {
@@ -144,20 +151,26 @@ export declare class Endpoint {
      *         response.reject('You are not an admin', 403);
      * });
      */
-    createChannel<Path extends string, EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> (path: PondPath<Path>, handler: (request: JoinRequest<Path, PresenceType, AssignType>, response: JoinResponse<EventType, PresenceType, AssignType>) => void | Promise<void>): PondChannel<EventType, PresenceType, AssignType>;
+    createChannel<Path extends string, EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns>(path: PondPath<Path>, handler: (request: JoinRequest<Path, PresenceType, AssignType>, response: JoinResponse<EventType, PresenceType, AssignType>) => void | Promise<void>): PondChannel<EventType, PresenceType, AssignType>;
 
     /**
      * @desc Broadcasts a message to all clients connected to this endpoint
-     * @param event - The event to broadcast
-     * @param payload - The payload to broadcast
+     * @param {string} event - The event to broadcast.
+     * @param {PondMessage} payload - The payload to broadcast.
+     * @returns {void}
      */
-    broadcast (event: string, payload: PondMessage): void;
+    broadcast(event: string, payload: PondMessage): void;
 
     /**
      * @desc Closes specific clients connected to this endpoint
-     * @param clientIds - The id for the client / clients to close
+     * @param {string | string[]} clientIds - The ids of the clients to close.
      */
-    closeConnection (clientIds: string | string[]): void;
+    closeConnection(clientIds: string | string[]): void;
+
+    /**
+     * @desc Returns all the clients connected to this endpoint
+     */
+    getClients(): WebSocket[];
 }
 
 export declare class Channel<EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
@@ -169,76 +182,82 @@ export declare class Channel<EventType extends PondEventMap = PondEventMap, Pres
     /**
      * @desc Gets the current assign data for the channel.
      */
-    getAssigns (): Record<string, AssignType>;
+    getAssigns(): Record<string, AssignType>;
 
     /**
      * @desc Gets the current presence data for the channel.
      */
-    getPresences (): Record<string, PresenceType>;
+    getPresences(): Record<string, PresenceType>;
 
     /**
      * @desc Gets the assign date for a specific user.
-     * @param userId - The id of the user to get the assign data for.
+     * @param {string} userId - The id of the user to get the data for.
      */
-    getUserData (userId: string): AssignType | null;
+    getUserData(userId: string): AssignType | null;
 
     /**
      * @desc Broadcasts a message to every client in the channel,
-     * @param event - The event to send.
-     * @param payload - The message to send.
+     * @param {string} event - The event to send.
+     * @param {PondMessage} payload - The message to send.
      */
-    broadcastMessage <Key extends keyof EventType> (event: Key, payload: EventType[Key]): void;
+    broadcast<Key extends keyof EventType>(event: Key, payload: EventType[Key]): void;
 
     /**
      * @desc Broadcasts a message to every client in the channel except the sender,
-     * @param userId - The id of the user to send the message from.
-     * @param event - The event to send.
-     * @param payload - The message to send.
+     * @param {string} userId - The id of the user to exclude from the broadcast.
+     * @param {string} event - The event to send.
+     * @param {PondMessage} payload - The message to send.
      */
-    broadcastMessageFromUser <Key extends keyof EventType> (userId: string, event: Key, payload: EventType[Key]): void;
+    broadcastFrom<Key extends keyof EventType>(userId: string, event: Key, payload: EventType[Key]): void;
 
     /**
      * @desc Sends a message to a specific client in the channel.
-     * @param userId - The id of the user to send the message to.
-     * @param event - The event to send.
-     * @param payload - The message to send.
-     */
-    sendToUser <Key extends keyof EventType> (userId: string, event: Key, payload: EventType[Key]): void;
-
-    /**
-     * @desc Sends a message to specific clients in the channel.
-     * @param userIds - The ids of the users to send the message to.
-     * @param event - The event to send.
-     * @param payload - The message to send.
+     * @param {string | string[]} clientIds - The id of the client to send the message to.
+     * @param {string} event - The event to send.
+     * @param {PondMessage} payload - The message to send.
      */
-    sendToUsers <Key extends keyof EventType> (userIds: string[], event: Key, payload: EventType[Key]): void;
+    broadcastTo<Key extends keyof EventType>(clientIds: string | string[], event: Key, payload: EventType[Key]): void;
 
     /**
      * @desc Bans a user from the channel.
-     * @param userId - The id of the user to ban.
-     * @param reason - The reason for the ban.
+     * @param {string} userId - The id of the user to ban.
+     * @param {string} reason - The reason for the ban.
      */
-    evictUser (userId: string, reason?: string): void;
+    evictUser(userId: string, reason?: string): void;
 
     /**
      * @desc tracks a user's presence in the channel
-     * @param userId - the id of the user to track
-     * @param presence - the presence of the user
+     * @param {string} userId - the id of the user to track
+     * @param {PondPresence} presence - the presence data to track
      */
-    trackPresence (userId: string, presence: PresenceType): void;
+    trackPresence(userId: string, presence: PresenceType): void;
 
     /**
      * @desc removes a user's presence from the channel
-     * @param userId - the id of the user to remove
+     * @param {string} userId - the id of the user to remove
      */
-    removePresence (userId: string): void;
+    removePresence(userId: string): void;
 
     /**
      * @desc updates a user's presence in the channel
-     * @param userId - the id of the user to update
-     * @param presence - the new presence of the user
+     * @param {string} userId - the id of the user to update
+     * @param {PondPresence} presence - the presence data to update
+     */
+    updatePresence(userId: string, presence: PresenceType): void;
+
+    /**
+     * @desc Subscribes a user to a channel.
+     * @param {string} userId - The id of the user.
+     * @param {string} channel - The channel to subscribe to.
+     */
+    subscribeTo(userId: string, channel: string): void;
+
+    /**
+     * @desc Unsubscribes a user from a channel.
+     * @param {string} userId - The id of the user.
+     * @param {string} channel - The channel to unsubscribe from.
      */
-    updatePresence (userId: string, presence: PresenceType): void;
+    unsubscribeFrom(userId: string, channel: string): void;
 }
 
 export declare class JoinRequest<Path extends string, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> extends AbstractRequest<Path, PresenceType, AssignType> {
@@ -256,53 +275,73 @@ export declare class JoinResponse<EventType extends PondEventMap = PondEventMap,
     hasResponded: boolean;
 
     /**
-     * @desc Accepts the request and optionally assigns data to the client
-     * @param assigns - the data to assign to the client
+     * @desc Assigns data to the client
+     * @param {PondAssigns} assigns - The data to assign
+     */
+    assign(assigns: AssignType): JoinResponse;
+
+    /**
+     * @desc Accepts the join request to the channel.
+     * @returns {JoinResponse} - The JoinResponse instance for chaining.
      */
-    accept (assigns?: AssignType): JoinResponse;
+    accept(): JoinResponse;
 
     /**
      * @desc Rejects the request and optionally assigns data to the client
-     * @param message - the error message
-     * @param errorCode - the error code
+     * @param {string} message - The error message
+     * @param {number} errorCode - The error code
      */
-    reject (message?: string, errorCode?: number): JoinResponse;
+    decline(message?: string, errorCode?: number): JoinResponse;
 
     /**
      * @desc Emits a direct message to the client
-     * @param event - the event name
-     * @param payload - the payload to send
-     * @param assigns - the data to assign to the client
+     * @param {string} event - The event name
+     * @param {PondMessage} payload - The payload to send
+     * @param {PondAssigns} assigns - The data to assign to the client
      */
-    send <Key extends keyof EventType> (event: Key, payload: EventType[Key], assigns?: AssignType): JoinResponse;
+    reply<Key extends keyof EventType>(event: Key, payload: EventType[Key], assigns?: AssignType): JoinResponse;
 
     /**
      * @desc Emits a message to all clients in the channel
-     * @param event - the event name
-     * @param payload - the payload to send
+     * @param {string} event - The event name
+     * @param {PondMessage} payload - The payload to send
      */
-    broadcast <Key extends keyof EventType> (event: Key, payload: EventType[Key]): JoinResponse;
+    broadcast<Key extends keyof EventType>(event: Key, payload: EventType[Key]): JoinResponse;
 
     /**
      * @desc Emits a message to all clients in the channel except the sender
      * @param event - the event name
      * @param payload - the payload to send
      */
-    broadcastFromUser <Key extends keyof EventType> (event: Key, payload: EventType[Key]): JoinResponse;
+    broadcastFrom<Key extends keyof EventType>(event: Key, payload: EventType[Key]): JoinResponse;
 
     /**
      * @desc Emits a message to a specific set of clients
-     * @param event - the event name
-     * @param payload  - the payload to send
-     * @param userIds - the ids of the clients to send the message to
+     * @param {string} event - The event name
+     * @param {PondMessage} payload - The payload to send
+     * @param {string | string[]} userIds - The ids of the clients to send the message to
      */
-    sendToUsers <Key extends keyof EventType> (event: Key, payload: EventType[Key], userIds: string[]): JoinResponse;
+    broadcastTo<Key extends keyof EventType>(event: Key, payload: EventType[Key], userIds: string | string[]): JoinResponse;
 
     /**
      * @desc tracks the presence of a client
-     * @param presence - the presence data to track
+     * @param {PondPresence} presence - the presence data to track
+     */
+    trackPresence(presence: PresenceType): JoinResponse;
+
+    /**
+     * @desc Subscribes the client to a channel.
+     * @param {string} channel - The channel to subscribe to.
+     * @returns {JoinResponse} - The JoinResponse instance for chaining.
+     */
+    subscribeTo(channel: string): JoinResponse;
+
+    /**
+     * @desc Unsubscribes the client from a channel.
+     * @param {string} channel - The channel to unsubscribe from.
+     * @returns {JoinResponse} - The JoinResponse instance for chaining.
      */
-    trackPresence (presence: PresenceType): JoinResponse;
+    unsubscribeFrom(channel: string): JoinResponse;
 }
 
 export declare class ConnectionResponse {
@@ -312,28 +351,47 @@ export declare class ConnectionResponse {
     hasResponded: boolean;
 
     /**
-     * @desc Accepts the request and optionally assigns data to the client
-     * @param assigns - the data to assign to the client
+     * @desc Assigns data to the user.
+     * @param {PondAssigns} assigns - The data to assign.
+     * @returns {ConnectionResponse} - The ConnectionResponse instance for chaining.
+     */
+    assign(assigns: PondAssigns): ConnectionResponse;
+
+    /**
+     * @desc Accepts the connection request to the endpoint.
      */
-    accept (assigns?: PondAssigns): void;
+    accept(): void;
 
     /**
      * @desc Rejects the request with the given error message
-     * @param message - the error message
-     * @param errorCode - the error code
+     * @param {string} message - The error message
+     * @param {number} errorCode - The error code
      */
-    reject (message?: string, errorCode?: number): void;
+    decline(message?: string, errorCode?: number): void;
 
     /**
      * @desc Emits a direct message to the client
-     * @param event - the event name
-     * @param payload - the payload to send
-     * @param assigns - the data to assign to the client
+     * @param {string} event - The event name
+     * @param {PondMessage} payload - The payload to send
+     */
+    reply(event: string, payload: PondMessage): ConnectionResponse;
+
+    /**
+     * @desc Subscribes the client to a channel.
+     * @param {string} channel - The channel to subscribe to.
+     * @returns {ConnectionResponse} - The JoinResponse instance for chaining.
      */
-    send (event: string, payload: PondMessage, assigns?: PondAssigns): void;
+    subscribeTo(channel: string): ConnectionResponse;
+
+    /**
+     * @desc Unsubscribes the client from a channel.
+     * @param {string} channel - The channel to unsubscribe from.
+     * @returns {ConnectionResponse} - The JoinResponse instance for chaining.
+     */
+    unsubscribeFrom(channel: string): ConnectionResponse;
 }
 
-export declare class PondChannel <EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
+export declare class PondChannel<EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
     /**
      * @desc Handles an event request made by a user
      * @param event - The event to listen for
@@ -345,7 +403,7 @@ export declare class PondChannel <EventType extends PondEventMap = PondEventMap,
      *     });
      * });
      */
-    onEvent<Event extends string> (event: PondPath<Event>, handler: (request: EventRequest<Event, PresenceType, AssignType>, response: EventResponse<EventType, PresenceType, AssignType>) => void | Promise<void>): void;
+    onEvent<Event extends string>(event: PondPath<Event>, handler: (request: EventRequest<Event, PresenceType, AssignType>, response: EventResponse<EventType, PresenceType, AssignType>) => void | Promise<void>): void;
 
     /**
      * @desc Broadcasts a message to all users in a channel
@@ -359,35 +417,39 @@ export declare class PondChannel <EventType extends PondEventMap = PondEventMap,
      *    channel: 'my_channel',
      *});
      */
-    broadcast <Key extends keyof EventType> (event: Key, payload: EventType[Key], channelName?: string): void;
+    broadcast<Key extends keyof EventType>(event: Key, payload: EventType[Key], channelName?: string): void;
 
     /**
      * @desc Handles the leave event for a user, can occur when a user disconnects or leaves a channel, use this to clean up any resources
-     * @param callback - The callback to execute when a user leaves
+     * @param {LeaveCallback} callback - The callback to execute when a user leaves
+     * @example
+     * pond.onLeave((event) => {
+     *     // Clean up resources
+     * });
      */
-    public onLeave (callback: LeaveCallback<EventType, PresenceType, AssignType>): void;
+    onLeave(callback: LeaveCallback<EventType, PresenceType, AssignType>): void;
 
     /**
      * @desc Gets a channel by name
-     * @param channelName - The name of the channel to get
+     * @param {string} channelName - The name of the channel to get
      */
-    public getChannel (channelName: string): Channel<EventType, PresenceType, AssignType>;
+    getChannel(channelName: string): Channel<EventType, PresenceType, AssignType>;
 }
 
 export declare class PondSocket {
-    constructor (server?: HTTPServer, socketServer?: WebSocketServer);
+    constructor(server?: HTTPServer, socketServer?: WebSocketServer);
 
     /**
      * @desc Specifies the port to listen on
      * @param args - the arguments to pass to the server
      */
-    listen (...args: any[]): HTTPServer<typeof import('http').IncomingMessage, typeof import('http').ServerResponse>;
+    listen(...args: any[]): HTTPServer<typeof import('http').IncomingMessage, typeof import('http').ServerResponse>;
 
     /**
      * @desc Closes the server
      * @param callback - the callback to call when the server is closed
      */
-    close (callback?: () => void): HTTPServer<typeof import('http').IncomingMessage, typeof import('http').ServerResponse>;
+    close(callback?: () => void): HTTPServer<typeof import('http').IncomingMessage, typeof import('http').ServerResponse>;
 
     /**
      * @desc Accepts a new socket upgrade request on the provided endpoint using the handler function to authenticate the socket
@@ -405,5 +467,5 @@ export declare class PondSocket {
      *    });
      * })
      */
-    createEndpoint<Path extends string> (path: PondPath<Path>, handler: (request: IncomingConnection<Path>, response: ConnectionResponse) => void | Promise<void>): Endpoint;
+    createEndpoint<Path extends string>(path: PondPath<Path>, handler: (request: IncomingConnection<Path>, response: ConnectionResponse) => void | Promise<void>): Endpoint;
 }

package/abstracts/abstractResponse.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PondResponse = void 0;
-class PondResponse {
-    constructor(requestId) {
-        this.requestId = requestId;
-    }
-}
-exports.PondResponse = PondResponse;