commandkit 0.1.10-dev.20231229085439 → 0.1.10-dev.20240108063947

package/dist/index.js

@@ -35,7 +35,16 @@ __export(src_exports, {
   createEffect: () => createEffect,
   createSignal: () => createSignal,
   defineConfig: () => defineConfig,
-  getConfig: () => getConfig
+  getConfig: () => getConfig,
+  response: () => response,
+  useChannel: () => useChannel,
+  useClient: () => useClient,
+  useCommandData: () => useCommandData,
+  useCommandKit: () => useCommandKit,
+  useGuild: () => useGuild,
+  useInteraction: () => useInteraction,
+  useMember: () => useMember,
+  useUser: () => useUser
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -126,7 +135,7 @@ async function loadCommandsWithRest(props) {
         props.type
       );
     } else {
-      throw new Error(colors_default.red(`\u274C Cannot reload commands when client is not ready.`));
+      throw new Error(colors_default.red(`Cannot reload commands when client is not ready.`));
     }
   } else {
     props.client.once("ready", async (c) => {
@@ -150,18 +159,16 @@ async function handleLoading(client, commands, devGuildIds, reloading, type) {
 async function loadGlobalCommands(client, commands, reloading) {
   const requestBody = commands.map((cmd) => cmd.data);
   await client.application.commands.set(requestBody).catch((error) => {
-    console.log(
+    throw new Error(
       colors_default.red(
-        `\u274C Error ${reloading ? "reloading" : "loading"} global application commands.
+        `Error ${reloading ? "reloading" : "loading"} global application commands.
 `
-      )
+      ),
+      error
     );
-    throw new Error(error);
   });
   console.log(
-    colors_default.green(
-      `\u2705 ${reloading ? "Reloaded" : "Loaded"} ${requestBody.length} global commands.`
-    )
+    colors_default.green(`${reloading ? "Reloaded" : "Loaded"} ${requestBody.length} global commands.`)
   );
 }
 async function loadDevCommands(client, commands, guildIds, reloading) {
@@ -169,23 +176,23 @@ async function loadDevCommands(client, commands, guildIds, reloading) {
   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.`
+      process.emitWarning(
+        `Cannot ${reloading ? "reload" : "load"} commands in guild "${guildId}" - guild doesn't exist or client isn't part of the guild.`
       );
       continue;
     }
     await targetGuild.commands.set(requestBody).catch((error) => {
-      console.log(
+      throw new Error(
         colors_default.red(
-          `\u274C Error ${reloading ? "reloading" : "loading"} developer application commands in guild "${targetGuild?.name || guildId}".
+          `Error ${reloading ? "reloading" : "loading"} developer application commands in guild "${targetGuild?.name || guildId}".
 `
-        )
+        ),
+        error
       );
-      throw new Error(error);
     });
     console.log(
       colors_default.green(
-        `\u2705 ${reloading ? "Reloaded" : "Loaded"} ${requestBody.length} developer commands in guild "${targetGuild.name}".`
+        `${reloading ? "Reloaded" : "Loaded"} ${requestBody.length} developer commands in guild "${targetGuild.name}".`
       )
     );
   }
@@ -212,7 +219,7 @@ async function registerCommands(props) {
     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.`));
+      throw new Error(colors_default.red(`Cannot reload commands when client is not ready.`));
     }
   } else {
     props.client.once("ready", async (c) => {
@@ -241,19 +248,20 @@ async function registerGlobalCommands(client, commands) {
     );
     if (command.options?.deleted) {
       if (!targetCommand) {
-        console.log(
+        process.emitWarning(
           colors_default.yellow(
-            `\u23E9 Ignoring: Command "${command.data.name}" is globally marked as deleted.`
+            `Ignoring: Command "${command.data.name}" is globally marked as deleted.`
           )
         );
       } else {
         await targetCommand.delete().catch((error) => {
-          console.log(
-            colors_default.red(`\u274C Failed to delete command "${command.data.name}" globally.`)
+          throw new Error(
+            colors_default.red(`Failed to delete command "${command.data.name}" globally.
+`),
+            error
           );
-          console.error(error);
         });
-        console.log(colors_default.green(`\u{1F6AE} Deleted command "${command.data.name}" globally.`));
+        console.log(colors_default.green(`Deleted command "${command.data.name}" globally.`));
       }
       continue;
     }
@@ -261,26 +269,26 @@ async function registerGlobalCommands(client, commands) {
       const commandsAreDifferent = areSlashCommandsDifferent(targetCommand, command.data);
       if (commandsAreDifferent) {
         await targetCommand.edit(command.data).catch((error) => {
-          console.log(
-            colors_default.red(
-              `\u274C Failed to edit command "${command.data.name}" globally.`
-            )
+          throw new Error(
+            colors_default.red(`Failed to edit command "${command.data.name}" globally.
+`),
+            error
           );
-          console.error(error);
         });
-        console.log(colors_default.green(`\u2705 Edited command "${command.data.name}" globally.`));
+        console.log(colors_default.green(`Edited command "${command.data.name}" globally.`));
         continue;
       }
     }
     if (targetCommand)
       continue;
     await appCommandsManager.create(command.data).catch((error) => {
-      console.log(
-        colors_default.red(`\u274C Failed to register command "${command.data.name}" globally.`)
+      throw new Error(
+        colors_default.red(`Failed to register command "${command.data.name}" globally.
+`),
+        error
       );
-      console.error(error);
     });
-    console.log(colors_default.green(`\u2705 Registered command "${command.data.name}" globally.`));
+    console.log(colors_default.green(`Registered command "${command.data.name}" globally.`));
   }
 }
 async function registerDevCommands(client, commands, guildIds) {
@@ -288,9 +296,9 @@ async function registerDevCommands(client, commands, guildIds) {
   for (const guildId of guildIds) {
     const guild = client.guilds.cache.get(guildId) || await client.guilds.fetch(guildId);
     if (!guild) {
-      console.log(
+      process.emitWarning(
         colors_default.yellow(
-          `\u23E9 Ignoring: Guild ${guildId} does not exist or client isn't in this guild.`
+          `Ignoring: Guild ${guildId} doesn't exist or client isn't part of the guild.`
         )
       );
       continue;
@@ -308,23 +316,23 @@ async function registerDevCommands(client, commands, guildIds) {
       const targetCommand = guildCommands.cache.find((cmd) => cmd.name === command.data.name);
       if (command.options?.deleted) {
         if (!targetCommand) {
-          console.log(
+          process.emitWarning(
             colors_default.yellow(
-              `\u23E9 Ignoring: Command "${command.data.name}" is marked as deleted for ${guildCommands.guild.name}.`
+              `Ignoring: Command "${command.data.name}" is marked as deleted in ${guildCommands.guild.name}.`
             )
           );
         } else {
           await targetCommand.delete().catch((error) => {
-            console.log(
+            throw new Error(
               colors_default.red(
-                `\u274C Failed to delete command "${command.data.name}" in ${guildCommands.guild.name}.`
-              )
+                `Failed to delete command "${command.data.name}" in ${guildCommands.guild.name}.`
+              ),
+              error
             );
-            console.error(error);
           });
           console.log(
             colors_default.green(
-              `\u{1F6AE} Deleted command "${command.data.name}" in ${guildCommands.guild.name}.`
+              `Deleted command "${command.data.name}" in ${guildCommands.guild.name}.`
             )
           );
         }
@@ -334,16 +342,17 @@ async function registerDevCommands(client, commands, guildIds) {
         const commandsAreDifferent = areSlashCommandsDifferent(targetCommand, command.data);
         if (commandsAreDifferent) {
           await targetCommand.edit(command.data).catch((error) => {
-            console.log(
+            throw new Error(
               colors_default.red(
-                `\u274C Failed to edit command "${command.data.name}" in ${guildCommands.guild.name}.`
-              )
+                `Failed to edit command "${command.data.name}" in ${guildCommands.guild.name}.
+`
+              ),
+              error
             );
-            console.error(error);
           });
           console.log(
             colors_default.green(
-              `\u2705 Edited command "${command.data.name}" in ${guildCommands.guild.name}.`
+              `Edited command "${command.data.name}" in ${guildCommands.guild.name}.`
             )
           );
           continue;
@@ -352,16 +361,17 @@ async function registerDevCommands(client, commands, guildIds) {
       if (targetCommand)
         continue;
       await guildCommands.create(command.data).catch((error) => {
-        console.log(
+        throw new Error(
           colors_default.red(
-            `\u274C Failed to register command "${command.data.name}" in ${guildCommands.guild.name}.`
-          )
+            `Failed to register command "${command.data.name}" in ${guildCommands.guild.name}.
+`
+          ),
+          error
         );
-        console.error(error);
       });
       console.log(
         colors_default.green(
-          `\u2705 Registered command "${command.data.name}" in ${guildCommands.guild.name}.`
+          `Registered command "${command.data.name}" in ${guildCommands.guild.name}.`
         )
       );
     }
@@ -469,8 +479,10 @@ function permissions_default({ interaction, targetCommand }) {
 var validations_default = [devOnly_default, permissions_default];
 
 // src/handlers/command-handler/CommandHandler.ts
+var import_async_hooks = require("async_hooks");
 var CommandHandler = class {
   #data;
+  context = null;
   constructor({ ...options }) {
     this.#data = {
       ...options,
@@ -479,20 +491,23 @@ var CommandHandler = class {
     };
   }
   async init() {
+    if (this.#data.enableHooks && !this.context) {
+      this.context = new import_async_hooks.AsyncLocalStorage();
+    }
     await this.#buildCommands();
     this.#buildBuiltInValidations();
     const devOnlyCommands = this.#data.commands.filter((cmd) => cmd.options?.devOnly);
     if (devOnlyCommands.length && !this.#data.devGuildIds.length) {
-      console.log(
+      process.emitWarning(
         colors_default.yellow(
-          '\u2139\uFE0F Warning: You have commands marked as "devOnly", but "devGuildIds" have not been set.'
+          'You have commands marked as "devOnly", but "devGuildIds" have not been set.'
         )
       );
     }
     if (devOnlyCommands.length && !this.#data.devUserIds.length && !this.#data.devRoleIds.length) {
-      console.log(
+      process.emitWarning(
         colors_default.yellow(
-          '\u2139\uFE0F Warning: You have commands marked as "devOnly", but "devUserIds" or "devRoleIds" have not been set.'
+          'You have commands marked as "devOnly", but "devUserIds" or "devRoleIds" have not been set.'
         )
       );
     }
@@ -531,33 +546,33 @@ var CommandHandler = class {
         commandObj.data = importedObj.data;
       }
       if (!commandObj.data) {
-        console.log(
+        process.emitWarning(
           colors_default.yellow(
-            `\u23E9 Ignoring: Command ${compactFilePath} does not export "data".`
+            `Ignoring: Command file ${compactFilePath} does not export "data".`
           )
         );
         continue;
       }
       if (!commandObj.data.name) {
-        console.log(
+        process.emitWarning(
           colors_default.yellow(
-            `\u23E9 Ignoring: Command ${compactFilePath} does not export "data.name".`
+            `Ignoring: Command file ${compactFilePath} does not export "data.name".`
           )
         );
         continue;
       }
       if (!commandObj.run) {
-        console.log(
+        process.emitWarning(
           colors_default.yellow(
-            `\u23E9 Ignoring: Command ${commandObj.data.name} does not export "run".`
+            `Ignoring: Command file ${commandObj.data.name} does not export "run".`
           )
         );
         continue;
       }
       if (typeof commandObj.run !== "function") {
-        console.log(
+        process.emitWarning(
           colors_default.yellow(
-            `\u23E9 Ignoring: Command ${commandObj.data.name} does not export "run" as a function.`
+            `Ignoring: Command file ${commandObj.data.name} does not export "run" as a function.`
           )
         );
         continue;
@@ -578,6 +593,7 @@ var CommandHandler = class {
     }
   }
   handleCommands() {
+    const areHooksEnabled = this.#data.enableHooks;
     this.#data.client.on("interactionCreate", async (interaction) => {
       if (!interaction.isChatInputCommand() && !interaction.isContextMenuCommand() && !interaction.isAutocomplete())
         return;
@@ -590,50 +606,65 @@ var CommandHandler = class {
       const { data, options, run, autocomplete, ...rest } = targetCommand;
       if (isAutocomplete && !autocomplete)
         return;
-      const commandObj = {
-        data: targetCommand.data,
-        options: targetCommand.options,
-        ...rest
-      };
-      if (this.#data.validationHandler) {
-        let canRun2 = true;
-        for (const validationFunction of this.#data.validationHandler.validations) {
-          const stopValidationLoop = await validationFunction({
-            interaction,
-            commandObj,
-            client: this.#data.client,
-            handler: this.#data.commandkitInstance
-          });
-          if (stopValidationLoop) {
-            canRun2 = false;
-            break;
+      const executor = async () => {
+        const commandObj = {
+          data: targetCommand.data,
+          options: targetCommand.options,
+          ...rest
+        };
+        if (this.#data.validationHandler) {
+          let canRun2 = true;
+          for (const validationFunction of this.#data.validationHandler.validations) {
+            const stopValidationLoop = await validationFunction({
+              interaction,
+              commandObj,
+              client: this.#data.client,
+              handler: this.#data.commandkitInstance
+            });
+            if (stopValidationLoop) {
+              canRun2 = false;
+              break;
+            }
           }
+          if (!canRun2)
+            return;
         }
-        if (!canRun2)
+        let canRun = true;
+        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;
-      }
-      let canRun = true;
-      if (!this.#data.skipBuiltInValidations) {
-        for (const validation of this.#data.builtInValidations) {
-          const stopValidationLoop = validation({
-            targetCommand,
+        const command = targetCommand[isAutocomplete ? "autocomplete" : "run"];
+        if (!areHooksEnabled) {
+          const context2 = {
             interaction,
-            handlerData: this.#data
-          });
-          if (stopValidationLoop) {
-            canRun = false;
-            break;
-          }
+            client: this.#data.client,
+            handler: this.#data.commandkitInstance
+          };
+          return await command(context2);
         }
-      }
-      if (!canRun)
-        return;
-      const context2 = {
-        interaction,
-        client: this.#data.client,
-        handler: this.#data.commandkitInstance
+        return command();
       };
-      await targetCommand[isAutocomplete ? "autocomplete" : "run"](context2);
+      if (this.context)
+        return this.context.run(
+          {
+            command: targetCommand.data,
+            interaction
+          },
+          executor
+        );
+      return executor();
     });
   }
   get commands() {
@@ -642,7 +673,9 @@ var CommandHandler = class {
   async reloadCommands(type) {
     if (!this.#data.commandsPath) {
       throw new Error(
-        'Cannot reload commands as "commandsPath" was not provided when instantiating CommandKit.'
+        colors_default.red(
+          'Cannot reload commands as "commandsPath" was not provided when instantiating CommandKit.'
+        )
       );
     }
     this.#data.commands = [];
@@ -704,9 +737,9 @@ var EventHandler = class {
         }
         const compactFilePath = eventFilePath.split(process.cwd())[1] || eventFilePath;
         if (typeof eventFunction !== "function") {
-          console.log(
+          process.emitWarning(
             colors_default.yellow(
-              `\u23E9 Ignoring: Event ${compactFilePath} does not export a function.`
+              `Ignoring: Event file ${compactFilePath} does not export a function.`
             )
           );
           continue;
@@ -735,7 +768,9 @@ var EventHandler = class {
   async reloadEvents(commandHandler) {
     if (!this.#data.eventsPath) {
       throw new Error(
-        'Cannot reload events as "eventsPath" was not provided when instantiating CommandKit.'
+        colors_default.red(
+          'Cannot reload events as "eventsPath" was not provided when instantiating CommandKit.'
+        )
       );
     }
     this.#data.events = [];
@@ -775,9 +810,9 @@ var ValidationHandler = class {
       }
       const compactFilePath = validationFilePath.split(process.cwd())[1] || validationFilePath;
       if (typeof validationFunction !== "function") {
-        console.log(
+        process.emitWarning(
           colors_default.yellow(
-            `\u23E9 Ignoring: Validation ${compactFilePath} does not export a function.`
+            `Ignoring: Validation file ${compactFilePath} does not export a function.`
           )
         );
         continue;
@@ -792,7 +827,9 @@ var ValidationHandler = class {
   async reloadValidations() {
     if (!this.#data.validationsPath) {
       throw new Error(
-        'Cannot reload validations as "validationsPath" was not provided when instantiating CommandKit.'
+        colors_default.red(
+          'Cannot reload validations as "validationsPath" was not provided when instantiating CommandKit.'
+        )
       );
     }
     const newValidations = await this.#buildValidations();
@@ -801,8 +838,9 @@ var ValidationHandler = class {
 };
 
 // src/CommandKit.ts
-var CommandKit = class {
+var CommandKit = class _CommandKit {
   #data;
+  static _instance = null;
   /**
    * Create a new command and event handler with CommandKit.
    *
@@ -819,8 +857,21 @@ var CommandKit = class {
       );
     }
     this.#data = options;
+    _CommandKit._instance = this;
     this.#init();
   }
+  /**
+   * Get the client attached to this CommandKit instance.
+   */
+  get client() {
+    return this.#data.client;
+  }
+  /**
+   * Get command handler instance.
+   */
+  get commandHandler() {
+    return this.#data.commandHandler;
+  }
   /**
    * (Private) Initialize CommandKit.
    */
@@ -851,7 +902,8 @@ var CommandKit = class {
         validationHandler: this.#data.validationHandler,
         skipBuiltInValidations: this.#data.skipBuiltInValidations || false,
         commandkitInstance: this,
-        bulkRegister: this.#data.bulkRegister || false
+        bulkRegister: this.#data.bulkRegister || false,
+        enableHooks: this.#data.experimental?.hooks ?? false
       });
       await commandHandler.init();
       this.#data.commandHandler = commandHandler;
@@ -1104,6 +1156,103 @@ function createEffect(callback) {
 function getCurrentObserver() {
   return context[context.length - 1];
 }
+
+// src/hooks/common.ts
+function getCommandKit() {
+  return CommandKit._instance;
+}
+function getCommandHandler() {
+  const handler = getCommandKit()?.commandHandler;
+  if (!handler) {
+    throw new Error("CommandKit is not initialized.");
+  }
+  return handler;
+}
+function getContext() {
+  const info = getCommandHandler().context;
+  if (!info) {
+    throw new Error("Context is not available, did you forget to enable hooks?");
+  }
+  return info;
+}
+function prepareHookInvocationError(name) {
+  return new Error(`Cannot invoke hook "${name}" outside of a command.`);
+}
+
+// src/hooks/useCommandKit.ts
+function useCommandKit() {
+  const kit = getCommandKit();
+  if (!kit)
+    throw new Error("CommandKit is not initialized.");
+  return kit;
+}
+
+// src/hooks/useClient.ts
+function useClient() {
+  return useCommandKit().client;
+}
+
+// src/hooks/useInteraction.ts
+function useInteraction() {
+  const data = getContext().getStore();
+  if (!data)
+    throw prepareHookInvocationError("useInteraction");
+  return data.interaction;
+}
+
+// src/hooks/response.ts
+async function response(data) {
+  const interaction = useInteraction();
+  if (interaction.isAutocomplete())
+    return;
+  if (interaction.replied || interaction.deferred) {
+    await interaction.editReply(data);
+  } else if (interaction.isMessageComponent()) {
+    await interaction.update(data);
+  } else {
+    await interaction.reply(data);
+  }
+}
+
+// src/hooks/useChannel.ts
+function useChannel() {
+  const data = getContext().getStore();
+  if (!data)
+    throw prepareHookInvocationError("useChannel");
+  return data.interaction.channel;
+}
+
+// src/hooks/useCommandData.ts
+function useCommandData() {
+  const data = getContext().getStore();
+  if (!data)
+    throw prepareHookInvocationError("useCommandData");
+  return data.command;
+}
+
+// src/hooks/useGuild.ts
+function useGuild() {
+  const data = getContext().getStore();
+  if (!data)
+    throw prepareHookInvocationError("useGuild");
+  return data.interaction.guild;
+}
+
+// src/hooks/useMember.ts
+function useMember() {
+  const data = getContext().getStore();
+  if (!data)
+    throw prepareHookInvocationError("useMember");
+  return data.interaction.member;
+}
+
+// src/hooks/useUser.ts
+function useUser() {
+  const data = getContext().getStore();
+  if (!data)
+    throw prepareHookInvocationError("useUser");
+  return data.interaction.user;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ButtonKit,
@@ -1111,5 +1260,14 @@ function getCurrentObserver() {
   createEffect,
   createSignal,
   defineConfig,
-  getConfig
+  getConfig,
+  response,
+  useChannel,
+  useClient,
+  useCommandData,
+  useCommandKit,
+  useGuild,
+  useInteraction,
+  useMember,
+  useUser
 });