@eleven-am/pondsocket 0.1.11 → 0.1.12

package/pondClient/channel.js

@@ -1,167 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Channel = void 0;
-const pondSocket_1 = require("../pondSocket");
-const pondBase_1 = require("../pondBase");
-class Channel {
-    constructor(name, receiver, broadcaster, params) {
-        this._name = name;
-        this._joinParams = params || {};
-        this._broadcaster = broadcaster;
-        this._connection = new pondBase_1.Subject(false);
-        this._receiver = new pondBase_1.Broadcast();
-        this._presence = new pondBase_1.Subject({
-            action: pondBase_1.PondBaseActions.REMOVE_FROM_POND,
-            change: null,
-            presence: []
-        });
-        this._subscription = receiver.subscribe(data => {
-            if (data.channelName === name) {
-                this._receiver.publish(data);
-                this._connection.publish(true);
-            }
-        });
-    }
-    /**
-     * @desc Connects to the channel.
-     */
-    join() {
-        const joinMessage = {
-            action: pondSocket_1.ClientActions.JOIN_CHANNEL,
-            channelName: this._name,
-            event: pondSocket_1.ClientActions.JOIN_CHANNEL,
-            payload: this._joinParams
-        };
-        this._receiver.subscribe(data => {
-            if (data.action === pondSocket_1.ServerActions.PRESENCE) {
-                const event = data.event;
-                const presenceData = data.payload;
-                this._presence.publish({
-                    action: event,
-                    change: presenceData.change,
-                    presence: presenceData.presence
-                });
-            }
-        });
-        this._broadcaster.publish(joinMessage);
-    }
-    /**
-     * @desc Disconnects from the channel.
-     */
-    leave() {
-        const leaveMessage = {
-            action: pondSocket_1.ClientActions.LEAVE_CHANNEL,
-            channelName: this._name,
-            event: pondSocket_1.ClientActions.LEAVE_CHANNEL,
-            payload: {}
-        };
-        this._broadcaster.publish(leaveMessage);
-        this._connection.publish(false);
-        this._subscription.unsubscribe();
-        this._connection.clear();
-        this._receiver.clear();
-        this._presence.clear();
-    }
-    /**
-     * @desc Monitors the channel for messages.
-     * @param event - The event to monitor.
-     * @param callback - The callback to call when a message is received.
-     */
-    onMessage(event, callback) {
-        return this._receiver.subscribe(data => {
-            if (data.action === pondSocket_1.ServerActions.MESSAGE && data.event === event)
-                callback(data.payload);
-        });
-    }
-    /**
-     * @desc Broadcasts a message to the channel, including yourself.
-     * @param event - The event to send.
-     * @param payload - The message to send.
-     */
-    broadcast(event, payload) {
-        const message = {
-            action: pondSocket_1.ClientActions.BROADCAST, channelName: this._name, payload: payload, event: event
-        };
-        this._broadcaster.publish(message);
-    }
-    /**
-     * @desc Broadcasts a message to every other client in the channel except yourself.
-     * @param event - The event to send.
-     * @param payload - The message to send.
-     */
-    broadcastFrom(event, payload) {
-        const message = {
-            action: pondSocket_1.ClientActions.BROADCAST_FROM, channelName: this._name, payload: payload, event: event
-        };
-        this._broadcaster.publish(message);
-    }
-    /**
-     * @desc Sends a message to specific clients in the channel.
-     * @param event - The event to send.
-     * @param payload - The message to send.
-     * @param recipient - The clients to send the message to.
-     */
-    sendMessage(event, payload, recipient) {
-        const message = {
-            action: pondSocket_1.ClientActions.SEND_MESSAGE_TO_USER,
-            channelName: this._name,
-            payload: payload,
-            event: event,
-            addresses: recipient
-        };
-        this._broadcaster.publish(message);
-    }
-    /**
-     * @desc Updates the presence state of the current client in the channel.
-     * @param presence - The presence state to update.
-     */
-    updatePresence(presence) {
-        const message = {
-            action: pondSocket_1.ClientActions.UPDATE_PRESENCE,
-            channelName: this._name,
-            payload: presence,
-            event: pondSocket_1.ClientActions.UPDATE_PRESENCE
-        };
-        this._broadcaster.publish(message);
-    }
-    /**
-     * @desc Detects when clients join the channel.
-     * @param callback - The callback to call when a client joins the channel.
-     */
-    onJoin(callback) {
-        return this._presence.subscribe(data => {
-            if (data.action === pondBase_1.PondBaseActions.ADD_TO_POND)
-                callback(data.change);
-        });
-    }
-    /**
-     * @desc Detects when clients leave the channel.
-     * @param callback - The callback to call when a client leaves the channel.
-     */
-    onLeave(callback) {
-        let presence = [];
-        return this._presence.subscribe(data => {
-            if (data.action === pondBase_1.PondBaseActions.REMOVE_FROM_POND) {
-                const missing = presence.filter(p => !data.presence.find(x => x.id === p.id));
-                missing.forEach(p => callback(p));
-            }
-            presence = data.presence;
-        });
-    }
-    /**
-     * @desc Gets the current presence state of the channel.
-     */
-    get presence() {
-        return this._presence.value.presence;
-    }
-    /**
-     * @desc Monitors the connection state of the channel.
-     * @param callback - The callback to call when the connection state changes.
-     */
-    onConnectionChange(callback) {
-        return this._connection.subscribe(data => {
-            callback(data);
-        });
-    }
-}
-exports.Channel = Channel;

package/pondClient/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./socket";
-export * from "./channel";

package/pondClient/index.js

@@ -1,18 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./socket"), exports);
-__exportStar(require("./channel"), exports);

package/pondClient/socket.d.ts

@@ -1,41 +0,0 @@
-import {Channel, ChannelParams} from "./channel";
-import {PondMessage} from "../pondSocket";
-
-declare type PondParams = {
-    [key: string]: string;
-};
-declare type PondState = "CONNECTING" | "OPEN" | "CLOSING" | "CLOSED";
-
-export declare class PondClient {
-
-    constructor(endpoint: string, params?: PondParams);
-
-    /**
-     * @desc Returns the current state of the socket.
-     */
-    getState(): PondState;
-
-    /**
-     * @desc Connects to the server and returns the socket.
-     */
-    connect(backoff?: number): void;
-
-    /**
-     * @desc Disconnects the socket from the server.
-     */
-    disconnect(): void;
-
-    /**
-     * @desc An event that is triggered when the socket receives a message.
-     * @param event - The event to subscribe to.
-     * @param callback - The callback to be called when the event is triggered.
-     */
-    onMessage(event: string, callback: (message: PondMessage) => void): import("../pondBase").Subscription;
-
-    /**
-     * @desc Creates a channel with the given name and params.
-     * @param name - The name of the channel.
-     * @param params - The params to send to the server.
-     */
-    createChannel(name: string, params?: ChannelParams): Channel;
-}

package/pondSocket/channel.d.ts

@@ -1,129 +0,0 @@
-import {default_t, Subscription} from "../pondBase";
-import {NewUser, PondAssigns, PondChannelData, PondMessage, PondPresence, ServerMessage} from "./types";
-import {PondSenders, ServerActions} from "./enums";
-import {ChannelHandler} from "./channelMiddleWare";
-
-export interface ChannelInfo {
-    name: string;
-    channelData: PondChannelData;
-    presence: PondPresence[];
-    assigns: PondPresence[];
-}
-
-export declare class Channel {
-    readonly name: string;
-
-    /**
-     * @desc Returns the channel info
-     */
-    get info(): Readonly<ChannelInfo>;
-
-    /**
-     * @desc Gets the channel's data
-     */
-    get data(): Readonly<PondChannelData>;
-
-    /**
-     * @desc Sets the channel's data
-     * @param data
-     */
-    set data(data: PondChannelData);
-
-    /**
-     * @desc Gets the channel's presence
-     */
-    get presence(): PondPresence[];
-
-    /**
-     * @desc Gets the channel's assigns
-     */
-    get assigns(): PondAssigns[];
-
-    /**
-     * @desc Gets a user's information
-     * @param clientId - The clientId of the user
-     */
-    getUserInfo(clientId: string): {
-        presence: PondPresence;
-        assigns: PondAssigns;
-    } | null;
-
-    /**
-     * @desc Checks if a user exists in the channel
-     * @param clientId - The clientId of the user
-     */
-    hasUser(clientId: string): boolean;
-
-    /**
-     * @desc Adds a new user to the channel
-     * @param user - The user to add to the channel
-     */
-    addUser(user: NewUser): void;
-
-    /**
-     * @desc Removes a user or group of users from the channel
-     * @param clientIds - The clientIds of the users to remove
-     */
-    removeUser(clientIds: string | string[]): void;
-
-    /**
-     * @desc Subscribes to the presence changes occuring in the channel
-     * @param callback - The callback to call when a presence change occurs
-     */
-    onPresenceChange(callback: (message: ServerMessage) => void): Subscription;
-
-    /**
-     * @desc Subscribes to the message events occuring in the channel
-     * @param callback - The callback to call when a message event occurs
-     */
-    onMessage(callback: ChannelHandler): void;
-
-    /**
-     * @desc Updates the state of a user in the channel
-     * @param clientId - The clientId of the user to update
-     * @param presence - The new presence of the user
-     * @param assigns - The new assigns of the user
-     */
-    updateUser(clientId: string, presence: PondPresence, assigns: PondAssigns): void;
-
-    /**
-     * @desc Broadcasts a message to all users in the channel
-     * @param event - The event name
-     * @param message - The message to send
-     * @param sender - The sender of the message
-     */
-    broadcast(event: string, message: PondMessage, sender?: PondSenders | string): void;
-
-    /**
-     * @desc Broadcasts a message to all users in the channel except the sender
-     * @param event - The event name
-     * @param message - The message to send
-     * @param clientId - The client id of the sender
-     */
-    broadcastFrom(event: string, message: PondMessage, clientId: string): void;
-
-    /**
-     * @desc Sends a message to a specific user or group of users
-     * @param event - The event name
-     * @param clientId - The client id of the user to send the message to
-     * @param message - The message to send
-     * @param sender - The client id of the sender
-     */
-    sendTo(event: string, message: PondMessage, sender: string, clientId: string | string[]): void;
-
-    /**
-     * @desc Subscribes to a channel event, used only by the sockets to subscribe to all events
-     * @param clientId - The client id of the user to send the message to
-     * @param callback - The callback to call when a message is received
-     */
-    subscribeToMessages(clientId: string, callback: (message: ServerMessage) => void): Subscription;
-
-    /**
-     * @desc Sends a message to a specific user without running the middleware
-     * @param event - The event name
-     * @param message - The message to send
-     * @param client - The client id of the user to send the message to
-     * @param action - The action to send
-     */
-    respondToClient(event: string, message: default_t, client: string, action?: ServerActions): void;
-}

package/pondSocket/channel.js

@@ -1,287 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Channel = void 0;
-const pondBase_1 = require("../pondBase");
-const enums_1 = require("./enums");
-const channelMiddleWare_1 = require("./channelMiddleWare");
-class Channel extends pondBase_1.BaseClass {
-    constructor(name, middleWare, removeChannel) {
-        super();
-        this.name = name;
-        this._channelPresence = new pondBase_1.PondBase();
-        this._channelAssigns = new pondBase_1.SimpleBase();
-        this._channelData = {};
-        this._middleWare = new channelMiddleWare_1.ChannelMiddleware();
-        this.removeChannel = removeChannel;
-        this._messages = new pondBase_1.Broadcast();
-        this._middleWare.merge(middleWare);
-    }
-    /**
-     * @desc Returns the channel info
-     */
-    get info() {
-        const data = {
-            name: this.name, channelData: this.data, presence: this.presence, assigns: this.assigns
-        };
-        return Object.freeze(data);
-    }
-    /**
-     * @desc Gets the channel's data
-     */
-    get data() {
-        const result = Object.assign({}, this._channelData);
-        return Object.freeze(result);
-    }
-    /**
-     * @desc Sets the channel's data
-     * @param data
-     */
-    set data(data) {
-        this._channelData = Object.assign(Object.assign({}, this._channelData), data);
-    }
-    /**
-     * @desc Gets the channel's presence
-     */
-    get presence() {
-        return this._channelPresence.map(presence => presence);
-    }
-    /**
-     * @desc Gets the channel's assigns
-     */
-    get assigns() {
-        return this._channelAssigns.map(assigns => assigns);
-    }
-    /**
-     * @desc Gets a user's information
-     * @param clientId - The clientId of the user
-     */
-    getUserInfo(clientId) {
-        const client = this._retrieveUser(clientId);
-        if (!client)
-            return null;
-        return {
-            presence: client.presence.doc, assigns: client.assigns.doc
-        };
-    }
-    /**
-     * @desc Checks if a user exists in the channel
-     * @param clientId - The clientId of the user
-     */
-    hasUser(clientId) {
-        return this._channelPresence.has(clientId);
-    }
-    /**
-     * @desc Adds a new user to the channel
-     * @param user - The user to add to the channel
-     */
-    addUser(user) {
-        const clientId = user.client.clientId;
-        if (this.hasUser(clientId))
-            throw new Error(`User with clientId ${clientId} already exists in channel ${this.name}`);
-        this._channelPresence.set(clientId, Object.assign(Object.assign({}, user.presence), { id: clientId }));
-        this._channelAssigns.set(clientId, user.assigns);
-        this._channelData = Object.assign(Object.assign(Object.assign({}, this._channelData), user.channelData));
-    }
-    /**
-     * @desc Removes a user or group of users from the channel
-     * @param clientIds - The clientIds of the users to remove
-     */
-    removeUser(clientIds) {
-        const clients = Array.isArray(clientIds) ? clientIds : [clientIds];
-        clients.forEach(clientId => {
-            const client = this._retrieveUser(clientId);
-            if (client) {
-                client.presence.removeDoc();
-                client.assigns.removeDoc();
-            }
-        });
-        if (this._channelPresence.size === 0)
-            this.removeChannel();
-    }
-    /**
-     * @desc Subscribes to the presence changes occurring in the channel
-     * @param callback - The callback to call when a presence change occurs
-     */
-    onPresenceChange(callback) {
-        return this._channelPresence.subscribe((docs, change, action) => {
-            const message = {
-                action: enums_1.ServerActions.PRESENCE,
-                payload: { presence: docs, change },
-                event: action,
-                channelName: this.name,
-            };
-            callback(message);
-        });
-    }
-    /**
-     * @desc Subscribes to the message events occurring in the channel
-     * @param callback - The callback to call when a message event occurs
-     */
-    onMessage(callback) {
-        this._middleWare.use(callback);
-    }
-    /**
-     * @desc Updates the state of a user in the channel
-     * @param clientId - The clientId of the user to update
-     * @param presence - The new presence of the user
-     * @param assigns - The new assigns of the user
-     */
-    updateUser(clientId, presence, assigns) {
-        const client = this._retrieveUser(clientId);
-        if (client) {
-            client.assigns.updateDoc(Object.assign(Object.assign({}, client.assigns.doc), assigns));
-            const presenceDoc = Object.assign(Object.assign({}, client.presence.doc), presence);
-            if (!this.areEqual(presenceDoc, client.presence.doc))
-                client.presence.updateDoc(presenceDoc);
-        }
-    }
-    /**
-     * @desc Broadcasts a message to all users in the channel
-     * @param event - The event name
-     * @param message - The message to send
-     * @param sender - The sender of the message
-     */
-    broadcast(event, message, sender = enums_1.PondSenders.POND_CHANNEL) {
-        const client = this._retrieveUser(sender);
-        if (!client && !Object.values(enums_1.PondSenders).includes(sender))
-            throw new Error(`Client with clientId ${sender} does not exist in channel ${this.name}`);
-        const channelEvent = {
-            client: {
-                clientId: sender,
-                clientAssigns: client ? client.assigns.doc : {},
-                clientPresence: client ? client.presence.doc : {}
-            },
-            event: event,
-            payload: message,
-            channel: this,
-        };
-        const newMessage = {
-            action: enums_1.ServerActions.MESSAGE, payload: message, event: event, channelName: this.name,
-        };
-        void this._middleWare.run(channelEvent, hasErrored => {
-            if (!hasErrored)
-                this._sendToClients(this._channelAssigns.keys, newMessage);
-        });
-    }
-    /**
-     * @desc Broadcasts a message to all users in the channel except the sender
-     * @param event - The event name
-     * @param message - The message to send
-     * @param clientId - The client id of the sender
-     */
-    broadcastFrom(event, message, clientId) {
-        const client = this._retrieveUser(clientId);
-        if (!client)
-            throw new Error(`Client with clientId ${clientId} does not exist in channel ${this.name}`);
-        const newMessage = {
-            action: enums_1.ServerActions.MESSAGE, payload: message, event: event, channelName: this.name,
-        };
-        const channelEvent = {
-            client: {
-                clientId: clientId,
-                clientAssigns: client.assigns.doc,
-                clientPresence: client.presence.doc
-            },
-            event: event,
-            payload: message,
-            channel: this,
-        };
-        void this._middleWare.run(channelEvent, hasErrored => {
-            if (!hasErrored) {
-                const clientIds = this._channelAssigns.keys.filter(id => id !== clientId);
-                this._sendToClients(clientIds, newMessage);
-            }
-        });
-    }
-    /**
-     * @desc Sends a message to a specific user or group of users
-     * @param event - The event name
-     * @param clientId - The client id of the user to send the message to
-     * @param message - The message to send
-     * @param sender - The client id of the sender
-     */
-    sendTo(event, message, sender, clientId) {
-        const client = this._retrieveUser(sender);
-        if (!client && !Object.values(enums_1.PondSenders).includes(sender))
-            throw new Error('Client not found');
-        const clientIds = Array.isArray(clientId) ? clientId : [clientId];
-        const notFound = clientIds.filter(id => !this._channelAssigns.has(id));
-        if (notFound.length > 0)
-            throw new Error(`Client(s) with clientId(s) ${notFound.join(', ')} were not found in channel ${this.name}`);
-        const newMessage = {
-            action: enums_1.ServerActions.MESSAGE, payload: message, event: event, channelName: this.name,
-        };
-        const channelEvent = {
-            client: {
-                clientId: sender,
-                clientAssigns: client ? client.assigns.doc : {},
-                clientPresence: client ? client.presence.doc : {}
-            },
-            channel: this,
-            event: event,
-            payload: message,
-        };
-        void this._middleWare.run(channelEvent, hasErrored => {
-            if (!hasErrored)
-                this._sendToClients(clientIds, newMessage);
-        });
-    }
-    /**
-     * @desc Subscribes to a channel event, used only by the sockets to subscribe to all events
-     * @param clientId - The client id of the user to send the message to
-     * @param callback - The callback to call when a message is received
-     */
-    subscribeToMessages(clientId, callback) {
-        const sub1 = this._messages.subscribe(({ clients, message }) => {
-            if (clients.includes(clientId))
-                callback(message);
-        });
-        const sub2 = this.onPresenceChange(callback);
-        return {
-            unsubscribe: () => {
-                sub1.unsubscribe();
-                sub2.unsubscribe();
-            }
-        };
-    }
-    /**
-     * @desc Sends a message to a specific user without running the middleware
-     * @param event - The event name
-     * @param message - The message to send
-     * @param client - The client id of the user to send the message to
-     * @param action - The action to send
-     */
-    respondToClient(event, message, client, action = enums_1.ServerActions.MESSAGE) {
-        const newMessage = {
-            action: action,
-            payload: message, event: event,
-            channelName: this.name,
-        };
-        this._sendToClients([client], newMessage);
-    }
-    /**
-     * @desc Sends a message to a specific user or group of users except the sender
-     * @param clients - The client id of the user to send the message to
-     * @param message - The message to send
-     * @private
-     */
-    _sendToClients(clients, message) {
-        void this._messages.publish({ clients, message });
-    }
-    /**
-     * @desc Retrieves a user from the channel
-     * @param clientId - The client id of the user to retrieve
-     * @private
-     */
-    _retrieveUser(clientId) {
-        const assigns = this._channelAssigns.get(clientId);
-        const presence = this._channelPresence.get(clientId);
-        if (assigns && presence !== null) {
-            return {
-                assigns: assigns, presence: presence,
-            };
-        }
-        return null;
-    }
-}
-exports.Channel = Channel;