Run tasks with a concurrency limit

Uploading fifty images at once floods the network. Uploading them one by one wastes time. A pool runs a few at a time and starts the next as soon as one finishes.

Implement promisePool(tasks, limit).

tasks is an array of functions. Each function takes no arguments and returns a promise (or a plain value). Calling the function starts the work. limit is the most tasks allowed to run at the same time.

promisePool returns a promise for an array of results, in the same order as tasks, whatever order they finished in.

With a limit of 2 and tasks that take 300, 100, 100, and 100 milliseconds:

const results = await promisePool([
  () => upload("a"), // 300ms
  () => upload("b"), // 100ms
  () => upload("c"), // 100ms
  () => upload("d"), // 100ms
], 2)
// t=0:   a and b start
// t=100: b finishes, c starts
// t=200: c finishes, d starts
// t=300: a and d finish. results are in the order a, b, c, d

The grader moves time on a virtual clock. setTimeout and clearTimeout work. Time does not pass on its own, and setInterval is not available.

Requirements:

• Never run more than limit tasks at once.
• Start a waiting task as soon as a running one finishes. Do not wait for a whole batch.
• Do not call any task until the pool has room for it.
• Return results in the order of tasks.
• If a task fails, reject with that error and start no further tasks.
• An empty array resolves to an empty array.

Write a top-level function named promisePool. Do not use export or module.exports.