An async queue that preserves order

Arguments

task() => Promise<T>

The work to enqueue, passed to queue.push. Zero-argument, returns a promise.

Returns

Promise<T> — push returns a promise that settles with the task's own result. A rejecting task only rejects its own promise — the queue keeps processing.

Examples

const queue = new AsyncQueue();
const results = await Promise.all([
  queue.push(async () => "a"),
  queue.push(async () => "b"),
  queue.push(async () => "c"),
]);
// results === ["a", "b", "c"] — one at a time, in push order

const queue = new AsyncQueue();
const first = queue
  .push(async () => { throw new Error("save failed"); })
  .catch((e) => "caught:" + e.message);
const second = queue.push(async () => "ok");
// await first  === "caught:save failed"
// await second === "ok" — queue carried on

What it has to do

• Never run two tasks at the same time.
• Start tasks in the order they were pushed, including ones pushed mid-run.
• Resolve each push with that task's own resolved value.
• Reject only the failing task's promise and keep processing the rest.

Notes

• Keep a tail promise and chain each new task onto it. The new tail swallows errors so one rejection can't poison the chain.
• Tasks pushed while an earlier one is running still go to the back of the queue — chaining preserves order for free.