qiwi
inside-out-promise
Produces promises with chainable resolvers and observable state.
Install
npm add inside-out-promise
yarn add inside-out-promiseKey features
- Chainable
resolveandrejectmethods - Exposed promise
stateandresultfields - Configurable
Promiseimplementation - TS and Flow typings out of box
Usage
import {factory} from 'inside-out-promise'
const promise = factory() // produces a promise
promise.then((data) => { // standard `thenable` iface
doSomething(data)
})
const data = await fetch({...})
promise.resolve(data) // internal resolver is exposed as public promise field
promise.result // data ref
promise.value // same data ref, result alias
promise.state // 'Fulfilled'
promise.status // status alias: 'Fulfilled'
promise.isPending() // false
promise.isFulfilled() // true
promise.isResolved() // true
// Or the same in OOP style
import {InsideOutPromise} from 'inside-out-promise'
const p = new InsideOutPromise()API
Resolvers
Both executor args — resolve and reject — are available as chainable public methods:
const promise = factory()
promise.resolve('foo') // This's a promise
promise.reject(new Error('bar')) // and this is tooChains
factory().resolve('value').then(data => {
// here's the value: data === 'value'
})
factory().catch(error => {
// the error goes here
}).reject(new Error())You're able to combine steps in Java-like style: first build the "CompletableFuture" chain and resolve it after
const p = new InsideOutPromise()
.then(data => data.repeat(2))
.then(data => data.toUpperCase())
.then(data => data + 'bar')
.resolve('foo')
const res = await p // 'FOOFOObar'Each step return InsideOutPromise instance inherited from Promise, Bluebird (see Configuration for details), etc, so the intanceof check still works.
const p1 = new InsideOutPromise()
const p2 = p1.then(data => data)
const v1 = await(p1)
const v2 = await(p2)
expect(p1).toBeInstanceOf(Promise)
expect(p2).toBeInstanceOf(Promise)
expect(p1).toBeInstanceOf(InsideOutPromise)
expect(p2).toBeInstanceOf(InsideOutPromise)State
Promise state field may take values: Pending, Fulfilled and Rejected
const promise = factory()
promise.state // 'Pending'
promise.resolve()
promise.state // 'Fulfilled'There're also 3 helper methods:
isPending()isRejected()isFulfilled()
InsideOutPromise
import InsideOutPromise from 'inside-out-promise'
const promise = new InsideOutPromise((resolve, reject) => {
// Legacy executor flow is still supported
// ...
})
promise.resolve('foo')
promise.then(data => console.log(data)) // It's `foo`Configuration
import factory from 'inside-out-promise'
import * as Bluebird from 'bluebird'
factory.Promise = Bluebird // Native `Promise` by default