Functions

promiseRetry(promiseFactory, options) ⇒

Retries promise factory until it resolves or maximum retries count is reached

Kind: global function
Returns: promise that resolves when promiseFactory resolves or rejects when maximum retries count is reached

| Param | Description | | -------------------- | -------------------------------------------- | | promiseFactory | function that returns a promise | | options | options object | | options.retriesCount | maximum retries count, default: Infinity | | options.minTime | minimum time between retries, default: 100 | | options.maxTime | maximum time between retries, default: 10000 |

Example

const promise = promiseRetry(() => fetch('https://example.com'), {
  retriesCount: 3,
})
promise
  .then(response => console.log(response))
  .catch(error => console.log(error))

promiseTry(anyFunction) ⇒

promiseTry allows us to move success / error handling to be promise based so we will handle both synchronous and asynchronous execution failures and success properly.

Kind: global function
Returns: promise that resolves to the return value of the function

| Param | Description | | ----------- | --------------------- | | anyFunction | function to be called |

Example

const promise = promiseTry(() => 1)
promise.then(value => console.log(value)) // 1

promiseQueue() ⇒

promiseQueue is a function that returns an object with two methods: add and flush. add takes a function that will be added to the queue and returns a promise that resolves to the function's return value when it is called and executed in order of addition to the queue. flush takes an error and rejects all pending promises with that error.

Kind: global function
Returns: object with add and flush methods
Example

const queue = promiseQueue()
const promise1 = queue.add(() => 1)
const promise2 = queue.add(() => 2)
promise1.then(value => console.log(value)) // 1
promise2.then(value => console.log(value)) // 2

promiseDeferred() ⇒

Creates a deferred object that can be resolved or rejected later.

Kind: global function
Returns: A deferred object with a promise and resolve and reject functions.
Example

const def = promiseDeferred()
const promise = def.promise
def.resolve(1)
return promise.then(res => console.log(res)) // 1

promiseTimeoutController() ⇒

promiseTimeoutController is a function that returns an object with two properties: racePromiseWithTimeout and signal. The main function, racePromiseWithTimeout, takes a promise and a timeout duration as parameters. It returns a promise that races the original promise with a timeout. If the original promise resolves or rejects before the timeout, the timeout is aborted. If the timeout occurs before the original promise completes, the request is aborted. The function also exposes the signal from the requestAbortController for external use.

Kind: global function
Returns: object with racePromiseWithTimeout and signal properties
Example

const { racePromiseWithTimeout, signal } = promiseTimeoutController()
const promise = fetch('https://example.com', { signal })
const result = await racePromiseWithTimeout(promise, 1000)