@eleven-am/pondsocket 0.1.198 → 0.1.200

package/types.d.ts

@@ -1,4 +1,4 @@
-import { Server, ServerResponse, IncomingMessage } from 'http';
+import { Server, ServerResponse, IncomingMessage, IncomingHttpHeaders } from 'http';
 
 import {
     IncomingConnection,
@@ -13,6 +13,7 @@ import {
     UserAssigns,
     JoinParams,
     EventParams,
+    Params,
 } from '@eleven-am/pondsocket-common';
 import { WebSocket, WebSocketServer } from 'ws';
 
@@ -33,7 +34,7 @@ export type LeaveCallback<EventTypes extends PondEventMap = PondEventMap, Presen
 
 export type OutgoingHandler<Event extends string, EventTypes extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> = (event: OutgoingEvent<Event, EventTypes, PresenceType, AssignType>) => PondMessage | Promise<PondMessage> | void | Promise<void>;
 
-export type RequestHandler<Request, Response> = (request: Request, response: Response) => void | Promise<void>;
+export type RequestHandler<Request> = (request: Request) => void | Promise<void>;
 
 export interface PondSocketOptions {
     server?: Server;
@@ -61,18 +62,16 @@ export declare class PondSocket {
      * @param path - the pattern to accept || can also be a regex
      * @param handler - the handler function to authenticate the socket
      * @example
-     * const endpoint = pond.createEndpoint('/api/socket', (req, res) => {
-     *    const token = req.query.token;
+     * const endpoint = pond.createEndpoint('/api/socket', (context) => {
+     *    const token = context.query.token;
      *    if (!token)
-     *       return res.decline('No token provided');
-     *    res.accept({
-     *       assign: {
-     *           token
-     *       }
-     *    });
+     *       return context.decline('No token provided');
+     *    context.assign({
+     *       token
+     *    }).accept();
      * })
      */
-    createEndpoint<Path extends string>(path: PondPath<Path>, handler: RequestHandler<IncomingConnection<Path>, ConnectionResponse>): Endpoint;
+    createEndpoint<Path extends string>(path: PondPath<Path>, handler: RequestHandler<ConnectionContext<Path>>): Endpoint;
 }
 
 export declare class Endpoint {
@@ -83,15 +82,14 @@ export declare class Endpoint {
      * @returns {PondChannel} - The PondChannel instance for the new channel
      *
      * @example
-     * const channel = endpoint.createChannel('/chat', (request, response) => {
-     *     if (request.user.assigns.admin)
-     *         response.accept();
-     *
+     * const channel = endpoint.createChannel('/chat', (context) => {
+     *     if (context.user.assigns.admin)
+     *         context.accept();
      *     else
-     *         response.decline('You are not an admin', 403);
+     *         context.decline('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: RequestHandler<JoinRequest<Path, PresenceType, AssignType>, JoinResponse<EventType, PresenceType, AssignType>>): PondChannel<EventType, PresenceType, AssignType>;
+    createChannel<Path extends string, EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns>(path: PondPath<Path>, handler: RequestHandler<JoinContext<Path, EventType, PresenceType, AssignType>>): PondChannel<EventType, PresenceType, AssignType>;
 
     /**
      * @desc Closes specific clients connected to this endpoint
@@ -111,13 +109,13 @@ export declare class PondChannel<EventType extends PondEventMap = PondEventMap,
      * @param {PondPath<string>} event - The event to handle
      * @param {RequestHandler} handler - The handlers to execute when the event is received
      * @example
-     * pond.onEvent('echo', (request, response) => {
-     *     response.reply('echo', {
-     *         message: request.event.payload,
+     * pond.onEvent('echo', (context) => {
+     *     context.reply('echo', {
+     *         message: context.event.payload,
      *     });
      * });
      */
-    onEvent<Event extends string>(event: PondPath<Event>, handler: RequestHandler<EventRequest<Event, PresenceType, AssignType>, EventResponse<EventType, PresenceType, AssignType>>): void;
+    onEvent<Event extends string>(event: PondPath<Event>, handler: RequestHandler<EventContext<Event, EventType, PresenceType, AssignType>>): 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
@@ -284,72 +282,122 @@ export declare class Channel<EventTypes extends PondEventMap = PondEventMap, Pre
     upsertPresence(userId: string, presence: PresenceType): Channel<EventTypes, PresenceType, AssignType>;
 }
 
-export declare class JoinRequest<Path extends string, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
-    get event(): PondEvent<Path>;
-
-    get channelName(): string;
-
-    get channel(): Channel
-
-    get joinParams(): JoinParams;
-
-    get presences(): UserPresences;
+export declare class ConnectionContext<Path extends string> {
+    /**
+     * @desc Checks if the server has responded to the connection request.
+     */
+    get hasResponded(): boolean;
 
-    get assigns(): UserAssigns;
+    /**
+     * @desc Get the connection details.
+     */
+    get connection(): IncomingConnection<Path>;
 
-    get user(): UserData<PresenceType, AssignType>;
-}
+    /**
+     * @desc Get the client ID.
+     */
+    get clientId(): string;
 
-export declare class EventRequest<Path extends string, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
-    get event(): PondEvent<Path>;
+    /**
+     * @desc Get the request ID.
+     */
+    get requestId(): string;
 
-    get channelName(): string;
+    /**
+     * @desc Get the request headers.
+     */
+    get headers(): IncomingHttpHeaders;
 
-    get channel(): Channel;
+    /**
+     * @desc Get the request cookies.
+     */
+    get cookies(): Record<string, string>;
 
-    get presences(): UserPresences;
+    /**
+     * @desc Get the client address.
+     */
+    get address(): string;
 
-    get assigns(): UserAssigns;
+    /**
+     * @desc Get the event parameters.
+     */
+    get event(): EventParams<Path>;
 
-    get user(): UserData<PresenceType, AssignType>;
-}
+    /**
+     * @desc Get the query parameters.
+     */
+    get query(): Record<string, string>;
 
-export declare class ConnectionResponse {
     /**
-     * @desc Checks if the server has responded to the connection request.
+     * @desc Get the path parameters.
      */
-    get hasResponded(): boolean;
+    get params(): Params<Path>;
 
     /**
      * @desc Assigns data to the user.
      * @param {PondAssigns} assigns - The data to assign.
-     * @returns {ConnectionResponse} - The ConnectionResponse instance for chaining.
+     * @returns {ConnectionContext} - The ConnectionContext instance for chaining.
      */
-    assign(assigns: PondAssigns): ConnectionResponse;
+    assign(assigns: PondAssigns): ConnectionContext<Path>;
 
     /**
      * @desc Accepts the connection request to the endpoint.
      */
-    accept(): ConnectionResponse;
+    accept(): ConnectionContext<Path>;
 
     /**
      * @desc Rejects the request with the given error message
      * @param {string} message - The error message
      * @param {number} errorCode - The error code
      */
-    decline(message?: string, errorCode?: number): void;
+    decline(message?: string, errorCode?: number): ConnectionContext<Path>;
 
     /**
      * @desc Emits a direct message to the client
      * @param {string} event - The event name
      * @param {PondMessage} payload - The payload to send
      */
-    reply(event: string, payload: PondMessage): ConnectionResponse;
+    reply(event: string, payload: PondMessage): ConnectionContext<Path>;
 }
 
-export declare class JoinResponse<EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
+export declare class JoinContext<Path extends string, EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
     /**
-     * @desc Checks if the server has responded to the connection request.
+     * @desc Get the event information.
+     */
+    get event(): PondEvent<Path>;
+
+    /**
+     * @desc Get the channel name.
+     */
+    get channelName(): string;
+
+    /**
+     * @desc Get the channel instance.
+     */
+    get channel(): Channel;
+
+    /**
+     * @desc Get the join parameters.
+     */
+    get joinParams(): JoinParams;
+
+    /**
+     * @desc Get all current presences in the channel.
+     */
+    get presences(): UserPresences;
+
+    /**
+     * @desc Get all current assigns in the channel.
+     */
+    get assigns(): UserAssigns;
+
+    /**
+     * @desc Get the user data.
+     */
+    get user(): UserData<PresenceType, AssignType>;
+
+    /**
+     * @desc Checks if the server has responded to the join request.
      */
     get hasResponded(): boolean;
 
@@ -357,42 +405,41 @@ export declare class JoinResponse<EventType extends PondEventMap = PondEventMap,
      * @desc Assigns data to the client
      * @param {PondAssigns} assigns - The data to assign
      */
-    assign(assigns: AssignType): JoinResponse;
+    assign(assigns: AssignType): JoinContext<Path, PresenceType, AssignType>;
 
     /**
      * @desc Accepts the join request to the channel.
-     * @returns {JoinResponse} - The JoinResponse instance for chaining.
+     * @returns {JoinContext} - The JoinContext instance for chaining.
      */
-    accept(): JoinResponse;
+    accept(): JoinContext<Path, PresenceType, AssignType>;
 
     /**
      * @desc Rejects the request and optionally assigns data to the client
      * @param {string} message - The error message
      * @param {number} errorCode - The error code
      */
-    decline(message?: string, errorCode?: number): JoinResponse;
+    decline(message?: string, errorCode?: number): JoinContext<Path, PresenceType, AssignType>;
 
     /**
      * @desc Emits a direct message 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
      */
-    reply<Key extends keyof EventType>(event: Key, payload: EventType[Key], assigns?: AssignType): JoinResponse;
+    reply<Key extends keyof EventType>(event: Key, payload: EventType[Key]): JoinContext<Path, PresenceType, AssignType>;
 
     /**
      * @desc Emits a message to all clients in the channel
      * @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]): JoinContext<Path, PresenceType, AssignType>;
 
     /**
      * @desc Emits a message to all clients in the channel except the sender
      * @param event - the event name
      * @param payload - the payload to send
      */
-    broadcastFrom<Key extends keyof EventType>(event: Key, payload: EventType[Key]): JoinResponse;
+    broadcastFrom<Key extends keyof EventType>(event: Key, payload: EventType[Key]): JoinContext<Path, PresenceType, AssignType>;
 
     /**
      * @desc Emits a message to a specific set of clients
@@ -400,89 +447,114 @@ export declare class JoinResponse<EventType extends PondEventMap = PondEventMap,
      * @param {PondMessage} payload - The payload to send
      * @param {string | string[]} userIds - The ids of the clients to send the message to
      */
-    broadcastTo<Key extends keyof EventType>(event: Key, payload: EventType[Key], userIds: string | string[]): JoinResponse;
+    broadcastTo<Key extends keyof EventType>(event: Key, payload: EventType[Key], userIds: string | string[]): JoinContext<Path, PresenceType, AssignType>;
 
     /**
      * @desc tracks the presence of a client
      * @param {PondPresence} presence - the presence data to track
      */
-    trackPresence(presence: PresenceType): JoinResponse;
+    trackPresence(presence: PresenceType): JoinContext<Path, PresenceType, AssignType>;
 }
 
-export declare class EventResponse<EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
+export declare class EventContext<Path extends string, EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
     /**
-     * @desc Checks if the server has responded to the connection request.
+     * @desc Get the event information.
      */
-    get hasResponded(): boolean;
+    get event(): PondEvent<Path>;
+
+    /**
+     * @desc Get the channel name.
+     */
+    get channelName(): string;
+
+    /**
+     * @desc Get the channel instance.
+     */
+    get channel(): Channel;
+
+    /**
+     * @desc Get all current presences in the channel.
+     */
+    get presences(): UserPresences;
+
+    /**
+     * @desc Get all current assigns in the channel.
+     */
+    get assigns(): UserAssigns;
+
+    /**
+     * @desc Get the user who sent the request.
+     */
+    get user(): UserData<PresenceType, AssignType>;
 
     /**
      * @desc Assigns data to the client.
      * @param {PondAssigns} assigns - The data to assign to the client.
-     * @returns {EventResponse} - The EventResponse instance for chaining.
+     * @returns {EventContext} - The EventContext instance for chaining.
      */
-    assign(assigns: AssignType): EventResponse<EventType, PresenceType, AssignType>;
+    assign(assigns: AssignType): EventContext<Path, EventType, PresenceType, AssignType>;
 
     /**
      * @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.
+     * @returns {EventContext} - The EventContext instance for chaining.
      */
-    reply<Event extends keyof EventType>(event: Event, payload: EventType[Event]): EventResponse<EventType, PresenceType, AssignType>;
+    reply<Event extends keyof EventType>(event: Event, payload: EventType[Event]): EventContext<Path, EventType, PresenceType, AssignType>;
 
     /**
      * @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.
+     * @returns {EventContext} - The EventContext instance for chaining.
      */
-    broadcast<Event extends keyof EventType>(event: Event, payload: EventType[Event]): EventResponse<EventType, PresenceType, AssignType>;
+    broadcast<Event extends keyof EventType>(event: Event, payload: EventType[Event]): EventContext<Path, EventType, PresenceType, AssignType>;
 
     /**
      * @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.
+     * @returns {EventContext} - The EventContext instance for chaining.
      */
-    broadcastFrom<UserEvent extends keyof EventType>(event: UserEvent, payload: EventType[UserEvent]): EventResponse<EventType, PresenceType, AssignType>;
+    broadcastFrom<UserEvent extends keyof EventType>(event: UserEvent, payload: EventType[UserEvent]): EventContext<Path, EventType, PresenceType, AssignType>;
 
     /**
      * @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.
+     * @returns {EventContext} - The EventContext instance for chaining.
      */
-    broadcastTo<UserEvent extends keyof EventType>(event: UserEvent, payload: EventType[UserEvent], userIds: string | string[]): EventResponse<EventType, PresenceType, AssignType>;
+    broadcastTo<UserEvent extends keyof EventType>(event: UserEvent, payload: EventType[UserEvent], userIds: string | string[]): EventContext<Path, EventType, PresenceType, AssignType>;
 
     /**
      * @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.
+     * @returns {EventContext} - The EventContext instance for chaining.
      */
-    trackPresence(presence: PresenceType, userId?: string): EventResponse<EventType, PresenceType, AssignType>;
+    trackPresence(presence: PresenceType, userId?: string): EventContext<Path, EventType, PresenceType, AssignType>;
 
     /**
      * @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.
+     * @returns {EventContext} - The EventContext instance for chaining.
      */
-    updatePresence(presence: PresenceType, userId?: string): EventResponse;
+    updatePresence(presence: PresenceType, userId?: string): EventContext<Path, EventType, PresenceType, AssignType>;
 
     /**
      * @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.
+     * @returns {EventContext} - The EventContext instance for chaining.
      */
-    removePresence(userId?: string): EventResponse;
+    removePresence(userId?: string): EventContext<Path, EventType, PresenceType, AssignType>;
 
     /**
      * @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.
-     * @returns {EventResponse} - The EventResponse instance for chaining.
+     * @returns {EventContext} - The EventContext instance for chaining.
      */
-    evictUser(reason: string, userId?: string): EventResponse;
+    evictUser(reason: string, userId?: string): EventContext<Path, EventType, PresenceType, AssignType>;
 }

package/requests/eventRequest.js

@@ -1,69 +0,0 @@
-"use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _EventRequest_event, _EventRequest_engine, _EventRequest_params;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventRequest = void 0;
-const channel_1 = require("../wrappers/channel");
-class EventRequest {
-    constructor(event, params, engine) {
-        _EventRequest_event.set(this, void 0);
-        _EventRequest_engine.set(this, void 0);
-        _EventRequest_params.set(this, void 0);
-        __classPrivateFieldSet(this, _EventRequest_event, event, "f");
-        __classPrivateFieldSet(this, _EventRequest_params, params, "f");
-        __classPrivateFieldSet(this, _EventRequest_engine, engine, "f");
-    }
-    /**
-     * The event information
-     */
-    get event() {
-        return {
-            event: __classPrivateFieldGet(this, _EventRequest_event, "f").event,
-            query: __classPrivateFieldGet(this, _EventRequest_params, "f").query,
-            params: __classPrivateFieldGet(this, _EventRequest_params, "f").params,
-            payload: __classPrivateFieldGet(this, _EventRequest_event, "f").payload,
-        };
-    }
-    /**
-     * The channel name
-     */
-    get channelName() {
-        return __classPrivateFieldGet(this, _EventRequest_engine, "f").name;
-    }
-    /**
-     * The channel instance
-     */
-    get channel() {
-        return new channel_1.Channel(__classPrivateFieldGet(this, _EventRequest_engine, "f"));
-    }
-    /**
-     * All current presences in the channel
-     */
-    get presences() {
-        return __classPrivateFieldGet(this, _EventRequest_engine, "f").getPresence();
-    }
-    /**
-     * All current assigns in the channel
-     */
-    get assigns() {
-        return __classPrivateFieldGet(this, _EventRequest_engine, "f").getAssigns();
-    }
-    /**
-     * The user who sent the request
-     */
-    get user() {
-        return __classPrivateFieldGet(this, _EventRequest_engine, "f").getUserData(__classPrivateFieldGet(this, _EventRequest_event, "f").sender);
-    }
-}
-exports.EventRequest = EventRequest;
-_EventRequest_event = new WeakMap(), _EventRequest_engine = new WeakMap(), _EventRequest_params = new WeakMap();

package/requests/joinRequest.js

@@ -1,56 +0,0 @@
-"use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _JoinRequest_options, _JoinRequest_engine;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JoinRequest = void 0;
-const channel_1 = require("../wrappers/channel");
-class JoinRequest {
-    constructor(options, channel) {
-        _JoinRequest_options.set(this, void 0);
-        _JoinRequest_engine.set(this, void 0);
-        __classPrivateFieldSet(this, _JoinRequest_options, options, "f");
-        __classPrivateFieldSet(this, _JoinRequest_engine, channel, "f");
-    }
-    get event() {
-        return {
-            event: __classPrivateFieldGet(this, _JoinRequest_engine, "f").name,
-            query: __classPrivateFieldGet(this, _JoinRequest_options, "f").params.query,
-            params: __classPrivateFieldGet(this, _JoinRequest_options, "f").params.params,
-            payload: __classPrivateFieldGet(this, _JoinRequest_options, "f").joinParams,
-        };
-    }
-    get channelName() {
-        return __classPrivateFieldGet(this, _JoinRequest_engine, "f").name;
-    }
-    get channel() {
-        return new channel_1.Channel(__classPrivateFieldGet(this, _JoinRequest_engine, "f"));
-    }
-    get presences() {
-        return __classPrivateFieldGet(this, _JoinRequest_engine, "f").getPresence();
-    }
-    get assigns() {
-        return __classPrivateFieldGet(this, _JoinRequest_engine, "f").getAssigns();
-    }
-    get user() {
-        return {
-            id: __classPrivateFieldGet(this, _JoinRequest_options, "f").clientId,
-            assigns: __classPrivateFieldGet(this, _JoinRequest_options, "f").assigns,
-            presence: {},
-        };
-    }
-    get joinParams() {
-        return __classPrivateFieldGet(this, _JoinRequest_options, "f").joinParams;
-    }
-}
-exports.JoinRequest = JoinRequest;
-_JoinRequest_options = new WeakMap(), _JoinRequest_engine = new WeakMap();

package/responses/connectionResponse.js

@@ -1,92 +0,0 @@
-"use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _ConnectionResponse_instances, _ConnectionResponse_executed, _ConnectionResponse_assigns, _ConnectionResponse_clientId, _ConnectionResponse_engine, _ConnectionResponse_params, _ConnectionResponse_webSocketServer, _ConnectionResponse_performChecks;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConnectionResponse = void 0;
-const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
-const httpError_1 = require("../errors/httpError");
-class ConnectionResponse {
-    constructor(clientId, { engine, params, webSocketServer }) {
-        _ConnectionResponse_instances.add(this);
-        _ConnectionResponse_executed.set(this, void 0);
-        _ConnectionResponse_assigns.set(this, void 0);
-        _ConnectionResponse_clientId.set(this, void 0);
-        _ConnectionResponse_engine.set(this, void 0);
-        _ConnectionResponse_params.set(this, void 0);
-        _ConnectionResponse_webSocketServer.set(this, void 0);
-        __classPrivateFieldSet(this, _ConnectionResponse_webSocketServer, webSocketServer, "f");
-        __classPrivateFieldSet(this, _ConnectionResponse_clientId, clientId, "f");
-        __classPrivateFieldSet(this, _ConnectionResponse_executed, false, "f");
-        __classPrivateFieldSet(this, _ConnectionResponse_engine, engine, "f");
-        __classPrivateFieldSet(this, _ConnectionResponse_params, params, "f");
-        __classPrivateFieldSet(this, _ConnectionResponse_assigns, {}, "f");
-    }
-    get hasResponded() {
-        return __classPrivateFieldGet(this, _ConnectionResponse_executed, "f");
-    }
-    assign(assigns) {
-        if (!__classPrivateFieldGet(this, _ConnectionResponse_executed, "f")) {
-            __classPrivateFieldSet(this, _ConnectionResponse_assigns, Object.assign(Object.assign({}, __classPrivateFieldGet(this, _ConnectionResponse_assigns, "f")), assigns), "f");
-        }
-        else {
-            const user = __classPrivateFieldGet(this, _ConnectionResponse_engine, "f").getUser(__classPrivateFieldGet(this, _ConnectionResponse_clientId, "f"));
-            user.assigns = Object.assign(Object.assign({}, user.assigns), assigns);
-        }
-        return this;
-    }
-    accept() {
-        __classPrivateFieldGet(this, _ConnectionResponse_instances, "m", _ConnectionResponse_performChecks).call(this);
-        __classPrivateFieldGet(this, _ConnectionResponse_webSocketServer, "f").handleUpgrade(__classPrivateFieldGet(this, _ConnectionResponse_params, "f").request, __classPrivateFieldGet(this, _ConnectionResponse_params, "f").socket, __classPrivateFieldGet(this, _ConnectionResponse_params, "f").head, (ws) => {
-            const cache = {
-                clientId: __classPrivateFieldGet(this, _ConnectionResponse_clientId, "f"),
-                subscriptions: new Set(),
-                assigns: __classPrivateFieldGet(this, _ConnectionResponse_assigns, "f"),
-                socket: ws,
-            };
-            __classPrivateFieldGet(this, _ConnectionResponse_webSocketServer, "f").emit('connection', ws);
-            __classPrivateFieldGet(this, _ConnectionResponse_engine, "f").manageSocket(cache);
-        });
-        return this;
-    }
-    decline(message, errorCode) {
-        __classPrivateFieldGet(this, _ConnectionResponse_instances, "m", _ConnectionResponse_performChecks).call(this);
-        const code = errorCode || 400;
-        const { socket } = __classPrivateFieldGet(this, _ConnectionResponse_params, "f");
-        const newMessage = message || 'Unauthorized connection';
-        socket.write(`HTTP/1.1 ${code} ${newMessage}\r\n\r\n`);
-        socket.destroy();
-        return this;
-    }
-    reply(event, payload) {
-        if (!__classPrivateFieldGet(this, _ConnectionResponse_executed, "f")) {
-            throw new httpError_1.HttpError(400, 'Connection has not been accepted');
-        }
-        const { socket } = __classPrivateFieldGet(this, _ConnectionResponse_engine, "f").getUser(__classPrivateFieldGet(this, _ConnectionResponse_clientId, "f"));
-        const message = {
-            event,
-            payload,
-            action: pondsocket_common_1.ServerActions.BROADCAST,
-            requestId: __classPrivateFieldGet(this, _ConnectionResponse_params, "f").requestId,
-            channelName: pondsocket_common_1.SystemSender.ENDPOINT,
-        };
-        __classPrivateFieldGet(this, _ConnectionResponse_engine, "f").sendMessage(socket, message);
-        return this;
-    }
-}
-exports.ConnectionResponse = ConnectionResponse;
-_ConnectionResponse_executed = new WeakMap(), _ConnectionResponse_assigns = new WeakMap(), _ConnectionResponse_clientId = new WeakMap(), _ConnectionResponse_engine = new WeakMap(), _ConnectionResponse_params = new WeakMap(), _ConnectionResponse_webSocketServer = new WeakMap(), _ConnectionResponse_instances = new WeakSet(), _ConnectionResponse_performChecks = function _ConnectionResponse_performChecks() {
-    if (__classPrivateFieldGet(this, _ConnectionResponse_executed, "f")) {
-        throw new httpError_1.HttpError(400, 'Response has already been executed');
-    }
-    __classPrivateFieldSet(this, _ConnectionResponse_executed, true, "f");
-};