mirror of
https://github.com/musix-org/musix-oss
synced 2024-11-10 11:20:19 +00:00
3624 lines
100 KiB
JavaScript
3624 lines
100 KiB
JavaScript
!function(e){"object"==typeof exports?module.exports=e():"function"==typeof define&&define.amd?define(e):"undefined"!=typeof window?window.when=e():"undefined"!=typeof global?global.when=e():"undefined"!=typeof self&&(self.when=e())}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
|
|
var when = module.exports = require('../when');
|
|
|
|
when.callbacks = require('../callbacks');
|
|
when.cancelable = require('../cancelable');
|
|
when.delay = require('../delay');
|
|
when.fn = require('../function');
|
|
when.guard = require('../guard');
|
|
when.keys = require('../keys');
|
|
when.nodefn = when.node = require('../node');
|
|
when.parallel = require('../parallel');
|
|
when.pipeline = require('../pipeline');
|
|
when.poll = require('../poll');
|
|
when.sequence = require('../sequence');
|
|
when.timeout = require('../timeout');
|
|
|
|
},{"../callbacks":2,"../cancelable":3,"../delay":4,"../function":5,"../guard":6,"../keys":7,"../node":26,"../parallel":27,"../pipeline":28,"../poll":29,"../sequence":30,"../timeout":31,"../when":32}],2:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright 2013-2014 original author or authors */
|
|
|
|
/**
|
|
* Collection of helper functions for interacting with 'traditional',
|
|
* callback-taking functions using a promise interface.
|
|
*
|
|
* @author Renato Zannon
|
|
* @contributor Brian Cavalier
|
|
*/
|
|
|
|
(function(define) {
|
|
define(function(require) {
|
|
|
|
var when = require('./when');
|
|
var Promise = when.Promise;
|
|
var _liftAll = require('./lib/liftAll');
|
|
var slice = Array.prototype.slice;
|
|
|
|
var makeApply = require('./lib/apply');
|
|
var _apply = makeApply(Promise, dispatch);
|
|
|
|
return {
|
|
lift: lift,
|
|
liftAll: liftAll,
|
|
apply: apply,
|
|
call: call,
|
|
promisify: promisify
|
|
};
|
|
|
|
/**
|
|
* Takes a `traditional` callback-taking function and returns a promise for its
|
|
* result, accepting an optional array of arguments (that might be values or
|
|
* promises). It assumes that the function takes its callback and errback as
|
|
* the last two arguments. The resolution of the promise depends on whether the
|
|
* function will call its callback or its errback.
|
|
*
|
|
* @example
|
|
* var domIsLoaded = callbacks.apply($);
|
|
* domIsLoaded.then(function() {
|
|
* doMyDomStuff();
|
|
* });
|
|
*
|
|
* @example
|
|
* function existingAjaxyFunction(url, callback, errback) {
|
|
* // Complex logic you'd rather not change
|
|
* }
|
|
*
|
|
* var promise = callbacks.apply(existingAjaxyFunction, ["/movies.json"]);
|
|
*
|
|
* promise.then(function(movies) {
|
|
* // Work with movies
|
|
* }, function(reason) {
|
|
* // Handle error
|
|
* });
|
|
*
|
|
* @param {function} asyncFunction function to be called
|
|
* @param {Array} [extraAsyncArgs] array of arguments to asyncFunction
|
|
* @returns {Promise} promise for the callback value of asyncFunction
|
|
*/
|
|
function apply(asyncFunction, extraAsyncArgs) {
|
|
return _apply(asyncFunction, this, extraAsyncArgs || []);
|
|
}
|
|
|
|
/**
|
|
* Apply helper that allows specifying thisArg
|
|
* @private
|
|
*/
|
|
function dispatch(f, thisArg, args, h) {
|
|
args.push(alwaysUnary(h.resolve, h), alwaysUnary(h.reject, h));
|
|
tryCatchResolve(f, thisArg, args, h);
|
|
}
|
|
|
|
function tryCatchResolve(f, thisArg, args, resolver) {
|
|
try {
|
|
f.apply(thisArg, args);
|
|
} catch(e) {
|
|
resolver.reject(e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Works as `callbacks.apply` does, with the difference that the arguments to
|
|
* the function are passed individually, instead of as an array.
|
|
*
|
|
* @example
|
|
* function sumInFiveSeconds(a, b, callback) {
|
|
* setTimeout(function() {
|
|
* callback(a + b);
|
|
* }, 5000);
|
|
* }
|
|
*
|
|
* var sumPromise = callbacks.call(sumInFiveSeconds, 5, 10);
|
|
*
|
|
* // Logs '15' 5 seconds later
|
|
* sumPromise.then(console.log);
|
|
*
|
|
* @param {function} asyncFunction function to be called
|
|
* @param {...*} args arguments that will be forwarded to the function
|
|
* @returns {Promise} promise for the callback value of asyncFunction
|
|
*/
|
|
function call(asyncFunction/*, arg1, arg2...*/) {
|
|
return _apply(asyncFunction, this, slice.call(arguments, 1));
|
|
}
|
|
|
|
/**
|
|
* Takes a 'traditional' callback/errback-taking function and returns a function
|
|
* that returns a promise instead. The resolution/rejection of the promise
|
|
* depends on whether the original function will call its callback or its
|
|
* errback.
|
|
*
|
|
* If additional arguments are passed to the `lift` call, they will be prepended
|
|
* on the calls to the original function, much like `Function.prototype.bind`.
|
|
*
|
|
* The resulting function is also "promise-aware", in the sense that, if given
|
|
* promises as arguments, it will wait for their resolution before executing.
|
|
*
|
|
* @example
|
|
* function traditionalAjax(method, url, callback, errback) {
|
|
* var xhr = new XMLHttpRequest();
|
|
* xhr.open(method, url);
|
|
*
|
|
* xhr.onload = callback;
|
|
* xhr.onerror = errback;
|
|
*
|
|
* xhr.send();
|
|
* }
|
|
*
|
|
* var promiseAjax = callbacks.lift(traditionalAjax);
|
|
* promiseAjax("GET", "/movies.json").then(console.log, console.error);
|
|
*
|
|
* var promiseAjaxGet = callbacks.lift(traditionalAjax, "GET");
|
|
* promiseAjaxGet("/movies.json").then(console.log, console.error);
|
|
*
|
|
* @param {Function} f traditional async function to be decorated
|
|
* @param {...*} [args] arguments to be prepended for the new function @deprecated
|
|
* @returns {Function} a promise-returning function
|
|
*/
|
|
function lift(f/*, args...*/) {
|
|
var args = arguments.length > 1 ? slice.call(arguments, 1) : [];
|
|
return function() {
|
|
return _apply(f, this, args.concat(slice.call(arguments)));
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Lift all the functions/methods on src
|
|
* @param {object|function} src source whose functions will be lifted
|
|
* @param {function?} combine optional function for customizing the lifting
|
|
* process. It is passed dst, the lifted function, and the property name of
|
|
* the original function on src.
|
|
* @param {(object|function)?} dst option destination host onto which to place lifted
|
|
* functions. If not provided, liftAll returns a new object.
|
|
* @returns {*} If dst is provided, returns dst with lifted functions as
|
|
* properties. If dst not provided, returns a new object with lifted functions.
|
|
*/
|
|
function liftAll(src, combine, dst) {
|
|
return _liftAll(lift, combine, dst, src);
|
|
}
|
|
|
|
/**
|
|
* `promisify` is a version of `lift` that allows fine-grained control over the
|
|
* arguments that passed to the underlying function. It is intended to handle
|
|
* functions that don't follow the common callback and errback positions.
|
|
*
|
|
* The control is done by passing an object whose 'callback' and/or 'errback'
|
|
* keys, whose values are the corresponding 0-based indexes of the arguments on
|
|
* the function. Negative values are interpreted as being relative to the end
|
|
* of the arguments array.
|
|
*
|
|
* If arguments are given on the call to the 'promisified' function, they are
|
|
* intermingled with the callback and errback. If a promise is given among them,
|
|
* the execution of the function will only occur after its resolution.
|
|
*
|
|
* @example
|
|
* var delay = callbacks.promisify(setTimeout, {
|
|
* callback: 0
|
|
* });
|
|
*
|
|
* delay(100).then(function() {
|
|
* console.log("This happens 100ms afterwards");
|
|
* });
|
|
*
|
|
* @example
|
|
* function callbackAsLast(errback, followsStandards, callback) {
|
|
* if(followsStandards) {
|
|
* callback("well done!");
|
|
* } else {
|
|
* errback("some programmers just want to watch the world burn");
|
|
* }
|
|
* }
|
|
*
|
|
* var promisified = callbacks.promisify(callbackAsLast, {
|
|
* callback: -1,
|
|
* errback: 0,
|
|
* });
|
|
*
|
|
* promisified(true).then(console.log, console.error);
|
|
* promisified(false).then(console.log, console.error);
|
|
*
|
|
* @param {Function} asyncFunction traditional function to be decorated
|
|
* @param {object} positions
|
|
* @param {number} [positions.callback] index at which asyncFunction expects to
|
|
* receive a success callback
|
|
* @param {number} [positions.errback] index at which asyncFunction expects to
|
|
* receive an error callback
|
|
* @returns {function} promisified function that accepts
|
|
*
|
|
* @deprecated
|
|
*/
|
|
function promisify(asyncFunction, positions) {
|
|
|
|
return function() {
|
|
var thisArg = this;
|
|
return Promise.all(arguments).then(function(args) {
|
|
var p = Promise._defer();
|
|
|
|
var callbackPos, errbackPos;
|
|
|
|
if(typeof positions.callback === 'number') {
|
|
callbackPos = normalizePosition(args, positions.callback);
|
|
}
|
|
|
|
if(typeof positions.errback === 'number') {
|
|
errbackPos = normalizePosition(args, positions.errback);
|
|
}
|
|
|
|
if(errbackPos < callbackPos) {
|
|
insertCallback(args, errbackPos, p._handler.reject, p._handler);
|
|
insertCallback(args, callbackPos, p._handler.resolve, p._handler);
|
|
} else {
|
|
insertCallback(args, callbackPos, p._handler.resolve, p._handler);
|
|
insertCallback(args, errbackPos, p._handler.reject, p._handler);
|
|
}
|
|
|
|
asyncFunction.apply(thisArg, args);
|
|
|
|
return p;
|
|
});
|
|
};
|
|
}
|
|
|
|
function normalizePosition(args, pos) {
|
|
return pos < 0 ? (args.length + pos + 2) : pos;
|
|
}
|
|
|
|
function insertCallback(args, pos, callback, thisArg) {
|
|
if(typeof pos === 'number') {
|
|
args.splice(pos, 0, alwaysUnary(callback, thisArg));
|
|
}
|
|
}
|
|
|
|
function alwaysUnary(fn, thisArg) {
|
|
return function() {
|
|
if (arguments.length > 1) {
|
|
fn.call(thisArg, slice.call(arguments));
|
|
} else {
|
|
fn.apply(thisArg, arguments);
|
|
}
|
|
};
|
|
}
|
|
});
|
|
})(typeof define === 'function' && define.amd ? define : function (factory) { module.exports = factory(require); });
|
|
|
|
},{"./lib/apply":11,"./lib/liftAll":23,"./when":32}],3:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright B Cavalier & J Hann */
|
|
|
|
/**
|
|
* cancelable.js
|
|
* @deprecated
|
|
*
|
|
* Decorator that makes a deferred "cancelable". It adds a cancel() method that
|
|
* will call a special cancel handler function and then reject the deferred. The
|
|
* cancel handler can be used to do resource cleanup, or anything else that should
|
|
* be done before any other rejection handlers are executed.
|
|
*
|
|
* Usage:
|
|
*
|
|
* var cancelableDeferred = cancelable(when.defer(), myCancelHandler);
|
|
*
|
|
* @author brian@hovercraftstudios.com
|
|
*/
|
|
|
|
(function(define) {
|
|
define(function() {
|
|
|
|
/**
|
|
* Makes deferred cancelable, adding a cancel() method.
|
|
* @deprecated
|
|
*
|
|
* @param deferred {Deferred} the {@link Deferred} to make cancelable
|
|
* @param canceler {Function} cancel handler function to execute when this deferred
|
|
* is canceled. This is guaranteed to run before all other rejection handlers.
|
|
* The canceler will NOT be executed if the deferred is rejected in the standard
|
|
* way, i.e. deferred.reject(). It ONLY executes if the deferred is canceled,
|
|
* i.e. deferred.cancel()
|
|
*
|
|
* @returns deferred, with an added cancel() method.
|
|
*/
|
|
return function(deferred, canceler) {
|
|
// Add a cancel method to the deferred to reject the delegate
|
|
// with the special canceled indicator.
|
|
deferred.cancel = function() {
|
|
try {
|
|
deferred.reject(canceler(deferred));
|
|
} catch(e) {
|
|
deferred.reject(e);
|
|
}
|
|
|
|
return deferred.promise;
|
|
};
|
|
|
|
return deferred;
|
|
};
|
|
|
|
});
|
|
})(typeof define === 'function' && define.amd ? define : function (factory) { module.exports = factory(); });
|
|
|
|
|
|
|
|
},{}],4:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright 2011-2013 original author or authors */
|
|
|
|
/**
|
|
* delay.js
|
|
*
|
|
* Helper that returns a promise that resolves after a delay.
|
|
*
|
|
* @author Brian Cavalier
|
|
* @author John Hann
|
|
*/
|
|
|
|
(function(define) {
|
|
define(function(require) {
|
|
|
|
var when = require('./when');
|
|
|
|
/**
|
|
* @deprecated Use when(value).delay(ms)
|
|
*/
|
|
return function delay(msec, value) {
|
|
return when(value).delay(msec);
|
|
};
|
|
|
|
});
|
|
})(typeof define === 'function' && define.amd ? define : function (factory) { module.exports = factory(require); });
|
|
|
|
|
|
|
|
},{"./when":32}],5:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright 2013-2014 original author or authors */
|
|
|
|
/**
|
|
* Collection of helper functions for wrapping and executing 'traditional'
|
|
* synchronous functions in a promise interface.
|
|
*
|
|
* @author Brian Cavalier
|
|
* @contributor Renato Zannon
|
|
*/
|
|
|
|
(function(define) {
|
|
define(function(require) {
|
|
|
|
var when = require('./when');
|
|
var attempt = when['try'];
|
|
var _liftAll = require('./lib/liftAll');
|
|
var _apply = require('./lib/apply')(when.Promise);
|
|
var slice = Array.prototype.slice;
|
|
|
|
return {
|
|
lift: lift,
|
|
liftAll: liftAll,
|
|
call: attempt,
|
|
apply: apply,
|
|
compose: compose
|
|
};
|
|
|
|
/**
|
|
* Takes a function and an optional array of arguments (that might be promises),
|
|
* and calls the function. The return value is a promise whose resolution
|
|
* depends on the value returned by the function.
|
|
* @param {function} f function to be called
|
|
* @param {Array} [args] array of arguments to func
|
|
* @returns {Promise} promise for the return value of func
|
|
*/
|
|
function apply(f, args) {
|
|
// slice args just in case the caller passed an Arguments instance
|
|
return _apply(f, this, args == null ? [] : slice.call(args));
|
|
}
|
|
|
|
/**
|
|
* Takes a 'regular' function and returns a version of that function that
|
|
* returns a promise instead of a plain value, and handles thrown errors by
|
|
* returning a rejected promise. Also accepts a list of arguments to be
|
|
* prepended to the new function, as does Function.prototype.bind.
|
|
*
|
|
* The resulting function is promise-aware, in the sense that it accepts
|
|
* promise arguments, and waits for their resolution.
|
|
* @param {Function} f function to be bound
|
|
* @param {...*} [args] arguments to be prepended for the new function @deprecated
|
|
* @returns {Function} a promise-returning function
|
|
*/
|
|
function lift(f /*, args... */) {
|
|
var args = arguments.length > 1 ? slice.call(arguments, 1) : [];
|
|
return function() {
|
|
return _apply(f, this, args.concat(slice.call(arguments)));
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Lift all the functions/methods on src
|
|
* @param {object|function} src source whose functions will be lifted
|
|
* @param {function?} combine optional function for customizing the lifting
|
|
* process. It is passed dst, the lifted function, and the property name of
|
|
* the original function on src.
|
|
* @param {(object|function)?} dst option destination host onto which to place lifted
|
|
* functions. If not provided, liftAll returns a new object.
|
|
* @returns {*} If dst is provided, returns dst with lifted functions as
|
|
* properties. If dst not provided, returns a new object with lifted functions.
|
|
*/
|
|
function liftAll(src, combine, dst) {
|
|
return _liftAll(lift, combine, dst, src);
|
|
}
|
|
|
|
/**
|
|
* Composes multiple functions by piping their return values. It is
|
|
* transparent to whether the functions return 'regular' values or promises:
|
|
* the piped argument is always a resolved value. If one of the functions
|
|
* throws or returns a rejected promise, the composed promise will be also
|
|
* rejected.
|
|
*
|
|
* The arguments (or promises to arguments) given to the returned function (if
|
|
* any), are passed directly to the first function on the 'pipeline'.
|
|
* @param {Function} f the function to which the arguments will be passed
|
|
* @param {...Function} [funcs] functions that will be composed, in order
|
|
* @returns {Function} a promise-returning composition of the functions
|
|
*/
|
|
function compose(f /*, funcs... */) {
|
|
var funcs = slice.call(arguments, 1);
|
|
|
|
return function() {
|
|
var thisArg = this;
|
|
var args = slice.call(arguments);
|
|
var firstPromise = attempt.apply(thisArg, [f].concat(args));
|
|
|
|
return when.reduce(funcs, function(arg, func) {
|
|
return func.call(thisArg, arg);
|
|
}, firstPromise);
|
|
};
|
|
}
|
|
});
|
|
})(typeof define === 'function' && define.amd ? define : function (factory) { module.exports = factory(require); });
|
|
|
|
|
|
|
|
},{"./lib/apply":11,"./lib/liftAll":23,"./when":32}],6:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright 2011-2013 original author or authors */
|
|
|
|
/**
|
|
* Generalized promise concurrency guard
|
|
* Adapted from original concept by Sakari Jokinen (Rocket Pack, Ltd.)
|
|
*
|
|
* @author Brian Cavalier
|
|
* @author John Hann
|
|
* @contributor Sakari Jokinen
|
|
*/
|
|
(function(define) {
|
|
define(function(require) {
|
|
|
|
var when = require('./when');
|
|
var slice = Array.prototype.slice;
|
|
|
|
guard.n = n;
|
|
|
|
return guard;
|
|
|
|
/**
|
|
* Creates a guarded version of f that can only be entered when the supplied
|
|
* condition allows.
|
|
* @param {function} condition represents a critical section that may only
|
|
* be entered when allowed by the condition
|
|
* @param {function} f function to guard
|
|
* @returns {function} guarded version of f
|
|
*/
|
|
function guard(condition, f) {
|
|
return function() {
|
|
var args = slice.call(arguments);
|
|
|
|
return when(condition()).withThis(this).then(function(exit) {
|
|
return when(f.apply(this, args))['finally'](exit);
|
|
});
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Creates a condition that allows only n simultaneous executions
|
|
* of a guarded function
|
|
* @param {number} allowed number of allowed simultaneous executions
|
|
* @returns {function} condition function which returns a promise that
|
|
* fulfills when the critical section may be entered. The fulfillment
|
|
* value is a function ("notifyExit") that must be called when the critical
|
|
* section has been exited.
|
|
*/
|
|
function n(allowed) {
|
|
var count = 0;
|
|
var waiting = [];
|
|
|
|
return function enter() {
|
|
return when.promise(function(resolve) {
|
|
if(count < allowed) {
|
|
resolve(exit);
|
|
} else {
|
|
waiting.push(resolve);
|
|
}
|
|
count += 1;
|
|
});
|
|
};
|
|
|
|
function exit() {
|
|
count = Math.max(count - 1, 0);
|
|
if(waiting.length > 0) {
|
|
waiting.shift()(exit);
|
|
}
|
|
}
|
|
}
|
|
|
|
});
|
|
}(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(require); }));
|
|
|
|
},{"./when":32}],7:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright 2011-2013 original author or authors */
|
|
|
|
/**
|
|
* Licensed under the MIT License at:
|
|
* http://www.opensource.org/licenses/mit-license.php
|
|
*
|
|
* @author Brian Cavalier
|
|
* @author John Hann
|
|
*/
|
|
(function(define) { 'use strict';
|
|
define(function(require) {
|
|
|
|
var when = require('./when');
|
|
var Promise = when.Promise;
|
|
var toPromise = when.resolve;
|
|
|
|
return {
|
|
all: when.lift(all),
|
|
map: map,
|
|
settle: settle
|
|
};
|
|
|
|
/**
|
|
* Resolve all the key-value pairs in the supplied object or promise
|
|
* for an object.
|
|
* @param {Promise|object} object or promise for object whose key-value pairs
|
|
* will be resolved
|
|
* @returns {Promise} promise for an object with the fully resolved key-value pairs
|
|
*/
|
|
function all(object) {
|
|
var p = Promise._defer();
|
|
var resolver = Promise._handler(p);
|
|
|
|
var results = {};
|
|
var keys = Object.keys(object);
|
|
var pending = keys.length;
|
|
|
|
for(var i=0, k; i<keys.length; ++i) {
|
|
k = keys[i];
|
|
Promise._handler(object[k]).fold(settleKey, k, results, resolver);
|
|
}
|
|
|
|
if(pending === 0) {
|
|
resolver.resolve(results);
|
|
}
|
|
|
|
return p;
|
|
|
|
function settleKey(k, x, resolver) {
|
|
/*jshint validthis:true*/
|
|
this[k] = x;
|
|
if(--pending === 0) {
|
|
resolver.resolve(results);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Map values in the supplied object's keys
|
|
* @param {Promise|object} object or promise for object whose key-value pairs
|
|
* will be reduced
|
|
* @param {function(value:*, key:String):*} f mapping function which may
|
|
* return either a promise or a value
|
|
* @returns {Promise} promise for an object with the mapped and fully
|
|
* resolved key-value pairs
|
|
*/
|
|
function map(object, f) {
|
|
return toPromise(object).then(function(object) {
|
|
return all(Object.keys(object).reduce(function(o, k) {
|
|
o[k] = toPromise(object[k]).fold(mapWithKey, k);
|
|
return o;
|
|
}, {}));
|
|
});
|
|
|
|
function mapWithKey(k, x) {
|
|
return f(x, k);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Resolve all key-value pairs in the supplied object and return a promise
|
|
* that will always fulfill with the outcome states of all input promises.
|
|
* @param {object} object whose key-value pairs will be settled
|
|
* @returns {Promise} promise for an object with the mapped and fully
|
|
* settled key-value pairs
|
|
*/
|
|
function settle(object) {
|
|
var keys = Object.keys(object);
|
|
var results = {};
|
|
|
|
if(keys.length === 0) {
|
|
return toPromise(results);
|
|
}
|
|
|
|
var p = Promise._defer();
|
|
var resolver = Promise._handler(p);
|
|
var promises = keys.map(function(k) { return object[k]; });
|
|
|
|
when.settle(promises).then(function(states) {
|
|
populateResults(keys, states, results, resolver);
|
|
});
|
|
|
|
return p;
|
|
}
|
|
|
|
function populateResults(keys, states, results, resolver) {
|
|
for(var i=0; i<keys.length; i++) {
|
|
results[keys[i]] = states[i];
|
|
}
|
|
resolver.resolve(results);
|
|
}
|
|
|
|
});
|
|
})(typeof define === 'function' && define.amd ? define : function (factory) { module.exports = factory(require); });
|
|
|
|
},{"./when":32}],8:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright 2010-2014 original author or authors */
|
|
/** @author Brian Cavalier */
|
|
/** @author John Hann */
|
|
|
|
(function(define) { 'use strict';
|
|
define(function (require) {
|
|
|
|
var makePromise = require('./makePromise');
|
|
var Scheduler = require('./Scheduler');
|
|
var async = require('./env').asap;
|
|
|
|
return makePromise({
|
|
scheduler: new Scheduler(async)
|
|
});
|
|
|
|
});
|
|
})(typeof define === 'function' && define.amd ? define : function (factory) { module.exports = factory(require); });
|
|
|
|
},{"./Scheduler":9,"./env":21,"./makePromise":24}],9:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright 2010-2014 original author or authors */
|
|
/** @author Brian Cavalier */
|
|
/** @author John Hann */
|
|
|
|
(function(define) { 'use strict';
|
|
define(function() {
|
|
|
|
// Credit to Twisol (https://github.com/Twisol) for suggesting
|
|
// this type of extensible queue + trampoline approach for next-tick conflation.
|
|
|
|
/**
|
|
* Async task scheduler
|
|
* @param {function} async function to schedule a single async function
|
|
* @constructor
|
|
*/
|
|
function Scheduler(async) {
|
|
this._async = async;
|
|
this._running = false;
|
|
|
|
this._queue = this;
|
|
this._queueLen = 0;
|
|
this._afterQueue = {};
|
|
this._afterQueueLen = 0;
|
|
|
|
var self = this;
|
|
this.drain = function() {
|
|
self._drain();
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Enqueue a task
|
|
* @param {{ run:function }} task
|
|
*/
|
|
Scheduler.prototype.enqueue = function(task) {
|
|
this._queue[this._queueLen++] = task;
|
|
this.run();
|
|
};
|
|
|
|
/**
|
|
* Enqueue a task to run after the main task queue
|
|
* @param {{ run:function }} task
|
|
*/
|
|
Scheduler.prototype.afterQueue = function(task) {
|
|
this._afterQueue[this._afterQueueLen++] = task;
|
|
this.run();
|
|
};
|
|
|
|
Scheduler.prototype.run = function() {
|
|
if (!this._running) {
|
|
this._running = true;
|
|
this._async(this.drain);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Drain the handler queue entirely, and then the after queue
|
|
*/
|
|
Scheduler.prototype._drain = function() {
|
|
var i = 0;
|
|
for (; i < this._queueLen; ++i) {
|
|
this._queue[i].run();
|
|
this._queue[i] = void 0;
|
|
}
|
|
|
|
this._queueLen = 0;
|
|
this._running = false;
|
|
|
|
for (i = 0; i < this._afterQueueLen; ++i) {
|
|
this._afterQueue[i].run();
|
|
this._afterQueue[i] = void 0;
|
|
}
|
|
|
|
this._afterQueueLen = 0;
|
|
};
|
|
|
|
return Scheduler;
|
|
|
|
});
|
|
}(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(); }));
|
|
|
|
},{}],10:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright 2010-2014 original author or authors */
|
|
/** @author Brian Cavalier */
|
|
/** @author John Hann */
|
|
|
|
(function(define) { 'use strict';
|
|
define(function() {
|
|
|
|
/**
|
|
* Custom error type for promises rejected by promise.timeout
|
|
* @param {string} message
|
|
* @constructor
|
|
*/
|
|
function TimeoutError (message) {
|
|
Error.call(this);
|
|
this.message = message;
|
|
this.name = TimeoutError.name;
|
|
if (typeof Error.captureStackTrace === 'function') {
|
|
Error.captureStackTrace(this, TimeoutError);
|
|
}
|
|
}
|
|
|
|
TimeoutError.prototype = Object.create(Error.prototype);
|
|
TimeoutError.prototype.constructor = TimeoutError;
|
|
|
|
return TimeoutError;
|
|
});
|
|
}(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(); }));
|
|
},{}],11:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright 2010-2014 original author or authors */
|
|
/** @author Brian Cavalier */
|
|
/** @author John Hann */
|
|
|
|
(function(define) { 'use strict';
|
|
define(function() {
|
|
|
|
makeApply.tryCatchResolve = tryCatchResolve;
|
|
|
|
return makeApply;
|
|
|
|
function makeApply(Promise, call) {
|
|
if(arguments.length < 2) {
|
|
call = tryCatchResolve;
|
|
}
|
|
|
|
return apply;
|
|
|
|
function apply(f, thisArg, args) {
|
|
var p = Promise._defer();
|
|
var l = args.length;
|
|
var params = new Array(l);
|
|
callAndResolve({ f:f, thisArg:thisArg, args:args, params:params, i:l-1, call:call }, p._handler);
|
|
|
|
return p;
|
|
}
|
|
|
|
function callAndResolve(c, h) {
|
|
if(c.i < 0) {
|
|
return call(c.f, c.thisArg, c.params, h);
|
|
}
|
|
|
|
var handler = Promise._handler(c.args[c.i]);
|
|
handler.fold(callAndResolveNext, c, void 0, h);
|
|
}
|
|
|
|
function callAndResolveNext(c, x, h) {
|
|
c.params[c.i] = x;
|
|
c.i -= 1;
|
|
callAndResolve(c, h);
|
|
}
|
|
}
|
|
|
|
function tryCatchResolve(f, thisArg, args, resolver) {
|
|
try {
|
|
resolver.resolve(f.apply(thisArg, args));
|
|
} catch(e) {
|
|
resolver.reject(e);
|
|
}
|
|
}
|
|
|
|
});
|
|
}(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(); }));
|
|
|
|
|
|
|
|
},{}],12:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright 2010-2014 original author or authors */
|
|
/** @author Brian Cavalier */
|
|
/** @author John Hann */
|
|
|
|
(function(define) { 'use strict';
|
|
define(function(require) {
|
|
|
|
var state = require('../state');
|
|
var applier = require('../apply');
|
|
|
|
return function array(Promise) {
|
|
|
|
var applyFold = applier(Promise);
|
|
var toPromise = Promise.resolve;
|
|
var all = Promise.all;
|
|
|
|
var ar = Array.prototype.reduce;
|
|
var arr = Array.prototype.reduceRight;
|
|
var slice = Array.prototype.slice;
|
|
|
|
// Additional array combinators
|
|
|
|
Promise.any = any;
|
|
Promise.some = some;
|
|
Promise.settle = settle;
|
|
|
|
Promise.map = map;
|
|
Promise.filter = filter;
|
|
Promise.reduce = reduce;
|
|
Promise.reduceRight = reduceRight;
|
|
|
|
/**
|
|
* When this promise fulfills with an array, do
|
|
* onFulfilled.apply(void 0, array)
|
|
* @param {function} onFulfilled function to apply
|
|
* @returns {Promise} promise for the result of applying onFulfilled
|
|
*/
|
|
Promise.prototype.spread = function(onFulfilled) {
|
|
return this.then(all).then(function(array) {
|
|
return onFulfilled.apply(this, array);
|
|
});
|
|
};
|
|
|
|
return Promise;
|
|
|
|
/**
|
|
* One-winner competitive race.
|
|
* Return a promise that will fulfill when one of the promises
|
|
* in the input array fulfills, or will reject when all promises
|
|
* have rejected.
|
|
* @param {array} promises
|
|
* @returns {Promise} promise for the first fulfilled value
|
|
*/
|
|
function any(promises) {
|
|
var p = Promise._defer();
|
|
var resolver = p._handler;
|
|
var l = promises.length>>>0;
|
|
|
|
var pending = l;
|
|
var errors = [];
|
|
|
|
for (var h, x, i = 0; i < l; ++i) {
|
|
x = promises[i];
|
|
if(x === void 0 && !(i in promises)) {
|
|
--pending;
|
|
continue;
|
|
}
|
|
|
|
h = Promise._handler(x);
|
|
if(h.state() > 0) {
|
|
resolver.become(h);
|
|
Promise._visitRemaining(promises, i, h);
|
|
break;
|
|
} else {
|
|
h.visit(resolver, handleFulfill, handleReject);
|
|
}
|
|
}
|
|
|
|
if(pending === 0) {
|
|
resolver.reject(new RangeError('any(): array must not be empty'));
|
|
}
|
|
|
|
return p;
|
|
|
|
function handleFulfill(x) {
|
|
/*jshint validthis:true*/
|
|
errors = null;
|
|
this.resolve(x); // this === resolver
|
|
}
|
|
|
|
function handleReject(e) {
|
|
/*jshint validthis:true*/
|
|
if(this.resolved) { // this === resolver
|
|
return;
|
|
}
|
|
|
|
errors.push(e);
|
|
if(--pending === 0) {
|
|
this.reject(errors);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* N-winner competitive race
|
|
* Return a promise that will fulfill when n input promises have
|
|
* fulfilled, or will reject when it becomes impossible for n
|
|
* input promises to fulfill (ie when promises.length - n + 1
|
|
* have rejected)
|
|
* @param {array} promises
|
|
* @param {number} n
|
|
* @returns {Promise} promise for the earliest n fulfillment values
|
|
*
|
|
* @deprecated
|
|
*/
|
|
function some(promises, n) {
|
|
/*jshint maxcomplexity:7*/
|
|
var p = Promise._defer();
|
|
var resolver = p._handler;
|
|
|
|
var results = [];
|
|
var errors = [];
|
|
|
|
var l = promises.length>>>0;
|
|
var nFulfill = 0;
|
|
var nReject;
|
|
var x, i; // reused in both for() loops
|
|
|
|
// First pass: count actual array items
|
|
for(i=0; i<l; ++i) {
|
|
x = promises[i];
|
|
if(x === void 0 && !(i in promises)) {
|
|
continue;
|
|
}
|
|
++nFulfill;
|
|
}
|
|
|
|
// Compute actual goals
|
|
n = Math.max(n, 0);
|
|
nReject = (nFulfill - n + 1);
|
|
nFulfill = Math.min(n, nFulfill);
|
|
|
|
if(n > nFulfill) {
|
|
resolver.reject(new RangeError('some(): array must contain at least '
|
|
+ n + ' item(s), but had ' + nFulfill));
|
|
} else if(nFulfill === 0) {
|
|
resolver.resolve(results);
|
|
}
|
|
|
|
// Second pass: observe each array item, make progress toward goals
|
|
for(i=0; i<l; ++i) {
|
|
x = promises[i];
|
|
if(x === void 0 && !(i in promises)) {
|
|
continue;
|
|
}
|
|
|
|
Promise._handler(x).visit(resolver, fulfill, reject, resolver.notify);
|
|
}
|
|
|
|
return p;
|
|
|
|
function fulfill(x) {
|
|
/*jshint validthis:true*/
|
|
if(this.resolved) { // this === resolver
|
|
return;
|
|
}
|
|
|
|
results.push(x);
|
|
if(--nFulfill === 0) {
|
|
errors = null;
|
|
this.resolve(results);
|
|
}
|
|
}
|
|
|
|
function reject(e) {
|
|
/*jshint validthis:true*/
|
|
if(this.resolved) { // this === resolver
|
|
return;
|
|
}
|
|
|
|
errors.push(e);
|
|
if(--nReject === 0) {
|
|
results = null;
|
|
this.reject(errors);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Apply f to the value of each promise in a list of promises
|
|
* and return a new list containing the results.
|
|
* @param {array} promises
|
|
* @param {function(x:*, index:Number):*} f mapping function
|
|
* @returns {Promise}
|
|
*/
|
|
function map(promises, f) {
|
|
return Promise._traverse(f, promises);
|
|
}
|
|
|
|
/**
|
|
* Filter the provided array of promises using the provided predicate. Input may
|
|
* contain promises and values
|
|
* @param {Array} promises array of promises and values
|
|
* @param {function(x:*, index:Number):boolean} predicate filtering predicate.
|
|
* Must return truthy (or promise for truthy) for items to retain.
|
|
* @returns {Promise} promise that will fulfill with an array containing all items
|
|
* for which predicate returned truthy.
|
|
*/
|
|
function filter(promises, predicate) {
|
|
var a = slice.call(promises);
|
|
return Promise._traverse(predicate, a).then(function(keep) {
|
|
return filterSync(a, keep);
|
|
});
|
|
}
|
|
|
|
function filterSync(promises, keep) {
|
|
// Safe because we know all promises have fulfilled if we've made it this far
|
|
var l = keep.length;
|
|
var filtered = new Array(l);
|
|
for(var i=0, j=0; i<l; ++i) {
|
|
if(keep[i]) {
|
|
filtered[j++] = Promise._handler(promises[i]).value;
|
|
}
|
|
}
|
|
filtered.length = j;
|
|
return filtered;
|
|
|
|
}
|
|
|
|
/**
|
|
* Return a promise that will always fulfill with an array containing
|
|
* the outcome states of all input promises. The returned promise
|
|
* will never reject.
|
|
* @param {Array} promises
|
|
* @returns {Promise} promise for array of settled state descriptors
|
|
*/
|
|
function settle(promises) {
|
|
return all(promises.map(settleOne));
|
|
}
|
|
|
|
function settleOne(p) {
|
|
// Optimize the case where we get an already-resolved when.js promise
|
|
// by extracting its state:
|
|
var handler;
|
|
if (p instanceof Promise) {
|
|
// This is our own Promise type and we can reach its handler internals:
|
|
handler = p._handler.join();
|
|
}
|
|
if((handler && handler.state() === 0) || !handler) {
|
|
// Either still pending, or not a Promise at all:
|
|
return toPromise(p).then(state.fulfilled, state.rejected);
|
|
}
|
|
|
|
// The promise is our own, but it is already resolved. Take a shortcut.
|
|
// Since we're not actually handling the resolution, we need to disable
|
|
// rejection reporting.
|
|
handler._unreport();
|
|
return state.inspect(handler);
|
|
}
|
|
|
|
/**
|
|
* Traditional reduce function, similar to `Array.prototype.reduce()`, but
|
|
* input may contain promises and/or values, and reduceFunc
|
|
* may return either a value or a promise, *and* initialValue may
|
|
* be a promise for the starting value.
|
|
* @param {Array|Promise} promises array or promise for an array of anything,
|
|
* may contain a mix of promises and values.
|
|
* @param {function(accumulated:*, x:*, index:Number):*} f reduce function
|
|
* @returns {Promise} that will resolve to the final reduced value
|
|
*/
|
|
function reduce(promises, f /*, initialValue */) {
|
|
return arguments.length > 2 ? ar.call(promises, liftCombine(f), arguments[2])
|
|
: ar.call(promises, liftCombine(f));
|
|
}
|
|
|
|
/**
|
|
* Traditional reduce function, similar to `Array.prototype.reduceRight()`, but
|
|
* input may contain promises and/or values, and reduceFunc
|
|
* may return either a value or a promise, *and* initialValue may
|
|
* be a promise for the starting value.
|
|
* @param {Array|Promise} promises array or promise for an array of anything,
|
|
* may contain a mix of promises and values.
|
|
* @param {function(accumulated:*, x:*, index:Number):*} f reduce function
|
|
* @returns {Promise} that will resolve to the final reduced value
|
|
*/
|
|
function reduceRight(promises, f /*, initialValue */) {
|
|
return arguments.length > 2 ? arr.call(promises, liftCombine(f), arguments[2])
|
|
: arr.call(promises, liftCombine(f));
|
|
}
|
|
|
|
function liftCombine(f) {
|
|
return function(z, x, i) {
|
|
return applyFold(f, void 0, [z,x,i]);
|
|
};
|
|
}
|
|
};
|
|
|
|
});
|
|
}(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(require); }));
|
|
|
|
},{"../apply":11,"../state":25}],13:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright 2010-2014 original author or authors */
|
|
/** @author Brian Cavalier */
|
|
/** @author John Hann */
|
|
|
|
(function(define) { 'use strict';
|
|
define(function() {
|
|
|
|
return function flow(Promise) {
|
|
|
|
var resolve = Promise.resolve;
|
|
var reject = Promise.reject;
|
|
var origCatch = Promise.prototype['catch'];
|
|
|
|
/**
|
|
* Handle the ultimate fulfillment value or rejection reason, and assume
|
|
* responsibility for all errors. If an error propagates out of result
|
|
* or handleFatalError, it will be rethrown to the host, resulting in a
|
|
* loud stack track on most platforms and a crash on some.
|
|
* @param {function?} onResult
|
|
* @param {function?} onError
|
|
* @returns {undefined}
|
|
*/
|
|
Promise.prototype.done = function(onResult, onError) {
|
|
this._handler.visit(this._handler.receiver, onResult, onError);
|
|
};
|
|
|
|
/**
|
|
* Add Error-type and predicate matching to catch. Examples:
|
|
* promise.catch(TypeError, handleTypeError)
|
|
* .catch(predicate, handleMatchedErrors)
|
|
* .catch(handleRemainingErrors)
|
|
* @param onRejected
|
|
* @returns {*}
|
|
*/
|
|
Promise.prototype['catch'] = Promise.prototype.otherwise = function(onRejected) {
|
|
if (arguments.length < 2) {
|
|
return origCatch.call(this, onRejected);
|
|
}
|
|
|
|
if(typeof onRejected !== 'function') {
|
|
return this.ensure(rejectInvalidPredicate);
|
|
}
|
|
|
|
return origCatch.call(this, createCatchFilter(arguments[1], onRejected));
|
|
};
|
|
|
|
/**
|
|
* Wraps the provided catch handler, so that it will only be called
|
|
* if the predicate evaluates truthy
|
|
* @param {?function} handler
|
|
* @param {function} predicate
|
|
* @returns {function} conditional catch handler
|
|
*/
|
|
function createCatchFilter(handler, predicate) {
|
|
return function(e) {
|
|
return evaluatePredicate(e, predicate)
|
|
? handler.call(this, e)
|
|
: reject(e);
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Ensures that onFulfilledOrRejected will be called regardless of whether
|
|
* this promise is fulfilled or rejected. onFulfilledOrRejected WILL NOT
|
|
* receive the promises' value or reason. Any returned value will be disregarded.
|
|
* onFulfilledOrRejected may throw or return a rejected promise to signal
|
|
* an additional error.
|
|
* @param {function} handler handler to be called regardless of
|
|
* fulfillment or rejection
|
|
* @returns {Promise}
|
|
*/
|
|
Promise.prototype['finally'] = Promise.prototype.ensure = function(handler) {
|
|
if(typeof handler !== 'function') {
|
|
return this;
|
|
}
|
|
|
|
return this.then(function(x) {
|
|
return runSideEffect(handler, this, identity, x);
|
|
}, function(e) {
|
|
return runSideEffect(handler, this, reject, e);
|
|
});
|
|
};
|
|
|
|
function runSideEffect (handler, thisArg, propagate, value) {
|
|
var result = handler.call(thisArg);
|
|
return maybeThenable(result)
|
|
? propagateValue(result, propagate, value)
|
|
: propagate(value);
|
|
}
|
|
|
|
function propagateValue (result, propagate, x) {
|
|
return resolve(result).then(function () {
|
|
return propagate(x);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Recover from a failure by returning a defaultValue. If defaultValue
|
|
* is a promise, it's fulfillment value will be used. If defaultValue is
|
|
* a promise that rejects, the returned promise will reject with the
|
|
* same reason.
|
|
* @param {*} defaultValue
|
|
* @returns {Promise} new promise
|
|
*/
|
|
Promise.prototype['else'] = Promise.prototype.orElse = function(defaultValue) {
|
|
return this.then(void 0, function() {
|
|
return defaultValue;
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Shortcut for .then(function() { return value; })
|
|
* @param {*} value
|
|
* @return {Promise} a promise that:
|
|
* - is fulfilled if value is not a promise, or
|
|
* - if value is a promise, will fulfill with its value, or reject
|
|
* with its reason.
|
|
*/
|
|
Promise.prototype['yield'] = function(value) {
|
|
return this.then(function() {
|
|
return value;
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Runs a side effect when this promise fulfills, without changing the
|
|
* fulfillment value.
|
|
* @param {function} onFulfilledSideEffect
|
|
* @returns {Promise}
|
|
*/
|
|
Promise.prototype.tap = function(onFulfilledSideEffect) {
|
|
return this.then(onFulfilledSideEffect)['yield'](this);
|
|
};
|
|
|
|
return Promise;
|
|
};
|
|
|
|
function rejectInvalidPredicate() {
|
|
throw new TypeError('catch predicate must be a function');
|
|
}
|
|
|
|
function evaluatePredicate(e, predicate) {
|
|
return isError(predicate) ? e instanceof predicate : predicate(e);
|
|
}
|
|
|
|
function isError(predicate) {
|
|
return predicate === Error
|
|
|| (predicate != null && predicate.prototype instanceof Error);
|
|
}
|
|
|
|
function maybeThenable(x) {
|
|
return (typeof x === 'object' || typeof x === 'function') && x !== null;
|
|
}
|
|
|
|
function identity(x) {
|
|
return x;
|
|
}
|
|
|
|
});
|
|
}(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(); }));
|
|
|
|
},{}],14:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright 2010-2014 original author or authors */
|
|
/** @author Brian Cavalier */
|
|
/** @author John Hann */
|
|
/** @author Jeff Escalante */
|
|
|
|
(function(define) { 'use strict';
|
|
define(function() {
|
|
|
|
return function fold(Promise) {
|
|
|
|
Promise.prototype.fold = function(f, z) {
|
|
var promise = this._beget();
|
|
|
|
this._handler.fold(function(z, x, to) {
|
|
Promise._handler(z).fold(function(x, z, to) {
|
|
to.resolve(f.call(this, z, x));
|
|
}, x, this, to);
|
|
}, z, promise._handler.receiver, promise._handler);
|
|
|
|
return promise;
|
|
};
|
|
|
|
return Promise;
|
|
};
|
|
|
|
});
|
|
}(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(); }));
|
|
|
|
},{}],15:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright 2010-2014 original author or authors */
|
|
/** @author Brian Cavalier */
|
|
/** @author John Hann */
|
|
|
|
(function(define) { 'use strict';
|
|
define(function(require) {
|
|
|
|
var inspect = require('../state').inspect;
|
|
|
|
return function inspection(Promise) {
|
|
|
|
Promise.prototype.inspect = function() {
|
|
return inspect(Promise._handler(this));
|
|
};
|
|
|
|
return Promise;
|
|
};
|
|
|
|
});
|
|
}(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(require); }));
|
|
|
|
},{"../state":25}],16:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright 2010-2014 original author or authors */
|
|
/** @author Brian Cavalier */
|
|
/** @author John Hann */
|
|
|
|
(function(define) { 'use strict';
|
|
define(function() {
|
|
|
|
return function generate(Promise) {
|
|
|
|
var resolve = Promise.resolve;
|
|
|
|
Promise.iterate = iterate;
|
|
Promise.unfold = unfold;
|
|
|
|
return Promise;
|
|
|
|
/**
|
|
* @deprecated Use github.com/cujojs/most streams and most.iterate
|
|
* Generate a (potentially infinite) stream of promised values:
|
|
* x, f(x), f(f(x)), etc. until condition(x) returns true
|
|
* @param {function} f function to generate a new x from the previous x
|
|
* @param {function} condition function that, given the current x, returns
|
|
* truthy when the iterate should stop
|
|
* @param {function} handler function to handle the value produced by f
|
|
* @param {*|Promise} x starting value, may be a promise
|
|
* @return {Promise} the result of the last call to f before
|
|
* condition returns true
|
|
*/
|
|
function iterate(f, condition, handler, x) {
|
|
return unfold(function(x) {
|
|
return [x, f(x)];
|
|
}, condition, handler, x);
|
|
}
|
|
|
|
/**
|
|
* @deprecated Use github.com/cujojs/most streams and most.unfold
|
|
* Generate a (potentially infinite) stream of promised values
|
|
* by applying handler(generator(seed)) iteratively until
|
|
* condition(seed) returns true.
|
|
* @param {function} unspool function that generates a [value, newSeed]
|
|
* given a seed.
|
|
* @param {function} condition function that, given the current seed, returns
|
|
* truthy when the unfold should stop
|
|
* @param {function} handler function to handle the value produced by unspool
|
|
* @param x {*|Promise} starting value, may be a promise
|
|
* @return {Promise} the result of the last value produced by unspool before
|
|
* condition returns true
|
|
*/
|
|
function unfold(unspool, condition, handler, x) {
|
|
return resolve(x).then(function(seed) {
|
|
return resolve(condition(seed)).then(function(done) {
|
|
return done ? seed : resolve(unspool(seed)).spread(next);
|
|
});
|
|
});
|
|
|
|
function next(item, newSeed) {
|
|
return resolve(handler(item)).then(function() {
|
|
return unfold(unspool, condition, handler, newSeed);
|
|
});
|
|
}
|
|
}
|
|
};
|
|
|
|
});
|
|
}(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(); }));
|
|
|
|
},{}],17:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright 2010-2014 original author or authors */
|
|
/** @author Brian Cavalier */
|
|
/** @author John Hann */
|
|
|
|
(function(define) { 'use strict';
|
|
define(function() {
|
|
|
|
return function progress(Promise) {
|
|
|
|
/**
|
|
* @deprecated
|
|
* Register a progress handler for this promise
|
|
* @param {function} onProgress
|
|
* @returns {Promise}
|
|
*/
|
|
Promise.prototype.progress = function(onProgress) {
|
|
return this.then(void 0, void 0, onProgress);
|
|
};
|
|
|
|
return Promise;
|
|
};
|
|
|
|
});
|
|
}(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(); }));
|
|
|
|
},{}],18:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright 2010-2014 original author or authors */
|
|
/** @author Brian Cavalier */
|
|
/** @author John Hann */
|
|
|
|
(function(define) { 'use strict';
|
|
define(function(require) {
|
|
|
|
var env = require('../env');
|
|
var TimeoutError = require('../TimeoutError');
|
|
|
|
function setTimeout(f, ms, x, y) {
|
|
return env.setTimer(function() {
|
|
f(x, y, ms);
|
|
}, ms);
|
|
}
|
|
|
|
return function timed(Promise) {
|
|
/**
|
|
* Return a new promise whose fulfillment value is revealed only
|
|
* after ms milliseconds
|
|
* @param {number} ms milliseconds
|
|
* @returns {Promise}
|
|
*/
|
|
Promise.prototype.delay = function(ms) {
|
|
var p = this._beget();
|
|
this._handler.fold(handleDelay, ms, void 0, p._handler);
|
|
return p;
|
|
};
|
|
|
|
function handleDelay(ms, x, h) {
|
|
setTimeout(resolveDelay, ms, x, h);
|
|
}
|
|
|
|
function resolveDelay(x, h) {
|
|
h.resolve(x);
|
|
}
|
|
|
|
/**
|
|
* Return a new promise that rejects after ms milliseconds unless
|
|
* this promise fulfills earlier, in which case the returned promise
|
|
* fulfills with the same value.
|
|
* @param {number} ms milliseconds
|
|
* @param {Error|*=} reason optional rejection reason to use, defaults
|
|
* to a TimeoutError if not provided
|
|
* @returns {Promise}
|
|
*/
|
|
Promise.prototype.timeout = function(ms, reason) {
|
|
var p = this._beget();
|
|
var h = p._handler;
|
|
|
|
var t = setTimeout(onTimeout, ms, reason, p._handler);
|
|
|
|
this._handler.visit(h,
|
|
function onFulfill(x) {
|
|
env.clearTimer(t);
|
|
this.resolve(x); // this = h
|
|
},
|
|
function onReject(x) {
|
|
env.clearTimer(t);
|
|
this.reject(x); // this = h
|
|
},
|
|
h.notify);
|
|
|
|
return p;
|
|
};
|
|
|
|
function onTimeout(reason, h, ms) {
|
|
var e = typeof reason === 'undefined'
|
|
? new TimeoutError('timed out after ' + ms + 'ms')
|
|
: reason;
|
|
h.reject(e);
|
|
}
|
|
|
|
return Promise;
|
|
};
|
|
|
|
});
|
|
}(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(require); }));
|
|
|
|
},{"../TimeoutError":10,"../env":21}],19:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright 2010-2014 original author or authors */
|
|
/** @author Brian Cavalier */
|
|
/** @author John Hann */
|
|
|
|
(function(define) { 'use strict';
|
|
define(function(require) {
|
|
|
|
var setTimer = require('../env').setTimer;
|
|
var format = require('../format');
|
|
|
|
return function unhandledRejection(Promise) {
|
|
|
|
var logError = noop;
|
|
var logInfo = noop;
|
|
var localConsole;
|
|
|
|
if(typeof console !== 'undefined') {
|
|
// Alias console to prevent things like uglify's drop_console option from
|
|
// removing console.log/error. Unhandled rejections fall into the same
|
|
// category as uncaught exceptions, and build tools shouldn't silence them.
|
|
localConsole = console;
|
|
logError = typeof localConsole.error !== 'undefined'
|
|
? function (e) { localConsole.error(e); }
|
|
: function (e) { localConsole.log(e); };
|
|
|
|
logInfo = typeof localConsole.info !== 'undefined'
|
|
? function (e) { localConsole.info(e); }
|
|
: function (e) { localConsole.log(e); };
|
|
}
|
|
|
|
Promise.onPotentiallyUnhandledRejection = function(rejection) {
|
|
enqueue(report, rejection);
|
|
};
|
|
|
|
Promise.onPotentiallyUnhandledRejectionHandled = function(rejection) {
|
|
enqueue(unreport, rejection);
|
|
};
|
|
|
|
Promise.onFatalRejection = function(rejection) {
|
|
enqueue(throwit, rejection.value);
|
|
};
|
|
|
|
var tasks = [];
|
|
var reported = [];
|
|
var running = null;
|
|
|
|
function report(r) {
|
|
if(!r.handled) {
|
|
reported.push(r);
|
|
logError('Potentially unhandled rejection [' + r.id + '] ' + format.formatError(r.value));
|
|
}
|
|
}
|
|
|
|
function unreport(r) {
|
|
var i = reported.indexOf(r);
|
|
if(i >= 0) {
|
|
reported.splice(i, 1);
|
|
logInfo('Handled previous rejection [' + r.id + '] ' + format.formatObject(r.value));
|
|
}
|
|
}
|
|
|
|
function enqueue(f, x) {
|
|
tasks.push(f, x);
|
|
if(running === null) {
|
|
running = setTimer(flush, 0);
|
|
}
|
|
}
|
|
|
|
function flush() {
|
|
running = null;
|
|
while(tasks.length > 0) {
|
|
tasks.shift()(tasks.shift());
|
|
}
|
|
}
|
|
|
|
return Promise;
|
|
};
|
|
|
|
function throwit(e) {
|
|
throw e;
|
|
}
|
|
|
|
function noop() {}
|
|
|
|
});
|
|
}(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(require); }));
|
|
|
|
},{"../env":21,"../format":22}],20:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright 2010-2014 original author or authors */
|
|
/** @author Brian Cavalier */
|
|
/** @author John Hann */
|
|
|
|
(function(define) { 'use strict';
|
|
define(function() {
|
|
|
|
return function addWith(Promise) {
|
|
/**
|
|
* Returns a promise whose handlers will be called with `this` set to
|
|
* the supplied receiver. Subsequent promises derived from the
|
|
* returned promise will also have their handlers called with receiver
|
|
* as `this`. Calling `with` with undefined or no arguments will return
|
|
* a promise whose handlers will again be called in the usual Promises/A+
|
|
* way (no `this`) thus safely undoing any previous `with` in the
|
|
* promise chain.
|
|
*
|
|
* WARNING: Promises returned from `with`/`withThis` are NOT Promises/A+
|
|
* compliant, specifically violating 2.2.5 (http://promisesaplus.com/#point-41)
|
|
*
|
|
* @param {object} receiver `this` value for all handlers attached to
|
|
* the returned promise.
|
|
* @returns {Promise}
|
|
*/
|
|
Promise.prototype['with'] = Promise.prototype.withThis = function(receiver) {
|
|
var p = this._beget();
|
|
var child = p._handler;
|
|
child.receiver = receiver;
|
|
this._handler.chain(child, receiver);
|
|
return p;
|
|
};
|
|
|
|
return Promise;
|
|
};
|
|
|
|
});
|
|
}(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(); }));
|
|
|
|
|
|
},{}],21:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright 2010-2014 original author or authors */
|
|
/** @author Brian Cavalier */
|
|
/** @author John Hann */
|
|
|
|
/*global process,document,setTimeout,clearTimeout,MutationObserver,WebKitMutationObserver*/
|
|
(function(define) { 'use strict';
|
|
define(function(require) {
|
|
/*jshint maxcomplexity:6*/
|
|
|
|
// Sniff "best" async scheduling option
|
|
// Prefer process.nextTick or MutationObserver, then check for
|
|
// setTimeout, and finally vertx, since its the only env that doesn't
|
|
// have setTimeout
|
|
|
|
var MutationObs;
|
|
var capturedSetTimeout = typeof setTimeout !== 'undefined' && setTimeout;
|
|
|
|
// Default env
|
|
var setTimer = function(f, ms) { return setTimeout(f, ms); };
|
|
var clearTimer = function(t) { return clearTimeout(t); };
|
|
var asap = function (f) { return capturedSetTimeout(f, 0); };
|
|
|
|
// Detect specific env
|
|
if (isNode()) { // Node
|
|
asap = function (f) { return process.nextTick(f); };
|
|
|
|
} else if (MutationObs = hasMutationObserver()) { // Modern browser
|
|
asap = initMutationObserver(MutationObs);
|
|
|
|
} else if (!capturedSetTimeout) { // vert.x
|
|
var vertxRequire = require;
|
|
var vertx = vertxRequire('vertx');
|
|
setTimer = function (f, ms) { return vertx.setTimer(ms, f); };
|
|
clearTimer = vertx.cancelTimer;
|
|
asap = vertx.runOnLoop || vertx.runOnContext;
|
|
}
|
|
|
|
return {
|
|
setTimer: setTimer,
|
|
clearTimer: clearTimer,
|
|
asap: asap
|
|
};
|
|
|
|
function isNode () {
|
|
return typeof process !== 'undefined' &&
|
|
Object.prototype.toString.call(process) === '[object process]';
|
|
}
|
|
|
|
function hasMutationObserver () {
|
|
return (typeof MutationObserver !== 'undefined' && MutationObserver) ||
|
|
(typeof WebKitMutationObserver !== 'undefined' && WebKitMutationObserver);
|
|
}
|
|
|
|
function initMutationObserver(MutationObserver) {
|
|
var scheduled;
|
|
var node = document.createTextNode('');
|
|
var o = new MutationObserver(run);
|
|
o.observe(node, { characterData: true });
|
|
|
|
function run() {
|
|
var f = scheduled;
|
|
scheduled = void 0;
|
|
f();
|
|
}
|
|
|
|
var i = 0;
|
|
return function (f) {
|
|
scheduled = f;
|
|
node.data = (i ^= 1);
|
|
};
|
|
}
|
|
});
|
|
}(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(require); }));
|
|
|
|
},{}],22:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright 2010-2014 original author or authors */
|
|
/** @author Brian Cavalier */
|
|
/** @author John Hann */
|
|
|
|
(function(define) { 'use strict';
|
|
define(function() {
|
|
|
|
return {
|
|
formatError: formatError,
|
|
formatObject: formatObject,
|
|
tryStringify: tryStringify
|
|
};
|
|
|
|
/**
|
|
* Format an error into a string. If e is an Error and has a stack property,
|
|
* it's returned. Otherwise, e is formatted using formatObject, with a
|
|
* warning added about e not being a proper Error.
|
|
* @param {*} e
|
|
* @returns {String} formatted string, suitable for output to developers
|
|
*/
|
|
function formatError(e) {
|
|
var s = typeof e === 'object' && e !== null && (e.stack || e.message) ? e.stack || e.message : formatObject(e);
|
|
return e instanceof Error ? s : s + ' (WARNING: non-Error used)';
|
|
}
|
|
|
|
/**
|
|
* Format an object, detecting "plain" objects and running them through
|
|
* JSON.stringify if possible.
|
|
* @param {Object} o
|
|
* @returns {string}
|
|
*/
|
|
function formatObject(o) {
|
|
var s = String(o);
|
|
if(s === '[object Object]' && typeof JSON !== 'undefined') {
|
|
s = tryStringify(o, s);
|
|
}
|
|
return s;
|
|
}
|
|
|
|
/**
|
|
* Try to return the result of JSON.stringify(x). If that fails, return
|
|
* defaultValue
|
|
* @param {*} x
|
|
* @param {*} defaultValue
|
|
* @returns {String|*} JSON.stringify(x) or defaultValue
|
|
*/
|
|
function tryStringify(x, defaultValue) {
|
|
try {
|
|
return JSON.stringify(x);
|
|
} catch(e) {
|
|
return defaultValue;
|
|
}
|
|
}
|
|
|
|
});
|
|
}(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(); }));
|
|
|
|
},{}],23:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright 2010-2014 original author or authors */
|
|
/** @author Brian Cavalier */
|
|
/** @author John Hann */
|
|
|
|
(function(define) { 'use strict';
|
|
define(function() {
|
|
|
|
return function liftAll(liftOne, combine, dst, src) {
|
|
if(typeof combine === 'undefined') {
|
|
combine = defaultCombine;
|
|
}
|
|
|
|
return Object.keys(src).reduce(function(dst, key) {
|
|
var f = src[key];
|
|
return typeof f === 'function' ? combine(dst, liftOne(f), key) : dst;
|
|
}, typeof dst === 'undefined' ? defaultDst(src) : dst);
|
|
};
|
|
|
|
function defaultCombine(o, f, k) {
|
|
o[k] = f;
|
|
return o;
|
|
}
|
|
|
|
function defaultDst(src) {
|
|
return typeof src === 'function' ? src.bind() : Object.create(src);
|
|
}
|
|
});
|
|
}(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(); }));
|
|
|
|
},{}],24:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright 2010-2014 original author or authors */
|
|
/** @author Brian Cavalier */
|
|
/** @author John Hann */
|
|
|
|
(function(define) { 'use strict';
|
|
define(function() {
|
|
|
|
return function makePromise(environment) {
|
|
|
|
var tasks = environment.scheduler;
|
|
var emitRejection = initEmitRejection();
|
|
|
|
var objectCreate = Object.create ||
|
|
function(proto) {
|
|
function Child() {}
|
|
Child.prototype = proto;
|
|
return new Child();
|
|
};
|
|
|
|
/**
|
|
* Create a promise whose fate is determined by resolver
|
|
* @constructor
|
|
* @returns {Promise} promise
|
|
* @name Promise
|
|
*/
|
|
function Promise(resolver, handler) {
|
|
this._handler = resolver === Handler ? handler : init(resolver);
|
|
}
|
|
|
|
/**
|
|
* Run the supplied resolver
|
|
* @param resolver
|
|
* @returns {Pending}
|
|
*/
|
|
function init(resolver) {
|
|
var handler = new Pending();
|
|
|
|
try {
|
|
resolver(promiseResolve, promiseReject, promiseNotify);
|
|
} catch (e) {
|
|
promiseReject(e);
|
|
}
|
|
|
|
return handler;
|
|
|
|
/**
|
|
* Transition from pre-resolution state to post-resolution state, notifying
|
|
* all listeners of the ultimate fulfillment or rejection
|
|
* @param {*} x resolution value
|
|
*/
|
|
function promiseResolve (x) {
|
|
handler.resolve(x);
|
|
}
|
|
/**
|
|
* Reject this promise with reason, which will be used verbatim
|
|
* @param {Error|*} reason rejection reason, strongly suggested
|
|
* to be an Error type
|
|
*/
|
|
function promiseReject (reason) {
|
|
handler.reject(reason);
|
|
}
|
|
|
|
/**
|
|
* @deprecated
|
|
* Issue a progress event, notifying all progress listeners
|
|
* @param {*} x progress event payload to pass to all listeners
|
|
*/
|
|
function promiseNotify (x) {
|
|
handler.notify(x);
|
|
}
|
|
}
|
|
|
|
// Creation
|
|
|
|
Promise.resolve = resolve;
|
|
Promise.reject = reject;
|
|
Promise.never = never;
|
|
|
|
Promise._defer = defer;
|
|
Promise._handler = getHandler;
|
|
|
|
/**
|
|
* Returns a trusted promise. If x is already a trusted promise, it is
|
|
* returned, otherwise returns a new trusted Promise which follows x.
|
|
* @param {*} x
|
|
* @return {Promise} promise
|
|
*/
|
|
function resolve(x) {
|
|
return isPromise(x) ? x
|
|
: new Promise(Handler, new Async(getHandler(x)));
|
|
}
|
|
|
|
/**
|
|
* Return a reject promise with x as its reason (x is used verbatim)
|
|
* @param {*} x
|
|
* @returns {Promise} rejected promise
|
|
*/
|
|
function reject(x) {
|
|
return new Promise(Handler, new Async(new Rejected(x)));
|
|
}
|
|
|
|
/**
|
|
* Return a promise that remains pending forever
|
|
* @returns {Promise} forever-pending promise.
|
|
*/
|
|
function never() {
|
|
return foreverPendingPromise; // Should be frozen
|
|
}
|
|
|
|
/**
|
|
* Creates an internal {promise, resolver} pair
|
|
* @private
|
|
* @returns {Promise}
|
|
*/
|
|
function defer() {
|
|
return new Promise(Handler, new Pending());
|
|
}
|
|
|
|
// Transformation and flow control
|
|
|
|
/**
|
|
* Transform this promise's fulfillment value, returning a new Promise
|
|
* for the transformed result. If the promise cannot be fulfilled, onRejected
|
|
* is called with the reason. onProgress *may* be called with updates toward
|
|
* this promise's fulfillment.
|
|
* @param {function=} onFulfilled fulfillment handler
|
|
* @param {function=} onRejected rejection handler
|
|
* @param {function=} onProgress @deprecated progress handler
|
|
* @return {Promise} new promise
|
|
*/
|
|
Promise.prototype.then = function(onFulfilled, onRejected, onProgress) {
|
|
var parent = this._handler;
|
|
var state = parent.join().state();
|
|
|
|
if ((typeof onFulfilled !== 'function' && state > 0) ||
|
|
(typeof onRejected !== 'function' && state < 0)) {
|
|
// Short circuit: value will not change, simply share handler
|
|
return new this.constructor(Handler, parent);
|
|
}
|
|
|
|
var p = this._beget();
|
|
var child = p._handler;
|
|
|
|
parent.chain(child, parent.receiver, onFulfilled, onRejected, onProgress);
|
|
|
|
return p;
|
|
};
|
|
|
|
/**
|
|
* If this promise cannot be fulfilled due to an error, call onRejected to
|
|
* handle the error. Shortcut for .then(undefined, onRejected)
|
|
* @param {function?} onRejected
|
|
* @return {Promise}
|
|
*/
|
|
Promise.prototype['catch'] = function(onRejected) {
|
|
return this.then(void 0, onRejected);
|
|
};
|
|
|
|
/**
|
|
* Creates a new, pending promise of the same type as this promise
|
|
* @private
|
|
* @returns {Promise}
|
|
*/
|
|
Promise.prototype._beget = function() {
|
|
return begetFrom(this._handler, this.constructor);
|
|
};
|
|
|
|
function begetFrom(parent, Promise) {
|
|
var child = new Pending(parent.receiver, parent.join().context);
|
|
return new Promise(Handler, child);
|
|
}
|
|
|
|
// Array combinators
|
|
|
|
Promise.all = all;
|
|
Promise.race = race;
|
|
Promise._traverse = traverse;
|
|
|
|
/**
|
|
* Return a promise that will fulfill when all promises in the
|
|
* input array have fulfilled, or will reject when one of the
|
|
* promises rejects.
|
|
* @param {array} promises array of promises
|
|
* @returns {Promise} promise for array of fulfillment values
|
|
*/
|
|
function all(promises) {
|
|
return traverseWith(snd, null, promises);
|
|
}
|
|
|
|
/**
|
|
* Array<Promise<X>> -> Promise<Array<f(X)>>
|
|
* @private
|
|
* @param {function} f function to apply to each promise's value
|
|
* @param {Array} promises array of promises
|
|
* @returns {Promise} promise for transformed values
|
|
*/
|
|
function traverse(f, promises) {
|
|
return traverseWith(tryCatch2, f, promises);
|
|
}
|
|
|
|
function traverseWith(tryMap, f, promises) {
|
|
var handler = typeof f === 'function' ? mapAt : settleAt;
|
|
|
|
var resolver = new Pending();
|
|
var pending = promises.length >>> 0;
|
|
var results = new Array(pending);
|
|
|
|
for (var i = 0, x; i < promises.length && !resolver.resolved; ++i) {
|
|
x = promises[i];
|
|
|
|
if (x === void 0 && !(i in promises)) {
|
|
--pending;
|
|
continue;
|
|
}
|
|
|
|
traverseAt(promises, handler, i, x, resolver);
|
|
}
|
|
|
|
if(pending === 0) {
|
|
resolver.become(new Fulfilled(results));
|
|
}
|
|
|
|
return new Promise(Handler, resolver);
|
|
|
|
function mapAt(i, x, resolver) {
|
|
if(!resolver.resolved) {
|
|
traverseAt(promises, settleAt, i, tryMap(f, x, i), resolver);
|
|
}
|
|
}
|
|
|
|
function settleAt(i, x, resolver) {
|
|
results[i] = x;
|
|
if(--pending === 0) {
|
|
resolver.become(new Fulfilled(results));
|
|
}
|
|
}
|
|
}
|
|
|
|
function traverseAt(promises, handler, i, x, resolver) {
|
|
if (maybeThenable(x)) {
|
|
var h = getHandlerMaybeThenable(x);
|
|
var s = h.state();
|
|
|
|
if (s === 0) {
|
|
h.fold(handler, i, void 0, resolver);
|
|
} else if (s > 0) {
|
|
handler(i, h.value, resolver);
|
|
} else {
|
|
resolver.become(h);
|
|
visitRemaining(promises, i+1, h);
|
|
}
|
|
} else {
|
|
handler(i, x, resolver);
|
|
}
|
|
}
|
|
|
|
Promise._visitRemaining = visitRemaining;
|
|
function visitRemaining(promises, start, handler) {
|
|
for(var i=start; i<promises.length; ++i) {
|
|
markAsHandled(getHandler(promises[i]), handler);
|
|
}
|
|
}
|
|
|
|
function markAsHandled(h, handler) {
|
|
if(h === handler) {
|
|
return;
|
|
}
|
|
|
|
var s = h.state();
|
|
if(s === 0) {
|
|
h.visit(h, void 0, h._unreport);
|
|
} else if(s < 0) {
|
|
h._unreport();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Fulfill-reject competitive race. Return a promise that will settle
|
|
* to the same state as the earliest input promise to settle.
|
|
*
|
|
* WARNING: The ES6 Promise spec requires that race()ing an empty array
|
|
* must return a promise that is pending forever. This implementation
|
|
* returns a singleton forever-pending promise, the same singleton that is
|
|
* returned by Promise.never(), thus can be checked with ===
|
|
*
|
|
* @param {array} promises array of promises to race
|
|
* @returns {Promise} if input is non-empty, a promise that will settle
|
|
* to the same outcome as the earliest input promise to settle. if empty
|
|
* is empty, returns a promise that will never settle.
|
|
*/
|
|
function race(promises) {
|
|
if(typeof promises !== 'object' || promises === null) {
|
|
return reject(new TypeError('non-iterable passed to race()'));
|
|
}
|
|
|
|
// Sigh, race([]) is untestable unless we return *something*
|
|
// that is recognizable without calling .then() on it.
|
|
return promises.length === 0 ? never()
|
|
: promises.length === 1 ? resolve(promises[0])
|
|
: runRace(promises);
|
|
}
|
|
|
|
function runRace(promises) {
|
|
var resolver = new Pending();
|
|
var i, x, h;
|
|
for(i=0; i<promises.length; ++i) {
|
|
x = promises[i];
|
|
if (x === void 0 && !(i in promises)) {
|
|
continue;
|
|
}
|
|
|
|
h = getHandler(x);
|
|
if(h.state() !== 0) {
|
|
resolver.become(h);
|
|
visitRemaining(promises, i+1, h);
|
|
break;
|
|
} else {
|
|
h.visit(resolver, resolver.resolve, resolver.reject);
|
|
}
|
|
}
|
|
return new Promise(Handler, resolver);
|
|
}
|
|
|
|
// Promise internals
|
|
// Below this, everything is @private
|
|
|
|
/**
|
|
* Get an appropriate handler for x, without checking for cycles
|
|
* @param {*} x
|
|
* @returns {object} handler
|
|
*/
|
|
function getHandler(x) {
|
|
if(isPromise(x)) {
|
|
return x._handler.join();
|
|
}
|
|
return maybeThenable(x) ? getHandlerUntrusted(x) : new Fulfilled(x);
|
|
}
|
|
|
|
/**
|
|
* Get a handler for thenable x.
|
|
* NOTE: You must only call this if maybeThenable(x) == true
|
|
* @param {object|function|Promise} x
|
|
* @returns {object} handler
|
|
*/
|
|
function getHandlerMaybeThenable(x) {
|
|
return isPromise(x) ? x._handler.join() : getHandlerUntrusted(x);
|
|
}
|
|
|
|
/**
|
|
* Get a handler for potentially untrusted thenable x
|
|
* @param {*} x
|
|
* @returns {object} handler
|
|
*/
|
|
function getHandlerUntrusted(x) {
|
|
try {
|
|
var untrustedThen = x.then;
|
|
return typeof untrustedThen === 'function'
|
|
? new Thenable(untrustedThen, x)
|
|
: new Fulfilled(x);
|
|
} catch(e) {
|
|
return new Rejected(e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Handler for a promise that is pending forever
|
|
* @constructor
|
|
*/
|
|
function Handler() {}
|
|
|
|
Handler.prototype.when
|
|
= Handler.prototype.become
|
|
= Handler.prototype.notify // deprecated
|
|
= Handler.prototype.fail
|
|
= Handler.prototype._unreport
|
|
= Handler.prototype._report
|
|
= noop;
|
|
|
|
Handler.prototype._state = 0;
|
|
|
|
Handler.prototype.state = function() {
|
|
return this._state;
|
|
};
|
|
|
|
/**
|
|
* Recursively collapse handler chain to find the handler
|
|
* nearest to the fully resolved value.
|
|
* @returns {object} handler nearest the fully resolved value
|
|
*/
|
|
Handler.prototype.join = function() {
|
|
var h = this;
|
|
while(h.handler !== void 0) {
|
|
h = h.handler;
|
|
}
|
|
return h;
|
|
};
|
|
|
|
Handler.prototype.chain = function(to, receiver, fulfilled, rejected, progress) {
|
|
this.when({
|
|
resolver: to,
|
|
receiver: receiver,
|
|
fulfilled: fulfilled,
|
|
rejected: rejected,
|
|
progress: progress
|
|
});
|
|
};
|
|
|
|
Handler.prototype.visit = function(receiver, fulfilled, rejected, progress) {
|
|
this.chain(failIfRejected, receiver, fulfilled, rejected, progress);
|
|
};
|
|
|
|
Handler.prototype.fold = function(f, z, c, to) {
|
|
this.when(new Fold(f, z, c, to));
|
|
};
|
|
|
|
/**
|
|
* Handler that invokes fail() on any handler it becomes
|
|
* @constructor
|
|
*/
|
|
function FailIfRejected() {}
|
|
|
|
inherit(Handler, FailIfRejected);
|
|
|
|
FailIfRejected.prototype.become = function(h) {
|
|
h.fail();
|
|
};
|
|
|
|
var failIfRejected = new FailIfRejected();
|
|
|
|
/**
|
|
* Handler that manages a queue of consumers waiting on a pending promise
|
|
* @constructor
|
|
*/
|
|
function Pending(receiver, inheritedContext) {
|
|
Promise.createContext(this, inheritedContext);
|
|
|
|
this.consumers = void 0;
|
|
this.receiver = receiver;
|
|
this.handler = void 0;
|
|
this.resolved = false;
|
|
}
|
|
|
|
inherit(Handler, Pending);
|
|
|
|
Pending.prototype._state = 0;
|
|
|
|
Pending.prototype.resolve = function(x) {
|
|
this.become(getHandler(x));
|
|
};
|
|
|
|
Pending.prototype.reject = function(x) {
|
|
if(this.resolved) {
|
|
return;
|
|
}
|
|
|
|
this.become(new Rejected(x));
|
|
};
|
|
|
|
Pending.prototype.join = function() {
|
|
if (!this.resolved) {
|
|
return this;
|
|
}
|
|
|
|
var h = this;
|
|
|
|
while (h.handler !== void 0) {
|
|
h = h.handler;
|
|
if (h === this) {
|
|
return this.handler = cycle();
|
|
}
|
|
}
|
|
|
|
return h;
|
|
};
|
|
|
|
Pending.prototype.run = function() {
|
|
var q = this.consumers;
|
|
var handler = this.handler;
|
|
this.handler = this.handler.join();
|
|
this.consumers = void 0;
|
|
|
|
for (var i = 0; i < q.length; ++i) {
|
|
handler.when(q[i]);
|
|
}
|
|
};
|
|
|
|
Pending.prototype.become = function(handler) {
|
|
if(this.resolved) {
|
|
return;
|
|
}
|
|
|
|
this.resolved = true;
|
|
this.handler = handler;
|
|
if(this.consumers !== void 0) {
|
|
tasks.enqueue(this);
|
|
}
|
|
|
|
if(this.context !== void 0) {
|
|
handler._report(this.context);
|
|
}
|
|
};
|
|
|
|
Pending.prototype.when = function(continuation) {
|
|
if(this.resolved) {
|
|
tasks.enqueue(new ContinuationTask(continuation, this.handler));
|
|
} else {
|
|
if(this.consumers === void 0) {
|
|
this.consumers = [continuation];
|
|
} else {
|
|
this.consumers.push(continuation);
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @deprecated
|
|
*/
|
|
Pending.prototype.notify = function(x) {
|
|
if(!this.resolved) {
|
|
tasks.enqueue(new ProgressTask(x, this));
|
|
}
|
|
};
|
|
|
|
Pending.prototype.fail = function(context) {
|
|
var c = typeof context === 'undefined' ? this.context : context;
|
|
this.resolved && this.handler.join().fail(c);
|
|
};
|
|
|
|
Pending.prototype._report = function(context) {
|
|
this.resolved && this.handler.join()._report(context);
|
|
};
|
|
|
|
Pending.prototype._unreport = function() {
|
|
this.resolved && this.handler.join()._unreport();
|
|
};
|
|
|
|
/**
|
|
* Wrap another handler and force it into a future stack
|
|
* @param {object} handler
|
|
* @constructor
|
|
*/
|
|
function Async(handler) {
|
|
this.handler = handler;
|
|
}
|
|
|
|
inherit(Handler, Async);
|
|
|
|
Async.prototype.when = function(continuation) {
|
|
tasks.enqueue(new ContinuationTask(continuation, this));
|
|
};
|
|
|
|
Async.prototype._report = function(context) {
|
|
this.join()._report(context);
|
|
};
|
|
|
|
Async.prototype._unreport = function() {
|
|
this.join()._unreport();
|
|
};
|
|
|
|
/**
|
|
* Handler that wraps an untrusted thenable and assimilates it in a future stack
|
|
* @param {function} then
|
|
* @param {{then: function}} thenable
|
|
* @constructor
|
|
*/
|
|
function Thenable(then, thenable) {
|
|
Pending.call(this);
|
|
tasks.enqueue(new AssimilateTask(then, thenable, this));
|
|
}
|
|
|
|
inherit(Pending, Thenable);
|
|
|
|
/**
|
|
* Handler for a fulfilled promise
|
|
* @param {*} x fulfillment value
|
|
* @constructor
|
|
*/
|
|
function Fulfilled(x) {
|
|
Promise.createContext(this);
|
|
this.value = x;
|
|
}
|
|
|
|
inherit(Handler, Fulfilled);
|
|
|
|
Fulfilled.prototype._state = 1;
|
|
|
|
Fulfilled.prototype.fold = function(f, z, c, to) {
|
|
runContinuation3(f, z, this, c, to);
|
|
};
|
|
|
|
Fulfilled.prototype.when = function(cont) {
|
|
runContinuation1(cont.fulfilled, this, cont.receiver, cont.resolver);
|
|
};
|
|
|
|
var errorId = 0;
|
|
|
|
/**
|
|
* Handler for a rejected promise
|
|
* @param {*} x rejection reason
|
|
* @constructor
|
|
*/
|
|
function Rejected(x) {
|
|
Promise.createContext(this);
|
|
|
|
this.id = ++errorId;
|
|
this.value = x;
|
|
this.handled = false;
|
|
this.reported = false;
|
|
|
|
this._report();
|
|
}
|
|
|
|
inherit(Handler, Rejected);
|
|
|
|
Rejected.prototype._state = -1;
|
|
|
|
Rejected.prototype.fold = function(f, z, c, to) {
|
|
to.become(this);
|
|
};
|
|
|
|
Rejected.prototype.when = function(cont) {
|
|
if(typeof cont.rejected === 'function') {
|
|
this._unreport();
|
|
}
|
|
runContinuation1(cont.rejected, this, cont.receiver, cont.resolver);
|
|
};
|
|
|
|
Rejected.prototype._report = function(context) {
|
|
tasks.afterQueue(new ReportTask(this, context));
|
|
};
|
|
|
|
Rejected.prototype._unreport = function() {
|
|
if(this.handled) {
|
|
return;
|
|
}
|
|
this.handled = true;
|
|
tasks.afterQueue(new UnreportTask(this));
|
|
};
|
|
|
|
Rejected.prototype.fail = function(context) {
|
|
this.reported = true;
|
|
emitRejection('unhandledRejection', this);
|
|
Promise.onFatalRejection(this, context === void 0 ? this.context : context);
|
|
};
|
|
|
|
function ReportTask(rejection, context) {
|
|
this.rejection = rejection;
|
|
this.context = context;
|
|
}
|
|
|
|
ReportTask.prototype.run = function() {
|
|
if(!this.rejection.handled && !this.rejection.reported) {
|
|
this.rejection.reported = true;
|
|
emitRejection('unhandledRejection', this.rejection) ||
|
|
Promise.onPotentiallyUnhandledRejection(this.rejection, this.context);
|
|
}
|
|
};
|
|
|
|
function UnreportTask(rejection) {
|
|
this.rejection = rejection;
|
|
}
|
|
|
|
UnreportTask.prototype.run = function() {
|
|
if(this.rejection.reported) {
|
|
emitRejection('rejectionHandled', this.rejection) ||
|
|
Promise.onPotentiallyUnhandledRejectionHandled(this.rejection);
|
|
}
|
|
};
|
|
|
|
// Unhandled rejection hooks
|
|
// By default, everything is a noop
|
|
|
|
Promise.createContext
|
|
= Promise.enterContext
|
|
= Promise.exitContext
|
|
= Promise.onPotentiallyUnhandledRejection
|
|
= Promise.onPotentiallyUnhandledRejectionHandled
|
|
= Promise.onFatalRejection
|
|
= noop;
|
|
|
|
// Errors and singletons
|
|
|
|
var foreverPendingHandler = new Handler();
|
|
var foreverPendingPromise = new Promise(Handler, foreverPendingHandler);
|
|
|
|
function cycle() {
|
|
return new Rejected(new TypeError('Promise cycle'));
|
|
}
|
|
|
|
// Task runners
|
|
|
|
/**
|
|
* Run a single consumer
|
|
* @constructor
|
|
*/
|
|
function ContinuationTask(continuation, handler) {
|
|
this.continuation = continuation;
|
|
this.handler = handler;
|
|
}
|
|
|
|
ContinuationTask.prototype.run = function() {
|
|
this.handler.join().when(this.continuation);
|
|
};
|
|
|
|
/**
|
|
* Run a queue of progress handlers
|
|
* @constructor
|
|
*/
|
|
function ProgressTask(value, handler) {
|
|
this.handler = handler;
|
|
this.value = value;
|
|
}
|
|
|
|
ProgressTask.prototype.run = function() {
|
|
var q = this.handler.consumers;
|
|
if(q === void 0) {
|
|
return;
|
|
}
|
|
|
|
for (var c, i = 0; i < q.length; ++i) {
|
|
c = q[i];
|
|
runNotify(c.progress, this.value, this.handler, c.receiver, c.resolver);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Assimilate a thenable, sending it's value to resolver
|
|
* @param {function} then
|
|
* @param {object|function} thenable
|
|
* @param {object} resolver
|
|
* @constructor
|
|
*/
|
|
function AssimilateTask(then, thenable, resolver) {
|
|
this._then = then;
|
|
this.thenable = thenable;
|
|
this.resolver = resolver;
|
|
}
|
|
|
|
AssimilateTask.prototype.run = function() {
|
|
var h = this.resolver;
|
|
tryAssimilate(this._then, this.thenable, _resolve, _reject, _notify);
|
|
|
|
function _resolve(x) { h.resolve(x); }
|
|
function _reject(x) { h.reject(x); }
|
|
function _notify(x) { h.notify(x); }
|
|
};
|
|
|
|
function tryAssimilate(then, thenable, resolve, reject, notify) {
|
|
try {
|
|
then.call(thenable, resolve, reject, notify);
|
|
} catch (e) {
|
|
reject(e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Fold a handler value with z
|
|
* @constructor
|
|
*/
|
|
function Fold(f, z, c, to) {
|
|
this.f = f; this.z = z; this.c = c; this.to = to;
|
|
this.resolver = failIfRejected;
|
|
this.receiver = this;
|
|
}
|
|
|
|
Fold.prototype.fulfilled = function(x) {
|
|
this.f.call(this.c, this.z, x, this.to);
|
|
};
|
|
|
|
Fold.prototype.rejected = function(x) {
|
|
this.to.reject(x);
|
|
};
|
|
|
|
Fold.prototype.progress = function(x) {
|
|
this.to.notify(x);
|
|
};
|
|
|
|
// Other helpers
|
|
|
|
/**
|
|
* @param {*} x
|
|
* @returns {boolean} true iff x is a trusted Promise
|
|
*/
|
|
function isPromise(x) {
|
|
return x instanceof Promise;
|
|
}
|
|
|
|
/**
|
|
* Test just enough to rule out primitives, in order to take faster
|
|
* paths in some code
|
|
* @param {*} x
|
|
* @returns {boolean} false iff x is guaranteed *not* to be a thenable
|
|
*/
|
|
function maybeThenable(x) {
|
|
return (typeof x === 'object' || typeof x === 'function') && x !== null;
|
|
}
|
|
|
|
function runContinuation1(f, h, receiver, next) {
|
|
if(typeof f !== 'function') {
|
|
return next.become(h);
|
|
}
|
|
|
|
Promise.enterContext(h);
|
|
tryCatchReject(f, h.value, receiver, next);
|
|
Promise.exitContext();
|
|
}
|
|
|
|
function runContinuation3(f, x, h, receiver, next) {
|
|
if(typeof f !== 'function') {
|
|
return next.become(h);
|
|
}
|
|
|
|
Promise.enterContext(h);
|
|
tryCatchReject3(f, x, h.value, receiver, next);
|
|
Promise.exitContext();
|
|
}
|
|
|
|
/**
|
|
* @deprecated
|
|
*/
|
|
function runNotify(f, x, h, receiver, next) {
|
|
if(typeof f !== 'function') {
|
|
return next.notify(x);
|
|
}
|
|
|
|
Promise.enterContext(h);
|
|
tryCatchReturn(f, x, receiver, next);
|
|
Promise.exitContext();
|
|
}
|
|
|
|
function tryCatch2(f, a, b) {
|
|
try {
|
|
return f(a, b);
|
|
} catch(e) {
|
|
return reject(e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return f.call(thisArg, x), or if it throws return a rejected promise for
|
|
* the thrown exception
|
|
*/
|
|
function tryCatchReject(f, x, thisArg, next) {
|
|
try {
|
|
next.become(getHandler(f.call(thisArg, x)));
|
|
} catch(e) {
|
|
next.become(new Rejected(e));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Same as above, but includes the extra argument parameter.
|
|
*/
|
|
function tryCatchReject3(f, x, y, thisArg, next) {
|
|
try {
|
|
f.call(thisArg, x, y, next);
|
|
} catch(e) {
|
|
next.become(new Rejected(e));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @deprecated
|
|
* Return f.call(thisArg, x), or if it throws, *return* the exception
|
|
*/
|
|
function tryCatchReturn(f, x, thisArg, next) {
|
|
try {
|
|
next.notify(f.call(thisArg, x));
|
|
} catch(e) {
|
|
next.notify(e);
|
|
}
|
|
}
|
|
|
|
function inherit(Parent, Child) {
|
|
Child.prototype = objectCreate(Parent.prototype);
|
|
Child.prototype.constructor = Child;
|
|
}
|
|
|
|
function snd(x, y) {
|
|
return y;
|
|
}
|
|
|
|
function noop() {}
|
|
|
|
function hasCustomEvent() {
|
|
if(typeof CustomEvent === 'function') {
|
|
try {
|
|
var ev = new CustomEvent('unhandledRejection');
|
|
return ev instanceof CustomEvent;
|
|
} catch (ignoredException) {}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function hasInternetExplorerCustomEvent() {
|
|
if(typeof document !== 'undefined' && typeof document.createEvent === 'function') {
|
|
try {
|
|
// Try to create one event to make sure it's supported
|
|
var ev = document.createEvent('CustomEvent');
|
|
ev.initCustomEvent('eventType', false, true, {});
|
|
return true;
|
|
} catch (ignoredException) {}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function initEmitRejection() {
|
|
/*global process, self, CustomEvent*/
|
|
if(typeof process !== 'undefined' && process !== null
|
|
&& typeof process.emit === 'function') {
|
|
// Returning falsy here means to call the default
|
|
// onPotentiallyUnhandledRejection API. This is safe even in
|
|
// browserify since process.emit always returns falsy in browserify:
|
|
// https://github.com/defunctzombie/node-process/blob/master/browser.js#L40-L46
|
|
return function(type, rejection) {
|
|
return type === 'unhandledRejection'
|
|
? process.emit(type, rejection.value, rejection)
|
|
: process.emit(type, rejection);
|
|
};
|
|
} else if(typeof self !== 'undefined' && hasCustomEvent()) {
|
|
return (function (self, CustomEvent) {
|
|
return function (type, rejection) {
|
|
var ev = new CustomEvent(type, {
|
|
detail: {
|
|
reason: rejection.value,
|
|
key: rejection
|
|
},
|
|
bubbles: false,
|
|
cancelable: true
|
|
});
|
|
|
|
return !self.dispatchEvent(ev);
|
|
};
|
|
}(self, CustomEvent));
|
|
} else if(typeof self !== 'undefined' && hasInternetExplorerCustomEvent()) {
|
|
return (function(self, document) {
|
|
return function(type, rejection) {
|
|
var ev = document.createEvent('CustomEvent');
|
|
ev.initCustomEvent(type, false, true, {
|
|
reason: rejection.value,
|
|
key: rejection
|
|
});
|
|
|
|
return !self.dispatchEvent(ev);
|
|
};
|
|
}(self, document));
|
|
}
|
|
|
|
return noop;
|
|
}
|
|
|
|
return Promise;
|
|
};
|
|
});
|
|
}(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(); }));
|
|
|
|
},{}],25:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright 2010-2014 original author or authors */
|
|
/** @author Brian Cavalier */
|
|
/** @author John Hann */
|
|
|
|
(function(define) { 'use strict';
|
|
define(function() {
|
|
|
|
return {
|
|
pending: toPendingState,
|
|
fulfilled: toFulfilledState,
|
|
rejected: toRejectedState,
|
|
inspect: inspect
|
|
};
|
|
|
|
function toPendingState() {
|
|
return { state: 'pending' };
|
|
}
|
|
|
|
function toRejectedState(e) {
|
|
return { state: 'rejected', reason: e };
|
|
}
|
|
|
|
function toFulfilledState(x) {
|
|
return { state: 'fulfilled', value: x };
|
|
}
|
|
|
|
function inspect(handler) {
|
|
var state = handler.state();
|
|
return state === 0 ? toPendingState()
|
|
: state > 0 ? toFulfilledState(handler.value)
|
|
: toRejectedState(handler.value);
|
|
}
|
|
|
|
});
|
|
}(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(); }));
|
|
|
|
},{}],26:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright 2013 original author or authors */
|
|
|
|
/**
|
|
* Collection of helpers for interfacing with node-style asynchronous functions
|
|
* using promises.
|
|
*
|
|
* @author Brian Cavalier
|
|
* @contributor Renato Zannon
|
|
*/
|
|
|
|
(function(define) {
|
|
define(function(require) {
|
|
|
|
var when = require('./when');
|
|
var _liftAll = require('./lib/liftAll');
|
|
var setTimer = require('./lib/env').setTimer;
|
|
var slice = Array.prototype.slice;
|
|
|
|
var _apply = require('./lib/apply')(when.Promise, dispatch);
|
|
|
|
return {
|
|
lift: lift,
|
|
liftAll: liftAll,
|
|
apply: apply,
|
|
call: call,
|
|
createCallback: createCallback,
|
|
bindCallback: bindCallback,
|
|
liftCallback: liftCallback
|
|
};
|
|
|
|
/**
|
|
* Takes a node-style async function and calls it immediately (with an optional
|
|
* array of arguments or promises for arguments). It returns a promise whose
|
|
* resolution depends on whether the async functions calls its callback with the
|
|
* conventional error argument or not.
|
|
*
|
|
* With this it becomes possible to leverage existing APIs while still reaping
|
|
* the benefits of promises.
|
|
*
|
|
* @example
|
|
* function onlySmallNumbers(n, callback) {
|
|
* if(n < 10) {
|
|
* callback(null, n + 10);
|
|
* } else {
|
|
* callback(new Error("Calculation failed"));
|
|
* }
|
|
* }
|
|
*
|
|
* var nodefn = require("when/node/function");
|
|
*
|
|
* // Logs '15'
|
|
* nodefn.apply(onlySmallNumbers, [5]).then(console.log, console.error);
|
|
*
|
|
* // Logs 'Calculation failed'
|
|
* nodefn.apply(onlySmallNumbers, [15]).then(console.log, console.error);
|
|
*
|
|
* @param {function} f node-style function that will be called
|
|
* @param {Array} [args] array of arguments to func
|
|
* @returns {Promise} promise for the value func passes to its callback
|
|
*/
|
|
function apply(f, args) {
|
|
return _apply(f, this, args || []);
|
|
}
|
|
|
|
function dispatch(f, thisArg, args, h) {
|
|
var cb = createCallback(h);
|
|
try {
|
|
switch(args.length) {
|
|
case 2: f.call(thisArg, args[0], args[1], cb); break;
|
|
case 1: f.call(thisArg, args[0], cb); break;
|
|
case 0: f.call(thisArg, cb); break;
|
|
default:
|
|
args.push(cb);
|
|
f.apply(thisArg, args);
|
|
}
|
|
} catch(e) {
|
|
h.reject(e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Has the same behavior that {@link apply} has, with the difference that the
|
|
* arguments to the function are provided individually, while {@link apply} accepts
|
|
* a single array.
|
|
*
|
|
* @example
|
|
* function sumSmallNumbers(x, y, callback) {
|
|
* var result = x + y;
|
|
* if(result < 10) {
|
|
* callback(null, result);
|
|
* } else {
|
|
* callback(new Error("Calculation failed"));
|
|
* }
|
|
* }
|
|
*
|
|
* // Logs '5'
|
|
* nodefn.call(sumSmallNumbers, 2, 3).then(console.log, console.error);
|
|
*
|
|
* // Logs 'Calculation failed'
|
|
* nodefn.call(sumSmallNumbers, 5, 10).then(console.log, console.error);
|
|
*
|
|
* @param {function} f node-style function that will be called
|
|
* @param {...*} [args] arguments that will be forwarded to the function
|
|
* @returns {Promise} promise for the value func passes to its callback
|
|
*/
|
|
function call(f /*, args... */) {
|
|
return _apply(f, this, slice.call(arguments, 1));
|
|
}
|
|
|
|
/**
|
|
* Takes a node-style function and returns new function that wraps the
|
|
* original and, instead of taking a callback, returns a promise. Also, it
|
|
* knows how to handle promises given as arguments, waiting for their
|
|
* resolution before executing.
|
|
*
|
|
* Upon execution, the orginal function is executed as well. If it passes
|
|
* a truthy value as the first argument to the callback, it will be
|
|
* interpreted as an error condition, and the promise will be rejected
|
|
* with it. Otherwise, the call is considered a resolution, and the promise
|
|
* is resolved with the callback's second argument.
|
|
*
|
|
* @example
|
|
* var fs = require("fs"), nodefn = require("when/node/function");
|
|
*
|
|
* var promiseRead = nodefn.lift(fs.readFile);
|
|
*
|
|
* // The promise is resolved with the contents of the file if everything
|
|
* // goes ok
|
|
* promiseRead('exists.txt').then(console.log, console.error);
|
|
*
|
|
* // And will be rejected if something doesn't work out
|
|
* // (e.g. the files does not exist)
|
|
* promiseRead('doesnt_exist.txt').then(console.log, console.error);
|
|
*
|
|
*
|
|
* @param {Function} f node-style function to be lifted
|
|
* @param {...*} [args] arguments to be prepended for the new function @deprecated
|
|
* @returns {Function} a promise-returning function
|
|
*/
|
|
function lift(f /*, args... */) {
|
|
var args1 = arguments.length > 1 ? slice.call(arguments, 1) : [];
|
|
return function() {
|
|
// TODO: Simplify once partialing has been removed
|
|
var l = args1.length;
|
|
var al = arguments.length;
|
|
var args = new Array(al + l);
|
|
var i;
|
|
for(i=0; i<l; ++i) {
|
|
args[i] = args1[i];
|
|
}
|
|
for(i=0; i<al; ++i) {
|
|
args[i+l] = arguments[i];
|
|
}
|
|
return _apply(f, this, args);
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Lift all the functions/methods on src
|
|
* @param {object|function} src source whose functions will be lifted
|
|
* @param {function?} combine optional function for customizing the lifting
|
|
* process. It is passed dst, the lifted function, and the property name of
|
|
* the original function on src.
|
|
* @param {(object|function)?} dst option destination host onto which to place lifted
|
|
* functions. If not provided, liftAll returns a new object.
|
|
* @returns {*} If dst is provided, returns dst with lifted functions as
|
|
* properties. If dst not provided, returns a new object with lifted functions.
|
|
*/
|
|
function liftAll(src, combine, dst) {
|
|
return _liftAll(lift, combine, dst, src);
|
|
}
|
|
|
|
/**
|
|
* Takes an object that responds to the resolver interface, and returns
|
|
* a function that will resolve or reject it depending on how it is called.
|
|
*
|
|
* @example
|
|
* function callbackTakingFunction(callback) {
|
|
* if(somethingWrongHappened) {
|
|
* callback(error);
|
|
* } else {
|
|
* callback(null, interestingValue);
|
|
* }
|
|
* }
|
|
*
|
|
* var when = require('when'), nodefn = require('when/node/function');
|
|
*
|
|
* var deferred = when.defer();
|
|
* callbackTakingFunction(nodefn.createCallback(deferred.resolver));
|
|
*
|
|
* deferred.promise.then(function(interestingValue) {
|
|
* // Use interestingValue
|
|
* });
|
|
*
|
|
* @param {Resolver} resolver that will be 'attached' to the callback
|
|
* @returns {Function} a node-style callback function
|
|
*/
|
|
function createCallback(resolver) {
|
|
return function(err, value) {
|
|
if(err) {
|
|
resolver.reject(err);
|
|
} else if(arguments.length > 2) {
|
|
resolver.resolve(slice.call(arguments, 1));
|
|
} else {
|
|
resolver.resolve(value);
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Attaches a node-style callback to a promise, ensuring the callback is
|
|
* called for either fulfillment or rejection. Returns a promise with the same
|
|
* state as the passed-in promise.
|
|
*
|
|
* @example
|
|
* var deferred = when.defer();
|
|
*
|
|
* function callback(err, value) {
|
|
* // Handle err or use value
|
|
* }
|
|
*
|
|
* bindCallback(deferred.promise, callback);
|
|
*
|
|
* deferred.resolve('interesting value');
|
|
*
|
|
* @param {Promise} promise The promise to be attached to.
|
|
* @param {Function} callback The node-style callback to attach.
|
|
* @returns {Promise} A promise with the same state as the passed-in promise.
|
|
*/
|
|
function bindCallback(promise, callback) {
|
|
promise = when(promise);
|
|
|
|
if (callback) {
|
|
promise.then(success, wrapped);
|
|
}
|
|
|
|
return promise;
|
|
|
|
function success(value) {
|
|
wrapped(null, value);
|
|
}
|
|
|
|
function wrapped(err, value) {
|
|
setTimer(function () {
|
|
callback(err, value);
|
|
}, 0);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Takes a node-style callback and returns new function that accepts a
|
|
* promise, calling the original callback when the promise is either
|
|
* fulfilled or rejected with the appropriate arguments.
|
|
*
|
|
* @example
|
|
* var deferred = when.defer();
|
|
*
|
|
* function callback(err, value) {
|
|
* // Handle err or use value
|
|
* }
|
|
*
|
|
* var wrapped = liftCallback(callback);
|
|
*
|
|
* // `wrapped` can now be passed around at will
|
|
* wrapped(deferred.promise);
|
|
*
|
|
* deferred.resolve('interesting value');
|
|
*
|
|
* @param {Function} callback The node-style callback to wrap.
|
|
* @returns {Function} The lifted, promise-accepting function.
|
|
*/
|
|
function liftCallback(callback) {
|
|
return function(promise) {
|
|
return bindCallback(promise, callback);
|
|
};
|
|
}
|
|
});
|
|
|
|
})(typeof define === 'function' && define.amd ? define : function (factory) { module.exports = factory(require); });
|
|
|
|
|
|
|
|
|
|
},{"./lib/apply":11,"./lib/env":21,"./lib/liftAll":23,"./when":32}],27:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright 2011-2013 original author or authors */
|
|
|
|
/**
|
|
* parallel.js
|
|
*
|
|
* Run a set of task functions in parallel. All tasks will
|
|
* receive the same args
|
|
*
|
|
* @author Brian Cavalier
|
|
* @author John Hann
|
|
*/
|
|
|
|
(function(define) {
|
|
define(function(require) {
|
|
|
|
var when = require('./when');
|
|
var all = when.Promise.all;
|
|
var slice = Array.prototype.slice;
|
|
|
|
/**
|
|
* Run array of tasks in parallel
|
|
* @param tasks {Array|Promise} array or promiseForArray of task functions
|
|
* @param [args] {*} arguments to be passed to all tasks
|
|
* @return {Promise} promise for array containing the
|
|
* result of each task in the array position corresponding
|
|
* to position of the task in the tasks array
|
|
*/
|
|
return function parallel(tasks /*, args... */) {
|
|
return all(slice.call(arguments, 1)).then(function(args) {
|
|
return when.map(tasks, function(task) {
|
|
return task.apply(void 0, args);
|
|
});
|
|
});
|
|
};
|
|
|
|
});
|
|
})(typeof define === 'function' && define.amd ? define : function (factory) { module.exports = factory(require); });
|
|
|
|
|
|
|
|
},{"./when":32}],28:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright 2011-2013 original author or authors */
|
|
|
|
/**
|
|
* pipeline.js
|
|
*
|
|
* Run a set of task functions in sequence, passing the result
|
|
* of the previous as an argument to the next. Like a shell
|
|
* pipeline, e.g. `cat file.txt | grep 'foo' | sed -e 's/foo/bar/g'
|
|
*
|
|
* @author Brian Cavalier
|
|
* @author John Hann
|
|
*/
|
|
|
|
(function(define) {
|
|
define(function(require) {
|
|
|
|
var when = require('./when');
|
|
var all = when.Promise.all;
|
|
var slice = Array.prototype.slice;
|
|
|
|
/**
|
|
* Run array of tasks in a pipeline where the next
|
|
* tasks receives the result of the previous. The first task
|
|
* will receive the initialArgs as its argument list.
|
|
* @param tasks {Array|Promise} array or promise for array of task functions
|
|
* @param [initialArgs...] {*} arguments to be passed to the first task
|
|
* @return {Promise} promise for return value of the final task
|
|
*/
|
|
return function pipeline(tasks /* initialArgs... */) {
|
|
// Self-optimizing function to run first task with multiple
|
|
// args using apply, but subsequence tasks via direct invocation
|
|
var runTask = function(args, task) {
|
|
runTask = function(arg, task) {
|
|
return task(arg);
|
|
};
|
|
|
|
return task.apply(null, args);
|
|
};
|
|
|
|
return all(slice.call(arguments, 1)).then(function(args) {
|
|
return when.reduce(tasks, function(arg, task) {
|
|
return runTask(arg, task);
|
|
}, args);
|
|
});
|
|
};
|
|
|
|
});
|
|
})(typeof define === 'function' && define.amd ? define : function (factory) { module.exports = factory(require); });
|
|
|
|
|
|
|
|
},{"./when":32}],29:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright 2012-2013 original author or authors */
|
|
|
|
/**
|
|
* poll.js
|
|
*
|
|
* Helper that polls until cancelled or for a condition to become true.
|
|
*
|
|
* @author Scott Andrews
|
|
*/
|
|
|
|
(function (define) { 'use strict';
|
|
define(function(require) {
|
|
|
|
var when = require('./when');
|
|
var attempt = when['try'];
|
|
var cancelable = require('./cancelable');
|
|
|
|
/**
|
|
* Periodically execute the task function on the msec delay. The result of
|
|
* the task may be verified by watching for a condition to become true. The
|
|
* returned deferred is cancellable if the polling needs to be cancelled
|
|
* externally before reaching a resolved state.
|
|
*
|
|
* The next vote is scheduled after the results of the current vote are
|
|
* verified and rejected.
|
|
*
|
|
* Polling may be terminated by the verifier returning a truthy value,
|
|
* invoking cancel() on the returned promise, or the task function returning
|
|
* a rejected promise.
|
|
*
|
|
* Usage:
|
|
*
|
|
* var count = 0;
|
|
* function doSomething() { return count++ }
|
|
*
|
|
* // poll until cancelled
|
|
* var p = poll(doSomething, 1000);
|
|
* ...
|
|
* p.cancel();
|
|
*
|
|
* // poll until condition is met
|
|
* poll(doSomething, 1000, function(result) { return result > 10 })
|
|
* .then(function(result) { assert result == 10 });
|
|
*
|
|
* // delay first vote
|
|
* poll(doSomething, 1000, anyFunc, true);
|
|
*
|
|
* @param task {Function} function that is executed after every timeout
|
|
* @param interval {number|Function} timeout in milliseconds
|
|
* @param [verifier] {Function} function to evaluate the result of the vote.
|
|
* May return a {Promise} or a {Boolean}. Rejecting the promise or a
|
|
* falsey value will schedule the next vote.
|
|
* @param [delayInitialTask] {boolean} if truthy, the first vote is scheduled
|
|
* instead of immediate
|
|
*
|
|
* @returns {Promise}
|
|
*/
|
|
return function poll(task, interval, verifier, delayInitialTask) {
|
|
var deferred, canceled, reject;
|
|
|
|
canceled = false;
|
|
deferred = cancelable(when.defer(), function () { canceled = true; });
|
|
reject = deferred.reject;
|
|
|
|
verifier = verifier || function () { return false; };
|
|
|
|
if (typeof interval !== 'function') {
|
|
interval = (function (interval) {
|
|
return function () { return when().delay(interval); };
|
|
})(interval);
|
|
}
|
|
|
|
function certify(result) {
|
|
deferred.resolve(result);
|
|
}
|
|
|
|
function schedule(result) {
|
|
attempt(interval).then(vote, reject);
|
|
if (result !== void 0) {
|
|
deferred.notify(result);
|
|
}
|
|
}
|
|
|
|
function vote() {
|
|
if (canceled) { return; }
|
|
when(task(),
|
|
function (result) {
|
|
when(verifier(result),
|
|
function (verification) {
|
|
return verification ? certify(result) : schedule(result);
|
|
},
|
|
function () { schedule(result); }
|
|
);
|
|
},
|
|
reject
|
|
);
|
|
}
|
|
|
|
if (delayInitialTask) {
|
|
schedule();
|
|
} else {
|
|
// if task() is blocking, vote will also block
|
|
vote();
|
|
}
|
|
|
|
// make the promise cancelable
|
|
deferred.promise = Object.create(deferred.promise);
|
|
deferred.promise.cancel = deferred.cancel;
|
|
|
|
return deferred.promise;
|
|
};
|
|
|
|
});
|
|
})(typeof define === 'function' && define.amd ? define : function (factory) { module.exports = factory(require); });
|
|
|
|
},{"./cancelable":3,"./when":32}],30:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright 2011-2013 original author or authors */
|
|
|
|
/**
|
|
* sequence.js
|
|
*
|
|
* Run a set of task functions in sequence. All tasks will
|
|
* receive the same args.
|
|
*
|
|
* @author Brian Cavalier
|
|
* @author John Hann
|
|
*/
|
|
|
|
(function(define) {
|
|
define(function(require) {
|
|
|
|
var when = require('./when');
|
|
var all = when.Promise.all;
|
|
var slice = Array.prototype.slice;
|
|
|
|
/**
|
|
* Run array of tasks in sequence with no overlap
|
|
* @param tasks {Array|Promise} array or promiseForArray of task functions
|
|
* @param [args] {*} arguments to be passed to all tasks
|
|
* @return {Promise} promise for an array containing
|
|
* the result of each task in the array position corresponding
|
|
* to position of the task in the tasks array
|
|
*/
|
|
return function sequence(tasks /*, args... */) {
|
|
var results = [];
|
|
|
|
return all(slice.call(arguments, 1)).then(function(args) {
|
|
return when.reduce(tasks, function(results, task) {
|
|
return when(task.apply(void 0, args), addResult);
|
|
}, results);
|
|
});
|
|
|
|
function addResult(result) {
|
|
results.push(result);
|
|
return results;
|
|
}
|
|
};
|
|
|
|
});
|
|
})(typeof define === 'function' && define.amd ? define : function (factory) { module.exports = factory(require); });
|
|
|
|
|
|
|
|
},{"./when":32}],31:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright 2011-2013 original author or authors */
|
|
|
|
/**
|
|
* timeout.js
|
|
*
|
|
* Helper that returns a promise that rejects after a specified timeout,
|
|
* if not explicitly resolved or rejected before that.
|
|
*
|
|
* @author Brian Cavalier
|
|
* @author John Hann
|
|
*/
|
|
|
|
(function(define) {
|
|
define(function(require) {
|
|
|
|
var when = require('./when');
|
|
|
|
/**
|
|
* @deprecated Use when(trigger).timeout(ms)
|
|
*/
|
|
return function timeout(msec, trigger) {
|
|
return when(trigger).timeout(msec);
|
|
};
|
|
});
|
|
})(typeof define === 'function' && define.amd ? define : function (factory) { module.exports = factory(require); });
|
|
|
|
|
|
|
|
},{"./when":32}],32:[function(require,module,exports){
|
|
/** @license MIT License (c) copyright 2010-2014 original author or authors */
|
|
|
|
/**
|
|
* Promises/A+ and when() implementation
|
|
* when is part of the cujoJS family of libraries (http://cujojs.com/)
|
|
* @author Brian Cavalier
|
|
* @author John Hann
|
|
*/
|
|
(function(define) { 'use strict';
|
|
define(function (require) {
|
|
|
|
var timed = require('./lib/decorators/timed');
|
|
var array = require('./lib/decorators/array');
|
|
var flow = require('./lib/decorators/flow');
|
|
var fold = require('./lib/decorators/fold');
|
|
var inspect = require('./lib/decorators/inspect');
|
|
var generate = require('./lib/decorators/iterate');
|
|
var progress = require('./lib/decorators/progress');
|
|
var withThis = require('./lib/decorators/with');
|
|
var unhandledRejection = require('./lib/decorators/unhandledRejection');
|
|
var TimeoutError = require('./lib/TimeoutError');
|
|
|
|
var Promise = [array, flow, fold, generate, progress,
|
|
inspect, withThis, timed, unhandledRejection]
|
|
.reduce(function(Promise, feature) {
|
|
return feature(Promise);
|
|
}, require('./lib/Promise'));
|
|
|
|
var apply = require('./lib/apply')(Promise);
|
|
|
|
// Public API
|
|
|
|
when.promise = promise; // Create a pending promise
|
|
when.resolve = Promise.resolve; // Create a resolved promise
|
|
when.reject = Promise.reject; // Create a rejected promise
|
|
|
|
when.lift = lift; // lift a function to return promises
|
|
when['try'] = attempt; // call a function and return a promise
|
|
when.attempt = attempt; // alias for when.try
|
|
|
|
when.iterate = Promise.iterate; // DEPRECATED (use cujojs/most streams) Generate a stream of promises
|
|
when.unfold = Promise.unfold; // DEPRECATED (use cujojs/most streams) Generate a stream of promises
|
|
|
|
when.join = join; // Join 2 or more promises
|
|
|
|
when.all = all; // Resolve a list of promises
|
|
when.settle = settle; // Settle a list of promises
|
|
|
|
when.any = lift(Promise.any); // One-winner race
|
|
when.some = lift(Promise.some); // Multi-winner race
|
|
when.race = lift(Promise.race); // First-to-settle race
|
|
|
|
when.map = map; // Array.map() for promises
|
|
when.filter = filter; // Array.filter() for promises
|
|
when.reduce = lift(Promise.reduce); // Array.reduce() for promises
|
|
when.reduceRight = lift(Promise.reduceRight); // Array.reduceRight() for promises
|
|
|
|
when.isPromiseLike = isPromiseLike; // Is something promise-like, aka thenable
|
|
|
|
when.Promise = Promise; // Promise constructor
|
|
when.defer = defer; // Create a {promise, resolve, reject} tuple
|
|
|
|
// Error types
|
|
|
|
when.TimeoutError = TimeoutError;
|
|
|
|
/**
|
|
* Get a trusted promise for x, or by transforming x with onFulfilled
|
|
*
|
|
* @param {*} x
|
|
* @param {function?} onFulfilled callback to be called when x is
|
|
* successfully fulfilled. If promiseOrValue is an immediate value, callback
|
|
* will be invoked immediately.
|
|
* @param {function?} onRejected callback to be called when x is
|
|
* rejected.
|
|
* @param {function?} onProgress callback to be called when progress updates
|
|
* are issued for x. @deprecated
|
|
* @returns {Promise} a new promise that will fulfill with the return
|
|
* value of callback or errback or the completion value of promiseOrValue if
|
|
* callback and/or errback is not supplied.
|
|
*/
|
|
function when(x, onFulfilled, onRejected, onProgress) {
|
|
var p = Promise.resolve(x);
|
|
if (arguments.length < 2) {
|
|
return p;
|
|
}
|
|
|
|
return p.then(onFulfilled, onRejected, onProgress);
|
|
}
|
|
|
|
/**
|
|
* Creates a new promise whose fate is determined by resolver.
|
|
* @param {function} resolver function(resolve, reject, notify)
|
|
* @returns {Promise} promise whose fate is determine by resolver
|
|
*/
|
|
function promise(resolver) {
|
|
return new Promise(resolver);
|
|
}
|
|
|
|
/**
|
|
* Lift the supplied function, creating a version of f that returns
|
|
* promises, and accepts promises as arguments.
|
|
* @param {function} f
|
|
* @returns {Function} version of f that returns promises
|
|
*/
|
|
function lift(f) {
|
|
return function() {
|
|
for(var i=0, l=arguments.length, a=new Array(l); i<l; ++i) {
|
|
a[i] = arguments[i];
|
|
}
|
|
return apply(f, this, a);
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Call f in a future turn, with the supplied args, and return a promise
|
|
* for the result.
|
|
* @param {function} f
|
|
* @returns {Promise}
|
|
*/
|
|
function attempt(f /*, args... */) {
|
|
/*jshint validthis:true */
|
|
for(var i=0, l=arguments.length-1, a=new Array(l); i<l; ++i) {
|
|
a[i] = arguments[i+1];
|
|
}
|
|
return apply(f, this, a);
|
|
}
|
|
|
|
/**
|
|
* Creates a {promise, resolver} pair, either or both of which
|
|
* may be given out safely to consumers.
|
|
* @return {{promise: Promise, resolve: function, reject: function, notify: function}}
|
|
*/
|
|
function defer() {
|
|
return new Deferred();
|
|
}
|
|
|
|
function Deferred() {
|
|
var p = Promise._defer();
|
|
|
|
function resolve(x) { p._handler.resolve(x); }
|
|
function reject(x) { p._handler.reject(x); }
|
|
function notify(x) { p._handler.notify(x); }
|
|
|
|
this.promise = p;
|
|
this.resolve = resolve;
|
|
this.reject = reject;
|
|
this.notify = notify;
|
|
this.resolver = { resolve: resolve, reject: reject, notify: notify };
|
|
}
|
|
|
|
/**
|
|
* Determines if x is promise-like, i.e. a thenable object
|
|
* NOTE: Will return true for *any thenable object*, and isn't truly
|
|
* safe, since it may attempt to access the `then` property of x (i.e.
|
|
* clever/malicious getters may do weird things)
|
|
* @param {*} x anything
|
|
* @returns {boolean} true if x is promise-like
|
|
*/
|
|
function isPromiseLike(x) {
|
|
return x && typeof x.then === 'function';
|
|
}
|
|
|
|
/**
|
|
* Return a promise that will resolve only once all the supplied arguments
|
|
* have resolved. The resolution value of the returned promise will be an array
|
|
* containing the resolution values of each of the arguments.
|
|
* @param {...*} arguments may be a mix of promises and values
|
|
* @returns {Promise}
|
|
*/
|
|
function join(/* ...promises */) {
|
|
return Promise.all(arguments);
|
|
}
|
|
|
|
/**
|
|
* Return a promise that will fulfill once all input promises have
|
|
* fulfilled, or reject when any one input promise rejects.
|
|
* @param {array|Promise} promises array (or promise for an array) of promises
|
|
* @returns {Promise}
|
|
*/
|
|
function all(promises) {
|
|
return when(promises, Promise.all);
|
|
}
|
|
|
|
/**
|
|
* Return a promise that will always fulfill with an array containing
|
|
* the outcome states of all input promises. The returned promise
|
|
* will only reject if `promises` itself is a rejected promise.
|
|
* @param {array|Promise} promises array (or promise for an array) of promises
|
|
* @returns {Promise} promise for array of settled state descriptors
|
|
*/
|
|
function settle(promises) {
|
|
return when(promises, Promise.settle);
|
|
}
|
|
|
|
/**
|
|
* Promise-aware array map function, similar to `Array.prototype.map()`,
|
|
* but input array may contain promises or values.
|
|
* @param {Array|Promise} promises array of anything, may contain promises and values
|
|
* @param {function(x:*, index:Number):*} mapFunc map function which may
|
|
* return a promise or value
|
|
* @returns {Promise} promise that will fulfill with an array of mapped values
|
|
* or reject if any input promise rejects.
|
|
*/
|
|
function map(promises, mapFunc) {
|
|
return when(promises, function(promises) {
|
|
return Promise.map(promises, mapFunc);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Filter the provided array of promises using the provided predicate. Input may
|
|
* contain promises and values
|
|
* @param {Array|Promise} promises array of promises and values
|
|
* @param {function(x:*, index:Number):boolean} predicate filtering predicate.
|
|
* Must return truthy (or promise for truthy) for items to retain.
|
|
* @returns {Promise} promise that will fulfill with an array containing all items
|
|
* for which predicate returned truthy.
|
|
*/
|
|
function filter(promises, predicate) {
|
|
return when(promises, function(promises) {
|
|
return Promise.filter(promises, predicate);
|
|
});
|
|
}
|
|
|
|
return when;
|
|
});
|
|
})(typeof define === 'function' && define.amd ? define : function (factory) { module.exports = factory(require); });
|
|
|
|
},{"./lib/Promise":8,"./lib/TimeoutError":10,"./lib/apply":11,"./lib/decorators/array":12,"./lib/decorators/flow":13,"./lib/decorators/fold":14,"./lib/decorators/inspect":15,"./lib/decorators/iterate":16,"./lib/decorators/progress":17,"./lib/decorators/timed":18,"./lib/decorators/unhandledRejection":19,"./lib/decorators/with":20}]},{},[1])
|
|
//# sourceMappingURL=when.js.map
|
|
(1)
|
|
});
|
|
; |