<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.noConflict support for use in <script> (@jahnjw).<script> usage outright. #607Q_DEBUG=1.tap method to promises, which will see a value
pass through without alteration.code === ETIMEDOUT (Kornel Lesiński)^ version predicate
operator in any transitive dependency.Q.nextTick.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.StopIteration global to distinguish SpiderMonkey
generators from ES6 generators, assuming that they will never
coexist.: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.
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.q.min.js is no longer checked-in. It is however still
created by Grunt and NPM.Q.async with implementations of the new
ES6 generators.nextTick affecting Safari 6.0.5 the first time a
page loads when an iframe is involved.passByCopy, join, and race.Error objects.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.nextTick to use an unrolled microtask within Q regardless
of how new ticks a requested. #316 @rkaticinspect for getting the state of a promise as
{state: "fulfilled" | "rejected" | "pending", value | reason}.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.Q.longStackSupport
to true to enable long stack traces.spawn for an immediately invoked asychronous generator.
@jlongstermapply, mcall, nmapply,
nmcall for method invocation.isPromise and isPromiseAlike now always returns a boolean
(even for falsy values). #284 @lfac-ptasync #288 @andywingostopUnhandledRejectionTracking, getUnhandledReasons,
resetUnhandledRejections.Q.timeout's errors a custom error message. #270
@jgrenonprocess.nextTick to setImmediate. #254 #259process global without a nextTick property. #267Q.promise throw early if given a non-function.timeout. #229 @omaresdelay.nbind to actually bind the thisArg. #232 @davidpadburynamespace
option. #225 @terinjokesvalueOf, and thus from isFulfilled, isRejected,
and isPending. #226 @benjamnThis 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.
The following deprecated or undocumented methods have been removed. Their replacements are listed here:
| 0.8.x method | 0.9 replacement |
|---|---|
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) |
(*) Use of thisp is discouraged. For calling methods, use post or
invoke.
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.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). #168delete and set (née put) no longer have a fulfillment value.thenReject is now included, as a counterpart to thenResolve.nextTick shim is now faster. #195 @rkatic.fbind no longer hard-binds the returned function's this to undefined.Q.reject no longer leaks memory. #148npost with no arguments now works. #207allResolved now works with non-Q promises ("thenables"). #179keys behavior is now correct even in browsers without native
Object.keys. #192 @rkaticisRejected and the exception property now work correctly if the
rejection reason is falsy. #198dispatchPromise(resolve, op, operands) instead of sendPromise(op, resolve, ...operands), which reduces the cases where Q needs to do
argument slicing.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.Q.isFulfilled; this lets Q.all
work on arrays containing foreign promises. #154nfcall, nfapply, and nfbind as thisp-less versions of
ncall, napply, and nbind. The latter are now deprecated. #142error.stack in a rejection handler will now give a long stack
trace. #103Q.timeout to clear its timeout handle when the promise is rejected;
previously, it kept the event loop alive until the timeout period expired.q/queue module, which exports an infinite promise queue
constructor.done as a replacement for end, taking the usual fulfillment,
rejection, and progress handlers. It's essentially equivalent to
then(f, r, p).end().Q.onerror, a settable error trap that you can use to get full stack
traces for uncaught errors. #94thenResolve as a shortcut for returning a constant value once a
promise is fulfilled. #108 @ForbesLindesaynend 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.end twice. #116 #121 @ef4ninvoke and npost to work on promises for objects with Node
methods. #134valueOf methods,
like Dates, by the promise's valueOf method. #135spread not calling the passed rejection handler if given a rejected
promise.nendpromise.then(onFulfilled, onRejected, onProgress),
promise.progress(onProgress), and deferred.notify(...progressData).put and del return the object acted upon for easier chaining.npost and ninvoke to pass the correct thisp. #74Q.all for arrays contain already-resolved promises or scalar
values. @ForbesLindesay.npmignore file so that dependent packages get a slimmer
node_modules directory.fapply, fcall, fbind for non-thisp
promised function calls.return for async generators, where generators
are implemented.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.deferred.makeNodeResolver() to replace the more cryptic
deferred.node() method.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.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.isFulfilled, isRejected, and isResolved
to the promise prototype.allResolved for waiting for every promise to either be
fulfilled or rejected, without propagating an error. @utvara #53Q.bind as a method to transform functions that
return and throw into promise-returning functions. See
an example. @domenicnode export to nbind, and added napply to
complete the set. node remains as deprecated. @domenic #58Method export to sender. Method
remains as deprecated and will be removed in the next
major version since I expect it has very little usage.msSetImmediate (IE10) or setImmediate
(available via polyfill)
as a browser-side nextTick implementation. #44 #50 #59process.nextTick.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.ref in favor of resolve as recommended by
@domenic.Q.all([]) #32 @domenicenqueue removed. Use nextTick instead.
This is more consistent with NodeJS and (subjectively)
more explicit and intuitive.def removed. Use master instead. The
term def was too confusing to new users.spy removed in favor of fin.wait removed. Do all(args).get(0) instead.join removed. Do all(args).spread(callback) instead.Q function module.exports alias
for Q.ref. It conflicts with Q.apply in weird
ways, making it uncallable.delay so that it accepts both (value, timeout) and (timeout) variations based on
arguments length.ref().spread(cb(...args)), a variant of
then that spreads an array across multiple arguments.
Useful with all().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.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.Array.prototype.reduce. The
enumerable property has bad side-effects. Libraries that
depend on this (for example, QQ) will need to be revised.report and asapcallback 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.MessageChannel
for nextTick.enqueue to nextTick.view and viewInfo for creating
views of promises either when or before they're
fulfilled.spy and
the name fin were useful. I've removed the old
fin implementation and renamed/aliased spy.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.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.when chainable.all chainable.all and refactored join and wait to use
it. All of these will now reject at the earliest
rejection.spy; now waits for resolution of
callback promise.join,
wait, and report into Q API methods.apply and call to the Q API, and apply
as a promise handler.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.def (although def remains shimmed until
the next major release) to master.MessageChannel for next tick task
enqueue in browsers that support it.error from the API. Since exceptions are
getting consumed, throwing them in an errback causes the
exception to silently disappear. Use end.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.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.end no longer returns a promise. It is the end of the
promise chain.when callbacks
and errbacks. These must be explicitly reported through
.end(), .then(null, Q.error), or some other
mechanism.report as an API method, which can be used as
an errback to report and propagate an error.report as a promise-chain method, so an error
can be reported if it passes such a gate.<script> support that regressed with 0.4.2
because of "use strict" in the module system
multi-plexer.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.defined method has been moved from q to q/util
since it gets no use in practice but is still
theoretically useful.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.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.join to "q/util" for variadically joining
multiple promises.invoke method has been added,
to replace post, since post will become backward-
incompatible in the next major release.when call are
now emitted to Node's "uncaughtException" process
event in addition to being returned as a rejection reason.when call
are now consumed, warned, and transformed into
rejections of the promise returned by when.deep method on dates and
other primitives. Github issue #11.makePromise, to replace the Promise function
eventually.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.promiseSend(op, resolved, ...) method and valueOf".ref that prevented del messages from
being received (gozala)keys message to promises and to the promise API.q/queue and q/util.q/queue.resolve and reject methods of defer objects now
return the resolution promise for convenience.q/util, which provides step, delay, shallow,
deep, and three reduction orders.q/queue module for a promise Queue.q-comm to the list of compatible libraries.defined from q, with intent to move it to
q/util.