A simple locking mechanism (for execution throttling, etc) (JavaScript)

lock.js

function newThrottler({ isBusy, lock, unlock, waitMs }) {
  const delay = (ms) => new Promise((res) => setTimeout(res, ms));

  return async function throttler(cb, ...args) {
    await Promise.resolve();
    while (!!(await isBusy())) {
      await delay(await waitMs()); // waits in event loop queue, until it interrupts for another attempt!
    }
    await lock();
    // ... DO ALL WORK for result
    const result = await cb.call(this, ...args);
    await unlock();
    return result;
  }
}

const throttler = newThrottler((function(){
  let semaphore = 0;
  return {
    isBusy: async () => (semaphore >= 1),
    lock: async () => (semaphore += 1),
    unlock: async () => (semaphore -= 1),
    waitMs: async () => 1000 + (1000 * Math.random())
  };
})());

// eg. usage #1: asyn threads, each result handled separately
function calcResult(num) { ... }
function handleResult(result) { ... }
const final = await Promise.all([1,2,3,4,5,.....].map(num => {
	throttler(calcResult, num).then(handleResult);
}));

// eg. usage #2: join threads, all results handled together
function calcResult(num) { ... }
function handleResults(results) { ... }
const results = await Promise.all(
  [1,2,3,4,5,.....].map(num => throttler(calcResult, num))
);
const final = handleResults(results);