@spatulox/simplediscordbot 1.7.1 → 2.0.0

package/dist/index.js

@@ -5279,7 +5279,7 @@ var InternetChecker = class {
           tries > 0 ? `Ping failed (${errorMsg}) - Attempt ${attempt}/${tries}` : `Ping failed (${errorMsg}) - Retrying in ${this.RETRY_TIME.toSeconds()} seconds...`
         );
         try {
-          await new Promise((resolve) => setTimeout(resolve, this.RETRY_TIME.toMilliseconds()));
+          await new Promise((resolve2) => setTimeout(resolve2, this.RETRY_TIME.toMilliseconds()));
         } catch {
           Log.error("Retry delay failed.");
         }
@@ -5435,31 +5435,85 @@ var _BotLog = class _BotLog {
       Log.warn("Client not ready for Discord logging init");
       return;
     }
-    if (Bot.config.log?.logChannelId) {
-      try {
-        const logCh = await Bot.client.channels.fetch(Bot.config.log.logChannelId);
-        if (logCh?.isTextBased()) {
-          _BotLog.logChannel = logCh;
-        } else {
-          Log.warn(`Log channel ${Bot.config.log.logChannelId} invalid`);
-        }
-      } catch (error) {
-        Log.error(`Log channel fetch failed: ${error}`);
-      }
-    }
-    if (Bot.config.log?.errorChannelId) {
+    const logTypes = [
+      { config: "info", prop: "logChannel" },
+      { config: "warn", prop: "warnChannel" },
+      { config: "error", prop: "errorChannel" },
+      { config: "debug", prop: "debugChannel" }
+    ];
+    for (const { config, prop } of logTypes) {
+      const channelId = Bot.config.log?.[config]?.channelId;
+      if (!channelId) continue;
       try {
-        const errorCh = await Bot.client.channels.fetch(Bot.config.log.errorChannelId);
-        if (errorCh?.isTextBased()) {
-          _BotLog.errorChannel = errorCh;
+        const channel = await Bot.client.channels.fetch(channelId);
+        if (channel?.isTextBased()) {
+          _BotLog[prop] = channel;
         } else {
-          Log.warn(`Error channel ${Bot.config.log.errorChannelId} invalid`);
+          Log.warn(`${config.charAt(0).toUpperCase() + config.slice(1)} channel ${channelId} invalid`);
         }
       } catch (error) {
-        Log.error(`Error channel fetch failed: ${error}`);
+        Log.error(`${config.charAt(0).toUpperCase() + config.slice(1)} channel fetch failed: ${error}`);
       }
     }
   }
+  /*public static async initDiscordLogging(): Promise<void> {
+          if (!Bot.client.isReady()) {
+              Log.warn('Client not ready for Discord logging init');
+              return;
+          }
+  
+          if (Bot.config.log?.info.channelId) {
+              try {
+                  const logCh = await Bot.client.channels.fetch(Bot.config.log.info.channelId) as TextChannel;
+                  if (logCh?.isTextBased()) {
+                      BotLog.logChannel = logCh;
+                  } else {
+                      Log.warn(`Log channel ${Bot.config.log.info.channelId} invalid`);
+                  }
+              } catch (error) {
+                  Log.error(`Log channel fetch failed: ${error}`);
+              }
+          }
+  
+          if (Bot.config.log?.warn.channelId) {
+              try {
+                  const errorCh = await Bot.client.channels.fetch(Bot.config.log.warn.channelId) as TextChannel;
+                  if (errorCh?.isTextBased()) {
+                      BotLog.warnChannel = errorCh;
+                  } else {
+                      Log.warn(`Warn channel ${Bot.config.log.warn.channelId} invalid`);
+                  }
+              } catch (error) {
+                  Log.error(`Warn channel fetch failed: ${error}`);
+              }
+          }
+  
+          if (Bot.config.log?.error.channelId) {
+              try {
+                  const errorCh = await Bot.client.channels.fetch(Bot.config.log.error.channelId) as TextChannel;
+                  if (errorCh?.isTextBased()) {
+                      BotLog.errorChannel = errorCh;
+                  } else {
+                      Log.warn(`Error channel ${Bot.config.log.error.channelId} invalid`);
+                  }
+              } catch (error) {
+                  Log.error(`Error channel fetch failed: ${error}`);
+              }
+          }
+  
+          if (Bot.config.log?.debug.channelId) {
+              try {
+                  const errorCh = await Bot.client.channels.fetch(Bot.config.log.debug.channelId) as TextChannel;
+                  if (errorCh?.isTextBased()) {
+                      BotLog.debugChannel = errorCh;
+                  } else {
+                      Log.warn(`Debug channel ${Bot.config.log.debug.channelId} invalid`);
+                  }
+              } catch (error) {
+                  Log.error(`Debug channel fetch failed: ${error}`);
+              }
+          }
+      }*/
   /**
    * Send content to specific Discord channel
    */
@@ -5526,8 +5580,8 @@ var _BotLog = class _BotLog {
         Log.warn(content);
       }
     }
-    if (logConfig?.warn.discord && this.logChannel) {
-      return await this._sendToChannel(this.logChannel, content, "warn");
+    if (logConfig?.warn.discord && this.warnChannel) {
+      return await this._sendToChannel(this.warnChannel, content, "warn");
     }
   }
   /**
@@ -5540,12 +5594,14 @@ var _BotLog = class _BotLog {
         Log.debug(content);
       }
     }
-    if (logConfig?.debug.discord && this.logChannel) {
-      return await this._sendToChannel(this.logChannel, content, "debug");
+    if (logConfig?.debug.discord && this.debugChannel) {
+      return await this._sendToChannel(this.debugChannel, content, "debug");
     }
   }
 };
 _BotLog.logChannel = null;
+_BotLog.warnChannel = null;
+_BotLog.debugChannel = null;
 _BotLog.errorChannel = null;
 var BotLog = _BotLog;
 
@@ -5661,8 +5717,8 @@ var EmbedManager = class {
   /**
    * Quick field adder
    */
-  static field(embed, name, value, inline = false) {
-    return embed.addFields({ name, value, inline });
+  static field(embed, field) {
+    return embed.addFields({ name: field.name, value: field.value, inline: field.inline ?? false });
   }
   static fields(embed, fields) {
     fields.forEach((f3) => {
@@ -14315,7 +14371,7 @@ var _Bot = class _Bot {
         Log.error(`Connection error : ${error}. Trying again...`);
         tries++;
         await new Promise(
-          (resolve) => setTimeout(resolve, Time.second.SEC_03.toMilliseconds())
+          (resolve2) => setTimeout(resolve2, Time.second.SEC_03.toMilliseconds())
         );
       }
     }
@@ -14478,86 +14534,102 @@ var FileManager = class {
 
 // src/manager/messages/WebhookManager.ts
 var import_discord7 = require("discord.js");
+var import_promises2 = require("fs/promises");
+var import_path2 = require("path");
 var WebhookManager = class {
-  constructor(channel, name = Bot.config.botName || "", avatarURL) {
-    this.channel = channel;
+  constructor(client, name, avatarPathOrUrl) {
+    this.client = client;
     this.name = name;
-    this.avatarURL = avatarURL;
+    this.avatarPathOrUrl = avatarPathOrUrl;
     this.webhook = null;
   }
-  get textChannel() {
-    return this.channel instanceof import_discord7.ThreadChannel ? this.channel.parent : this.channel;
+  async getAvatar() {
+    if (!this.avatarPathOrUrl) return null;
+    if (this.avatarPathOrUrl.startsWith("http://") || this.avatarPathOrUrl.startsWith("https://")) {
+      return this.avatarPathOrUrl;
+    }
+    try {
+      const resolvedPath = (0, import_path2.resolve)(process.cwd(), this.avatarPathOrUrl);
+      return await (0, import_promises2.readFile)(resolvedPath);
+    } catch (error) {
+      Bot.log.warn(`Failed to load avatar from ${this.avatarPathOrUrl}: ${error}`);
+      return null;
+    }
+  }
+  /**
+   * Récupère le channel à partir de l'ID ou utilise directement si TextChannel/ThreadChannel
+   */
+  async getTextChannel(channelId) {
+    const channel = await this.client.channels.fetch(channelId);
+    if (!channel || !(channel instanceof import_discord7.TextChannel)) {
+      throw new Error(`Channel ${channelId} is not a TextChannel`);
+    }
+    return channel;
   }
   /**
    * Get or create webhook (lazy initialization)
    */
-  async getWebhook() {
+  async getWebhook(channelId) {
     if (this.webhook) return this.webhook;
     try {
-      const webhooks = await this.textChannel.fetchWebhooks();
-      this.webhook = webhooks.find((h3) => h3.name === this.name && h3.owner?.id == Bot.client.user?.id) ?? await this.textChannel.createWebhook({
+      const textChannel = await this.getTextChannel(channelId);
+      const webhooks = await textChannel.fetchWebhooks();
+      this.webhook = webhooks.find((h3) => h3.name === this.name && h3.owner?.id == this.client.user?.id) ?? await textChannel.createWebhook({
         name: this.name,
-        avatar: this.avatarURL,
+        avatar: await this.getAvatar(),
         reason: "Auto-created by WebhookManager"
       });
-      Log.info(`Webhook ${this.webhook.id} ready for ${this.textChannel.id}`);
+      Bot.log.debug(`Webhook ${this.webhook.id} ready for channel ${channelId}`);
       return this.webhook;
     } catch (error) {
-      Log.error(`Failed to setup webhook: ${error}`);
+      Bot.log.error(`Failed to setup webhook for ${channelId}: ${error}`);
       throw error;
     }
   }
-  async send(content) {
-    const webhook = await this.getWebhook();
-    const options = {};
+  async send(channelId, content) {
+    const webhook = await this.getWebhook(channelId);
+    let options = {};
     if (SendableComponentBuilder.isSendableComponent(content)) {
-      const t3 = SendableComponentBuilder.buildMessage(content);
-      options.embeds = t3.embeds;
-      options.components = t3.components;
-    } else if (typeof content == "string") {
+      options = SendableComponentBuilder.buildMessage(content);
+    } else if (typeof content === "string") {
       options.content = content;
     } else if (typeof content === "object") {
       Object.assign(options, content);
     } else {
-      options.content = content;
-    }
-    if (this.channel instanceof import_discord7.ThreadChannel) {
-      options.threadId = this.channel.id;
+      options.content = String(content);
     }
     try {
-      const message = await webhook.send(options);
-      Log.info(`Webhook sent to ${this.channel.id}: ${content}`);
-      return message;
+      return await webhook.send(options);
     } catch (error) {
-      Log.error(`Webhook send failed ${this.channel.id}: ${error}`);
+      Bot.log.error(`Webhook send failed to ${channelId}: ${error}`);
       return null;
     }
   }
   /**
    * Quick success embed
    */
-  async success(message) {
-    return await this.send(EmbedManager.success(message));
+  async success(channelId, message) {
+    return await this.send(channelId, EmbedManager.success(message));
   }
   /**
    * Quick error embed
    */
-  async error(message) {
-    return await this.send(EmbedManager.error(message));
+  async error(channelId, message) {
+    return await this.send(channelId, EmbedManager.error(message));
   }
   /**
    * Delete webhook
    */
-  async delete(reason) {
+  async delete(channelId, reason) {
     if (!this.webhook) return;
     try {
       await this.webhook.delete(reason ?? "Deleted by WebhookManager");
-      Log.info(`Webhook ${this.webhook.id} deleted`);
+      Bot.log.info(`Webhook ${this.webhook.id} deleted from ${channelId}`);
     } catch (error) {
       if (error.message.includes("Unknown Webhook")) {
-        Log.warn("Webhook already deleted");
+        Bot.log.warn(`Webhook already deleted from ${channelId}`);
       } else {
-        Log.error(`Failed to delete webhook: ${error}`);
+        Bot.log.error(`Failed to delete webhook from ${channelId}: ${error}`);
       }
     } finally {
       this.webhook = null;
@@ -14863,7 +14935,7 @@ var ReactionManager = class {
 };
 
 // src/manager/guild/GuildManager.ts
-var import_discord15 = require("discord.js");
+var import_discord14 = require("discord.js");
 
 // src/manager/direct/BasicUserManager.ts
 var import_discord9 = require("discord.js");
@@ -14938,22 +15010,9 @@ var BasicUserManager = class {
 };
 
 // src/manager/guild/GuildUserManager.ts
-var import_discord10 = require("discord.js");
-var import_promises2 = require("timers/promises");
+var import_promises3 = require("timers/promises");
 var MAX_NICKNAME_LENGTH = 32;
 var GuildUserManager = class extends BasicUserManager {
-  static async find(userId, guild) {
-    try {
-      if (guild instanceof import_discord10.Guild) {
-        return await guild.members.fetch(userId);
-      } else {
-        return await (await GuildManager.find(guild)).members.fetch(userId);
-      }
-    } catch (error) {
-      Log.error(`UserManager: Member ${userId} not found`);
-      return null;
-    }
-  }
   static async rename(member, nickname, maxAttempts = 3) {
     if (nickname.length > MAX_NICKNAME_LENGTH) {
       nickname = nickname.slice(0, MAX_NICKNAME_LENGTH);
@@ -14963,11 +15022,11 @@ var GuildUserManager = class extends BasicUserManager {
         const oldName = member.displayName;
         await member.setNickname(nickname.trim());
         Log.info(`Renaming user: ${oldName} \u2192 ${nickname.trim()}`);
-        await (0, import_promises2.setTimeout)(1500);
+        await (0, import_promises3.setTimeout)(1500);
         return true;
       } catch (error) {
         console.error(`Attempt ${attempts + 1} failed when renaming ${member.displayName} into ${nickname.trim()}:`, error);
-        await (0, import_promises2.setTimeout)(1e3);
+        await (0, import_promises3.setTimeout)(1e3);
       }
     }
     Bot.log.info(EmbedManager.error(`Failed to rename ${member.displayName} to ${nickname.trim()} after ${maxAttempts} attempts.`));
@@ -15242,15 +15301,15 @@ var RoleManager = class {
 };
 
 // src/manager/guild/ChannelManager/ForumChannelManager.ts
-var import_discord11 = require("discord.js");
+var import_discord10 = require("discord.js");
 var ForumChannelManager = class extends GuildChannelManager {
   static async findInGuild(guildId, channelId) {
     const channel = await super.findInGuild(guildId, channelId);
-    return channel instanceof import_discord11.ForumChannel ? channel : null;
+    return channel instanceof import_discord10.ForumChannel ? channel : null;
   }
   static async find(channelId) {
     const channel = await super.find(channelId);
-    return channel instanceof import_discord11.ForumChannel ? channel : null;
+    return channel instanceof import_discord10.ForumChannel ? channel : null;
   }
   static findAll(guildId) {
     const guild = Bot.client.guilds.cache.get(guildId);
@@ -15258,27 +15317,27 @@ var ForumChannelManager = class extends GuildChannelManager {
       Log.warn(`Guild ${guildId} not found`);
       return [];
     }
-    return Array.from(guild.channels.cache.values()).filter((c3) => c3 instanceof import_discord11.ForumChannel);
+    return Array.from(guild.channels.cache.values()).filter((c3) => c3 instanceof import_discord10.ForumChannel);
   }
   static async create(guildId, name, options) {
     return await super._create(guildId, {
       name,
-      type: import_discord11.ChannelType.GuildForum,
+      type: import_discord10.ChannelType.GuildForum,
       ...options
     });
   }
 };
 
 // src/manager/guild/ChannelManager/NewsChannelManager.ts
-var import_discord12 = require("discord.js");
+var import_discord11 = require("discord.js");
 var NewsChannelManager = class extends GuildChannelManager {
   static async findInGuild(guildId, channelId) {
     const channel = await super.findInGuild(guildId, channelId);
-    return channel instanceof import_discord12.NewsChannel ? channel : null;
+    return channel instanceof import_discord11.NewsChannel ? channel : null;
   }
   static async find(channelId) {
     const channel = await super.find(channelId);
-    return channel instanceof import_discord12.NewsChannel ? channel : null;
+    return channel instanceof import_discord11.NewsChannel ? channel : null;
   }
   static findAll(guildId) {
     const guild = Bot.client.guilds.cache.get(guildId);
@@ -15286,27 +15345,27 @@ var NewsChannelManager = class extends GuildChannelManager {
       Log.warn(`Guild ${guildId} not found`);
       return [];
     }
-    return Array.from(guild.channels.cache.values()).filter((c3) => c3 instanceof import_discord12.NewsChannel);
+    return Array.from(guild.channels.cache.values()).filter((c3) => c3 instanceof import_discord11.NewsChannel);
   }
   static async create(guildId, name, options) {
     return await super._create(guildId, {
       name,
-      type: import_discord12.ChannelType.GuildAnnouncement,
+      type: import_discord11.ChannelType.GuildAnnouncement,
       ...options
     });
   }
 };
 
 // src/manager/guild/ChannelManager/StageChannelManager.ts
-var import_discord13 = require("discord.js");
+var import_discord12 = require("discord.js");
 var StageChannelManager = class extends GuildChannelManager {
   static async findInGuild(guildId, channelId) {
     const channel = await super.findInGuild(guildId, channelId);
-    return channel instanceof import_discord13.StageChannel ? channel : null;
+    return channel instanceof import_discord12.StageChannel ? channel : null;
   }
   static async find(channelId) {
     const channel = await super.find(channelId);
-    return channel instanceof import_discord13.StageChannel ? channel : null;
+    return channel instanceof import_discord12.StageChannel ? channel : null;
   }
   static findAll(guildId) {
     const guild = Bot.client.guilds.cache.get(guildId);
@@ -15314,12 +15373,12 @@ var StageChannelManager = class extends GuildChannelManager {
       Log.warn(`Guild ${guildId} not found`);
       return [];
     }
-    return Array.from(guild.channels.cache.values()).filter((c3) => c3 instanceof import_discord13.StageChannel);
+    return Array.from(guild.channels.cache.values()).filter((c3) => c3 instanceof import_discord12.StageChannel);
   }
   static async create(guildId, name, options) {
     return await super._create(guildId, {
       name,
-      type: import_discord13.ChannelType.GuildStageVoice,
+      type: import_discord12.ChannelType.GuildStageVoice,
       ...options
     });
   }
@@ -15367,7 +15426,7 @@ var ThreadChannelManager = class {
 };
 
 // src/manager/guild/ChannelManager/GuildVoiceChannelManager.ts
-var import_discord14 = require("discord.js");
+var import_discord13 = require("discord.js");
 var GuildVoiceChannelManager = class extends GuildChannelManager {
   static async findInGuild(guildId, channelId) {
     const channel = await super.findInGuild(guildId, channelId);
@@ -15383,12 +15442,12 @@ var GuildVoiceChannelManager = class extends GuildChannelManager {
       Log.warn(`Guild ${guildId} not found`);
       return [];
     }
-    return Array.from(guild.channels.cache.values()).filter((c3) => c3 instanceof import_discord14.VoiceChannel);
+    return Array.from(guild.channels.cache.values()).filter((c3) => c3 instanceof import_discord13.VoiceChannel);
   }
   static async create(guildId, name, options) {
     return await super._create(guildId, {
       name,
-      type: import_discord14.ChannelType.GuildVoice,
+      type: import_discord13.ChannelType.GuildVoice,
       ...options
     });
   }
@@ -15470,7 +15529,14 @@ var GuildManager = class {
     return Array.from(Bot.client.guilds.cache.values());
   }
   static async find(guild_id) {
-    return await Bot.client.guilds.fetch(guild_id);
+    try {
+      const cached = Bot.client.guilds.cache.get(guild_id);
+      if (cached) return cached;
+      return await Bot.client.guilds.fetch(guild_id);
+    } catch (error) {
+      Log.error(`GuildManager: Guild ${guild_id} : ${error} `);
+      return null;
+    }
   }
   /**
    * Search channel by ID (TextChannel, DMChannel, ThreadChannel)
@@ -15509,7 +15575,7 @@ var GuildManager = class {
    */
   static async fetchAllMembers(guildId, MAX_ATTEMPTS = 3, RETRY_DELAY = Time.minute.MIN_05.toMilliseconds()) {
     let guild;
-    if (guildId instanceof import_discord15.Guild) {
+    if (guildId instanceof import_discord14.Guild) {
       guild = guildId;
     } else {
       let tmp = Bot.client.guilds.cache.get(guildId);
@@ -15562,10 +15628,10 @@ var GuildManager = class {
       if (!toChannel) {
         throw new Error(`To channel ${toChannelId} not found`);
       }
-      if (!(fromChannel instanceof import_discord15.VoiceChannel || fromChannel instanceof import_discord15.StageChannel)) {
+      if (!(fromChannel instanceof import_discord14.VoiceChannel || fromChannel instanceof import_discord14.StageChannel)) {
         throw new Error(`From channel ${fromChannelId} is not a voice/stage channel`);
       }
-      if (!(toChannel instanceof import_discord15.VoiceChannel || toChannel instanceof import_discord15.StageChannel)) {
+      if (!(toChannel instanceof import_discord14.VoiceChannel || toChannel instanceof import_discord14.StageChannel)) {
         throw new Error(`To channel ${toChannelId} is not a voice/stage channel`);
       }
       if (member.voice.channelId !== fromChannelId) {
@@ -15602,7 +15668,7 @@ var UserManager = class extends BasicUserManager {
 };
 
 // src/manager/interactions/ModalManager.ts
-var import_discord16 = require("discord.js");
+var import_discord15 = require("discord.js");
 var ModalFieldType = /* @__PURE__ */ ((ModalFieldType2) => {
   ModalFieldType2[ModalFieldType2["SHORT"] = 0] = "SHORT";
   ModalFieldType2[ModalFieldType2["LONG"] = 1] = "LONG";
@@ -15616,13 +15682,13 @@ var ModalManager = class {
    * Creates base Modal - SIMPLE API !
    */
   static create(modalTitle, customId) {
-    return new import_discord16.ModalBuilder().setTitle(modalTitle).setCustomId(customId);
+    return new import_discord15.ModalBuilder().setTitle(modalTitle).setCustomId(customId);
   }
   /**
    * Individual field creator
    */
   static _createField(opt) {
-    const builder = new import_discord16.TextInputBuilder().setCustomId(opt.customId).setRequired(opt.required ?? false);
+    const builder = new import_discord15.TextInputBuilder().setCustomId(opt.customId).setRequired(opt.required ?? false);
     if (opt.value) {
       builder.setValue(opt.value);
     }
@@ -15633,22 +15699,22 @@ var ModalManager = class {
     }
     switch (opt.type) {
       case 0 /* SHORT */:
-        builder.setStyle(import_discord16.TextInputStyle.Short).setMaxLength(4e3);
+        builder.setStyle(import_discord15.TextInputStyle.Short).setMaxLength(4e3);
         break;
       case 1 /* LONG */:
-        builder.setStyle(import_discord16.TextInputStyle.Paragraph).setMaxLength(4e3);
+        builder.setStyle(import_discord15.TextInputStyle.Paragraph).setMaxLength(4e3);
         break;
       case 2 /* NUMBER */:
-        builder.setStyle(import_discord16.TextInputStyle.Short).setMaxLength(10);
+        builder.setStyle(import_discord15.TextInputStyle.Short).setMaxLength(10);
         break;
       case 3 /* DATE */:
-        builder.setStyle(import_discord16.TextInputStyle.Short).setMaxLength(10).setPlaceholder("YYYY-MM-DD / DD-MM-YYYY or YYYY/MM/DD / DD/MM/YYYY");
+        builder.setStyle(import_discord15.TextInputStyle.Short).setMaxLength(10).setPlaceholder("YYYY-MM-DD / DD-MM-YYYY or YYYY/MM/DD / DD/MM/YYYY");
         break;
       case 4 /* PHONE */:
-        builder.setStyle(import_discord16.TextInputStyle.Short).setMaxLength(20);
+        builder.setStyle(import_discord15.TextInputStyle.Short).setMaxLength(20);
         break;
     }
-    return new import_discord16.LabelBuilder().setLabel(opt.label).setTextInputComponent(builder);
+    return new import_discord15.LabelBuilder().setLabel(opt.label).setTextInputComponent(builder);
   }
   /**
   * Simple modal with ONE field - DIRECT ModalBuilder return !
@@ -15756,7 +15822,7 @@ var ModalManager = class {
 };
 
 // src/manager/messages/ComponentManager.ts
-var import_discord17 = require("discord.js");
+var import_discord16 = require("discord.js");
 var ComponentManager = class {
   static get DEFAULT_COLOR() {
     return Bot.config?.defaultSimpleColor || 6064856 /* default */;
@@ -15765,28 +15831,28 @@ var ComponentManager = class {
    * Creates base ComponentV2
    */
   static create(option) {
-    const container = new import_discord17.ContainerBuilder();
+    const container = new import_discord16.ContainerBuilder();
     const colorC = option?.color ?? this.DEFAULT_COLOR;
     if (colorC !== "transparent" /* transparent */) {
       container.setAccentColor(colorC);
     }
     if (option?.title || option?.thumbnailUrl) {
       if (option?.thumbnailUrl) {
-        const headerSection = new import_discord17.SectionBuilder().addTextDisplayComponents(
-          new import_discord17.TextDisplayBuilder().setContent(
+        const headerSection = new import_discord16.SectionBuilder().addTextDisplayComponents(
+          new import_discord16.TextDisplayBuilder().setContent(
             option?.title ? option.title : "\u200B"
           )
         ).setThumbnailAccessory(
-          new import_discord17.ThumbnailBuilder().setURL(option.thumbnailUrl)
+          new import_discord16.ThumbnailBuilder().setURL(option.thumbnailUrl)
         );
         container.addSectionComponents(headerSection);
       } else {
         container.addTextDisplayComponents(
-          new import_discord17.TextDisplayBuilder().setContent(option.title)
+          new import_discord16.TextDisplayBuilder().setContent(option.title)
         );
       }
       if (option?.description) {
-        container.addTextDisplayComponents(new import_discord17.TextDisplayBuilder().setContent(option.description));
+        container.addTextDisplayComponents(new import_discord16.TextDisplayBuilder().setContent(option.description));
       }
       if (option?.separator) {
         container.addSeparatorComponents(this.separator(option.separator));
@@ -15798,20 +15864,20 @@ var ComponentManager = class {
    * Creates simple ComponentV2 with just description
    */
   static simple(description, color = null) {
-    return this.create({ color }).addTextDisplayComponents(new import_discord17.TextDisplayBuilder().setContent(description)).addSeparatorComponents(this.separator());
+    return this.create({ color }).addTextDisplayComponents(new import_discord16.TextDisplayBuilder().setContent(description)).addSeparatorComponents(this.separator());
   }
   /**
    * Creates success ComponentV2
    */
   static success(description) {
-    return this.create({ title: "Success", color: 65280 /* success */ }).addTextDisplayComponents(new import_discord17.TextDisplayBuilder().setContent(description)).addSeparatorComponents(this.separator());
+    return this.create({ title: "Success", color: 65280 /* success */ }).addTextDisplayComponents(new import_discord16.TextDisplayBuilder().setContent(description)).addSeparatorComponents(this.separator());
   }
   /**
    * Creates debug ComponentV2
    */
   static debug(description) {
     return this.create({ title: "Debug", color: 25600 /* minecraft */ }).addTextDisplayComponents(
-      new import_discord17.TextDisplayBuilder().setContent(description)
+      new import_discord16.TextDisplayBuilder().setContent(description)
     ).addSeparatorComponents(this.separator());
   }
   /**
@@ -15819,31 +15885,31 @@ var ComponentManager = class {
    */
   static error(description) {
     return this.create({ title: "Something went wrong", color: 8912917 /* error */ }).addTextDisplayComponents(
-      new import_discord17.TextDisplayBuilder().setContent(description)
+      new import_discord16.TextDisplayBuilder().setContent(description)
     ).addSeparatorComponents(this.separator());
   }
-  static separator(spacing = import_discord17.SeparatorSpacingSize.Small) {
-    return new import_discord17.SeparatorBuilder().setDivider(true).setSpacing(spacing);
+  static separator(spacing = import_discord16.SeparatorSpacingSize.Small) {
+    return new import_discord16.SeparatorBuilder().setDivider(true).setSpacing(spacing);
   }
   /**
    * Quick field adder
    */
   static fieldAddText(container, options) {
-    options.name && container.addTextDisplayComponents(new import_discord17.TextDisplayBuilder().setContent(`__**${options.name}**__`));
-    container.addTextDisplayComponents(new import_discord17.TextDisplayBuilder().setContent(options.value));
+    options.name && container.addTextDisplayComponents(new import_discord16.TextDisplayBuilder().setContent(`__**${options.name}**__`));
+    container.addTextDisplayComponents(new import_discord16.TextDisplayBuilder().setContent(options.value));
   }
   static field(container, field) {
     if ("button" in field && Array.isArray(field.button) && field.button.length > 0) {
-      const actionRow = new import_discord17.ActionRowBuilder().addComponents(field.button);
+      const actionRow = new import_discord16.ActionRowBuilder().addComponents(field.button);
       this.fieldAddText(container, { name: field.name, value: field.value });
       container.addActionRowComponents(actionRow);
     } else if ("button" in field && !Array.isArray(field.button) || "thumbnailUrl" in field) {
-      const section = new import_discord17.SectionBuilder();
+      const section = new import_discord16.SectionBuilder();
       this.fieldAddText(section, { name: field.name, value: field.value });
       if ("button" in field && !Array.isArray(field.button)) {
         section.setButtonAccessory(field.button);
       } else if ("thumbnailUrl" in field) {
-        section.setThumbnailAccessory(new import_discord17.ThumbnailBuilder().setURL(field.thumbnailUrl));
+        section.setThumbnailAccessory(new import_discord16.ThumbnailBuilder().setURL(field.thumbnailUrl));
       }
       container.addSectionComponents(section);
     } else {
@@ -15871,9 +15937,9 @@ var ComponentManager = class {
    * Add a media gallery (links)
    */
   static mediaGallery(container, medias) {
-    const gallery = new import_discord17.MediaGalleryBuilder();
+    const gallery = new import_discord16.MediaGalleryBuilder();
     medias.forEach((med) => {
-      gallery.addItems(new import_discord17.MediaGalleryItemBuilder().setURL(med.url).setSpoiler(med.spoiler ?? false));
+      gallery.addItems(new import_discord16.MediaGalleryItemBuilder().setURL(med.url).setSpoiler(med.spoiler ?? false));
     });
     container.addMediaGalleryComponents(gallery);
     return container;
@@ -15890,12 +15956,12 @@ var ComponentManager = class {
     const files = [];
     const fileArray = Array.isArray(file) ? file : [file];
     fileArray.forEach((f3) => {
-      const attachment = new import_discord17.AttachmentBuilder(f3.buffer, {
+      const attachment = new import_discord16.AttachmentBuilder(f3.buffer, {
         name: f3.name
       });
       files.push(attachment);
       container.addFileComponents(
-        new import_discord17.FileBuilder().setURL(`attachment://${f3.name}`).setSpoiler(f3.spoiler ?? false)
+        new import_discord16.FileBuilder().setURL(`attachment://${f3.name}`).setSpoiler(f3.spoiler ?? false)
       );
       container.addSeparatorComponents(this.separator());
     });
@@ -15903,7 +15969,7 @@ var ComponentManager = class {
   }
   static footer(container) {
     container.addTextDisplayComponents(
-      new import_discord17.TextDisplayBuilder().setContent(`-# **${Bot.config?.botName || "Bot"} \xB7 <t:${Math.floor(Date.now() / 1e3)}:d> <t:${Math.floor(Date.now() / 1e3)}:t>**`)
+      new import_discord16.TextDisplayBuilder().setContent(`-# **${Bot.config?.botName || "Bot"} \xB7 <t:${Math.floor(Date.now() / 1e3)}:d> <t:${Math.floor(Date.now() / 1e3)}:t>**`)
     );
     return container;
   }
@@ -15921,12 +15987,12 @@ var ComponentManager = class {
       return {
         components: [container],
         files: Array.isArray(file) ? file : [file],
-        flags: [import_discord17.MessageFlags.IsComponentsV2]
+        flags: [import_discord16.MessageFlags.IsComponentsV2]
       };
     }
     return {
       components: [container],
-      flags: [import_discord17.MessageFlags.IsComponentsV2]
+      flags: [import_discord16.MessageFlags.IsComponentsV2]
     };
   }
   static toInteraction(container, file = null, footer = true) {
@@ -15935,7 +16001,7 @@ var ComponentManager = class {
     }
     const base = {
       components: [container],
-      flags: [import_discord17.MessageFlags.IsComponentsV2]
+      flags: [import_discord16.MessageFlags.IsComponentsV2]
     };
     if (file) {
       return {
@@ -15963,29 +16029,29 @@ var ComponentManager = class {
 };
 
 // src/manager/interactions/ButtonManager.ts
-var import_discord18 = require("discord.js");
+var import_discord17 = require("discord.js");
 var ButtonManager = class _ButtonManager {
   static create(options) {
-    const btn = new import_discord18.ButtonBuilder().setCustomId(options.customId).setLabel(options.label ?? "Button").setStyle(options.style).setDisabled(options.disabled ?? false);
+    const btn = new import_discord17.ButtonBuilder().setCustomId(options.customId).setLabel(options.label ?? "Button").setStyle(options.style).setDisabled(options.disabled ?? false);
     if (options.emoji) {
       btn.setEmoji(options.emoji);
     }
     return btn;
   }
   static primary(options) {
-    return this.create({ ...options, style: import_discord18.ButtonStyle.Primary });
+    return this.create({ ...options, style: import_discord17.ButtonStyle.Primary });
   }
   static success(options) {
-    return this.create({ ...options, style: import_discord18.ButtonStyle.Success });
+    return this.create({ ...options, style: import_discord17.ButtonStyle.Success });
   }
   static secondary(options) {
-    return this.create({ ...options, style: import_discord18.ButtonStyle.Secondary });
+    return this.create({ ...options, style: import_discord17.ButtonStyle.Secondary });
   }
   static danger(options) {
-    return this.create({ ...options, style: import_discord18.ButtonStyle.Danger });
+    return this.create({ ...options, style: import_discord17.ButtonStyle.Danger });
   }
   static link(options) {
-    const btn = new import_discord18.ButtonBuilder().setLabel(options.label).setStyle(import_discord18.ButtonStyle.Link).setURL(options.url);
+    const btn = new import_discord17.ButtonBuilder().setLabel(options.label).setStyle(import_discord17.ButtonStyle.Link).setURL(options.url);
     if (options.emoji) btn.setEmoji(options.emoji);
     return btn;
   }
@@ -15997,7 +16063,7 @@ var ButtonManager = class _ButtonManager {
   }
   static row(but) {
     const buttons = Array.isArray(but) ? but.slice(0, 5) : [but];
-    return new import_discord18.ActionRowBuilder().addComponents(buttons);
+    return new import_discord17.ActionRowBuilder().addComponents(buttons);
   }
   static toMessage(button) {
     return {
@@ -16007,7 +16073,7 @@ var ButtonManager = class _ButtonManager {
   static toInteraction(button, ephemeral = false) {
     return {
       components: this.createRowsToReturn(button),
-      flags: ephemeral ? [import_discord18.MessageFlags.Ephemeral] : []
+      flags: ephemeral ? [import_discord17.MessageFlags.Ephemeral] : []
     };
   }
   static toInteractionEdit(button) {
@@ -16018,10 +16084,10 @@ var ButtonManager = class _ButtonManager {
   static createRowsToReturn(button) {
     if (Array.isArray(button)) {
       return button.map(
-        (btn) => btn instanceof import_discord18.ActionRowBuilder ? btn : _ButtonManager.row(btn)
+        (btn) => btn instanceof import_discord17.ActionRowBuilder ? btn : _ButtonManager.row(btn)
       );
     }
-    return button instanceof import_discord18.ActionRowBuilder ? [button] : [_ButtonManager.row(button)];
+    return button instanceof import_discord17.ActionRowBuilder ? [button] : [_ButtonManager.row(button)];
   }
 };
 
@@ -16038,8 +16104,8 @@ var SimpleMutex = class {
    */
   async lock() {
     if (this._locked) {
-      return new Promise((resolve) => {
-        this.queue.push(resolve);
+      return new Promise((resolve2) => {
+        this.queue.push(resolve2);
       });
     }
     this._locked = true;
@@ -16066,7 +16132,7 @@ var SimpleMutex = class {
 // package.json
 var package_default = {
   name: "@spatulox/simplediscordbot",
-  version: "1.7.0",
+  version: "1.7.1",
   author: "Spatulox",
   description: "Simple discord bot framework to set up a bot under 30 secondes",
   exports: {