commandkit 1.2.0-rc.9 → 1.2.0

package/dist/utils/error-codes.js

@@ -1,6 +1,54 @@
-const require_error_codes = require('../error-codes-Ds0bnPvT.js');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-exports.CommandKitErrorCodes = require_error_codes.CommandKitErrorCodes;
-exports.createCommandKitError = require_error_codes.createCommandKitError;
-exports.isCommandKitError = require_error_codes.isCommandKitError;
-exports.isErrorType = require_error_codes.isErrorType;
+//#region src/utils/error-codes.ts
+/**
+* The error codes used by CommandKit.
+*/
+const CommandKitErrorCodes = {
+	StopMiddlewares: Symbol("kStopMiddlewares"),
+	ForwardedCommand: Symbol("kForwardedCommand"),
+	InvalidCommandPrefix: Symbol("kInvalidCommandPrefix"),
+	PluginCaptureHandle: Symbol("kPluginCaptureHandle"),
+	StopEvents: Symbol("kStopEvents")
+};
+/**
+* Creates a new CommandKit error with the specified code.
+* @param code The error code to assign to the error.
+* @returns A new CommandKit error instance.
+*/
+function createCommandKitError(code) {
+	const error = /* @__PURE__ */ new Error();
+	Reflect.set(error, "code", code);
+	return error;
+}
+/**
+* Checks if the given error is a CommandKit error.
+* @param error The error to check.
+* @returns True if the error is a CommandKit error, false otherwise.
+*/
+function isCommandKitError(error) {
+	if (!(error instanceof Error)) return false;
+	const code = Reflect.get(error, "code");
+	for (const key in CommandKitErrorCodes) if (CommandKitErrorCodes[key] === code) return true;
+	return false;
+}
+/**
+* Checks if the given error is of a specific CommandKit error type.
+* @param error The error to check.
+* @param code The error code or an array of error codes to check against.
+* @returns True if the error matches the specified code(s), false otherwise.
+*/
+function isErrorType(error, code) {
+	if (!isCommandKitError(error)) return false;
+	const errorCode = Reflect.get(error, "code");
+	if (!errorCode) return false;
+	if (Array.isArray(code)) return code.includes(errorCode);
+	return errorCode === code;
+}
+
+//#endregion
+exports.CommandKitErrorCodes = CommandKitErrorCodes;
+exports.createCommandKitError = createCommandKitError;
+exports.isCommandKitError = isCommandKitError;
+exports.isErrorType = isErrorType;
+//# sourceMappingURL=error-codes.js.map

package/dist/utils/error-codes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-codes.js","names":[],"sources":["../../src/utils/error-codes.ts"],"sourcesContent":["/**\n * The error codes used by CommandKit.\n */\nexport const CommandKitErrorCodes = {\n  /**\n   * Error code for exiting middleware.\n   */\n  StopMiddlewares: Symbol('kStopMiddlewares'),\n  /**\n   * Error code for forwarded commands.\n   */\n  ForwardedCommand: Symbol('kForwardedCommand'),\n  /**\n   * Error code for invalid command prefix.\n   */\n  InvalidCommandPrefix: Symbol('kInvalidCommandPrefix'),\n  /**\n   * Error code for plugin capture handle.\n   */\n  PluginCaptureHandle: Symbol('kPluginCaptureHandle'),\n  /**\n   * Error code for event interruption signal\n   */\n  StopEvents: Symbol('kStopEvents'),\n} as const;\n\n/**\n * The type for CommandKit errors.\n */\nexport type CommandKitError = Error & { code: symbol };\n\n/**\n * Creates a new CommandKit error with the specified code.\n * @param code The error code to assign to the error.\n * @returns A new CommandKit error instance.\n */\nexport function createCommandKitError(code: symbol): CommandKitError {\n  const error = new Error() as CommandKitError;\n\n  Reflect.set(error, 'code', code);\n\n  return error;\n}\n\n/**\n * Checks if the given error is a CommandKit error.\n * @param error The error to check.\n * @returns True if the error is a CommandKit error, false otherwise.\n */\nexport function isCommandKitError(error: unknown): error is CommandKitError {\n  if (!(error instanceof Error)) return false;\n  const code = Reflect.get(error, 'code');\n\n  for (const key in CommandKitErrorCodes) {\n    if (CommandKitErrorCodes[key as keyof typeof CommandKitErrorCodes] === code)\n      return true;\n  }\n\n  return false;\n}\n\n/**\n * Checks if the given error is of a specific CommandKit error type.\n * @param error The error to check.\n * @param code The error code or an array of error codes to check against.\n * @returns True if the error matches the specified code(s), false otherwise.\n */\nexport function isErrorType(error: unknown, code: symbol | symbol[]): boolean {\n  if (!isCommandKitError(error)) return false;\n  const errorCode = Reflect.get(error, 'code');\n\n  if (!errorCode) return false;\n\n  if (Array.isArray(code)) return code.includes(errorCode);\n\n  return errorCode === code;\n}\n"],"mappings":";;;;;;AAGA,MAAa,uBAAuB;CAIlC,iBAAiB,OAAO,mBAAmB;CAI3C,kBAAkB,OAAO,oBAAoB;CAI7C,sBAAsB,OAAO,wBAAwB;CAIrD,qBAAqB,OAAO,uBAAuB;CAInD,YAAY,OAAO,cAAc;CAClC;;;;;;AAYD,SAAgB,sBAAsB,MAA+B;CACnE,MAAM,wBAAQ,IAAI,OAAO;AAEzB,SAAQ,IAAI,OAAO,QAAQ,KAAK;AAEhC,QAAO;;;;;;;AAQT,SAAgB,kBAAkB,OAA0C;AAC1E,KAAI,EAAE,iBAAiB,OAAQ,QAAO;CACtC,MAAM,OAAO,QAAQ,IAAI,OAAO,OAAO;AAEvC,MAAK,MAAM,OAAO,qBAChB,KAAI,qBAAqB,SAA8C,KACvE,QAAE;AAGJ,QAAO;;;;;;;;AAST,SAAgB,YAAY,OAAgB,MAAkC;AAC5E,KAAI,CAAC,kBAAkB,MAAM,CAAE,QAAO;CACtC,MAAM,YAAY,QAAQ,IAAI,OAAO,OAAO;AAE5C,KAAI,CAAC,UAAW,QAAO;AAEvB,KAAI,MAAM,QAAQ,KAAK,CAAE,QAAO,KAAK,SAAS,UAAU;AAExD,QAAO,cAAc"}

package/dist/utils/resolve-file-url.d.ts

@@ -1,2 +1,11 @@
-import { toFileURL } from "../resolve-file-url-yO8bUxok.js";
-export { toFileURL };
+//#region src/utils/resolve-file-url.d.ts
+/**
+ * Convert a local file path to a file URL.
+ * @param filePath - The local file's path.
+ * @param withTs - Whether to append a timestamp to the URL.
+ * @returns - The converted file URL.
+ */
+declare function toFileURL(filePath: string, withTs?: boolean): string;
+//#endregion
+export { toFileURL };
+//# sourceMappingURL=resolve-file-url.d.ts.map

package/dist/utils/resolve-file-url.js

@@ -1,3 +1,19 @@
-const require_resolve_file_url = require('../resolve-file-url-ChIyw-Vf.js');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('../chunk-BE-pF4vm.js');
+let path = require("path");
+path = require_chunk.__toESM(path);
 
-exports.toFileURL = require_resolve_file_url.toFileURL;
+//#region src/utils/resolve-file-url.ts
+/**
+* Convert a local file path to a file URL.
+* @param filePath - The local file's path.
+* @param withTs - Whether to append a timestamp to the URL.
+* @returns - The converted file URL.
+*/
+function toFileURL(filePath, withTs = false) {
+	return `${"file://" + path.default.resolve(filePath).replace(/\\\\|\\/g, "/")}${withTs ? `?ts=${Date.now()}` : ""}`;
+}
+
+//#endregion
+exports.toFileURL = toFileURL;
+//# sourceMappingURL=resolve-file-url.js.map

package/dist/utils/resolve-file-url.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-file-url.js","names":[],"sources":["../../src/utils/resolve-file-url.ts"],"sourcesContent":["import path from 'path';\n\n/**\n * Convert a local file path to a file URL.\n * @param filePath - The local file's path.\n * @param withTs - Whether to append a timestamp to the URL.\n * @returns - The converted file URL.\n */\nexport function toFileURL(filePath: string, withTs = false) {\n  const resolvedPath = path.resolve(filePath);\n  return `${'file://' + resolvedPath.replace(/\\\\\\\\|\\\\/g, '/')}${withTs ? `?ts=${Date.now()}` : ''}`;\n}\n"],"mappings":";;;;;;;;;;;;AAQA,SAAgB,UAAU,UAAkB,SAAS,OAAO;AAE1D,QAAO,GAAG,YADW,aAAK,QAAQ,SAAS,CACR,QAAQ,YAAY,IAAI,GAAG,SAAS,OAAO,KAAK,KAAK,KAAK"}

package/dist/utils/types-package.js

@@ -1,5 +1,62 @@
-require('../constants-B5_Ta7PR.js');
-const require_types_package = require('../types-package-BWArjyBF.js');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('../chunk-BE-pF4vm.js');
+const require_utils_constants = require('./constants.js');
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+let node_fs_promises = require("node:fs/promises");
 
-exports.generateTypesPackage = require_types_package.generateTypesPackage;
-exports.rewriteCommandDeclaration = require_types_package.rewriteCommandDeclaration;
+//#region src/utils/types-package.ts
+/**
+* @private
+*/
+async function generateTypesPackage(force = false) {
+	const location = (0, node_path.join)(require_utils_constants.COMMANDKIT_CWD, "node_modules", "commandkit-types");
+	if (!require_utils_constants.COMMANDKIT_IS_DEV && !force) return location;
+	const packageJSON = (0, node_path.join)(location, "package.json");
+	const index = (0, node_path.join)(location, "index.js");
+	const types = (0, node_path.join)(location, "index.d.ts");
+	const command = (0, node_path.join)(location, "command.d.ts");
+	const packageJSONContent = {
+		name: "commandkit-types",
+		version: "1.0.0",
+		description: "CommandKit types package",
+		type: "commonjs",
+		main: "index.js",
+		types: "index.d.ts"
+	};
+	const indexContent = `module.exports = {};`;
+	const typesContent = `// Main types index file - imports all type declarations
+import './command';
+export {};
+`;
+	const commandTypesContent = `// Auto-generated command types
+  export {};
+declare module 'commandkit' {
+   type CommandTypeData = string
+}`;
+	await (0, node_fs_promises.mkdir)(location, { recursive: true }).catch(() => {});
+	await (0, node_fs_promises.writeFile)(packageJSON, JSON.stringify(packageJSONContent, null, 2));
+	await (0, node_fs_promises.writeFile)(index, indexContent);
+	await (0, node_fs_promises.writeFile)(types, typesContent);
+	await (0, node_fs_promises.writeFile)(command, commandTypesContent);
+	return location;
+}
+/**
+* @private
+*/
+async function rewriteCommandDeclaration(data) {
+	const commandTypesContent = `// Auto-generated command types
+  declare module 'commandkit' {
+    ${data}
+}
+    export {};
+`;
+	const location = (0, node_path.join)(require_utils_constants.COMMANDKIT_CWD, "node_modules", "commandkit-types");
+	if (!(0, node_fs.existsSync)(location)) return;
+	await (0, node_fs_promises.writeFile)((0, node_path.join)(location, "command.d.ts"), commandTypesContent, { encoding: "utf-8" });
+}
+
+//#endregion
+exports.generateTypesPackage = generateTypesPackage;
+exports.rewriteCommandDeclaration = rewriteCommandDeclaration;
+//# sourceMappingURL=types-package.js.map

package/dist/utils/types-package.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-package.js","names":[],"sources":["../../src/utils/types-package.ts"],"sourcesContent":["import { mkdir, writeFile } from 'node:fs/promises';\nimport { join } from 'node:path';\nimport { COMMANDKIT_CWD, COMMANDKIT_IS_DEV } from './constants';\nimport { existsSync } from 'node:fs';\n\n/**\n * @private\n */\nexport async function generateTypesPackage(force = false) {\n  const location = join(COMMANDKIT_CWD, 'node_modules', 'commandkit-types');\n  if (!COMMANDKIT_IS_DEV && !force) return location;\n  const packageJSON = join(location, 'package.json');\n  const index = join(location, 'index.js');\n  const types = join(location, 'index.d.ts');\n  const command = join(location, 'command.d.ts');\n\n  const packageJSONContent = {\n    name: 'commandkit-types',\n    version: '1.0.0',\n    description: 'CommandKit types package',\n    type: 'commonjs',\n    main: 'index.js',\n    types: 'index.d.ts',\n  };\n\n  const indexContent = `module.exports = {};`;\n\n  // Restructuring the type declarations to properly extend rather than replace types\n  const typesContent = `// Main types index file - imports all type declarations\nimport './command';\nexport {};\n`;\n\n  // Properly set up command types to extend the CommandTypeData interface\n  const commandTypesContent = `// Auto-generated command types\n  export {};\ndeclare module 'commandkit' {\n   type CommandTypeData = string\n}`;\n\n  await mkdir(location, { recursive: true }).catch(() => {});\n  await writeFile(packageJSON, JSON.stringify(packageJSONContent, null, 2));\n  await writeFile(index, indexContent);\n  await writeFile(types, typesContent);\n  await writeFile(command, commandTypesContent);\n\n  return location;\n}\n\n/**\n * @private\n */\nexport async function rewriteCommandDeclaration(data: string) {\n  const commandTypesContent = `// Auto-generated command types\n  declare module 'commandkit' {\n    ${data}\n}\n    export {};\n`;\n\n  const location = join(COMMANDKIT_CWD, 'node_modules', 'commandkit-types');\n\n  if (!existsSync(location)) return;\n\n  const type = join(location, 'command.d.ts');\n\n  await writeFile(type, commandTypesContent, { encoding: 'utf-8' });\n}\n"],"mappings":";;;;;;;;;;;AAQA,eAAsB,qBAAqB,QAAQ,OAAO;CACxD,MAAM,+BAAgB,wCAAgB,gBAAgB,mBAAmB;AACzE,KAAI,CAAC,6CAAqB,CAAC,MAAO,QAAO;CACzC,MAAM,kCAAmB,UAAU,eAAe;CAClD,MAAM,4BAAa,UAAU,WAAW;CACxC,MAAM,4BAAa,UAAU,aAAa;CAC1C,MAAM,8BAAe,UAAU,eAAe;CAE9C,MAAM,qBAAqB;EACzB,MAAM;EACN,SAAS;EACT,aAAa;EACb,MAAM;EACN,MAAM;EACN,OAAO;EACR;CAED,MAAM,eAAe;CAGrB,MAAM,eAAe;;;;CAMrB,MAAM,sBAAsB;;;;;AAM5B,mCAAY,UAAU,EAAE,WAAW,MAAM,CAAC,CAAC,YAAY,GAAG;AAC1D,uCAAgB,aAAa,KAAK,UAAU,oBAAoB,MAAM,EAAE,CAAC;AACzE,uCAAgB,OAAO,aAAa;AACpC,uCAAgB,OAAO,aAAa;AACpC,uCAAgB,SAAS,oBAAoB;AAE7C,QAAO;;;;;AAMT,eAAsB,0BAA0B,MAAc;CAC5D,MAAM,sBAAsB;;MAExB,KAAI;;;;CAKR,MAAM,+BAAgB,wCAAgB,gBAAgB,mBAAmB;AAEzE,KAAI,yBAAY,SAAS,CAAE;AAI3B,2DAFkB,UAAU,eAAe,EAErB,qBAAqB,EAAE,UAAU,SAAS,CAAC"}

package/dist/utils/useful-stuff/async-queue.js

@@ -1,3 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 //#region src/utils/useful-stuff/async-queue.ts
 var AsyncQueue = class {
@@ -37,8 +38,7 @@ var AsyncQueue = class {
 				}
 				this.running++;
 				try {
-					const result = await task();
-					resolve(result);
+					resolve(await task());
 				} catch (err) {
 					reject(err);
 				} finally {

package/dist/utils/useful-stuff/async-queue.js.map

@@ -1 +1 @@
-{"version":3,"file":"async-queue.js","names":[],"sources":["../../../src/utils/useful-stuff/async-queue.ts"],"sourcesContent":["/**\n * Async queue implementation for processing tasks sequentially or with limited concurrency.\n * Useful for rate-limiting, batching, or controlling resource usage.\n */\n\nexport interface AsyncQueueOptions {\n  /** Maximum number of concurrent tasks. Default: 1 (sequential) */\n  concurrency?: number;\n  /** Optional callback invoked when all tasks are completed */\n  onDrain?: () => void | Promise<void>;\n  /** Optional AbortSignal for cancelling the queue */\n  signal?: AbortSignal;\n}\n\nexport type AsyncQueueTask<T> = () => Promise<T>;\n\nexport class AsyncQueue {\n  private readonly concurrency: number;\n  private readonly onDrain?: () => void | Promise<void>;\n  private readonly signal?: AbortSignal;\n  private running = 0;\n  private paused = false;\n  private aborted = false;\n  private queue: Array<() => void> = [];\n\n  constructor(options: AsyncQueueOptions = {}) {\n    this.concurrency = options.concurrency ?? 1;\n    this.onDrain = options.onDrain;\n    this.signal = options.signal;\n\n    if (this.signal) {\n      this.signal.addEventListener('abort', () => {\n        this.abort();\n      });\n    }\n  }\n\n  /**\n   * Adds a task to the queue.\n   * @param task - The async function to execute.\n   * @param signal - Optional AbortSignal for cancelling this specific task.\n   * @returns Promise resolving to the result of the task.\n   */\n  public add<T>(task: AsyncQueueTask<T>, signal?: AbortSignal): Promise<T> {\n    if (this.aborted) {\n      return Promise.reject(new Error('Queue has been aborted'));\n    }\n\n    return new Promise<T>((resolve, reject) => {\n      const run = async () => {\n        if (this.paused || this.aborted) {\n          if (this.aborted) {\n            reject(new Error('Queue has been aborted'));\n          } else {\n            this.queue.push(run);\n          }\n          return;\n        }\n\n        // Check if task-specific signal is aborted\n        if (signal?.aborted) {\n          reject(new Error('Task was aborted'));\n          return;\n        }\n\n        this.running++;\n        try {\n          const result = await task();\n          resolve(result);\n        } catch (err) {\n          reject(err);\n        } finally {\n          this.running--;\n          this.next();\n        }\n      };\n\n      if (this.running < this.concurrency && !this.paused && !this.aborted) {\n        run();\n      } else {\n        this.queue.push(run);\n      }\n    });\n  }\n\n  /**\n   * Pauses the queue. No new tasks will be started until resumed.\n   */\n  public pause() {\n    this.paused = true;\n  }\n\n  /**\n   * Resumes the queue and processes pending tasks.\n   */\n  public resume() {\n    if (!this.paused) return;\n    this.paused = false;\n    this.next();\n  }\n\n  /**\n   * Aborts the queue, rejecting all pending tasks.\n   */\n  public abort() {\n    this.aborted = true;\n    this.clear();\n  }\n\n  /**\n   * Clears all pending tasks from the queue.\n   */\n  public clear() {\n    this.queue = [];\n  }\n\n  /**\n   * Returns the number of running tasks.\n   */\n  public getRunning(): number {\n    return this.running;\n  }\n\n  /**\n   * Returns the number of pending tasks in the queue.\n   */\n  public getPending(): number {\n    return this.queue.length;\n  }\n\n  /**\n   * Returns true if the queue is currently paused.\n   */\n  public isPaused(): boolean {\n    return this.paused;\n  }\n\n  /**\n   * Returns true if the queue has been aborted.\n   */\n  public isAborted(): boolean {\n    return this.aborted;\n  }\n\n  private next() {\n    if (this.paused || this.aborted) return;\n    while (this.running < this.concurrency && this.queue.length > 0) {\n      const fn = this.queue.shift();\n      if (fn) fn();\n    }\n    if (this.running === 0 && this.queue.length === 0 && this.onDrain) {\n      this.onDrain();\n    }\n  }\n}\n\n/**\n * Creates a new async queue instance with the specified configuration.\n * @param options - Configuration options for the async queue.\n * @returns New AsyncQueue instance.\n *\n * @example\n * ```typescript\n * const controller = new AbortController();\n * const queue = createAsyncQueue({\n *   concurrency: 2,\n *   signal: controller.signal\n * });\n * queue.add(async () => await doSomething());\n * controller.abort(); // Aborts the queue\n * ```\n */\nexport function createAsyncQueue(options?: AsyncQueueOptions): AsyncQueue {\n  return new AsyncQueue(options);\n}\n"],"mappings":";;AAgBA,IAAa,aAAb,MAAwB;CACtB,AAAiB;CACjB,AAAiB;CACjB,AAAiB;CACjB,AAAQ,UAAU;CAClB,AAAQ,SAAS;CACjB,AAAQ,UAAU;CAClB,AAAQ,QAA2B,EAAE;CAErC,YAAY,UAA6B,EAAE,EAAE;AAC3C,OAAK,cAAc,QAAQ,eAAe;AAC1C,OAAK,UAAU,QAAQ;AACvB,OAAK,SAAS,QAAQ;AAEtB,MAAI,KAAK,OACP,MAAK,OAAO,iBAAiB,eAAe;AAC1C,QAAK,OAAO;IACZ;;;;;;;;CAUN,AAAO,IAAO,MAAyB,QAAkC;AACvE,MAAI,KAAK,QACP,QAAO,QAAQ,uBAAO,IAAI,MAAM,yBAAyB,CAAC;AAG5D,SAAO,IAAI,SAAY,SAAS,WAAW;GACzC,MAAM,MAAM,YAAY;AACtB,QAAI,KAAK,UAAU,KAAK,SAAS;AAC/B,SAAI,KAAK,QACP,wBAAO,IAAI,MAAM,yBAAyB,CAAC;SAE3C,MAAK,MAAM,KAAK,IAAI;AAEtB;;AAIF,wDAAI,OAAQ,SAAS;AACnB,4BAAO,IAAI,MAAM,mBAAmB,CAAC;AACrC;;AAGF,SAAK;AACL,QAAI;KACF,MAAM,SAAS,MAAM,MAAM;AAC3B,aAAQ,OAAO;aACR,KAAK;AACZ,YAAO,IAAI;cACH;AACR,UAAK;AACL,UAAK,MAAM;;;AAIf,OAAI,KAAK,UAAU,KAAK,eAAe,CAAC,KAAK,UAAU,CAAC,KAAK,QAC3D,MAAK;OAEL,MAAK,MAAM,KAAK,IAAI;IAEtB;;;;;CAMJ,AAAO,QAAQ;AACb,OAAK,SAAS;;;;;CAMhB,AAAO,SAAS;AACd,MAAI,CAAC,KAAK,OAAQ;AAClB,OAAK,SAAS;AACd,OAAK,MAAM;;;;;CAMb,AAAO,QAAQ;AACb,OAAK,UAAU;AACf,OAAK,OAAO;;;;;CAMd,AAAO,QAAQ;AACb,OAAK,QAAQ,EAAE;;;;;CAMjB,AAAO,aAAqB;AAC1B,SAAO,KAAK;;;;;CAMd,AAAO,aAAqB;AAC1B,SAAO,KAAK,MAAM;;;;;CAMpB,AAAO,WAAoB;AACzB,SAAO,KAAK;;;;;CAMd,AAAO,YAAqB;AAC1B,SAAO,KAAK;;CAGd,AAAQ,OAAO;AACb,MAAI,KAAK,UAAU,KAAK,QAAS;AACjC,SAAO,KAAK,UAAU,KAAK,eAAe,KAAK,MAAM,SAAS,GAAG;GAC/D,MAAM,KAAK,KAAK,MAAM,OAAO;AAC7B,OAAI,GAAI,KAAI;;AAEd,MAAI,KAAK,YAAY,KAAK,KAAK,MAAM,WAAW,KAAK,KAAK,QACxD,MAAK,SAAS;;;;;;;;;;;;;;;;;;;AAqBpB,SAAgB,iBAAiB,SAAyC;AACxE,QAAO,IAAI,WAAW,QAAQ"}
+{"version":3,"file":"async-queue.js","names":[],"sources":["../../../src/utils/useful-stuff/async-queue.ts"],"sourcesContent":["/**\n * Async queue implementation for processing tasks sequentially or with limited concurrency.\n * Useful for rate-limiting, batching, or controlling resource usage.\n */\n\nexport interface AsyncQueueOptions {\n  /** Maximum number of concurrent tasks. Default: 1 (sequential) */\n  concurrency?: number;\n  /** Optional callback invoked when all tasks are completed */\n  onDrain?: () => void | Promise<void>;\n  /** Optional AbortSignal for cancelling the queue */\n  signal?: AbortSignal;\n}\n\nexport type AsyncQueueTask<T> = () => Promise<T>;\n\nexport class AsyncQueue {\n  private readonly concurrency: number;\n  private readonly onDrain?: () => void | Promise<void>;\n  private readonly signal?: AbortSignal;\n  private running = 0;\n  private paused = false;\n  private aborted = false;\n  private queue: Array<() => void> = [];\n\n  constructor(options: AsyncQueueOptions = {}) {\n    this.concurrency = options.concurrency ?? 1;\n    this.onDrain = options.onDrain;\n    this.signal = options.signal;\n\n    if (this.signal) {\n      this.signal.addEventListener('abort', () => {\n        this.abort();\n      });\n    }\n  }\n\n  /**\n   * Adds a task to the queue.\n   * @param task - The async function to execute.\n   * @param signal - Optional AbortSignal for cancelling this specific task.\n   * @returns Promise resolving to the result of the task.\n   */\n  public add<T>(task: AsyncQueueTask<T>, signal?: AbortSignal): Promise<T> {\n    if (this.aborted) {\n      return Promise.reject(new Error('Queue has been aborted'));\n    }\n\n    return new Promise<T>((resolve, reject) => {\n      const run = async () => {\n        if (this.paused || this.aborted) {\n          if (this.aborted) {\n            reject(new Error('Queue has been aborted'));\n          } else {\n            this.queue.push(run);\n          }\n          return;\n        }\n\n        // Check if task-specific signal is aborted\n        if (signal?.aborted) {\n          reject(new Error('Task was aborted'));\n          return;\n        }\n\n        this.running++;\n        try {\n          const result = await task();\n          resolve(result);\n        } catch (err) {\n          reject(err);\n        } finally {\n          this.running--;\n          this.next();\n        }\n      };\n\n      if (this.running < this.concurrency && !this.paused && !this.aborted) {\n        run();\n      } else {\n        this.queue.push(run);\n      }\n    });\n  }\n\n  /**\n   * Pauses the queue. No new tasks will be started until resumed.\n   */\n  public pause() {\n    this.paused = true;\n  }\n\n  /**\n   * Resumes the queue and processes pending tasks.\n   */\n  public resume() {\n    if (!this.paused) return;\n    this.paused = false;\n    this.next();\n  }\n\n  /**\n   * Aborts the queue, rejecting all pending tasks.\n   */\n  public abort() {\n    this.aborted = true;\n    this.clear();\n  }\n\n  /**\n   * Clears all pending tasks from the queue.\n   */\n  public clear() {\n    this.queue = [];\n  }\n\n  /**\n   * Returns the number of running tasks.\n   */\n  public getRunning(): number {\n    return this.running;\n  }\n\n  /**\n   * Returns the number of pending tasks in the queue.\n   */\n  public getPending(): number {\n    return this.queue.length;\n  }\n\n  /**\n   * Returns true if the queue is currently paused.\n   */\n  public isPaused(): boolean {\n    return this.paused;\n  }\n\n  /**\n   * Returns true if the queue has been aborted.\n   */\n  public isAborted(): boolean {\n    return this.aborted;\n  }\n\n  private next() {\n    if (this.paused || this.aborted) return;\n    while (this.running < this.concurrency && this.queue.length > 0) {\n      const fn = this.queue.shift();\n      if (fn) fn();\n    }\n    if (this.running === 0 && this.queue.length === 0 && this.onDrain) {\n      this.onDrain();\n    }\n  }\n}\n\n/**\n * Creates a new async queue instance with the specified configuration.\n * @param options - Configuration options for the async queue.\n * @returns New AsyncQueue instance.\n *\n * @example\n * ```typescript\n * const controller = new AbortController();\n * const queue = createAsyncQueue({\n *   concurrency: 2,\n *   signal: controller.signal\n * });\n * queue.add(async () => await doSomething());\n * controller.abort(); // Aborts the queue\n * ```\n */\nexport function createAsyncQueue(options?: AsyncQueueOptions): AsyncQueue {\n  return new AsyncQueue(options);\n}\n"],"mappings":";;;AAgBA,IAAa,aAAb,MAAwB;CACtB,AAAiB;CACjB,AAAiB;CACjB,AAAiB;CACjB,AAAQ,UAAU;CAClB,AAAQ,SAAS;CACjB,AAAQ,UAAU;CAClB,AAAQ,QAA2B,EAAE;CAErC,YAAY,UAA6B,EAAE,EAAE;AAC3C,OAAK,cAAc,QAAQ,eAAe;AAC1C,OAAK,UAAU,QAAQ;AACvB,OAAK,SAAS,QAAQ;AAEtB,MAAI,KAAK,OACP,MAAK,OAAO,iBAAiB,eAAe;AAC1C,QAAK,OAAO;IACZ;;;;;;;;CAUN,AAAO,IAAO,MAAyB,QAAkC;AACvE,MAAI,KAAK,QACP,QAAO,QAAQ,uBAAO,IAAI,MAAM,yBAAyB,CAAC;AAG5D,SAAO,IAAI,SAAY,SAAS,WAAW;GACzC,MAAM,MAAM,YAAY;AACtB,QAAI,KAAK,UAAU,KAAK,SAAS;AAC/B,SAAI,KAAK,QACP,wBAAO,IAAI,MAAM,yBAAyB,CAAC;SAE3C,MAAK,MAAM,KAAK,IAAI;AAEtB;;AAIF,wDAAI,OAAQ,SAAS;AACnB,4BAAO,IAAI,MAAM,mBAAmB,CAAC;AACrC;;AAGF,SAAK;AACL,QAAI;AAEF,aADe,MAAM,MAAM,CACZ;aACR,KAAK;AACZ,YAAO,IAAI;cACH;AACR,UAAK;AACL,UAAK,MAAM;;;AAIf,OAAI,KAAK,UAAU,KAAK,eAAe,CAAC,KAAK,UAAU,CAAC,KAAK,QAC3D,MAAK;OAEL,MAAK,MAAM,KAAK,IAAI;IAEtB;;;;;CAMJ,AAAO,QAAQ;AACb,OAAK,SAAS;;;;;CAMhB,AAAO,SAAS;AACd,MAAI,CAAC,KAAK,OAAQ;AAClB,OAAK,SAAS;AACd,OAAK,MAAM;;;;;CAMb,AAAO,QAAQ;AACb,OAAK,UAAU;AACf,OAAK,OAAO;;;;;CAMd,AAAO,QAAQ;AACb,OAAK,QAAQ,EAAE;;;;;CAMjB,AAAO,aAAqB;AAC1B,SAAO,KAAK;;;;;CAMd,AAAO,aAAqB;AAC1B,SAAO,KAAK,MAAM;;;;;CAMpB,AAAO,WAAoB;AACzB,SAAO,KAAK;;;;;CAMd,AAAO,YAAqB;AAC1B,SAAO,KAAK;;CAGd,AAAQ,OAAO;AACb,MAAI,KAAK,UAAU,KAAK,QAAS;AACjC,SAAO,KAAK,UAAU,KAAK,eAAe,KAAK,MAAM,SAAS,GAAG;GAC/D,MAAM,KAAK,KAAK,MAAM,OAAO;AAC7B,OAAI,GAAI,KAAI;;AAEd,MAAI,KAAK,YAAY,KAAK,KAAK,MAAM,WAAW,KAAK,KAAK,QACxD,MAAK,SAAS;;;;;;;;;;;;;;;;;;;AAqBpB,SAAgB,iBAAiB,SAAyC;AACxE,QAAO,IAAI,WAAW,QAAQ"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"mutex.js","names":[],"sources":["../../../src/utils/useful-stuff/mutex.ts"],"sourcesContent":["/**\n * Async mutex implementation for coordinating access to shared resources.\n * Provides mutual exclusion to ensure only one task can access a resource at a time.\n */\n\n/**\n * Interface for mutex storage implementations.\n * Provides methods to store, retrieve, and delete mutex lock data.\n */\nexport interface MutexStorage {\n  /**\n   * Attempts to acquire a lock for a given key\n   * @param key - The unique identifier for the mutex lock\n   * @param timeout - Optional timeout in milliseconds for the lock\n   * @param signal - Optional AbortSignal for cancelling the acquisition\n   * @returns Promise resolving to true if lock was acquired, false if timeout or already locked\n   */\n  acquire(\n    key: string,\n    timeout?: number,\n    signal?: AbortSignal,\n  ): Promise<boolean>;\n\n  /**\n   * Releases the lock for a given key\n   * @param key - The unique identifier for the mutex lock\n   * @returns Promise that resolves when the lock is released\n   */\n  release(key: string): Promise<void>;\n\n  /**\n   * Checks if a lock is currently held for a given key\n   * @param key - The unique identifier for the mutex lock\n   * @returns Promise resolving to true if the lock is held, false otherwise\n   */\n  isLocked(key: string): Promise<boolean>;\n}\n\n/**\n * Configuration options for mutex\n */\nexport interface MutexOptions {\n  /** Default timeout in milliseconds for lock acquisition. Default: 30000 */\n  timeout?: number;\n  /** Storage implementation for persisting mutex data. Default: {@link MemoryMutexStorage} */\n  storage?: MutexStorage;\n}\n\n/**\n * In-memory storage implementation for mutex locks.\n * Suitable for single-instance applications.\n */\nexport class MemoryMutexStorage implements MutexStorage {\n  private readonly locks = new Map<\n    string,\n    { holder: string; acquiredAt: number }\n  >();\n\n  /**\n   * Attempts to acquire a lock for a given key\n   * @param key - The unique identifier for the mutex lock\n   * @param timeout - Optional timeout in milliseconds for the lock\n   * @param signal - Optional AbortSignal for cancelling the acquisition\n   * @returns Promise resolving to true if lock was acquired, false if timeout or already locked\n   */\n  async acquire(\n    key: string,\n    timeout: number = 30000,\n    signal?: AbortSignal,\n  ): Promise<boolean> {\n    const holder = this.generateHolderId();\n    const startTime = Date.now();\n\n    while (Date.now() - startTime < timeout) {\n      // Check if aborted\n      if (signal?.aborted) {\n        throw new Error('Lock acquisition was aborted');\n      }\n\n      if (!this.locks.has(key)) {\n        this.locks.set(key, { holder, acquiredAt: Date.now() });\n        return true;\n      }\n      await this.delay(10);\n    }\n\n    return false;\n  }\n\n  /**\n   * Releases the lock for a given key\n   * @param key - The unique identifier for the mutex lock\n   * @returns Promise that resolves when the lock is released\n   */\n  async release(key: string): Promise<void> {\n    this.locks.delete(key);\n  }\n\n  /**\n   * Checks if a lock is currently held for a given key\n   * @param key - The unique identifier for the mutex lock\n   * @returns Promise resolving to true if the lock is held, false otherwise\n   */\n  async isLocked(key: string): Promise<boolean> {\n    return this.locks.has(key);\n  }\n\n  private generateHolderId(): string {\n    return `holder_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;\n  }\n\n  private delay(ms: number): Promise<void> {\n    return new Promise((resolve) => setTimeout(resolve, ms));\n  }\n}\n\n/**\n * Async mutex implementation that provides mutual exclusion for shared resources.\n * Ensures only one task can access a protected resource at a time.\n */\nexport class Mutex {\n  private storage: MutexStorage;\n  private readonly defaultTimeout: number;\n\n  /**\n   * Creates a new mutex instance\n   * @param options - Configuration options for the mutex\n   */\n  public constructor(options: MutexOptions = {}) {\n    this.storage = options.storage || new MemoryMutexStorage();\n    this.defaultTimeout = options.timeout || 30000;\n  }\n\n  /**\n   * Sets the storage implementation for the mutex\n   * @param storage - The storage implementation to use\n   */\n  public setStorage(storage: MutexStorage) {\n    this.storage = storage;\n  }\n\n  /**\n   * Gets the storage implementation for the mutex\n   * @returns The storage implementation\n   */\n  public getStorage(): MutexStorage {\n    return this.storage;\n  }\n\n  /**\n   * Acquires a lock for the given key\n   * @param key - The unique identifier for the mutex lock\n   * @param timeout - Optional timeout in milliseconds for lock acquisition\n   * @param signal - Optional AbortSignal for cancelling the acquisition\n   * @returns Promise resolving to true if lock was acquired, false if timeout\n   */\n  public async acquire(\n    key: string,\n    timeout?: number,\n    signal?: AbortSignal,\n  ): Promise<boolean> {\n    return this.storage.acquire(key, timeout || this.defaultTimeout, signal);\n  }\n\n  /**\n   * Releases the lock for the given key\n   * @param key - The unique identifier for the mutex lock\n   * @returns Promise that resolves when the lock is released\n   */\n  public async release(key: string): Promise<void> {\n    return this.storage.release(key);\n  }\n\n  /**\n   * Checks if a lock is currently held for the given key\n   * @param key - The unique identifier for the mutex lock\n   * @returns Promise resolving to true if the lock is held, false otherwise\n   */\n  public async isLocked(key: string): Promise<boolean> {\n    return this.storage.isLocked(key);\n  }\n\n  /**\n   * Executes a function with exclusive access to the resource\n   * @param key - The unique identifier for the mutex lock\n   * @param fn - The function to execute with exclusive access\n   * @param timeout - Optional timeout in milliseconds for lock acquisition\n   * @param signal - Optional AbortSignal for cancelling the lock acquisition\n   * @returns Promise resolving to the result of the function execution\n   * @throws Error if lock acquisition fails or function execution fails\n   */\n  public async withLock<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 lock 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 mutex\n   * @returns Object containing the current timeout value\n   */\n  public getConfig(): Omit<MutexOptions, 'storage'> {\n    return {\n      timeout: this.defaultTimeout,\n    };\n  }\n}\n\n/**\n * Default mutex instance for global use\n */\nexport const defaultMutex = new Mutex();\n\n/**\n * Convenience function to execute a function with exclusive access using the default mutex.\n *\n * @param key - The unique identifier for the mutex lock\n * @param fn - The function to execute with exclusive access\n * @param timeout - Optional timeout in milliseconds for lock acquisition\n * @param signal - Optional AbortSignal for cancelling the lock 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 withMutex('shared-resource', async () => {\n *   // This code runs with exclusive access\n *   return await updateSharedResource();\n * }, 30000, controller.signal);\n * controller.abort(); // Cancels the lock acquisition\n * ```\n */\nexport async function withMutex<T>(\n  key: string,\n  fn: () => Promise<T> | T,\n  timeout?: number,\n  signal?: AbortSignal,\n): Promise<T> {\n  return defaultMutex.withLock(key, fn, timeout, signal);\n}\n\n/**\n * Creates a new mutex instance with the specified configuration\n * @param options - Configuration options for the mutex\n * @returns New Mutex instance\n *\n * @example\n * ```typescript\n * const mutex = createMutex({\n *   timeout: 60000,\n *   storage: new RedisMutexStorage()\n * });\n * ```\n */\nexport function createMutex(options: MutexOptions): Mutex {\n  return new Mutex(options);\n}\n\n/**\n * Acquires a lock using the default mutex\n * @param key - The unique identifier for the mutex lock\n * @param timeout - Optional timeout in milliseconds for lock acquisition\n * @param signal - Optional AbortSignal for cancelling the acquisition\n * @returns Promise resolving to true if lock was acquired, false if timeout\n */\nexport async function acquireLock(\n  key: string,\n  timeout?: number,\n  signal?: AbortSignal,\n): Promise<boolean> {\n  return defaultMutex.acquire(key, timeout, signal);\n}\n\n/**\n * Releases a lock using the default mutex\n * @param key - The unique identifier for the mutex lock\n * @returns Promise that resolves when the lock is released\n */\nexport async function releaseLock(key: string): Promise<void> {\n  return defaultMutex.release(key);\n}\n\n/**\n * Checks if a lock is held using the default mutex\n * @param key - The unique identifier for the mutex lock\n * @returns Promise resolving to true if the lock is held, false otherwise\n */\nexport async function isLocked(key: string): Promise<boolean> {\n  return defaultMutex.isLocked(key);\n}\n"],"mappings":";;;;;;AAoDA,IAAa,qBAAb,MAAwD;CACtD,AAAiB,wBAAQ,IAAI,KAG5B;;;;;;;;CASD,MAAM,QACN,KACA,UAAkB,KAClB,QACmB;EACjB,MAAM,SAAS,KAAK,kBAAkB;EACtC,MAAM,YAAY,KAAK,KAAK;AAE5B,SAAO,KAAK,KAAK,GAAG,YAAY,SAAS;AAEvC,uDAAI,OAAQ,QACV,OAAM,IAAI,MAAM,+BAA+B;AAGjD,OAAI,CAAC,KAAK,MAAM,IAAI,IAAI,EAAE;AACxB,SAAK,MAAM,IAAI,KAAK;KAAE;KAAQ,YAAY,KAAK,KAAK;KAAE,CAAC;AACvD,WAAO;;AAET,SAAM,KAAK,MAAM,GAAG;;AAGtB,SAAO;;;;;;;CAQT,MAAM,QAAQ,KAA4B;AACxC,OAAK,MAAM,OAAO,IAAI;;;;;;;CAQxB,MAAM,SAAS,KAA+B;AAC5C,SAAO,KAAK,MAAM,IAAI,IAAI;;CAG5B,AAAQ,mBAA2B;AACjC,SAAO,UAAU,KAAK,KAAK,CAAC,GAAG,KAAK,QAAQ,CAAC,SAAS,GAAG,CAAC,OAAO,GAAG,EAAE;;CAGxE,AAAQ,MAAM,IAA2B;AACvC,SAAO,IAAI,SAAS,YAAY,WAAW,SAAS,GAAG,CAAC;;;;;;;AAQ5D,IAAa,QAAb,MAAmB;CACjB,AAAQ;CACR,AAAiB;;;;;CAMjB,AAAO,YAAY,UAAwB,EAAE,EAAE;AAC7C,OAAK,UAAU,QAAQ,WAAW,IAAI,oBAAoB;AAC1D,OAAK,iBAAiB,QAAQ,WAAW;;;;;;CAO3C,AAAO,WAAW,SAAuB;AACvC,OAAK,UAAU;;;;;;CAOjB,AAAO,aAA2B;AAChC,SAAO,KAAK;;;;;;;;;CAUd,MAAa,QACb,KACA,SACA,QACmB;AACjB,SAAO,KAAK,QAAQ,QAAQ,KAAK,WAAW,KAAK,gBAAgB,OAAO;;;;;;;CAQ1E,MAAa,QAAQ,KAA4B;AAC/C,SAAO,KAAK,QAAQ,QAAQ,IAAI;;;;;;;CAQlC,MAAa,SAAS,KAA+B;AACnD,SAAO,KAAK,QAAQ,SAAS,IAAI;;;;;;;;;;;CAYnC,MAAa,SACb,KACA,IACA,SACA,QACa;AAEX,MAAI,CADa,MAAM,KAAK,QAAQ,KAAK,SAAS,OAAO,CAEvD,OAAM,IAAI,MAAM,mCAAmC,MAAM;AAG3D,MAAI;AACF,UAAO,MAAM,IAAI;YACT;AACR,SAAM,KAAK,QAAQ,IAAI;;;;;;;CAQ3B,AAAO,YAA2C;AAChD,SAAO,EACL,SAAS,KAAK,gBACf;;;;;;AAOL,MAAa,eAAe,IAAI,OAAO;;;;;;;;;;;;;;;;;;;;AAqBvC,eAAsB,UACtB,KACA,IACA,SACA,QACa;AACX,QAAO,aAAa,SAAS,KAAK,IAAI,SAAS,OAAO;;;;;;;;;;;;;;;AAgBxD,SAAgB,YAAY,SAA8B;AACxD,QAAO,IAAI,MAAM,QAAQ;;;;;;;;;AAU3B,eAAsB,YACtB,KACA,SACA,QACmB;AACjB,QAAO,aAAa,QAAQ,KAAK,SAAS,OAAO;;;;;;;AAQnD,eAAsB,YAAY,KAA4B;AAC5D,QAAO,aAAa,QAAQ,IAAI;;;;;;;AAQlC,eAAsB,SAAS,KAA+B;AAC5D,QAAO,aAAa,SAAS,IAAI"}
+{"version":3,"file":"mutex.js","names":[],"sources":["../../../src/utils/useful-stuff/mutex.ts"],"sourcesContent":["/**\n * Async mutex implementation for coordinating access to shared resources.\n * Provides mutual exclusion to ensure only one task can access a resource at a time.\n */\n\n/**\n * Interface for mutex storage implementations.\n * Provides methods to store, retrieve, and delete mutex lock data.\n */\nexport interface MutexStorage {\n  /**\n   * Attempts to acquire a lock for a given key\n   * @param key - The unique identifier for the mutex lock\n   * @param timeout - Optional timeout in milliseconds for the lock\n   * @param signal - Optional AbortSignal for cancelling the acquisition\n   * @returns Promise resolving to true if lock was acquired, false if timeout or already locked\n   */\n  acquire(\n    key: string,\n    timeout?: number,\n    signal?: AbortSignal,\n  ): Promise<boolean>;\n\n  /**\n   * Releases the lock for a given key\n   * @param key - The unique identifier for the mutex lock\n   * @returns Promise that resolves when the lock is released\n   */\n  release(key: string): Promise<void>;\n\n  /**\n   * Checks if a lock is currently held for a given key\n   * @param key - The unique identifier for the mutex lock\n   * @returns Promise resolving to true if the lock is held, false otherwise\n   */\n  isLocked(key: string): Promise<boolean>;\n}\n\n/**\n * Configuration options for mutex\n */\nexport interface MutexOptions {\n  /** Default timeout in milliseconds for lock acquisition. Default: 30000 */\n  timeout?: number;\n  /** Storage implementation for persisting mutex data. Default: {@link MemoryMutexStorage} */\n  storage?: MutexStorage;\n}\n\n/**\n * In-memory storage implementation for mutex locks.\n * Suitable for single-instance applications.\n */\nexport class MemoryMutexStorage implements MutexStorage {\n  private readonly locks = new Map<\n    string,\n    { holder: string; acquiredAt: number }\n  >();\n\n  /**\n   * Attempts to acquire a lock for a given key\n   * @param key - The unique identifier for the mutex lock\n   * @param timeout - Optional timeout in milliseconds for the lock\n   * @param signal - Optional AbortSignal for cancelling the acquisition\n   * @returns Promise resolving to true if lock was acquired, false if timeout or already locked\n   */\n  async acquire(\n    key: string,\n    timeout: number = 30000,\n    signal?: AbortSignal,\n  ): Promise<boolean> {\n    const holder = this.generateHolderId();\n    const startTime = Date.now();\n\n    while (Date.now() - startTime < timeout) {\n      // Check if aborted\n      if (signal?.aborted) {\n        throw new Error('Lock acquisition was aborted');\n      }\n\n      if (!this.locks.has(key)) {\n        this.locks.set(key, { holder, acquiredAt: Date.now() });\n        return true;\n      }\n      await this.delay(10);\n    }\n\n    return false;\n  }\n\n  /**\n   * Releases the lock for a given key\n   * @param key - The unique identifier for the mutex lock\n   * @returns Promise that resolves when the lock is released\n   */\n  async release(key: string): Promise<void> {\n    this.locks.delete(key);\n  }\n\n  /**\n   * Checks if a lock is currently held for a given key\n   * @param key - The unique identifier for the mutex lock\n   * @returns Promise resolving to true if the lock is held, false otherwise\n   */\n  async isLocked(key: string): Promise<boolean> {\n    return this.locks.has(key);\n  }\n\n  private generateHolderId(): string {\n    return `holder_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;\n  }\n\n  private delay(ms: number): Promise<void> {\n    return new Promise((resolve) => setTimeout(resolve, ms));\n  }\n}\n\n/**\n * Async mutex implementation that provides mutual exclusion for shared resources.\n * Ensures only one task can access a protected resource at a time.\n */\nexport class Mutex {\n  private storage: MutexStorage;\n  private readonly defaultTimeout: number;\n\n  /**\n   * Creates a new mutex instance\n   * @param options - Configuration options for the mutex\n   */\n  public constructor(options: MutexOptions = {}) {\n    this.storage = options.storage || new MemoryMutexStorage();\n    this.defaultTimeout = options.timeout || 30000;\n  }\n\n  /**\n   * Sets the storage implementation for the mutex\n   * @param storage - The storage implementation to use\n   */\n  public setStorage(storage: MutexStorage) {\n    this.storage = storage;\n  }\n\n  /**\n   * Gets the storage implementation for the mutex\n   * @returns The storage implementation\n   */\n  public getStorage(): MutexStorage {\n    return this.storage;\n  }\n\n  /**\n   * Acquires a lock for the given key\n   * @param key - The unique identifier for the mutex lock\n   * @param timeout - Optional timeout in milliseconds for lock acquisition\n   * @param signal - Optional AbortSignal for cancelling the acquisition\n   * @returns Promise resolving to true if lock was acquired, false if timeout\n   */\n  public async acquire(\n    key: string,\n    timeout?: number,\n    signal?: AbortSignal,\n  ): Promise<boolean> {\n    return this.storage.acquire(key, timeout || this.defaultTimeout, signal);\n  }\n\n  /**\n   * Releases the lock for the given key\n   * @param key - The unique identifier for the mutex lock\n   * @returns Promise that resolves when the lock is released\n   */\n  public async release(key: string): Promise<void> {\n    return this.storage.release(key);\n  }\n\n  /**\n   * Checks if a lock is currently held for the given key\n   * @param key - The unique identifier for the mutex lock\n   * @returns Promise resolving to true if the lock is held, false otherwise\n   */\n  public async isLocked(key: string): Promise<boolean> {\n    return this.storage.isLocked(key);\n  }\n\n  /**\n   * Executes a function with exclusive access to the resource\n   * @param key - The unique identifier for the mutex lock\n   * @param fn - The function to execute with exclusive access\n   * @param timeout - Optional timeout in milliseconds for lock acquisition\n   * @param signal - Optional AbortSignal for cancelling the lock acquisition\n   * @returns Promise resolving to the result of the function execution\n   * @throws Error if lock acquisition fails or function execution fails\n   */\n  public async withLock<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 lock 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 mutex\n   * @returns Object containing the current timeout value\n   */\n  public getConfig(): Omit<MutexOptions, 'storage'> {\n    return {\n      timeout: this.defaultTimeout,\n    };\n  }\n}\n\n/**\n * Default mutex instance for global use\n */\nexport const defaultMutex = new Mutex();\n\n/**\n * Convenience function to execute a function with exclusive access using the default mutex.\n *\n * @param key - The unique identifier for the mutex lock\n * @param fn - The function to execute with exclusive access\n * @param timeout - Optional timeout in milliseconds for lock acquisition\n * @param signal - Optional AbortSignal for cancelling the lock 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 withMutex('shared-resource', async () => {\n *   // This code runs with exclusive access\n *   return await updateSharedResource();\n * }, 30000, controller.signal);\n * controller.abort(); // Cancels the lock acquisition\n * ```\n */\nexport async function withMutex<T>(\n  key: string,\n  fn: () => Promise<T> | T,\n  timeout?: number,\n  signal?: AbortSignal,\n): Promise<T> {\n  return defaultMutex.withLock(key, fn, timeout, signal);\n}\n\n/**\n * Creates a new mutex instance with the specified configuration\n * @param options - Configuration options for the mutex\n * @returns New Mutex instance\n *\n * @example\n * ```typescript\n * const mutex = createMutex({\n *   timeout: 60000,\n *   storage: new RedisMutexStorage()\n * });\n * ```\n */\nexport function createMutex(options: MutexOptions): Mutex {\n  return new Mutex(options);\n}\n\n/**\n * Acquires a lock using the default mutex\n * @param key - The unique identifier for the mutex lock\n * @param timeout - Optional timeout in milliseconds for lock acquisition\n * @param signal - Optional AbortSignal for cancelling the acquisition\n * @returns Promise resolving to true if lock was acquired, false if timeout\n */\nexport async function acquireLock(\n  key: string,\n  timeout?: number,\n  signal?: AbortSignal,\n): Promise<boolean> {\n  return defaultMutex.acquire(key, timeout, signal);\n}\n\n/**\n * Releases a lock using the default mutex\n * @param key - The unique identifier for the mutex lock\n * @returns Promise that resolves when the lock is released\n */\nexport async function releaseLock(key: string): Promise<void> {\n  return defaultMutex.release(key);\n}\n\n/**\n * Checks if a lock is held using the default mutex\n * @param key - The unique identifier for the mutex lock\n * @returns Promise resolving to true if the lock is held, false otherwise\n */\nexport async function isLocked(key: string): Promise<boolean> {\n  return defaultMutex.isLocked(key);\n}\n"],"mappings":";;;;;;;AAoDA,IAAa,qBAAb,MAAwD;CACtD,AAAiB,wBAAQ,IAAI,KAG5B;;;;;;;;CASD,MAAM,QACN,KACA,UAAkB,KAClB,QACmB;EACjB,MAAM,SAAS,KAAK,kBAAkB;EACtC,MAAM,YAAY,KAAK,KAAK;AAE5B,SAAO,KAAK,KAAK,GAAG,YAAY,SAAS;AAEvC,uDAAI,OAAQ,QACV,OAAM,IAAI,MAAM,+BAA+B;AAGjD,OAAI,CAAC,KAAK,MAAM,IAAI,IAAI,EAAE;AACxB,SAAK,MAAM,IAAI,KAAK;KAAE;KAAQ,YAAY,KAAK,KAAK;KAAE,CAAC;AACvD,WAAO;;AAET,SAAM,KAAK,MAAM,GAAG;;AAGtB,SAAO;;;;;;;CAQT,MAAM,QAAQ,KAA4B;AACxC,OAAK,MAAM,OAAO,IAAI;;;;;;;CAQxB,MAAM,SAAS,KAA+B;AAC5C,SAAO,KAAK,MAAM,IAAI,IAAI;;CAG5B,AAAQ,mBAA2B;AACjC,SAAO,UAAU,KAAK,KAAK,CAAC,GAAG,KAAK,QAAQ,CAAC,SAAS,GAAG,CAAC,OAAO,GAAG,EAAE;;CAGxE,AAAQ,MAAM,IAA2B;AACvC,SAAO,IAAI,SAAS,YAAY,WAAW,SAAS,GAAG,CAAC;;;;;;;AAQ5D,IAAa,QAAb,MAAmB;CACjB,AAAQ;CACR,AAAiB;;;;;CAMjB,AAAO,YAAY,UAAwB,EAAE,EAAE;AAC7C,OAAK,UAAU,QAAQ,WAAW,IAAI,oBAAoB;AAC1D,OAAK,iBAAiB,QAAQ,WAAW;;;;;;CAO3C,AAAO,WAAW,SAAuB;AACvC,OAAK,UAAU;;;;;;CAOjB,AAAO,aAA2B;AAChC,SAAO,KAAK;;;;;;;;;CAUd,MAAa,QACb,KACA,SACA,QACmB;AACjB,SAAO,KAAK,QAAQ,QAAQ,KAAK,WAAW,KAAK,gBAAgB,OAAO;;;;;;;CAQ1E,MAAa,QAAQ,KAA4B;AAC/C,SAAO,KAAK,QAAQ,QAAQ,IAAI;;;;;;;CAQlC,MAAa,SAAS,KAA+B;AACnD,SAAO,KAAK,QAAQ,SAAS,IAAI;;;;;;;;;;;CAYnC,MAAa,SACb,KACA,IACA,SACA,QACa;AAEX,MAAI,CADa,MAAM,KAAK,QAAQ,KAAK,SAAS,OAAO,CAEvD,OAAM,IAAI,MAAM,mCAAmC,MAAM;AAG3D,MAAI;AACF,UAAO,MAAM,IAAI;YACT;AACR,SAAM,KAAK,QAAQ,IAAI;;;;;;;CAQ3B,AAAO,YAA2C;AAChD,SAAO,EACL,SAAS,KAAK,gBACf;;;;;;AAOL,MAAa,eAAe,IAAI,OAAO;;;;;;;;;;;;;;;;;;;;AAqBvC,eAAsB,UACtB,KACA,IACA,SACA,QACa;AACX,QAAO,aAAa,SAAS,KAAK,IAAI,SAAS,OAAO;;;;;;;;;;;;;;;AAgBxD,SAAgB,YAAY,SAA8B;AACxD,QAAO,IAAI,MAAM,QAAQ;;;;;;;;;AAU3B,eAAsB,YACtB,KACA,SACA,QACmB;AACjB,QAAO,aAAa,QAAQ,KAAK,SAAS,OAAO;;;;;;;AAQnD,eAAsB,YAAY,KAA4B;AAC5D,QAAO,aAAa,QAAQ,IAAI;;;;;;;AAQlC,eAAsB,SAAS,KAA+B;AAC5D,QAAO,aAAa,SAAS,IAAI"}

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

@@ -1,3 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 //#region src/utils/useful-stuff/ratelimiter.ts
 /**
@@ -81,8 +82,7 @@ var RateLimiter = class {
 	*/
 	async limit(key) {
 		const now = Date.now();
-		const lastReset = this.lastReset.get(key) || 0;
-		if (now - lastReset > this.resetInterval) {
+		if (now - (this.lastReset.get(key) || 0) > this.resetInterval) {
 			await this.storage.delete(key);
 			this.lastReset.set(key, now);
 			this.limits.set(key, 0);

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;EACtB,MAAM,YAAY,KAAK,UAAU,IAAI,IAAI,IAAI;AAI7C,MAHuB,MAAM,YAGR,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.js

@@ -1,3 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 //#region src/utils/useful-stuff/semaphore.ts
 /**
@@ -142,9 +143,7 @@ var Semaphore = class {
 	* @returns Promise resolving to the number of acquired permits
 	*/
 	async getAcquiredPermits(key) {
-		const total = await this.getTotalPermits(key);
-		const available = await this.getAvailablePermits(key);
-		return total - available;
+		return await this.getTotalPermits(key) - await this.getAvailablePermits(key);
 	}
 	/**
 	* Executes a function with a permit from the semaphore

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":"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"}

package/dist/utils/utilities.d.ts

@@ -1,2 +1,113 @@
-import { JsonSerialize, SimpleProxy, createProxy, debounce, defer, devOnly, findAppDirectory, getCurrentDirectory, getSourceDirectories } from "../utilities-DtdPlr4c.js";
-export { JsonSerialize, SimpleProxy, createProxy, debounce, defer, devOnly, findAppDirectory, getCurrentDirectory, getSourceDirectories };
+//#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,45 +1,13 @@
-require('../colors-DL3ucTiT.js');
-require('../ActionRow-CbdGFWMT.js');
-require('../error-codes-Ds0bnPvT.js');
-const require_commandkit = require('../commandkit-Bm0gLN8i.js');
-require('../common-CcfjYnPG.js');
-require('../common-vnMIelAE.js');
-require('../container-C6GtfAPW.js');
-require('../file-DVOELoNv.js');
-require('../media-gallery-zDtJ3kxb.js');
-require('../section-DlvrDoJK.js');
-require('../separator-DL6QH5H1.js');
-require('../text-display-DbMumig_.js');
-require('../v2-DofkPKHs.js');
-require('../element-Bak9llw_.js');
-require('../types-CUZOquUl.js');
-require('../EventInterceptor-CQEXyUTp.js');
-require('../constants-B5_Ta7PR.js');
-require('../PluginCommon-Cvl5yYM_.js');
-require('../CompilerPlugin-M8r3yNAl.js');
-require('../RuntimePlugin-BUecuBIU.js');
-require('../types-q0Nm882H.js');
-require('../resolve-file-url-ChIyw-Vf.js');
-require('../runtime-DB9CiPfe.js');
-require('../utils-KsNof0Xz.js');
-require('../types-package-BWArjyBF.js');
-require('../constants-BOOGN85p.js');
-require('../EventWorkerContext-Dq29tieI.js');
-require('../signals-ChFMD7mB.js');
-require('../MessageCommandParser-CEuO6Ex3.js');
-require('../helpers-BSwwrKJW.js');
-require('../CommandsRouter-Cgcy6cK9.js');
-require('../EventsRouter-3Gygh-km.js');
-require('../router-Dn35v30f.js');
-require('../common-Dxr9-XPa.js');
-require('../CommandKitEventsChannel-BtRzr3Tz.js');
-require('../store-CM6pWVZh.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;
 exports.createProxy = require_commandkit.createProxy;
 exports.debounce = require_commandkit.debounce;
 exports.defer = require_commandkit.defer;
 exports.devOnly = require_commandkit.devOnly;
 exports.findAppDirectory = require_commandkit.findAppDirectory;
 exports.getCurrentDirectory = require_commandkit.getCurrentDirectory;
-exports.getSourceDirectories = require_commandkit.getSourceDirectories;
+exports.getSourceDirectories = require_commandkit.getSourceDirectories;
+exports.noBuildOnly = require_commandkit.noBuildOnly;