bakit 1.0.0-beta.5 → 1.0.0-beta.8

package/dist/index.js

@@ -1,3 +1,6 @@
+// src/index.ts
+import "reflect-metadata";
+
 // src/BakitClient.ts
 import {
   Client,
@@ -18,6 +21,125 @@ import { pathToFileURL } from "url";
 // src/command/CommandEntry.ts
 import { Collection } from "discord.js";
 
+// 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(state, target, descriptor);
+    };
+  }
+  createErrorHookDecorator(state) {
+    return (target, _key, descriptor) => {
+      this.addHook(state, target, descriptor);
+    };
+  }
+  addHook(state, target, descriptor) {
+    if (target.constructor !== this.target) {
+      throw new Error("Hook is used at unknown constructor.");
+    }
+    const { value: method } = descriptor;
+    if (typeof method !== "function") {
+      throw new Error("Invalid target method for hook.");
+    }
+    const hook = {
+      state,
+      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) {
+    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 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 group = new CommandGroupEntry(fullOptions, this);
+    this.children.set(fullOptions.name, group);
+    return group;
+  }
+};
+var CommandGroupEntry = class extends BaseCommandGroupEntry {
+  constructor(options, parent) {
+    super(options);
+    this.parent = parent;
+  }
+};
+var SubcommandEntry = class extends BaseCommandEntry {
+  constructor(options, parent) {
+    super(options);
+    this.parent = parent;
+  }
+};
+
+// src/command/Command.ts
+var CommandAPI;
+((CommandAPI2) => {
+  const rootEntries = /* @__PURE__ */ new WeakMap();
+  function use(root) {
+    return (target) => {
+      root.setTarget(target);
+      rootEntries.set(target, root);
+    };
+  }
+  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";
@@ -121,157 +243,14 @@ var Arg = {
   member
 };
 
-// src/command/CommandEntry.ts
-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) {
-    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) {
-    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 = _BaseCommandEntry.getHooks(constructor, true);
-    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.`
-          );
-        }
-      }
-    }
-    hooks.push({
-      state,
-      entry,
-      method
-    });
-  }
-};
-var BaseCommandGroupEntry = class extends BaseCommandEntry {
-  children = new Collection();
-  subcommand(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.`);
-    }
-    if (!(this instanceof CommandGroupEntry) && !(this instanceof RootCommandEntry)) {
-      throw new Error(`Invalid parent "${this.constructor.name}"`);
-    }
-    const entry = new SubcommandEntry(options, this);
-    this.children.set(entry.options.name, entry);
-    return entry;
-  }
-};
-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");
-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
 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) {
@@ -281,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();
@@ -311,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 */:
@@ -388,9 +390,6 @@ var CommandRegistry = class _CommandRegistry {
   }
 };
 
-// src/command/index.ts
-import "reflect-metadata";
-
 // src/command/Context.ts
 import {
   ChatInputCommandInteraction,
@@ -564,13 +563,13 @@ var ArgumentResolver = class _ArgumentResolver {
     return this.options.message.client;
   }
   static create(message) {
-    const client2 = message.client;
-    const { enableMentionPrefix } = client2.options;
+    const client = message.client;
+    const { enableMentionPrefix } = client.options;
     const prefixes = [
       // Custom prefixes specified in options
-      ...client2.options.prefixes ?? [],
+      ...client.options.prefixes ?? [],
       // Use bot mention as prefix if enabled
-      ...enableMentionPrefix ? [client2.user.toString()] : []
+      ...enableMentionPrefix ? [client.user.toString()] : []
     ];
     const prefix = prefixes.find((p) => message.content.startsWith(p)) ?? null;
     if (!prefix) {
@@ -813,191 +812,171 @@ var StateBox = class _StateBox {
 };
 
 // src/listener/ListenerEntry.ts
-var ListenerHookExecutionState = /* @__PURE__ */ ((ListenerHookExecutionState2) => {
-  ListenerHookExecutionState2["Main"] = "main";
-  ListenerHookExecutionState2["Pre"] = "pre";
-  ListenerHookExecutionState2["Post"] = "post";
-  ListenerHookExecutionState2["Error"] = "error";
-  return ListenerHookExecutionState2;
-})(ListenerHookExecutionState || {});
-var ListenerEntry = class _ListenerEntry {
+var ListenerEntry = class extends BaseEntry {
   constructor(options) {
+    super();
     this.options = options;
   }
-  static hooksKey = Symbol("hooks");
-  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) {
-    const { cache: cache2 } = this;
-    let hooks = cache2.get(constructor) ?? Reflect.getMetadata(this.hooksKey, constructor);
-    if (!hooks) {
-      hooks = [];
-      if (init) {
-        Reflect.defineMetadata(this.hooksKey, hooks, constructor);
-        this.cache.set(
-          constructor,
-          hooks
-        );
-      }
-    }
-    return init ? hooks : [...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
+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 normalizedOptions = typeof options === "object" ? { once: false, ...options } : { name: options, once: false };
-  return new ListenerEntry(normalizedOptions);
+  const fullOptions = typeof options !== "object" ? { name: options, once: false } : { once: false, ...options };
+  return new ListenerEntry(fullOptions);
 }
-var LISTENER_ENTRY_KEY = Symbol("entry");
-function use2(listener) {
-  return (target) => {
-    Reflect.defineMetadata(LISTENER_ENTRY_KEY, listener, target);
-  };
-}
-function getEntry(constructor) {
-  return Reflect.getMetadata(LISTENER_ENTRY_KEY, constructor);
-}
-var Listener = Object.assign(ListenerFactory, {
-  use: use2,
-  getEntry
-});
+var Listener = Object.assign(ListenerFactory, ListenerAPI);
 
 // src/listener/ListenerRegistry.ts
-var client;
-var constructors = /* @__PURE__ */ new Set();
-var instances = /* @__PURE__ */ new WeakMap();
-var executors = /* @__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;
-  }
-  const instance = new constructor();
-  constructors.add(constructor);
-  instances.set(constructor, instance);
-  const executor = createExecutor(constructor, instance);
-  executors.set(instance, executor);
-  options.emitter[options.once ? "once" : "on"](options.name, (...args) => {
-    void executor(...args);
-  });
-}
-function remove(constructor) {
-  const entry = Listener.getEntry(constructor);
-  if (!entry) {
-    return;
-  }
-  constructors.delete(constructor);
-  const instance = instances.get(constructor);
-  if (!instance) {
-    return;
-  }
-  instances.delete(constructor);
-  const executor = executors.get(instance);
-  if (!executor) {
-    return;
-  }
-  const { name, emitter } = entry.options;
-  emitter?.removeListener(name, executor);
-  executors.delete(instance);
-}
-function removeAll() {
-  for (const constructor of constructors) {
-    remove(constructor);
-  }
-}
-function setClient(newClient) {
-  client = newClient;
-}
-function createExecutor(constructor, instance) {
-  const entry = Listener.getEntry(constructor);
-  if (!entry) {
-    throw new Error("Missing listener entry");
-  }
-  const hooks = ListenerEntry.getHooks(constructor).filter((hook) => hook.entry === entry);
-  const hookGroup = makeHookGroup(hooks);
-  return async function(...args) {
-    if (!hookGroup.main) {
-      return;
+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}"`);
     }
-    try {
-      if (hookGroup.pre) {
-        const preMethod = hookGroup.pre.method;
-        await preMethod.call(instance, ...args);
+    const { options } = entry;
+    if (!options.emitter) {
+      if (!this.client) {
+        throw new Error("Client is not ready.");
       }
-      await hookGroup.main.method.call(instance, ...args);
-      if (hookGroup.post) {
-        const postMethod = hookGroup.post.method;
-        await postMethod.call(instance, ...args);
+      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++;
       }
-    } catch (error) {
-      if (hookGroup.error) {
-        const errorMethod = hookGroup.error.method;
-        await errorMethod.call(instance, error, ...args);
-      } else {
-        throw error;
+    }
+    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);
     }
-  };
-}
-function makeHookGroup(hooks) {
-  const hooksByType = {
-    ["pre" /* Pre */]: void 0,
-    ["main" /* Main */]: void 0,
-    ["post" /* Post */]: void 0,
-    ["error" /* Error */]: void 0
-  };
-  for (const hook of hooks) {
-    hooksByType[hook.state] = hook;
+    const result = [];
+    for (const loader of loaders) {
+      result.push(await loader);
+    }
+    return result;
   }
-  return hooksByType;
-}
-var ListenerRegistry = {
-  constructors,
-  instances,
-  executors,
-  add,
-  setClient,
-  remove,
-  removeAll
 };
 
 // src/BakitClient.ts
@@ -1007,10 +986,10 @@ var BakitClient = class _BakitClient extends Client {
       options.getSyntaxErrorMessage = _BakitClient.getSyntaxErrorMessage;
     }
     super(options);
-    ListenerRegistry.setClient(this);
+    ListenerRegistry["setClient"](this);
     this.once(
       Events.ClientReady,
-      (client2) => void this.registerApplicationCommands(client2)
+      (client) => void this.registerApplicationCommands(client)
     );
     this.on(Events.InteractionCreate, (interaction) => void this.handleInteraction(interaction));
     this.on(Events.MessageCreate, (message) => void this.handleMessage(message));
@@ -1030,14 +1009,15 @@ var BakitClient = class _BakitClient extends Client {
       content
     };
   };
-  async registerApplicationCommands(client2) {
+  async registerApplicationCommands(client) {
     const commands = CommandRegistry.constructors.map((c) => CommandRegistry.buildSlashCommand(c));
-    await client2.application.commands.set(commands);
+    await client.application.commands.set(commands);
   }
   async handleMessage(message) {
     if (message.author.bot) {
       return;
     }
+    const context = new MessageContext(message);
     const resolver = ArgumentResolver.create(message);
     if (!resolver) {
       return;
@@ -1047,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()) {
@@ -1060,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) {
@@ -1126,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(CommandHookExecutionState).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 {
@@ -1206,18 +1190,16 @@ export {
   BaseContext,
   ChatInputContext,
   Command,
+  CommandAPI,
   CommandFactory,
   CommandGroupEntry,
-  CommandHookExecutionState,
   CommandRegistry,
   CommandSyntaxError,
   CommandSyntaxErrorType,
-  HOOKS_KEY,
-  LISTENER_ENTRY_KEY,
   Listener,
+  ListenerAPI,
   ListenerEntry,
   ListenerFactory,
-  ListenerHookExecutionState,
   ListenerRegistry,
   MessageContext,
   RootCommandEntry,