commandkit 0.0.9 → 0.1.0

package/dist/index.js

@@ -1,17 +1,654 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./CommandKit"), exports);
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  CommandKit: () => CommandKit,
+  CommandType: () => CommandType
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/utils/get-paths.ts
+var import_path = __toESM(require("path"));
+var import_fs = __toESM(require("fs"));
+function getFilePaths(directory, nesting) {
+  let filePaths = [];
+  if (!directory)
+    return filePaths;
+  const files = import_fs.default.readdirSync(directory, { withFileTypes: true });
+  for (const file of files) {
+    const filePath = import_path.default.join(directory, file.name);
+    if (file.isFile()) {
+      filePaths.push(filePath);
+    }
+    if (nesting && file.isDirectory()) {
+      filePaths = [...filePaths, ...getFilePaths(filePath, true)];
+    }
+  }
+  return filePaths;
+}
+function getFolderPaths(directory, nesting) {
+  let folderPaths = [];
+  if (!directory)
+    return folderPaths;
+  const folders = import_fs.default.readdirSync(directory, { withFileTypes: true });
+  for (const folder of folders) {
+    const folderPath = import_path.default.join(directory, folder.name);
+    if (folder.isDirectory()) {
+      folderPaths.push(folderPath);
+      if (nesting) {
+        folderPaths = [...folderPaths, ...getFolderPaths(folderPath, true)];
+      }
+    }
+  }
+  return folderPaths;
+}
+
+// src/utils/resolve-file-url.ts
+var import_path2 = __toESM(require("path"));
+function toFileURL(filePath) {
+  const resolvedPath = import_path2.default.resolve(filePath);
+  return "file://" + resolvedPath.replace(/\\/g, "/");
+}
+
+// src/handlers/command-handler/validations/botPermissions.ts
+function botPermissions_default({ interaction, targetCommand }) {
+  const botMember = interaction.guild?.members.me;
+  let commandPermissions = targetCommand.options?.botPermissions;
+  if (!botMember || !commandPermissions)
+    return;
+  if (!Array.isArray(commandPermissions)) {
+    commandPermissions = [commandPermissions];
+  }
+  const missingPermissions = [];
+  for (const permission of commandPermissions) {
+    const hasPermission = botMember.permissions.has(permission);
+    if (!hasPermission) {
+      missingPermissions.push(`\`${permission.toString()}\``);
+    }
+  }
+  if (missingPermissions.length) {
+    interaction.reply({
+      content: `\u274C I do not have enough permissions to execute this command. Missing: ${missingPermissions.join(
+        ", "
+      )}`,
+      ephemeral: true
+    });
+    return true;
+  }
+}
+
+// src/handlers/command-handler/validations/devOnly.ts
+function devOnly_default({ interaction, targetCommand, handlerData }) {
+  if (targetCommand.options?.devOnly) {
+    if (interaction.inGuild() && !handlerData.devGuildIds.includes(interaction.guildId)) {
+      interaction.reply({
+        content: "\u274C This command can only be used inside development servers.",
+        ephemeral: true
+      });
+      return true;
+    }
+    const guildMember = interaction.guild?.members.cache.get(interaction.user.id);
+    const memberRoles = guildMember?.roles.cache;
+    let hasDevRole = false;
+    memberRoles?.forEach((role) => {
+      if (handlerData.devRoleIds?.includes(role.id)) {
+        hasDevRole = true;
+      }
+    });
+    const isDevUser = handlerData.devUserIds.includes(interaction.user.id) || hasDevRole;
+    if (!isDevUser) {
+      interaction.reply({
+        content: "\u274C This command can only be used by developers.",
+        ephemeral: true
+      });
+      return true;
+    }
+  }
+}
+
+// src/handlers/command-handler/validations/guildOnly.ts
+function guildOnly_default({ interaction, targetCommand }) {
+  if (targetCommand.options?.guildOnly && !interaction.inGuild()) {
+    interaction.reply({
+      content: "\u274C This command can only be used inside a server.",
+      ephemeral: true
+    });
+    return true;
+  }
+}
+
+// src/handlers/command-handler/validations/userPermissions.ts
+function userPermissions_default({ interaction, targetCommand }) {
+  const memberPermissions = interaction.memberPermissions;
+  let commandPermissions = targetCommand.options?.userPermissions;
+  if (!memberPermissions || !commandPermissions)
+    return;
+  if (!Array.isArray(commandPermissions)) {
+    commandPermissions = [commandPermissions];
+  }
+  const missingPermissions = [];
+  for (const permission of commandPermissions) {
+    const hasPermission = memberPermissions.has(permission);
+    if (!hasPermission) {
+      missingPermissions.push(`\`${permission.toString()}\``);
+    }
+  }
+  if (missingPermissions.length) {
+    interaction.reply({
+      content: `\u274C You do not have enough permissions to run this command. Missing: ${missingPermissions.join(
+        ", "
+      )}`,
+      ephemeral: true
+    });
+    return true;
+  }
+}
+
+// src/handlers/command-handler/validations/index.ts
+var validations_default = [botPermissions_default, devOnly_default, guildOnly_default, userPermissions_default];
+
+// src/handlers/command-handler/utils/areSlashCommandsDifferent.ts
+function areSlashCommandsDifferent(appCommand, localCommand) {
+  if (!appCommand.options)
+    appCommand.options = [];
+  if (!localCommand.options)
+    localCommand.options = [];
+  if (!appCommand.description)
+    appCommand.description = "";
+  if (!localCommand.description)
+    localCommand.description = "";
+  if (localCommand.description !== appCommand.description || localCommand.options.length !== appCommand.options.length) {
+    return true;
+  }
+}
+
+// src/handlers/command-handler/functions/registerCommands.ts
+var import_safe = __toESM(require("colors/safe"));
+async function registerCommands(commandHandler) {
+  const client = commandHandler._data.client;
+  const devGuildIds = commandHandler._data.devGuildIds;
+  const commands = commandHandler._data.commands;
+  client.once("ready", async () => {
+    const devGuilds = [];
+    for (const devGuildId of devGuildIds) {
+      const guild = client.guilds.cache.get(devGuildId);
+      if (!guild) {
+        console.log(
+          import_safe.default.yellow(
+            `\u23E9 Ignoring: Guild ${devGuildId} does not exist or client isn't in this guild.`
+          )
+        );
+        continue;
+      }
+      devGuilds.push(guild);
+    }
+    const appCommands = client.application?.commands;
+    await appCommands?.fetch();
+    const devGuildCommands = [];
+    for (const guild of devGuilds) {
+      const guildCommands = guild.commands;
+      await guildCommands?.fetch();
+      devGuildCommands.push(guildCommands);
+    }
+    for (const command of commands) {
+      let commandData = command.data;
+      if (command.options?.deleted) {
+        const targetCommand = appCommands?.cache.find(
+          (cmd) => cmd.name === commandData.name
+        );
+        if (!targetCommand) {
+          console.log(
+            import_safe.default.yellow(
+              `\u23E9 Ignoring: Command "${commandData.name}" is globally marked as deleted.`
+            )
+          );
+        } else {
+          targetCommand.delete().then(() => {
+            console.log(
+              import_safe.default.green(`\u{1F6AE} Deleted command "${commandData.name}" globally.`)
+            );
+          });
+        }
+        for (const guildCommands of devGuildCommands) {
+          const targetCommand2 = guildCommands.cache.find(
+            (cmd) => cmd.name === commandData.name
+          );
+          if (!targetCommand2) {
+            console.log(
+              import_safe.default.yellow(
+                `\u23E9 Ignoring: Command "${commandData.name}" is marked as deleted for ${guildCommands.guild.name}.`
+              )
+            );
+          } else {
+            targetCommand2.delete().then(() => {
+              console.log(
+                import_safe.default.green(
+                  `\u{1F6AE} Deleted command "${commandData.name}" in ${guildCommands.guild.name}.`
+                )
+              );
+            });
+          }
+        }
+        continue;
+      }
+      let editedCommand = false;
+      const appGlobalCommand = appCommands?.cache.find(
+        (cmd) => cmd.name === commandData.name
+      );
+      if (appGlobalCommand) {
+        const commandsAreDifferent = areSlashCommandsDifferent(
+          appGlobalCommand,
+          commandData
+        );
+        if (commandsAreDifferent) {
+          appGlobalCommand.edit(commandData).then(() => {
+            console.log(
+              import_safe.default.green(`\u2705 Edited command "${commandData.name}" globally.`)
+            );
+          }).catch((error) => {
+            console.log(
+              import_safe.default.red(
+                `\u274C Failed to edit command "${commandData.name}" globally.`
+              )
+            );
+            console.error(error);
+          });
+          editedCommand = true;
+        }
+      }
+      for (const guildCommands of devGuildCommands) {
+        const appGuildCommand = guildCommands.cache.find(
+          (cmd) => cmd.name === commandData.name
+        );
+        if (appGuildCommand) {
+          const commandsAreDifferent = areSlashCommandsDifferent(
+            appGuildCommand,
+            commandData
+          );
+          if (commandsAreDifferent) {
+            appGuildCommand.edit(commandData).then(() => {
+              console.log(
+                import_safe.default.green(
+                  `\u2705 Edited command "${commandData.name}" in ${guildCommands.guild.name}.`
+                )
+              );
+            }).catch((error) => {
+              console.log(
+                import_safe.default.red(
+                  `\u274C Failed to edit command "${commandData.name}" in ${guildCommands.guild.name}.`
+                )
+              );
+              console.error(error);
+            });
+            editedCommand = true;
+          }
+        }
+      }
+      if (editedCommand)
+        continue;
+      if (command.options?.devOnly) {
+        if (!devGuilds.length) {
+          console.log(
+            import_safe.default.yellow(
+              `\u23E9 Ignoring: Cannot register command "${commandData.name}" as no valid "devGuildIds" were provided.`
+            )
+          );
+          continue;
+        }
+        for (const guild of devGuilds) {
+          const cmdExists = guild.commands.cache.some(
+            (cmd) => cmd.name === commandData.name
+          );
+          if (cmdExists)
+            continue;
+          guild?.commands.create(commandData).then(() => {
+            console.log(
+              import_safe.default.green(
+                `\u2705 Registered command "${commandData.name}" in ${guild.name}.`
+              )
+            );
+          }).catch((error) => {
+            console.log(
+              import_safe.default.red(
+                `\u274C Failed to register command "${commandData.name}" in ${guild.name}.`
+              )
+            );
+            console.error(error);
+          });
+        }
+      } else {
+        const cmdExists = appCommands?.cache.some((cmd) => cmd.name === commandData.name);
+        if (cmdExists)
+          continue;
+        appCommands?.create(commandData).then(() => {
+          console.log(
+            import_safe.default.green(`\u2705 Registered command "${commandData.name}" globally.`)
+          );
+        }).catch((error) => {
+          console.log(
+            import_safe.default.red(
+              `\u274C Failed to register command "${commandData.name}" globally.`
+            )
+          );
+          console.error(error);
+        });
+      }
+    }
+  });
+}
+
+// src/handlers/command-handler/functions/handleCommands.ts
+function handleCommands(commandHandler) {
+  const client = commandHandler._data.client;
+  const handler = commandHandler._data.commandKitInstance;
+  client.on("interactionCreate", async (interaction) => {
+    if (!interaction.isChatInputCommand() && !interaction.isContextMenuCommand())
+      return;
+    const targetCommand = commandHandler._data.commands.find(
+      (cmd) => cmd.data.name === interaction.commandName
+    );
+    if (!targetCommand)
+      return;
+    const { data, options, run, ...rest } = targetCommand;
+    const commandObj = {
+      data: targetCommand.data,
+      options: targetCommand.options,
+      ...rest
+    };
+    let canRun = true;
+    for (const validationFunction of commandHandler._data.customValidations) {
+      const stopValidationLoop = await validationFunction({
+        interaction,
+        client,
+        commandObj,
+        handler
+      });
+      if (stopValidationLoop) {
+        canRun = false;
+        break;
+      }
+    }
+    if (!canRun)
+      return;
+    if (!commandHandler._data.skipBuiltInValidations) {
+      for (const validation of commandHandler._data.builtInValidations) {
+        const stopValidationLoop = validation({
+          targetCommand,
+          interaction,
+          handlerData: commandHandler._data
+        });
+        if (stopValidationLoop) {
+          canRun = false;
+          break;
+        }
+      }
+    }
+    if (!canRun)
+      return;
+    targetCommand.run({ interaction, client, handler });
+  });
+}
+
+// src/handlers/command-handler/CommandHandler.ts
+var import_safe2 = __toESM(require("colors/safe"));
+var CommandHandler = class {
+  _data;
+  constructor({ ...options }) {
+    this._data = {
+      ...options,
+      builtInValidations: [],
+      commands: []
+    };
+  }
+  async init() {
+    await this.#buildCommands();
+    this.#buildValidations();
+    await this.#registerCommands();
+    this.#handleCommands();
+  }
+  async #buildCommands() {
+    const commandFilePaths = getFilePaths(this._data.commandsPath, true).filter(
+      (path3) => path3.endsWith(".js") || path3.endsWith(".ts")
+    );
+    for (const commandFilePath of commandFilePaths) {
+      const modulePath = toFileURL(commandFilePath);
+      let commandObj = await import(modulePath);
+      const compactFilePath = commandFilePath.split(process.cwd())[1] || commandFilePath;
+      if (commandObj.default)
+        commandObj = commandObj.default;
+      if (!commandObj.data) {
+        console.log(
+          import_safe2.default.yellow(
+            `\u23E9 Ignoring: Command ${compactFilePath} does not export "data".`
+          )
+        );
+        continue;
+      }
+      if (!commandObj.run) {
+        console.log(
+          import_safe2.default.yellow(`\u23E9 Ignoring: Command ${compactFilePath} does not export "run".`)
+        );
+        continue;
+      }
+      this._data.commands.push(commandObj);
+    }
+  }
+  #buildValidations() {
+    for (const validationFunction of validations_default) {
+      this._data.builtInValidations.push(validationFunction);
+    }
+  }
+  async #registerCommands() {
+    await registerCommands(this);
+  }
+  #handleCommands() {
+    handleCommands(this);
+  }
+  get commands() {
+    return this._data.commands;
+  }
+};
+
+// src/handlers/event-handler/EventHandler.ts
+var import_safe3 = __toESM(require("colors/safe"));
+var EventHandler = class {
+  #data;
+  constructor({ ...options }) {
+    this.#data = {
+      ...options,
+      events: []
+    };
+  }
+  async init() {
+    await this.#buildEvents();
+    this.#registerEvents();
+  }
+  async #buildEvents() {
+    const eventFolderPaths = getFolderPaths(this.#data.eventsPath);
+    for (const eventFolderPath of eventFolderPaths) {
+      const eventName = eventFolderPath.replace(/\\/g, "/").split("/").pop();
+      const eventFilePaths = getFilePaths(eventFolderPath, true).filter(
+        (path3) => path3.endsWith(".js") || path3.endsWith(".ts")
+      );
+      const eventObj = {
+        name: eventName,
+        functions: []
+      };
+      this.#data.events.push(eventObj);
+      for (const eventFilePath of eventFilePaths) {
+        const modulePath = toFileURL(eventFilePath);
+        let eventFunction = (await import(modulePath)).default;
+        const compactFilePath = eventFilePath.split(process.cwd())[1] || eventFilePath;
+        if (typeof eventFunction !== "function") {
+          console.log(
+            import_safe3.default.yellow(
+              `\u23E9 Ignoring: Event ${compactFilePath} does not export a function.`
+            )
+          );
+          continue;
+        }
+        eventObj.functions.push(eventFunction);
+      }
+    }
+  }
+  #registerEvents() {
+    const client = this.#data.client;
+    const handler = this.#data.commandKitInstance;
+    for (const eventObj of this.#data.events) {
+      client.on(eventObj.name, async (...params) => {
+        for (const eventFunction of eventObj.functions) {
+          const stopEventLoop = await eventFunction(...params, client, handler);
+          if (stopEventLoop) {
+            break;
+          }
+        }
+      });
+    }
+  }
+  get events() {
+    return this.#data.events;
+  }
+};
+
+// src/handlers/validation-handler/ValidationHandler.ts
+var import_safe4 = __toESM(require("colors/safe"));
+var ValidationHandler = class {
+  #data;
+  constructor({ ...options }) {
+    this.#data = {
+      ...options,
+      validations: []
+    };
+  }
+  async init() {
+    await this.#buildValidations();
+  }
+  async #buildValidations() {
+    const validationFilePaths = getFilePaths(this.#data.validationsPath, true).filter(
+      (path3) => path3.endsWith(".js") || path3.endsWith(".ts")
+    );
+    for (const validationFilePath of validationFilePaths) {
+      const modulePath = toFileURL(validationFilePath);
+      let validationFunction = (await import(modulePath)).default;
+      const compactFilePath = validationFilePath.split(process.cwd())[1] || validationFilePath;
+      if (typeof validationFunction !== "function") {
+        console.log(
+          import_safe4.default.yellow(
+            `\u23E9 Ignoring: Validation ${compactFilePath} does not export a function.`
+          )
+        );
+        continue;
+      }
+      this.#data.validations.push(validationFunction);
+    }
+  }
+  get validations() {
+    return this.#data.validations;
+  }
+};
+
+// src/CommandKit.ts
+var import_safe5 = __toESM(require("colors/safe"));
+var CommandKit = class {
+  #data;
+  constructor({ ...options }) {
+    if (!options.client) {
+      throw new Error(import_safe5.default.red('"client" is required when instantiating CommandKit.'));
+    }
+    if (options.validationsPath && !options.commandsPath) {
+      throw new Error(
+        import_safe5.default.red('"commandsPath" is required when "validationsPath" is set.')
+      );
+    }
+    this.#data = {
+      ...options,
+      commands: []
+    };
+    this.#init();
+  }
+  async #init() {
+    if (this.#data.eventsPath) {
+      const eventHandler = new EventHandler({
+        client: this.#data.client,
+        eventsPath: this.#data.eventsPath,
+        commandKitInstance: this
+      });
+      await eventHandler.init();
+    }
+    let validationFunctions = [];
+    if (this.#data.validationsPath) {
+      const validationHandler = new ValidationHandler({
+        validationsPath: this.#data.validationsPath
+      });
+      await validationHandler.init();
+      validationHandler.validations.forEach((v) => validationFunctions.push(v));
+    }
+    if (this.#data.commandsPath) {
+      const commandHandler = new CommandHandler({
+        client: this.#data.client,
+        commandsPath: this.#data.commandsPath,
+        devGuildIds: this.#data.devGuildIds || [],
+        devUserIds: this.#data.devUserIds || [],
+        devRoleIds: this.#data.devRoleIds || [],
+        customValidations: validationFunctions,
+        skipBuiltInValidations: this.#data.skipBuiltInValidations || false,
+        commandKitInstance: this
+      });
+      await commandHandler.init();
+      this.#data.commands = commandHandler.commands;
+    }
+  }
+  /**
+   * Returns all the commands that CommandKit is handling.
+   *
+   * @returns An array of command objects
+   */
+  get commands() {
+    const commands = this.#data.commands.map((cmd) => {
+      const { run, ...command } = cmd;
+      return command;
+    });
+    return commands;
+  }
+};
+
+// src/types/index.ts
+var CommandType = /* @__PURE__ */ ((CommandType2) => {
+  CommandType2[CommandType2["ChatInput"] = 1] = "ChatInput";
+  CommandType2[CommandType2["Message"] = 3] = "Message";
+  CommandType2[CommandType2["User"] = 2] = "User";
+  return CommandType2;
+})(CommandType || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CommandKit,
+  CommandType
+});