@spatulox/simplediscordbot 2.2.1 → 3.0.0

package/dist/index.mjs

@@ -1,293 +1,8 @@
 // src/core/Bot.ts
 import { Events, version } from "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;
-  }
-};
+import { Time } from "@spatulox/utils";
+import { Log as Log3 } from "@spatulox/utils";
+import { InternetChecker } from "@spatulox/utils";
 
 // src/core/BotLog.ts
 import {
@@ -296,6 +11,7 @@ import {
   ContainerBuilder,
   MessageFlags as MessageFlags2
 } from "discord.js";
+import { Log } from "@spatulox/utils";
 
 // src/manager/interactible/SelectMenuManager.ts
 import {
@@ -783,6 +499,7 @@ import {
   User,
   GuildMember
 } from "discord.js";
+import { Log as Log2 } from "@spatulox/utils";
 
 // src/manager/builder/SendableComponentBuilder.ts
 import {
@@ -853,13 +570,13 @@ var BotMessage = class {
   static async send(channel, content, component) {
     try {
       if (!channel) {
-        Log.warn("Cannot send message: Invalid channel ID");
+        Log2.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}`);
+          Log2.warn(`Cannot send message : Invalid channel ID: ${channel}`);
           return null;
         }
         channel = fetchedChannel;
@@ -889,14 +606,14 @@ var BotMessage = class {
         throw e;
       }
     } catch (e) {
-      Log.error(`Cannot send message : ${e}`);
+      Log2.error(`Cannot send message : ${e}`);
       return null;
     }
   }
   static async sendDM(userOrId, content, component) {
     try {
       if (!userOrId) {
-        Log.warn("Cannot send DM: Invalid user / ID");
+        Log2.warn("Cannot send DM: Invalid user / ID");
         return null;
       }
       let targetUser;
@@ -905,7 +622,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}`);
+          Log2.warn(`Cannot send DM: User not found for ID: ${userOrId}`);
           return null;
         }
         targetUser = fetchedUser;
@@ -922,7 +639,7 @@ var BotMessage = class {
       }
       return await targetUser.send(messageCreate);
     } catch (error) {
-      Log.error(`Cannot send DM to ${userOrId}: ${error}`);
+      Log2.error(`Cannot send DM to ${userOrId}: ${error}`);
       return null;
     }
   }
@@ -1026,7 +743,7 @@ var BotInteraction = class {
 // package.json
 var package_default = {
   name: "@spatulox/simplediscordbot",
-  version: "2.2.0",
+  version: "2.2.2",
   author: "Spatulox",
   description: "Simple discord bot framework to set up a bot under 30 secondes",
   exports: {
@@ -1048,7 +765,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"
@@ -1108,15 +826,15 @@ var Bot = class _Bot {
     return _Bot._config;
   }
   constructor(client, config = {}) {
-    Log.info("----------------------------------------------------");
-    Log.info("Starting Bot");
+    Log3.info("----------------------------------------------------");
+    Log3.info("Starting Bot");
     _Bot.criticConfig = { dev: BotEnv.dev, token: BotEnv.token };
     _Bot._config = config;
     _Bot._client = client;
     (async () => {
-      Log.info(`Using discord.js version: ${version}`);
-      Log.info(`Using simplediscordbot version: ${SimpleDiscordBotInfo.version}`);
-      Log.info("Trying to connect to Discord Servers");
+      Log3.info(`Using discord.js version: ${version}`);
+      Log3.info(`Using simplediscordbot version: ${SimpleDiscordBotInfo.version}`);
+      Log3.info("Trying to connect to Discord Servers");
       await InternetChecker.checkConnection(3);
       await this.login();
     })();
@@ -1131,12 +849,12 @@ var Bot = class _Bot {
         _Bot._client.on(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}`);
+            Log3.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...`);
+        Log3.error(`Connection error : ${error}. Trying again...`);
         tries++;
         await new Promise(
           (resolve2) => setTimeout(resolve2, Time.second.SEC_03.toMilliseconds())
@@ -1144,7 +862,7 @@ var Bot = class _Bot {
       }
     }
     if (!success) {
-      Log.error("Impossible to connect the bot after 3 attempts");
+      Log3.error("Impossible to connect the bot after 3 attempts");
       return false;
     }
     return true;
@@ -1152,12 +870,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}`);
+      Log3.info(`Activity defined : ${message}`);
     }
   }
   static setRandomActivity(randomActivity, intervalMs = null) {
     if (randomActivity.length == 0) {
-      Log.error("Bot.randomActivity = [{}] is empty");
+      Log3.error("Bot.randomActivity = [{}] is empty");
       return;
     }
     const pickRandom = () => {
@@ -1167,335 +885,21 @@ var Bot = class _Bot {
     };
     if (intervalMs === null) {
       pickRandom();
-      Log.info(`Activity set ONCE`);
+      Log3.info(`Activity set ONCE`);
       return;
     }
     pickRandom();
     setInterval(async () => {
       pickRandom();
     }, intervalMs);
-    Log.info(`Random activity started (every ${Math.round(intervalMs / 6e4)}min)`);
+    Log3.info(`Random activity started (every ${Math.round(intervalMs / 6e4)}min)`);
     return;
   }
 };
 
-// src/manager/FileManager.ts
-import path from "path";
-import fs from "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 fs.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 fs.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 fs.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 fs.readdir(directoryPath);
-      return files.filter((file) => path.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 fs.readdir(directoryPath);
-      return files.filter((file) => path.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 fs.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 = path.join(directoryPath, `${cleanFilename}.json`);
-      const jsonContent = JSON.stringify(data, null, 2);
-      await fs.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 fs.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
-import path2 from "path";
-var CacheManager = class {
-  static get cacheDir() {
-    let folderPath = "simplediscordbot";
-    if (Bot.config?.botName) {
-      folderPath = this.cleanCacheId(Bot.config?.botName?.toLowerCase()).replace(" ", "_");
-    }
-    return path2.join(process.cwd(), `.${folderPath}cache`);
-  }
-  static cleanCacheId(key) {
-    return key.replace(/[^a-zA-Z0-9_-]/g, "_");
-  }
-  static createFilePath(filename) {
-    return path2.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
+import { FileManager } from "@spatulox/utils";
+import { CacheManager } from "@spatulox/utils";
 
 // src/manager/messages/WebhookManager.ts
 import {
@@ -1512,9 +916,6 @@ var WebhookManager = class {
     this.name = name;
     this.avatarPathOrUrl = avatarPathOrUrl;
   }
-  client;
-  name;
-  avatarPathOrUrl;
   webhook = null;
   async getAvatar() {
     if (!this.avatarPathOrUrl) return null;
@@ -1630,10 +1031,17 @@ var WebhookManager = class {
   }
 };
 
+// src/manager/messages/ReactionManager.ts
+import { Log as Log7 } from "@spatulox/utils";
+
 // src/manager/guild/ChannelManager/GuildTextChannelManager.ts
 import { TextChannel as TextChannel4, ChannelType as ChannelType2 } from "discord.js";
 
+// src/manager/guild/ChannelManager/GuildChannelManager.ts
+import { Log as Log5 } from "@spatulox/utils";
+
 // src/manager/guild/ChannelManager/GuildMessageManager.ts
+import { Log as Log4 } from "@spatulox/utils";
 var GuildMessageManager = class {
   /**
    * Impl
@@ -1642,7 +1050,7 @@ var GuildMessageManager = class {
     try {
       const channel = await GuildTextChannelManager.find(channelId);
       if (!channel) {
-        Log.error(`Channel ${channelId} not found in guild`);
+        Log4.error(`Channel ${channelId} not found in guild`);
         return null;
       }
       let payload;
@@ -1655,7 +1063,7 @@ var GuildMessageManager = class {
       }
       return await channel.send(payload);
     } catch (error) {
-      Log.error(`Failed to send message to ${channelId}: ${error}`);
+      Log4.error(`Failed to send message to ${channelId}: ${error}`);
       throw error;
     }
   }
@@ -1666,15 +1074,15 @@ var GuildMessageManager = class {
     try {
       const channel = await GuildTextChannelManager.find(channelId);
       if (!channel) {
-        Log.error(`Channel ${channelId} not found`);
+        Log4.error(`Channel ${channelId} not found`);
         return false;
       }
       const message = await channel.messages.fetch(messageId);
       await message.delete();
-      Log.info(`Deleted message ${messageId} from ${channelId}`);
+      Log4.info(`Deleted message ${messageId} from ${channelId}`);
       return true;
     } catch (error) {
-      Log.error(`Failed to delete message ${messageId} from ${channelId}: ${error}`);
+      Log4.error(`Failed to delete message ${messageId} from ${channelId}: ${error}`);
       return false;
     }
   }
@@ -1685,14 +1093,14 @@ var GuildMessageManager = class {
     try {
       const channel = await GuildTextChannelManager.find(channelId);
       if (!channel) {
-        Log.error(`Channel ${channelId} not found`);
+        Log4.error(`Channel ${channelId} not found`);
         return [];
       }
       const messages = await channel.messages.fetch({ limit });
-      Log.info(`Fetched ${messages.size} messages from ${channelId}`);
+      Log4.info(`Fetched ${messages.size} messages from ${channelId}`);
       return Array.from(messages.values());
     } catch (error) {
-      Log.error(`Failed to fetch messages from ${channelId}: ${error}`);
+      Log4.error(`Failed to fetch messages from ${channelId}: ${error}`);
       return [];
     }
   }
@@ -1703,13 +1111,13 @@ var GuildMessageManager = class {
     try {
       const channel = await GuildTextChannelManager.find(channelId);
       if (!channel) {
-        Log.error(`Channel ${channelId} not found`);
+        Log4.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}`);
+      Log4.error(`Failed to fetch message ${messageId} from ${channelId}: ${error}`);
       return null;
     }
   }
@@ -1725,13 +1133,13 @@ var GuildChannelManager = class _GuildChannelManager {
     try {
       const guild = Bot.client.guilds.cache.get(guildId);
       if (!guild) {
-        Log.warn(`Guild ${guildId} not found`);
+        Log5.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}`);
+      Log5.error(`Failed to find channel ${channelId} in guild ${guildId}: ${error}`);
       return null;
     }
   }
@@ -1741,10 +1149,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`);
+      Log5.warn(`Channel ${channelId} not found in any guild`);
       return null;
     } catch (error) {
-      Log.error(`Failed to find channel ${channelId}: ${error}`);
+      Log5.error(`Failed to find channel ${channelId}: ${error}`);
       return null;
     }
   }
@@ -1752,12 +1160,12 @@ var GuildChannelManager = class _GuildChannelManager {
     try {
       const guild = Bot.client.guilds.cache.get(guildId);
       if (!guild) {
-        Log.warn(`Guild ${guildId} not found`);
+        Log5.warn(`Guild ${guildId} not found`);
         return [];
       }
       return Array.from(guild.channels.cache.values());
     } catch (error) {
-      Log.error(`Failed to find channel ${guildId}: ${error}`);
+      Log5.error(`Failed to find channel ${guildId}: ${error}`);
       return [];
     }
   }
@@ -1768,14 +1176,14 @@ var GuildChannelManager = class _GuildChannelManager {
     try {
       const guild = Bot.client.guilds.cache.get(guildId);
       if (!guild) {
-        Log.warn(`Guild ${guildId} not found`);
+        Log5.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}`);
+      Log5.error(`Failed to find channel ${guildId}: ${error}`);
       return [];
     }
   }
@@ -1786,10 +1194,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}`);
+      Log5.info(`Created channel ${channel.name} (${channel.id}) in guild ${guildId}`);
       return channel;
     } catch (error) {
-      Log.error(`Failed to create channel in guild ${guildId}: ${error}`);
+      Log5.error(`Failed to create channel in guild ${guildId}: ${error}`);
       throw error;
     }
   }
@@ -1800,16 +1208,17 @@ var GuildChannelManager = class _GuildChannelManager {
         throw new Error(`Channel ${channelId} not found`);
       }
       await channel.delete();
-      Log.info(`Deleted channel ${channelId}`);
+      Log5.info(`Deleted channel ${channelId}`);
       return true;
     } catch (error) {
-      Log.error(`Failed to delete channel ${channelId}: ${error}`);
+      Log5.error(`Failed to delete channel ${channelId}: ${error}`);
       throw error;
     }
   }
 };
 
 // src/manager/guild/ChannelManager/GuildTextChannelManager.ts
+import { Log as Log6 } from "@spatulox/utils";
 var GuildTextChannelManager = class extends GuildChannelManager {
   static async findInGuild(guildId, channelId) {
     const channel = await super.findInGuild(guildId, channelId);
@@ -1822,7 +1231,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`);
+      Log6.warn(`Guild ${guildId} not found`);
       return [];
     }
     return Array.from(guild.channels.cache.values()).filter((c) => c instanceof TextChannel4);
@@ -1852,9 +1261,9 @@ var ReactionManager = class {
       }
       const message = await channel.messages.fetch(messageId);
       await message.react(emoji);
-      Log.info(`Added reaction ${emoji} to message ${messageId}`);
+      Log7.info(`Added reaction ${emoji} to message ${messageId}`);
     } catch (error) {
-      Log.error(`Failed to add reaction to ${messageId}: ${error}`);
+      Log7.error(`Failed to add reaction to ${messageId}: ${error}`);
       throw error;
     }
   }
@@ -1874,9 +1283,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}`);
+      Log7.info(`Removed reaction ${emoji} from user ${userId} on message ${messageId}`);
     } catch (error) {
-      Log.error(`Failed to remove reaction from ${messageId}: ${error}`);
+      Log7.error(`Failed to remove reaction from ${messageId}: ${error}`);
       throw error;
     }
   }
@@ -1900,10 +1309,10 @@ var ReactionManager = class {
           users: Array.from(users.values())
         });
       }
-      Log.info(`Fetched ${reactionList.length} reactions for message ${messageId}`);
+      Log7.info(`Fetched ${reactionList.length} reactions for message ${messageId}`);
       return reactionList;
     } catch (error) {
-      Log.error(`Failed to fetch reactions for ${messageId}: ${error}`);
+      Log7.error(`Failed to fetch reactions for ${messageId}: ${error}`);
       throw error;
     }
   }
@@ -1918,9 +1327,9 @@ var ReactionManager = class {
       }
       const message = await channel.messages.fetch(messageId);
       await message.reactions.removeAll();
-      Log.info(`Cleared all reactions from message ${messageId}`);
+      Log7.info(`Cleared all reactions from message ${messageId}`);
     } catch (error) {
-      Log.error(`Failed to clear reactions from ${messageId}: ${error}`);
+      Log7.error(`Failed to clear reactions from ${messageId}: ${error}`);
       throw error;
     }
   }
@@ -1928,9 +1337,15 @@ var ReactionManager = class {
 
 // src/manager/guild/GuildManager.ts
 import { Guild as Guild2, StageChannel as StageChannel2, VoiceChannel as VoiceChannel2 } from "discord.js";
+import { Log as Log16 } from "@spatulox/utils";
+import { Time as Time2 } from "@spatulox/utils";
+
+// src/manager/guild/GuildUserManager.ts
+import { Log as Log9 } from "@spatulox/utils";
 
 // src/manager/direct/BasicUserManager.ts
 import { GuildMember as GuildMember2 } from "discord.js";
+import { Log as Log8 } from "@spatulox/utils";
 var BasicUserManager = class {
   /**
    * Find member in specific guild
@@ -1946,7 +1361,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) Log8.error(`UserManager: Member ${memberId} not found in guild ${targetGuild.id}`);
     return member;
   }
   /**
@@ -1989,13 +1404,13 @@ var BasicUserManager = class {
       }
       const message = await dmChannel.send(payload);
       if (user instanceof GuildMember2) {
-        Log.info(`Sent DM to ${user.id} (${user.user.username}): "${(payload.content || "Embed/Component").substring(0, 50)}..."`);
+        Log8.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)}..."`);
+        Log8.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}`);
+      Log8.error(`Failed to send DM to ${user_id_or_user}: ${error}`);
       throw new Error(`Cannot send DM to ${user_id_or_user}`);
     }
   }
@@ -2013,7 +1428,7 @@ var GuildUserManager = class extends BasicUserManager {
       try {
         const oldName = member.displayName;
         await member.setNickname(nickname.trim());
-        Log.info(`Renaming user: ${oldName} \u2192 ${nickname.trim()}`);
+        Log9.info(`Renaming user: ${oldName} \u2192 ${nickname.trim()}`);
         await setTimeout2(1500);
         return true;
       } catch (error) {
@@ -2031,13 +1446,13 @@ var GuildUserManager = class extends BasicUserManager {
     try {
       const guild = await GuildManager.find(guildId);
       if (!guild) {
-        Log.warn(`Guild ${guildId} not found`);
+        Log9.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}`);
+      Log9.debug(`User ${userId} is not banned from guild ${guildId}`);
       return false;
     }
   }
@@ -2051,9 +1466,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}`);
+      Log9.info(`Disconnected member ${memberId} from voice in guild ${guildId}`);
     } catch (error) {
-      Log.error(`Failed to disconnect member ${memberId} from voice in ${guildId}: ${error}`);
+      Log9.error(`Failed to disconnect member ${memberId} from voice in ${guildId}: ${error}`);
       throw error;
     }
   }
@@ -2068,7 +1483,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}`);
+      Log9.debug(`Member ${memberId} not found or not in voice in guild ${guildId}`);
       return false;
     }
   }
@@ -2082,9 +1497,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"}`);
+      Log9.info(`Server muted ${memberId} in guild ${guildId}: ${reason || "No reason"}`);
     } catch (error) {
-      Log.error(`Failed to server mute ${memberId} in ${guildId}:, error`);
+      Log9.error(`Failed to server mute ${memberId} in ${guildId}:, error`);
       throw error;
     }
   }
@@ -2098,9 +1513,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"}`);
+      Log9.info(`Server unmuted ${memberId} in guild ${guildId}: ${reason || "No reason"}`);
     } catch (error) {
-      Log.error(`Failed to server unmute ${memberId} in ${guildId}: ${error}`);
+      Log9.error(`Failed to server unmute ${memberId} in ${guildId}: ${error}`);
       throw error;
     }
   }
@@ -2114,9 +1529,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"}`);
+      Log9.info(`Server deafened ${memberId} in guild ${guildId}: ${reason || "No reason"}`);
     } catch (error) {
-      Log.error(`Failed to server deafen ${memberId} in ${guildId}: ${error}`);
+      Log9.error(`Failed to server deafen ${memberId} in ${guildId}: ${error}`);
       throw error;
     }
   }
@@ -2130,9 +1545,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"}`);
+      Log9.info(`Server undeafened ${memberId} in guild ${guildId}: ${reason || "No reason"}`);
     } catch (error) {
-      Log.error(`Failed to server undeafen ${memberId} in ${guildId}: ${error}`);
+      Log9.error(`Failed to server undeafen ${memberId} in ${guildId}: ${error}`);
       throw error;
     }
   }
@@ -2147,9 +1562,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"}`);
+      Log9.info(`Timed out ${memberId} for ${duration}ms in guild ${guildId}: ${reason || "No reason"}`);
     } catch (error) {
-      Log.error(`Failed to timeout ${memberId} in ${guildId}: ${error}`);
+      Log9.error(`Failed to timeout ${memberId} in ${guildId}: ${error}`);
       throw error;
     }
   }
@@ -2163,9 +1578,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"}`);
+      Log9.info(`Untimed out ${memberId} in guild ${guildId}: ${reason || "No reason"}`);
     } catch (error) {
-      Log.error(`Failed to untimeout ${memberId} in ${guildId}: ${error}`);
+      Log9.error(`Failed to untimeout ${memberId} in ${guildId}: ${error}`);
       throw error;
     }
   }
@@ -2179,9 +1594,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"}`);
+      Log9.info(`Kicked ${memberId} from guild ${guildId}: ${reason || "No reason"}`);
     } catch (error) {
-      Log.error(`Failed to kick ${memberId} from ${guildId}: ${error}`);
+      Log9.error(`Failed to kick ${memberId} from ${guildId}: ${error}`);
       throw error;
     }
   }
@@ -2192,9 +1607,9 @@ var GuildUserManager = class extends BasicUserManager {
     }
     try {
       await guild.members.ban(userId, banOption);
-      Log.info(`Banned user ${userId} from guild ${guildId}`);
+      Log9.info(`Banned user ${userId} from guild ${guildId}`);
     } catch (error) {
-      Log.error(`Failed to ban user ${userId} from guild ${guildId}: ${error}`);
+      Log9.error(`Failed to ban user ${userId} from guild ${guildId}: ${error}`);
       throw error;
     }
   }
@@ -2205,15 +1620,16 @@ var GuildUserManager = class extends BasicUserManager {
     }
     try {
       await guild.members.unban(userId, reason);
-      Log.info(`Unbanned user ${userId} from guild ${guildId}`);
+      Log9.info(`Unbanned user ${userId} from guild ${guildId}`);
     } catch (error) {
-      Log.error(`Failed to unban user ${userId} from guild ${guildId}: ${error}`);
+      Log9.error(`Failed to unban user ${userId} from guild ${guildId}: ${error}`);
       throw error;
     }
   }
 };
 
 // src/manager/guild/RoleManager.ts
+import { Log as Log10 } from "@spatulox/utils";
 var RoleManager = class {
   /**
    * Add role - CACHE ONLY
@@ -2224,14 +1640,14 @@ var RoleManager = class {
     try {
       const role = member.guild.roles.cache.get(roleId);
       if (!role) {
-        Log.warn(`Role ${roleId} not found in cache`);
+        Log10.warn(`Role ${roleId} not found in cache`);
         return false;
       }
       await member.roles.add(role);
-      Log.info(`\u2705 Added ${role.name} to ${member.displayName}`);
+      Log10.info(`\u2705 Added ${role.name} to ${member.displayName}`);
       return true;
     } catch (error) {
-      Log.error(`Failed to add role ${roleId}: ${error}`);
+      Log10.error(`Failed to add role ${roleId}: ${error}`);
       return false;
     }
   }
@@ -2251,14 +1667,14 @@ var RoleManager = class {
         );
       }
       if (!role) {
-        Log.warn(`Role ${roleIdOrName} not found for ${member.displayName}`);
+        Log10.warn(`Role ${roleIdOrName} not found for ${member.displayName}`);
         return false;
       }
       await member.roles.remove(role);
-      Log.info(`\u2705 Removed ${role.name} from ${member.displayName}`);
+      Log10.info(`\u2705 Removed ${role.name} from ${member.displayName}`);
       return true;
     } catch (error) {
-      Log.error(`Failed to remove role ${roleIdOrName}: ${error}`);
+      Log10.error(`Failed to remove role ${roleIdOrName}: ${error}`);
       return false;
     }
   }
@@ -2268,7 +1684,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`);
+      Log10.warn(`Role ${roleIdOrName} not found`);
       throw new Error(`Role not found`);
     }
     if (member.roles.cache.has(role.id)) {
@@ -2294,6 +1710,7 @@ var RoleManager = class {
 
 // src/manager/guild/ChannelManager/ForumChannelManager.ts
 import { ChannelType as ChannelType3, ForumChannel } from "discord.js";
+import { Log as Log11 } from "@spatulox/utils";
 var ForumChannelManager = class extends GuildChannelManager {
   static async findInGuild(guildId, channelId) {
     const channel = await super.findInGuild(guildId, channelId);
@@ -2306,7 +1723,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`);
+      Log11.warn(`Guild ${guildId} not found`);
       return [];
     }
     return Array.from(guild.channels.cache.values()).filter((c) => c instanceof ForumChannel);
@@ -2322,6 +1739,7 @@ var ForumChannelManager = class extends GuildChannelManager {
 
 // src/manager/guild/ChannelManager/NewsChannelManager.ts
 import { ChannelType as ChannelType4, NewsChannel } from "discord.js";
+import { Log as Log12 } from "@spatulox/utils";
 var NewsChannelManager = class extends GuildChannelManager {
   static async findInGuild(guildId, channelId) {
     const channel = await super.findInGuild(guildId, channelId);
@@ -2334,7 +1752,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`);
+      Log12.warn(`Guild ${guildId} not found`);
       return [];
     }
     return Array.from(guild.channels.cache.values()).filter((c) => c instanceof NewsChannel);
@@ -2350,6 +1768,7 @@ var NewsChannelManager = class extends GuildChannelManager {
 
 // src/manager/guild/ChannelManager/StageChannelManager.ts
 import { ChannelType as ChannelType5, StageChannel } from "discord.js";
+import { Log as Log13 } from "@spatulox/utils";
 var StageChannelManager = class extends GuildChannelManager {
   static async findInGuild(guildId, channelId) {
     const channel = await super.findInGuild(guildId, channelId);
@@ -2362,7 +1781,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`);
+      Log13.warn(`Guild ${guildId} not found`);
       return [];
     }
     return Array.from(guild.channels.cache.values()).filter((c) => c instanceof StageChannel);
@@ -2419,6 +1838,7 @@ var ThreadChannelManager = class {
 
 // src/manager/guild/ChannelManager/GuildVoiceChannelManager.ts
 import { ChannelType as ChannelType6, VoiceChannel } from "discord.js";
+import { Log as Log14 } from "@spatulox/utils";
 var GuildVoiceChannelManager = class extends GuildChannelManager {
   static async findInGuild(guildId, channelId) {
     const channel = await super.findInGuild(guildId, channelId);
@@ -2431,7 +1851,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`);
+      Log14.warn(`Guild ${guildId} not found`);
       return [];
     }
     return Array.from(guild.channels.cache.values()).filter((c) => c instanceof VoiceChannel);
@@ -2457,6 +1877,7 @@ var GuildChannelList = class {
 };
 
 // src/manager/guild/InviteManager.ts
+import { Log as Log15 } from "@spatulox/utils";
 var InviteManager = class {
   /**
    * Create an invite for a channel
@@ -2475,10 +1896,10 @@ var InviteManager = class {
         reason: options.reason
       };
       const invite = await guild.invites.create(channelId, inviteOptions);
-      Log.info(`Created invite ${invite.code} for channel ${channelId}`);
+      Log15.info(`Created invite ${invite.code} for channel ${channelId}`);
       return invite;
     } catch (error) {
-      Log.error(`Failed to create invite for channel ${channelId}: ${error}`);
+      Log15.error(`Failed to create invite for channel ${channelId}: ${error}`);
       throw error;
     }
   }
@@ -2488,10 +1909,10 @@ var InviteManager = class {
   static async delete(invite) {
     try {
       await invite.delete();
-      Log.info(`Deleted invite ${invite.code} from guild ${invite.guild?.id}`);
+      Log15.info(`Deleted invite ${invite.code} from guild ${invite.guild?.id}`);
       return true;
     } catch (error) {
-      Log.error(`Failed to delete invite ${invite.code}: ${error}`);
+      Log15.error(`Failed to delete invite ${invite.code}: ${error}`);
       return false;
     }
   }
@@ -2506,10 +1927,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}`);
+      Log15.info(`Fetched ${inviteList.length} invites for guild ${guildId}`);
       return inviteList;
     } catch (error) {
-      Log.error(`Failed to fetch invites for guild ${guildId}: ${error}`);
+      Log15.error(`Failed to fetch invites for guild ${guildId}: ${error}`);
       throw error;
     }
   }
@@ -2530,7 +1951,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} `);
+      Log16.error(`GuildManager: Guild ${guild_id} : ${error} `);
       return null;
     }
   }
@@ -2541,7 +1962,7 @@ var GuildManager = class {
     try {
       return await GuildChannelManager.findInGuild(guildId, channelId);
     } catch (error) {
-      Log.error(`Failed to fetch channel ${channelId}: ${error}`);
+      Log16.error(`Failed to fetch channel ${channelId}: ${error}`);
       return null;
     }
   }
@@ -2552,7 +1973,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}`);
+      Log16.error(`Failed to fetch member ${memberId} in guild ${guildId}: ${error}`);
       return null;
     }
   }
@@ -2569,7 +1990,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 = Time2.minute.MIN_05.toMilliseconds()) {
     let guild;
     if (guildId instanceof Guild2) {
       guild = guildId;
@@ -2580,10 +2001,10 @@ var GuildManager = class {
     }
     for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
       try {
-        Log.info(`UserManager: Fetching ${guild.name} members (attempt ${attempt})`);
+        Log16.info(`UserManager: Fetching ${guild.name} members (attempt ${attempt})`);
         return await guild.members.fetch();
       } catch (error) {
-        Log.error(`UserManager: Fetch failed (attempt ${attempt}): ${error}`);
+        Log16.error(`UserManager: Fetch failed (attempt ${attempt}): ${error}`);
         if (attempt < MAX_ATTEMPTS) {
           await new Promise((r) => setTimeout(r, RETRY_DELAY));
         }
@@ -2600,7 +2021,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}`);
+      Log16.error(`Failed to list bans in guild ${guildId}: ${error}`);
       throw error;
     }
   }
@@ -2635,26 +2056,27 @@ var GuildManager = class {
       }
       try {
         await member.voice.setChannel(toChannel);
-        Log.info(`Moved member ${memberId} from ${fromChannelId} to ${toChannelId}`);
+        Log16.info(`Moved member ${memberId} from ${fromChannelId} to ${toChannelId}`);
       } catch (error) {
-        Log.error(`Failed to move member ${memberId} from ${fromChannelId} to ${toChannelId}: ${error}`);
+        Log16.error(`Failed to move member ${memberId} from ${fromChannelId} to ${toChannelId}: ${error}`);
         throw error;
       }
       return true;
     } catch (e) {
-      Log.error(`Failed to move member ${e}`);
+      Log16.error(`Failed to move member ${e}`);
       return false;
     }
   }
 };
 
 // src/manager/direct/UserManager.ts
+import { Log as Log17 } from "@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) Log17.error(`UserManager: User ${userId} not found`);
     return user;
   }
 };
@@ -2909,7 +2331,7 @@ var ComponentManager = class {
     options.value && container.addTextDisplayComponents(new TextDisplayBuilder().setContent(options.value));
   }
   static field(container, field) {
-    const hasText = "name" in field && "value" in field && field.name && field.value;
+    const hasText = ("name" in field || "value" in field) && (field.name || field.value);
     if ("button" in field && Array.isArray(field.button) && field.button.length > 0) {
       const actionRow = new ActionRowBuilder4().addComponents(field.button);
       if (hasText) this.fieldAddText(container, { name: field.name, value: field.value });
@@ -3114,46 +2536,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
+import { Time as Time3 } from "@spatulox/utils";
+import { Log as Log18 } from "@spatulox/utils";
+import { SimpleMutex } from "@spatulox/utils";
 
 // src/constants/DiscordRegex.ts
 var DiscordRegex = class {
@@ -3278,7 +2664,7 @@ export {
   EmbedManager,
   FileManager,
   GuildManager,
-  Log,
+  Log18 as Log,
   ModalFieldType,
   ModalManager,
   ReactionManager,
@@ -3286,7 +2672,7 @@ export {
   SimpleColor,
   SimpleDiscordBotInfo,
   SimpleMutex,
-  Time,
+  Time3 as Time,
   UserManager,
   WebhookManager
 };