commandkit 1.2.0-rc.13 → 1.2.0-rc.15

package/dist/utils/useful-stuff/semaphore.d.ts

@@ -9,30 +9,30 @@
  */
 interface SemaphoreStorage {
   /**
-       * Attempts to acquire a permit for a given key
-       * @param key - The unique identifier for the semaphore
-       * @param timeout - Optional timeout in milliseconds for permit acquisition
-       * @param signal - Optional AbortSignal for cancelling the acquisition
-       * @returns Promise resolving to true if permit was acquired, false if timeout or no permits available
-       */
+   * Attempts to acquire a permit for a given key
+   * @param key - The unique identifier for the semaphore
+   * @param timeout - Optional timeout in milliseconds for permit acquisition
+   * @param signal - Optional AbortSignal for cancelling the acquisition
+   * @returns Promise resolving to true if permit was acquired, false if timeout or no permits available
+   */
   acquire(key: string, timeout?: number, signal?: AbortSignal): Promise<boolean>;
   /**
-       * Releases a permit for a given key
-       * @param key - The unique identifier for the semaphore
-       * @returns Promise that resolves when the permit is released
-       */
+   * Releases a permit for a given key
+   * @param key - The unique identifier for the semaphore
+   * @returns Promise that resolves when the permit is released
+   */
   release(key: string): Promise<void>;
   /**
-       * Gets the number of available permits for a given key
-       * @param key - The unique identifier for the semaphore
-       * @returns Promise resolving to the number of available permits
-       */
+   * Gets the number of available permits for a given key
+   * @param key - The unique identifier for the semaphore
+   * @returns Promise resolving to the number of available permits
+   */
   getAvailablePermits(key: string): Promise<number>;
   /**
-       * Gets the total number of permits for a given key
-       * @param key - The unique identifier for the semaphore
-       * @returns Promise resolving to the total number of permits
-       */
+   * Gets the total number of permits for a given key
+   * @param key - The unique identifier for the semaphore
+   * @returns Promise resolving to the total number of permits
+   */
   getTotalPermits(key: string): Promise<number>;
 }
 /**
@@ -53,36 +53,36 @@ interface SemaphoreOptions {
 declare class MemorySemaphoreStorage implements SemaphoreStorage {
   private readonly semaphores;
   /**
-       * Attempts to acquire a permit for a given key
-       * @param key - The unique identifier for the semaphore
-       * @param timeout - Optional timeout in milliseconds for permit acquisition
-       * @param signal - Optional AbortSignal for cancelling the acquisition
-       * @returns Promise resolving to true if permit was acquired, false if timeout or no permits available
-       */
+   * Attempts to acquire a permit for a given key
+   * @param key - The unique identifier for the semaphore
+   * @param timeout - Optional timeout in milliseconds for permit acquisition
+   * @param signal - Optional AbortSignal for cancelling the acquisition
+   * @returns Promise resolving to true if permit was acquired, false if timeout or no permits available
+   */
   acquire(key: string, timeout?: number, signal?: AbortSignal): Promise<boolean>;
   /**
-       * Releases a permit for a given key
-       * @param key - The unique identifier for the semaphore
-       * @returns Promise that resolves when the permit is released
-       */
+   * Releases a permit for a given key
+   * @param key - The unique identifier for the semaphore
+   * @returns Promise that resolves when the permit is released
+   */
   release(key: string): Promise<void>;
   /**
-       * Gets the number of available permits for a given key
-       * @param key - The unique identifier for the semaphore
-       * @returns Promise resolving to the number of available permits
-       */
+   * Gets the number of available permits for a given key
+   * @param key - The unique identifier for the semaphore
+   * @returns Promise resolving to the number of available permits
+   */
   getAvailablePermits(key: string): Promise<number>;
   /**
-       * Gets the total number of permits for a given key
-       * @param key - The unique identifier for the semaphore
-       * @returns Promise resolving to the total number of permits
-       */
+   * Gets the total number of permits for a given key
+   * @param key - The unique identifier for the semaphore
+   * @returns Promise resolving to the total number of permits
+   */
   getTotalPermits(key: string): Promise<number>;
   /**
-       * Initializes a semaphore with the specified number of permits
-       * @param key - The unique identifier for the semaphore
-       * @param permits - The total number of permits to allocate
-       */
+   * Initializes a semaphore with the specified number of permits
+   * @param key - The unique identifier for the semaphore
+   * @param permits - The total number of permits to allocate
+   */
   initialize(key: string, permits: number): void;
   private delay;
 }
@@ -95,66 +95,66 @@ declare class Semaphore {
   private readonly defaultPermits;
   private readonly defaultTimeout;
   /**
-       * Creates a new semaphore instance
-       * @param options - Configuration options for the semaphore
-       */
+   * Creates a new semaphore instance
+   * @param options - Configuration options for the semaphore
+   */
   constructor(options?: SemaphoreOptions);
   /**
-       * Sets the storage implementation for the semaphore
-       * @param storage - The storage implementation to use
-       */
+   * Sets the storage implementation for the semaphore
+   * @param storage - The storage implementation to use
+   */
   setStorage(storage: SemaphoreStorage): void;
   /**
-       * Gets the storage implementation for the semaphore
-       * @returns The storage implementation
-       */
+   * Gets the storage implementation for the semaphore
+   * @returns The storage implementation
+   */
   getStorage(): SemaphoreStorage;
   /**
-       * Acquires a permit for the given key
-       * @param key - The unique identifier for the semaphore
-       * @param timeout - Optional timeout in milliseconds for permit acquisition
-       * @param signal - Optional AbortSignal for cancelling the acquisition
-       * @returns Promise resolving to true if permit was acquired, false if timeout
-       */
+   * Acquires a permit for the given key
+   * @param key - The unique identifier for the semaphore
+   * @param timeout - Optional timeout in milliseconds for permit acquisition
+   * @param signal - Optional AbortSignal for cancelling the acquisition
+   * @returns Promise resolving to true if permit was acquired, false if timeout
+   */
   acquire(key: string, timeout?: number, signal?: AbortSignal): Promise<boolean>;
   /**
-       * Releases a permit for the given key
-       * @param key - The unique identifier for the semaphore
-       * @returns Promise that resolves when the permit is released
-       */
+   * Releases a permit for the given key
+   * @param key - The unique identifier for the semaphore
+   * @returns Promise that resolves when the permit is released
+   */
   release(key: string): Promise<void>;
   /**
-       * Gets the number of available permits for the given key
-       * @param key - The unique identifier for the semaphore
-       * @returns Promise resolving to the number of available permits
-       */
+   * Gets the number of available permits for the given key
+   * @param key - The unique identifier for the semaphore
+   * @returns Promise resolving to the number of available permits
+   */
   getAvailablePermits(key: string): Promise<number>;
   /**
-       * Gets the total number of permits for the given key
-       * @param key - The unique identifier for the semaphore
-       * @returns Promise resolving to the total number of permits
-       */
+   * Gets the total number of permits for the given key
+   * @param key - The unique identifier for the semaphore
+   * @returns Promise resolving to the total number of permits
+   */
   getTotalPermits(key: string): Promise<number>;
   /**
-       * Gets the number of acquired permits for the given key
-       * @param key - The unique identifier for the semaphore
-       * @returns Promise resolving to the number of acquired permits
-       */
+   * Gets the number of acquired permits for the given key
+   * @param key - The unique identifier for the semaphore
+   * @returns Promise resolving to the number of acquired permits
+   */
   getAcquiredPermits(key: string): Promise<number>;
   /**
-       * Executes a function with a permit from the semaphore
-       * @param key - The unique identifier for the semaphore
-       * @param fn - The function to execute with a permit
-       * @param timeout - Optional timeout in milliseconds for permit acquisition
-       * @param signal - Optional AbortSignal for cancelling the permit acquisition
-       * @returns Promise resolving to the result of the function execution
-       * @throws Error if permit acquisition fails or function execution fails
-       */
+   * Executes a function with a permit from the semaphore
+   * @param key - The unique identifier for the semaphore
+   * @param fn - The function to execute with a permit
+   * @param timeout - Optional timeout in milliseconds for permit acquisition
+   * @param signal - Optional AbortSignal for cancelling the permit acquisition
+   * @returns Promise resolving to the result of the function execution
+   * @throws Error if permit acquisition fails or function execution fails
+   */
   withPermit<T>(key: string, fn: () => Promise<T> | T, timeout?: number, signal?: AbortSignal): Promise<T>;
   /**
-       * Gets the current configuration of the semaphore
-       * @returns Object containing the current permits and timeout values
-       */
+   * Gets the current configuration of the semaphore
+   * @returns Object containing the current permits and timeout values
+   */
   getConfig(): Omit<SemaphoreOptions, 'storage'>;
 }
 /**

package/dist/utils/useful-stuff/semaphore.js

@@ -1,3 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 //#region src/utils/useful-stuff/semaphore.ts
 /**

package/dist/utils/useful-stuff/semaphore.js.map

@@ -1 +1 @@
-{"version":3,"file":"semaphore.js","names":[],"sources":["../../../src/utils/useful-stuff/semaphore.ts"],"sourcesContent":["/**\n * Async semaphore implementation for controlling access to a limited pool of resources.\n * Allows a specified number of concurrent operations while blocking additional requests.\n */\n\n/**\n * Interface for semaphore storage implementations.\n * Provides methods to store, retrieve, and manage semaphore permit data.\n */\nexport interface SemaphoreStorage {\n  /**\n   * Attempts to acquire a permit for a given key\n   * @param key - The unique identifier for the semaphore\n   * @param timeout - Optional timeout in milliseconds for permit acquisition\n   * @param signal - Optional AbortSignal for cancelling the acquisition\n   * @returns Promise resolving to true if permit was acquired, false if timeout or no permits available\n   */\n  acquire(\n    key: string,\n    timeout?: number,\n    signal?: AbortSignal,\n  ): Promise<boolean>;\n\n  /**\n   * Releases a permit for a given key\n   * @param key - The unique identifier for the semaphore\n   * @returns Promise that resolves when the permit is released\n   */\n  release(key: string): Promise<void>;\n\n  /**\n   * Gets the number of available permits for a given key\n   * @param key - The unique identifier for the semaphore\n   * @returns Promise resolving to the number of available permits\n   */\n  getAvailablePermits(key: string): Promise<number>;\n\n  /**\n   * Gets the total number of permits for a given key\n   * @param key - The unique identifier for the semaphore\n   * @returns Promise resolving to the total number of permits\n   */\n  getTotalPermits(key: string): Promise<number>;\n}\n\n/**\n * Configuration options for semaphore\n */\nexport interface SemaphoreOptions {\n  /** Maximum number of concurrent permits allowed. Default: 1 */\n  permits?: number;\n  /** Default timeout in milliseconds for permit acquisition. Default: 30000 */\n  timeout?: number;\n  /** Storage implementation for persisting semaphore data. Default: {@link MemorySemaphoreStorage} */\n  storage?: SemaphoreStorage;\n}\n\n/**\n * In-memory storage implementation for semaphore permits.\n * Suitable for single-instance applications.\n */\nexport class MemorySemaphoreStorage implements SemaphoreStorage {\n  private readonly semaphores = new Map<\n    string,\n    { total: number; available: number }\n  >();\n\n  /**\n   * Attempts to acquire a permit for a given key\n   * @param key - The unique identifier for the semaphore\n   * @param timeout - Optional timeout in milliseconds for permit acquisition\n   * @param signal - Optional AbortSignal for cancelling the acquisition\n   * @returns Promise resolving to true if permit was acquired, false if timeout or no permits available\n   */\n  async acquire(\n    key: string,\n    timeout: number = 30000,\n    signal?: AbortSignal,\n  ): Promise<boolean> {\n    const startTime = Date.now();\n\n    while (Date.now() - startTime < timeout) {\n      // Check if aborted\n      if (signal?.aborted) {\n        throw new Error('Permit acquisition was aborted');\n      }\n\n      const semaphore = this.semaphores.get(key);\n      if (semaphore && semaphore.available > 0) {\n        semaphore.available--;\n        return true;\n      }\n      await this.delay(10);\n    }\n\n    return false;\n  }\n\n  /**\n   * Releases a permit for a given key\n   * @param key - The unique identifier for the semaphore\n   * @returns Promise that resolves when the permit is released\n   */\n  async release(key: string): Promise<void> {\n    const semaphore = this.semaphores.get(key);\n    if (semaphore && semaphore.available < semaphore.total) {\n      semaphore.available++;\n    }\n  }\n\n  /**\n   * Gets the number of available permits for a given key\n   * @param key - The unique identifier for the semaphore\n   * @returns Promise resolving to the number of available permits\n   */\n  async getAvailablePermits(key: string): Promise<number> {\n    const semaphore = this.semaphores.get(key);\n    return semaphore ? semaphore.available : 0;\n  }\n\n  /**\n   * Gets the total number of permits for a given key\n   * @param key - The unique identifier for the semaphore\n   * @returns Promise resolving to the total number of permits\n   */\n  async getTotalPermits(key: string): Promise<number> {\n    const semaphore = this.semaphores.get(key);\n    return semaphore ? semaphore.total : 0;\n  }\n\n  /**\n   * Initializes a semaphore with the specified number of permits\n   * @param key - The unique identifier for the semaphore\n   * @param permits - The total number of permits to allocate\n   */\n  initialize(key: string, permits: number): void {\n    this.semaphores.set(key, { total: permits, available: permits });\n  }\n\n  private delay(ms: number): Promise<void> {\n    return new Promise((resolve) => setTimeout(resolve, ms));\n  }\n}\n\n/**\n * Async semaphore implementation that controls access to a limited pool of resources.\n * Allows a specified number of concurrent operations while blocking additional requests.\n */\nexport class Semaphore {\n  private storage: SemaphoreStorage;\n  private readonly defaultPermits: number;\n  private readonly defaultTimeout: number;\n\n  /**\n   * Creates a new semaphore instance\n   * @param options - Configuration options for the semaphore\n   */\n  public constructor(options: SemaphoreOptions = {}) {\n    this.storage = options.storage || new MemorySemaphoreStorage();\n    this.defaultPermits = options.permits || 1;\n    this.defaultTimeout = options.timeout || 30000;\n  }\n\n  /**\n   * Sets the storage implementation for the semaphore\n   * @param storage - The storage implementation to use\n   */\n  public setStorage(storage: SemaphoreStorage) {\n    this.storage = storage;\n  }\n\n  /**\n   * Gets the storage implementation for the semaphore\n   * @returns The storage implementation\n   */\n  public getStorage(): SemaphoreStorage {\n    return this.storage;\n  }\n\n  /**\n   * Acquires a permit for the given key\n   * @param key - The unique identifier for the semaphore\n   * @param timeout - Optional timeout in milliseconds for permit acquisition\n   * @param signal - Optional AbortSignal for cancelling the acquisition\n   * @returns Promise resolving to true if permit was acquired, false if timeout\n   */\n  public async acquire(\n    key: string,\n    timeout?: number,\n    signal?: AbortSignal,\n  ): Promise<boolean> {\n    // Initialize semaphore if it doesn't exist\n    if (this.storage instanceof MemorySemaphoreStorage) {\n      const totalPermits = await this.storage.getTotalPermits(key);\n      if (totalPermits === 0) {\n        (this.storage as MemorySemaphoreStorage).initialize(\n          key,\n          this.defaultPermits,\n        );\n      }\n    }\n\n    return this.storage.acquire(key, timeout || this.defaultTimeout, signal);\n  }\n\n  /**\n   * Releases a permit for the given key\n   * @param key - The unique identifier for the semaphore\n   * @returns Promise that resolves when the permit is released\n   */\n  public async release(key: string): Promise<void> {\n    return this.storage.release(key);\n  }\n\n  /**\n   * Gets the number of available permits for the given key\n   * @param key - The unique identifier for the semaphore\n   * @returns Promise resolving to the number of available permits\n   */\n  public async getAvailablePermits(key: string): Promise<number> {\n    return this.storage.getAvailablePermits(key);\n  }\n\n  /**\n   * Gets the total number of permits for the given key\n   * @param key - The unique identifier for the semaphore\n   * @returns Promise resolving to the total number of permits\n   */\n  public async getTotalPermits(key: string): Promise<number> {\n    return this.storage.getTotalPermits(key);\n  }\n\n  /**\n   * Gets the number of acquired permits for the given key\n   * @param key - The unique identifier for the semaphore\n   * @returns Promise resolving to the number of acquired permits\n   */\n  public async getAcquiredPermits(key: string): Promise<number> {\n    const total = await this.getTotalPermits(key);\n    const available = await this.getAvailablePermits(key);\n    return total - available;\n  }\n\n  /**\n   * Executes a function with a permit from the semaphore\n   * @param key - The unique identifier for the semaphore\n   * @param fn - The function to execute with a permit\n   * @param timeout - Optional timeout in milliseconds for permit acquisition\n   * @param signal - Optional AbortSignal for cancelling the permit acquisition\n   * @returns Promise resolving to the result of the function execution\n   * @throws Error if permit acquisition fails or function execution fails\n   */\n  public async withPermit<T>(\n    key: string,\n    fn: () => Promise<T> | T,\n    timeout?: number,\n    signal?: AbortSignal,\n  ): Promise<T> {\n    const acquired = await this.acquire(key, timeout, signal);\n    if (!acquired) {\n      throw new Error(`Failed to acquire permit for key: ${key}`);\n    }\n\n    try {\n      return await fn();\n    } finally {\n      await this.release(key);\n    }\n  }\n\n  /**\n   * Gets the current configuration of the semaphore\n   * @returns Object containing the current permits and timeout values\n   */\n  public getConfig(): Omit<SemaphoreOptions, 'storage'> {\n    return {\n      permits: this.defaultPermits,\n      timeout: this.defaultTimeout,\n    };\n  }\n}\n\n/**\n * Default semaphore instance for global use\n */\nexport const defaultSemaphore = new Semaphore();\n\n/**\n * Convenience function to execute a function with a permit using the default semaphore.\n *\n * @param key - The unique identifier for the semaphore\n * @param fn - The function to execute with a permit\n * @param timeout - Optional timeout in milliseconds for permit acquisition\n * @param signal - Optional AbortSignal for cancelling the permit acquisition\n * @returns Promise resolving to the result of the function execution\n *\n * @example\n * ```typescript\n * const controller = new AbortController();\n * const result = await withPermit('database-connection', async () => {\n *   // This code runs with a permit from the semaphore\n *   return await executeDatabaseQuery();\n * }, 30000, controller.signal);\n * controller.abort(); // Cancels the permit acquisition\n * ```\n */\nexport async function withPermit<T>(\n  key: string,\n  fn: () => Promise<T> | T,\n  timeout?: number,\n  signal?: AbortSignal,\n): Promise<T> {\n  return defaultSemaphore.withPermit(key, fn, timeout, signal);\n}\n\n/**\n * Creates a new semaphore instance with the specified configuration\n * @param options - Configuration options for the semaphore\n * @returns New Semaphore instance\n *\n * @example\n * ```typescript\n * const semaphore = createSemaphore({\n *   permits: 5,\n *   timeout: 60000,\n *   storage: new RedisSemaphoreStorage()\n * });\n * ```\n */\nexport function createSemaphore(options: SemaphoreOptions): Semaphore {\n  return new Semaphore(options);\n}\n\n/**\n * Acquires a permit using the default semaphore\n * @param key - The unique identifier for the semaphore\n * @param timeout - Optional timeout in milliseconds for permit acquisition\n * @param signal - Optional AbortSignal for cancelling the acquisition\n * @returns Promise resolving to true if permit was acquired, false if timeout\n */\nexport async function acquirePermit(\n  key: string,\n  timeout?: number,\n  signal?: AbortSignal,\n): Promise<boolean> {\n  return defaultSemaphore.acquire(key, timeout, signal);\n}\n\n/**\n * Releases a permit using the default semaphore\n * @param key - The unique identifier for the semaphore\n * @returns Promise that resolves when the permit is released\n */\nexport async function releasePermit(key: string): Promise<void> {\n  return defaultSemaphore.release(key);\n}\n\n/**\n * Gets the number of available permits using the default semaphore\n * @param key - The unique identifier for the semaphore\n * @returns Promise resolving to the number of available permits\n */\nexport async function getAvailablePermits(key: string): Promise<number> {\n  return defaultSemaphore.getAvailablePermits(key);\n}\n\n/**\n * Gets the number of acquired permits using the default semaphore\n * @param key - The unique identifier for the semaphore\n * @returns Promise resolving to the number of acquired permits\n */\nexport async function getAcquiredPermits(key: string): Promise<number> {\n  return defaultSemaphore.getAcquiredPermits(key);\n}\n"],"mappings":"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"}
+{"version":3,"file":"semaphore.js","names":[],"sources":["../../../src/utils/useful-stuff/semaphore.ts"],"sourcesContent":["/**\n * Async semaphore implementation for controlling access to a limited pool of resources.\n * Allows a specified number of concurrent operations while blocking additional requests.\n */\n\n/**\n * Interface for semaphore storage implementations.\n * Provides methods to store, retrieve, and manage semaphore permit data.\n */\nexport interface SemaphoreStorage {\n  /**\n   * Attempts to acquire a permit for a given key\n   * @param key - The unique identifier for the semaphore\n   * @param timeout - Optional timeout in milliseconds for permit acquisition\n   * @param signal - Optional AbortSignal for cancelling the acquisition\n   * @returns Promise resolving to true if permit was acquired, false if timeout or no permits available\n   */\n  acquire(\n    key: string,\n    timeout?: number,\n    signal?: AbortSignal,\n  ): Promise<boolean>;\n\n  /**\n   * Releases a permit for a given key\n   * @param key - The unique identifier for the semaphore\n   * @returns Promise that resolves when the permit is released\n   */\n  release(key: string): Promise<void>;\n\n  /**\n   * Gets the number of available permits for a given key\n   * @param key - The unique identifier for the semaphore\n   * @returns Promise resolving to the number of available permits\n   */\n  getAvailablePermits(key: string): Promise<number>;\n\n  /**\n   * Gets the total number of permits for a given key\n   * @param key - The unique identifier for the semaphore\n   * @returns Promise resolving to the total number of permits\n   */\n  getTotalPermits(key: string): Promise<number>;\n}\n\n/**\n * Configuration options for semaphore\n */\nexport interface SemaphoreOptions {\n  /** Maximum number of concurrent permits allowed. Default: 1 */\n  permits?: number;\n  /** Default timeout in milliseconds for permit acquisition. Default: 30000 */\n  timeout?: number;\n  /** Storage implementation for persisting semaphore data. Default: {@link MemorySemaphoreStorage} */\n  storage?: SemaphoreStorage;\n}\n\n/**\n * In-memory storage implementation for semaphore permits.\n * Suitable for single-instance applications.\n */\nexport class MemorySemaphoreStorage implements SemaphoreStorage {\n  private readonly semaphores = new Map<\n    string,\n    { total: number; available: number }\n  >();\n\n  /**\n   * Attempts to acquire a permit for a given key\n   * @param key - The unique identifier for the semaphore\n   * @param timeout - Optional timeout in milliseconds for permit acquisition\n   * @param signal - Optional AbortSignal for cancelling the acquisition\n   * @returns Promise resolving to true if permit was acquired, false if timeout or no permits available\n   */\n  async acquire(\n    key: string,\n    timeout: number = 30000,\n    signal?: AbortSignal,\n  ): Promise<boolean> {\n    const startTime = Date.now();\n\n    while (Date.now() - startTime < timeout) {\n      // Check if aborted\n      if (signal?.aborted) {\n        throw new Error('Permit acquisition was aborted');\n      }\n\n      const semaphore = this.semaphores.get(key);\n      if (semaphore && semaphore.available > 0) {\n        semaphore.available--;\n        return true;\n      }\n      await this.delay(10);\n    }\n\n    return false;\n  }\n\n  /**\n   * Releases a permit for a given key\n   * @param key - The unique identifier for the semaphore\n   * @returns Promise that resolves when the permit is released\n   */\n  async release(key: string): Promise<void> {\n    const semaphore = this.semaphores.get(key);\n    if (semaphore && semaphore.available < semaphore.total) {\n      semaphore.available++;\n    }\n  }\n\n  /**\n   * Gets the number of available permits for a given key\n   * @param key - The unique identifier for the semaphore\n   * @returns Promise resolving to the number of available permits\n   */\n  async getAvailablePermits(key: string): Promise<number> {\n    const semaphore = this.semaphores.get(key);\n    return semaphore ? semaphore.available : 0;\n  }\n\n  /**\n   * Gets the total number of permits for a given key\n   * @param key - The unique identifier for the semaphore\n   * @returns Promise resolving to the total number of permits\n   */\n  async getTotalPermits(key: string): Promise<number> {\n    const semaphore = this.semaphores.get(key);\n    return semaphore ? semaphore.total : 0;\n  }\n\n  /**\n   * Initializes a semaphore with the specified number of permits\n   * @param key - The unique identifier for the semaphore\n   * @param permits - The total number of permits to allocate\n   */\n  initialize(key: string, permits: number): void {\n    this.semaphores.set(key, { total: permits, available: permits });\n  }\n\n  private delay(ms: number): Promise<void> {\n    return new Promise((resolve) => setTimeout(resolve, ms));\n  }\n}\n\n/**\n * Async semaphore implementation that controls access to a limited pool of resources.\n * Allows a specified number of concurrent operations while blocking additional requests.\n */\nexport class Semaphore {\n  private storage: SemaphoreStorage;\n  private readonly defaultPermits: number;\n  private readonly defaultTimeout: number;\n\n  /**\n   * Creates a new semaphore instance\n   * @param options - Configuration options for the semaphore\n   */\n  public constructor(options: SemaphoreOptions = {}) {\n    this.storage = options.storage || new MemorySemaphoreStorage();\n    this.defaultPermits = options.permits || 1;\n    this.defaultTimeout = options.timeout || 30000;\n  }\n\n  /**\n   * Sets the storage implementation for the semaphore\n   * @param storage - The storage implementation to use\n   */\n  public setStorage(storage: SemaphoreStorage) {\n    this.storage = storage;\n  }\n\n  /**\n   * Gets the storage implementation for the semaphore\n   * @returns The storage implementation\n   */\n  public getStorage(): SemaphoreStorage {\n    return this.storage;\n  }\n\n  /**\n   * Acquires a permit for the given key\n   * @param key - The unique identifier for the semaphore\n   * @param timeout - Optional timeout in milliseconds for permit acquisition\n   * @param signal - Optional AbortSignal for cancelling the acquisition\n   * @returns Promise resolving to true if permit was acquired, false if timeout\n   */\n  public async acquire(\n    key: string,\n    timeout?: number,\n    signal?: AbortSignal,\n  ): Promise<boolean> {\n    // Initialize semaphore if it doesn't exist\n    if (this.storage instanceof MemorySemaphoreStorage) {\n      const totalPermits = await this.storage.getTotalPermits(key);\n      if (totalPermits === 0) {\n        (this.storage as MemorySemaphoreStorage).initialize(\n          key,\n          this.defaultPermits,\n        );\n      }\n    }\n\n    return this.storage.acquire(key, timeout || this.defaultTimeout, signal);\n  }\n\n  /**\n   * Releases a permit for the given key\n   * @param key - The unique identifier for the semaphore\n   * @returns Promise that resolves when the permit is released\n   */\n  public async release(key: string): Promise<void> {\n    return this.storage.release(key);\n  }\n\n  /**\n   * Gets the number of available permits for the given key\n   * @param key - The unique identifier for the semaphore\n   * @returns Promise resolving to the number of available permits\n   */\n  public async getAvailablePermits(key: string): Promise<number> {\n    return this.storage.getAvailablePermits(key);\n  }\n\n  /**\n   * Gets the total number of permits for the given key\n   * @param key - The unique identifier for the semaphore\n   * @returns Promise resolving to the total number of permits\n   */\n  public async getTotalPermits(key: string): Promise<number> {\n    return this.storage.getTotalPermits(key);\n  }\n\n  /**\n   * Gets the number of acquired permits for the given key\n   * @param key - The unique identifier for the semaphore\n   * @returns Promise resolving to the number of acquired permits\n   */\n  public async getAcquiredPermits(key: string): Promise<number> {\n    const total = await this.getTotalPermits(key);\n    const available = await this.getAvailablePermits(key);\n    return total - available;\n  }\n\n  /**\n   * Executes a function with a permit from the semaphore\n   * @param key - The unique identifier for the semaphore\n   * @param fn - The function to execute with a permit\n   * @param timeout - Optional timeout in milliseconds for permit acquisition\n   * @param signal - Optional AbortSignal for cancelling the permit acquisition\n   * @returns Promise resolving to the result of the function execution\n   * @throws Error if permit acquisition fails or function execution fails\n   */\n  public async withPermit<T>(\n    key: string,\n    fn: () => Promise<T> | T,\n    timeout?: number,\n    signal?: AbortSignal,\n  ): Promise<T> {\n    const acquired = await this.acquire(key, timeout, signal);\n    if (!acquired) {\n      throw new Error(`Failed to acquire permit for key: ${key}`);\n    }\n\n    try {\n      return await fn();\n    } finally {\n      await this.release(key);\n    }\n  }\n\n  /**\n   * Gets the current configuration of the semaphore\n   * @returns Object containing the current permits and timeout values\n   */\n  public getConfig(): Omit<SemaphoreOptions, 'storage'> {\n    return {\n      permits: this.defaultPermits,\n      timeout: this.defaultTimeout,\n    };\n  }\n}\n\n/**\n * Default semaphore instance for global use\n */\nexport const defaultSemaphore = new Semaphore();\n\n/**\n * Convenience function to execute a function with a permit using the default semaphore.\n *\n * @param key - The unique identifier for the semaphore\n * @param fn - The function to execute with a permit\n * @param timeout - Optional timeout in milliseconds for permit acquisition\n * @param signal - Optional AbortSignal for cancelling the permit acquisition\n * @returns Promise resolving to the result of the function execution\n *\n * @example\n * ```typescript\n * const controller = new AbortController();\n * const result = await withPermit('database-connection', async () => {\n *   // This code runs with a permit from the semaphore\n *   return await executeDatabaseQuery();\n * }, 30000, controller.signal);\n * controller.abort(); // Cancels the permit acquisition\n * ```\n */\nexport async function withPermit<T>(\n  key: string,\n  fn: () => Promise<T> | T,\n  timeout?: number,\n  signal?: AbortSignal,\n): Promise<T> {\n  return defaultSemaphore.withPermit(key, fn, timeout, signal);\n}\n\n/**\n * Creates a new semaphore instance with the specified configuration\n * @param options - Configuration options for the semaphore\n * @returns New Semaphore instance\n *\n * @example\n * ```typescript\n * const semaphore = createSemaphore({\n *   permits: 5,\n *   timeout: 60000,\n *   storage: new RedisSemaphoreStorage()\n * });\n * ```\n */\nexport function createSemaphore(options: SemaphoreOptions): Semaphore {\n  return new Semaphore(options);\n}\n\n/**\n * Acquires a permit using the default semaphore\n * @param key - The unique identifier for the semaphore\n * @param timeout - Optional timeout in milliseconds for permit acquisition\n * @param signal - Optional AbortSignal for cancelling the acquisition\n * @returns Promise resolving to true if permit was acquired, false if timeout\n */\nexport async function acquirePermit(\n  key: string,\n  timeout?: number,\n  signal?: AbortSignal,\n): Promise<boolean> {\n  return defaultSemaphore.acquire(key, timeout, signal);\n}\n\n/**\n * Releases a permit using the default semaphore\n * @param key - The unique identifier for the semaphore\n * @returns Promise that resolves when the permit is released\n */\nexport async function releasePermit(key: string): Promise<void> {\n  return defaultSemaphore.release(key);\n}\n\n/**\n * Gets the number of available permits using the default semaphore\n * @param key - The unique identifier for the semaphore\n * @returns Promise resolving to the number of available permits\n */\nexport async function getAvailablePermits(key: string): Promise<number> {\n  return defaultSemaphore.getAvailablePermits(key);\n}\n\n/**\n * Gets the number of acquired permits using the default semaphore\n * @param key - The unique identifier for the semaphore\n * @returns Promise resolving to the number of acquired permits\n */\nexport async function getAcquiredPermits(key: string): Promise<number> {\n  return defaultSemaphore.getAcquiredPermits(key);\n}\n"],"mappings":";;;;;;;AA6DA,IAAa,yBAAb,MAAgE;CAC9D,AAAiB,6BAAa,IAAI,KAGjC;;;;;;;;CASD,MAAM,QACN,KACA,UAAkB,KAClB,QACmB;EACjB,MAAM,YAAY,KAAK,KAAK;AAE5B,SAAO,KAAK,KAAK,GAAG,YAAY,SAAS;AAEvC,uDAAI,OAAQ,QACV,OAAM,IAAI,MAAM,iCAAiC;GAGnD,MAAM,YAAY,KAAK,WAAW,IAAI,IAAI;AAC1C,OAAI,aAAa,UAAU,YAAY,GAAG;AACxC,cAAU;AACV,WAAO;;AAET,SAAM,KAAK,MAAM,GAAG;;AAGtB,SAAO;;;;;;;CAQT,MAAM,QAAQ,KAA4B;EACxC,MAAM,YAAY,KAAK,WAAW,IAAI,IAAI;AAC1C,MAAI,aAAa,UAAU,YAAY,UAAU,MAC/C,WAAU;;;;;;;CASd,MAAM,oBAAoB,KAA8B;EACtD,MAAM,YAAY,KAAK,WAAW,IAAI,IAAI;AAC1C,SAAO,YAAY,UAAU,YAAY;;;;;;;CAQ3C,MAAM,gBAAgB,KAA8B;EAClD,MAAM,YAAY,KAAK,WAAW,IAAI,IAAI;AAC1C,SAAO,YAAY,UAAU,QAAQ;;;;;;;CAQvC,WAAW,KAAa,SAAuB;AAC7C,OAAK,WAAW,IAAI,KAAK;GAAE,OAAO;GAAS,WAAW;GAAS,CAAC;;CAGlE,AAAQ,MAAM,IAA2B;AACvC,SAAO,IAAI,SAAS,YAAY,WAAW,SAAS,GAAG,CAAC;;;;;;;AAQ5D,IAAa,YAAb,MAAuB;CACrB,AAAQ;CACR,AAAiB;CACjB,AAAiB;;;;;CAMjB,AAAO,YAAY,UAA4B,EAAE,EAAE;AACjD,OAAK,UAAU,QAAQ,WAAW,IAAI,wBAAwB;AAC9D,OAAK,iBAAiB,QAAQ,WAAW;AACzC,OAAK,iBAAiB,QAAQ,WAAW;;;;;;CAO3C,AAAO,WAAW,SAA2B;AAC3C,OAAK,UAAU;;;;;;CAOjB,AAAO,aAA+B;AACpC,SAAO,KAAK;;;;;;;;;CAUd,MAAa,QACb,KACA,SACA,QACmB;AAEjB,MAAI,KAAK,mBAAmB,wBAE1B;OADqB,MAAM,KAAK,QAAQ,gBAAgB,IAAI,KACvC,EACnB,CAAC,KAAK,QAAmC,WACvC,KACA,KAAK,eACN;;AAIL,SAAO,KAAK,QAAQ,QAAQ,KAAK,WAAW,KAAK,gBAAgB,OAAO;;;;;;;CAQ1E,MAAa,QAAQ,KAA4B;AAC/C,SAAO,KAAK,QAAQ,QAAQ,IAAI;;;;;;;CAQlC,MAAa,oBAAoB,KAA8B;AAC7D,SAAO,KAAK,QAAQ,oBAAoB,IAAI;;;;;;;CAQ9C,MAAa,gBAAgB,KAA8B;AACzD,SAAO,KAAK,QAAQ,gBAAgB,IAAI;;;;;;;CAQ1C,MAAa,mBAAmB,KAA8B;AAG5D,SAFc,MAAM,KAAK,gBAAgB,IAAI,GAC3B,MAAM,KAAK,oBAAoB,IAAI;;;;;;;;;;;CAavD,MAAa,WACb,KACA,IACA,SACA,QACa;AAEX,MAAI,CADa,MAAM,KAAK,QAAQ,KAAK,SAAS,OAAO,CAEvD,OAAM,IAAI,MAAM,qCAAqC,MAAM;AAG7D,MAAI;AACF,UAAO,MAAM,IAAI;YACT;AACR,SAAM,KAAK,QAAQ,IAAI;;;;;;;CAQ3B,AAAO,YAA+C;AACpD,SAAO;GACL,SAAS,KAAK;GACd,SAAS,KAAK;GACf;;;;;;AAOL,MAAa,mBAAmB,IAAI,WAAW;;;;;;;;;;;;;;;;;;;;AAqB/C,eAAsB,WACtB,KACA,IACA,SACA,QACa;AACX,QAAO,iBAAiB,WAAW,KAAK,IAAI,SAAS,OAAO;;;;;;;;;;;;;;;;AAiB9D,SAAgB,gBAAgB,SAAsC;AACpE,QAAO,IAAI,UAAU,QAAQ;;;;;;;;;AAU/B,eAAsB,cACtB,KACA,SACA,QACmB;AACjB,QAAO,iBAAiB,QAAQ,KAAK,SAAS,OAAO;;;;;;;AAQvD,eAAsB,cAAc,KAA4B;AAC9D,QAAO,iBAAiB,QAAQ,IAAI;;;;;;;AAQtC,eAAsB,oBAAoB,KAA8B;AACtE,QAAO,iBAAiB,oBAAoB,IAAI;;;;;;;AAQlD,eAAsB,mBAAmB,KAA8B;AACrE,QAAO,iBAAiB,mBAAmB,IAAI"}

package/dist/utils/utilities.d.ts

@@ -93,13 +93,13 @@ declare function noBuildOnly<T extends (...args: any[]) => any>(fn: T): T;
  */
 interface SimpleProxy<T extends object> {
   /**
-       * The proxied object that mirrors the target.
-       */
+   * The proxied object that mirrors the target.
+   */
   proxy: T;
   /**
-       * Sets a new target object for the proxy.
-       * @param newTarget The new target object to set.
-       */
+   * Sets a new target object for the proxy.
+   * @param newTarget The new target object to set.
+   */
   setTarget(newTarget: T): void;
 }
 /**

package/dist/utils/utilities.js

@@ -1,27 +1,5 @@
-require('../colors-Csc0X4QJ.js');
-require('../ActionRow-CSN_UKmM.js');
-const require_commandkit = require('../commandkit-SIjTLD2R.js');
-require('../container-DCPljKVH.js');
-require('../file-Ca1kpEtE.js');
-require('../media-gallery-u3gjX7yD.js');
-require('../section-BC8LF-B2.js');
-require('../separator-BUTiW7uz.js');
-require('../text-display-DANahMN3.js');
-require('../label-B6vXvwLM.js');
-require('../poll-CFe8yvoJ.js');
-require('../display-WDb9wMCv.js');
-require('../constants-CxkFFZ7p.js');
-require('../types-package-CsTNfvv2.js');
-require('../constants-Cw8VjCVz.js');
-require('../EventWorkerContext-Dfhgv329.js');
-require('../signals-B8z1wJ6W.js');
-require('../helpers-Btx1FSZx.js');
-require('../MessageCommandParser-Bs9fimmd.js');
-require('../CommandsRouter-C_HLsrGX.js');
-require('../EventsRouter-DZYIha6m.js');
-require('../router-BvamdzoF.js');
-require('../common-DSRs_mfw.js');
-require('../store-D8r_hryO.js');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_commandkit = require('../commandkit--k6yDJEr.js');
 
 exports.JsonSerialize = require_commandkit.JsonSerialize;
 exports.buildOnly = require_commandkit.buildOnly;

package/dist/utils/warning.js

@@ -1,5 +1,39 @@
-const require_warning = require('../warning-CszH8HeS.js');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-exports.emitWarning = require_warning.emitWarning;
-exports.warnDeprecated = require_warning.warnDeprecated;
-exports.warnUnstable = require_warning.warnUnstable;
+//#region src/utils/warning.ts
+const WARNED_KEYS = /* @__PURE__ */ new Set();
+const DEPRECATED_KEYS = /* @__PURE__ */ new Set();
+/**
+* Emit a warning message to the console as a CommandKitWarning.
+* @param message - The warning message to emit.
+* @param code - The warning code (default is 'CommandKitWarning').
+*/
+function emitWarning(message, code = "CommandKitWarning") {
+	process.emitWarning(message, { code });
+}
+/**
+* Emit a warning for unstable features in CommandKit.
+* @param name - The name of the unstable feature.
+* @example warnUnstable('MyUnstableFeature');
+*/
+function warnUnstable(name) {
+	if (WARNED_KEYS.has(name)) return;
+	WARNED_KEYS.add(name);
+	emitWarning(`${name} is unstable and may change in future versions.`, "CommandKitUnstableWarning");
+}
+function warnDeprecated({ what, message, where }) {
+	const name = `${what}:${where}`;
+	if (DEPRECATED_KEYS.has(name)) return;
+	DEPRECATED_KEYS.add(name);
+	emitWarning([
+		`${what} is deprecated`,
+		where ? `in ${where}` : "",
+		message || "and may be removed in future versions."
+	].filter(Boolean).join(" "), "CommandKitDeprecatedWarning");
+}
+
+//#endregion
+exports.emitWarning = emitWarning;
+exports.warnDeprecated = warnDeprecated;
+exports.warnUnstable = warnUnstable;
+//# sourceMappingURL=warning.js.map

package/dist/utils/warning.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"warning.js","names":[],"sources":["../../src/utils/warning.ts"],"sourcesContent":["const WARNED_KEYS = new Set<string>();\nconst DEPRECATED_KEYS = new Set<string>();\n\n/**\n * Emit a warning message to the console as a CommandKitWarning.\n * @param message - The warning message to emit.\n * @param code - The warning code (default is 'CommandKitWarning').\n */\nexport function emitWarning(message: string, code = 'CommandKitWarning') {\n  process.emitWarning(message, { code });\n}\n\n/**\n * Emit a warning for unstable features in CommandKit.\n * @param name - The name of the unstable feature.\n * @example warnUnstable('MyUnstableFeature');\n */\nexport function warnUnstable(name: string) {\n  if (WARNED_KEYS.has(name)) return;\n\n  WARNED_KEYS.add(name);\n\n  emitWarning(\n    `${name} is unstable and may change in future versions.`,\n    'CommandKitUnstableWarning',\n  );\n}\nexport function warnDeprecated({\n  what,\n  message,\n  where,\n}: {\n  what: string;\n  where?: string;\n  message?: string;\n}) {\n  const name = `${what}:${where}`;\n\n  if (DEPRECATED_KEYS.has(name)) return;\n\n  DEPRECATED_KEYS.add(name);\n\n  emitWarning(\n    [\n      `${what} is deprecated`,\n      where ? `in ${where}` : '',\n      message || 'and may be removed in future versions.',\n    ]\n      .filter(Boolean)\n      .join(' '),\n    'CommandKitDeprecatedWarning',\n  );\n}\n"],"mappings":";;;AAAA,MAAM,8BAAc,IAAI,KAAa;AACrC,MAAM,kCAAkB,IAAI,KAAa;;;;;;AAOzC,SAAgB,YAAY,SAAiB,OAAO,qBAAqB;AACvE,SAAQ,YAAY,SAAS,EAAE,MAAM,CAAC;;;;;;;AAQxC,SAAgB,aAAa,MAAc;AACzC,KAAI,YAAY,IAAI,KAAK,CAAE;AAE3B,aAAY,IAAI,KAAK;AAErB,aACE,GAAG,KAAK,kDACR,4BACD;;AAEH,SAAgB,eAAe,EAC7B,MACA,SACA,SAKC;CACD,MAAM,OAAO,GAAG,KAAK,GAAG;AAExB,KAAI,gBAAgB,IAAI,KAAK,CAAE;AAE/B,iBAAgB,IAAI,KAAK;AAEzB,aACE;EACA,GAAG,KAAE;EACL,QAAQ,MAAM,UAAU;EACxB,WAAW;EAAyC,CAEpD,OAAG,QAAO,CACV,KAAG,IAAM,EACT,8BACD"}

package/dist/version.js

@@ -1,3 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 //#region src/version.ts
 /**
@@ -6,7 +7,7 @@
 /**
 * The current version of CommandKit.
 */
-const version = "1.2.0-rc.13";
+const version = "1.2.0-rc.15";
 
 //#endregion
 exports.version = version;

package/dist/version.js.map

@@ -1 +1 @@
-{"version":3,"file":"version.js","names":[],"sources":["../src/version.ts"],"sourcesContent":["/**\n * @private\n */\nfunction $version(): string {\n  'use macro';\n  return require('../package.json').version;\n}\n\n/**\n * The current version of CommandKit.\n */\nexport const version: string = $version();\n"],"mappings":";;;;;;;;AAWA,MAAa,UAA4B"}
+{"version":3,"file":"version.js","names":[],"sources":["../src/version.ts"],"sourcesContent":["/**\n * @private\n */\nfunction $version(): string {\n  'use macro';\n  return require('../package.json').version;\n}\n\n/**\n * The current version of CommandKit.\n */\nexport const version: string = $version();\n"],"mappings":";;;;;;;;;AAWA,MAAa,UAA4B"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "commandkit",
   "description": "Beginner friendly command & event handler for Discord.js",
-  "version": "1.2.0-rc.13",
+  "version": "1.2.0-rc.15",
   "license": "GPL-3.0-only",
   "type": "commonjs",
   "main": "./dist/index.js",
@@ -168,26 +168,23 @@
   "dependencies": {
     "@rollup/plugin-json": "^6.1.0",
     "chokidar": "^4.0.3",
-    "commander": "^13.0.0",
-    "directive-to-hof": "^0.0.2",
-    "dotenv": "^16.4.7",
+    "commander": "^14.0.3",
+    "directive-to-hof": "^0.0.3",
     "ms": "^2.1.3",
-    "ora": "^8.0.1",
+    "ora": "^9.3.0",
     "picocolors": "^1.1.1",
-    "rfdc": "^1.3.1",
-    "rimraf": "^6.0.0",
-    "tsdown": "^0.20.0-beta.3",
+    "rimraf": "^6.1.3",
+    "tsdown": "^0.21.0-beta.2",
     "use-macro": "^1.1.0"
   },
   "devDependencies": {
-    "@types/ms": "^2.0.0",
-    "@types/node": "^22.10.2",
-    "@types/yargs": "^17.0.32",
-    "discord.js": "^14.24.0",
-    "tsx": "^4.19.2",
+    "@types/ms": "^2.1.0",
+    "@types/node": "^25.3.2",
+    "discord.js": "^14.25.1",
+    "tsx": "^4.21.0",
     "typescript": "^5.9.3",
-    "vitest": "^3.0.5",
-    "tsconfig": "0.0.0-rc.13"
+    "vitest": "^4.0.18",
+    "tsconfig": "0.0.0-rc.15"
   },
   "engines": {
     "node": ">=24"

package/dist/ActionRow-CSN_UKmM.js

@@ -1,25 +0,0 @@
-const require_chunk = require('./chunk-kSYXY2_d.js');
-let discord_js = require("discord.js");
-
-//#region src/components/interactive/action-row/ActionRow.ts
-/**
-* The action row component.
-* @param props The action row properties.
-* @returns The commandkit element.
-* @example <ActionRow><Button label="Click me" style={ButtonStyle.Primary} customId="click_me" /></ActionRow>
-*/
-function ActionRow(props) {
-	const row = new discord_js.ActionRowBuilder();
-	if (Array.isArray(props.children)) row.setComponents(...props.children);
-	else if (props.children) row.setComponents(props.children);
-	return row;
-}
-
-//#endregion
-Object.defineProperty(exports, 'ActionRow', {
-  enumerable: true,
-  get: function () {
-    return ActionRow;
-  }
-});
-//# sourceMappingURL=ActionRow-CSN_UKmM.js.map

package/dist/CommandKitEventsChannel-CnT5ymYe.js

@@ -1,88 +0,0 @@
-const require_chunk = require('./chunk-kSYXY2_d.js');
-let node_events = require("node:events");
-node_events = require_chunk.__toESM(node_events);
-
-//#region src/events/CommandKitEventsChannel.ts
-/**
-* Represents a channel for emitting and listening to events in CommandKit.
-* This class provides methods to manage event listeners and emit events
-* within a specific namespace.
-*/
-var CommandKitEventsChannel = class {
-	emitter = new node_events.default();
-	/**
-	* Creates a new instance of CommandKitEventsChannel.
-	* @param commandkit The CommandKit instance that this channel belongs to.
-	*/
-	constructor(commandkit) {
-		this.commandkit = commandkit;
-	}
-	/**
-	* Creates a namespaced event channel. This allows you to manage events
-	* within a specific namespace, preventing conflicts with other event channels.
-	* This is useful for organizing events related to different parts of your application.
-	* @param namespace The namespace for the event channel.
-	* @returns An object containing methods for managing events within the namespace.
-	* @example commandkit.events.to('customNamespace').emit('eventName', data);
-	*/
-	to(namespace) {
-		return {
-			on: this.on.bind(this, namespace),
-			off: this.off.bind(this, namespace),
-			once: this.once.bind(this, namespace),
-			emit: this.emit.bind(this, namespace),
-			removeAllListeners: this.removeAllListeners.bind(this, namespace)
-		};
-	}
-	/**
-	* Register an event listener for a specific event within the namespace.
-	* @param namespace The namespace for the event channel.
-	* @param event The name of the event to listen for.
-	* @param listener The function to call when the event is emitted.
-	*/
-	on(namespace, event, listener) {
-		this.emitter.on(`${namespace}:${event}`, listener);
-	}
-	/**
-	* Unregister an event listener for a specific event within the namespace.
-	* @param namespace The namespace for the event channel.
-	* @param event The name of the event to stop listening for.
-	* @param listener The function that was registered as the listener.
-	*/
-	off(namespace, event, listener) {
-		this.emitter.off(`${namespace}:${event}`, listener);
-	}
-	/**
-	* Register an event listener that will be called only once for a specific event
-	* within the namespace.
-	* @param namespace The namespace for the event channel.
-	* @param event The name of the event to listen for.
-	* @param listener The function to call when the event is emitted.
-	*/
-	once(namespace, event, listener) {
-		this.emitter.once(`${namespace}:${event}`, listener);
-	}
-	/**
-	* Emit an event within the specified namespace, calling all registered listeners.
-	* @param namespace The namespace for the event channel.
-	* @param event The name of the event to emit.
-	* @param args The arguments to pass to the listeners.
-	* @returns A boolean indicating whether any listeners were called.
-	*/
-	emit(namespace, event, ...args) {
-		return this.emitter.emit(`${namespace}:${event}`, ...args);
-	}
-	removeAllListeners(namespace, event) {
-		if (event) this.emitter.removeAllListeners(`${namespace}:${event}`);
-		else this.emitter.removeAllListeners(namespace);
-	}
-};
-
-//#endregion
-Object.defineProperty(exports, 'CommandKitEventsChannel', {
-  enumerable: true,
-  get: function () {
-    return CommandKitEventsChannel;
-  }
-});
-//# sourceMappingURL=CommandKitEventsChannel-CnT5ymYe.js.map

package/dist/CommandKitEventsChannel-CnT5ymYe.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"CommandKitEventsChannel-CnT5ymYe.js","names":[],"sources":["../src/events/CommandKitEventsChannel.ts"],"sourcesContent":["import EventEmitter from 'node:events';\nimport type { CommandKit } from '../commandkit';\nimport type { AsyncFunction, GenericFunction } from '../context/async-context';\n\n/**\n * The function type for event listeners.\n */\nexport type ListenerFunction = GenericFunction | AsyncFunction;\n\n/**\n * Represents a channel for emitting and listening to events in CommandKit.\n * This class provides methods to manage event listeners and emit events\n * within a specific namespace.\n */\nexport class CommandKitEventsChannel {\n  private emitter = new EventEmitter();\n\n  /**\n   * Creates a new instance of CommandKitEventsChannel.\n   * @param commandkit The CommandKit instance that this channel belongs to.\n   */\n  public constructor(public readonly commandkit: CommandKit) {}\n\n  /**\n   * Creates a namespaced event channel. This allows you to manage events\n   * within a specific namespace, preventing conflicts with other event channels.\n   * This is useful for organizing events related to different parts of your application.\n   * @param namespace The namespace for the event channel.\n   * @returns An object containing methods for managing events within the namespace.\n   * @example commandkit.events.to('customNamespace').emit('eventName', data);\n   */\n  public to(namespace: string) {\n    return {\n      on: this.on.bind(this, namespace),\n      off: this.off.bind(this, namespace),\n      once: this.once.bind(this, namespace),\n      emit: this.emit.bind(this, namespace),\n      removeAllListeners: this.removeAllListeners.bind(this, namespace),\n    };\n  }\n\n  /**\n   * Register an event listener for a specific event within the namespace.\n   * @param namespace The namespace for the event channel.\n   * @param event The name of the event to listen for.\n   * @param listener The function to call when the event is emitted.\n   */\n  public on(namespace: string, event: string, listener: ListenerFunction) {\n    this.emitter.on(`${namespace}:${event}`, listener);\n  }\n\n  /**\n   * Unregister an event listener for a specific event within the namespace.\n   * @param namespace The namespace for the event channel.\n   * @param event The name of the event to stop listening for.\n   * @param listener The function that was registered as the listener.\n   */\n  public off(namespace: string, event: string, listener: ListenerFunction) {\n    this.emitter.off(`${namespace}:${event}`, listener);\n  }\n\n  /**\n   * Register an event listener that will be called only once for a specific event\n   * within the namespace.\n   * @param namespace The namespace for the event channel.\n   * @param event The name of the event to listen for.\n   * @param listener The function to call when the event is emitted.\n   */\n  public once(namespace: string, event: string, listener: ListenerFunction) {\n    this.emitter.once(`${namespace}:${event}`, listener);\n  }\n\n  /**\n   * Emit an event within the specified namespace, calling all registered listeners.\n   * @param namespace The namespace for the event channel.\n   * @param event The name of the event to emit.\n   * @param args The arguments to pass to the listeners.\n   * @returns A boolean indicating whether any listeners were called.\n   */\n  public emit(namespace: string, event: string, ...args: any[]) {\n    return this.emitter.emit(`${namespace}:${event}`, ...args);\n  }\n\n  /**\n   * Remove all listeners for a specific event or all events within the namespace.\n   * @param namespace The namespace for the event channel.\n   * @param event The name of the event to remove listeners for. If not provided, all listeners for all events in the namespace will be removed.\n   */\n  public removeAllListeners(namespace: string): void;\n  public removeAllListeners(namespace: string, event: string): void;\n  public removeAllListeners(namespace: string, event?: string): void {\n    if (event) {\n      this.emitter.removeAllListeners(`${namespace}:${event}`);\n    } else {\n      this.emitter.removeAllListeners(namespace);\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;AAcA,IAAa,0BAAb,MAAqC;CACnC,AAAQ,UAAU,IAAI,qBAAc;;;;;CAMpC,AAAO,YAAY,AAAgB,YAAwB;EAAxB;;;;;;;;;;CAUnC,AAAO,GAAG,WAAmB;AAC3B,SAAO;GACL,IAAI,KAAK,GAAG,KAAK,MAAM,UAAU;GACjC,KAAK,KAAK,IAAI,KAAK,MAAM,UAAU;GACnC,MAAM,KAAK,KAAK,KAAK,MAAM,UAAU;GACrC,MAAM,KAAK,KAAK,KAAK,MAAM,UAAU;GACrC,oBAAoB,KAAK,mBAAmB,KAAK,MAAM,UAAU;GAClE;;;;;;;;CASH,AAAO,GAAG,WAAmB,OAAe,UAA4B;AACtE,OAAK,QAAQ,GAAG,GAAG,UAAU,GAAG,SAAS,SAAS;;;;;;;;CASpD,AAAO,IAAI,WAAmB,OAAe,UAA4B;AACvE,OAAK,QAAQ,IAAI,GAAG,UAAU,GAAG,SAAS,SAAS;;;;;;;;;CAUrD,AAAO,KAAK,WAAmB,OAAe,UAA4B;AACxE,OAAK,QAAQ,KAAK,GAAG,UAAU,GAAG,SAAS,SAAS;;;;;;;;;CAUtD,AAAO,KAAK,WAAmB,OAAe,GAAG,MAAa;AAC5D,SAAO,KAAK,QAAQ,KAAK,GAAG,UAAU,GAAG,SAAS,GAAG,KAAK;;CAU5D,AAAO,mBAAmB,WAAmB,OAAsB;AACjE,MAAI,MACF,MAAK,QAAQ,mBAAmB,GAAG,UAAU,GAAG,QAAQ;MAExD,MAAK,QAAQ,mBAAmB,UAAU"}