@guardbot/framework 1.0.0

package/build/index.mjs

@@ -0,0 +1,665 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/utils/errors.ts
+import { inspect } from "util";
+var messages = {
+  NoOptions: () => `No options object was provided.`,
+  InvalidOption: (name) => `No "${name}" option was provided.`,
+  InvalidType: (name, expected, actual) => `Expected "${name}" to be of type "${expected}", but got "${actual}".`,
+  InvalidValue: (name, expected) => `Expected "${name}" to be any one of the listed values: ${expected.map((v) => `"${v}"`).join(" | ")}`,
+  InvalidValues: (name, expected) => `Expected "${name}" to contain only the listed values: ${expected.map((v) => `"${v}"`).join(" | ")}`,
+  UnknownComponent: (type, id) => `Encountered an error as there is no "${type}" loaded with the id "${id}".`,
+  ComponentLoadError: (type, error) => `Encountered an error while loading the "${type}": 
+${inspect(error)}`,
+  ComponentAlreadyLoaded: (type, id) => `Encountered an error as a "${type}" with the id "${id}" is already loaded.`,
+  AppCommandRegister: (error, guildId) => `Encountered an error while registering commands ${guildId ? `to guild "${guildId}"` : ""}: 
+${inspect(error)}`
+};
+var FrameworkError = class extends Error {
+  constructor(id, ...values) {
+    const message = messages[id](...values);
+    super(message);
+    this.name = `Error [ ${id} ]`;
+  }
+};
+var FrameworkTypeError = class extends TypeError {
+  constructor(id, ...values) {
+    const message = messages[id](...values);
+    super(message);
+    this.name = `TypeError [ ${id} ]`;
+  }
+};
+
+// src/autocomplete/Autocompleter.ts
+function Autocompleter(options) {
+  if (!options) throw new FrameworkError("NoOptions");
+  if (typeof options !== "object") throw new FrameworkTypeError("InvalidType", "options", "object", typeof options);
+  if (!options.name || !options.name?.length) throw new FrameworkError("InvalidOption", "name");
+  if (typeof options.name !== "string") throw new FrameworkTypeError("InvalidType", "name", "string", typeof options.name);
+  if (!options.execute) throw new FrameworkError("InvalidOption", "execute");
+  if (typeof options.execute !== "function") throw new FrameworkTypeError("InvalidType", "execute", "function", typeof options.execute);
+  if (options.disabled !== void 0 && typeof options.disabled !== "boolean") throw new FrameworkTypeError("InvalidType", "disabled", "boolean", typeof options.disabled);
+  return {
+    id: options.name,
+    name: options.name,
+    disabled: options.disabled ?? false,
+    execute: options.execute
+  };
+}
+
+// src/commands/ContextCommand.ts
+import { ApplicationIntegrationType as ApplicationIntegrationType2, InteractionContextType as InteractionContextType2 } from "discord.js";
+
+// src/utils/utils.ts
+import { ApplicationCommandType, ApplicationIntegrationType, InteractionContextType, PermissionsBitField } from "discord.js";
+import path from "path";
+import fs from "fs";
+async function listFiles(dir) {
+  if (!fs.existsSync(dir)) return [];
+  const files = [];
+  const items = fs.readdirSync(dir, { withFileTypes: true });
+  for (const item of items) {
+    const fullPath = path.join(dir, item.name);
+    if (item.isDirectory()) files.push(...await listFiles(fullPath));
+    else if (item.name.endsWith(".js") || item.name.endsWith(".ts")) files.push(fullPath);
+  }
+  return files;
+}
+function isPermissionResolvable(option) {
+  try {
+    PermissionsBitField.resolve(option);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function unixTimestamp(date, type = "f") {
+  return `<t:${Math.floor(new Date(date).valueOf() / 1e3)}:${type}>`;
+}
+function resolveCommandType(type) {
+  return type === "Slash" ? ApplicationCommandType.ChatInput : type === "ContextUser" ? ApplicationCommandType.User : ApplicationCommandType.Message;
+}
+function resolveCommandContexts(contexts) {
+  return contexts?.length ? contexts.map((c) => typeof c === "string" ? InteractionContextType[c] : c) : [InteractionContextType.Guild];
+}
+function resolveIntegrationTypes(types) {
+  return types?.length ? types.map((c) => typeof c === "string" ? ApplicationIntegrationType[c] : c) : [ApplicationIntegrationType.GuildInstall];
+}
+
+// src/commands/Command.ts
+var CommandTypes = ["Slash", "Message", "ContextMessage", "ContextUser"];
+function Command(options) {
+  if (!options) throw new FrameworkError("NoOptions");
+  if (typeof options !== "object") throw new FrameworkTypeError("InvalidType", "options", "object", typeof options);
+  if (!options.name || !options.name?.length) throw new FrameworkError("InvalidOption", "name");
+  if (typeof options.name !== "string") throw new FrameworkTypeError("InvalidType", "name", "string", typeof options.name);
+  if (!options.description || !options.description?.length) throw new FrameworkError("InvalidOption", "description");
+  if (typeof options.description !== "string") throw new FrameworkTypeError("InvalidType", "description", "string", typeof options.name);
+  if (!options.commandType) throw new FrameworkError("InvalidOption", "commandType");
+  if (!CommandTypes.includes(options.commandType)) throw new FrameworkError("InvalidValue", "commandType", CommandTypes);
+  if (options.memberPermissions !== void 0 && !isPermissionResolvable(options.memberPermissions)) throw new FrameworkTypeError("InvalidType", "memberPermissions", "PermissionResolvable", typeof options.memberPermissions);
+  if (options.clientPermissions !== void 0 && !isPermissionResolvable(options.clientPermissions)) throw new FrameworkTypeError("InvalidType", "clientPermissions", "PermissionResolvable", typeof options.clientPermissions);
+  if (options.cooldown && typeof options.cooldown !== "number") throw new FrameworkTypeError("InvalidType", "cooldown", "number", typeof options.cooldown);
+  if (options.disabled !== void 0 && typeof options.disabled !== "boolean") throw new FrameworkTypeError("InvalidType", "disabled", "boolean", typeof options.disabled);
+  return {
+    ...options,
+    id: `${options.commandType}:${options.name}`,
+    name: options.name,
+    description: options.description,
+    commandType: options.commandType,
+    memberPermissions: options.memberPermissions ?? void 0,
+    clientPermissions: options.clientPermissions ?? void 0,
+    cooldown: options.cooldown ?? void 0,
+    disabled: options.disabled ?? false
+  };
+}
+
+// src/commands/ContextCommand.ts
+var CommandScope = ["default", "guild", "global"];
+var CommandTypes2 = ["ContextUser", "ContextMessage"];
+var CommandContexts = ["Guild", "BotDM", "PrivateChannel", 0, 1, 2];
+var IntegrationTypes = ["GuildInstall", "UserInstall", 0, 1];
+function ContextCommand(options) {
+  if (!options.commandType) throw new FrameworkError("InvalidOption", "commandType");
+  if (typeof options.commandScope !== "string" || !CommandTypes2.includes(options.commandType)) throw new FrameworkError("InvalidValue", "commandType", CommandTypes2);
+  if (!options.commandScope) throw new FrameworkError("InvalidOption", "commandScope");
+  if (typeof options.commandScope !== "string" || !CommandScope.includes(options.commandScope)) throw new FrameworkError("InvalidValue", "commandScope", CommandScope);
+  if (options.commandContexts && !Array.isArray(options.commandContexts)) throw new FrameworkTypeError("InvalidType", "commandContexts", "Array", typeof options.commandContexts);
+  if (options.commandContexts && options.commandContexts.some((c) => !CommandContexts.includes(c))) throw new FrameworkError("InvalidValues", "commandContexts", CommandContexts);
+  if (options.integrationTypes && !Array.isArray(options.integrationTypes)) throw new FrameworkTypeError("InvalidType", "integrationTypes", "Array", typeof options.integrationTypes);
+  if (options.integrationTypes && options.integrationTypes.some((c) => !IntegrationTypes.includes(c))) throw new FrameworkError("InvalidValues", "integrationTypes", IntegrationTypes);
+  if (!options.execute) throw new FrameworkError("InvalidOption", "execute");
+  if (typeof options.execute !== "function") throw new FrameworkTypeError("InvalidType", "execute", "function", typeof options.execute);
+  if (!options.commandContexts) options.commandContexts = [InteractionContextType2.Guild];
+  if (!options.integrationTypes) options.integrationTypes = [ApplicationIntegrationType2.GuildInstall];
+  return Command({
+    ...options,
+    commandType: options.commandType
+  });
+}
+
+// src/commands/MessageCommand.ts
+var Contexts = ["BotDM", "Guild"];
+function MessageCommand(options) {
+  if (options.aliases && !Array.isArray(options.aliases)) throw new FrameworkTypeError("InvalidType", "aliases", "array", typeof options.aliases);
+  if (options.usage && typeof options.usage !== "string") throw new FrameworkTypeError("InvalidType", "usage", "string", typeof options.usage);
+  if (options.contexts && !Array.isArray(options.contexts)) throw new FrameworkTypeError("InvalidType", "contexts", "array", typeof options.contexts);
+  if (options.contexts && options.contexts.some((c) => !Contexts.includes(c))) throw new FrameworkError("InvalidValues", "contexts", Contexts);
+  if (!options.execute) throw new FrameworkError("InvalidOption", "execute");
+  if (typeof options.execute !== "function") throw new FrameworkTypeError("InvalidType", "execute", "function", typeof options.execute);
+  if (options.devOnly !== void 0 && typeof options.devOnly !== "boolean") throw new FrameworkTypeError("InvalidType", "devOnly", "boolean", typeof options.devOnly);
+  if (!options.contexts) options.contexts = ["Guild"];
+  if (options.devOnly === void 0) options.devOnly = false;
+  return Command({
+    ...options,
+    commandType: "Message"
+  });
+}
+
+// src/commands/SlashCommand.ts
+import { ApplicationIntegrationType as ApplicationIntegrationType3, InteractionContextType as InteractionContextType3 } from "discord.js";
+var CommandScope2 = ["default", "guild", "global"];
+var CommandContexts2 = ["Guild", "BotDM", "PrivateChannel", 0, 1, 2];
+var IntegrationTypes2 = ["GuildInstall", "UserInstall", 0, 1];
+function SlashCommand(options) {
+  if (!options.commandScope) throw new FrameworkError("InvalidOption", "commandScope");
+  if (typeof options.commandScope !== "string" || !CommandScope2.includes(options.commandScope)) throw new FrameworkError("InvalidValue", "commandScope", CommandScope2);
+  if (options.commandContexts && !Array.isArray(options.commandContexts)) throw new FrameworkTypeError("InvalidType", "commandContexts", "Array", typeof options.commandContexts);
+  if (options.commandContexts && options.commandContexts.some((c) => !CommandContexts2.includes(c))) throw new FrameworkError("InvalidValues", "commandContexts", CommandContexts2);
+  if (options.integrationTypes && !Array.isArray(options.integrationTypes)) throw new FrameworkTypeError("InvalidType", "integrationTypes", "Array", typeof options.integrationTypes);
+  if (options.integrationTypes && options.integrationTypes.some((c) => !IntegrationTypes2.includes(c))) throw new FrameworkError("InvalidType", "integrationTypes", IntegrationTypes2);
+  if (!options.execute) throw new FrameworkError("InvalidOption", "execute");
+  if (typeof options.execute !== "function") throw new FrameworkTypeError("InvalidType", "execute", "function", typeof options.execute);
+  if (!options.commandContexts) options.commandContexts = [InteractionContextType3.Guild];
+  if (!options.integrationTypes) options.integrationTypes = [ApplicationIntegrationType3.GuildInstall];
+  return Command({
+    ...options,
+    commandType: "Slash"
+  });
+}
+
+// src/listeners/Listener.ts
+function Listener(options) {
+  if (!options) throw new FrameworkError("NoOptions");
+  if (typeof options !== "object") throw new FrameworkTypeError("InvalidType", "options", "object", typeof options);
+  if (!options.name || !options.name?.length) throw new FrameworkError("InvalidOption", "name");
+  if (typeof options.name !== "string") throw new FrameworkTypeError("InvalidType", "name", "string", typeof options.name);
+  if (!options.execute) throw new FrameworkError("InvalidOption", "execute");
+  if (typeof options.execute !== "function") throw new FrameworkTypeError("InvalidType", "execute", "function", typeof options.execute);
+  if (options.once !== void 0 && typeof options.once !== "boolean") throw new FrameworkTypeError("InvalidType", "once", "boolean", typeof options.once);
+  if (options.disabled !== void 0 && typeof options.disabled !== "boolean") throw new FrameworkTypeError("InvalidType", "disabled", "boolean", typeof options.disabled);
+  return {
+    id: `Client:${options.name}`,
+    name: options.name,
+    once: options.once ?? false,
+    disabled: options.disabled ?? false,
+    execute: options.execute
+  };
+}
+
+// src/FrameworkClient.ts
+import { Collection as Collection2, Client as DiscordClient } from "discord.js";
+
+// src/autocomplete/AutocompleteModule.ts
+import { pathToFileURL } from "url";
+import EventEmitter from "events";
+import path2 from "path";
+var AutocompleteModule = class extends EventEmitter {
+  client;
+  constructor(client) {
+    super();
+    this.client = client;
+    this.client.on("interactionCreate", (interaction) => this._handleInteraction(interaction));
+  }
+  async load(filepath, reload = false) {
+    const completerModule = await import(pathToFileURL(filepath).href);
+    const completer = completerModule.autocomplete ?? completerModule.default ?? completerModule;
+    if (typeof completer !== "object" || !completer.name || completer.disabled) return false;
+    if (!reload && this.client.autocomplete.has(completer.id)) throw new FrameworkError("ComponentAlreadyLoaded", "autocomplete", completer.id);
+    completer.filepath = filepath;
+    this.client.autocomplete.set(completer.id, completer);
+    return true;
+  }
+  async loadAll() {
+    const listenerDirs = path2.resolve(this.client.rootDir, "autocomplete");
+    const files = await listFiles(listenerDirs);
+    for (const file of files) {
+      try {
+        await this.load(path2.resolve(file));
+      } catch (error) {
+        this.client.emit("error", new FrameworkError("ComponentLoadError", "autocomplete", error));
+      }
+    }
+  }
+  reload(id) {
+    const completer = this.client.autocomplete.get(id);
+    if (!completer) throw new FrameworkError("UnknownComponent", "autocomplete", id);
+    this.unload(id, true);
+    this.load(completer.filepath, true);
+  }
+  unload(id, reload = false) {
+    if (!this.client.autocomplete.has(id)) throw new FrameworkError("UnknownComponent", "autocomplete", id);
+    const completer = this.client.autocomplete.get(id);
+    delete __require.cache[completer.filepath];
+    if (!reload) this.client.autocomplete.delete(id);
+  }
+  async _handleInteraction(interaction) {
+    if (!interaction.isAutocomplete()) return;
+    const option = interaction.options.getFocused(true);
+    const command = this.client.commands.get(`Slash:${interaction.commandName}`);
+    const completer = this.client.autocomplete.get(option.name);
+    if (!option || !command || command.commandType !== "Slash") {
+      this.emit("unknown", interaction);
+      return;
+    }
+    if (completer && !completer.disabled) {
+      try {
+        this.emit("execute", { interaction, command, completer });
+        await completer.execute(this.client, interaction, command, option.value);
+        this.emit("success", { interaction, command, completer });
+      } catch (error) {
+        this.emit("success", { interaction, command, completer, error });
+      }
+    } else if (typeof command.autocomplete === "function" && !command.disabled) {
+      try {
+        this.emit("execute", { interaction, command, completer });
+        await command.autocomplete(this.client, interaction);
+        this.emit("success", { interaction, command, completer });
+      } catch (error) {
+        this.emit("success", { interaction, command, completer, error });
+      }
+    } else {
+      this.emit("unknown", interaction);
+    }
+  }
+};
+
+// src/listeners/ListenersModule.ts
+import { pathToFileURL as pathToFileURL2 } from "url";
+import path3 from "path";
+var ListenerModule = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async load(filepath, reload = false) {
+    const listenerModule = await import(pathToFileURL2(filepath).href);
+    const listener = listenerModule.listener ?? listenerModule.default ?? listenerModule;
+    if (typeof listener !== "object" || !listener.name || listener.disabled) return false;
+    if (!reload && this.client.events.has(listener.id)) throw new FrameworkError("ComponentAlreadyLoaded", "listener", listener.id);
+    listener.filepath = filepath;
+    listener._execute = (...args) => listener.execute(...args);
+    this.client[listener.once ? "once" : "on"](listener.name, listener._execute);
+    this.client.events.set(listener.id, listener);
+    return true;
+  }
+  async loadAll() {
+    const listenerDirs = path3.resolve(this.client.rootDir, "listeners");
+    const files = await listFiles(listenerDirs);
+    for (const file of files) {
+      try {
+        await this.load(path3.resolve(file));
+      } catch (error) {
+        this.client.emit("error", new FrameworkError("ComponentLoadError", "listener", error));
+      }
+    }
+  }
+  reload(id) {
+    if (!this.client.events.has(id)) throw new FrameworkError("UnknownComponent", "listener", id);
+    const listener = this.client.events.get(id);
+    this.unload(id, true);
+    this.load(listener.filepath, true);
+  }
+  unload(id, reload = false) {
+    if (!this.client.events.has(id)) throw new FrameworkError("UnknownComponent", "listener", id);
+    const listener = this.client.events.get(id);
+    if (listener._execute) this.client.off(listener.name, listener._execute);
+    delete __require.cache[listener.filepath];
+    if (!reload) this.client.events.delete(id);
+  }
+};
+
+// src/commands/CommandsModule.ts
+import { Collection, MessageFlags } from "discord.js";
+import { pathToFileURL as pathToFileURL3 } from "url";
+import EventEmitter2 from "events";
+import path4 from "path";
+var CommandsModule = class extends EventEmitter2 {
+  client;
+  handler = {};
+  constructor(client) {
+    super();
+    this.client = client;
+    this.client.on("messageCreate", (message) => this._handleMessage(message));
+    this.client.on("interactionCreate", (interaction) => this._handleInteraction(interaction));
+  }
+  setHandler(key, callback) {
+    return this.handler[key] = callback;
+  }
+  setMessageInterceptor(callback) {
+    return this.handler.MessageCommandInterceptor = callback;
+  }
+  setInteractionInterceptor(callback) {
+    return this.handler.InteractionCommandInterceptor = callback;
+  }
+  async load(filepath, reload = false) {
+    const commandModule = await import(pathToFileURL3(filepath).href);
+    const command = commandModule?.command ?? commandModule?.default?.default ?? commandModule?.default ?? commandModule;
+    if (typeof command !== "object" || !command.name || command.disabled) return false;
+    if (!reload && this.client.commands.has(command.id)) throw new FrameworkError("ComponentAlreadyLoaded", "command", command.id);
+    command.filepath = filepath;
+    this.client.commands.set(command.id, command);
+    if (command.commandType === "Message" && Array.isArray(command.aliases)) command.aliases.forEach((alias) => {
+      if (typeof alias === "string" && !this.client.aliases.get(alias)) this.client.aliases.set(alias, command.id);
+    });
+    return true;
+  }
+  async loadAll() {
+    const commandsDir = path4.resolve(this.client.rootDir, "commands");
+    const files = await listFiles(commandsDir);
+    for (const file of files) {
+      try {
+        await this.load(path4.resolve(file));
+      } catch (error) {
+        this.client.emit("error", new FrameworkError("ComponentLoadError", "commands", error));
+      }
+    }
+  }
+  reload(id) {
+    if (!this.client.commands.has(id)) throw new FrameworkError("UnknownComponent", "commands", id);
+    const command = this.client.commands.get(id);
+    this.unload(id, true);
+    this.load(command.filepath, true);
+  }
+  unload(id, reload = false) {
+    if (!this.client.commands.has(id)) throw new FrameworkError("UnknownComponent", "commands", id);
+    const command = this.client.commands.get(id);
+    delete __require.cache[command.filepath];
+    if (!reload) this.client.commands.delete(id);
+  }
+  async registerOnStart(guildIds, commands) {
+    for (const guildId of guildIds) {
+      try {
+        await this.publishGuild(guildId, commands);
+      } catch (error) {
+        this.client.emit("error", new FrameworkError("AppCommandRegister", error, guildId));
+      }
+    }
+  }
+  async publishGlobal(commands) {
+    if (!this.client.application) return false;
+    const commandsToSet = (commands ?? this.client.commands).filter((c) => c.commandType !== "Message" && c.commandScope !== "guild" && !c.disabled).map((c) => this._getCommandData(c));
+    return this.client.application.commands.set(commandsToSet);
+  }
+  async publishGuild(guildId, commands) {
+    const commandsToSet = (commands ?? this.client.commands).filter((c) => c.commandType !== "Message" && c.commandScope !== "global" && !c.disabled).map((c) => this._getCommandData(c));
+    const guild = await this.client.guilds.fetch({ guild: guildId, force: false });
+    if (guild) guild.commands.set(commandsToSet);
+  }
+  async _handleMessage(message) {
+    if (!message.content?.length || message.author.bot) return;
+    if (this.handler.MessageCommandInterceptor) {
+      const shouldContinue = await this.handler.MessageCommandInterceptor(message);
+      if (!shouldContinue) return;
+    }
+    const prefixRegex = new RegExp(`^(<@!?${message.client.user.id}>${this.client.prefix ? `|${this.client.prefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}` : ""})\\s*`);
+    if (!prefixRegex.test(message.content.toLowerCase())) return;
+    const matchedPrefix = message.content.toLowerCase().match(prefixRegex)?.[1];
+    if (!matchedPrefix) return;
+    const args = (message.content || "").slice(matchedPrefix.length).trim().split(/ +/);
+    const commandName = args.shift()?.toLowerCase();
+    if (!commandName) return;
+    const commandId = `Message:${commandName}`;
+    const command = this.client.commands.get(commandId) || this.client.commands.get(this.client.aliases.get(commandId) || "");
+    if (!command || command.commandType !== "Message" || command.disabled || command.devOnly && !this.client.developers.includes(message.author.id)) return;
+    if (!message.inGuild() && !command.contexts.includes("BotDM") || message.inGuild() && !command.contexts.includes("Guild")) return;
+    if (message.inGuild() && command.memberPermissions) {
+      const executor = await message.guild.members.fetch({ user: message.author.id, force: false });
+      const memberPerms = executor.permissionsIn(message.channel) ?? executor.permissions;
+      if (!memberPerms.has(command.memberPermissions)) {
+        const missingPermsArray = memberPerms.missing(command.memberPermissions);
+        if (typeof this.handler.onMemberPermissions === "function") return this.handler.onMemberPermissions(message, command, missingPermsArray);
+        else return await message.reply({ content: "\u274C You don't have the required permission(s) to use this command." }).then((m) => {
+          setTimeout(() => m.delete().catch((e) => null), 1e4);
+        }).catch(() => null);
+      }
+    }
+    if (message.inGuild() && command.clientPermissions) {
+      const clientMember = await message.guild.members.fetchMe({ force: false });
+      const clientPerms = clientMember.permissionsIn(message.channel) ?? clientMember.permissions;
+      if (!clientMember.permissions.has(command.clientPermissions)) {
+        const missingPermsArray = clientPerms.missing(command.clientPermissions);
+        if (typeof this.handler.onClientPermissions === "function") return this.handler.onClientPermissions(message, command, missingPermsArray);
+        else return await message.reply({ content: `\u274C ${clientMember.displayName} requires ${missingPermsArray.map((p) => `\` ${p.replace(/([A-Z])/g, (_, l, i) => i === 0 ? l : ` ${l}`)} \``).join(" ")} permission(s) to run this command.` }).then((m) => {
+          setTimeout(() => m.delete().catch((e) => null), 1e4);
+        }).catch(() => null);
+      }
+    }
+    if (command.cooldown && command.cooldown > 1e3) {
+      if (!this.client.cooldowns.has(commandId)) this.client.cooldowns.set(commandId, new Collection());
+      const commandCooldowns = this.client.cooldowns.get(commandId);
+      if (commandCooldowns) {
+        if (commandCooldowns.has(message.author.id)) {
+          const expirationDate = new Date((commandCooldowns.get(message.author.id) || 0) + command.cooldown);
+          if (expirationDate.valueOf() - Date.now() > 1e3) {
+            if (typeof this.handler.onCooldown === "function") return this.handler.onCooldown(message, command, expirationDate);
+            else return await message.reply({ content: `\u274C Slow down and try the Command Again **${unixTimestamp(new Date(expirationDate), "R")}**.` }).then((m) => {
+              setTimeout(() => m.delete().catch((e) => null), expirationDate.valueOf() - Date.now());
+            });
+          }
+        }
+        commandCooldowns.set(message.author.id, (/* @__PURE__ */ new Date()).valueOf());
+        setTimeout(() => commandCooldowns.delete(message.author.id), command.cooldown);
+      }
+    }
+    try {
+      this.emit("execute", { context: message, command });
+      await command.execute(this.client, message, args);
+      this.emit("success", { context: message, command });
+    } catch (error) {
+      this.emit("error", { context: message, command, error });
+    }
+  }
+  async _handleInteraction(interaction) {
+    if (!interaction.isChatInputCommand() && !interaction.isContextMenuCommand()) return;
+    if (this.handler.InteractionCommandInterceptor) {
+      const shouldContinue = await this.handler.InteractionCommandInterceptor(interaction);
+      if (!shouldContinue) return;
+    }
+    const commandId = `${this._getCommandId(interaction)}:${interaction.commandName}`;
+    const command = this.client.commands.get(commandId);
+    if (!command || command.disabled || command.commandType === "Message") {
+      this.emit("unknown", interaction);
+      return;
+    }
+    if (interaction.guild && interaction.channel && !interaction.channel.isDMBased() && command.clientPermissions) {
+      const clientMember = await interaction.guild.members.fetchMe({ force: false });
+      const clientPerms = interaction.channel.isSendable() ? clientMember.permissionsIn(interaction.channel) : clientMember.permissions;
+      if (!clientPerms.has(command.clientPermissions)) {
+        const missingPermsArray = clientPerms.missing(command.clientPermissions);
+        if (typeof this.handler.onClientPermissions === "function") return this.handler.onClientPermissions(interaction, command, missingPermsArray);
+        else return await interaction.reply({ content: `\u274C ${clientMember.displayName} requires ${missingPermsArray.map((p) => `\` ${p.replace(/([A-Z])/g, (_, l, i) => i === 0 ? l : ` ${l}`)} \``).join(" ")} permission(s) to run this command.`, flags: MessageFlags.Ephemeral });
+      }
+    }
+    if (command.cooldown && command.cooldown > 1e3) {
+      if (!this.client.cooldowns.has(commandId)) this.client.cooldowns.set(commandId, new Collection());
+      const commandCooldowns = this.client.cooldowns.get(commandId);
+      if (commandCooldowns) {
+        if (commandCooldowns.has(interaction.user.id)) {
+          const expirationDate = new Date((commandCooldowns.get(interaction.user.id) || 0) + command.cooldown);
+          if (expirationDate.valueOf() - Date.now() > 1e3) {
+            if (typeof this.handler.onCooldown === "function") return this.handler.onCooldown(interaction, command, expirationDate);
+            else return await interaction.reply({ content: `\u274C Slow down and try the Command Again **${unixTimestamp(new Date(expirationDate), "R")}**.`, flags: MessageFlags.Ephemeral });
+          }
+        }
+        commandCooldowns.set(interaction.user.id, (/* @__PURE__ */ new Date()).valueOf());
+        setTimeout(() => commandCooldowns.delete(interaction.user.id), command.cooldown);
+      }
+    }
+    try {
+      this.emit("execute", { context: interaction, command });
+      await command.execute(this.client, interaction);
+      this.emit("success", { context: interaction, command });
+    } catch (error) {
+      this.emit("error", { context: interaction, command, error });
+    }
+  }
+  _getCommandId(interaction) {
+    if (interaction.isChatInputCommand()) return "Slash";
+    else if (interaction.isUserContextMenuCommand()) return "ContextUser";
+    else if (interaction.isMessageContextMenuCommand()) return "ContextMessage";
+    return "unknown";
+  }
+  _getCommandData(command) {
+    return {
+      name: command.name,
+      description: command.description,
+      type: resolveCommandType(command.commandType),
+      defaultMemberPermissions: command.memberPermissions ?? null,
+      contexts: resolveCommandContexts(command.commandContexts),
+      integrationTypes: resolveIntegrationTypes(command.integrationTypes),
+      nameLocalizations: command.nameLocalizations,
+      descriptionLocalizations: command.descriptionLocalizations,
+      ...command.commandType === "Slash" ? { options: command.options ?? [] } : {}
+    };
+  }
+};
+
+// src/FrameworkClient.ts
+import fs2 from "fs";
+var FrameworkClient = class extends DiscordClient {
+  rootDir;
+  prefix;
+  developers;
+  constructor(frameworkOptions) {
+    super(frameworkOptions.clientOptions);
+    this.prefix = frameworkOptions.prefix ?? "!";
+    this.rootDir = frameworkOptions.rootDir ?? (fs2.existsSync("./src") ? "./src" : "./");
+    this.developers = frameworkOptions.developers || [];
+    this.autocomplete = new Collection2();
+    this.events = new Collection2();
+    this.aliases = new Collection2();
+    this.commands = new Collection2();
+    this.cooldowns = new Collection2();
+    this.autocompleteModule = new AutocompleteModule(this);
+    this.listenerModule = new ListenerModule(this);
+    this.commandsModule = new CommandsModule(this);
+    this.on("interactionCreate", (interaction) => {
+      if (interaction.isAnySelectMenu()) return this.emit("selectMenuInteraction", interaction);
+      else if (interaction.isModalSubmit()) return this.emit("modalSubmitInteraction", interaction);
+      else if (interaction.isButton()) return this.emit("buttonInteraction", interaction);
+    });
+    this.once("clientReady", async () => {
+      if (frameworkOptions.registerOnStart && frameworkOptions.guildsToRegister?.length) {
+        await this.commandsModule.registerOnStart(frameworkOptions.guildsToRegister);
+      }
+    });
+  }
+  async start(token) {
+    await this.autocompleteModule.loadAll();
+    await this.commandsModule.loadAll();
+    await this.listenerModule.loadAll();
+    await this.login(token);
+  }
+};
+
+// src/extensions/Message.ts
+import { Message as Message2, MessageCollector, InteractionCollector, InteractionType } from "discord.js";
+function prefix() {
+  return this.client.prefix;
+}
+function isDeveloper() {
+  return this.client.developers.includes(this.author.id);
+}
+function awaitMemberResponse(options = {}) {
+  return new Promise((resolve, reject) => {
+    if (!this.channel) {
+      return reject(new Error("Channel not available for this message."));
+    }
+    const collector = new MessageCollector(this.channel, {
+      time: 6e4,
+      filter: (m) => m.author.id === this.author.id && (m.content || "").length > 0,
+      ...options,
+      max: 1
+    });
+    collector.on("end", (messages2, reason) => {
+      const message = messages2.first();
+      if (message) {
+        if (options.deleteMessage) message.delete().catch(() => null);
+        resolve(message);
+      } else {
+        reject(new Error(reason));
+      }
+    });
+  });
+}
+function createModalSubmitCollector(options = {}) {
+  return new InteractionCollector(this.client, {
+    ...options,
+    interactionType: InteractionType.ModalSubmit,
+    message: this
+  });
+}
+function awaitModalSubmitComponent(options = {}) {
+  return new Promise((resolve, reject) => {
+    const collector = new InteractionCollector(this.client, {
+      time: 6e4,
+      filter: (i) => i.user.id === this.author.id,
+      ...options,
+      interactionType: InteractionType.ModalSubmit,
+      message: this,
+      max: 1
+    });
+    collector.on("end", (interactions, reason) => {
+      const interaction = interactions.first();
+      if (interaction) resolve(interaction);
+      else reject(new Error(reason));
+    });
+  });
+}
+Object.defineProperties(Message2.prototype, {
+  prefix: { get: prefix, configurable: true },
+  isDeveloper: { value: isDeveloper, writable: true, configurable: true },
+  awaitMemberResponse: { value: awaitMemberResponse, writable: true, configurable: true },
+  createModalSubmitCollector: { value: createModalSubmitCollector, writable: true, configurable: true },
+  awaitModalSubmitComponent: { value: awaitModalSubmitComponent, writable: true, configurable: true }
+});
+
+// src/Builders.ts
+import {
+  SlashCommandAttachmentOption,
+  SlashCommandBooleanOption,
+  SlashCommandChannelOption,
+  SlashCommandIntegerOption,
+  SlashCommandMentionableOption,
+  SlashCommandNumberOption,
+  SlashCommandRoleOption,
+  SlashCommandStringOption,
+  SlashCommandSubcommandBuilder,
+  SlashCommandSubcommandGroupBuilder,
+  SlashCommandOptionsOnlyBuilder
+} from "discord.js";
+export {
+  SlashCommandAttachmentOption as AttachmentOption,
+  Autocompleter,
+  SlashCommandBooleanOption as BooleanOption,
+  SlashCommandChannelOption as ChannelOption,
+  ContextCommand,
+  FrameworkClient,
+  SlashCommandIntegerOption as IntegerOption,
+  Listener,
+  SlashCommandMentionableOption as MentionableOption,
+  MessageCommand,
+  SlashCommandNumberOption as NumberOption,
+  SlashCommandRoleOption as RoleOption,
+  SlashCommand,
+  SlashCommandOptionsOnlyBuilder as SlashCommandOptionsBuilder,
+  SlashCommandStringOption as StringOption,
+  SlashCommandSubcommandBuilder as SubcommandBuilder,
+  SlashCommandSubcommandGroupBuilder as SubcommandGroupBuilder
+};