• Classes
• Modules
• Everything

 /**
 Represents an asynchronous operation. Provides a
 standard API for subscribing to the moment that the operation completes either
 successfully (`fulfill()`) or unsuccessfully (`reject()`).
 
 @class Promise.Resolver
 @constructor
 @param {Promise} promise The promise instance this resolver will be handling
 **/
 function Resolver(promise) {
 /**
 List of success callbacks
 
 @property _callbacks
 @type Array
 @private
 **/
 this._callbacks = [];
 
 /**
 List of failure callbacks
 
 @property _errbacks
 @type Array
 @private
 **/
 this._errbacks = [];
 
 /**
 The promise for this Resolver.
 
 @property promise
 @type Promise
 @deprecated
 **/
 this.promise = promise;
 
 /**
 The status of the operation. This property may take only one of the following
 values: 'pending', 'fulfilled' or 'rejected'.
 
 @property _status
 @type String
 @default 'pending'
 @private
 **/
 this._status = 'pending';
 
 /**
 This value that this promise represents.
 
 @property _result
 @type Any
 @private
 **/
 this._result = null;
 }
 
 Y.mix(Resolver.prototype, {
 /**
 Resolves the promise, signaling successful completion of the
 represented operation. All "onFulfilled" subscriptions are executed and passed
 the value provided to this method. After calling `fulfill()`, `reject()` and
 `notify()` are disabled.
 
 @method fulfill
 @param {Any} value Value to pass along to the "onFulfilled" subscribers
 **/
 fulfill: function (value) {
 if (this._status === 'pending') {
 this._result = value;
 this._status = 'fulfilled';
 }
 
 if (this._status === 'fulfilled') {
 this._notify(this._callbacks, this._result);
 
 // Reset the callback list so that future calls to fulfill()
 // won't call the same callbacks again. Promises keep a list
 // of callbacks, they're not the same as events. In practice,
 // calls to fulfill() after the first one should not be made by
 // the user but by then()
 this._callbacks = [];
 
 // Once a promise gets fulfilled it can't be rejected, so
 // there is no point in keeping the list. Remove it to help
 // garbage collection
 this._errbacks = null;
 }
 },
 
 /**
 Resolves the promise, signaling *un*successful completion of the
 represented operation. All "onRejected" subscriptions are executed with
 the value provided to this method. After calling `reject()`, `resolve()`
 and `notify()` are disabled.
 
 @method reject
 @param {Any} value Value to pass along to the "reject" subscribers
 **/
 reject: function (reason) {
 if (this._status === 'pending') {
 this._result = reason;
 this._status = 'rejected';
 }
 
 if (this._status === 'rejected') {
 if (!this._errbacks.length) { Y.log('This promise was rejected but no error handlers were registered to it', 'info', NAME); }
 this._notify(this._errbacks, this._result);
 
 // See fulfill()
 this._callbacks = null;
 this._errbacks = [];
 }
 },
 
 /*
 Given a certain value A passed as a parameter, this method resolves the
 promise to the value A.
 
 If A is a promise, `resolve` will cause the resolver to adopt the state of A
 and once A is resolved, it will resolve the resolver's promise as well.
 This behavior "flattens" A by calling `then` recursively and essentially
 disallows promises-for-promises.
 
 This is the default algorithm used when using the function passed as the
 first argument to the promise initialization function. This means that
 the following code returns a promise for the value 'hello world':
 
 var promise1 = new Y.Promise(function (resolve) {
 resolve('hello world');
 });
 var promise2 = new Y.Promise(function (resolve) {
 resolve(promise1);
 });
 promise2.then(function (value) {
 assert(value === 'hello world'); // true
 });
 
 @method resolve
 @param [Any] value A regular JS value or a promise
 */
 resolve: function (value) {
 var self = this;
 
 if (Promise.isPromise(value)) {
 value.then(function (value) {
 self.resolve(value);
 }, function (reason) {
 self.reject(reason);
 });
 } else {
 this.fulfill(value);
 }
 },
 
 /**
 Schedule execution of a callback to either or both of "resolve" and
 "reject" resolutions for the Resolver. The callbacks
 are wrapped in a new Resolver and that Resolver's corresponding promise
 is returned. This allows operation chaining ala
 `functionA().then(functionB).then(functionC)` where `functionA` returns
 a promise, and `functionB` and `functionC` _may_ return promises.
 
 @method then
 @param {Function} [callback] function to execute if the Resolver
 resolves successfully
 @param {Function} [errback] function to execute if the Resolver
 resolves unsuccessfully
 @return {Promise} The promise of a new Resolver wrapping the resolution
 of either "resolve" or "reject" callback
 @deprecated
 **/
 then: function (callback, errback) {
 return this.promise.then(callback, errback);
 },
 
 /**
 Schedule execution of a callback to either or both of "resolve" and
 "reject" resolutions of this resolver. If the resolver is not pending,
 the correct callback gets called automatically.
 
 @method _addCallbacks
 @param {Function} [callback] function to execute if the Resolver
 resolves successfully
 @param {Function} [errback] function to execute if the Resolver
 resolves unsuccessfully
 @private
 **/
 _addCallbacks: function (callback, errback) {
 var callbackList = this._callbacks,
 errbackList = this._errbacks,
 status = this._status,
 result = this._result;
 
 if (callbackList && typeof callback === 'function') {
 callbackList.push(callback);
 }
 if (errbackList && typeof errback === 'function') {
 errbackList.push(errback);
 }
 
 // If a promise is already fulfilled or rejected, notify the newly added
 // callbacks by calling fulfill() or reject()
 if (status === 'fulfilled') {
 this.fulfill(result);
 } else if (status === 'rejected') {
 this.reject(result);
 }
 },
 
 /**
 Returns the current status of the Resolver as a string "pending",
 "fulfilled", or "rejected".
 
 @method getStatus
 @return {String}
 @deprecated
 **/
 getStatus: function () {
 Y.log('resolver.getStatus() will be removed in the future', 'warn', NAME);
 return this._status;
 },
 
 /**
 Executes an array of callbacks from a specified context, passing a set of
 arguments.
 
 @method _notify
 @param {Function[]} subs The array of subscriber callbacks
 @param {Any} result Value to pass the callbacks
 @protected
 **/
 _notify: function (subs, result) {
 // Since callback lists are reset synchronously, the subs list never
 // changes after _notify() receives it. Avoid calling Y.soon() for
 // an empty list
 if (subs.length) {
 // Calling all callbacks after Y.soon to guarantee
 // asynchronicity. Because setTimeout can cause unnecessary
 // delays that *can* become noticeable in some situations
 // (especially in Node.js)
 Y.soon(function () {
 var i, len;
 
 for (i = 0, len = subs.length; i < len; ++i) {
 subs[i](result);
 }
 });
 }
 }
 
 }, true);
 
 Y.Promise.Resolver = Resolver;