@eleven-am/pondsocket 0.1.199 → 0.1.201

package/abstracts/distributor.js

@@ -0,0 +1,126 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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 _RedisDistributedBackend_instances, _RedisDistributedBackend_publishClient, _RedisDistributedBackend_subscribeClient, _RedisDistributedBackend_keyPrefix, _RedisDistributedBackend_subject, _RedisDistributedBackend_isConnected, _RedisDistributedBackend_initialize, _RedisDistributedBackend_handleRedisMessage, _RedisDistributedBackend_isValidMessage, _RedisDistributedBackend_buildKey;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisDistributedBackend = void 0;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+const redis_1 = require("redis");
+const types_1 = require("../types");
+class RedisDistributedBackend {
+    constructor(options = {}) {
+        _RedisDistributedBackend_instances.add(this);
+        _RedisDistributedBackend_publishClient.set(this, void 0);
+        _RedisDistributedBackend_subscribeClient.set(this, void 0);
+        _RedisDistributedBackend_keyPrefix.set(this, void 0);
+        _RedisDistributedBackend_subject.set(this, void 0);
+        _RedisDistributedBackend_isConnected.set(this, false);
+        const { host = 'localhost', port = 6379, password, database = 0, url, keyPrefix = 'pondsocket', } = options;
+        __classPrivateFieldSet(this, _RedisDistributedBackend_keyPrefix, keyPrefix, "f");
+        __classPrivateFieldSet(this, _RedisDistributedBackend_subject, new pondsocket_common_1.Subject(), "f");
+        // Create Redis clients
+        const clientConfig = url
+            ? { url }
+            : { socket: { host,
+                    port },
+                password,
+                database };
+        __classPrivateFieldSet(this, _RedisDistributedBackend_publishClient, (0, redis_1.createClient)(clientConfig), "f");
+        __classPrivateFieldSet(this, _RedisDistributedBackend_subscribeClient, __classPrivateFieldGet(this, _RedisDistributedBackend_publishClient, "f").duplicate(), "f");
+        void __classPrivateFieldGet(this, _RedisDistributedBackend_instances, "m", _RedisDistributedBackend_initialize).call(this);
+    }
+    /**
+     * Gets the subject for subscribing to distributed messages
+     */
+    get subject() {
+        return __classPrivateFieldGet(this, _RedisDistributedBackend_subject, "f");
+    }
+    /**
+     * Subscribe to messages for a specific endpoint and channel
+     */
+    subscribe(endpointName, channelName, handler) {
+        return this.subject.subscribe((message) => {
+            if (message.endpointName === endpointName && message.channelName === channelName) {
+                handler(message);
+            }
+        });
+    }
+    /**
+     * Broadcasts a message to all nodes for a specific endpoint and channel
+     */
+    broadcast(endpointName, channelName, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!__classPrivateFieldGet(this, _RedisDistributedBackend_isConnected, "f")) {
+                throw new Error('Redis backend is not connected');
+            }
+            const key = __classPrivateFieldGet(this, _RedisDistributedBackend_instances, "m", _RedisDistributedBackend_buildKey).call(this, endpointName, channelName);
+            const serializedMessage = JSON.stringify(message);
+            yield __classPrivateFieldGet(this, _RedisDistributedBackend_publishClient, "f").publish(key, serializedMessage);
+        });
+    }
+    /**
+     * Cleanup and close all Redis connections
+     */
+    cleanup() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.subject.close();
+            if (__classPrivateFieldGet(this, _RedisDistributedBackend_subscribeClient, "f").isOpen) {
+                yield __classPrivateFieldGet(this, _RedisDistributedBackend_subscribeClient, "f").quit();
+            }
+            if (__classPrivateFieldGet(this, _RedisDistributedBackend_publishClient, "f").isOpen) {
+                yield __classPrivateFieldGet(this, _RedisDistributedBackend_publishClient, "f").quit();
+            }
+            __classPrivateFieldSet(this, _RedisDistributedBackend_isConnected, false, "f");
+        });
+    }
+}
+exports.RedisDistributedBackend = RedisDistributedBackend;
+_RedisDistributedBackend_publishClient = new WeakMap(), _RedisDistributedBackend_subscribeClient = new WeakMap(), _RedisDistributedBackend_keyPrefix = new WeakMap(), _RedisDistributedBackend_subject = new WeakMap(), _RedisDistributedBackend_isConnected = new WeakMap(), _RedisDistributedBackend_instances = new WeakSet(), _RedisDistributedBackend_initialize = function _RedisDistributedBackend_initialize() {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield Promise.all([
+            __classPrivateFieldGet(this, _RedisDistributedBackend_publishClient, "f").connect(),
+            __classPrivateFieldGet(this, _RedisDistributedBackend_subscribeClient, "f").connect(),
+        ]);
+        const pattern = `${__classPrivateFieldGet(this, _RedisDistributedBackend_keyPrefix, "f")}:*`;
+        yield __classPrivateFieldGet(this, _RedisDistributedBackend_subscribeClient, "f").pSubscribe(pattern, (message) => {
+            __classPrivateFieldGet(this, _RedisDistributedBackend_instances, "m", _RedisDistributedBackend_handleRedisMessage).call(this, message);
+        });
+        __classPrivateFieldSet(this, _RedisDistributedBackend_isConnected, true, "f");
+    });
+}, _RedisDistributedBackend_handleRedisMessage = function _RedisDistributedBackend_handleRedisMessage(message) {
+    try {
+        const parsedMessage = JSON.parse(message);
+        if (__classPrivateFieldGet(this, _RedisDistributedBackend_instances, "m", _RedisDistributedBackend_isValidMessage).call(this, parsedMessage)) {
+            this.subject.publish(parsedMessage);
+        }
+    }
+    catch (_a) {
+        // Silently ignore invalid messages
+    }
+}, _RedisDistributedBackend_isValidMessage = function _RedisDistributedBackend_isValidMessage(message) {
+    return (typeof message === 'object' &&
+        typeof message.type === 'string' &&
+        Object.values(types_1.DistributedMessageType).includes(message.type) &&
+        typeof message.endpointName === 'string' &&
+        typeof message.channelName === 'string');
+}, _RedisDistributedBackend_buildKey = function _RedisDistributedBackend_buildKey(endpointName, channelName) {
+    return `${__classPrivateFieldGet(this, _RedisDistributedBackend_keyPrefix, "f")}:${endpointName}:${channelName}`;
+};

package/abstracts/middleware.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 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");
@@ -64,6 +73,26 @@ class Middleware {
         };
         next();
     }
+    runAsync(req, res, final) {
+        let index = 0;
+        const next = (err) => __awaiter(this, void 0, void 0, function* () {
+            if (err) {
+                return final(__classPrivateFieldGet(this, _Middleware_instances, "m", _Middleware_handleError).call(this, err));
+            }
+            if (index >= __classPrivateFieldGet(this, _Middleware_stack, "f").length) {
+                return final();
+            }
+            const middleware = __classPrivateFieldGet(this, _Middleware_stack, "f")[index];
+            index++;
+            try {
+                yield middleware(req, res, next);
+            }
+            catch (error) {
+                return final(__classPrivateFieldGet(this, _Middleware_instances, "m", _Middleware_handleError).call(this, error));
+            }
+        });
+        return next();
+    }
 }
 exports.Middleware = Middleware;
 _Middleware_stack = new WeakMap(), _Middleware_instances = new WeakSet(), _Middleware_handleError = function _Middleware_handleError(error) {

package/abstracts/types.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DistributedMessageType = void 0;
+var DistributedMessageType;
+(function (DistributedMessageType) {
+    DistributedMessageType["STATE_REQUEST"] = "STATE_REQUEST";
+    DistributedMessageType["STATE_RESPONSE"] = "STATE_RESPONSE";
+    DistributedMessageType["USER_JOINED"] = "USER_JOINED";
+    DistributedMessageType["USER_LEFT"] = "USER_LEFT";
+    DistributedMessageType["USER_MESSAGE"] = "USER_MESSAGE";
+    DistributedMessageType["PRESENCE_UPDATE"] = "PRESENCE_UPDATE";
+    DistributedMessageType["PRESENCE_REMOVED"] = "PRESENCE_REMOVED";
+    DistributedMessageType["ASSIGNS_UPDATE"] = "ASSIGNS_UPDATE";
+    DistributedMessageType["ASSIGNS_REMOVED"] = "ASSIGNS_REMOVED";
+    DistributedMessageType["EVICT_USER"] = "EVICT_USER";
+})(DistributedMessageType || (exports.DistributedMessageType = DistributedMessageType = {}));

package/contexts/baseContext.js

@@ -0,0 +1,86 @@
+"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 _BaseContext_engine, _BaseContext_params, _BaseContext_event, _BaseContext_sender, _BaseContext_payload;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseContext = void 0;
+const channel_1 = require("../wrappers/channel");
+class BaseContext {
+    constructor(engine, params, event, payload, sender) {
+        _BaseContext_engine.set(this, void 0);
+        _BaseContext_params.set(this, void 0);
+        _BaseContext_event.set(this, void 0);
+        _BaseContext_sender.set(this, void 0);
+        _BaseContext_payload.set(this, void 0);
+        __classPrivateFieldSet(this, _BaseContext_engine, engine, "f");
+        __classPrivateFieldSet(this, _BaseContext_params, params, "f");
+        __classPrivateFieldSet(this, _BaseContext_event, event, "f");
+        __classPrivateFieldSet(this, _BaseContext_payload, payload, "f");
+        __classPrivateFieldSet(this, _BaseContext_sender, sender, "f");
+    }
+    /**
+     * The event information
+     */
+    get event() {
+        return {
+            event: __classPrivateFieldGet(this, _BaseContext_event, "f"),
+            query: __classPrivateFieldGet(this, _BaseContext_params, "f").query,
+            params: __classPrivateFieldGet(this, _BaseContext_params, "f").params,
+            payload: __classPrivateFieldGet(this, _BaseContext_payload, "f"),
+        };
+    }
+    /**
+     * The channel name
+     */
+    get channelName() {
+        return __classPrivateFieldGet(this, _BaseContext_engine, "f").name;
+    }
+    /**
+     * The channel instance
+     */
+    get channel() {
+        return new channel_1.Channel(__classPrivateFieldGet(this, _BaseContext_engine, "f"));
+    }
+    /**
+     * All current presences in the channel
+     */
+    get presences() {
+        return __classPrivateFieldGet(this, _BaseContext_engine, "f").getPresence();
+    }
+    /**
+     * All current assigns in the channel
+     */
+    get assigns() {
+        return __classPrivateFieldGet(this, _BaseContext_engine, "f").getAssigns();
+    }
+    /**
+     * The user who sent the request
+     */
+    get user() {
+        return this.channel.getUserData(__classPrivateFieldGet(this, _BaseContext_sender, "f"));
+    }
+    /**
+     * Gets the channel engine instance
+     * @protected
+     */
+    get engine() {
+        return __classPrivateFieldGet(this, _BaseContext_engine, "f");
+    }
+    /**
+     * Updates the event parameters.
+     */
+    updateParams(params) {
+        __classPrivateFieldSet(this, _BaseContext_params, params, "f");
+    }
+}
+exports.BaseContext = BaseContext;
+_BaseContext_engine = new WeakMap(), _BaseContext_params = new WeakMap(), _BaseContext_event = new WeakMap(), _BaseContext_sender = new WeakMap(), _BaseContext_payload = new WeakMap();

package/contexts/connectionContext.js

@@ -0,0 +1,169 @@
+"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 _ConnectionContext_instances, _ConnectionContext_executed, _ConnectionContext_assigns, _ConnectionContext_clientId, _ConnectionContext_engine, _ConnectionContext_params, _ConnectionContext_webSocketServer, _ConnectionContext_connectionData, _ConnectionContext_performChecks;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionContext = void 0;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+const httpError_1 = require("../errors/httpError");
+/**
+ * ConnectionContext combines IncomingConnection data with ConnectionResponse functionality.
+ */
+class ConnectionContext {
+    constructor(connectionData, { engine, params, webSocketServer }) {
+        _ConnectionContext_instances.add(this);
+        _ConnectionContext_executed.set(this, void 0);
+        _ConnectionContext_assigns.set(this, void 0);
+        _ConnectionContext_clientId.set(this, void 0);
+        _ConnectionContext_engine.set(this, void 0);
+        _ConnectionContext_params.set(this, void 0);
+        _ConnectionContext_webSocketServer.set(this, void 0);
+        _ConnectionContext_connectionData.set(this, void 0);
+        __classPrivateFieldSet(this, _ConnectionContext_webSocketServer, webSocketServer, "f");
+        __classPrivateFieldSet(this, _ConnectionContext_clientId, connectionData.id, "f");
+        __classPrivateFieldSet(this, _ConnectionContext_executed, false, "f");
+        __classPrivateFieldSet(this, _ConnectionContext_engine, engine, "f");
+        __classPrivateFieldSet(this, _ConnectionContext_params, params, "f");
+        __classPrivateFieldSet(this, _ConnectionContext_assigns, {}, "f");
+        __classPrivateFieldSet(this, _ConnectionContext_connectionData, connectionData, "f");
+    }
+    /**
+     * Whether the connection has been handled
+     */
+    get hasResponded() {
+        return __classPrivateFieldGet(this, _ConnectionContext_executed, "f");
+    }
+    /**
+     * Connection details including headers, cookies, address, id, etc.
+     */
+    get connection() {
+        return __classPrivateFieldGet(this, _ConnectionContext_connectionData, "f");
+    }
+    /**
+     * The request parameters
+     */
+    get requestId() {
+        return __classPrivateFieldGet(this, _ConnectionContext_params, "f").requestId;
+    }
+    /**
+     * The client ID
+     */
+    get clientId() {
+        return __classPrivateFieldGet(this, _ConnectionContext_clientId, "f");
+    }
+    /**
+     * The request headers
+     */
+    get headers() {
+        return __classPrivateFieldGet(this, _ConnectionContext_connectionData, "f").headers;
+    }
+    /**
+     * The request cookies
+     */
+    get cookies() {
+        return __classPrivateFieldGet(this, _ConnectionContext_connectionData, "f").cookies;
+    }
+    /**
+     * The client address
+     */
+    get address() {
+        return __classPrivateFieldGet(this, _ConnectionContext_connectionData, "f").address;
+    }
+    /**
+     * The event parameters
+     */
+    get event() {
+        return {
+            query: __classPrivateFieldGet(this, _ConnectionContext_connectionData, "f").query,
+            params: __classPrivateFieldGet(this, _ConnectionContext_connectionData, "f").params,
+        };
+    }
+    /**
+     * The query parameters
+     */
+    get query() {
+        return __classPrivateFieldGet(this, _ConnectionContext_connectionData, "f").query;
+    }
+    /**
+     * The path parameters
+     */
+    get params() {
+        return __classPrivateFieldGet(this, _ConnectionContext_connectionData, "f").params;
+    }
+    /**
+     * Assigns data to the client
+     */
+    assign(assigns) {
+        if (!__classPrivateFieldGet(this, _ConnectionContext_executed, "f")) {
+            __classPrivateFieldSet(this, _ConnectionContext_assigns, Object.assign(Object.assign({}, __classPrivateFieldGet(this, _ConnectionContext_assigns, "f")), assigns), "f");
+        }
+        else {
+            const user = __classPrivateFieldGet(this, _ConnectionContext_engine, "f").getUser(__classPrivateFieldGet(this, _ConnectionContext_clientId, "f"));
+            user.assigns = Object.assign(Object.assign({}, user.assigns), assigns);
+        }
+        return this;
+    }
+    /**
+     * Accepts the connection request
+     */
+    accept() {
+        __classPrivateFieldGet(this, _ConnectionContext_instances, "m", _ConnectionContext_performChecks).call(this);
+        __classPrivateFieldGet(this, _ConnectionContext_webSocketServer, "f").handleUpgrade(__classPrivateFieldGet(this, _ConnectionContext_params, "f").request, __classPrivateFieldGet(this, _ConnectionContext_params, "f").socket, __classPrivateFieldGet(this, _ConnectionContext_params, "f").head, (ws) => {
+            const cache = {
+                clientId: __classPrivateFieldGet(this, _ConnectionContext_clientId, "f"),
+                subscriptions: new Set(),
+                assigns: __classPrivateFieldGet(this, _ConnectionContext_assigns, "f"),
+                socket: ws,
+            };
+            __classPrivateFieldGet(this, _ConnectionContext_webSocketServer, "f").emit('connection', ws);
+            __classPrivateFieldGet(this, _ConnectionContext_engine, "f").manageSocket(cache);
+        });
+        return this;
+    }
+    /**
+     * Declines the connection request
+     */
+    decline(message, errorCode) {
+        __classPrivateFieldGet(this, _ConnectionContext_instances, "m", _ConnectionContext_performChecks).call(this);
+        const code = errorCode || 400;
+        const { socket } = __classPrivateFieldGet(this, _ConnectionContext_params, "f");
+        const newMessage = message || 'Unauthorized connection';
+        socket.write(`HTTP/1.1 ${code} ${newMessage}\r\n\r\n`);
+        socket.destroy();
+        return this;
+    }
+    /**
+     * Sends a direct reply to the client
+     */
+    reply(event, payload) {
+        if (!__classPrivateFieldGet(this, _ConnectionContext_executed, "f")) {
+            throw new httpError_1.HttpError(400, 'Connection has not been accepted');
+        }
+        const { socket } = __classPrivateFieldGet(this, _ConnectionContext_engine, "f").getUser(__classPrivateFieldGet(this, _ConnectionContext_clientId, "f"));
+        const message = {
+            event,
+            payload,
+            action: pondsocket_common_1.ServerActions.BROADCAST,
+            requestId: __classPrivateFieldGet(this, _ConnectionContext_params, "f").requestId,
+            channelName: pondsocket_common_1.SystemSender.ENDPOINT,
+        };
+        __classPrivateFieldGet(this, _ConnectionContext_engine, "f").sendMessage(socket, message);
+        return this;
+    }
+}
+exports.ConnectionContext = ConnectionContext;
+_ConnectionContext_executed = new WeakMap(), _ConnectionContext_assigns = new WeakMap(), _ConnectionContext_clientId = new WeakMap(), _ConnectionContext_engine = new WeakMap(), _ConnectionContext_params = new WeakMap(), _ConnectionContext_webSocketServer = new WeakMap(), _ConnectionContext_connectionData = new WeakMap(), _ConnectionContext_instances = new WeakSet(), _ConnectionContext_performChecks = function _ConnectionContext_performChecks() {
+    if (__classPrivateFieldGet(this, _ConnectionContext_executed, "f")) {
+        throw new httpError_1.HttpError(400, 'Response has already been executed');
+    }
+    __classPrivateFieldSet(this, _ConnectionContext_executed, true, "f");
+};

package/contexts/eventContext.js

@@ -0,0 +1,99 @@
+"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 _EventContext_instances, _EventContext_event, _EventContext_requestId, _EventContext_sendMessage;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventContext = void 0;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+const baseContext_1 = require("./baseContext");
+/**
+ * EventContext combines the functionality of EventRequest and EventResponse
+ * to provide a unified interface for handling events in a channel.
+ */
+class EventContext extends baseContext_1.BaseContext {
+    constructor(event, params, engine) {
+        super(engine, params, event.event, event.payload, event.sender);
+        _EventContext_instances.add(this);
+        _EventContext_event.set(this, void 0);
+        _EventContext_requestId.set(this, void 0);
+        __classPrivateFieldSet(this, _EventContext_event, event, "f");
+        __classPrivateFieldSet(this, _EventContext_requestId, event.requestId, "f");
+    }
+    /**
+     * Assigns data to the client
+     */
+    assign(assigns) {
+        this.channel.updateAssigns(__classPrivateFieldGet(this, _EventContext_event, "f").sender, assigns);
+        return this;
+    }
+    /**
+     * Sends a direct reply to the client
+     */
+    reply(event, payload) {
+        this.engine.sendMessage(pondsocket_common_1.SystemSender.CHANNEL, [__classPrivateFieldGet(this, _EventContext_event, "f").sender], pondsocket_common_1.ServerActions.SYSTEM, event, payload, __classPrivateFieldGet(this, _EventContext_requestId, "f"));
+        return this;
+    }
+    /**
+     * Broadcasts a message to all users in the channel
+     */
+    broadcast(event, payload) {
+        __classPrivateFieldGet(this, _EventContext_instances, "m", _EventContext_sendMessage).call(this, pondsocket_common_1.ChannelReceiver.ALL_USERS, event, payload);
+        return this;
+    }
+    /**
+     * Broadcasts a message to all users except the sender
+     */
+    broadcastFrom(event, payload) {
+        __classPrivateFieldGet(this, _EventContext_instances, "m", _EventContext_sendMessage).call(this, pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, event, payload);
+        return this;
+    }
+    /**
+     * Broadcasts a message to specific users
+     */
+    broadcastTo(event, payload, userIds) {
+        const ids = Array.isArray(userIds) ? userIds : [userIds];
+        __classPrivateFieldGet(this, _EventContext_instances, "m", _EventContext_sendMessage).call(this, ids, event, payload);
+        return this;
+    }
+    /**
+     * Tracks a user's presence
+     */
+    trackPresence(presence, userId = __classPrivateFieldGet(this, _EventContext_event, "f").sender) {
+        this.channel.trackPresence(userId, presence);
+        return this;
+    }
+    /**
+     * Updates a user's presence
+     */
+    updatePresence(presence, userId = __classPrivateFieldGet(this, _EventContext_event, "f").sender) {
+        this.channel.updatePresence(userId, presence);
+        return this;
+    }
+    /**
+     * Kicks a user from the channel
+     */
+    evictUser(reason, userId = __classPrivateFieldGet(this, _EventContext_event, "f").sender) {
+        this.channel.evictUser(userId, reason);
+        return this;
+    }
+    /**
+     * Removes a user's presence
+     */
+    removePresence(userId = __classPrivateFieldGet(this, _EventContext_event, "f").sender) {
+        this.channel.removePresence(userId);
+        return this;
+    }
+}
+exports.EventContext = EventContext;
+_EventContext_event = new WeakMap(), _EventContext_requestId = new WeakMap(), _EventContext_instances = new WeakSet(), _EventContext_sendMessage = function _EventContext_sendMessage(recipient, event, payload) {
+    this.engine.sendMessage(__classPrivateFieldGet(this, _EventContext_event, "f").sender, recipient, pondsocket_common_1.ServerActions.BROADCAST, event, payload, __classPrivateFieldGet(this, _EventContext_requestId, "f"));
+};