bakit 1.0.0-beta.8 → 2.0.0-alpha.1

package/dist/command/index.js

@@ -1,473 +0,0 @@
-// 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/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/CommandRegistry.ts
-import {
-  Collection as Collection2,
-  SlashCommandBuilder,
-  SlashCommandSubcommandBuilder,
-  SlashCommandSubcommandGroupBuilder
-} from "discord.js";
-import glob from "tiny-glob";
-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) {
-      throw new Error(`No root found for "${constructor.name}"`);
-    }
-    const { options } = root;
-    this.constructors.set(options.name, constructor);
-    this.instances.set(options.name, new constructor());
-  }
-  /**
-   * 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();
-      const { default: constructor } = await import(fileURL);
-      _CommandRegistry.add(constructor);
-      return constructor;
-    });
-    if (parallel) {
-      return await Promise.all(loaders);
-    }
-    const result = [];
-    for (const loader of loaders) {
-      result.push(await loader);
-    }
-    return result;
-  }
-  /**
-   * 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 { 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);
-    }
-    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);
-        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 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);
-    }
-  }
-  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((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((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((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 */:
-      case "member" /* Member */: {
-        builder.addUserOption((option) => setupOption(option));
-        break;
-      }
-    }
-  }
-};
-
-// src/command/Context.ts
-import {
-  ChatInputCommandInteraction,
-  Message
-} from "discord.js";
-var BaseContext = class {
-  constructor(source) {
-    this.source = source;
-  }
-  get client() {
-    return this.source.client;
-  }
-  get channel() {
-    return this.source.channel;
-  }
-  get channelId() {
-    return this.source.channelId;
-  }
-  get guild() {
-    return this.source.guild;
-  }
-  get guildId() {
-    return this.source.guildId;
-  }
-  inGuild() {
-    return Boolean(this.guildId);
-  }
-  inCachedGuild() {
-    if (this.isChatInput()) {
-      return this.source.inCachedGuild();
-    } else if (this.isMessage()) {
-      return this.source.inGuild();
-    } else {
-      throw new Error("Invalid source");
-    }
-  }
-  get author() {
-    if (this.isChatInput()) {
-      return this.source.user;
-    } else if (this.isMessage()) {
-      return this.source.author;
-    } else {
-      throw new Error("Invalid source");
-    }
-  }
-  isChatInput() {
-    return this.source instanceof ChatInputCommandInteraction;
-  }
-  isMessage() {
-    return this.source instanceof Message;
-  }
-};
-var ChatInputContext = class extends BaseContext {
-  async send(options) {
-    if (typeof options === "string") {
-      options = { content: options };
-    }
-    const sendOptions = {
-      ...options,
-      withResponse: true
-    };
-    if (this.source.deferred || this.source.replied) {
-      return await this.source.followUp(sendOptions);
-    }
-    const response = await this.source.reply(sendOptions);
-    return response.resource?.message;
-  }
-};
-var MessageContext = class extends BaseContext {
-  async send(options) {
-    const { channel } = this;
-    if (!channel?.isSendable()) {
-      throw new Error("Invalid channel or channel is not sendable");
-    }
-    return await channel.send(options);
-  }
-};
-export {
-  Arg,
-  ArgumentType,
-  BaseCommandEntry,
-  BaseCommandGroupEntry,
-  BaseContext,
-  ChatInputContext,
-  Command,
-  CommandAPI,
-  CommandFactory,
-  CommandGroupEntry,
-  CommandRegistry,
-  MessageContext,
-  RootCommandEntry,
-  SubcommandEntry
-};