@chriscdn/promise-semaphore 3.1.2 → 4.0.0

package/lib/index.d.ts

@@ -1,2 +1,90 @@
-export { Semaphore } from "./semaphore";
-export { GroupSemaphore } from "./group-semaphore";
+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 };

package/lib/index.js

@@ -0,0 +1,179 @@
+// 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;
+    }
+  }
+};
+export {
+  GroupSemaphore,
+  Semaphore
+};
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +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":[]}

package/package.json

@@ -1,29 +1,24 @@
 {
   "name": "@chriscdn/promise-semaphore",
-  "version": "3.1.2",
+  "version": "4.0.0",
   "description": "Limit or throttle the simultaneous execution of asynchronous code in separate iterations of the event loop.",
   "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": {
-    "types": "./lib/index.d.ts",
-    "require": "./lib/promise-semaphore.cjs",
-    "default": "./lib/promise-semaphore.modern.js"
-  },
+  "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
+  "exports": "./lib/index.js",
   "scripts": {
-    "build": "rm -rf ./lib/ && microbundle --format modern,esm,cjs",
-    "dev": "microbundle watch",
+    "build": "tsup",
+    "watch": "yarn build --watch",
     "test": "vitest"
   },
   "devDependencies": {
-    "microbundle": "^0.15.1",
-    "vitest": "^4.0.5"
+    "@tsconfig/strictest": "^2.0.8",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.8"
   },
   "files": [
     "lib"

package/lib/group-semaphore.d.ts

@@ -1,25 +0,0 @@
-/**
- * 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 };

package/lib/promise-semaphore.cjs

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

package/lib/promise-semaphore.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"promise-semaphore.cjs","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        } 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];\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];\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"],"names":["defaultKey","_isPrimitiveKey","item","includes","resolveKey","_ref","key","SemaphoreItem","maxConcurrent","queue","this","count","_proto","prototype","_createClass","incrementCount","decrementCount","acquire","priority","_this","canAcquire","Promise","resolve","push","sort","a","b","release","resolveFunc","shift","setTimeout","get","Semaphore","semaphoreInstances","Error","_proto2","hasSemaphoreInstance","Boolean","getSemaphoreInstance","tidy","_key","_ref2","_priority","hasTasks","request","fn","_this2","then","_finallyRethrows","_wasThrown","_result","e","reject","requestIfAvailable","GroupSemaphore","_semaphore","_activeCounts","_groupWaiters","_this$_activeCounts$k","_this$_groupWaiters$k","activeCount","waiter"],"mappings":"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"}

package/lib/promise-semaphore.modern.js

@@ -1,2 +0,0 @@
-const e="_default",t=e=>["string","number"].includes(typeof e),s=s=>{var r;return null!=(r=t(s)?s:s.key)?r:e};class r{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}incrementCount(){this.count++}decrementCount(){this.count--}acquire(e){return this.canAcquire?(this.incrementCount(),Promise.resolve()):new Promise(t=>{this.queue.push({resolve:t,priority:e}),this.queue.sort((e,t)=>t.priority-e.priority)})}release(){const e=this.queue.shift();e?setTimeout(e.resolve,0):this.decrementCount()}}class n{constructor(e=1){if(this.semaphoreInstances=void 0,this.maxConcurrent=void 0,this.semaphoreInstances={},this.maxConcurrent=e,e<1)throw new Error("The maxConcurrent must be 1 or greater.")}hasSemaphoreInstance(t=e){return Boolean(this.semaphoreInstances[t])}getSemaphoreInstance(t=e){return this.hasSemaphoreInstance(t)||(this.semaphoreInstances[t]=new r(this.maxConcurrent)),this.semaphoreInstances[t]}tidy(t=e){this.hasSemaphoreInstance(t)&&0===this.getSemaphoreInstance(t).count&&delete this.semaphoreInstances[t]}canAcquire(t=e){const r=s(t);return!this.hasSemaphoreInstance(r)||this.getSemaphoreInstance(r).canAcquire}acquire(r=e){const n=s(r),i=null!=(o=t(a=r)?0:a.priority)?o:0;var a,o;return this.getSemaphoreInstance(n).acquire(i)}release(t=e){const r=s(t);this.getSemaphoreInstance(r).release(),this.tidy(r)}count(t=e){const r=s(t);return this.hasSemaphoreInstance(r)?this.getSemaphoreInstance(r).count:0}hasTasks(t=e){return this.count(t)>0}async request(t,s=e){try{return await this.acquire(s),await t()}finally{this.release(s)}}async requestIfAvailable(t,s=e){return this.canAcquire(s)?this.request(t,s):null}}class i{constructor(){this._semaphore=new n,this._activeCounts={},this._groupWaiters={}}async acquire(e){var t,s;const r=null!=(t=this._activeCounts[e])?t:0;this._activeCounts[e]=r+1;const n=null!=(s=this._groupWaiters[e])?s:this._semaphore.acquire();this._groupWaiters[e]=n,await n}release(e){const t=this._activeCounts[e];1===t?(this._semaphore.release(),delete this._activeCounts[e],delete this._groupWaiters[e]):this._activeCounts[e]=t-1}}export{i as GroupSemaphore,n as Semaphore};
-//# sourceMappingURL=promise-semaphore.modern.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"promise-semaphore.modern.js","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        } 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];\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];\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"],"names":["defaultKey","_isPrimitiveKey","item","includes","resolveKey","_ref","key","SemaphoreItem","constructor","maxConcurrent","queue","this","count","canAcquire","incrementCount","decrementCount","acquire","priority","Promise","resolve","push","sort","a","b","release","resolveFunc","shift","setTimeout","Semaphore","semaphoreInstances","Error","hasSemaphoreInstance","Boolean","getSemaphoreInstance","tidy","_key","_priority","_ref2","hasTasks","request","fn","requestIfAvailable","GroupSemaphore","_semaphore","_activeCounts","_groupWaiters","_this$_activeCounts$k","_this$_groupWaiters$k","activeCount","waiter"],"mappings":"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"}

package/lib/promise-semaphore.module.js

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"promise-semaphore.module.js","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        } 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];\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];\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"],"names":["defaultKey","_isPrimitiveKey","item","includes","resolveKey","_ref","key","SemaphoreItem","maxConcurrent","queue","this","count","_proto","prototype","_createClass","incrementCount","decrementCount","acquire","priority","_this","canAcquire","Promise","resolve","push","sort","a","b","release","resolveFunc","shift","setTimeout","get","Semaphore","semaphoreInstances","Error","_proto2","hasSemaphoreInstance","Boolean","getSemaphoreInstance","tidy","_key","_ref2","_priority","hasTasks","request","fn","_this2","then","_finallyRethrows","_wasThrown","_result","e","reject","requestIfAvailable","GroupSemaphore","_semaphore","_activeCounts","_groupWaiters","_this$_activeCounts$k","_this$_groupWaiters$k","activeCount","waiter"],"mappings":"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"}

package/lib/semaphore.d.ts

@@ -1,64 +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>;
-}
-export { Semaphore };