p-limit

sindresorhus/p-limit is an open-source project by sindresorhus: Run multiple promise-returning & async functions with limited concurrency. Indexed here so it can be found — not resold.

It is free. Get it from the upstream repository: https://github.com/sindresorhus/p-limit

From the project's own README (excerpt, reproduced for discovery under its MIT license):

p-limit

> Run multiple promise-returning & async functions with limited concurrency

Works in Node.js and browsers.

Install

Usage

API

pLimit(concurrency) default export

Returns a limit function.

concurrency

Type: number object\ Minimum: 1

Concurrency limit.

You can pass a number or an options object with a concurrency property.

rejectOnClear

Type: boolean\ Default: false

Reject pending promises with an AbortError when clearQueue() is called. This is recommended if you await the returned promises, for example with Promise.all, so pending tasks do not remain unresolved after clearQueue().

limit(fn, ...args)

Returns the promise returned by calling fn(...args).

fn

Type: Function

Promise-returning/async function.

args

Any arguments to pass through to fn.

Support for passing arguments on to the fn is provided in order to be able to avoid creating unnecessary closures. You probably don't need this optimization unless you're pushing a lot of functions.

Warning: Avoid calling the same limit function inside a function that is already limited by it. This can create a deadlock where inner tasks never run. Use a separate limiter for inner tasks.

limit.map(iterable, mapperFunction)

Process an iterable of inputs with limited concurrency.

The mapper function receives the item value and its index.

Returns a promise equivalent to Promise.all(Array.from(iterable, (item, index) => limit(mapperFunction, item, index))).

If the iterable throws during iteration, the returned promise rejects with that error. Mapper functions that were already scheduled still run, and their results are discarded.

This is a convenience function for processing inputs that arrive in batches. For more complex use cases, see p-map.

limit.activeCount

The number of promises that…