It takes an array of functions that return promises (asyncFunctions) and the maximum number of functions to be executed concurrently (maxConcurrent). The function will execute up to maxConcurrent functions in parallel, and once a function completes, it will start a new one until all functions have completed. The function returns a promise that r…

concurrentTaskQueue.ts

export async function concurrentTaskQueue<T>(asyncFunctions: Array<() => Promise<T>>, maxConcurrent: number): Promise<T[]> {
    let currentIndex = 0;
    const runningFunctions = new Set<Promise<T>>();
    const orderedRunnedFunctions: Map<Promise<T>, number> = new Map();
    let results: Array<T> = Array(asyncFunctions.length);
    while (currentIndex < asyncFunctions.length) {
        while (runningFunctions.size < maxConcurrent && currentIndex < asyncFunctions.length) {
            const asyncFunction = asyncFunctions[currentIndex];
            const promise = asyncFunction().finally(() => {
                runningFunctions.delete(promise);
            });
            runningFunctions.add(promise);
            orderedRunnedFunctions.set(promise, currentIndex);
            currentIndex++;
        }
        await Promise.race(Array.from(runningFunctions))
    }
    await Promise.all(Array.from(runningFunctions));
    for (const [promise, index] of orderedRunnedFunctions) {
        results[index] = await promise;
    }
    return results
}