@eleven-am/pondsocket 0.1.4 → 0.1.6

package/package.json

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

package/pondClient/channel.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Channel = void 0;
-const rxjs_1 = require("rxjs");
-const operators_1 = require("rxjs/operators");
-const pondSocket_1 = require("../pondSocket");
-const pondBase_1 = require("../pondBase");
-class Channel {
-    constructor(channel, params, socket) {
+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;
@@ -15,138 +15,149 @@ class Channel {
         this._subject = new rxjs_1.Subject();
         this._connectedSubject = new pondBase_1.Subject(false);
     }
-    get isActive() {
-        return this._connectedSubject.value;
-    }
+    Object.defineProperty(Channel.prototype, "isActive", {
+        get: function () {
+            return this._connectedSubject.value;
+        },
+        enumerable: false,
+        configurable: true
+    });
     /**
      * @desc Connects to the channel.
      */
-    join() {
+    Channel.prototype.join = function () {
+        var _this = this;
         if (this._connectedSubject.value)
             return this;
-        const observable = this._init();
-        const subscription = observable
-            .subscribe(message => {
-            this._connectedSubject.publish(true);
+        var observable = this._init();
+        var subscription = observable
+            .subscribe(function (message) {
+            _this._connectedSubject.publish(true);
             if (message.action === "PRESENCE")
-                this._presenceSubject.next(message.payload.presence);
+                _this._presenceSubject.next(message.payload.presence);
             else if (message.action === "MESSAGE")
-                this._subject.next(message);
+                _this._subject.next(message);
             else if (message.event === "KICKED_FROM_CHANNEL")
-                this.leave();
+                _this.leave();
         });
         this._subscriptions.push(subscription);
         return this;
-    }
+    };
     /**
      * @desc Disconnects from the channel.
      */
-    leave() {
+    Channel.prototype.leave = function () {
         void this._connectedSubject.publish(false);
         this._presenceSubject.complete();
-        this._subscriptions.forEach(subscription => subscription.unsubscribe());
+        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.
      */
-    onPresenceUpdate(callback) {
-        const sub = this._presenceSubject.subscribe(callback);
+    Channel.prototype.onPresenceUpdate = function (callback) {
+        var sub = this._presenceSubject.subscribe(callback);
         this._subscriptions.push(sub);
         return sub;
-    }
+    };
     /**
      * @desc Monitors the channel for messages.
      * @param callback - The callback to call when a message is received.
      */
-    onMessage(callback) {
-        const sub = this._subject
-            .pipe((0, operators_1.filter)((message) => message.action === "MESSAGE"))
-            .subscribe(message => callback(message.event, message.payload));
+    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;
-    }
+    };
     /**
      * @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 = {
+    Channel.prototype.broadcast = function (event, payload) {
+        var message = {
             channelName: this.channel,
-            payload, event,
+            payload: payload,
+            event: event,
             action: pondSocket_1.ClientActions.BROADCAST
         };
         this._socket.next(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 = {
+    Channel.prototype.broadcastFrom = function (event, payload) {
+        var message = {
             channelName: this.channel,
-            payload, event,
+            payload: payload,
+            event: event,
             action: pondSocket_1.ClientActions.BROADCAST_FROM
         };
         this._socket.next(message);
-    }
+    };
     /**
      * @desc Updates the presence state of the current client in the channel.
      * @param presence - The presence state to update.
      */
-    updatePresence(presence) {
+    Channel.prototype.updatePresence = function (presence) {
         this._socket.next({
             action: pondSocket_1.ClientActions.UPDATE_PRESENCE,
             channelName: this.channel,
             event: "PRESENCE",
             payload: presence
         });
-    }
+    };
     /**
      * @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 addresses = Array.isArray(recipient) ? recipient : [recipient];
-        const message = {
+    Channel.prototype.sendMessage = function (event, payload, recipient) {
+        var addresses = Array.isArray(recipient) ? recipient : [recipient];
+        var message = {
             channelName: this.channel,
-            payload, event, addresses,
+            payload: payload,
+            event: event,
+            addresses: addresses,
             action: pondSocket_1.ClientActions.SEND_MESSAGE_TO_USER
         };
         this._socket.next(message);
-    }
+    };
     /**
      * @desc Listens for the connections state of the channel.
      * @param callback - The callback to call when the connection state changes.
      */
-    onConnectionChange(callback) {
-        const sub = this._connectedSubject.subscribe(callback);
+    Channel.prototype.onConnectionChange = function (callback) {
+        var sub = this._connectedSubject.subscribe(callback);
         this._subscriptions.push(sub);
         return sub;
-    }
+    };
     /**
      * @desc Initializes the channel.
      * @private
      */
-    _init() {
-        const observable = this._socket.multiplex(() => ({
+    Channel.prototype._init = function () {
+        var _this = this;
+        var observable = this._socket.multiplex(function () { return ({
             action: "JOIN_CHANNEL",
-            channelName: this.channel,
+            channelName: _this.channel,
             event: "JOIN_CHANNEL",
-            payload: this._params
-        }), () => ({
+            payload: _this._params
+        }); }, function () { return ({
             action: "LEAVE_CHANNEL",
-            channelName: this.channel,
+            channelName: _this.channel,
             event: "LEAVE_CHANNEL",
-            payload: this._params
-        }), message => message.channelName === this.channel);
+            payload: _this._params
+        }); }, function (message) { return message.channelName === _this.channel; });
         return observable;
-    }
-}
+    };
+    return Channel;
+}());
 exports.Channel = Channel;

package/pondClient/socket.d.ts

@@ -25,7 +25,7 @@ export declare class PondClient {
      * @param channel - The name of the channel.
      * @param params - The params to send to the server.
      */
-    createChannel(channel: string, params?: ChannelParams): Channel | null;
+    createChannel(channel: string, params?: ChannelParams): Channel;
 
     /**
      * @desc An event that is triggered when the socket receives a message.

package/pondClient/socket.js

@@ -1,29 +1,48 @@
 "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;
-const webSocket_1 = require("rxjs/webSocket");
-const rxjs_1 = require("rxjs");
-const channel_1 = require("./channel");
-const operators_1 = require("rxjs/operators");
-const pondBase_1 = require("../pondBase");
-class PondClient {
-    constructor(endpoint, params) {
+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 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 = (maxTries, ms) => {
-            return (0, rxjs_1.pipe)((0, operators_1.retryWhen)(attempts => {
-                const observableForRetries = (0, rxjs_1.zip)((0, rxjs_1.range)(1, maxTries), attempts)
-                    .pipe((0, operators_1.map)(([elemFromRange]) => elemFromRange), (0, operators_1.map)(i => i * i), (0, rxjs_1.switchMap)(i => (0, rxjs_1.timer)(i * ms)));
-                const observableForFailure = (0, rxjs_1.throwError)(new Error("Could not connect to server"))
+        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);
             }));
         };
-        let address;
+        var address;
         try {
             address = new URL(endpoint);
         }
@@ -31,9 +50,9 @@ class PondClient {
             address = new URL(window.location.toString());
             address.pathname = endpoint;
         }
-        const query = new URLSearchParams(params);
+        var query = new URLSearchParams(params);
         address.search = query.toString();
-        const protocol = address.protocol === "https:" ? "wss:" : "ws:";
+        var protocol = address.protocol === "https:" ? "wss:" : "ws:";
         if (address.protocol !== "wss:" && address.protocol !== "ws:")
             address.protocol = protocol;
         this.address = address;
@@ -42,75 +61,72 @@ class PondClient {
     /**
      * @desc Connects to the server and returns the socket.
      */
-    connect() {
+    PondClient.prototype.connect = function () {
+        var _this = this;
         if (this.socketState !== "CLOSED")
             return;
         this.socketState = "CONNECTING";
-        const socket = (0, webSocket_1.webSocket)({
+        var socket = (0, webSocket_1.webSocket)({
             url: this.address.toString(),
             openObserver: {
-                next: () => {
-                    this.socketState = "OPEN";
+                next: function () {
+                    _this.socketState = "OPEN";
                 }
             },
             closeObserver: {
-                next: () => {
-                    this.socketState = "CLOSED";
+                next: function () {
+                    _this.socketState = "CLOSED";
                 }
             },
             closingObserver: {
-                next: () => {
-                    this.socketState = "CLOSING";
+                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.
      */
-    getState() {
+    PondClient.prototype.getState = function () {
         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.
      */
-    createChannel(channel, params) {
-        const channelDoc = this.channels.get(channel);
-        if (channelDoc)
-            return channelDoc.doc;
-        if (this.socket) {
-            const newChannel = new channel_1.Channel(channel, params || {}, this.socket);
-            this.channels.set(channel, newChannel);
-            return newChannel;
-        }
-        return null;
-    }
+    PondClient.prototype.createChannel = function (channel, params) {
+        var _this = this;
+        return this.channels.getOrCreate(channel, function () {
+            return new channel_1.Channel(channel, params || {}, _this.socket);
+        }).doc;
+    };
     /**
      * @desc An event that is triggered when the socket receives a message.
      * @param callback - The callback to be called when the event is triggered.
      */
-    onMessage(callback) {
+    PondClient.prototype.onMessage = function (callback) {
         var _a;
-        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.subscribe(data => {
+        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.subscribe(function (data) {
             if (data.event)
                 callback(data.event, data.payload);
         });
-    }
+    };
     /**
      * @desc Disconnects the socket from the server.
      */
-    disconnect() {
+    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();
-    }
-}
+    };
+    return PondClient;
+}());
 exports.PondClient = PondClient;

package/pondSocket/pondResponse.d.ts

@@ -1,6 +1,5 @@
 import {ResponsePicker} from "../pondBase";
 import {PondMessage, SendResponse} from "./types";
-import {Channel} from "./channel";
 
 export declare abstract class PondResponse<T extends ResponsePicker = ResponsePicker.CHANNEL> {
     /**