|
|
/*!
|
|
|
* @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 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
|
|
|
};
|
|
|
|
|
|
export default rsvp;
|
|
|
export { asap, cast, Promise, EventTarget, all$1 as all, allSettled, race$1 as race, hash, hashSettled, rethrow, defer, denodeify, configure, on, off, resolve$2 as resolve, reject$2 as reject, map, async, filter };
|
|
|
|
|
|
//# sourceMappingURL=rsvp.es.map
|