| 'use strict'; |
| |
| var PENDING = 'pending'; |
| var SETTLED = 'settled'; |
| var FULFILLED = 'fulfilled'; |
| var REJECTED = 'rejected'; |
| var NOOP = function () {}; |
| var isNode = typeof global !== 'undefined' && typeof global.process !== 'undefined' && typeof global.process.emit === 'function'; |
| |
| var asyncSetTimer = typeof setImmediate === 'undefined' ? setTimeout : setImmediate; |
| var asyncQueue = []; |
| var asyncTimer; |
| |
| function asyncFlush() { |
| // run promise callbacks |
| for (var i = 0; i < asyncQueue.length; i++) { |
| asyncQueue[i][0](asyncQueue[i][1]); |
| } |
| |
| // reset async asyncQueue |
| asyncQueue = []; |
| asyncTimer = false; |
| } |
| |
| function asyncCall(callback, arg) { |
| asyncQueue.push([callback, arg]); |
| |
| if (!asyncTimer) { |
| asyncTimer = true; |
| asyncSetTimer(asyncFlush, 0); |
| } |
| } |
| |
| function invokeResolver(resolver, promise) { |
| function resolvePromise(value) { |
| resolve(promise, value); |
| } |
| |
| function rejectPromise(reason) { |
| reject(promise, reason); |
| } |
| |
| try { |
| resolver(resolvePromise, rejectPromise); |
| } catch (e) { |
| rejectPromise(e); |
| } |
| } |
| |
| function invokeCallback(subscriber) { |
| var owner = subscriber.owner; |
| var settled = owner._state; |
| var value = owner._data; |
| var callback = subscriber[settled]; |
| var promise = subscriber.then; |
| |
| if (typeof callback === 'function') { |
| settled = FULFILLED; |
| try { |
| value = callback(value); |
| } catch (e) { |
| reject(promise, e); |
| } |
| } |
| |
| if (!handleThenable(promise, value)) { |
| if (settled === FULFILLED) { |
| resolve(promise, value); |
| } |
| |
| if (settled === REJECTED) { |
| reject(promise, value); |
| } |
| } |
| } |
| |
| function handleThenable(promise, value) { |
| var resolved; |
| |
| try { |
| if (promise === value) { |
| throw new TypeError('A promises callback cannot return that same promise.'); |
| } |
| |
| if (value && (typeof value === 'function' || typeof value === 'object')) { |
| // then should be retrieved only once |
| var then = value.then; |
| |
| if (typeof then === 'function') { |
| then.call(value, function (val) { |
| if (!resolved) { |
| resolved = true; |
| |
| if (value === val) { |
| fulfill(promise, val); |
| } else { |
| resolve(promise, val); |
| } |
| } |
| }, function (reason) { |
| if (!resolved) { |
| resolved = true; |
| |
| reject(promise, reason); |
| } |
| }); |
| |
| return true; |
| } |
| } |
| } catch (e) { |
| if (!resolved) { |
| reject(promise, e); |
| } |
| |
| return true; |
| } |
| |
| return false; |
| } |
| |
| function resolve(promise, value) { |
| if (promise === value || !handleThenable(promise, value)) { |
| fulfill(promise, value); |
| } |
| } |
| |
| function fulfill(promise, value) { |
| if (promise._state === PENDING) { |
| promise._state = SETTLED; |
| promise._data = value; |
| |
| asyncCall(publishFulfillment, promise); |
| } |
| } |
| |
| function reject(promise, reason) { |
| if (promise._state === PENDING) { |
| promise._state = SETTLED; |
| promise._data = reason; |
| |
| asyncCall(publishRejection, promise); |
| } |
| } |
| |
| function publish(promise) { |
| promise._then = promise._then.forEach(invokeCallback); |
| } |
| |
| function publishFulfillment(promise) { |
| promise._state = FULFILLED; |
| publish(promise); |
| } |
| |
| function publishRejection(promise) { |
| promise._state = REJECTED; |
| publish(promise); |
| if (!promise._handled && isNode) { |
| global.process.emit('unhandledRejection', promise._data, promise); |
| } |
| } |
| |
| function notifyRejectionHandled(promise) { |
| global.process.emit('rejectionHandled', promise); |
| } |
| |
| /** |
| * @class |
| */ |
| function Promise(resolver) { |
| if (typeof resolver !== 'function') { |
| throw new TypeError('Promise resolver ' + resolver + ' is not a function'); |
| } |
| |
| if (this instanceof Promise === false) { |
| throw new TypeError('Failed to construct \'Promise\': Please use the \'new\' operator, this object constructor cannot be called as a function.'); |
| } |
| |
| this._then = []; |
| |
| invokeResolver(resolver, this); |
| } |
| |
| Promise.prototype = { |
| constructor: Promise, |
| |
| _state: PENDING, |
| _then: null, |
| _data: undefined, |
| _handled: false, |
| |
| then: function (onFulfillment, onRejection) { |
| var subscriber = { |
| owner: this, |
| then: new this.constructor(NOOP), |
| fulfilled: onFulfillment, |
| rejected: onRejection |
| }; |
| |
| if ((onRejection || onFulfillment) && !this._handled) { |
| this._handled = true; |
| if (this._state === REJECTED && isNode) { |
| asyncCall(notifyRejectionHandled, this); |
| } |
| } |
| |
| if (this._state === FULFILLED || this._state === REJECTED) { |
| // already resolved, call callback async |
| asyncCall(invokeCallback, subscriber); |
| } else { |
| // subscribe |
| this._then.push(subscriber); |
| } |
| |
| return subscriber.then; |
| }, |
| |
| catch: function (onRejection) { |
| return this.then(null, onRejection); |
| } |
| }; |
| |
| Promise.all = function (promises) { |
| if (!Array.isArray(promises)) { |
| throw new TypeError('You must pass an array to Promise.all().'); |
| } |
| |
| return new Promise(function (resolve, reject) { |
| var results = []; |
| var remaining = 0; |
| |
| function resolver(index) { |
| remaining++; |
| return function (value) { |
| results[index] = value; |
| if (!--remaining) { |
| resolve(results); |
| } |
| }; |
| } |
| |
| for (var i = 0, promise; i < promises.length; i++) { |
| promise = promises[i]; |
| |
| if (promise && typeof promise.then === 'function') { |
| promise.then(resolver(i), reject); |
| } else { |
| results[i] = promise; |
| } |
| } |
| |
| if (!remaining) { |
| resolve(results); |
| } |
| }); |
| }; |
| |
| Promise.race = function (promises) { |
| if (!Array.isArray(promises)) { |
| throw new TypeError('You must pass an array to Promise.race().'); |
| } |
| |
| return new Promise(function (resolve, reject) { |
| for (var i = 0, promise; i < promises.length; i++) { |
| promise = promises[i]; |
| |
| if (promise && typeof promise.then === 'function') { |
| promise.then(resolve, reject); |
| } else { |
| resolve(promise); |
| } |
| } |
| }); |
| }; |
| |
| Promise.resolve = function (value) { |
| if (value && typeof value === 'object' && value.constructor === Promise) { |
| return value; |
| } |
| |
| return new Promise(function (resolve) { |
| resolve(value); |
| }); |
| }; |
| |
| Promise.reject = function (reason) { |
| return new Promise(function (resolve, reject) { |
| reject(reason); |
| }); |
| }; |
| |
| module.exports = Promise; |