@stryke/helpers 0.10.9 → 0.10.11

package/dist/mutex.d.mts

@@ -1,72 +0,0 @@
-//#region src/mutex.d.ts
-/**
- * A Mutex (mutual exclusion lock) for async functions.
- * It allows only one async task to access a critical section at a time.
- *
- * @example
- * ```typescript
- * const mutex = new Mutex();
- *
- * async function criticalSection() {
- *   await mutex.acquire();
- *   try {
- *     // This code section cannot be executed simultaneously
- *   } finally {
- *     mutex.release();
- *   }
- * }
- *
- * criticalSection();
- * criticalSection(); // This call will wait until the first call releases the mutex.
- * ```
- */
-declare class Mutex {
-  private semaphore;
-  /**
-   * Checks if the mutex is currently locked.
-   * @returns True if the mutex is locked, false otherwise.
-   *
-   * @example
-   * const mutex = new Mutex();
-   * console.log(mutex.isLocked); // false
-   * await mutex.acquire();
-   * console.log(mutex.isLocked); // true
-   * mutex.release();
-   * console.log(mutex.isLocked); // false
-   */
-  get isLocked(): boolean;
-  /**
-   * Acquires the mutex, blocking if necessary until it is available.
-   * @returns A promise that resolves when the mutex is acquired.
-   *
-   * @example
-   * ```typescript
-   * const mutex = new Mutex();
-   * await mutex.acquire();
-   * try {
-   *   // This code section cannot be executed simultaneously
-   * } finally {
-   *   mutex.release();
-   * }
-   * ```
-   */
-  acquire(): Promise<void>;
-  /**
-   * Releases the mutex, allowing another waiting task to proceed.
-   *
-   * @example
-   * ```typescript
-   * const mutex = new Mutex();
-   * await mutex.acquire();
-   * try {
-   *   // This code section cannot be executed simultaneously
-   * } finally {
-   *   mutex.release(); // Allows another waiting task to proceed.
-   * }
-   * ```
-   */
-  release(): void;
-}
-//#endregion
-export { Mutex };
-//# sourceMappingURL=mutex.d.mts.map

package/dist/mutex.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mutex.d.mts","names":[],"sources":["../src/mutex.ts"],"sourcesContent":[],"mappings":";;AAyCA;;;;;;;;;;;;;;;;;;;;cAAa,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAkCa"}

package/dist/mutex.mjs

@@ -1,81 +0,0 @@
-import { Semaphore } from "./semaphore.mjs";
-
-//#region src/mutex.ts
-/**
-* A Mutex (mutual exclusion lock) for async functions.
-* It allows only one async task to access a critical section at a time.
-*
-* @example
-* ```typescript
-* const mutex = new Mutex();
-*
-* async function criticalSection() {
-*   await mutex.acquire();
-*   try {
-*     // This code section cannot be executed simultaneously
-*   } finally {
-*     mutex.release();
-*   }
-* }
-*
-* criticalSection();
-* criticalSection(); // This call will wait until the first call releases the mutex.
-* ```
-*/
-var Mutex = class {
-	semaphore = new Semaphore(1);
-	/**
-	* Checks if the mutex is currently locked.
-	* @returns True if the mutex is locked, false otherwise.
-	*
-	* @example
-	* const mutex = new Mutex();
-	* console.log(mutex.isLocked); // false
-	* await mutex.acquire();
-	* console.log(mutex.isLocked); // true
-	* mutex.release();
-	* console.log(mutex.isLocked); // false
-	*/
-	get isLocked() {
-		return this.semaphore.available === 0;
-	}
-	/**
-	* Acquires the mutex, blocking if necessary until it is available.
-	* @returns A promise that resolves when the mutex is acquired.
-	*
-	* @example
-	* ```typescript
-	* const mutex = new Mutex();
-	* await mutex.acquire();
-	* try {
-	*   // This code section cannot be executed simultaneously
-	* } finally {
-	*   mutex.release();
-	* }
-	* ```
-	*/
-	async acquire() {
-		return this.semaphore.acquire();
-	}
-	/**
-	* Releases the mutex, allowing another waiting task to proceed.
-	*
-	* @example
-	* ```typescript
-	* const mutex = new Mutex();
-	* await mutex.acquire();
-	* try {
-	*   // This code section cannot be executed simultaneously
-	* } finally {
-	*   mutex.release(); // Allows another waiting task to proceed.
-	* }
-	* ```
-	*/
-	release() {
-		this.semaphore.release();
-	}
-};
-
-//#endregion
-export { Mutex };
-//# sourceMappingURL=mutex.mjs.map

package/dist/mutex.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"mutex.mjs","names":[],"sources":["../src/mutex.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport { Semaphore } from \"./semaphore\";\n\n/**\n * A Mutex (mutual exclusion lock) for async functions.\n * It allows only one async task to access a critical section at a time.\n *\n * @example\n * ```typescript\n * const mutex = new Mutex();\n *\n * async function criticalSection() {\n *   await mutex.acquire();\n *   try {\n *     // This code section cannot be executed simultaneously\n *   } finally {\n *     mutex.release();\n *   }\n * }\n *\n * criticalSection();\n * criticalSection(); // This call will wait until the first call releases the mutex.\n * ```\n */\nexport class Mutex {\n  private semaphore = new Semaphore(1);\n\n  /**\n   * Checks if the mutex is currently locked.\n   * @returns True if the mutex is locked, false otherwise.\n   *\n   * @example\n   * const mutex = new Mutex();\n   * console.log(mutex.isLocked); // false\n   * await mutex.acquire();\n   * console.log(mutex.isLocked); // true\n   * mutex.release();\n   * console.log(mutex.isLocked); // false\n   */\n  public get isLocked(): boolean {\n    return this.semaphore.available === 0;\n  }\n\n  /**\n   * Acquires the mutex, blocking if necessary until it is available.\n   * @returns A promise that resolves when the mutex is acquired.\n   *\n   * @example\n   * ```typescript\n   * const mutex = new Mutex();\n   * await mutex.acquire();\n   * try {\n   *   // This code section cannot be executed simultaneously\n   * } finally {\n   *   mutex.release();\n   * }\n   * ```\n   */\n  public async acquire(): Promise<void> {\n    return this.semaphore.acquire();\n  }\n\n  /**\n   * Releases the mutex, allowing another waiting task to proceed.\n   *\n   * @example\n   * ```typescript\n   * const mutex = new Mutex();\n   * await mutex.acquire();\n   * try {\n   *   // This code section cannot be executed simultaneously\n   * } finally {\n   *   mutex.release(); // Allows another waiting task to proceed.\n   * }\n   * ```\n   */\n  public release(): void {\n    this.semaphore.release();\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAyCA,IAAa,QAAb,MAAmB;CACjB,AAAQ,YAAY,IAAI,UAAU,EAAE;;;;;;;;;;;;;CAcpC,IAAW,WAAoB;AAC7B,SAAO,KAAK,UAAU,cAAc;;;;;;;;;;;;;;;;;CAkBtC,MAAa,UAAyB;AACpC,SAAO,KAAK,UAAU,SAAS;;;;;;;;;;;;;;;;CAiBjC,AAAO,UAAgB;AACrB,OAAK,UAAU,SAAS"}

package/dist/once.cjs

@@ -1,27 +0,0 @@
-
-//#region src/once.ts
-/** silence "error TS2322" but practically this is safer and more convenient than resorting to `any` in a random place */
-function safeFunctionCast(fn) {
-	return fn;
-}
-/**
-* Executes a function only once.
-*
-* @param fn - The function to be executed only once.
-* @returns A function that, when called, will execute the original function only once.
-*/
-function once(fn) {
-	let result;
-	let called = false;
-	return safeFunctionCast(function(...args) {
-		if (!called) {
-			result = fn.apply(this, args);
-			called = true;
-		}
-		return result;
-	});
-}
-
-//#endregion
-exports.once = once;
-exports.safeFunctionCast = safeFunctionCast;

package/dist/once.d.cts

@@ -1,13 +0,0 @@
-//#region src/once.d.ts
-/** silence "error TS2322" but practically this is safer and more convenient than resorting to `any` in a random place */
-declare function safeFunctionCast<TFunc extends (...args: any[]) => any>(fn: (...args: Parameters<TFunc>) => ReturnType<TFunc>): TFunc;
-/**
- * Executes a function only once.
- *
- * @param fn - The function to be executed only once.
- * @returns A function that, when called, will execute the original function only once.
- */
-declare function once<TFunc extends (...args: any[]) => any>(fn: TFunc): TFunc;
-//#endregion
-export { once, safeFunctionCast };
-//# sourceMappingURL=once.d.cts.map

package/dist/once.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"once.d.cts","names":[],"sources":["../src/once.ts"],"sourcesContent":[],"mappings":";;AAmBgB,iBAAA,gBAAgB,CAAA,cAAA,CAAA,GAAA,IAAA,EAAA,GAAA,EAAA,EAAA,GAAA,GAAA,CAAA,CAAA,EAAA,EAAA,CAAA,GAAA,IAAA,EAChB,UADgB,CACL,KADK,CAAA,EAAA,GACM,UADN,CACiB,KADjB,CAAA,CAAA,EAE7B,KAF6B;;;;;;;AAehB,iBAAA,IAAgD,CAAA,cAAa,CAAA,GAAA,IAAA,EAAA,GAAA,EAAA,EAAA,GAAA,GAAA,CAAA,CAAA,EAAA,EAAb,KAAa,CAAA,EAAL,KAAK"}

package/dist/once.d.mts

@@ -1,13 +0,0 @@
-//#region src/once.d.ts
-/** silence "error TS2322" but practically this is safer and more convenient than resorting to `any` in a random place */
-declare function safeFunctionCast<TFunc extends (...args: any[]) => any>(fn: (...args: Parameters<TFunc>) => ReturnType<TFunc>): TFunc;
-/**
- * Executes a function only once.
- *
- * @param fn - The function to be executed only once.
- * @returns A function that, when called, will execute the original function only once.
- */
-declare function once<TFunc extends (...args: any[]) => any>(fn: TFunc): TFunc;
-//#endregion
-export { once, safeFunctionCast };
-//# sourceMappingURL=once.d.mts.map

package/dist/once.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"once.d.mts","names":[],"sources":["../src/once.ts"],"sourcesContent":[],"mappings":";;AAmBgB,iBAAA,gBAAgB,CAAA,cAAA,CAAA,GAAA,IAAA,EAAA,GAAA,EAAA,EAAA,GAAA,GAAA,CAAA,CAAA,EAAA,EAAA,CAAA,GAAA,IAAA,EAChB,UADgB,CACL,KADK,CAAA,EAAA,GACM,UADN,CACiB,KADjB,CAAA,CAAA,EAE7B,KAF6B;;;;;;;AAehB,iBAAA,IAAgD,CAAA,cAAa,CAAA,GAAA,IAAA,EAAA,GAAA,EAAA,EAAA,GAAA,GAAA,CAAA,CAAA,EAAA,EAAb,KAAa,CAAA,EAAL,KAAK"}

package/dist/once.mjs

@@ -1,26 +0,0 @@
-//#region src/once.ts
-/** silence "error TS2322" but practically this is safer and more convenient than resorting to `any` in a random place */
-function safeFunctionCast(fn) {
-	return fn;
-}
-/**
-* Executes a function only once.
-*
-* @param fn - The function to be executed only once.
-* @returns A function that, when called, will execute the original function only once.
-*/
-function once(fn) {
-	let result;
-	let called = false;
-	return safeFunctionCast(function(...args) {
-		if (!called) {
-			result = fn.apply(this, args);
-			called = true;
-		}
-		return result;
-	});
-}
-
-//#endregion
-export { once, safeFunctionCast };
-//# sourceMappingURL=once.mjs.map

package/dist/once.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"once.mjs","names":["result: ReturnType<TFunc>"],"sources":["../src/once.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\n/** silence \"error TS2322\" but practically this is safer and more convenient than resorting to `any` in a random place */\nexport function safeFunctionCast<TFunc extends (...args: any[]) => any>(\n  fn: (...args: Parameters<TFunc>) => ReturnType<TFunc>\n): TFunc {\n  // @ts-expect-error\n  //   error TS2322: Type '(...args: Parameters<F>) => ReturnType<F>' is not assignable to type 'F'.\n  //   '(...args: Parameters<F>) => ReturnType<F>' is assignable to the constraint of type 'F', but 'F' could be instantiated with a different subtype of constraint '(...args: any[]) => any'.\n  return fn;\n}\n\n/**\n * Executes a function only once.\n *\n * @param fn - The function to be executed only once.\n * @returns A function that, when called, will execute the original function only once.\n */\nexport function once<TFunc extends (...args: any[]) => any>(fn: TFunc): TFunc {\n  let result: ReturnType<TFunc>;\n  let called = false;\n\n  // eslint-disable-next-line func-names\n  return safeFunctionCast<TFunc>(function (this: unknown, ...args) {\n    if (!called) {\n      result = fn.apply(this, args);\n      called = true;\n    }\n    return result;\n  });\n}\n"],"mappings":";;AAmBA,SAAgB,iBACd,IACO;AAIP,QAAO;;;;;;;;AAST,SAAgB,KAA4C,IAAkB;CAC5E,IAAIA;CACJ,IAAI,SAAS;AAGb,QAAO,iBAAwB,SAAyB,GAAG,MAAM;AAC/D,MAAI,CAAC,QAAQ;AACX,YAAS,GAAG,MAAM,MAAM,KAAK;AAC7B,YAAS;;AAEX,SAAO;GACP"}

package/dist/parallel.cjs

@@ -1,39 +0,0 @@
-
-//#region src/parallel.ts
-/**
-* Executes a callback function on a set of inputs in parallel, with a specified concurrency limit and optional interval between task executions.
-*
-* @param inputs - A set of inputs to process.
-* @param cb - A callback function that takes an input and returns a value or a promise. This function will be executed for each input in the set.
-* @param options - An object containing options for the parallel execution
-* @returns A promise that resolves to an object containing an array of errors that occurred during the execution of the tasks. If no errors occurred, the array will be empty.
-*/
-async function runParallel(inputs, cb, options) {
-	const errors = [];
-	const tasks = /* @__PURE__ */ new Set();
-	function queueNext() {
-		const route = inputs.values().next().value;
-		if (!route) return;
-		inputs.delete(route);
-		const task = (options.interval ? new Promise((resolve) => {
-			setTimeout(resolve, options.interval);
-		}) : Promise.resolve()).then(() => cb(route)).catch((error) => {
-			console.error(error);
-			errors.push(error);
-		});
-		tasks.add(task);
-		return task.then(async () => {
-			tasks.delete(task);
-			if (inputs.size > 0) return refillQueue();
-		});
-	}
-	async function refillQueue() {
-		const workers = Math.min(options.concurrency - tasks.size, inputs.size);
-		return Promise.all(Array.from({ length: workers }, async () => queueNext()));
-	}
-	await refillQueue();
-	return { errors };
-}
-
-//#endregion
-exports.runParallel = runParallel;

package/dist/parallel.d.cts

@@ -1,25 +0,0 @@
-//#region src/parallel.d.ts
-interface RunParallelOptions {
-  /**
-   * The maximum number of tasks to run concurrently. This option is required and must be a positive integer.
-   */
-  concurrency: number;
-  /**
-   * An optional interval (in milliseconds) to wait between the execution of each task. If specified, the function will wait for the specified interval before starting the next task. If not specified, tasks will be executed immediately one after another without any delay.
-   */
-  interval?: number;
-}
-/**
- * Executes a callback function on a set of inputs in parallel, with a specified concurrency limit and optional interval between task executions.
- *
- * @param inputs - A set of inputs to process.
- * @param cb - A callback function that takes an input and returns a value or a promise. This function will be executed for each input in the set.
- * @param options - An object containing options for the parallel execution
- * @returns A promise that resolves to an object containing an array of errors that occurred during the execution of the tasks. If no errors occurred, the array will be empty.
- */
-declare function runParallel<T>(inputs: Set<T>, cb: (input: T) => unknown | Promise<unknown>, options: RunParallelOptions): Promise<{
-  errors: unknown[];
-}>;
-//#endregion
-export { RunParallelOptions, runParallel };
-//# sourceMappingURL=parallel.d.cts.map

package/dist/parallel.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parallel.d.cts","names":[],"sources":["../src/parallel.ts"],"sourcesContent":[],"mappings":";UAkBiB,kBAAA;EAAA;AAmBjB;;EACU,WAAA,EAAA,MAAA;EACI;;;EAEX,QAAA,CAAA,EAAA,MAAA;;;;;;;;;;iBAJmB,uBACZ,IAAI,gBACA,gBAAgB,2BACnB,qBACR"}

package/dist/parallel.d.mts

@@ -1,25 +0,0 @@
-//#region src/parallel.d.ts
-interface RunParallelOptions {
-  /**
-   * The maximum number of tasks to run concurrently. This option is required and must be a positive integer.
-   */
-  concurrency: number;
-  /**
-   * An optional interval (in milliseconds) to wait between the execution of each task. If specified, the function will wait for the specified interval before starting the next task. If not specified, tasks will be executed immediately one after another without any delay.
-   */
-  interval?: number;
-}
-/**
- * Executes a callback function on a set of inputs in parallel, with a specified concurrency limit and optional interval between task executions.
- *
- * @param inputs - A set of inputs to process.
- * @param cb - A callback function that takes an input and returns a value or a promise. This function will be executed for each input in the set.
- * @param options - An object containing options for the parallel execution
- * @returns A promise that resolves to an object containing an array of errors that occurred during the execution of the tasks. If no errors occurred, the array will be empty.
- */
-declare function runParallel<T>(inputs: Set<T>, cb: (input: T) => unknown | Promise<unknown>, options: RunParallelOptions): Promise<{
-  errors: unknown[];
-}>;
-//#endregion
-export { RunParallelOptions, runParallel };
-//# sourceMappingURL=parallel.d.mts.map

package/dist/parallel.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parallel.d.mts","names":[],"sources":["../src/parallel.ts"],"sourcesContent":[],"mappings":";UAkBiB,kBAAA;EAAA;AAmBjB;;EACU,WAAA,EAAA,MAAA;EACI;;;EAEX,QAAA,CAAA,EAAA,MAAA;;;;;;;;;;iBAJmB,uBACZ,IAAI,gBACA,gBAAgB,2BACnB,qBACR"}

package/dist/parallel.mjs

@@ -1,39 +0,0 @@
-//#region src/parallel.ts
-/**
-* Executes a callback function on a set of inputs in parallel, with a specified concurrency limit and optional interval between task executions.
-*
-* @param inputs - A set of inputs to process.
-* @param cb - A callback function that takes an input and returns a value or a promise. This function will be executed for each input in the set.
-* @param options - An object containing options for the parallel execution
-* @returns A promise that resolves to an object containing an array of errors that occurred during the execution of the tasks. If no errors occurred, the array will be empty.
-*/
-async function runParallel(inputs, cb, options) {
-	const errors = [];
-	const tasks = /* @__PURE__ */ new Set();
-	function queueNext() {
-		const route = inputs.values().next().value;
-		if (!route) return;
-		inputs.delete(route);
-		const task = (options.interval ? new Promise((resolve) => {
-			setTimeout(resolve, options.interval);
-		}) : Promise.resolve()).then(() => cb(route)).catch((error) => {
-			console.error(error);
-			errors.push(error);
-		});
-		tasks.add(task);
-		return task.then(async () => {
-			tasks.delete(task);
-			if (inputs.size > 0) return refillQueue();
-		});
-	}
-	async function refillQueue() {
-		const workers = Math.min(options.concurrency - tasks.size, inputs.size);
-		return Promise.all(Array.from({ length: workers }, async () => queueNext()));
-	}
-	await refillQueue();
-	return { errors };
-}
-
-//#endregion
-export { runParallel };
-//# sourceMappingURL=parallel.mjs.map

package/dist/parallel.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"parallel.mjs","names":["errors: unknown[]"],"sources":["../src/parallel.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nexport interface RunParallelOptions {\n  /**\n   * The maximum number of tasks to run concurrently. This option is required and must be a positive integer.\n   */\n  concurrency: number;\n  /**\n   * An optional interval (in milliseconds) to wait between the execution of each task. If specified, the function will wait for the specified interval before starting the next task. If not specified, tasks will be executed immediately one after another without any delay.\n   */\n  interval?: number;\n}\n\n/**\n * Executes a callback function on a set of inputs in parallel, with a specified concurrency limit and optional interval between task executions.\n *\n * @param inputs - A set of inputs to process.\n * @param cb - A callback function that takes an input and returns a value or a promise. This function will be executed for each input in the set.\n * @param options - An object containing options for the parallel execution\n * @returns A promise that resolves to an object containing an array of errors that occurred during the execution of the tasks. If no errors occurred, the array will be empty.\n */\nexport async function runParallel<T>(\n  inputs: Set<T>,\n  cb: (input: T) => unknown | Promise<unknown>,\n  options: RunParallelOptions\n): Promise<{ errors: unknown[] }> {\n  const errors: unknown[] = [];\n  const tasks = new Set<Promise<unknown>>();\n\n  function queueNext(): undefined | Promise<unknown> {\n    const route = inputs.values().next().value;\n    if (!route) {\n      return;\n    }\n\n    inputs.delete(route);\n    const task = (\n      options.interval\n        ? new Promise(resolve => {\n            setTimeout(resolve, options.interval);\n          })\n        : Promise.resolve()\n    )\n      .then(() => cb(route))\n      .catch(error => {\n        // eslint-disable-next-line no-console\n        console.error(error);\n        errors.push(error);\n      });\n\n    tasks.add(task);\n    return task.then(async () => {\n      tasks.delete(task);\n      if (inputs.size > 0) {\n        return refillQueue();\n      }\n\n      return void 0;\n    });\n  }\n\n  async function refillQueue(): Promise<unknown> {\n    const workers = Math.min(options.concurrency - tasks.size, inputs.size);\n\n    return Promise.all(\n      Array.from({ length: workers }, async () => queueNext())\n    );\n  }\n\n  await refillQueue();\n  return { errors };\n}\n"],"mappings":";;;;;;;;;AAqCA,eAAsB,YACpB,QACA,IACA,SACgC;CAChC,MAAMA,SAAoB,EAAE;CAC5B,MAAM,wBAAQ,IAAI,KAAuB;CAEzC,SAAS,YAA0C;EACjD,MAAM,QAAQ,OAAO,QAAQ,CAAC,MAAM,CAAC;AACrC,MAAI,CAAC,MACH;AAGF,SAAO,OAAO,MAAM;EACpB,MAAM,QACJ,QAAQ,WACJ,IAAI,SAAQ,YAAW;AACrB,cAAW,SAAS,QAAQ,SAAS;IACrC,GACF,QAAQ,SAAS,EAEpB,WAAW,GAAG,MAAM,CAAC,CACrB,OAAM,UAAS;AAEd,WAAQ,MAAM,MAAM;AACpB,UAAO,KAAK,MAAM;IAClB;AAEJ,QAAM,IAAI,KAAK;AACf,SAAO,KAAK,KAAK,YAAY;AAC3B,SAAM,OAAO,KAAK;AAClB,OAAI,OAAO,OAAO,EAChB,QAAO,aAAa;IAItB;;CAGJ,eAAe,cAAgC;EAC7C,MAAM,UAAU,KAAK,IAAI,QAAQ,cAAc,MAAM,MAAM,OAAO,KAAK;AAEvE,SAAO,QAAQ,IACb,MAAM,KAAK,EAAE,QAAQ,SAAS,EAAE,YAAY,WAAW,CAAC,CACzD;;AAGH,OAAM,aAAa;AACnB,QAAO,EAAE,QAAQ"}

package/dist/semaphore.cjs

@@ -1,105 +0,0 @@
-
-//#region src/semaphore.ts
-/**
-* A counting semaphore for async functions that manages available permits.
-* Semaphores are mainly used to limit the number of concurrent async tasks.
-*
-* Each `acquire` operation takes a permit or waits until one is available.
-* Each `release` operation adds a permit, potentially allowing a waiting task to proceed.
-*
-* The semaphore ensures fairness by maintaining a FIFO (First In, First Out) order for acquirers.
-*
-* @example
-* const sema = new Semaphore(2);
-*
-* async function task() \{
-*   await sema.acquire();
-*   try \{
-*     // This code can only be executed by two tasks at the same time
-*   \} finally \{
-*     sema.release();
-*   \}
-* \}
-*
-* task();
-* task();
-* task(); // This task will wait until one of the previous tasks releases the semaphore.
-*/
-var Semaphore = class {
-	/**
-	* The maximum number of concurrent operations allowed.
-	*/
-	capacity;
-	/**
-	* The number of available permits.
-	*/
-	available;
-	deferredTasks = [];
-	/**
-	* Creates an instance of Semaphore.
-	* @param capacity - The maximum number of concurrent operations allowed.
-	*
-	* @example
-	* ```ts
-	* const sema = new Semaphore(3); // Allows up to 3 concurrent operations.
-	* ```
-	*/
-	constructor(capacity) {
-		this.capacity = capacity;
-		this.available = capacity;
-	}
-	/**
-	* Acquires a semaphore, blocking if necessary until one is available.
-	*
-	* @example
-	* ```ts
-	* const sema = new Semaphore(1);
-	*
-	* async function criticalSection() {
-	*   await sema.acquire();
-	*   try {
-	*     // This code section cannot be executed simultaneously
-	*   } finally {
-	*     sema.release();
-	*   }
-	* }
-	* ```
-	*
-	* @returns A promise that resolves when the semaphore is acquired.
-	*/
-	async acquire() {
-		if (this.available > 0) {
-			this.available--;
-			return;
-		}
-		return new Promise((resolve) => {
-			this.deferredTasks.push(resolve);
-		});
-	}
-	/**
-	* Releases a semaphore, allowing one more operation to proceed.
-	*
-	* @example
-	* const sema = new Semaphore(1);
-	*
-	* async function task() \{
-	*   await sema.acquire();
-	*   try \{
-	*     // This code can only be executed by two tasks at the same time
-	*   \} finally \{
-	*     sema.release(); // Allows another waiting task to proceed.
-	*   \}
-	* \}
-	*/
-	release() {
-		const deferredTask = this.deferredTasks.shift();
-		if (deferredTask != null) {
-			deferredTask();
-			return;
-		}
-		if (this.available < this.capacity) this.available++;
-	}
-};
-
-//#endregion
-exports.Semaphore = Semaphore;

package/dist/semaphore.d.cts

@@ -1,86 +0,0 @@
-//#region src/semaphore.d.ts
-/**
- * A counting semaphore for async functions that manages available permits.
- * Semaphores are mainly used to limit the number of concurrent async tasks.
- *
- * Each `acquire` operation takes a permit or waits until one is available.
- * Each `release` operation adds a permit, potentially allowing a waiting task to proceed.
- *
- * The semaphore ensures fairness by maintaining a FIFO (First In, First Out) order for acquirers.
- *
- * @example
- * const sema = new Semaphore(2);
- *
- * async function task() \{
- *   await sema.acquire();
- *   try \{
- *     // This code can only be executed by two tasks at the same time
- *   \} finally \{
- *     sema.release();
- *   \}
- * \}
- *
- * task();
- * task();
- * task(); // This task will wait until one of the previous tasks releases the semaphore.
- */
-declare class Semaphore {
-  /**
-   * The maximum number of concurrent operations allowed.
-   */
-  capacity: number;
-  /**
-   * The number of available permits.
-   */
-  available: number;
-  private deferredTasks;
-  /**
-   * Creates an instance of Semaphore.
-   * @param capacity - The maximum number of concurrent operations allowed.
-   *
-   * @example
-   * ```ts
-   * const sema = new Semaphore(3); // Allows up to 3 concurrent operations.
-   * ```
-   */
-  constructor(capacity: number);
-  /**
-   * Acquires a semaphore, blocking if necessary until one is available.
-   *
-   * @example
-   * ```ts
-   * const sema = new Semaphore(1);
-   *
-   * async function criticalSection() {
-   *   await sema.acquire();
-   *   try {
-   *     // This code section cannot be executed simultaneously
-   *   } finally {
-   *     sema.release();
-   *   }
-   * }
-   * ```
-   *
-   * @returns A promise that resolves when the semaphore is acquired.
-   */
-  acquire(): Promise<void>;
-  /**
-   * Releases a semaphore, allowing one more operation to proceed.
-   *
-   * @example
-   * const sema = new Semaphore(1);
-   *
-   * async function task() \{
-   *   await sema.acquire();
-   *   try \{
-   *     // This code can only be executed by two tasks at the same time
-   *   \} finally \{
-   *     sema.release(); // Allows another waiting task to proceed.
-   *   \}
-   * \}
-   */
-  release(): void;
-}
-//#endregion
-export { Semaphore };
-//# sourceMappingURL=semaphore.d.cts.map

package/dist/semaphore.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"semaphore.d.cts","names":[],"sources":["../src/semaphore.ts"],"sourcesContent":[],"mappings":";;AA2CA;;;;;;;;;;;;;;;;;;;;;;;;cAAa,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA8CM"}