bakit 1.0.0-beta.1 → 1.0.0-beta.3

package/dist/{BakitClient-BWxRFtSg.d.ts → BakitClient-BWs93qO-.d.ts}

@@ -31,13 +31,15 @@ declare class MessageContext<Cached extends boolean = boolean, InGuild extends b
 type Context<Cached extends boolean = boolean, InGuild extends boolean = boolean> = ChatInputContext<Cached, InGuild> | MessageContext<Cached, InGuild>;
 
 type CommandConstructor = new (...args: unknown[]) => object;
-declare abstract class Command {
-    static create(options: CreateOptions<BaseCommandEntryOptions>): RootCommandEntry;
-    static use(command: RootCommandEntry): (target: CommandConstructor) => void;
-    static getRoot(constructor: CommandConstructor): RootCommandEntry | undefined;
-}
+declare function use(command: RootCommandEntry): (target: CommandConstructor) => void;
+declare function getRoot(constructor: CommandConstructor): RootCommandEntry | undefined;
+declare function CommandFactory(options: CreateCommandOptions<BaseCommandEntryOptions> | string): RootCommandEntry;
+declare const Command: typeof CommandFactory & {
+    use: typeof use;
+    getRoot: typeof getRoot;
+};
 
-declare enum HookExecutionState {
+declare enum CommandHookExecutionState {
     Main = "main",
     Pre = "pre",
     Post = "post",
@@ -45,7 +47,7 @@ declare enum HookExecutionState {
 }
 type CommandHookMethod = (ctx: Context, ...args: any[]) => Awaitable<void>;
 interface CommandHook {
-    state: HookExecutionState;
+    state: CommandHookExecutionState;
     method: CommandHookMethod;
     entry: CommandEntry;
 }
@@ -54,7 +56,7 @@ interface BaseCommandEntryOptions {
     description: string;
     nsfw?: boolean;
 }
-type CreateOptions<T extends BaseCommandEntryOptions> = SetOptional<T, "description"> | string;
+type CreateCommandOptions<T extends BaseCommandEntryOptions> = SetOptional<T, "description"> | string;
 declare const HOOKS_KEY: unique symbol;
 declare abstract class BaseCommandEntry {
     options: BaseCommandEntryOptions;
@@ -72,7 +74,7 @@ declare abstract class BaseCommandEntry {
 }
 declare abstract class BaseCommandGroupEntry extends BaseCommandEntry {
     children: Collection<string, CommandGroupEntry | SubcommandEntry>;
-    subcommand(options: CreateOptions<BaseCommandEntryOptions>): SubcommandEntry;
+    subcommand(options: CreateCommandOptions<BaseCommandEntryOptions>): SubcommandEntry;
 }
 declare class CommandGroupEntry extends BaseCommandGroupEntry {
     options: BaseCommandEntryOptions;
@@ -83,7 +85,7 @@ declare class CommandGroupEntry extends BaseCommandGroupEntry {
 declare class RootCommandEntry extends BaseCommandGroupEntry {
     options: BaseCommandEntryOptions;
     constructor(options: BaseCommandEntryOptions);
-    group(options: CreateOptions<BaseCommandEntryOptions>): CommandGroupEntry;
+    group(options: CreateCommandOptions<BaseCommandEntryOptions>): CommandGroupEntry;
 }
 declare class SubcommandEntry extends BaseCommandEntry {
     options: BaseCommandEntryOptions;
@@ -129,19 +131,22 @@ interface MemberArgumentOptions extends BaseArgumentOptions {
 }
 type ArgumentOptions = StringArgumentOptions | IntegerArgumentOptions | NumberArgumentOptions | UserArgumentOptions | MemberArgumentOptions;
 
-declare abstract class Arg {
-    private static cache;
-    static string: (options: string | Omit<StringArgumentOptions, "type">) => (target: object, key: string | symbol, _index: number) => void;
-    static integer: (options: string | Omit<IntegerArgumentOptions, "type">) => (target: object, key: string | symbol, _index: number) => void;
-    static number: (options: string | Omit<NumberArgumentOptions, "type">) => (target: object, key: string | symbol, _index: number) => void;
-    static user: (options: string | Omit<UserArgumentOptions, "type">) => (target: object, key: string | symbol, _index: number) => void;
-    static member: (options: string | Omit<MemberArgumentOptions, "type">) => (target: object, key: string | symbol, _index: number) => void;
-    static getMethodArguments(method: CommandHook["method"]): readonly ArgumentOptions[];
-    static getMethodArguments(method: CommandHook["method"], init: true): ArgumentOptions[];
-    static format(arg: ArgumentOptions): string;
-    static describeArgumentExpectation(arg: ArgumentOptions): string;
-    protected static createArgument<Options extends ArgumentOptions>(type: Options["type"]): (options: Omit<Options, "type"> | string) => (target: object, key: string | symbol, _index: number) => void;
-}
+declare function getMethodArguments(method: CommandHook["method"]): readonly ArgumentOptions[];
+declare function getMethodArguments(method: CommandHook["method"], init: true): ArgumentOptions[];
+declare function createArgument<Options extends ArgumentOptions>(type: Options["type"]): (options: Omit<Options, "type"> | string) => (target: object, key: string | symbol, _index: number) => void;
+declare function describeArgumentExpectation(arg: ArgumentOptions): string;
+declare function format(arg: ArgumentOptions): string;
+declare const Arg: {
+    getMethodArguments: typeof getMethodArguments;
+    createArgument: typeof createArgument;
+    describeArgumentExpectation: typeof describeArgumentExpectation;
+    format: typeof format;
+    string: (options: string | Omit<StringArgumentOptions, "type">) => (target: object, key: string | symbol, _index: number) => void;
+    number: (options: string | Omit<NumberArgumentOptions, "type">) => (target: object, key: string | symbol, _index: number) => void;
+    integer: (options: string | Omit<IntegerArgumentOptions, "type">) => (target: object, key: string | symbol, _index: number) => void;
+    user: (options: string | Omit<UserArgumentOptions, "type">) => (target: object, key: string | symbol, _index: number) => void;
+    member: (options: string | Omit<MemberArgumentOptions, "type">) => (target: object, key: string | symbol, _index: number) => void;
+};
 
 declare class CommandRegistry {
     static constructors: Collection<string, CommandConstructor>;
@@ -196,4 +201,4 @@ declare class BakitClient<Ready extends boolean = boolean> extends Client<Ready>
     private createHookRecord;
 }
 
-export { Arg as A, type BakitClientOptions as B, type CommandHookMethod as C, type GetSyntaxErrorMessageFunction as G, HookExecutionState as H, type IntegerArgumentOptions as I, type MemberArgumentOptions as M, type NumberArgumentOptions as N, RootCommandEntry as R, type StringArgumentOptions as S, type UserArgumentOptions as U, BakitClient as a, ArgumentType as b, type BaseArgumentOptions as c, type ArgumentOptions as d, type CommandHook as e, type BaseCommandEntryOptions as f, type CreateOptions as g, HOOKS_KEY as h, BaseCommandEntry as i, BaseCommandGroupEntry as j, CommandGroupEntry as k, SubcommandEntry as l, type CommandEntry as m, type CommandConstructor as n, Command as o, CommandRegistry as p, type ChatInputContextSendOptions as q, type MessageContextSendOptions as r, type ContextSendOptions as s, BaseContext as t, ChatInputContext as u, MessageContext as v, type Context as w, CommandSyntaxErrorType as x, type CommandSyntaxErrorOptions as y, CommandSyntaxError as z };
+export { Arg as A, type BakitClientOptions as B, CommandHookExecutionState as C, CommandSyntaxErrorType as D, type CommandSyntaxErrorOptions as E, CommandSyntaxError as F, type GetSyntaxErrorMessageFunction as G, HOOKS_KEY as H, type IntegerArgumentOptions as I, type MemberArgumentOptions as M, type NumberArgumentOptions as N, RootCommandEntry as R, type StringArgumentOptions as S, type UserArgumentOptions as U, BakitClient as a, ArgumentType as b, type BaseArgumentOptions as c, type ArgumentOptions as d, type CommandHookMethod as e, type CommandHook as f, type BaseCommandEntryOptions as g, type CreateCommandOptions as h, BaseCommandEntry as i, BaseCommandGroupEntry as j, CommandGroupEntry as k, SubcommandEntry as l, type CommandEntry as m, type CommandConstructor as n, getRoot as o, CommandFactory as p, Command as q, CommandRegistry as r, type ChatInputContextSendOptions as s, type MessageContextSendOptions as t, use as u, type ContextSendOptions as v, BaseContext as w, ChatInputContext as x, MessageContext as y, type Context as z };

package/dist/command/index.d.ts

@@ -1,3 +1,3 @@
-export { A as Arg, d as ArgumentOptions, b as ArgumentType, c as BaseArgumentOptions, i as BaseCommandEntry, f as BaseCommandEntryOptions, j as BaseCommandGroupEntry, t as BaseContext, u as ChatInputContext, q as ChatInputContextSendOptions, o as Command, n as CommandConstructor, m as CommandEntry, k as CommandGroupEntry, e as CommandHook, C as CommandHookMethod, p as CommandRegistry, w as Context, s as ContextSendOptions, g as CreateOptions, h as HOOKS_KEY, H as HookExecutionState, I as IntegerArgumentOptions, M as MemberArgumentOptions, v as MessageContext, r as MessageContextSendOptions, N as NumberArgumentOptions, R as RootCommandEntry, S as StringArgumentOptions, l as SubcommandEntry, U as UserArgumentOptions } from '../BakitClient-BWxRFtSg.js';
+export { A as Arg, d as ArgumentOptions, b as ArgumentType, c as BaseArgumentOptions, i as BaseCommandEntry, g as BaseCommandEntryOptions, j as BaseCommandGroupEntry, w as BaseContext, x as ChatInputContext, s as ChatInputContextSendOptions, q as Command, n as CommandConstructor, m as CommandEntry, p as CommandFactory, k as CommandGroupEntry, f as CommandHook, C as CommandHookExecutionState, e as CommandHookMethod, r as CommandRegistry, z as Context, v as ContextSendOptions, h as CreateCommandOptions, H as HOOKS_KEY, I as IntegerArgumentOptions, M as MemberArgumentOptions, y as MessageContext, t as MessageContextSendOptions, N as NumberArgumentOptions, R as RootCommandEntry, S as StringArgumentOptions, l as SubcommandEntry, U as UserArgumentOptions, o as getRoot, u as use } from '../BakitClient-BWs93qO-.js';
 import 'discord.js';
 import 'type-fest';

package/dist/command/index.js

@@ -13,97 +13,106 @@ var ArgumentType = /* @__PURE__ */ ((ArgumentType2) => {
 
 // src/command/argument/Arg.ts
 var ARGS_KEY = Symbol("args");
-var Arg = class _Arg {
-  static cache = /* @__PURE__ */ new WeakMap();
-  static string = _Arg.createArgument("string" /* String */);
-  static integer = _Arg.createArgument("integer" /* Integer */);
-  static number = _Arg.createArgument("number" /* Number */);
-  static user = _Arg.createArgument("user" /* User */);
-  static member = _Arg.createArgument("member" /* Member */);
-  static getMethodArguments(method, init = false) {
-    let args = this.cache.get(method) ?? Reflect.getMetadata(ARGS_KEY, method);
-    if (!args) {
-      args = [];
-      if (init) {
-        Reflect.defineMetadata(ARGS_KEY, args, method);
-        this.cache.set(method, args);
-      }
+var cache = /* @__PURE__ */ new WeakMap();
+function getMethodArguments(method, init = false) {
+  let args = cache.get(method) ?? Reflect.getMetadata(ARGS_KEY, method);
+  if (!args) {
+    args = [];
+    if (init) {
+      Reflect.defineMetadata(ARGS_KEY, args, method);
+      cache.set(method, args);
     }
-    return init ? args : Object.freeze([...args]);
   }
-  static format(arg) {
-    const { name, required, tuple } = arg;
-    const opening = required ? "<" : "[";
-    const closing = required ? ">" : "]";
-    const prefix = tuple ? "..." : "";
-    return `${opening}${prefix}${name}: ${this.describeArgumentExpectation(arg)}${closing}`;
-  }
-  static describeArgumentExpectation(arg) {
-    const parts = [arg.type];
-    switch (arg.type) {
-      case "string" /* String */: {
-        if (arg.minLength && !arg.maxLength) {
-          parts.push(`\u2265 ${String(arg.minLength)}`);
-        }
-        if (!arg.minLength && arg.maxLength) {
-          parts.push(`\u2264 ${String(arg.maxLength)}`);
-        }
-        if (arg.minLength && arg.maxLength) {
-          parts.push(`${String(arg.minLength)} - ${String(arg.maxLength)}`);
-        }
-        break;
+  return init ? args : Object.freeze([...args]);
+}
+function createArgument(type) {
+  return function(options) {
+    const objOptions = typeof options === "string" ? { name: options } : options;
+    const fullOptions = { ...objOptions, type };
+    if (!fullOptions.description) {
+      fullOptions.description = fullOptions.name;
+    }
+    if (!("required" in fullOptions)) {
+      fullOptions.required = true;
+    }
+    return function(target, key, _index) {
+      const method = Object.getOwnPropertyDescriptor(target, key)?.value;
+      if (!method) {
+        throw new Error("No method found");
       }
-      case "number" /* Number */:
-      case "integer" /* Integer */: {
-        if (arg.minValue !== void 0 && arg.maxValue === void 0) {
-          parts.push(`\u2265 ${String(arg.minValue)}`);
-        }
-        if (arg.minValue === void 0 && arg.maxValue !== void 0) {
-          parts.push(`\u2264 ${String(arg.maxValue)}`);
-        }
-        if (arg.minValue !== void 0 && arg.maxValue !== void 0) {
-          parts.push(`${String(arg.minValue)} - ${String(arg.maxValue)}`);
-        }
-        break;
+      const args = getMethodArguments(method, true);
+      args.unshift(fullOptions);
+    };
+  };
+}
+var string = createArgument("string" /* String */);
+var integer = createArgument("integer" /* Integer */);
+var number = createArgument("number" /* Number */);
+var user = createArgument("user" /* User */);
+var member = createArgument("member" /* Member */);
+function describeArgumentExpectation(arg) {
+  const parts = [arg.type];
+  switch (arg.type) {
+    case "string" /* String */: {
+      if (arg.minLength && !arg.maxLength) {
+        parts.push(`\u2265 ${String(arg.minLength)}`);
       }
-      case "user" /* User */:
-      case "member" /* Member */: {
-        break;
+      if (!arg.minLength && arg.maxLength) {
+        parts.push(`\u2264 ${String(arg.maxLength)}`);
+      }
+      if (arg.minLength && arg.maxLength) {
+        parts.push(`${String(arg.minLength)} - ${String(arg.maxLength)}`);
       }
+      break;
     }
-    return parts.join(", ");
-  }
-  static createArgument(type) {
-    return function(options) {
-      const objOptions = typeof options === "string" ? { name: options } : options;
-      const fullOptions = { ...objOptions, type };
-      if (!fullOptions.description) {
-        fullOptions.description = fullOptions.name;
+    case "number" /* Number */:
+    case "integer" /* Integer */: {
+      if (arg.minValue !== void 0 && arg.maxValue === void 0) {
+        parts.push(`\u2265 ${String(arg.minValue)}`);
       }
-      if (!("required" in fullOptions)) {
-        fullOptions.required = true;
+      if (arg.minValue === void 0 && arg.maxValue !== void 0) {
+        parts.push(`\u2264 ${String(arg.maxValue)}`);
       }
-      return function(target, key, _index) {
-        const method = Object.getOwnPropertyDescriptor(target, key)?.value;
-        if (!method) {
-          throw new Error("No method found");
-        }
-        const args = _Arg.getMethodArguments(method, true);
-        args.unshift(fullOptions);
-      };
-    };
+      if (arg.minValue !== void 0 && arg.maxValue !== void 0) {
+        parts.push(`${String(arg.minValue)} - ${String(arg.maxValue)}`);
+      }
+      break;
+    }
+    case "user" /* User */:
+    case "member" /* Member */: {
+      break;
+    }
   }
+  return parts.join(", ");
+}
+function format(arg) {
+  const { name, required, tuple } = arg;
+  const opening = required ? "<" : "[";
+  const closing = required ? ">" : "]";
+  const prefix = tuple ? "..." : "";
+  return `${opening}${prefix}${name}: ${describeArgumentExpectation(arg)}${closing}`;
+}
+var Arg = {
+  getMethodArguments,
+  createArgument,
+  describeArgumentExpectation,
+  format,
+  string,
+  number,
+  integer,
+  user,
+  member
 };
 
 // src/command/CommandEntry.ts
 import { Collection } from "discord.js";
-var HookExecutionState = /* @__PURE__ */ ((HookExecutionState2) => {
-  HookExecutionState2["Main"] = "main";
-  HookExecutionState2["Pre"] = "pre";
-  HookExecutionState2["Post"] = "post";
-  HookExecutionState2["Error"] = "error";
-  return HookExecutionState2;
-})(HookExecutionState || {});
+var CommandHookExecutionState = /* @__PURE__ */ ((CommandHookExecutionState2) => {
+  CommandHookExecutionState2["Main"] = "main";
+  CommandHookExecutionState2["Pre"] = "pre";
+  CommandHookExecutionState2["Post"] = "post";
+  CommandHookExecutionState2["Error"] = "error";
+  return CommandHookExecutionState2;
+})(CommandHookExecutionState || {});
 var HOOKS_KEY = Symbol("hooks");
 var BaseCommandEntry = class _BaseCommandEntry {
   constructor(options) {
@@ -221,25 +230,27 @@ var SubcommandEntry = class extends BaseCommandEntry {
 
 // src/command/Command.ts
 var ROOT_KEY = Symbol("root");
-var Command = class {
-  static create(options) {
-    if (typeof options === "string") {
-      options = { name: options };
-    }
-    if (!options.description) {
-      options.description = options.name;
-    }
-    return new RootCommandEntry(options);
-  }
-  static use(command) {
-    return (target) => {
-      Reflect.defineMetadata(ROOT_KEY, command, target);
-    };
-  }
-  static getRoot(constructor) {
-    return Reflect.getMetadata(ROOT_KEY, constructor);
-  }
-};
+function use(command) {
+  return (target) => {
+    Reflect.defineMetadata(ROOT_KEY, command, target);
+  };
+}
+function getRoot(constructor) {
+  return Reflect.getMetadata(ROOT_KEY, constructor);
+}
+function CommandFactory(options) {
+  if (typeof options === "string") {
+    options = { name: options };
+  }
+  if (!options.description) {
+    options.description = options.name;
+  }
+  return new RootCommandEntry(options);
+}
+var Command = Object.assign(CommandFactory, {
+  use,
+  getRoot
+});
 
 // src/command/CommandRegistry.ts
 import {
@@ -454,11 +465,14 @@ export {
   BaseContext,
   ChatInputContext,
   Command,
+  CommandFactory,
   CommandGroupEntry,
+  CommandHookExecutionState,
   CommandRegistry,
   HOOKS_KEY,
-  HookExecutionState,
   MessageContext,
   RootCommandEntry,
-  SubcommandEntry
+  SubcommandEntry,
+  getRoot,
+  use
 };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { A as Arg, d as ArgumentOptions, b as ArgumentType, a as BakitClient, B as BakitClientOptions, c as BaseArgumentOptions, i as BaseCommandEntry, f as BaseCommandEntryOptions, j as BaseCommandGroupEntry, t as BaseContext, u as ChatInputContext, q as ChatInputContextSendOptions, o as Command, n as CommandConstructor, m as CommandEntry, k as CommandGroupEntry, e as CommandHook, C as CommandHookMethod, p as CommandRegistry, z as CommandSyntaxError, y as CommandSyntaxErrorOptions, x as CommandSyntaxErrorType, w as Context, s as ContextSendOptions, g as CreateOptions, G as GetSyntaxErrorMessageFunction, h as HOOKS_KEY, H as HookExecutionState, I as IntegerArgumentOptions, M as MemberArgumentOptions, v as MessageContext, r as MessageContextSendOptions, N as NumberArgumentOptions, R as RootCommandEntry, S as StringArgumentOptions, l as SubcommandEntry, U as UserArgumentOptions } from './BakitClient-BWxRFtSg.js';
+export { A as Arg, d as ArgumentOptions, b as ArgumentType, a as BakitClient, B as BakitClientOptions, c as BaseArgumentOptions, i as BaseCommandEntry, g as BaseCommandEntryOptions, j as BaseCommandGroupEntry, w as BaseContext, x as ChatInputContext, s as ChatInputContextSendOptions, q as Command, n as CommandConstructor, m as CommandEntry, p as CommandFactory, k as CommandGroupEntry, f as CommandHook, C as CommandHookExecutionState, e as CommandHookMethod, r as CommandRegistry, F as CommandSyntaxError, E as CommandSyntaxErrorOptions, D as CommandSyntaxErrorType, z as Context, v as ContextSendOptions, h as CreateCommandOptions, G as GetSyntaxErrorMessageFunction, H as HOOKS_KEY, I as IntegerArgumentOptions, M as MemberArgumentOptions, y as MessageContext, t as MessageContextSendOptions, N as NumberArgumentOptions, R as RootCommandEntry, S as StringArgumentOptions, l as SubcommandEntry, U as UserArgumentOptions, o as getRoot, u as use } from './BakitClient-BWs93qO-.js';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import 'discord.js';
 import 'type-fest';

package/dist/index.js

@@ -30,96 +30,105 @@ var ArgumentType = /* @__PURE__ */ ((ArgumentType2) => {
 
 // src/command/argument/Arg.ts
 var ARGS_KEY = Symbol("args");
-var Arg = class _Arg {
-  static cache = /* @__PURE__ */ new WeakMap();
-  static string = _Arg.createArgument("string" /* String */);
-  static integer = _Arg.createArgument("integer" /* Integer */);
-  static number = _Arg.createArgument("number" /* Number */);
-  static user = _Arg.createArgument("user" /* User */);
-  static member = _Arg.createArgument("member" /* Member */);
-  static getMethodArguments(method, init = false) {
-    let args = this.cache.get(method) ?? Reflect.getMetadata(ARGS_KEY, method);
-    if (!args) {
-      args = [];
-      if (init) {
-        Reflect.defineMetadata(ARGS_KEY, args, method);
-        this.cache.set(method, args);
-      }
+var cache = /* @__PURE__ */ new WeakMap();
+function getMethodArguments(method, init = false) {
+  let args = cache.get(method) ?? Reflect.getMetadata(ARGS_KEY, method);
+  if (!args) {
+    args = [];
+    if (init) {
+      Reflect.defineMetadata(ARGS_KEY, args, method);
+      cache.set(method, args);
     }
-    return init ? args : Object.freeze([...args]);
   }
-  static format(arg) {
-    const { name, required, tuple } = arg;
-    const opening = required ? "<" : "[";
-    const closing = required ? ">" : "]";
-    const prefix = tuple ? "..." : "";
-    return `${opening}${prefix}${name}: ${this.describeArgumentExpectation(arg)}${closing}`;
-  }
-  static describeArgumentExpectation(arg) {
-    const parts = [arg.type];
-    switch (arg.type) {
-      case "string" /* String */: {
-        if (arg.minLength && !arg.maxLength) {
-          parts.push(`\u2265 ${String(arg.minLength)}`);
-        }
-        if (!arg.minLength && arg.maxLength) {
-          parts.push(`\u2264 ${String(arg.maxLength)}`);
-        }
-        if (arg.minLength && arg.maxLength) {
-          parts.push(`${String(arg.minLength)} - ${String(arg.maxLength)}`);
-        }
-        break;
+  return init ? args : Object.freeze([...args]);
+}
+function createArgument(type) {
+  return function(options) {
+    const objOptions = typeof options === "string" ? { name: options } : options;
+    const fullOptions = { ...objOptions, type };
+    if (!fullOptions.description) {
+      fullOptions.description = fullOptions.name;
+    }
+    if (!("required" in fullOptions)) {
+      fullOptions.required = true;
+    }
+    return function(target, key, _index) {
+      const method = Object.getOwnPropertyDescriptor(target, key)?.value;
+      if (!method) {
+        throw new Error("No method found");
       }
-      case "number" /* Number */:
-      case "integer" /* Integer */: {
-        if (arg.minValue !== void 0 && arg.maxValue === void 0) {
-          parts.push(`\u2265 ${String(arg.minValue)}`);
-        }
-        if (arg.minValue === void 0 && arg.maxValue !== void 0) {
-          parts.push(`\u2264 ${String(arg.maxValue)}`);
-        }
-        if (arg.minValue !== void 0 && arg.maxValue !== void 0) {
-          parts.push(`${String(arg.minValue)} - ${String(arg.maxValue)}`);
-        }
-        break;
+      const args = getMethodArguments(method, true);
+      args.unshift(fullOptions);
+    };
+  };
+}
+var string = createArgument("string" /* String */);
+var integer = createArgument("integer" /* Integer */);
+var number = createArgument("number" /* Number */);
+var user = createArgument("user" /* User */);
+var member = createArgument("member" /* Member */);
+function describeArgumentExpectation(arg) {
+  const parts = [arg.type];
+  switch (arg.type) {
+    case "string" /* String */: {
+      if (arg.minLength && !arg.maxLength) {
+        parts.push(`\u2265 ${String(arg.minLength)}`);
       }
-      case "user" /* User */:
-      case "member" /* Member */: {
-        break;
+      if (!arg.minLength && arg.maxLength) {
+        parts.push(`\u2264 ${String(arg.maxLength)}`);
+      }
+      if (arg.minLength && arg.maxLength) {
+        parts.push(`${String(arg.minLength)} - ${String(arg.maxLength)}`);
       }
+      break;
     }
-    return parts.join(", ");
-  }
-  static createArgument(type) {
-    return function(options) {
-      const objOptions = typeof options === "string" ? { name: options } : options;
-      const fullOptions = { ...objOptions, type };
-      if (!fullOptions.description) {
-        fullOptions.description = fullOptions.name;
+    case "number" /* Number */:
+    case "integer" /* Integer */: {
+      if (arg.minValue !== void 0 && arg.maxValue === void 0) {
+        parts.push(`\u2265 ${String(arg.minValue)}`);
       }
-      if (!("required" in fullOptions)) {
-        fullOptions.required = true;
+      if (arg.minValue === void 0 && arg.maxValue !== void 0) {
+        parts.push(`\u2264 ${String(arg.maxValue)}`);
       }
-      return function(target, key, _index) {
-        const method = Object.getOwnPropertyDescriptor(target, key)?.value;
-        if (!method) {
-          throw new Error("No method found");
-        }
-        const args = _Arg.getMethodArguments(method, true);
-        args.unshift(fullOptions);
-      };
-    };
+      if (arg.minValue !== void 0 && arg.maxValue !== void 0) {
+        parts.push(`${String(arg.minValue)} - ${String(arg.maxValue)}`);
+      }
+      break;
+    }
+    case "user" /* User */:
+    case "member" /* Member */: {
+      break;
+    }
   }
+  return parts.join(", ");
+}
+function format(arg) {
+  const { name, required, tuple } = arg;
+  const opening = required ? "<" : "[";
+  const closing = required ? ">" : "]";
+  const prefix = tuple ? "..." : "";
+  return `${opening}${prefix}${name}: ${describeArgumentExpectation(arg)}${closing}`;
+}
+var Arg = {
+  getMethodArguments,
+  createArgument,
+  describeArgumentExpectation,
+  format,
+  string,
+  number,
+  integer,
+  user,
+  member
 };
 
 // src/command/CommandEntry.ts
-var HookExecutionState = /* @__PURE__ */ ((HookExecutionState2) => {
-  HookExecutionState2["Main"] = "main";
-  HookExecutionState2["Pre"] = "pre";
-  HookExecutionState2["Post"] = "post";
-  HookExecutionState2["Error"] = "error";
-  return HookExecutionState2;
-})(HookExecutionState || {});
+var CommandHookExecutionState = /* @__PURE__ */ ((CommandHookExecutionState2) => {
+  CommandHookExecutionState2["Main"] = "main";
+  CommandHookExecutionState2["Pre"] = "pre";
+  CommandHookExecutionState2["Post"] = "post";
+  CommandHookExecutionState2["Error"] = "error";
+  return CommandHookExecutionState2;
+})(CommandHookExecutionState || {});
 var HOOKS_KEY = Symbol("hooks");
 var BaseCommandEntry = class _BaseCommandEntry {
   constructor(options) {
@@ -237,25 +246,27 @@ var SubcommandEntry = class extends BaseCommandEntry {
 
 // src/command/Command.ts
 var ROOT_KEY = Symbol("root");
-var Command = class {
-  static create(options) {
-    if (typeof options === "string") {
-      options = { name: options };
-    }
-    if (!options.description) {
-      options.description = options.name;
-    }
-    return new RootCommandEntry(options);
-  }
-  static use(command) {
-    return (target) => {
-      Reflect.defineMetadata(ROOT_KEY, command, target);
-    };
+function use(command) {
+  return (target) => {
+    Reflect.defineMetadata(ROOT_KEY, command, target);
+  };
+}
+function getRoot(constructor) {
+  return Reflect.getMetadata(ROOT_KEY, constructor);
+}
+function CommandFactory(options) {
+  if (typeof options === "string") {
+    options = { name: options };
   }
-  static getRoot(constructor) {
-    return Reflect.getMetadata(ROOT_KEY, constructor);
+  if (!options.description) {
+    options.description = options.name;
   }
-};
+  return new RootCommandEntry(options);
+}
+var Command = Object.assign(CommandFactory, {
+  use,
+  getRoot
+});
 
 // src/command/CommandRegistry.ts
 var CommandRegistry = class _CommandRegistry {
@@ -553,13 +564,13 @@ var ArgumentResolver = class _ArgumentResolver {
     return this.options.message.client;
   }
   static create(message) {
-    const client = message.client;
-    const { enableMentionPrefix } = client.options;
+    const client2 = message.client;
+    const { enableMentionPrefix } = client2.options;
     const prefixes = [
       // Custom prefixes specified in options
-      ...client.options.prefixes ?? [],
+      ...client2.options.prefixes ?? [],
       // Use bot mention as prefix if enabled
-      ...enableMentionPrefix ? [client.user.toString()] : []
+      ...enableMentionPrefix ? [client2.user.toString()] : []
     ];
     const prefix = prefixes.find((p) => message.content.startsWith(p)) ?? null;
     if (!prefix) {
@@ -699,11 +710,11 @@ var ArgumentResolver = class _ArgumentResolver {
     if (!userId) {
       return null;
     }
-    const user = await this.client.users.fetch(userId).catch(() => null);
-    if (!user) {
+    const user2 = await this.client.users.fetch(userId).catch(() => null);
+    if (!user2) {
       return null;
     }
-    return user;
+    return user2;
   }
   matchIntegerValue(arg, value) {
     const intVal = parseInt(value, 10);
@@ -801,6 +812,133 @@ var StateBox = class _StateBox {
   }
 };
 
+// src/listener/ListenerEntry.ts
+var HOOKS_KEY2 = Symbol("hooks");
+var ListenerEntry = class _ListenerEntry {
+  constructor(options) {
+    this.options = options;
+  }
+  static cache = /* @__PURE__ */ new WeakMap();
+  main = _ListenerEntry.createMainHookDecorator("main" /* Main */, this);
+  pre = _ListenerEntry.createMainHookDecorator("pre" /* Pre */, this);
+  post = _ListenerEntry.createMainHookDecorator("post" /* Post */, this);
+  error = _ListenerEntry.createErrorHookDecorator("error" /* Error */, this);
+  static getHooks(constructor, init = false) {
+    let hooks = this.cache.get(constructor) ?? Reflect.getMetadata(HOOKS_KEY2, constructor);
+    if (!hooks) {
+      hooks = [];
+      if (init) {
+        Reflect.defineMetadata(HOOKS_KEY2, hooks, constructor);
+        this.cache.set(constructor, hooks);
+      }
+    }
+    return init ? hooks : Object.freeze([...hooks]);
+  }
+  static createMainHookDecorator(state, entry) {
+    return (target, _key, descriptor) => {
+      this.addHook(target, state, descriptor.value, entry);
+    };
+  }
+  static createErrorHookDecorator(state, entry) {
+    return (target, _key, descriptor) => {
+      this.addHook(target, state, descriptor.value, entry);
+    };
+  }
+  static addHook(target, state, method, entry) {
+    const { constructor } = target;
+    const hooks = this.getHooks(constructor, true);
+    if (typeof method !== "function") {
+      throw new Error("CommandEntry decorator must be used with a class method.");
+    }
+    if (hooks.some((hook2) => hook2.state === state && hook2.entry === entry)) {
+      throw new Error(
+        `Hook "${state}" is already defined for entry "${String(entry.options.name)}".`
+      );
+    }
+    const hook = {
+      state,
+      entry,
+      method
+    };
+    hooks.push(hook);
+  }
+};
+
+// src/listener/Listener.ts
+function ListenerFactory(options) {
+  if (typeof options !== "object") {
+    options = {
+      name: options,
+      once: false
+    };
+  }
+  options.once = Boolean(options.once);
+  return new ListenerEntry(options);
+}
+var ENTRY_KEY = Symbol("entry");
+function use2(listener) {
+  return (target) => {
+    Reflect.defineMetadata(ENTRY_KEY, listener, target);
+  };
+}
+function getEntry(constructor) {
+  return Reflect.getMetadata(ENTRY_KEY, constructor);
+}
+var Listener = Object.assign(ListenerFactory, {
+  use: use2,
+  getEntry
+});
+
+// src/listener/ListenerRegistry.ts
+var client;
+var constructors = /* @__PURE__ */ new Set();
+var instances = /* @__PURE__ */ new WeakMap();
+function add(constructor) {
+  const entry = Listener.getEntry(constructor);
+  if (!entry) {
+    throw new Error(`No entry found for "${constructor.name}"`);
+  }
+  const { options } = entry;
+  if (!options.emitter) {
+    if (!client) {
+      throw new Error("Client is not ready.");
+    }
+    options.emitter = client;
+  }
+  constructors.add(constructor);
+  instances.set(constructor, new constructor());
+}
+function remove(constructor) {
+  const entry = Listener.getEntry(constructor);
+  if (!entry) {
+    return;
+  }
+  constructors.delete(constructor);
+  instances.delete(constructor);
+  const hook = ListenerEntry.getHooks(constructor).find((hook2) => hook2.entry === entry);
+  if (!hook) {
+    return;
+  }
+  const { name, emitter } = entry.options;
+  emitter?.removeListener(name, hook.method);
+}
+function removeAll() {
+  for (const constructor of constructors) {
+    remove(constructor);
+  }
+}
+function setClient(newClient) {
+  client = newClient;
+}
+var ListenerRegistry = {
+  constructors,
+  instances,
+  add,
+  setClient,
+  remove,
+  removeAll
+};
+
 // src/BakitClient.ts
 var BakitClient = class _BakitClient extends Client {
   constructor(options) {
@@ -808,9 +946,10 @@ var BakitClient = class _BakitClient extends Client {
       options.getSyntaxErrorMessage = _BakitClient.getSyntaxErrorMessage;
     }
     super(options);
+    ListenerRegistry.setClient(this);
     this.once(
       Events.ClientReady,
-      (client) => void this.registerApplicationCommands(client)
+      (client2) => void this.registerApplicationCommands(client2)
     );
     this.on(Events.InteractionCreate, (interaction) => void this.handleInteraction(interaction));
     this.on(Events.MessageCreate, (message) => void this.handleMessage(message));
@@ -830,9 +969,9 @@ var BakitClient = class _BakitClient extends Client {
       content
     };
   };
-  async registerApplicationCommands(client) {
+  async registerApplicationCommands(client2) {
     const commands = CommandRegistry.constructors.map((c) => CommandRegistry.buildSlashCommand(c));
-    await client.application.commands.set(commands);
+    await client2.application.commands.set(commands);
   }
   async handleMessage(message) {
     if (message.author.bot) {
@@ -988,7 +1127,7 @@ var BakitClient = class _BakitClient extends Client {
     return { root, group, subcommand: sub };
   }
   createHookRecord(hooks) {
-    return Object.values(HookExecutionState).reduce(
+    return Object.values(CommandHookExecutionState).reduce(
       (acc, state) => {
         acc[state] = hooks.find((h) => h.state === state);
         return acc;
@@ -1006,15 +1145,18 @@ export {
   BaseContext,
   ChatInputContext,
   Command,
+  CommandFactory,
   CommandGroupEntry,
+  CommandHookExecutionState,
   CommandRegistry,
   CommandSyntaxError,
   CommandSyntaxErrorType,
   HOOKS_KEY,
-  HookExecutionState,
   MessageContext,
   RootCommandEntry,
   StateBox,
   SubcommandEntry,
-  extractId
+  extractId,
+  getRoot,
+  use
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "bakit",
-	"version": "1.0.0-beta.1",
+	"version": "1.0.0-beta.3",
 	"description": "A framework for discord.js",
 	"type": "module",
 	"exports": {
@@ -12,8 +12,7 @@
 	"scripts": {
 		"build": "tsup",
 		"type-check": "tsc --noEmit",
-		"test": "vitest run --pass-with-no-tests",
-		"prepare": "husky"
+		"test": "vitest run --pass-with-no-tests"
 	},
 	"files": [
 		"dist"
@@ -30,25 +29,6 @@
 	"peerDependencies": {
 		"discord.js": "^14.0.0"
 	},
-	"devDependencies": {
-		"@eslint/js": "^9.34.0",
-		"@types/node": "^24.3.0",
-		"@vitest/ui": "^3.2.4",
-		"discord.js": "^14.22.1",
-		"dotenv": "^17.2.1",
-		"eslint": "^9.34.0",
-		"eslint-config-prettier": "^10.1.8",
-		"eslint-plugin-prettier": "^5.5.4",
-		"husky": "^9.1.7",
-		"lint-staged": "^16.1.5",
-		"prettier": "^3.6.2",
-		"tsup": "^8.5.0",
-		"tsx": "^4.20.5",
-		"typescript": "^5.9.2",
-		"typescript-eslint": "^8.40.0",
-		"vitest": "^3.2.4",
-		"bakit": "link:../../.local/share/pnpm/global/5/node_modules/bakit"
-	},
 	"dependencies": {
 		"reflect-metadata": "^0.2.2",
 		"tiny-glob": "^0.2.9",

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Louis Johnson
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/README.md

@@ -1,2 +0,0 @@
-# bakit
-A discord.js framework