@chriscdn/promise-semaphore 2.0.0 → 2.0.2

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.cjs.js

@@ -139,3 +139,4 @@ class Semaphore {
 }
 
 module.exports = Semaphore;
+//# sourceMappingURL=index.cjs.js.map

package/lib/index.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs.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":[],"mappings":"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"}

package/lib/index.es.js

@@ -137,3 +137,4 @@ class Semaphore {
 }
 
 export { Semaphore as default };
+//# sourceMappingURL=index.es.js.map

package/lib/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.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":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chriscdn/promise-semaphore",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "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",
@@ -14,14 +14,14 @@
     "test": "jest"
   },
   "devDependencies": {
-    "@types/jest": "^29.4.0",
-    "esbuild": "^0.17.10",
-    "jest": "^29.4.3",
-    "rollup": "^3.17.3",
-    "rollup-plugin-dts": "^5.2.0",
+    "@types/jest": "^29.5.4",
+    "esbuild": "^0.19.2",
+    "jest": "^29.7.0",
+    "rollup": "^3.29.1",
+    "rollup-plugin-dts": "^6.0.2",
     "rollup-plugin-esbuild": "^5.0.0",
-    "ts-jest": "^29.0.5",
-    "typescript": "^4.9.5"
+    "ts-jest": "^29.1.1",
+    "typescript": "^5.2.2"
   },
   "keywords": [
     "promise",

package/rollup.config.mjs

@@ -12,8 +12,7 @@ export default [
       {
         file: pkg.main,
         format: 'cjs',
-        // sourcemap: true,
-        // exports: 'default',
+        sourcemap: true,
       },
     ],
   },
@@ -24,8 +23,7 @@ export default [
       {
         file: pkg.module,
         format: 'es',
-        // sourcemap: true,
-        // exports: 'default',
+        sourcemap: true,
       },
     ],
   },
@@ -33,8 +31,7 @@ export default [
     input,
     plugins: [dts()],
     output: {
-      file: 'lib/index.d.ts',
-      format: 'es',
+      file: pkg.types,
     },
   },
 ]

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
-}