promise based semaphore - caller controllable promise interface

Semaphore.js

function Semaphore() {
  // controllable promise
  let _resolve;
  let _reject;

  const promiseSemaphore = new Promise((resolve, reject) => {
    _resolve = resolve;
    _reject = reject;
  });

  promiseSemaphore.resolve = _resolve;
  promiseSemaphore.reject = _reject;

  return promiseSemaphore;
}

This is used to simplify resource management or resource initialisation.

First caller will await completion. Other callers will get the promise interface to either wait as well or continue immediately.

await load();

await Promise.all([
  load(),
  load(),
  load(),
]);

Example for something that may need to be awaited but can run again.

let loadingPromise = null;

async function load() {
  if (loadingPromise) return loadingPromise;

  loadingPromise = Semaphore();

  // do important work, with a number of callers waiting

  // notify everything awaiting the completion
  loadingPromise.resolve();

  // allow this to be run again
  loadingPromise = null;
}

For something that should only be run once, don't reset the promise variable.

let loadingPromise = null;

async function load(e) {
  if (loadingPromise) return loadingPromise;

  loadingPromise = Semaphore();

  // do important work once (load a resource from the API)

  // notify everything awaiting the completion
  loadingPromise.resolve();

  // anything requesting this again will get a resolved promise and continue.
}