bakit 1.0.0-beta.1 → 1.0.0-beta.11

package/dist/index.js

@@ -1,3 +1,6 @@
+// src/index.ts
+import "reflect-metadata";
+
 // src/BakitClient.ts
 import {
   Client,
@@ -18,249 +21,236 @@ import { pathToFileURL } from "url";
 // src/command/CommandEntry.ts
 import { Collection } from "discord.js";
 
-// src/command/argument/Argument.ts
-var ArgumentType = /* @__PURE__ */ ((ArgumentType2) => {
-  ArgumentType2["String"] = "string";
-  ArgumentType2["Integer"] = "integer";
-  ArgumentType2["Number"] = "number";
-  ArgumentType2["User"] = "user";
-  ArgumentType2["Member"] = "member";
-  return ArgumentType2;
-})(ArgumentType || {});
-
-// 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);
-      }
-    }
-    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;
-      }
-      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;
-      }
-      case "user" /* User */:
-      case "member" /* Member */: {
-        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;
-      }
-      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");
-        }
-        const args = _Arg.getMethodArguments(method, true);
-        args.unshift(fullOptions);
-      };
-    };
-  }
-};
-
-// src/command/CommandEntry.ts
-var HookExecutionState = /* @__PURE__ */ ((HookExecutionState2) => {
-  HookExecutionState2["Main"] = "main";
-  HookExecutionState2["Pre"] = "pre";
-  HookExecutionState2["Post"] = "post";
-  HookExecutionState2["Error"] = "error";
-  return HookExecutionState2;
-})(HookExecutionState || {});
-var HOOKS_KEY = Symbol("hooks");
-var BaseCommandEntry = class _BaseCommandEntry {
-  constructor(options) {
-    this.options = options;
-  }
-  static cache = /* @__PURE__ */ new WeakMap();
-  main = _BaseCommandEntry.createMainHookDecorator("main" /* Main */, this);
-  pre = _BaseCommandEntry.createMainHookDecorator("pre" /* Pre */, this);
-  post = _BaseCommandEntry.createMainHookDecorator("post" /* Post */, this);
-  error = _BaseCommandEntry.createErrorHookDecorator("error" /* Error */, this);
-  static getHooks(constructor, init = false) {
-    let hooks = this.cache.get(constructor) ?? Reflect.getMetadata(HOOKS_KEY, constructor);
-    if (!hooks) {
-      hooks = [];
-      if (init) {
-        Reflect.defineMetadata(HOOKS_KEY, hooks, constructor);
-        this.cache.set(constructor, hooks);
-      }
-    }
-    return init ? hooks : Object.freeze([...hooks]);
-  }
-  static createMainHookDecorator(state, entry) {
+// src/base/BaseEntry.ts
+var BaseEntry = class {
+  target;
+  hooks = {
+    ["MAIN" /* Main */]: void 0,
+    ["ERROR" /* Error */]: void 0,
+    ["POST" /* Post */]: void 0,
+    ["PRE" /* Pre */]: void 0
+  };
+  main;
+  pre;
+  post;
+  error;
+  constructor() {
+    this.main = this.createMainHookDecorator("MAIN" /* Main */);
+    this.pre = this.createMainHookDecorator("PRE" /* Pre */);
+    this.post = this.createMainHookDecorator("POST" /* Post */);
+    this.error = this.createMainHookDecorator("ERROR" /* Error */);
+  }
+  setTarget(target) {
+    this.target = target;
+  }
+  createMainHookDecorator(state) {
     return (target, _key, descriptor) => {
-      this.addHook(target, state, descriptor.value, entry);
+      this.addHook(state, target, descriptor);
     };
   }
-  static createErrorHookDecorator(state, entry) {
+  createErrorHookDecorator(state) {
     return (target, _key, descriptor) => {
-      this.addHook(target, state, descriptor.value, entry);
+      this.addHook(state, target, descriptor);
     };
   }
-  static addHook(target, state, method, entry) {
-    const { constructor } = target;
-    const hooks = _BaseCommandEntry.getHooks(constructor, true);
+  addHook(state, target, descriptor) {
+    if (this.target && this.target !== target.constructor) {
+      throw new Error("Hook is used at wrong constructor.");
+    }
+    const { value: method } = descriptor;
     if (typeof method !== "function") {
-      throw new Error("CommandEntry decorator must be used with a class method.");
-    }
-    if (hooks.some((hook) => hook.state === state && hook.entry === entry)) {
-      throw new Error(`Hook "${state}" is already defined for entry "${entry.options.name}".`);
-    }
-    if ("parent" in entry) {
-      const parentHook = hooks.find(
-        (hook) => hook.entry === entry.parent && hook.state === "main" /* Main */
-      );
-      if (parentHook) {
-        const parentArgs = Arg.getMethodArguments(parentHook.method);
-        if (parentArgs.at(-1)?.tuple) {
-          throw new Error(
-            `Cannot add hook "${state}" to entry "${entry.options.name}" because its parent "${entry.parent.options.name}" has a tuple argument.`
-          );
-        }
-      }
+      throw new Error("Invalid target method for hook.");
     }
-    hooks.push({
+    const hook = {
       state,
-      entry,
-      method
-    });
+      method,
+      entry: this
+    };
+    this.hooks[state] = hook;
+  }
+};
+
+// src/command/CommandEntry.ts
+var BaseCommandEntry = class extends BaseEntry {
+  constructor(options) {
+    super();
+    this.options = options;
   }
 };
 var BaseCommandGroupEntry = class extends BaseCommandEntry {
   children = new Collection();
   subcommand(options) {
-    if (typeof options === "string") {
-      options = { name: options };
+    const fullOptions = typeof options === "string" ? { name: options, description: `${options} command` } : { description: `${options.name} command`, ...options };
+    if (this.children.has(fullOptions.name)) {
+      throw new Error(`Entry "${fullOptions.name}" is already existed.`);
     }
-    if (!options.description) {
-      options.description = options.name;
-    }
-    if (this.children.has(options.name)) {
-      throw new Error(`Entry with name "${options.name}" already exists.`);
-    }
-    if (!(this instanceof CommandGroupEntry) && !(this instanceof RootCommandEntry)) {
-      throw new Error(`Invalid parent "${this.constructor.name}"`);
+    const subcommand = new SubcommandEntry(fullOptions, this);
+    this.children.set(fullOptions.name, subcommand);
+    return subcommand;
+  }
+};
+var RootCommandEntry = class extends BaseCommandGroupEntry {
+  group(options) {
+    const fullOptions = typeof options === "string" ? { name: options, description: `${options} command` } : { description: `${options.name} command`, ...options };
+    if (this.children.has(fullOptions.name)) {
+      throw new Error(`Entry "${fullOptions.name}" is already existed.`);
     }
-    const entry = new SubcommandEntry(options, this);
-    this.children.set(entry.options.name, entry);
-    return entry;
+    const group = new CommandGroupEntry(fullOptions, this);
+    this.children.set(fullOptions.name, group);
+    return group;
   }
 };
 var CommandGroupEntry = class extends BaseCommandGroupEntry {
   constructor(options, parent) {
     super(options);
-    this.options = options;
     this.parent = parent;
   }
 };
-var RootCommandEntry = class extends BaseCommandGroupEntry {
-  constructor(options) {
-    super(options);
-    this.options = options;
-  }
-  group(options) {
-    if (typeof options === "string") {
-      options = { name: options };
-    }
-    if (!options.description) {
-      options.description = options.name;
-    }
-    if (this.children.has(options.name)) {
-      throw new Error(`Entry with name "${options.name}" already exists.`);
-    }
-    const entry = new CommandGroupEntry(options, this);
-    this.children.set(entry.options.name, entry);
-    return entry;
-  }
-};
 var SubcommandEntry = class extends BaseCommandEntry {
   constructor(options, parent) {
     super(options);
-    this.options = options;
     this.parent = parent;
   }
 };
 
 // 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) {
+var CommandAPI;
+((CommandAPI2) => {
+  const rootEntries = /* @__PURE__ */ new WeakMap();
+  function use(root) {
     return (target) => {
-      Reflect.defineMetadata(ROOT_KEY, command, target);
+      root.setTarget(target);
+      rootEntries.set(target, root);
     };
   }
-  static getRoot(constructor) {
-    return Reflect.getMetadata(ROOT_KEY, constructor);
+  CommandAPI2.use = use;
+  function getRoot(constructor) {
+    return rootEntries.get(constructor);
+  }
+  CommandAPI2.getRoot = getRoot;
+})(CommandAPI || (CommandAPI = {}));
+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, CommandAPI);
+
+// src/command/argument/Argument.ts
+var ArgumentType = /* @__PURE__ */ ((ArgumentType2) => {
+  ArgumentType2["String"] = "string";
+  ArgumentType2["Integer"] = "integer";
+  ArgumentType2["Number"] = "number";
+  ArgumentType2["User"] = "user";
+  ArgumentType2["Member"] = "member";
+  return ArgumentType2;
+})(ArgumentType || {});
+
+// src/command/argument/Arg.ts
+var ARGS_KEY = Symbol("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]);
+}
+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");
+      }
+      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)}`);
+      }
+      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;
+    }
+    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;
+    }
+    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/CommandRegistry.ts
 var CommandRegistry = class _CommandRegistry {
   static constructors = new Collection2();
   static instances = new Collection2();
+  /**
+   * Add a command to the registry.
+   * @param constructor The command class you want to add.
+   */
   static add(constructor) {
     const root = Command.getRoot(constructor);
     if (!root) {
@@ -270,20 +260,13 @@ var CommandRegistry = class _CommandRegistry {
     this.constructors.set(options.name, constructor);
     this.instances.set(options.name, new constructor());
   }
-  static buildSlashCommand(constructor) {
-    const builder = new SlashCommandBuilder();
-    const root = Command.getRoot(constructor);
-    if (!root) {
-      throw new Error(`No root found for "${constructor.name}"`);
-    }
-    const { options } = root;
-    builder.setName(options.name);
-    builder.setDescription(options.description || "");
-    builder.setNSFW(Boolean(options.nsfw));
-    this.buildSlashCommandOptions(builder, constructor);
-    return builder.toJSON();
-  }
-  static async loadDirectory(pattern, parallel = true) {
+  /**
+   * Load and add all commands which matched provided glob pattern to the registry.
+   * @param pattern glob pattern to load.
+   * @param parallel load all matched results in parallel, enabled by default.
+   * @returns All loaded command constructors.
+   */
+  static async load(pattern, parallel = true) {
     const files = await glob(pattern);
     const loaders = files.map(async (file) => {
       const fileURL = pathToFileURL(file).toString();
@@ -300,72 +283,102 @@ var CommandRegistry = class _CommandRegistry {
     }
     return result;
   }
-  static buildSlashCommandOptions(builder, constructor) {
+  /**
+   * Build a command into application command data.
+   * @param constructor The command class you want to build.
+   * @returns a REST JSON version of the application command data.
+   */
+  static buildSlashCommand(constructor) {
     const root = Command.getRoot(constructor);
     if (!root) {
       throw new Error(`No root found for "${constructor.name}"`);
     }
-    const hooks = new Collection2(
-      BaseCommandEntry.getHooks(constructor).filter((hook) => hook.state === "main" /* Main */).map((hook) => [hook.entry, hook])
-    );
-    const rootHook = hooks.get(root);
-    if (!root.children.size && hooks.size) {
-      if (!rootHook) {
-        return;
-      }
-      for (const arg of Arg.getMethodArguments(rootHook.method)) {
-        this.buildSlashCommandOption(builder, arg);
-      }
-      return;
+    const { options } = root;
+    const builder = new SlashCommandBuilder().setName(options.name).setDescription(options.description).setNSFW(Boolean(options.nsfw));
+    const args = this.getMainHookArguments(root);
+    if (root.children.size) {
+      this.buildSlashCommandSubcommands(builder, root, args);
+    } else {
+      this.buildSlashCommandOptions(builder, args);
     }
-    for (const child of root.children.values()) {
-      const hook = hooks.get(child);
-      const inheritedArgs = [];
-      if (rootHook) {
-        inheritedArgs.push(...Arg.getMethodArguments(rootHook.method));
-      }
-      if (child instanceof SubcommandEntry) {
-        this.buildSubcommand(builder, child, hook, inheritedArgs);
-      } else if (child instanceof CommandGroupEntry) {
-        if (hook) {
-          inheritedArgs.push(...Arg.getMethodArguments(hook.method));
-        }
+    return builder.toJSON();
+  }
+  static getMainHookArguments(entry) {
+    const { hooks } = entry;
+    const mainHook = hooks["MAIN" /* Main */];
+    return mainHook ? Arg.getMethodArguments(mainHook.method) : [];
+  }
+  static buildSlashCommandSubcommands(parent, entry, inheritedArgs) {
+    const { children } = entry;
+    for (const child of children.values()) {
+      if (child instanceof CommandGroupEntry && parent instanceof SlashCommandBuilder) {
         const { options } = child;
         const group = new SlashCommandSubcommandGroupBuilder().setName(options.name).setDescription(options.description);
-        for (const subChild of child.children.values()) {
-          this.buildSubcommand(group, subChild, hooks.get(subChild), inheritedArgs);
-        }
-        builder.addSubcommandGroup(group);
+        this.buildSlashCommandSubcommands(group, child, [
+          ...inheritedArgs,
+          ...this.getMainHookArguments(child)
+        ]);
+        parent.addSubcommandGroup(group);
+      } else if (child instanceof SubcommandEntry) {
+        const { options } = child;
+        const subcommand = new SlashCommandSubcommandBuilder().setName(options.name).setDescription(options.description);
+        this.buildSlashCommandOptions(subcommand, [
+          ...inheritedArgs,
+          ...this.getMainHookArguments(child)
+        ]);
+        parent.addSubcommand(subcommand);
       }
     }
   }
-  static buildSubcommand(parent, entry, hook, inheritedArgs) {
-    const { options } = entry;
-    const subcommand = new SlashCommandSubcommandBuilder().setName(options.name).setDescription(options.description);
-    const args = [...inheritedArgs];
-    if (hook) {
-      args.push(...Arg.getMethodArguments(hook.method));
+  static buildSlashCommandOptions(builder, args) {
+    const argGroup = Object.groupBy(args, ({ required }) => required ? "required" : "optional");
+    const orderedArgs = [...argGroup.required || [], ...argGroup.optional || []];
+    for (const arg of orderedArgs) {
+      this.attachSlashCommandOption(builder, arg);
     }
-    for (const arg of args) {
-      this.buildSlashCommandOption(subcommand, arg);
-    }
-    parent.addSubcommand(subcommand);
   }
-  static buildSlashCommandOption(builder, arg) {
+  static attachSlashCommandOption(builder, arg) {
     const setupOption = (option) => {
       return option.setName(arg.name).setDescription(arg.description || arg.name).setRequired(Boolean(arg.required));
     };
     switch (arg.type) {
       case "string" /* String */: {
-        builder.addStringOption((option) => setupOption(option));
+        builder.addStringOption((data) => {
+          const option = setupOption(data);
+          if (arg.maxLength) {
+            option.setMaxLength(arg.maxLength);
+          }
+          if (arg.minLength) {
+            option.setMinLength(arg.minLength);
+          }
+          return option;
+        });
         break;
       }
       case "integer" /* Integer */: {
-        builder.addIntegerOption((option) => setupOption(option));
+        builder.addIntegerOption((data) => {
+          const option = setupOption(data);
+          if (arg.maxValue) {
+            option.setMaxValue(arg.maxValue);
+          }
+          if (arg.minValue) {
+            option.setMinValue(arg.minValue);
+          }
+          return option;
+        });
         break;
       }
       case "number" /* Number */: {
-        builder.addNumberOption((option) => setupOption(option));
+        builder.addNumberOption((data) => {
+          const option = setupOption(data);
+          if (arg.maxValue) {
+            option.setMaxValue(arg.maxValue);
+          }
+          if (arg.minValue) {
+            option.setMinValue(arg.minValue);
+          }
+          return option;
+        });
         break;
       }
       case "user" /* User */:
@@ -377,9 +390,6 @@ var CommandRegistry = class _CommandRegistry {
   }
 };
 
-// src/command/index.ts
-import "reflect-metadata";
-
 // src/command/Context.ts
 import {
   ChatInputCommandInteraction,
@@ -699,11 +709,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 +811,174 @@ var StateBox = class _StateBox {
   }
 };
 
+// src/listener/ListenerEntry.ts
+var ListenerEntry = class extends BaseEntry {
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+};
+
+// src/listener/Listener.ts
+var ListenerAPI;
+((ListenerAPI2) => {
+  ListenerAPI2.ENTRY_KEY = Symbol("entry");
+  function use(entry) {
+    return (target) => {
+      Reflect.defineMetadata(ListenerAPI2.ENTRY_KEY, entry, target);
+    };
+  }
+  ListenerAPI2.use = use;
+  function getEntry(target) {
+    return Reflect.getMetadata(ListenerAPI2.ENTRY_KEY, target);
+  }
+  ListenerAPI2.getEntry = getEntry;
+})(ListenerAPI || (ListenerAPI = {}));
+function ListenerFactory(options) {
+  const fullOptions = typeof options !== "object" ? { name: options, once: false } : { once: false, ...options };
+  return new ListenerEntry(fullOptions);
+}
+var Listener = Object.assign(ListenerFactory, ListenerAPI);
+
+// src/listener/ListenerRegistry.ts
+import glob2 from "tiny-glob";
+import { pathToFileURL as pathToFileURL2 } from "url";
+var ListenerRegistry = class {
+  static client;
+  static constructors = /* @__PURE__ */ new Set();
+  static instances = /* @__PURE__ */ new WeakMap();
+  static executors = /* @__PURE__ */ new WeakMap();
+  /**
+   * Add and register a listener to the registry.
+   * If `options.emitter` is not provided, the registry will use the base `client` by default.
+   * @param constructor The listener class you want to add.
+   */
+  static 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 (!this.client) {
+        throw new Error("Client is not ready.");
+      }
+      options.emitter = this.client;
+    }
+    const instance = new constructor();
+    const executor = this.createExecutor(constructor, instance);
+    this.constructors.add(constructor);
+    this.instances.set(constructor, instance);
+    this.executors.set(instance, executor);
+    options.emitter[options.once ? "once" : "on"](options.name, (...args) => {
+      void executor(...args);
+    });
+  }
+  /**
+   * Remove and unregister a listener from the registry.
+   * @param constructor The listener class you want to remove.
+   * @returns `boolean`, returns `true` if the listener is removed successfully.
+   */
+  static remove(constructor) {
+    const entry = Listener.getEntry(constructor);
+    if (!entry) {
+      return false;
+    }
+    this.constructors.delete(constructor);
+    const instance = this.instances.get(constructor);
+    if (!instance) {
+      return false;
+    }
+    this.instances.delete(constructor);
+    const executor = this.executors.get(instance);
+    if (!executor) {
+      return false;
+    }
+    const { name, emitter } = entry.options;
+    emitter?.removeListener(name, executor);
+    this.executors.delete(instance);
+    return true;
+  }
+  /**
+   * Remove and unregister all listeners from the registry.
+   * @returns Amount of removed listeners.
+   */
+  static removeAll() {
+    let removedAmount = 0;
+    for (const constructor of this.constructors) {
+      if (this.remove(constructor)) {
+        removedAmount++;
+      }
+    }
+    return removedAmount;
+  }
+  /**
+   * Set base client for the registry to fallback as default emitter. This should be used only by BakitClient and stay untouched.
+   * @param newClient base client to set for the registry.
+   */
+  static setClient(newClient) {
+    this.client = newClient;
+  }
+  static createExecutor(constructor, instance) {
+    const entry = Listener.getEntry(constructor);
+    if (!entry) {
+      throw new Error("Missing listener entry");
+    }
+    const { hooks } = entry;
+    return async function(...args) {
+      const mainHook = hooks["MAIN" /* Main */];
+      const preHook = hooks["PRE" /* Pre */];
+      const postHook = hooks["POST" /* Post */];
+      const errorHook = hooks["ERROR" /* Error */];
+      if (!mainHook) {
+        return;
+      }
+      try {
+        if (preHook) {
+          await preHook.method.call(instance, ...args);
+        }
+        await mainHook.method.call(instance, ...args);
+        if (postHook) {
+          await postHook.method.call(instance, ...args);
+        }
+      } catch (error) {
+        if (errorHook) {
+          await errorHook.method.call(
+            instance,
+            error,
+            ...args
+          );
+        } else {
+          throw error;
+        }
+      }
+    };
+  }
+  /**
+   * Load and add all listeners which matched provided glob pattern to the registry.
+   * @param pattern glob pattern to load.
+   * @param parallel load all matched results in parallel, enabled by default.
+   * @returns All loaded listener constructors.
+   */
+  static async load(pattern, parallel = true) {
+    const files = await glob2(pattern);
+    const loaders = files.map(async (file) => {
+      const fileURL = pathToFileURL2(file).toString();
+      const { default: constructor } = await import(fileURL);
+      this.add(constructor);
+      return constructor;
+    });
+    if (parallel) {
+      return Promise.all(loaders);
+    }
+    const result = [];
+    for (const loader of loaders) {
+      result.push(await loader);
+    }
+    return result;
+  }
+};
+
 // src/BakitClient.ts
 var BakitClient = class _BakitClient extends Client {
   constructor(options) {
@@ -808,6 +986,7 @@ var BakitClient = class _BakitClient extends Client {
       options.getSyntaxErrorMessage = _BakitClient.getSyntaxErrorMessage;
     }
     super(options);
+    ListenerRegistry["setClient"](this);
     this.once(
       Events.ClientReady,
       (client) => void this.registerApplicationCommands(client)
@@ -838,6 +1017,7 @@ var BakitClient = class _BakitClient extends Client {
     if (message.author.bot) {
       return;
     }
+    const context = new MessageContext(message);
     const resolver = ArgumentResolver.create(message);
     if (!resolver) {
       return;
@@ -847,9 +1027,7 @@ var BakitClient = class _BakitClient extends Client {
     if (!command) {
       return;
     }
-    const hooks = BaseCommandEntry.getHooks(command.constructor);
-    const context = new MessageContext(message);
-    await StateBox.run(() => this.handleMessageHooks(context, hooks, command, resolver));
+    await StateBox.run(() => this.handleMessageHooks(context, command, resolver));
   }
   async handleInteraction(interaction) {
     if (!interaction.isChatInputCommand()) {
@@ -860,54 +1038,57 @@ var BakitClient = class _BakitClient extends Client {
     if (!command) {
       return;
     }
-    const hooks = BaseCommandEntry.getHooks(command.constructor);
     const context = new ChatInputContext(interaction);
-    await StateBox.run(() => this.handleChatInputHooks(context, hooks, command));
+    await StateBox.run(() => this.handleChatInputHooks(context, command));
   }
-  async handleChatInputHooks(context, hooks, instance) {
-    const targetHooks = this.getChatInputTargetHooks(context.source, hooks);
+  async handleChatInputHooks(context, instance) {
+    const targetHooks = this.getChatInputTargetHooks(context.source, instance);
     let inheritedArgs = [];
-    for (const record of [targetHooks.root, targetHooks.group, targetHooks.subcommand]) {
-      const newArgs = await this.runChatInputHooks(context, instance, record, inheritedArgs);
+    for (const hooks of [targetHooks.root, targetHooks.group, targetHooks.subcommand]) {
+      if (!hooks) {
+        continue;
+      }
+      const newArgs = await this.runChatInputHooks(context, instance, hooks, inheritedArgs);
       if (newArgs) {
         inheritedArgs = newArgs;
       }
     }
   }
-  async handleMessageHooks(context, hooks, instance, resolver) {
+  async handleMessageHooks(context, instance, resolver) {
     if (!resolver) {
       return;
     }
-    const rootEntry = Command.getRoot(instance.constructor);
-    if (!rootEntry) return;
-    const rootRecord = this.createHookRecord(hooks.filter((hook) => hook.entry === rootEntry));
-    resolver = await this.runMessageHooks(context, instance, rootRecord, resolver);
+    const root = Command.getRoot(instance.constructor);
+    if (!root) {
+      return;
+    }
+    resolver = await this.runMessageHooks(context, instance, root.hooks, resolver);
     if (!resolver) {
       return;
     }
-    const usedValues = resolver.parsedValues.length;
-    const nextTrigger = resolver.values[usedValues + 1];
-    const nextHook = hooks.find((hook) => hook.entry.options.name === nextTrigger);
-    const nextRecord = this.createHookRecord(nextHook ? [nextHook] : []);
-    resolver = await this.runMessageHooks(context, instance, nextRecord, resolver);
+    await this.handleChildMessageHooks(context, root, instance, resolver);
+  }
+  async handleChildMessageHooks(context, parent, instance, resolver, skip = 1) {
     if (!resolver) {
       return;
     }
-    if (nextRecord.main?.entry instanceof CommandGroupEntry) {
-      const groupEntry = nextRecord.main.entry;
-      const subTrigger = resolver.values[usedValues + 2];
-      const subHook = hooks.find(
-        (h) => h.entry instanceof SubcommandEntry && h.entry.options.name === subTrigger && h.entry.parent === groupEntry
-      );
-      const subRecord = this.createHookRecord(subHook ? [subHook] : []);
-      resolver = await this.runMessageHooks(context, instance, subRecord, resolver);
+    const usedValues = resolver.parsedValues.length;
+    const nextTrigger = resolver.values[usedValues + skip];
+    const child = parent.children.get(nextTrigger);
+    if (!child) {
+      return;
+    }
+    resolver = await this.runMessageHooks(context, instance, child.hooks, resolver);
+    if (child instanceof CommandGroupEntry) {
+      await this.handleChildMessageHooks(context, child, instance, resolver, skip + 1);
     }
   }
-  async runMessageHooks(context, instance, record, resolver) {
-    if (!record.main) {
+  async runMessageHooks(context, instance, hooks, resolver) {
+    const mainHook = hooks["MAIN" /* Main */];
+    if (!mainHook) {
       return resolver;
     }
-    const args = Arg.getMethodArguments(record.main.method);
+    const args = Arg.getMethodArguments(mainHook.method);
     try {
       resolver = await resolver.resolve(args);
     } catch (error) {
@@ -926,75 +1107,78 @@ var BakitClient = class _BakitClient extends Client {
       }
       throw error;
     }
-    try {
-      await record.pre?.method.call(instance, context, ...resolver.parsedValues);
-      await record.main.method.call(instance, context, ...resolver.parsedValues);
-      await record.post?.method.call(instance, context, ...resolver.parsedValues);
-    } catch (error) {
-      if (record.error) {
-        await record.error.method.call(instance, context, error, ...resolver.parsedValues);
-      } else {
-        throw error;
-      }
-    }
+    await this.runHooks(context, instance, hooks, resolver.parsedValues);
     return resolver;
   }
-  async runChatInputHooks(context, instance, record, inheritedArgs) {
-    if (!record.main) {
+  async runChatInputHooks(context, instance, hooks, inheritedArgs) {
+    const mainHook = hooks["MAIN" /* Main */];
+    if (!mainHook) {
       return;
     }
-    const newArgs = Arg.getMethodArguments(record.main.method).map(
+    const newArgs = Arg.getMethodArguments(mainHook.method).map(
       (arg) => ArgumentResolver.resolveChatInput(context.source, arg)
     );
     const argValues = [...inheritedArgs, ...newArgs];
+    await this.runHooks(context, instance, hooks, argValues);
+    return argValues;
+  }
+  async runHooks(context, instance, hooks, args) {
+    const mainHook = hooks["MAIN" /* Main */];
+    const preHook = hooks["PRE" /* Pre */];
+    const postHook = hooks["POST" /* Post */];
+    const errorHook = hooks["ERROR" /* Error */];
+    if (!mainHook) {
+      return;
+    }
+    const execute = async (hook, error) => {
+      if (!hook) {
+        return;
+      }
+      if (hook.state === "ERROR" /* Error */) {
+        await hook.method.call(instance, error, context, ...args);
+      } else {
+        await hook.method.call(instance, context, ...args);
+      }
+    };
     try {
-      await record.pre?.method.call(instance, context, ...argValues);
-      await record.main.method.call(instance, context, ...argValues);
-      await record.post?.method.call(instance, context, ...argValues);
+      await execute(preHook);
+      await execute(mainHook);
+      await execute(postHook);
     } catch (error) {
-      if (record.error) {
-        await record.error.method.call(instance, context, error, ...argValues);
+      if (errorHook) {
+        await execute(errorHook, error);
       } else {
         throw error;
       }
     }
-    return argValues;
   }
-  getChatInputTargetHooks(interaction, hooks) {
-    const subcommand = interaction.options.getSubcommand(false);
-    const subcommandGroup = interaction.options.getSubcommandGroup(false);
-    const root = this.createHookRecord(
-      hooks.filter((hook) => hook.entry instanceof RootCommandEntry)
-    );
-    const group = this.createHookRecord(
-      hooks.filter(({ entry }) => {
-        return entry instanceof CommandGroupEntry && entry.options.name === subcommandGroup;
-      })
-    );
-    const sub = this.createHookRecord(
-      hooks.filter(({ entry }) => {
-        if (!(entry instanceof SubcommandEntry) || !(entry.options.name === subcommand)) {
-          return false;
-        }
-        if (subcommandGroup) {
-          const { parent } = entry;
-          if (!(parent instanceof CommandGroupEntry) || parent.options.name !== subcommandGroup) {
-            return false;
-          }
-        }
-        return true;
-      })
-    );
-    return { root, group, subcommand: sub };
-  }
-  createHookRecord(hooks) {
-    return Object.values(HookExecutionState).reduce(
-      (acc, state) => {
-        acc[state] = hooks.find((h) => h.state === state);
-        return acc;
-      },
-      {}
-    );
+  getChatInputTargetHooks(interaction, instance) {
+    const subcommandName = interaction.options.getSubcommand(false);
+    const groupName = interaction.options.getSubcommandGroup(false);
+    const root = Command.getRoot(instance.constructor);
+    if (!root) {
+      throw new Error("No root found.");
+    }
+    let group;
+    if (groupName) {
+      const child = root.children.get(groupName);
+      if (child instanceof CommandGroupEntry) {
+        group = child;
+      }
+    }
+    let subcommand;
+    if (subcommandName) {
+      const parent = group || root;
+      const child = parent.children.get(subcommandName);
+      if (child instanceof SubcommandEntry) {
+        subcommand = child;
+      }
+    }
+    return {
+      root: root.hooks,
+      group: group?.hooks,
+      subcommand: subcommand?.hooks
+    };
   }
 };
 export {
@@ -1006,12 +1190,17 @@ export {
   BaseContext,
   ChatInputContext,
   Command,
+  CommandAPI,
+  CommandFactory,
   CommandGroupEntry,
   CommandRegistry,
   CommandSyntaxError,
   CommandSyntaxErrorType,
-  HOOKS_KEY,
-  HookExecutionState,
+  Listener,
+  ListenerAPI,
+  ListenerEntry,
+  ListenerFactory,
+  ListenerRegistry,
   MessageContext,
   RootCommandEntry,
   StateBox,