9 declarations
import {AsyncSemaphore} from '@fuzdev/fuz_util/async.js'; Async semaphore for concurrency limiting.
With Infinity permits, acquire() always resolves immediately.
constructortype new (permits: number): AsyncSemaphore
permitsnumberthrows
Error - if `permits < 0`acquiretype (): Promise<void>
Promise<void>releasetype (): void
voidAsyncStatus import type {AsyncStatus} from '@fuzdev/fuz_util/async.js'; <T>(): Deferred<T> import {create_deferred} from '@fuzdev/fuz_util/async.js'; Creates an object with a promise and its resolve/reject handlers.
Deferred<T> create_deferred<T>TDeferred<T> import type {Deferred} from '@fuzdev/fuz_util/async.js'; A deferred object with a promise and its resolve/reject handlers.
Deferred<T>Tpromisetype Promise<T>
resolvetype (value: T) => void
rejecttype (reason: any) => void
<T>(items: Iterable<T>, concurrency: number, fn: (item: T, index: number) => void | Promise<void>, signal?: AbortSignal | undefined): Promise<...> import {each_concurrent} from '@fuzdev/fuz_util/async.js'; Runs a function on each item with controlled concurrency. Like map_concurrent but doesn't collect results (more efficient for side effects).
itemsIterable<T>concurrencymaximum number of concurrent operations
numberfn(item: T, index: number) => void | Promise<void>signal?optional AbortSignal to cancel processing
AbortSignal | undefinedPromise<void> each_concurrent<T>TError - if `concurrency < 1`await each_concurrent(
file_paths,
5, // max 5 concurrent deletions
async (path) => { await unlink(path); },
);(value: unknown): value is Promise<unknown> import {is_promise} from '@fuzdev/fuz_util/async.js'; Checks if value is a Promise (or thenable).
valueunknownboolean <T, R>(items: Iterable<T>, concurrency: number, fn: (item: T, index: number) => R | Promise<R>, signal?: AbortSignal | undefined): Promise<...> import {map_concurrent} from '@fuzdev/fuz_util/async.js'; Maps over items with controlled concurrency, preserving input order.
itemsIterable<T>concurrencymaximum number of concurrent operations
numberfn(item: T, index: number) => R | Promise<R>signal?optional AbortSignal to cancel processing
AbortSignal | undefinedPromise<R[]> array of results in same order as input
map_concurrent<T, R>TRError - if `concurrency < 1`const results = await map_concurrent(
file_paths,
5, // max 5 concurrent reads
async (path) => readFile(path, 'utf8'),
);<T, R>(items: Iterable<T>, concurrency: number, fn: (item: T, index: number) => R | Promise<R>, signal?: AbortSignal | undefined): Promise<...> import {map_concurrent_settled} from '@fuzdev/fuz_util/async.js'; Like map_concurrent but collects all results/errors instead of failing fast.
Returns an array of settlement objects matching the Promise.allSettled pattern.
On abort, resolves with partial results: completed items keep their real settlements, in-flight and un-started items are settled as rejected with the abort reason.
itemsIterable<T>concurrencymaximum number of concurrent operations
numberfn(item: T, index: number) => R | Promise<R>signal?optional AbortSignal to cancel processing
AbortSignal | undefinedPromise<PromiseSettledResult<R>[]> array of PromiseSettledResult objects in input order
map_concurrent_settled<T, R>TRError - if `concurrency < 1`const results = await map_concurrent_settled(urls, 5, fetch);
for (const [i, result] of results.entries()) {
if (result.status === 'fulfilled') {
console.log(`${urls[i]}: ${result.value.status}`);
} else {
console.error(`${urls[i]}: ${result.reason}`);
}
}(duration?: number): Promise<void> import {wait} from '@fuzdev/fuz_util/async.js'; Waits for the given duration before resolving.
durationnumber0Promise<void>