@eleven-am/pondsocket 0.1.0

package/pondBase/simpleBase.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleBase = exports.PondDocument = void 0;
+class PondDocument {
+    constructor(id, removeDoc, updateDoc, getDoc) {
+        this._removeDoc = removeDoc;
+        this._updateDoc = updateDoc;
+        this._getDoc = getDoc;
+        this._id = id;
+    }
+    get id() {
+        return this._id;
+    }
+    get doc() {
+        return this._getDoc();
+    }
+    /**
+     * @desc Removes the document from the collection
+     */
+    removeDoc() {
+        const doc = this._getDoc();
+        this._removeDoc();
+        return doc;
+    }
+    /**
+     * @desc Updates the document in the collection
+     * @param value - the new value of the document
+     */
+    updateDoc(value) {
+        this._updateDoc(value);
+        return this;
+    }
+}
+exports.PondDocument = PondDocument;
+class SimpleBase {
+    constructor(callbacks) {
+        this._db = {};
+        this._update = callbacks || null;
+    }
+    /**
+     * @desc Get the number of documents
+     */
+    get size() {
+        return Object.keys(this._db).length;
+    }
+    /**
+     * @desc Get all the documents in the database
+     */
+    get all() {
+        return Object.keys(this._db).map(this._createPondDocument.bind(this));
+    }
+    /**
+     * @desc Makes the database iterable
+     */
+    [Symbol.iterator]() {
+        return this.all[Symbol.iterator]();
+    }
+    /**
+     * @desc Create a generator for the pond
+     */
+    *generator() {
+        for (const key in this._db) {
+            yield this._createPondDocument(key);
+        }
+    }
+    /**
+     * @desc Get a document by key
+     * @param key - The key of the document
+     */
+    get(key) {
+        const doc = this._db[key];
+        if (doc)
+            return this._createPondDocument(key);
+        return null;
+    }
+    /**
+     * @desc getOrCreate a document in the database
+     * @param key - The key of the document
+     * @param creator - The function to create the document
+     */
+    getOrCreate(key, creator) {
+        const doc = this.get(key);
+        if (doc)
+            return doc;
+        return this.set(key, creator(this._createPondDocument(key)));
+    }
+    /**
+     * @desc Upsert a document in the database
+     * @param key - The key of the document
+     * @param value - The value of the document
+     */
+    upsert(key, value) {
+        const doc = this.get(key);
+        if (doc)
+            return doc.updateDoc(value);
+        return this.set(key, value);
+    }
+    /**
+     * @desc checks if a document exists
+     * @param key - The key of the document
+     */
+    has(key) {
+        return this._db[key] !== undefined;
+    }
+    /**
+     * @desc Set a document to the database
+     * @param key - The key of the document
+     * @param value - The value of the document
+     */
+    set(key, value) {
+        var _a;
+        const oldValue = this._db[key] || null;
+        this._db[key] = value;
+        (_a = this._update) === null || _a === void 0 ? void 0 : _a.call(this, { oldValue, currentValue: value });
+        return this._createPondDocument(key);
+    }
+    /**
+     * @desc Find a document by a query function
+     * @param query - The query function
+     */
+    find(query) {
+        for (const key in this._db) {
+            const doc = this._db[key];
+            if (query(doc, key))
+                return this._createPondDocument(key);
+        }
+        return null;
+    }
+    /**
+     * @desc Map the pond to a new array
+     * @param mapper - The mapper function
+     */
+    map(mapper) {
+        return Object.keys(this._db).map(key => mapper(this._db[key], key));
+    }
+    /**
+     * @desc Filters the pond using a query function
+     * @param query - The query function
+     */
+    filter(query) {
+        return Object.keys(this._db)
+            .filter(key => query(this._db[key], key))
+            .map(this._createPondDocument.bind(this));
+    }
+    /**
+     * @desc Reduce the pond to a single value
+     * @param reducer - The reducer function
+     * @param initialValue - The initial value of the reducer
+     */
+    reduce(reducer, initialValue) {
+        return Object.values(this._db).reduce(reducer, initialValue);
+    }
+    /**
+     * @desc Gets all the keys of the database
+     */
+    get keys() {
+        return Object.keys(this._db);
+    }
+    /**
+     * @desc Gets all the values of the database
+     */
+    get values() {
+        return Object.values(this._db);
+    }
+    /**
+     * @desc Generate a generic pond document
+     * @param id - The id of the document
+     */
+    createGenericDocument(id) {
+        const idValue = id || Math.random().toString(36).substr(2, 9);
+        return this._createPondDocument(idValue);
+    }
+    /**
+     * @desc Delete a document by key
+     */
+    _delete(key) {
+        var _a;
+        const oldValue = this._db[key];
+        delete this._db[key];
+        (_a = this._update) === null || _a === void 0 ? void 0 : _a.call(this, { oldValue, currentValue: null });
+    }
+    /**
+     * @desc Retrieve a document from the database
+     * @param key - The key of the document
+     */
+    _getDocument(key) {
+        const data = this._db[key];
+        if (!data)
+            return null;
+        return data;
+    }
+    /**
+     * @desc Create a pond document
+     * @param id - The id of the document
+     * @private
+     */
+    _createPondDocument(id) {
+        const removeDoc = this._delete.bind(this, id);
+        const updateDoc = this.set.bind(this, id);
+        const getDoc = this._getDocument.bind(this, id);
+        return new PondDocument(id, removeDoc, updateDoc, getDoc);
+    }
+    /**
+     * @desc Gets the raw database
+     * @protected
+     */
+    _getDB() {
+        return this._db;
+    }
+}
+exports.SimpleBase = SimpleBase;

package/pondBase/simpleBase.test.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const simpleBase_1 = require("./simpleBase");
+describe('SimpleBase', () => {
+    it('should ba instantiated', () => {
+        const base = new simpleBase_1.SimpleBase();
+        expect(base).toBeTruthy();
+    });
+    it('should set a value', () => {
+        const base = new simpleBase_1.SimpleBase();
+        base.set('test', { name: 'test' });
+        expect(base.size).toBe(1);
+    });
+    it('should get a value', () => {
+        var _a;
+        const base = new simpleBase_1.SimpleBase();
+        base.set('test', { name: 'test' });
+        expect((_a = base.get('test')) === null || _a === void 0 ? void 0 : _a.doc).toStrictEqual({ name: 'test' });
+    });
+    it('should upsert a value', () => {
+        var _a, _b;
+        const base = new simpleBase_1.SimpleBase();
+        expect((_a = base.get('test')) === null || _a === void 0 ? void 0 : _a.doc).toBeUndefined();
+        expect(base.size).toBe(0);
+        base.getOrCreate('test', () => ({ name: 'test' }));
+        expect(base.size).toBe(1);
+        expect((_b = base.get('test')) === null || _b === void 0 ? void 0 : _b.doc).toStrictEqual({ name: 'test' });
+    });
+    it('should tell if a document exists', () => {
+        const base = new simpleBase_1.SimpleBase();
+        expect(base.has('test')).toBe(false);
+        base.set('test', { name: 'test' });
+        expect(base.has('test')).toBe(true);
+    });
+    it('should return an array of filtered documents', () => {
+        const base = new simpleBase_1.SimpleBase();
+        base.set('test', { name: 'test' });
+        base.set('test2', { name: 'test2' });
+        base.set('test3', { name: 'test3' });
+        expect(base.filter(doc => doc.name === 'test').map(doc => doc.doc.name)).toEqual(['test']);
+    });
+    it('should return an array of mapped documents', () => {
+        const base = new simpleBase_1.SimpleBase();
+        base.set('test', { name: 'test' });
+        base.set('test2', { name: 'test2' });
+        base.set('test3', { name: 'test3' });
+        expect(base.map(doc => doc.name)).toEqual(['test', 'test2', 'test3']);
+    });
+    it('should return an empty array of  documents', () => {
+        const base = new simpleBase_1.SimpleBase();
+        expect(base.map(doc => doc.name)).toEqual([]);
+        expect(base.filter(doc => doc.name === 'test').map(doc => doc.doc.name)).toEqual([]);
+    });
+    it('should return a document by a query function', () => {
+        var _a;
+        const base = new simpleBase_1.SimpleBase();
+        base.set('test', { name: 'test' });
+        base.set('test2', { name: 'test2' });
+        base.set('test3', { name: 'test3' });
+        expect((_a = base.find(doc => doc.name === 'test2')) === null || _a === void 0 ? void 0 : _a.doc.name).toBe('test2');
+    });
+    it('should return null if no document is found by a query function', () => {
+        const base = new simpleBase_1.SimpleBase();
+        base.set('test', { name: 'test' });
+        base.set('test2', { name: 'test2' });
+        base.set('test3', { name: 'test3' });
+        expect(base.find(doc => doc.name === 'test4')).toBeNull();
+    });
+    it('should reduce the pond to a single value', () => {
+        const base = new simpleBase_1.SimpleBase();
+        base.set('test', { name: 'test' });
+        base.set('test2', { name: 'test2' });
+        base.set('test3', { name: 'test3' });
+        expect(base.reduce((acc, doc) => acc + doc.name, '')).toBe('testtest2test3');
+    });
+    it('should return the size of the pond', () => {
+        const base = new simpleBase_1.SimpleBase();
+        base.set('test', { name: 'test' });
+        base.set('test2', { name: 'test2' });
+        base.set('test3', { name: 'test3' });
+        expect(base.size).toBe(3);
+    });
+    it('should provide an empty document', () => {
+        const base = new simpleBase_1.SimpleBase();
+        const test = base.createGenericDocument();
+        expect(test).toBeInstanceOf(simpleBase_1.PondDocument);
+        expect(test.doc).toBeNull();
+    });
+    it('should provide a document with a value', () => {
+        const base = new simpleBase_1.SimpleBase();
+        const test = base.createGenericDocument('test');
+        expect(base.size).toBe(0);
+        expect(test).toBeInstanceOf(simpleBase_1.PondDocument);
+        expect(test.id).toBe('test');
+    });
+    it('should be iterable', () => {
+        const base = new simpleBase_1.SimpleBase();
+        base.set('test', { name: 'test' });
+        base.set('test2', { name: 'test2' });
+        base.set('test3', { name: 'test3' });
+        expect([...base].map(doc => doc.doc.name)).toEqual(['test', 'test2', 'test3']);
+    });
+    it('should be iterable with a for of loop', () => {
+        const base = new simpleBase_1.SimpleBase();
+        base.set('test', { name: 'test' });
+        base.set('test2', { name: 'test2' });
+        base.set('test3', { name: 'test3' });
+        const docs = [];
+        for (const doc of base) {
+            docs.push(doc.doc.name);
+        }
+        expect(docs).toEqual(['test', 'test2', 'test3']);
+    });
+    it('should be have a generator', () => {
+        const base = new simpleBase_1.SimpleBase();
+        base.set('test', { name: 'test' });
+        base.set('test2', { name: 'test2' });
+        base.set('test3', { name: 'test3' });
+        const docs = [];
+        for (const doc of base.generator()) {
+            docs.push(doc.doc.name);
+        }
+        expect(docs).toEqual(['test', 'test2', 'test3']);
+    });
+});
+describe('PondDocument', () => {
+    it('should be able to set a value', () => {
+        var _a;
+        const base = new simpleBase_1.SimpleBase();
+        const test = base.createGenericDocument('test');
+        test.updateDoc({ name: 'test' });
+        expect((_a = base.get('test')) === null || _a === void 0 ? void 0 : _a.doc).toStrictEqual({ name: 'test' });
+    });
+    it('should be able to get a value', () => {
+        const base = new simpleBase_1.SimpleBase();
+        const test = base.createGenericDocument('test');
+        test.updateDoc({ name: 'test' });
+        expect(test.doc).toStrictEqual({ name: 'test' });
+    });
+    it('should be able to delete a value', () => {
+        const base = new simpleBase_1.SimpleBase();
+        const test = base.createGenericDocument('test');
+        test.updateDoc({ name: 'test' });
+        expect(base.size).toBe(1);
+        test.removeDoc();
+        expect(base.size).toBe(0);
+    });
+    it('should be able to get the id', () => {
+        const base = new simpleBase_1.SimpleBase();
+        const test = base.createGenericDocument('test');
+        expect(test.id).toBe('test');
+    });
+});

package/pondBase/types.d.ts

@@ -0,0 +1,2 @@
+export declare type default_t<T = any> = Record<string, T>;
+export declare type PondPath = string | RegExp;

package/pondBase/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/pondClient/channel.d.ts

@@ -0,0 +1,66 @@
+import {Subscription} from "rxjs";
+import {PondAssigns, PondMessage, PondPresence} from "../pondSocket";
+
+export declare type ChannelParams = PondAssigns;
+
+export declare class Channel {
+    readonly channel: string;
+
+    get isActive(): boolean;
+
+    /**
+     * @desc Connects to the channel.
+     */
+    join(): this;
+
+    /**
+     * @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 callback - The callback to call when a message is received.
+     */
+    onMessage(callback: (event: string, message: PondMessage) => void): Subscription;
+
+    /**
+     * @desc Broadcasts a message to the channel, including yourself.
+     * @param event - The event to send.
+     * @param payload - The message to send.
+     */
+    broadcast(event: string, payload: PondMessage): void;
+
+    /**
+     * @desc Broadcasts a message to every other client in the channel except yourself.
+     * @param event - The event to send.
+     * @param payload - The message to send.
+     */
+    broadcastFrom(event: string, payload: PondMessage): void;
+
+    /**
+     * @desc Updates the presence state of the current client in the channel.
+     * @param presence - The presence state to update.
+     */
+    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.
+     */
+    sendMessage(event: string, payload: PondMessage, recipient: string[]): void;
+
+    /**
+     * @desc Listens for the connections state of the channel.
+     * @param callback - The callback to call when the connection state changes.
+     */
+    onConnectionChange(callback: (connected: boolean) => void): import("../pondBase").Subscription;
+}

package/pondClient/channel.js

@@ -0,0 +1,152 @@
+"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) {
+        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);
+    }
+    get isActive() {
+        return this._connectedSubject.value;
+    }
+    /**
+     * @desc Connects to the channel.
+     */
+    join() {
+        if (this._connectedSubject.value)
+            return this;
+        const observable = this._init();
+        const subscription = observable
+            .subscribe(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();
+        });
+        this._subscriptions.push(subscription);
+        return this;
+    }
+    /**
+     * @desc Disconnects from the channel.
+     */
+    leave() {
+        void this._connectedSubject.publish(false);
+        this._presenceSubject.complete();
+        this._subscriptions.forEach(subscription => 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);
+        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));
+        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 = {
+            channelName: this.channel,
+            payload, 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 = {
+            channelName: this.channel,
+            payload, 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) {
+        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 = {
+            channelName: this.channel,
+            payload, event, 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);
+        this._subscriptions.push(sub);
+        return sub;
+    }
+    /**
+     * @desc Initializes the channel.
+     * @private
+     */
+    _init() {
+        const observable = this._socket.multiplex(() => ({
+            action: "JOIN_CHANNEL",
+            channelName: this.channel,
+            event: "JOIN_CHANNEL",
+            payload: this._params
+        }), () => ({
+            action: "LEAVE_CHANNEL",
+            channelName: this.channel,
+            event: "LEAVE_CHANNEL",
+            payload: this._params
+        }), message => message.channelName === this.channel);
+        return observable;
+    }
+}
+exports.Channel = Channel;

package/pondClient/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./socket";
+export * from "./channel";

package/pondClient/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./socket"), exports);
+__exportStar(require("./channel"), exports);

package/pondClient/socket.d.ts

@@ -0,0 +1,42 @@
+import {Channel, ChannelParams} from "./channel";
+import {default_t} from "../pondBase";
+
+declare type PondParams = {
+    [key: string]: string;
+};
+declare type PondState = "CONNECTING" | "OPEN" | "CLOSING" | "CLOSED";
+
+export declare class PondClient {
+
+    constructor(endpoint: string, params?: PondParams);
+
+    /**
+     * @desc Connects to the server and returns the socket.
+     */
+    connect(): this | undefined;
+
+    /**
+     * @desc Returns the current state of the socket.
+     */
+    getState(): PondState;
+
+    /**
+     * @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: string, params?: ChannelParams): Channel | null;
+
+    /**
+     * @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: (event: string, message: default_t) => void): void;
+
+    /**
+     * @desc Disconnects the socket from the server.
+     */
+    disconnect(): void;
+}
+
+export {};