pool_gen.js

async function* poolResults(items, concurrency, worker) {
  const it = items[Symbol.iterator]();
  const buffer = [];
  
  let active = 0;
  let wake = null;

  const signal = () => {
    if (wake) { 
      const w = wake; 
      wake = null; 
      w();
    }
  };

  const launch = () => {
    const next = it.next();
    if (next.done) return;
    active++;
    Promise.resolve(worker(next.value))
      .then(value => buffer.push({ value }))
      .catch(error => buffer.push({ error }))
      .finally(() => {
        active--;
        launch();
        signal();
      });
  };

  for (let i = 0; i < concurrency; i++) launch();

  while (active > 0 || buffer.length > 0) {
    if (buffer.length === 0) {
      await new Promise(r => (wake = r));
      continue;
    }
    const { value, error } = buffer.shift();
    if (error) throw error;
    yield value;
  }
}

rolling_pool.ts

async function pool<T>(items: T[], concurrency: number, worker: (x: T) => Promise<void>) {
  let i = 0;
  const run = async () => {
    while (i < items.length) {
      await worker(items[i++]);
    }
  };
  await Promise.all(Array.from({ length: concurrency }, run));
}