@stryke/helpers 0.10.10 → 0.10.11

package/dist/semaphore.d.mts

@@ -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.mts.map

package/dist/semaphore.d.mts.map

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

package/dist/semaphore.mjs

@@ -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
-export { Semaphore };
-//# sourceMappingURL=semaphore.mjs.map

package/dist/semaphore.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"semaphore.mjs","names":[],"sources":["../src/semaphore.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/**\n * A counting semaphore for async functions that manages available permits.\n * Semaphores are mainly used to limit the number of concurrent async tasks.\n *\n * Each `acquire` operation takes a permit or waits until one is available.\n * Each `release` operation adds a permit, potentially allowing a waiting task to proceed.\n *\n * The semaphore ensures fairness by maintaining a FIFO (First In, First Out) order for acquirers.\n *\n * @example\n * const sema = new Semaphore(2);\n *\n * async function task() \\{\n *   await sema.acquire();\n *   try \\{\n *     // This code can only be executed by two tasks at the same time\n *   \\} finally \\{\n *     sema.release();\n *   \\}\n * \\}\n *\n * task();\n * task();\n * task(); // This task will wait until one of the previous tasks releases the semaphore.\n */\nexport class Semaphore {\n  /**\n   * The maximum number of concurrent operations allowed.\n   */\n  public capacity: number;\n\n  /**\n   * The number of available permits.\n   */\n  public available: number;\n\n  private deferredTasks: Array<() => void> = [];\n\n  /**\n   * Creates an instance of Semaphore.\n   * @param capacity - The maximum number of concurrent operations allowed.\n   *\n   * @example\n   * ```ts\n   * const sema = new Semaphore(3); // Allows up to 3 concurrent operations.\n   * ```\n   */\n  constructor(capacity: number) {\n    this.capacity = capacity;\n    this.available = capacity;\n  }\n\n  /**\n   * Acquires a semaphore, blocking if necessary until one is available.\n   *\n   * @example\n   * ```ts\n   * const sema = new Semaphore(1);\n   *\n   * async function criticalSection() {\n   *   await sema.acquire();\n   *   try {\n   *     // This code section cannot be executed simultaneously\n   *   } finally {\n   *     sema.release();\n   *   }\n   * }\n   * ```\n   *\n   * @returns A promise that resolves when the semaphore is acquired.\n   */\n  async acquire(): Promise<void> {\n    if (this.available > 0) {\n      this.available--;\n      return;\n    }\n\n    return new Promise<void>(resolve => {\n      this.deferredTasks.push(resolve);\n    });\n  }\n\n  /**\n   * Releases a semaphore, allowing one more operation to proceed.\n   *\n   * @example\n   * const sema = new Semaphore(1);\n   *\n   * async function task() \\{\n   *   await sema.acquire();\n   *   try \\{\n   *     // This code can only be executed by two tasks at the same time\n   *   \\} finally \\{\n   *     sema.release(); // Allows another waiting task to proceed.\n   *   \\}\n   * \\}\n   */\n  release(): void {\n    const deferredTask = this.deferredTasks.shift();\n\n    if (deferredTask != null) {\n      deferredTask();\n      return;\n    }\n\n    if (this.available < this.capacity) {\n      this.available++;\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,IAAa,YAAb,MAAuB;;;;CAIrB,AAAO;;;;CAKP,AAAO;CAEP,AAAQ,gBAAmC,EAAE;;;;;;;;;;CAW7C,YAAY,UAAkB;AAC5B,OAAK,WAAW;AAChB,OAAK,YAAY;;;;;;;;;;;;;;;;;;;;;CAsBnB,MAAM,UAAyB;AAC7B,MAAI,KAAK,YAAY,GAAG;AACtB,QAAK;AACL;;AAGF,SAAO,IAAI,SAAc,YAAW;AAClC,QAAK,cAAc,KAAK,QAAQ;IAChC;;;;;;;;;;;;;;;;;CAkBJ,UAAgB;EACd,MAAM,eAAe,KAAK,cAAc,OAAO;AAE/C,MAAI,gBAAgB,MAAM;AACxB,iBAAc;AACd;;AAGF,MAAI,KAAK,YAAY,KAAK,SACxB,MAAK"}

package/dist/throttle.cjs

@@ -1,43 +0,0 @@
-
-//#region src/throttle.ts
-/**
-* Creates a throttled function that only invokes the provided function at most once
-* per every `throttleMs` milliseconds. Subsequent calls to the throttled function
-* within the wait time will not trigger the execution of the original function.
-*
-* @example
-* ```typescript
-* const throttledFunction = throttle(() => {
-*   console.log('Function executed');
-* }, 1000);
-*
-* // Will log 'Function executed' immediately
-* throttledFunction();
-*
-* // Will not log anything as it is within the throttle time
-* throttledFunction();
-*
-* // After 1 second
-* setTimeout(() => {
-*   throttledFunction(); // Will log 'Function executed'
-* }, 1000);
-* ```
-*
-* @param func - The function to throttle.
-* @param throttleMs - The number of milliseconds to throttle executions to.
-* @returns A new throttled function that accepts the same parameters as the original function.
-*/
-function throttle(func, throttleMs) {
-	let lastCallTime;
-	const throttledFunction = ((...args) => {
-		const now = Date.now();
-		if (lastCallTime == null || now - lastCallTime >= throttleMs) {
-			lastCallTime = now;
-			func(...args);
-		}
-	});
-	return throttledFunction;
-}
-
-//#endregion
-exports.throttle = throttle;

package/dist/throttle.d.cts

@@ -1,32 +0,0 @@
-//#region src/throttle.d.ts
-/**
- * Creates a throttled function that only invokes the provided function at most once
- * per every `throttleMs` milliseconds. Subsequent calls to the throttled function
- * within the wait time will not trigger the execution of the original function.
- *
- * @example
- * ```typescript
- * const throttledFunction = throttle(() => {
- *   console.log('Function executed');
- * }, 1000);
- *
- * // Will log 'Function executed' immediately
- * throttledFunction();
- *
- * // Will not log anything as it is within the throttle time
- * throttledFunction();
- *
- * // After 1 second
- * setTimeout(() => {
- *   throttledFunction(); // Will log 'Function executed'
- * }, 1000);
- * ```
- *
- * @param func - The function to throttle.
- * @param throttleMs - The number of milliseconds to throttle executions to.
- * @returns A new throttled function that accepts the same parameters as the original function.
- */
-declare function throttle<F extends (...args: any[]) => void>(func: F, throttleMs: number): F;
-//#endregion
-export { throttle };
-//# sourceMappingURL=throttle.d.cts.map

package/dist/throttle.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"throttle.d.cts","names":[],"sources":["../src/throttle.ts"],"sourcesContent":[],"mappings":";;AA6CA;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,mDACR,wBAEL"}

package/dist/throttle.d.mts

@@ -1,32 +0,0 @@
-//#region src/throttle.d.ts
-/**
- * Creates a throttled function that only invokes the provided function at most once
- * per every `throttleMs` milliseconds. Subsequent calls to the throttled function
- * within the wait time will not trigger the execution of the original function.
- *
- * @example
- * ```typescript
- * const throttledFunction = throttle(() => {
- *   console.log('Function executed');
- * }, 1000);
- *
- * // Will log 'Function executed' immediately
- * throttledFunction();
- *
- * // Will not log anything as it is within the throttle time
- * throttledFunction();
- *
- * // After 1 second
- * setTimeout(() => {
- *   throttledFunction(); // Will log 'Function executed'
- * }, 1000);
- * ```
- *
- * @param func - The function to throttle.
- * @param throttleMs - The number of milliseconds to throttle executions to.
- * @returns A new throttled function that accepts the same parameters as the original function.
- */
-declare function throttle<F extends (...args: any[]) => void>(func: F, throttleMs: number): F;
-//#endregion
-export { throttle };
-//# sourceMappingURL=throttle.d.mts.map

package/dist/throttle.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"throttle.d.mts","names":[],"sources":["../src/throttle.ts"],"sourcesContent":[],"mappings":";;AA6CA;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,mDACR,wBAEL"}

package/dist/throttle.mjs

@@ -1,43 +0,0 @@
-//#region src/throttle.ts
-/**
-* Creates a throttled function that only invokes the provided function at most once
-* per every `throttleMs` milliseconds. Subsequent calls to the throttled function
-* within the wait time will not trigger the execution of the original function.
-*
-* @example
-* ```typescript
-* const throttledFunction = throttle(() => {
-*   console.log('Function executed');
-* }, 1000);
-*
-* // Will log 'Function executed' immediately
-* throttledFunction();
-*
-* // Will not log anything as it is within the throttle time
-* throttledFunction();
-*
-* // After 1 second
-* setTimeout(() => {
-*   throttledFunction(); // Will log 'Function executed'
-* }, 1000);
-* ```
-*
-* @param func - The function to throttle.
-* @param throttleMs - The number of milliseconds to throttle executions to.
-* @returns A new throttled function that accepts the same parameters as the original function.
-*/
-function throttle(func, throttleMs) {
-	let lastCallTime;
-	const throttledFunction = ((...args) => {
-		const now = Date.now();
-		if (lastCallTime == null || now - lastCallTime >= throttleMs) {
-			lastCallTime = now;
-			func(...args);
-		}
-	});
-	return throttledFunction;
-}
-
-//#endregion
-export { throttle };
-//# sourceMappingURL=throttle.mjs.map

package/dist/throttle.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"throttle.mjs","names":["lastCallTime: number | null"],"sources":["../src/throttle.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/**\n * Creates a throttled function that only invokes the provided function at most once\n * per every `throttleMs` milliseconds. Subsequent calls to the throttled function\n * within the wait time will not trigger the execution of the original function.\n *\n * @example\n * ```typescript\n * const throttledFunction = throttle(() => {\n *   console.log('Function executed');\n * }, 1000);\n *\n * // Will log 'Function executed' immediately\n * throttledFunction();\n *\n * // Will not log anything as it is within the throttle time\n * throttledFunction();\n *\n * // After 1 second\n * setTimeout(() => {\n *   throttledFunction(); // Will log 'Function executed'\n * }, 1000);\n * ```\n *\n * @param func - The function to throttle.\n * @param throttleMs - The number of milliseconds to throttle executions to.\n * @returns A new throttled function that accepts the same parameters as the original function.\n */\nexport function throttle<F extends (...args: any[]) => void>(\n  func: F,\n  throttleMs: number\n): F {\n  let lastCallTime: number | null;\n\n  const throttledFunction = ((...args: Parameters<F>) => {\n    const now = Date.now();\n\n    if (lastCallTime == null || now - lastCallTime >= throttleMs) {\n      lastCallTime = now;\n      func(...args);\n    }\n  }) as F;\n\n  return throttledFunction;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,SAAgB,SACd,MACA,YACG;CACH,IAAIA;CAEJ,MAAM,sBAAsB,GAAG,SAAwB;EACrD,MAAM,MAAM,KAAK,KAAK;AAEtB,MAAI,gBAAgB,QAAQ,MAAM,gBAAgB,YAAY;AAC5D,kBAAe;AACf,QAAK,GAAG,KAAK;;;AAIjB,QAAO"}

package/dist/timeout.cjs

@@ -1,18 +0,0 @@
-const require_errors = require('./errors.cjs');
-const require_delay = require('./delay.cjs');
-
-//#region src/timeout.ts
-/**
-* Returns a promise that rejects with a `TimeoutError` after a specified delay.
-*
-* @param ms - The delay duration in milliseconds.
-* @returns A promise that rejects with a `TimeoutError` after the specified delay.
-* @throws Throws a `TimeoutError` after the specified delay.
-*/
-async function timeout(ms) {
-	await require_delay.delay(ms);
-	throw new require_errors.TimeoutError();
-}
-
-//#endregion
-exports.timeout = timeout;

package/dist/timeout.d.cts

@@ -1,12 +0,0 @@
-//#region src/timeout.d.ts
-/**
- * Returns a promise that rejects with a `TimeoutError` after a specified delay.
- *
- * @param ms - The delay duration in milliseconds.
- * @returns A promise that rejects with a `TimeoutError` after the specified delay.
- * @throws Throws a `TimeoutError` after the specified delay.
- */
-declare function timeout(ms: number): Promise<never>;
-//#endregion
-export { timeout };
-//# sourceMappingURL=timeout.d.cts.map

package/dist/timeout.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"timeout.d.cts","names":[],"sources":["../src/timeout.ts"],"sourcesContent":[],"mappings":";;AA4BA;;;;;;iBAAsB,OAAA,cAAqB"}

package/dist/timeout.d.mts

@@ -1,12 +0,0 @@
-//#region src/timeout.d.ts
-/**
- * Returns a promise that rejects with a `TimeoutError` after a specified delay.
- *
- * @param ms - The delay duration in milliseconds.
- * @returns A promise that rejects with a `TimeoutError` after the specified delay.
- * @throws Throws a `TimeoutError` after the specified delay.
- */
-declare function timeout(ms: number): Promise<never>;
-//#endregion
-export { timeout };
-//# sourceMappingURL=timeout.d.mts.map

package/dist/timeout.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"timeout.d.mts","names":[],"sources":["../src/timeout.ts"],"sourcesContent":[],"mappings":";;AA4BA;;;;;;iBAAsB,OAAA,cAAqB"}

package/dist/timeout.mjs

@@ -1,19 +0,0 @@
-import { TimeoutError } from "./errors.mjs";
-import { delay } from "./delay.mjs";
-
-//#region src/timeout.ts
-/**
-* Returns a promise that rejects with a `TimeoutError` after a specified delay.
-*
-* @param ms - The delay duration in milliseconds.
-* @returns A promise that rejects with a `TimeoutError` after the specified delay.
-* @throws Throws a `TimeoutError` after the specified delay.
-*/
-async function timeout(ms) {
-	await delay(ms);
-	throw new TimeoutError();
-}
-
-//#endregion
-export { timeout };
-//# sourceMappingURL=timeout.mjs.map

package/dist/timeout.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"timeout.mjs","names":[],"sources":["../src/timeout.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 { delay } from \"./delay\";\nimport { TimeoutError } from \"./errors\";\n\n/**\n * Returns a promise that rejects with a `TimeoutError` after a specified delay.\n *\n * @param ms - The delay duration in milliseconds.\n * @returns A promise that rejects with a `TimeoutError` after the specified delay.\n * @throws Throws a `TimeoutError` after the specified delay.\n */\nexport async function timeout(ms: number): Promise<never> {\n  await delay(ms);\n  throw new TimeoutError();\n}\n"],"mappings":";;;;;;;;;;;AA4BA,eAAsB,QAAQ,IAA4B;AACxD,OAAM,MAAM,GAAG;AACf,OAAM,IAAI,cAAc"}

package/dist/with-timeout.cjs

@@ -1,28 +0,0 @@
-const require_timeout = require('./timeout.cjs');
-
-//#region src/with-timeout.ts
-/**
-* Executes an async function and enforces a timeout.
-*
-* If the promise does not resolve within the specified time,
-* the timeout will trigger and the returned promise will be rejected.
-*
-* @example
-* ```typescript
-* try {
-*   await withTimeout(() => {}, 1000); // Timeout exception after 1 second
-* } catch (error) {
-*   console.error(error); // Will log 'TimeoutError'
-* }
-* ```
-*
-* @param run - A function that returns a promise to be executed.
-* @param ms - The timeout duration in milliseconds.
-* @returns A promise that resolves with the result of the `run` function or rejects if the timeout is reached.
-*/
-async function withTimeout(run, ms) {
-	return Promise.race([run(), require_timeout.timeout(ms)]);
-}
-
-//#endregion
-exports.withTimeout = withTimeout;

package/dist/with-timeout.d.cts

@@ -1,24 +0,0 @@
-//#region src/with-timeout.d.ts
-/**
- * Executes an async function and enforces a timeout.
- *
- * If the promise does not resolve within the specified time,
- * the timeout will trigger and the returned promise will be rejected.
- *
- * @example
- * ```typescript
- * try {
- *   await withTimeout(() => {}, 1000); // Timeout exception after 1 second
- * } catch (error) {
- *   console.error(error); // Will log 'TimeoutError'
- * }
- * ```
- *
- * @param run - A function that returns a promise to be executed.
- * @param ms - The timeout duration in milliseconds.
- * @returns A promise that resolves with the result of the `run` function or rejects if the timeout is reached.
- */
-declare function withTimeout<T>(run: () => Promise<T>, ms: number): Promise<T>;
-//#endregion
-export { withTimeout };
-//# sourceMappingURL=with-timeout.d.cts.map

package/dist/with-timeout.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"with-timeout.d.cts","names":[],"sources":["../src/with-timeout.ts"],"sourcesContent":[],"mappings":";;AAuCA;;;;;;;;;;;;;;;;;;iBAAsB,0BACT,QAAQ,iBAElB,QAAQ"}

package/dist/with-timeout.d.mts

@@ -1,24 +0,0 @@
-//#region src/with-timeout.d.ts
-/**
- * Executes an async function and enforces a timeout.
- *
- * If the promise does not resolve within the specified time,
- * the timeout will trigger and the returned promise will be rejected.
- *
- * @example
- * ```typescript
- * try {
- *   await withTimeout(() => {}, 1000); // Timeout exception after 1 second
- * } catch (error) {
- *   console.error(error); // Will log 'TimeoutError'
- * }
- * ```
- *
- * @param run - A function that returns a promise to be executed.
- * @param ms - The timeout duration in milliseconds.
- * @returns A promise that resolves with the result of the `run` function or rejects if the timeout is reached.
- */
-declare function withTimeout<T>(run: () => Promise<T>, ms: number): Promise<T>;
-//#endregion
-export { withTimeout };
-//# sourceMappingURL=with-timeout.d.mts.map

package/dist/with-timeout.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"with-timeout.d.mts","names":[],"sources":["../src/with-timeout.ts"],"sourcesContent":[],"mappings":";;AAuCA;;;;;;;;;;;;;;;;;;iBAAsB,0BACT,QAAQ,iBAElB,QAAQ"}

package/dist/with-timeout.mjs

@@ -1,29 +0,0 @@
-import { timeout } from "./timeout.mjs";
-
-//#region src/with-timeout.ts
-/**
-* Executes an async function and enforces a timeout.
-*
-* If the promise does not resolve within the specified time,
-* the timeout will trigger and the returned promise will be rejected.
-*
-* @example
-* ```typescript
-* try {
-*   await withTimeout(() => {}, 1000); // Timeout exception after 1 second
-* } catch (error) {
-*   console.error(error); // Will log 'TimeoutError'
-* }
-* ```
-*
-* @param run - A function that returns a promise to be executed.
-* @param ms - The timeout duration in milliseconds.
-* @returns A promise that resolves with the result of the `run` function or rejects if the timeout is reached.
-*/
-async function withTimeout(run, ms) {
-	return Promise.race([run(), timeout(ms)]);
-}
-
-//#endregion
-export { withTimeout };
-//# sourceMappingURL=with-timeout.mjs.map

package/dist/with-timeout.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"with-timeout.mjs","names":[],"sources":["../src/with-timeout.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 { timeout } from \"./timeout\";\n\n/**\n * Executes an async function and enforces a timeout.\n *\n * If the promise does not resolve within the specified time,\n * the timeout will trigger and the returned promise will be rejected.\n *\n * @example\n * ```typescript\n * try {\n *   await withTimeout(() => {}, 1000); // Timeout exception after 1 second\n * } catch (error) {\n *   console.error(error); // Will log 'TimeoutError'\n * }\n * ```\n *\n * @param run - A function that returns a promise to be executed.\n * @param ms - The timeout duration in milliseconds.\n * @returns A promise that resolves with the result of the `run` function or rejects if the timeout is reached.\n */\nexport async function withTimeout<T>(\n  run: () => Promise<T>,\n  ms: number\n): Promise<T> {\n  return Promise.race([run(), timeout(ms) as T]);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAuCA,eAAsB,YACpB,KACA,IACY;AACZ,QAAO,QAAQ,KAAK,CAAC,KAAK,EAAE,QAAQ,GAAG,CAAM,CAAC"}