mirror of
https://github.com/actions/setup-python.git
synced 2024-11-30 03:45:17 +00:00
2559 lines
74 KiB
JavaScript
2559 lines
74 KiB
JavaScript
/*!
|
||
* @overview RSVP - a tiny implementation of Promises/A+.
|
||
* @copyright Copyright (c) 2016 Yehuda Katz, Tom Dale, Stefan Penner and contributors
|
||
* @license Licensed under MIT license
|
||
* See https://raw.githubusercontent.com/tildeio/rsvp.js/master/LICENSE
|
||
* @version 4.8.4+ff10049b
|
||
*/
|
||
|
||
(function (global, factory) {
|
||
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
|
||
typeof define === 'function' && define.amd ? define(['exports'], factory) :
|
||
(factory((global.RSVP = {})));
|
||
}(this, (function (exports) { 'use strict';
|
||
|
||
function callbacksFor(object) {
|
||
var callbacks = object._promiseCallbacks;
|
||
|
||
if (!callbacks) {
|
||
callbacks = object._promiseCallbacks = {};
|
||
}
|
||
|
||
return callbacks;
|
||
}
|
||
|
||
/**
|
||
@class EventTarget
|
||
@for rsvp
|
||
@public
|
||
*/
|
||
var EventTarget = {
|
||
|
||
/**
|
||
`EventTarget.mixin` extends an object with EventTarget methods. For
|
||
Example:
|
||
```javascript
|
||
import EventTarget from 'rsvp';
|
||
let object = {};
|
||
EventTarget.mixin(object);
|
||
object.on('finished', function(event) {
|
||
// handle event
|
||
});
|
||
object.trigger('finished', { detail: value });
|
||
```
|
||
`EventTarget.mixin` also works with prototypes:
|
||
```javascript
|
||
import EventTarget from 'rsvp';
|
||
let Person = function() {};
|
||
EventTarget.mixin(Person.prototype);
|
||
let yehuda = new Person();
|
||
let tom = new Person();
|
||
yehuda.on('poke', function(event) {
|
||
console.log('Yehuda says OW');
|
||
});
|
||
tom.on('poke', function(event) {
|
||
console.log('Tom says OW');
|
||
});
|
||
yehuda.trigger('poke');
|
||
tom.trigger('poke');
|
||
```
|
||
@method mixin
|
||
@for rsvp
|
||
@private
|
||
@param {Object} object object to extend with EventTarget methods
|
||
*/
|
||
mixin: function (object) {
|
||
object.on = this.on;
|
||
object.off = this.off;
|
||
object.trigger = this.trigger;
|
||
object._promiseCallbacks = undefined;
|
||
return object;
|
||
},
|
||
|
||
|
||
/**
|
||
Registers a callback to be executed when `eventName` is triggered
|
||
```javascript
|
||
object.on('event', function(eventInfo){
|
||
// handle the event
|
||
});
|
||
object.trigger('event');
|
||
```
|
||
@method on
|
||
@for EventTarget
|
||
@private
|
||
@param {String} eventName name of the event to listen for
|
||
@param {Function} callback function to be called when the event is triggered.
|
||
*/
|
||
on: function (eventName, callback) {
|
||
if (typeof callback !== 'function') {
|
||
throw new TypeError('Callback must be a function');
|
||
}
|
||
|
||
var allCallbacks = callbacksFor(this);
|
||
var callbacks = allCallbacks[eventName];
|
||
|
||
if (!callbacks) {
|
||
callbacks = allCallbacks[eventName] = [];
|
||
}
|
||
|
||
if (callbacks.indexOf(callback) === -1) {
|
||
callbacks.push(callback);
|
||
}
|
||
},
|
||
|
||
|
||
/**
|
||
You can use `off` to stop firing a particular callback for an event:
|
||
```javascript
|
||
function doStuff() { // do stuff! }
|
||
object.on('stuff', doStuff);
|
||
object.trigger('stuff'); // doStuff will be called
|
||
// Unregister ONLY the doStuff callback
|
||
object.off('stuff', doStuff);
|
||
object.trigger('stuff'); // doStuff will NOT be called
|
||
```
|
||
If you don't pass a `callback` argument to `off`, ALL callbacks for the
|
||
event will not be executed when the event fires. For example:
|
||
```javascript
|
||
let callback1 = function(){};
|
||
let callback2 = function(){};
|
||
object.on('stuff', callback1);
|
||
object.on('stuff', callback2);
|
||
object.trigger('stuff'); // callback1 and callback2 will be executed.
|
||
object.off('stuff');
|
||
object.trigger('stuff'); // callback1 and callback2 will not be executed!
|
||
```
|
||
@method off
|
||
@for rsvp
|
||
@private
|
||
@param {String} eventName event to stop listening to
|
||
@param {Function} [callback] optional argument. If given, only the function
|
||
given will be removed from the event's callback queue. If no `callback`
|
||
argument is given, all callbacks will be removed from the event's callback
|
||
queue.
|
||
*/
|
||
off: function (eventName, callback) {
|
||
var allCallbacks = callbacksFor(this);
|
||
|
||
if (!callback) {
|
||
allCallbacks[eventName] = [];
|
||
return;
|
||
}
|
||
|
||
var callbacks = allCallbacks[eventName];
|
||
var index = callbacks.indexOf(callback);
|
||
|
||
if (index !== -1) {
|
||
callbacks.splice(index, 1);
|
||
}
|
||
},
|
||
|
||
|
||
/**
|
||
Use `trigger` to fire custom events. For example:
|
||
```javascript
|
||
object.on('foo', function(){
|
||
console.log('foo event happened!');
|
||
});
|
||
object.trigger('foo');
|
||
// 'foo event happened!' logged to the console
|
||
```
|
||
You can also pass a value as a second argument to `trigger` that will be
|
||
passed as an argument to all event listeners for the event:
|
||
```javascript
|
||
object.on('foo', function(value){
|
||
console.log(value.name);
|
||
});
|
||
object.trigger('foo', { name: 'bar' });
|
||
// 'bar' logged to the console
|
||
```
|
||
@method trigger
|
||
@for rsvp
|
||
@private
|
||
@param {String} eventName name of the event to be triggered
|
||
@param {*} [options] optional value to be passed to any event handlers for
|
||
the given `eventName`
|
||
*/
|
||
trigger: function (eventName, options, label) {
|
||
var allCallbacks = callbacksFor(this);
|
||
|
||
var callbacks = allCallbacks[eventName];
|
||
if (callbacks) {
|
||
// Don't cache the callbacks.length since it may grow
|
||
var callback = void 0;
|
||
for (var i = 0; i < callbacks.length; i++) {
|
||
callback = callbacks[i];
|
||
callback(options, label);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
var config = {
|
||
instrument: false
|
||
};
|
||
|
||
EventTarget['mixin'](config);
|
||
|
||
function configure(name, value) {
|
||
if (arguments.length === 2) {
|
||
config[name] = value;
|
||
} else {
|
||
return config[name];
|
||
}
|
||
}
|
||
|
||
var queue = [];
|
||
|
||
function scheduleFlush() {
|
||
setTimeout(function () {
|
||
for (var i = 0; i < queue.length; i++) {
|
||
var entry = queue[i];
|
||
|
||
var payload = entry.payload;
|
||
|
||
payload.guid = payload.key + payload.id;
|
||
payload.childGuid = payload.key + payload.childId;
|
||
if (payload.error) {
|
||
payload.stack = payload.error.stack;
|
||
}
|
||
|
||
config['trigger'](entry.name, entry.payload);
|
||
}
|
||
queue.length = 0;
|
||
}, 50);
|
||
}
|
||
|
||
function instrument(eventName, promise, child) {
|
||
if (1 === queue.push({
|
||
name: eventName,
|
||
payload: {
|
||
key: promise._guidKey,
|
||
id: promise._id,
|
||
eventName: eventName,
|
||
detail: promise._result,
|
||
childId: child && child._id,
|
||
label: promise._label,
|
||
timeStamp: Date.now(),
|
||
error: config["instrument-with-stack"] ? new Error(promise._label) : null
|
||
} })) {
|
||
scheduleFlush();
|
||
}
|
||
}
|
||
|
||
/**
|
||
`Promise.resolve` returns a promise that will become resolved with the
|
||
passed `value`. It is shorthand for the following:
|
||
|
||
```javascript
|
||
import Promise from 'rsvp';
|
||
|
||
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
|
||
import Promise from 'rsvp';
|
||
|
||
let promise = RSVP.Promise.resolve(1);
|
||
|
||
promise.then(function(value){
|
||
// value === 1
|
||
});
|
||
```
|
||
|
||
@method resolve
|
||
@for Promise
|
||
@static
|
||
@param {*} object value that the returned promise will be resolved with
|
||
@param {String} [label] optional string for identifying the returned promise.
|
||
Useful for tooling.
|
||
@return {Promise} a promise that will become fulfilled with the given
|
||
`value`
|
||
*/
|
||
function resolve$$1(object, label) {
|
||
/*jshint validthis:true */
|
||
var Constructor = this;
|
||
|
||
if (object && typeof object === 'object' && object.constructor === Constructor) {
|
||
return object;
|
||
}
|
||
|
||
var promise = new Constructor(noop, label);
|
||
resolve$1(promise, object);
|
||
return promise;
|
||
}
|
||
|
||
function withOwnPromise() {
|
||
return new TypeError('A promises callback cannot return that same promise.');
|
||
}
|
||
|
||
function objectOrFunction(x) {
|
||
var type = typeof x;
|
||
return x !== null && (type === 'object' || type === 'function');
|
||
}
|
||
|
||
function noop() {}
|
||
|
||
var PENDING = void 0;
|
||
var FULFILLED = 1;
|
||
var REJECTED = 2;
|
||
|
||
var TRY_CATCH_ERROR = { error: null };
|
||
|
||
function getThen(promise) {
|
||
try {
|
||
return promise.then;
|
||
} catch (error) {
|
||
TRY_CATCH_ERROR.error = error;
|
||
return TRY_CATCH_ERROR;
|
||
}
|
||
}
|
||
|
||
var tryCatchCallback = void 0;
|
||
function tryCatcher() {
|
||
try {
|
||
var target = tryCatchCallback;
|
||
tryCatchCallback = null;
|
||
return target.apply(this, arguments);
|
||
} catch (e) {
|
||
TRY_CATCH_ERROR.error = e;
|
||
return TRY_CATCH_ERROR;
|
||
}
|
||
}
|
||
|
||
function tryCatch(fn) {
|
||
tryCatchCallback = fn;
|
||
return tryCatcher;
|
||
}
|
||
|
||
function handleForeignThenable(promise, thenable, then$$1) {
|
||
config.async(function (promise) {
|
||
var sealed = false;
|
||
var result = tryCatch(then$$1).call(thenable, function (value) {
|
||
if (sealed) {
|
||
return;
|
||
}
|
||
sealed = true;
|
||
if (thenable === value) {
|
||
fulfill(promise, value);
|
||
} else {
|
||
resolve$1(promise, value);
|
||
}
|
||
}, function (reason) {
|
||
if (sealed) {
|
||
return;
|
||
}
|
||
sealed = true;
|
||
|
||
reject(promise, reason);
|
||
}, 'Settle: ' + (promise._label || ' unknown promise'));
|
||
|
||
if (!sealed && result === TRY_CATCH_ERROR) {
|
||
sealed = true;
|
||
var error = TRY_CATCH_ERROR.error;
|
||
TRY_CATCH_ERROR.error = null;
|
||
reject(promise, error);
|
||
}
|
||
}, promise);
|
||
}
|
||
|
||
function handleOwnThenable(promise, thenable) {
|
||
if (thenable._state === FULFILLED) {
|
||
fulfill(promise, thenable._result);
|
||
} else if (thenable._state === REJECTED) {
|
||
thenable._onError = null;
|
||
reject(promise, thenable._result);
|
||
} else {
|
||
subscribe(thenable, undefined, function (value) {
|
||
if (thenable === value) {
|
||
fulfill(promise, value);
|
||
} else {
|
||
resolve$1(promise, value);
|
||
}
|
||
}, function (reason) {
|
||
return reject(promise, reason);
|
||
});
|
||
}
|
||
}
|
||
|
||
function handleMaybeThenable(promise, maybeThenable, then$$1) {
|
||
var isOwnThenable = maybeThenable.constructor === promise.constructor && then$$1 === then && promise.constructor.resolve === resolve$$1;
|
||
|
||
if (isOwnThenable) {
|
||
handleOwnThenable(promise, maybeThenable);
|
||
} else if (then$$1 === TRY_CATCH_ERROR) {
|
||
var error = TRY_CATCH_ERROR.error;
|
||
TRY_CATCH_ERROR.error = null;
|
||
reject(promise, error);
|
||
} else if (typeof then$$1 === 'function') {
|
||
handleForeignThenable(promise, maybeThenable, then$$1);
|
||
} else {
|
||
fulfill(promise, maybeThenable);
|
||
}
|
||
}
|
||
|
||
function resolve$1(promise, value) {
|
||
if (promise === value) {
|
||
fulfill(promise, value);
|
||
} else if (objectOrFunction(value)) {
|
||
handleMaybeThenable(promise, value, getThen(value));
|
||
} 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) {
|
||
if (config.instrument) {
|
||
instrument('fulfilled', promise);
|
||
}
|
||
} else {
|
||
config.async(publish, promise);
|
||
}
|
||
}
|
||
|
||
function reject(promise, reason) {
|
||
if (promise._state !== PENDING) {
|
||
return;
|
||
}
|
||
promise._state = REJECTED;
|
||
promise._result = reason;
|
||
config.async(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) {
|
||
config.async(publish, parent);
|
||
}
|
||
}
|
||
|
||
function publish(promise) {
|
||
var subscribers = promise._subscribers;
|
||
var settled = promise._state;
|
||
|
||
if (config.instrument) {
|
||
instrument(settled === FULFILLED ? 'fulfilled' : 'rejected', promise);
|
||
}
|
||
|
||
if (subscribers.length === 0) {
|
||
return;
|
||
}
|
||
|
||
var child = void 0,
|
||
callback = void 0,
|
||
result = promise._result;
|
||
|
||
for (var i = 0; i < subscribers.length; i += 3) {
|
||
child = subscribers[i];
|
||
callback = subscribers[i + settled];
|
||
|
||
if (child) {
|
||
invokeCallback(settled, child, callback, result);
|
||
} else {
|
||
callback(result);
|
||
}
|
||
}
|
||
|
||
promise._subscribers.length = 0;
|
||
}
|
||
|
||
function invokeCallback(state, promise, callback, result) {
|
||
var hasCallback = typeof callback === 'function';
|
||
var value = void 0;
|
||
|
||
if (hasCallback) {
|
||
value = tryCatch(callback)(result);
|
||
} else {
|
||
value = result;
|
||
}
|
||
|
||
if (promise._state !== PENDING) {
|
||
// noop
|
||
} else if (value === promise) {
|
||
reject(promise, withOwnPromise());
|
||
} else if (value === TRY_CATCH_ERROR) {
|
||
var error = TRY_CATCH_ERROR.error;
|
||
TRY_CATCH_ERROR.error = null; // release
|
||
reject(promise, error);
|
||
} else if (hasCallback) {
|
||
resolve$1(promise, value);
|
||
} else if (state === FULFILLED) {
|
||
fulfill(promise, value);
|
||
} else if (state === REJECTED) {
|
||
reject(promise, value);
|
||
}
|
||
}
|
||
|
||
function initializePromise(promise, resolver) {
|
||
var resolved = false;
|
||
try {
|
||
resolver(function (value) {
|
||
if (resolved) {
|
||
return;
|
||
}
|
||
resolved = true;
|
||
resolve$1(promise, value);
|
||
}, function (reason) {
|
||
if (resolved) {
|
||
return;
|
||
}
|
||
resolved = true;
|
||
reject(promise, reason);
|
||
});
|
||
} catch (e) {
|
||
reject(promise, e);
|
||
}
|
||
}
|
||
|
||
function then(onFulfillment, onRejection, label) {
|
||
var parent = this;
|
||
var state = parent._state;
|
||
|
||
if (state === FULFILLED && !onFulfillment || state === REJECTED && !onRejection) {
|
||
config.instrument && instrument('chained', parent, parent);
|
||
return parent;
|
||
}
|
||
|
||
parent._onError = null;
|
||
|
||
var child = new parent.constructor(noop, label);
|
||
var result = parent._result;
|
||
|
||
config.instrument && instrument('chained', parent, child);
|
||
|
||
if (state === PENDING) {
|
||
subscribe(parent, child, onFulfillment, onRejection);
|
||
} else {
|
||
var callback = state === FULFILLED ? onFulfillment : onRejection;
|
||
config.async(function () {
|
||
return invokeCallback(state, child, callback, result);
|
||
});
|
||
}
|
||
|
||
return child;
|
||
}
|
||
|
||
var Enumerator = function () {
|
||
function Enumerator(Constructor, input, abortOnReject, label) {
|
||
this._instanceConstructor = Constructor;
|
||
this.promise = new Constructor(noop, label);
|
||
this._abortOnReject = abortOnReject;
|
||
this._isUsingOwnPromise = Constructor === Promise;
|
||
this._isUsingOwnResolve = Constructor.resolve === resolve$$1;
|
||
|
||
this._init.apply(this, arguments);
|
||
}
|
||
|
||
Enumerator.prototype._init = function _init(Constructor, input) {
|
||
var len = input.length || 0;
|
||
this.length = len;
|
||
this._remaining = len;
|
||
this._result = new Array(len);
|
||
|
||
this._enumerate(input);
|
||
};
|
||
|
||
Enumerator.prototype._enumerate = function _enumerate(input) {
|
||
var length = this.length;
|
||
var promise = this.promise;
|
||
|
||
for (var i = 0; promise._state === PENDING && i < length; i++) {
|
||
this._eachEntry(input[i], i, true);
|
||
}
|
||
this._checkFullfillment();
|
||
};
|
||
|
||
Enumerator.prototype._checkFullfillment = function _checkFullfillment() {
|
||
if (this._remaining === 0) {
|
||
var result = this._result;
|
||
fulfill(this.promise, result);
|
||
this._result = null;
|
||
}
|
||
};
|
||
|
||
Enumerator.prototype._settleMaybeThenable = function _settleMaybeThenable(entry, i, firstPass) {
|
||
var c = this._instanceConstructor;
|
||
|
||
if (this._isUsingOwnResolve) {
|
||
var then$$1 = getThen(entry);
|
||
|
||
if (then$$1 === then && entry._state !== PENDING) {
|
||
entry._onError = null;
|
||
this._settledAt(entry._state, i, entry._result, firstPass);
|
||
} else if (typeof then$$1 !== 'function') {
|
||
this._settledAt(FULFILLED, i, entry, firstPass);
|
||
} else if (this._isUsingOwnPromise) {
|
||
var promise = new c(noop);
|
||
handleMaybeThenable(promise, entry, then$$1);
|
||
this._willSettleAt(promise, i, firstPass);
|
||
} else {
|
||
this._willSettleAt(new c(function (resolve) {
|
||
return resolve(entry);
|
||
}), i, firstPass);
|
||
}
|
||
} else {
|
||
this._willSettleAt(c.resolve(entry), i, firstPass);
|
||
}
|
||
};
|
||
|
||
Enumerator.prototype._eachEntry = function _eachEntry(entry, i, firstPass) {
|
||
if (entry !== null && typeof entry === 'object') {
|
||
this._settleMaybeThenable(entry, i, firstPass);
|
||
} else {
|
||
this._setResultAt(FULFILLED, i, entry, firstPass);
|
||
}
|
||
};
|
||
|
||
Enumerator.prototype._settledAt = function _settledAt(state, i, value, firstPass) {
|
||
var promise = this.promise;
|
||
|
||
if (promise._state === PENDING) {
|
||
if (this._abortOnReject && state === REJECTED) {
|
||
reject(promise, value);
|
||
} else {
|
||
this._setResultAt(state, i, value, firstPass);
|
||
this._checkFullfillment();
|
||
}
|
||
}
|
||
};
|
||
|
||
Enumerator.prototype._setResultAt = function _setResultAt(state, i, value, firstPass) {
|
||
this._remaining--;
|
||
this._result[i] = value;
|
||
};
|
||
|
||
Enumerator.prototype._willSettleAt = function _willSettleAt(promise, i, firstPass) {
|
||
var _this = this;
|
||
|
||
subscribe(promise, undefined, function (value) {
|
||
return _this._settledAt(FULFILLED, i, value, firstPass);
|
||
}, function (reason) {
|
||
return _this._settledAt(REJECTED, i, reason, firstPass);
|
||
});
|
||
};
|
||
|
||
return Enumerator;
|
||
}();
|
||
|
||
|
||
function setSettledResult(state, i, value) {
|
||
this._remaining--;
|
||
if (state === FULFILLED) {
|
||
this._result[i] = {
|
||
state: 'fulfilled',
|
||
value: value
|
||
};
|
||
} else {
|
||
this._result[i] = {
|
||
state: 'rejected',
|
||
reason: value
|
||
};
|
||
}
|
||
}
|
||
|
||
/**
|
||
`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
|
||
import Promise, { resolve } from 'rsvp';
|
||
|
||
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 `RSVP.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
|
||
import Promise, { resolve, reject } from 'rsvp';
|
||
|
||
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
|
||
@for Promise
|
||
@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, label) {
|
||
if (!Array.isArray(entries)) {
|
||
return this.reject(new TypeError("Promise.all must be called with an array"), label);
|
||
}
|
||
return new Enumerator(this, entries, true /* abort on reject */, label).promise;
|
||
}
|
||
|
||
/**
|
||
`Promise.race` returns a new promise which is settled in the same way as the
|
||
first passed promise to settle.
|
||
|
||
Example:
|
||
|
||
```javascript
|
||
import Promise from 'rsvp';
|
||
|
||
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
|
||
import Promise from 'rsvp';
|
||
|
||
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
|
||
import Promise from 'rsvp';
|
||
|
||
Promise.race([ajax('foo.json'), timeout(5000)])
|
||
```
|
||
|
||
@method race
|
||
@for Promise
|
||
@static
|
||
@param {Array} entries array of promises to observe
|
||
@param {String} [label] optional string for describing the promise returned.
|
||
Useful for tooling.
|
||
@return {Promise} a promise which settles in the same way as the first passed
|
||
promise to settle.
|
||
*/
|
||
function race(entries, label) {
|
||
/*jshint validthis:true */
|
||
var Constructor = this;
|
||
|
||
var promise = new Constructor(noop, label);
|
||
|
||
if (!Array.isArray(entries)) {
|
||
reject(promise, new TypeError('Promise.race must be called with an array'));
|
||
return promise;
|
||
}
|
||
|
||
for (var i = 0; promise._state === PENDING && i < entries.length; i++) {
|
||
subscribe(Constructor.resolve(entries[i]), undefined, function (value) {
|
||
return resolve$1(promise, value);
|
||
}, function (reason) {
|
||
return reject(promise, reason);
|
||
});
|
||
}
|
||
|
||
return promise;
|
||
}
|
||
|
||
/**
|
||
`Promise.reject` returns a promise rejected with the passed `reason`.
|
||
It is shorthand for the following:
|
||
|
||
```javascript
|
||
import Promise from 'rsvp';
|
||
|
||
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
|
||
import Promise from 'rsvp';
|
||
|
||
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
|
||
@for Promise
|
||
@static
|
||
@param {*} reason value that the returned promise will be rejected with.
|
||
@param {String} [label] optional string for identifying the returned promise.
|
||
Useful for tooling.
|
||
@return {Promise} a promise rejected with the given `reason`.
|
||
*/
|
||
function reject$1(reason, label) {
|
||
/*jshint validthis:true */
|
||
var Constructor = this;
|
||
var promise = new Constructor(noop, label);
|
||
reject(promise, reason);
|
||
return promise;
|
||
}
|
||
|
||
var guidKey = 'rsvp_' + Date.now() + '-';
|
||
var counter = 0;
|
||
|
||
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
|
||
@public
|
||
@param {function} resolver
|
||
@param {String} [label] optional string for labeling the promise.
|
||
Useful for tooling.
|
||
@constructor
|
||
*/
|
||
|
||
var Promise = function () {
|
||
function Promise(resolver, label) {
|
||
this._id = counter++;
|
||
this._label = label;
|
||
this._state = undefined;
|
||
this._result = undefined;
|
||
this._subscribers = [];
|
||
|
||
config.instrument && instrument('created', this);
|
||
|
||
if (noop !== resolver) {
|
||
typeof resolver !== 'function' && needsResolver();
|
||
this instanceof Promise ? initializePromise(this, resolver) : needsNew();
|
||
}
|
||
}
|
||
|
||
Promise.prototype._onError = function _onError(reason) {
|
||
var _this = this;
|
||
|
||
config.after(function () {
|
||
if (_this._onError) {
|
||
config.trigger('error', reason, _this._label);
|
||
}
|
||
});
|
||
};
|
||
|
||
/**
|
||
`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
|
||
@param {String} [label] optional string for labeling the promise.
|
||
Useful for tooling.
|
||
@return {Promise}
|
||
*/
|
||
|
||
|
||
Promise.prototype.catch = function _catch(onRejection, label) {
|
||
return this.then(undefined, onRejection, label);
|
||
};
|
||
|
||
/**
|
||
`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 findOtherAuthor();
|
||
} finally {
|
||
// always runs
|
||
// doesn't affect the return value
|
||
}
|
||
```
|
||
|
||
Asynchronous example:
|
||
|
||
```js
|
||
findAuthor().catch(function(reason){
|
||
return findOtherAuthor();
|
||
}).finally(function(){
|
||
// author was either found, or not
|
||
});
|
||
```
|
||
|
||
@method finally
|
||
@param {Function} callback
|
||
@param {String} [label] optional string for labeling the promise.
|
||
Useful for tooling.
|
||
@return {Promise}
|
||
*/
|
||
|
||
|
||
Promise.prototype.finally = function _finally(callback, label) {
|
||
var promise = this;
|
||
var constructor = promise.constructor;
|
||
|
||
if (typeof callback === 'function') {
|
||
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.cast = resolve$$1; // deprecated
|
||
Promise.all = all;
|
||
Promise.race = race;
|
||
Promise.resolve = resolve$$1;
|
||
Promise.reject = reject$1;
|
||
|
||
Promise.prototype._guidKey = guidKey;
|
||
|
||
/**
|
||
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} onFulfillment
|
||
@param {Function} onRejection
|
||
@param {String} [label] optional string for labeling the promise.
|
||
Useful for tooling.
|
||
@return {Promise}
|
||
*/
|
||
Promise.prototype.then = then;
|
||
|
||
function makeObject(_, argumentNames) {
|
||
var obj = {};
|
||
var length = _.length;
|
||
var args = new Array(length);
|
||
|
||
for (var x = 0; x < length; x++) {
|
||
args[x] = _[x];
|
||
}
|
||
|
||
for (var i = 0; i < argumentNames.length; i++) {
|
||
var name = argumentNames[i];
|
||
obj[name] = args[i + 1];
|
||
}
|
||
|
||
return obj;
|
||
}
|
||
|
||
function arrayResult(_) {
|
||
var length = _.length;
|
||
var args = new Array(length - 1);
|
||
|
||
for (var i = 1; i < length; i++) {
|
||
args[i - 1] = _[i];
|
||
}
|
||
|
||
return args;
|
||
}
|
||
|
||
function wrapThenable(then, promise) {
|
||
return {
|
||
then: function (onFulFillment, onRejection) {
|
||
return then.call(promise, onFulFillment, onRejection);
|
||
}
|
||
};
|
||
}
|
||
|
||
/**
|
||
`denodeify` takes a 'node-style' function and returns a function that
|
||
will return an `Promise`. You can use `denodeify` in Node.js or the
|
||
browser when you'd prefer to use promises over using callbacks. For example,
|
||
`denodeify` transforms the following:
|
||
|
||
```javascript
|
||
let fs = require('fs');
|
||
|
||
fs.readFile('myfile.txt', function(err, data){
|
||
if (err) return handleError(err);
|
||
handleData(data);
|
||
});
|
||
```
|
||
|
||
into:
|
||
|
||
```javascript
|
||
let fs = require('fs');
|
||
let readFile = denodeify(fs.readFile);
|
||
|
||
readFile('myfile.txt').then(handleData, handleError);
|
||
```
|
||
|
||
If the node function has multiple success parameters, then `denodeify`
|
||
just returns the first one:
|
||
|
||
```javascript
|
||
let request = denodeify(require('request'));
|
||
|
||
request('http://example.com').then(function(res) {
|
||
// ...
|
||
});
|
||
```
|
||
|
||
However, if you need all success parameters, setting `denodeify`'s
|
||
second parameter to `true` causes it to return all success parameters
|
||
as an array:
|
||
|
||
```javascript
|
||
let request = denodeify(require('request'), true);
|
||
|
||
request('http://example.com').then(function(result) {
|
||
// result[0] -> res
|
||
// result[1] -> body
|
||
});
|
||
```
|
||
|
||
Or if you pass it an array with names it returns the parameters as a hash:
|
||
|
||
```javascript
|
||
let request = denodeify(require('request'), ['res', 'body']);
|
||
|
||
request('http://example.com').then(function(result) {
|
||
// result.res
|
||
// result.body
|
||
});
|
||
```
|
||
|
||
Sometimes you need to retain the `this`:
|
||
|
||
```javascript
|
||
let app = require('express')();
|
||
let render = denodeify(app.render.bind(app));
|
||
```
|
||
|
||
The denodified function inherits from the original function. It works in all
|
||
environments, except IE 10 and below. Consequently all properties of the original
|
||
function are available to you. However, any properties you change on the
|
||
denodeified function won't be changed on the original function. Example:
|
||
|
||
```javascript
|
||
let request = denodeify(require('request')),
|
||
cookieJar = request.jar(); // <- Inheritance is used here
|
||
|
||
request('http://example.com', {jar: cookieJar}).then(function(res) {
|
||
// cookieJar.cookies holds now the cookies returned by example.com
|
||
});
|
||
```
|
||
|
||
Using `denodeify` makes it easier to compose asynchronous operations instead
|
||
of using callbacks. For example, instead of:
|
||
|
||
```javascript
|
||
let fs = require('fs');
|
||
|
||
fs.readFile('myfile.txt', function(err, data){
|
||
if (err) { ... } // Handle error
|
||
fs.writeFile('myfile2.txt', data, function(err){
|
||
if (err) { ... } // Handle error
|
||
console.log('done')
|
||
});
|
||
});
|
||
```
|
||
|
||
you can chain the operations together using `then` from the returned promise:
|
||
|
||
```javascript
|
||
let fs = require('fs');
|
||
let readFile = denodeify(fs.readFile);
|
||
let writeFile = denodeify(fs.writeFile);
|
||
|
||
readFile('myfile.txt').then(function(data){
|
||
return writeFile('myfile2.txt', data);
|
||
}).then(function(){
|
||
console.log('done')
|
||
}).catch(function(error){
|
||
// Handle error
|
||
});
|
||
```
|
||
|
||
@method denodeify
|
||
@public
|
||
@static
|
||
@for rsvp
|
||
@param {Function} nodeFunc a 'node-style' function that takes a callback as
|
||
its last argument. The callback expects an error to be passed as its first
|
||
argument (if an error occurred, otherwise null), and the value from the
|
||
operation as its second argument ('function(err, value){ }').
|
||
@param {Boolean|Array} [options] An optional paramter that if set
|
||
to `true` causes the promise to fulfill with the callback's success arguments
|
||
as an array. This is useful if the node function has multiple success
|
||
paramters. If you set this paramter to an array with names, the promise will
|
||
fulfill with a hash with these names as keys and the success parameters as
|
||
values.
|
||
@return {Function} a function that wraps `nodeFunc` to return a `Promise`
|
||
*/
|
||
function denodeify(nodeFunc, options) {
|
||
var fn = function () {
|
||
var l = arguments.length;
|
||
var args = new Array(l + 1);
|
||
var promiseInput = false;
|
||
|
||
for (var i = 0; i < l; ++i) {
|
||
var arg = arguments[i];
|
||
|
||
if (!promiseInput) {
|
||
// TODO: clean this up
|
||
promiseInput = needsPromiseInput(arg);
|
||
if (promiseInput === TRY_CATCH_ERROR) {
|
||
var error = TRY_CATCH_ERROR.error;
|
||
TRY_CATCH_ERROR.error = null;
|
||
var p = new Promise(noop);
|
||
reject(p, error);
|
||
return p;
|
||
} else if (promiseInput && promiseInput !== true) {
|
||
arg = wrapThenable(promiseInput, arg);
|
||
}
|
||
}
|
||
args[i] = arg;
|
||
}
|
||
|
||
var promise = new Promise(noop);
|
||
|
||
args[l] = function (err, val) {
|
||
if (err) {
|
||
reject(promise, err);
|
||
} else if (options === undefined) {
|
||
resolve$1(promise, val);
|
||
} else if (options === true) {
|
||
resolve$1(promise, arrayResult(arguments));
|
||
} else if (Array.isArray(options)) {
|
||
resolve$1(promise, makeObject(arguments, options));
|
||
} else {
|
||
resolve$1(promise, val);
|
||
}
|
||
};
|
||
|
||
if (promiseInput) {
|
||
return handlePromiseInput(promise, args, nodeFunc, this);
|
||
} else {
|
||
return handleValueInput(promise, args, nodeFunc, this);
|
||
}
|
||
};
|
||
|
||
fn.__proto__ = nodeFunc;
|
||
|
||
return fn;
|
||
}
|
||
|
||
function handleValueInput(promise, args, nodeFunc, self) {
|
||
var result = tryCatch(nodeFunc).apply(self, args);
|
||
if (result === TRY_CATCH_ERROR) {
|
||
var error = TRY_CATCH_ERROR.error;
|
||
TRY_CATCH_ERROR.error = null;
|
||
reject(promise, error);
|
||
}
|
||
return promise;
|
||
}
|
||
|
||
function handlePromiseInput(promise, args, nodeFunc, self) {
|
||
return Promise.all(args).then(function (args) {
|
||
return handleValueInput(promise, args, nodeFunc, self);
|
||
});
|
||
}
|
||
|
||
function needsPromiseInput(arg) {
|
||
if (arg !== null && typeof arg === 'object') {
|
||
if (arg.constructor === Promise) {
|
||
return true;
|
||
} else {
|
||
return getThen(arg);
|
||
}
|
||
} else {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/**
|
||
This is a convenient alias for `Promise.all`.
|
||
|
||
@method all
|
||
@public
|
||
@static
|
||
@for rsvp
|
||
@param {Array} array Array of promises.
|
||
@param {String} [label] An optional label. This is useful
|
||
for tooling.
|
||
*/
|
||
function all$1(array, label) {
|
||
return Promise.all(array, label);
|
||
}
|
||
|
||
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
||
|
||
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
||
|
||
/**
|
||
@module rsvp
|
||
@public
|
||
**/
|
||
|
||
var AllSettled = function (_Enumerator) {
|
||
_inherits(AllSettled, _Enumerator);
|
||
|
||
function AllSettled(Constructor, entries, label) {
|
||
return _possibleConstructorReturn(this, _Enumerator.call(this, Constructor, entries, false /* don't abort on reject */, label));
|
||
}
|
||
|
||
return AllSettled;
|
||
}(Enumerator);
|
||
|
||
AllSettled.prototype._setResultAt = setSettledResult;
|
||
|
||
/**
|
||
`RSVP.allSettled` is similar to `RSVP.all`, but instead of implementing
|
||
a fail-fast method, it waits until all the promises have returned and
|
||
shows you all the results. This is useful if you want to handle multiple
|
||
promises' failure states together as a set.
|
||
Returns a promise that is fulfilled when all the given promises have been
|
||
settled. The return promise is fulfilled with an array of the states of
|
||
the promises passed into the `promises` array argument.
|
||
Each state object will either indicate fulfillment or rejection, and
|
||
provide the corresponding value or reason. The states will take one of
|
||
the following formats:
|
||
```javascript
|
||
{ state: 'fulfilled', value: value }
|
||
or
|
||
{ state: 'rejected', reason: reason }
|
||
```
|
||
Example:
|
||
```javascript
|
||
let promise1 = RSVP.Promise.resolve(1);
|
||
let promise2 = RSVP.Promise.reject(new Error('2'));
|
||
let promise3 = RSVP.Promise.reject(new Error('3'));
|
||
let promises = [ promise1, promise2, promise3 ];
|
||
RSVP.allSettled(promises).then(function(array){
|
||
// array == [
|
||
// { state: 'fulfilled', value: 1 },
|
||
// { state: 'rejected', reason: Error },
|
||
// { state: 'rejected', reason: Error }
|
||
// ]
|
||
// Note that for the second item, reason.message will be '2', and for the
|
||
// third item, reason.message will be '3'.
|
||
}, function(error) {
|
||
// Not run. (This block would only be called if allSettled had failed,
|
||
// for instance if passed an incorrect argument type.)
|
||
});
|
||
```
|
||
@method allSettled
|
||
@public
|
||
@static
|
||
@for rsvp
|
||
@param {Array} entries
|
||
@param {String} [label] - optional string that describes the promise.
|
||
Useful for tooling.
|
||
@return {Promise} promise that is fulfilled with an array of the settled
|
||
states of the constituent promises.
|
||
*/
|
||
|
||
function allSettled(entries, label) {
|
||
if (!Array.isArray(entries)) {
|
||
return Promise.reject(new TypeError("Promise.allSettled must be called with an array"), label);
|
||
}
|
||
|
||
return new AllSettled(Promise, entries, label).promise;
|
||
}
|
||
|
||
/**
|
||
This is a convenient alias for `Promise.race`.
|
||
|
||
@method race
|
||
@public
|
||
@static
|
||
@for rsvp
|
||
@param {Array} array Array of promises.
|
||
@param {String} [label] An optional label. This is useful
|
||
for tooling.
|
||
*/
|
||
function race$1(array, label) {
|
||
return Promise.race(array, label);
|
||
}
|
||
|
||
function _possibleConstructorReturn$1(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
||
|
||
function _inherits$1(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
||
|
||
var PromiseHash = function (_Enumerator) {
|
||
_inherits$1(PromiseHash, _Enumerator);
|
||
|
||
function PromiseHash(Constructor, object) {
|
||
var abortOnReject = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
|
||
var label = arguments[3];
|
||
return _possibleConstructorReturn$1(this, _Enumerator.call(this, Constructor, object, abortOnReject, label));
|
||
}
|
||
|
||
PromiseHash.prototype._init = function _init(Constructor, object) {
|
||
this._result = {};
|
||
this._enumerate(object);
|
||
};
|
||
|
||
PromiseHash.prototype._enumerate = function _enumerate(input) {
|
||
var keys = Object.keys(input);
|
||
|
||
var length = keys.length;
|
||
var promise = this.promise;
|
||
this._remaining = length;
|
||
|
||
var key = void 0,
|
||
val = void 0;
|
||
for (var i = 0; promise._state === PENDING && i < length; i++) {
|
||
key = keys[i];
|
||
val = input[key];
|
||
this._eachEntry(val, key, true);
|
||
}
|
||
|
||
this._checkFullfillment();
|
||
};
|
||
|
||
return PromiseHash;
|
||
}(Enumerator);
|
||
|
||
/**
|
||
`hash` is similar to `all`, but takes an object instead of an array
|
||
for its `promises` argument.
|
||
|
||
Returns a promise that is fulfilled when all the given promises have been
|
||
fulfilled, or rejected if any of them become rejected. The returned promise
|
||
is fulfilled with a hash that has the same key names as the `promises` object
|
||
argument. If any of the values in the object are not promises, they will
|
||
simply be copied over to the fulfilled object.
|
||
|
||
Example:
|
||
|
||
```javascript
|
||
let promises = {
|
||
myPromise: resolve(1),
|
||
yourPromise: resolve(2),
|
||
theirPromise: resolve(3),
|
||
notAPromise: 4
|
||
};
|
||
|
||
hash(promises).then(function(hash){
|
||
// hash here is an object that looks like:
|
||
// {
|
||
// myPromise: 1,
|
||
// yourPromise: 2,
|
||
// theirPromise: 3,
|
||
// notAPromise: 4
|
||
// }
|
||
});
|
||
```
|
||
|
||
If any of the `promises` given to `hash` are rejected, the first promise
|
||
that is rejected will be given as the reason to the rejection handler.
|
||
|
||
Example:
|
||
|
||
```javascript
|
||
let promises = {
|
||
myPromise: resolve(1),
|
||
rejectedPromise: reject(new Error('rejectedPromise')),
|
||
anotherRejectedPromise: reject(new Error('anotherRejectedPromise')),
|
||
};
|
||
|
||
hash(promises).then(function(hash){
|
||
// Code here never runs because there are rejected promises!
|
||
}, function(reason) {
|
||
// reason.message === 'rejectedPromise'
|
||
});
|
||
```
|
||
|
||
An important note: `hash` is intended for plain JavaScript objects that
|
||
are just a set of keys and values. `hash` will NOT preserve prototype
|
||
chains.
|
||
|
||
Example:
|
||
|
||
```javascript
|
||
import { hash, resolve } from 'rsvp';
|
||
function MyConstructor(){
|
||
this.example = resolve('Example');
|
||
}
|
||
|
||
MyConstructor.prototype = {
|
||
protoProperty: resolve('Proto Property')
|
||
};
|
||
|
||
let myObject = new MyConstructor();
|
||
|
||
hash(myObject).then(function(hash){
|
||
// protoProperty will not be present, instead you will just have an
|
||
// object that looks like:
|
||
// {
|
||
// example: 'Example'
|
||
// }
|
||
//
|
||
// hash.hasOwnProperty('protoProperty'); // false
|
||
// 'undefined' === typeof hash.protoProperty
|
||
});
|
||
```
|
||
|
||
@method hash
|
||
@public
|
||
@static
|
||
@for rsvp
|
||
@param {Object} object
|
||
@param {String} [label] optional string that describes the promise.
|
||
Useful for tooling.
|
||
@return {Promise} promise that is fulfilled when all properties of `promises`
|
||
have been fulfilled, or rejected if any of them become rejected.
|
||
*/
|
||
function hash(object, label) {
|
||
return Promise.resolve(object, label).then(function (object) {
|
||
if (object === null || typeof object !== 'object') {
|
||
throw new TypeError("Promise.hash must be called with an object");
|
||
}
|
||
return new PromiseHash(Promise, object, label).promise;
|
||
});
|
||
}
|
||
|
||
function _possibleConstructorReturn$2(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
||
|
||
function _inherits$2(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
||
|
||
var HashSettled = function (_PromiseHash) {
|
||
_inherits$2(HashSettled, _PromiseHash);
|
||
|
||
function HashSettled(Constructor, object, label) {
|
||
return _possibleConstructorReturn$2(this, _PromiseHash.call(this, Constructor, object, false, label));
|
||
}
|
||
|
||
return HashSettled;
|
||
}(PromiseHash);
|
||
|
||
HashSettled.prototype._setResultAt = setSettledResult;
|
||
|
||
/**
|
||
`hashSettled` is similar to `allSettled`, but takes an object
|
||
instead of an array for its `promises` argument.
|
||
|
||
Unlike `all` or `hash`, which implement a fail-fast method,
|
||
but like `allSettled`, `hashSettled` waits until all the
|
||
constituent promises have returned and then shows you all the results
|
||
with their states and values/reasons. This is useful if you want to
|
||
handle multiple promises' failure states together as a set.
|
||
|
||
Returns a promise that is fulfilled when all the given promises have been
|
||
settled, or rejected if the passed parameters are invalid.
|
||
|
||
The returned promise is fulfilled with a hash that has the same key names as
|
||
the `promises` object argument. If any of the values in the object are not
|
||
promises, they will be copied over to the fulfilled object and marked with state
|
||
'fulfilled'.
|
||
|
||
Example:
|
||
|
||
```javascript
|
||
import { hashSettled, resolve } from 'rsvp';
|
||
|
||
let promises = {
|
||
myPromise: resolve(1),
|
||
yourPromise: resolve(2),
|
||
theirPromise: resolve(3),
|
||
notAPromise: 4
|
||
};
|
||
|
||
hashSettled(promises).then(function(hash){
|
||
// hash here is an object that looks like:
|
||
// {
|
||
// myPromise: { state: 'fulfilled', value: 1 },
|
||
// yourPromise: { state: 'fulfilled', value: 2 },
|
||
// theirPromise: { state: 'fulfilled', value: 3 },
|
||
// notAPromise: { state: 'fulfilled', value: 4 }
|
||
// }
|
||
});
|
||
```
|
||
|
||
If any of the `promises` given to `hash` are rejected, the state will
|
||
be set to 'rejected' and the reason for rejection provided.
|
||
|
||
Example:
|
||
|
||
```javascript
|
||
import { hashSettled, reject, resolve } from 'rsvp';
|
||
|
||
let promises = {
|
||
myPromise: resolve(1),
|
||
rejectedPromise: reject(new Error('rejection')),
|
||
anotherRejectedPromise: reject(new Error('more rejection')),
|
||
};
|
||
|
||
hashSettled(promises).then(function(hash){
|
||
// hash here is an object that looks like:
|
||
// {
|
||
// myPromise: { state: 'fulfilled', value: 1 },
|
||
// rejectedPromise: { state: 'rejected', reason: Error },
|
||
// anotherRejectedPromise: { state: 'rejected', reason: Error },
|
||
// }
|
||
// Note that for rejectedPromise, reason.message == 'rejection',
|
||
// and for anotherRejectedPromise, reason.message == 'more rejection'.
|
||
});
|
||
```
|
||
|
||
An important note: `hashSettled` is intended for plain JavaScript objects that
|
||
are just a set of keys and values. `hashSettled` will NOT preserve prototype
|
||
chains.
|
||
|
||
Example:
|
||
|
||
```javascript
|
||
import Promise, { hashSettled, resolve } from 'rsvp';
|
||
|
||
function MyConstructor(){
|
||
this.example = resolve('Example');
|
||
}
|
||
|
||
MyConstructor.prototype = {
|
||
protoProperty: Promise.resolve('Proto Property')
|
||
};
|
||
|
||
let myObject = new MyConstructor();
|
||
|
||
hashSettled(myObject).then(function(hash){
|
||
// protoProperty will not be present, instead you will just have an
|
||
// object that looks like:
|
||
// {
|
||
// example: { state: 'fulfilled', value: 'Example' }
|
||
// }
|
||
//
|
||
// hash.hasOwnProperty('protoProperty'); // false
|
||
// 'undefined' === typeof hash.protoProperty
|
||
});
|
||
```
|
||
|
||
@method hashSettled
|
||
@public
|
||
@for rsvp
|
||
@param {Object} object
|
||
@param {String} [label] optional string that describes the promise.
|
||
Useful for tooling.
|
||
@return {Promise} promise that is fulfilled when when all properties of `promises`
|
||
have been settled.
|
||
@static
|
||
*/
|
||
|
||
function hashSettled(object, label) {
|
||
return Promise.resolve(object, label).then(function (object) {
|
||
if (object === null || typeof object !== 'object') {
|
||
throw new TypeError("hashSettled must be called with an object");
|
||
}
|
||
|
||
return new HashSettled(Promise, object, false, label).promise;
|
||
});
|
||
}
|
||
|
||
/**
|
||
`rethrow` will rethrow an error on the next turn of the JavaScript event
|
||
loop in order to aid debugging.
|
||
|
||
Promises A+ specifies that any exceptions that occur with a promise must be
|
||
caught by the promises implementation and bubbled to the last handler. For
|
||
this reason, it is recommended that you always specify a second rejection
|
||
handler function to `then`. However, `rethrow` will throw the exception
|
||
outside of the promise, so it bubbles up to your console if in the browser,
|
||
or domain/cause uncaught exception in Node. `rethrow` will also throw the
|
||
error again so the error can be handled by the promise per the spec.
|
||
|
||
```javascript
|
||
import { rethrow } from 'rsvp';
|
||
|
||
function throws(){
|
||
throw new Error('Whoops!');
|
||
}
|
||
|
||
let promise = new Promise(function(resolve, reject){
|
||
throws();
|
||
});
|
||
|
||
promise.catch(rethrow).then(function(){
|
||
// Code here doesn't run because the promise became rejected due to an
|
||
// error!
|
||
}, function (err){
|
||
// handle the error here
|
||
});
|
||
```
|
||
|
||
The 'Whoops' error will be thrown on the next turn of the event loop
|
||
and you can watch for it in your console. You can also handle it using a
|
||
rejection handler given to `.then` or `.catch` on the returned promise.
|
||
|
||
@method rethrow
|
||
@public
|
||
@static
|
||
@for rsvp
|
||
@param {Error} reason reason the promise became rejected.
|
||
@throws Error
|
||
@static
|
||
*/
|
||
function rethrow(reason) {
|
||
setTimeout(function () {
|
||
throw reason;
|
||
});
|
||
throw reason;
|
||
}
|
||
|
||
/**
|
||
`defer` returns an object similar to jQuery's `$.Deferred`.
|
||
`defer` should be used when porting over code reliant on `$.Deferred`'s
|
||
interface. New code should use the `Promise` constructor instead.
|
||
|
||
The object returned from `defer` is a plain object with three properties:
|
||
|
||
* promise - an `Promise`.
|
||
* reject - a function that causes the `promise` property on this object to
|
||
become rejected
|
||
* resolve - a function that causes the `promise` property on this object to
|
||
become fulfilled.
|
||
|
||
Example:
|
||
|
||
```javascript
|
||
let deferred = defer();
|
||
|
||
deferred.resolve("Success!");
|
||
|
||
deferred.promise.then(function(value){
|
||
// value here is "Success!"
|
||
});
|
||
```
|
||
|
||
@method defer
|
||
@public
|
||
@static
|
||
@for rsvp
|
||
@param {String} [label] optional string for labeling the promise.
|
||
Useful for tooling.
|
||
@return {Object}
|
||
*/
|
||
|
||
function defer(label) {
|
||
var deferred = { resolve: undefined, reject: undefined };
|
||
|
||
deferred.promise = new Promise(function (resolve, reject) {
|
||
deferred.resolve = resolve;
|
||
deferred.reject = reject;
|
||
}, label);
|
||
|
||
return deferred;
|
||
}
|
||
|
||
function _possibleConstructorReturn$3(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
||
|
||
function _inherits$3(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
||
|
||
var MapEnumerator = function (_Enumerator) {
|
||
_inherits$3(MapEnumerator, _Enumerator);
|
||
|
||
function MapEnumerator(Constructor, entries, mapFn, label) {
|
||
return _possibleConstructorReturn$3(this, _Enumerator.call(this, Constructor, entries, true, label, mapFn));
|
||
}
|
||
|
||
MapEnumerator.prototype._init = function _init(Constructor, input, bool, label, mapFn) {
|
||
var len = input.length || 0;
|
||
this.length = len;
|
||
this._remaining = len;
|
||
this._result = new Array(len);
|
||
this._mapFn = mapFn;
|
||
|
||
this._enumerate(input);
|
||
};
|
||
|
||
MapEnumerator.prototype._setResultAt = function _setResultAt(state, i, value, firstPass) {
|
||
if (firstPass) {
|
||
var val = tryCatch(this._mapFn)(value, i);
|
||
if (val === TRY_CATCH_ERROR) {
|
||
this._settledAt(REJECTED, i, val.error, false);
|
||
} else {
|
||
this._eachEntry(val, i, false);
|
||
}
|
||
} else {
|
||
this._remaining--;
|
||
this._result[i] = value;
|
||
}
|
||
};
|
||
|
||
return MapEnumerator;
|
||
}(Enumerator);
|
||
|
||
/**
|
||
`map` is similar to JavaScript's native `map` method. `mapFn` is eagerly called
|
||
meaning that as soon as any promise resolves its value will be passed to `mapFn`.
|
||
`map` returns a promise that will become fulfilled with the result of running
|
||
`mapFn` on the values the promises become fulfilled with.
|
||
|
||
For example:
|
||
|
||
```javascript
|
||
import { map, resolve } from 'rsvp';
|
||
|
||
let promise1 = resolve(1);
|
||
let promise2 = resolve(2);
|
||
let promise3 = resolve(3);
|
||
let promises = [ promise1, promise2, promise3 ];
|
||
|
||
let mapFn = function(item){
|
||
return item + 1;
|
||
};
|
||
|
||
map(promises, mapFn).then(function(result){
|
||
// result is [ 2, 3, 4 ]
|
||
});
|
||
```
|
||
|
||
If any of the `promises` given to `map` are rejected, the first promise
|
||
that is rejected will be given as an argument to the returned promise's
|
||
rejection handler. For example:
|
||
|
||
```javascript
|
||
import { map, reject, resolve } from 'rsvp';
|
||
|
||
let promise1 = resolve(1);
|
||
let promise2 = reject(new Error('2'));
|
||
let promise3 = reject(new Error('3'));
|
||
let promises = [ promise1, promise2, promise3 ];
|
||
|
||
let mapFn = function(item){
|
||
return item + 1;
|
||
};
|
||
|
||
map(promises, mapFn).then(function(array){
|
||
// Code here never runs because there are rejected promises!
|
||
}, function(reason) {
|
||
// reason.message === '2'
|
||
});
|
||
```
|
||
|
||
`map` will also wait if a promise is returned from `mapFn`. For example,
|
||
say you want to get all comments from a set of blog posts, but you need
|
||
the blog posts first because they contain a url to those comments.
|
||
|
||
```javscript
|
||
import { map } from 'rsvp';
|
||
|
||
let mapFn = function(blogPost){
|
||
// getComments does some ajax and returns an Promise that is fulfilled
|
||
// with some comments data
|
||
return getComments(blogPost.comments_url);
|
||
};
|
||
|
||
// getBlogPosts does some ajax and returns an Promise that is fulfilled
|
||
// with some blog post data
|
||
map(getBlogPosts(), mapFn).then(function(comments){
|
||
// comments is the result of asking the server for the comments
|
||
// of all blog posts returned from getBlogPosts()
|
||
});
|
||
```
|
||
|
||
@method map
|
||
@public
|
||
@static
|
||
@for rsvp
|
||
@param {Array} promises
|
||
@param {Function} mapFn function to be called on each fulfilled promise.
|
||
@param {String} [label] optional string for labeling the promise.
|
||
Useful for tooling.
|
||
@return {Promise} promise that is fulfilled with the result of calling
|
||
`mapFn` on each fulfilled promise or value when they become fulfilled.
|
||
The promise will be rejected if any of the given `promises` become rejected.
|
||
*/
|
||
function map(promises, mapFn, label) {
|
||
if (typeof mapFn !== 'function') {
|
||
return Promise.reject(new TypeError("map expects a function as a second argument"), label);
|
||
}
|
||
|
||
return Promise.resolve(promises, label).then(function (promises) {
|
||
if (!Array.isArray(promises)) {
|
||
throw new TypeError("map must be called with an array");
|
||
}
|
||
return new MapEnumerator(Promise, promises, mapFn, label).promise;
|
||
});
|
||
}
|
||
|
||
/**
|
||
This is a convenient alias for `Promise.resolve`.
|
||
|
||
@method resolve
|
||
@public
|
||
@static
|
||
@for rsvp
|
||
@param {*} value value that the returned promise will be resolved with
|
||
@param {String} [label] optional string for identifying the returned promise.
|
||
Useful for tooling.
|
||
@return {Promise} a promise that will become fulfilled with the given
|
||
`value`
|
||
*/
|
||
function resolve$2(value, label) {
|
||
return Promise.resolve(value, label);
|
||
}
|
||
|
||
/**
|
||
This is a convenient alias for `Promise.reject`.
|
||
|
||
@method reject
|
||
@public
|
||
@static
|
||
@for rsvp
|
||
@param {*} reason value that the returned promise will be rejected with.
|
||
@param {String} [label] optional string for identifying the returned promise.
|
||
Useful for tooling.
|
||
@return {Promise} a promise rejected with the given `reason`.
|
||
*/
|
||
function reject$2(reason, label) {
|
||
return Promise.reject(reason, label);
|
||
}
|
||
|
||
function _possibleConstructorReturn$4(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
||
|
||
function _inherits$4(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
||
|
||
var EMPTY_OBJECT = {};
|
||
|
||
var FilterEnumerator = function (_MapEnumerator) {
|
||
_inherits$4(FilterEnumerator, _MapEnumerator);
|
||
|
||
function FilterEnumerator() {
|
||
return _possibleConstructorReturn$4(this, _MapEnumerator.apply(this, arguments));
|
||
}
|
||
|
||
FilterEnumerator.prototype._checkFullfillment = function _checkFullfillment() {
|
||
if (this._remaining === 0 && this._result !== null) {
|
||
var result = this._result.filter(function (val) {
|
||
return val !== EMPTY_OBJECT;
|
||
});
|
||
fulfill(this.promise, result);
|
||
this._result = null;
|
||
}
|
||
};
|
||
|
||
FilterEnumerator.prototype._setResultAt = function _setResultAt(state, i, value, firstPass) {
|
||
if (firstPass) {
|
||
this._result[i] = value;
|
||
var val = tryCatch(this._mapFn)(value, i);
|
||
if (val === TRY_CATCH_ERROR) {
|
||
this._settledAt(REJECTED, i, val.error, false);
|
||
} else {
|
||
this._eachEntry(val, i, false);
|
||
}
|
||
} else {
|
||
this._remaining--;
|
||
if (!value) {
|
||
this._result[i] = EMPTY_OBJECT;
|
||
}
|
||
}
|
||
};
|
||
|
||
return FilterEnumerator;
|
||
}(MapEnumerator);
|
||
|
||
/**
|
||
`filter` is similar to JavaScript's native `filter` method.
|
||
`filterFn` is eagerly called meaning that as soon as any promise
|
||
resolves its value will be passed to `filterFn`. `filter` returns
|
||
a promise that will become fulfilled with the result of running
|
||
`filterFn` on the values the promises become fulfilled with.
|
||
|
||
For example:
|
||
|
||
```javascript
|
||
import { filter, resolve } from 'rsvp';
|
||
|
||
let promise1 = resolve(1);
|
||
let promise2 = resolve(2);
|
||
let promise3 = resolve(3);
|
||
|
||
let promises = [promise1, promise2, promise3];
|
||
|
||
let filterFn = function(item){
|
||
return item > 1;
|
||
};
|
||
|
||
filter(promises, filterFn).then(function(result){
|
||
// result is [ 2, 3 ]
|
||
});
|
||
```
|
||
|
||
If any of the `promises` given to `filter` are rejected, the first promise
|
||
that is rejected will be given as an argument to the returned promise's
|
||
rejection handler. For example:
|
||
|
||
```javascript
|
||
import { filter, reject, resolve } from 'rsvp';
|
||
|
||
let promise1 = resolve(1);
|
||
let promise2 = reject(new Error('2'));
|
||
let promise3 = reject(new Error('3'));
|
||
let promises = [ promise1, promise2, promise3 ];
|
||
|
||
let filterFn = function(item){
|
||
return item > 1;
|
||
};
|
||
|
||
filter(promises, filterFn).then(function(array){
|
||
// Code here never runs because there are rejected promises!
|
||
}, function(reason) {
|
||
// reason.message === '2'
|
||
});
|
||
```
|
||
|
||
`filter` will also wait for any promises returned from `filterFn`.
|
||
For instance, you may want to fetch a list of users then return a subset
|
||
of those users based on some asynchronous operation:
|
||
|
||
```javascript
|
||
import { filter, resolve } from 'rsvp';
|
||
|
||
let alice = { name: 'alice' };
|
||
let bob = { name: 'bob' };
|
||
let users = [ alice, bob ];
|
||
|
||
let promises = users.map(function(user){
|
||
return resolve(user);
|
||
});
|
||
|
||
let filterFn = function(user){
|
||
// Here, Alice has permissions to create a blog post, but Bob does not.
|
||
return getPrivilegesForUser(user).then(function(privs){
|
||
return privs.can_create_blog_post === true;
|
||
});
|
||
};
|
||
filter(promises, filterFn).then(function(users){
|
||
// true, because the server told us only Alice can create a blog post.
|
||
users.length === 1;
|
||
// false, because Alice is the only user present in `users`
|
||
users[0] === bob;
|
||
});
|
||
```
|
||
|
||
@method filter
|
||
@public
|
||
@static
|
||
@for rsvp
|
||
@param {Array} promises
|
||
@param {Function} filterFn - function to be called on each resolved value to
|
||
filter the final results.
|
||
@param {String} [label] optional string describing the promise. Useful for
|
||
tooling.
|
||
@return {Promise}
|
||
*/
|
||
|
||
function filter(promises, filterFn, label) {
|
||
if (typeof filterFn !== 'function') {
|
||
return Promise.reject(new TypeError("filter expects function as a second argument"), label);
|
||
}
|
||
|
||
return Promise.resolve(promises, label).then(function (promises) {
|
||
if (!Array.isArray(promises)) {
|
||
throw new TypeError("filter must be called with an array");
|
||
}
|
||
return new FilterEnumerator(Promise, promises, filterFn, label).promise;
|
||
});
|
||
}
|
||
|
||
var len = 0;
|
||
var vertxNext = void 0;
|
||
function asap(callback, arg) {
|
||
queue$1[len] = callback;
|
||
queue$1[len + 1] = arg;
|
||
len += 2;
|
||
if (len === 2) {
|
||
// If len is 1, 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.
|
||
scheduleFlush$1();
|
||
}
|
||
}
|
||
|
||
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() {
|
||
var nextTick = process.nextTick;
|
||
// node version 0.10.x displays a deprecation warning when nextTick is used recursively
|
||
// setImmediate should be used instead instead
|
||
var version = process.versions.node.match(/^(?:(\d+)\.)?(?:(\d+)\.)?(\*|\d+)$/);
|
||
if (Array.isArray(version) && version[1] === '0' && version[2] === '10') {
|
||
nextTick = setImmediate;
|
||
}
|
||
return function () {
|
||
return 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 () {
|
||
return 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() {
|
||
return function () {
|
||
return setTimeout(flush, 1);
|
||
};
|
||
}
|
||
|
||
var queue$1 = new Array(1000);
|
||
|
||
function flush() {
|
||
for (var i = 0; i < len; i += 2) {
|
||
var callback = queue$1[i];
|
||
var arg = queue$1[i + 1];
|
||
|
||
callback(arg);
|
||
|
||
queue$1[i] = undefined;
|
||
queue$1[i + 1] = undefined;
|
||
}
|
||
|
||
len = 0;
|
||
}
|
||
|
||
function attemptVertex() {
|
||
try {
|
||
var vertx = Function('return this')().require('vertx');
|
||
vertxNext = vertx.runOnLoop || vertx.runOnContext;
|
||
return useVertxTimer();
|
||
} catch (e) {
|
||
return useSetTimeout();
|
||
}
|
||
}
|
||
|
||
var scheduleFlush$1 = void 0;
|
||
// Decide what async method to use to triggering processing of queued callbacks:
|
||
if (isNode) {
|
||
scheduleFlush$1 = useNextTick();
|
||
} else if (BrowserMutationObserver) {
|
||
scheduleFlush$1 = useMutationObserver();
|
||
} else if (isWorker) {
|
||
scheduleFlush$1 = useMessageChannel();
|
||
} else if (browserWindow === undefined && typeof require === 'function') {
|
||
scheduleFlush$1 = attemptVertex();
|
||
} else {
|
||
scheduleFlush$1 = useSetTimeout();
|
||
}
|
||
|
||
// defaults
|
||
config.async = asap;
|
||
config.after = function (cb) {
|
||
return setTimeout(cb, 0);
|
||
};
|
||
var cast = resolve$2;
|
||
|
||
var async = function (callback, arg) {
|
||
return config.async(callback, arg);
|
||
};
|
||
|
||
function on() {
|
||
config.on.apply(config, arguments);
|
||
}
|
||
|
||
function off() {
|
||
config.off.apply(config, arguments);
|
||
}
|
||
|
||
// Set up instrumentation through `window.__PROMISE_INTRUMENTATION__`
|
||
if (typeof window !== 'undefined' && typeof window['__PROMISE_INSTRUMENTATION__'] === 'object') {
|
||
var callbacks = window['__PROMISE_INSTRUMENTATION__'];
|
||
configure('instrument', true);
|
||
for (var eventName in callbacks) {
|
||
if (callbacks.hasOwnProperty(eventName)) {
|
||
on(eventName, callbacks[eventName]);
|
||
}
|
||
}
|
||
}
|
||
|
||
// the default export here is for backwards compat:
|
||
// https://github.com/tildeio/rsvp.js/issues/434
|
||
var rsvp = {
|
||
asap: asap,
|
||
cast: cast,
|
||
Promise: Promise,
|
||
EventTarget: EventTarget,
|
||
all: all$1,
|
||
allSettled: allSettled,
|
||
race: race$1,
|
||
hash: hash,
|
||
hashSettled: hashSettled,
|
||
rethrow: rethrow,
|
||
defer: defer,
|
||
denodeify: denodeify,
|
||
configure: configure,
|
||
on: on,
|
||
off: off,
|
||
resolve: resolve$2,
|
||
reject: reject$2,
|
||
map: map,
|
||
async: async,
|
||
filter: filter
|
||
};
|
||
|
||
exports.default = rsvp;
|
||
exports.asap = asap;
|
||
exports.cast = cast;
|
||
exports.Promise = Promise;
|
||
exports.EventTarget = EventTarget;
|
||
exports.all = all$1;
|
||
exports.allSettled = allSettled;
|
||
exports.race = race$1;
|
||
exports.hash = hash;
|
||
exports.hashSettled = hashSettled;
|
||
exports.rethrow = rethrow;
|
||
exports.defer = defer;
|
||
exports.denodeify = denodeify;
|
||
exports.configure = configure;
|
||
exports.on = on;
|
||
exports.off = off;
|
||
exports.resolve = resolve$2;
|
||
exports.reject = reject$2;
|
||
exports.map = map;
|
||
exports.async = async;
|
||
exports.filter = filter;
|
||
|
||
Object.defineProperty(exports, '__esModule', { value: true });
|
||
|
||
})));
|
||
|
||
|
||
|
||
|
||
|
||
//# sourceMappingURL=rsvp.map
|