commandkit 1.2.0-dev.20251125125452 → 1.2.0-dev.20260115004503

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

@@ -13,23 +13,23 @@ declare const DEFAULT_MAX_REQUESTS = 10;
  */
 interface RateLimitStorage {
   /**
-   * Retrieves the current request count for a given key
-   * @param key - The unique identifier for the rate limit entry
-   * @returns Promise resolving to the current request count
-   */
+       * Retrieves the current request count for a given key
+       * @param key - The unique identifier for the rate limit entry
+       * @returns Promise resolving to the current request count
+       */
   get(key: string): Promise<number>;
   /**
-   * Sets the request count for a given key
-   * @param key - The unique identifier for the rate limit entry
-   * @param value - The request count to store
-   * @returns Promise that resolves when the value is stored
-   */
+       * Sets the request count for a given key
+       * @param key - The unique identifier for the rate limit entry
+       * @param value - The request count to store
+       * @returns Promise that resolves when the value is stored
+       */
   set(key: string, value: number): Promise<void>;
   /**
-   * Deletes the rate limit entry for a given key
-   * @param key - The unique identifier for the rate limit entry
-   * @returns Promise that resolves when the entry is deleted
-   */
+       * Deletes the rate limit entry for a given key
+       * @param key - The unique identifier for the rate limit entry
+       * @returns Promise that resolves when the entry is deleted
+       */
   delete(key: string): Promise<void>;
 }
 /**
@@ -50,23 +50,23 @@ interface RateLimitOptions {
 declare class MemoryRateLimitStorage implements RateLimitStorage {
   private readonly store;
   /**
-   * Retrieves the current request count for a given key
-   * @param key - The unique identifier for the rate limit entry
-   * @returns Promise resolving to the current request count or 0 if not found
-   */
+       * Retrieves the current request count for a given key
+       * @param key - The unique identifier for the rate limit entry
+       * @returns Promise resolving to the current request count or 0 if not found
+       */
   get(key: string): Promise<number>;
   /**
-   * Sets the request count for a given key
-   * @param key - The unique identifier for the rate limit entry
-   * @param value - The request count to store
-   * @returns Promise that resolves immediately
-   */
+       * Sets the request count for a given key
+       * @param key - The unique identifier for the rate limit entry
+       * @param value - The request count to store
+       * @returns Promise that resolves immediately
+       */
   set(key: string, value: number): Promise<void>;
   /**
-   * Deletes the rate limit entry for a given key
-   * @param key - The unique identifier for the rate limit entry
-   * @returns Promise that resolves immediately
-   */
+       * Deletes the rate limit entry for a given key
+       * @param key - The unique identifier for the rate limit entry
+       * @returns Promise that resolves immediately
+       */
   delete(key: string): Promise<void>;
 }
 /**
@@ -81,50 +81,50 @@ declare class RateLimiter {
   private readonly lastReset;
   private readonly resetInterval;
   /**
-   * Creates a new rate limiter instance
-   * @param maxRequests - Maximum number of requests allowed per interval (default: 10)
-   * @param interval - Time interval in milliseconds for the rate limit window (default: 60000)
-   * @param storage - Optional storage implementation (default: MemoryRateLimitStorage)
-   */
+       * Creates a new rate limiter instance
+       * @param maxRequests - Maximum number of requests allowed per interval (default: 10)
+       * @param interval - Time interval in milliseconds for the rate limit window (default: 60000)
+       * @param storage - Optional storage implementation (default: MemoryRateLimitStorage)
+       */
   constructor(maxRequests?: number, interval?: number, storage?: RateLimitStorage);
   /**
-   * Sets the storage implementation for the rate limiter
-   * @param storage - The storage implementation to use
-   */
+       * Sets the storage implementation for the rate limiter
+       * @param storage - The storage implementation to use
+       */
   setStorage(storage: RateLimitStorage): void;
   /**
-   * Gets the storage implementation for the rate limiter
-   * @returns The storage implementation
-   */
+       * Gets the storage implementation for the rate limiter
+       * @returns The storage implementation
+       */
   getStorage(): RateLimitStorage;
   /**
-   * Checks if a request is allowed for the given key and increments the counter if allowed
-   * @param key - The unique identifier for the rate limit entry
-   * @returns Promise resolving to true if the request is allowed, false if rate limited
-   */
+       * Checks if a request is allowed for the given key and increments the counter if allowed
+       * @param key - The unique identifier for the rate limit entry
+       * @returns Promise resolving to true if the request is allowed, false if rate limited
+       */
   limit(key: string): Promise<boolean>;
   /**
-   * Gets the remaining requests allowed for a given key
-   * @param key - The unique identifier for the rate limit entry
-   * @returns Promise resolving to the number of remaining requests
-   */
+       * Gets the remaining requests allowed for a given key
+       * @param key - The unique identifier for the rate limit entry
+       * @returns Promise resolving to the number of remaining requests
+       */
   getRemaining(key: string): Promise<number>;
   /**
-   * Gets the time until the rate limit resets for a given key
-   * @param key - The unique identifier for the rate limit entry
-   * @returns Promise resolving to the time in milliseconds until reset, or 0 if no limit is active
-   */
+       * Gets the time until the rate limit resets for a given key
+       * @param key - The unique identifier for the rate limit entry
+       * @returns Promise resolving to the time in milliseconds until reset, or 0 if no limit is active
+       */
   getResetTime(key: string): Promise<number>;
   /**
-   * Resets the rate limit for a given key
-   * @param key - The unique identifier for the rate limit entry
-   * @returns Promise that resolves when the reset is complete
-   */
+       * Resets the rate limit for a given key
+       * @param key - The unique identifier for the rate limit entry
+       * @returns Promise that resolves when the reset is complete
+       */
   reset(key: string): Promise<void>;
   /**
-   * Gets the current configuration of the rate limiter
-   * @returns Object containing the current maxRequests and interval values
-   */
+       * Gets the current configuration of the rate limiter
+       * @returns Object containing the current maxRequests and interval values
+       */
   getConfig(): Omit<RateLimitOptions, 'storage'>;
 }
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"ratelimiter.js","names":[],"sources":["../../../src/utils/useful-stuff/ratelimiter.ts"],"sourcesContent":["/**\n * Default timeout interval for rate limiting in milliseconds\n */\nexport const DEFAULT_TIMEOUT = 60000;\n\n/**\n * Default maximum number of requests allowed per interval\n */\nexport const DEFAULT_MAX_REQUESTS = 10;\n\n/**\n * Interface for rate limit storage implementations.\n * Provides methods to store, retrieve, and delete rate limit data.\n */\nexport interface RateLimitStorage {\n  /**\n   * Retrieves the current request count for a given key\n   * @param key - The unique identifier for the rate limit entry\n   * @returns Promise resolving to the current request count\n   */\n  get(key: string): Promise<number>;\n\n  /**\n   * Sets the request count for a given key\n   * @param key - The unique identifier for the rate limit entry\n   * @param value - The request count to store\n   * @returns Promise that resolves when the value is stored\n   */\n  set(key: string, value: number): Promise<void>;\n\n  /**\n   * Deletes the rate limit entry for a given key\n   * @param key - The unique identifier for the rate limit entry\n   * @returns Promise that resolves when the entry is deleted\n   */\n  delete(key: string): Promise<void>;\n}\n\n/**\n * Configuration options for rate limiting\n */\nexport interface RateLimitOptions {\n  /** Maximum number of requests allowed per interval. Default: 10 */\n  maxRequests?: number;\n  /** Time interval in milliseconds for the rate limit window. Default: 60000 */\n  interval?: number;\n  /** Storage implementation for persisting rate limit data. Default: {@link MemoryRateLimitStorage} */\n  storage?: RateLimitStorage;\n}\n\n/**\n * In-memory storage implementation for rate limiting.\n * Suitable for single-instance applications.\n */\nexport class MemoryRateLimitStorage implements RateLimitStorage {\n  private readonly store = new Map<string, number>();\n\n  /**\n   * Retrieves the current request count for a given key\n   * @param key - The unique identifier for the rate limit entry\n   * @returns Promise resolving to the current request count or 0 if not found\n   */\n  async get(key: string): Promise<number> {\n    return this.store.get(key) || 0;\n  }\n\n  /**\n   * Sets the request count for a given key\n   * @param key - The unique identifier for the rate limit entry\n   * @param value - The request count to store\n   * @returns Promise that resolves immediately\n   */\n  async set(key: string, value: number): Promise<void> {\n    this.store.set(key, value);\n  }\n\n  /**\n   * Deletes the rate limit entry for a given key\n   * @param key - The unique identifier for the rate limit entry\n   * @returns Promise that resolves immediately\n   */\n  async delete(key: string): Promise<void> {\n    this.store.delete(key);\n  }\n}\n\n/**\n * Rate limiter implementation that enforces request limits per key.\n * Supports configurable request limits and time intervals.\n */\nexport class RateLimiter {\n  private readonly limits: Map<string, number> = new Map();\n  private readonly lastReset: Map<string, number> = new Map();\n  private readonly resetInterval: number;\n\n  /**\n   * Creates a new rate limiter instance\n   * @param maxRequests - Maximum number of requests allowed per interval (default: 10)\n   * @param interval - Time interval in milliseconds for the rate limit window (default: 60000)\n   * @param storage - Optional storage implementation (default: MemoryRateLimitStorage)\n   */\n  public constructor(\n    private readonly maxRequests: number = DEFAULT_MAX_REQUESTS,\n    private readonly interval: number = DEFAULT_TIMEOUT,\n    private storage: RateLimitStorage = new MemoryRateLimitStorage(),\n  ) {\n    this.resetInterval = interval;\n  }\n\n  /**\n   * Sets the storage implementation for the rate limiter\n   * @param storage - The storage implementation to use\n   */\n  public setStorage(storage: RateLimitStorage) {\n    this.storage = storage;\n  }\n\n  /**\n   * Gets the storage implementation for the rate limiter\n   * @returns The storage implementation\n   */\n  public getStorage(): RateLimitStorage {\n    return this.storage;\n  }\n\n  /**\n   * Checks if a request is allowed for the given key and increments the counter if allowed\n   * @param key - The unique identifier for the rate limit entry\n   * @returns Promise resolving to true if the request is allowed, false if rate limited\n   */\n  public async limit(key: string): Promise<boolean> {\n    const now = Date.now();\n    const lastReset = this.lastReset.get(key) || 0;\n    const timeSinceReset = now - lastReset;\n\n    // Reset counter if interval has passed\n    if (timeSinceReset > this.resetInterval) {\n      await this.storage.delete(key);\n      this.lastReset.set(key, now);\n      this.limits.set(key, 0);\n    }\n\n    // Get current count from storage\n    const currentCount = await this.storage.get(key);\n\n    // Check if limit exceeded\n    if (currentCount >= this.maxRequests) {\n      return false;\n    }\n\n    // Increment counter\n    const newCount = currentCount + 1;\n    await this.storage.set(key, newCount);\n    this.limits.set(key, newCount);\n\n    return true;\n  }\n\n  /**\n   * Gets the remaining requests allowed for a given key\n   * @param key - The unique identifier for the rate limit entry\n   * @returns Promise resolving to the number of remaining requests\n   */\n  public async getRemaining(key: string): Promise<number> {\n    const currentCount = await this.storage.get(key);\n    return Math.max(0, this.maxRequests - currentCount);\n  }\n\n  /**\n   * Gets the time until the rate limit resets for a given key\n   * @param key - The unique identifier for the rate limit entry\n   * @returns Promise resolving to the time in milliseconds until reset, or 0 if no limit is active\n   */\n  public async getResetTime(key: string): Promise<number> {\n    const lastReset = this.lastReset.get(key) || 0;\n    const now = Date.now();\n    const timeSinceReset = now - lastReset;\n\n    if (timeSinceReset >= this.resetInterval) {\n      return 0;\n    }\n\n    return this.resetInterval - timeSinceReset;\n  }\n\n  /**\n   * Resets the rate limit for a given key\n   * @param key - The unique identifier for the rate limit entry\n   * @returns Promise that resolves when the reset is complete\n   */\n  public async reset(key: string): Promise<void> {\n    await this.storage.delete(key);\n    this.limits.delete(key);\n    this.lastReset.delete(key);\n  }\n\n  /**\n   * Gets the current configuration of the rate limiter\n   * @returns Object containing the current maxRequests and interval values\n   */\n  public getConfig(): Omit<RateLimitOptions, 'storage'> {\n    return {\n      maxRequests: this.maxRequests,\n      interval: this.interval,\n    };\n  }\n}\n\n/**\n * Default rate limiter instance for global use\n */\nexport const defaultRateLimiter = new RateLimiter();\n\n/**\n * Convenience function to check if a request is allowed for a given key.\n * Uses the default rate limiter instance.\n *\n * @param key - The unique identifier for the rate limit entry\n * @returns Promise resolving to true if the request is allowed, false if rate limited\n *\n * @example\n * ```typescript\n * const allowed = await ratelimit('user:123');\n * // update the default rate limiter config\n * import { defaultRateLimiter } from 'commandkit/ratelimit';\n *\n * // update max allowed requests\n * defaultRateLimiter.setMaxRequests(10);\n *\n * // update the timeout interval\n * defaultRateLimiter.setInterval(30000);\n *\n * // update the storage implementation\n * defaultRateLimiter.setStorage(new RedisStorage());\n * ```\n */\nexport async function ratelimit(key: string): Promise<boolean> {\n  return defaultRateLimiter.limit(key);\n}\n\n/**\n * Creates a new rate limiter instance with the specified configuration\n * @param options - Configuration options for the rate limiter\n * @returns New RateLimiter instance\n *\n * @example\n * ```typescript\n * const limiter = createRateLimiter({\n *   maxRequests: 5,\n *   interval: 30000,\n *   storage: new CustomStorage()\n * });\n * ```\n */\nexport function createRateLimiter(options: RateLimitOptions): RateLimiter {\n  return new RateLimiter(\n    options.maxRequests,\n    options.interval,\n    options.storage,\n  );\n}\n\n/**\n * Gets the remaining requests for a key using the default rate limiter\n * @param key - The unique identifier for the rate limit entry\n * @returns Promise resolving to the number of remaining requests\n */\nexport async function getRemainingRequests(key: string): Promise<number> {\n  return defaultRateLimiter.getRemaining(key);\n}\n\n/**\n * Gets the reset time for a key using the default rate limiter\n * @param key - The unique identifier for the rate limit entry\n * @returns Promise resolving to the time in milliseconds until reset\n */\nexport async function getResetTime(key: string): Promise<number> {\n  return defaultRateLimiter.getResetTime(key);\n}\n\n/**\n * Resets the rate limit for a key using the default rate limiter\n * @param key - The unique identifier for the rate limit entry\n * @returns Promise that resolves when the reset is complete\n */\nexport async function resetRateLimit(key: string): Promise<void> {\n  return defaultRateLimiter.reset(key);\n}\n"],"mappings":";;;;;AAGA,MAAa,kBAAkB;;;;AAK/B,MAAa,uBAAuB;;;;;AA8CpC,IAAa,yBAAb,MAAgE;CAC9D,AAAiB,wBAAQ,IAAI,KAAqB;;;;;;CAOlD,MAAM,IAAI,KAA8B;AACtC,SAAO,KAAK,MAAM,IAAI,IAAI,IAAI;;;;;;;;CAShC,MAAM,IAAI,KAAa,OAA8B;AACnD,OAAK,MAAM,IAAI,KAAK,MAAM;;;;;;;CAQ5B,MAAM,OAAO,KAA4B;AACvC,OAAK,MAAM,OAAO,IAAI;;;;;;;AAQ1B,IAAa,cAAb,MAAyB;CACvB,AAAiB,yBAA8B,IAAI,KAAK;CACxD,AAAiB,4BAAiC,IAAI,KAAK;CAC3D,AAAiB;;;;;;;CAQjB,AAAO,YACP,AAAiB,cAAsB,sBACvC,AAAiB,WAAmB,iBACpC,AAAQ,UAA4B,IAAI,wBAAwB,EAChE;EAHiB;EACA;EACT;AAEN,OAAK,gBAAgB;;;;;;CAOvB,AAAO,WAAW,SAA2B;AAC3C,OAAK,UAAU;;;;;;CAOjB,AAAO,aAA+B;AACpC,SAAO,KAAK;;;;;;;CAQd,MAAa,MAAM,KAA+B;EAChD,MAAM,MAAM,KAAK,KAAK;AAKtB,MAHuB,OADL,KAAK,UAAU,IAAI,IAAI,IAAI,KAIxB,KAAK,eAAe;AACvC,SAAM,KAAK,QAAQ,OAAO,IAAI;AAC9B,QAAK,UAAU,IAAI,KAAK,IAAI;AAC5B,QAAK,OAAO,IAAI,KAAK,EAAE;;EAIzB,MAAM,eAAe,MAAM,KAAK,QAAQ,IAAI,IAAI;AAGhD,MAAI,gBAAgB,KAAK,YACvB,QAAO;EAIT,MAAM,WAAW,eAAe;AAChC,QAAM,KAAK,QAAQ,IAAI,KAAK,SAAS;AACrC,OAAK,OAAO,IAAI,KAAK,SAAS;AAE9B,SAAO;;;;;;;CAQT,MAAa,aAAa,KAA8B;EACtD,MAAM,eAAe,MAAM,KAAK,QAAQ,IAAI,IAAI;AAChD,SAAO,KAAK,IAAI,GAAG,KAAK,cAAc,aAAa;;;;;;;CAQrD,MAAa,aAAa,KAA8B;EACtD,MAAM,YAAY,KAAK,UAAU,IAAI,IAAI,IAAI;EAE7C,MAAM,iBADM,KAAK,KAAK,GACO;AAE7B,MAAI,kBAAkB,KAAK,cACzB,QAAO;AAGT,SAAO,KAAK,gBAAgB;;;;;;;CAQ9B,MAAa,MAAM,KAA4B;AAC7C,QAAM,KAAK,QAAQ,OAAO,IAAI;AAC9B,OAAK,OAAO,OAAO,IAAI;AACvB,OAAK,UAAU,OAAO,IAAI;;;;;;CAO5B,AAAO,YAA+C;AACpD,SAAO;GACL,aAAa,KAAK;GAClB,UAAU,KAAK;GAChB;;;;;;AAOL,MAAa,qBAAqB,IAAI,aAAa;;;;;;;;;;;;;;;;;;;;;;;;AAyBnD,eAAsB,UAAU,KAA+B;AAC7D,QAAO,mBAAmB,MAAM,IAAI;;;;;;;;;;;;;;;;AAiBtC,SAAgB,kBAAkB,SAAwC;AACxE,QAAO,IAAI,YACT,QAAQ,aACR,QAAQ,UACR,QAAQ,QACT;;;;;;;AAQH,eAAsB,qBAAqB,KAA8B;AACvE,QAAO,mBAAmB,aAAa,IAAI;;;;;;;AAQ7C,eAAsB,aAAa,KAA8B;AAC/D,QAAO,mBAAmB,aAAa,IAAI;;;;;;;AAQ7C,eAAsB,eAAe,KAA4B;AAC/D,QAAO,mBAAmB,MAAM,IAAI"}
+{"version":3,"file":"ratelimiter.js","names":[],"sources":["../../../src/utils/useful-stuff/ratelimiter.ts"],"sourcesContent":["/**\n * Default timeout interval for rate limiting in milliseconds\n */\nexport const DEFAULT_TIMEOUT = 60000;\n\n/**\n * Default maximum number of requests allowed per interval\n */\nexport const DEFAULT_MAX_REQUESTS = 10;\n\n/**\n * Interface for rate limit storage implementations.\n * Provides methods to store, retrieve, and delete rate limit data.\n */\nexport interface RateLimitStorage {\n  /**\n   * Retrieves the current request count for a given key\n   * @param key - The unique identifier for the rate limit entry\n   * @returns Promise resolving to the current request count\n   */\n  get(key: string): Promise<number>;\n\n  /**\n   * Sets the request count for a given key\n   * @param key - The unique identifier for the rate limit entry\n   * @param value - The request count to store\n   * @returns Promise that resolves when the value is stored\n   */\n  set(key: string, value: number): Promise<void>;\n\n  /**\n   * Deletes the rate limit entry for a given key\n   * @param key - The unique identifier for the rate limit entry\n   * @returns Promise that resolves when the entry is deleted\n   */\n  delete(key: string): Promise<void>;\n}\n\n/**\n * Configuration options for rate limiting\n */\nexport interface RateLimitOptions {\n  /** Maximum number of requests allowed per interval. Default: 10 */\n  maxRequests?: number;\n  /** Time interval in milliseconds for the rate limit window. Default: 60000 */\n  interval?: number;\n  /** Storage implementation for persisting rate limit data. Default: {@link MemoryRateLimitStorage} */\n  storage?: RateLimitStorage;\n}\n\n/**\n * In-memory storage implementation for rate limiting.\n * Suitable for single-instance applications.\n */\nexport class MemoryRateLimitStorage implements RateLimitStorage {\n  private readonly store = new Map<string, number>();\n\n  /**\n   * Retrieves the current request count for a given key\n   * @param key - The unique identifier for the rate limit entry\n   * @returns Promise resolving to the current request count or 0 if not found\n   */\n  async get(key: string): Promise<number> {\n    return this.store.get(key) || 0;\n  }\n\n  /**\n   * Sets the request count for a given key\n   * @param key - The unique identifier for the rate limit entry\n   * @param value - The request count to store\n   * @returns Promise that resolves immediately\n   */\n  async set(key: string, value: number): Promise<void> {\n    this.store.set(key, value);\n  }\n\n  /**\n   * Deletes the rate limit entry for a given key\n   * @param key - The unique identifier for the rate limit entry\n   * @returns Promise that resolves immediately\n   */\n  async delete(key: string): Promise<void> {\n    this.store.delete(key);\n  }\n}\n\n/**\n * Rate limiter implementation that enforces request limits per key.\n * Supports configurable request limits and time intervals.\n */\nexport class RateLimiter {\n  private readonly limits: Map<string, number> = new Map();\n  private readonly lastReset: Map<string, number> = new Map();\n  private readonly resetInterval: number;\n\n  /**\n   * Creates a new rate limiter instance\n   * @param maxRequests - Maximum number of requests allowed per interval (default: 10)\n   * @param interval - Time interval in milliseconds for the rate limit window (default: 60000)\n   * @param storage - Optional storage implementation (default: MemoryRateLimitStorage)\n   */\n  public constructor(\n    private readonly maxRequests: number = DEFAULT_MAX_REQUESTS,\n    private readonly interval: number = DEFAULT_TIMEOUT,\n    private storage: RateLimitStorage = new MemoryRateLimitStorage(),\n  ) {\n    this.resetInterval = interval;\n  }\n\n  /**\n   * Sets the storage implementation for the rate limiter\n   * @param storage - The storage implementation to use\n   */\n  public setStorage(storage: RateLimitStorage) {\n    this.storage = storage;\n  }\n\n  /**\n   * Gets the storage implementation for the rate limiter\n   * @returns The storage implementation\n   */\n  public getStorage(): RateLimitStorage {\n    return this.storage;\n  }\n\n  /**\n   * Checks if a request is allowed for the given key and increments the counter if allowed\n   * @param key - The unique identifier for the rate limit entry\n   * @returns Promise resolving to true if the request is allowed, false if rate limited\n   */\n  public async limit(key: string): Promise<boolean> {\n    const now = Date.now();\n    const lastReset = this.lastReset.get(key) || 0;\n    const timeSinceReset = now - lastReset;\n\n    // Reset counter if interval has passed\n    if (timeSinceReset > this.resetInterval) {\n      await this.storage.delete(key);\n      this.lastReset.set(key, now);\n      this.limits.set(key, 0);\n    }\n\n    // Get current count from storage\n    const currentCount = await this.storage.get(key);\n\n    // Check if limit exceeded\n    if (currentCount >= this.maxRequests) {\n      return false;\n    }\n\n    // Increment counter\n    const newCount = currentCount + 1;\n    await this.storage.set(key, newCount);\n    this.limits.set(key, newCount);\n\n    return true;\n  }\n\n  /**\n   * Gets the remaining requests allowed for a given key\n   * @param key - The unique identifier for the rate limit entry\n   * @returns Promise resolving to the number of remaining requests\n   */\n  public async getRemaining(key: string): Promise<number> {\n    const currentCount = await this.storage.get(key);\n    return Math.max(0, this.maxRequests - currentCount);\n  }\n\n  /**\n   * Gets the time until the rate limit resets for a given key\n   * @param key - The unique identifier for the rate limit entry\n   * @returns Promise resolving to the time in milliseconds until reset, or 0 if no limit is active\n   */\n  public async getResetTime(key: string): Promise<number> {\n    const lastReset = this.lastReset.get(key) || 0;\n    const now = Date.now();\n    const timeSinceReset = now - lastReset;\n\n    if (timeSinceReset >= this.resetInterval) {\n      return 0;\n    }\n\n    return this.resetInterval - timeSinceReset;\n  }\n\n  /**\n   * Resets the rate limit for a given key\n   * @param key - The unique identifier for the rate limit entry\n   * @returns Promise that resolves when the reset is complete\n   */\n  public async reset(key: string): Promise<void> {\n    await this.storage.delete(key);\n    this.limits.delete(key);\n    this.lastReset.delete(key);\n  }\n\n  /**\n   * Gets the current configuration of the rate limiter\n   * @returns Object containing the current maxRequests and interval values\n   */\n  public getConfig(): Omit<RateLimitOptions, 'storage'> {\n    return {\n      maxRequests: this.maxRequests,\n      interval: this.interval,\n    };\n  }\n}\n\n/**\n * Default rate limiter instance for global use\n */\nexport const defaultRateLimiter = new RateLimiter();\n\n/**\n * Convenience function to check if a request is allowed for a given key.\n * Uses the default rate limiter instance.\n *\n * @param key - The unique identifier for the rate limit entry\n * @returns Promise resolving to true if the request is allowed, false if rate limited\n *\n * @example\n * ```typescript\n * const allowed = await ratelimit('user:123');\n * // update the default rate limiter config\n * import { defaultRateLimiter } from 'commandkit/ratelimit';\n *\n * // update max allowed requests\n * defaultRateLimiter.setMaxRequests(10);\n *\n * // update the timeout interval\n * defaultRateLimiter.setInterval(30000);\n *\n * // update the storage implementation\n * defaultRateLimiter.setStorage(new RedisStorage());\n * ```\n */\nexport async function ratelimit(key: string): Promise<boolean> {\n  return defaultRateLimiter.limit(key);\n}\n\n/**\n * Creates a new rate limiter instance with the specified configuration\n * @param options - Configuration options for the rate limiter\n * @returns New RateLimiter instance\n *\n * @example\n * ```typescript\n * const limiter = createRateLimiter({\n *   maxRequests: 5,\n *   interval: 30000,\n *   storage: new CustomStorage()\n * });\n * ```\n */\nexport function createRateLimiter(options: RateLimitOptions): RateLimiter {\n  return new RateLimiter(\n    options.maxRequests,\n    options.interval,\n    options.storage,\n  );\n}\n\n/**\n * Gets the remaining requests for a key using the default rate limiter\n * @param key - The unique identifier for the rate limit entry\n * @returns Promise resolving to the number of remaining requests\n */\nexport async function getRemainingRequests(key: string): Promise<number> {\n  return defaultRateLimiter.getRemaining(key);\n}\n\n/**\n * Gets the reset time for a key using the default rate limiter\n * @param key - The unique identifier for the rate limit entry\n * @returns Promise resolving to the time in milliseconds until reset\n */\nexport async function getResetTime(key: string): Promise<number> {\n  return defaultRateLimiter.getResetTime(key);\n}\n\n/**\n * Resets the rate limit for a key using the default rate limiter\n * @param key - The unique identifier for the rate limit entry\n * @returns Promise that resolves when the reset is complete\n */\nexport async function resetRateLimit(key: string): Promise<void> {\n  return defaultRateLimiter.reset(key);\n}\n"],"mappings":";;;;;AAGA,MAAa,kBAAkB;;;;AAK/B,MAAa,uBAAuB;;;;;AA8CpC,IAAa,yBAAb,MAAgE;CAC9D,AAAiB,wBAAQ,IAAI,KAAqB;;;;;;CAOlD,MAAM,IAAI,KAA8B;AACtC,SAAO,KAAK,MAAM,IAAI,IAAI,IAAI;;;;;;;;CAShC,MAAM,IAAI,KAAa,OAA8B;AACnD,OAAK,MAAM,IAAI,KAAK,MAAM;;;;;;;CAQ5B,MAAM,OAAO,KAA4B;AACvC,OAAK,MAAM,OAAO,IAAI;;;;;;;AAQ1B,IAAa,cAAb,MAAyB;CACvB,AAAiB,yBAA8B,IAAI,KAAK;CACxD,AAAiB,4BAAiC,IAAI,KAAK;CAC3D,AAAiB;;;;;;;CAQjB,AAAO,YACP,AAAU,cAA6B,sBACvC,AAAU,WAA0B,iBACpC,AAAE,UAAkC,IAAE,wBAA0B,EAChE;EAHU;EACA;EACR;AAEA,OAAK,gBAAgB;;;;;;CAOvB,AAAO,WAAW,SAA2B;AAC3C,OAAK,UAAU;;;;;;CAOjB,AAAO,aAA+B;AACpC,SAAO,KAAK;;;;;;;CAQd,MAAa,MAAM,KAA+B;EAChD,MAAM,MAAM,KAAK,KAAK;AAKtB,MAHuB,OADL,KAAK,UAAU,IAAI,IAAI,IAAI,KAIxB,KAAK,eAAe;AACvC,SAAM,KAAK,QAAQ,OAAO,IAAI;AAC9B,QAAK,UAAU,IAAI,KAAK,IAAI;AAC5B,QAAK,OAAO,IAAI,KAAK,EAAE;;EAIzB,MAAM,eAAe,MAAM,KAAK,QAAQ,IAAI,IAAI;AAGhD,MAAI,gBAAgB,KAAK,YACvB,QAAO;EAIT,MAAM,WAAW,eAAe;AAChC,QAAM,KAAK,QAAQ,IAAI,KAAK,SAAS;AACrC,OAAK,OAAO,IAAI,KAAK,SAAS;AAE9B,SAAO;;;;;;;CAQT,MAAa,aAAa,KAA8B;EACtD,MAAM,eAAe,MAAM,KAAK,QAAQ,IAAI,IAAI;AAChD,SAAO,KAAK,IAAI,GAAG,KAAK,cAAc,aAAa;;;;;;;CAQrD,MAAa,aAAa,KAA8B;EACtD,MAAM,YAAY,KAAK,UAAU,IAAI,IAAI,IAAI;EAE7C,MAAM,iBADM,KAAK,KAAK,GACO;AAE7B,MAAI,kBAAkB,KAAK,cACzB,QAAO;AAGT,SAAO,KAAK,gBAAgB;;;;;;;CAQ9B,MAAa,MAAM,KAA4B;AAC7C,QAAM,KAAK,QAAQ,OAAO,IAAI;AAC9B,OAAK,OAAO,OAAO,IAAI;AACvB,OAAK,UAAU,OAAO,IAAI;;;;;;CAO5B,AAAO,YAA+C;AACpD,SAAO;GACL,aAAa,KAAK;GAClB,UAAU,KAAK;GAChB;;;;;;AAOL,MAAa,qBAAqB,IAAI,aAAa;;;;;;;;;;;;;;;;;;;;;;;;AAyBnD,eAAsB,UAAU,KAA+B;AAC7D,QAAO,mBAAmB,MAAM,IAAI;;;;;;;;;;;;;;;;AAiBtC,SAAgB,kBAAkB,SAAwC;AACxE,QAAO,IAAI,YACT,QAAQ,aACR,QAAQ,UACR,QAAQ,QACT;;;;;;;AAQH,eAAsB,qBAAqB,KAA8B;AACvE,QAAO,mBAAmB,aAAa,IAAI;;;;;;;AAQ7C,eAAsB,aAAa,KAA8B;AAC/D,QAAO,mBAAmB,aAAa,IAAI;;;;;;;AAQ7C,eAAsB,eAAe,KAA4B;AAC/D,QAAO,mBAAmB,MAAM,IAAI"}

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/utilities.d.ts

@@ -1,2 +1,113 @@
-import { a as debounce, c as findAppDirectory, d as noBuildOnly, i as createProxy, l as getCurrentDirectory, n as SimpleProxy, o as defer, r as buildOnly, s as devOnly, t as JsonSerialize, u as getSourceDirectories } from "../utilities-BV9Osg71.js";
-export { JsonSerialize, SimpleProxy, buildOnly, createProxy, debounce, defer, devOnly, findAppDirectory, getCurrentDirectory, getSourceDirectories, noBuildOnly };
+//#region src/utils/utilities.d.ts
+/**
+ * Returns the current working directory of the CommandKit application.
+ * This is typically the directory where the source code is located.
+ */
+declare function getCurrentDirectory(): string;
+/**
+ * Returns the possible source directories for the CommandKit application.
+ * This includes the `src`, `.commandkit`, and the distribution directory.
+ * @returns An array of possible source directories.
+ */
+declare function getSourceDirectories(): string[];
+/**
+ * Returns the path to the app directory.
+ * @returns The path to the app directory or `null` if not found.
+ */
+declare function findAppDirectory(): string | null;
+/**
+ * Debounces a function.
+ * @param fn The function to debounce.
+ * @param ms The debounce time in milliseconds.
+ * @returns The debounced function.
+ * @example
+ * const debouncedFn = debounce(() => {
+ *   console.log('Debounced function called');
+ * }, 300);
+ *
+ * debouncedFn(); // Will only execute after 300ms of inactivity
+ * debouncedFn(); // Will reset the timer
+ * debouncedFn(); // Will reset the timer again
+ */
+declare function debounce<R, F extends (...args: any[]) => R>(fn: F, ms: number): F;
+/**
+ * Defers the execution of a function.
+ * @param fn The function to defer.
+ * @param timeout The time in milliseconds to wait before executing the function. Defaults to 0.
+ * @example
+ * defer(() => {
+ *   console.log('This will run after a delay');
+ * });
+ *
+ * console.log('This will run immediately');
+ */
+declare function defer<T>(fn: () => T, timeout?: number): void;
+/**
+ * Serializes a value to JSON.
+ * @param value The value to serialize.
+ * @param defaultValue The default value to return if the value is not serializable.
+ * @returns The serialized value.
+ */
+declare function JsonSerialize<R = any>(value: any, defaultValue?: R): R;
+/**
+ * Creates a function from the given function that runs only in development mode.
+ * @param fn The function to run in development mode.
+ * @returns The function that runs only in development mode.
+ * @example
+ * ```ts
+ * const devOnlyFn = devOnly(() => {
+ *   console.log('This function runs only in development mode');
+ * });
+ * devOnlyFn(); // This will log the message only in development mode
+ * ```
+ */
+declare function devOnly<T extends (...args: any[]) => any>(fn: T): T;
+/**
+ * Creates a function from the given function that runs only in build mode.
+ * @param fn The function to run in build mode.
+ * @returns The function that runs only in build mode.
+ * @example
+ * ```ts
+ * const buildOnlyFn = buildOnly(() => {
+ *   console.log('This function runs only in build mode');
+ * });
+ * buildOnlyFn(); // This will log the message only in build mode
+ * ```
+ */
+declare function buildOnly<T extends (...args: any[]) => any>(fn: T): T;
+/**
+ * Creates a function from the given function that runs only outside of build mode.
+ * @param fn The function to run outside of build mode.
+ * @returns The function that runs only outside of build mode.
+ * @example
+ * ```ts
+ * const noBuildOnlyFn = noBuildOnly(() => {
+ *   console.log('This function runs only outside of build mode');
+ * });
+ * noBuildOnlyFn(); // This will log the message only outside of build mode
+ * ```
+ */
+declare function noBuildOnly<T extends (...args: any[]) => any>(fn: T): T;
+/**
+ * Represents a simple proxy object that mirrors a target object.
+ */
+interface SimpleProxy<T extends object> {
+  /**
+       * 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.
+       */
+  setTarget(newTarget: T): void;
+}
+/**
+ * Creates a simple proxy object that mirrors the target object.
+ * @param target The target object to proxy.
+ * @returns The proxied object.
+ */
+declare function createProxy<T extends object>(target: T): SimpleProxy<T>;
+//#endregion
+export { JsonSerialize, SimpleProxy, buildOnly, createProxy, debounce, defer, devOnly, findAppDirectory, getCurrentDirectory, getSourceDirectories, noBuildOnly };
+//# sourceMappingURL=utilities.d.ts.map

package/dist/utils/utilities.js

@@ -1,42 +1,27 @@
-require('../colors-CLmBiP9I.js');
-require('../ActionRow-D6knpVd6.js');
-require('../error-codes-Ds0bnPvT.js');
-const require_commandkit = require('../commandkit-B0wT0Mxx.js');
-require('../warning-CszH8HeS.js');
-require('../common-CEordwf3.js');
-require('../common-C2jAjX4U.js');
-require('../container-C319x4cG.js');
-require('../file-DgEXJx3x.js');
-require('../media-gallery-DdU7o9Cf.js');
-require('../section-C4qfgzOQ.js');
-require('../separator-CsoRs1aX.js');
-require('../text-display-C0oSz5y0.js');
-require('../label-CCHbfQW8.js');
-require('../poll-6lSMoohv.js');
+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('../element-DibzzA5L.js');
-require('../types-TC4g3w91.js');
-require('../EventInterceptor-BWoEJMHZ.js');
 require('../constants-CxkFFZ7p.js');
-require('../PluginCommon-Bp5T3ubs.js');
-require('../CompilerPlugin-DbN5-ls3.js');
-require('../RuntimePlugin-Bq6z-Upz.js');
-require('../types-Cdh4uaFR.js');
-require('../resolve-file-url-CJoD0FAn.js');
-require('../runtime-Skt5NiOc.js');
-require('../utils-Br3eenD1.js');
-require('../types-package-BxIhhZgZ.js');
-require('../constants-BqrEmoih.js');
-require('../EventWorkerContext-yTm5vI3b.js');
-require('../signals-C2Ly0wDt.js');
-require('../helpers-0FUA42u8.js');
-require('../MessageCommandParser-CD7ynlBO.js');
-require('../CommandsRouter-NAgpWzTJ.js');
-require('../EventsRouter-D4_vBMhl.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-B2-sF49Q.js');
-require('../CommandKitEventsChannel-2l9Za-le.js');
-require('../store-GrsErvli.js');
+require('../common-DSRs_mfw.js');
+require('../store-D8r_hryO.js');
 
 exports.JsonSerialize = require_commandkit.JsonSerialize;
 exports.buildOnly = require_commandkit.buildOnly;

package/dist/utils/warning.d.ts

@@ -1,2 +1,25 @@
-import { n as warnDeprecated, r as warnUnstable, t as emitWarning } from "../warning-BucG024D.js";
-export { emitWarning, warnDeprecated, warnUnstable };
+//#region src/utils/warning.d.ts
+/**
+ * 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').
+ */
+declare function emitWarning(message: string, code?: string): void;
+/**
+ * Emit a warning for unstable features in CommandKit.
+ * @param name - The name of the unstable feature.
+ * @example warnUnstable('MyUnstableFeature');
+ */
+declare function warnUnstable(name: string): void;
+declare function warnDeprecated({
+  what,
+  message,
+  where
+}: {
+  what: string;
+  where?: string;
+  message?: string;
+}): void;
+//#endregion
+export { emitWarning, warnDeprecated, warnUnstable };
+//# sourceMappingURL=warning.d.ts.map