CHANGES.md

3.2.0

• Potentially unhandled rejections are now logged to console.error by default, even without using done or when/monitor/console. As before, enabling when/monitor/console still adds long async stack traces, and using done still makes errors fatal
• promise.timeout now rejects with a TimeoutError by default (unless you specify a custom reason) for better pattern matching with promise.catch.
• Performance improvements to node.lift: lifted functions and lifting are faster now.
• Deprecated:
  • Using when/node.lift, when/function.lift, and when/callbacks.lift to provide partial arguments
  • promise.then's 3rd argument, and when()'s 4th argument. Use the dedicated promise.progress API to listen to promise progress events.

3.1.0

• Added optional reason param to promise.timeout to specify your own timeout value.
• Another significant speed bump for when.all (and es6-shim Promise.all)
• More when/monitor/console long stack trace improvements. Traces can track nested async functions even if you forget to return a promise.
• Clean up bower and npm installs by ignoring more markdown files

3.0.1

• API doc updates and fixes
• Improvements to unhandled rejection long stack trace filtering
• Internal performance improvements

3.0.0

• New internal architecture with significant performance improvements and memory efficiency
• New APIs
  • when.try, when.lift, when.reduceRight, when.iterate, when.unfold, when.race
  • promise.with, promise.else, promise.delay, promise.timeout, promise.progress
• New liftAll variants for lifting all of an object's functions in one shot, eg. var promisedFs = node.liftAll(require('fs'))
  • fn.liftAll, node.liftAll, callbacks.liftAll
• when.Promise public, inheritance-friendly, Promise constructor
• New ES6 Promise shim
• Check out the tips for upgrading to 3.0 from 2.x

2.8.0

• Experimental ES6 generator support via new when/generator module, with lift, call, apply.

2.7.1

• Internal changes to reduce overall memory usage, along with minor performance improvements.

2.7.0

• Added promise.catch and promise.finally as synonyms for promise.otherwise and promise.ensure. (#212)
• New browserify build for those using globals. (#209)
• Added ender support to package.json. (#223)
• Fix compatibility with PhantomJS's CommonJS module support. (#226)
• Fix Sauce Labs tests for pull requests. (#216)
• Added bower.json ignore to trim files installed via bower. (#193)

2.6.0

• New promise.done allows consuming the ultimate value at the end of a promise chain while ensuring that any errors are thrown to the host environment so you get loud stack traces.
• when/node/function bindCallback and liftCallback now behave more like standard node-style APIs in that they allow exceptions to propagate to the host environment for loud stack traces.

2.5.1

• ensure now ignores non-functions, like then does, for consistency. (#207)

2.5.0

• Promises/A+ 1.1 compliant. Passes version 2.0.0 of the Promises/A+ test suite.

2.4.1

• New MutationObserver scheduler further reduces "time-to-first-handler" in modern browsers. (#198)
  • Also, this works around a horrible IE10 bug (desktop and mobile) that renders setImmediate, MessageChannel, and postMessage unusable as fast task schedulers. Many thanks to @plaa and @calvinmetcalf for their help in discovering the problem and working out a solution. (#197)

2.4.0

• Experimental support for vert.x 2.x. Should now run in vert.x >= 1.1.0.
• New when.isPromiseLike as the more accurately-named synonym for when.isPromise.
• DEPRECATED: when.isPromise. It can only tell you that something is "promise-like" (aka "thenable") anyway. Use the new, more accurately-named when.isPromiseLike instead.
• Fix for promise monitor reporting extra unhandled rejections for when.all and when.map.

2.3.0

• New promise.tap for adding side effects to a promise chain.
• New MessageChannel scheduler reduces "time-to-first" handler, in environments that support it.
• Performance optimizations for promise resolution.
• Internal architecture improvements to pave the way for when.js 3.0.0.

2.2.1

• Fix for when.defer().reject() bypassing the unhandled rejection monitor. (#166)
• Fix for when/function, when/callbacks, and when/node/function not preserving thisArg. (#162)
• Doc clarifications for promise.yield. (#164)

2.2.0

• New experimental promise monitoring and debugging via when/monitor/console.
• New when.promise(resolver) promise creation API. A lighter alternative to the heavier when.defer()
• New bindCallback and liftCallback in when/node/function for more integration options with node-style callbacks.

2.1.1

• Quote internal usages of promise.yield to workaround .NET minifier tools that don't yet understand ES5 identifier-as-property rules. See #157

2.1.0

• New when.settle that settles an array of promises, regardless of whether the fulfill or reject.
• New when/guard generalized concurrency guarding and limiting
• New promise.inspect for synchronously getting a snapshot of a promise's state at a particular instant.
• Significant performance improvements when resolving promises with non-primitives (Arrays, Objects, etc.)
• Experimental vert.x support
• DEPRECATED: onFulfilled, onRejected, onProgress handler arguments to when.all, when.any, when.some. Use the returned promise's then() (or otherwise(), ensure(), etc) to register handlers instead.
  • For example, do this: when.all(array).then(onFulfilled, onRejected) instead of this: when.all(array, onFulfilled, onRejected). The functionality is equivalent.

2.0.1

• Account for the fact that Mocha creates a global named process. Thanks Narsul

2.0.0

• Fully asynchronous resolutions.
• Promises/A+ compliance.
• New when/keys module with all() and map() for object keys/values.
• New promise.ensure as a better, and safer, replacement for promise.always. See discussion as to why promise.always is mistake-prone.
  • DEPRECATED: promise.always
• lift() is now the preferred name for what was bind() in when/function, when/node/function, and when/callbacks.
  • DEPRECATED: bind() in when/function, when/node/function, and when/callbacks. Use lift() instead.

1.8.1

• Last 1.x.x release before 2.0.0 barring critical fixes.
  • To prepare for 2.0.0, test your code against the dev-200 branch. It is fully API compatible, but has fully asynchronous resolutions.
• Performance improvements for when/function.
• Documentation updates and fixes. Thanks, @unscriptable!
• DEPRECATED: deferred.progress and deferred.resolver.progress. Use deferred.notify and deferred.resolver.notify instead.
• DEPRECATED: when.chain. Use resolver.resolve(promise) or resolver.resolve(promise.yield) (see promise.yield) instead.
• DEPRECATED: when/timed module. Use when/delay and when/timeout modules instead.

1.8.0

• New when/function, when/node/function, and when/callbacks with functional programming goodness, and adapters for turning callback-based APIs into promise-based APIs. Kudos @riccieri!
• New when/unfold, and when/unfold/list promise-aware anamorphic unfolds that can be used to generate and/or process unbounded lists.
• New when/poll promise-based periodic polling and task execution. Kudos @scothis!

1.7.1

• Removed leftover internal usages of deferred.then.
• when/debug allows configuring the set of "fatal" error types that will be rethrown to the host env.

1.7.0

• DEPRECATED: deferred.then is deprecated and will be removed in an upcoming release. Use deferred.promise.then instead.
• promise.yield(promiseOrValue) convenience API for substituting a new value into a promise chain.
• promise.spread(variadicFunction) convenience API for spreading an array onto a fulfill handler that accepts variadic arguments. Mmmm, buttery
• Doc improvements:
  • when() and promise.then() have more info about callbacks and chaining behavior.
  • More info and clarifications about the roles of Deferred and Resolver
  • Several minor clarifications for various APIs
• Internal improvements to assimilation and interoperability with other promise implementations.

1.6.1

• Fix for accidental coercion of non-promises. See #62.

1.6.0

• New when.join - Joins 2 or more promises together into a single promise.
• when.some and when.any now act like competitive races, and have generally more useful behavior. Read the discussion in #60.
• Experimental progress event propagation. Progress events will propagate through promise chains. Read the details here.
• Temporarily removed calls to Object.freeze. Promises are no longer frozen due to a horrendous v8 performance penalty. Read discussion here.
  • IMPORTANT: Continue to treat promises as if they are frozen, since freeze() will be reintroduced once v8 performance improves.
• when/debug now allows setting global a debugging callback for rejected promises.

1.5.2

• Integrate @domenic's Promises/A Test Suite. Runs via npm test.
• No functional change

1.5.1

• Performance optimization for when.defer, up to 1.5x in some cases.
• when/debug can now log exceptions and rejections in deeper promise chains, in some cases, even when the promises involved aren't when.js promises.

1.5.0

• New task execution and concurrency management: when/sequence, when/pipeline, and when/parallel.
• Performance optimizations for when.all and when.map, up to 2x in some cases.
• Options for disabling paranoid mode that provides a significant performance gain in v8 (e.g. Node and Chrome). See this v8 performance problem with Object.freeze for more info.
• Important: deferred and deferred.resolver no longer throw when resolved/rejected multiple times. They will return silently as if the they had succeeded. This prevents parties to whom only the resolver has been given from using try/catch to determine the state of the associated promise.
  • For debugging, you can use the when/debug module, which will still throw when a deferred is resolved/rejected multiple times.

1.4.4

• Change UMD boilerplate to check for exports to avoid a problem with QUnit. See #54 for more info.

1.4.3

• Fix for infinite promise coercion between when.js and Q (See #50). Thanks @kriskowal and @domenic

1.4.2

• Fix for IE8 infinite recursion (See #49)

1.4.1

• Code and unit test cleanup and streamlining--no functional changes.

1.4.0

• Create a resolved promise: when.resolve(value) creates a resolved promise for value. See API docs.
• Resolve/reject return something useful: deferred.resolve and deferred.reject now return a promise for the fulfilled or rejected value.
• Resolve a deferred with another promise: deferred.resolve(promise) - when promise resolves or rejects, so will deferred.

1.3.0

• Fixed a deviation from the Promises/A spec where returning undefined from a callback or errback would cause the previous value to be forwarded. See #31
  • This could be a breaking change if you depended on this behavior. If you encounter problems, the solution is to ensure that your promise callbacks (registered either with when() or .then()) return what you intend, keeping in mind that not returning something is equivalent to returning undefined.
• This change also restores compatibility with the promises returned by jQuery.get(), which seem to reject with themselves as the rejection value. See issue #41 for more information and discussion. Thanks to @KidkArolis for raising the issue.

1.2.0

• promise.otherwise(errback) as a shortcut for promise.then(null, errback). See discussion here and here. Thanks to @jonnyreeves for suggesting the name "otherwise".
• when/debug now detects exceptions that typically represent coding errors, such as SyntaxError, ReferenceError, etc. and propagates them to the host environment. In other words, you'll get a very loud stack trace.

1.1.1

• Updated wiki map/reduce examples, and added simple promise forwarding example
• Fix for calling when.any() without a callback (#33)
• Fix version number in when.js source (#36)

1.1.0

• when.all/any/some/map/reduce can all now accept a promise for an array in addition to an actual array as input. This allows composing functions to do interesting things like when.reduce(when.map(...))
• when.reject(promiseOrValue) that returns a new, rejected promise.
• promise.always(callback) as a shortcut for promise.then(callback, callback)
• Highly experimental when/debug module: a drop-in replacement for the main when module that enables debug logging for promises created or consumed by when.js

1.0.4

• Travis CI integration
• Fix for cancelable deferred not invoking progress callbacks. (#24 Thanks @scothis)
• The promise returned by when.chain now rejects when the input promise rejects.

1.0.3

• Fix for specific situation where null could incorrectly be used as a promise resolution value (#23)

1.0.2

• Updated README for running unit tests in both Node and Browsers. See Running the Unit Tests below.
• Set package name to 'when' in package.json

1.0.1

• Fix for rejections propagating in some cases when they shouldn't have been (#19)
• Using buster.js for unit tests now.

1.0.0

• First official when.js release as a part of cujojs.
• Added when/cancelable decorator for creating cancelable deferreds
• Added when/delay and when/timeout helpers for creating delayed promises and promises that timeout and reject if not resolved first.

0.11.1

• Added when/apply helper module for using arguments-based and variadic callbacks with when.all, when.some, when.map, or any promise that resolves to an array. (#14)
• .then(), when(), and all other methods that accept callback/errback/progress handlers will throw if you pass something that's not a function. (#15)

0.11.0

• when.js now assimilates thenables that pass the Promises/A duck-type test, but which may not be fully Promises/A compliant, such as jQuery's Deferred and curl's global API (See the API at a glance section)
  • when(), and when.all/some/any/map/reduce/chain() are all now guaranteed to return a fully Promises/A compliant promise, even when their input is not compliant.
  • Any non-compliant thenable returned by a callback or errback will also be assimilated to protect subsequent promises and callbacks in a promise chain, and preserve Promises/A forwarding guarantees.

0.10.4

• Important Fix for some AMD build/optimizer tools: Switching back to more verbose, builder-friendly boilerplate
  • If you are using when.js 0.10.3 with the dojo or RequireJS build tools, you should update to v.10.4 as soon as possible.

0.10.3

Warning: This version will not work with most AMD build tools. You should update to 0.10.4 as soon as possible.

• Minor package.json updates
• Slightly smaller module boilerplate

0.10.2

• Performance optimizations for when.map() (thanks @smitranic), especially for large arrays where the mapFunc is also async (i.e. returns a promise)
• when.all/some/any/map/reduce handle sparse arrays (thanks @rwaldrn)
• Other minor performance optimizations

0.10.1

• Minor tweaks (thanks @johan)
  • Add missing semis that WebStorm didn't catch
  • Fix DOH submodule ref, and update README with info for running unit tests

0.10.0

• when.map and when.reduce - just like Array.map and Array.reduce, but they operate on promises and arrays of promises
• Lots of internal size and performance optimizations
• Still only 1k!

0.9.4

• Important fix for break in promise chains