diff options
Diffstat (limited to 'node_modules/when/dist/browser/when.debug.js')
| -rw-r--r-- | node_modules/when/dist/browser/when.debug.js | 4021 |
1 files changed, 4021 insertions, 0 deletions
diff --git a/node_modules/when/dist/browser/when.debug.js b/node_modules/when/dist/browser/when.debug.js new file mode 100644 index 000000000..8b1b356a2 --- /dev/null +++ b/node_modules/when/dist/browser/when.debug.js @@ -0,0 +1,4021 @@ +!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){ +require('../monitor/console'); +module.exports = require('./when.browserify.js'); + + +},{"../monitor/console":30,"./when.browserify.js":2}],2:[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":3,"../cancelable":4,"../delay":5,"../function":6,"../guard":7,"../keys":8,"../node":32,"../parallel":33,"../pipeline":34,"../poll":35,"../sequence":36,"../timeout":37,"../when":38}],3:[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":12,"./lib/liftAll":24,"./when":38}],4:[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(); }); + + + +},{}],5:[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":38}],6:[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":12,"./lib/liftAll":24,"./when":38}],7:[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":38}],8:[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":38}],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 (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":10,"./env":22,"./makePromise":25}],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() { + + // 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(); })); + +},{}],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() { + + /** + * 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(); })); +},{}],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() { + + 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(); })); + + + +},{}],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(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) { + var h = Promise._handler(p); + if(h.state() === 0) { + return toPromise(p).then(state.fulfilled, state.rejected); + } + + h._unreport(); + return state.inspect(h); + } + + /** + * 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":12,"../state":26}],14:[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(); })); + +},{}],15:[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(); })); + +},{}],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(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":26}],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 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(); })); + +},{}],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() { + + 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(); })); + +},{}],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 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":11,"../env":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(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":22,"../format":23}],21:[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(); })); + + +},{}],22:[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 === 'function' && MutationObserver) || + (typeof WebKitMutationObserver === 'function' && 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); })); + +},{}],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 { + 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(); })); + +},{}],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 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(); })); + +},{}],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 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 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' && typeof CustomEvent === 'function') { + return (function(noop, self, CustomEvent) { + var hasCustomEvent = false; + try { + var ev = new CustomEvent('unhandledRejection'); + hasCustomEvent = ev instanceof CustomEvent; + } catch (e) {} + + return !hasCustomEvent ? noop : function(type, rejection) { + var ev = new CustomEvent(type, { + detail: { + reason: rejection.value, + key: rejection + }, + bubbles: false, + cancelable: true + }); + + return !self.dispatchEvent(ev); + }; + }(noop, self, CustomEvent)); + } + + return noop; + } + + return Promise; + }; +}); +}(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(); })); + +},{}],26:[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(); })); + +},{}],27:[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 PromiseMonitor = require('./monitor/PromiseMonitor'); + var ConsoleReporter = require('./monitor/ConsoleReporter'); + + var promiseMonitor = new PromiseMonitor(new ConsoleReporter()); + + return function(Promise) { + return promiseMonitor.monitor(Promise); + }; +}); +}(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(require); })); + +},{"./monitor/ConsoleReporter":28,"./monitor/PromiseMonitor":29}],28:[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 error = require('./error'); + var unhandledRejectionsMsg = '[promises] Unhandled rejections: '; + var allHandledMsg = '[promises] All previously unhandled rejections have now been handled'; + + function ConsoleReporter() { + this._previouslyReported = false; + } + + ConsoleReporter.prototype = initDefaultLogging(); + + ConsoleReporter.prototype.log = function(traces) { + if(traces.length === 0) { + if(this._previouslyReported) { + this._previouslyReported = false; + this.msg(allHandledMsg); + } + return; + } + + this._previouslyReported = true; + this.groupStart(unhandledRejectionsMsg + traces.length); + try { + this._log(traces); + } finally { + this.groupEnd(); + } + }; + + ConsoleReporter.prototype._log = function(traces) { + for(var i=0; i<traces.length; ++i) { + this.warn(error.format(traces[i])); + } + }; + + function initDefaultLogging() { + /*jshint maxcomplexity:7*/ + var log, warn, groupStart, groupEnd; + + if(typeof console === 'undefined') { + log = warn = consoleNotAvailable; + } else { + // 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. + var localConsole = console; + if(typeof localConsole.error === 'function' + && typeof localConsole.dir === 'function') { + warn = function(s) { + localConsole.error(s); + }; + + log = function(s) { + localConsole.log(s); + }; + + if(typeof localConsole.groupCollapsed === 'function') { + groupStart = function(s) { + localConsole.groupCollapsed(s); + }; + groupEnd = function() { + localConsole.groupEnd(); + }; + } + } else { + // IE8 has console.log and JSON, so we can make a + // reasonably useful warn() from those. + // Credit to webpro (https://github.com/webpro) for this idea + // typeof localConsole.log will return 'object' in IE8, so can't test it with === 'function' + // Since this is more of a corner case for IE8, I'm ok to check it with !== 'undefined' to reduce complexity + if (typeof localConsole.log !== 'undefined' && typeof JSON !== 'undefined') { + log = warn = function(x) { + if (typeof x !== 'string') { + try { + x = JSON.stringify(x); + } catch (e) { + } + } + localConsole.log(x); + }; + } else { + log = warn = consoleNotAvailable; + } + } + } + + return { + msg: log, + warn: warn, + groupStart: groupStart || warn, + groupEnd: groupEnd || consoleNotAvailable + }; + } + + function consoleNotAvailable() {} + + return ConsoleReporter; + +}); +}(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(require); })); + +},{"./error":31}],29:[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 defaultStackJumpSeparator = 'from execution context:'; + var defaultStackFilter = /[\s\(\/\\](node|module|timers)\.js:|when([\/\\]{1,2}(lib|monitor|es6-shim)[\/\\]{1,2}|\.js)|(new\sPromise)\b|(\b(PromiseMonitor|ConsoleReporter|Scheduler|RunHandlerTask|ProgressTask|Promise|.*Handler)\.[\w_]\w\w+\b)|\b(tryCatch\w+|getHandler\w*)\b/i; + + var setTimer = require('../lib/env').setTimer; + var error = require('./error'); + + var executionContext = []; + + function PromiseMonitor(reporter) { + this.logDelay = 0; + this.stackFilter = defaultStackFilter; + this.stackJumpSeparator = defaultStackJumpSeparator; + this.filterDuplicateFrames = true; + + this._reporter = reporter; + if(typeof reporter.configurePromiseMonitor === 'function') { + reporter.configurePromiseMonitor(this); + } + + this._traces = []; + this._traceTask = 0; + + var self = this; + this._doLogTraces = function() { + self._logTraces(); + }; + } + + PromiseMonitor.prototype.monitor = function(Promise) { + var self = this; + Promise.createContext = function(p, context) { + p.context = self.createContext(p, context); + }; + + Promise.enterContext = function(p) { + executionContext.push(p.context); + }; + + Promise.exitContext = function() { + executionContext.pop(); + }; + + Promise.onPotentiallyUnhandledRejection = function(rejection, extraContext) { + return self.addTrace(rejection, extraContext); + }; + + Promise.onPotentiallyUnhandledRejectionHandled = function(rejection) { + return self.removeTrace(rejection); + }; + + Promise.onFatalRejection = function(rejection, extraContext) { + return self.fatal(rejection, extraContext); + }; + + return this; + }; + + PromiseMonitor.prototype.createContext = function(at, parentContext) { + var context = { + parent: parentContext || executionContext[executionContext.length - 1], + stack: void 0 + }; + error.captureStack(context, at.constructor); + return context; + }; + + PromiseMonitor.prototype.addTrace = function(handler, extraContext) { + var t, i; + + for(i = this._traces.length-1; i >= 0; --i) { + t = this._traces[i]; + if(t.handler === handler) { + break; + } + } + + if(i >= 0) { + t.extraContext = extraContext; + } else { + this._traces.push({ + handler: handler, + extraContext: extraContext + }); + } + + this.logTraces(); + }; + + PromiseMonitor.prototype.removeTrace = function(/*handler*/) { + this.logTraces(); + }; + + PromiseMonitor.prototype.fatal = function(handler, extraContext) { + var err = new Error(); + err.stack = this._createLongTrace(handler.value, handler.context, extraContext).join('\n'); + setTimer(function() { + throw err; + }, 0); + }; + + PromiseMonitor.prototype.logTraces = function() { + if(!this._traceTask) { + this._traceTask = setTimer(this._doLogTraces, this.logDelay); + } + }; + + PromiseMonitor.prototype._logTraces = function() { + this._traceTask = void 0; + this._traces = this._traces.filter(filterHandled); + this._reporter.log(this.formatTraces(this._traces)); + }; + + + PromiseMonitor.prototype.formatTraces = function(traces) { + return traces.map(function(t) { + return this._createLongTrace(t.handler.value, t.handler.context, t.extraContext); + }, this); + }; + + PromiseMonitor.prototype._createLongTrace = function(e, context, extraContext) { + var trace = error.parse(e) || [String(e) + ' (WARNING: non-Error used)']; + trace = filterFrames(this.stackFilter, trace, 0); + this._appendContext(trace, context); + this._appendContext(trace, extraContext); + return this.filterDuplicateFrames ? this._removeDuplicates(trace) : trace; + }; + + PromiseMonitor.prototype._removeDuplicates = function(trace) { + var seen = {}; + var sep = this.stackJumpSeparator; + var count = 0; + return trace.reduceRight(function(deduped, line, i) { + if(i === 0) { + deduped.unshift(line); + } else if(line === sep) { + if(count > 0) { + deduped.unshift(line); + count = 0; + } + } else if(!seen[line]) { + seen[line] = true; + deduped.unshift(line); + ++count; + } + return deduped; + }, []); + }; + + PromiseMonitor.prototype._appendContext = function(trace, context) { + trace.push.apply(trace, this._createTrace(context)); + }; + + PromiseMonitor.prototype._createTrace = function(traceChain) { + var trace = []; + var stack; + + while(traceChain) { + stack = error.parse(traceChain); + + if (stack) { + stack = filterFrames(this.stackFilter, stack); + appendStack(trace, stack, this.stackJumpSeparator); + } + + traceChain = traceChain.parent; + } + + return trace; + }; + + function appendStack(trace, stack, separator) { + if (stack.length > 1) { + stack[0] = separator; + trace.push.apply(trace, stack); + } + } + + function filterFrames(stackFilter, stack) { + return stack.filter(function(frame) { + return !stackFilter.test(frame); + }); + } + + function filterHandled(t) { + return !t.handler.handled; + } + + return PromiseMonitor; +}); +}(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(require); })); + +},{"../lib/env":22,"./error":31}],30:[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 monitor = require('../monitor'); + var Promise = require('../when').Promise; + + return monitor(Promise); + +}); +}(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(require); })); + +},{"../monitor":27,"../when":38}],31:[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() { + + var parse, captureStack, format; + + if(Error.captureStackTrace) { + // Use Error.captureStackTrace if available + parse = function(e) { + return e && e.stack && e.stack.split('\n'); + }; + + format = formatAsString; + captureStack = Error.captureStackTrace; + + } else { + // Otherwise, do minimal feature detection to determine + // how to capture and format reasonable stacks. + parse = function(e) { + var stack = e && e.stack && e.stack.split('\n'); + if(stack && e.message) { + stack.unshift(e.message); + } + return stack; + }; + + (function() { + var e = new Error(); + if(typeof e.stack !== 'string') { + format = formatAsString; + captureStack = captureSpiderMonkeyStack; + } else { + format = formatAsErrorWithStack; + captureStack = useStackDirectly; + } + }()); + } + + function captureSpiderMonkeyStack(host) { + try { + throw new Error(); + } catch(err) { + host.stack = err.stack; + } + } + + function useStackDirectly(host) { + host.stack = new Error().stack; + } + + function formatAsString(longTrace) { + return join(longTrace); + } + + function formatAsErrorWithStack(longTrace) { + var e = new Error(); + e.stack = formatAsString(longTrace); + return e; + } + + // About 5-10x faster than String.prototype.join o_O + function join(a) { + var sep = false; + var s = ''; + for(var i=0; i< a.length; ++i) { + if(sep) { + s += '\n' + a[i]; + } else { + s+= a[i]; + sep = true; + } + } + return s; + } + + return { + parse: parse, + format: format, + captureStack: captureStack + }; + +}); +}(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(); })); + +},{}],32:[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":12,"./lib/env":22,"./lib/liftAll":24,"./when":38}],33:[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":38}],34:[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":38}],35:[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":4,"./when":38}],36:[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":38}],37:[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":38}],38:[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":9,"./lib/TimeoutError":11,"./lib/apply":12,"./lib/decorators/array":13,"./lib/decorators/flow":14,"./lib/decorators/fold":15,"./lib/decorators/inspect":16,"./lib/decorators/iterate":17,"./lib/decorators/progress":18,"./lib/decorators/timed":19,"./lib/decorators/unhandledRejection":20,"./lib/decorators/with":21}]},{},[1]) +//# sourceMappingURL=when.debug.js.map +(1) +}); +;
\ No newline at end of file |