bakit 1.0.0-beta.1 → 1.0.0-beta.10

package/dist/command/index.js

@@ -1,6 +1,3 @@
-// src/command/index.ts
-import "reflect-metadata";
-
 // src/command/argument/Argument.ts
 var ArgumentType = /* @__PURE__ */ ((ArgumentType2) => {
   ArgumentType2["String"] = "string";
@@ -13,233 +10,218 @@ 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 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);
-    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}".`);
+  addHook(state, target, descriptor) {
+    if (this.target && this.target !== target.constructor) {
+      throw new Error("Hook is used at wrong constructor.");
     }
-    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.`
-          );
-        }
-      }
+    const { value: method } = descriptor;
+    if (typeof method !== "function") {
+      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 };
-    }
-    if (!options.description) {
-      options.description = options.name;
-    }
-    if (this.children.has(options.name)) {
-      throw new Error(`Entry with name "${options.name}" already exists.`);
+    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 (!(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/CommandRegistry.ts
 import {
@@ -253,6 +235,10 @@ import { pathToFileURL } from "url";
 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) {
@@ -262,20 +248,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();
@@ -292,72 +271,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));
-    }
-    for (const arg of args) {
-      this.buildSlashCommandOption(subcommand, arg);
+  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);
     }
-    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 */:
@@ -454,10 +463,10 @@ export {
   BaseContext,
   ChatInputContext,
   Command,
+  CommandAPI,
+  CommandFactory,
   CommandGroupEntry,
   CommandRegistry,
-  HOOKS_KEY,
-  HookExecutionState,
   MessageContext,
   RootCommandEntry,
   SubcommandEntry