Queue Executor in Vanilla Javascript / Typescript

executor.js

export const waitForMillis = async (millis: number) => {
  return new Promise(resolve => setTimeout(resolve, millis));
};

export const executor = (concurrency = 100) => {
  let workers = 0;
  let index = 0;
  let queue = [];

  const waitFor = async () => {
    do {
      if (workers === 0 && index === queue.length) return true;
      await waitForMillis(250);
    } while (true);
  };

  const execute = (...jobs: (() => Promise<any>)[]) => {
    queue.push(...jobs);

    const finished = index => result => {
      queue[index] = result;
      workers--;
      tick();
    };

    const tick = () => {
      if (workers < concurrency && index < queue.length) {
        const resolver = queue[index];
        resolver().then(finished(index)).catch(finished(index));
        ++index && ++workers;
        tick();
      }
      
      // cleanup queue
      if (workers === 0 && index === queue.length) {
        index = 0;
        queue.length = 0;
      }
    };
    tick();
  };

  return {
    execute,
    waitFor
  };
};

usage.js

import { executor } from './executor';

const globalExecutor = executor(2); // max of 2 parallel executions

globalExecutor.execute(functionThatResolvesPromise);
globalExecutor.execute(anotherFunctionThatResolvesPromise);
globalExecutor.execute(functionThatWillWaitForExecution);


await globalExecutor.waitFor();