commandkit 0.1.1 → 0.1.3-dev.20231002185336

package/dist/index.js

@@ -31,7 +31,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   CommandKit: () => CommandKit,
-  CommandType: () => CommandType
+  CommandType: () => CommandType,
+  ReloadType: () => ReloadType
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -75,7 +76,286 @@ function getFolderPaths(directory, nesting) {
 var import_path2 = __toESM(require("path"));
 function toFileURL(filePath) {
   const resolvedPath = import_path2.default.resolve(filePath);
-  return "file://" + resolvedPath.replace(/\\/g, "/");
+  return "file://" + resolvedPath.replace(/\\\\|\\/g, "/");
+}
+
+// src/utils/colors.ts
+var resetColor = "\x1B[0m";
+var colors_default = {
+  reset: (text) => `${text}${resetColor}`,
+  bright: (text) => `\x1B[1m${text}${resetColor}`,
+  dim: (text) => `\x1B[2m${text}${resetColor}`,
+  underscore: (text) => `\x1B[4m${text}${resetColor}`,
+  blink: (text) => `\x1B[5m${text}${resetColor}`,
+  reverse: (text) => `\x1B[7m${text}${resetColor}`,
+  hidden: (text) => `\x1B[8m${text}${resetColor}`,
+  black: (text) => `\x1B[30m${text}${resetColor}`,
+  red: (text) => `\x1B[31m${text}${resetColor}`,
+  green: (text) => `\x1B[32m${text}${resetColor}`,
+  yellow: (text) => `\x1B[33m${text}${resetColor}`,
+  blue: (text) => `\x1B[34m${text}${resetColor}`,
+  magenta: (text) => `\x1B[35m${text}${resetColor}`,
+  cyan: (text) => `\x1B[36m${text}${resetColor}`,
+  white: (text) => `\x1B[37m${text}${resetColor}`,
+  bgBlack: (text) => `\x1B[40m${text}${resetColor}`,
+  bgRed: (text) => `\x1B[41m${text}${resetColor}`,
+  bgGreen: (text) => `\x1B[42m${text}${resetColor}`,
+  bgYellow: (text) => `\x1B[43m${text}${resetColor}`,
+  bgBlue: (text) => `\x1B[44m${text}${resetColor}`,
+  bgMagenta: (text) => `\x1B[45m${text}${resetColor}`,
+  bgCyan: (text) => `\x1B[46m${text}${resetColor}`,
+  bgWhite: (text) => `\x1B[47m${text}${resetColor}`
+};
+
+// src/handlers/command-handler/functions/loadCommandsWithRest.ts
+async function loadCommandsWithRest(props) {
+  if (props.reloading) {
+    if (props.client.isReady()) {
+      await handleLoading(
+        props.client,
+        props.commands,
+        props.devGuildIds,
+        props.reloading,
+        props.type
+      );
+    } else {
+      throw new Error(colors_default.red(`\u274C Cannot reload commands when client is not ready.`));
+    }
+  } else {
+    props.client.once("ready", async (c) => {
+      await handleLoading(c, props.commands, props.devGuildIds, props.reloading, props.type);
+    });
+  }
+}
+async function handleLoading(client, commands, devGuildIds, reloading, type) {
+  const devOnlyCommands = commands.filter((cmd) => cmd.options?.devOnly);
+  const globalCommands = commands.filter((cmd) => !cmd.options?.devOnly);
+  if (type === "dev") {
+    await loadDevCommands(client, devOnlyCommands, devGuildIds, reloading);
+  } else if (type === "global") {
+    await loadGlobalCommands(client, globalCommands, reloading);
+  } else {
+    await loadDevCommands(client, devOnlyCommands, devGuildIds, reloading);
+    await loadGlobalCommands(client, globalCommands, reloading);
+  }
+}
+async function loadGlobalCommands(client, commands, reloading) {
+  const requestBody = commands.map((cmd) => cmd.data);
+  await client.application.commands.set(requestBody).catch((error) => {
+    console.log(
+      colors_default.red(
+        `\u274C Error ${reloading ? "reloading" : "loading"} global application commands.
+`
+      )
+    );
+    throw new Error(error);
+  });
+  console.log(
+    colors_default.green(
+      `\u2705 ${reloading ? "Reloaded" : "Loaded"} ${requestBody.length} global commands.`
+    )
+  );
+}
+async function loadDevCommands(client, commands, guildIds, reloading) {
+  const requestBody = commands.map((cmd) => cmd.data);
+  for (const guildId of guildIds) {
+    const targetGuild = client.guilds.cache.get(guildId) || await client.guilds.fetch(guildId);
+    if (!targetGuild) {
+      console.log(
+        `Couldn't ${reloading ? "reloading" : "loading"} commands in guild "${targetGuild}" - guild doesn't exist or client isn't part of the guild.`
+      );
+      continue;
+    }
+    await targetGuild.commands.set(requestBody).catch((error) => {
+      console.log(
+        colors_default.red(
+          `\u274C Error ${reloading ? "reloading" : "loading"} developer application commands in guild "${targetGuild?.name || guildId}".
+`
+        )
+      );
+      throw new Error(error);
+    });
+    console.log(
+      colors_default.green(
+        `\u2705 ${reloading ? "Reloaded" : "Loaded"} ${requestBody.length} developer commands in guild "${targetGuild.name}".`
+      )
+    );
+  }
+}
+
+// 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
+async function registerCommands(props) {
+  if (props.reloading) {
+    if (props.client.isReady()) {
+      await handleRegistration(props.client, props.commands, props.devGuildIds, props.type);
+    } else {
+      throw new Error(colors_default.red(`\u274C Cannot reload commands when client is not ready.`));
+    }
+  } else {
+    props.client.once("ready", async (c) => {
+      await handleRegistration(c, props.commands, props.devGuildIds, props.type);
+    });
+  }
+}
+async function handleRegistration(client, commands, devGuildIds, type) {
+  const devOnlyCommands = commands.filter((cmd) => cmd.options?.devOnly);
+  const globalCommands = commands.filter((cmd) => !cmd.options?.devOnly);
+  if (type === "dev") {
+    await registerDevCommands(client, devOnlyCommands, devGuildIds);
+  } else if (type === "global") {
+    await registerGlobalCommands(client, globalCommands);
+  } else {
+    await registerDevCommands(client, devOnlyCommands, devGuildIds);
+    await registerGlobalCommands(client, globalCommands);
+  }
+}
+async function registerGlobalCommands(client, commands) {
+  const appCommandsManager = client.application.commands;
+  await appCommandsManager.fetch();
+  for (const command of commands) {
+    const targetCommand = appCommandsManager.cache.find(
+      (cmd) => cmd.name === command.data.name
+    );
+    if (command.options?.deleted) {
+      if (!targetCommand) {
+        console.log(
+          colors_default.yellow(
+            `\u23E9 Ignoring: Command "${command.data.name}" is globally marked as deleted.`
+          )
+        );
+      } else {
+        targetCommand.delete().then(() => {
+          console.log(
+            colors_default.green(`\u{1F6AE} Deleted command "${command.data.name}" globally.`)
+          );
+        });
+      }
+      continue;
+    }
+    if (targetCommand) {
+      const commandsAreDifferent = areSlashCommandsDifferent(targetCommand, command.data);
+      if (commandsAreDifferent) {
+        targetCommand.edit(command.data).then(() => {
+          console.log(
+            colors_default.green(`\u2705 Edited command "${command.data.name}" globally.`)
+          );
+        }).catch((error) => {
+          console.log(
+            colors_default.red(
+              `\u274C Failed to edit command "${command.data.name}" globally.`
+            )
+          );
+          console.error(error);
+        });
+        continue;
+      }
+    }
+    if (targetCommand)
+      continue;
+    appCommandsManager.create(command.data).then(() => {
+      console.log(colors_default.green(`\u2705 Registered command "${command.data.name}" globally.`));
+    }).catch((error) => {
+      console.log(
+        colors_default.red(`\u274C Failed to register command "${command.data.name}" globally.`)
+      );
+      console.error(error);
+    });
+  }
+}
+async function registerDevCommands(client, commands, guildIds) {
+  const devGuilds = [];
+  for (const guildId of guildIds) {
+    const guild = client.guilds.cache.get(guildId) || await client.guilds.fetch(guildId);
+    if (!guild) {
+      console.log(
+        colors_default.yellow(
+          `\u23E9 Ignoring: Guild ${guildId} does not exist or client isn't in this guild.`
+        )
+      );
+      continue;
+    }
+    devGuilds.push(guild);
+  }
+  const guildCommandsManagers = [];
+  for (const guild of devGuilds) {
+    const guildCommandsManager = guild.commands;
+    await guildCommandsManager.fetch();
+    guildCommandsManagers.push(guildCommandsManager);
+  }
+  for (const command of commands) {
+    for (const guildCommands of guildCommandsManagers) {
+      const targetCommand = guildCommands.cache.find((cmd) => cmd.name === command.data.name);
+      if (command.options?.deleted) {
+        if (!targetCommand) {
+          console.log(
+            colors_default.yellow(
+              `\u23E9 Ignoring: Command "${command.data.name}" is marked as deleted for ${guildCommands.guild.name}.`
+            )
+          );
+        } else {
+          targetCommand.delete().then(() => {
+            console.log(
+              colors_default.green(
+                `\u{1F6AE} Deleted command "${command.data.name}" in ${guildCommands.guild.name}.`
+              )
+            );
+          });
+        }
+        continue;
+      }
+      if (targetCommand) {
+        const commandsAreDifferent = areSlashCommandsDifferent(targetCommand, command.data);
+        if (commandsAreDifferent) {
+          targetCommand.edit(command.data).then(() => {
+            console.log(
+              colors_default.green(
+                `\u2705 Edited command "${command.data.name}" in ${guildCommands.guild.name}.`
+              )
+            );
+          }).catch((error) => {
+            console.log(
+              colors_default.red(
+                `\u274C Failed to edit command "${command.data.name}" in ${guildCommands.guild.name}.`
+              )
+            );
+            console.error(error);
+          });
+          continue;
+        }
+      }
+      if (targetCommand)
+        continue;
+      guildCommands.create(command.data).then(() => {
+        console.log(
+          colors_default.green(
+            `\u2705 Registered command "${command.data.name}" in ${guildCommands.guild.name}.`
+          )
+        );
+      }).catch((error) => {
+        console.log(
+          colors_default.red(
+            `\u274C Failed to register command "${command.data.name}" in ${guildCommands.guild.name}.`
+          )
+        );
+        console.error(error);
+      });
+    }
+  }
 }
 
 // src/handlers/command-handler/validations/botPermissions.ts
@@ -119,7 +399,7 @@ function devOnly_default({ interaction, targetCommand, handlerData }) {
     const memberRoles = guildMember?.roles.cache;
     let hasDevRole = false;
     memberRoles?.forEach((role) => {
-      if (handlerData.devRoleIds?.includes(role.id)) {
+      if (handlerData.devRoleIds.includes(role.id)) {
         hasDevRole = true;
       }
     });
@@ -175,254 +455,13 @@ function userPermissions_default({ interaction, targetCommand }) {
 // 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 import_rfdc = __toESM(require("rfdc"));
+var clone = (0, import_rfdc.default)();
 var CommandHandler = class {
-  _data;
+  #data;
   constructor({ ...options }) {
-    this._data = {
+    this.#data = {
       ...options,
       builtInValidations: [],
       commands: []
@@ -431,54 +470,177 @@ var CommandHandler = class {
   async init() {
     await this.#buildCommands();
     this.#buildValidations();
-    await this.#registerCommands();
+    const devOnlyCommands = this.#data.commands.filter((cmd) => cmd.options?.devOnly);
+    if (devOnlyCommands.length && !this.#data.devGuildIds.length) {
+      console.log(
+        colors_default.yellow(
+          '\u2139\uFE0F Warning: You have commands marked as "devOnly" but "devGuildIds" has not been set.'
+        )
+      );
+    }
+    if (devOnlyCommands.length && !this.#data.devUserIds.length && !this.#data.devRoleIds.length) {
+      console.log(
+        colors_default.yellow(
+          '\u2139\uFE0F Warning: You have commands marked as "devOnly" but not "devUserIds" or "devRoleIds" were set.'
+        )
+      );
+    }
+    if (this.#data.useRest) {
+      await loadCommandsWithRest({
+        client: this.#data.client,
+        devGuildIds: this.#data.devGuildIds,
+        commands: this.#data.commands
+      });
+    } else {
+      await registerCommands({
+        client: this.#data.client,
+        devGuildIds: this.#data.devGuildIds,
+        commands: this.#data.commands
+      });
+    }
     this.#handleCommands();
   }
   async #buildCommands() {
-    const commandFilePaths = getFilePaths(this._data.commandsPath, true).filter(
-      (path3) => path3.endsWith(".js") || path3.endsWith(".ts")
+    const allowedExtensions = /\.(js|mjs|cjs|ts)$/i;
+    const commandFilePaths = getFilePaths(this.#data.commandsPath, true).filter(
+      (path3) => allowedExtensions.test(path3)
     );
     for (const commandFilePath of commandFilePaths) {
       const modulePath = toFileURL(commandFilePath);
-      let commandObj = await import(modulePath);
+      let importedObj = await import(`${modulePath}?t=${Date.now()}`);
+      let commandObj = clone(importedObj);
+      if (typeof module !== "undefined" && typeof require !== "undefined") {
+        delete require.cache[require.resolve(commandFilePath)];
+      }
       const compactFilePath = commandFilePath.split(process.cwd())[1] || commandFilePath;
       if (commandObj.default)
         commandObj = commandObj.default;
       if (!commandObj.data) {
         console.log(
-          import_safe2.default.yellow(
+          colors_default.yellow(
             `\u23E9 Ignoring: Command ${compactFilePath} does not export "data".`
           )
         );
         continue;
       }
+      if (!commandObj.data.name) {
+        console.log(
+          colors_default.yellow(
+            `\u23E9 Ignoring: Command ${compactFilePath} does not export "data.name".`
+          )
+        );
+        continue;
+      }
       if (!commandObj.run) {
         console.log(
-          import_safe2.default.yellow(`\u23E9 Ignoring: Command ${compactFilePath} does not export "run".`)
+          colors_default.yellow(
+            `\u23E9 Ignoring: Command ${commandObj.data.name} does not export "run".`
+          )
+        );
+        continue;
+      }
+      if (typeof commandObj.run !== "function") {
+        console.log(
+          colors_default.yellow(
+            `\u23E9 Ignoring: Command ${commandObj.data.name} does not export "run" as a function.`
+          )
         );
         continue;
       }
-      this._data.commands.push(commandObj);
+      commandObj.filePath = commandFilePath;
+      let commandCategory = commandFilePath.split(this.#data.commandsPath)[1]?.replace(/\\\\|\\/g, "/").split("/")[1] || null;
+      if (commandCategory && allowedExtensions.test(commandCategory)) {
+        commandObj.category = null;
+      } else {
+        commandObj.category = commandCategory;
+      }
+      this.#data.commands.push(commandObj);
     }
   }
   #buildValidations() {
     for (const validationFunction of validations_default) {
-      this._data.builtInValidations.push(validationFunction);
+      this.#data.builtInValidations.push(validationFunction);
     }
   }
-  async #registerCommands() {
-    await registerCommands(this);
-  }
   #handleCommands() {
-    handleCommands(this);
+    this.#data.client.on("interactionCreate", async (interaction) => {
+      if (!interaction.isChatInputCommand() && !interaction.isContextMenuCommand())
+        return;
+      const targetCommand = this.#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 this.#data.customValidations) {
+        const stopValidationLoop = await validationFunction({
+          interaction,
+          commandObj,
+          client: this.#data.client,
+          handler: this.#data.handler
+        });
+        if (stopValidationLoop) {
+          canRun = false;
+          break;
+        }
+      }
+      if (!canRun)
+        return;
+      if (!this.#data.skipBuiltInValidations) {
+        for (const validation of this.#data.builtInValidations) {
+          const stopValidationLoop = validation({
+            targetCommand,
+            interaction,
+            handlerData: this.#data
+          });
+          if (stopValidationLoop) {
+            canRun = false;
+            break;
+          }
+        }
+      }
+      if (!canRun)
+        return;
+      targetCommand.run({
+        interaction,
+        client: this.#data.client,
+        handler: this.#data.handler
+      });
+    });
   }
   get commands() {
-    return this._data.commands;
+    return this.#data.commands;
+  }
+  async reloadCommands(type) {
+    this.#data.commands = [];
+    await this.#buildCommands();
+    if (this.#data.useRest) {
+      await loadCommandsWithRest({
+        client: this.#data.client,
+        devGuildIds: this.#data.devGuildIds,
+        commands: this.#data.commands,
+        reloading: true,
+        type
+      });
+    } else {
+      await registerCommands({
+        client: this.#data.client,
+        devGuildIds: this.#data.devGuildIds,
+        commands: this.#data.commands,
+        reloading: true,
+        type
+      });
+    }
   }
 };
 
 // src/handlers/event-handler/EventHandler.ts
-var import_safe3 = __toESM(require("colors/safe"));
 var EventHandler = class {
   #data;
   constructor({ ...options }) {
@@ -494,7 +656,7 @@ var EventHandler = class {
   async #buildEvents() {
     const eventFolderPaths = getFolderPaths(this.#data.eventsPath);
     for (const eventFolderPath of eventFolderPaths) {
-      const eventName = eventFolderPath.replace(/\\/g, "/").split("/").pop();
+      const eventName = eventFolderPath.replace(/\\\\|\\/g, "/").split("/").pop();
       const eventFilePaths = getFilePaths(eventFolderPath, true).filter(
         (path3) => path3.endsWith(".js") || path3.endsWith(".ts")
       );
@@ -512,7 +674,7 @@ var EventHandler = class {
         const compactFilePath = eventFilePath.split(process.cwd())[1] || eventFilePath;
         if (typeof eventFunction !== "function") {
           console.log(
-            import_safe3.default.yellow(
+            colors_default.yellow(
               `\u23E9 Ignoring: Event ${compactFilePath} does not export a function.`
             )
           );
@@ -542,7 +704,6 @@ var EventHandler = class {
 };
 
 // src/handlers/validation-handler/ValidationHandler.ts
-var import_safe4 = __toESM(require("colors/safe"));
 var ValidationHandler = class {
   #data;
   constructor({ ...options }) {
@@ -567,7 +728,7 @@ var ValidationHandler = class {
       const compactFilePath = validationFilePath.split(process.cwd())[1] || validationFilePath;
       if (typeof validationFunction !== "function") {
         console.log(
-          import_safe4.default.yellow(
+          colors_default.yellow(
             `\u23E9 Ignoring: Validation ${compactFilePath} does not export a function.`
           )
         );
@@ -582,22 +743,18 @@ var ValidationHandler = class {
 };
 
 // src/CommandKit.ts
-var import_safe5 = __toESM(require("colors/safe"));
 var CommandKit = class {
   #data;
-  constructor({ ...options }) {
+  constructor(options) {
     if (!options.client) {
-      throw new Error(import_safe5.default.red('"client" is required when instantiating CommandKit.'));
+      throw new Error(colors_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.')
+        colors_default.red('"commandsPath" is required when "validationsPath" is set.')
       );
     }
-    this.#data = {
-      ...options,
-      commands: []
-    };
+    this.#data = options;
     this.#init();
   }
   async #init() {
@@ -608,6 +765,7 @@ var CommandKit = class {
         commandKitInstance: this
       });
       await eventHandler.init();
+      this.#data.eventHandler = eventHandler;
     }
     let validationFunctions = [];
     if (this.#data.validationsPath) {
@@ -616,6 +774,7 @@ var CommandKit = class {
       });
       await validationHandler.init();
       validationHandler.validations.forEach((v) => validationFunctions.push(v));
+      this.#data.validationHandler = validationHandler;
     }
     if (this.#data.commandsPath) {
       const commandHandler = new CommandHandler({
@@ -626,24 +785,71 @@ var CommandKit = class {
         devRoleIds: this.#data.devRoleIds || [],
         customValidations: validationFunctions,
         skipBuiltInValidations: this.#data.skipBuiltInValidations || false,
-        commandKitInstance: this
+        handler: this,
+        useRest: this.#data.useRest || false
       });
       await commandHandler.init();
-      this.#data.commands = commandHandler.commands;
+      this.#data.commandHandler = commandHandler;
     }
   }
   /**
-   * Returns all the commands that CommandKit is handling.
-   *
-   * @returns An array of command objects
+   * Updates application commands with the latest from "commandsPath".
+   * @experimental
+   */
+  async reloadCommands(type) {
+    if (!this.#data.commandHandler)
+      return;
+    await this.#data.commandHandler.reloadCommands(type);
+  }
+  /**
+   * @returns An array of objects of all the commands that CommandKit is handling.
    */
   get commands() {
-    const commands = this.#data.commands.map((cmd) => {
+    if (!this.#data.commandHandler) {
+      return [];
+    }
+    const commands = this.#data.commandHandler.commands.map((cmd) => {
       const { run, ...command } = cmd;
       return command;
     });
     return commands;
   }
+  /**
+   * @returns The path to the commands folder which was set when instantiating CommandKit.
+   */
+  get commandsPath() {
+    return this.#data.commandsPath;
+  }
+  /**
+   * @returns The path to the events folder which was set when instantiating CommandKit.
+   */
+  get eventsPath() {
+    return this.#data.eventsPath;
+  }
+  /**
+   * @returns The path to the validations folder which was set when instantiating CommandKit.
+   */
+  get validationsPath() {
+    return this.#data.validationsPath;
+  }
+  /**
+   * @returns An array of all the developer user IDs which was set when instantiating CommandKit.
+   */
+  get devUserIds() {
+    return this.#data.devUserIds || [];
+  }
+  /**
+   * @returns An array of all the developer guild IDs which was set when instantiating CommandKit.
+   */
+  get devGuildIds() {
+    return this.#data.devGuildIds || [];
+  }
+  /**
+   * @returns An array of all the developer role IDs which was set when instantiating CommandKit.
+   */
+  get devRoleIds() {
+    return this.#data.devRoleIds || [];
+  }
 };
 
 // src/types/index.ts
@@ -653,8 +859,14 @@ var CommandType = /* @__PURE__ */ ((CommandType2) => {
   CommandType2[CommandType2["User"] = 2] = "User";
   return CommandType2;
 })(CommandType || {});
+var ReloadType = /* @__PURE__ */ ((ReloadType2) => {
+  ReloadType2["Developer"] = "dev";
+  ReloadType2["Global"] = "global";
+  return ReloadType2;
+})(ReloadType || {});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CommandKit,
-  CommandType
+  CommandType,
+  ReloadType
 });