@eleven-am/pondsocket 0.1.7 → 0.1.9

package/README.md

@@ -19,13 +19,11 @@ Multiple endpoints can be created but every endpoint is independent of the other
 
 ```js
   import { PondSocket } from "@eleven-am/pondsocket";
-  import parse from "url";
   
   const pond = new PondSocket();
  
   const endpoint = pond.createEndpoint('/api/socket', (req, res, _endpoint) => {
-       const { query } = parse(req.url || '');     
-       const { token } = query;     
+       const token = req.query.token;   
        if (!token)         
             return res.reject('No token provided');      
        res.accept({
@@ -69,7 +67,7 @@ It can be anything from a boolean to an instance of a class. This data cannot be
 
 ```js
     channel.on('hello', (req, res, channel) => {      
-       const users = channel.getPresence();      
+       const users = channel.presence;      
        res.assign({
            assign: {
                pingDate: new Date(),
@@ -91,7 +89,7 @@ In case there is no *on* function, the message will be sent without any action b
 ```js
     import { PondClient } from "@eleven-am/pondsocket/client";
 
-    export const socket = new PondClientSocket('/api/socket', {});
+    export const socket = new PondClient('/api/socket', {});
     socket.connect();
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "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/baseClass.js

@@ -1,53 +1,71 @@
 "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;
-class BaseClass {
+var BaseClass = /** @class */ (function () {
+    function BaseClass() {
+    }
     /**
      * @desc checks if the pattern is matchable
      * @param pattern - the pattern to check
      */
-    static isPatternMatchable(pattern) {
+    BaseClass.isPatternMatchable = function (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
      */
-    compareStringToPattern(string, pattern) {
+    BaseClass.prototype.compareStringToPattern = function (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
      */
-    isObjectEmpty(obj) {
+    BaseClass.prototype.isObjectEmpty = function (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
      */
-    generateEventRequest(path, address) {
-        const match = this._matchStringToPattern(address, path);
+    BaseClass.prototype.generateEventRequest = function (path, address) {
+        var 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
      */
-    areEqual(obj1, obj2) {
+    BaseClass.prototype.areEqual = function (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
@@ -56,17 +74,17 @@ class BaseClass {
      * /api/id?name=abc should return { name: 'abc' }
      * /api/id?name=abc&age=123 should return { name: 'abc', age: '123' }
      */
-    _parseQueries(path) {
-        const obj = {};
-        const params = path.split('?')[1];
+    BaseClass.prototype._parseQueries = function (path) {
+        var obj = {};
+        var params = path.split('?')[1];
         if (params) {
-            params.split('&').forEach(param => {
-                const [key, value] = param.split('=');
+            params.split('&').forEach(function (param) {
+                var _a = __read(param.split('='), 2), key = _a[0], value = _a[1];
                 obj[key] = value;
             });
         }
         return obj;
-    }
+    };
     /**
      * @desc Returns the {key: value} matches of a string
      * @param string - the string to create the regex from
@@ -78,34 +96,35 @@ class BaseClass {
      * hello:id should match hello:123 and return { id: 123 }
      * @private
      */
-    _matchString(string, pattern) {
-        const replace = pattern.replace(/:[^/]+/g, '([^/]+)');
-        const regExp = new RegExp(`^${replace}$`);
-        const matches = string.split('?')[0].match(regExp);
+    BaseClass.prototype._matchString = function (string, pattern) {
+        var replace = pattern.replace(/:[^/]+/g, '([^/]+)');
+        var regExp = new RegExp("^".concat(replace, "$"));
+        var matches = string.split('?')[0].match(regExp);
         if (matches) {
-            const keys = pattern.match(/:[^/]+/g);
+            var keys = pattern.match(/:[^/]+/g);
             if (keys) {
-                const obj = {};
-                keys.forEach((key, index) => {
-                    obj[key.replace(':', '')] = matches[index + 1].replace(/\?.*$/, '');
+                var obj_1 = {};
+                keys.forEach(function (key, index) {
+                    obj_1[key.replace(':', '')] = matches[index + 1].replace(/\?.*$/, '');
                 });
-                return obj;
+                return obj_1;
             }
         }
         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
      */
-    _matchStringToPattern(string, pattern) {
+    BaseClass.prototype._matchStringToPattern = function (string, pattern) {
         if (BaseClass.isPatternMatchable(pattern))
             return this._matchString(string, pattern);
-        const valid = this.compareStringToPattern(string, pattern);
+        var 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 });
-const baseClass_1 = require("./baseClass");
-describe('BaseClass', () => {
-    const baseClass = new baseClass_1.BaseClass();
-    it('should return true when object is empty', () => {
+var baseClass_1 = require("./baseClass");
+describe('BaseClass', function () {
+    var baseClass = new baseClass_1.BaseClass();
+    it('should return true when object is empty', function () {
         expect(baseClass.isObjectEmpty({})).toBe(true);
     });
-    it('should return false when object is not empty', () => {
+    it('should return false when object is not empty', function () {
         expect(baseClass.isObjectEmpty({ test: 5 })).toBe(false);
     });
-    it('should return true if a string matches a regex | string', () => {
-        const regex = new RegExp(/^test/);
+    it('should return true if a string matches a regex | string', function () {
+        var regex = new RegExp(/^test/);
         expect(baseClass.compareStringToPattern('test', regex)).toBe(true);
-        const string = 'test';
+        var string = 'test';
         expect(baseClass.compareStringToPattern('test', string)).toBe(true);
     });
-    it('should return false if a string does not match a regex | string', () => {
-        const regex = new RegExp(/^test$/);
+    it('should return false if a string does not match a regex | string', function () {
+        var regex = new RegExp(/^test$/);
         expect(baseClass.compareStringToPattern('test2', regex)).toBe(false);
-        const string = 'test';
+        var string = 'test';
         expect(baseClass.compareStringToPattern('test2', string)).toBe(false);
     });
-    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';
+    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';
         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', () => {
         // 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
-        const thirdPattern = 'test:id';
-        const thirdString = 'test5';
+        var thirdPattern = 'test:id';
+        var thirdString = 'test5';
         expect(baseClass['_matchString'](thirdString, thirdPattern)).toEqual({ id: '5' });
     });
-    it('should return the query of string', () => {
-        const string = '/test/5?test=5';
-        const secondString = '/test/5?test=5&test2=6';
+    it('should return the query of string', function () {
+        var string = '/test/5?test=5';
+        var 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', () => {
-        const object = { test: 5 };
-        const secondObject = { 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 };
         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', () => {
-        const pattern = 'pondSocket';
-        const string = '/test2/5';
+    it('should return null if the string does not match the pattern', function () {
+        var pattern = 'pondSocket';
+        var string = '/test2/5';
         expect(baseClass['_matchStringToPattern'](string, pattern)).toBe(null);
     });
-    it('should return the params of a string matching the pattern', () => {
-        const pattern = 'pondSocket';
-        const string = 'pondSocket';
+    it('should return the params of a string matching the pattern', function () {
+        var pattern = 'pondSocket';
+        var string = 'pondSocket';
         expect(baseClass['_matchStringToPattern'](string, pattern)).toEqual({});
     });
-    it('should generateEventRequest', () => {
-        const pattern = 'pondSocket:test';
-        const string = 'pondSockethello?test=5&test2=6';
+    it('should generateEventRequest', function () {
+        var pattern = 'pondSocket:test';
+        var string = 'pondSockethello?test=5&test2=6';
         expect(baseClass.generateEventRequest(pattern, string)).toEqual({
             address: string,
             params: { test: 'hello' },
             query: { test: '5', test2: '6' }
         });
-        const unMatchingString = 'pondXocket2hello?test=5&test2=6';
+        var unMatchingString = 'pondXocket2hello?test=5&test2=6';
         expect(baseClass.generateEventRequest(pattern, unMatchingString)).toEqual(null);
     });
 });

package/pondBase/pondBase.js

@@ -1,60 +1,121 @@
 "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;
-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;
+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;
     }
+    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
      */
-    subscribe(handler) {
-        return this._broadcast.subscribe((data) => {
-            let change = enums_1.PondBaseActions.UPDATE_IN_POND;
+    PondBase.prototype.subscribe = function (handler) {
+        var _this = this;
+        return this._broadcast.subscribe(function (data) {
+            var 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
      */
-    addDoc(doc) {
-        return super.set(this._nanoid, doc);
-    }
+    PondBase.prototype.addDoc = function (doc) {
+        return _super.prototype.set.call(this, 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
      */
-    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, { ...doc.doc, [key]: (foreignDoc === null || foreignDoc === void 0 ? void 0 : foreignDoc.doc) || null });
+    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; }
         }
         return newPond;
-    }
-}
+    };
+    return PondBase;
+}(simpleBase_1.SimpleBase));
 exports.PondBase = PondBase;

package/pondBase/pondBase.test.js

@@ -1,101 +1,129 @@
 "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 });
-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();
+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();
         expect(base['_broadcast']['_subscribers'].size).toBe(0);
-        const mockSubscriber = jest.fn();
+        var mockSubscriber = jest.fn();
         base.subscribe(mockSubscriber);
         expect(base['_broadcast']['_subscribers'].size).toBe(1);
     });
-    it('should be able to remove a subscriber', () => {
-        const base = new pondBase_1.PondBase();
+    it('should be able to remove a subscriber', function () {
+        var base = new pondBase_1.PondBase();
         expect(base['_broadcast']['_subscribers'].size).toBe(0);
-        const mockSubscriber = jest.fn();
-        const subscription = base.subscribe(mockSubscriber);
+        var mockSubscriber = jest.fn();
+        var 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', () => {
-        const base = new pondBase_1.PondBase();
-        const mockSubscriber = jest.fn();
+    it('should fire the subscriber when a document is added', function () {
+        var base = new pondBase_1.PondBase();
+        var 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', () => {
-        const base = new pondBase_1.PondBase();
-        const mockSubscriber = jest.fn();
+    it('should fire the subscriber when a document is removed', function () {
+        var base = new pondBase_1.PondBase();
+        var mockSubscriber = jest.fn();
         base.subscribe(mockSubscriber);
-        const data = base.set('test', { name: 'test' });
+        var 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', () => {
-        const base = new pondBase_1.PondBase();
-        const mockSubscriber = jest.fn();
+    it('should fire the subscriber when a document is updated', function () {
+        var base = new pondBase_1.PondBase();
+        var mockSubscriber = jest.fn();
         base.subscribe(mockSubscriber);
-        const data = base.set('test', { name: 'test' });
+        var 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', () => {
+    it('should add a document to the database', function () {
         var _a, _b;
-        const base = new pondBase_1.PondBase();
-        const data = base.addDoc({ name: 'test' });
+        var base = new pondBase_1.PondBase();
+        var 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', () => {
-        const owners = new pondBase_1.PondBase();
-        const pets = new pondBase_1.PondBase();
+    it('should left join with another pond', function () {
+        var owners = new pondBase_1.PondBase();
+        var 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' });
-        const joined = pets.leftJoin(owners, 'owner', 'name');
-        expect([...joined].map(({ doc }) => doc)).toEqual([
+        var joined = pets.leftJoin(owners, 'owner', 'name');
+        expect(__spreadArray([], __read(joined), false).map(function (_a) {
+            var doc = _a.doc;
+            return 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', () => {
-        const base = new pondBase_1.PondBase();
+    it('should be able to get the keys', function () {
+        var 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', () => {
-        const base = new pondBase_1.PondBase();
+    it('should be able to get the values', function () {
+        var 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', () => {
+    it('should be able to upsert a document', function () {
         var _a, _b;
-        const base = new pondBase_1.PondBase();
+        var 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', () => {
+    it('should be able to getOrCreate a document with a function', function () {
         var _a, _b;
-        const base = new pondBase_1.PondBase();
-        base.getOrCreate('test', () => ({ name: 'test' }));
+        var base = new pondBase_1.PondBase();
+        base.getOrCreate('test', function () { return ({ name: 'test' }); });
         expect((_a = base.get('test')) === null || _a === void 0 ? void 0 : _a.doc).toEqual({ name: 'test' });
-        base.getOrCreate('test', () => ({ name: 'test2' }));
+        base.getOrCreate('test', function () { return ({ name: 'test2' }); });
         expect((_b = base.get('test')) === null || _b === void 0 ? void 0 : _b.doc).toEqual({ name: 'test' });
     });
 });