@eleven-am/pondsocket 0.1.8 → 0.1.9

package/pondClient/channel.d.ts

@@ -1,34 +1,28 @@
-import {Subscription} from "rxjs";
-import {PondAssigns, PondMessage, PondPresence} from "../pondSocket";
+import {ClientMessage, PondAssigns, PondMessage, PondPresence, ServerMessage} from "../pondSocket";
+import {Broadcast, Subscription} from "../pondBase";
 
 export declare type ChannelParams = PondAssigns;
 
 export declare class Channel {
-    readonly channel: string;
 
-    get isActive(): boolean;
+    constructor(name: string, receiver: Broadcast<ServerMessage, void>, broadcaster: Broadcast<ClientMessage, void>, params?: ChannelParams);
 
     /**
      * @desc Connects to the channel.
      */
-    join(): this;
+    join(): void;
 
     /**
      * @desc Disconnects from the channel.
      */
     leave(): void;
 
-    /**
-     * @desc Monitors the presence state of the channel.
-     * @param callback - The callback to call when the presence state changes.
-     */
-    onPresenceUpdate(callback: (presence: PondPresence[]) => void): Subscription;
-
     /**
      * @desc Monitors the channel for messages.
+     * @param event - The event to monitor.
      * @param callback - The callback to call when a message is received.
      */
-    onMessage(callback: (event: string, message: PondMessage) => void): Subscription;
+    onMessage(event: string, callback: (message: PondMessage) => void): Subscription;
 
     /**
      * @desc Broadcasts a message to the channel, including yourself.
@@ -44,6 +38,14 @@ export declare class Channel {
      */
     broadcastFrom(event: string, payload: PondMessage): void;
 
+    /**
+     * @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: string, payload: PondMessage, recipient: string[]): void;
+
     /**
      * @desc Updates the presence state of the current client in the channel.
      * @param presence - The presence state to update.
@@ -51,16 +53,14 @@ export declare class Channel {
     updatePresence(presence: PondPresence): void;
 
     /**
-     * @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.
+     * @desc Monitors the presence state of the channel.
+     * @param callback - The callback to call when the presence state changes.
      */
-    sendMessage(event: string, payload: PondMessage, recipient: string[]): void;
+    onPresence(callback: (change: PondPresence | null, presence: PondPresence[]) => void): Subscription;
 
     /**
-     * @desc Listens for the connections state of the channel.
+     * @desc Monitors the connection state of the channel.
      * @param callback - The callback to call when the connection state changes.
      */
-    onConnectionChange(callback: (connected: boolean) => void): import("../pondBase").Subscription;
+    onConnectionChange(callback: (connected: boolean) => void): Subscription;
 }

package/pondClient/channel.js

@@ -1,77 +1,72 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Channel = void 0;
-var rxjs_1 = require("rxjs");
-var operators_1 = require("rxjs/operators");
 var pondSocket_1 = require("../pondSocket");
 var pondBase_1 = require("../pondBase");
 var Channel = /** @class */ (function () {
-    function Channel(channel, params, socket) {
-        this._subscriptions = [];
-        this._presenceSubject = new rxjs_1.Subject();
-        this.channel = channel;
-        this._params = params;
-        this._socket = socket;
-        this._subject = new rxjs_1.Subject();
-        this._connectedSubject = new pondBase_1.Subject(false);
+    function Channel(name, receiver, broadcaster, params) {
+        var _this = this;
+        this._name = name;
+        this._joinParams = params || {};
+        this._broadcaster = broadcaster;
+        this._connection = new pondBase_1.Subject(false);
+        this._receiver = new pondBase_1.Broadcast();
+        this._subscription = receiver.subscribe(function (data) {
+            if (data.channelName === name) {
+                _this._receiver.publish(data);
+                _this._connection.publish(true);
+            }
+        });
+        this._presence = new pondBase_1.Subject({
+            change: null,
+            presence: []
+        });
     }
-    Object.defineProperty(Channel.prototype, "isActive", {
-        get: function () {
-            return this._connectedSubject.value;
-        },
-        enumerable: false,
-        configurable: true
-    });
     /**
      * @desc Connects to the channel.
      */
     Channel.prototype.join = function () {
         var _this = this;
-        if (this._connectedSubject.value)
-            return this;
-        var observable = this._init();
-        var subscription = observable
-            .subscribe(function (message) {
-            _this._connectedSubject.publish(true);
-            if (message.action === "PRESENCE")
-                _this._presenceSubject.next(message.payload.presence);
-            else if (message.action === "MESSAGE")
-                _this._subject.next(message);
-            else if (message.event === "KICKED_FROM_CHANNEL")
-                _this.leave();
+        var joinMessage = {
+            action: pondSocket_1.ClientActions.JOIN_CHANNEL,
+            channelName: this._name,
+            event: pondSocket_1.ClientActions.JOIN_CHANNEL,
+            payload: this._joinParams
+        };
+        this._receiver.subscribe(function (data) {
+            if (data.action === pondSocket_1.ServerActions.PRESENCE) {
+                _this._presence.publish(data.payload);
+            }
         });
-        this._subscriptions.push(subscription);
-        return this;
+        this._broadcaster.publish(joinMessage);
     };
     /**
      * @desc Disconnects from the channel.
      */
     Channel.prototype.leave = function () {
-        void this._connectedSubject.publish(false);
-        this._presenceSubject.complete();
-        this._subscriptions.forEach(function (subscription) { return subscription.unsubscribe(); });
-        this._subscriptions = [];
-        this._subject.complete();
-    };
-    /**
-     * @desc Monitors the presence state of the channel.
-     * @param callback - The callback to call when the presence state changes.
-     */
-    Channel.prototype.onPresenceUpdate = function (callback) {
-        var sub = this._presenceSubject.subscribe(callback);
-        this._subscriptions.push(sub);
-        return sub;
+        var 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.
      */
-    Channel.prototype.onMessage = function (callback) {
-        var sub = this._subject
-            .pipe((0, operators_1.filter)(function (message) { return message.action === "MESSAGE"; }))
-            .subscribe(function (message) { return callback(message.event, message.payload); });
-        this._subscriptions.push(sub);
-        return sub;
+    Channel.prototype.onMessage = function (event, callback) {
+        return this._receiver.subscribe(function (data) {
+            if (data.action === pondSocket_1.ServerActions.MESSAGE && data.event === event)
+                callback(data.payload);
+        });
     };
     /**
      * @desc Broadcasts a message to the channel, including yourself.
@@ -80,12 +75,9 @@ var Channel = /** @class */ (function () {
      */
     Channel.prototype.broadcast = function (event, payload) {
         var message = {
-            channelName: this.channel,
-            payload: payload,
-            event: event,
-            action: pondSocket_1.ClientActions.BROADCAST
+            action: pondSocket_1.ClientActions.BROADCAST, channelName: this._name, payload: payload, event: event
         };
-        this._socket.next(message);
+        this._broadcaster.publish(message);
     };
     /**
      * @desc Broadcasts a message to every other client in the channel except yourself.
@@ -94,24 +86,9 @@ var Channel = /** @class */ (function () {
      */
     Channel.prototype.broadcastFrom = function (event, payload) {
         var message = {
-            channelName: this.channel,
-            payload: payload,
-            event: event,
-            action: pondSocket_1.ClientActions.BROADCAST_FROM
+            action: pondSocket_1.ClientActions.BROADCAST_FROM, channelName: this._name, payload: payload, event: event
         };
-        this._socket.next(message);
-    };
-    /**
-     * @desc Updates the presence state of the current client in the channel.
-     * @param presence - The presence state to update.
-     */
-    Channel.prototype.updatePresence = function (presence) {
-        this._socket.next({
-            action: pondSocket_1.ClientActions.UPDATE_PRESENCE,
-            channelName: this.channel,
-            event: "PRESENCE",
-            payload: presence
-        });
+        this._broadcaster.publish(message);
     };
     /**
      * @desc Sends a message to specific clients in the channel.
@@ -120,43 +97,45 @@ var Channel = /** @class */ (function () {
      * @param recipient - The clients to send the message to.
      */
     Channel.prototype.sendMessage = function (event, payload, recipient) {
-        var addresses = Array.isArray(recipient) ? recipient : [recipient];
         var message = {
-            channelName: this.channel,
+            action: pondSocket_1.ClientActions.SEND_MESSAGE_TO_USER,
+            channelName: this._name,
             payload: payload,
             event: event,
-            addresses: addresses,
-            action: pondSocket_1.ClientActions.SEND_MESSAGE_TO_USER
+            addresses: recipient
         };
-        this._socket.next(message);
+        this._broadcaster.publish(message);
     };
     /**
-     * @desc Listens for the connections state of the channel.
-     * @param callback - The callback to call when the connection state changes.
+     * @desc Updates the presence state of the current client in the channel.
+     * @param presence - The presence state to update.
      */
-    Channel.prototype.onConnectionChange = function (callback) {
-        var sub = this._connectedSubject.subscribe(callback);
-        this._subscriptions.push(sub);
-        return sub;
+    Channel.prototype.updatePresence = function (presence) {
+        var message = {
+            action: pondSocket_1.ClientActions.UPDATE_PRESENCE,
+            channelName: this._name,
+            payload: presence,
+            event: pondSocket_1.ClientActions.UPDATE_PRESENCE
+        };
+        this._broadcaster.publish(message);
     };
     /**
-     * @desc Initializes the channel.
-     * @private
+     * @desc Monitors the presence state of the channel.
+     * @param callback - The callback to call when the presence state changes.
      */
-    Channel.prototype._init = function () {
-        var _this = this;
-        var observable = this._socket.multiplex(function () { return ({
-            action: "JOIN_CHANNEL",
-            channelName: _this.channel,
-            event: "JOIN_CHANNEL",
-            payload: _this._params
-        }); }, function () { return ({
-            action: "LEAVE_CHANNEL",
-            channelName: _this.channel,
-            event: "LEAVE_CHANNEL",
-            payload: _this._params
-        }); }, function (message) { return message.channelName === _this.channel; });
-        return observable;
+    Channel.prototype.onPresence = function (callback) {
+        return this._presence.subscribe(function (data) {
+            callback(data.change, data.presence);
+        });
+    };
+    /**
+     * @desc Monitors the connection state of the channel.
+     * @param callback - The callback to call when the connection state changes.
+     */
+    Channel.prototype.onConnectionChange = function (callback) {
+        return this._connection.subscribe(function (data) {
+            callback(data);
+        });
     };
     return Channel;
 }());

package/pondClient/socket.d.ts

@@ -1,5 +1,5 @@
 import {Channel, ChannelParams} from "./channel";
-import {default_t} from "../pondBase";
+import {PondMessage} from "../pondSocket";
 
 declare type PondParams = {
     [key: string]: string;
@@ -11,32 +11,31 @@ export declare class PondClient {
     constructor(endpoint: string, params?: PondParams);
 
     /**
-     * @desc Connects to the server and returns the socket.
+     * @desc Returns the current state of the socket.
      */
-    connect(): this | undefined;
+    getState(): PondState;
 
     /**
-     * @desc Returns the current state of the socket.
+     * @desc Connects to the server and returns the socket.
      */
-    getState(): PondState;
+    connect(backoff?: number): void;
 
     /**
-     * @desc Creates a channel with the given name and params.
-     * @param channel - The name of the channel.
-     * @param params - The params to send to the server.
+     * @desc Disconnects the socket from the server.
      */
-    createChannel(channel: string, params?: ChannelParams): Channel;
+    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(callback: (event: string, message: default_t) => void): void;
+    onMessage(event: string, callback: (message: PondMessage) => void): import("../pondBase").Subscription;
 
     /**
-     * @desc Disconnects the socket from the server.
+     * @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.
      */
-    disconnect(): void;
+    createChannel(name: string, params?: ChannelParams): Channel;
 }
-
-export {};

package/pondClient/socket.js

@@ -1,47 +1,11 @@
 "use strict";
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PondClient = void 0;
-var webSocket_1 = require("rxjs/webSocket");
-var rxjs_1 = require("rxjs");
 var channel_1 = require("./channel");
-var operators_1 = require("rxjs/operators");
 var pondBase_1 = require("../pondBase");
+var pondSocket_1 = require("../pondSocket");
 var PondClient = /** @class */ (function () {
     function PondClient(endpoint, params) {
-        this.socketState = "CLOSED";
-        /**
-         * @desc A retry strategy for the socket.
-         * @param maxTries - The maximum number of retries.
-         * @param ms - The number of milliseconds to wait before retrying.
-         */
-        this._retryStrategy = function (maxTries, ms) {
-            return (0, rxjs_1.pipe)((0, operators_1.retryWhen)(function (attempts) {
-                var observableForRetries = (0, rxjs_1.zip)((0, rxjs_1.range)(1, maxTries), attempts)
-                    .pipe((0, operators_1.map)(function (_a) {
-                    var _b = __read(_a, 1), elemFromRange = _b[0];
-                    return elemFromRange;
-                }), (0, operators_1.map)(function (i) { return i * i; }), (0, rxjs_1.switchMap)(function (i) { return (0, rxjs_1.timer)(i * ms); }));
-                var observableForFailure = (0, rxjs_1.throwError)(new Error("Could not connect to server"))
-                    .pipe((0, rxjs_1.materialize)(), (0, rxjs_1.delay)(1000), (0, rxjs_1.dematerialize)());
-                return (0, rxjs_1.concat)(observableForRetries, observableForFailure);
-            }));
-        };
         var address;
         try {
             address = new URL(endpoint);
@@ -56,76 +20,81 @@ var PondClient = /** @class */ (function () {
         if (address.protocol !== "wss:" && address.protocol !== "ws:")
             address.protocol = protocol;
         this.address = address;
-        this.channels = new pondBase_1.PondBase();
+        this._socketState = "CLOSED";
+        this._channels = {};
+        this._broadcaster = new pondBase_1.Broadcast();
+        this._receiver = new pondBase_1.Broadcast();
     }
-    /**
-     * @desc Connects to the server and returns the socket.
-     */
-    PondClient.prototype.connect = function () {
-        var _this = this;
-        if (this.socketState !== "CLOSED")
-            return;
-        this.socketState = "CONNECTING";
-        var socket = (0, webSocket_1.webSocket)({
-            url: this.address.toString(),
-            openObserver: {
-                next: function () {
-                    _this.socketState = "OPEN";
-                }
-            },
-            closeObserver: {
-                next: function () {
-                    _this.socketState = "CLOSED";
-                }
-            },
-            closingObserver: {
-                next: function () {
-                    _this.socketState = "CLOSING";
-                }
-            }
-        });
-        this.socket = socket;
-        this.subscription = socket.pipe(this._retryStrategy(100, 1000)).subscribe();
-        return this;
-    };
     /**
      * @desc Returns the current state of the socket.
      */
     PondClient.prototype.getState = function () {
-        return this.socketState;
+        return this._socketState;
     };
     /**
-     * @desc Creates a channel with the given name and params.
-     * @param channel - The name of the channel.
-     * @param params - The params to send to the server.
+     * @desc Connects to the server and returns the socket.
      */
-    PondClient.prototype.createChannel = function (channel, params) {
+    PondClient.prototype.connect = function (backoff) {
         var _this = this;
-        return this.channels.getOrCreate(channel, function () {
-            return new channel_1.Channel(channel, params || {}, _this.socket);
-        }).doc;
+        if (backoff === void 0) { backoff = 1; }
+        var socket = new WebSocket(this.address.toString());
+        var sub = this._receiver.subscribe(function (message) {
+            socket.send(JSON.stringify(message));
+        });
+        socket.onopen = function () {
+            _this._socketState = "OPEN";
+        };
+        socket.onclose = function () {
+            _this._socketState = "CLOSED";
+            sub.unsubscribe();
+        };
+        socket.onmessage = function (message) {
+            var data = JSON.parse(message.data);
+            _this._broadcaster.publish(data);
+        };
+        socket.onerror = function () {
+            _this._socketState = "CLOSED";
+            sub.unsubscribe();
+            setTimeout(function () {
+                _this.connect(backoff * 2);
+            }, backoff * 1000);
+        };
+        this._socket = socket;
+    };
+    /**
+     * @desc Disconnects the socket from the server.
+     */
+    PondClient.prototype.disconnect = function () {
+        var _a;
+        Object.values(this._channels).forEach(function (channel) { return channel.leave(); });
+        this._socketState = "CLOSED";
+        this._broadcaster.clear();
+        this._receiver.clear();
+        (_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.
      */
-    PondClient.prototype.onMessage = function (callback) {
-        var _a;
-        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.subscribe(function (data) {
-            if (data.event)
-                callback(data.event, data.payload);
+    PondClient.prototype.onMessage = function (event, callback) {
+        return this._broadcaster.subscribe(function (data) {
+            if (data.action === pondSocket_1.ServerActions.MESSAGE && data.event === event)
+                callback(data.payload);
         });
     };
     /**
-     * @desc Disconnects the socket from the server.
+     * @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.
      */
-    PondClient.prototype.disconnect = function () {
-        var _a, _b, _c;
-        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.complete();
-        (_b = this.socket) === null || _b === void 0 ? void 0 : _b.unsubscribe();
-        (_c = this.subscription) === null || _c === void 0 ? void 0 : _c.unsubscribe();
-        this.socket = undefined;
-        this.channels = new pondBase_1.PondBase();
+    PondClient.prototype.createChannel = function (name, params) {
+        if (this._channels[name])
+            return this._channels[name];
+        var channel = new channel_1.Channel(name, this._broadcaster, this._receiver, params);
+        this._channels[name] = channel;
+        return channel;
     };
     return PondClient;
 }());