Resolves to the first function that resolves, otherwise rejects.
Calls the given functions in sequence, passing the result onto the next as a Promise rather than a value.
Unlike waterfall which passes resolved values, you can use this to combine
other Promise consuming functions like branch.
A function that only resolves. Useful in branch and if you want to ignore
errors.
Returns a Promise which resolves or rejects based on a given function.
This is a functional alternative to using new Promise().
Takes an array or object map of promises and only resolves when all values resolve, rejecting otherwise.
The resulting value is an array or object map of the resolved values from each Promise.
If any of the promises reject, the entire function will reject with that reason.
Passing an array is equivalent to using Promise.all().
Reverses the result of a Promise. So a rejected Promise becomes resolved and a resolved Promise becomes rejected.
When resolved, it provides the rejected error. When rejected, provides a generic error.
Creates an Error with the given message. This is a functional alternative to
new Error().
Creates a rejected Promise with the given Error.
Use reason() to neatly pass an error.
This is an alternative to Promise.reject().
Passes a given value to each function, finally resolving to the same value.
If any of the functions reject, the entire function will reject with that reason.
You can think of this like a Relay Race in sports. The baton is the passed to the next runner and doesn't change. If a runner drops the baton, the other runners won't receive the baton and the team fails.
Resolves to a Promise which rejects if the given value is null or undefined, otherwise resolves with that value.
Creates a resolved Promise with the given value.
This is an alternative to Promise.resolve().
Takes an object map and calls the given functions sequentially, assigning key-values from each step and passing the result onto the next.
If any of the functions reject, the entire function will reject with that reason.
This is useful if you're building up an object sequentially instead of at
once like you might do with every.
Calls the given function sequentially as each Promise resolves, passing the value onto the next.
If any of the functions reject, the entire function will reject with that reason.
Generated using TypeDoc
Calls a function based on whether a given promise resolves or rejects.
This is a functional way of doing a
promise.then, making it reusable.