@spatulox/simplediscordbot 1.7.1 → 2.0.1

package/dist/index.mjs

@@ -5248,7 +5248,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.");
         }
@@ -5418,31 +5418,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
    */
@@ -5509,8 +5563,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");
     }
   }
   /**
@@ -5523,12 +5577,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;
 
@@ -5647,8 +5703,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) => {
@@ -14309,7 +14365,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())
         );
       }
     }
@@ -14472,88 +14528,104 @@ var FileManager = class {
 
 // src/manager/messages/WebhookManager.ts
 import {
-  ThreadChannel as ThreadChannel2
+  TextChannel as TextChannel3
 } from "discord.js";
+import { readFile } from "fs/promises";
+import { resolve } from "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 ThreadChannel2 ? 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 = resolve(process.cwd(), this.avatarPathOrUrl);
+      return await 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 TextChannel3)) {
+      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 ThreadChannel2) {
-      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;
@@ -14859,11 +14931,7 @@ var ReactionManager = class {
 };
 
 // src/manager/guild/GuildManager.ts
-import {
-  Guild as Guild3,
-  VoiceChannel as VoiceChannel2,
-  StageChannel as StageChannel2
-} from "discord.js";
+import { Guild as Guild2, StageChannel as StageChannel2, VoiceChannel as VoiceChannel2 } from "discord.js";
 
 // src/manager/direct/BasicUserManager.ts
 import { GuildMember as GuildMember2 } from "discord.js";
@@ -14938,22 +15006,9 @@ var BasicUserManager = class {
 };
 
 // src/manager/guild/GuildUserManager.ts
-import { Guild as Guild2 } from "discord.js";
 import { setTimeout as setTimeout2 } from "timers/promises";
 var MAX_NICKNAME_LENGTH = 32;
 var GuildUserManager = class extends BasicUserManager {
-  static async find(userId, guild) {
-    try {
-      if (guild instanceof Guild2) {
-        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);
@@ -15470,7 +15525,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 +15571,7 @@ var GuildManager = class {
    */
   static async fetchAllMembers(guildId, MAX_ATTEMPTS = 3, RETRY_DELAY = Time.minute.MIN_05.toMilliseconds()) {
     let guild;
-    if (guildId instanceof Guild3) {
+    if (guildId instanceof Guild2) {
       guild = guildId;
     } else {
       let tmp = Bot.client.guilds.cache.get(guildId);
@@ -16061,8 +16123,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;
@@ -16089,7 +16151,7 @@ var SimpleMutex = class {
 // package.json
 var package_default = {
   name: "@spatulox/simplediscordbot",
-  version: "1.7.0",
+  version: "2.0.0",
   author: "Spatulox",
   description: "Simple discord bot framework to set up a bot under 30 secondes",
   exports: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spatulox/simplediscordbot",
-  "version": "1.7.1",
+  "version": "2.0.1",
   "author": "Spatulox",
   "description": "Simple discord bot framework to set up a bot under 30 secondes",
   "exports": {