@spatulox/simplediscordbot 2.2.2 → 3.0.0

package/dist/index.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -33,21 +23,21 @@ __export(index_exports, {
   Bot: () => Bot,
   BotEnv: () => BotEnv,
   ButtonManager: () => ButtonManager,
-  CacheManager: () => CacheManager,
+  CacheManager: () => import_utils22.CacheManager,
   ComponentManager: () => ComponentManager,
   DiscordRegex: () => DiscordRegex,
   EmbedManager: () => EmbedManager,
-  FileManager: () => FileManager,
+  FileManager: () => import_utils21.FileManager,
   GuildManager: () => GuildManager,
-  Log: () => Log,
+  Log: () => import_utils24.Log,
   ModalFieldType: () => ModalFieldType,
   ModalManager: () => ModalManager,
   ReactionManager: () => ReactionManager,
   SelectMenuManager: () => SelectMenuManager,
   SimpleColor: () => SimpleColor,
   SimpleDiscordBotInfo: () => SimpleDiscordBotInfo,
-  SimpleMutex: () => SimpleMutex,
-  Time: () => Time,
+  SimpleMutex: () => import_utils25.SimpleMutex,
+  Time: () => import_utils23.Time,
   UserManager: () => UserManager,
   WebhookManager: () => WebhookManager
 });
@@ -55,297 +45,13 @@ module.exports = __toCommonJS(index_exports);
 
 // src/core/Bot.ts
 var import_discord6 = require("discord.js");
-
-// src/utils/UnitTime.ts
-var UnitTime = class {
-  constructor(val) {
-    this.val = val;
-  }
-  val;
-  toMilliseconds() {
-    return this.val;
-  }
-  toSeconds() {
-    return this.val / 1e3;
-  }
-  toMinutes() {
-    return this.val / (60 * 1e3);
-  }
-  toHours() {
-    return this.val / (60 * 60 * 1e3);
-  }
-  toDays() {
-    return this.val / (24 * 60 * 60 * 1e3);
-  }
-  toString() {
-    return this.val.toString();
-  }
-  valueOf() {
-    return this.val;
-  }
-  value() {
-    return this.val;
-  }
-};
-var Milliseconds = {
-  MS_100: new UnitTime(100),
-  MS_200: new UnitTime(200),
-  MS_500: new UnitTime(500),
-  MS_800: new UnitTime(800),
-  MS_1000: new UnitTime(1e3)
-};
-var Seconds = {
-  SEC_01: new UnitTime(1e3),
-  SEC_02: new UnitTime(2e3),
-  SEC_03: new UnitTime(3e3),
-  SEC_04: new UnitTime(4e3),
-  SEC_05: new UnitTime(5e3),
-  SEC_06: new UnitTime(6e3),
-  SEC_07: new UnitTime(7e3),
-  SEC_08: new UnitTime(8e3),
-  SEC_09: new UnitTime(9e3),
-  SEC_10: new UnitTime(1e4),
-  SEC_11: new UnitTime(11e3),
-  SEC_12: new UnitTime(12e3),
-  SEC_13: new UnitTime(13e3),
-  SEC_14: new UnitTime(14e3),
-  SEC_15: new UnitTime(15e3),
-  SEC_16: new UnitTime(16e3),
-  SEC_17: new UnitTime(17e3),
-  SEC_18: new UnitTime(18e3),
-  SEC_19: new UnitTime(19e3),
-  SEC_20: new UnitTime(2e4),
-  SEC_21: new UnitTime(21e3),
-  SEC_22: new UnitTime(22e3),
-  SEC_23: new UnitTime(23e3),
-  SEC_24: new UnitTime(24e3),
-  SEC_25: new UnitTime(25e3),
-  SEC_26: new UnitTime(26e3),
-  SEC_27: new UnitTime(27e3),
-  SEC_28: new UnitTime(28e3),
-  SEC_29: new UnitTime(29e3),
-  SEC_30: new UnitTime(3e4),
-  SEC_31: new UnitTime(31e3),
-  SEC_32: new UnitTime(32e3),
-  SEC_33: new UnitTime(33e3),
-  SEC_34: new UnitTime(34e3),
-  SEC_35: new UnitTime(35e3),
-  SEC_36: new UnitTime(36e3),
-  SEC_37: new UnitTime(37e3),
-  SEC_38: new UnitTime(38e3),
-  SEC_39: new UnitTime(39e3),
-  SEC_40: new UnitTime(4e4),
-  SEC_41: new UnitTime(41e3),
-  SEC_42: new UnitTime(42e3),
-  SEC_43: new UnitTime(43e3),
-  SEC_44: new UnitTime(44e3),
-  SEC_45: new UnitTime(45e3),
-  SEC_46: new UnitTime(46e3),
-  SEC_47: new UnitTime(47e3),
-  SEC_48: new UnitTime(48e3),
-  SEC_49: new UnitTime(49e3),
-  SEC_50: new UnitTime(5e4),
-  SEC_51: new UnitTime(51e3),
-  SEC_52: new UnitTime(52e3),
-  SEC_53: new UnitTime(53e3),
-  SEC_54: new UnitTime(54e3),
-  SEC_55: new UnitTime(55e3),
-  SEC_56: new UnitTime(56e3),
-  SEC_57: new UnitTime(57e3),
-  SEC_58: new UnitTime(58e3),
-  SEC_59: new UnitTime(59e3),
-  SEC_60: new UnitTime(6e4)
-};
-var Minutes = {
-  MIN_01: new UnitTime(6e4),
-  MIN_02: new UnitTime(12e4),
-  MIN_03: new UnitTime(18e4),
-  MIN_04: new UnitTime(24e4),
-  MIN_05: new UnitTime(3e5),
-  MIN_06: new UnitTime(36e4),
-  MIN_07: new UnitTime(42e4),
-  MIN_08: new UnitTime(48e4),
-  MIN_09: new UnitTime(54e4),
-  MIN_10: new UnitTime(6e5),
-  MIN_11: new UnitTime(66e4),
-  MIN_12: new UnitTime(72e4),
-  MIN_13: new UnitTime(78e4),
-  MIN_14: new UnitTime(84e4),
-  MIN_15: new UnitTime(9e5),
-  MIN_16: new UnitTime(96e4),
-  MIN_17: new UnitTime(102e4),
-  MIN_18: new UnitTime(108e4),
-  MIN_19: new UnitTime(114e4),
-  MIN_20: new UnitTime(12e5),
-  MIN_21: new UnitTime(126e4),
-  MIN_22: new UnitTime(132e4),
-  MIN_23: new UnitTime(138e4),
-  MIN_24: new UnitTime(144e4),
-  MIN_25: new UnitTime(15e5),
-  MIN_26: new UnitTime(156e4),
-  MIN_27: new UnitTime(162e4),
-  MIN_28: new UnitTime(168e4),
-  MIN_29: new UnitTime(174e4),
-  MIN_30: new UnitTime(18e5),
-  MIN_31: new UnitTime(186e4),
-  MIN_32: new UnitTime(192e4),
-  MIN_33: new UnitTime(198e4),
-  MIN_34: new UnitTime(204e4),
-  MIN_35: new UnitTime(21e5),
-  MIN_36: new UnitTime(216e4),
-  MIN_37: new UnitTime(222e4),
-  MIN_38: new UnitTime(228e4),
-  MIN_39: new UnitTime(234e4),
-  MIN_40: new UnitTime(24e5),
-  MIN_41: new UnitTime(246e4),
-  MIN_42: new UnitTime(252e4),
-  MIN_43: new UnitTime(258e4),
-  MIN_44: new UnitTime(264e4),
-  MIN_45: new UnitTime(27e5),
-  MIN_46: new UnitTime(276e4),
-  MIN_47: new UnitTime(282e4),
-  MIN_48: new UnitTime(288e4),
-  MIN_49: new UnitTime(294e4),
-  MIN_50: new UnitTime(3e6),
-  MIN_51: new UnitTime(306e4),
-  MIN_52: new UnitTime(312e4),
-  MIN_53: new UnitTime(318e4),
-  MIN_54: new UnitTime(324e4),
-  MIN_55: new UnitTime(33e5),
-  MIN_56: new UnitTime(336e4),
-  MIN_57: new UnitTime(342e4),
-  MIN_58: new UnitTime(348e4),
-  MIN_59: new UnitTime(354e4),
-  MIN_60: new UnitTime(36e5)
-};
-var Hours = {
-  HOUR_01: new UnitTime(36e5),
-  HOUR_02: new UnitTime(72e5),
-  HOUR_03: new UnitTime(108e5),
-  HOUR_04: new UnitTime(144e5),
-  HOUR_05: new UnitTime(18e6),
-  HOUR_06: new UnitTime(216e5),
-  HOUR_07: new UnitTime(252e5),
-  HOUR_08: new UnitTime(288e5),
-  HOUR_09: new UnitTime(324e5),
-  HOUR_10: new UnitTime(36e6),
-  HOUR_11: new UnitTime(396e5),
-  HOUR_12: new UnitTime(432e5),
-  HOUR_13: new UnitTime(468e5),
-  HOUR_14: new UnitTime(504e5),
-  HOUR_15: new UnitTime(54e6),
-  HOUR_16: new UnitTime(576e5),
-  HOUR_17: new UnitTime(612e5),
-  HOUR_18: new UnitTime(648e5),
-  HOUR_19: new UnitTime(684e5),
-  HOUR_20: new UnitTime(72e6),
-  HOUR_21: new UnitTime(756e5),
-  HOUR_22: new UnitTime(792e5),
-  HOUR_23: new UnitTime(828e5),
-  HOUR_24: new UnitTime(864e5)
-};
-var Days = {
-  DAY_01: new UnitTime(864e5),
-  DAY_02: new UnitTime(1728e5),
-  DAY_03: new UnitTime(2592e5),
-  DAY_04: new UnitTime(3456e5),
-  DAY_05: new UnitTime(432e6),
-  DAY_06: new UnitTime(5184e5),
-  DAY_07: new UnitTime(6048e5),
-  DAY_08: new UnitTime(6912e5),
-  DAY_09: new UnitTime(7776e5),
-  DAY_10: new UnitTime(864e6)
-};
-var Time = {
-  milisecond: Milliseconds,
-  second: Seconds,
-  minute: Minutes,
-  hour: Hours,
-  day: Days,
-  get DAY() {
-    const h = (/* @__PURE__ */ new Date()).getHours();
-    return h >= 7 && h < 23;
-  },
-  get NIGHT() {
-    return !this.DAY;
-  }
-};
-
-// src/utils/Log.ts
-var Log = class {
-  static getPrefix(level) {
-    const now = /* @__PURE__ */ new Date();
-    const timestamp = `[${now.toLocaleDateString()} - ${now.toLocaleTimeString()}]`;
-    return `${timestamp} [${level.toUpperCase()}]`;
-  }
-  static info(message) {
-    console.info(`${this.getPrefix("info")} ${message}`);
-  }
-  static warn(message) {
-    console.warn(`${this.getPrefix("warn")} ${message}`);
-  }
-  static error(message) {
-    console.error(`${this.getPrefix("error")} ${message}`);
-  }
-  static debug(message) {
-    console.debug(`${this.getPrefix("debug")} ${message}`);
-  }
-  static table(data) {
-    const prefix = this.getPrefix("table");
-    console.info(`${prefix} Table output:`);
-    console.table(data);
-  }
-};
-
-// src/utils/InternetChecker.ts
-var InternetChecker = class {
-  static TARGET = "https://one.one.one.one/";
-  // Cloudflare DNS HTTPS
-  static RETRY_TIME = Time.second.SEC_30;
-  /**
-   * Check internet connection towards 1.1.1.1 (Cloudflare DNS)
-   * @param tries Number of attempts (0 = infini)
-   */
-  static async checkConnection(tries = 0) {
-    let attempt = 0;
-    Log.info(
-      tries > 0 ? `HTTP ping ${this.TARGET} (max ${tries} attempts)...` : `HTTP ping ${this.TARGET} (infinite attempts)...`
-    );
-    while (tries === 0 || attempt < tries) {
-      try {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), 5e3);
-        const response = await fetch(this.TARGET, {
-          method: "HEAD",
-          signal: controller.signal,
-          cache: "no-store"
-        });
-        clearTimeout(timeoutId);
-        if (response.ok) {
-          const latency = response.headers.get("x-response-time") || "<1ms";
-          Log.info(`Internet connection OK (${latency})`);
-          return true;
-        }
-      } catch (error) {
-        attempt++;
-        const errorMsg = error.name === "AbortError" ? "Timeout (5s)" : error.message || "Unknown";
-        Log.warn(
-          tries > 0 ? `Ping failed (${errorMsg}) - Attempt ${attempt}/${tries}` : `Ping failed (${errorMsg}) - Retrying in ${this.RETRY_TIME.toSeconds()} seconds...`
-        );
-        try {
-          await new Promise((resolve2) => setTimeout(resolve2, this.RETRY_TIME.toMilliseconds()));
-        } catch {
-          Log.error("Retry delay failed.");
-        }
-      }
-    }
-    Log.error(`No response from ${this.TARGET} after all attempts.`);
-    return false;
-  }
-};
+var import_utils3 = require("@spatulox/utils");
+var import_utils4 = require("@spatulox/utils");
+var import_utils5 = require("@spatulox/utils");
 
 // src/core/BotLog.ts
 var import_discord2 = require("discord.js");
+var import_utils = require("@spatulox/utils");
 
 // src/manager/interactible/SelectMenuManager.ts
 var import_discord = require("discord.js");
@@ -499,7 +205,7 @@ var BotLog = class _BotLog {
    */
   static async initDiscordLogging() {
     if (!Bot.client.isReady()) {
-      Log.warn("Client not ready for Discord logging init");
+      import_utils.Log.warn("Client not ready for Discord logging init");
       return;
     }
     const logTypes = [
@@ -516,10 +222,10 @@ var BotLog = class _BotLog {
         if (channel?.isTextBased()) {
           _BotLog[prop] = channel;
         } else {
-          Log.warn(`${config.charAt(0).toUpperCase() + config.slice(1)} channel ${channelId} invalid`);
+          import_utils.Log.warn(`${config.charAt(0).toUpperCase() + config.slice(1)} channel ${channelId} invalid`);
         }
       } catch (error) {
-        Log.error(`${config.charAt(0).toUpperCase() + config.slice(1)} channel fetch failed: ${error}`);
+        import_utils.Log.error(`${config.charAt(0).toUpperCase() + config.slice(1)} channel fetch failed: ${error}`);
       }
     }
   }
@@ -591,7 +297,7 @@ var BotLog = class _BotLog {
       if (content instanceof import_discord2.EmbedBuilder) {
         const text = content.data.description ?? content.data.title;
         if (text) {
-          Log.info(text);
+          import_utils.Log.info(text);
         }
         msg = await channel.send({ embeds: [content] });
       } else if (SelectMenuManager.isSelectMenuList(content)) {
@@ -605,7 +311,7 @@ var BotLog = class _BotLog {
         msg = await channel.send(`[${timestamp}] [${prefix.toUpperCase()}] ${content}`);
       }
     } catch (error) {
-      Log.error(`Failed to send to Discord channel: ${error}`);
+      import_utils.Log.error(`Failed to send to Discord channel: ${error}`);
     }
     return msg;
   }
@@ -616,7 +322,7 @@ var BotLog = class _BotLog {
     const logConfig = Bot.config?.log;
     if (!logConfig || logConfig.info.console) {
       if (typeof content == "string") {
-        Log.info(content);
+        import_utils.Log.info(content);
       }
     }
     if (logConfig?.info.discord && this.logChannel) {
@@ -630,7 +336,7 @@ var BotLog = class _BotLog {
     const logConfig = Bot.config.log;
     if (!logConfig || logConfig.error.console) {
       if (typeof content == "string") {
-        Log.error(content);
+        import_utils.Log.error(content);
       }
     }
     if (logConfig?.error.discord && this.errorChannel) {
@@ -644,7 +350,7 @@ var BotLog = class _BotLog {
     const logConfig = Bot.config.log;
     if (!logConfig || logConfig?.warn.console) {
       if (typeof content == "string") {
-        Log.warn(content);
+        import_utils.Log.warn(content);
       }
     }
     if (logConfig?.warn.discord && this.warnChannel) {
@@ -659,7 +365,7 @@ var BotLog = class _BotLog {
     const logConfig = Bot.config.log;
     if (!logConfig || logConfig?.debug.console) {
       if (typeof content == "string") {
-        Log.debug(content);
+        import_utils.Log.debug(content);
       }
     }
     if (logConfig?.debug.discord && this.debugChannel) {
@@ -818,6 +524,7 @@ var EmbedManager = class {
 
 // src/core/BotMessage.ts
 var import_discord5 = require("discord.js");
+var import_utils2 = require("@spatulox/utils");
 
 // src/manager/builder/SendableComponentBuilder.ts
 var import_discord4 = require("discord.js");
@@ -883,13 +590,13 @@ var BotMessage = class {
   static async send(channel, content, component) {
     try {
       if (!channel) {
-        Log.warn("Cannot send message: Invalid channel ID");
+        import_utils2.Log.warn("Cannot send message: Invalid channel ID");
         return null;
       }
       if (typeof channel === "string") {
         const fetchedChannel = Bot.client.channels.cache.get(channel);
         if (!fetchedChannel?.isTextBased()) {
-          Log.warn(`Cannot send message : Invalid channel ID: ${channel}`);
+          import_utils2.Log.warn(`Cannot send message : Invalid channel ID: ${channel}`);
           return null;
         }
         channel = fetchedChannel;
@@ -919,14 +626,14 @@ var BotMessage = class {
         throw e;
       }
     } catch (e) {
-      Log.error(`Cannot send message : ${e}`);
+      import_utils2.Log.error(`Cannot send message : ${e}`);
       return null;
     }
   }
   static async sendDM(userOrId, content, component) {
     try {
       if (!userOrId) {
-        Log.warn("Cannot send DM: Invalid user / ID");
+        import_utils2.Log.warn("Cannot send DM: Invalid user / ID");
         return null;
       }
       let targetUser;
@@ -935,7 +642,7 @@ var BotMessage = class {
       } else {
         const fetchedUser = await Bot.client.users.fetch(userOrId);
         if (!fetchedUser) {
-          Log.warn(`Cannot send DM: User not found for ID: ${userOrId}`);
+          import_utils2.Log.warn(`Cannot send DM: User not found for ID: ${userOrId}`);
           return null;
         }
         targetUser = fetchedUser;
@@ -952,7 +659,7 @@ var BotMessage = class {
       }
       return await targetUser.send(messageCreate);
     } catch (error) {
-      Log.error(`Cannot send DM to ${userOrId}: ${error}`);
+      import_utils2.Log.error(`Cannot send DM to ${userOrId}: ${error}`);
       return null;
     }
   }
@@ -1056,7 +763,7 @@ var BotInteraction = class {
 // package.json
 var package_default = {
   name: "@spatulox/simplediscordbot",
-  version: "2.2.1",
+  version: "2.2.2",
   author: "Spatulox",
   description: "Simple discord bot framework to set up a bot under 30 secondes",
   exports: {
@@ -1078,7 +785,8 @@ var package_default = {
   },
   license: "MIT",
   dependencies: {
-    "@spatulox/discord-interaction-manager": "^2.0.6"
+    "@spatulox/discord-interaction-manager": "^2.0.6",
+    "@spatulox/utils": "^0.1.1"
   },
   peerDependencies: {
     "discord.js": "^14.26.0"
@@ -1138,16 +846,16 @@ var Bot = class _Bot {
     return _Bot._config;
   }
   constructor(client, config = {}) {
-    Log.info("----------------------------------------------------");
-    Log.info("Starting Bot");
+    import_utils4.Log.info("----------------------------------------------------");
+    import_utils4.Log.info("Starting Bot");
     _Bot.criticConfig = { dev: BotEnv.dev, token: BotEnv.token };
     _Bot._config = config;
     _Bot._client = client;
     (async () => {
-      Log.info(`Using discord.js version: ${import_discord6.version}`);
-      Log.info(`Using simplediscordbot version: ${SimpleDiscordBotInfo.version}`);
-      Log.info("Trying to connect to Discord Servers");
-      await InternetChecker.checkConnection(3);
+      import_utils4.Log.info(`Using discord.js version: ${import_discord6.version}`);
+      import_utils4.Log.info(`Using simplediscordbot version: ${SimpleDiscordBotInfo.version}`);
+      import_utils4.Log.info("Trying to connect to Discord Servers");
+      await import_utils5.InternetChecker.checkConnection(3);
       await this.login();
     })();
   }
@@ -1161,20 +869,20 @@ var Bot = class _Bot {
         _Bot._client.on(import_discord6.Events.ClientReady, async () => {
           if (_Bot._client.user) {
             await _Bot.log.initDiscordLogging();
-            Log.info(`Connected on ${_Bot._client.guilds.cache.size} servers as ${_Bot._client.user.tag}`);
+            import_utils4.Log.info(`Connected on ${_Bot._client.guilds.cache.size} servers as ${_Bot._client.user.tag}`);
             _Bot.log.info(EmbedManager.description("Bot Started"));
           }
         });
       } catch (error) {
-        Log.error(`Connection error : ${error}. Trying again...`);
+        import_utils4.Log.error(`Connection error : ${error}. Trying again...`);
         tries++;
         await new Promise(
-          (resolve2) => setTimeout(resolve2, Time.second.SEC_03.toMilliseconds())
+          (resolve2) => setTimeout(resolve2, import_utils3.Time.second.SEC_03.toMilliseconds())
         );
       }
     }
     if (!success) {
-      Log.error("Impossible to connect the bot after 3 attempts");
+      import_utils4.Log.error("Impossible to connect the bot after 3 attempts");
       return false;
     }
     return true;
@@ -1182,12 +890,12 @@ var Bot = class _Bot {
   static setActivity(message, type) {
     if (_Bot._client.user) {
       _Bot._client.user.setActivity({ name: message, type });
-      Log.info(`Activity defined : ${message}`);
+      import_utils4.Log.info(`Activity defined : ${message}`);
     }
   }
   static setRandomActivity(randomActivity, intervalMs = null) {
     if (randomActivity.length == 0) {
-      Log.error("Bot.randomActivity = [{}] is empty");
+      import_utils4.Log.error("Bot.randomActivity = [{}] is empty");
       return;
     }
     const pickRandom = () => {
@@ -1197,349 +905,32 @@ var Bot = class _Bot {
     };
     if (intervalMs === null) {
       pickRandom();
-      Log.info(`Activity set ONCE`);
+      import_utils4.Log.info(`Activity set ONCE`);
       return;
     }
     pickRandom();
     setInterval(async () => {
       pickRandom();
     }, intervalMs);
-    Log.info(`Random activity started (every ${Math.round(intervalMs / 6e4)}min)`);
+    import_utils4.Log.info(`Random activity started (every ${Math.round(intervalMs / 6e4)}min)`);
     return;
   }
 };
 
-// src/manager/FileManager.ts
-var import_path = __toESM(require("path"));
-var import_promises = __toESM(require("fs/promises"));
-var FileManager = class {
-  /**
-   * Check if a file exist
-   * @param filePath File path with file name
-   * @returns true si le fichier existe, false sinon
-   */
-  static async fileExists(filePath) {
-    try {
-      await import_promises.default.access(filePath);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Reads a JSON file synchronously.
-   * @param filePath Full path to the JSON file
-   * @returns Parsed JSON object or 'Error' string on failure
-   */
-  static async readJsonFile(filePath) {
-    try {
-      const data = await import_promises.default.readFile(filePath, "utf8");
-      return JSON.parse(data);
-    } catch (error) {
-      Log.error(`Failed to read JSON file ${filePath}: ${error}`);
-      return false;
-    }
-  }
-  /**
-   * Lists all directories in a given path.
-   * @param directoryPath Path to scan for directories
-   * @returns Array of directory names or false on error
-   */
-  static async listDirectories(directoryPath) {
-    try {
-      const files = await import_promises.default.readdir(directoryPath, { withFileTypes: true });
-      return files.filter((file) => file.isDirectory()).map((dir) => dir.name);
-    } catch (error) {
-      Log.error(`Failed to read directory ${directoryPath}: ${error}`);
-      return false;
-    }
-  }
-  /**
-   * Lists all JSON files in a directory.
-   * @param directoryPath Path to scan for JSON files
-   * @returns Array of JSON filenames or false on error
-   */
-  static async listJsonFiles(directoryPath) {
-    try {
-      const files = await import_promises.default.readdir(directoryPath);
-      return files.filter((file) => import_path.default.extname(file) === ".json");
-    } catch (error) {
-      Log.error(`Failed to read directory ${directoryPath}: ${error}`);
-      return false;
-    }
-  }
-  /**
-   * Lists files with specific extension in a directory.
-   * @param directoryPath Path to scan
-   * @param extension File extension (with or without dot)
-   * @returns Array of matching filenames or 'Error' string on failure
-   */
-  static async listFiles(directoryPath, extension) {
-    if (typeof directoryPath !== "string" || typeof extension !== "string") {
-      Log.error("Directory path and extension must be strings");
-      return false;
-    }
-    try {
-      let ext = extension;
-      if (ext.startsWith(".")) {
-        ext = ext.slice(1);
-      }
-      const files = await import_promises.default.readdir(directoryPath);
-      return files.filter((file) => import_path.default.extname(file) === `.${ext}`);
-    } catch (error) {
-      Log.error(`Failed to read directory ${directoryPath}: ${error}`);
-      return false;
-    }
-  }
-  /**
-   * Creates directory structure and writes JSON data to file.
-   * @param directoryPath Full directory path (creates if missing)
-   * @param filename Filename without extension
-   * @param data Data to write (JSON serializable)
-   * @param sendErrorToErrorChannel Send error to the error channel
-   * @returns true on success, false on failure
-   */
-  static async writeJsonFile(directoryPath, filename, data, sendErrorToErrorChannel = true) {
-    if (Array.isArray(data) && data.length === 1 && data[0] === "Error") {
-      Log.error(`Cannot save data for ${filename}: data contains 'Error'`);
-      return false;
-    }
-    try {
-      await import_promises.default.mkdir(directoryPath, { recursive: true });
-      if (!filename || filename.trim() === "") {
-        Log.error("Cannot write JSON file: empty filename");
-        return false;
-      }
-      const cleanFilename = filename.replace(/\.json$/i, "");
-      const filePath = import_path.default.join(directoryPath, `${cleanFilename}.json`);
-      const jsonContent = JSON.stringify(data, null, 2);
-      await import_promises.default.writeFile(filePath, jsonContent);
-      Log.info(`Successfully wrote data to ${filePath}`);
-      return true;
-    } catch (error) {
-      const cleanFilename = filename.replace(/\.json$/i, "") || "unknown";
-      if (sendErrorToErrorChannel) {
-        await Bot.log.info(EmbedManager.error(`Failed to write file ${directoryPath}/${cleanFilename}.json: ${error}`));
-      } else {
-        Log.error(`Failed to write file ${directoryPath}/${cleanFilename}.json: ${error}`);
-      }
-      return false;
-    }
-  }
-  /**
-   * Delete a file
-   * @param filePath Full file path
-   * @returns true si supprimé avec succès, false sinon
-   */
-  static async deleteFile(filePath) {
-    try {
-      if (!await this.fileExists(filePath)) {
-        Log.warn(`File does not exist: ${filePath}`);
-        return false;
-      }
-      await import_promises.default.unlink(filePath);
-      Log.info(`Successfully deleted file: ${filePath}`);
-      return true;
-    } catch (error) {
-      Log.error(`Failed to delete file ${filePath}: ${error}`);
-      return false;
-    }
-  }
-};
-
-// src/manager/CacheManager.ts
-var import_path2 = __toESM(require("path"));
-var CacheManager = class {
-  static get cacheDir() {
-    let folderPath = "simplediscordbot";
-    if (Bot.config?.botName) {
-      folderPath = this.cleanCacheId(Bot.config?.botName?.toLowerCase()).replace(" ", "_");
-    }
-    return import_path2.default.join(process.cwd(), `.${folderPath}cache`);
-  }
-  static cleanCacheId(key) {
-    return key.replace(/[^a-zA-Z0-9_-]/g, "_");
-  }
-  static createFilePath(filename) {
-    return import_path2.default.join(this.cacheDir, `${filename}.json`);
-  }
-  /**
-   * New file with cache_id as name
-   * @param cache_id - id which become the cache file name
-   * @param initialData - optional initial data
-   * @returns true if success, false otherwise
-   */
-  static async createCache(cache_id, initialData = {}) {
-    if (!cache_id || typeof cache_id !== "string" || cache_id.trim() === "") {
-      Bot.log.error('"Key" to create a cache must be a non-empty string');
-      return false;
-    }
-    const cleanCacheId = cache_id.replace(/[^a-zA-Z0-9_-]/g, "_");
-    Bot.log.info(`Creating cache file: ${cleanCacheId}.json`);
-    return await FileManager.writeJsonFile(
-      this.cacheDir,
-      this.cleanCacheId(cache_id),
-      initialData,
-      true
-    );
-  }
-  /**
-   * Read cache data or create empty one
-   * @param cache_id
-   * @param default_data default data with default key/value This will be send back if the cache doesn't exist and need to be created
-   * @returns true if success, false otherwise
-   */
-  static async getOrCreateCache(cache_id, default_data) {
-    if (!cache_id || typeof cache_id !== "string" || cache_id.trim() === "") {
-      Log.error('"cache_id" to get or create a cache must be a non-empty string');
-      return false;
-    }
-    const cleanCacheId = this.cleanCacheId(cache_id);
-    const filePath = this.createFilePath(cleanCacheId);
-    if (await FileManager.fileExists(filePath)) {
-      Log.info(`Cache already exists: ${cleanCacheId}.json`);
-      return FileManager.readJsonFile(filePath);
-    }
-    Log.info(`Creating new cache file: ${this.cacheDir}/${cleanCacheId}.json`);
-    const res = await FileManager.writeJsonFile(
-      this.cacheDir,
-      cleanCacheId,
-      default_data,
-      false
-    );
-    return res ? default_data : false;
-  }
-  /**
-   * Read cache data
-   * @param cache_id - cache_id to read
-   * @returns Json data, false otherwise
-   */
-  static async readCache(cache_id) {
-    if (!cache_id || typeof cache_id !== "string") {
-      Bot.log.error('"Key" must be a string');
-      return false;
-    }
-    const cleanCacheId = this.cleanCacheId(cache_id);
-    const filePath = this.createFilePath(cleanCacheId);
-    if (!await FileManager.fileExists(filePath)) {
-      Log.debug(`Cache not found: ${cleanCacheId}.json`);
-      return false;
-    }
-    return await FileManager.readJsonFile(filePath);
-  }
-  /**
-   * Overwrite cache data with the new data
-   * @param cache_id - ID of the cache
-   * @param data - new data
-   * @returns true if success, false otherwise
-   */
-  static async writeCache(cache_id, data) {
-    if (!cache_id || typeof cache_id !== "string") {
-      Log.error("Cache ID must be a string");
-      return false;
-    }
-    const cleanCacheId = this.cleanCacheId(cache_id);
-    Bot.log.info(`Writing to cache: ${cleanCacheId}.json`);
-    return await FileManager.writeJsonFile(
-      this.cacheDir,
-      cleanCacheId,
-      data,
-      true
-    );
-  }
-  /**
-   * Update specific property of the cache
-   * @param cache_id - ID of the cache
-   * @param property - property to update, with key and value
-   * @returns true if success, false otherwise
-   */
-  static async updateCacheProperty(cache_id, property) {
-    const cacheData = await this.readCache(cache_id);
-    if (cacheData === false) {
-      Log.error(`Cache ${cache_id} not found`);
-      return false;
-    }
-    cacheData[property.key] = property.value;
-    return await this.writeCache(cache_id, cacheData);
-  }
-  /**
-   * Reset an entire cache
-   * @param cache_id - cache ID to reset
-   * @returns true if success, false otherwise
-   */
-  static async resetCache(cache_id) {
-    try {
-      const cleanCacheId = cache_id.replace(/[^a-zA-Z0-9_-]/g, "_");
-      await this.writeCache(cache_id, {});
-      Log.info(`Reset cache: ${cleanCacheId}.json`);
-      return true;
-    } catch (error) {
-      Log.error(`Failed to reset cache ${cache_id}: ${error}`);
-      return false;
-    }
-  }
-  /**
-   * Delete an entire cache
-   * @param cache_id - cache ID to delete
-   * @returns true if success, false otherwise
-   */
-  static async deleteCache(cache_id) {
-    try {
-      const cleanCacheId = cache_id.replace(/[^a-zA-Z0-9_-]/g, "_");
-      const filePath = this.createFilePath(cleanCacheId);
-      if (await FileManager.deleteFile(filePath)) {
-        Log.info(`Deleted cache: ${cleanCacheId}.json`);
-        return true;
-      }
-      return false;
-    } catch (error) {
-      Log.error(`Failed to delete cache ${cache_id}: ${error}`);
-      return false;
-    }
-  }
-  /**
-   * List every existing cache
-   * @returns Array of cache_id, false otherwise
-   */
-  static async listCaches() {
-    return await FileManager.listJsonFiles(this.cacheDir);
-  }
-  /**
-   * Clean cache data
-   * @returns true if success, false otherwise
-   */
-  static async clearAllCaches() {
-    try {
-      const caches = await this.listCaches();
-      if (caches === false || caches.length === 0) {
-        return true;
-      }
-      let success = true;
-      for (const cache of caches) {
-        const result = await this.deleteCache(cache.replace(".json", ""));
-        if (!result) success = false;
-      }
-      return success;
-    } catch (error) {
-      Log.error(`Failed to clear caches: ${error}`);
-      return false;
-    }
-  }
-};
+// src/index.ts
+var import_utils21 = require("@spatulox/utils");
+var import_utils22 = require("@spatulox/utils");
 
 // src/manager/messages/WebhookManager.ts
 var import_discord7 = require("discord.js");
-var import_promises2 = require("fs/promises");
-var import_path3 = require("path");
+var import_promises = require("fs/promises");
+var import_path = require("path");
 var WebhookManager = class {
   constructor(client, name, avatarPathOrUrl) {
     this.client = client;
     this.name = name;
     this.avatarPathOrUrl = avatarPathOrUrl;
   }
-  client;
-  name;
-  avatarPathOrUrl;
   webhook = null;
   async getAvatar() {
     if (!this.avatarPathOrUrl) return null;
@@ -1547,8 +938,8 @@ var WebhookManager = class {
       return this.avatarPathOrUrl;
     }
     try {
-      const resolvedPath = (0, import_path3.resolve)(process.cwd(), this.avatarPathOrUrl);
-      return await (0, import_promises2.readFile)(resolvedPath);
+      const resolvedPath = (0, import_path.resolve)(process.cwd(), this.avatarPathOrUrl);
+      return await (0, import_promises.readFile)(resolvedPath);
     } catch (error) {
       Bot.log.warn(`Failed to load avatar from ${this.avatarPathOrUrl}: ${error}`);
       return null;
@@ -1655,10 +1046,17 @@ var WebhookManager = class {
   }
 };
 
+// src/manager/messages/ReactionManager.ts
+var import_utils9 = require("@spatulox/utils");
+
 // src/manager/guild/ChannelManager/GuildTextChannelManager.ts
 var import_discord8 = require("discord.js");
 
+// src/manager/guild/ChannelManager/GuildChannelManager.ts
+var import_utils7 = require("@spatulox/utils");
+
 // src/manager/guild/ChannelManager/GuildMessageManager.ts
+var import_utils6 = require("@spatulox/utils");
 var GuildMessageManager = class {
   /**
    * Impl
@@ -1667,7 +1065,7 @@ var GuildMessageManager = class {
     try {
       const channel = await GuildTextChannelManager.find(channelId);
       if (!channel) {
-        Log.error(`Channel ${channelId} not found in guild`);
+        import_utils6.Log.error(`Channel ${channelId} not found in guild`);
         return null;
       }
       let payload;
@@ -1680,7 +1078,7 @@ var GuildMessageManager = class {
       }
       return await channel.send(payload);
     } catch (error) {
-      Log.error(`Failed to send message to ${channelId}: ${error}`);
+      import_utils6.Log.error(`Failed to send message to ${channelId}: ${error}`);
       throw error;
     }
   }
@@ -1691,15 +1089,15 @@ var GuildMessageManager = class {
     try {
       const channel = await GuildTextChannelManager.find(channelId);
       if (!channel) {
-        Log.error(`Channel ${channelId} not found`);
+        import_utils6.Log.error(`Channel ${channelId} not found`);
         return false;
       }
       const message = await channel.messages.fetch(messageId);
       await message.delete();
-      Log.info(`Deleted message ${messageId} from ${channelId}`);
+      import_utils6.Log.info(`Deleted message ${messageId} from ${channelId}`);
       return true;
     } catch (error) {
-      Log.error(`Failed to delete message ${messageId} from ${channelId}: ${error}`);
+      import_utils6.Log.error(`Failed to delete message ${messageId} from ${channelId}: ${error}`);
       return false;
     }
   }
@@ -1710,14 +1108,14 @@ var GuildMessageManager = class {
     try {
       const channel = await GuildTextChannelManager.find(channelId);
       if (!channel) {
-        Log.error(`Channel ${channelId} not found`);
+        import_utils6.Log.error(`Channel ${channelId} not found`);
         return [];
       }
       const messages = await channel.messages.fetch({ limit });
-      Log.info(`Fetched ${messages.size} messages from ${channelId}`);
+      import_utils6.Log.info(`Fetched ${messages.size} messages from ${channelId}`);
       return Array.from(messages.values());
     } catch (error) {
-      Log.error(`Failed to fetch messages from ${channelId}: ${error}`);
+      import_utils6.Log.error(`Failed to fetch messages from ${channelId}: ${error}`);
       return [];
     }
   }
@@ -1728,13 +1126,13 @@ var GuildMessageManager = class {
     try {
       const channel = await GuildTextChannelManager.find(channelId);
       if (!channel) {
-        Log.error(`Channel ${channelId} not found`);
+        import_utils6.Log.error(`Channel ${channelId} not found`);
         return null;
       }
       const message = await channel.messages.fetch(messageId);
       return message;
     } catch (error) {
-      Log.error(`Failed to fetch message ${messageId} from ${channelId}: ${error}`);
+      import_utils6.Log.error(`Failed to fetch message ${messageId} from ${channelId}: ${error}`);
       return null;
     }
   }
@@ -1750,13 +1148,13 @@ var GuildChannelManager = class _GuildChannelManager {
     try {
       const guild = Bot.client.guilds.cache.get(guildId);
       if (!guild) {
-        Log.warn(`Guild ${guildId} not found`);
+        import_utils7.Log.warn(`Guild ${guildId} not found`);
         return null;
       }
       const channel = await guild.channels.fetch(channelId);
       return channel ?? null;
     } catch (error) {
-      Log.error(`Failed to find channel ${channelId} in guild ${guildId}: ${error}`);
+      import_utils7.Log.error(`Failed to find channel ${channelId} in guild ${guildId}: ${error}`);
       return null;
     }
   }
@@ -1766,10 +1164,10 @@ var GuildChannelManager = class _GuildChannelManager {
       if (cached && !cached.isDMBased()) return cached;
       const channel = await Bot.client.channels.fetch(channelId);
       if (channel && !channel.isDMBased()) return channel;
-      Log.warn(`Channel ${channelId} not found in any guild`);
+      import_utils7.Log.warn(`Channel ${channelId} not found in any guild`);
       return null;
     } catch (error) {
-      Log.error(`Failed to find channel ${channelId}: ${error}`);
+      import_utils7.Log.error(`Failed to find channel ${channelId}: ${error}`);
       return null;
     }
   }
@@ -1777,12 +1175,12 @@ var GuildChannelManager = class _GuildChannelManager {
     try {
       const guild = Bot.client.guilds.cache.get(guildId);
       if (!guild) {
-        Log.warn(`Guild ${guildId} not found`);
+        import_utils7.Log.warn(`Guild ${guildId} not found`);
         return [];
       }
       return Array.from(guild.channels.cache.values());
     } catch (error) {
-      Log.error(`Failed to find channel ${guildId}: ${error}`);
+      import_utils7.Log.error(`Failed to find channel ${guildId}: ${error}`);
       return [];
     }
   }
@@ -1793,14 +1191,14 @@ var GuildChannelManager = class _GuildChannelManager {
     try {
       const guild = Bot.client.guilds.cache.get(guildId);
       if (!guild) {
-        Log.warn(`Guild ${guildId} not found`);
+        import_utils7.Log.warn(`Guild ${guildId} not found`);
         return [];
       }
       return Array.from(guild.channels.cache.values()).filter(
         (channel) => channel.name.toLowerCase().includes(name.toLowerCase())
       );
     } catch (error) {
-      Log.error(`Failed to find channel ${guildId}: ${error}`);
+      import_utils7.Log.error(`Failed to find channel ${guildId}: ${error}`);
       return [];
     }
   }
@@ -1811,10 +1209,10 @@ var GuildChannelManager = class _GuildChannelManager {
         throw new Error(`Guild ${guildId} not found`);
       }
       const channel = await guild.channels.create(options);
-      Log.info(`Created channel ${channel.name} (${channel.id}) in guild ${guildId}`);
+      import_utils7.Log.info(`Created channel ${channel.name} (${channel.id}) in guild ${guildId}`);
       return channel;
     } catch (error) {
-      Log.error(`Failed to create channel in guild ${guildId}: ${error}`);
+      import_utils7.Log.error(`Failed to create channel in guild ${guildId}: ${error}`);
       throw error;
     }
   }
@@ -1825,16 +1223,17 @@ var GuildChannelManager = class _GuildChannelManager {
         throw new Error(`Channel ${channelId} not found`);
       }
       await channel.delete();
-      Log.info(`Deleted channel ${channelId}`);
+      import_utils7.Log.info(`Deleted channel ${channelId}`);
       return true;
     } catch (error) {
-      Log.error(`Failed to delete channel ${channelId}: ${error}`);
+      import_utils7.Log.error(`Failed to delete channel ${channelId}: ${error}`);
       throw error;
     }
   }
 };
 
 // src/manager/guild/ChannelManager/GuildTextChannelManager.ts
+var import_utils8 = require("@spatulox/utils");
 var GuildTextChannelManager = class extends GuildChannelManager {
   static async findInGuild(guildId, channelId) {
     const channel = await super.findInGuild(guildId, channelId);
@@ -1847,7 +1246,7 @@ var GuildTextChannelManager = class extends GuildChannelManager {
   static findAll(guildId) {
     const guild = Bot.client.guilds.cache.get(guildId);
     if (!guild) {
-      Log.warn(`Guild ${guildId} not found`);
+      import_utils8.Log.warn(`Guild ${guildId} not found`);
       return [];
     }
     return Array.from(guild.channels.cache.values()).filter((c) => c instanceof import_discord8.TextChannel);
@@ -1877,9 +1276,9 @@ var ReactionManager = class {
       }
       const message = await channel.messages.fetch(messageId);
       await message.react(emoji);
-      Log.info(`Added reaction ${emoji} to message ${messageId}`);
+      import_utils9.Log.info(`Added reaction ${emoji} to message ${messageId}`);
     } catch (error) {
-      Log.error(`Failed to add reaction to ${messageId}: ${error}`);
+      import_utils9.Log.error(`Failed to add reaction to ${messageId}: ${error}`);
       throw error;
     }
   }
@@ -1899,9 +1298,9 @@ var ReactionManager = class {
       }
       const user = await Bot.client.users.fetch(userId);
       await reaction.users.remove(user);
-      Log.info(`Removed reaction ${emoji} from user ${userId} on message ${messageId}`);
+      import_utils9.Log.info(`Removed reaction ${emoji} from user ${userId} on message ${messageId}`);
     } catch (error) {
-      Log.error(`Failed to remove reaction from ${messageId}: ${error}`);
+      import_utils9.Log.error(`Failed to remove reaction from ${messageId}: ${error}`);
       throw error;
     }
   }
@@ -1925,10 +1324,10 @@ var ReactionManager = class {
           users: Array.from(users.values())
         });
       }
-      Log.info(`Fetched ${reactionList.length} reactions for message ${messageId}`);
+      import_utils9.Log.info(`Fetched ${reactionList.length} reactions for message ${messageId}`);
       return reactionList;
     } catch (error) {
-      Log.error(`Failed to fetch reactions for ${messageId}: ${error}`);
+      import_utils9.Log.error(`Failed to fetch reactions for ${messageId}: ${error}`);
       throw error;
     }
   }
@@ -1943,9 +1342,9 @@ var ReactionManager = class {
       }
       const message = await channel.messages.fetch(messageId);
       await message.reactions.removeAll();
-      Log.info(`Cleared all reactions from message ${messageId}`);
+      import_utils9.Log.info(`Cleared all reactions from message ${messageId}`);
     } catch (error) {
-      Log.error(`Failed to clear reactions from ${messageId}: ${error}`);
+      import_utils9.Log.error(`Failed to clear reactions from ${messageId}: ${error}`);
       throw error;
     }
   }
@@ -1953,9 +1352,15 @@ var ReactionManager = class {
 
 // src/manager/guild/GuildManager.ts
 var import_discord14 = require("discord.js");
+var import_utils18 = require("@spatulox/utils");
+var import_utils19 = require("@spatulox/utils");
+
+// src/manager/guild/GuildUserManager.ts
+var import_utils11 = require("@spatulox/utils");
 
 // src/manager/direct/BasicUserManager.ts
 var import_discord9 = require("discord.js");
+var import_utils10 = require("@spatulox/utils");
 var BasicUserManager = class {
   /**
    * Find member in specific guild
@@ -1971,7 +1376,7 @@ var BasicUserManager = class {
     const cached = targetGuild.members.cache.get(memberId);
     if (cached) return cached;
     const member = await targetGuild.members.fetch(memberId).catch(() => null);
-    if (!member) Log.error(`UserManager: Member ${memberId} not found in guild ${targetGuild.id}`);
+    if (!member) import_utils10.Log.error(`UserManager: Member ${memberId} not found in guild ${targetGuild.id}`);
     return member;
   }
   /**
@@ -2014,20 +1419,20 @@ var BasicUserManager = class {
       }
       const message = await dmChannel.send(payload);
       if (user instanceof import_discord9.GuildMember) {
-        Log.info(`Sent DM to ${user.id} (${user.user.username}): "${(payload.content || "Embed/Component").substring(0, 50)}..."`);
+        import_utils10.Log.info(`Sent DM to ${user.id} (${user.user.username}): "${(payload.content || "Embed/Component").substring(0, 50)}..."`);
       } else {
-        Log.info(`Sent DM to ${user.id} (${user.username}): "${(payload.content || "Embed/Component").substring(0, 50)}..."`);
+        import_utils10.Log.info(`Sent DM to ${user.id} (${user.username}): "${(payload.content || "Embed/Component").substring(0, 50)}..."`);
       }
       return message;
     } catch (error) {
-      Log.error(`Failed to send DM to ${user_id_or_user}: ${error}`);
+      import_utils10.Log.error(`Failed to send DM to ${user_id_or_user}: ${error}`);
       throw new Error(`Cannot send DM to ${user_id_or_user}`);
     }
   }
 };
 
 // src/manager/guild/GuildUserManager.ts
-var import_promises3 = require("timers/promises");
+var import_promises2 = require("timers/promises");
 var MAX_NICKNAME_LENGTH = 32;
 var GuildUserManager = class extends BasicUserManager {
   static async rename(member, nickname, maxAttempts = 3) {
@@ -2038,12 +1443,12 @@ var GuildUserManager = class extends BasicUserManager {
       try {
         const oldName = member.displayName;
         await member.setNickname(nickname.trim());
-        Log.info(`Renaming user: ${oldName} \u2192 ${nickname.trim()}`);
-        await (0, import_promises3.setTimeout)(1500);
+        import_utils11.Log.info(`Renaming user: ${oldName} \u2192 ${nickname.trim()}`);
+        await (0, import_promises2.setTimeout)(1500);
         return true;
       } catch (error) {
         console.error(`Attempt ${attempts + 1} failed when renaming ${member.displayName} into ${nickname.trim()}:`, error);
-        await (0, import_promises3.setTimeout)(1e3);
+        await (0, import_promises2.setTimeout)(1e3);
       }
     }
     Bot.log.info(EmbedManager.error(`Failed to rename ${member.displayName} to ${nickname.trim()} after ${maxAttempts} attempts.`));
@@ -2056,13 +1461,13 @@ var GuildUserManager = class extends BasicUserManager {
     try {
       const guild = await GuildManager.find(guildId);
       if (!guild) {
-        Log.warn(`Guild ${guildId} not found`);
+        import_utils11.Log.warn(`Guild ${guildId} not found`);
         return false;
       }
       const ban = await guild.bans.fetch(userId);
       return !!ban;
     } catch (error) {
-      Log.debug(`User ${userId} is not banned from guild ${guildId}`);
+      import_utils11.Log.debug(`User ${userId} is not banned from guild ${guildId}`);
       return false;
     }
   }
@@ -2076,9 +1481,9 @@ var GuildUserManager = class extends BasicUserManager {
         throw new Error(`Member ${memberId} not found or not in a voice channel`);
       }
       await member.voice.disconnect();
-      Log.info(`Disconnected member ${memberId} from voice in guild ${guildId}`);
+      import_utils11.Log.info(`Disconnected member ${memberId} from voice in guild ${guildId}`);
     } catch (error) {
-      Log.error(`Failed to disconnect member ${memberId} from voice in ${guildId}: ${error}`);
+      import_utils11.Log.error(`Failed to disconnect member ${memberId} from voice in ${guildId}: ${error}`);
       throw error;
     }
   }
@@ -2093,7 +1498,7 @@ var GuildUserManager = class extends BasicUserManager {
       }
       return member.voice.channelId !== null;
     } catch (error) {
-      Log.debug(`Member ${memberId} not found or not in voice in guild ${guildId}`);
+      import_utils11.Log.debug(`Member ${memberId} not found or not in voice in guild ${guildId}`);
       return false;
     }
   }
@@ -2107,9 +1512,9 @@ var GuildUserManager = class extends BasicUserManager {
         throw new Error(`User ${guildId} not found`);
       }
       await member.voice.setMute(true, reason);
-      Log.info(`Server muted ${memberId} in guild ${guildId}: ${reason || "No reason"}`);
+      import_utils11.Log.info(`Server muted ${memberId} in guild ${guildId}: ${reason || "No reason"}`);
     } catch (error) {
-      Log.error(`Failed to server mute ${memberId} in ${guildId}:, error`);
+      import_utils11.Log.error(`Failed to server mute ${memberId} in ${guildId}:, error`);
       throw error;
     }
   }
@@ -2123,9 +1528,9 @@ var GuildUserManager = class extends BasicUserManager {
         throw new Error(`User ${guildId} not found`);
       }
       await member.voice.setMute(false, reason);
-      Log.info(`Server unmuted ${memberId} in guild ${guildId}: ${reason || "No reason"}`);
+      import_utils11.Log.info(`Server unmuted ${memberId} in guild ${guildId}: ${reason || "No reason"}`);
     } catch (error) {
-      Log.error(`Failed to server unmute ${memberId} in ${guildId}: ${error}`);
+      import_utils11.Log.error(`Failed to server unmute ${memberId} in ${guildId}: ${error}`);
       throw error;
     }
   }
@@ -2139,9 +1544,9 @@ var GuildUserManager = class extends BasicUserManager {
         throw new Error(`User ${guildId} not found`);
       }
       await member.voice.setDeaf(true, reason);
-      Log.info(`Server deafened ${memberId} in guild ${guildId}: ${reason || "No reason"}`);
+      import_utils11.Log.info(`Server deafened ${memberId} in guild ${guildId}: ${reason || "No reason"}`);
     } catch (error) {
-      Log.error(`Failed to server deafen ${memberId} in ${guildId}: ${error}`);
+      import_utils11.Log.error(`Failed to server deafen ${memberId} in ${guildId}: ${error}`);
       throw error;
     }
   }
@@ -2155,9 +1560,9 @@ var GuildUserManager = class extends BasicUserManager {
         throw new Error(`User ${guildId} not found`);
       }
       await member.voice.setDeaf(false, reason);
-      Log.info(`Server undeafened ${memberId} in guild ${guildId}: ${reason || "No reason"}`);
+      import_utils11.Log.info(`Server undeafened ${memberId} in guild ${guildId}: ${reason || "No reason"}`);
     } catch (error) {
-      Log.error(`Failed to server undeafen ${memberId} in ${guildId}: ${error}`);
+      import_utils11.Log.error(`Failed to server undeafen ${memberId} in ${guildId}: ${error}`);
       throw error;
     }
   }
@@ -2172,9 +1577,9 @@ var GuildUserManager = class extends BasicUserManager {
       }
       const expires = Date.now() + duration;
       await member.timeout(expires, reason);
-      Log.info(`Timed out ${memberId} for ${duration}ms in guild ${guildId}: ${reason || "No reason"}`);
+      import_utils11.Log.info(`Timed out ${memberId} for ${duration}ms in guild ${guildId}: ${reason || "No reason"}`);
     } catch (error) {
-      Log.error(`Failed to timeout ${memberId} in ${guildId}: ${error}`);
+      import_utils11.Log.error(`Failed to timeout ${memberId} in ${guildId}: ${error}`);
       throw error;
     }
   }
@@ -2188,9 +1593,9 @@ var GuildUserManager = class extends BasicUserManager {
         throw new Error(`User ${guildId} not found`);
       }
       await member.timeout(null, reason);
-      Log.info(`Untimed out ${memberId} in guild ${guildId}: ${reason || "No reason"}`);
+      import_utils11.Log.info(`Untimed out ${memberId} in guild ${guildId}: ${reason || "No reason"}`);
     } catch (error) {
-      Log.error(`Failed to untimeout ${memberId} in ${guildId}: ${error}`);
+      import_utils11.Log.error(`Failed to untimeout ${memberId} in ${guildId}: ${error}`);
       throw error;
     }
   }
@@ -2204,9 +1609,9 @@ var GuildUserManager = class extends BasicUserManager {
         throw new Error(`User ${guildId} not found`);
       }
       await member.kick(reason);
-      Log.info(`Kicked ${memberId} from guild ${guildId}: ${reason || "No reason"}`);
+      import_utils11.Log.info(`Kicked ${memberId} from guild ${guildId}: ${reason || "No reason"}`);
     } catch (error) {
-      Log.error(`Failed to kick ${memberId} from ${guildId}: ${error}`);
+      import_utils11.Log.error(`Failed to kick ${memberId} from ${guildId}: ${error}`);
       throw error;
     }
   }
@@ -2217,9 +1622,9 @@ var GuildUserManager = class extends BasicUserManager {
     }
     try {
       await guild.members.ban(userId, banOption);
-      Log.info(`Banned user ${userId} from guild ${guildId}`);
+      import_utils11.Log.info(`Banned user ${userId} from guild ${guildId}`);
     } catch (error) {
-      Log.error(`Failed to ban user ${userId} from guild ${guildId}: ${error}`);
+      import_utils11.Log.error(`Failed to ban user ${userId} from guild ${guildId}: ${error}`);
       throw error;
     }
   }
@@ -2230,15 +1635,16 @@ var GuildUserManager = class extends BasicUserManager {
     }
     try {
       await guild.members.unban(userId, reason);
-      Log.info(`Unbanned user ${userId} from guild ${guildId}`);
+      import_utils11.Log.info(`Unbanned user ${userId} from guild ${guildId}`);
     } catch (error) {
-      Log.error(`Failed to unban user ${userId} from guild ${guildId}: ${error}`);
+      import_utils11.Log.error(`Failed to unban user ${userId} from guild ${guildId}: ${error}`);
       throw error;
     }
   }
 };
 
 // src/manager/guild/RoleManager.ts
+var import_utils12 = require("@spatulox/utils");
 var RoleManager = class {
   /**
    * Add role - CACHE ONLY
@@ -2249,14 +1655,14 @@ var RoleManager = class {
     try {
       const role = member.guild.roles.cache.get(roleId);
       if (!role) {
-        Log.warn(`Role ${roleId} not found in cache`);
+        import_utils12.Log.warn(`Role ${roleId} not found in cache`);
         return false;
       }
       await member.roles.add(role);
-      Log.info(`\u2705 Added ${role.name} to ${member.displayName}`);
+      import_utils12.Log.info(`\u2705 Added ${role.name} to ${member.displayName}`);
       return true;
     } catch (error) {
-      Log.error(`Failed to add role ${roleId}: ${error}`);
+      import_utils12.Log.error(`Failed to add role ${roleId}: ${error}`);
       return false;
     }
   }
@@ -2276,14 +1682,14 @@ var RoleManager = class {
         );
       }
       if (!role) {
-        Log.warn(`Role ${roleIdOrName} not found for ${member.displayName}`);
+        import_utils12.Log.warn(`Role ${roleIdOrName} not found for ${member.displayName}`);
         return false;
       }
       await member.roles.remove(role);
-      Log.info(`\u2705 Removed ${role.name} from ${member.displayName}`);
+      import_utils12.Log.info(`\u2705 Removed ${role.name} from ${member.displayName}`);
       return true;
     } catch (error) {
-      Log.error(`Failed to remove role ${roleIdOrName}: ${error}`);
+      import_utils12.Log.error(`Failed to remove role ${roleIdOrName}: ${error}`);
       return false;
     }
   }
@@ -2293,7 +1699,7 @@ var RoleManager = class {
   static async toggle(member, roleIdOrName) {
     const role = member.roles.cache.get(roleIdOrName) || member.roles.cache.find((r) => r.name.toLowerCase() === roleIdOrName.toString().toLowerCase());
     if (!role) {
-      Log.warn(`Role ${roleIdOrName} not found`);
+      import_utils12.Log.warn(`Role ${roleIdOrName} not found`);
       throw new Error(`Role not found`);
     }
     if (member.roles.cache.has(role.id)) {
@@ -2319,6 +1725,7 @@ var RoleManager = class {
 
 // src/manager/guild/ChannelManager/ForumChannelManager.ts
 var import_discord10 = require("discord.js");
+var import_utils13 = require("@spatulox/utils");
 var ForumChannelManager = class extends GuildChannelManager {
   static async findInGuild(guildId, channelId) {
     const channel = await super.findInGuild(guildId, channelId);
@@ -2331,7 +1738,7 @@ var ForumChannelManager = class extends GuildChannelManager {
   static findAll(guildId) {
     const guild = Bot.client.guilds.cache.get(guildId);
     if (!guild) {
-      Log.warn(`Guild ${guildId} not found`);
+      import_utils13.Log.warn(`Guild ${guildId} not found`);
       return [];
     }
     return Array.from(guild.channels.cache.values()).filter((c) => c instanceof import_discord10.ForumChannel);
@@ -2347,6 +1754,7 @@ var ForumChannelManager = class extends GuildChannelManager {
 
 // src/manager/guild/ChannelManager/NewsChannelManager.ts
 var import_discord11 = require("discord.js");
+var import_utils14 = require("@spatulox/utils");
 var NewsChannelManager = class extends GuildChannelManager {
   static async findInGuild(guildId, channelId) {
     const channel = await super.findInGuild(guildId, channelId);
@@ -2359,7 +1767,7 @@ var NewsChannelManager = class extends GuildChannelManager {
   static findAll(guildId) {
     const guild = Bot.client.guilds.cache.get(guildId);
     if (!guild) {
-      Log.warn(`Guild ${guildId} not found`);
+      import_utils14.Log.warn(`Guild ${guildId} not found`);
       return [];
     }
     return Array.from(guild.channels.cache.values()).filter((c) => c instanceof import_discord11.NewsChannel);
@@ -2375,6 +1783,7 @@ var NewsChannelManager = class extends GuildChannelManager {
 
 // src/manager/guild/ChannelManager/StageChannelManager.ts
 var import_discord12 = require("discord.js");
+var import_utils15 = require("@spatulox/utils");
 var StageChannelManager = class extends GuildChannelManager {
   static async findInGuild(guildId, channelId) {
     const channel = await super.findInGuild(guildId, channelId);
@@ -2387,7 +1796,7 @@ var StageChannelManager = class extends GuildChannelManager {
   static findAll(guildId) {
     const guild = Bot.client.guilds.cache.get(guildId);
     if (!guild) {
-      Log.warn(`Guild ${guildId} not found`);
+      import_utils15.Log.warn(`Guild ${guildId} not found`);
       return [];
     }
     return Array.from(guild.channels.cache.values()).filter((c) => c instanceof import_discord12.StageChannel);
@@ -2444,6 +1853,7 @@ var ThreadChannelManager = class {
 
 // src/manager/guild/ChannelManager/GuildVoiceChannelManager.ts
 var import_discord13 = require("discord.js");
+var import_utils16 = require("@spatulox/utils");
 var GuildVoiceChannelManager = class extends GuildChannelManager {
   static async findInGuild(guildId, channelId) {
     const channel = await super.findInGuild(guildId, channelId);
@@ -2456,7 +1866,7 @@ var GuildVoiceChannelManager = class extends GuildChannelManager {
   static findAll(guildId) {
     const guild = Bot.client.guilds.cache.get(guildId);
     if (!guild) {
-      Log.warn(`Guild ${guildId} not found`);
+      import_utils16.Log.warn(`Guild ${guildId} not found`);
       return [];
     }
     return Array.from(guild.channels.cache.values()).filter((c) => c instanceof import_discord13.VoiceChannel);
@@ -2482,6 +1892,7 @@ var GuildChannelList = class {
 };
 
 // src/manager/guild/InviteManager.ts
+var import_utils17 = require("@spatulox/utils");
 var InviteManager = class {
   /**
    * Create an invite for a channel
@@ -2500,10 +1911,10 @@ var InviteManager = class {
         reason: options.reason
       };
       const invite = await guild.invites.create(channelId, inviteOptions);
-      Log.info(`Created invite ${invite.code} for channel ${channelId}`);
+      import_utils17.Log.info(`Created invite ${invite.code} for channel ${channelId}`);
       return invite;
     } catch (error) {
-      Log.error(`Failed to create invite for channel ${channelId}: ${error}`);
+      import_utils17.Log.error(`Failed to create invite for channel ${channelId}: ${error}`);
       throw error;
     }
   }
@@ -2513,10 +1924,10 @@ var InviteManager = class {
   static async delete(invite) {
     try {
       await invite.delete();
-      Log.info(`Deleted invite ${invite.code} from guild ${invite.guild?.id}`);
+      import_utils17.Log.info(`Deleted invite ${invite.code} from guild ${invite.guild?.id}`);
       return true;
     } catch (error) {
-      Log.error(`Failed to delete invite ${invite.code}: ${error}`);
+      import_utils17.Log.error(`Failed to delete invite ${invite.code}: ${error}`);
       return false;
     }
   }
@@ -2531,10 +1942,10 @@ var InviteManager = class {
       }
       const invites = await guild.invites.fetch();
       const inviteList = Array.from(invites.values());
-      Log.info(`Fetched ${inviteList.length} invites for guild ${guildId}`);
+      import_utils17.Log.info(`Fetched ${inviteList.length} invites for guild ${guildId}`);
       return inviteList;
     } catch (error) {
-      Log.error(`Failed to fetch invites for guild ${guildId}: ${error}`);
+      import_utils17.Log.error(`Failed to fetch invites for guild ${guildId}: ${error}`);
       throw error;
     }
   }
@@ -2555,7 +1966,7 @@ var GuildManager = class {
       if (cached) return cached;
       return await Bot.client.guilds.fetch(guild_id);
     } catch (error) {
-      Log.error(`GuildManager: Guild ${guild_id} : ${error} `);
+      import_utils18.Log.error(`GuildManager: Guild ${guild_id} : ${error} `);
       return null;
     }
   }
@@ -2566,7 +1977,7 @@ var GuildManager = class {
     try {
       return await GuildChannelManager.findInGuild(guildId, channelId);
     } catch (error) {
-      Log.error(`Failed to fetch channel ${channelId}: ${error}`);
+      import_utils18.Log.error(`Failed to fetch channel ${channelId}: ${error}`);
       return null;
     }
   }
@@ -2577,7 +1988,7 @@ var GuildManager = class {
     try {
       return await this.user.findInGuild(guildId, guildId);
     } catch (error) {
-      Log.error(`Failed to fetch member ${memberId} in guild ${guildId}: ${error}`);
+      import_utils18.Log.error(`Failed to fetch member ${memberId} in guild ${guildId}: ${error}`);
       return null;
     }
   }
@@ -2594,7 +2005,7 @@ var GuildManager = class {
   /**
    * Fetch all members with retry (heavy operation)
    */
-  static async fetchAllMembers(guildId, MAX_ATTEMPTS = 3, RETRY_DELAY = Time.minute.MIN_05.toMilliseconds()) {
+  static async fetchAllMembers(guildId, MAX_ATTEMPTS = 3, RETRY_DELAY = import_utils19.Time.minute.MIN_05.toMilliseconds()) {
     let guild;
     if (guildId instanceof import_discord14.Guild) {
       guild = guildId;
@@ -2605,10 +2016,10 @@ var GuildManager = class {
     }
     for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
       try {
-        Log.info(`UserManager: Fetching ${guild.name} members (attempt ${attempt})`);
+        import_utils18.Log.info(`UserManager: Fetching ${guild.name} members (attempt ${attempt})`);
         return await guild.members.fetch();
       } catch (error) {
-        Log.error(`UserManager: Fetch failed (attempt ${attempt}): ${error}`);
+        import_utils18.Log.error(`UserManager: Fetch failed (attempt ${attempt}): ${error}`);
         if (attempt < MAX_ATTEMPTS) {
           await new Promise((r) => setTimeout(r, RETRY_DELAY));
         }
@@ -2625,7 +2036,7 @@ var GuildManager = class {
       const bans = await guild.bans.fetch({ limit });
       return Array.from(bans.values());
     } catch (error) {
-      Log.error(`Failed to list bans in guild ${guildId}: ${error}`);
+      import_utils18.Log.error(`Failed to list bans in guild ${guildId}: ${error}`);
       throw error;
     }
   }
@@ -2660,26 +2071,27 @@ var GuildManager = class {
       }
       try {
         await member.voice.setChannel(toChannel);
-        Log.info(`Moved member ${memberId} from ${fromChannelId} to ${toChannelId}`);
+        import_utils18.Log.info(`Moved member ${memberId} from ${fromChannelId} to ${toChannelId}`);
       } catch (error) {
-        Log.error(`Failed to move member ${memberId} from ${fromChannelId} to ${toChannelId}: ${error}`);
+        import_utils18.Log.error(`Failed to move member ${memberId} from ${fromChannelId} to ${toChannelId}: ${error}`);
         throw error;
       }
       return true;
     } catch (e) {
-      Log.error(`Failed to move member ${e}`);
+      import_utils18.Log.error(`Failed to move member ${e}`);
       return false;
     }
   }
 };
 
 // src/manager/direct/UserManager.ts
+var import_utils20 = require("@spatulox/utils");
 var UserManager = class extends BasicUserManager {
   static async find(userId) {
     const cached = Bot.client.users.cache.get(userId);
     if (cached) return cached;
     const user = await Bot.client.users.fetch(userId).catch(() => null);
-    if (!user) Log.error(`UserManager: User ${userId} not found`);
+    if (!user) import_utils20.Log.error(`UserManager: User ${userId} not found`);
     return user;
   }
 };
@@ -3116,46 +2528,10 @@ var ButtonManager = class _ButtonManager {
   }
 };
 
-// src/utils/SimpleMutex.ts
-var SimpleMutex = class {
-  _locked;
-  // Indique si le mutex est verrouillé
-  queue;
-  // File d'attente des fonctions de résolution
-  constructor() {
-    this._locked = false;
-    this.queue = [];
-  }
-  /**
-   * Verrouille le mutex. Si le mutex est déjà verrouillé, la méthode retourne une promesse qui sera résolue une fois que le mutex sera disponible.
-   * @returns Une promesse résolue lorsque le mutex est verrouillé.
-   */
-  async lock() {
-    if (this._locked) {
-      return new Promise((resolve2) => {
-        this.queue.push(resolve2);
-      });
-    }
-    this._locked = true;
-    return Promise.resolve();
-  }
-  /**
-   * Déverrouille le mutex. Si une file d'attente existe, débloque le prochain élément dans la file.
-   */
-  unlock() {
-    if (this.queue.length > 0) {
-      const nextResolve = this.queue.shift();
-      if (nextResolve) {
-        nextResolve();
-      }
-      return;
-    }
-    this._locked = false;
-  }
-  get locked() {
-    return this._locked;
-  }
-};
+// src/index.ts
+var import_utils23 = require("@spatulox/utils");
+var import_utils24 = require("@spatulox/utils");
+var import_utils25 = require("@spatulox/utils");
 
 // src/constants/DiscordRegex.ts
 var DiscordRegex = class {