449 lines
14 KiB
JavaScript
449 lines
14 KiB
JavaScript
//////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// This is a generated file. You can view the original //
|
|
// source in your browser if your browser supports source maps. //
|
|
// Source maps are supported by all recent versions of Chrome, Safari, //
|
|
// and Firefox, and by Internet Explorer 11. //
|
|
// //
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
(function () {
|
|
|
|
/* Imports */
|
|
var Meteor = Package.meteor.Meteor;
|
|
var global = Package.meteor.global;
|
|
var meteorEnv = Package.meteor.meteorEnv;
|
|
var _ = Package.underscore._;
|
|
var Tracker = Package.tracker.Tracker;
|
|
var Deps = Package.tracker.Deps;
|
|
var EJSON = Package.ejson.EJSON;
|
|
var meteorInstall = Package.modules.meteorInstall;
|
|
var meteorBabelHelpers = Package['babel-runtime'].meteorBabelHelpers;
|
|
var Promise = Package.promise.Promise;
|
|
var Symbol = Package['ecmascript-runtime-client'].Symbol;
|
|
var Map = Package['ecmascript-runtime-client'].Map;
|
|
var Set = Package['ecmascript-runtime-client'].Set;
|
|
|
|
/* Package-scope variables */
|
|
var ReactiveDict;
|
|
|
|
var require = meteorInstall({"node_modules":{"meteor":{"reactive-dict":{"migration.js":function(require,exports,module){
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/reactive-dict/migration.js //
|
|
// //
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
module.export({
|
|
ReactiveDict: function () {
|
|
return ReactiveDict;
|
|
}
|
|
});
|
|
var ReactiveDict;
|
|
module.watch(require("./reactive-dict"), {
|
|
ReactiveDict: function (v) {
|
|
ReactiveDict = v;
|
|
}
|
|
}, 0);
|
|
ReactiveDict._migratedDictData = {}; // name -> data
|
|
|
|
ReactiveDict._dictsToMigrate = {}; // name -> ReactiveDict
|
|
|
|
ReactiveDict._loadMigratedDict = function (dictName) {
|
|
if (_.has(ReactiveDict._migratedDictData, dictName)) {
|
|
var data = ReactiveDict._migratedDictData[dictName];
|
|
delete ReactiveDict._migratedDictData[dictName];
|
|
return data;
|
|
}
|
|
|
|
return null;
|
|
};
|
|
|
|
ReactiveDict._registerDictForMigrate = function (dictName, dict) {
|
|
if (_.has(ReactiveDict._dictsToMigrate, dictName)) throw new Error("Duplicate ReactiveDict name: " + dictName);
|
|
ReactiveDict._dictsToMigrate[dictName] = dict;
|
|
};
|
|
|
|
if (Meteor.isClient && Package.reload) {
|
|
// Put old migrated data into ReactiveDict._migratedDictData,
|
|
// where it can be accessed by ReactiveDict._loadMigratedDict.
|
|
var migrationData = Package.reload.Reload._migrationData('reactive-dict');
|
|
|
|
if (migrationData && migrationData.dicts) ReactiveDict._migratedDictData = migrationData.dicts; // On migration, assemble the data from all the dicts that have been
|
|
// registered.
|
|
|
|
Package.reload.Reload._onMigrate('reactive-dict', function () {
|
|
var dictsToMigrate = ReactiveDict._dictsToMigrate;
|
|
var dataToMigrate = {};
|
|
|
|
for (var dictName in meteorBabelHelpers.sanitizeForInObject(dictsToMigrate)) {
|
|
dataToMigrate[dictName] = dictsToMigrate[dictName]._getMigrationData();
|
|
}
|
|
|
|
return [true, {
|
|
dicts: dataToMigrate
|
|
}];
|
|
});
|
|
}
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
},"reactive-dict.js":function(require,exports,module){
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/reactive-dict/reactive-dict.js //
|
|
// //
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
|
|
|
|
var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
|
|
|
|
module.export({
|
|
ReactiveDict: function () {
|
|
return ReactiveDict;
|
|
}
|
|
});
|
|
|
|
// XXX come up with a serialization method which canonicalizes object key
|
|
// order, which would allow us to use objects as values for equals.
|
|
function stringify(value) {
|
|
if (value === undefined) {
|
|
return 'undefined';
|
|
}
|
|
|
|
return EJSON.stringify(value);
|
|
}
|
|
|
|
function parse(serialized) {
|
|
if (serialized === undefined || serialized === 'undefined') {
|
|
return undefined;
|
|
}
|
|
|
|
return EJSON.parse(serialized);
|
|
}
|
|
|
|
function changed(v) {
|
|
v && v.changed();
|
|
} // XXX COMPAT WITH 0.9.1 : accept migrationData instead of dictName
|
|
|
|
|
|
var ReactiveDict =
|
|
/*#__PURE__*/
|
|
function () {
|
|
function ReactiveDict(dictName, dictData) {
|
|
// this.keys: key -> value
|
|
this.keys = {};
|
|
|
|
if (dictName) {
|
|
// name given; migration will be performed
|
|
if (typeof dictName === 'string') {
|
|
// the normal case, argument is a string name.
|
|
// Only run migration logic on client, it will cause
|
|
// duplicate name errors on server during reloads.
|
|
// _registerDictForMigrate will throw an error on duplicate name.
|
|
Meteor.isClient && ReactiveDict._registerDictForMigrate(dictName, this);
|
|
|
|
var migratedData = Meteor.isClient && ReactiveDict._loadMigratedDict(dictName);
|
|
|
|
if (migratedData) {
|
|
// Don't stringify migrated data
|
|
this.keys = migratedData;
|
|
} else {
|
|
// Use _setObject to make sure values are stringified
|
|
this._setObject(dictData || {});
|
|
}
|
|
|
|
this.name = dictName;
|
|
} else if ((0, _typeof2.default)(dictName) === 'object') {
|
|
// back-compat case: dictName is actually migrationData
|
|
// Use _setObject to make sure values are stringified
|
|
this._setObject(dictName);
|
|
} else {
|
|
throw new Error("Invalid ReactiveDict argument: " + dictName);
|
|
}
|
|
} else if ((0, _typeof2.default)(dictData) === 'object') {
|
|
this._setObject(dictData);
|
|
}
|
|
|
|
this.allDeps = new Tracker.Dependency();
|
|
this.keyDeps = {}; // key -> Dependency
|
|
|
|
this.keyValueDeps = {}; // key -> Dependency
|
|
} // set() began as a key/value method, but we are now overloading it
|
|
// to take an object of key/value pairs, similar to backbone
|
|
// http://backbonejs.org/#Model-set
|
|
|
|
|
|
var _proto = ReactiveDict.prototype;
|
|
|
|
_proto.set = function () {
|
|
function set(keyOrObject, value) {
|
|
if ((0, _typeof2.default)(keyOrObject) === 'object' && value === undefined) {
|
|
// Called as `dict.set({...})`
|
|
this._setObject(keyOrObject);
|
|
|
|
return;
|
|
} // the input isn't an object, so it must be a key
|
|
// and we resume with the rest of the function
|
|
|
|
|
|
var key = keyOrObject;
|
|
value = stringify(value);
|
|
|
|
var keyExisted = _.has(this.keys, key);
|
|
|
|
var oldSerializedValue = keyExisted ? this.keys[key] : 'undefined';
|
|
var isNewValue = value !== oldSerializedValue;
|
|
this.keys[key] = value;
|
|
|
|
if (isNewValue || !keyExisted) {
|
|
// Using the changed utility function here because this.allDeps might not exist yet,
|
|
// when setting initial data from constructor
|
|
changed(this.allDeps);
|
|
} // Don't trigger changes when setting initial data from constructor,
|
|
// this.KeyDeps is undefined in this case
|
|
|
|
|
|
if (isNewValue && this.keyDeps) {
|
|
changed(this.keyDeps[key]);
|
|
|
|
if (this.keyValueDeps[key]) {
|
|
changed(this.keyValueDeps[key][oldSerializedValue]);
|
|
changed(this.keyValueDeps[key][value]);
|
|
}
|
|
}
|
|
}
|
|
|
|
return set;
|
|
}();
|
|
|
|
_proto.setDefault = function () {
|
|
function setDefault(keyOrObject, value) {
|
|
if ((0, _typeof2.default)(keyOrObject) === 'object' && value === undefined) {
|
|
// Called as `dict.setDefault({...})`
|
|
this._setDefaultObject(keyOrObject);
|
|
|
|
return;
|
|
} // the input isn't an object, so it must be a key
|
|
// and we resume with the rest of the function
|
|
|
|
|
|
var key = keyOrObject;
|
|
|
|
if (!_.has(this.keys, key)) {
|
|
this.set(key, value);
|
|
}
|
|
}
|
|
|
|
return setDefault;
|
|
}();
|
|
|
|
_proto.get = function () {
|
|
function get(key) {
|
|
this._ensureKey(key);
|
|
|
|
this.keyDeps[key].depend();
|
|
return parse(this.keys[key]);
|
|
}
|
|
|
|
return get;
|
|
}();
|
|
|
|
_proto.equals = function () {
|
|
function equals(key, value) {
|
|
var _this = this;
|
|
|
|
// Mongo.ObjectID is in the 'mongo' package
|
|
var ObjectID = null;
|
|
|
|
if (Package.mongo) {
|
|
ObjectID = Package.mongo.Mongo.ObjectID;
|
|
} // We don't allow objects (or arrays that might include objects) for
|
|
// .equals, because JSON.stringify doesn't canonicalize object key
|
|
// order. (We can make equals have the right return value by parsing the
|
|
// current value and using EJSON.equals, but we won't have a canonical
|
|
// element of keyValueDeps[key] to store the dependency.) You can still use
|
|
// "EJSON.equals(reactiveDict.get(key), value)".
|
|
//
|
|
// XXX we could allow arrays as long as we recursively check that there
|
|
// are no objects
|
|
|
|
|
|
if (typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean' && typeof value !== 'undefined' && !(value instanceof Date) && !(ObjectID && value instanceof ObjectID) && value !== null) {
|
|
throw new Error("ReactiveDict.equals: value must be scalar");
|
|
}
|
|
|
|
var serializedValue = stringify(value);
|
|
|
|
if (Tracker.active) {
|
|
this._ensureKey(key);
|
|
|
|
if (!_.has(this.keyValueDeps[key], serializedValue)) {
|
|
this.keyValueDeps[key][serializedValue] = new Tracker.Dependency();
|
|
}
|
|
|
|
var isNew = this.keyValueDeps[key][serializedValue].depend();
|
|
|
|
if (isNew) {
|
|
Tracker.onInvalidate(function () {
|
|
// clean up [key][serializedValue] if it's now empty, so we don't
|
|
// use O(n) memory for n = values seen ever
|
|
if (!_this.keyValueDeps[key][serializedValue].hasDependents()) {
|
|
delete _this.keyValueDeps[key][serializedValue];
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
var oldValue = undefined;
|
|
|
|
if (_.has(this.keys, key)) {
|
|
oldValue = parse(this.keys[key]);
|
|
}
|
|
|
|
return EJSON.equals(oldValue, value);
|
|
}
|
|
|
|
return equals;
|
|
}();
|
|
|
|
_proto.all = function () {
|
|
function all() {
|
|
this.allDeps.depend();
|
|
var ret = {};
|
|
|
|
_.each(this.keys, function (value, key) {
|
|
ret[key] = parse(value);
|
|
});
|
|
|
|
return ret;
|
|
}
|
|
|
|
return all;
|
|
}();
|
|
|
|
_proto.clear = function () {
|
|
function clear() {
|
|
var _this2 = this;
|
|
|
|
var oldKeys = this.keys;
|
|
this.keys = {};
|
|
this.allDeps.changed();
|
|
|
|
_.each(oldKeys, function (value, key) {
|
|
changed(_this2.keyDeps[key]);
|
|
|
|
if (_this2.keyValueDeps[key]) {
|
|
changed(_this2.keyValueDeps[key][value]);
|
|
changed(_this2.keyValueDeps[key]['undefined']);
|
|
}
|
|
});
|
|
}
|
|
|
|
return clear;
|
|
}();
|
|
|
|
_proto.delete = function () {
|
|
function _delete(key) {
|
|
var didRemove = false;
|
|
|
|
if (_.has(this.keys, key)) {
|
|
var oldValue = this.keys[key];
|
|
delete this.keys[key];
|
|
changed(this.keyDeps[key]);
|
|
|
|
if (this.keyValueDeps[key]) {
|
|
changed(this.keyValueDeps[key][oldValue]);
|
|
changed(this.keyValueDeps[key]['undefined']);
|
|
}
|
|
|
|
this.allDeps.changed();
|
|
didRemove = true;
|
|
}
|
|
|
|
return didRemove;
|
|
}
|
|
|
|
return _delete;
|
|
}();
|
|
|
|
_proto.destroy = function () {
|
|
function destroy() {
|
|
this.clear();
|
|
|
|
if (this.name && _.has(ReactiveDict._dictsToMigrate, this.name)) {
|
|
delete ReactiveDict._dictsToMigrate[this.name];
|
|
}
|
|
}
|
|
|
|
return destroy;
|
|
}();
|
|
|
|
_proto._setObject = function () {
|
|
function _setObject(object) {
|
|
var _this3 = this;
|
|
|
|
_.each(object, function (value, key) {
|
|
_this3.set(key, value);
|
|
});
|
|
}
|
|
|
|
return _setObject;
|
|
}();
|
|
|
|
_proto._setDefaultObject = function () {
|
|
function _setDefaultObject(object) {
|
|
var _this4 = this;
|
|
|
|
_.each(object, function (value, key) {
|
|
_this4.setDefault(key, value);
|
|
});
|
|
}
|
|
|
|
return _setDefaultObject;
|
|
}();
|
|
|
|
_proto._ensureKey = function () {
|
|
function _ensureKey(key) {
|
|
if (!(key in this.keyDeps)) {
|
|
this.keyDeps[key] = new Tracker.Dependency();
|
|
this.keyValueDeps[key] = {};
|
|
}
|
|
}
|
|
|
|
return _ensureKey;
|
|
}(); // Get a JSON value that can be passed to the constructor to
|
|
// create a new ReactiveDict with the same contents as this one
|
|
|
|
|
|
_proto._getMigrationData = function () {
|
|
function _getMigrationData() {
|
|
// XXX sanitize and make sure it's JSONible?
|
|
return this.keys;
|
|
}
|
|
|
|
return _getMigrationData;
|
|
}();
|
|
|
|
return ReactiveDict;
|
|
}();
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}}}}},{
|
|
"extensions": [
|
|
".js",
|
|
".json"
|
|
]
|
|
});
|
|
var exports = require("/node_modules/meteor/reactive-dict/migration.js");
|
|
|
|
/* Exports */
|
|
Package._define("reactive-dict", exports, {
|
|
ReactiveDict: ReactiveDict
|
|
});
|
|
|
|
})();
|