@chriscdn/promise-semaphore 2.0.1 → 2.0.3

package/__tests__/semaphore.test.ts

@@ -1,143 +1,143 @@
-import Semaphore from '../src/index'
+import Semaphore from "../src/index";
 
-const pause = async (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+const pause = async (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
-test('Acquire & Release Basic', async () => {
-  const semaphore = new Semaphore()
-  expect(semaphore.canAcquire()).toBe(true)
-  await semaphore.acquire()
-  expect(semaphore.canAcquire()).toBe(false)
-  expect(semaphore.hasTasks()).toBe(true)
-  expect(semaphore.count()).toBe(1)
-  semaphore.release()
-  expect(semaphore.canAcquire()).toBe(true)
-  expect(semaphore.count()).toBe(0)
-})
+test("Acquire & Release Basic", async () => {
+  const semaphore = new Semaphore();
+  expect(semaphore.canAcquire()).toBe(true);
+  await semaphore.acquire();
+  expect(semaphore.canAcquire()).toBe(false);
+  expect(semaphore.hasTasks()).toBe(true);
+  expect(semaphore.count()).toBe(1);
+  semaphore.release();
+  expect(semaphore.canAcquire()).toBe(true);
+  expect(semaphore.count()).toBe(0);
+});
 
-test('Semaphore 1', async () => {
-  const semaphore = new Semaphore()
+test("Semaphore 1", async () => {
+  const semaphore = new Semaphore();
 
   semaphore
     .acquire()
     .then(async () => await pause(1000))
-    .finally(() => semaphore.release())
+    .finally(() => semaphore.release());
 
-  expect(semaphore.canAcquire()).toBe(false)
+  expect(semaphore.canAcquire()).toBe(false);
 
-  await pause(600)
+  await pause(600);
 
-  expect(semaphore.canAcquire()).toBe(false)
+  expect(semaphore.canAcquire()).toBe(false);
 
-  await pause(600)
+  await pause(600);
 
-  expect(semaphore.canAcquire()).toBe(true)
-})
+  expect(semaphore.canAcquire()).toBe(true);
+});
 
-test('Semaphore 2', async () => {
-  const semaphore = new Semaphore()
+test("Semaphore 2", async () => {
+  const semaphore = new Semaphore();
 
-  let tester = 0
+  let tester = 0;
 
   semaphore
     .acquire()
     .then(() => pause(1000))
     .then(() => (tester = 10))
-    .finally(() => semaphore.release())
+    .finally(() => semaphore.release());
 
   // tests acquire waits for previous to complete
   await semaphore
     .acquire()
     .then(() => expect(tester).toBe(10))
-    .finally(() => semaphore.release())
-})
+    .finally(() => semaphore.release());
+});
 
-test('Semaphore 3', async () => {
-  const semaphore = new Semaphore(2)
+test("Semaphore 3", async () => {
+  const semaphore = new Semaphore(2);
 
-  let tester = 0
+  let tester = 0;
 
   semaphore
     .acquire()
     .then(() => pause(1000))
     .then(() => (tester = 20))
-    .finally(() => semaphore.release())
+    .finally(() => semaphore.release());
 
   semaphore
     .acquire()
     .then(() => pause(500))
     .then(() => (tester = 10))
-    .finally(() => semaphore.release())
+    .finally(() => semaphore.release());
 
-  expect(semaphore.count()).toBe(2)
-  expect(semaphore.hasTasks()).toBe(true)
+  expect(semaphore.count()).toBe(2);
+  expect(semaphore.hasTasks()).toBe(true);
 
   // expect 10 since this next block will run before the first has completed
   await semaphore
     .acquire()
     .then(() => expect(tester).toBe(10))
-    .finally(() => semaphore.release())
+    .finally(() => semaphore.release());
 
-  expect(semaphore.count()).toBe(1)
-  expect(semaphore.hasTasks()).toBe(true)
-  expect(semaphore.canAcquire()).toBe(true)
-})
+  expect(semaphore.count()).toBe(1);
+  expect(semaphore.hasTasks()).toBe(true);
+  expect(semaphore.canAcquire()).toBe(true);
+});
 
-test('Request 1', async () => {
-  const semaphore = new Semaphore()
+test("Request 1", async () => {
+  const semaphore = new Semaphore();
 
-  let tester = 0
+  let tester = 0;
 
   semaphore.request(async () => {
-    await pause(1000)
-    tester = 20
-  })
+    await pause(1000);
+    tester = 20;
+  });
 
   semaphore.request(async () => {
-    await pause(500)
-    tester = 10
-  })
+    await pause(500);
+    tester = 10;
+  });
 
   await semaphore.request(async () => {
-    expect(tester).toBe(10)
-  })
-})
+    expect(tester).toBe(10);
+  });
+});
 
-test('Request 2', async () => {
-  const semaphore = new Semaphore(2)
+test("Request 2", async () => {
+  const semaphore = new Semaphore(2);
 
-  let tester = 0
+  let tester = 0;
 
   semaphore.request(async () => {
-    await pause(1000)
-    tester = 20
-  })
+    await pause(1000);
+    tester = 20;
+  });
 
   semaphore.request(async () => {
-    await pause(500)
-    tester = 10
-  })
+    await pause(500);
+    tester = 10;
+  });
 
   await semaphore.request(async () => {
-    expect(tester).toBe(10)
-  })
-})
+    expect(tester).toBe(10);
+  });
+});
 
-test('Request 3', async () => {
-  const semaphore = new Semaphore(3)
+test("Request 3", async () => {
+  const semaphore = new Semaphore(3);
 
-  let tester = 0
+  let tester = 0;
 
   semaphore.request(async () => {
-    await pause(1000)
-    tester = 20
-  })
+    await pause(1000);
+    tester = 20;
+  });
 
   semaphore.request(async () => {
-    await pause(500)
-    tester = 10
-  })
+    await pause(500);
+    tester = 10;
+  });
 
   await semaphore.request(async () => {
-    expect(tester).toBe(0)
-  })
-})
+    expect(tester).toBe(0);
+  });
+});

package/lib/index.d.ts

@@ -1,64 +1,63 @@
-declare class Semaphore {
-    private semaphoreInstances;
-    private maxConcurrent;
-    /**
-     *
-     * @param {number} [maxConcurrent] The maximum number of concurrent locks.
-     */
-    constructor(maxConcurrent?: number);
-    private hasSemaphoreInstance;
-    private getSemaphoreInstance;
-    /**
-     *
-     * @param {string | number} [key]- Optional, the semaphore key.
-     */
-    private tidy;
-    /**
-     * A synchronous function to determine whether a lock can be acquired.
-     *
-     * @param {string | number} [key]- Optional, the semaphore key.
-     * @returns {boolean} Returns true if the lock on `key` can be acquired, false
-     * otherwise.
-     */
-    canAcquire(key?: string | number): boolean;
-    /**
-     *
-     * @param {string | number} [key]- Optional, the semaphore key.
-     */
-    acquire(key?: string | number): Promise<void>;
-    /**
-     *
-     * @param {string | number} [key]- Optional, the semaphore key.
-     */
-    release(key?: string | number): void;
-    /**
-     * The number of active locks.  Will always be less or equal to `max`.
-     *
-     * @param {string | number} [key]- Optional, the semaphore key.
-     */
-    count(key?: string | number): number;
-    /**
-     *
-     * @param {string | number} [key]- Optional, the semaphore key.
-     * @returns {boolean} True if the semaphore and key has locks, false otherwise.
-     */
-    hasTasks(key?: string | number): boolean;
-    /**
-     *
-     * @param {Function<T>} fn The function to execute.
-     * @param {string | number} [key]- Optional, the semaphore key.
-     * @returns {Promise<T>}
-     */
-    request<T>(fn: Function, key?: string | number): Promise<T>;
-    /**
-     * Asynchronously executes `fn` if a lock can be immediately acquired.
-     * Otherwise, returns null.
-     *
-     * @param {Function<T>} fn The function to execute.
-     * @param {string | number} [key]- Optional, the semaphore key.
-     * @returns {Promise<T>}
-     */
-    requestIfAvailable<T>(fn: Function, key?: string | number): Promise<T | null>;
-}
-
-export { Semaphore as default };
+declare class Semaphore {
+    private semaphoreInstances;
+    private maxConcurrent;
+    /**
+     *
+     * @param {number} [maxConcurrent] The maximum number of concurrent locks.
+     */
+    constructor(maxConcurrent?: number);
+    private hasSemaphoreInstance;
+    private getSemaphoreInstance;
+    /**
+     *
+     * @param {string | number} [key]- Optional, the semaphore key.
+     */
+    private tidy;
+    /**
+     * A synchronous function to determine whether a lock can be acquired.
+     *
+     * @param {string | number} [key]- Optional, the semaphore key.
+     * @returns {boolean} Returns true if the lock on `key` can be acquired, false
+     * otherwise.
+     */
+    canAcquire(key?: string | number): boolean;
+    /**
+     *
+     * @param {string | number} [key]- Optional, the semaphore key.
+     */
+    acquire(key?: string | number): Promise<void>;
+    /**
+     *
+     * @param {string | number} [key]- Optional, the semaphore key.
+     */
+    release(key?: string | number): void;
+    /**
+     * The number of active locks.  Will always be less or equal to `max`.
+     *
+     * @param {string | number} [key]- Optional, the semaphore key.
+     */
+    count(key?: string | number): number;
+    /**
+     *
+     * @param {string | number} [key]- Optional, the semaphore key.
+     * @returns {boolean} True if the semaphore and key has locks, false otherwise.
+     */
+    hasTasks(key?: string | number): boolean;
+    /**
+     *
+     * @param {Function<T>} fn The function to execute.
+     * @param {string | number} [key]- Optional, the semaphore key.
+     * @returns {Promise<T>}
+     */
+    request<T>(fn: Function, key?: string | number): Promise<T>;
+    /**
+     * Asynchronously executes `fn` if a lock can be immediately acquired.
+     * Otherwise, returns null.
+     *
+     * @param {Function<T>} fn The function to execute.
+     * @param {string | number} [key]- Optional, the semaphore key.
+     * @returns {Promise<T>}
+     */
+    requestIfAvailable<T>(fn: Function, key?: string | number): Promise<T | null>;
+}
+export default Semaphore;

package/lib/promise-semaphore.cjs

@@ -0,0 +1,2 @@
+var e=/*#__PURE__*/function(){function e(e){this.queue=void 0,this.maxConcurrent=void 0,this.count=void 0,this.queue=[],this.maxConcurrent=e,this.count=0}var t,n,r=e.prototype;return r.acquire=function(){var e=this;return this.canAcquire?(this.count++,Promise.resolve()):new Promise(function(t){return e.queue.push(t)})},r.release=function(){var e=this.queue.shift();e?setTimeout(e,0):this.count--},t=e,(n=[{key:"canAcquire",get:function(){return this.count<this.maxConcurrent}}])&&function(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,"symbol"==typeof(i=function(e,t){if("object"!=typeof e||null===e)return e;var n=e[Symbol.toPrimitive];if(void 0!==n){var r=n.call(e,"string");if("object"!=typeof r)return r;throw new TypeError("@@toPrimitive must return a primitive value.")}return String(e)}(r.key))?i:String(i),r)}var i}(t.prototype,n),Object.defineProperty(t,"prototype",{writable:!1}),e}(),t="_default";module.exports=/*#__PURE__*/function(){function n(e){void 0===e&&(e=1),this.semaphoreInstances=void 0,this.maxConcurrent=void 0,this.semaphoreInstances={},this.maxConcurrent=e}var r=n.prototype;return r.hasSemaphoreInstance=function(e){return void 0===e&&(e=t),Boolean(this.semaphoreInstances[e])},r.getSemaphoreInstance=function(n){return void 0===n&&(n=t),this.hasSemaphoreInstance(n)||(this.semaphoreInstances[n]=new e(this.maxConcurrent)),this.semaphoreInstances[n]},r.tidy=function(e){void 0===e&&(e=t),this.hasSemaphoreInstance(e)&&0==this.getSemaphoreInstance(e).count&&delete this.semaphoreInstances[e]},r.canAcquire=function(e){return void 0===e&&(e=t),this.getSemaphoreInstance(e).canAcquire},r.acquire=function(e){return void 0===e&&(e=t),this.getSemaphoreInstance(e).acquire()},r.release=function(e){void 0===e&&(e=t),this.getSemaphoreInstance(e).release(),this.tidy(e)},r.count=function(e){return void 0===e&&(e=t),this.hasSemaphoreInstance(e)?this.getSemaphoreInstance(e).count:0},r.hasTasks=function(e){return void 0===e&&(e=t),this.count(e)>0},r.request=function(e,n){void 0===n&&(n=t);try{var r=this;return Promise.resolve(function(t,i){try{var o=Promise.resolve(r.acquire(n)).then(function(){return Promise.resolve(e())})}catch(e){return i(!0,e)}return o&&o.then?o.then(i.bind(null,!1),i.bind(null,!0)):i(!1,o)}(0,function(e,t){if(r.release(n),e)throw t;return t}))}catch(e){return Promise.reject(e)}},r.requestIfAvailable=function(e,n){void 0===n&&(n=t);try{return this.canAcquire(n)?Promise.resolve(this.request(e,n)):Promise.resolve(null)}catch(e){return Promise.reject(e)}},n}();
+//# sourceMappingURL=promise-semaphore.cjs.map

package/lib/promise-semaphore.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise-semaphore.cjs","sources":["../src/index.ts"],"sourcesContent":["class SemaphoreItem {\n  private queue: Array<Function>;\n  private maxConcurrent: number;\n  /**\n   * The number of locks.\n   */\n  public count: number;\n\n  constructor(maxConcurrent: number) {\n    this.queue = [];\n    this.maxConcurrent = maxConcurrent;\n    this.count = 0;\n  }\n\n  get canAcquire(): boolean {\n    return this.count < this.maxConcurrent;\n  }\n\n  acquire(): Promise<void> {\n    if (this.canAcquire) {\n      this.count++;\n      return Promise.resolve();\n    } else {\n      return new Promise((resolve) => this.queue.push(resolve));\n    }\n  }\n\n  release(): void {\n    const resolveFunc = this.queue.shift();\n\n    if (resolveFunc) {\n      // Give the micro task queue a small break instead of calling resolveFunc() directly\n      setTimeout(resolveFunc, 0);\n      // resolveFunc()\n    } else {\n      this.count--;\n    }\n  }\n}\n\nconst defaultKey = \"_default\";\n\nclass Semaphore {\n  private semaphoreInstances: Record<string | number, SemaphoreItem>;\n  private maxConcurrent: number;\n\n  /**\n   *\n   * @param {number} [maxConcurrent] The maximum number of concurrent locks.\n   */\n  constructor(maxConcurrent: number = 1) {\n    this.semaphoreInstances = {};\n    this.maxConcurrent = maxConcurrent;\n  }\n\n  private hasSemaphoreInstance(key: string | number = defaultKey) {\n    return Boolean(this.semaphoreInstances[key]);\n  }\n\n  private getSemaphoreInstance(key: string | number = defaultKey) {\n    if (!this.hasSemaphoreInstance(key)) {\n      this.semaphoreInstances[key] = new SemaphoreItem(this.maxConcurrent);\n    }\n    return this.semaphoreInstances[key];\n  }\n\n  /**\n   *\n   * @param {string | number} [key]- Optional, the semaphore key.\n   */\n  private tidy(key: string | number = defaultKey): void {\n    if (\n      this.hasSemaphoreInstance(key) &&\n      this.getSemaphoreInstance(key).count == 0\n    ) {\n      delete this.semaphoreInstances[key];\n    }\n  }\n\n  /**\n   * A synchronous function to determine whether a lock can be acquired.\n   *\n   * @param {string | number} [key]- Optional, the semaphore key.\n   * @returns {boolean} Returns true if the lock on `key` can be acquired, false\n   * otherwise.\n   */\n  canAcquire(key: string | number = defaultKey): boolean {\n    return this.getSemaphoreInstance(key).canAcquire;\n  }\n\n  /**\n   *\n   * @param {string | number} [key]- Optional, the semaphore key.\n   */\n  acquire(key: string | number = defaultKey) {\n    return this.getSemaphoreInstance(key).acquire();\n  }\n\n  /**\n   *\n   * @param {string | number} [key]- Optional, the semaphore key.\n   */\n  release(key: string | number = defaultKey): void {\n    this.getSemaphoreInstance(key).release();\n    this.tidy(key);\n  }\n\n  /**\n   * The number of active locks.  Will always be less or equal to `max`.\n   *\n   * @param {string | number} [key]- Optional, the semaphore key.\n   */\n  count(key: string | number = defaultKey): number {\n    if (this.hasSemaphoreInstance(key)) {\n      return this.getSemaphoreInstance(key).count;\n    } else {\n      return 0;\n    }\n  }\n\n  /**\n   *\n   * @param {string | number} [key]- Optional, the semaphore key.\n   * @returns {boolean} True if the semaphore and key has locks, false otherwise.\n   */\n  hasTasks(key: string | number = defaultKey): boolean {\n    return this.count(key) > 0;\n  }\n\n  /**\n   *\n   * @param {Function<T>} fn The function to execute.\n   * @param {string | number} [key]- Optional, the semaphore key.\n   * @returns {Promise<T>}\n   */\n  async request<T>(\n    fn: Function,\n    key: string | number = defaultKey\n  ): Promise<T> {\n    try {\n      await this.acquire(key);\n      return await fn();\n    } finally {\n      this.release(key);\n    }\n  }\n\n  /**\n   * Asynchronously executes `fn` if a lock can be immediately acquired.\n   * Otherwise, returns null.\n   *\n   * @param {Function<T>} fn The function to execute.\n   * @param {string | number} [key]- Optional, the semaphore key.\n   * @returns {Promise<T>}\n   */\n  async requestIfAvailable<T>(\n    fn: Function,\n    key: string | number = defaultKey\n  ): Promise<T | null> {\n    if (this.canAcquire(key)) {\n      return this.request(fn, key);\n    } else {\n      return null;\n    }\n  }\n}\n\nexport default Semaphore;\n"],"names":["SemaphoreItem","maxConcurrent","this","queue","count","_proto","prototype","acquire","_this","canAcquire","Promise","resolve","push","release","resolveFunc","shift","setTimeout","key","get","defaultKey","Semaphore","semaphoreInstances","_proto2","hasSemaphoreInstance","Boolean","getSemaphoreInstance","tidy","hasTasks","request","fn","_this2","then","_finallyRethrows","_wasThrown","_result","e","reject","requestIfAvailable"],"mappings":"IAAMA,0BAQJ,SAAAA,EAAYC,GAAqBC,KAPzBC,WACAF,EAAAA,KAAAA,mBAIDG,EAAAA,KAAAA,aAGLF,KAAKC,MAAQ,GACbD,KAAKD,cAAgBA,EACrBC,KAAKE,MAAQ,CACf,CAAC,QAAAC,EAAAL,EAAAM,UAIAN,OAJAK,EAMDE,QAAA,eAAOC,EAAAN,KACL,OAAIA,KAAKO,YACPP,KAAKE,QACEM,QAAQC,eAEJD,QAAQ,SAACC,GAAY,OAAAH,EAAKL,MAAMS,KAAKD,EAAQ,EAE5D,EAACN,EAEDQ,QAAA,WACE,IAAMC,EAAcZ,KAAKC,MAAMY,QAE3BD,EAEFE,WAAWF,EAAa,GAGxBZ,KAAKE,OAET,IAACJ,OAAAiB,IAAA,aAAAC,IAvBD,WACE,OAAOhB,KAAKE,MAAQF,KAAKD,aAC3B,mgBAACD,CAAA,IAwBGmB,EAAa,uCAEJ,WAQb,SAAAC,EAAYnB,QAAAA,IAAAA,IAAAA,EAAwB,GAACC,KAP7BmB,wBAAkB,EAAAnB,KAClBD,mBAON,EAAAC,KAAKmB,mBAAqB,CAAE,EAC5BnB,KAAKD,cAAgBA,CACvB,CAAC,IAAAqB,EAAAF,EAAAd,UA+GA,OA/GAgB,EAEOC,qBAAA,SAAqBN,GAC3B,gBAD2BA,IAAAA,EAAuBE,GAC3CK,QAAQtB,KAAKmB,mBAAmBJ,GACzC,EAACK,EAEOG,qBAAA,SAAqBR,GAI3B,gBAJ2BA,IAAAA,EAAuBE,GAC7CjB,KAAKqB,qBAAqBN,KAC7Bf,KAAKmB,mBAAmBJ,GAAO,IAAIjB,EAAcE,KAAKD,gBAE7CC,KAACmB,mBAAmBJ,EACjC,EAACK,EAMOI,KAAA,SAAKT,QAAAA,IAAAA,IAAAA,EAAuBE,GAEhCjB,KAAKqB,qBAAqBN,IACc,GAAxCf,KAAKuB,qBAAqBR,GAAKb,cAExBF,KAAKmB,mBAAmBJ,EAEnC,EAACK,EASDb,WAAA,SAAWQ,GACT,gBADSA,IAAAA,EAAuBE,GACzBjB,KAAKuB,qBAAqBR,GAAKR,UACxC,EAACa,EAMDf,QAAA,SAAQU,GACN,gBADMA,IAAAA,EAAuBE,GAClBjB,KAACuB,qBAAqBR,GAAKV,SACxC,EAACe,EAMDT,QAAA,SAAQI,QAAAA,IAAAA,IAAAA,EAAuBE,GAC7BjB,KAAKuB,qBAAqBR,GAAKJ,UAC/BX,KAAKwB,KAAKT,EACZ,EAACK,EAODlB,MAAA,SAAMa,GACJ,gBADIA,IAAAA,EAAuBE,GACvBjB,KAAKqB,qBAAqBN,QAChBQ,qBAAqBR,GAAKb,MAGvC,CACH,EAACkB,EAODK,SAAA,SAASV,GACP,gBADOA,IAAAA,EAAuBE,GACvBjB,KAAKE,MAAMa,GAAO,CAC3B,EAACK,EAQKM,QAAOA,SACXC,EACAZ,YAAAA,IAAAA,EAAuBE,GAAU,IAAA,IAAAW,EAGzB5B,KAAIQ,OAAAA,QAAAC,gCADRD,QAAAC,QACImB,EAAKvB,QAAQU,IAAIc,KAAA,WAAA,OAAArB,QAAAC,QACVkB,IACd,4FAFWG,CADR,EAGHC,SAAAA,EAAAC,GACmB,GAAlBJ,EAAKjB,QAAQI,GAAKgB,EAAAC,MAAAA,SAAAA,CAAA,GAEtB,CAAC,MAAAC,GAAAzB,OAAAA,QAAA0B,OAAAD,EAAAb,CAAAA,EAAAA,EAUKe,mBAAkB,SACtBR,EACAZ,QAAAA,IAAAA,IAAAA,EAAuBE,GAAU,IAEjC,OAAIjB,KAAKO,WAAWQ,GAClBP,QAAAC,QADET,KACU0B,QAAQC,EAAIZ,IAExBP,QAAAC,QAAO,KAEX,CAAC,MAAAwB,GAAAzB,OAAAA,QAAA0B,OAAAD,EAAA,CAAA,EAAAf,CAAA,CA1HY"}

package/lib/promise-semaphore.modern.js

@@ -0,0 +1,2 @@
+class e{constructor(e){this.queue=void 0,this.maxConcurrent=void 0,this.count=void 0,this.queue=[],this.maxConcurrent=e,this.count=0}get canAcquire(){return this.count<this.maxConcurrent}acquire(){return this.canAcquire?(this.count++,Promise.resolve()):new Promise(e=>this.queue.push(e))}release(){const e=this.queue.shift();e?setTimeout(e,0):this.count--}}const t="_default";class s{constructor(e=1){this.semaphoreInstances=void 0,this.maxConcurrent=void 0,this.semaphoreInstances={},this.maxConcurrent=e}hasSemaphoreInstance(e=t){return Boolean(this.semaphoreInstances[e])}getSemaphoreInstance(s=t){return this.hasSemaphoreInstance(s)||(this.semaphoreInstances[s]=new e(this.maxConcurrent)),this.semaphoreInstances[s]}tidy(e=t){this.hasSemaphoreInstance(e)&&0==this.getSemaphoreInstance(e).count&&delete this.semaphoreInstances[e]}canAcquire(e=t){return this.getSemaphoreInstance(e).canAcquire}acquire(e=t){return this.getSemaphoreInstance(e).acquire()}release(e=t){this.getSemaphoreInstance(e).release(),this.tidy(e)}count(e=t){return this.hasSemaphoreInstance(e)?this.getSemaphoreInstance(e).count:0}hasTasks(e=t){return this.count(e)>0}async request(e,s=t){try{return await this.acquire(s),await e()}finally{this.release(s)}}async requestIfAvailable(e,s=t){return this.canAcquire(s)?this.request(e,s):null}}export{s as default};
+//# sourceMappingURL=promise-semaphore.modern.js.map

package/lib/promise-semaphore.modern.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise-semaphore.modern.js","sources":["../src/index.ts"],"sourcesContent":["class SemaphoreItem {\n  private queue: Array<Function>;\n  private maxConcurrent: number;\n  /**\n   * The number of locks.\n   */\n  public count: number;\n\n  constructor(maxConcurrent: number) {\n    this.queue = [];\n    this.maxConcurrent = maxConcurrent;\n    this.count = 0;\n  }\n\n  get canAcquire(): boolean {\n    return this.count < this.maxConcurrent;\n  }\n\n  acquire(): Promise<void> {\n    if (this.canAcquire) {\n      this.count++;\n      return Promise.resolve();\n    } else {\n      return new Promise((resolve) => this.queue.push(resolve));\n    }\n  }\n\n  release(): void {\n    const resolveFunc = this.queue.shift();\n\n    if (resolveFunc) {\n      // Give the micro task queue a small break instead of calling resolveFunc() directly\n      setTimeout(resolveFunc, 0);\n      // resolveFunc()\n    } else {\n      this.count--;\n    }\n  }\n}\n\nconst defaultKey = \"_default\";\n\nclass Semaphore {\n  private semaphoreInstances: Record<string | number, SemaphoreItem>;\n  private maxConcurrent: number;\n\n  /**\n   *\n   * @param {number} [maxConcurrent] The maximum number of concurrent locks.\n   */\n  constructor(maxConcurrent: number = 1) {\n    this.semaphoreInstances = {};\n    this.maxConcurrent = maxConcurrent;\n  }\n\n  private hasSemaphoreInstance(key: string | number = defaultKey) {\n    return Boolean(this.semaphoreInstances[key]);\n  }\n\n  private getSemaphoreInstance(key: string | number = defaultKey) {\n    if (!this.hasSemaphoreInstance(key)) {\n      this.semaphoreInstances[key] = new SemaphoreItem(this.maxConcurrent);\n    }\n    return this.semaphoreInstances[key];\n  }\n\n  /**\n   *\n   * @param {string | number} [key]- Optional, the semaphore key.\n   */\n  private tidy(key: string | number = defaultKey): void {\n    if (\n      this.hasSemaphoreInstance(key) &&\n      this.getSemaphoreInstance(key).count == 0\n    ) {\n      delete this.semaphoreInstances[key];\n    }\n  }\n\n  /**\n   * A synchronous function to determine whether a lock can be acquired.\n   *\n   * @param {string | number} [key]- Optional, the semaphore key.\n   * @returns {boolean} Returns true if the lock on `key` can be acquired, false\n   * otherwise.\n   */\n  canAcquire(key: string | number = defaultKey): boolean {\n    return this.getSemaphoreInstance(key).canAcquire;\n  }\n\n  /**\n   *\n   * @param {string | number} [key]- Optional, the semaphore key.\n   */\n  acquire(key: string | number = defaultKey) {\n    return this.getSemaphoreInstance(key).acquire();\n  }\n\n  /**\n   *\n   * @param {string | number} [key]- Optional, the semaphore key.\n   */\n  release(key: string | number = defaultKey): void {\n    this.getSemaphoreInstance(key).release();\n    this.tidy(key);\n  }\n\n  /**\n   * The number of active locks.  Will always be less or equal to `max`.\n   *\n   * @param {string | number} [key]- Optional, the semaphore key.\n   */\n  count(key: string | number = defaultKey): number {\n    if (this.hasSemaphoreInstance(key)) {\n      return this.getSemaphoreInstance(key).count;\n    } else {\n      return 0;\n    }\n  }\n\n  /**\n   *\n   * @param {string | number} [key]- Optional, the semaphore key.\n   * @returns {boolean} True if the semaphore and key has locks, false otherwise.\n   */\n  hasTasks(key: string | number = defaultKey): boolean {\n    return this.count(key) > 0;\n  }\n\n  /**\n   *\n   * @param {Function<T>} fn The function to execute.\n   * @param {string | number} [key]- Optional, the semaphore key.\n   * @returns {Promise<T>}\n   */\n  async request<T>(\n    fn: Function,\n    key: string | number = defaultKey\n  ): Promise<T> {\n    try {\n      await this.acquire(key);\n      return await fn();\n    } finally {\n      this.release(key);\n    }\n  }\n\n  /**\n   * Asynchronously executes `fn` if a lock can be immediately acquired.\n   * Otherwise, returns null.\n   *\n   * @param {Function<T>} fn The function to execute.\n   * @param {string | number} [key]- Optional, the semaphore key.\n   * @returns {Promise<T>}\n   */\n  async requestIfAvailable<T>(\n    fn: Function,\n    key: string | number = defaultKey\n  ): Promise<T | null> {\n    if (this.canAcquire(key)) {\n      return this.request(fn, key);\n    } else {\n      return null;\n    }\n  }\n}\n\nexport default Semaphore;\n"],"names":["SemaphoreItem","constructor","maxConcurrent","queue","count","this","canAcquire","acquire","Promise","resolve","push","release","resolveFunc","shift","setTimeout","defaultKey","Semaphore","semaphoreInstances","hasSemaphoreInstance","key","Boolean","getSemaphoreInstance","tidy","hasTasks","request","fn","requestIfAvailable"],"mappings":"AAAA,MAAMA,EAQJC,WAAAA,CAAYC,GAPJC,KAAAA,WACAD,EAAAA,KAAAA,0BAIDE,WAAK,EAGVC,KAAKF,MAAQ,GACbE,KAAKH,cAAgBA,EACrBG,KAAKD,MAAQ,CACf,CAEA,cAAIE,GACF,YAAYF,MAAQC,KAAKH,aAC3B,CAEAK,OAAAA,GACE,OAAIF,KAAKC,YACPD,KAAKD,QACEI,QAAQC,WAER,IAAID,QAASC,GAAYJ,KAAKF,MAAMO,KAAKD,GAEpD,CAEAE,OAAAA,GACE,MAAMC,EAAcP,KAAKF,MAAMU,QAE3BD,EAEFE,WAAWF,EAAa,GAGxBP,KAAKD,OAET,EAGF,MAAMW,EAAa,WAEnB,MAAMC,EAQJf,WAAAA,CAAYC,EAAwB,GAP5Be,KAAAA,+BACAf,mBAAa,EAOnBG,KAAKY,mBAAqB,CAAA,EAC1BZ,KAAKH,cAAgBA,CACvB,CAEQgB,oBAAAA,CAAqBC,EAAuBJ,GAClD,OAAOK,QAAQf,KAAKY,mBAAmBE,GACzC,CAEQE,oBAAAA,CAAqBF,EAAuBJ,GAIlD,OAHKV,KAAKa,qBAAqBC,KAC7Bd,KAAKY,mBAAmBE,GAAO,IAAInB,EAAcK,KAAKH,gBAEjDG,KAAKY,mBAAmBE,EACjC,CAMQG,IAAAA,CAAKH,EAAuBJ,GAEhCV,KAAKa,qBAAqBC,IACc,GAAxCd,KAAKgB,qBAAqBF,GAAKf,cAExBC,KAAKY,mBAAmBE,EAEnC,CASAb,UAAAA,CAAWa,EAAuBJ,GAChC,OAAWV,KAACgB,qBAAqBF,GAAKb,UACxC,CAMAC,OAAAA,CAAQY,EAAuBJ,GAC7B,OAAOV,KAAKgB,qBAAqBF,GAAKZ,SACxC,CAMAI,OAAAA,CAAQQ,EAAuBJ,GAC7BV,KAAKgB,qBAAqBF,GAAKR,UAC/BN,KAAKiB,KAAKH,EACZ,CAOAf,KAAAA,CAAMe,EAAuBJ,GAC3B,OAAIV,KAAKa,qBAAqBC,GACjBd,KAACgB,qBAAqBF,GAAKf,MAE/B,CAEX,CAOAmB,QAAAA,CAASJ,EAAuBJ,GAC9B,OAAWV,KAACD,MAAMe,GAAO,CAC3B,CAQA,aAAMK,CACJC,EACAN,EAAuBJ,GAEvB,IAEE,aADUV,KAACE,QAAQY,SACNM,GACd,CAAA,QACCpB,KAAKM,QAAQQ,EACd,CACH,CAUA,wBAAMO,CACJD,EACAN,EAAuBJ,GAEvB,OAAIV,KAAKC,WAAWa,GACPd,KAACmB,QAAQC,EAAIN,GAEjB,IAEX"}

package/lib/promise-semaphore.module.js

@@ -0,0 +1,2 @@
+var e=/*#__PURE__*/function(){function e(e){this.queue=void 0,this.maxConcurrent=void 0,this.count=void 0,this.queue=[],this.maxConcurrent=e,this.count=0}var t,n,r=e.prototype;return r.acquire=function(){var e=this;return this.canAcquire?(this.count++,Promise.resolve()):new Promise(function(t){return e.queue.push(t)})},r.release=function(){var e=this.queue.shift();e?setTimeout(e,0):this.count--},t=e,(n=[{key:"canAcquire",get:function(){return this.count<this.maxConcurrent}}])&&function(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,"symbol"==typeof(i=function(e,t){if("object"!=typeof e||null===e)return e;var n=e[Symbol.toPrimitive];if(void 0!==n){var r=n.call(e,"string");if("object"!=typeof r)return r;throw new TypeError("@@toPrimitive must return a primitive value.")}return String(e)}(r.key))?i:String(i),r)}var i}(t.prototype,n),Object.defineProperty(t,"prototype",{writable:!1}),e}(),t="_default",n=/*#__PURE__*/function(){function n(e){void 0===e&&(e=1),this.semaphoreInstances=void 0,this.maxConcurrent=void 0,this.semaphoreInstances={},this.maxConcurrent=e}var r=n.prototype;return r.hasSemaphoreInstance=function(e){return void 0===e&&(e=t),Boolean(this.semaphoreInstances[e])},r.getSemaphoreInstance=function(n){return void 0===n&&(n=t),this.hasSemaphoreInstance(n)||(this.semaphoreInstances[n]=new e(this.maxConcurrent)),this.semaphoreInstances[n]},r.tidy=function(e){void 0===e&&(e=t),this.hasSemaphoreInstance(e)&&0==this.getSemaphoreInstance(e).count&&delete this.semaphoreInstances[e]},r.canAcquire=function(e){return void 0===e&&(e=t),this.getSemaphoreInstance(e).canAcquire},r.acquire=function(e){return void 0===e&&(e=t),this.getSemaphoreInstance(e).acquire()},r.release=function(e){void 0===e&&(e=t),this.getSemaphoreInstance(e).release(),this.tidy(e)},r.count=function(e){return void 0===e&&(e=t),this.hasSemaphoreInstance(e)?this.getSemaphoreInstance(e).count:0},r.hasTasks=function(e){return void 0===e&&(e=t),this.count(e)>0},r.request=function(e,n){void 0===n&&(n=t);try{var r=this;return Promise.resolve(function(t,i){try{var o=Promise.resolve(r.acquire(n)).then(function(){return Promise.resolve(e())})}catch(e){return i(!0,e)}return o&&o.then?o.then(i.bind(null,!1),i.bind(null,!0)):i(!1,o)}(0,function(e,t){if(r.release(n),e)throw t;return t}))}catch(e){return Promise.reject(e)}},r.requestIfAvailable=function(e,n){void 0===n&&(n=t);try{return this.canAcquire(n)?Promise.resolve(this.request(e,n)):Promise.resolve(null)}catch(e){return Promise.reject(e)}},n}();export{n as default};
+//# sourceMappingURL=promise-semaphore.module.js.map

package/lib/promise-semaphore.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise-semaphore.module.js","sources":["../src/index.ts"],"sourcesContent":["class SemaphoreItem {\n  private queue: Array<Function>;\n  private maxConcurrent: number;\n  /**\n   * The number of locks.\n   */\n  public count: number;\n\n  constructor(maxConcurrent: number) {\n    this.queue = [];\n    this.maxConcurrent = maxConcurrent;\n    this.count = 0;\n  }\n\n  get canAcquire(): boolean {\n    return this.count < this.maxConcurrent;\n  }\n\n  acquire(): Promise<void> {\n    if (this.canAcquire) {\n      this.count++;\n      return Promise.resolve();\n    } else {\n      return new Promise((resolve) => this.queue.push(resolve));\n    }\n  }\n\n  release(): void {\n    const resolveFunc = this.queue.shift();\n\n    if (resolveFunc) {\n      // Give the micro task queue a small break instead of calling resolveFunc() directly\n      setTimeout(resolveFunc, 0);\n      // resolveFunc()\n    } else {\n      this.count--;\n    }\n  }\n}\n\nconst defaultKey = \"_default\";\n\nclass Semaphore {\n  private semaphoreInstances: Record<string | number, SemaphoreItem>;\n  private maxConcurrent: number;\n\n  /**\n   *\n   * @param {number} [maxConcurrent] The maximum number of concurrent locks.\n   */\n  constructor(maxConcurrent: number = 1) {\n    this.semaphoreInstances = {};\n    this.maxConcurrent = maxConcurrent;\n  }\n\n  private hasSemaphoreInstance(key: string | number = defaultKey) {\n    return Boolean(this.semaphoreInstances[key]);\n  }\n\n  private getSemaphoreInstance(key: string | number = defaultKey) {\n    if (!this.hasSemaphoreInstance(key)) {\n      this.semaphoreInstances[key] = new SemaphoreItem(this.maxConcurrent);\n    }\n    return this.semaphoreInstances[key];\n  }\n\n  /**\n   *\n   * @param {string | number} [key]- Optional, the semaphore key.\n   */\n  private tidy(key: string | number = defaultKey): void {\n    if (\n      this.hasSemaphoreInstance(key) &&\n      this.getSemaphoreInstance(key).count == 0\n    ) {\n      delete this.semaphoreInstances[key];\n    }\n  }\n\n  /**\n   * A synchronous function to determine whether a lock can be acquired.\n   *\n   * @param {string | number} [key]- Optional, the semaphore key.\n   * @returns {boolean} Returns true if the lock on `key` can be acquired, false\n   * otherwise.\n   */\n  canAcquire(key: string | number = defaultKey): boolean {\n    return this.getSemaphoreInstance(key).canAcquire;\n  }\n\n  /**\n   *\n   * @param {string | number} [key]- Optional, the semaphore key.\n   */\n  acquire(key: string | number = defaultKey) {\n    return this.getSemaphoreInstance(key).acquire();\n  }\n\n  /**\n   *\n   * @param {string | number} [key]- Optional, the semaphore key.\n   */\n  release(key: string | number = defaultKey): void {\n    this.getSemaphoreInstance(key).release();\n    this.tidy(key);\n  }\n\n  /**\n   * The number of active locks.  Will always be less or equal to `max`.\n   *\n   * @param {string | number} [key]- Optional, the semaphore key.\n   */\n  count(key: string | number = defaultKey): number {\n    if (this.hasSemaphoreInstance(key)) {\n      return this.getSemaphoreInstance(key).count;\n    } else {\n      return 0;\n    }\n  }\n\n  /**\n   *\n   * @param {string | number} [key]- Optional, the semaphore key.\n   * @returns {boolean} True if the semaphore and key has locks, false otherwise.\n   */\n  hasTasks(key: string | number = defaultKey): boolean {\n    return this.count(key) > 0;\n  }\n\n  /**\n   *\n   * @param {Function<T>} fn The function to execute.\n   * @param {string | number} [key]- Optional, the semaphore key.\n   * @returns {Promise<T>}\n   */\n  async request<T>(\n    fn: Function,\n    key: string | number = defaultKey\n  ): Promise<T> {\n    try {\n      await this.acquire(key);\n      return await fn();\n    } finally {\n      this.release(key);\n    }\n  }\n\n  /**\n   * Asynchronously executes `fn` if a lock can be immediately acquired.\n   * Otherwise, returns null.\n   *\n   * @param {Function<T>} fn The function to execute.\n   * @param {string | number} [key]- Optional, the semaphore key.\n   * @returns {Promise<T>}\n   */\n  async requestIfAvailable<T>(\n    fn: Function,\n    key: string | number = defaultKey\n  ): Promise<T | null> {\n    if (this.canAcquire(key)) {\n      return this.request(fn, key);\n    } else {\n      return null;\n    }\n  }\n}\n\nexport default Semaphore;\n"],"names":["SemaphoreItem","maxConcurrent","this","queue","count","_proto","prototype","acquire","_this","canAcquire","Promise","resolve","push","release","resolveFunc","shift","setTimeout","key","get","defaultKey","Semaphore","semaphoreInstances","_proto2","hasSemaphoreInstance","Boolean","getSemaphoreInstance","tidy","hasTasks","request","fn","_this2","then","_finallyRethrows","_wasThrown","_result","e","reject","requestIfAvailable"],"mappings":"IAAMA,0BAQJ,SAAAA,EAAYC,GAAqBC,KAPzBC,WACAF,EAAAA,KAAAA,mBAIDG,EAAAA,KAAAA,aAGLF,KAAKC,MAAQ,GACbD,KAAKD,cAAgBA,EACrBC,KAAKE,MAAQ,CACf,CAAC,QAAAC,EAAAL,EAAAM,UAIAN,OAJAK,EAMDE,QAAA,eAAOC,EAAAN,KACL,OAAIA,KAAKO,YACPP,KAAKE,QACEM,QAAQC,eAEJD,QAAQ,SAACC,GAAY,OAAAH,EAAKL,MAAMS,KAAKD,EAAQ,EAE5D,EAACN,EAEDQ,QAAA,WACE,IAAMC,EAAcZ,KAAKC,MAAMY,QAE3BD,EAEFE,WAAWF,EAAa,GAGxBZ,KAAKE,OAET,IAACJ,OAAAiB,IAAA,aAAAC,IAvBD,WACE,OAAOhB,KAAKE,MAAQF,KAAKD,aAC3B,mgBAACD,CAAA,IAwBGmB,EAAa,WAEbC,eAAS,WAQb,SAAAA,EAAYnB,QAAAA,IAAAA,IAAAA,EAAwB,GAACC,KAP7BmB,wBAAkB,EAAAnB,KAClBD,mBAON,EAAAC,KAAKmB,mBAAqB,CAAE,EAC5BnB,KAAKD,cAAgBA,CACvB,CAAC,IAAAqB,EAAAF,EAAAd,UA+GA,OA/GAgB,EAEOC,qBAAA,SAAqBN,GAC3B,gBAD2BA,IAAAA,EAAuBE,GAC3CK,QAAQtB,KAAKmB,mBAAmBJ,GACzC,EAACK,EAEOG,qBAAA,SAAqBR,GAI3B,gBAJ2BA,IAAAA,EAAuBE,GAC7CjB,KAAKqB,qBAAqBN,KAC7Bf,KAAKmB,mBAAmBJ,GAAO,IAAIjB,EAAcE,KAAKD,gBAE7CC,KAACmB,mBAAmBJ,EACjC,EAACK,EAMOI,KAAA,SAAKT,QAAAA,IAAAA,IAAAA,EAAuBE,GAEhCjB,KAAKqB,qBAAqBN,IACc,GAAxCf,KAAKuB,qBAAqBR,GAAKb,cAExBF,KAAKmB,mBAAmBJ,EAEnC,EAACK,EASDb,WAAA,SAAWQ,GACT,gBADSA,IAAAA,EAAuBE,GACzBjB,KAAKuB,qBAAqBR,GAAKR,UACxC,EAACa,EAMDf,QAAA,SAAQU,GACN,gBADMA,IAAAA,EAAuBE,GAClBjB,KAACuB,qBAAqBR,GAAKV,SACxC,EAACe,EAMDT,QAAA,SAAQI,QAAAA,IAAAA,IAAAA,EAAuBE,GAC7BjB,KAAKuB,qBAAqBR,GAAKJ,UAC/BX,KAAKwB,KAAKT,EACZ,EAACK,EAODlB,MAAA,SAAMa,GACJ,gBADIA,IAAAA,EAAuBE,GACvBjB,KAAKqB,qBAAqBN,QAChBQ,qBAAqBR,GAAKb,MAGvC,CACH,EAACkB,EAODK,SAAA,SAASV,GACP,gBADOA,IAAAA,EAAuBE,GACvBjB,KAAKE,MAAMa,GAAO,CAC3B,EAACK,EAQKM,QAAOA,SACXC,EACAZ,YAAAA,IAAAA,EAAuBE,GAAU,IAAA,IAAAW,EAGzB5B,KAAIQ,OAAAA,QAAAC,gCADRD,QAAAC,QACImB,EAAKvB,QAAQU,IAAIc,KAAA,WAAA,OAAArB,QAAAC,QACVkB,IACd,4FAFWG,CADR,EAGHC,SAAAA,EAAAC,GACmB,GAAlBJ,EAAKjB,QAAQI,GAAKgB,EAAAC,MAAAA,SAAAA,CAAA,GAEtB,CAAC,MAAAC,GAAAzB,OAAAA,QAAA0B,OAAAD,EAAAb,CAAAA,EAAAA,EAUKe,mBAAkB,SACtBR,EACAZ,QAAAA,IAAAA,IAAAA,EAAuBE,GAAU,IAEjC,OAAIjB,KAAKO,WAAWQ,GAClBP,QAAAC,QADET,KACU0B,QAAQC,EAAIZ,IAExBP,QAAAC,QAAO,KAEX,CAAC,MAAAwB,GAAAzB,OAAAA,QAAA0B,OAAAD,EAAA,CAAA,EAAAf,CAAA,CA1HY"}

package/lib/promise-semaphore.umd.js

@@ -0,0 +1,3 @@
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e||self).promiseSemaphore=t()}(this,function(){var e=/*#__PURE__*/function(){function e(e){this.queue=void 0,this.maxConcurrent=void 0,this.count=void 0,this.queue=[],this.maxConcurrent=e,this.count=0}var t,n,r=e.prototype;return r.acquire=function(){var e=this;return this.canAcquire?(this.count++,Promise.resolve()):new Promise(function(t){return e.queue.push(t)})},r.release=function(){var e=this.queue.shift();e?setTimeout(e,0):this.count--},t=e,(n=[{key:"canAcquire",get:function(){return this.count<this.maxConcurrent}}])&&function(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,"symbol"==typeof(i=function(e,t){if("object"!=typeof e||null===e)return e;var n=e[Symbol.toPrimitive];if(void 0!==n){var r=n.call(e,"string");if("object"!=typeof r)return r;throw new TypeError("@@toPrimitive must return a primitive value.")}return String(e)}(r.key))?i:String(i),r)}var i}(t.prototype,n),Object.defineProperty(t,"prototype",{writable:!1}),e}(),t="_default";/*#__PURE__*/
+return function(){function n(e){void 0===e&&(e=1),this.semaphoreInstances=void 0,this.maxConcurrent=void 0,this.semaphoreInstances={},this.maxConcurrent=e}var r=n.prototype;return r.hasSemaphoreInstance=function(e){return void 0===e&&(e=t),Boolean(this.semaphoreInstances[e])},r.getSemaphoreInstance=function(n){return void 0===n&&(n=t),this.hasSemaphoreInstance(n)||(this.semaphoreInstances[n]=new e(this.maxConcurrent)),this.semaphoreInstances[n]},r.tidy=function(e){void 0===e&&(e=t),this.hasSemaphoreInstance(e)&&0==this.getSemaphoreInstance(e).count&&delete this.semaphoreInstances[e]},r.canAcquire=function(e){return void 0===e&&(e=t),this.getSemaphoreInstance(e).canAcquire},r.acquire=function(e){return void 0===e&&(e=t),this.getSemaphoreInstance(e).acquire()},r.release=function(e){void 0===e&&(e=t),this.getSemaphoreInstance(e).release(),this.tidy(e)},r.count=function(e){return void 0===e&&(e=t),this.hasSemaphoreInstance(e)?this.getSemaphoreInstance(e).count:0},r.hasTasks=function(e){return void 0===e&&(e=t),this.count(e)>0},r.request=function(e,n){void 0===n&&(n=t);try{var r=this;return Promise.resolve(function(t,i){try{var o=Promise.resolve(r.acquire(n)).then(function(){return Promise.resolve(e())})}catch(e){return i(!0,e)}return o&&o.then?o.then(i.bind(null,!1),i.bind(null,!0)):i(!1,o)}(0,function(e,t){if(r.release(n),e)throw t;return t}))}catch(e){return Promise.reject(e)}},r.requestIfAvailable=function(e,n){void 0===n&&(n=t);try{return this.canAcquire(n)?Promise.resolve(this.request(e,n)):Promise.resolve(null)}catch(e){return Promise.reject(e)}},n}()});
+//# sourceMappingURL=promise-semaphore.umd.js.map

package/lib/promise-semaphore.umd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise-semaphore.umd.js","sources":["../src/index.ts"],"sourcesContent":["class SemaphoreItem {\n  private queue: Array<Function>;\n  private maxConcurrent: number;\n  /**\n   * The number of locks.\n   */\n  public count: number;\n\n  constructor(maxConcurrent: number) {\n    this.queue = [];\n    this.maxConcurrent = maxConcurrent;\n    this.count = 0;\n  }\n\n  get canAcquire(): boolean {\n    return this.count < this.maxConcurrent;\n  }\n\n  acquire(): Promise<void> {\n    if (this.canAcquire) {\n      this.count++;\n      return Promise.resolve();\n    } else {\n      return new Promise((resolve) => this.queue.push(resolve));\n    }\n  }\n\n  release(): void {\n    const resolveFunc = this.queue.shift();\n\n    if (resolveFunc) {\n      // Give the micro task queue a small break instead of calling resolveFunc() directly\n      setTimeout(resolveFunc, 0);\n      // resolveFunc()\n    } else {\n      this.count--;\n    }\n  }\n}\n\nconst defaultKey = \"_default\";\n\nclass Semaphore {\n  private semaphoreInstances: Record<string | number, SemaphoreItem>;\n  private maxConcurrent: number;\n\n  /**\n   *\n   * @param {number} [maxConcurrent] The maximum number of concurrent locks.\n   */\n  constructor(maxConcurrent: number = 1) {\n    this.semaphoreInstances = {};\n    this.maxConcurrent = maxConcurrent;\n  }\n\n  private hasSemaphoreInstance(key: string | number = defaultKey) {\n    return Boolean(this.semaphoreInstances[key]);\n  }\n\n  private getSemaphoreInstance(key: string | number = defaultKey) {\n    if (!this.hasSemaphoreInstance(key)) {\n      this.semaphoreInstances[key] = new SemaphoreItem(this.maxConcurrent);\n    }\n    return this.semaphoreInstances[key];\n  }\n\n  /**\n   *\n   * @param {string | number} [key]- Optional, the semaphore key.\n   */\n  private tidy(key: string | number = defaultKey): void {\n    if (\n      this.hasSemaphoreInstance(key) &&\n      this.getSemaphoreInstance(key).count == 0\n    ) {\n      delete this.semaphoreInstances[key];\n    }\n  }\n\n  /**\n   * A synchronous function to determine whether a lock can be acquired.\n   *\n   * @param {string | number} [key]- Optional, the semaphore key.\n   * @returns {boolean} Returns true if the lock on `key` can be acquired, false\n   * otherwise.\n   */\n  canAcquire(key: string | number = defaultKey): boolean {\n    return this.getSemaphoreInstance(key).canAcquire;\n  }\n\n  /**\n   *\n   * @param {string | number} [key]- Optional, the semaphore key.\n   */\n  acquire(key: string | number = defaultKey) {\n    return this.getSemaphoreInstance(key).acquire();\n  }\n\n  /**\n   *\n   * @param {string | number} [key]- Optional, the semaphore key.\n   */\n  release(key: string | number = defaultKey): void {\n    this.getSemaphoreInstance(key).release();\n    this.tidy(key);\n  }\n\n  /**\n   * The number of active locks.  Will always be less or equal to `max`.\n   *\n   * @param {string | number} [key]- Optional, the semaphore key.\n   */\n  count(key: string | number = defaultKey): number {\n    if (this.hasSemaphoreInstance(key)) {\n      return this.getSemaphoreInstance(key).count;\n    } else {\n      return 0;\n    }\n  }\n\n  /**\n   *\n   * @param {string | number} [key]- Optional, the semaphore key.\n   * @returns {boolean} True if the semaphore and key has locks, false otherwise.\n   */\n  hasTasks(key: string | number = defaultKey): boolean {\n    return this.count(key) > 0;\n  }\n\n  /**\n   *\n   * @param {Function<T>} fn The function to execute.\n   * @param {string | number} [key]- Optional, the semaphore key.\n   * @returns {Promise<T>}\n   */\n  async request<T>(\n    fn: Function,\n    key: string | number = defaultKey\n  ): Promise<T> {\n    try {\n      await this.acquire(key);\n      return await fn();\n    } finally {\n      this.release(key);\n    }\n  }\n\n  /**\n   * Asynchronously executes `fn` if a lock can be immediately acquired.\n   * Otherwise, returns null.\n   *\n   * @param {Function<T>} fn The function to execute.\n   * @param {string | number} [key]- Optional, the semaphore key.\n   * @returns {Promise<T>}\n   */\n  async requestIfAvailable<T>(\n    fn: Function,\n    key: string | number = defaultKey\n  ): Promise<T | null> {\n    if (this.canAcquire(key)) {\n      return this.request(fn, key);\n    } else {\n      return null;\n    }\n  }\n}\n\nexport default Semaphore;\n"],"names":["SemaphoreItem","maxConcurrent","this","queue","count","_proto","prototype","acquire","_this","canAcquire","Promise","resolve","push","release","resolveFunc","shift","setTimeout","key","get","defaultKey","Semaphore","semaphoreInstances","_proto2","hasSemaphoreInstance","Boolean","getSemaphoreInstance","tidy","hasTasks","request","fn","_this2","then","_finallyRethrows","_wasThrown","_result","e","reject","requestIfAvailable"],"mappings":"uOAAMA,0BAQJ,SAAAA,EAAYC,GAAqBC,KAPzBC,WACAF,EAAAA,KAAAA,mBAIDG,EAAAA,KAAAA,aAGLF,KAAKC,MAAQ,GACbD,KAAKD,cAAgBA,EACrBC,KAAKE,MAAQ,CACf,CAAC,QAAAC,EAAAL,EAAAM,UAIAN,OAJAK,EAMDE,QAAA,eAAOC,EAAAN,KACL,OAAIA,KAAKO,YACPP,KAAKE,QACEM,QAAQC,eAEJD,QAAQ,SAACC,GAAY,OAAAH,EAAKL,MAAMS,KAAKD,EAAQ,EAE5D,EAACN,EAEDQ,QAAA,WACE,IAAMC,EAAcZ,KAAKC,MAAMY,QAE3BD,EAEFE,WAAWF,EAAa,GAGxBZ,KAAKE,OAET,IAACJ,OAAAiB,IAAA,aAAAC,IAvBD,WACE,OAAOhB,KAAKE,MAAQF,KAAKD,aAC3B,mgBAACD,CAAA,IAwBGmB,EAAa;OAEJ,WAQb,SAAAC,EAAYnB,QAAAA,IAAAA,IAAAA,EAAwB,GAACC,KAP7BmB,wBAAkB,EAAAnB,KAClBD,mBAON,EAAAC,KAAKmB,mBAAqB,CAAE,EAC5BnB,KAAKD,cAAgBA,CACvB,CAAC,IAAAqB,EAAAF,EAAAd,UA+GA,OA/GAgB,EAEOC,qBAAA,SAAqBN,GAC3B,gBAD2BA,IAAAA,EAAuBE,GAC3CK,QAAQtB,KAAKmB,mBAAmBJ,GACzC,EAACK,EAEOG,qBAAA,SAAqBR,GAI3B,gBAJ2BA,IAAAA,EAAuBE,GAC7CjB,KAAKqB,qBAAqBN,KAC7Bf,KAAKmB,mBAAmBJ,GAAO,IAAIjB,EAAcE,KAAKD,gBAE7CC,KAACmB,mBAAmBJ,EACjC,EAACK,EAMOI,KAAA,SAAKT,QAAAA,IAAAA,IAAAA,EAAuBE,GAEhCjB,KAAKqB,qBAAqBN,IACc,GAAxCf,KAAKuB,qBAAqBR,GAAKb,cAExBF,KAAKmB,mBAAmBJ,EAEnC,EAACK,EASDb,WAAA,SAAWQ,GACT,gBADSA,IAAAA,EAAuBE,GACzBjB,KAAKuB,qBAAqBR,GAAKR,UACxC,EAACa,EAMDf,QAAA,SAAQU,GACN,gBADMA,IAAAA,EAAuBE,GAClBjB,KAACuB,qBAAqBR,GAAKV,SACxC,EAACe,EAMDT,QAAA,SAAQI,QAAAA,IAAAA,IAAAA,EAAuBE,GAC7BjB,KAAKuB,qBAAqBR,GAAKJ,UAC/BX,KAAKwB,KAAKT,EACZ,EAACK,EAODlB,MAAA,SAAMa,GACJ,gBADIA,IAAAA,EAAuBE,GACvBjB,KAAKqB,qBAAqBN,QAChBQ,qBAAqBR,GAAKb,MAGvC,CACH,EAACkB,EAODK,SAAA,SAASV,GACP,gBADOA,IAAAA,EAAuBE,GACvBjB,KAAKE,MAAMa,GAAO,CAC3B,EAACK,EAQKM,QAAOA,SACXC,EACAZ,YAAAA,IAAAA,EAAuBE,GAAU,IAAA,IAAAW,EAGzB5B,KAAIQ,OAAAA,QAAAC,gCADRD,QAAAC,QACImB,EAAKvB,QAAQU,IAAIc,KAAA,WAAA,OAAArB,QAAAC,QACVkB,IACd,4FAFWG,CADR,EAGHC,SAAAA,EAAAC,GACmB,GAAlBJ,EAAKjB,QAAQI,GAAKgB,EAAAC,MAAAA,SAAAA,CAAA,GAEtB,CAAC,MAAAC,GAAAzB,OAAAA,QAAA0B,OAAAD,EAAAb,CAAAA,EAAAA,EAUKe,mBAAkB,SACtBR,EACAZ,QAAAA,IAAAA,IAAAA,EAAuBE,GAAU,IAEjC,OAAIjB,KAAKO,WAAWQ,GAClBP,QAAAC,QADET,KACU0B,QAAQC,EAAIZ,IAExBP,QAAAC,QAAO,KAEX,CAAC,MAAAwB,GAAAzB,OAAAA,QAAA0B,OAAAD,EAAA,CAAA,EAAAf,CAAA,CA1HY"}

package/package.json

@@ -1,27 +1,26 @@
 {
   "name": "@chriscdn/promise-semaphore",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "Limit or throttle the simultaneous execution of asynchronous code in separate iterations of the event loop.",
-  "main": "lib/index.cjs.js",
-  "module": "lib/index.es.js",
-  "types": "lib/index.d.ts",
   "repository": "https://github.com/chriscdn/promise-semaphore",
   "author": "Christopher Meyer <chris@schwiiz.org>",
   "license": "MIT",
+  "type": "module",
+  "source": "./src/index.ts",
+  "main": "./lib/promise-semaphore.cjs",
+  "module": "./lib/promise-semaphore.module.js",
+  "unpkg": "./lib/promise-semaphore.umd.js",
+  "exports": {
+    "require": "./lib/promise-semaphore.cjs",
+    "default": "./lib/promise-semaphore.modern.js"
+  },
+  "types": "./lib/index.d.ts",
   "scripts": {
-    "build": "rollup -c",
-    "watch": "rollup -c --watch",
-    "test": "jest"
+    "build": "rm -rf ./lib/ && microbundle",
+    "dev": "microbundle watch"
   },
   "devDependencies": {
-    "@types/jest": "^29.4.0",
-    "esbuild": "^0.17.10",
-    "jest": "^29.4.3",
-    "rollup": "^3.17.3",
-    "rollup-plugin-dts": "^5.2.0",
-    "rollup-plugin-esbuild": "^5.0.0",
-    "ts-jest": "^29.0.5",
-    "typescript": "^4.9.5"
+    "microbundle": "^0.15.1"
   },
   "keywords": [
     "promise",

package/src/index.ts

@@ -1,67 +1,67 @@
 class SemaphoreItem {
-  private queue: Array<Function>
-  private maxConcurrent: number
+  private queue: Array<Function>;
+  private maxConcurrent: number;
   /**
    * The number of locks.
    */
-  public count: number
+  public count: number;
 
   constructor(maxConcurrent: number) {
-    this.queue = []
-    this.maxConcurrent = maxConcurrent
-    this.count = 0
+    this.queue = [];
+    this.maxConcurrent = maxConcurrent;
+    this.count = 0;
   }
 
   get canAcquire(): boolean {
-    return this.count < this.maxConcurrent
+    return this.count < this.maxConcurrent;
   }
 
   acquire(): Promise<void> {
     if (this.canAcquire) {
-      this.count++
-      return Promise.resolve()
+      this.count++;
+      return Promise.resolve();
     } else {
-      return new Promise((resolve) => this.queue.push(resolve))
+      return new Promise((resolve) => this.queue.push(resolve));
     }
   }
 
   release(): void {
-    const resolveFunc = this.queue.shift()
+    const resolveFunc = this.queue.shift();
 
     if (resolveFunc) {
       // Give the micro task queue a small break instead of calling resolveFunc() directly
-      setTimeout(resolveFunc, 0)
+      setTimeout(resolveFunc, 0);
       // resolveFunc()
     } else {
-      this.count--
+      this.count--;
     }
   }
 }
 
-const defaultKey = '_default'
+const defaultKey = "_default";
 
 class Semaphore {
-  private semaphoreInstances: Record<string | number, SemaphoreItem>
-  private maxConcurrent: number
+  private semaphoreInstances: Record<string | number, SemaphoreItem>;
+  private maxConcurrent: number;
 
   /**
    *
    * @param {number} [maxConcurrent] The maximum number of concurrent locks.
    */
   constructor(maxConcurrent: number = 1) {
-    this.semaphoreInstances = {}
-    this.maxConcurrent = maxConcurrent
+    this.semaphoreInstances = {};
+    this.maxConcurrent = maxConcurrent;
   }
 
   private hasSemaphoreInstance(key: string | number = defaultKey) {
-    return Boolean(this.semaphoreInstances[key])
+    return Boolean(this.semaphoreInstances[key]);
   }
 
   private getSemaphoreInstance(key: string | number = defaultKey) {
     if (!this.hasSemaphoreInstance(key)) {
-      this.semaphoreInstances[key] = new SemaphoreItem(this.maxConcurrent)
+      this.semaphoreInstances[key] = new SemaphoreItem(this.maxConcurrent);
     }
-    return this.semaphoreInstances[key]
+    return this.semaphoreInstances[key];
   }
 
   /**
@@ -73,7 +73,7 @@ class Semaphore {
       this.hasSemaphoreInstance(key) &&
       this.getSemaphoreInstance(key).count == 0
     ) {
-      delete this.semaphoreInstances[key]
+      delete this.semaphoreInstances[key];
     }
   }
 
@@ -85,7 +85,7 @@ class Semaphore {
    * otherwise.
    */
   canAcquire(key: string | number = defaultKey): boolean {
-    return this.getSemaphoreInstance(key).canAcquire
+    return this.getSemaphoreInstance(key).canAcquire;
   }
 
   /**
@@ -93,7 +93,7 @@ class Semaphore {
    * @param {string | number} [key]- Optional, the semaphore key.
    */
   acquire(key: string | number = defaultKey) {
-    return this.getSemaphoreInstance(key).acquire()
+    return this.getSemaphoreInstance(key).acquire();
   }
 
   /**
@@ -101,8 +101,8 @@ class Semaphore {
    * @param {string | number} [key]- Optional, the semaphore key.
    */
   release(key: string | number = defaultKey): void {
-    this.getSemaphoreInstance(key).release()
-    this.tidy(key)
+    this.getSemaphoreInstance(key).release();
+    this.tidy(key);
   }
 
   /**
@@ -112,9 +112,9 @@ class Semaphore {
    */
   count(key: string | number = defaultKey): number {
     if (this.hasSemaphoreInstance(key)) {
-      return this.getSemaphoreInstance(key).count
+      return this.getSemaphoreInstance(key).count;
     } else {
-      return 0
+      return 0;
     }
   }
 
@@ -124,7 +124,7 @@ class Semaphore {
    * @returns {boolean} True if the semaphore and key has locks, false otherwise.
    */
   hasTasks(key: string | number = defaultKey): boolean {
-    return this.count(key) > 0
+    return this.count(key) > 0;
   }
 
   /**
@@ -138,10 +138,10 @@ class Semaphore {
     key: string | number = defaultKey
   ): Promise<T> {
     try {
-      await this.acquire(key)
-      return await fn()
+      await this.acquire(key);
+      return await fn();
     } finally {
-      this.release(key)
+      this.release(key);
     }
   }
 
@@ -158,11 +158,11 @@ class Semaphore {
     key: string | number = defaultKey
   ): Promise<T | null> {
     if (this.canAcquire(key)) {
-      return this.request(fn, key)
+      return this.request(fn, key);
     } else {
-      return null
+      return null;
     }
   }
 }
 
-export default Semaphore
+export default Semaphore;

package/.prettierrc

@@ -1,4 +0,0 @@
-{
-  "semi": false,
-  "singleQuote": true
-}

package/lib/index.cjs.js

@@ -1,141 +0,0 @@
-'use strict';
-
-class SemaphoreItem {
-  queue;
-  maxConcurrent;
-  /**
-   * The number of locks.
-   */
-  count;
-  constructor(maxConcurrent) {
-    this.queue = [];
-    this.maxConcurrent = maxConcurrent;
-    this.count = 0;
-  }
-  get canAcquire() {
-    return this.count < this.maxConcurrent;
-  }
-  acquire() {
-    if (this.canAcquire) {
-      this.count++;
-      return Promise.resolve();
-    } else {
-      return new Promise((resolve) => this.queue.push(resolve));
-    }
-  }
-  release() {
-    const resolveFunc = this.queue.shift();
-    if (resolveFunc) {
-      setTimeout(resolveFunc, 0);
-    } else {
-      this.count--;
-    }
-  }
-}
-const defaultKey = "_default";
-class Semaphore {
-  semaphoreInstances;
-  maxConcurrent;
-  /**
-   *
-   * @param {number} [maxConcurrent] The maximum number of concurrent locks.
-   */
-  constructor(maxConcurrent = 1) {
-    this.semaphoreInstances = {};
-    this.maxConcurrent = maxConcurrent;
-  }
-  hasSemaphoreInstance(key = defaultKey) {
-    return Boolean(this.semaphoreInstances[key]);
-  }
-  getSemaphoreInstance(key = defaultKey) {
-    if (!this.hasSemaphoreInstance(key)) {
-      this.semaphoreInstances[key] = new SemaphoreItem(this.maxConcurrent);
-    }
-    return this.semaphoreInstances[key];
-  }
-  /**
-   *
-   * @param {string | number} [key]- Optional, the semaphore key.
-   */
-  tidy(key = defaultKey) {
-    if (this.hasSemaphoreInstance(key) && this.getSemaphoreInstance(key).count == 0) {
-      delete this.semaphoreInstances[key];
-    }
-  }
-  /**
-   * A synchronous function to determine whether a lock can be acquired.
-   *
-   * @param {string | number} [key]- Optional, the semaphore key.
-   * @returns {boolean} Returns true if the lock on `key` can be acquired, false
-   * otherwise.
-   */
-  canAcquire(key = defaultKey) {
-    return this.getSemaphoreInstance(key).canAcquire;
-  }
-  /**
-   *
-   * @param {string | number} [key]- Optional, the semaphore key.
-   */
-  acquire(key = defaultKey) {
-    return this.getSemaphoreInstance(key).acquire();
-  }
-  /**
-   *
-   * @param {string | number} [key]- Optional, the semaphore key.
-   */
-  release(key = defaultKey) {
-    this.getSemaphoreInstance(key).release();
-    this.tidy(key);
-  }
-  /**
-   * The number of active locks.  Will always be less or equal to `max`.
-   *
-   * @param {string | number} [key]- Optional, the semaphore key.
-   */
-  count(key = defaultKey) {
-    if (this.hasSemaphoreInstance(key)) {
-      return this.getSemaphoreInstance(key).count;
-    } else {
-      return 0;
-    }
-  }
-  /**
-   *
-   * @param {string | number} [key]- Optional, the semaphore key.
-   * @returns {boolean} True if the semaphore and key has locks, false otherwise.
-   */
-  hasTasks(key = defaultKey) {
-    return this.count(key) > 0;
-  }
-  /**
-   *
-   * @param {Function<T>} fn The function to execute.
-   * @param {string | number} [key]- Optional, the semaphore key.
-   * @returns {Promise<T>}
-   */
-  async request(fn, key = defaultKey) {
-    try {
-      await this.acquire(key);
-      return await fn();
-    } finally {
-      this.release(key);
-    }
-  }
-  /**
-   * Asynchronously executes `fn` if a lock can be immediately acquired.
-   * Otherwise, returns null.
-   *
-   * @param {Function<T>} fn The function to execute.
-   * @param {string | number} [key]- Optional, the semaphore key.
-   * @returns {Promise<T>}
-   */
-  async requestIfAvailable(fn, key = defaultKey) {
-    if (this.canAcquire(key)) {
-      return this.request(fn, key);
-    } else {
-      return null;
-    }
-  }
-}
-
-module.exports = Semaphore;

package/lib/index.es.js

@@ -1,139 +0,0 @@
-class SemaphoreItem {
-  queue;
-  maxConcurrent;
-  /**
-   * The number of locks.
-   */
-  count;
-  constructor(maxConcurrent) {
-    this.queue = [];
-    this.maxConcurrent = maxConcurrent;
-    this.count = 0;
-  }
-  get canAcquire() {
-    return this.count < this.maxConcurrent;
-  }
-  acquire() {
-    if (this.canAcquire) {
-      this.count++;
-      return Promise.resolve();
-    } else {
-      return new Promise((resolve) => this.queue.push(resolve));
-    }
-  }
-  release() {
-    const resolveFunc = this.queue.shift();
-    if (resolveFunc) {
-      setTimeout(resolveFunc, 0);
-    } else {
-      this.count--;
-    }
-  }
-}
-const defaultKey = "_default";
-class Semaphore {
-  semaphoreInstances;
-  maxConcurrent;
-  /**
-   *
-   * @param {number} [maxConcurrent] The maximum number of concurrent locks.
-   */
-  constructor(maxConcurrent = 1) {
-    this.semaphoreInstances = {};
-    this.maxConcurrent = maxConcurrent;
-  }
-  hasSemaphoreInstance(key = defaultKey) {
-    return Boolean(this.semaphoreInstances[key]);
-  }
-  getSemaphoreInstance(key = defaultKey) {
-    if (!this.hasSemaphoreInstance(key)) {
-      this.semaphoreInstances[key] = new SemaphoreItem(this.maxConcurrent);
-    }
-    return this.semaphoreInstances[key];
-  }
-  /**
-   *
-   * @param {string | number} [key]- Optional, the semaphore key.
-   */
-  tidy(key = defaultKey) {
-    if (this.hasSemaphoreInstance(key) && this.getSemaphoreInstance(key).count == 0) {
-      delete this.semaphoreInstances[key];
-    }
-  }
-  /**
-   * A synchronous function to determine whether a lock can be acquired.
-   *
-   * @param {string | number} [key]- Optional, the semaphore key.
-   * @returns {boolean} Returns true if the lock on `key` can be acquired, false
-   * otherwise.
-   */
-  canAcquire(key = defaultKey) {
-    return this.getSemaphoreInstance(key).canAcquire;
-  }
-  /**
-   *
-   * @param {string | number} [key]- Optional, the semaphore key.
-   */
-  acquire(key = defaultKey) {
-    return this.getSemaphoreInstance(key).acquire();
-  }
-  /**
-   *
-   * @param {string | number} [key]- Optional, the semaphore key.
-   */
-  release(key = defaultKey) {
-    this.getSemaphoreInstance(key).release();
-    this.tidy(key);
-  }
-  /**
-   * The number of active locks.  Will always be less or equal to `max`.
-   *
-   * @param {string | number} [key]- Optional, the semaphore key.
-   */
-  count(key = defaultKey) {
-    if (this.hasSemaphoreInstance(key)) {
-      return this.getSemaphoreInstance(key).count;
-    } else {
-      return 0;
-    }
-  }
-  /**
-   *
-   * @param {string | number} [key]- Optional, the semaphore key.
-   * @returns {boolean} True if the semaphore and key has locks, false otherwise.
-   */
-  hasTasks(key = defaultKey) {
-    return this.count(key) > 0;
-  }
-  /**
-   *
-   * @param {Function<T>} fn The function to execute.
-   * @param {string | number} [key]- Optional, the semaphore key.
-   * @returns {Promise<T>}
-   */
-  async request(fn, key = defaultKey) {
-    try {
-      await this.acquire(key);
-      return await fn();
-    } finally {
-      this.release(key);
-    }
-  }
-  /**
-   * Asynchronously executes `fn` if a lock can be immediately acquired.
-   * Otherwise, returns null.
-   *
-   * @param {Function<T>} fn The function to execute.
-   * @param {string | number} [key]- Optional, the semaphore key.
-   * @returns {Promise<T>}
-   */
-  async requestIfAvailable(fn, key = defaultKey) {
-    if (this.canAcquire(key)) {
-      return this.request(fn, key);
-    } else {
-      return null;
-    }
-  }
-}
-
-export { Semaphore as default };

package/rollup.config.mjs

@@ -1,40 +0,0 @@
-import pkg from './package.json' assert { type: 'json' }
-import dts from 'rollup-plugin-dts'
-import esbuild from 'rollup-plugin-esbuild'
-
-const input = 'src/index.ts'
-
-export default [
-  {
-    input,
-    plugins: [esbuild()],
-    output: [
-      {
-        file: pkg.main,
-        format: 'cjs',
-        // sourcemap: true,
-        // exports: 'default',
-      },
-    ],
-  },
-  {
-    input,
-    plugins: [esbuild()],
-    output: [
-      {
-        file: pkg.module,
-        format: 'es',
-        // sourcemap: true,
-        // exports: 'default',
-      },
-    ],
-  },
-  {
-    input,
-    plugins: [dts()],
-    output: {
-      file: 'lib/index.d.ts',
-      format: 'es',
-    },
-  },
-]

package/tsconfig.json

@@ -1,6 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "esnext",
-    "esModuleInterop": true
-  }
-}