| /*! |
| * @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 |