Functional locking mechanism

lock.js

class LockError extends Error {}

function createLock () {
  /** @type {boolean} */
  let locked = false;
  /** @type {PromiseObject[]} */
  let pending = [];


  function acquire () {
    return new Promise((resolve, reject) => {
      const promise = { resolve, reject };

      if (locked) {
        pending.push(promise);
      } else {
        locked = true;
        promise.resolve();
      }
    });
  }

  function release () {
    if (pending.length) {
      const nextPromise = pending.shift();
      nextPromise.resolve();
    } else {
      locked = false;
    }
  }

  function clear () {
    const clearance = [...pending];
    pending.length = 0;

    for (let promise of clearance) {
      promise.reject(new LockError('Lock queue was cleared'));
    }
  }


  return {
    get locked () { return locked; },
    get count () { return pending.length; },

    acquire,
    release,
    clear,
  };
}

/**
 * @typedef {object} PromiseObject
 * @property {Function} resolve
 * @property {Function} reject
 */