mongodb-livedata-server 0.0.1

package/dist/meteor/random/AleaRandomGenerator.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractRandomGenerator_1 = __importDefault(require("./AbstractRandomGenerator"));
+// Alea PRNG, which is not cryptographically strong
+// see http://baagoe.org/en/wiki/Better_random_numbers_for_javascript
+// for a full discussion and Alea implementation.
+function Alea(seeds) {
+    function Mash() {
+        let n = 0xefc8249d;
+        const mash = (data) => {
+            data = data.toString();
+            for (let i = 0; i < data.length; i++) {
+                n += data.charCodeAt(i);
+                let h = 0.02519603282416938 * n;
+                n = h >>> 0;
+                h -= n;
+                h *= n;
+                n = h >>> 0;
+                h -= n;
+                n += h * 0x100000000; // 2^32
+            }
+            return (n >>> 0) * 2.3283064365386963e-10; // 2^-32
+        };
+        mash.version = 'Mash 0.9';
+        return mash;
+    }
+    let s0 = 0;
+    let s1 = 0;
+    let s2 = 0;
+    let c = 1;
+    if (seeds.length === 0) {
+        seeds = [+new Date];
+    }
+    let mash = Mash();
+    s0 = mash(' ');
+    s1 = mash(' ');
+    s2 = mash(' ');
+    for (let i = 0; i < seeds.length; i++) {
+        s0 -= mash(seeds[i]);
+        if (s0 < 0) {
+            s0 += 1;
+        }
+        s1 -= mash(seeds[i]);
+        if (s1 < 0) {
+            s1 += 1;
+        }
+        s2 -= mash(seeds[i]);
+        if (s2 < 0) {
+            s2 += 1;
+        }
+    }
+    mash = null;
+    const random = () => {
+        const t = (2091639 * s0) + (c * 2.3283064365386963e-10); // 2^-32
+        s0 = s1;
+        s1 = s2;
+        return s2 = t - (c = t | 0);
+    };
+    random.uint32 = () => random() * 0x100000000; // 2^32
+    random.fract53 = () => random() +
+        ((random() * 0x200000 | 0) * 1.1102230246251565e-16); // 2^-53
+    random.version = 'Alea 0.9';
+    random.args = seeds;
+    return random;
+}
+// options:
+// - seeds: an array
+//   whose items will be `toString`ed and used as the seed to the Alea
+//   algorithm
+class AleaRandomGenerator extends AbstractRandomGenerator_1.default {
+    constructor({ seeds = [] } = {}) {
+        super();
+        if (!seeds) {
+            throw new Error('No seeds were provided for Alea PRNG');
+        }
+        this.alea = Alea(seeds);
+    }
+    /**
+     * @name Random.fraction
+     * @summary Return a number between 0 and 1, like `Math.random`.
+     * @locus Anywhere
+     */
+    fraction() {
+        return this.alea();
+    }
+}
+exports.default = AleaRandomGenerator;

package/dist/meteor/random/NodeRandomGenerator.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = __importDefault(require("crypto"));
+const AbstractRandomGenerator_1 = __importDefault(require("./AbstractRandomGenerator"));
+class NodeRandomGenerator extends AbstractRandomGenerator_1.default {
+    /**
+     * @name Random.fraction
+     * @summary Return a number between 0 and 1, like `Math.random`.
+     * @locus Anywhere
+     */
+    fraction() {
+        const numerator = Number.parseInt(this.hexString(8), 16);
+        return numerator * 2.3283064365386963e-10; // 2^-3;
+    }
+    /**
+     * @name Random.hexString
+     * @summary Return a random string of `n` hexadecimal digits.
+     * @locus Anywhere
+     * @param {Number} n Length of the string
+     */
+    hexString(digits) {
+        const numBytes = Math.ceil(digits / 2);
+        let bytes;
+        // Try to get cryptographically strong randomness. Fall back to
+        // non-cryptographically strong if not available.
+        try {
+            bytes = crypto_1.default.randomBytes(numBytes);
+        }
+        catch (e) {
+            // XXX should re-throw any error except insufficient entropy
+            bytes = crypto_1.default.pseudoRandomBytes(numBytes);
+        }
+        const result = bytes.toString('hex');
+        // If the number of digits is odd, we'll have generated an extra 4 bits
+        // of randomness, so we need to trim the last digit.
+        return result.substring(0, digits);
+    }
+}
+exports.default = NodeRandomGenerator;

package/dist/meteor/random/createAleaGenerator.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const AleaRandomGenerator_1 = __importDefault(require("./AleaRandomGenerator"));
+// instantiate RNG.  Heuristically collect entropy from various sources when a
+// cryptographic PRNG isn't available.
+// client sources
+const height = (typeof window !== 'undefined' && window.innerHeight) ||
+    (typeof document !== 'undefined'
+        && document.documentElement
+        && document.documentElement.clientHeight) ||
+    (typeof document !== 'undefined'
+        && document.body
+        && document.body.clientHeight) ||
+    1;
+const width = (typeof window !== 'undefined' && window.innerWidth) ||
+    (typeof document !== 'undefined'
+        && document.documentElement
+        && document.documentElement.clientWidth) ||
+    (typeof document !== 'undefined'
+        && document.body
+        && document.body.clientWidth) ||
+    1;
+const agent = (typeof navigator !== 'undefined' && navigator.userAgent) || '';
+function createAleaGenerator() {
+    return new AleaRandomGenerator_1.default({
+        seeds: [new Date, height, width, agent, Math.random()],
+    });
+}
+exports.default = createAleaGenerator;

package/dist/meteor/random/createRandom.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const AleaRandomGenerator_1 = __importDefault(require("./AleaRandomGenerator"));
+const createAleaGenerator_1 = __importDefault(require("./createAleaGenerator"));
+function createRandom(generator) {
+    // Create a non-cryptographically secure PRNG with a given seed (using
+    // the Alea algorithm)
+    generator.createWithSeeds = (...seeds) => {
+        if (seeds.length === 0) {
+            throw new Error('No seeds were provided');
+        }
+        return new AleaRandomGenerator_1.default({ seeds });
+    };
+    // Used like `Random`, but much faster and not cryptographically
+    // secure
+    generator.insecure = (0, createAleaGenerator_1.default)();
+    return generator;
+}
+exports.default = createRandom;

package/dist/meteor/random/main.js

@@ -0,0 +1,12 @@
+"use strict";
+// We use cryptographically strong PRNGs (crypto.getRandomBytes())
+// When using crypto.getRandomValues(), our primitive is hexString(),
+// from which we construct fraction().
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Random = void 0;
+const NodeRandomGenerator_1 = __importDefault(require("./NodeRandomGenerator"));
+const createRandom_1 = __importDefault(require("./createRandom"));
+exports.Random = (0, createRandom_1.default)(new NodeRandomGenerator_1.default());

package/livedata_server.ts

@@ -0,0 +1,3 @@
+export { DDPServer } from "./meteor/ddp/livedata_server";
+export { LiveMongoConnection } from "./meteor/mongo/live_connection";
+export { LiveCursor } from "./meteor/mongo/live_cursor";

package/meteor/LICENSE

@@ -0,0 +1,28 @@
+The MIT License (MIT)
+
+Copyright (c) 2011 - present Meteor Software Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+====================================================================
+This license applies to all code in Meteor that is not an externally
+maintained library. Externally maintained libraries have their own
+licenses, included in the LICENSES directory.
+====================================================================

package/meteor/binary-heap/max_heap.ts

@@ -0,0 +1,225 @@
+export interface MaxHeapOptions {
+    initData?: {id: string, value: any}[],
+    IdMap?: any
+}
+
+// Constructor of Heap
+// - comparator - Function - given two items returns a number
+// - options:
+//   - initData - Array - Optional - the initial data in a format:
+//        Object:
+//          - id - String - unique id of the item
+//          - value - Any - the data value
+//      each value is retained
+//   - IdMap - Constructor - Optional - custom IdMap class to store id->index
+//       mappings internally. Standard IdMap is used by default.
+export class MaxHeap {
+    protected _comparator: (a: any, b: any) => number;
+    protected _heap: any[];
+    private _heapIdx: any;
+    constructor(comparator: (a: any, b: any) => number, options: MaxHeapOptions = {}) {
+        if (typeof comparator !== 'function') {
+            throw new Error('Passed comparator is invalid, should be a comparison function');
+        }
+
+        // a C-style comparator that is given two values and returns a number,
+        // negative if the first value is less than the second, positive if the second
+        // value is greater than the first and zero if they are equal.
+        this._comparator = comparator;
+
+        if (!options.IdMap) {
+            options.IdMap = Map;
+        }
+
+        // _heapIdx maps an id to an index in the Heap array the corresponding value
+        // is located on.
+        this._heapIdx = new options.IdMap;
+
+        // The Heap data-structure implemented as a 0-based contiguous array where
+        // every item on index idx is a node in a complete binary tree. Every node can
+        // have children on indexes idx*2+1 and idx*2+2, except for the leaves. Every
+        // node has a parent on index (idx-1)/2;
+        this._heap = [];
+
+        // If the initial array is passed, we can build the heap in linear time
+        // complexity (O(N)) compared to linearithmic time complexity (O(nlogn)) if
+        // we push elements one by one.
+        if (Array.isArray(options.initData)) {
+            this._initFromData(options.initData);
+        }
+    }
+
+    // Builds a new heap in-place in linear time based on passed data
+    _initFromData(data) {
+        this._heap = data.map(({ id, value }) => ({ id, value }));
+
+        data.forEach(({ id }, i) => this._heapIdx.set(id, i));
+
+        if (!data.length) {
+            return;
+        }
+
+        // start from the first non-leaf - the parent of the last leaf
+        for (let i = parentIdx(data.length - 1); i >= 0; i--) {
+            this._downHeap(i);
+        }
+    }
+
+    _downHeap(idx) {
+        while (leftChildIdx(idx) < this.size()) {
+            const left = leftChildIdx(idx);
+            const right = rightChildIdx(idx);
+            let largest = idx;
+
+            if (left < this.size()) {
+                largest = this._maxIndex(largest, left);
+            }
+
+            if (right < this.size()) {
+                largest = this._maxIndex(largest, right);
+            }
+
+            if (largest === idx) {
+                break;
+            }
+
+            this._swap(largest, idx);
+            idx = largest;
+        }
+    }
+
+    _upHeap(idx) {
+        while (idx > 0) {
+            const parent = parentIdx(idx);
+            if (this._maxIndex(parent, idx) === idx) {
+                this._swap(parent, idx)
+                idx = parent;
+            } else {
+                break;
+            }
+        }
+    }
+
+    _maxIndex(idxA, idxB) {
+        const valueA = this._get(idxA);
+        const valueB = this._get(idxB);
+        return this._comparator(valueA, valueB) >= 0 ? idxA : idxB;
+    }
+
+    // Internal: gets raw data object placed on idxth place in heap
+    _get(idx) {
+        return this._heap[idx].value;
+    }
+
+    _swap(idxA, idxB) {
+        const recA = this._heap[idxA];
+        const recB = this._heap[idxB];
+
+        this._heapIdx.set(recA.id, idxB);
+        this._heapIdx.set(recB.id, idxA);
+
+        this._heap[idxA] = recB;
+        this._heap[idxB] = recA;
+    }
+
+    get(id) {
+        return this.has(id) ?
+            this._get(this._heapIdx.get(id)) :
+            null;
+    }
+
+    set(id, value) {
+        if (this.has(id)) {
+            if (this.get(id) === value) {
+                return;
+            }
+
+            const idx = this._heapIdx.get(id);
+            this._heap[idx].value = value;
+
+            // Fix the new value's position
+            // Either bubble new value up if it is greater than its parent
+            this._upHeap(idx);
+            // or bubble it down if it is smaller than one of its children
+            this._downHeap(idx);
+        } else {
+            this._heapIdx.set(id, this._heap.length);
+            this._heap.push({ id, value });
+            this._upHeap(this._heap.length - 1);
+        }
+    }
+
+    remove(id) {
+        if (this.has(id)) {
+            const last = this._heap.length - 1;
+            const idx = this._heapIdx.get(id);
+
+            if (idx !== last) {
+                this._swap(idx, last);
+                this._heap.pop();
+                this._heapIdx.remove(id);
+
+                // Fix the swapped value's position
+                this._upHeap(idx);
+                this._downHeap(idx);
+            } else {
+                this._heap.pop();
+                this._heapIdx.remove(id);
+            }
+        }
+    }
+
+    has(id) {
+        return this._heapIdx.has(id);
+    }
+
+    empty() {
+        return !this.size();
+    }
+
+    clear() {
+        this._heap = [];
+        this._heapIdx.clear();
+    }
+
+    // iterate over values in no particular order
+    forEach(iterator) {
+        this._heap.forEach(obj => iterator(obj.value, obj.id));
+    }
+
+    size() {
+        return this._heap.length;
+    }
+
+    setDefault(id, def) {
+        if (this.has(id)) {
+            return this.get(id);
+        }
+
+        this.set(id, def);
+        return def;
+    }
+
+    clone() {
+        const clone = new MaxHeap(this._comparator, { initData: this._heap });
+        return clone;
+    }
+
+    maxElementId() {
+        return this.size() ? this._heap[0].id : null;
+    }
+
+    _selfCheck() {
+        for (let i = 1; i < this._heap.length; i++) {
+            if (this._maxIndex(parentIdx(i), i) !== parentIdx(i)) {
+                throw new Error(`An item with id ${this._heap[i].id}` +
+                    " has a parent younger than it: " +
+                    this._heap[parentIdx(i)].id);
+            }
+        }
+    }
+}
+
+const leftChildIdx = i => i * 2 + 1;
+const rightChildIdx = i => i * 2 + 2;
+const parentIdx = i => (i - 1) >> 1;

package/meteor/binary-heap/min_heap.ts

@@ -0,0 +1,15 @@
+import { MaxHeap, MaxHeapOptions } from './max_heap';
+
+export class MinHeap extends MaxHeap {
+    constructor(comparator, options?: MaxHeapOptions) {
+        super((a, b) => -comparator(a, b), options);
+    }
+
+    maxElementId() {
+        throw new Error("Cannot call maxElementId on MinHeap");
+    }
+
+    minElementId() {
+        return super.maxElementId();
+    }
+};

package/meteor/binary-heap/min_max_heap.ts

@@ -0,0 +1,53 @@
+import { MaxHeap, MaxHeapOptions } from './max_heap';
+import { MinHeap } from './min_heap';
+
+// This implementation of Min/Max-Heap is just a subclass of Max-Heap
+// with a Min-Heap as an encapsulated property.
+//
+// Most of the operations are just proxy methods to call the same method on both
+// heaps.
+//
+// This implementation takes 2*N memory but is fairly simple to write and
+// understand. And the constant factor of a simple Heap is usually smaller
+// compared to other two-way priority queues like Min/Max Heaps
+// (http://www.cs.otago.ac.nz/staffpriv/mike/Papers/MinMaxHeaps/MinMaxHeaps.pdf)
+// and Interval Heaps
+// (http://www.cise.ufl.edu/~sahni/dsaac/enrich/c13/double.htm)
+export class MinMaxHeap extends MaxHeap {
+    private _minHeap: MinHeap;
+
+    constructor(comparator, options?: MaxHeapOptions) {
+        super(comparator, options);
+        this._minHeap = new MinHeap(comparator, options);
+    }
+
+    set(id: string, value: any) {
+        super.set(id, value);
+        this._minHeap.set(id, value);
+    }
+
+    remove(id: string) {
+        super.remove(id);
+        this._minHeap.remove(id);
+    }
+
+    clear() {
+        super.clear();
+        this._minHeap.clear();
+    }
+
+    setDefault(id: string, def: any) {
+        super.setDefault(id, def);
+        return this._minHeap.setDefault(id, def);
+    }
+
+    clone() {
+        const clone = new MinMaxHeap(this._comparator, { initData: this._heap });
+        return clone;
+    }
+
+    minElementId() {
+        return this._minHeap.minElementId();
+    }
+
+};

package/meteor/callback-hook/hook.ts

@@ -0,0 +1,85 @@
+const hasOwn = Object.prototype.hasOwnProperty;
+
+export class Hook {
+    private nextCallbackId: number;
+    private callbacks: Record<string, Function>;
+    private exceptionHandler: Function;
+
+    constructor(options?) {
+        options = options || {};
+        this.nextCallbackId = 0;
+        this.callbacks = Object.create(null);
+        // Whether to wrap callbacks with Meteor.bindEnvironment
+
+        if (options.exceptionHandler) {
+            this.exceptionHandler = options.exceptionHandler;
+        } else if (options.debugPrintExceptions) {
+            if (typeof options.debugPrintExceptions !== "string") {
+                throw new Error("Hook option debugPrintExceptions should be a string");
+            }
+            this.exceptionHandler = options.debugPrintExceptions;
+        }
+    }
+
+    register(callback) {
+        var exceptionHandler = this.exceptionHandler || function (exception) {
+            // Note: this relies on the undocumented fact that if bindEnvironment's
+            // onException throws, and you are invoking the callback either in the
+            // browser or from within a Fiber in Node, the exception is propagated.
+            throw exception;
+        };
+
+        callback = dontBindEnvironment(callback, exceptionHandler);
+
+        var id = this.nextCallbackId++;
+        this.callbacks[id] = callback;
+
+        return {
+            callback,
+            stop: () => {
+                delete this.callbacks[id];
+            }
+        };
+    }
+
+    // For each registered callback, call the passed iterator function
+    // with the callback.
+    //
+    // The iterator function can choose whether or not to call the
+    // callback.  (For example, it might not call the callback if the
+    // observed object has been closed or terminated).
+    //
+    // The iteration is stopped if the iterator function returns a falsy
+    // value or throws an exception.
+    each(iterator: (callback: Function) => boolean) {
+        var ids = Object.keys(this.callbacks);
+        for (var i = 0; i < ids.length; ++i) {
+            var id = ids[i];
+            // check to see if the callback was removed during iteration
+            if (hasOwn.call(this.callbacks, id)) {
+                var callback = this.callbacks[id];
+                if (!iterator(callback)) {
+                    break;
+                }
+            }
+        }
+    }
+}
+
+function dontBindEnvironment(func, onException, _this?) {
+    if (!onException || typeof (onException) === 'string') {
+        var description = onException || "callback of async function";
+        onException = function (error) {
+            console.error("Exception in " + description, error);
+        };
+    }
+
+    return function (...args) {
+        try {
+            var ret = func.apply(_this, args);
+        } catch (e) {
+            onException(e);
+        }
+        return ret;
+    };
+}