mongodb-livedata-server 0.0.1

package/dist/meteor/ejson/ejson.js

@@ -0,0 +1,569 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clone = exports.equals = exports.isBinary = exports.parse = exports.stringify = exports.fromJSONValue = exports._adjustTypesFromJSONValue = exports.toJSONValue = exports._adjustTypesToJSONValue = exports._getConverters = exports._getTypes = exports._isCustomType = exports.addType = void 0;
+const utils_1 = require("./utils");
+const stringify_1 = __importDefault(require("./stringify"));
+// Custom type interface definition
+/**
+ * @class CustomType
+ * @instanceName customType
+ * @memberOf EJSON
+ * @summary The interface that a class must satisfy to be able to become an
+ * EJSON custom type via EJSON.addType.
+ */
+/**
+ * @function typeName
+ * @memberOf EJSON.CustomType
+ * @summary Return the tag used to identify this type.  This must match the
+ *          tag used to register this type with
+ *          [`EJSON.addType`](#ejson_add_type).
+ * @locus Anywhere
+ * @instance
+ */
+/**
+ * @function toJSONValue
+ * @memberOf EJSON.CustomType
+ * @summary Serialize this instance into a JSON-compatible value.
+ * @locus Anywhere
+ * @instance
+ */
+/**
+ * @function clone
+ * @memberOf EJSON.CustomType
+ * @summary Return a value `r` such that `this.equals(r)` is true, and
+ *          modifications to `r` do not affect `this` and vice versa.
+ * @locus Anywhere
+ * @instance
+ */
+/**
+ * @function equals
+ * @memberOf EJSON.CustomType
+ * @summary Return `true` if `other` has a value equal to `this`; `false`
+ *          otherwise.
+ * @locus Anywhere
+ * @param {Object} other Another object to compare this to.
+ * @instance
+ */
+const customTypes = new Map();
+// Add a custom type, using a method of your choice to get to and
+// from a basic JSON-able representation.  The factory argument
+// is a function of JSON-able --> your object
+// The type you add must have:
+// - A toJSONValue() method, so that Meteor can serialize it
+// - a typeName() method, to show how to look it up in our type table.
+// It is okay if these methods are monkey-patched on.
+// EJSON.clone will use toJSONValue and the given factory to produce
+// a clone, but you may specify a method clone() that will be
+// used instead.
+// Similarly, EJSON.equals will use toJSONValue to make comparisons,
+// but you may provide a method equals() instead.
+/**
+ * @summary Add a custom datatype to EJSON.
+ * @locus Anywhere
+ * @param {String} name A tag for your custom type; must be unique among
+ *                      custom data types defined in your project, and must
+ *                      match the result of your type's `typeName` method.
+ * @param {Function} factory A function that deserializes a JSON-compatible
+ *                           value into an instance of your type.  This should
+ *                           match the serialization performed by your
+ *                           type's `toJSONValue` method.
+ */
+function addType(name, factory) {
+    if (customTypes.has(name)) {
+        throw new Error(`Type ${name} already present`);
+    }
+    customTypes.set(name, factory);
+}
+exports.addType = addType;
+;
+const builtinConverters = [
+    {
+        matchJSONValue(obj) {
+            return (0, utils_1.hasOwn)(obj, '$date') && (0, utils_1.lengthOf)(obj) === 1;
+        },
+        matchObject(obj) {
+            return obj instanceof Date;
+        },
+        toJSONValue(obj) {
+            return { $date: obj.getTime() };
+        },
+        fromJSONValue(obj) {
+            return new Date(obj.$date);
+        },
+    },
+    {
+        matchJSONValue(obj) {
+            return (0, utils_1.hasOwn)(obj, '$regexp')
+                && (0, utils_1.hasOwn)(obj, '$flags')
+                && (0, utils_1.lengthOf)(obj) === 2;
+        },
+        matchObject(obj) {
+            return obj instanceof RegExp;
+        },
+        toJSONValue(regexp) {
+            return {
+                $regexp: regexp.source,
+                $flags: regexp.flags
+            };
+        },
+        fromJSONValue(obj) {
+            // Replaces duplicate / invalid flags.
+            return new RegExp(obj.$regexp, obj.$flags
+                // Cut off flags at 50 chars to avoid abusing RegExp for DOS.
+                .slice(0, 50)
+                .replace(/[^gimuy]/g, '')
+                .replace(/(.)(?=.*\1)/g, ''));
+        },
+    },
+    {
+        // which we match.)
+        matchJSONValue(obj) {
+            return (0, utils_1.hasOwn)(obj, '$InfNaN') && (0, utils_1.lengthOf)(obj) === 1;
+        },
+        matchObject: utils_1.isInfOrNaN,
+        toJSONValue(obj) {
+            let sign;
+            if (Number.isNaN(obj)) {
+                sign = 0;
+            }
+            else if (obj === Infinity) {
+                sign = 1;
+            }
+            else {
+                sign = -1;
+            }
+            return { $InfNaN: sign };
+        },
+        fromJSONValue(obj) {
+            return obj.$InfNaN / 0;
+        },
+    },
+    {
+        matchJSONValue(obj) {
+            return (0, utils_1.hasOwn)(obj, '$binary') && (0, utils_1.lengthOf)(obj) === 1;
+        },
+        matchObject(obj) {
+            return typeof Uint8Array !== 'undefined' && obj instanceof Uint8Array
+                || (obj && (0, utils_1.hasOwn)(obj, '$Uint8ArrayPolyfill'));
+        },
+        toJSONValue(obj) {
+            return { $binary: Buffer.from(obj).toString("base64") };
+        },
+        fromJSONValue(obj) {
+            return Buffer.from(obj.$binary, "base64").toString();
+        },
+    },
+    {
+        matchJSONValue(obj) {
+            return (0, utils_1.hasOwn)(obj, '$escape') && (0, utils_1.lengthOf)(obj) === 1;
+        },
+        matchObject(obj) {
+            let match = false;
+            if (obj) {
+                const keyCount = (0, utils_1.lengthOf)(obj);
+                if (keyCount === 1 || keyCount === 2) {
+                    match =
+                        builtinConverters.some(converter => converter.matchJSONValue(obj));
+                }
+            }
+            return match;
+        },
+        toJSONValue(obj) {
+            const newObj = {};
+            (0, utils_1.keysOf)(obj).forEach(key => {
+                newObj[key] = toJSONValue(obj[key]);
+            });
+            return { $escape: newObj };
+        },
+        fromJSONValue(obj) {
+            const newObj = {};
+            (0, utils_1.keysOf)(obj.$escape).forEach(key => {
+                newObj[key] = fromJSONValue(obj.$escape[key]);
+            });
+            return newObj;
+        },
+    },
+    {
+        matchJSONValue(obj) {
+            return (0, utils_1.hasOwn)(obj, '$type')
+                && (0, utils_1.hasOwn)(obj, '$value') && (0, utils_1.lengthOf)(obj) === 2;
+        },
+        matchObject(obj) {
+            return _isCustomType(obj);
+        },
+        toJSONValue(obj) {
+            const jsonValue = obj.toJSONValue();
+            return { $type: obj.typeName(), $value: jsonValue };
+        },
+        fromJSONValue(obj) {
+            const typeName = obj.$type;
+            if (!customTypes.has(typeName)) {
+                throw new Error(`Custom EJSON type ${typeName} is not defined`);
+            }
+            const converter = customTypes.get(typeName);
+            return converter(obj.$value);
+        },
+    },
+];
+function _isCustomType(obj) {
+    return obj &&
+        (0, utils_1.isFunction)(obj.toJSONValue) &&
+        (0, utils_1.isFunction)(obj.typeName) &&
+        customTypes.has(obj.typeName());
+}
+exports._isCustomType = _isCustomType;
+function _getTypes(isOriginal = false) { return (isOriginal ? customTypes : (0, utils_1.convertMapToObject)(customTypes)); }
+exports._getTypes = _getTypes;
+function _getConverters() { return builtinConverters; }
+exports._getConverters = _getConverters;
+// Either return the JSON-compatible version of the argument, or undefined (if
+// the item isn't itself replaceable, but maybe some fields in it are)
+const toJSONValueHelper = item => {
+    for (let i = 0; i < builtinConverters.length; i++) {
+        const converter = builtinConverters[i];
+        if (converter.matchObject(item)) {
+            return converter.toJSONValue(item);
+        }
+    }
+    return undefined;
+};
+// for both arrays and objects, in-place modification.
+function _adjustTypesToJSONValue(obj) {
+    // Is it an atom that we need to adjust?
+    if (obj === null) {
+        return null;
+    }
+    const maybeChanged = toJSONValueHelper(obj);
+    if (maybeChanged !== undefined) {
+        return maybeChanged;
+    }
+    // Other atoms are unchanged.
+    if (!(0, utils_1.isObject)(obj)) {
+        return obj;
+    }
+    // Iterate over array or object structure.
+    (0, utils_1.keysOf)(obj).forEach(key => {
+        const value = obj[key];
+        if (!(0, utils_1.isObject)(value) && value !== undefined &&
+            !(0, utils_1.isInfOrNaN)(value)) {
+            return; // continue
+        }
+        const changed = toJSONValueHelper(value);
+        if (changed) {
+            obj[key] = changed;
+            return; // on to the next key
+        }
+        // if we get here, value is an object but not adjustable
+        // at this level.  recurse.
+        _adjustTypesToJSONValue(value);
+    });
+    return obj;
+}
+exports._adjustTypesToJSONValue = _adjustTypesToJSONValue;
+;
+/**
+ * @summary Serialize an EJSON-compatible value into its plain JSON
+ *          representation.
+ * @locus Anywhere
+ * @param {EJSON} val A value to serialize to plain JSON.
+ */
+function toJSONValue(item) {
+    const changed = toJSONValueHelper(item);
+    if (changed !== undefined) {
+        return changed;
+    }
+    let newItem = item;
+    if ((0, utils_1.isObject)(item)) {
+        newItem = clone(item);
+        _adjustTypesToJSONValue(newItem);
+    }
+    return newItem;
+}
+exports.toJSONValue = toJSONValue;
+;
+// Either return the argument changed to have the non-json
+// rep of itself (the Object version) or the argument itself.
+// DOES NOT RECURSE.  For actually getting the fully-changed value, use
+// EJSON.fromJSONValue
+const fromJSONValueHelper = value => {
+    if ((0, utils_1.isObject)(value) && value !== null) {
+        const keys = (0, utils_1.keysOf)(value);
+        if (keys.length <= 2
+            && keys.every(k => typeof k === 'string' && k.substr(0, 1) === '$')) {
+            for (let i = 0; i < builtinConverters.length; i++) {
+                const converter = builtinConverters[i];
+                if (converter.matchJSONValue(value)) {
+                    return converter.fromJSONValue(value);
+                }
+            }
+        }
+    }
+    return value;
+};
+// for both arrays and objects. Tries its best to just
+// use the object you hand it, but may return something
+// different if the object you hand it itself needs changing.
+function _adjustTypesFromJSONValue(obj) {
+    if (obj === null) {
+        return null;
+    }
+    const maybeChanged = fromJSONValueHelper(obj);
+    if (maybeChanged !== obj) {
+        return maybeChanged;
+    }
+    // Other atoms are unchanged.
+    if (!(0, utils_1.isObject)(obj)) {
+        return obj;
+    }
+    (0, utils_1.keysOf)(obj).forEach(key => {
+        const value = obj[key];
+        if ((0, utils_1.isObject)(value)) {
+            const changed = fromJSONValueHelper(value);
+            if (value !== changed) {
+                obj[key] = changed;
+                return;
+            }
+            // if we get here, value is an object but not adjustable
+            // at this level.  recurse.
+            _adjustTypesFromJSONValue(value);
+        }
+    });
+    return obj;
+}
+exports._adjustTypesFromJSONValue = _adjustTypesFromJSONValue;
+;
+/**
+ * @summary Deserialize an EJSON value from its plain JSON representation.
+ * @locus Anywhere
+ * @param {JSONCompatible} val A value to deserialize into EJSON.
+ */
+function fromJSONValue(item) {
+    let changed = fromJSONValueHelper(item);
+    if (changed === item && (0, utils_1.isObject)(item)) {
+        changed = clone(item);
+        _adjustTypesFromJSONValue(changed);
+    }
+    return changed;
+}
+exports.fromJSONValue = fromJSONValue;
+;
+/**
+ * @summary Serialize a value to a string. For EJSON values, the serialization
+ *          fully represents the value. For non-EJSON values, serializes the
+ *          same way as `JSON.stringify`.
+ * @locus Anywhere
+ * @param {EJSON} val A value to stringify.
+ * @param {Object} [options]
+ * @param {Boolean | Integer | String} options.indent Indents objects and
+ * arrays for easy readability.  When `true`, indents by 2 spaces; when an
+ * integer, indents by that number of spaces; and when a string, uses the
+ * string as the indentation pattern.
+ * @param {Boolean} options.canonical When `true`, stringifies keys in an
+ *                                    object in sorted order.
+ */
+function stringify(val, opts) {
+    return (0, utils_1.handleError)((item, options) => {
+        let serialized;
+        const json = toJSONValue(item);
+        if (options && (options.canonical || options.indent)) {
+            serialized = (0, stringify_1.default)(json, options);
+        }
+        else {
+            serialized = JSON.stringify(json);
+        }
+        return serialized;
+    }, val, opts);
+}
+exports.stringify = stringify;
+/**
+ * @summary Parse a string into an EJSON value. Throws an error if the string
+ *          is not valid EJSON.
+ * @locus Anywhere
+ * @param {String} str A string to parse into an EJSON value.
+ */
+function parse(item) {
+    if (typeof item !== 'string') {
+        throw new Error('EJSON.parse argument should be a string');
+    }
+    return fromJSONValue(JSON.parse(item));
+}
+exports.parse = parse;
+;
+/**
+ * @summary Returns true if `x` is a buffer of binary data, as returned from
+ *          [`EJSON.newBinary`](#ejson_new_binary).
+ * @param {Object} x The variable to check.
+ * @locus Anywhere
+ */
+function isBinary(obj) {
+    return !!((typeof Uint8Array !== 'undefined' && obj instanceof Uint8Array) ||
+        (obj && obj.$Uint8ArrayPolyfill));
+}
+exports.isBinary = isBinary;
+;
+/**
+ * @summary Return true if `a` and `b` are equal to each other.  Return false
+ *          otherwise.  Uses the `equals` method on `a` if present, otherwise
+ *          performs a deep comparison.
+ * @locus Anywhere
+ * @param {EJSON} a
+ * @param {EJSON} b
+ * @param {Object} [options]
+ * @param {Boolean} options.keyOrderSensitive Compare in key sensitive order,
+ * if supported by the JavaScript implementation.  For example, `{a: 1, b: 2}`
+ * is equal to `{b: 2, a: 1}` only when `keyOrderSensitive` is `false`.  The
+ * default is `false`.
+ */
+function equals(a, b, options) {
+    let i;
+    const keyOrderSensitive = !!(options && options.keyOrderSensitive);
+    if (a === b) {
+        return true;
+    }
+    // This differs from the IEEE spec for NaN equality, b/c we don't want
+    // anything ever with a NaN to be poisoned from becoming equal to anything.
+    if (Number.isNaN(a) && Number.isNaN(b)) {
+        return true;
+    }
+    // if either one is falsy, they'd have to be === to be equal
+    if (!a || !b) {
+        return false;
+    }
+    if (!((0, utils_1.isObject)(a) && (0, utils_1.isObject)(b))) {
+        return false;
+    }
+    if (a instanceof Date && b instanceof Date) {
+        return a.valueOf() === b.valueOf();
+    }
+    if (isBinary(a) && isBinary(b)) {
+        if (a.length !== b.length) {
+            return false;
+        }
+        for (i = 0; i < a.length; i++) {
+            if (a[i] !== b[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if ((0, utils_1.isFunction)(a.equals)) {
+        return a.equals(b, options);
+    }
+    if ((0, utils_1.isFunction)(b.equals)) {
+        return b.equals(a, options);
+    }
+    // Array.isArray works across iframes while instanceof won't
+    const aIsArray = Array.isArray(a);
+    const bIsArray = Array.isArray(b);
+    // if not both or none are array they are not equal
+    if (aIsArray !== bIsArray) {
+        return false;
+    }
+    if (aIsArray && bIsArray) {
+        if (a.length !== b.length) {
+            return false;
+        }
+        for (i = 0; i < a.length; i++) {
+            if (!equals(a[i], b[i], options)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // fallback for custom types that don't implement their own equals
+    switch (+_isCustomType(a) + +_isCustomType(b)) {
+        case 1: return false;
+        case 2: return equals(toJSONValue(a), toJSONValue(b));
+        default: // Do nothing
+    }
+    // fall back to structural equality of objects
+    let ret;
+    const aKeys = (0, utils_1.keysOf)(a);
+    const bKeys = (0, utils_1.keysOf)(b);
+    if (keyOrderSensitive) {
+        i = 0;
+        ret = aKeys.every(key => {
+            if (i >= bKeys.length) {
+                return false;
+            }
+            if (key !== bKeys[i]) {
+                return false;
+            }
+            if (!equals(a[key], b[bKeys[i]], options)) {
+                return false;
+            }
+            i++;
+            return true;
+        });
+    }
+    else {
+        i = 0;
+        ret = aKeys.every(key => {
+            if (!(0, utils_1.hasOwn)(b, key)) {
+                return false;
+            }
+            if (!equals(a[key], b[key], options)) {
+                return false;
+            }
+            i++;
+            return true;
+        });
+    }
+    return ret && i === bKeys.length;
+}
+exports.equals = equals;
+;
+/**
+ * @summary Return a deep copy of `val`.
+ * @locus Anywhere
+ * @param {EJSON} val A value to copy.
+ */
+function clone(v) {
+    let ret;
+    if (!(0, utils_1.isObject)(v)) {
+        return v;
+    }
+    if (v === null) {
+        return null; // null has typeof "object"
+    }
+    if (v instanceof Date) {
+        return new Date(v.getTime());
+    }
+    // RegExps are not really EJSON elements (eg we don't define a serialization
+    // for them), but they're immutable anyway, so we can support them in clone.
+    if (v instanceof RegExp) {
+        return v;
+    }
+    if (isBinary(v)) {
+        ret = new Uint8Array(v.length);
+        for (let i = 0; i < v.length; i++) {
+            ret[i] = v[i];
+        }
+        return ret;
+    }
+    if (Array.isArray(v)) {
+        return v.map(clone);
+    }
+    if ((0, utils_1.isArguments)(v)) {
+        return Array.from(v).map(clone);
+    }
+    // handle general user-defined typed Objects if they have a clone method
+    if ("clone" in v && (0, utils_1.isFunction)(v.clone)) {
+        return v.clone();
+    }
+    // handle other custom types
+    if (_isCustomType(v)) {
+        return fromJSONValue(clone(toJSONValue(v)));
+    }
+    // handle other objects
+    ret = {};
+    (0, utils_1.keysOf)(v).forEach((key) => {
+        ret[key] = clone(v[key]);
+    });
+    return ret;
+}
+exports.clone = clone;
+;

package/dist/meteor/ejson/stringify.js

@@ -0,0 +1,119 @@
+"use strict";
+// Based on json2.js from https://github.com/douglascrockford/JSON-js
+//
+//    json2.js
+//    2012-10-08
+//
+//    Public Domain.
+//
+//    NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
+Object.defineProperty(exports, "__esModule", { value: true });
+function quote(string) {
+    return JSON.stringify(string);
+}
+const str = (key, holder, singleIndent, outerIndent, canonical) => {
+    const value = holder[key];
+    // What happens next depends on the value's type.
+    switch (typeof value) {
+        case 'string':
+            return quote(value);
+        case 'number':
+            // JSON numbers must be finite. Encode non-finite numbers as null.
+            return isFinite(value) ? String(value) : 'null';
+        case 'boolean':
+            return String(value);
+        // If the type is 'object', we might be dealing with an object or an array or
+        // null.
+        case 'object': {
+            // Due to a specification blunder in ECMAScript, typeof null is 'object',
+            // so watch out for that case.
+            if (!value) {
+                return 'null';
+            }
+            // Make an array to hold the partial results of stringifying this object
+            // value.
+            const innerIndent = outerIndent + singleIndent;
+            const partial = [];
+            let v;
+            // Is the value an array?
+            if (Array.isArray(value) || ({}).hasOwnProperty.call(value, 'callee')) {
+                // The value is an array. Stringify every element. Use null as a
+                // placeholder for non-JSON values.
+                const length = value.length;
+                for (let i = 0; i < length; i += 1) {
+                    partial[i] =
+                        str(i, value, singleIndent, innerIndent, canonical) || 'null';
+                }
+                // Join all of the elements together, separated with commas, and wrap
+                // them in brackets.
+                if (partial.length === 0) {
+                    v = '[]';
+                }
+                else if (innerIndent) {
+                    v = '[\n' +
+                        innerIndent +
+                        partial.join(',\n' +
+                            innerIndent) +
+                        '\n' +
+                        outerIndent +
+                        ']';
+                }
+                else {
+                    v = '[' + partial.join(',') + ']';
+                }
+                return v;
+            }
+            // Iterate through all of the keys in the object.
+            let keys = Object.keys(value);
+            if (canonical) {
+                keys = keys.sort();
+            }
+            keys.forEach(k => {
+                v = str(k, value, singleIndent, innerIndent, canonical);
+                if (v) {
+                    partial.push(quote(k) + (innerIndent ? ': ' : ':') + v);
+                }
+            });
+            // Join all of the member texts together, separated with commas,
+            // and wrap them in braces.
+            if (partial.length === 0) {
+                v = '{}';
+            }
+            else if (innerIndent) {
+                v = '{\n' +
+                    innerIndent +
+                    partial.join(',\n' +
+                        innerIndent) +
+                    '\n' +
+                    outerIndent +
+                    '}';
+            }
+            else {
+                v = '{' + partial.join(',') + '}';
+            }
+            return v;
+        }
+        default: // Do nothing
+    }
+};
+// If the JSON object does not yet have a stringify method, give it one.
+const canonicalStringify = (value, options) => {
+    // Make a fake root object containing our value under the key of ''.
+    // Return the result of stringifying the value.
+    const allOptions = Object.assign({
+        indent: '',
+        canonical: false,
+    }, options);
+    if (allOptions.indent === true) {
+        allOptions.indent = '  ';
+    }
+    else if (typeof allOptions.indent === 'number') {
+        let newIndent = '';
+        for (let i = 0; i < allOptions.indent; i++) {
+            newIndent += ' ';
+        }
+        allOptions.indent = newIndent;
+    }
+    return str('', { '': value }, allOptions.indent, '', allOptions.canonical);
+};
+exports.default = canonicalStringify;