1177 lines
28 KiB
JavaScript
1177 lines
28 KiB
JavaScript
|
/*!
|
||
|
|
* @overview es6-promise - a tiny implementation of Promises/A+.
|
||
|
|
* @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)
|
||
|
|
* @license Licensed under MIT license
|
||
|
|
* See https://raw.githubusercontent.com/stefanpenner/es6-promise/master/LICENSE
|
||
|
|
* @version v4.2.8+1e68dce6
|
||
|
|
*/
|
||
|
|
|
||
|
|
(function (global, factory) {
|
||
|
|
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
|
||
|
|
typeof define === 'function' && define.amd ? define(factory) :
|
||
|
|
(global.ES6Promise = factory());
|
||
|
|
}(this, (function () { 'use strict';
|
||
|
|
|
||
|
|
function objectOrFunction(x) {
|
||
|
|
var type = typeof x;
|
||
|
|
return x !== null && (type === 'object' || type === 'function');
|
||
|
|
}
|
||
|
|
|
||
|
|
function isFunction(x) {
|
||
|
|
return typeof x === 'function';
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
var _isArray = void 0;
|
||
|
|
if (Array.isArray) {
|
||
|
|
_isArray = Array.isArray;
|
||
|
|
} else {
|
||
|
|
_isArray = function (x) {
|
||
|
|
return Object.prototype.toString.call(x) === '[object Array]';
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
var isArray = _isArray;
|
||
|
|
|
||
|
|
var len = 0;
|
||
|
|
var vertxNext = void 0;
|
||
|
|
var customSchedulerFn = void 0;
|
||
|
|
|
||
|
|
var asap = function asap(callback, arg) {
|
||
|
|
queue[len] = callback;
|
||
|
|
queue[len + 1] = arg;
|
||
|
|
len += 2;
|
||
|
|
if (len === 2) {
|
||
|
|
// If len is 2, that means that we need to schedule an async flush.
|
||
|
|
// If additional callbacks are queued before the queue is flushed, they
|
||
|
|
// will be processed by this flush that we are scheduling.
|
||
|
|
if (customSchedulerFn) {
|
||
|
|
customSchedulerFn(flush);
|
||
|
|
} else {
|
||
|
|
scheduleFlush();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
function setScheduler(scheduleFn) {
|
||
|
|
customSchedulerFn = scheduleFn;
|
||
|
|
}
|
||
|
|
|
||
|
|
function setAsap(asapFn) {
|
||
|
|
asap = asapFn;
|
||
|
|
}
|
||
|
|
|
||
|
|
var browserWindow = typeof window !== 'undefined' ? window : undefined;
|
||
|
|
var browserGlobal = browserWindow || {};
|
||
|
|
var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
|
||
|
|
var isNode = typeof self === 'undefined' && typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';
|
||
|
|
|
||
|
|
// test for web worker but not in IE10
|
||
|
|
var isWorker = typeof Uint8ClampedArray !== 'undefined' && typeof importScripts !== 'undefined' && typeof MessageChannel !== 'undefined';
|
||
|
|
|
||
|
|
// node
|
||
|
|
function useNextTick() {
|
||
|
|
// node version 0.10.x displays a deprecation warning when nextTick is used recursively
|
||
|
|
// see https://github.com/cujojs/when/issues/410 for details
|
||
|
|
return function () {
|
||
|
|
return process.nextTick(flush);
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
// vertx
|
||
|
|
function useVertxTimer() {
|
||
|
|
if (typeof vertxNext !== 'undefined') {
|
||
|
|
return function () {
|
||
|
|
vertxNext(flush);
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
return useSetTimeout();
|
||
|
|
}
|
||
|
|
|
||
|
|
function useMutationObserver() {
|
||
|
|
var iterations = 0;
|
||
|
|
var observer = new BrowserMutationObserver(flush);
|
||
|
|
var node = document.createTextNode('');
|
||
|
|
observer.observe(node, { characterData: true });
|
||
|
|
|
||
|
|
return function () {
|
||
|
|
node.data = iterations = ++iterations % 2;
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
// web worker
|
||
|
|
function useMessageChannel() {
|
||
|
|
var channel = new MessageChannel();
|
||
|
|
channel.port1.onmessage = flush;
|
||
|
|
return function () {
|
||
|
|
return channel.port2.postMessage(0);
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
function useSetTimeout() {
|
||
|
|
// Store setTimeout reference so es6-promise will be unaffected by
|
||
|
|
// other code modifying setTimeout (like sinon.useFakeTimers())
|
||
|
|
var globalSetTimeout = setTimeout;
|
||
|
|
return function () {
|
||
|
|
return globalSetTimeout(flush, 1);
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
var queue = new Array(1000);
|
||
|
|
function flush() {
|
||
|
|
for (var i = 0; i < len; i += 2) {
|
||
|
|
var callback = queue[i];
|
||
|
|
var arg = queue[i + 1];
|
||
|
|
|
||
|
|
callback(arg);
|
||
|
|
|
||
|
|
queue[i] = undefined;
|
||
|
|
queue[i + 1] = undefined;
|
||
|
|
}
|
||
|
|
|
||
|
|
len = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
function attemptVertx() {
|
||
|
|
try {
|
||
|
|
var vertx = Function('return this')().require('vertx');
|
||
|
|
vertxNext = vertx.runOnLoop || vertx.runOnContext;
|
||
|
|
return useVertxTimer();
|
||
|
|
} catch (e) {
|
||
|
|
return useSetTimeout();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
var scheduleFlush = void 0;
|
||
|
|
// Decide what async method to use to triggering processing of queued callbacks:
|
||
|
|
if (isNode) {
|
||
|
|
scheduleFlush = useNextTick();
|
||
|
|
} else if (BrowserMutationObserver) {
|
||
|
|
scheduleFlush = useMutationObserver();
|
||
|
|
} else if (isWorker) {
|
||
|
|
scheduleFlush = useMessageChannel();
|
||
|
|
} else if (browserWindow === undefined && typeof require === 'function') {
|
||
|
|
scheduleFlush = attemptVertx();
|
||
|
|
} else {
|
||
|
|
scheduleFlush = useSetTimeout();
|
||
|
|
}
|
||
|
|
|
||
|
|
function then(onFulfillment, onRejection) {
|
||
|
|
var parent = this;
|
||
|
|
|
||
|
|
var child = new this.constructor(noop);
|
||
|
|
|
||
|
|
if (child[PROMISE_ID] === undefined) {
|
||
|
|
makePromise(child);
|
||
|
|
}
|
||
|
|
|
||
|
|
var _state = parent._state;
|
||
|
|
|
||
|
|
|
||
|
|
if (_state) {
|
||
|
|
var callback = arguments[_state - 1];
|
||
|
|
asap(function () {
|
||
|
|
return invokeCallback(_state, child, callback, parent._result);
|
||
|
|
});
|
||
|
|
} else {
|
||
|
|
subscribe(parent, child, onFulfillment, onRejection);
|
||
|
|
}
|
||
|
|
|
||
|
|
return child;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
`Promise.resolve` returns a promise that will become resolved with the
|
||
|
|
passed `value`. It is shorthand for the following:
|
||
|
|
|
||
|
|
```javascript
|
||
|
|
let promise = new Promise(function(resolve, reject){
|
||
|
|
resolve(1);
|
||
|
|
});
|
||
|
|
|
||
|
|
promise.then(function(value){
|
||
|
|
// value === 1
|
||
|
|
});
|
||
|
|
```
|
||
|
|
|
||
|
|
Instead of writing the above, your code now simply becomes the following:
|
||
|
|
|
||
|
|
```javascript
|
||
|
|
let promise = Promise.resolve(1);
|
||
|
|
|
||
|
|
promise.then(function(value){
|
||
|
|
// value === 1
|
||
|
|
});
|
||
|
|
```
|
||
|
|
|
||
|
|
@method resolve
|
||
|
|
@static
|
||
|
|
@param {Any} value value that the returned promise will be resolved with
|
||
|
|
Useful for tooling.
|
||
|
|
@return {Promise} a promise that will become fulfilled with the given
|
||
|
|
`value`
|
||
|
|
*/
|
||
|
|
function resolve$1(object) {
|
||
|
|
/*jshint validthis:true */
|
||
|
|
var Constructor = this;
|
||
|
|
|
||
|
|
if (object && typeof object === 'object' && object.constructor === Constructor) {
|
||
|
|
return object;
|
||
|
|
}
|
||
|
|
|
||
|
|
var promise = new Constructor(noop);
|
||
|
|
resolve(promise, object);
|
||
|
|
return promise;
|
||
|
|
}
|
||
|
|
|
||
|
|
var PROMISE_ID = Math.random().toString(36).substring(2);
|
||
|
|
|
||
|
|
function noop() {}
|
||
|
|
|
||
|
|
var PENDING = void 0;
|
||
|
|
var FULFILLED = 1;
|
||
|
|
var REJECTED = 2;
|
||
|
|
|
||
|
|
function selfFulfillment() {
|
||
|
|
return new TypeError("You cannot resolve a promise with itself");
|
||
|
|
}
|
||
|
|
|
||
|
|
function cannotReturnOwn() {
|
||
|
|
return new TypeError('A promises callback cannot return that same promise.');
|
||
|
|
}
|
||
|
|
|
||
|
|
function tryThen(then$$1, value, fulfillmentHandler, rejectionHandler) {
|
||
|
|
try {
|
||
|
|
then$$1.call(value, fulfillmentHandler, rejectionHandler);
|
||
|
|
} catch (e) {
|
||
|
|
return e;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function handleForeignThenable(promise, thenable, then$$1) {
|
||
|
|
asap(function (promise) {
|
||
|
|
var sealed = false;
|
||
|
|
var error = tryThen(then$$1, thenable, function (value) {
|
||
|
|
if (sealed) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
sealed = true;
|
||
|
|
if (thenable !== value) {
|
||
|
|
resolve(promise, value);
|
||
|
|
} else {
|
||
|
|
fulfill(promise, value);
|
||
|
|
}
|
||
|
|
}, function (reason) {
|
||
|
|
if (sealed) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
sealed = true;
|
||
|
|
|
||
|
|
reject(promise, reason);
|
||
|
|
}, 'Settle: ' + (promise._label || ' unknown promise'));
|
||
|
|
|
||
|
|
if (!sealed && error) {
|
||
|
|
sealed = true;
|
||
|
|
reject(promise, error);
|
||
|
|
}
|
||
|
|
}, promise);
|
||
|
|
}
|
||
|
|
|
||
|
|
function handleOwnThenable(promise, thenable) {
|
||
|
|
if (thenable._state === FULFILLED) {
|
||
|
|
fulfill(promise, thenable._result);
|
||
|
|
} else if (thenable._state === REJECTED) {
|
||
|
|
reject(promise, thenable._result);
|
||
|
|
} else {
|
||
|
|
subscribe(thenable, undefined, function (value) {
|
||
|
|
return resolve(promise, value);
|
||
|
|
}, function (reason) {
|
||
|
|
return reject(promise, reason);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function handleMaybeThenable(promise, maybeThenable, then$$1) {
|
||
|
|
if (maybeThenable.constructor === promise.constructor && then$$1 === then && maybeThenable.constructor.resolve === resolve$1) {
|
||
|
|
handleOwnThenable(promise, maybeThenable);
|
||
|
|
} else {
|
||
|
|
if (then$$1 === undefined) {
|
||
|
|
fulfill(promise, maybeThenable);
|
||
|
|
} else if (isFunction(then$$1)) {
|
||
|
|
handleForeignThenable(promise, maybeThenable, then$$1);
|
||
|
|
} else {
|
||
|
|
fulfill(promise, maybeThenable);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function resolve(promise, value) {
|
||
|
|
if (promise === value) {
|
||
|
|
reject(promise, selfFulfillment());
|
||
|
|
} else if (objectOrFunction(value)) {
|
||
|
|
var then$$1 = void 0;
|
||
|
|
try {
|
||
|
|
then$$1 = value.then;
|
||
|
|
} catch (error) {
|
||
|
|
reject(promise, error);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
handleMaybeThenable(promise, value, then$$1);
|
||
|
|
} else {
|
||
|
|
fulfill(promise, value);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function publishRejection(promise) {
|
||
|
|
if (promise._onerror) {
|
||
|
|
promise._onerror(promise._result);
|
||
|
|
}
|
||
|
|
|
||
|
|
publish(promise);
|
||
|
|
}
|
||
|
|
|
||
|
|
function fulfill(promise, value) {
|
||
|
|
if (promise._state !== PENDING) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
promise._result = value;
|
||
|
|
promise._state = FULFILLED;
|
||
|
|
|
||
|
|
if (promise._subscribers.length !== 0) {
|
||
|
|
asap(publish, promise);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function reject(promise, reason) {
|
||
|
|
if (promise._state !== PENDING) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
promise._state = REJECTED;
|
||
|
|
promise._result = reason;
|
||
|
|
|
||
|
|
asap(publishRejection, promise);
|
||
|
|
}
|
||
|
|
|
||
|
|
function subscribe(parent, child, onFulfillment, onRejection) {
|
||
|
|
var _subscribers = parent._subscribers;
|
||
|
|
var length = _subscribers.length;
|
||
|
|
|
||
|
|
|
||
|
|
parent._onerror = null;
|
||
|
|
|
||
|
|
_subscribers[length] = child;
|
||
|
|
_subscribers[length + FULFILLED] = onFulfillment;
|
||
|
|
_subscribers[length + REJECTED] = onRejection;
|
||
|
|
|
||
|
|
if (length === 0 && parent._state) {
|
||
|
|
asap(publish, parent);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function publish(promise) {
|
||
|
|
var subscribers = promise._subscribers;
|
||
|
|
var settled = promise._state;
|
||
|
|
|
||
|
|
if (subscribers.length === 0) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
var child = void 0,
|
||
|
|
callback = void 0,
|
||
|
|
detail = promise._result;
|
||
|
|
|
||
|
|
for (var i = 0; i < subscribers.length; i += 3) {
|
||
|
|
child = subscribers[i];
|
||
|
|
callback = subscribers[i + settled];
|
||
|
|
|
||
|
|
if (child) {
|
||
|
|
invokeCallback(settled, child, callback, detail);
|
||
|
|
} else {
|
||
|
|
callback(detail);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
promise._subscribers.length = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
function invokeCallback(settled, promise, callback, detail) {
|
||
|
|
var hasCallback = isFunction(callback),
|
||
|
|
value = void 0,
|
||
|
|
error = void 0,
|
||
|
|
succeeded = true;
|
||
|
|
|
||
|
|
if (hasCallback) {
|
||
|
|
try {
|
||
|
|
value = callback(detail);
|
||
|
|
} catch (e) {
|
||
|
|
succeeded = false;
|
||
|
|
error = e;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (promise === value) {
|
||
|
|
reject(promise, cannotReturnOwn());
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
value = detail;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (promise._state !== PENDING) {
|
||
|
|
// noop
|
||
|
|
} else if (hasCallback && succeeded) {
|
||
|
|
resolve(promise, value);
|
||
|
|
} else if (succeeded === false) {
|
||
|
|
reject(promise, error);
|
||
|
|
} else if (settled === FULFILLED) {
|
||
|
|
fulfill(promise, value);
|
||
|
|
} else if (settled === REJECTED) {
|
||
|
|
reject(promise, value);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function initializePromise(promise, resolver) {
|
||
|
|
try {
|
||
|
|
resolver(function resolvePromise(value) {
|
||
|
|
resolve(promise, value);
|
||
|
|
}, function rejectPromise(reason) {
|
||
|
|
reject(promise, reason);
|
||
|
|
});
|
||
|
|
} catch (e) {
|
||
|
|
reject(promise, e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
var id = 0;
|
||
|
|
function nextId() {
|
||
|
|
return id++;
|
||
|
|
}
|
||
|
|
|
||
|
|
function makePromise(promise) {
|
||
|
|
promise[PROMISE_ID] = id++;
|
||
|
|
promise._state = undefined;
|
||
|
|
promise._result = undefined;
|
||
|
|
promise._subscribers = [];
|
||
|
|
}
|
||
|
|
|
||
|
|
function validationError() {
|
||
|
|
return new Error('Array Methods must be provided an Array');
|
||
|
|
}
|
||
|
|
|
||
|
|
var Enumerator = function () {
|
||
|
|
function Enumerator(Constructor, input) {
|
||
|
|
this._instanceConstructor = Constructor;
|
||
|
|
this.promise = new Constructor(noop);
|
||
|
|
|
||
|
|
if (!this.promise[PROMISE_ID]) {
|
||
|
|
makePromise(this.promise);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (isArray(input)) {
|
||
|
|
this.length = input.length;
|
||
|
|
this._remaining = input.length;
|
||
|
|
|
||
|
|
this._result = new Array(this.length);
|
||
|
|
|
||
|
|
if (this.length === 0) {
|
||
|
|
fulfill(this.promise, this._result);
|
||
|
|
} else {
|
||
|
|
this.length = this.length || 0;
|
||
|
|
this._enumerate(input);
|
||
|
|
if (this._remaining === 0) {
|
||
|
|
fulfill(this.promise, this._result);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
reject(this.promise, validationError());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
Enumerator.prototype._enumerate = function _enumerate(input) {
|
||
|
|
for (var i = 0; this._state === PENDING && i < input.length; i++) {
|
||
|
|
this._eachEntry(input[i], i);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
Enumerator.prototype._eachEntry = function _eachEntry(entry, i) {
|
||
|
|
var c = this._instanceConstructor;
|
||
|
|
var resolve$$1 = c.resolve;
|
||
|
|
|
||
|
|
|
||
|
|
if (resolve$$1 === resolve$1) {
|
||
|
|
var _then = void 0;
|
||
|
|
var error = void 0;
|
||
|
|
var didError = false;
|
||
|
|
try {
|
||
|
|
_then = entry.then;
|
||
|
|
} catch (e) {
|
||
|
|
didError = true;
|
||
|
|
error = e;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (_then === then && entry._state !== PENDING) {
|
||
|
|
this._settledAt(entry._state, i, entry._result);
|
||
|
|
} else if (typeof _then !== 'function') {
|
||
|
|
this._remaining--;
|
||
|
|
this._result[i] = entry;
|
||
|
|
} else if (c === Promise$2) {
|
||
|
|
var promise = new c(noop);
|
||
|
|
if (didError) {
|
||
|
|
reject(promise, error);
|
||
|
|
} else {
|
||
|
|
handleMaybeThenable(promise, entry, _then);
|
||
|
|
}
|
||
|
|
this._willSettleAt(promise, i);
|
||
|
|
} else {
|
||
|
|
this._willSettleAt(new c(function (resolve$$1) {
|
||
|
|
return resolve$$1(entry);
|
||
|
|
}), i);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
this._willSettleAt(resolve$$1(entry), i);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
Enumerator.prototype._settledAt = function _settledAt(state, i, value) {
|
||
|
|
var promise = this.promise;
|
||
|
|
|
||
|
|
|
||
|
|
if (promise._state === PENDING) {
|
||
|
|
this._remaining--;
|
||
|
|
|
||
|
|
if (state === REJECTED) {
|
||
|
|
reject(promise, value);
|
||
|
|
} else {
|
||
|
|
this._result[i] = value;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (this._remaining === 0) {
|
||
|
|
fulfill(promise, this._result);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
Enumerator.prototype._willSettleAt = function _willSettleAt(promise, i) {
|
||
|
|
var enumerator = this;
|
||
|
|
|
||
|
|
subscribe(promise, undefined, function (value) {
|
||
|
|
return enumerator._settledAt(FULFILLED, i, value);
|
||
|
|
}, function (reason) {
|
||
|
|
return enumerator._settledAt(REJECTED, i, reason);
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
return Enumerator;
|
||
|
|
}();
|
||
|
|
|
||
|
|
/**
|
||
|
|
`Promise.all` accepts an array of promises, and returns a new promise which
|
||
|
|
is fulfilled with an array of fulfillment values for the passed promises, or
|
||
|
|
rejected with the reason of the first passed promise to be rejected. It casts all
|
||
|
|
elements of the passed iterable to promises as it runs this algorithm.
|
||
|
|
|
||
|
|
Example:
|
||
|
|
|
||
|
|
```javascript
|
||
|
|
let promise1 = resolve(1);
|
||
|
|
let promise2 = resolve(2);
|
||
|
|
let promise3 = resolve(3);
|
||
|
|
let promises = [ promise1, promise2, promise3 ];
|
||
|
|
|
||
|
|
Promise.all(promises).then(function(array){
|
||
|
|
// The array here would be [ 1, 2, 3 ];
|
||
|
|
});
|
||
|
|
```
|
||
|
|
|
||
|
|
If any of the `promises` given to `all` are rejected, the first promise
|
||
|
|
that is rejected will be given as an argument to the returned promises's
|
||
|
|
rejection handler. For example:
|
||
|
|
|
||
|
|
Example:
|
||
|
|
|
||
|
|
```javascript
|
||
|
|
let promise1 = resolve(1);
|
||
|
|
let promise2 = reject(new Error("2"));
|
||
|
|
let promise3 = reject(new Error("3"));
|
||
|
|
let promises = [ promise1, promise2, promise3 ];
|
||
|
|
|
||
|
|
Promise.all(promises).then(function(array){
|
||
|
|
// Code here never runs because there are rejected promises!
|
||
|
|
}, function(error) {
|
||
|
|
// error.message === "2"
|
||
|
|
});
|
||
|
|
```
|
||
|
|
|
||
|
|
@method all
|
||
|
|
@static
|
||
|
|
@param {Array} entries array of promises
|
||
|
|
@param {String} label optional string for labeling the promise.
|
||
|
|
Useful for tooling.
|
||
|
|
@return {Promise} promise that is fulfilled when all `promises` have been
|
||
|
|
fulfilled, or rejected if any of them become rejected.
|
||
|
|
@static
|
||
|
|
*/
|
||
|
|
function all(entries) {
|
||
|
|
return new Enumerator(this, entries).promise;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
`Promise.race` returns a new promise which is settled in the same way as the
|
||
|
|
first passed promise to settle.
|
||
|
|
|
||
|
|
Example:
|
||
|
|
|
||
|
|
```javascript
|
||
|
|
let promise1 = new Promise(function(resolve, reject){
|
||
|
|
setTimeout(function(){
|
||
|
|
resolve('promise 1');
|
||
|
|
}, 200);
|
||
|
|
});
|
||
|
|
|
||
|
|
let promise2 = new Promise(function(resolve, reject){
|
||
|
|
setTimeout(function(){
|
||
|
|
resolve('promise 2');
|
||
|
|
}, 100);
|
||
|
|
});
|
||
|
|
|
||
|
|
Promise.race([promise1, promise2]).then(function(result){
|
||
|
|
// result === 'promise 2' because it was resolved before promise1
|
||
|
|
// was resolved.
|
||
|
|
});
|
||
|
|
```
|
||
|
|
|
||
|
|
`Promise.race` is deterministic in that only the state of the first
|
||
|
|
settled promise matters. For example, even if other promises given to the
|
||
|
|
`promises` array argument are resolved, but the first settled promise has
|
||
|
|
become rejected before the other promises became fulfilled, the returned
|
||
|
|
promise will become rejected:
|
||
|
|
|
||
|
|
```javascript
|
||
|
|
let promise1 = new Promise(function(resolve, reject){
|
||
|
|
setTimeout(function(){
|
||
|
|
resolve('promise 1');
|
||
|
|
}, 200);
|
||
|
|
});
|
||
|
|
|
||
|
|
let promise2 = new Promise(function(resolve, reject){
|
||
|
|
setTimeout(function(){
|
||
|
|
reject(new Error('promise 2'));
|
||
|
|
}, 100);
|
||
|
|
});
|
||
|
|
|
||
|
|
Promise.race([promise1, promise2]).then(function(result){
|
||
|
|
// Code here never runs
|
||
|
|
}, function(reason){
|
||
|
|
// reason.message === 'promise 2' because promise 2 became rejected before
|
||
|
|
// promise 1 became fulfilled
|
||
|
|
});
|
||
|
|
```
|
||
|
|
|
||
|
|
An example real-world use case is implementing timeouts:
|
||
|
|
|
||
|
|
```javascript
|
||
|
|
Promise.race([ajax('foo.json'), timeout(5000)])
|
||
|
|
```
|
||
|
|
|
||
|
|
@method race
|
||
|
|
@static
|
||
|
|
@param {Array} promises array of promises to observe
|
||
|
|
Useful for tooling.
|
||
|
|
@return {Promise} a promise which settles in the same way as the first passed
|
||
|
|
promise to settle.
|
||
|
|
*/
|
||
|
|
function race(entries) {
|
||
|
|
/*jshint validthis:true */
|
||
|
|
var Constructor = this;
|
||
|
|
|
||
|
|
if (!isArray(entries)) {
|
||
|
|
return new Constructor(function (_, reject) {
|
||
|
|
return reject(new TypeError('You must pass an array to race.'));
|
||
|
|
});
|
||
|
|
} else {
|
||
|
|
return new Constructor(function (resolve, reject) {
|
||
|
|
var length = entries.length;
|
||
|
|
for (var i = 0; i < length; i++) {
|
||
|
|
Constructor.resolve(entries[i]).then(resolve, reject);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
`Promise.reject` returns a promise rejected with the passed `reason`.
|
||
|
|
It is shorthand for the following:
|
||
|
|
|
||
|
|
```javascript
|
||
|
|
let promise = new Promise(function(resolve, reject){
|
||
|
|
reject(new Error('WHOOPS'));
|
||
|
|
});
|
||
|
|
|
||
|
|
promise.then(function(value){
|
||
|
|
// Code here doesn't run because the promise is rejected!
|
||
|
|
}, function(reason){
|
||
|
|
// reason.message === 'WHOOPS'
|
||
|
|
});
|
||
|
|
```
|
||
|
|
|
||
|
|
Instead of writing the above, your code now simply becomes the following:
|
||
|
|
|
||
|
|
```javascript
|
||
|
|
let promise = Promise.reject(new Error('WHOOPS'));
|
||
|
|
|
||
|
|
promise.then(function(value){
|
||
|
|
// Code here doesn't run because the promise is rejected!
|
||
|
|
}, function(reason){
|
||
|
|
// reason.message === 'WHOOPS'
|
||
|
|
});
|
||
|
|
```
|
||
|
|
|
||
|
|
@method reject
|
||
|
|
@static
|
||
|
|
@param {Any} reason value that the returned promise will be rejected with.
|
||
|
|
Useful for tooling.
|
||
|
|
@return {Promise} a promise rejected with the given `reason`.
|
||
|
|
*/
|
||
|
|
function reject$1(reason) {
|
||
|
|
/*jshint validthis:true */
|
||
|
|
var Constructor = this;
|
||
|
|
var promise = new Constructor(noop);
|
||
|
|
reject(promise, reason);
|
||
|
|
return promise;
|
||
|
|
}
|
||
|
|
|
||
|
|
function needsResolver() {
|
||
|
|
throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
|
||
|
|
}
|
||
|
|
|
||
|
|
function needsNew() {
|
||
|
|
throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
Promise objects represent the eventual result of an asynchronous operation. The
|
||
|
|
primary way of interacting with a promise is through its `then` method, which
|
||
|
|
registers callbacks to receive either a promise's eventual value or the reason
|
||
|
|
why the promise cannot be fulfilled.
|
||
|
|
|
||
|
|
Terminology
|
||
|
|
-----------
|
||
|
|
|
||
|
|
- `promise` is an object or function with a `then` method whose behavior conforms to this specification.
|
||
|
|
- `thenable` is an object or function that defines a `then` method.
|
||
|
|
- `value` is any legal JavaScript value (including undefined, a thenable, or a promise).
|
||
|
|
- `exception` is a value that is thrown using the throw statement.
|
||
|
|
- `reason` is a value that indicates why a promise was rejected.
|
||
|
|
- `settled` the final resting state of a promise, fulfilled or rejected.
|
||
|
|
|
||
|
|
A promise can be in one of three states: pending, fulfilled, or rejected.
|
||
|
|
|
||
|
|
Promises that are fulfilled have a fulfillment value and are in the fulfilled
|
||
|
|
state. Promises that are rejected have a rejection reason and are in the
|
||
|
|
rejected state. A fulfillment value is never a thenable.
|
||
|
|
|
||
|
|
Promises can also be said to *resolve* a value. If this value is also a
|
||
|
|
promise, then the original promise's settled state will match the value's
|
||
|
|
settled state. So a promise that *resolves* a promise that rejects will
|
||
|
|
itself reject, and a promise that *resolves* a promise that fulfills will
|
||
|
|
itself fulfill.
|
||
|
|
|
||
|
|
|
||
|
|
Basic Usage:
|
||
|
|
------------
|
||
|
|
|
||
|
|
```js
|
||
|
|
let promise = new Promise(function(resolve, reject) {
|
||
|
|
// on success
|
||
|
|
resolve(value);
|
||
|
|
|
||
|
|
// on failure
|
||
|
|
reject(reason);
|
||
|
|
});
|
||
|
|
|
||
|
|
promise.then(function(value) {
|
||
|
|
// on fulfillment
|
||
|
|
}, function(reason) {
|
||
|
|
// on rejection
|
||
|
|
});
|
||
|
|
```
|
||
|
|
|
||
|
|
Advanced Usage:
|
||
|
|
---------------
|
||
|
|
|
||
|
|
Promises shine when abstracting away asynchronous interactions such as
|
||
|
|
`XMLHttpRequest`s.
|
||
|
|
|
||
|
|
```js
|
||
|
|
function getJSON(url) {
|
||
|
|
return new Promise(function(resolve, reject){
|
||
|
|
let xhr = new XMLHttpRequest();
|
||
|
|
|
||
|
|
xhr.open('GET', url);
|
||
|
|
xhr.onreadystatechange = handler;
|
||
|
|
xhr.responseType = 'json';
|
||
|
|
xhr.setRequestHeader('Accept', 'application/json');
|
||
|
|
xhr.send();
|
||
|
|
|
||
|
|
function handler() {
|
||
|
|
if (this.readyState === this.DONE) {
|
||
|
|
if (this.status === 200) {
|
||
|
|
resolve(this.response);
|
||
|
|
} else {
|
||
|
|
reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
getJSON('/posts.json').then(function(json) {
|
||
|
|
// on fulfillment
|
||
|
|
}, function(reason) {
|
||
|
|
// on rejection
|
||
|
|
});
|
||
|
|
```
|
||
|
|
|
||
|
|
Unlike callbacks, promises are great composable primitives.
|
||
|
|
|
||
|
|
```js
|
||
|
|
Promise.all([
|
||
|
|
getJSON('/posts'),
|
||
|
|
getJSON('/comments')
|
||
|
|
]).then(function(values){
|
||
|
|
values[0] // => postsJSON
|
||
|
|
values[1] // => commentsJSON
|
||
|
|
|
||
|
|
return values;
|
||
|
|
});
|
||
|
|
```
|
||
|
|
|
||
|
|
@class Promise
|
||
|
|
@param {Function} resolver
|
||
|
|
Useful for tooling.
|
||
|
|
@constructor
|
||
|
|
*/
|
||
|
|
|
||
|
|
var Promise$2 = function () {
|
||
|
|
function Promise(resolver) {
|
||
|
|
this[PROMISE_ID] = nextId();
|
||
|
|
this._result = this._state = undefined;
|
||
|
|
this._subscribers = [];
|
||
|
|
|
||
|
|
if (noop !== resolver) {
|
||
|
|
typeof resolver !== 'function' && needsResolver();
|
||
|
|
this instanceof Promise ? initializePromise(this, resolver) : needsNew();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
The primary way of interacting with a promise is through its `then` method,
|
||
|
|
which registers callbacks to receive either a promise's eventual value or the
|
||
|
|
reason why the promise cannot be fulfilled.
|
||
|
|
```js
|
||
|
|
findUser().then(function(user){
|
||
|
|
// user is available
|
||
|
|
}, function(reason){
|
||
|
|
// user is unavailable, and you are given the reason why
|
||
|
|
});
|
||
|
|
```
|
||
|
|
Chaining
|
||
|
|
--------
|
||
|
|
The return value of `then` is itself a promise. This second, 'downstream'
|
||
|
|
promise is resolved with the return value of the first promise's fulfillment
|
||
|
|
or rejection handler, or rejected if the handler throws an exception.
|
||
|
|
```js
|
||
|
|
findUser().then(function (user) {
|
||
|
|
return user.name;
|
||
|
|
}, function (reason) {
|
||
|
|
return 'default name';
|
||
|
|
}).then(function (userName) {
|
||
|
|
// If `findUser` fulfilled, `userName` will be the user's name, otherwise it
|
||
|
|
// will be `'default name'`
|
||
|
|
});
|
||
|
|
findUser().then(function (user) {
|
||
|
|
throw new Error('Found user, but still unhappy');
|
||
|
|
}, function (reason) {
|
||
|
|
throw new Error('`findUser` rejected and we're unhappy');
|
||
|
|
}).then(function (value) {
|
||
|
|
// never reached
|
||
|
|
}, function (reason) {
|
||
|
|
// if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.
|
||
|
|
// If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'.
|
||
|
|
});
|
||
|
|
```
|
||
|
|
If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.
|
||
|
|
```js
|
||
|
|
findUser().then(function (user) {
|
||
|
|
throw new PedagogicalException('Upstream error');
|
||
|
|
}).then(function (value) {
|
||
|
|
// never reached
|
||
|
|
}).then(function (value) {
|
||
|
|
// never reached
|
||
|
|
}, function (reason) {
|
||
|
|
// The `PedgagocialException` is propagated all the way down to here
|
||
|
|
});
|
||
|
|
```
|
||
|
|
Assimilation
|
||
|
|
------------
|
||
|
|
Sometimes the value you want to propagate to a downstream promise can only be
|
||
|
|
retrieved asynchronously. This can be achieved by returning a promise in the
|
||
|
|
fulfillment or rejection handler. The downstream promise will then be pending
|
||
|
|
until the returned promise is settled. This is called *assimilation*.
|
||
|
|
```js
|
||
|
|
findUser().then(function (user) {
|
||
|
|
return findCommentsByAuthor(user);
|
||
|
|
}).then(function (comments) {
|
||
|
|
// The user's comments are now available
|
||
|
|
});
|
||
|
|
```
|
||
|
|
If the assimliated promise rejects, then the downstream promise will also reject.
|
||
|
|
```js
|
||
|
|
findUser().then(function (user) {
|
||
|
|
return findCommentsByAuthor(user);
|
||
|
|
}).then(function (comments) {
|
||
|
|
// If `findCommentsByAuthor` fulfills, we'll have the value here
|
||
|
|
}, function (reason) {
|
||
|
|
// If `findCommentsByAuthor` rejects, we'll have the reason here
|
||
|
|
});
|
||
|
|
```
|
||
|
|
Simple Example
|
||
|
|
--------------
|
||
|
|
Synchronous Example
|
||
|
|
```javascript
|
||
|
|
let result;
|
||
|
|
try {
|
||
|
|
result = findResult();
|
||
|
|
// success
|
||
|
|
} catch(reason) {
|
||
|
|
// failure
|
||
|
|
}
|
||
|
|
```
|
||
|
|
Errback Example
|
||
|
|
```js
|
||
|
|
findResult(function(result, err){
|
||
|
|
if (err) {
|
||
|
|
// failure
|
||
|
|
} else {
|
||
|
|
// success
|
||
|
|
}
|
||
|
|
});
|
||
|
|
```
|
||
|
|
Promise Example;
|
||
|
|
```javascript
|
||
|
|
findResult().then(function(result){
|
||
|
|
// success
|
||
|
|
}, function(reason){
|
||
|
|
// failure
|
||
|
|
});
|
||
|
|
```
|
||
|
|
Advanced Example
|
||
|
|
--------------
|
||
|
|
Synchronous Example
|
||
|
|
```javascript
|
||
|
|
let author, books;
|
||
|
|
try {
|
||
|
|
author = findAuthor();
|
||
|
|
books = findBooksByAuthor(author);
|
||
|
|
// success
|
||
|
|
} catch(reason) {
|
||
|
|
// failure
|
||
|
|
}
|
||
|
|
```
|
||
|
|
Errback Example
|
||
|
|
```js
|
||
|
|
function foundBooks(books) {
|
||
|
|
}
|
||
|
|
function failure(reason) {
|
||
|
|
}
|
||
|
|
findAuthor(function(author, err){
|
||
|
|
if (err) {
|
||
|
|
failure(err);
|
||
|
|
// failure
|
||
|
|
} else {
|
||
|
|
try {
|
||
|
|
findBoooksByAuthor(author, function(books, err) {
|
||
|
|
if (err) {
|
||
|
|
failure(err);
|
||
|
|
} else {
|
||
|
|
try {
|
||
|
|
foundBooks(books);
|
||
|
|
} catch(reason) {
|
||
|
|
failure(reason);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
});
|
||
|
|
} catch(error) {
|
||
|
|
failure(err);
|
||
|
|
}
|
||
|
|
// success
|
||
|
|
}
|
||
|
|
});
|
||
|
|
```
|
||
|
|
Promise Example;
|
||
|
|
```javascript
|
||
|
|
findAuthor().
|
||
|
|
then(findBooksByAuthor).
|
||
|
|
then(function(books){
|
||
|
|
// found books
|
||
|
|
}).catch(function(reason){
|
||
|
|
// something went wrong
|
||
|
|
});
|
||
|
|
```
|
||
|
|
@method then
|
||
|
|
@param {Function} onFulfilled
|
||
|
|
@param {Function} onRejected
|
||
|
|
Useful for tooling.
|
||
|
|
@return {Promise}
|
||
|
|
*/
|
||
|
|
|
||
|
|
/**
|
||
|
|
`catch` is simply sugar for `then(undefined, onRejection)` which makes it the same
|
||
|
|
as the catch block of a try/catch statement.
|
||
|
|
```js
|
||
|
|
function findAuthor(){
|
||
|
|
throw new Error('couldn't find that author');
|
||
|
|
}
|
||
|
|
// synchronous
|
||
|
|
try {
|
||
|
|
findAuthor();
|
||
|
|
} catch(reason) {
|
||
|
|
// something went wrong
|
||
|
|
}
|
||
|
|
// async with promises
|
||
|
|
findAuthor().catch(function(reason){
|
||
|
|
// something went wrong
|
||
|
|
});
|
||
|
|
```
|
||
|
|
@method catch
|
||
|
|
@param {Function} onRejection
|
||
|
|
Useful for tooling.
|
||
|
|
@return {Promise}
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
Promise.prototype.catch = function _catch(onRejection) {
|
||
|
|
return this.then(null, onRejection);
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
`finally` will be invoked regardless of the promise's fate just as native
|
||
|
|
try/catch/finally behaves
|
||
|
|
|
||
|
|
Synchronous example:
|
||
|
|
|
||
|
|
```js
|
||
|
|
findAuthor() {
|
||
|
|
if (Math.random() > 0.5) {
|
||
|
|
throw new Error();
|
||
|
|
}
|
||
|
|
return new Author();
|
||
|
|
}
|
||
|
|
|
||
|
|
try {
|
||
|
|
return findAuthor(); // succeed or fail
|
||
|
|
} catch(error) {
|
||
|
|
return findOtherAuther();
|
||
|
|
} finally {
|
||
|
|
// always runs
|
||
|
|
// doesn't affect the return value
|
||
|
|
}
|
||
|
|
```
|
||
|
|
|
||
|
|
Asynchronous example:
|
||
|
|
|
||
|
|
```js
|
||
|
|
findAuthor().catch(function(reason){
|
||
|
|
return findOtherAuther();
|
||
|
|
}).finally(function(){
|
||
|
|
// author was either found, or not
|
||
|
|
});
|
||
|
|
```
|
||
|
|
|
||
|
|
@method finally
|
||
|
|
@param {Function} callback
|
||
|
|
@return {Promise}
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
Promise.prototype.finally = function _finally(callback) {
|
||
|
|
var promise = this;
|
||
|
|
var constructor = promise.constructor;
|
||
|
|
|
||
|
|
if (isFunction(callback)) {
|
||
|
|
return promise.then(function (value) {
|
||
|
|
return constructor.resolve(callback()).then(function () {
|
||
|
|
return value;
|
||
|
|
});
|
||
|
|
}, function (reason) {
|
||
|
|
return constructor.resolve(callback()).then(function () {
|
||
|
|
throw reason;
|
||
|
|
});
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
return promise.then(callback, callback);
|
||
|
|
};
|
||
|
|
|
||
|
|
return Promise;
|
||
|
|
}();
|
||
|
|
|
||
|
|
Promise$2.prototype.then = then;
|
||
|
|
Promise$2.all = all;
|
||
|
|
Promise$2.race = race;
|
||
|
|
Promise$2.resolve = resolve$1;
|
||
|
|
Promise$2.reject = reject$1;
|
||
|
|
Promise$2._setScheduler = setScheduler;
|
||
|
|
Promise$2._setAsap = setAsap;
|
||
|
|
Promise$2._asap = asap;
|
||
|
|
|
||
|
|
/*global self*/
|
||
|
|
function polyfill() {
|
||
|
|
var local = void 0;
|
||
|
|
|
||
|
|
if (typeof global !== 'undefined') {
|
||
|
|
local = global;
|
||
|
|
} else if (typeof self !== 'undefined') {
|
||
|
|
local = self;
|
||
|
|
} else {
|
||
|
|
try {
|
||
|
|
local = Function('return this')();
|
||
|
|
} catch (e) {
|
||
|
|
throw new Error('polyfill failed because global object is unavailable in this environment');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
var P = local.Promise;
|
||
|
|
|
||
|
|
if (P) {
|
||
|
|
var promiseToString = null;
|
||
|
|
try {
|
||
|
|
promiseToString = Object.prototype.toString.call(P.resolve());
|
||
|
|
} catch (e) {
|
||
|
|
// silently ignored
|
||
|
|
}
|
||
|
|
|
||
|
|
if (promiseToString === '[object Promise]' && !P.cast) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
local.Promise = Promise$2;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Strange compat..
|
||
|
|
Promise$2.polyfill = polyfill;
|
||
|
|
Promise$2.Promise = Promise$2;
|
||
|
|
|
||
|
|
Promise$2.polyfill();
|
||
|
|
|
||
|
|
return Promise$2;
|
||
|
|
|
||
|
|
})));
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
//# sourceMappingURL=es6-promise.auto.map
|