@eleven-am/pondsocket 0.1.49 → 0.1.51

package/abstracts/abstractRequest.js

@@ -0,0 +1,58 @@
+"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 _AbstractRequest_eventObject, _AbstractRequest_event, _AbstractRequest_payload;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractRequest = void 0;
+const matcher_1 = require("../matcher/matcher");
+class AbstractRequest {
+    constructor(event, engine, payload) {
+        _AbstractRequest_eventObject.set(this, void 0);
+        _AbstractRequest_event.set(this, void 0);
+        _AbstractRequest_payload.set(this, void 0);
+        this._engine = engine;
+        __classPrivateFieldSet(this, _AbstractRequest_event, event, "f");
+        __classPrivateFieldSet(this, _AbstractRequest_eventObject, null, "f");
+        __classPrivateFieldSet(this, _AbstractRequest_payload, payload, "f");
+    }
+    get event() {
+        if (__classPrivateFieldGet(this, _AbstractRequest_eventObject, "f") === null) {
+            throw new Error('Event was not parsed');
+        }
+        return {
+            event: __classPrivateFieldGet(this, _AbstractRequest_event, "f"),
+            params: __classPrivateFieldGet(this, _AbstractRequest_eventObject, "f").params || {},
+            query: __classPrivateFieldGet(this, _AbstractRequest_eventObject, "f").query || {},
+            payload: __classPrivateFieldGet(this, _AbstractRequest_payload, "f"),
+        };
+    }
+    get channelNme() {
+        return this._engine.name;
+    }
+    get assigns() {
+        return this._engine.getAssigns();
+    }
+    get presence() {
+        var _a;
+        return ((_a = this._engine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence()) || {};
+    }
+    /**
+     * @desc Parses the event and returns true if the event matches the path
+     * @param path - the path to match
+     */
+    _parseQueries(path) {
+        __classPrivateFieldSet(this, _AbstractRequest_eventObject, (0, matcher_1.parseAddress)(path, __classPrivateFieldGet(this, _AbstractRequest_event, "f")), "f");
+        return __classPrivateFieldGet(this, _AbstractRequest_eventObject, "f") !== null;
+    }
+}
+exports.AbstractRequest = AbstractRequest;
+_AbstractRequest_eventObject = new WeakMap(), _AbstractRequest_event = new WeakMap(), _AbstractRequest_payload = new WeakMap();

package/abstracts/middleware.js

@@ -0,0 +1,51 @@
+"use strict";
+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 _Middleware_stack;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Middleware = void 0;
+class Middleware {
+    constructor(second) {
+        _Middleware_stack.set(this, []);
+        if (second) {
+            __classPrivateFieldGet(this, _Middleware_stack, "f").push(...__classPrivateFieldGet(second, _Middleware_stack, "f"));
+        }
+    }
+    /**
+     * @desc Adds a middleware function to the middleware stack
+     * @param middleware - the middleware function to add
+     */
+    use(middleware) {
+        __classPrivateFieldGet(this, _Middleware_stack, "f").push(middleware);
+    }
+    /**
+     * @desc Runs the middleware stack
+     * @param req - the request object
+     * @param res - the response object
+     * @param final - the final function to call
+     */
+    run(req, res, final) {
+        const temp = __classPrivateFieldGet(this, _Middleware_stack, "f").concat();
+        const nextFunction = () => {
+            const middleware = temp.shift();
+            if (middleware) {
+                middleware(req, res, nextFunction);
+            }
+            else {
+                final();
+            }
+        };
+        nextFunction();
+    }
+    /**
+     * @desc Returns the middleware stack length
+     */
+    get length() {
+        return __classPrivateFieldGet(this, _Middleware_stack, "f").length;
+    }
+}
+exports.Middleware = Middleware;
+_Middleware_stack = new WeakMap();

package/channel/channel.js

@@ -0,0 +1,253 @@
+"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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var _ChannelEngine_instances, _ChannelEngine_receiver, _ChannelEngine_presenceEngine, _ChannelEngine_users, _ChannelEngine_parentEngine, _ChannelEngine_subscribe, _ChannelEngine_getUsersFromRecipients;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelEngine = void 0;
+const eventRequest_1 = require("./eventRequest");
+const eventResponse_1 = require("./eventResponse");
+const enums_1 = require("../enums");
+const pondError_1 = require("../errors/pondError");
+const presence_1 = require("../presence/presence");
+const subject_1 = require("../subjects/subject");
+class ChannelEngine {
+    constructor(name, parent) {
+        _ChannelEngine_instances.add(this);
+        _ChannelEngine_receiver.set(this, void 0);
+        _ChannelEngine_presenceEngine.set(this, void 0);
+        _ChannelEngine_users.set(this, void 0);
+        _ChannelEngine_parentEngine.set(this, void 0);
+        this.name = name;
+        __classPrivateFieldSet(this, _ChannelEngine_receiver, new subject_1.Subject(), "f");
+        __classPrivateFieldSet(this, _ChannelEngine_users, new Map(), "f");
+        __classPrivateFieldSet(this, _ChannelEngine_parentEngine, parent, "f");
+    }
+    /**
+     * @desc Adds a user to the channel
+     * @param userId - The id of the user to add
+     * @param assigns - The assigns to add to the user
+     * @param onMessage - The callback to call when a message is received
+     */
+    addUser(userId, assigns, onMessage) {
+        const oldUser = __classPrivateFieldGet(this, _ChannelEngine_users, "f").get(userId);
+        if (oldUser) {
+            const message = `ChannelEngine: User with id ${userId} already exists in channel ${this.name}`;
+            const code = 404;
+            throw new pondError_1.ChannelError(message, code, this.name);
+        }
+        __classPrivateFieldGet(this, _ChannelEngine_users, "f").set(userId, assigns);
+        return __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_subscribe).call(this, userId, onMessage);
+    }
+    /**
+     * @desc Removes a user from the channel
+     * @param userId - The id of the user to remove
+     * @param graceful - Whether to remove the user gracefully or not
+     */
+    removeUser(userId, graceful = false) {
+        var _a;
+        const user = __classPrivateFieldGet(this, _ChannelEngine_users, "f").get(userId);
+        if (user) {
+            __classPrivateFieldGet(this, _ChannelEngine_users, "f").delete(userId);
+            __classPrivateFieldGet(this, _ChannelEngine_receiver, "f").unsubscribe(userId);
+            (_a = __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f")) === null || _a === void 0 ? void 0 : _a.removePresence(userId, graceful);
+            if (__classPrivateFieldGet(this, _ChannelEngine_users, "f").size === 0) {
+                __classPrivateFieldGet(this, _ChannelEngine_parentEngine, "f").destroyChannel();
+            }
+        }
+        else if (!graceful) {
+            throw new pondError_1.ChannelError(`ChannelEngine: User with id ${userId} does not exist in channel ${this.name}`, 404, this.name);
+        }
+    }
+    /**
+     * @desc Kicks a user from the channel
+     * @param userId - The id of the user to kick
+     * @param reason - The reason for kicking the user
+     */
+    kickUser(userId, reason) {
+        this.sendMessage(enums_1.SystemSender.CHANNEL, [userId], enums_1.ServerActions.SYSTEM, 'kicked_out', {
+            message: reason !== null && reason !== void 0 ? reason : 'You have been kicked out of the channel',
+        });
+        this.removeUser(userId);
+        this.sendMessage(enums_1.SystemSender.CHANNEL, enums_1.ChannelReceiver.ALL_USERS, enums_1.ServerActions.SYSTEM, 'kicked', {
+            userId,
+            reason,
+        });
+    }
+    /**
+     * @desc Self destructs the channel
+     * @param reason - The reason for self-destructing the channel
+     */
+    destroy(reason) {
+        this.sendMessage(enums_1.SystemSender.CHANNEL, enums_1.ChannelReceiver.ALL_USERS, enums_1.ServerActions.ERROR, 'destroyed', {
+            message: reason !== null && reason !== void 0 ? reason : 'Channel has been destroyed',
+        });
+        __classPrivateFieldGet(this, _ChannelEngine_parentEngine, "f").destroyChannel();
+        __classPrivateFieldGet(this, _ChannelEngine_users, "f").forEach((_, userId) => __classPrivateFieldGet(this, _ChannelEngine_receiver, "f").unsubscribe(userId));
+    }
+    /**
+     * @desc Updates a user's assigns
+     * @param userId - The id of the user to update
+     * @param assigns - The new assigns of the user
+     */
+    updateAssigns(userId, assigns) {
+        const user = __classPrivateFieldGet(this, _ChannelEngine_users, "f").get(userId);
+        if (user) {
+            __classPrivateFieldGet(this, _ChannelEngine_users, "f").set(userId, Object.assign(Object.assign({}, user), assigns));
+        }
+        else {
+            throw new pondError_1.ChannelError(`ChannelEngine: User with id ${userId} does not exist in channel ${this.name}`, 404, this.name);
+        }
+    }
+    /**
+     * @desc Gets the data of a user
+     * @param userId - The id of the user to get
+     */
+    getUserData(userId) {
+        const presence = __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f") ? __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f").getUserPresence(userId) : {};
+        if (__classPrivateFieldGet(this, _ChannelEngine_users, "f").has(userId)) {
+            return {
+                id: userId,
+                assigns: __classPrivateFieldGet(this, _ChannelEngine_users, "f").get(userId),
+                presence: presence || {},
+            };
+        }
+        return undefined;
+    }
+    /**
+     * @desc Gets the assign data of all users
+     */
+    getAssigns() {
+        const assigns = {};
+        __classPrivateFieldGet(this, _ChannelEngine_users, "f").forEach((value, key) => {
+            assigns[key] = value;
+        });
+        return assigns;
+    }
+    /**
+     * @desc Sends a message to a specified set of users, from a specified sender
+     * @param sender - The sender of the message
+     * @param recipient - The users to send the message to
+     * @param action - The action of the message
+     * @param event - The event name
+     * @param payload - The payload of the message
+     * @private
+     */
+    sendMessage(sender, recipient, action, event, payload) {
+        if (!__classPrivateFieldGet(this, _ChannelEngine_users, "f").has(sender) && sender !== enums_1.SystemSender.CHANNEL) {
+            throw new pondError_1.ChannelError(`ChannelEngine: User with id ${sender} does not exist in channel ${this.name}`, 404, this.name);
+        }
+        const eventMessage = {
+            recipients: __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_getUsersFromRecipients).call(this, recipient, sender),
+            channelName: this.name,
+            action,
+            payload,
+            event,
+        };
+        __classPrivateFieldGet(this, _ChannelEngine_receiver, "f").publish(eventMessage);
+    }
+    /**
+     * @desc Handles a message from a user
+     * @param userId - The id of the user who sent the message
+     * @param message - The message received
+     */
+    broadcastMessage(userId, message) {
+        if (!__classPrivateFieldGet(this, _ChannelEngine_users, "f").has(userId)) {
+            throw new pondError_1.ChannelError(`ChannelEngine: User with id ${userId} does not exist in channel ${this.name}`, 404, this.name);
+        }
+        const responseEvent = {
+            sender: userId,
+            event: message.event,
+            payload: message.payload,
+            action: enums_1.ServerActions.BROADCAST,
+            channelName: this.name,
+            recipients: __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_getUsersFromRecipients).call(this, message.addresses || enums_1.ChannelReceiver.ALL_USERS, userId),
+        };
+        const request = new eventRequest_1.EventRequest(responseEvent, this);
+        const response = new eventResponse_1.EventResponse(responseEvent, this);
+        __classPrivateFieldGet(this, _ChannelEngine_parentEngine, "f").execute(request, response, () => {
+            this.sendMessage(enums_1.SystemSender.CHANNEL, [userId], enums_1.ServerActions.ERROR, enums_1.ErrorTypes.HANDLER_NOT_FOUND, {
+                message: 'A handler did not respond to the event',
+                code: 404,
+            });
+        });
+    }
+    /**
+     * @desc Begins tracking a user's presence
+     * @param userId - The id of the user to track
+     * @param presence - The initial presence of the user
+     */
+    trackPresence(userId, presence) {
+        var _a;
+        if (!__classPrivateFieldGet(this, _ChannelEngine_users, "f").has(userId)) {
+            throw new pondError_1.ChannelError(`ChannelEngine: User with id ${userId} does not exist in channel ${this.name}`, 404, this.name);
+        }
+        __classPrivateFieldSet(this, _ChannelEngine_presenceEngine, (_a = __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f")) !== null && _a !== void 0 ? _a : new presence_1.PresenceEngine(this.name), "f");
+        __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f").trackPresence(userId, presence, (change) => {
+            const { type } = change, rest = __rest(change, ["type"]);
+            this.sendMessage(enums_1.SystemSender.CHANNEL, [userId], enums_1.ServerActions.PRESENCE, type, rest);
+        });
+    }
+    /**
+     * @desc Gets the presence engine for the channel
+     */
+    get presenceEngine() {
+        return __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f");
+    }
+    /**
+     * @desc Gets the number of users in the channel
+     */
+    get size() {
+        return __classPrivateFieldGet(this, _ChannelEngine_users, "f").size;
+    }
+}
+exports.ChannelEngine = ChannelEngine;
+_ChannelEngine_receiver = new WeakMap(), _ChannelEngine_presenceEngine = new WeakMap(), _ChannelEngine_users = new WeakMap(), _ChannelEngine_parentEngine = new WeakMap(), _ChannelEngine_instances = new WeakSet(), _ChannelEngine_subscribe = function _ChannelEngine_subscribe(userId, onMessage) {
+    __classPrivateFieldGet(this, _ChannelEngine_receiver, "f").subscribeWith(userId, (_a) => {
+        var { recipients } = _a, event = __rest(_a, ["recipients"]);
+        if (recipients.includes(userId)) {
+            onMessage(event);
+        }
+    });
+}, _ChannelEngine_getUsersFromRecipients = function _ChannelEngine_getUsersFromRecipients(recipients, sender) {
+    const allUsers = Array.from(__classPrivateFieldGet(this, _ChannelEngine_users, "f").keys());
+    let users;
+    switch (recipients) {
+        case enums_1.ChannelReceiver.ALL_USERS:
+            users = allUsers;
+            break;
+        case enums_1.ChannelReceiver.ALL_EXCEPT_SENDER:
+            if (sender === enums_1.SystemSender.CHANNEL) {
+                throw new pondError_1.ChannelError(`ChannelEngine: Cannot use ${enums_1.ChannelReceiver.ALL_EXCEPT_SENDER} with ${enums_1.SystemSender.CHANNEL}`, 500, this.name);
+            }
+            users = allUsers.filter((user) => user !== sender);
+            break;
+        default:
+            const absentUsers = recipients.filter((user) => !allUsers.includes(user));
+            if (absentUsers.length > 0) {
+                throw new pondError_1.ChannelError(`ChannelEngine: Users ${absentUsers.join(', ')} are not in channel ${this.name}`, 400, this.name);
+            }
+            users = recipients;
+            break;
+    }
+    return users;
+};

package/{server/channel → channel}/eventRequest.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventRequest = void 0;
 const abstractRequest_1 = require("../abstracts/abstractRequest");
+const pondError_1 = require("../errors/pondError");
 class EventRequest extends abstractRequest_1.AbstractRequest {
     constructor(event, engine) {
         super(event.event, engine, event.payload);
@@ -10,7 +11,9 @@ class EventRequest extends abstractRequest_1.AbstractRequest {
     get user() {
         const assigns = this._engine.getUserData(this._internalEvent.sender);
         if (!assigns) {
-            throw new Error(`ChannelRequest: User with id ${this._internalEvent.sender} does not exist in channel ${this._engine.name}`);
+            const message = `ChannelRequest: User with id ${this._internalEvent.sender} does not exist in channel ${this._engine.name}`;
+            const code = 404;
+            throw new pondError_1.ChannelError(message, code, this._engine.name);
         }
         return assigns;
     }

package/channel/eventResponse.js

@@ -0,0 +1,150 @@
+"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 _EventResponse_instances, _EventResponse_event, _EventResponse_engine, _EventResponse_executed, _EventResponse_manageAssigns, _EventResponse_performChecks;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventResponse = void 0;
+const abstractResponse_1 = require("../abstracts/abstractResponse");
+const enums_1 = require("../enums");
+const pondError_1 = require("../errors/pondError");
+class EventResponse extends abstractResponse_1.PondResponse {
+    constructor(event, engine) {
+        super();
+        _EventResponse_instances.add(this);
+        _EventResponse_event.set(this, void 0);
+        _EventResponse_engine.set(this, void 0);
+        _EventResponse_executed.set(this, void 0);
+        __classPrivateFieldSet(this, _EventResponse_event, event, "f");
+        __classPrivateFieldSet(this, _EventResponse_engine, engine, "f");
+        __classPrivateFieldSet(this, _EventResponse_executed, false, "f");
+    }
+    /**
+     * @desc Accepts the request and optionally assigns data to the client
+     * @param assigns - the data to assign to the client
+     */
+    accept(assigns) {
+        __classPrivateFieldGet(this, _EventResponse_instances, "m", _EventResponse_manageAssigns).call(this, assigns);
+        __classPrivateFieldGet(this, _EventResponse_engine, "f").sendMessage(__classPrivateFieldGet(this, _EventResponse_event, "f").sender, __classPrivateFieldGet(this, _EventResponse_event, "f").recipients, __classPrivateFieldGet(this, _EventResponse_event, "f").action, __classPrivateFieldGet(this, _EventResponse_event, "f").event, __classPrivateFieldGet(this, _EventResponse_event, "f").payload);
+        return this;
+    }
+    /**
+     * @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
+     */
+    reject(message, errorCode, assigns) {
+        __classPrivateFieldGet(this, _EventResponse_instances, "m", _EventResponse_manageAssigns).call(this, assigns);
+        const text = message || 'Unauthorized request';
+        __classPrivateFieldGet(this, _EventResponse_engine, "f").sendMessage(enums_1.SystemSender.CHANNEL, [__classPrivateFieldGet(this, _EventResponse_event, "f").sender], enums_1.ServerActions.ERROR, enums_1.ErrorTypes.UNAUTHORIZED_BROADCAST, {
+            message: text,
+            code: errorCode || 403,
+        });
+        return this;
+    }
+    /**
+     * @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
+     */
+    send(event, payload, assigns) {
+        this.accept(assigns);
+        __classPrivateFieldGet(this, _EventResponse_engine, "f").sendMessage(enums_1.SystemSender.CHANNEL, [__classPrivateFieldGet(this, _EventResponse_event, "f").sender], enums_1.ServerActions.SYSTEM, event, payload);
+    }
+    /**
+     * @desc Sends a message to all clients in the channel
+     * @param event - the event to send
+     * @param payload - the payload to send
+     */
+    broadcast(event, payload) {
+        __classPrivateFieldGet(this, _EventResponse_engine, "f").sendMessage(__classPrivateFieldGet(this, _EventResponse_event, "f").sender, enums_1.ChannelReceiver.ALL_USERS, enums_1.ServerActions.BROADCAST, event, payload);
+        return this;
+    }
+    /**
+     * @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
+     */
+    broadcastFromUser(event, payload) {
+        __classPrivateFieldGet(this, _EventResponse_engine, "f").sendMessage(__classPrivateFieldGet(this, _EventResponse_event, "f").sender, enums_1.ChannelReceiver.ALL_EXCEPT_SENDER, enums_1.ServerActions.BROADCAST, event, payload);
+        return this;
+    }
+    /**
+     * @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
+     */
+    sendToUsers(event, payload, userIds) {
+        __classPrivateFieldGet(this, _EventResponse_engine, "f").sendMessage(__classPrivateFieldGet(this, _EventResponse_event, "f").sender, userIds, enums_1.ServerActions.BROADCAST, event, payload);
+        return this;
+    }
+    /**
+     * @desc Tracks a user's presence in the channel
+     * @param presence - the initial presence data
+     * @param userId - the id of the user to track
+     */
+    trackPresence(presence, userId) {
+        __classPrivateFieldGet(this, _EventResponse_engine, "f").trackPresence(userId || __classPrivateFieldGet(this, _EventResponse_event, "f").sender, presence);
+        return this;
+    }
+    /**
+     * @desc Updates a user's presence in the channel
+     * @param presence - the updated presence data
+     * @param userId - the id of the user to update
+     */
+    updatePresence(presence, userId) {
+        var _a;
+        (_a = __classPrivateFieldGet(this, _EventResponse_engine, "f").presenceEngine) === null || _a === void 0 ? void 0 : _a.updatePresence(userId || __classPrivateFieldGet(this, _EventResponse_event, "f").sender, presence);
+        return this;
+    }
+    /**
+     * @desc Removes a user's presence from the channel
+     * @param userId - the id of the user to remove
+     */
+    unTrackPresence(userId) {
+        var _a;
+        userId = userId || __classPrivateFieldGet(this, _EventResponse_event, "f").sender;
+        (_a = __classPrivateFieldGet(this, _EventResponse_engine, "f").presenceEngine) === null || _a === void 0 ? void 0 : _a.removePresence(userId);
+        return this;
+    }
+    /**
+     * @desc Evicts a user from the channel
+     * @param reason - the reason for the eviction
+     * @param userId - the id of the user to evict,
+     */
+    evictUser(reason, userId) {
+        __classPrivateFieldGet(this, _EventResponse_engine, "f").kickUser(userId || __classPrivateFieldGet(this, _EventResponse_event, "f").sender, reason);
+    }
+    /**
+     * @desc Closes the channel from the server side for all clients
+     * @param reason - the reason for closing the channel
+     */
+    closeChannel(reason) {
+        __classPrivateFieldGet(this, _EventResponse_engine, "f").destroy(reason);
+    }
+}
+exports.EventResponse = EventResponse;
+_EventResponse_event = new WeakMap(), _EventResponse_engine = new WeakMap(), _EventResponse_executed = new WeakMap(), _EventResponse_instances = new WeakSet(), _EventResponse_manageAssigns = function _EventResponse_manageAssigns(assigns) {
+    __classPrivateFieldGet(this, _EventResponse_instances, "m", _EventResponse_performChecks).call(this);
+    if (assigns) {
+        __classPrivateFieldGet(this, _EventResponse_engine, "f").updateAssigns(__classPrivateFieldGet(this, _EventResponse_event, "f").sender, assigns);
+    }
+}, _EventResponse_performChecks = function _EventResponse_performChecks() {
+    if (__classPrivateFieldGet(this, _EventResponse_executed, "f")) {
+        const message = 'Event response has already been executed';
+        const code = 403;
+        throw new pondError_1.ChannelError(message, code, __classPrivateFieldGet(this, _EventResponse_engine, "f").name);
+    }
+    __classPrivateFieldSet(this, _EventResponse_executed, true, "f");
+};