@eleven-am/pondsocket 0.1.11 → 0.1.12

package/dist/client/channel.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Channel = void 0;
+const channelEngine_1 = require("../server/channel/channelEngine");
+const endpoint_1 = require("../server/endpoint/endpoint");
+const presenceEngine_1 = require("../server/presence/presenceEngine");
+const subjectUtils_1 = require("../server/utils/subjectUtils");
+class Channel {
+    constructor(publisher, clientState, name, receiver, params = {}) {
+        this._name = name;
+        this._queue = [];
+        this._finished = false;
+        this._joinParams = params;
+        this._publisher = publisher;
+        this._clientState = clientState;
+        this._receiver = new subjectUtils_1.SimpleSubject();
+        this._joinState = new subjectUtils_1.SimpleBehaviorSubject(false);
+        this._presence = new subjectUtils_1.SimpleBehaviorSubject([]);
+        this._presenceSub = this._init();
+    }
+    /**
+     * @desc Connects to the channel.
+     */
+    join() {
+        if (this._finished) {
+            throw new Error('This channel has been closed');
+        }
+        const joinMessage = {
+            action: endpoint_1.ClientActions.JOIN_CHANNEL,
+            channelName: this._name,
+            event: endpoint_1.ClientActions.JOIN_CHANNEL,
+            payload: this._joinParams,
+        };
+        this._publish(joinMessage);
+    }
+    /**
+     * @desc Disconnects from the channel.
+     */
+    leave() {
+        const leaveMessage = {
+            action: endpoint_1.ClientActions.LEAVE_CHANNEL,
+            channelName: this._name,
+            event: endpoint_1.ClientActions.LEAVE_CHANNEL,
+            payload: {},
+        };
+        this._publish(leaveMessage);
+        this._finished = true;
+        this._presenceSub();
+    }
+    /**
+     * @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 === channelEngine_1.ServerActions.BROADCAST && data.event === event && data.channelName === this._name) {
+                return callback(data.payload);
+            }
+        });
+    }
+    /**
+     * @desc Monitors the connection state of the channel.
+     * @param callback - The callback to call when the connection state changes.
+     */
+    onConnectionChange(callback) {
+        return this._joinState.subscribe((data) => {
+            callback(data);
+        });
+    }
+    /**
+     * @desc Detects when clients join the channel.
+     * @param callback - The callback to call when a client joins the channel.
+     */
+    onJoin(callback) {
+        return this._receiver.subscribe((data) => {
+            if (data.action === channelEngine_1.ServerActions.PRESENCE && data.event === presenceEngine_1.PresenceEventTypes.JOIN && data.channelName === this._name) {
+                return callback(data.payload.changed);
+            }
+        });
+    }
+    /**
+     * @desc Detects when clients leave the channel.
+     * @param callback - The callback to call when a client leaves the channel.
+     */
+    onLeave(callback) {
+        return this._receiver.subscribe((data) => {
+            if (data.action === channelEngine_1.ServerActions.PRESENCE && data.event === presenceEngine_1.PresenceEventTypes.LEAVE && data.channelName === this._name) {
+                return callback(data.payload.changed);
+            }
+        });
+    }
+    /**
+     * @desc Detects when clients change their presence in the channel.
+     * @param callback - The callback to call when a client changes their presence in the channel.
+     */
+    onPresenceChange(callback) {
+        return this._receiver.subscribe((data) => {
+            if (data.action === channelEngine_1.ServerActions.PRESENCE && data.event === presenceEngine_1.PresenceEventTypes.UPDATE && data.channelName === this._name) {
+                return callback(data.payload);
+            }
+        });
+    }
+    /**
+     * @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) {
+        this._send(event, payload, recipient);
+    }
+    /**
+     * @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) {
+        this._send(event, payload, 'all_except_sender');
+    }
+    /**
+     * @desc Broadcasts a message to the channel, including yourself.
+     * @param event - The event to send.
+     * @param payload - The message to send.
+     */
+    broadcast(event, payload) {
+        this._send(event, payload);
+    }
+    /**
+     * @desc Gets the current connection state of the channel.
+     */
+    isConnected() {
+        return this._joinState.value;
+    }
+    /**
+     * @desc check is the channel has been closed.
+     */
+    hasClosed() {
+        return this._finished;
+    }
+    /**
+     * @desc Gets the current presence of the channel.
+     */
+    getPresence() {
+        return this._presence.value;
+    }
+    /**
+     * @desc Monitors the presence of the channel.
+     * @param callback - The callback to call when the presence changes.
+     */
+    onUsersChange(callback) {
+        return this._presence.subscribe((data) => {
+            callback(data);
+        });
+    }
+    _send(event, payload, receivers = 'all_users') {
+        const message = {
+            action: endpoint_1.ClientActions.BROADCAST,
+            channelName: this._name,
+            event,
+            payload,
+            addresses: receivers,
+        };
+        this._publish(message);
+    }
+    _publish(data) {
+        if (!this._joinState.value || this._clientState.value !== 'OPEN') {
+            this._queue.push(data);
+            return;
+        }
+        this._publisher(data);
+    }
+    _init() {
+        const unsubStateChange = this._clientState.subscribe((state) => {
+            if (state === 'OPEN') {
+                const joinMessage = {
+                    action: endpoint_1.ClientActions.JOIN_CHANNEL,
+                    channelName: this._name,
+                    event: endpoint_1.ClientActions.JOIN_CHANNEL,
+                    payload: this._joinParams,
+                };
+                this._publisher(joinMessage);
+                this._queue.forEach((message) => {
+                    this._publisher(message);
+                });
+                this._queue = [];
+            }
+        });
+        const unsubPresence = this._receiver.subscribe((data) => {
+            if (data.action === channelEngine_1.ServerActions.PRESENCE && data.channelName === this._name) {
+                this._presence.publish(data.payload.presence);
+            }
+        });
+        return () => {
+            unsubStateChange();
+            unsubPresence();
+        };
+    }
+}
+exports.Channel = Channel;

package/dist/client/index.d.ts

@@ -0,0 +1,122 @@
+// eslint-disable-next-line import/no-unresolved
+import { PondMessage, JoinParams, PondPresence } from '../index';
+export type PondState = 'CONNECTING' | 'OPEN' | 'CLOSING' | 'CLOSED';
+type Unsubscribe = () => void;
+
+export interface PresencePayload {
+    changed: PondPresence;
+    presence: PondPresence[];
+}
+
+export declare class Channel {
+    /**
+     * @desc Connects to the channel.
+     */
+    public join(): void;
+
+    /**
+     * @desc Disconnects from the channel.
+     */
+    public leave(): void;
+
+    /**
+     * @desc Monitors the channel for messages.
+     * @param event - The event to monitor.
+     * @param callback - The callback to call when a message is received.
+     */
+    public onMessage(event: string, callback: (message: PondMessage) => void): Unsubscribe;
+
+    /**
+     * @desc Monitors the connection state of the channel.
+     * @param callback - The callback to call when the connection state changes.
+     */
+    public onConnectionChange(callback: (connected: boolean) => void): Unsubscribe;
+
+    /**
+     * @desc Detects when clients join the channel.
+     * @param callback - The callback to call when a client joins the channel.
+     */
+    public onJoin(callback: (presence: PondPresence) => void): Unsubscribe;
+
+    /**
+     * @desc Detects when clients leave the channel.
+     * @param callback - The callback to call when a client leaves the channel.
+     */
+    public onLeave(callback: (presence: PondPresence) => void): Unsubscribe;
+
+    /**
+     * @desc Detects when clients change their presence in the channel.
+     * @param callback - The callback to call when a client changes their presence in the channel.
+     */
+    public onPresenceChange(callback: (presence: PresencePayload) => void): Unsubscribe;
+
+    /**
+     * @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.
+     */
+    public sendMessage(event: string, payload: PondMessage, recipient: string[]): void;
+
+    /**
+     * @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.
+     */
+    public broadcastFrom(event: string, payload: PondMessage): void;
+
+    /**
+     * @desc Broadcasts a message to the channel, including yourself.
+     * @param event - The event to send.
+     * @param payload - The message to send.
+     */
+    public broadcast(event: string, payload: PondMessage): void;
+
+    /**
+     * @desc Gets the current connection state of the channel.
+     */
+    public isConnected(): boolean;
+
+
+    /**
+     * @desc check is the channel has been closed.
+     */
+    public hasClosed(): boolean;
+
+    /**
+     * @desc Gets the current presence of the channel.
+     */
+    public getPresence(): PondPresence[];
+
+    /**
+     * @desc Monitors the presence of the channel.
+     * @param callback - The callback to call when the presence changes.
+     */
+    public onUsersChange(callback: (users: PondPresence[]) => void): Unsubscribe;
+}
+
+export default class PondClient {
+    constructor(endpoint: string, params?: Record<string, any>);
+
+    /**
+     * @desc Connects to the server and returns the socket.
+     */
+    public connect(backoff?: number): void;
+
+    /**
+     * @desc Returns the current state of the socket.
+     */
+    public getState(): PondState;
+
+    /**
+     * @desc Disconnects the socket.
+     */
+    public disconnect(): void;
+
+    /**
+     * @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.
+     */
+    public createChannel(name: string, params?: JoinParams): Channel;
+}

package/{pondClient/socket.js → dist/client/index.js}

@@ -1,11 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PondClient = void 0;
 const channel_1 = require("./channel");
-const pondSocket_1 = require("../pondSocket");
-const pondBase_1 = require("../pondBase");
+const subjectUtils_1 = require("../server/utils/subjectUtils");
 class PondClient {
-    constructor(endpoint, params) {
+    constructor(endpoint, params = {}) {
         let address;
         try {
             address = new URL(endpoint);
@@ -16,43 +14,29 @@ class PondClient {
         }
         const query = new URLSearchParams(params);
         address.search = query.toString();
-        const protocol = address.protocol === "https:" ? "wss:" : "ws:";
-        if (address.protocol !== "wss:" && address.protocol !== "ws:")
+        const protocol = address.protocol === 'https:' ? 'wss:' : 'ws:';
+        if (address.protocol !== 'wss:' && address.protocol !== 'ws:') {
             address.protocol = protocol;
+        }
         this.address = address;
-        this._socketState = "CLOSED";
         this._channels = {};
-        this._broadcaster = new pondBase_1.Broadcast();
-        this._receiver = new pondBase_1.Broadcast();
-    }
-    /**
-     * @desc Returns the current state of the socket.
-     */
-    getState() {
-        return this._socketState;
+        this._broadcaster = new subjectUtils_1.SimpleSubject();
+        this._connectionState = new subjectUtils_1.SimpleBehaviorSubject('CLOSED');
     }
     /**
      * @desc Connects to the server and returns the socket.
      */
     connect(backoff = 1) {
         const socket = new WebSocket(this.address.toString());
-        const sub = this._receiver.subscribe((message) => {
-            socket.send(JSON.stringify(message));
-        });
         socket.onopen = () => {
-            this._socketState = "OPEN";
-        };
-        socket.onclose = () => {
-            this._socketState = "CLOSED";
-            sub.unsubscribe();
+            this._connectionState.publish('OPEN');
         };
         socket.onmessage = (message) => {
             const data = JSON.parse(message.data);
             this._broadcaster.publish(data);
         };
         socket.onerror = () => {
-            this._socketState = "CLOSED";
-            sub.unsubscribe();
+            this._connectionState.publish('CLOSED');
             setTimeout(() => {
                 this.connect(backoff * 2);
             }, backoff * 1000);
@@ -60,39 +44,41 @@ class PondClient {
         this._socket = socket;
     }
     /**
-     * @desc Disconnects the socket from the server.
+     * @desc Returns the current state of the socket.
+     */
+    getState() {
+        return this._connectionState.value;
+    }
+    /**
+     * @desc Disconnects the socket.
      */
     disconnect() {
         var _a;
-        Object.values(this._channels).forEach(channel => channel.leave());
-        this._socketState = "CLOSED";
-        this._broadcaster.clear();
-        this._receiver.clear();
+        Object.values(this._channels).forEach((channel) => channel.leave());
         (_a = this._socket) === null || _a === void 0 ? void 0 : _a.close();
         this._channels = {};
     }
-    /**
-     * @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, callback) {
-        return this._broadcaster.subscribe(data => {
-            if (data.action === pondSocket_1.ServerActions.MESSAGE && data.event === event)
-                callback(data.payload);
-        });
-    }
     /**
      * @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, params) {
-        if (this._channels[name])
+        if (this._channels[name] && !this._channels[name].hasClosed()) {
             return this._channels[name];
-        const channel = new channel_1.Channel(name, this._broadcaster, this._receiver, params);
+        }
+        const publisher = this._createPublisher();
+        const channel = new channel_1.Channel(publisher, this._connectionState, name, this._broadcaster, params);
         this._channels[name] = channel;
         return channel;
     }
+    _createPublisher() {
+        return (message) => {
+            var _a;
+            if (((_a = this._socket) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN) {
+                this._socket.send(JSON.stringify(message));
+            }
+        };
+    }
 }
-exports.PondClient = PondClient;
+exports.default = PondClient;

package/dist/express/index.d.ts

@@ -0,0 +1,36 @@
+/* eslint-disable import/no-unresolved */
+import { Express } from 'express';
+
+import { EndpointHandler, Endpoint, PondPath } from '../index';
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+interface PondSocketExpressApp extends Express {
+
+    /**
+     * @desc Accepts a new socket upgrade request on the provided endpoint using the handler function to authenticate the socket
+     * @param path - the pattern to accept || can also be a regex
+     * @param handler - the handler function to authenticate the socket
+     * @example
+     * const endpoint = pond.createEndpoint('/api/socket', (req, res) => {
+     *    const token = req.query.token;
+     *    if (!token)
+     *       return res.reject("No token provided");
+     *    res.accept({
+     *       assign: {
+     *           token
+     *       }
+     *    });
+     * })
+     */
+    upgrade(path: PondPath, handler: EndpointHandler): Endpoint;
+}
+
+/**
+ * @desc Creates a pond socket server
+ * @param app - The Express app to be used by the server
+ * @constructor
+ */
+declare const PondSocket: (app: Express) => PondSocketExpressApp;
+
+export default PondSocket;

package/dist/express/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const http_1 = require("http");
+const pondSocket_1 = require("../server/server/pondSocket");
+/**
+ * @desc Creates a pond socket server
+ * @param app - The Express app to be used by the server
+ * @constructor
+ */
+const PondSocket = (app) => {
+    const server = (0, http_1.createServer)(app);
+    const pondSocket = new pondSocket_1.PondSocket(server);
+    app.upgrade = (path, handler) => pondSocket.createEndpoint(path, handler);
+    return app;
+};
+exports.default = PondSocket;