sfcode An Online Competing and Development Environment

1.4.1

- Address an issue that prevented Q from being used as a `<script>` for Firefox add-ons. Q can now be used in any environment that provides `window` or `self` globals, favoring `window` since add-ons have an an immutable `self` that is distinct from `window`.

# 1.4.0

- Add `noConflict` support for use in `<script>` (@jahnjw).

# 1.3.0

- Add tracking for unhandled and handled rejections in Node.js (@benjamingr).

# 1.2.1

- Fix Node.js environment detection for modern Browserify (@kahnjw).

# 1.2.0

- Added Q.any(promisesArray) method (@vergara). Returns a promise fulfilled with the value of the first resolved promise in promisesArray. If all promises in promisesArray are rejected, it returns a rejected promise.

# 1.1.2

- Removed extraneous files from the npm package by using the "files" whitelist in package.json instead of the .npmignore blacklist. (@anton-rudeshko)

# 1.1.1

- Fix a pair of regressions in bootstrapping, one which precluded WebWorker support, and another that precluded support in `<script>` usage outright. #607

# 1.1.0

- Adds support for enabling long stack traces in node.js by setting environment variable `Q_DEBUG=1`.
- Introduces the `tap` method to promises, which will see a value pass through without alteration.
- Use instanceof to recognize own promise instances as opposed to thenables.
- Construct timeout errors with `code === ETIMEDOUT` (Kornel Lesiński)
- More descriminant CommonJS module environment detection.
- Dropped continuous integration for Node.js 0.6 and 0.8 because of changes to npm that preclude the use of new `^` version predicate operator in any transitive dependency.
- Users can now override `Q.nextTick`.

# 1.0.1

- Adds support for `Q.Promise`, which implements common usage of the ES6 `Promise` constructor and its methods. `Promise` does not have a valid promise constructor and a proper implementation awaits version 2 of Q.
- Removes the console stopgap for a promise inspector. This no longer works with any degree of reliability.
- Fixes support for content security policies that forbid eval. Now using the `StopIteration` global to distinguish SpiderMonkey generators from ES6 generators, assuming that they will never coexist.

# 1.0.0

:cake: This is all but a re-release of version 0.9, which has settled into a gentle maintenance mode and rightly deserves an official 1.0. An ambitious 2.0 release is already around the corner, but 0.9/1.0 have been distributed far and wide and demand long term support.

- Q will now attempt to post a debug message in browsers regardless of whether window.Touch is defined. Chrome at least now has this property regardless of whether touch is supported by the underlying hardware.
- Remove deprecation warning from `promise.valueOf`. The function is called by the browser in various ways so there is no way to distinguish usage that should be migrated from usage that cannot be altered.

# 0.9.7

- :warning: `q.min.js` is no longer checked-in. It is however still created by Grunt and NPM.
- Fixes a bug that inhibited `Q.async` with implementations of the new ES6 generators.
- Fixes a bug with `nextTick` affecting Safari 6.0.5 the first time a page loads when an `iframe` is involved.
- Introduces `passByCopy`, `join`, and `race`.
- Shows stack traces or error messages on the console, instead of `Error` objects.
- Elimintates wrapper methods for improved performance.
- `Q.all` now propagates progress notifications of the form you might expect of ES6 iterations, `{value, index}` where the `value` is the progress notification from the promise at `index`.

# 0.9.6

- Fixes a bug in recognizing the difference between compatible Q promises, and Q promises from before the implementation of "inspect". The latter are now coerced.
- Fixes an infinite asynchronous coercion cycle introduced by former solution, in two independently sufficient ways. 1.) All promises returned by makePromise now implement "inspect", albeit a default that reports that the promise has an "unknown" state. 2.) The implementation of "then/when" is now in "then" instead of "when", so that the responsibility to "coerce" the given promise rests solely in the "when" method and the "then" method may assume that "this" is a promise of the right type.
- Refactors `nextTick` to use an unrolled microtask within Q regardless of how new ticks a requested. #316 @rkatic

# 0.9.5

- Introduces `inspect` for getting the state of a promise as `{state: "fulfilled" | "rejected" | "pending", value | reason}`.
- Introduces `allSettled` which produces an array of promises states for the input promises once they have all "settled". This is in accordance with a discussion on Promises/A+ that "settled" refers to a promise that is "fulfilled" or "rejected". "resolved" refers to a deferred promise that has been "resolved" to another promise, "sealing its fate" to the fate of the successor promise.
- Long stack traces are now off by default. Set `Q.longStackSupport` to true to enable long stack traces.
- Long stack traces can now follow the entire asynchronous history of a promise, not just a single jump.
- Introduces `spawn` for an immediately invoked asychronous generator. @jlongster
- Support for experimental synonyms `mapply`, `mcall`, `nmapply`, `nmcall` for method invocation.

# 0.9.4

- `isPromise` and `isPromiseAlike` now always returns a boolean (even for falsy values). #284 @lfac-pt
- Support for ES6 Generators in `async` #288 @andywingo
- Clear duplicate promise rejections from dispatch methods #238 @SLaks
- Unhandled rejection API #296 @domenic `stopUnhandledRejectionTracking`, `getUnhandledReasons`, `resetUnhandledRejections`.

# 0.9.3

- Add the ability to give `Q.timeout`'s errors a custom error message. #270 @jgrenon
- Fix Q's call-stack busting behavior in Node.js 0.10, by switching from `process.nextTick` to `setImmediate`. #254 #259
- Fix Q's behavior when used with the Mocha test runner in the browser, since Mocha introduces a fake `process` global without a `nextTick` property. #267
- Fix some, but not all, cases wherein Q would give false positives in its unhandled rejection detection (#252). A fix for other cases (#238) is hopefully coming soon.
- Made `Q.promise` throw early if given a non-function.

# 0.9.2

- Pass through progress notifications when using `timeout`. #229 @omares
- Pass through progress notifications when using `delay`.
- Fix `nbind` to actually bind the `thisArg`. #232 @davidpadbury

# 0.9.1

- Made the AMD detection compatible with the RequireJS optimizer's `namespace` option. #225 @terinjokes
- Fix side effects from `valueOf`, and thus from `isFulfilled`, `isRejected`, and `isPending`. #226 @benjamn

# 0.9.0

This release removes many layers of deprecated methods and brings Q closer to alignment with Mark Miller’s TC39 strawman for concurrency. At the same time, it fixes many bugs and adds a few features around error handling. Finally, it comes with an updated and comprehensive API Reference.

## API Cleanup

The following deprecated or undocumented methods have been removed. Their replacements are listed here:

0.8.x method

0.9 replacement </thead> <tbody>

`Q.ref`

`Q`

`call`, `apply`, `bind` (*)

`fcall`/`invoke`, `fapply`/`post`, `fbind`

`ncall`, `napply` (*)

`nfcall`/`ninvoke`, `nfapply`/`npost`

`end`

`done`

`put`

`set`

`node`

`nbind`

`nend`

`nodeify`

`isResolved`

`isPending`

`deferred.node`

`deferred.makeNodeResolver`

`Method`, `sender`

`dispatcher`

`send`

`dispatch`

`view`, `viewInfo`

(none) </tbody>

(*) Use of `thisp` is discouraged. For calling methods, use `post` or `invoke`.

## Alignment with the Concurrency Strawman

- Q now exports a `Q(value)` function, an alias for `resolve`. `Q.call`, `Q.apply`, and `Q.bind` were removed to make room for the same methods on the function prototype.
- `invoke` has been aliased to `send` in all its forms.
- `post` with no method name acts like `fapply`.

## Error Handling

- Long stack traces can be turned off by setting `Q.stackJumpLimit` to zero. In the future, this property will be used to fine tune how many stack jumps are retained in long stack traces; for now, anything nonzero is treated as one (since Q only tracks one stack jump at the moment, see #144). #168
- In Node.js, if there are unhandled rejections when the process exits, they are output to the console. #115

## Other

- `delete` and `set` (née `put`) no longer have a fulfillment value.
- Q promises are no longer frozen, which helps with performance.
- `thenReject` is now included, as a counterpart to `thenResolve`.
- The included browser `nextTick` shim is now faster. #195 @rkatic.

## Bug Fixes

- Q now works in Internet Explorer 10. #186 @ForbesLindesay
- `fbind` no longer hard-binds the returned function's `this` to `undefined`. #202
- `Q.reject` no longer leaks memory. #148
- `npost` with no arguments now works. #207
- `allResolved` now works with non-Q promises ("thenables"). #179
- `keys` behavior is now correct even in browsers without native `Object.keys`. #192 @rkatic
- `isRejected` and the `exception` property now work correctly if the rejection reason is falsy. #198

## Internals and Advanced

- The internal interface for a promise now uses `dispatchPromise(resolve, op, operands)` instead of `sendPromise(op, resolve, ...operands)`, which reduces the cases where Q needs to do argument slicing.
- The internal protocol uses different operands. "put" is now "set". "del" is now "delete". "view" and "viewInfo" have been removed.
- `Q.fulfill` has been added. It is distinct from `Q.resolve` in that it does not pass promises through, nor coerces promises from other systems. The promise becomes the fulfillment value. This is only recommended for use when trying to fulfill a promise with an object that has a `then` function that is at the same time not a promise.

# 0.8.12

- Treat foreign promises as unresolved in `Q.isFulfilled`; this lets `Q.all` work on arrays containing foreign promises. #154
- Fix minor incompliances with the Promises/A+ spec and test suite. #157 #158

# 0.8.11

- Added `nfcall`, `nfapply`, and `nfbind` as `thisp`-less versions of `ncall`, `napply`, and `nbind`. The latter are now deprecated. #142
- Long stack traces no longer cause linearly-growing memory usage when chaining promises together. #111
- Inspecting `error.stack` in a rejection handler will now give a long stack trace. #103
- Fixed `Q.timeout` to clear its timeout handle when the promise is rejected; previously, it kept the event loop alive until the timeout period expired. #145 @dfilatov
- Added `q/queue` module, which exports an infinite promise queue constructor.

# 0.8.10

- Added `done` as a replacement for `end`, taking the usual fulfillment, rejection, and progress handlers. It's essentially equivalent to `then(f, r, p).end()`.
- Added `Q.onerror`, a settable error trap that you can use to get full stack traces for uncaught errors. #94
- Added `thenResolve` as a shortcut for returning a constant value once a promise is fulfilled. #108 @ForbesLindesay
- Various tweaks to progress notification, including propagation and transformation of progress values and only forwarding a single progress object.
- Renamed `nend` to `nodeify`. It no longer returns an always-fulfilled promise when a Node callback is passed.
- `deferred.resolve` and `deferred.reject` no longer (sometimes) return `deferred.promise`.
- Fixed stack traces getting mangled if they hit `end` twice. #116 #121 @ef4
- Fixed `ninvoke` and `npost` to work on promises for objects with Node methods. #134
- Fixed accidental coercion of objects with nontrivial `valueOf` methods, like `Date`s, by the promise's `valueOf` method. #135
- Fixed `spread` not calling the passed rejection handler if given a rejected promise.

# 0.8.9

- Added `nend`
- Added preliminary progress notification support, via `promise.then(onFulfilled, onRejected, onProgress)`, `promise.progress(onProgress)`, and `deferred.notify(...progressData)`.
- Made `put` and `del` return the object acted upon for easier chaining. #84
- Fixed coercion cycles with cooperating promises. #106

# 0.8.7

- Support Montage Require

# 0.8.6

- Fixed `npost` and `ninvoke` to pass the correct `thisp`. #74
- Fixed various cases involving unorthodox rejection reasons. #73 #90 @ef4
- Fixed double-resolving of misbehaved custom promises. #75
- Sped up `Q.all` for arrays contain already-resolved promises or scalar values. @ForbesLindesay
- Made stack trace filtering work when concatenating assets. #93 @ef4
- Added warnings for deprecated methods. @ForbesLindesay
- Added `.npmignore` file so that dependent packages get a slimmer `node_modules` directory.

# 0.8.5

- Added preliminary support for long traces (@domenic)
- Added `fapply`, `fcall`, `fbind` for non-thisp promised function calls.
- Added `return` for async generators, where generators are implemented.
- Rejected promises now have an "exception" property. If an object isRejected(object), then object.valueOf().exception will be the wrapped error.
- Added Jasmine specifications
- Support Internet Explorers 7–9 (with multiple bug fixes @domenic)
- Support Firefox 12
- Support Safari 5.1.5
- Support Chrome 18

# 0.8.4

- WARNING: `promise.timeout` is now rejected with an `Error` object and the message now includes the duration of the timeout in miliseconds. This doesn't constitute (in my opinion) a backward-incompatibility since it is a change of an undocumented and unspecified public behavior, but if you happened to depend on the exception being a string, you will need to revise your code.
- Added `deferred.makeNodeResolver()` to replace the more cryptic `deferred.node()` method.
- Added experimental `Q.promise(maker(resolve, reject))` to make a promise inside a callback, such that thrown exceptions in the callback are converted and the resolver and rejecter are arguments. This is a shorthand for making a deferred directly and inspired by @gozala’s stream constructor pattern and the Microsoft Windows Metro Promise constructor interface.
- Added experimental `Q.begin()` that is intended to kick off chains of `.then` so that each of these can be reordered without having to edit the new and former first step.

# 0.8.3

- Added `isFulfilled`, `isRejected`, and `isResolved` to the promise prototype.
- Added `allResolved` for waiting for every promise to either be fulfilled or rejected, without propagating an error. @utvara #53
- Added `Q.bind` as a method to transform functions that return and throw into promise-returning functions. See an example. @domenic
- Renamed `node` export to `nbind`, and added `napply` to complete the set. `node` remains as deprecated. @domenic #58
- Renamed `Method` export to `sender`. `Method` remains as deprecated and will be removed in the next major version since I expect it has very little usage.
- Added browser console message indicating a live list of unhandled errors.
- Added support for `msSetImmediate` (IE10) or `setImmediate` (available via polyfill) as a browser-side `nextTick` implementation. #44 #50 #59
- Stopped using the event-queue dependency, which was in place for Narwhal support: now directly using `process.nextTick`.
- WARNING: EXPERIMENTAL: added `finally` alias for `fin`, `catch` alias for `fail`, `try` alias for `call`, and `delete` alias for `del`. These properties are enquoted in the library for cross-browser compatibility, but may be used as property names in modern engines.

# 0.8.2

- Deprecated `ref` in favor of `resolve` as recommended by @domenic.
- Update event-queue dependency.

# 0.8.1

- Fixed Opera bug. #35 @cadorn
- Fixed `Q.all([])` #32 @domenic

# 0.8.0

- WARNING: `enqueue` removed. Use `nextTick` instead. This is more consistent with NodeJS and (subjectively) more explicit and intuitive.
- WARNING: `def` removed. Use `master` instead. The term `def` was too confusing to new users.
- WARNING: `spy` removed in favor of `fin`.
- WARNING: `wait` removed. Do `all(args).get(0)` instead.
- WARNING: `join` removed. Do `all(args).spread(callback)` instead.
- WARNING: Removed the `Q` function module.exports alias for `Q.ref`. It conflicts with `Q.apply` in weird ways, making it uncallable.
- Revised `delay` so that it accepts both `(value, timeout)` and `(timeout)` variations based on arguments length.
- Added `ref().spread(cb(...args))`, a variant of `then` that spreads an array across multiple arguments. Useful with `all()`.
- Added `defer().node()` Node callback generator. The callback accepts `(error, value)` or `(error, ...values)`. For multiple value arguments, the fulfillment value is an array, useful in conjunction with `spread`.
- Added `node` and `ncall`, both with the signature `(fun, thisp_opt, ...args)`. The former is a decorator and the latter calls immediately. `node` optional binds and partially applies. `ncall` can bind and pass arguments.

# 0.7.2

- Fixed thenable promise assimilation.

# 0.7.1

- Stopped shimming `Array.prototype.reduce`. The enumerable property has bad side-effects. Libraries that depend on this (for example, QQ) will need to be revised.

# 0.7.0 - BACKWARD INCOMPATIBILITY

- WARNING: Removed `report` and `asap`
- WARNING: The `callback` argument of the `fin` function no longer receives any arguments. Thus, it can be used to call functions that should not receive arguments on resolution. Use `when`, `then`, or `fail` if you need a value.
- IMPORTANT: Fixed a bug in the use of `MessageChannel` for `nextTick`.
- Renamed `enqueue` to `nextTick`.
- Added experimental `view` and `viewInfo` for creating views of promises either when or before they're fulfilled.
- Shims are now externally applied so subsequent scripts or dependees can use them.
- Improved minification results.
- Improved readability.

# 0.6.0 - BACKWARD INCOMPATIBILITY

- WARNING: In practice, the implementation of `spy` and the name `fin` were useful. I've removed the old `fin` implementation and renamed/aliased `spy`.
- The "q" module now exports its `ref` function as a "Q" constructor, with module systems that support exports assignment including NodeJS, RequireJS, and when used as a `<script>` tag. Notably, strictly compliant CommonJS does not support this, but UncommonJS does.
- Added `async` decorator for generators that use yield to "trampoline" promises. In engines that support generators (SpiderMonkey), this will greatly reduce the need for nested callbacks.
- Made `when` chainable.
- Made `all` chainable.

# 0.5.3

- Added `all` and refactored `join` and `wait` to use it. All of these will now reject at the earliest rejection.

# 0.5.2

- Minor improvement to `spy`; now waits for resolution of callback promise.

# 0.5.1

- Made most Q API methods chainable on promise objects, and turned the previous promise-methods of `join`, `wait`, and `report` into Q API methods.
- Added `apply` and `call` to the Q API, and `apply` as a promise handler.
- Added `fail`, `fin`, and `spy` to Q and the promise prototype for convenience when observing rejection, fulfillment and rejection, or just observing without affecting the resolution.
- Renamed `def` (although `def` remains shimmed until the next major release) to `master`.
- Switched to using `MessageChannel` for next tick task enqueue in browsers that support it.

# 0.5.0 - MINOR BACKWARD INCOMPATIBILITY

- Exceptions are no longer reported when consumed.
- Removed `error` from the API. Since exceptions are getting consumed, throwing them in an errback causes the exception to silently disappear. Use `end`.
- Added `end` as both an API method and a promise-chain ending method. It causes propagated rejections to be thrown, which allows Node to write stack traces and emit `uncaughtException` events, and browsers to likewise emit `onerror` and log to the console.
- Added `join` and `wait` as promise chain functions, so you can wait for variadic promises, returning your own promise back, or join variadic promises, resolving with a callback that receives variadic fulfillment values.

# 0.4.4

- `end` no longer returns a promise. It is the end of the promise chain.
- Stopped reporting thrown exceptions in `when` callbacks and errbacks. These must be explicitly reported through `.end()`, `.then(null, Q.error)`, or some other mechanism.
- Added `report` as an API method, which can be used as an errback to report and propagate an error.
- Added `report` as a promise-chain method, so an error can be reported if it passes such a gate.

# 0.4.3

- Fixed `<script>` support that regressed with 0.4.2 because of "use strict" in the module system multi-plexer.

# 0.4.2

- Added support for RequireJS (jburke)

# 0.4.1

- Added an "end" method to the promise prototype, as a shorthand for waiting for the promise to be resolved gracefully, and failing to do so, to dump an error message.

# 0.4.0 - BACKWARD INCOMPATIBLE*

- *Removed the utility modules. NPM and Node no longer expose any module except the main module. These have been moved and merged into the "qq" package.
- *In a non-CommonJS browser, q.js can be used as a script. It now creates a Q global variable.
- Fixed thenable assimilation.
- Fixed some issues with asap, when it resolves to undefined, or throws an exception.

# 0.3.0 - BACKWARD-INCOMPATIBLE

- The `post` method has been reverted to its original signature, as provided in Tyler Close's `ref_send` API. That is, `post` accepts two arguments, the second of which is an arbitrary object, but usually invocation arguments as an `Array`. To provide variadic arguments to `post`, there is a new `invoke` function that posts the variadic arguments to the value given in the first argument.
- The `defined` method has been moved from `q` to `q/util` since it gets no use in practice but is still theoretically useful.
- The `Promise` constructor has been renamed to `makePromise` to be consistent with the convention that functions that do not require the `new` keyword to be used as constructors have camelCase names.
- The `isResolved` function has been renamed to `isFulfilled`. There is a new `isResolved` function that indicates whether a value is not a promise or, if it is a promise, whether it has been either fulfilled or rejected. The code has been revised to reflect this nuance in terminology.

# 0.2.10

- Added `join` to `"q/util"` for variadically joining multiple promises.

# 0.2.9

- The future-compatible `invoke` method has been added, to replace `post`, since `post` will become backward- incompatible in the next major release.
- Exceptions thrown in the callbacks of a `when` call are now emitted to Node's `"uncaughtException"` `process` event in addition to being returned as a rejection reason.

# 0.2.8

- Exceptions thrown in the callbacks of a `when` call are now consumed, warned, and transformed into rejections of the promise returned by `when`.

# 0.2.7

- Fixed a minor bug in thenable assimilation, regressed because of the change in the forwarding protocol.
- Fixed behavior of "q/util" `deep` method on dates and other primitives. Github issue #11.

# 0.2.6

- Thenables (objects with a "then" method) are accepted and provided, bringing this implementation of Q into conformance with Promises/A, B, and D.
- Added `makePromise`, to replace the `Promise` function eventually.
- Rejections are now also duck-typed. A rejection is a promise with a valueOf method that returns a rejection descriptor. A rejection descriptor has a "promiseRejected" property equal to "true" and a "reason" property corresponding to the rejection reason.
- Altered the `makePromise` API such that the `fallback` method no longer receives a superfluous `resolved` method after the `operator`. The fallback method is responsible only for returning a resolution. This breaks an undocumented API, so third-party API's depending on the previous undocumented behavior may break.

# 0.2.5

- Changed promises into a duck-type such that multiple instances of the Q module can exchange promise objects. A promise is now defined as "an object that implements the `promiseSend(op, resolved, ...)` method and `valueOf`".
- Exceptions in promises are now captured and returned as rejections.

# 0.2.4

- Fixed bug in `ref` that prevented `del` messages from being received (gozala)
- Fixed a conflict with FireFox 4; constructor property is now read-only.

# 0.2.3

- Added `keys` message to promises and to the promise API.

# 0.2.2

- Added boilerplate to `q/queue` and `q/util`.
- Fixed missing dependency to `q/queue`.

# 0.2.1

- The `resolve` and `reject` methods of `defer` objects now return the resolution promise for convenience.
- Added `q/util`, which provides `step`, `delay`, `shallow`, `deep`, and three reduction orders.
- Added `q/queue` module for a promise `Queue`.
- Added `q-comm` to the list of compatible libraries.
- Deprecated `defined` from `q`, with intent to move it to `q/util`.

# 0.2.0 - BACKWARD INCOMPATIBLE

- Changed post(ref, name, args) to variadic post(ref, name, ...args). BACKWARD INCOMPATIBLE
- Added a def(value) method to annotate an object as being necessarily a local value that cannot be serialized, such that inter-process/worker/vat promise communication libraries will send messages to it, but never send it back.
- Added a send(value, op, ...args) method to the public API, for forwarding messages to a value or promise in a future turn.

# 0.1.9

- Added isRejected() for testing whether a value is a rejected promise. isResolved() retains the behavior of stating that rejected promises are not resolved.

# 0.1.8

- Fixed isResolved(null) and isResolved(undefined) [issue #9]
- Fixed a problem with the Object.create shim

# 0.1.7

- shimmed ES5 Object.create in addition to Object.freeze for compatibility on non-ES5 engines (gozala)

# 0.1.6

- Q.isResolved added
- promise.valueOf() now returns the value of resolved and near values
- asap retried
- promises are frozen when possible

# 0.1.5

- fixed dependency list for Teleport (gozala)
- all unit tests now pass (gozala)

# 0.1.4

- added support for Teleport as an engine (gozala)
- simplified and updated methods for getting internal print and enqueue functions universally (gozala)

# 0.1.3

- fixed erroneous link to the q module in package.json

# 0.1.2

- restructured for overlay style package compatibility

# 0.1.0

- removed asap because it was broken, probably down to the philosophy.

# 0.0.3

- removed q-util
- fixed asap so it returns a value if completed

# 0.0.2

- added q-util

# 0.0.1

- initial version