@eleven-am/pondsocket 0.1.9 → 0.1.11

package/package.json

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

package/pondBase/baseClass.js

@@ -1,71 +1,53 @@
 "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.BaseClass = void 0;
-var BaseClass = /** @class */ (function () {
-    function BaseClass() {
-    }
+class BaseClass {
     /**
      * @desc checks if the pattern is matchable
      * @param pattern - the pattern to check
      */
-    BaseClass.isPatternMatchable = function (pattern) {
+    static isPatternMatchable(pattern) {
         return typeof pattern === 'string' && pattern.includes(':');
-    };
+    }
     /**
      * @desc compares string to string | regex
      * @param string - the string to compare to the pattern
      * @param pattern - the pattern to compare to the string
      */
-    BaseClass.prototype.compareStringToPattern = function (string, pattern) {
+    compareStringToPattern(string, pattern) {
         if (typeof pattern === 'string')
             return string.split('?')[0] === pattern;
         else
             return pattern.test(string);
-    };
+    }
     /**
      * @desc Checks if the given object is empty
      * @param obj - the object to check
      */
-    BaseClass.prototype.isObjectEmpty = function (obj) {
+    isObjectEmpty(obj) {
         return Object.keys(obj).length === 0;
-    };
+    }
     /**
      * @desc Generates a pond request resolver object
      * @param path - the path to resolve
      * @param address - the address to resolve
      */
-    BaseClass.prototype.generateEventRequest = function (path, address) {
-        var match = this._matchStringToPattern(address, path);
+    generateEventRequest(path, address) {
+        const match = this._matchStringToPattern(address, path);
         if (match)
             return {
                 params: match, query: this._parseQueries(address), address: address
             };
         return null;
-    };
+    }
     /**
      * @desc Compares if two objects are equal
      * @param obj1 - the first object
      * @param obj2 - the second object
      */
-    BaseClass.prototype.areEqual = function (obj1, obj2) {
+    areEqual(obj1, obj2) {
         return JSON.stringify(obj1) === JSON.stringify(obj2);
-    };
+    }
     /**
      * @desc Creates an object from the params of a path
      * @param path - the path to create the object from
@@ -74,17 +56,17 @@ var BaseClass = /** @class */ (function () {
      * /api/id?name=abc should return { name: 'abc' }
      * /api/id?name=abc&age=123 should return { name: 'abc', age: '123' }
      */
-    BaseClass.prototype._parseQueries = function (path) {
-        var obj = {};
-        var params = path.split('?')[1];
+    _parseQueries(path) {
+        const obj = {};
+        const params = path.split('?')[1];
         if (params) {
-            params.split('&').forEach(function (param) {
-                var _a = __read(param.split('='), 2), key = _a[0], value = _a[1];
+            params.split('&').forEach(param => {
+                const [key, value] = param.split('=');
                 obj[key] = value;
             });
         }
         return obj;
-    };
+    }
     /**
      * @desc Returns the {key: value} matches of a string
      * @param string - the string to create the regex from
@@ -96,35 +78,34 @@ var BaseClass = /** @class */ (function () {
      * hello:id should match hello:123 and return { id: 123 }
      * @private
      */
-    BaseClass.prototype._matchString = function (string, pattern) {
-        var replace = pattern.replace(/:[^/]+/g, '([^/]+)');
-        var regExp = new RegExp("^".concat(replace, "$"));
-        var matches = string.split('?')[0].match(regExp);
+    _matchString(string, pattern) {
+        const replace = pattern.replace(/:[^/]+/g, '([^/]+)');
+        const regExp = new RegExp(`^${replace}$`);
+        const matches = string.split('?')[0].match(regExp);
         if (matches) {
-            var keys = pattern.match(/:[^/]+/g);
+            const keys = pattern.match(/:[^/]+/g);
             if (keys) {
-                var obj_1 = {};
-                keys.forEach(function (key, index) {
-                    obj_1[key.replace(':', '')] = matches[index + 1].replace(/\?.*$/, '');
+                const obj = {};
+                keys.forEach((key, index) => {
+                    obj[key.replace(':', '')] = matches[index + 1].replace(/\?.*$/, '');
                 });
-                return obj_1;
+                return obj;
             }
         }
         return null;
-    };
+    }
     /**
      * @desc matches a string to a pattern and returns its params if any
      * @param string - the string to match
      * @param pattern - the pattern to match to
      */
-    BaseClass.prototype._matchStringToPattern = function (string, pattern) {
+    _matchStringToPattern(string, pattern) {
         if (BaseClass.isPatternMatchable(pattern))
             return this._matchString(string, pattern);
-        var valid = this.compareStringToPattern(string, pattern);
+        const valid = this.compareStringToPattern(string, pattern);
         if (valid)
             return {};
         return null;
-    };
-    return BaseClass;
-}());
+    }
+}
 exports.BaseClass = BaseClass;

package/pondBase/baseClass.test.js

@@ -1,31 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var baseClass_1 = require("./baseClass");
-describe('BaseClass', function () {
-    var baseClass = new baseClass_1.BaseClass();
-    it('should return true when object is empty', function () {
+const baseClass_1 = require("./baseClass");
+describe('BaseClass', () => {
+    const baseClass = new baseClass_1.BaseClass();
+    it('should return true when object is empty', () => {
         expect(baseClass.isObjectEmpty({})).toBe(true);
     });
-    it('should return false when object is not empty', function () {
+    it('should return false when object is not empty', () => {
         expect(baseClass.isObjectEmpty({ test: 5 })).toBe(false);
     });
-    it('should return true if a string matches a regex | string', function () {
-        var regex = new RegExp(/^test/);
+    it('should return true if a string matches a regex | string', () => {
+        const regex = new RegExp(/^test/);
         expect(baseClass.compareStringToPattern('test', regex)).toBe(true);
-        var string = 'test';
+        const string = 'test';
         expect(baseClass.compareStringToPattern('test', string)).toBe(true);
     });
-    it('should return false if a string does not match a regex | string', function () {
-        var regex = new RegExp(/^test$/);
+    it('should return false if a string does not match a regex | string', () => {
+        const regex = new RegExp(/^test$/);
         expect(baseClass.compareStringToPattern('test2', regex)).toBe(false);
-        var string = 'test';
+        const string = 'test';
         expect(baseClass.compareStringToPattern('test2', string)).toBe(false);
     });
-    it('should return the params of a string matching the pattern', function () {
-        var pattern = '/test/:id';
-        var secondPattern = '/test/:id/:id2';
-        var string = '/test/5';
-        var secondString = '/test/5/6';
+    it('should return the params of a string matching the pattern', () => {
+        const pattern = '/test/:id';
+        const secondPattern = '/test/:id/:id2';
+        const string = '/test/5';
+        const secondString = '/test/5/6';
         expect(baseClass['_matchString'](string, pattern)).toEqual({ id: '5' });
         expect(baseClass['_matchString'](secondString, secondPattern)).toEqual({ id: '5', id2: '6' });
         // this function fails if the pattern is not a string or regex
@@ -33,41 +33,41 @@ describe('BaseClass', function () {
         // But will return null if the string is smaller than the pattern
         expect(baseClass['_matchString'](string, secondPattern)).toEqual(null);
         //it should also match patterns without the slash
-        var thirdPattern = 'test:id';
-        var thirdString = 'test5';
+        const thirdPattern = 'test:id';
+        const thirdString = 'test5';
         expect(baseClass['_matchString'](thirdString, thirdPattern)).toEqual({ id: '5' });
     });
-    it('should return the query of string', function () {
-        var string = '/test/5?test=5';
-        var secondString = '/test/5?test=5&test2=6';
+    it('should return the query of string', () => {
+        const string = '/test/5?test=5';
+        const secondString = '/test/5?test=5&test2=6';
         expect(baseClass['_parseQueries'](string)).toEqual({ test: '5' });
         expect(baseClass['_parseQueries'](secondString)).toEqual({ test: '5', test2: '6' });
     });
-    it('should return true if an object matches another object', function () {
-        var object = { test: 5 };
-        var secondObject = { test: 5, test2: 6 };
+    it('should return true if an object matches another object', () => {
+        const object = { test: 5 };
+        const secondObject = { test: 5, test2: 6 };
         expect(baseClass.areEqual(object, object)).toBe(true);
         expect(baseClass.areEqual(object, secondObject)).toBe(false);
     });
-    it('should return null if the string does not match the pattern', function () {
-        var pattern = 'pondSocket';
-        var string = '/test2/5';
+    it('should return null if the string does not match the pattern', () => {
+        const pattern = 'pondSocket';
+        const string = '/test2/5';
         expect(baseClass['_matchStringToPattern'](string, pattern)).toBe(null);
     });
-    it('should return the params of a string matching the pattern', function () {
-        var pattern = 'pondSocket';
-        var string = 'pondSocket';
+    it('should return the params of a string matching the pattern', () => {
+        const pattern = 'pondSocket';
+        const string = 'pondSocket';
         expect(baseClass['_matchStringToPattern'](string, pattern)).toEqual({});
     });
-    it('should generateEventRequest', function () {
-        var pattern = 'pondSocket:test';
-        var string = 'pondSockethello?test=5&test2=6';
+    it('should generateEventRequest', () => {
+        const pattern = 'pondSocket:test';
+        const string = 'pondSockethello?test=5&test2=6';
         expect(baseClass.generateEventRequest(pattern, string)).toEqual({
             address: string,
             params: { test: 'hello' },
             query: { test: '5', test2: '6' }
         });
-        var unMatchingString = 'pondXocket2hello?test=5&test2=6';
+        const unMatchingString = 'pondXocket2hello?test=5&test2=6';
         expect(baseClass.generateEventRequest(pattern, unMatchingString)).toEqual(null);
     });
 });

package/pondBase/pondBase.js

@@ -1,121 +1,60 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PondBase = void 0;
-var pubSub_1 = require("./pubSub");
-var simpleBase_1 = require("./simpleBase");
-var enums_1 = require("./enums");
-var PondBase = /** @class */ (function (_super) {
-    __extends(PondBase, _super);
-    function PondBase() {
-        var _this = this;
-        var broadcast = new pubSub_1.Broadcast();
-        _this = _super.call(this, function (data) { return broadcast.publish(data); }) || this;
-        _this._broadcast = broadcast;
-        return _this;
+const pubSub_1 = require("./pubSub");
+const simpleBase_1 = require("./simpleBase");
+const enums_1 = require("./enums");
+class PondBase extends simpleBase_1.SimpleBase {
+    constructor() {
+        const broadcast = new pubSub_1.Broadcast();
+        super((data) => broadcast.publish(data));
+        this._broadcast = broadcast;
+    }
+    /**
+     * @des Generate a key for a new document
+     */
+    get _nanoid() {
+        let id = '';
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        for (let i = 0; i < 21; i++) {
+            id += chars.charAt(Math.floor(Math.random() * chars.length));
+        }
+        return id;
     }
-    Object.defineProperty(PondBase.prototype, "_nanoid", {
-        /**
-         * @des Generate a key for a new document
-         */
-        get: function () {
-            var id = '';
-            var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-            for (var i = 0; i < 21; i++) {
-                id += chars.charAt(Math.floor(Math.random() * chars.length));
-            }
-            return id;
-        },
-        enumerable: false,
-        configurable: true
-    });
     /**
      * @desc Subscribe to the database
      * @param handler - The handler to call when the database is updated
      */
-    PondBase.prototype.subscribe = function (handler) {
-        var _this = this;
-        return this._broadcast.subscribe(function (data) {
-            var change = enums_1.PondBaseActions.UPDATE_IN_POND;
+    subscribe(handler) {
+        return this._broadcast.subscribe((data) => {
+            let change = enums_1.PondBaseActions.UPDATE_IN_POND;
             if (data.oldValue === null)
                 change = enums_1.PondBaseActions.ADD_TO_POND;
             else if (data.currentValue === null)
                 change = enums_1.PondBaseActions.REMOVE_FROM_POND;
-            handler(Object.values(_this._getDB()), data.currentValue || data.oldValue, change);
+            handler(Object.values(this._getDB()), data.currentValue || data.oldValue, change);
         });
-    };
+    }
     /**
      * @desc Add a document to the database
      * @param doc - The document to add
      */
-    PondBase.prototype.addDoc = function (doc) {
-        return _super.prototype.set.call(this, this._nanoid, doc);
-    };
+    addDoc(doc) {
+        return super.set(this._nanoid, doc);
+    }
     /**
      * @desc Left join two ponds on a key on this pond and a foreign key on the other pond
      * @param pond - The pond to join with
      * @param key - The key to join on
      * @param foreignKey - The foreign key to join on
      */
-    PondBase.prototype.leftJoin = function (pond, key, foreignKey) {
-        var e_1, _a;
-        var newPond = new PondBase();
-        var _loop_1 = function (doc) {
-            var _d;
-            var foreignDoc = pond.find(function (d) { return d[foreignKey] === doc.doc[key]; });
-            newPond.set(doc.id, __assign(__assign({}, doc.doc), (_d = {}, _d[key] = (foreignDoc === null || foreignDoc === void 0 ? void 0 : foreignDoc.doc) || null, _d)));
-        };
-        try {
-            for (var _b = __values(this), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var doc = _c.value;
-                _loop_1(doc);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_1) throw e_1.error; }
+    leftJoin(pond, key, foreignKey) {
+        const newPond = new PondBase();
+        for (const doc of this) {
+            const foreignDoc = pond.find((d) => d[foreignKey] === doc.doc[key]);
+            newPond.set(doc.id, Object.assign(Object.assign({}, doc.doc), { [key]: (foreignDoc === null || foreignDoc === void 0 ? void 0 : foreignDoc.doc) || null }));
         }
         return newPond;
-    };
-    return PondBase;
-}(simpleBase_1.SimpleBase));
+    }
+}
 exports.PondBase = PondBase;

package/pondBase/pondBase.test.js

@@ -1,129 +1,101 @@
 "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;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-var pondBase_1 = require("./pondBase");
-var enums_1 = require("./enums");
-describe('PondBase', function () {
-    it('should be able to take in a subscriber', function () {
-        var base = new pondBase_1.PondBase();
+const pondBase_1 = require("./pondBase");
+const enums_1 = require("./enums");
+describe('PondBase', () => {
+    it('should be able to take in a subscriber', () => {
+        const base = new pondBase_1.PondBase();
         expect(base['_broadcast']['_subscribers'].size).toBe(0);
-        var mockSubscriber = jest.fn();
+        const mockSubscriber = jest.fn();
         base.subscribe(mockSubscriber);
         expect(base['_broadcast']['_subscribers'].size).toBe(1);
     });
-    it('should be able to remove a subscriber', function () {
-        var base = new pondBase_1.PondBase();
+    it('should be able to remove a subscriber', () => {
+        const base = new pondBase_1.PondBase();
         expect(base['_broadcast']['_subscribers'].size).toBe(0);
-        var mockSubscriber = jest.fn();
-        var subscription = base.subscribe(mockSubscriber);
+        const mockSubscriber = jest.fn();
+        const subscription = base.subscribe(mockSubscriber);
         expect(base['_broadcast']['_subscribers'].size).toBe(1);
         subscription.unsubscribe();
         expect(base['_broadcast']['_subscribers'].size).toBe(0);
     });
-    it('should fire the subscriber when a document is added', function () {
-        var base = new pondBase_1.PondBase();
-        var mockSubscriber = jest.fn();
+    it('should fire the subscriber when a document is added', () => {
+        const base = new pondBase_1.PondBase();
+        const mockSubscriber = jest.fn();
         base.subscribe(mockSubscriber);
         base.set('test', { name: 'test' });
         expect(mockSubscriber).toBeCalled();
         expect(mockSubscriber).toBeCalledWith([{ name: "test" }], { name: "test" }, enums_1.PondBaseActions.ADD_TO_POND);
     });
-    it('should fire the subscriber when a document is removed', function () {
-        var base = new pondBase_1.PondBase();
-        var mockSubscriber = jest.fn();
+    it('should fire the subscriber when a document is removed', () => {
+        const base = new pondBase_1.PondBase();
+        const mockSubscriber = jest.fn();
         base.subscribe(mockSubscriber);
-        var data = base.set('test', { name: 'test' });
+        const data = base.set('test', { name: 'test' });
         expect(mockSubscriber).toBeCalledWith([{ name: "test" }], { name: "test" }, enums_1.PondBaseActions.ADD_TO_POND);
         mockSubscriber.mockClear();
         data.removeDoc();
         expect(mockSubscriber).toBeCalledWith([], { name: "test" }, enums_1.PondBaseActions.REMOVE_FROM_POND);
     });
-    it('should fire the subscriber when a document is updated', function () {
-        var base = new pondBase_1.PondBase();
-        var mockSubscriber = jest.fn();
+    it('should fire the subscriber when a document is updated', () => {
+        const base = new pondBase_1.PondBase();
+        const mockSubscriber = jest.fn();
         base.subscribe(mockSubscriber);
-        var data = base.set('test', { name: 'test' });
+        const data = base.set('test', { name: 'test' });
         expect(mockSubscriber).toBeCalledWith([{ name: "test" }], { name: "test" }, enums_1.PondBaseActions.ADD_TO_POND);
         mockSubscriber.mockClear();
         data.updateDoc({ name: 'test2' });
         expect(mockSubscriber).toBeCalledWith([{ name: "test2" }], { name: "test2" }, enums_1.PondBaseActions.UPDATE_IN_POND);
     });
-    it('should add a document to the database', function () {
+    it('should add a document to the database', () => {
         var _a, _b;
-        var base = new pondBase_1.PondBase();
-        var data = base.addDoc({ name: 'test' });
+        const base = new pondBase_1.PondBase();
+        const data = base.addDoc({ name: 'test' });
         expect(data.id).toBeDefined();
         expect((_a = base.get(data.id)) === null || _a === void 0 ? void 0 : _a.doc).toEqual(data.doc);
         expect((_b = base.get(data.id)) === null || _b === void 0 ? void 0 : _b.doc).toEqual({ name: 'test' });
     });
-    it('should left join with another pond', function () {
-        var owners = new pondBase_1.PondBase();
-        var pets = new pondBase_1.PondBase();
+    it('should left join with another pond', () => {
+        const owners = new pondBase_1.PondBase();
+        const pets = new pondBase_1.PondBase();
         owners.addDoc({ name: 'test', age: 10 });
         owners.set('test2', { name: 'test2', age: 12 });
         pets.addDoc({ name: 'test', owner: 'test' });
         pets.addDoc({ name: 'test2', owner: 'test2' });
         pets.set('test3', { name: 'test3', owner: 'test3' });
-        var joined = pets.leftJoin(owners, 'owner', 'name');
-        expect(__spreadArray([], __read(joined), false).map(function (_a) {
-            var doc = _a.doc;
-            return doc;
-        })).toEqual([
+        const joined = pets.leftJoin(owners, 'owner', 'name');
+        expect([...joined].map(({ doc }) => doc)).toEqual([
             { name: 'test', owner: { name: 'test', age: 10 } },
             { name: 'test2', owner: { name: 'test2', age: 12 } },
             { name: 'test3', owner: null }
         ]);
     });
-    it('should be able to get the keys', function () {
-        var base = new pondBase_1.PondBase();
+    it('should be able to get the keys', () => {
+        const base = new pondBase_1.PondBase();
         base.set('test', { name: 'test' });
         base.set('test2', { name: 'test2' });
         expect(base.keys).toEqual(['test', 'test2']);
     });
-    it('should be able to get the values', function () {
-        var base = new pondBase_1.PondBase();
+    it('should be able to get the values', () => {
+        const base = new pondBase_1.PondBase();
         base.addDoc({ name: 'test' });
         base.set('test2', { name: 'test2' });
         expect(base.values).toEqual([{ name: 'test' }, { name: 'test2' }]);
     });
-    it('should be able to upsert a document', function () {
+    it('should be able to upsert a document', () => {
         var _a, _b;
-        var base = new pondBase_1.PondBase();
+        const base = new pondBase_1.PondBase();
         base.upsert('test', { name: 'test' });
         expect((_a = base.get('test')) === null || _a === void 0 ? void 0 : _a.doc).toEqual({ name: 'test' });
         base.upsert('test', { name: 'test2' });
         expect((_b = base.get('test')) === null || _b === void 0 ? void 0 : _b.doc).toEqual({ name: 'test2' });
     });
-    it('should be able to getOrCreate a document with a function', function () {
+    it('should be able to getOrCreate a document with a function', () => {
         var _a, _b;
-        var base = new pondBase_1.PondBase();
-        base.getOrCreate('test', function () { return ({ name: 'test' }); });
+        const base = new pondBase_1.PondBase();
+        base.getOrCreate('test', () => ({ name: 'test' }));
         expect((_a = base.get('test')) === null || _a === void 0 ? void 0 : _a.doc).toEqual({ name: 'test' });
-        base.getOrCreate('test', function () { return ({ name: 'test2' }); });
+        base.getOrCreate('test', () => ({ name: 'test2' }));
         expect((_b = base.get('test')) === null || _b === void 0 ? void 0 : _b.doc).toEqual({ name: 'test' });
     });
 });

package/pondBase/pubSub.d.ts

@@ -4,11 +4,6 @@ export declare class Subscription {
 
 export declare class Broadcast<T, A> {
 
-    /**
-     * @desc Gets the number of subscribers
-     */
-    get subscriberCount(): number;
-
     /**
      * @desc Subscribe to the broadcast
      * @param handler - The handler to call when the broadcast is published
@@ -35,17 +30,21 @@ export declare class Subject<T, A> extends Broadcast<T, A> {
      */
     get value(): T;
 
+    /**
+     * @desc Get the list of observers
+     * @returns The list of observers
+     */
+    get observers(): Set<(data: T) => Anything<A>>;
+
     /**
      * @desc Subscribe to the subject
-     * @param handler - The handler to call when the subject is published
      */
     subscribe(handler: (data: T) => A): Subscription;
 
     /**
      * @desc Publish to the subject
-     * @param data - The data to publish
      */
-    publish(data: T): A | undefined;
+    publish(data: T): Anything<A>;
 }
 
 export declare class EventPubSub<T, A> {
@@ -55,7 +54,7 @@ export declare class EventPubSub<T, A> {
      * @param event - The event to subscribe to
      * @param handler - The handler to call when the event subject is published
      */
-    subscribe(event: string, handler: (data: T) => A): Subscription;
+    subscribe(event: string, handler: (data: T) => Anything<A>): Subscription;
 
     /**
      * @desc Publish to the event subject