vimcord 1.0.22 → 1.0.24

package/dist/index.js

@@ -92,18 +92,8 @@ function validateCommandPermissions(permissions, client, user, command) {
     return { validated: false, failReason: 7 /* NotBotOwner */ };
   }
   if (__existsAndTrue(permissions.botStaffOnly)) {
-    if (!client.config.staff.superUsers.includes(user.id)) {
-      return { validated: false, failReason: 8 /* NotBotStaff */ };
-    }
-    if (inGuild) {
-      for (const [k, role] of user.roles.cache) {
-        if (!user.roles.cache.has(role.id)) {
-          missingRoles.push(role.id);
-        }
-      }
-      if (missingRoles.length) {
-        return { validated: false, failReason: 8 /* NotBotStaff */, missingRoles };
-      }
+    if (client.config.staff.ownerId === user.id || client.config.staff.superUsers.includes(user.id)) {
+      return { validated: true };
     }
     if (command instanceof BaseInteraction && command.isCommand()) {
       let commandName = null;
@@ -113,17 +103,30 @@ function validateCommandPermissions(permissions, client, user, command) {
       } else {
         commandName = command.commandName;
       }
-      if (!client.config.staff.bypassers.some(
+      if (client.config.staff.bypassers.some(
         (bypass) => bypass.commandName.toLowerCase() === commandName.toLowerCase() && bypass.userIds.includes(user.id)
       )) {
-        return { validated: false, failReason: 8 /* NotBotStaff */ };
+        return { validated: true };
       }
     }
-    if (typeof command === "string" && !client.config.staff.bypassers.some(
+    if (typeof command === "string" && client.config.staff.bypassers.some(
       (bypass) => bypass.commandName.toLowerCase() === command.toLowerCase() && bypass.userIds.includes(user.id)
     )) {
-      return { validated: false, failReason: 8 /* NotBotStaff */ };
+      return { validated: true };
     }
+    if (inGuild) {
+      for (const role of user.roles.cache.values()) {
+        if (!user.roles.cache.has(role.id)) {
+          missingRoles.push(role.id);
+        }
+      }
+      if (missingRoles.length) {
+        return { validated: false, failReason: 8 /* NotBotStaff */, missingRoles };
+      } else {
+        return { validated: true };
+      }
+    }
+    return { validated: false, failReason: 8 /* NotBotStaff */ };
   }
   return { validated: true };
 }
@@ -428,12 +431,12 @@ function getProcessDir() {
   if (!mainPath) return "";
   return path.dirname(mainPath);
 }
-async function importModulesFromDir(dir, fnPrefix) {
+async function importModulesFromDir(dir, suffix) {
   const cwd = getProcessDir();
   const MODULE_RELATIVE_PATH = path.join(cwd, dir);
   const MODULE_LOG_PATH = dir;
   const files = $.fs.readDir(MODULE_RELATIVE_PATH).filter(
-    (fn) => fn.endsWith(`${fnPrefix ? `.${fnPrefix}` : ""}.js`) || fn.endsWith(`${fnPrefix ? `.${fnPrefix}` : ""}.ts`)
+    (fn) => fn.endsWith(`${suffix ? `.${suffix}` : ""}.js`) || fn.endsWith(`${suffix ? `.${suffix}` : ""}.ts`)
   );
   if (!files.length) {
     return [];
@@ -663,8 +666,9 @@ var EventBuilder = class _EventBuilder {
 
 // src/builders/prefixCommand.builder.ts
 var PrefixCommandBuilder = class extends BaseCommandBuilder {
-  constructor(config) {
-    super(1 /* Prefix */, config);
+  constructor(options) {
+    super(1 /* Prefix */, options);
+    this.options = options;
     const originalExecute = this.options.execute;
     this.options.execute = async (client, message) => {
       return await this.handleExecution(client, message, originalExecute);
@@ -871,7 +875,13 @@ var defaultConfig = {
   name: "Discord Bot",
   appVersion: "1.0.0",
   verbose: false,
-  disableBanner: false
+  disableBanner: false,
+  moduleSuffixes: {
+    slashCommand: "slash",
+    contextCommand: "ctx",
+    prefixCommand: "prefix",
+    event: "event"
+  }
 };
 function createVimcordAppConfig(options = {}) {
   return _6.merge(defaultConfig, options);
@@ -1240,7 +1250,7 @@ function formatThousands(num, sep = ",") {
 // src/modules/status.manager.ts
 import EventEmitter from "events";
 import { $ as $2 } from "qznt";
-var VimcordStatusManager = class {
+var StatusManager = class {
   client;
   logger;
   emitter = new EventEmitter();
@@ -1361,192 +1371,232 @@ var VimcordStatusManager = class {
 };
 
 // src/modules/command.manager.ts
-import { REST, Routes } from "discord.js";
-var VimcordAppCommandManager = class {
-  constructor(client, typeName) {
+import { Routes } from "discord.js";
+var BaseCommandManager = class {
+  type;
+  client;
+  commands = /* @__PURE__ */ new Map();
+  moduleSuffix;
+  constructor(client, type, moduleSuffix) {
+    this.type = type;
     this.client = client;
-    this.typeName = typeName;
-    this.client.whenReady().then((c) => this.rest = new REST().setToken(c.token));
+    this.moduleSuffix = moduleSuffix;
   }
-  commands = /* @__PURE__ */ new Map();
-  rest;
+  /**
+   * Gets a command by name.
+   */
   get(name) {
-    return this.commands.get(name);
+    if (this.type === 1 /* Prefix */) {
+      const config = this.client.config.prefixCommands;
+      const search = config.allowCaseInsensitiveCommandNames ? name.toLowerCase() : name;
+      return Array.from(this.commands.values()).find((cmd) => {
+        const commandName = "builder" in cmd ? cmd.builder.name : cmd.options.name;
+        const trigger = config.allowCaseInsensitiveCommandNames ? commandName.toLowerCase() : commandName;
+        if (trigger === search) return true;
+        if ("aliases" in cmd.options) {
+          return cmd.options.aliases?.some(
+            (a) => config.allowCaseInsensitiveCommandNames ? a.toLowerCase() === search : a === search
+          );
+        }
+      });
+    } else {
+      return this.commands.get(name);
+    }
   }
   /**
-   * Filters and returns commands based on deployment options
+   * Gets/filters commands and orders them alphabetically
    */
-  getAll(options) {
+  getAll(options = {}) {
     const matchedCommands = /* @__PURE__ */ new Map();
     const isDev = this.client.config.app.devMode;
     for (const cmd of this.commands.values()) {
-      const config = cmd.toConfig();
-      const name = cmd.builder.name;
-      if (options?.names || options?.fuzzyNames) {
-        const nameMatched = options.names?.includes(name) || options.fuzzyNames?.some((fuzzy) => name.includes(fuzzy));
+      const commandName = "builder" in cmd ? cmd.builder.name : cmd.options.name;
+      if (options.names || options.fuzzyNames) {
+        const nameMatched = options.names?.includes(commandName) || options.fuzzyNames?.some((fuzzy) => commandName.includes(fuzzy));
         if (!nameMatched) continue;
       }
-      if (options?.ignoreDeploymentOptions) {
-        matchedCommands.set(name, cmd);
+      if (options.ignoreDeploymentOptions) {
+        matchedCommands.set(commandName, cmd);
         continue;
       }
-      const deployment = config.deployment || {};
+      const deployment = "deployment" in cmd.options ? cmd.options.deployment ?? {} : {};
       const isProperEnv = !deployment.environments || deployment.environments.includes(isDev ? "development" : "production");
       if (!isProperEnv) continue;
-      if (options?.globalOnly && deployment.global === false) continue;
-      matchedCommands.set(name, cmd);
+      if (options.globalOnly && deployment.global === false) continue;
+      matchedCommands.set(commandName, cmd);
+    }
+    return Array.from(matchedCommands.values()).sort((a, b) => {
+      const commandNameA = "builder" in a ? a.builder.name : a.options.name;
+      const commandNameB = "builder" in b ? b.builder.name : b.options.name;
+      return commandNameA.localeCompare(commandNameB);
+    });
+  }
+  /**
+   * Groups commands by category alphabetically.
+   */
+  sortByCategory() {
+    const categories = /* @__PURE__ */ new Map();
+    for (const cmd of this.commands.values()) {
+      const metadata = cmd.options.metadata;
+      if (!metadata?.category) continue;
+      let entry = categories.get(metadata.category);
+      if (!entry) {
+        entry = {
+          name: metadata.category,
+          emoji: metadata.categoryEmoji,
+          commands: []
+        };
+        categories.set(metadata.category, entry);
+      }
+      entry.commands.push(cmd);
     }
-    return matchedCommands;
+    return Array.from(categories.values()).sort((a, b) => a.name.localeCompare(b.name)).map((cat) => {
+      cat.commands.sort((a, b) => {
+        const commandNameA = "builder" in a ? a.builder.name : a.options.name;
+        const commandNameB = "builder" in b ? b.builder.name : b.options.name;
+        return commandNameA.localeCompare(commandNameB);
+      });
+      return cat;
+    });
+  }
+  /**
+   * Imports command modules from a directory.
+   * @param dir Path of one or more folders.
+   * @param set Replaces imported command modules with the ones found.
+   */
+  async importFrom(dir, set = false) {
+    if (set) this.commands.clear();
+    const dirs = Array.isArray(dir) ? dir : [dir];
+    const modules = [];
+    for (const _dir of dirs) {
+      const results = await importModulesFromDir(_dir, this.moduleSuffix);
+      modules.push(...results.map(({ module }) => module.default));
+    }
+    for (const module of modules) {
+      const commandName = "builder" in module ? module.builder.name : module.options.name;
+      this.commands.set(commandName, module);
+    }
+    let moduleType;
+    switch (this.type) {
+      case 0 /* Slash */:
+        moduleType = "Prefix Commands";
+        break;
+      case 2 /* Context */:
+        moduleType = "Context Commands";
+        break;
+      case 1 /* Prefix */:
+        moduleType = "Prefix Commands";
+        break;
+    }
+    this.client.logger.moduleLoaded(moduleType, modules.length);
+    return this.commands;
+  }
+};
+var SlashCommandManager = class extends BaseCommandManager {
+  constructor(client) {
+    super(client, 0 /* Slash */, client.config.app.moduleSuffixes.slashCommand);
+  }
+};
+var ContextCommandManager = class extends BaseCommandManager {
+  constructor(client) {
+    super(client, 2 /* Context */, client.config.app.moduleSuffixes.contextCommand);
+  }
+};
+var PrefixCommandManager = class extends BaseCommandManager {
+  constructor(client) {
+    super(client, 1 /* Prefix */, client.config.app.moduleSuffixes.prefixCommand);
+  }
+};
+var CommandManager = class {
+  client;
+  slash;
+  prefix;
+  context;
+  constructor(client) {
+    this.client = client;
+    this.slash = new SlashCommandManager(client);
+    this.prefix = new PrefixCommandManager(client);
+    this.context = new ContextCommandManager(client);
+  }
+  getAllAppCommands(options = {}) {
+    return [...this.slash.getAll(options), ...this.context.getAll(options)];
   }
-  async registerGlobal(options) {
+  async registerGlobal(options = {}) {
     const client = await this.client.whenReady();
-    const commands = Array.from(
-      this.getAll({
-        names: options?.commands,
-        fuzzyNames: options?.fuzzyCommands,
-        globalOnly: true
-      }).values()
-    ).map((cmd) => cmd.builder.toJSON());
+    if (!client.rest) {
+      console.error(`[CommandManager] \u2716 Failed to register app commands globally: REST is not initialized`);
+      return;
+    }
+    const commands = this.getAllAppCommands(options);
     if (!commands.length) {
-      console.log(`[${this.typeName}] No commands to register`);
+      console.log("[CommandManager] No commands to register globally");
       return;
     }
-    console.log(`[${this.typeName}] Registering ${commands.length} commands globally...`);
+    console.log(`[CommandManager] Registering (${commands.length}) commands globally...`);
     try {
-      await this.rest.put(Routes.applicationCommands(client.user.id), { body: commands });
-      console.log(`[${this.typeName}] \u2714 Registered app commands globally`);
+      await client.rest.put(Routes.applicationCommands(client.user.id), { body: commands });
+      console.log(`[CommandManager] \u2714 Registered app commands globally`);
     } catch (err) {
-      console.log(`[${this.typeName}] \u2716 Failed to register app commands globally`, err);
+      console.error(`[CommandManager] \u2716 Failed to register app commands globally`, err);
     }
   }
-  async registerGuild(options) {
+  async unregisterGlobal() {
     const client = await this.client.whenReady();
-    const commands = Array.from(
-      this.getAll({
-        names: options?.commands,
-        fuzzyNames: options?.fuzzyCommands
-      }).values()
-    ).map((cmd) => cmd.builder.toJSON());
+    if (!client.rest) {
+      console.error(`[CommandManager] \u2716 Failed to remove app commands globally: REST is not initialized`);
+      return;
+    }
+    try {
+      await client.rest.put(Routes.applicationCommands(client.user.id), { body: [] });
+      console.log(`[CommandManager] \u2714 Removed app commands globally`);
+    } catch (err) {
+      console.error(`[CommandManager] \u2716 Failed to remove app commands globally`, err);
+    }
+  }
+  async registerGuild(options = {}) {
+    const client = await this.client.whenReady();
+    if (!client.rest) {
+      console.error(`[CommandManager] \u2716 Failed to register app commands by guild: REST is not initialized`);
+      return;
+    }
+    const commands = this.getAllAppCommands(options);
     if (!commands.length) {
-      console.log(`[${this.typeName}] No commands to register`);
+      console.log("[CommandManager] No commands to register by guild");
       return;
     }
-    const guildIds = options?.guilds || client.guilds.cache.map((g) => g.id);
-    console.log(`[${this.typeName}] Registering ${commands.length} commands for ${guildIds.length} guilds...`);
+    const guildIds = options.guilds || client.guilds.cache.map((g) => g.id);
+    console.log(`[CommandManager] Registering (${commands.length}) commands for ${guildIds.length} guilds...`);
     await Promise.all(
       guildIds.map(
-        (guildId) => this.rest.put(Routes.applicationGuildCommands(client.user.id, guildId), { body: commands }).then(() => {
+        (guildId) => client.rest.put(Routes.applicationGuildCommands(client.user.id, guildId), { body: commands }).then(() => {
           const gName = client.guilds.cache.get(guildId)?.name || "n/a";
-          console.log(`[${this.typeName}] \u2714 Set app commands in guild: ${guildId} (${gName})`);
+          console.log(`[CommandManager] \u2714 Set app commands in guild: ${guildId} (${gName})`);
         }).catch((err) => {
           const gName = client.guilds.cache.get(guildId)?.name || "n/a";
-          console.log(`[${this.typeName}] \u2716 Failed to set app commands in guild: ${guildId} (${gName})`, err);
+          console.log(`[CommandManager] \u2716 Failed to set app commands in guild: ${guildId} (${gName})`, err);
         })
       )
     );
   }
-  async unregisterGuild(options) {
+  async unregisterGuild(options = {}) {
     const client = await this.client.whenReady();
-    const guildIds = options?.guilds || client.guilds.cache.map((g) => g.id);
-    console.log(`[${this.typeName}] Unregistering commands from ${guildIds.length} guilds...`);
+    if (!client.rest) {
+      console.error(`[CommandManager] \u2716 Failed to register app commands by guild: REST is not initialized`);
+      return;
+    }
+    const guildIds = options.guilds || client.guilds.cache.map((g) => g.id);
+    console.log(`[CommandManager] Unregistering commands from ${guildIds.length} guilds...`);
     await Promise.all(
       guildIds.map(
-        (guildId) => this.rest.put(Routes.applicationGuildCommands(client.user.id, guildId), { body: [] }).then(() => console.log(`[${this.typeName}] \u2714 Removed app commands in guild: ${guildId}`)).catch(
-          (err) => console.log(`[${this.typeName}] \u2716 Failed to remove app commands in guild: ${guildId}`, err)
-        )
+        (guildId) => client.rest.put(Routes.applicationGuildCommands(client.user.id, guildId), { body: [] }).then(() => console.log(`[CommandManager] \u2714 Removed app commands in guild: ${guildId}`)).catch((err) => console.log(`[CommandManager] \u2716 Failed to remove app commands in guild: ${guildId}`, err))
       )
     );
   }
-  async unregisterGlobal() {
-    const client = await this.client.whenReady();
-    try {
-      await this.rest.put(Routes.applicationCommands(client.user.id), { body: [] });
-      console.log(`[${this.typeName}] \u2714 Removed app commands globally`);
-    } catch (err) {
-      console.log(`[${this.typeName}] \u2716 Failed to remove app commands globally`, err);
-    }
-  }
-};
-var VimcordSlashCommandManager = class extends VimcordAppCommandManager {
-  constructor(client) {
-    super(client, "SlashCommandManager");
-  }
-  async importFrom(dir, replaceAll = false) {
-    if (replaceAll) this.commands.clear();
-    const dirs = Array.isArray(dir) ? dir : [dir];
-    const modules = (await Promise.all(
-      dirs.map((d) => importModulesFromDir(d, "slash"))
-    )).flat();
-    for (const { module } of modules) {
-      this.commands.set(module.default.builder.name, module.default);
-    }
-    this.client.logger.moduleLoaded("Slash Commands", modules.length);
-    return this.commands;
-  }
-};
-var VimcordContextCommandManager = class extends VimcordAppCommandManager {
-  constructor(client) {
-    super(client, "ContextCommandManager");
-  }
-  async importFrom(dir, replaceAll = false) {
-    if (replaceAll) this.commands.clear();
-    const dirs = Array.isArray(dir) ? dir : [dir];
-    const modules = (await Promise.all(
-      dirs.map((d) => importModulesFromDir(d, "ctx"))
-    )).flat();
-    for (const { module } of modules) {
-      this.commands.set(module.default.builder.name, module.default);
-    }
-    this.client.logger.moduleLoaded("Context Commands", modules.length);
-    return this.commands;
-  }
-};
-var VimcordPrefixCommandManager = class {
-  constructor(client) {
-    this.client = client;
-  }
-  commands = /* @__PURE__ */ new Map();
-  resolve(trigger) {
-    const config = this.client.config.prefixCommands;
-    const search = config.allowCaseInsensitiveCommandNames ? trigger.toLowerCase() : trigger;
-    return Array.from(this.commands.values()).find((cmd) => {
-      const opts = cmd.toConfig();
-      const name = config.allowCaseInsensitiveCommandNames ? opts.name.toLowerCase() : opts.name;
-      if (name === search) return true;
-      return opts.aliases?.some(
-        (a) => config.allowCaseInsensitiveCommandNames ? a.toLowerCase() === search : a === search
-      );
-    });
-  }
-  async importFrom(dir, replaceAll = false) {
-    if (replaceAll) this.commands.clear();
-    const dirs = Array.isArray(dir) ? dir : [dir];
-    const modules = (await Promise.all(
-      dirs.map(
-        (d) => importModulesFromDir(d, "prefix")
-      )
-    )).flat();
-    for (const { module } of modules) {
-      this.commands.set(module.default.toConfig().name, module.default);
-    }
-    this.client.logger.moduleLoaded("Prefix Commands", modules.length);
-    return this.commands;
-  }
-};
-var VimcordCommandManager = class {
-  slash;
-  prefix;
-  context;
-  constructor(client) {
-    this.slash = new VimcordSlashCommandManager(client);
-    this.prefix = new VimcordPrefixCommandManager(client);
-    this.context = new VimcordContextCommandManager(client);
-  }
 };
 
 // src/modules/event.manager.ts
 import { Events } from "discord.js";
-var VimcordEventManager = class {
+var EventManager = class {
   client;
   events = /* @__PURE__ */ new Map();
   logger;
@@ -2129,7 +2179,7 @@ async function sendCommandErrorEmbed(client, error, guild, messageOrInteraction)
   const embed_error = config?.embed?.(new BetterEmbed(), error, guild) || new BetterEmbed({
     color: "Red",
     title: "Something went wrong",
-    description: "If you keep encountering this error, please report it"
+    description: "If you keep encountering this error, please report it."
   });
   const msg = await embed_error.send(messageOrInteraction, {
     components: [actionRow],
@@ -2175,7 +2225,7 @@ async function retryExponentialBackoff(fn, maxRetries = 3, retryDelay = 1e3) {
 }
 
 // package.json
-var version = "1.0.22";
+var version = "1.0.24";
 
 // src/client.ts
 import { randomUUID as randomUUID3 } from "crypto";
@@ -2269,9 +2319,9 @@ var Vimcord = class _Vimcord extends Client2 {
       prefixCommands: createVimcordPrefixCommandConfig(config.prefixCommands),
       contextCommands: createVimcordContextCommandConfig(config.contextCommands)
     };
-    this.status = new VimcordStatusManager(this);
-    this.events = new VimcordEventManager(this);
-    this.commands = new VimcordCommandManager(this);
+    this.status = new StatusManager(this);
+    this.events = new EventManager(this);
+    this.commands = new CommandManager(this);
     if (this.features.useEnv) {
       if (typeof this.features.useEnv === "object") {
         dotEnv.config({ quiet: true, ...this.features.useEnv });
@@ -2470,7 +2520,7 @@ var defaultPrefixCommandHandler = new EventBuilder({
     const args = contentWithoutPrefix.split(/\s+/);
     const trigger = args.shift();
     if (!trigger) return;
-    const command = client.commands.prefix.resolve(trigger);
+    const command = client.commands.prefix.get(trigger);
     if (!command) return;
     message.content = args.join(" ");
     try {
@@ -2790,7 +2840,7 @@ var MongoSchemaBuilder = class {
       return this.model.findOne(filter, projection, { ...options, lean: options?.lean ?? true });
     });
   }
-  async fetchAll(filter, projection, options) {
+  async fetchAll(filter = {}, projection, options) {
     return await this.execute(async () => {
       return this.model.find(filter, projection, { ...options, lean: options?.lean ?? true });
     }) || [];
@@ -4090,13 +4140,11 @@ CLI.addCommand("register", "Register app commands (slash & context) globally, or
   switch (mode) {
     case "guild":
       CLI.logger.info("Registering guild commands...");
-      await client.commands.slash.registerGuild({ guilds: guildIds });
-      await client.commands.context.registerGuild({ guilds: guildIds });
+      await client.commands.registerGuild({ guilds: guildIds });
       break;
     case "global":
       CLI.logger.info("Registering global commands...");
-      await client.commands.slash.registerGlobal();
-      await client.commands.context.registerGlobal();
+      await client.commands.registerGlobal();
       break;
   }
 });
@@ -4112,13 +4160,11 @@ CLI.addCommand("unregister", "Unregister app commands globally, or per guild", a
   switch (mode) {
     case "guild":
       CLI.logger.info("Unregistering guild commands...");
-      await client.commands.slash.unregisterGuild({ guilds: guildIds });
-      await client.commands.context.unregisterGuild({ guilds: guildIds });
+      await client.commands.unregisterGuild({ guilds: guildIds });
       break;
     case "global":
       CLI.logger.info("Unregistering global commands...");
-      await client.commands.slash.unregisterGlobal();
-      await client.commands.context.unregisterGlobal();
+      await client.commands.unregisterGlobal();
       break;
   }
 });
@@ -4219,16 +4265,20 @@ function pickRandom(arr, options) {
 }
 export {
   BaseCommandBuilder,
+  BaseCommandManager,
   BetterCollector,
   BetterContainer,
   BetterEmbed,
   BetterModal,
   CLI,
   CollectorTimeoutType,
+  CommandManager,
   CommandType,
   ContextCommandBuilder,
+  ContextCommandManager,
   DynaSend,
   EventBuilder,
+  EventManager,
   LOGGER_COLORS,
   LogLevel,
   Logger,
@@ -4239,20 +4289,17 @@ export {
   PaginationType,
   Paginator,
   PrefixCommandBuilder,
+  PrefixCommandManager,
   Prompt,
   PromptResolveType,
   RateLimitScope,
   SendMethod,
   SlashCommandBuilder,
+  SlashCommandManager,
+  StatusManager,
   StatusType,
   Vimcord,
   VimcordCLI,
-  VimcordCommandManager,
-  VimcordContextCommandManager,
-  VimcordEventManager,
-  VimcordPrefixCommandManager,
-  VimcordSlashCommandManager,
-  VimcordStatusManager,
   __zero,
   cleanMention,
   clientInstances,