@eleven-am/pondsocket 0.1.169 → 0.1.170

package/engines/endpointEngine.js

@@ -0,0 +1,163 @@
+"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 _EndpointEngine_instances, _EndpointEngine_clientFactory, _EndpointEngine_sockets, _EndpointEngine_middleware, _EndpointEngine_lobbyEngines, _EndpointEngine_handleSocketClose, _EndpointEngine_handleMessage, _EndpointEngine_joinChannel, _EndpointEngine_leaveChannel, _EndpointEngine_retrieveChannel, _EndpointEngine_buildError, _EndpointEngine_broadcastMessage, _EndpointEngine_readMessage;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EndpointEngine = void 0;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+const lobbyEngine_1 = require("./lobbyEngine");
+const middleware_1 = require("../abstracts/middleware");
+const httpError_1 = require("../errors/httpError");
+const managerFactory_1 = require("../managers/managerFactory");
+const matcher_1 = require("../matcher/matcher");
+const joinRequest_1 = require("../requests/joinRequest");
+const joinResponse_1 = require("../responses/joinResponse");
+const pondChannel_1 = require("../wrappers/pondChannel");
+class EndpointEngine {
+    constructor(clientFactory) {
+        _EndpointEngine_instances.add(this);
+        _EndpointEngine_clientFactory.set(this, void 0);
+        _EndpointEngine_sockets.set(this, void 0);
+        _EndpointEngine_middleware.set(this, void 0);
+        _EndpointEngine_lobbyEngines.set(this, void 0);
+        __classPrivateFieldSet(this, _EndpointEngine_sockets, new Map(), "f");
+        __classPrivateFieldSet(this, _EndpointEngine_lobbyEngines, new Map(), "f");
+        __classPrivateFieldSet(this, _EndpointEngine_middleware, new middleware_1.Middleware(), "f");
+        __classPrivateFieldSet(this, _EndpointEngine_clientFactory, clientFactory, "f");
+    }
+    createChannel(path, handler) {
+        const pondChannel = new lobbyEngine_1.LobbyEngine(this);
+        __classPrivateFieldGet(this, _EndpointEngine_middleware, "f").use((user, joinParams, next) => __awaiter(this, void 0, void 0, function* () {
+            const event = (0, matcher_1.parseAddress)(path, user.channelName);
+            if (event) {
+                const options = {
+                    clientId: user.clientId,
+                    assigns: user.assigns,
+                    params: event,
+                    joinParams,
+                };
+                const channel = yield pondChannel.getOrCreateChannel(user.channelName);
+                const request = new joinRequest_1.JoinRequest(options, channel);
+                const response = new joinResponse_1.JoinResponse(user, channel);
+                return handler(request, response, next);
+            }
+            next();
+        }));
+        __classPrivateFieldGet(this, _EndpointEngine_lobbyEngines, "f").set(path, pondChannel);
+        return new pondChannel_1.PondChannel(pondChannel);
+    }
+    getClients() {
+        return [...__classPrivateFieldGet(this, _EndpointEngine_sockets, "f").values()];
+    }
+    getUser(clientId) {
+        const user = __classPrivateFieldGet(this, _EndpointEngine_sockets, "f").get(clientId);
+        if (!user) {
+            throw new httpError_1.HttpError(404, `GatewayEngine: User ${clientId} does not exist`);
+        }
+        return user;
+    }
+    manageSocket(cache) {
+        __classPrivateFieldGet(this, _EndpointEngine_sockets, "f").set(cache.clientId, cache);
+        cache.socket.on('message', (message) => __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_readMessage).call(this, cache, message));
+        cache.socket.on('close', () => __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_handleSocketClose).call(this, cache));
+        cache.socket.on('error', () => __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_handleSocketClose).call(this, cache));
+        const event = {
+            event: pondsocket_common_1.Events.CONNECTION,
+            action: pondsocket_common_1.ServerActions.CONNECT,
+            channelName: pondsocket_common_1.SystemSender.ENDPOINT,
+            requestId: (0, pondsocket_common_1.uuid)(),
+            payload: {},
+        };
+        this.sendMessage(cache.socket, event);
+    }
+    createManager(channelName, onLeave) {
+        return managerFactory_1.ManagerFactory.create(channelName, __classPrivateFieldGet(this, _EndpointEngine_clientFactory, "f"), onLeave);
+    }
+    sendMessage(socket, message) {
+        socket.send(JSON.stringify(message));
+    }
+    closeConnection(clientIds) {
+        const clients = typeof clientIds === 'string' ? [clientIds] : clientIds;
+        this.getClients()
+            .forEach(({ clientId, socket }) => {
+            if (clients.includes(clientId)) {
+                socket.close();
+            }
+        });
+    }
+}
+exports.EndpointEngine = EndpointEngine;
+_EndpointEngine_clientFactory = new WeakMap(), _EndpointEngine_sockets = new WeakMap(), _EndpointEngine_middleware = new WeakMap(), _EndpointEngine_lobbyEngines = new WeakMap(), _EndpointEngine_instances = new WeakSet(), _EndpointEngine_handleSocketClose = function _EndpointEngine_handleSocketClose(cache) {
+    __classPrivateFieldGet(this, _EndpointEngine_sockets, "f").delete(cache.clientId);
+    cache.subscriptions.forEach((unsubscribe) => unsubscribe());
+}, _EndpointEngine_handleMessage = function _EndpointEngine_handleMessage(cache, message) {
+    switch (message.action) {
+        case pondsocket_common_1.ClientActions.JOIN_CHANNEL:
+            __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_joinChannel).call(this, message.channelName, cache, message.payload, message.requestId);
+            break;
+        case pondsocket_common_1.ClientActions.LEAVE_CHANNEL:
+            __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_leaveChannel).call(this, message.channelName, cache);
+            break;
+        case pondsocket_common_1.ClientActions.BROADCAST:
+            __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_broadcastMessage).call(this, cache, message);
+            break;
+        default:
+            throw new Error(`GatewayEngine: Action ${message.action} does not exist`);
+    }
+}, _EndpointEngine_joinChannel = function _EndpointEngine_joinChannel(channel, socket, joinParams, requestId) {
+    const cache = Object.assign(Object.assign({}, socket), { requestId, channelName: channel });
+    __classPrivateFieldGet(this, _EndpointEngine_middleware, "f").run(cache, joinParams, (error) => {
+        error = error || new httpError_1.HttpError(404, `GatewayEngine: Channel ${channel} does not exist`);
+        throw error;
+    });
+}, _EndpointEngine_leaveChannel = function _EndpointEngine_leaveChannel(channel, socket) {
+    const engine = __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_retrieveChannel).call(this, channel);
+    engine.removeUser(socket.clientId);
+}, _EndpointEngine_retrieveChannel = function _EndpointEngine_retrieveChannel(channel) {
+    for (const [path, manager] of __classPrivateFieldGet(this, _EndpointEngine_lobbyEngines, "f")) {
+        const event = (0, matcher_1.parseAddress)(path, channel);
+        if (event) {
+            return manager.getChannel(channel);
+        }
+    }
+    throw new httpError_1.HttpError(404, `GatewayEngine: Channel ${channel} does not exist`);
+}, _EndpointEngine_buildError = function _EndpointEngine_buildError(error) {
+    const event = {
+        event: pondsocket_common_1.ErrorTypes.INVALID_MESSAGE,
+        action: pondsocket_common_1.ServerActions.ERROR,
+        channelName: pondsocket_common_1.SystemSender.ENDPOINT,
+        requestId: (0, pondsocket_common_1.uuid)(),
+        payload: {},
+    };
+    return event;
+}, _EndpointEngine_broadcastMessage = function _EndpointEngine_broadcastMessage(socket, message) {
+    const engine = __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_retrieveChannel).call(this, message.channelName);
+    engine.broadcastMessage(socket.clientId, message);
+}, _EndpointEngine_readMessage = function _EndpointEngine_readMessage(cache, message) {
+    try {
+        const data = JSON.parse(message);
+        const result = pondsocket_common_1.clientMessageSchema.parse(data);
+        __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_handleMessage).call(this, cache, result);
+    }
+    catch (e) {
+        this.sendMessage(cache.socket, __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_buildError).call(this, e));
+    }
+};

package/engines/lobbyEngine.js

@@ -0,0 +1,79 @@
+"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 _LobbyEngine_instances, _LobbyEngine_channels, _LobbyEngine_getChannel, _LobbyEngine_createChannel;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LobbyEngine = void 0;
+const channelEngine_1 = require("./channelEngine");
+const middleware_1 = require("../abstracts/middleware");
+const httpError_1 = require("../errors/httpError");
+const matcher_1 = require("../matcher/matcher");
+const eventRequest_1 = require("../requests/eventRequest");
+const eventResponse_1 = require("../responses/eventResponse");
+class LobbyEngine {
+    constructor(parent) {
+        _LobbyEngine_instances.add(this);
+        this.parent = parent;
+        _LobbyEngine_channels.set(this, void 0);
+        this.middleware = new middleware_1.Middleware();
+        __classPrivateFieldSet(this, _LobbyEngine_channels, new Map(), "f");
+    }
+    onLeave(callback) {
+        this.leaveCallback = callback;
+    }
+    onEvent(event, handler) {
+        this.middleware.use((requestEvent, channel, next) => {
+            const params = (0, matcher_1.parseAddress)(event, requestEvent.event);
+            if (params) {
+                const eventRequest = new eventRequest_1.EventRequest(requestEvent, params, channel);
+                const response = new eventResponse_1.EventResponse(requestEvent, channel);
+                return handler(eventRequest, response, next);
+            }
+            return next();
+        });
+    }
+    getOrCreateChannel(channelName) {
+        const oldChannel = __classPrivateFieldGet(this, _LobbyEngine_instances, "m", _LobbyEngine_getChannel).call(this, channelName);
+        if (oldChannel) {
+            return oldChannel;
+        }
+        return __classPrivateFieldGet(this, _LobbyEngine_instances, "m", _LobbyEngine_createChannel).call(this, channelName);
+    }
+    getChannel(channelName) {
+        const channel = __classPrivateFieldGet(this, _LobbyEngine_channels, "f").get(channelName);
+        if (!channel) {
+            throw new httpError_1.HttpError(404, `Channel ${channelName} not found`);
+        }
+        return channel;
+    }
+}
+exports.LobbyEngine = LobbyEngine;
+_LobbyEngine_channels = new WeakMap(), _LobbyEngine_instances = new WeakSet(), _LobbyEngine_getChannel = function _LobbyEngine_getChannel(channelName) {
+    return __classPrivateFieldGet(this, _LobbyEngine_channels, "f").get(channelName) || null;
+}, _LobbyEngine_createChannel = function _LobbyEngine_createChannel(channelName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const onManagerClose = __classPrivateFieldGet(this, _LobbyEngine_channels, "f").delete.bind(__classPrivateFieldGet(this, _LobbyEngine_channels, "f"), channelName);
+        const manager = yield this.parent.createManager(channelName, onManagerClose);
+        const channel = new channelEngine_1.ChannelEngine(this, channelName, manager);
+        __classPrivateFieldGet(this, _LobbyEngine_channels, "f").set(channelName, channel);
+        return channel;
+    });
+};

package/errors/httpError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpError = void 0;
+class HttpError extends Error {
+    constructor(statusCode, message) {
+        super(message);
+        this.statusCode = statusCode;
+        this.name = 'HttpError';
+    }
+}
+exports.HttpError = HttpError;

package/index.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const pondSocket_1 = require("./server/pondSocket");
-exports.default = pondSocket_1.PondSocket;
+const server_1 = require("./server/server");
+exports.default = server_1.PondSocket;

package/managers/distributedManager.js

@@ -0,0 +1,115 @@
+"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 _DistributedManager_client, _DistributedManager_subscriptions;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DistributedManager = void 0;
+const manager_1 = require("./manager");
+class DistributedManager extends manager_1.Manager {
+    constructor(client) {
+        super(client.channelId);
+        _DistributedManager_client.set(this, void 0);
+        _DistributedManager_subscriptions.set(this, null);
+        __classPrivateFieldSet(this, _DistributedManager_client, client, "f");
+    }
+    trackPresence(userId, data) {
+        const message = this.processPresenceData(manager_1.ActionTypes.CREATE, userId, data);
+        __classPrivateFieldGet(this, _DistributedManager_client, "f").publishPresenceChange(userId, data);
+        return this.broadcast(message);
+    }
+    updatePresence(userId, data) {
+        const message = this.processPresenceData(manager_1.ActionTypes.UPDATE, userId, data);
+        __classPrivateFieldGet(this, _DistributedManager_client, "f").publishPresenceChange(userId, data);
+        return this.broadcast(message);
+    }
+    removePresence(userId) {
+        const message = this.processPresenceData(manager_1.ActionTypes.DELETE, userId, null);
+        __classPrivateFieldGet(this, _DistributedManager_client, "f").publishPresenceChange(userId, null);
+        return this.broadcast(message);
+    }
+    setAssigns(userId, data) {
+        this.processAssignsData(manager_1.ActionTypes.CREATE, userId, data);
+        __classPrivateFieldGet(this, _DistributedManager_client, "f").publishAssignsChange(userId, data);
+    }
+    updateAssigns(userId, data) {
+        this.processAssignsData(manager_1.ActionTypes.UPDATE, userId, data);
+        __classPrivateFieldGet(this, _DistributedManager_client, "f").publishAssignsChange(userId, data);
+    }
+    removeAssigns(userId) {
+        this.processAssignsData(manager_1.ActionTypes.DELETE, userId, null);
+        __classPrivateFieldGet(this, _DistributedManager_client, "f").publishAssignsChange(userId, null);
+    }
+    removeUser(userId) {
+        const userData = super.removeUser(userId);
+        __classPrivateFieldGet(this, _DistributedManager_client, "f").publishUserLeave(userId);
+        return userData;
+    }
+    broadcast(message) {
+        __classPrivateFieldGet(this, _DistributedManager_client, "f").publishChannelMessage(message);
+    }
+    initialize(unsubscribe) {
+        const _super = Object.create(null, {
+            initialize: { get: () => super.initialize }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield _super.initialize.call(this, unsubscribe);
+            this.presenceCache = yield __classPrivateFieldGet(this, _DistributedManager_client, "f").getPresenceCache();
+            this.assignsCache = yield __classPrivateFieldGet(this, _DistributedManager_client, "f").getAssignsCache();
+            const leaveSubscription = __classPrivateFieldGet(this, _DistributedManager_client, "f").subscribeToUserLeaves((userId) => {
+                var _a;
+                (_a = this.userSubscriptions.get(userId)) === null || _a === void 0 ? void 0 : _a();
+                this.userSubscriptions.delete(userId);
+            });
+            const presenceSubscription = __classPrivateFieldGet(this, _DistributedManager_client, "f").subscribeToPresenceChanges(({ userId, state }) => {
+                if (state) {
+                    this.presenceCache.set(userId, state);
+                }
+                else {
+                    this.presenceCache.delete(userId);
+                }
+            });
+            const assignSubscription = __classPrivateFieldGet(this, _DistributedManager_client, "f").subscribeToAssignsChanges(({ userId, state }) => {
+                if (state) {
+                    this.assignsCache.set(userId, state);
+                }
+                else {
+                    this.assignsCache.delete(userId);
+                }
+            });
+            const messageSubscription = __classPrivateFieldGet(this, _DistributedManager_client, "f").subscribeToChannelMessages((message) => {
+                this.publisher.publish(message);
+            });
+            __classPrivateFieldSet(this, _DistributedManager_subscriptions, () => {
+                leaveSubscription();
+                presenceSubscription();
+                assignSubscription();
+                messageSubscription();
+            }, "f");
+        });
+    }
+    close() {
+        var _a;
+        (_a = __classPrivateFieldGet(this, _DistributedManager_subscriptions, "f")) === null || _a === void 0 ? void 0 : _a.call(this);
+        return super.close();
+    }
+}
+exports.DistributedManager = DistributedManager;
+_DistributedManager_client = new WeakMap(), _DistributedManager_subscriptions = new WeakMap();

package/managers/localManager.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalManager = void 0;
+const manager_1 = require("./manager");
+class LocalManager extends manager_1.Manager {
+    constructor(channelId) {
+        super(channelId);
+    }
+    trackPresence(userId, data) {
+        const message = this.processPresenceData(manager_1.ActionTypes.CREATE, userId, data);
+        return this.broadcast(message);
+    }
+    updatePresence(userId, data) {
+        const message = this.processPresenceData(manager_1.ActionTypes.UPDATE, userId, data);
+        return this.broadcast(message);
+    }
+    removePresence(userId) {
+        const message = this.processPresenceData(manager_1.ActionTypes.DELETE, userId, null);
+        return this.broadcast(message);
+    }
+    setAssigns(userId, data) {
+        return this.processAssignsData(manager_1.ActionTypes.CREATE, userId, data);
+    }
+    updateAssigns(userId, data) {
+        return this.processAssignsData(manager_1.ActionTypes.UPDATE, userId, data);
+    }
+    removeAssigns(userId) {
+        return this.processAssignsData(manager_1.ActionTypes.DELETE, userId, null);
+    }
+    removeUser(userId) {
+        var _a;
+        const userData = super.removeUser(userId);
+        (_a = this.userSubscriptions.get(userId)) === null || _a === void 0 ? void 0 : _a();
+        this.userSubscriptions.delete(userId);
+        return userData;
+    }
+    broadcast(message) {
+        this.publisher.publish(message);
+    }
+}
+exports.LocalManager = LocalManager;

package/managers/manager.js

@@ -0,0 +1,219 @@
+"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 _Manager_instances, _Manager_onClose, _Manager_processData;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Manager = exports.ActionTypes = void 0;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+const httpError_1 = require("../errors/httpError");
+var DataTypes;
+(function (DataTypes) {
+    DataTypes["PRESENCE"] = "presence";
+    DataTypes["ASSIGNS"] = "assigns";
+})(DataTypes || (DataTypes = {}));
+var ActionTypes;
+(function (ActionTypes) {
+    ActionTypes["CREATE"] = "create";
+    ActionTypes["UPDATE"] = "update";
+    ActionTypes["DELETE"] = "delete";
+})(ActionTypes || (exports.ActionTypes = ActionTypes = {}));
+class Manager {
+    constructor(channelId) {
+        _Manager_instances.add(this);
+        this.channelId = channelId;
+        this.userSubscriptions = new Map();
+        this.publisher = new pondsocket_common_1.Subject();
+        this.presenceCache = new Map();
+        this.assignsCache = new Map();
+        _Manager_onClose.set(this, null);
+    }
+    get userIds() {
+        return new Set(this.assignsCache.keys());
+    }
+    /**
+     * @desc Initializes the data manager
+     * @param unsubscribe - The callback to call when the manager is closed
+     */
+    initialize(unsubscribe) {
+        __classPrivateFieldSet(this, _Manager_onClose, unsubscribe, "f");
+        return Promise.resolve();
+    }
+    /**
+     * @desc Returns the presence of a user
+     * @param userId - The id of the user
+     */
+    getPresence(userId) {
+        return this.presenceCache.get(userId) || null;
+    }
+    /**
+     * @desc Returns all the presence
+     */
+    getAllPresence() {
+        return new Map(this.presenceCache);
+    }
+    /**
+     * @desc Creates or updates the presence of a user
+     * @param userId - The id of the user
+     * @param data - The presence data
+     */
+    upsertPresence(userId, data) {
+        if (this.presenceCache.has(userId)) {
+            this.updatePresence(userId, data);
+        }
+        else {
+            this.trackPresence(userId, data);
+        }
+    }
+    /**
+     * @desc Returns the assigns of a user
+     * @param userId - The id of the user
+     */
+    getAssigns(userId) {
+        return this.assignsCache.get(userId) || null;
+    }
+    /**
+     * @desc Returns all the assigns
+     */
+    getAllAssigns() {
+        return new Map(this.assignsCache);
+    }
+    /**
+     * @desc Closes the data manager
+     */
+    close() {
+        var _a;
+        this.publisher.close();
+        this.presenceCache.clear();
+        this.assignsCache.clear();
+        this.userSubscriptions.forEach((unsubscribe) => unsubscribe());
+        this.userSubscriptions.clear();
+        (_a = __classPrivateFieldGet(this, _Manager_onClose, "f")) === null || _a === void 0 ? void 0 : _a.call(this);
+    }
+    /**
+     * @desc Subscribes to incoming messages
+     * @param userId - The id of the user
+     * @param assigns - The assigns of the user
+     * @param onMessage - The callback to call when a message is received
+     */
+    addUser(userId, assigns, onMessage) {
+        this.setAssigns(userId, assigns);
+        const subscription = this.publisher.subscribe((_a) => {
+            var { recipients } = _a, event = __rest(_a, ["recipients"]);
+            if (recipients.includes(userId)) {
+                onMessage(event);
+            }
+        });
+        this.userSubscriptions.set(userId, subscription);
+    }
+    /**
+     * @desc Unsubscribes from incoming messages
+     * @param userId - The id of the user
+     */
+    removeUser(userId) {
+        var _a;
+        const userData = this.getUserData(userId);
+        this.removePresence(userId);
+        this.removeAssigns(userId);
+        (_a = this.userSubscriptions.get(userId)) === null || _a === void 0 ? void 0 : _a();
+        this.userSubscriptions.delete(userId);
+        if (this.assignsCache.size === 0) {
+            this.close();
+        }
+        return userData;
+    }
+    /**
+     * @desc Returns the data of a user
+     * @param userId - The id of the user
+     */
+    getUserData(userId) {
+        const presence = this.getPresence(userId);
+        const assigns = this.getAssigns(userId);
+        if (!presence && !assigns) {
+            const message = `User with id ${userId} does not exist in the channel ${this.channelId}`;
+            const code = 404;
+            throw new httpError_1.HttpError(code, message);
+        }
+        return {
+            assigns: assigns || {},
+            presence: presence || {},
+            id: userId,
+        };
+    }
+    /**
+     * @desc Processes presence data
+     * @param action - The action to perform
+     * @param userId - The id of the user
+     * @param data - The presence data
+     */
+    processPresenceData(action, userId, data) {
+        const current = data ? data : this.presenceCache.get(userId);
+        __classPrivateFieldGet(this, _Manager_instances, "m", _Manager_processData).call(this, this.presenceCache, DataTypes.PRESENCE, action, userId, data);
+        const total = Array.from(this.presenceCache.values());
+        const userIds = Array.from(this.presenceCache.keys());
+        const event = action === ActionTypes.CREATE ? pondsocket_common_1.PresenceEventTypes.JOIN : action === ActionTypes.UPDATE ? pondsocket_common_1.PresenceEventTypes.UPDATE : pondsocket_common_1.PresenceEventTypes.LEAVE;
+        return {
+            event,
+            requestId: (0, pondsocket_common_1.uuid)(),
+            recipients: userIds,
+            channelName: this.channelId,
+            action: pondsocket_common_1.ServerActions.PRESENCE,
+            payload: {
+                changed: current,
+                presence: total,
+            },
+        };
+    }
+    /**
+     * @desc Processes assigns data
+     * @param action - The action to perform
+     * @param userId - The id of the user
+     * @param data - The assigns data
+     */
+    processAssignsData(action, userId, data) {
+        __classPrivateFieldGet(this, _Manager_instances, "m", _Manager_processData).call(this, this.assignsCache, DataTypes.ASSIGNS, action, userId, data);
+    }
+}
+exports.Manager = Manager;
+_Manager_onClose = new WeakMap(), _Manager_instances = new WeakSet(), _Manager_processData = function _Manager_processData(cache, dataType, action, userId, data) {
+    if (action === ActionTypes.CREATE && cache.has(userId)) {
+        const message = `User with id ${userId} already exists in the ${dataType} cache`;
+        const code = 409;
+        throw new httpError_1.HttpError(code, message);
+    }
+    else if ((action === ActionTypes.UPDATE || action === ActionTypes.DELETE) && !cache.has(userId)) {
+        const message = `User with id ${userId} does not exist in the ${dataType} cache`;
+        const code = 404;
+        throw new httpError_1.HttpError(code, message);
+    }
+    if (action !== ActionTypes.DELETE && !data) {
+        const message = `Data is required for ${action} action`;
+        const code = 400;
+        throw new httpError_1.HttpError(code, message);
+    }
+    if (data) {
+        cache.set(userId, data);
+    }
+    else {
+        cache.delete(userId);
+    }
+};