139 lines
5.3 KiB
JavaScript
139 lines
5.3 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 Tracker = Package.tracker.Tracker;
|
|
var Deps = Package.tracker.Deps;
|
|
|
|
/* Package-scope variables */
|
|
var ReactiveVar;
|
|
|
|
(function(){
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/reactive-var/reactive-var.js //
|
|
// //
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
/*
|
|
* ## [new] ReactiveVar(initialValue, [equalsFunc])
|
|
*
|
|
* A ReactiveVar holds a single value that can be get and set,
|
|
* such that calling `set` will invalidate any Computations that
|
|
* called `get`, according to the usual contract for reactive
|
|
* data sources.
|
|
*
|
|
* A ReactiveVar is much like a Session variable -- compare `foo.get()`
|
|
* to `Session.get("foo")` -- but it doesn't have a global name and isn't
|
|
* automatically migrated across hot code pushes. Also, while Session
|
|
* variables can only hold JSON or EJSON, ReactiveVars can hold any value.
|
|
*
|
|
* An important property of ReactiveVars, which is sometimes the reason
|
|
* to use one, is that setting the value to the same value as before has
|
|
* no effect, meaning ReactiveVars can be used to absorb extra
|
|
* invalidations that wouldn't serve a purpose. However, by default,
|
|
* ReactiveVars are extremely conservative about what changes they
|
|
* absorb. Calling `set` with an object argument will *always* trigger
|
|
* invalidations, because even if the new value is `===` the old value,
|
|
* the object may have been mutated. You can change the default behavior
|
|
* by passing a function of two arguments, `oldValue` and `newValue`,
|
|
* to the constructor as `equalsFunc`.
|
|
*
|
|
* This class is extremely basic right now, but the idea is to evolve
|
|
* it into the ReactiveVar of Geoff's Lickable Forms proposal.
|
|
*/
|
|
|
|
/**
|
|
* @class
|
|
* @instanceName reactiveVar
|
|
* @summary Constructor for a ReactiveVar, which represents a single reactive variable.
|
|
* @locus Client
|
|
* @param {Any} initialValue The initial value to set. `equalsFunc` is ignored when setting the initial value.
|
|
* @param {Function} [equalsFunc] Optional. A function of two arguments, called on the old value and the new value whenever the ReactiveVar is set. If it returns true, no set is performed. If omitted, the default `equalsFunc` returns true if its arguments are `===` and are of type number, boolean, string, undefined, or null.
|
|
*/
|
|
ReactiveVar = function (initialValue, equalsFunc) {
|
|
if (! (this instanceof ReactiveVar))
|
|
// called without `new`
|
|
return new ReactiveVar(initialValue, equalsFunc);
|
|
|
|
this.curValue = initialValue;
|
|
this.equalsFunc = equalsFunc;
|
|
this.dep = new Tracker.Dependency;
|
|
};
|
|
|
|
ReactiveVar._isEqual = function (oldValue, newValue) {
|
|
var a = oldValue, b = newValue;
|
|
// Two values are "equal" here if they are `===` and are
|
|
// number, boolean, string, undefined, or null.
|
|
if (a !== b)
|
|
return false;
|
|
else
|
|
return ((!a) || (typeof a === 'number') || (typeof a === 'boolean') ||
|
|
(typeof a === 'string'));
|
|
};
|
|
|
|
/**
|
|
* @summary Returns the current value of the ReactiveVar, establishing a reactive dependency.
|
|
* @locus Client
|
|
*/
|
|
ReactiveVar.prototype.get = function () {
|
|
if (Tracker.active)
|
|
this.dep.depend();
|
|
|
|
return this.curValue;
|
|
};
|
|
|
|
/**
|
|
* @summary Sets the current value of the ReactiveVar, invalidating the Computations that called `get` if `newValue` is different from the old value.
|
|
* @locus Client
|
|
* @param {Any} newValue
|
|
*/
|
|
ReactiveVar.prototype.set = function (newValue) {
|
|
var oldValue = this.curValue;
|
|
|
|
if ((this.equalsFunc || ReactiveVar._isEqual)(oldValue, newValue))
|
|
// value is same as last time
|
|
return;
|
|
|
|
this.curValue = newValue;
|
|
this.dep.changed();
|
|
};
|
|
|
|
ReactiveVar.prototype.toString = function () {
|
|
return 'ReactiveVar{' + this.get() + '}';
|
|
};
|
|
|
|
ReactiveVar.prototype._numListeners = function() {
|
|
// Tests want to know.
|
|
// Accesses a private field of Tracker.Dependency.
|
|
var count = 0;
|
|
for (var id in this.dep._dependentsById)
|
|
count++;
|
|
return count;
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}).call(this);
|
|
|
|
|
|
/* Exports */
|
|
Package._define("reactive-var", {
|
|
ReactiveVar: ReactiveVar
|
|
});
|
|
|
|
})();
|