@eleven-am/pondsocket 0.1.162 → 0.1.164

package/endpoint/endpoint.js

@@ -55,7 +55,7 @@ class EndpointEngine {
      * });
      */
     createChannel(path, handler) {
-        const pondChannel = new lobby_1.LobbyEngine(this);
+        const pondChannel = new lobby_1.LobbyEngine(this, path);
         __classPrivateFieldGet(this, _EndpointEngine_middleware, "f").use((user, joinParams, next) => {
             const event = (0, matcher_1.parseAddress)(path, user.channelName);
             if (event) {

package/lobby/lobby.js

@@ -10,20 +10,26 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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_channels, _LobbyEngine_middleware, _LobbyEngine_leaveCallback, _LobbyEngine_parentEngine, _PondChannel_lobby;
+var _LobbyEngine_instances, _LobbyEngine_channels, _LobbyEngine_middleware, _LobbyEngine_leaveCallback, _LobbyEngine_parentEngine, _LobbyEngine_path, _LobbyEngine_performAction, _PondChannel_lobby;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PondChannel = exports.LobbyEngine = void 0;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
 const middleware_1 = require("../abstracts/middleware");
 const channel_1 = require("../channel/channel");
+const pondError_1 = require("../errors/pondError");
+const matcher_1 = require("../matcher/matcher");
 class LobbyEngine {
-    constructor(endpointEngine) {
+    constructor(endpointEngine, path) {
+        _LobbyEngine_instances.add(this);
         _LobbyEngine_channels.set(this, void 0);
         _LobbyEngine_middleware.set(this, void 0);
         _LobbyEngine_leaveCallback.set(this, void 0);
         _LobbyEngine_parentEngine.set(this, void 0);
+        _LobbyEngine_path.set(this, void 0);
         __classPrivateFieldSet(this, _LobbyEngine_parentEngine, endpointEngine, "f");
         __classPrivateFieldSet(this, _LobbyEngine_channels, new Set(), "f");
         __classPrivateFieldSet(this, _LobbyEngine_middleware, new middleware_1.Middleware(), "f");
+        __classPrivateFieldSet(this, _LobbyEngine_path, path, "f");
     }
     /**
      * @desc The parent engine
@@ -99,9 +105,55 @@ class LobbyEngine {
         __classPrivateFieldGet(this, _LobbyEngine_channels, "f").add(newChannel);
         return newChannel;
     }
+    /**
+     * @desc Sends a message to all clients in the channel
+     * @param channelName - the name of the channel to send the message to
+     * @param event - the event to send
+     * @param payload - the payload to send
+     */
+    broadcast(channelName, event, payload) {
+        __classPrivateFieldGet(this, _LobbyEngine_instances, "m", _LobbyEngine_performAction).call(this, channelName, (channel) => {
+            channel.sendMessage(pondsocket_common_1.SystemSender.CHANNEL, pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
+        });
+    }
+    /**
+     * @desc Sends a message to all clients in the channel except the client making the request
+     * @param channelName - the name of the channel to send the message to
+     * @param event - the event to send
+     * @param payload - the payload to send
+     */
+    broadcastFrom(channelName, event, payload) {
+        __classPrivateFieldGet(this, _LobbyEngine_instances, "m", _LobbyEngine_performAction).call(this, channelName, (channel) => {
+            channel.sendMessage(pondsocket_common_1.SystemSender.CHANNEL, pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
+        });
+    }
+    /**
+     * @desc Sends a message to a set of clients in the channel
+     * @param channelName - the name of the channel to send the message to
+     * @param event - the event to send
+     * @param payload - the payload to send
+     * @param userIds - the ids of the clients to send the message to
+     */
+    broadcastTo(channelName, event, payload, userIds) {
+        const ids = Array.isArray(userIds) ? userIds : [userIds];
+        __classPrivateFieldGet(this, _LobbyEngine_instances, "m", _LobbyEngine_performAction).call(this, channelName, (channel) => {
+            channel.sendMessage(pondsocket_common_1.SystemSender.CHANNEL, ids, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
+        });
+    }
 }
 exports.LobbyEngine = LobbyEngine;
-_LobbyEngine_channels = new WeakMap(), _LobbyEngine_middleware = new WeakMap(), _LobbyEngine_leaveCallback = new WeakMap(), _LobbyEngine_parentEngine = new WeakMap();
+_LobbyEngine_channels = new WeakMap(), _LobbyEngine_middleware = new WeakMap(), _LobbyEngine_leaveCallback = new WeakMap(), _LobbyEngine_parentEngine = new WeakMap(), _LobbyEngine_path = new WeakMap(), _LobbyEngine_instances = new WeakSet(), _LobbyEngine_performAction = function _LobbyEngine_performAction(channelName, handler) {
+    const matches = (0, matcher_1.parseAddress)(__classPrivateFieldGet(this, _LobbyEngine_path, "f"), channelName);
+    if (matches === null) {
+        throw new pondError_1.EndpointError('Invalid channel name', 402);
+    }
+    const channel = this.getChannel(channelName) || this.createChannel(channelName);
+    const assigns = channel.getAssigns();
+    handler(channel);
+    if (Object.keys(assigns).length === 0) {
+        this.destroyChannel(channelName);
+    }
+};
 class PondChannel {
     constructor(lobby) {
         _PondChannel_lobby.set(this, void 0);
@@ -120,6 +172,15 @@ class PondChannel {
         }
         return null;
     }
+    broadcast(channelName, event, payload) {
+        __classPrivateFieldGet(this, _PondChannel_lobby, "f").broadcast(channelName, event, payload);
+    }
+    broadcastFrom(channelName, event, payload) {
+        __classPrivateFieldGet(this, _PondChannel_lobby, "f").broadcastFrom(channelName, event, payload);
+    }
+    broadcastTo(channelName, event, payload, userIds) {
+        __classPrivateFieldGet(this, _PondChannel_lobby, "f").broadcastTo(channelName, event, payload, userIds);
+    }
 }
 exports.PondChannel = PondChannel;
 _PondChannel_lobby = new WeakMap();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket",
-  "version": "0.1.162",
+  "version": "0.1.164",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",

package/types.d.ts

@@ -54,7 +54,7 @@ export declare class PondSocket {
      * const endpoint = pond.createEndpoint('/api/socket', (req, res) => {
      *    const token = req.query.token;
      *    if (!token)
-     *       return res.reject('No token provided');
+     *       return res.decline('No token provided');
      *    res.accept({
      *       assign: {
      *           token
@@ -78,7 +78,7 @@ export declare class Endpoint {
      *         response.accept();
      *
      *     else
-     *         response.reject('You are not an admin', 403);
+     *         response.decline('You are not an admin', 403);
      * });
      */
     createChannel<Path extends string, EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns>(path: PondPath<Path>, handler: RequestHandler<JoinRequest<Path, PresenceType, AssignType>, JoinResponse<EventType, PresenceType, AssignType>>): PondChannel<EventType, PresenceType, AssignType>;
@@ -117,20 +117,6 @@ export declare class PondChannel<EventType extends PondEventMap = PondEventMap,
      */
     onEvent<Event extends string>(event: PondPath<Event>, handler: RequestHandler<EventRequest<Event, PresenceType, AssignType>, EventResponse<EventType, PresenceType, AssignType>>): void;
 
-    /**
-     * @desc Broadcasts a message to all users in a channel
-     * @param event - The event to broadcast
-     * @param payload - The payload to send
-     * @param channelName - The channel to broadcast to (if not specified, broadcast to all channels)
-     * @example
-     * pond.broadcast('echo', {
-     *    message: 'Hello World',
-     *    timestamp: Date.now(),
-     *    channel: 'my_channel',
-     *});
-     */
-    broadcast<Key extends keyof EventType>(event: Key, payload: EventType[Key], channelName?: string): void;
-
     /**
      * @desc Handles the leave event for a user, can occur when a user disconnects or leaves a channel, use this to clean up any resources
      * @param {LeaveCallback} callback - The callback to execute when a user leaves
@@ -147,8 +133,53 @@ export declare class PondChannel<EventType extends PondEventMap = PondEventMap,
      * @returns {Channel} - The channel instance
      * @example
      * const channel = pond.getChannel('my_channel')!;
+     *
+     * if (channel === null) {
+     *    console.log('Channel not found');
+     *    return;
+     * }
      */
     getChannel(channelName: string): Channel<EventType, PresenceType, AssignType> | null;
+
+    /**
+     * Broadcasts a message to all clients in the channel
+     * @param channelName - The name of the channel to broadcast to
+     * @param event - The event to send
+     * @param payload - The payload to send
+     * @example
+     *
+     * pond.broadcast('my_channel', 'message', {
+     *     text: 'Hello, world!'
+     * });
+     */
+    broadcast <Key extends keyof EventType>(channelName: string, event: Key, payload: EventType[Key]): void;
+
+    /**
+     * Broadcasts a message to all clients in the channel except the sender
+     * @param channelName - The name of the channel to broadcast to
+     * @param event - The event to send
+     * @param payload - The payload to send
+     * @example
+     *
+     * pond.broadcastFrom('my_channel', 'message', {
+     *     text: 'Hello, everyone but me!'
+     * });
+     */
+    broadcastFrom <Key extends keyof EventType> (channelName: string, event: Key, payload: EventType[Key]): void
+
+    /**
+     * Broadcasts a message to a specific set of clients
+     * @param channelName - The name of the channel to broadcast to
+     * @param event - The event to send
+     * @param payload - The payload to send
+     * @param userIds - The ids of the clients to send the message to
+     * @example
+     *
+     * pond.broadcastTo('my_channel', 'message', {
+     *    text: 'Hello, specific people!'
+     * }, ['user1', 'user2']);
+     */
+    broadcastTo <Key extends keyof EventType> (channelName: string, event: Key, payload: EventType[Key], userIds: string | string[]): void;
 }
 
 export declare class Channel<EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {