diff options
Diffstat (limited to 'node_modules/when/dist/browser/when.debug.js')
| -rw-r--r-- | node_modules/when/dist/browser/when.debug.js | 4059 |
1 files changed, 0 insertions, 4059 deletions
diff --git a/node_modules/when/dist/browser/when.debug.js b/node_modules/when/dist/browser/when.debug.js deleted file mode 100644 index 4f0097946..000000000 --- a/node_modules/when/dist/browser/when.debug.js +++ /dev/null @@ -1,4059 +0,0 @@ -!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) { - // Optimize the case where we get an already-resolved when.js promise - // by extracting its state: - var handler; - if (p instanceof Promise) { - // This is our own Promise type and we can reach its handler internals: - handler = p._handler.join(); - } - if((handler && handler.state() === 0) || !handler) { - // Either still pending, or not a Promise at all: - return toPromise(p).then(state.fulfilled, state.rejected); - } - - // The promise is our own, but it is already resolved. Take a shortcut. - // Since we're not actually handling the resolution, we need to disable - // rejection reporting. - handler._unreport(); - return state.inspect(handler); - } - - /** - * Traditional reduce function, similar to `Array.prototype.reduce()`, but - * input may contain promises and/or values, and reduceFunc - * may return either a value or a promise, *and* initialValue may - * be a promise for the starting value. - * @param {Array|Promise} promises array or promise for an array of anything, - * may contain a mix of promises and values. - * @param {function(accumulated:*, x:*, index:Number):*} f reduce function - * @returns {Promise} that will resolve to the final reduced value - */ - function reduce(promises, f /*, initialValue */) { - return arguments.length > 2 ? ar.call(promises, liftCombine(f), arguments[2]) - : ar.call(promises, liftCombine(f)); - } - - /** - * Traditional reduce function, similar to `Array.prototype.reduceRight()`, but - * input may contain promises and/or values, and reduceFunc - * may return either a value or a promise, *and* initialValue may - * be a promise for the starting value. - * @param {Array|Promise} promises array or promise for an array of anything, - * may contain a mix of promises and values. - * @param {function(accumulated:*, x:*, index:Number):*} f reduce function - * @returns {Promise} that will resolve to the final reduced value - */ - function reduceRight(promises, f /*, initialValue */) { - return arguments.length > 2 ? arr.call(promises, liftCombine(f), arguments[2]) - : arr.call(promises, liftCombine(f)); - } - - function liftCombine(f) { - return function(z, x, i) { - return applyFold(f, void 0, [z,x,i]); - }; - } - }; - -}); -}(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(require); })); - -},{"../apply":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 !== 'undefined' && MutationObserver) || - (typeof WebKitMutationObserver !== 'undefined' && WebKitMutationObserver); - } - - function initMutationObserver(MutationObserver) { - var scheduled; - var node = document.createTextNode(''); - var o = new MutationObserver(run); - o.observe(node, { characterData: true }); - - function run() { - var f = scheduled; - scheduled = void 0; - f(); - } - - var i = 0; - return function (f) { - scheduled = f; - node.data = (i ^= 1); - }; - } -}); -}(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(require); })); - -},{}],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 hasCustomEvent() { - if(typeof CustomEvent === 'function') { - try { - var ev = new CustomEvent('unhandledRejection'); - return ev instanceof CustomEvent; - } catch (ignoredException) {} - } - return false; - } - - function hasInternetExplorerCustomEvent() { - if(typeof document !== 'undefined' && typeof document.createEvent === 'function') { - try { - // Try to create one event to make sure it's supported - var ev = document.createEvent('CustomEvent'); - ev.initCustomEvent('eventType', false, true, {}); - return true; - } catch (ignoredException) {} - } - return false; - } - - function initEmitRejection() { - /*global process, self, CustomEvent*/ - if(typeof process !== 'undefined' && process !== null - && typeof process.emit === 'function') { - // Returning falsy here means to call the default - // onPotentiallyUnhandledRejection API. This is safe even in - // browserify since process.emit always returns falsy in browserify: - // https://github.com/defunctzombie/node-process/blob/master/browser.js#L40-L46 - return function(type, rejection) { - return type === 'unhandledRejection' - ? process.emit(type, rejection.value, rejection) - : process.emit(type, rejection); - }; - } else if(typeof self !== 'undefined' && hasCustomEvent()) { - return (function (self, CustomEvent) { - return function (type, rejection) { - var ev = new CustomEvent(type, { - detail: { - reason: rejection.value, - key: rejection - }, - bubbles: false, - cancelable: true - }); - - return !self.dispatchEvent(ev); - }; - }(self, CustomEvent)); - } else if(typeof self !== 'undefined' && hasInternetExplorerCustomEvent()) { - return (function(self, document) { - return function(type, rejection) { - var ev = document.createEvent('CustomEvent'); - ev.initCustomEvent(type, false, true, { - reason: rejection.value, - key: rejection - }); - - return !self.dispatchEvent(ev); - }; - }(self, document)); - } - - return noop; - } - - return Promise; - }; -}); -}(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(); })); - -},{}],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 |