@eleven-am/pondsocket 0.1.8 → 0.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",
@@ -28,7 +28,6 @@
     "url": "git+https://github.com/Eleven-am/pondSocket.git"
   },
   "dependencies": {
-    "rxjs": "^7.5.6",
     "ws": "^8.8.1"
   },
   "devDependencies": {

package/pondBase/baseClass.d.ts

@@ -49,5 +49,7 @@ export declare class BaseClass {
      * /api/id?name=abc should return { name: 'abc' }
      * /api/id?name=abc&age=123 should return { name: 'abc', age: '123' }
      */
-    protected _parseQueries(path: string): default_t<string>;
+    protected _parseQueries(path: string): {
+        [p: string]: string;
+    };
 }

package/pondBase/pondBase.js

@@ -52,7 +52,7 @@ class PondBase extends simpleBase_1.SimpleBase {
         const newPond = new PondBase();
         for (const doc of this) {
             const foreignDoc = pond.find((d) => d[foreignKey] === doc.doc[key]);
-            newPond.set(doc.id, { ...doc.doc, [key]: (foreignDoc === null || foreignDoc === void 0 ? void 0 : foreignDoc.doc) || null });
+            newPond.set(doc.id, Object.assign(Object.assign({}, doc.doc), { [key]: (foreignDoc === null || foreignDoc === void 0 ? void 0 : foreignDoc.doc) || null }));
         }
         return newPond;
     }

package/pondBase/pubSub.d.ts

@@ -5,21 +5,26 @@ export declare class Subscription {
 export declare class Broadcast<T, A> {
 
     /**
-     * @desc Subscribe to the broadcast
-     * @param handler - The handler to call when the broadcast is published
+     * @desc Gets the number of subscribers
      */
-    subscribe(handler: (data: T) => A): Subscription;
+    get subscriberCount(): number;
 
     /**
-     * @desc Gets the number of subscribers
+     * @desc Subscribe to the broadcast
+     * @param handler - The handler to call when the broadcast is published
      */
-    public get subscriberCount(): number;
+    subscribe(handler: (data: T) => A): Subscription;
 
     /**
      * @desc Publish to the broadcast
      * @param data - The data to publish
      */
     publish(data: T): A | undefined;
+
+    /**
+     * @dec clears all subscribers
+     */
+    clear(): void;
 }
 
 export declare class Subject<T, A> extends Broadcast<T, A> {

package/pondBase/pubSub.js

@@ -39,6 +39,12 @@ class Broadcast {
         }
         return result;
     }
+    /**
+     * @dec clears all subscribers
+     */
+    clear() {
+        this._subscribers.clear();
+    }
 }
 exports.Broadcast = Broadcast;
 class Subject extends Broadcast {

package/pondBase/pubSub.test.js

@@ -82,6 +82,20 @@ describe('Broadcast', () => {
         expect(subscriber2).toHaveBeenCalledWith('Hello');
         expect(subscriber3).not.toHaveBeenCalled();
     });
+    it('should clear all subscribers', () => {
+        const broadcast = new pubSub_1.Broadcast();
+        const subscriber1 = jest.fn();
+        const subscriber2 = jest.fn();
+        broadcast.subscribe(subscriber1);
+        broadcast.subscribe(subscriber2);
+        broadcast.publish('Hello');
+        broadcast.clear();
+        broadcast.publish('Hello Again');
+        expect(subscriber1).toHaveBeenCalledWith('Hello');
+        expect(subscriber1).not.toHaveBeenCalledWith('Hello Again');
+        expect(subscriber2).toHaveBeenCalledWith('Hello');
+        expect(subscriber2).not.toHaveBeenCalledWith('Hello Again');
+    });
 });
 describe('Subject', () => {
     it('should be defined', () => {

package/pondBase/simpleBase.d.ts

@@ -1,9 +1,4 @@
 export declare class PondDocument<T> {
-    private readonly _id;
-    private readonly _getDoc;
-    private readonly _removeDoc;
-    private readonly _updateDoc;
-
     constructor(id: string, removeDoc: () => void, updateDoc: (value: T) => PondDocument<T>, getDoc: () => T);
 
     get id(): string;

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,163 +1,139 @@
 "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);
+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._subscription = receiver.subscribe(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();
+    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) {
+                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;
-    };
+    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.
      */
-    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;
-    };
+    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.
      */
-    Channel.prototype.broadcast = function (event, payload) {
-        var message = {
-            channelName: this.channel,
-            payload: payload,
-            event: event,
-            action: pondSocket_1.ClientActions.BROADCAST
+    broadcast(event, payload) {
+        const message = {
+            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.
      * @param event - The event to send.
      * @param payload - The message to send.
      */
-    Channel.prototype.broadcastFrom = function (event, payload) {
-        var message = {
-            channelName: this.channel,
-            payload: payload,
-            event: event,
-            action: pondSocket_1.ClientActions.BROADCAST_FROM
+    broadcastFrom(event, payload) {
+        const message = {
+            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.
      * @param event - The event to send.
      * @param payload - The message to send.
      * @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,
+    sendMessage(event, payload, recipient) {
+        const message = {
+            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.
+     */
+    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 Monitors the presence state of the channel.
+     * @param callback - The callback to call when the presence state changes.
      */
-    Channel.prototype.onConnectionChange = function (callback) {
-        var sub = this._connectedSubject.subscribe(callback);
-        this._subscriptions.push(sub);
-        return sub;
-    };
+    onPresence(callback) {
+        return this._presence.subscribe(data => {
+            callback(data.change, data.presence);
+        });
+    }
     /**
-     * @desc Initializes the channel.
-     * @private
+     * @desc Monitors the connection state of the channel.
+     * @param callback - The callback to call when the connection 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;
-    };
-    return Channel;
-}());
+    onConnectionChange(callback) {
+        return this._connection.subscribe(data => {
+            callback(data);
+        });
+    }
+}
 exports.Channel = 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,48 +1,12 @@
 "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 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;
+const channel_1 = require("./channel");
+const pondBase_1 = require("../pondBase");
+const pondSocket_1 = require("../pondSocket");
+class PondClient {
+    constructor(endpoint, params) {
+        let address;
         try {
             address = new URL(endpoint);
         }
@@ -50,83 +14,85 @@ var PondClient = /** @class */ (function () {
             address = new URL(window.location.toString());
             address.pathname = endpoint;
         }
-        var query = new URLSearchParams(params);
+        const query = new URLSearchParams(params);
         address.search = query.toString();
-        var protocol = address.protocol === "https:" ? "wss:" : "ws:";
+        const protocol = address.protocol === "https:" ? "wss:" : "ws:";
         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.
+     * @desc Returns the current state of 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;
-    };
+    getState() {
+        return this._socketState;
+    }
     /**
-     * @desc Returns the current state of the socket.
+     * @desc Connects to the server and returns the socket.
      */
-    PondClient.prototype.getState = function () {
-        return this.socketState;
-    };
+    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();
+        };
+        socket.onmessage = (message) => {
+            const data = JSON.parse(message.data);
+            this._broadcaster.publish(data);
+        };
+        socket.onerror = () => {
+            this._socketState = "CLOSED";
+            sub.unsubscribe();
+            setTimeout(() => {
+                this.connect(backoff * 2);
+            }, backoff * 1000);
+        };
+        this._socket = socket;
+    }
     /**
-     * @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.
      */
-    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;
-    };
+    disconnect() {
+        var _a;
+        Object.values(this._channels).forEach(channel => 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);
+    onMessage(event, callback) {
+        return this._broadcaster.subscribe(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();
-    };
-    return PondClient;
-}());
+    createChannel(name, params) {
+        if (this._channels[name])
+            return this._channels[name];
+        const channel = new channel_1.Channel(name, this._broadcaster, this._receiver, params);
+        this._channels[name] = channel;
+        return channel;
+    }
+}
 exports.PondClient = PondClient;

package/pondSocket/channel.js

@@ -29,7 +29,7 @@ class Channel extends pondBase_1.BaseClass {
      * @desc Gets the channel's data
      */
     get data() {
-        const result = { ...this._channelData };
+        const result = Object.assign({}, this._channelData);
         return Object.freeze(result);
     }
     /**
@@ -37,7 +37,7 @@ class Channel extends pondBase_1.BaseClass {
      * @param data
      */
     set data(data) {
-        this._channelData = { ...this._channelData, ...data };
+        this._channelData = Object.assign(Object.assign({}, this._channelData), data);
     }
     /**
      * @desc Gets the channel's presence
@@ -78,9 +78,9 @@ class Channel extends pondBase_1.BaseClass {
         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, { ...user.presence, id: clientId });
+        this._channelPresence.set(clientId, Object.assign(Object.assign({}, user.presence), { id: clientId }));
         this._channelAssigns.set(clientId, user.assigns);
-        this._channelData = Object.assign({ ...this._channelData, ...user.channelData });
+        this._channelData = Object.assign(Object.assign(Object.assign({}, this._channelData), user.channelData));
     }
     /**
      * @desc Removes a user or group of users from the channel
@@ -129,8 +129,8 @@ class Channel extends pondBase_1.BaseClass {
     updateUser(clientId, presence, assigns) {
         const client = this._retrieveUser(clientId);
         if (client) {
-            client.assigns.updateDoc(Object.assign({ ...client.assigns.doc }, assigns));
-            const presenceDoc = Object.assign({ ...client.presence.doc }, presence);
+            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);
         }

package/pondSocket/channel.test.js

@@ -220,10 +220,10 @@ describe('Channel', () => {
     });
     it('should be possible to remove multiple users at once', () => {
         const { channel, user } = (0, exports.createChannel)('test');
-        const user1 = { ...user };
+        const user1 = Object.assign({}, user);
         user1.client.clientId = 'test1';
         channel.addUser(user1);
-        const user2 = { ...user };
+        const user2 = Object.assign({}, user);
         user2.client.clientId = 'test2';
         channel.addUser(user2);
         expect(channel.info.presence.length).toBe(2);

package/pondSocket/endpoint.js

@@ -66,10 +66,7 @@ class Endpoint extends pondBase_1.BaseClass {
      */
     authoriseConnection(request, socket, head, data) {
         const doc = this._sockets.createGenericDocument();
-        const req = {
-            headers: request.headers,
-            ...data, clientId: doc.id
-        };
+        const req = Object.assign(Object.assign({ headers: request.headers }, data), { clientId: doc.id });
         const resolver = (assigns, data) => {
             if (data.error) {
                 socket.write(`HTTP/1.1 ${data.error.code} ${data.error.message}\r\n\r\n`);

package/pondSocket/endpoint.test.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -23,7 +32,7 @@ describe('endpoint', () => {
         expect(new endpoint_1.Endpoint(socketServer, handler)).toBeInstanceOf(endpoint_1.Endpoint);
     });
     // Functionality tests
-    it('should be able to close a socket', async () => {
+    it('should be able to close a socket', () => __awaiter(void 0, void 0, void 0, function* () {
         const { socket, server } = createPondSocket();
         expect(server).toBeDefined();
         const endpoint = socket.createEndpoint('/api/:path', (req, res) => {
@@ -33,14 +42,14 @@ describe('endpoint', () => {
                 endpoint.closeConnection(req.clientId);
             }, 100);
         });
-        await (0, superwstest_1.default)(server)
+        yield (0, superwstest_1.default)(server)
             .ws('/api/socket')
             .expectUpgrade(res => expect(res.statusCode).toBe(101))
             .wait(200)
             .expectClosed();
         server.close();
-    });
-    it('should be able to list connections', async () => {
+    }));
+    it('should be able to list connections', () => __awaiter(void 0, void 0, void 0, function* () {
         const { socket, server } = createPondSocket();
         let connectionsCount = 0;
         expect(server).toBeDefined();
@@ -49,17 +58,17 @@ describe('endpoint', () => {
             connectionsCount = endpoint.listConnections().length;
             res.accept();
         });
-        await (0, superwstest_1.default)(server)
+        yield (0, superwstest_1.default)(server)
             .ws('/api/socket')
             .expectUpgrade(res => expect(res.statusCode).toBe(101));
-        await (0, superwstest_1.default)(server)
+        yield (0, superwstest_1.default)(server)
             .ws('/api/socket')
             .expectUpgrade(res => expect(res.statusCode).toBe(101));
         server.close(); // Close the server to stop the connection from being kept alive
         expect(connectionsCount).toBe(1);
         expect(endpoint.listConnections().length).toBe(2); // The connections are still in the list
-    });
-    it('should be capable of sending messages to all clients', async () => {
+    }));
+    it('should be capable of sending messages to all clients', () => __awaiter(void 0, void 0, void 0, function* () {
         const { socket, server } = createPondSocket();
         expect(server).toBeDefined();
         let users = 0;
@@ -69,7 +78,7 @@ describe('endpoint', () => {
             if (users > 0)
                 endpoint.broadcast('TEST', { message: 'Hello everyone' });
         });
-        await (0, superwstest_1.default)(server)
+        yield (0, superwstest_1.default)(server)
             .ws('/api/socket')
             .expectUpgrade(res => expect(res.statusCode).toBe(101))
             .expectJson({
@@ -82,7 +91,7 @@ describe('endpoint', () => {
                 message: 'Hello everyone'
             }
         });
-        await (0, superwstest_1.default)(server)
+        yield (0, superwstest_1.default)(server)
             .ws('/api/secondSocket')
             .expectUpgrade(res => expect(res.statusCode).toBe(101))
             .expectJson({
@@ -96,8 +105,8 @@ describe('endpoint', () => {
             }
         });
         server.close();
-    });
-    it('should be able to accept connections on this handler', async () => {
+    }));
+    it('should be able to accept connections on this handler', () => __awaiter(void 0, void 0, void 0, function* () {
         const { socket, server } = createPondSocket();
         expect(server).toBeDefined();
         const endpoint = socket.createEndpoint('/api/:room', (_, res) => {
@@ -122,22 +131,20 @@ describe('endpoint', () => {
         const message = {
             action: enums_1.ClientActions.JOIN_CHANNEL, channelName: '/test/socket', event: 'TEST', payload: {}
         };
-        await (0, superwstest_1.default)(server)
+        yield (0, superwstest_1.default)(server)
             .ws('/api/socket')
             .expectUpgrade(res => expect(res.statusCode).toBe(101))
             .sendJson(message)
             .expectJson(); // receives a presence message, this can not be matched because the payload is dynamic
-        await (0, superwstest_1.default)(server)
+        yield (0, superwstest_1.default)(server)
             .ws('/api/socket')
             .expectUpgrade(res => expect(res.statusCode).toBe(101))
-            .sendJson({
-            ...message, channelName: '/socket/socket'
-        })
+            .sendJson(Object.assign(Object.assign({}, message), { channelName: '/socket/socket' }))
             .expectJson(); // receives a presence message, this can not be matched because the payload is dynamic
         expect([...endpoint['_channels'].generator()]).toHaveLength(2);
         server.close();
-    });
-    it('should refuse connections if there are no handlers', async () => {
+    }));
+    it('should refuse connections if there are no handlers', () => __awaiter(void 0, void 0, void 0, function* () {
         const { socket, server } = createPondSocket();
         expect(server).toBeDefined();
         const endpoint = socket.createEndpoint('/api/:room', (_, res) => {
@@ -154,22 +161,21 @@ describe('endpoint', () => {
         const message = {
             action: enums_1.ClientActions.JOIN_CHANNEL, channelName: '/test/socket', event: 'TEST', payload: {}
         };
-        await (0, superwstest_1.default)(server)
+        yield (0, superwstest_1.default)(server)
             .ws('/api/socket')
             .expectUpgrade(res => expect(res.statusCode).toBe(101))
             .sendJson(message)
             .expectJson(); // receives a presence message, this can not be matched because the payload is dynamic
-        await (0, superwstest_1.default)(server)
+        yield (0, superwstest_1.default)(server)
             .ws('/api/socket')
             .expectUpgrade(res => expect(res.statusCode).toBe(101))
-            .sendJson({
-            ...message, channelName: '/socket/socket' // This channel handler does not exist
-        })
+            .sendJson(Object.assign(Object.assign({}, message), { channelName: '/socket/socket' // This channel handler does not exist
+         }))
             .expectJson(); // receives a presence message, this can not be matched because the payload is dynamic
         expect([...endpoint['_channels'].generator()]).toHaveLength(1);
         server.close();
-    });
-    it('should send an error when we send an incomplete message', async () => {
+    }));
+    it('should send an error when we send an incomplete message', () => __awaiter(void 0, void 0, void 0, function* () {
         const { socket, server } = createPondSocket();
         expect(server).toBeDefined();
         const endpoint = socket.createEndpoint('/api/:room', (_, res) => {
@@ -186,7 +192,7 @@ describe('endpoint', () => {
         const message = {
             action: enums_1.ClientActions.LEAVE_CHANNEL, channelName: '/test/socket', event: 'TEST', payload: {}
         };
-        await (0, superwstest_1.default)(server)
+        yield (0, superwstest_1.default)(server)
             .ws('/api/socket')
             .expectUpgrade(res => expect(res.statusCode).toBe(101))
             .sendJson(message)
@@ -198,12 +204,10 @@ describe('endpoint', () => {
                 message: "Channel /test/socket does not exist"
             }
         });
-        await (0, superwstest_1.default)(server)
+        yield (0, superwstest_1.default)(server)
             .ws('/api/socket')
             .expectUpgrade(res => expect(res.statusCode).toBe(101))
-            .sendJson({
-            ...message, action: null
-        })
+            .sendJson(Object.assign(Object.assign({}, message), { action: null }))
             .expectJson({
             action: enums_1.ServerActions.ERROR,
             event: "error",
@@ -212,12 +216,10 @@ describe('endpoint', () => {
                 message: "No action provided",
             }
         });
-        await (0, superwstest_1.default)(server)
+        yield (0, superwstest_1.default)(server)
             .ws('/api/socket')
             .expectUpgrade(res => expect(res.statusCode).toBe(101))
-            .sendJson({
-            ...message, action: enums_1.ClientActions.BROADCAST, channelName: null
-        })
+            .sendJson(Object.assign(Object.assign({}, message), { action: enums_1.ClientActions.BROADCAST, channelName: null }))
             .expectJson({
             action: enums_1.ServerActions.ERROR,
             event: "error",
@@ -226,12 +228,10 @@ describe('endpoint', () => {
                 message: "No channel name provided",
             }
         });
-        await (0, superwstest_1.default)(server)
+        yield (0, superwstest_1.default)(server)
             .ws('/api/socket')
             .expectUpgrade(res => expect(res.statusCode).toBe(101))
-            .sendJson({
-            ...message, action: enums_1.ClientActions.BROADCAST_FROM, payload: null
-        })
+            .sendJson(Object.assign(Object.assign({}, message), { action: enums_1.ClientActions.BROADCAST_FROM, payload: null }))
             .expectJson({
             action: enums_1.ServerActions.ERROR,
             event: "error",
@@ -241,7 +241,7 @@ describe('endpoint', () => {
             }
         });
         // send incorrect Json message
-        await (0, superwstest_1.default)(server)
+        yield (0, superwstest_1.default)(server)
             .ws('/api/socket')
             .expectUpgrade(res => expect(res.statusCode).toBe(101))
             .send('"action": "JOIN_CHANNEL", "channelName": "/test/socket", "event": "TEST", "payload": {}}')
@@ -255,8 +255,8 @@ describe('endpoint', () => {
         });
         expect([...endpoint['_channels'].generator()]).toHaveLength(1);
         server.close();
-    });
-    it('should send an error when the channel exists but other things happen', async () => {
+    }));
+    it('should send an error when the channel exists but other things happen', () => __awaiter(void 0, void 0, void 0, function* () {
         const { socket, server } = createPondSocket();
         expect(server).toBeDefined();
         const endpoint = socket.createEndpoint('/api/:room', (_, res) => {
@@ -282,28 +282,22 @@ describe('endpoint', () => {
         const message = {
             action: enums_1.ClientActions.JOIN_CHANNEL, channelName: '/test/socket', event: 'TEST', payload: {}
         };
-        await (0, superwstest_1.default)(server)
+        yield (0, superwstest_1.default)(server)
             .ws('/api/socket')
             .expectUpgrade(res => expect(res.statusCode).toBe(101))
             .sendJson(message)
             .expectJson() // receives a presence message, this can not be matched because the payload is dynamic
-            .sendJson({
-            ...message, event: '/test/TEST2', action: enums_1.ClientActions.BROADCAST,
-        })
+            .sendJson(Object.assign(Object.assign({}, message), { event: '/test/TEST2', action: enums_1.ClientActions.BROADCAST }))
             .expectJson({
             action: "ERROR", event: "error", channelName: "/test/socket", payload: {
                 message: "Message rejected", code: 403
             }
         })
-            .sendJson({
-            ...message, channelName: "/test/socket", action: enums_1.ClientActions.BROADCAST,
-        })
+            .sendJson(Object.assign(Object.assign({}, message), { channelName: "/test/socket", action: enums_1.ClientActions.BROADCAST }))
             .expectJson({
             action: enums_1.ServerActions.MESSAGE, payload: {}, event: "TEST", channelName: "/test/socket"
         })
-            .sendJson({
-            ...message, action: enums_1.ClientActions.SEND_MESSAGE_TO_USER,
-        })
+            .sendJson(Object.assign(Object.assign({}, message), { action: enums_1.ClientActions.SEND_MESSAGE_TO_USER }))
             .expectJson({
             action: enums_1.ServerActions.ERROR,
             event: "error",
@@ -314,8 +308,8 @@ describe('endpoint', () => {
         });
         expect(endpoint.listChannels()).toHaveLength(1);
         server.close();
-    });
-    it('should be capable of sending messages to a specific user', async () => {
+    }));
+    it('should be capable of sending messages to a specific user', () => __awaiter(void 0, void 0, void 0, function* () {
         const { socket, server } = createPondSocket();
         expect(server).toBeDefined();
         const endpoint = socket.createEndpoint('/api/:room', (_, res) => {
@@ -341,22 +335,20 @@ describe('endpoint', () => {
         const message = {
             action: enums_1.ClientActions.JOIN_CHANNEL, channelName: '/test/socket', event: 'TEST', payload: {}
         };
-        await (0, superwstest_1.default)(server)
+        yield (0, superwstest_1.default)(server)
             .ws('/api/socket')
             .expectUpgrade(res => expect(res.statusCode).toBe(101))
             .sendJson(message)
             .expectJson() // receives a presence message, this can not be matched because the payload is dynamic
-            .sendJson({
-            ...message, action: enums_1.ClientActions.BROADCAST_FROM, payload: {
+            .sendJson(Object.assign(Object.assign({}, message), { action: enums_1.ClientActions.BROADCAST_FROM, payload: {
                 message: {
                     action: enums_1.ServerActions.MESSAGE, payload: {}, event: "TEST", channelName: "/test/socket"
                 }
-            }
-        });
+            } }));
         expect(endpoint.listChannels()).toHaveLength(1);
         server.close();
-    });
-    it('should be able to update user presence on user demand', async () => {
+    }));
+    it('should be able to update user presence on user demand', () => __awaiter(void 0, void 0, void 0, function* () {
         const { socket, server } = createPondSocket();
         expect(server).toBeDefined();
         const endpoint = socket.createEndpoint('/api/:room', (_, res) => {
@@ -369,22 +361,18 @@ describe('endpoint', () => {
         const message = {
             action: enums_1.ClientActions.JOIN_CHANNEL, channelName: '/test/socket', event: 'TEST', payload: {}
         };
-        await (0, superwstest_1.default)(server)
+        yield (0, superwstest_1.default)(server)
             .ws('/api/socket')
             .expectUpgrade(res => expect(res.statusCode).toBe(101))
             .sendJson(message)
             .expectJson() // receives a presence message, this can not be matched because the payload is dynamic
-            .sendJson({
-            ...message, action: enums_1.ClientActions.UPDATE_PRESENCE, payload: {
+            .sendJson(Object.assign(Object.assign({}, message), { action: enums_1.ClientActions.UPDATE_PRESENCE, payload: {
                 presence: {
                     status: 'online'
                 }
-            }
-        })
+            } }))
             .expectJson() // receives a presence message, this can not be matched because the payload is dynamic
-            .sendJson({
-            ...message, action: enums_1.ClientActions.SEND_MESSAGE_TO_USER, addresses: [], payload: {}
-        })
+            .sendJson(Object.assign(Object.assign({}, message), { action: enums_1.ClientActions.SEND_MESSAGE_TO_USER, addresses: [], payload: {} }))
             .expectJson({
             action: enums_1.ServerActions.ERROR,
             event: "error",
@@ -393,9 +381,7 @@ describe('endpoint', () => {
                 message: "Error while executing event 'TEST' on channel '/test/socket': No addresses provided"
             }
         })
-            .sendJson({
-            ...message, action: enums_1.ClientActions.SEND_MESSAGE_TO_USER, addresses: ['hello'], payload: {}
-        })
+            .sendJson(Object.assign(Object.assign({}, message), { action: enums_1.ClientActions.SEND_MESSAGE_TO_USER, addresses: ['hello'], payload: {} }))
             .expectJson({
             action: enums_1.ServerActions.ERROR,
             event: "error",
@@ -404,32 +390,25 @@ describe('endpoint', () => {
                 message: "Error while executing event 'TEST' on channel '/test/socket': Client(s) with clientId(s) hello were not found in channel /test/socket"
             }
         })
-            .sendJson({
-            ...message, action: enums_1.ClientActions.UPDATE_PRESENCE, payload: {
+            .sendJson(Object.assign(Object.assign({}, message), { action: enums_1.ClientActions.UPDATE_PRESENCE, payload: {
                 assigns: {
                     status: 'online'
                 }
-            }
-        })
+            } }))
             .close()
             .expectClosed();
         expect(endpoint.listChannels()).toHaveLength(1); // the channel has not been removed yet
-        await (0, superwstest_1.default)(server)
+        yield (0, superwstest_1.default)(server)
             .ws('/api/newSocket')
             .expectUpgrade(res => expect(res.statusCode).toBe(101))
-            .sendJson({
-            ...message, channelName: '/test/socket2',
-        })
+            .sendJson(Object.assign(Object.assign({}, message), { channelName: '/test/socket2' }))
             .expectJson() // receives a presence message, this can not be matched because the payload is dynamic
-            .sendJson({
-            ...message, action: enums_1.ClientActions.LEAVE_CHANNEL,
-            channelName: '/test/socket2',
-        })
+            .sendJson(Object.assign(Object.assign({}, message), { action: enums_1.ClientActions.LEAVE_CHANNEL, channelName: '/test/socket2' }))
             .expectJson();
         expect(endpoint.listChannels()).toHaveLength(0); // by now the first channel should have been removed; and since we gracefully closed the connection, the second channel should have been removed as well
         server.close();
-    });
-    it('should ba able to send messages to a specific user', async () => {
+    }));
+    it('should ba able to send messages to a specific user', () => __awaiter(void 0, void 0, void 0, function* () {
         const { socket, server } = createPondSocket();
         expect(server).toBeDefined();
         const endpoint = socket.createEndpoint('/api/:room', (_, res) => {
@@ -448,18 +427,16 @@ describe('endpoint', () => {
         const message = {
             action: enums_1.ClientActions.JOIN_CHANNEL, channelName: '/test/socket', event: 'TEST', payload: {}
         };
-        await (0, superwstest_1.default)(server)
+        yield (0, superwstest_1.default)(server)
             .ws('/api/socket')
             .expectUpgrade(res => expect(res.statusCode).toBe(101))
             .sendJson(message)
             .expectJson() // receives a presence message, this can not be matched because the payload is dynamic
-            .sendJson({
-            ...message, action: enums_1.ClientActions.BROADCAST_FROM, payload: {
+            .sendJson(Object.assign(Object.assign({}, message), { action: enums_1.ClientActions.BROADCAST_FROM, payload: {
                 message: {
                     action: enums_1.ServerActions.MESSAGE, payload: {}, event: "TEST", channelName: "/test/socket"
                 }
-            }
-        }).expectJson({
+            } })).expectJson({
             action: enums_1.ServerActions.MESSAGE,
             event: 'Test', channelName: enums_1.PondSenders.ENDPOINT,
             payload: {
@@ -468,8 +445,8 @@ describe('endpoint', () => {
         });
         expect(endpoint.listChannels()).toHaveLength(1);
         server.close();
-    });
-    it('should be able ot manage error from the client side', async () => {
+    }));
+    it('should be able ot manage error from the client side', () => __awaiter(void 0, void 0, void 0, function* () {
         const { socket, server } = createPondSocket();
         expect(server).toBeDefined();
         const endpoint = socket.createEndpoint('/api/:room', (_, res) => {
@@ -496,7 +473,7 @@ describe('endpoint', () => {
             }
         };
         try {
-            await (0, superwstest_1.default)(server)
+            yield (0, superwstest_1.default)(server)
                 .ws('/api/socket')
                 .expectUpgrade(res => expect(res.statusCode).toBe(101))
                 .sendJson(message)
@@ -509,5 +486,5 @@ describe('endpoint', () => {
         expect(endpoint.listChannels()).toHaveLength(0); // the socket should have been removed
         expect(endpoint['_findChannel']('/test/socket')).toBeUndefined();
         server.close();
-    });
+    }));
 });

package/pondSocket/pondChannel.js

@@ -68,11 +68,7 @@ class PondChannel extends pondBase_1.BaseClass {
             document.removeDoc();
             return response.reject(`Invalid channel name: ${channelName}`);
         }
-        const request = {
-            joinParams, ...resolved,
-            clientId: user.clientId, channelName,
-            clientAssigns: user.assigns
-        };
+        const request = Object.assign(Object.assign({ joinParams }, resolved), { clientId: user.clientId, channelName, clientAssigns: user.assigns });
         this._handler(request, response, channel);
         if (channel.presence.length === 0)
             document.removeDoc();
@@ -207,11 +203,7 @@ class PondChannel extends pondBase_1.BaseClass {
             const info = this.generateEventRequest(event, data.event);
             if (!info)
                 return;
-            const req = {
-                ...data,
-                params: info.params,
-                query: info.query,
-            };
+            const req = Object.assign(Object.assign({}, data), { params: info.params, query: info.query });
             callback(req, res, channel);
         });
     }

package/pondSocket/server.test.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -75,7 +84,7 @@ describe('server', () => {
         expect(socketClient.write).toHaveBeenCalled();
         expect(socketClient.destroy).toHaveBeenCalled();
     });
-    it('should be able to accept a socket if a handler is provided', async () => {
+    it('should be able to accept a socket if a handler is provided', () => __awaiter(void 0, void 0, void 0, function* () {
         const socket = new pondSocket_1.PondSocket();
         const server = socket.listen(3001, () => {
             console.log('server listening');
@@ -88,14 +97,14 @@ describe('server', () => {
             expect(req.params.path).toBe('socket');
             res.accept();
         });
-        await (0, superwstest_1.default)(server)
+        yield (0, superwstest_1.default)(server)
             .ws('/api/socket')
             .expectUpgrade(res => expect(res.statusCode).toBe(101))
             .close()
             .expectClosed();
         server.close();
-    });
-    it('should be able to reject a socket if the handler rejects', async () => {
+    }));
+    it('should be able to reject a socket if the handler rejects', () => __awaiter(void 0, void 0, void 0, function* () {
         const socket = new pondSocket_1.PondSocket();
         const server = socket.listen(3001, () => {
             console.log('server listening');
@@ -105,12 +114,12 @@ describe('server', () => {
             expect(req.params.path).toBe('socket');
             res.reject();
         });
-        await (0, superwstest_1.default)(server)
+        yield (0, superwstest_1.default)(server)
             .ws('/api/socket')
             .expectConnectionError();
         server.close();
-    });
-    it('should be able to send a message after connection', async () => {
+    }));
+    it('should be able to send a message after connection', () => __awaiter(void 0, void 0, void 0, function* () {
         const socket = new pondSocket_1.PondSocket();
         const server = socket.listen(3001, () => {
             console.log('server listening');
@@ -120,7 +129,7 @@ describe('server', () => {
             expect(req.params.path).toBe('socket');
             res.send('testEvent', { test: 'test' });
         });
-        await (0, superwstest_1.default)(server)
+        yield (0, superwstest_1.default)(server)
             .ws('/api/socket')
             .expectUpgrade(res => expect(res.statusCode).toBe(101))
             .expectJson({
@@ -132,5 +141,5 @@ describe('server', () => {
             .close()
             .expectClosed();
         server.close();
-    });
+    }));
 });