commandkit 0.1.6 → 0.1.7-dev.20231212150647

package/dist/index.mjs

@@ -6,48 +6,52 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
-// src/utils/get-paths.ts
+// src/utils/resolve-file-url.ts
 import path from "path";
-import fs from "fs";
-function getFilePaths(directory, nesting) {
+function toFileURL(filePath) {
+  const resolvedPath = path.resolve(filePath);
+  return "file://" + resolvedPath.replace(/\\\\|\\/g, "/");
+}
+
+// src/utils/get-paths.ts
+import path2 from "path";
+import fs from "fs/promises";
+async function getFilePaths(directory, nesting) {
   let filePaths = [];
   if (!directory)
     return filePaths;
-  const files = fs.readdirSync(directory, { withFileTypes: true });
+  const files = await fs.readdir(directory, { withFileTypes: true });
   for (const file of files) {
-    const filePath = path.join(directory, file.name);
+    const filePath = path2.join(directory, file.name);
     if (file.isFile()) {
       filePaths.push(filePath);
     }
     if (nesting && file.isDirectory()) {
-      filePaths = [...filePaths, ...getFilePaths(filePath, true)];
+      filePaths = [...filePaths, ...await getFilePaths(filePath, true)];
     }
   }
   return filePaths;
 }
-function getFolderPaths(directory, nesting) {
+async function getFolderPaths(directory, nesting) {
   let folderPaths = [];
   if (!directory)
     return folderPaths;
-  const folders = fs.readdirSync(directory, { withFileTypes: true });
+  const folders = await fs.readdir(directory, { withFileTypes: true });
   for (const folder of folders) {
-    const folderPath = path.join(directory, folder.name);
+    const folderPath = path2.join(directory, folder.name);
     if (folder.isDirectory()) {
       folderPaths.push(folderPath);
       if (nesting) {
-        folderPaths = [...folderPaths, ...getFolderPaths(folderPath, true)];
+        folderPaths = [...folderPaths, ...await getFolderPaths(folderPath, true)];
       }
     }
   }
   return folderPaths;
 }
 
-// src/utils/resolve-file-url.ts
-import path2 from "path";
-function toFileURL(filePath) {
-  const resolvedPath = path2.resolve(filePath);
-  return "file://" + resolvedPath.replace(/\\\\|\\/g, "/");
-}
+// src/utils/clone.ts
+import rfdc from "rfdc";
+var clone = rfdc();
 
 // src/utils/colors.ts
 var resetColor = "\x1B[0m";
@@ -331,35 +335,10 @@ async function registerDevCommands(client, commands, guildIds) {
   }
 }
 
-// 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 (interaction.isAutocomplete())
+    return;
   if (targetCommand.options?.devOnly) {
     if (interaction.inGuild() && !handlerData.devGuildIds.includes(interaction.guildId)) {
       interaction.reply({
@@ -387,50 +366,76 @@ function devOnly_default({ interaction, targetCommand, handlerData }) {
   }
 }
 
-// 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/permissions.ts
+import { EmbedBuilder } from "discord.js";
+function permissions_default({ interaction, targetCommand }) {
+  if (interaction.isAutocomplete())
+    return;
+  const userPermissions = interaction.memberPermissions;
+  let userPermissionsRequired = targetCommand.options?.userPermissions;
+  let missingUserPermissions = [];
+  if (typeof userPermissionsRequired === "string") {
+    userPermissionsRequired = [userPermissionsRequired];
   }
-}
-
-// src/handlers/command-handler/validations/userPermissions.ts
-function userPermissions_default({ interaction, targetCommand }) {
-  const memberPermissions = interaction.memberPermissions;
-  let commandPermissions = targetCommand.options?.userPermissions;
-  if (!memberPermissions || !commandPermissions)
+  const botPermissions = interaction.guild?.members.me?.permissions;
+  let botPermissionsRequired = targetCommand.options?.botPermissions;
+  let missingBotPermissions = [];
+  if (typeof botPermissionsRequired === "string") {
+    botPermissionsRequired = [botPermissionsRequired];
+  }
+  if (!userPermissionsRequired?.length && !botPermissionsRequired?.length) {
     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;
   }
+  if (userPermissions && userPermissionsRequired) {
+    for (const permission of userPermissionsRequired) {
+      const hasPermission = userPermissions.has(permission);
+      if (!hasPermission) {
+        missingUserPermissions.push(permission);
+      }
+    }
+  }
+  if (botPermissions && botPermissionsRequired) {
+    for (const permission of botPermissionsRequired) {
+      const hasPermission = botPermissions.has(permission);
+      if (!hasPermission) {
+        missingBotPermissions.push(permission);
+      }
+    }
+  }
+  if (!missingUserPermissions.length && !missingBotPermissions.length) {
+    return;
+  }
+  const pattern = /([a-z])([A-Z])|([A-Z]+)([A-Z][a-z])/g;
+  missingUserPermissions = missingUserPermissions.map((str) => str.replace(pattern, "$1$3 $2$4"));
+  missingBotPermissions = missingBotPermissions.map((str) => str.replace(pattern, "$1$3 $2$4"));
+  let embedDescription = "";
+  const formatter = new Intl.ListFormat("en", { style: "long", type: "conjunction" });
+  const getPermissionWord = (permissions) => permissions.length === 1 ? "permission" : "permissions";
+  if (missingUserPermissions.length) {
+    const formattedPermissions = missingUserPermissions.map((p) => `\`${p}\``);
+    const permissionsString = formatter.format(formattedPermissions);
+    embedDescription += `- You must have the ${permissionsString} ${getPermissionWord(
+      missingUserPermissions
+    )} to be able to run this command.
+`;
+  }
+  if (missingBotPermissions.length) {
+    const formattedPermissions = missingBotPermissions.map((p) => `\`${p}\``);
+    const permissionsString = formatter.format(formattedPermissions);
+    embedDescription += `- I must have the ${permissionsString} ${getPermissionWord(
+      missingBotPermissions
+    )} to be able to execute this command.
+`;
+  }
+  const embed = new EmbedBuilder().setTitle(`:x: Missing permissions!`).setDescription(embedDescription).setColor("Red");
+  interaction.reply({ embeds: [embed], ephemeral: true });
+  return true;
 }
 
 // src/handlers/command-handler/validations/index.ts
-var validations_default = [botPermissions_default, devOnly_default, guildOnly_default, userPermissions_default];
+var validations_default = [devOnly_default, permissions_default];
 
 // src/handlers/command-handler/CommandHandler.ts
-import rdfc from "rfdc";
-var clone = rdfc();
 var CommandHandler = class {
   #data;
   constructor({ ...options }) {
@@ -442,19 +447,19 @@ var CommandHandler = class {
   }
   async init() {
     await this.#buildCommands();
-    this.#buildValidations();
+    this.#buildBuiltInValidations();
     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.'
+          '\u2139\uFE0F Warning: 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(
         colors_default.yellow(
-          '\u2139\uFE0F Warning: You have commands marked as "devOnly" but not "devUserIds" or "devRoleIds" were set.'
+          '\u2139\uFE0F Warning: You have commands marked as "devOnly", but "devUserIds" or "devRoleIds" have not been set.'
         )
       );
     }
@@ -475,12 +480,11 @@ var CommandHandler = class {
   }
   async #buildCommands() {
     const allowedExtensions = /\.(js|mjs|cjs|ts)$/i;
-    const commandFilePaths = getFilePaths(this.#data.commandsPath, true).filter(
-      (path3) => allowedExtensions.test(path3)
-    );
+    const paths = await getFilePaths(this.#data.commandsPath, true);
+    const commandFilePaths = paths.filter((path3) => allowedExtensions.test(path3));
     for (const commandFilePath of commandFilePaths) {
       const modulePath = toFileURL(commandFilePath);
-      let importedObj = await import(`${modulePath}?t=${Date.now()}`);
+      const importedObj = await import(`${modulePath}?t=${Date.now()}`);
       let commandObj = clone(importedObj);
       if (typeof module !== "undefined" && typeof __require !== "undefined") {
         delete __require.cache[__require.resolve(commandFilePath)];
@@ -532,24 +536,34 @@ var CommandHandler = class {
       } else {
         commandObj.category = commandCategory;
       }
+      if (commandObj.options?.guildOnly) {
+        console.log(
+          colors_default.yellow(
+            `\u2139\uFE0F Deprecation warning: The command "${commandObj.data.name}" uses "options.guildOnly", which will be deprecated soon. Use "data.dm_permission" instead.`
+          )
+        );
+      }
       this.#data.commands.push(commandObj);
     }
   }
-  #buildValidations() {
-    for (const validationFunction of validations_default) {
-      this.#data.builtInValidations.push(validationFunction);
+  #buildBuiltInValidations() {
+    for (const builtInValidationFunction of validations_default) {
+      this.#data.builtInValidations.push(builtInValidationFunction);
     }
   }
   handleCommands() {
     this.#data.client.on("interactionCreate", async (interaction) => {
-      if (!interaction.isChatInputCommand() && !interaction.isContextMenuCommand())
+      if (!interaction.isChatInputCommand() && !interaction.isContextMenuCommand() && !interaction.isAutocomplete())
         return;
+      const isAutocomplete = interaction.isAutocomplete();
       const targetCommand = this.#data.commands.find(
         (cmd) => cmd.data.name === interaction.commandName
       );
       if (!targetCommand)
         return;
-      const { data, options, run, ...rest } = targetCommand;
+      const { data, options, run, autocompleteRun, ...rest } = targetCommand;
+      if (isAutocomplete && !autocompleteRun)
+        return;
       const commandObj = {
         data: targetCommand.data,
         options: targetCommand.options,
@@ -588,17 +602,23 @@ var CommandHandler = class {
       }
       if (!canRun)
         return;
-      targetCommand.run({
+      const context2 = {
         interaction,
         client: this.#data.client,
         handler: this.#data.commandkitInstance
-      });
+      };
+      await targetCommand[isAutocomplete ? "autocompleteRun" : "run"](context2);
     });
   }
   get commands() {
     return this.#data.commands;
   }
   async reloadCommands(type) {
+    if (!this.#data.commandsPath) {
+      throw new Error(
+        'Cannot reload commands as "commandsPath" was not provided when instantiating CommandKit.'
+      );
+    }
     this.#data.commands = [];
     await this.#buildCommands();
     if (this.#data.bulkRegister) {
@@ -619,13 +639,9 @@ var CommandHandler = class {
       });
     }
   }
-  async useUpdatedValidations() {
-  }
 };
 
 // src/handlers/event-handler/EventHandler.ts
-import rdfc2 from "rfdc";
-var clone2 = rdfc2();
 var EventHandler = class {
   #data;
   constructor({ ...options }) {
@@ -639,13 +655,12 @@ var EventHandler = class {
     this.#registerEvents();
   }
   async #buildEvents() {
-    const eventFolderPaths = getFolderPaths(this.#data.eventsPath);
+    const eventFolderPaths = await getFolderPaths(this.#data.eventsPath);
     for (const eventFolderPath of eventFolderPaths) {
       const eventName = eventFolderPath.replace(/\\\\|\\/g, "/").split("/").pop();
       const allowedExtensions = /\.(js|mjs|cjs|ts)$/i;
-      const eventFilePaths = getFilePaths(eventFolderPath, true).filter(
-        (path3) => allowedExtensions.test(path3)
-      );
+      const eventPaths = await getFilePaths(eventFolderPath, true);
+      const eventFilePaths = eventPaths.filter((path3) => allowedExtensions.test(path3));
       const eventObj = {
         name: eventName,
         functions: []
@@ -654,7 +669,7 @@ var EventHandler = class {
       for (const eventFilePath of eventFilePaths) {
         const modulePath = toFileURL(eventFilePath);
         let importedFunction = (await import(`${modulePath}?t=${Date.now()}`)).default;
-        let eventFunction = clone2(importedFunction);
+        let eventFunction = clone(importedFunction);
         if (typeof module !== "undefined" && typeof __require !== "undefined") {
           delete __require.cache[__require.resolve(eventFilePath)];
         }
@@ -692,6 +707,11 @@ var EventHandler = class {
     return this.#data.events;
   }
   async reloadEvents(commandHandler) {
+    if (!this.#data.eventsPath) {
+      throw new Error(
+        'Cannot reload events as "eventsPath" was not provided when instantiating CommandKit.'
+      );
+    }
     this.#data.events = [];
     await this.#buildEvents();
     this.#data.client.removeAllListeners();
@@ -701,8 +721,6 @@ var EventHandler = class {
 };
 
 // src/handlers/validation-handler/ValidationHandler.ts
-import rdfc3 from "rfdc";
-var clone3 = rdfc3();
 var ValidationHandler = class {
   #data;
   constructor({ ...options }) {
@@ -712,17 +730,17 @@ var ValidationHandler = class {
     };
   }
   async init() {
-    await this.#buildValidations();
+    this.#data.validations = await this.#buildValidations();
   }
   async #buildValidations() {
     const allowedExtensions = /\.(js|mjs|cjs|ts)$/i;
-    const validationFilePaths = getFilePaths(this.#data.validationsPath, true).filter(
-      (path3) => allowedExtensions.test(path3)
-    );
+    const validationPaths = await getFilePaths(this.#data.validationsPath, true);
+    const validationFilePaths = validationPaths.filter((path3) => allowedExtensions.test(path3));
+    const validationFunctions = [];
     for (const validationFilePath of validationFilePaths) {
       const modulePath = toFileURL(validationFilePath);
       let importedFunction = (await import(`${modulePath}?t=${Date.now()}`)).default;
-      let validationFunction = clone3(importedFunction);
+      let validationFunction = clone(importedFunction);
       if (typeof module !== "undefined" && typeof __require !== "undefined") {
         delete __require.cache[__require.resolve(validationFilePath)];
       }
@@ -738,21 +756,33 @@ var ValidationHandler = class {
         );
         continue;
       }
-      this.#data.validations.push(validationFunction);
+      validationFunctions.push(validationFunction);
     }
+    return validationFunctions;
   }
   get validations() {
     return this.#data.validations;
   }
   async reloadValidations() {
-    this.#data.validations = [];
-    await this.#buildValidations();
+    if (!this.#data.validationsPath) {
+      throw new Error(
+        'Cannot reload validations as "validationsPath" was not provided when instantiating CommandKit.'
+      );
+    }
+    const newValidations = await this.#buildValidations();
+    this.#data.validations = newValidations;
   }
 };
 
 // src/CommandKit.ts
 var CommandKit = class {
   #data;
+  /**
+   * Create a new command and event handler with CommandKit.
+   *
+   * @param options - The default CommandKit configuration.
+   * @see {@link https://commandkit.js.org/docs/commandkit-setup}
+   */
   constructor(options) {
     if (!options.client) {
       throw new Error(colors_default.red('"client" is required when instantiating CommandKit.'));
@@ -765,6 +795,9 @@ var CommandKit = class {
     this.#data = options;
     this.#init();
   }
+  /**
+   * (Private) Initialize CommandKit.
+   */
   async #init() {
     if (this.#data.eventsPath) {
       const eventHandler = new EventHandler({
@@ -873,20 +906,150 @@ var CommandKit = class {
   }
 };
 
-// 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 || {});
-var ReloadType = /* @__PURE__ */ ((ReloadType2) => {
-  ReloadType2["Developer"] = "dev";
-  ReloadType2["Global"] = "global";
-  return ReloadType2;
-})(ReloadType || {});
+// src/components/ButtonKit.ts
+import {
+  ButtonStyle,
+  ButtonBuilder,
+  ComponentType
+} from "discord.js";
+var ButtonKit = class extends ButtonBuilder {
+  #onClickHandler = null;
+  #contextData = null;
+  #collector = null;
+  onClick(handler, data) {
+    if (this.data.style === ButtonStyle.Link) {
+      throw new TypeError('Cannot setup "onClick" handler on link buttons.');
+    }
+    this.#destroyCollector();
+    this.#onClickHandler = handler;
+    if (handler && data)
+      this.#contextData = data;
+    this.#setupInteractionCollector();
+    return this;
+  }
+  #setupInteractionCollector() {
+    if (!this.#contextData || !this.#onClickHandler)
+      return;
+    const message = this.#contextData.message;
+    if (!message) {
+      throw new TypeError(
+        'Cannot setup "onClick" handler without a message in the context data.'
+      );
+    }
+    if ("customId" in this.data && !this.data.customId) {
+      throw new TypeError('Cannot setup "onClick" handler on a button without a custom id.');
+    }
+    const data = {
+      time: 864e5,
+      autoReset: true,
+      ...this.#contextData
+    };
+    const collector = this.#collector = message.createMessageComponentCollector({
+      filter: (interaction) => interaction.customId === this.data.custom_id && interaction.message.id === message.id,
+      componentType: ComponentType.Button,
+      ...data
+    });
+    this.#collector.on("collect", (interaction) => {
+      const handler = this.#onClickHandler;
+      if (!handler)
+        return this.#destroyCollector();
+      if (!this.#collector) {
+        return collector.stop("destroyed");
+      }
+      if (data.autoReset) {
+        this.#collector.resetTimer();
+      }
+      return handler(interaction);
+    });
+    this.#collector.on("end", () => {
+      this.#destroyCollector();
+    });
+  }
+  #destroyCollector() {
+    this.#onClickHandler?.(null);
+    this.#collector?.stop("end");
+    this.#collector?.removeAllListeners();
+    this.#collector = null;
+    this.#contextData = null;
+    this.#onClickHandler = null;
+  }
+};
+
+// src/config.ts
+var globalConfig = {
+  envExtra: true,
+  outDir: "dist",
+  watch: true,
+  clearRestartLogs: true,
+  minify: false,
+  sourcemap: false,
+  nodeOptions: [],
+  antiCrash: true
+};
+function getConfig() {
+  return globalConfig;
+}
+var requiredProps = ["src", "main"];
+function defineConfig(config) {
+  for (const prop of requiredProps) {
+    if (!config[prop]) {
+      throw new Error(`[CommandKit Config] Missing required config property: ${prop}`);
+    }
+  }
+  globalConfig = {
+    ...globalConfig,
+    ...config
+  };
+  return globalConfig;
+}
+
+// src/utils/signal.ts
+var context = [];
+function createSignal(value) {
+  const subscribers = /* @__PURE__ */ new Set();
+  let disposed = false;
+  let val = value instanceof Function ? value() : value;
+  const getter = () => {
+    if (!disposed) {
+      const running = getCurrentObserver();
+      if (running)
+        subscribers.add(running);
+    }
+    return val;
+  };
+  const setter = (newValue) => {
+    if (disposed)
+      return;
+    val = newValue instanceof Function ? newValue(val) : newValue;
+    for (const subscriber of subscribers) {
+      subscriber();
+    }
+  };
+  const dispose = () => {
+    subscribers.clear();
+    disposed = true;
+  };
+  return [getter, setter, dispose];
+}
+function createEffect(callback) {
+  const execute = () => {
+    context.push(execute);
+    try {
+      callback();
+    } finally {
+      context.pop();
+    }
+  };
+  execute();
+}
+function getCurrentObserver() {
+  return context[context.length - 1];
+}
 export {
+  ButtonKit,
   CommandKit,
-  CommandType,
-  ReloadType
+  createEffect,
+  createSignal,
+  defineConfig,
+  getConfig
 };