mongodb-livedata-server 0.1.3 → 0.1.4

package/dist/meteor/ordered-dict/ordered_dict.js

@@ -1,198 +1,198 @@
-"use strict";
-// This file defines an ordered dictionary abstraction that is useful for
-// maintaining a dataset backed by observeChanges.  It supports ordering items
-// by specifying the item they now come before.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OrderedDict = void 0;
-// The implementation is a dictionary that contains nodes of a doubly-linked
-// list as its values.
-// constructs a new element struct
-// next and prev are whole elements, not keys.
-function element(key, value, next, prev) {
-    return {
-        key: key,
-        value: value,
-        next: next,
-        prev: prev
-    };
-}
-class OrderedDict {
-    constructor(...args) {
-        this._dict = Object.create(null);
-        this._first = null;
-        this._last = null;
-        this._size = 0;
-        if (typeof args[0] === 'function') {
-            this._stringify = args.shift();
-        }
-        else {
-            this._stringify = function (x) { return x; };
-        }
-        args.forEach(kv => this.putBefore(kv[0], kv[1], null));
-    }
-    // the "prefix keys with a space" thing comes from here
-    // https://github.com/documentcloud/underscore/issues/376#issuecomment-2815649
-    _k(key) {
-        return " " + this._stringify(key);
-    }
-    empty() {
-        return !this._first;
-    }
-    get size() {
-        return this._size;
-    }
-    _linkEltIn(elt) {
-        if (!elt.next) {
-            elt.prev = this._last;
-            if (this._last)
-                this._last.next = elt;
-            this._last = elt;
-        }
-        else {
-            elt.prev = elt.next.prev;
-            elt.next.prev = elt;
-            if (elt.prev)
-                elt.prev.next = elt;
-        }
-        if (this._first === null || this._first === elt.next)
-            this._first = elt;
-    }
-    _linkEltOut(elt) {
-        if (elt.next)
-            elt.next.prev = elt.prev;
-        if (elt.prev)
-            elt.prev.next = elt.next;
-        if (elt === this._last)
-            this._last = elt.prev;
-        if (elt === this._first)
-            this._first = elt.next;
-    }
-    putBefore(key, item, before) {
-        if (this._dict[this._k(key)])
-            throw new Error("Item " + key + " already present in OrderedDict");
-        var elt = before ?
-            element(key, item, this._dict[this._k(before)]) :
-            element(key, item, null);
-        if (typeof elt.next === "undefined")
-            throw new Error("could not find item to put this one before");
-        this._linkEltIn(elt);
-        this._dict[this._k(key)] = elt;
-        this._size++;
-    }
-    append(key, item) {
-        this.putBefore(key, item, null);
-    }
-    delete(key) {
-        var elt = this._dict[this._k(key)];
-        if (typeof elt === "undefined")
-            throw new Error("Item " + key + " not present in OrderedDict");
-        this._linkEltOut(elt);
-        this._size--;
-        delete this._dict[this._k(key)];
-        return elt.value;
-    }
-    get(key) {
-        if (this.has(key)) {
-            return this._dict[this._k(key)].value;
-        }
-    }
-    has(key) {
-        return Object.prototype.hasOwnProperty.call(this._dict, this._k(key));
-    }
-    // Iterate through the items in this dictionary in order, calling
-    // iter(value, key, index) on each one.
-    // Stops whenever iter returns OrderedDict.BREAK, or after the last element.
-    forEach(iter, context = null) {
-        var i = 0;
-        var elt = this._first;
-        while (elt !== null) {
-            var b = iter.call(context, elt.value, elt.key, i);
-            if (b === OrderedDict.BREAK)
-                return;
-            elt = elt.next;
-            i++;
-        }
-    }
-    first() {
-        if (this.empty()) {
-            return;
-        }
-        return this._first.key;
-    }
-    firstValue() {
-        if (this.empty()) {
-            return;
-        }
-        return this._first.value;
-    }
-    last() {
-        if (this.empty()) {
-            return;
-        }
-        return this._last.key;
-    }
-    lastValue() {
-        if (this.empty()) {
-            return;
-        }
-        return this._last.value;
-    }
-    prev(key) {
-        if (this.has(key)) {
-            var elt = this._dict[this._k(key)];
-            if (elt.prev)
-                return elt.prev.key;
-        }
-        return null;
-    }
-    next(key) {
-        if (this.has(key)) {
-            var elt = this._dict[this._k(key)];
-            if (elt.next)
-                return elt.next.key;
-        }
-        return null;
-    }
-    moveBefore(key, before) {
-        var elt = this._dict[this._k(key)];
-        var eltBefore = before ? this._dict[this._k(before)] : null;
-        if (typeof elt === "undefined") {
-            throw new Error("Item to move is not present");
-        }
-        if (typeof eltBefore === "undefined") {
-            throw new Error("Could not find element to move this one before");
-        }
-        if (eltBefore === elt.next) // no moving necessary
-            return;
-        // remove from its old place
-        this._linkEltOut(elt);
-        // patch into its new place
-        elt.next = eltBefore;
-        this._linkEltIn(elt);
-    }
-    // Linear, sadly.
-    indexOf(key) {
-        var ret = null;
-        this.forEach((v, k, i) => {
-            if (this._k(k) === this._k(key)) {
-                ret = i;
-                return OrderedDict.BREAK;
-            }
-            return;
-        });
-        return ret;
-    }
-    _checkRep() {
-        Object.keys(this._dict).forEach(k => {
-            const v = this._dict[k];
-            if (v.next === v) {
-                throw new Error("Next is a loop");
-            }
-            if (v.prev === v) {
-                throw new Error("Prev is a loop");
-            }
-        });
-    }
-}
-exports.OrderedDict = OrderedDict;
-OrderedDict.BREAK = { "break": true };
+"use strict";
+// This file defines an ordered dictionary abstraction that is useful for
+// maintaining a dataset backed by observeChanges.  It supports ordering items
+// by specifying the item they now come before.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderedDict = void 0;
+// The implementation is a dictionary that contains nodes of a doubly-linked
+// list as its values.
+// constructs a new element struct
+// next and prev are whole elements, not keys.
+function element(key, value, next, prev) {
+    return {
+        key: key,
+        value: value,
+        next: next,
+        prev: prev
+    };
+}
+class OrderedDict {
+    constructor(...args) {
+        this._dict = Object.create(null);
+        this._first = null;
+        this._last = null;
+        this._size = 0;
+        if (typeof args[0] === 'function') {
+            this._stringify = args.shift();
+        }
+        else {
+            this._stringify = function (x) { return x; };
+        }
+        args.forEach(kv => this.putBefore(kv[0], kv[1], null));
+    }
+    // the "prefix keys with a space" thing comes from here
+    // https://github.com/documentcloud/underscore/issues/376#issuecomment-2815649
+    _k(key) {
+        return " " + this._stringify(key);
+    }
+    empty() {
+        return !this._first;
+    }
+    get size() {
+        return this._size;
+    }
+    _linkEltIn(elt) {
+        if (!elt.next) {
+            elt.prev = this._last;
+            if (this._last)
+                this._last.next = elt;
+            this._last = elt;
+        }
+        else {
+            elt.prev = elt.next.prev;
+            elt.next.prev = elt;
+            if (elt.prev)
+                elt.prev.next = elt;
+        }
+        if (this._first === null || this._first === elt.next)
+            this._first = elt;
+    }
+    _linkEltOut(elt) {
+        if (elt.next)
+            elt.next.prev = elt.prev;
+        if (elt.prev)
+            elt.prev.next = elt.next;
+        if (elt === this._last)
+            this._last = elt.prev;
+        if (elt === this._first)
+            this._first = elt.next;
+    }
+    putBefore(key, item, before) {
+        if (this._dict[this._k(key)])
+            throw new Error("Item " + key + " already present in OrderedDict");
+        var elt = before ?
+            element(key, item, this._dict[this._k(before)]) :
+            element(key, item, null);
+        if (typeof elt.next === "undefined")
+            throw new Error("could not find item to put this one before");
+        this._linkEltIn(elt);
+        this._dict[this._k(key)] = elt;
+        this._size++;
+    }
+    append(key, item) {
+        this.putBefore(key, item, null);
+    }
+    delete(key) {
+        var elt = this._dict[this._k(key)];
+        if (typeof elt === "undefined")
+            throw new Error("Item " + key + " not present in OrderedDict");
+        this._linkEltOut(elt);
+        this._size--;
+        delete this._dict[this._k(key)];
+        return elt.value;
+    }
+    get(key) {
+        if (this.has(key)) {
+            return this._dict[this._k(key)].value;
+        }
+    }
+    has(key) {
+        return Object.prototype.hasOwnProperty.call(this._dict, this._k(key));
+    }
+    // Iterate through the items in this dictionary in order, calling
+    // iter(value, key, index) on each one.
+    // Stops whenever iter returns OrderedDict.BREAK, or after the last element.
+    forEach(iter, context = null) {
+        var i = 0;
+        var elt = this._first;
+        while (elt !== null) {
+            var b = iter.call(context, elt.value, elt.key, i);
+            if (b === OrderedDict.BREAK)
+                return;
+            elt = elt.next;
+            i++;
+        }
+    }
+    first() {
+        if (this.empty()) {
+            return;
+        }
+        return this._first.key;
+    }
+    firstValue() {
+        if (this.empty()) {
+            return;
+        }
+        return this._first.value;
+    }
+    last() {
+        if (this.empty()) {
+            return;
+        }
+        return this._last.key;
+    }
+    lastValue() {
+        if (this.empty()) {
+            return;
+        }
+        return this._last.value;
+    }
+    prev(key) {
+        if (this.has(key)) {
+            var elt = this._dict[this._k(key)];
+            if (elt.prev)
+                return elt.prev.key;
+        }
+        return null;
+    }
+    next(key) {
+        if (this.has(key)) {
+            var elt = this._dict[this._k(key)];
+            if (elt.next)
+                return elt.next.key;
+        }
+        return null;
+    }
+    moveBefore(key, before) {
+        var elt = this._dict[this._k(key)];
+        var eltBefore = before ? this._dict[this._k(before)] : null;
+        if (typeof elt === "undefined") {
+            throw new Error("Item to move is not present");
+        }
+        if (typeof eltBefore === "undefined") {
+            throw new Error("Could not find element to move this one before");
+        }
+        if (eltBefore === elt.next) // no moving necessary
+            return;
+        // remove from its old place
+        this._linkEltOut(elt);
+        // patch into its new place
+        elt.next = eltBefore;
+        this._linkEltIn(elt);
+    }
+    // Linear, sadly.
+    indexOf(key) {
+        var ret = null;
+        this.forEach((v, k, i) => {
+            if (this._k(k) === this._k(key)) {
+                ret = i;
+                return OrderedDict.BREAK;
+            }
+            return;
+        });
+        return ret;
+    }
+    _checkRep() {
+        Object.keys(this._dict).forEach(k => {
+            const v = this._dict[k];
+            if (v.next === v) {
+                throw new Error("Next is a loop");
+            }
+            if (v.prev === v) {
+                throw new Error("Prev is a loop");
+            }
+        });
+    }
+}
+exports.OrderedDict = OrderedDict;
+OrderedDict.BREAK = { "break": true };

package/dist/meteor/random/AbstractRandomGenerator.d.ts

@@ -1,42 +1,42 @@
-export default class RandomGenerator {
-    /**
-     * @name Random.fraction
-     * @summary Return a number between 0 and 1, like `Math.random`.
-     * @locus Anywhere
-     */
-    fraction(): number;
-    /**
-     * @name Random.hexString
-     * @summary Return a random string of `n` hexadecimal digits.
-     * @locus Anywhere
-     * @param {Number} n Length of the string
-     */
-    hexString(digits: any): string;
-    _randomString(charsCount: any, alphabet: any): string;
-    /**
-     * @name Random.id
-     * @summary Return a unique identifier, such as `"Jjwjg6gouWLXhMGKW"`, that is
-     * likely to be unique in the whole world.
-     * @locus Anywhere
-     * @param {Number} [n] Optional length of the identifier in characters
-     *   (defaults to 17)
-     */
-    id(charsCount: any): string;
-    /**
-     * @name Random.secret
-     * @summary Return a random string of printable characters with 6 bits of
-     * entropy per character. Use `Random.secret` for security-critical secrets
-     * that are intended for machine, rather than human, consumption.
-     * @locus Anywhere
-     * @param {Number} [n] Optional length of the secret string (defaults to 43
-     *   characters, or 256 bits of entropy)
-     */
-    secret(charsCount: any): string;
-    /**
-     * @name Random.choice
-     * @summary Return a random element of the given array or string.
-     * @locus Anywhere
-     * @param {Array|String} arrayOrString Array or string to choose from
-     */
-    choice(arrayOrString: any): any;
-}
+export default class RandomGenerator {
+    /**
+     * @name Random.fraction
+     * @summary Return a number between 0 and 1, like `Math.random`.
+     * @locus Anywhere
+     */
+    fraction(): number;
+    /**
+     * @name Random.hexString
+     * @summary Return a random string of `n` hexadecimal digits.
+     * @locus Anywhere
+     * @param {Number} n Length of the string
+     */
+    hexString(digits: any): string;
+    _randomString(charsCount: any, alphabet: any): string;
+    /**
+     * @name Random.id
+     * @summary Return a unique identifier, such as `"Jjwjg6gouWLXhMGKW"`, that is
+     * likely to be unique in the whole world.
+     * @locus Anywhere
+     * @param {Number} [n] Optional length of the identifier in characters
+     *   (defaults to 17)
+     */
+    id(charsCount: any): string;
+    /**
+     * @name Random.secret
+     * @summary Return a random string of printable characters with 6 bits of
+     * entropy per character. Use `Random.secret` for security-critical secrets
+     * that are intended for machine, rather than human, consumption.
+     * @locus Anywhere
+     * @param {Number} [n] Optional length of the secret string (defaults to 43
+     *   characters, or 256 bits of entropy)
+     */
+    secret(charsCount: any): string;
+    /**
+     * @name Random.choice
+     * @summary Return a random element of the given array or string.
+     * @locus Anywhere
+     * @param {Array|String} arrayOrString Array or string to choose from
+     */
+    choice(arrayOrString: any): any;
+}

package/dist/meteor/random/AbstractRandomGenerator.js

@@ -1,92 +1,92 @@
-"use strict";
-// We use cryptographically strong PRNGs (crypto.getRandomBytes() on the server,
-// window.crypto.getRandomValues() in the browser) when available. If these
-// PRNGs fail, we fall back to the Alea PRNG, which is not cryptographically
-// strong, and we seed it with various sources such as the date, Math.random,
-// and window size on the client.  When using crypto.getRandomValues(), our
-// primitive is hexString(), from which we construct fraction(). When using
-// window.crypto.getRandomValues() or alea, the primitive is fraction and we use
-// that to construct hex string.
-Object.defineProperty(exports, "__esModule", { value: true });
-const UNMISTAKABLE_CHARS = '23456789ABCDEFGHJKLMNPQRSTWXYZabcdefghijkmnopqrstuvwxyz';
-const BASE64_CHARS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' +
-    '0123456789-_';
-// `type` is one of `RandomGenerator.Type` as defined below.
-//
-// options:
-// - seeds: (required, only for RandomGenerator.Type.ALEA) an array
-//   whose items will be `toString`ed and used as the seed to the Alea
-//   algorithm
-class RandomGenerator {
-    /**
-     * @name Random.fraction
-     * @summary Return a number between 0 and 1, like `Math.random`.
-     * @locus Anywhere
-     */
-    fraction() {
-        throw new Error(`Unknown random generator type`);
-    }
-    /**
-     * @name Random.hexString
-     * @summary Return a random string of `n` hexadecimal digits.
-     * @locus Anywhere
-     * @param {Number} n Length of the string
-     */
-    hexString(digits) {
-        return this._randomString(digits, '0123456789abcdef');
-    }
-    _randomString(charsCount, alphabet) {
-        let result = '';
-        for (let i = 0; i < charsCount; i++) {
-            result += this.choice(alphabet);
-        }
-        return result;
-    }
-    /**
-     * @name Random.id
-     * @summary Return a unique identifier, such as `"Jjwjg6gouWLXhMGKW"`, that is
-     * likely to be unique in the whole world.
-     * @locus Anywhere
-     * @param {Number} [n] Optional length of the identifier in characters
-     *   (defaults to 17)
-     */
-    id(charsCount) {
-        // 17 characters is around 96 bits of entropy, which is the amount of
-        // state in the Alea PRNG.
-        if (charsCount === undefined) {
-            charsCount = 17;
-        }
-        return this._randomString(charsCount, UNMISTAKABLE_CHARS);
-    }
-    /**
-     * @name Random.secret
-     * @summary Return a random string of printable characters with 6 bits of
-     * entropy per character. Use `Random.secret` for security-critical secrets
-     * that are intended for machine, rather than human, consumption.
-     * @locus Anywhere
-     * @param {Number} [n] Optional length of the secret string (defaults to 43
-     *   characters, or 256 bits of entropy)
-     */
-    secret(charsCount) {
-        // Default to 256 bits of entropy, or 43 characters at 6 bits per
-        // character.
-        if (charsCount === undefined) {
-            charsCount = 43;
-        }
-        return this._randomString(charsCount, BASE64_CHARS);
-    }
-    /**
-     * @name Random.choice
-     * @summary Return a random element of the given array or string.
-     * @locus Anywhere
-     * @param {Array|String} arrayOrString Array or string to choose from
-     */
-    choice(arrayOrString) {
-        const index = Math.floor(this.fraction() * arrayOrString.length);
-        if (typeof arrayOrString === 'string') {
-            return arrayOrString.substr(index, 1);
-        }
-        return arrayOrString[index];
-    }
-}
-exports.default = RandomGenerator;
+"use strict";
+// We use cryptographically strong PRNGs (crypto.getRandomBytes() on the server,
+// window.crypto.getRandomValues() in the browser) when available. If these
+// PRNGs fail, we fall back to the Alea PRNG, which is not cryptographically
+// strong, and we seed it with various sources such as the date, Math.random,
+// and window size on the client.  When using crypto.getRandomValues(), our
+// primitive is hexString(), from which we construct fraction(). When using
+// window.crypto.getRandomValues() or alea, the primitive is fraction and we use
+// that to construct hex string.
+Object.defineProperty(exports, "__esModule", { value: true });
+const UNMISTAKABLE_CHARS = '23456789ABCDEFGHJKLMNPQRSTWXYZabcdefghijkmnopqrstuvwxyz';
+const BASE64_CHARS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' +
+    '0123456789-_';
+// `type` is one of `RandomGenerator.Type` as defined below.
+//
+// options:
+// - seeds: (required, only for RandomGenerator.Type.ALEA) an array
+//   whose items will be `toString`ed and used as the seed to the Alea
+//   algorithm
+class RandomGenerator {
+    /**
+     * @name Random.fraction
+     * @summary Return a number between 0 and 1, like `Math.random`.
+     * @locus Anywhere
+     */
+    fraction() {
+        throw new Error(`Unknown random generator type`);
+    }
+    /**
+     * @name Random.hexString
+     * @summary Return a random string of `n` hexadecimal digits.
+     * @locus Anywhere
+     * @param {Number} n Length of the string
+     */
+    hexString(digits) {
+        return this._randomString(digits, '0123456789abcdef');
+    }
+    _randomString(charsCount, alphabet) {
+        let result = '';
+        for (let i = 0; i < charsCount; i++) {
+            result += this.choice(alphabet);
+        }
+        return result;
+    }
+    /**
+     * @name Random.id
+     * @summary Return a unique identifier, such as `"Jjwjg6gouWLXhMGKW"`, that is
+     * likely to be unique in the whole world.
+     * @locus Anywhere
+     * @param {Number} [n] Optional length of the identifier in characters
+     *   (defaults to 17)
+     */
+    id(charsCount) {
+        // 17 characters is around 96 bits of entropy, which is the amount of
+        // state in the Alea PRNG.
+        if (charsCount === undefined) {
+            charsCount = 17;
+        }
+        return this._randomString(charsCount, UNMISTAKABLE_CHARS);
+    }
+    /**
+     * @name Random.secret
+     * @summary Return a random string of printable characters with 6 bits of
+     * entropy per character. Use `Random.secret` for security-critical secrets
+     * that are intended for machine, rather than human, consumption.
+     * @locus Anywhere
+     * @param {Number} [n] Optional length of the secret string (defaults to 43
+     *   characters, or 256 bits of entropy)
+     */
+    secret(charsCount) {
+        // Default to 256 bits of entropy, or 43 characters at 6 bits per
+        // character.
+        if (charsCount === undefined) {
+            charsCount = 43;
+        }
+        return this._randomString(charsCount, BASE64_CHARS);
+    }
+    /**
+     * @name Random.choice
+     * @summary Return a random element of the given array or string.
+     * @locus Anywhere
+     * @param {Array|String} arrayOrString Array or string to choose from
+     */
+    choice(arrayOrString) {
+        const index = Math.floor(this.fraction() * arrayOrString.length);
+        if (typeof arrayOrString === 'string') {
+            return arrayOrString.substr(index, 1);
+        }
+        return arrayOrString[index];
+    }
+}
+exports.default = RandomGenerator;