@types/q

Variables

• longStackSupport

Functions

• all()
• allResolved()
• allSettled()
• async()
• defer()
• delay()
• denodeify()
• fbind()
• fcall()
• invoke()
• isFulfilled()
• isPending()
• isPromise()
• isPromiseAlike()
• isRejected()
• mcall()
• nbind()
• nearer()
• nextTick()
• nfapply()
• nfbind()
• nfcall()
• ninvoke()
• noConflict()
• npost()
• nsend()
• onerror()
• Promise()
• promised()
• Q()
• race()
• reject()
• resolve()
• send()
• spread()
• timeout()
• try()
• when()

Interfaces

• Deferred

  • makeNodeResolver()
  • notify()
  • promise
  • reject()
  • resolve()
• Promise

  • catch()
  • delay()
  • delete()
  • done()
  • fail()
  • fapply()
  • fcall()
  • fin()
  • finally()
  • get()
  • inspect()
  • invoke()
  • isFulfilled()
  • isPending()
  • isRejected()
  • keys()
  • nodeify()
  • post()
  • progress()
  • set()
  • spread()
  • tap()
  • then()
  • thenReject()
  • thenResolve()
  • timeout()
  • valueOf()
• PromiseState

  • reason
  • state
  • value

Type Aliases

• IPromise
• IWhenable

variable longStackSupport

let longStackSupport: boolean;

• A settable property that lets you turn on long stack trace support. If turned on, "stack jumps" will be tracked across asynchronous promise operations, so that if an uncaught error is thrown by done or a rejection reason's stack property is inspected in a rejection callback, a long stack trace is produced.

function all

all: {
    <A, B, C, D, E, F>(
        promises: IWhenable<
            [
                IWhenable<A>,
                IWhenable<B>,
                IWhenable<C>,
                IWhenable<D>,
                IWhenable<E>,
                IWhenable<F>
            ]
        >
    ): Promise<[A, B, C, D, E, F]>;
    <A, B, C, D, E>(
        promises: IWhenable<
            [IWhenable<A>, IWhenable<B>, IWhenable<C>, IWhenable<D>, IWhenable<E>]
        >
    ): Promise<[A, B, C, D, E]>;
    <A, B, C, D>(
        promises: IWhenable<[IWhenable<A>, IWhenable<B>, IWhenable<C>, IWhenable<D>]>
    ): Promise<[A, B, C, D]>;
    <A, B, C>(
        promises: IWhenable<[IWhenable<A>, IWhenable<B>, IWhenable<C>]>
    ): Promise<[A, B, C]>;
    <A, B>(promises: IWhenable<[IPromise<A>, IPromise<B>]>): Promise<[A, B]>;
    <A, B>(promises: IWhenable<[A, IPromise<B>]>): Promise<[A, B]>;
    <A, B>(promises: IWhenable<[IPromise<A>, B]>): Promise<[A, B]>;
    <A, B>(promises: IWhenable<[A, B]>): Promise<[A, B]>;
    <T>(promises: IWhenable<IWhenable<T>[]>): Promise<T[]>;
};

• Returns a promise that is fulfilled with an array containing the fulfillment value of each promise, or is rejected with the same rejection reason as the first promise to be rejected.

function allResolved

allResolved: <T>(
    promises: IWhenable<Array<IWhenable<T>>>
) => Promise<Promise<T>[]>;

• Deprecated Alias for allSettled()

function allSettled

allSettled: <T>(
    promises: IWhenable<Array<IWhenable<T>>>
) => Promise<PromiseState<T>[]>;

• Returns a promise that is fulfilled with an array of promise state snapshots, but only after all the original promises have settled, i.e. become either fulfilled or rejected.

function async

async: <T>(generatorFunction: any) => (...args: any[]) => Promise<T>;

• This is an experimental tool for converting a generator function into a deferred function. This has the potential of reducing nested callbacks in engines that support yield.

function defer

defer: <T>() => Deferred<T>;

• Returns a "deferred" object with a: promise property resolve(value) method reject(reason) method notify(value) method makeNodeResolver() method

function delay

delay: {
    <T>(promiseOrValue: T | Promise<T>, ms: number): Promise<T>;
    (ms: number): Promise<void>;
};

• Returns a promise that will have the same result as promise, but will only be fulfilled or rejected after at least ms milliseconds have passed.

• Returns a promise that will be fulfilled with undefined after at least ms milliseconds have passed.

function denodeify

denodeify: <T>(
    nodeFunction: (...args: any[]) => any,
    ...args: any[]
) => (...args: any[]) => Promise<T>;

• Alias for nfbind()

function fbind

fbind: <T>(
    method: (...args: any[]) => IWhenable<T>,
    ...args: any[]
) => (...args: any[]) => Promise<T>;

• (Deprecated) Returns a new function that calls a function asynchronously with the given variadic arguments, and returns a promise. Notably, any synchronous return values or thrown exceptions are transformed, respectively, into fulfillment values or rejection reasons for the promise returned by this new function. This method is especially useful in its static form for wrapping functions to ensure that they are always asynchronous, and that any thrown exceptions (intentional or accidental) are appropriately transformed into a returned rejected promise. For example:

  Example 1

  var getUserData = Q.fbind(function (userName) { if (!userName) { throw new Error("userName must be truthy!"); } if (localCache.has(userName)) { return localCache.get(userName); } return getUserFromCloud(userName); });

function fcall

fcall: <T>(method: (...args: any[]) => T, ...args: any[]) => Promise<T>;

• Returns a promise for the result of calling a function, with the given variadic arguments. Has the same return value/thrown exception translation as explained above for fbind. In its static form, it is aliased as Q.try, since it has semantics similar to a try block (but handling both synchronous exceptions and asynchronous rejections). This allows code like

  Example 1

  Q.try(function () { if (!isConnectedToCloud()) { throw new Error("The cloud is down!"); } return syncToCloud(); }) .catch(function (error) { console.error("Couldn't sync to the cloud", error); });

function invoke

invoke: <T>(obj: any, functionName: string, ...args: any[]) => Promise<T>;

• Returns a promise for the result of calling the named method of an object with the given variadic arguments. The object itself is this in the function, just like a synchronous method call.

function isFulfilled

isFulfilled: (promise: Promise<any>) => boolean;

• Returns whether a given promise is in the fulfilled state. When the static version is used on non-promises, the result is always true.

function isPending

isPending: (promiseOrObject: any) => boolean;

• Returns whether a given promise is in the pending state. When the static version is used on non-promises, the result is always false.

function isPromise

isPromise: (object: any) => object is Promise<any>;

• Returns whether the given value is a Q promise.

function isPromiseAlike

isPromiseAlike: (object: any) => object is IPromise<any>;

• Returns whether the given value is a promise (i.e. it's an object with a then function).

function isRejected

isRejected: (promise: Promise<any>) => boolean;

• Returns whether a given promise is in the rejected state. When the static version is used on non-promises, the result is always false.

function mcall

mcall: <T>(obj: any, functionName: string, ...args: any[]) => Promise<T>;

• Alias for invoke()

function nbind

nbind: <T>(
    nodeFunction: (...args: any[]) => any,
    thisArg: any,
    ...args: any[]
) => (...args: any[]) => Promise<T>;

• Creates a promise-returning function from a Node.js-style method, optionally binding it with the given variadic arguments. An example:

  Example 1

  var Kitty = mongoose.model("Kitty"); var findKitties = Q.nbind(Kitty.find, Kitty); findKitties({ cute: true }).done(function (theKitties) { //... });

function nearer

nearer: <T>(promise: Promise<T>) => T;

• If an object is not a promise, it is as "near" as possible. If a promise is rejected, it is as "near" as possible too. If it's a fulfilled promise, the fulfillment value is nearer. If it's a deferred promise and the deferred has been resolved, the resolution is "nearer".

function nextTick

nextTick: (callback: (...args: any[]) => any) => void;

function nfapply

nfapply: <T>(nodeFunction: (...args: any[]) => any, args: any[]) => Promise<T>;

• Calls a Node.js-style function with the given array of arguments, returning a promise that is fulfilled if the Node.js function calls back with a result, or rejected if it calls back with an error (or throws one synchronously). An example:

  Example 1

  Q.nfapply(FS.readFile, ["foo.txt", "utf-8"]).done(function (text) { });

  Note that this example only works because FS.readFile is a function exported from a module, not a method on an object. For methods, e.g. redisClient.get, you must bind the method to an instance before passing it to Q.nfapply (or, generally, as an argument to any function call):

  Example 2

  Q.nfapply(redisClient.get.bind(redisClient), ["user:1:id"]).done(function (user) { });

  The better strategy for methods would be to use Q.npost, as shown below.

function nfbind

nfbind: <T>(
    nodeFunction: (...args: any[]) => any,
    ...args: any[]
) => (...args: any[]) => Promise<T>;

• Creates a promise-returning function from a Node.js-style function, optionally binding it with the given variadic arguments. An example:

  Example 1

  var readFile = Q.nfbind(FS.readFile); readFile("foo.txt", "utf-8").done(function (text) { //... });

  Note that if you have a method that uses the Node.js callback pattern, as opposed to just a function, you will need to bind its this value before passing it to nfbind, like so:

  Example 2

  var Kitty = mongoose.model("Kitty"); var findKitties = Q.nfbind(Kitty.find.bind(Kitty));

  The better strategy for methods would be to use Q.nbind, as shown below.

function nfcall

nfcall: <T>(nodeFunction: (...args: any[]) => any, ...args: any[]) => Promise<T>;

• Calls a Node.js-style function with the given variadic arguments, returning a promise that is fulfilled if the Node.js function calls back with a result, or rejected if it calls back with an error (or throws one synchronously). An example:

  Example 1

  Q.nfcall(FS.readFile, "foo.txt", "utf-8").done(function (text) { });

  The same warning about functions vs. methods applies for nfcall as it does for nfapply. In this case, the better strategy would be to use Q.ninvoke.

function ninvoke

ninvoke: <T>(
    nodeModule: any,
    functionName: string,
    ...args: any[]
) => Promise<T>;

• Calls a Node.js-style method with the given variadic arguments, returning a promise that is fulfilled if the method calls back with a result, or rejected if it calls back with an error (or throws one synchronously). An example:

  Example 1

  Q.ninvoke(redisClient, "get", "user:1:id").done(function (user) { });

function noConflict

noConflict: () => typeof Q;

• Resets the global "Q" variable to the value it has before Q was loaded. This will either be undefined if there was no version or the version of Q which was already loaded before.

  Returns

  The last version of Q.

function npost

npost: <T>(nodeModule: any, functionName: string, args: any[]) => Promise<T>;

• Calls a Node.js-style method with the given arguments array, returning a promise that is fulfilled if the method calls back with a result, or rejected if it calls back with an error (or throws one synchronously). An example:

  Example 1

  Q.npost(redisClient, "get", ["user:1:id"]).done(function (user) { });

function nsend

nsend: <T>(nodeModule: any, functionName: string, ...args: any[]) => Promise<T>;

• Alias for ninvoke()

function onerror

onerror: (reason: any) => void;

• A settable property that will intercept any uncaught errors that would otherwise be thrown in the next tick of the event loop, usually as a result of done. Can be useful for getting the full stack trace of an error in browsers, which is not usually possible with window.onerror.

function Promise

Promise: <T>(
    resolver: (
        resolve: (val?: IWhenable<T>) => void,
        reject: (reason?: any) => void,
        notify: (progress: any) => void
    ) => void
) => Promise<T>;

• Synchronously calls resolver(resolve, reject, notify) and returns a promise whose state is controlled by the functions passed to resolver. This is an alternative promise-creation API that has the same power as the deferred concept, but without introducing another conceptual entity. If resolver throws an exception, the returned promise will be rejected with that thrown exception as the rejection reason. note: In the latest github, this method is called Q.Promise, but if you are using the npm package version 0.9.7 or below, the method is called Q.promise (lowercase vs uppercase p).

function promised

promised: <T>(callback: (...args: any[]) => T) => (...args: any[]) => Promise<T>;

• Creates a new version of func that accepts any combination of promise and non-promise values, converting them to their fulfillment values before calling the original func. The returned version also always returns a promise: if func does a return or throw, then Q.promised(func) will return fulfilled or rejected promise, respectively. This can be useful for creating functions that accept either promises or non-promise values, and for ensuring that the function always returns a promise even in the face of unintentional thrown exceptions.

function Q

Q: typeof Q;

• If value is a Q promise, returns the promise. If value is a promise from another library it is coerced into a Q promise (where possible). If value is not a promise, returns a promise that is fulfilled with value.

• Calling with nothing at all creates a void promise

function race

race: <T>(promises: Array<IWhenable<T>>) => Promise<T>;

• Returns a promise for the first of an array of promises to become settled.

function reject

reject: <T>(reason?: any) => Promise<T>;

• Returns a promise that is rejected with reason.

function resolve

resolve: <T>(object?: IWhenable<T>) => Promise<T>;

• Calling resolve with a pending promise causes promise to wait on the passed promise, becoming fulfilled with its fulfillment value or rejected with its rejection reason (or staying pending forever, if the passed promise does). Calling resolve with a rejected promise causes promise to be rejected with the passed promise's rejection reason. Calling resolve with a fulfilled promise causes promise to be fulfilled with the passed promise's fulfillment value. Calling resolve with a non-promise value causes promise to be fulfilled with that value.

function send

send: <T>(obj: any, functionName: string, ...args: any[]) => Promise<T>;

• Alias for invoke()

function spread

spread: <T, U>(
    promises: Array<IWhenable<T>>,
    onFulfilled: (...args: T[]) => IWhenable<U>,
    onRejected?: (reason: any) => IWhenable<U>
) => Promise<U>;

• Like then, but "spreads" the array into a variadic fulfillment handler. If any of the promises in the array are rejected, instead calls onRejected with the first rejected promise's rejection reason. This is especially useful in conjunction with all.

function timeout

timeout: <T>(promise: Promise<T>, ms: number, message?: string) => Promise<T>;

• Returns a promise that will have the same result as promise, except that if promise is not fulfilled or rejected before ms milliseconds, the returned promise will be rejected with an Error with the given message. If message is not supplied, the message will be "Timed out after " + ms + " ms".

function try

try: <T>(method: (...args: any[]) => T, ...args: any[]) => Promise<T>

• Returns a promise for the result of calling a function, with the given variadic arguments. Has the same return value/thrown exception translation as explained above for fbind. In its static form, it is aliased as Q.try, since it has semantics similar to a try block (but handling both synchronous exceptions and asynchronous rejections). This allows code like

  Example 1

  Q.try(function () { if (!isConnectedToCloud()) { throw new Error("The cloud is down!"); } return syncToCloud(); }) .catch(function (error) { console.error("Couldn't sync to the cloud", error); });

function when

when: {
    (): Promise<void>;
    <T>(value: IWhenable<T>): Promise<T>;
    <T, U>(
        value: IWhenable<T>,
        onFulfilled: (val: T) => IWhenable<U>,
        onRejected?: (reason: any) => IWhenable<U>,
        onProgress?: (progress: any) => any
    ): Promise<U>;
};

type IPromise

type IPromise<T> = PromiseLike<T>;

type IWhenable

type IWhenable<T> = PromiseLike<T> | T;