@chriscdn/promise-semaphore 3.1.3 → 4.0.1

package/README.md

@@ -11,17 +11,11 @@ Using npm:
 npm install @chriscdn/promise-semaphore
 ```
 
-Using yarn:
-
-```bash
-yarn add @chriscdn/promise-semaphore
-```
-
 ## Version 3
 
 Version 3 introduces two main changes:
 
-- A new `GroupSemaphore` class has been added. It allows multiple tasks within the same group (identified by a key) to run concurrently while ensuring that only one group's tasks are active at a time. See below for documentation.
+- A new `GroupSemaphore` class has been added. It allows multiple tasks within the same group (identified by a key) to run concurrently while ensuring that only one group's tasks are active at a time. See documenation below for details.
 - The default export has been replaced with a named export.
 
 Change:

package/lib/index.d.ts

@@ -1,67 +1,69 @@
+//#region src/semaphore.d.ts
 type KeyPrimitive = string | number;
 type Key = KeyPrimitive | {
-    key?: KeyPrimitive;
+  key?: KeyPrimitive;
 };
 type KeyOptions = Key & {
-    priority?: number;
+  priority?: number;
 };
 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?: Key): boolean;
-    /**
-     * @param {string | number} [key]- Optional, the semaphore key.
-     */
-    acquire(key?: KeyOptions): Promise<void>;
-    /**
-     * @param {string | number} [key]- Optional, the semaphore key.
-     */
-    release(key?: Key): void;
-    /**
-     * The number of active locks.  Will always be less or equal to `max`.
-     *
-     * @param {string | number} [key]- Optional, the semaphore key.
-     */
-    count(key?: Key): number;
-    /**
-     * @param {string | number} [key]- Optional, the semaphore key.
-     * @returns {boolean} True if the semaphore and key has locks, false otherwise.
-     */
-    hasTasks(key?: Key): 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?: KeyOptions): 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?: KeyOptions): Promise<T | null>;
+  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?: Key): boolean;
+  /**
+   * @param {string | number} [key]- Optional, the semaphore key.
+   */
+  acquire(key?: KeyOptions): Promise<void>;
+  /**
+   * @param {string | number} [key]- Optional, the semaphore key.
+   */
+  release(key?: Key): void;
+  /**
+   * The number of active locks.  Will always be less or equal to `max`.
+   *
+   * @param {string | number} [key]- Optional, the semaphore key.
+   */
+  count(key?: Key): number;
+  /**
+   * @param {string | number} [key]- Optional, the semaphore key.
+   * @returns {boolean} True if the semaphore and key has locks, false otherwise.
+   */
+  hasTasks(key?: Key): 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?: KeyOptions): 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?: KeyOptions): Promise<T | null>;
 }
-
+//#endregion
+//#region src/group-semaphore.d.ts
 /**
  * GroupSemaphore manages a shared semaphore for different groups of tasks. Each
  * group is identified by a unique key, and the semaphore ensures only one group
@@ -80,11 +82,12 @@ declare class Semaphore {
  * are active.
  */
 declare class GroupSemaphore {
-    private _semaphore;
-    private _activeCounts;
-    private _groupWaiters;
-    acquire(key: string): Promise<void>;
-    release(key: string): void;
+  private _semaphore;
+  private _activeCounts;
+  private _groupWaiters;
+  acquire(key: string): Promise<void>;
+  release(key: string): void;
 }
-
+//#endregion
 export { GroupSemaphore, Semaphore };
+//# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -1,179 +1,180 @@
-// src/semaphore.ts
-var defaultKey = "_default";
-var _isPrimitiveKey = (item) => ["string", "number"].includes(typeof item);
-var resolveKey = (item) => (_isPrimitiveKey(item) ? item : item.key) ?? defaultKey;
-var resolvePriority = (item) => (_isPrimitiveKey(item) ? 0 : item.priority) ?? 0;
+//#region src/semaphore.ts
+const defaultKey = "_default";
+const _isPrimitiveKey = (item) => ["string", "number"].includes(typeof item);
+const resolveKey = (item) => (_isPrimitiveKey(item) ? item : item.key) ?? defaultKey;
+const resolvePriority = (item) => (_isPrimitiveKey(item) ? 0 : item.priority) ?? 0;
 var SemaphoreItem = class {
-  queue;
-  maxConcurrent;
-  /**
-   * The number of locks.
-   */
-  count;
-  constructor(maxConcurrent) {
-    this.queue = [];
-    this.maxConcurrent = maxConcurrent;
-    this.count = 0;
-  }
-  get canAcquire() {
-    return this.count < this.maxConcurrent;
-  }
-  incrementCount() {
-    this.count++;
-  }
-  decrementCount() {
-    this.count--;
-  }
-  acquire(priority) {
-    if (this.canAcquire) {
-      this.incrementCount();
-      return Promise.resolve();
-    } else {
-      return new Promise((resolve) => {
-        this.queue.push({ resolve, priority });
-        this.queue.sort((a, b) => b.priority - a.priority);
-      });
-    }
-  }
-  release() {
-    const resolveFunc = this.queue.shift();
-    if (resolveFunc) {
-      setTimeout(resolveFunc.resolve, 0);
-    } else {
-      this.decrementCount();
-    }
-  }
+	queue;
+	maxConcurrent;
+	/**
+	* The number of locks.
+	*/
+	count;
+	constructor(maxConcurrent) {
+		this.queue = [];
+		this.maxConcurrent = maxConcurrent;
+		this.count = 0;
+	}
+	get canAcquire() {
+		return this.count < this.maxConcurrent;
+	}
+	incrementCount() {
+		this.count++;
+	}
+	decrementCount() {
+		this.count--;
+	}
+	acquire(priority) {
+		if (this.canAcquire) {
+			this.incrementCount();
+			return Promise.resolve();
+		} else return new Promise((resolve) => {
+			this.queue.push({
+				resolve,
+				priority
+			});
+			this.queue.sort((a, b) => b.priority - a.priority);
+		});
+	}
+	release() {
+		const resolveFunc = this.queue.shift();
+		if (resolveFunc) setTimeout(resolveFunc.resolve, 0);
+		else this.decrementCount();
+	}
 };
 var Semaphore = class {
-  semaphoreInstances;
-  maxConcurrent;
-  /**
-   * @param {number} [maxConcurrent] The maximum number of concurrent locks.
-   */
-  constructor(maxConcurrent = 1) {
-    this.semaphoreInstances = {};
-    this.maxConcurrent = maxConcurrent;
-    if (maxConcurrent < 1) {
-      throw new Error("The maxConcurrent must be 1 or greater.");
-    }
-  }
-  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) {
-    const _key = resolveKey(key);
-    return !this.hasSemaphoreInstance(_key) || this.getSemaphoreInstance(_key).canAcquire;
-  }
-  /**
-   * @param {string | number} [key]- Optional, the semaphore key.
-   */
-  acquire(key = defaultKey) {
-    const _key = resolveKey(key);
-    const _priority = resolvePriority(key);
-    return this.getSemaphoreInstance(_key).acquire(_priority);
-  }
-  /**
-   * @param {string | number} [key]- Optional, the semaphore key.
-   */
-  release(key = defaultKey) {
-    const _key = resolveKey(key);
-    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) {
-    const _key = resolveKey(key);
-    return this.hasSemaphoreInstance(_key) ? this.getSemaphoreInstance(_key).count : 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;
-    }
-  }
+	semaphoreInstances;
+	maxConcurrent;
+	/**
+	* @param {number} [maxConcurrent] The maximum number of concurrent locks.
+	*/
+	constructor(maxConcurrent = 1) {
+		this.semaphoreInstances = {};
+		this.maxConcurrent = maxConcurrent;
+		if (maxConcurrent < 1) throw new Error("The maxConcurrent must be 1 or greater.");
+	}
+	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) {
+		const _key = resolveKey(key);
+		return !this.hasSemaphoreInstance(_key) || this.getSemaphoreInstance(_key).canAcquire;
+	}
+	/**
+	* @param {string | number} [key]- Optional, the semaphore key.
+	*/
+	acquire(key = defaultKey) {
+		const _key = resolveKey(key);
+		const _priority = resolvePriority(key);
+		return this.getSemaphoreInstance(_key).acquire(_priority);
+	}
+	/**
+	* @param {string | number} [key]- Optional, the semaphore key.
+	*/
+	release(key = defaultKey) {
+		const _key = resolveKey(key);
+		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) {
+		const _key = resolveKey(key);
+		return this.hasSemaphoreInstance(_key) ? this.getSemaphoreInstance(_key).count : 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;
+	}
 };
-
-// src/group-semaphore.ts
+//#endregion
+//#region src/group-semaphore.ts
+/**
+* GroupSemaphore manages a shared semaphore for different groups of tasks. Each
+* group is identified by a unique key, and the semaphore ensures only one group
+* can run its tasks concurrently.
+*
+* - acquire(key): Increments the active count for the given group. If it's the
+*   first task for the group (active count is 0), it acquires the global
+*   semaphore, ensuring only one group's tasks can proceed at a time.
+*   Subsequent calls in the group increment the count and are permitted to run.
+* - release(key): Decrements the active count for the group. If the last task
+*   for that group is released, it releases the global semaphore, allowing
+*   other groups to proceed.
+*
+* This ensures that only one group can execute concurrently, but multiple tasks
+* within the same group can run as long as no other tasks from different groups
+* are active.
+*/
 var GroupSemaphore = class {
-  _semaphore = new Semaphore();
-  _activeCounts = {};
-  _groupWaiters = {};
-  async acquire(key) {
-    const activeCount = this._activeCounts[key] ?? 0;
-    this._activeCounts[key] = activeCount + 1;
-    const waiter = this._groupWaiters[key] ?? this._semaphore.acquire();
-    this._groupWaiters[key] = waiter;
-    await waiter;
-  }
-  release(key) {
-    const activeCount = this._activeCounts[key];
-    if (activeCount === 1) {
-      this._semaphore.release();
-      delete this._activeCounts[key];
-      delete this._groupWaiters[key];
-    } else {
-      this._activeCounts[key] = activeCount - 1;
-    }
-  }
-};
-export {
-  GroupSemaphore,
-  Semaphore
+	_semaphore = new Semaphore();
+	_activeCounts = {};
+	_groupWaiters = {};
+	async acquire(key) {
+		const activeCount = this._activeCounts[key] ?? 0;
+		this._activeCounts[key] = activeCount + 1;
+		const waiter = this._groupWaiters[key] ?? this._semaphore.acquire();
+		this._groupWaiters[key] = waiter;
+		await waiter;
+	}
+	release(key) {
+		const activeCount = this._activeCounts[key];
+		if (activeCount === 1) {
+			this._semaphore.release();
+			delete this._activeCounts[key];
+			delete this._groupWaiters[key];
+		} else this._activeCounts[key] = activeCount - 1;
+	}
 };
+//#endregion
+export { GroupSemaphore, Semaphore };
+
 //# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/semaphore.ts","../src/group-semaphore.ts"],"sourcesContent":["const defaultKey = \"_default\";\n\ntype KeyPrimitive = string | number;\n\ntype Key = KeyPrimitive | { key?: KeyPrimitive };\ntype KeyOptions = Key & { priority?: number };\n\nconst _isPrimitiveKey = (item: Key): item is KeyPrimitive =>\n    [\"string\", \"number\"].includes(typeof item);\n\nconst resolveKey = (item: Key): KeyPrimitive =>\n    (_isPrimitiveKey(item) ? item : item.key) ?? defaultKey;\n\nconst resolvePriority = (item: KeyOptions) =>\n    (_isPrimitiveKey(item) ? 0 : item.priority) ?? 0;\n\nclass SemaphoreItem {\n    private queue: Array<{\n        resolve: Function;\n        priority: number;\n    }>;\n    private maxConcurrent: number;\n\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    private incrementCount() {\n        this.count++;\n    }\n\n    private decrementCount() {\n        this.count--;\n    }\n\n    acquire(priority: number): Promise<void> {\n        if (this.canAcquire) {\n            this.incrementCount();\n            return Promise.resolve();\n        } else {\n            return new Promise((resolve) => {\n                this.queue.push({ resolve, priority });\n                this.queue.sort((a, b) => b.priority - a.priority);\n            });\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.resolve, 0);\n            // queueMicrotask(() => resolveFunc.resolve());\n        } else {\n            this.decrementCount();\n        }\n    }\n}\n\nclass Semaphore {\n    private semaphoreInstances: Record<string | number, SemaphoreItem>;\n    private maxConcurrent: number;\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        if (maxConcurrent < 1) {\n            throw new Error(\"The maxConcurrent must be 1 or greater.\");\n        }\n    }\n\n    private hasSemaphoreInstance(key: KeyPrimitive = defaultKey) {\n        return Boolean(this.semaphoreInstances[key]);\n    }\n\n    private getSemaphoreInstance(key: KeyPrimitive = defaultKey) {\n        if (!this.hasSemaphoreInstance(key)) {\n            this.semaphoreInstances[key] = new SemaphoreItem(\n                this.maxConcurrent,\n            );\n        }\n        return this.semaphoreInstances[key] as SemaphoreItem;\n    }\n\n    /**\n     * @param {string | number} [key]- Optional, the semaphore key.\n     */\n    private tidy(key: KeyPrimitive = 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: Key = defaultKey): boolean {\n        const _key = resolveKey(key);\n\n        return !this.hasSemaphoreInstance(_key) ||\n            this.getSemaphoreInstance(_key).canAcquire;\n    }\n\n    /**\n     * @param {string | number} [key]- Optional, the semaphore key.\n     */\n    acquire(key: KeyOptions = defaultKey) {\n        const _key = resolveKey(key);\n        const _priority = resolvePriority(key);\n\n        return this.getSemaphoreInstance(_key).acquire(_priority);\n    }\n\n    /**\n     * @param {string | number} [key]- Optional, the semaphore key.\n     */\n    release(key: Key = defaultKey): void {\n        const _key = resolveKey(key);\n\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: Key = defaultKey): number {\n        const _key = resolveKey(key);\n\n        return (this.hasSemaphoreInstance(_key))\n            ? this.getSemaphoreInstance(_key).count\n            : 0;\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: Key = defaultKey): boolean {\n        return this.count(key) > 0;\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: KeyOptions = 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: KeyOptions = 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 { Semaphore };\n","import { Semaphore } from \"./semaphore\";\n\n/**\n * GroupSemaphore manages a shared semaphore for different groups of tasks. Each\n * group is identified by a unique key, and the semaphore ensures only one group\n * can run its tasks concurrently.\n *\n * - acquire(key): Increments the active count for the given group. If it's the\n *   first task for the group (active count is 0), it acquires the global\n *   semaphore, ensuring only one group's tasks can proceed at a time.\n *   Subsequent calls in the group increment the count and are permitted to run.\n * - release(key): Decrements the active count for the group. If the last task\n *   for that group is released, it releases the global semaphore, allowing\n *   other groups to proceed.\n *\n * This ensures that only one group can execute concurrently, but multiple tasks\n * within the same group can run as long as no other tasks from different groups\n * are active.\n */\nclass GroupSemaphore {\n    private _semaphore = new Semaphore();\n    private _activeCounts: Record<string, number> = {};\n    private _groupWaiters: Record<string, Promise<void>> = {};\n\n    async acquire(key: string) {\n        const activeCount = this._activeCounts[key] ?? 0;\n        this._activeCounts[key] = activeCount + 1;\n        const waiter = this._groupWaiters[key] ?? this._semaphore.acquire();\n        this._groupWaiters[key] = waiter;\n        await waiter;\n    }\n\n    release(key: string) {\n        const activeCount = this._activeCounts[key] as number;\n\n        if (activeCount === 1) {\n            this._semaphore.release();\n            delete this._activeCounts[key];\n            delete this._groupWaiters[key];\n        } else {\n            this._activeCounts[key] = activeCount - 1;\n        }\n    }\n}\n\nexport { GroupSemaphore };\n"],"mappings":"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","names":[]}
+{"version":3,"file":"index.js","names":[],"sources":["../src/semaphore.ts","../src/group-semaphore.ts"],"sourcesContent":["const defaultKey = \"_default\";\n\ntype KeyPrimitive = string | number;\n\ntype Key = KeyPrimitive | { key?: KeyPrimitive };\ntype KeyOptions = Key & { priority?: number };\n\nconst _isPrimitiveKey = (item: Key): item is KeyPrimitive =>\n  [\"string\", \"number\"].includes(typeof item);\n\nconst resolveKey = (item: Key): KeyPrimitive =>\n  (_isPrimitiveKey(item) ? item : item.key) ?? defaultKey;\n\nconst resolvePriority = (item: KeyOptions) =>\n  (_isPrimitiveKey(item) ? 0 : item.priority) ?? 0;\n\nclass SemaphoreItem {\n  private queue: Array<{\n    resolve: Function;\n    priority: number;\n  }>;\n  private maxConcurrent: number;\n\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  private incrementCount() {\n    this.count++;\n  }\n\n  private decrementCount() {\n    this.count--;\n  }\n\n  acquire(priority: number): Promise<void> {\n    if (this.canAcquire) {\n      this.incrementCount();\n      return Promise.resolve();\n    } else {\n      return new Promise((resolve) => {\n        this.queue.push({ resolve, priority });\n        this.queue.sort((a, b) => b.priority - a.priority);\n      });\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.resolve, 0);\n      // queueMicrotask(() => resolveFunc.resolve());\n    } else {\n      this.decrementCount();\n    }\n  }\n}\n\nclass Semaphore {\n  private semaphoreInstances: Record<string | number, SemaphoreItem>;\n  private maxConcurrent: number;\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    if (maxConcurrent < 1) {\n      throw new Error(\"The maxConcurrent must be 1 or greater.\");\n    }\n  }\n\n  private hasSemaphoreInstance(key: KeyPrimitive = defaultKey) {\n    return Boolean(this.semaphoreInstances[key]);\n  }\n\n  private getSemaphoreInstance(key: KeyPrimitive = defaultKey) {\n    if (!this.hasSemaphoreInstance(key)) {\n      this.semaphoreInstances[key] = new SemaphoreItem(this.maxConcurrent);\n    }\n    return this.semaphoreInstances[key] as SemaphoreItem;\n  }\n\n  /**\n   * @param {string | number} [key]- Optional, the semaphore key.\n   */\n  private tidy(key: KeyPrimitive = 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: Key = defaultKey): boolean {\n    const _key = resolveKey(key);\n\n    return (\n      !this.hasSemaphoreInstance(_key) ||\n      this.getSemaphoreInstance(_key).canAcquire\n    );\n  }\n\n  /**\n   * @param {string | number} [key]- Optional, the semaphore key.\n   */\n  acquire(key: KeyOptions = defaultKey) {\n    const _key = resolveKey(key);\n    const _priority = resolvePriority(key);\n\n    return this.getSemaphoreInstance(_key).acquire(_priority);\n  }\n\n  /**\n   * @param {string | number} [key]- Optional, the semaphore key.\n   */\n  release(key: Key = defaultKey): void {\n    const _key = resolveKey(key);\n\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: Key = defaultKey): number {\n    const _key = resolveKey(key);\n\n    return this.hasSemaphoreInstance(_key)\n      ? this.getSemaphoreInstance(_key).count\n      : 0;\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: Key = defaultKey): boolean {\n    return this.count(key) > 0;\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>(fn: Function, key: KeyOptions = defaultKey): 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: KeyOptions = 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 { Semaphore };\n","import { Semaphore } from \"./semaphore\";\n\n/**\n * GroupSemaphore manages a shared semaphore for different groups of tasks. Each\n * group is identified by a unique key, and the semaphore ensures only one group\n * can run its tasks concurrently.\n *\n * - acquire(key): Increments the active count for the given group. If it's the\n *   first task for the group (active count is 0), it acquires the global\n *   semaphore, ensuring only one group's tasks can proceed at a time.\n *   Subsequent calls in the group increment the count and are permitted to run.\n * - release(key): Decrements the active count for the group. If the last task\n *   for that group is released, it releases the global semaphore, allowing\n *   other groups to proceed.\n *\n * This ensures that only one group can execute concurrently, but multiple tasks\n * within the same group can run as long as no other tasks from different groups\n * are active.\n */\nclass GroupSemaphore {\n  private _semaphore = new Semaphore();\n  private _activeCounts: Record<string, number> = {};\n  private _groupWaiters: Record<string, Promise<void>> = {};\n\n  async acquire(key: string) {\n    const activeCount = this._activeCounts[key] ?? 0;\n    this._activeCounts[key] = activeCount + 1;\n    const waiter = this._groupWaiters[key] ?? this._semaphore.acquire();\n    this._groupWaiters[key] = waiter;\n    await waiter;\n  }\n\n  release(key: string) {\n    const activeCount = this._activeCounts[key] as number;\n\n    if (activeCount === 1) {\n      this._semaphore.release();\n      delete this._activeCounts[key];\n      delete this._groupWaiters[key];\n    } else {\n      this._activeCounts[key] = activeCount - 1;\n    }\n  }\n}\n\nexport { GroupSemaphore };\n"],"mappings":"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"}

package/package.json

@@ -1,36 +1,26 @@
 {
   "name": "@chriscdn/promise-semaphore",
-  "version": "3.1.3",
+  "version": "4.0.1",
   "description": "Limit or throttle the simultaneous execution of asynchronous code in separate iterations of the event loop.",
-  "repository": "https://github.com/chriscdn/promise-semaphore",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chriscdn/promise-semaphore"
+  },
   "author": "Christopher Meyer <chris@schwiiz.org>",
   "license": "MIT",
   "type": "module",
-  "main": "./lib/index.cjs",
-  "module": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "exports": {
     ".": {
-      "import": {
-        "types": "./lib/index.d.ts",
-        "default": "./lib/index.js"
-      },
-      "require": {
-        "types": "./lib/index.d.cts",
-        "default": "./lib/index.cjs"
-      }
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.js"
     }
   },
-  "scripts": {
-    "build": "tsup",
-    "watch": "yarn build --watch",
-    "test": "vitest"
-  },
   "devDependencies": {
     "@tsconfig/strictest": "^2.0.8",
-    "tsup": "^8.5.1",
+    "tsdown": "0.22.14",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.8"
+    "vitest": "^4.1.10"
   },
   "files": [
     "lib"
@@ -42,5 +32,10 @@
     "mutex",
     "async",
     "throttle"
-  ]
-}
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "watch": "pn build --watch",
+    "test": "vitest"
+  }
+}

package/lib/index.cjs

@@ -1,207 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  GroupSemaphore: () => GroupSemaphore,
-  Semaphore: () => Semaphore
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/semaphore.ts
-var defaultKey = "_default";
-var _isPrimitiveKey = (item) => ["string", "number"].includes(typeof item);
-var resolveKey = (item) => (_isPrimitiveKey(item) ? item : item.key) ?? defaultKey;
-var resolvePriority = (item) => (_isPrimitiveKey(item) ? 0 : item.priority) ?? 0;
-var SemaphoreItem = class {
-  queue;
-  maxConcurrent;
-  /**
-   * The number of locks.
-   */
-  count;
-  constructor(maxConcurrent) {
-    this.queue = [];
-    this.maxConcurrent = maxConcurrent;
-    this.count = 0;
-  }
-  get canAcquire() {
-    return this.count < this.maxConcurrent;
-  }
-  incrementCount() {
-    this.count++;
-  }
-  decrementCount() {
-    this.count--;
-  }
-  acquire(priority) {
-    if (this.canAcquire) {
-      this.incrementCount();
-      return Promise.resolve();
-    } else {
-      return new Promise((resolve) => {
-        this.queue.push({ resolve, priority });
-        this.queue.sort((a, b) => b.priority - a.priority);
-      });
-    }
-  }
-  release() {
-    const resolveFunc = this.queue.shift();
-    if (resolveFunc) {
-      setTimeout(resolveFunc.resolve, 0);
-    } else {
-      this.decrementCount();
-    }
-  }
-};
-var Semaphore = class {
-  semaphoreInstances;
-  maxConcurrent;
-  /**
-   * @param {number} [maxConcurrent] The maximum number of concurrent locks.
-   */
-  constructor(maxConcurrent = 1) {
-    this.semaphoreInstances = {};
-    this.maxConcurrent = maxConcurrent;
-    if (maxConcurrent < 1) {
-      throw new Error("The maxConcurrent must be 1 or greater.");
-    }
-  }
-  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) {
-    const _key = resolveKey(key);
-    return !this.hasSemaphoreInstance(_key) || this.getSemaphoreInstance(_key).canAcquire;
-  }
-  /**
-   * @param {string | number} [key]- Optional, the semaphore key.
-   */
-  acquire(key = defaultKey) {
-    const _key = resolveKey(key);
-    const _priority = resolvePriority(key);
-    return this.getSemaphoreInstance(_key).acquire(_priority);
-  }
-  /**
-   * @param {string | number} [key]- Optional, the semaphore key.
-   */
-  release(key = defaultKey) {
-    const _key = resolveKey(key);
-    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) {
-    const _key = resolveKey(key);
-    return this.hasSemaphoreInstance(_key) ? this.getSemaphoreInstance(_key).count : 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;
-    }
-  }
-};
-
-// src/group-semaphore.ts
-var GroupSemaphore = class {
-  _semaphore = new Semaphore();
-  _activeCounts = {};
-  _groupWaiters = {};
-  async acquire(key) {
-    const activeCount = this._activeCounts[key] ?? 0;
-    this._activeCounts[key] = activeCount + 1;
-    const waiter = this._groupWaiters[key] ?? this._semaphore.acquire();
-    this._groupWaiters[key] = waiter;
-    await waiter;
-  }
-  release(key) {
-    const activeCount = this._activeCounts[key];
-    if (activeCount === 1) {
-      this._semaphore.release();
-      delete this._activeCounts[key];
-      delete this._groupWaiters[key];
-    } else {
-      this._activeCounts[key] = activeCount - 1;
-    }
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  GroupSemaphore,
-  Semaphore
-});
-//# sourceMappingURL=index.cjs.map

package/lib/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/index.ts","../src/semaphore.ts","../src/group-semaphore.ts"],"sourcesContent":["export { Semaphore } from \"./semaphore\";\nexport { GroupSemaphore } from \"./group-semaphore\";\n","const defaultKey = \"_default\";\n\ntype KeyPrimitive = string | number;\n\ntype Key = KeyPrimitive | { key?: KeyPrimitive };\ntype KeyOptions = Key & { priority?: number };\n\nconst _isPrimitiveKey = (item: Key): item is KeyPrimitive =>\n    [\"string\", \"number\"].includes(typeof item);\n\nconst resolveKey = (item: Key): KeyPrimitive =>\n    (_isPrimitiveKey(item) ? item : item.key) ?? defaultKey;\n\nconst resolvePriority = (item: KeyOptions) =>\n    (_isPrimitiveKey(item) ? 0 : item.priority) ?? 0;\n\nclass SemaphoreItem {\n    private queue: Array<{\n        resolve: Function;\n        priority: number;\n    }>;\n    private maxConcurrent: number;\n\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    private incrementCount() {\n        this.count++;\n    }\n\n    private decrementCount() {\n        this.count--;\n    }\n\n    acquire(priority: number): Promise<void> {\n        if (this.canAcquire) {\n            this.incrementCount();\n            return Promise.resolve();\n        } else {\n            return new Promise((resolve) => {\n                this.queue.push({ resolve, priority });\n                this.queue.sort((a, b) => b.priority - a.priority);\n            });\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.resolve, 0);\n            // queueMicrotask(() => resolveFunc.resolve());\n        } else {\n            this.decrementCount();\n        }\n    }\n}\n\nclass Semaphore {\n    private semaphoreInstances: Record<string | number, SemaphoreItem>;\n    private maxConcurrent: number;\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        if (maxConcurrent < 1) {\n            throw new Error(\"The maxConcurrent must be 1 or greater.\");\n        }\n    }\n\n    private hasSemaphoreInstance(key: KeyPrimitive = defaultKey) {\n        return Boolean(this.semaphoreInstances[key]);\n    }\n\n    private getSemaphoreInstance(key: KeyPrimitive = defaultKey) {\n        if (!this.hasSemaphoreInstance(key)) {\n            this.semaphoreInstances[key] = new SemaphoreItem(\n                this.maxConcurrent,\n            );\n        }\n        return this.semaphoreInstances[key] as SemaphoreItem;\n    }\n\n    /**\n     * @param {string | number} [key]- Optional, the semaphore key.\n     */\n    private tidy(key: KeyPrimitive = 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: Key = defaultKey): boolean {\n        const _key = resolveKey(key);\n\n        return !this.hasSemaphoreInstance(_key) ||\n            this.getSemaphoreInstance(_key).canAcquire;\n    }\n\n    /**\n     * @param {string | number} [key]- Optional, the semaphore key.\n     */\n    acquire(key: KeyOptions = defaultKey) {\n        const _key = resolveKey(key);\n        const _priority = resolvePriority(key);\n\n        return this.getSemaphoreInstance(_key).acquire(_priority);\n    }\n\n    /**\n     * @param {string | number} [key]- Optional, the semaphore key.\n     */\n    release(key: Key = defaultKey): void {\n        const _key = resolveKey(key);\n\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: Key = defaultKey): number {\n        const _key = resolveKey(key);\n\n        return (this.hasSemaphoreInstance(_key))\n            ? this.getSemaphoreInstance(_key).count\n            : 0;\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: Key = defaultKey): boolean {\n        return this.count(key) > 0;\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: KeyOptions = 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: KeyOptions = 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 { Semaphore };\n","import { Semaphore } from \"./semaphore\";\n\n/**\n * GroupSemaphore manages a shared semaphore for different groups of tasks. Each\n * group is identified by a unique key, and the semaphore ensures only one group\n * can run its tasks concurrently.\n *\n * - acquire(key): Increments the active count for the given group. If it's the\n *   first task for the group (active count is 0), it acquires the global\n *   semaphore, ensuring only one group's tasks can proceed at a time.\n *   Subsequent calls in the group increment the count and are permitted to run.\n * - release(key): Decrements the active count for the group. If the last task\n *   for that group is released, it releases the global semaphore, allowing\n *   other groups to proceed.\n *\n * This ensures that only one group can execute concurrently, but multiple tasks\n * within the same group can run as long as no other tasks from different groups\n * are active.\n */\nclass GroupSemaphore {\n    private _semaphore = new Semaphore();\n    private _activeCounts: Record<string, number> = {};\n    private _groupWaiters: Record<string, Promise<void>> = {};\n\n    async acquire(key: string) {\n        const activeCount = this._activeCounts[key] ?? 0;\n        this._activeCounts[key] = activeCount + 1;\n        const waiter = this._groupWaiters[key] ?? this._semaphore.acquire();\n        this._groupWaiters[key] = waiter;\n        await waiter;\n    }\n\n    release(key: string) {\n        const activeCount = this._activeCounts[key] as number;\n\n        if (activeCount === 1) {\n            this._semaphore.release();\n            delete this._activeCounts[key];\n            delete this._groupWaiters[key];\n        } else {\n            this._activeCounts[key] = activeCount - 1;\n        }\n    }\n}\n\nexport { GroupSemaphore };\n"],"mappings":"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","names":[]}

package/lib/index.d.cts

@@ -1,90 +0,0 @@
-type KeyPrimitive = string | number;
-type Key = KeyPrimitive | {
-    key?: KeyPrimitive;
-};
-type KeyOptions = Key & {
-    priority?: number;
-};
-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?: Key): boolean;
-    /**
-     * @param {string | number} [key]- Optional, the semaphore key.
-     */
-    acquire(key?: KeyOptions): Promise<void>;
-    /**
-     * @param {string | number} [key]- Optional, the semaphore key.
-     */
-    release(key?: Key): void;
-    /**
-     * The number of active locks.  Will always be less or equal to `max`.
-     *
-     * @param {string | number} [key]- Optional, the semaphore key.
-     */
-    count(key?: Key): number;
-    /**
-     * @param {string | number} [key]- Optional, the semaphore key.
-     * @returns {boolean} True if the semaphore and key has locks, false otherwise.
-     */
-    hasTasks(key?: Key): 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?: KeyOptions): 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?: KeyOptions): Promise<T | null>;
-}
-
-/**
- * GroupSemaphore manages a shared semaphore for different groups of tasks. Each
- * group is identified by a unique key, and the semaphore ensures only one group
- * can run its tasks concurrently.
- *
- * - acquire(key): Increments the active count for the given group. If it's the
- *   first task for the group (active count is 0), it acquires the global
- *   semaphore, ensuring only one group's tasks can proceed at a time.
- *   Subsequent calls in the group increment the count and are permitted to run.
- * - release(key): Decrements the active count for the group. If the last task
- *   for that group is released, it releases the global semaphore, allowing
- *   other groups to proceed.
- *
- * This ensures that only one group can execute concurrently, but multiple tasks
- * within the same group can run as long as no other tasks from different groups
- * are active.
- */
-declare class GroupSemaphore {
-    private _semaphore;
-    private _activeCounts;
-    private _groupWaiters;
-    acquire(key: string): Promise<void>;
-    release(key: string): void;
-}
-
-export { GroupSemaphore, Semaphore };