djs-next 1.0.0-dev.1

package/dist/index.mjs

@@ -0,0 +1,885 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/client.ts
+import { Client, Collection as Collection3 } from "discord.js";
+
+// src/handlers/commandHandler.ts
+import { Collection, REST, Routes } from "discord.js";
+import fs2 from "fs";
+import path2 from "path";
+import { pathToFileURL } from "url";
+
+// src/handlers/utils.ts
+import fs from "fs";
+import path from "path";
+function getAllFiles(dirPath, arrayOfFiles = []) {
+  const files = fs.readdirSync(dirPath);
+  files.forEach((file) => {
+    const fullPath = path.join(dirPath, file);
+    if (fs.statSync(fullPath).isDirectory()) {
+      arrayOfFiles = getAllFiles(fullPath, arrayOfFiles);
+    } else {
+      if (file.endsWith(".js") || file.endsWith(".ts") || file.endsWith(".mjs") || file.endsWith(".cjs")) {
+        if (!file.endsWith(".d.ts")) {
+          arrayOfFiles.push(fullPath);
+        }
+      }
+    }
+  });
+  return arrayOfFiles;
+}
+
+// src/handlers/commandHandler.ts
+async function loadAndDeployCommands(commandsDir, token, clientId, guildId) {
+  const flatCommands = new Collection();
+  if (!fs2.existsSync(commandsDir)) {
+    console.warn(`[djs-next] Commands directory "${commandsDir}" does not exist.`);
+    return flatCommands;
+  }
+  const commandFiles = getAllFiles(commandsDir);
+  const rootNodes = /* @__PURE__ */ new Map();
+  function getOrCreateNode(pathParts) {
+    let currentMap = rootNodes;
+    let currentNode;
+    for (const part of pathParts) {
+      if (!currentMap.has(part)) {
+        currentMap.set(part, {
+          name: part,
+          description: `${part} command`,
+          // Fallback description
+          options: [],
+          children: /* @__PURE__ */ new Map()
+        });
+      }
+      currentNode = currentMap.get(part);
+      currentMap = currentNode.children;
+    }
+    return currentNode;
+  }
+  for (const file of commandFiles) {
+    const relativePath = path2.relative(commandsDir, file);
+    const parsed = path2.parse(relativePath);
+    const dirParts = parsed.dir ? parsed.dir.split(path2.sep) : [];
+    const name = parsed.name;
+    const pathParts = [...dirParts];
+    if (name !== "index") {
+      pathParts.push(name);
+    }
+    if (pathParts.length === 0) continue;
+    if (pathParts.length > 3) {
+      console.warn(`[djs-next] Command path too deep (Discord allows max 3 levels): ${relativePath}`);
+      continue;
+    }
+    const module = await import(pathToFileURL(file).href);
+    const commandData = module.default || module.command || module;
+    if (commandData) commandData.filepath = file;
+    const node = getOrCreateNode(pathParts);
+    if (commandData.description) node.description = commandData.description;
+    if (commandData.options) node.options = commandData.options;
+    if (commandData.execute) {
+      node.execute = commandData.execute;
+      flatCommands.set(pathParts.join(" "), commandData);
+    }
+  }
+  function buildCommandJSON(node, depth) {
+    const json = {
+      name: node.name,
+      description: node.description
+    };
+    if (node.children.size > 0) {
+      json.options = [];
+      for (const [_, childNode] of node.children) {
+        const childJson = buildCommandJSON(childNode, depth + 1);
+        if (depth === 0) {
+          childJson.type = childNode.children.size > 0 ? 2 : 1;
+        } else if (depth === 1) {
+          childJson.type = 1;
+        }
+        json.options.push(childJson);
+      }
+    } else if (node.options && node.options.length > 0) {
+      json.options = node.options;
+    }
+    return json;
+  }
+  const commandsData = Array.from(rootNodes.values()).map((node) => buildCommandJSON(node, 0));
+  const rest = new REST({ version: "10" }).setToken(token);
+  try {
+    console.log(`[djs-next] Started refreshing ${commandsData.length} File-System application (/) commands.`);
+    let data;
+    if (guildId) {
+      data = await rest.put(
+        Routes.applicationGuildCommands(clientId, guildId),
+        { body: commandsData }
+      );
+    } else {
+      data = await rest.put(
+        Routes.applicationCommands(clientId),
+        { body: commandsData }
+      );
+    }
+    console.log(`[djs-next] Successfully reloaded ${data.length} File-System application (/) commands.`);
+  } catch (error) {
+    console.error(`[djs-next] Failed to deploy commands:`, error);
+  }
+  return flatCommands;
+}
+
+// src/handlers/eventHandler.ts
+import fs3 from "fs";
+import { pathToFileURL as pathToFileURL2 } from "url";
+async function loadEvents(client2, eventsDir) {
+  if (!fs3.existsSync(eventsDir)) {
+    console.warn(`[djs-next] Events directory "${eventsDir}" does not exist.`);
+    return;
+  }
+  const eventFiles = getAllFiles(eventsDir);
+  let loadedEvents = 0;
+  for (const file of eventFiles) {
+    const eventModule = await import(pathToFileURL2(file).href);
+    const eventData = eventModule.default?.event || eventModule.event || eventModule.default || eventModule;
+    if (eventData) eventData.filepath = file;
+    if (!eventData || !eventData.name || !eventData.execute) {
+      console.warn(`[djs-next] The event at ${file} is missing a required "name" or "execute" property.`);
+      continue;
+    }
+    if (eventData.once) {
+      client2.once(eventData.name, (...args2) => eventData.execute(client2, ...args2));
+    } else {
+      client2.on(eventData.name, (...args2) => eventData.execute(client2, ...args2));
+    }
+    loadedEvents++;
+  }
+  if (loadedEvents > 0) {
+    console.log(`[djs-next] Successfully loaded ${loadedEvents} events.`);
+  }
+}
+
+// src/handlers/componentHandler.ts
+import { Collection as Collection2 } from "discord.js";
+import fs4 from "fs";
+import path3 from "path";
+import { pathToFileURL as pathToFileURL3 } from "url";
+async function loadComponents(componentsDir) {
+  const components2 = new Collection2();
+  if (!fs4.existsSync(componentsDir)) return components2;
+  const files = getAllFiles(componentsDir);
+  for (const file of files) {
+    const module = await import(pathToFileURL3(file).href);
+    const componentData = module.default || module.component || module;
+    if (componentData) componentData.filepath = file;
+    if (!componentData || !componentData.execute) continue;
+    const parsed = path3.parse(file);
+    const customId = componentData.customId || parsed.name;
+    components2.set(customId, componentData);
+  }
+  console.log(`[djs-next] Successfully loaded ${components2.size} components.`);
+  return components2;
+}
+
+// src/handlers/taskHandler.ts
+import fs5 from "fs";
+import { pathToFileURL as pathToFileURL4 } from "url";
+async function loadTasks(client2, tasksDir) {
+  if (!fs5.existsSync(tasksDir)) return;
+  const files = getAllFiles(tasksDir);
+  let loaded = 0;
+  for (const file of files) {
+    const module = await import(pathToFileURL4(file).href);
+    const taskData = module.default || module.task || module;
+    if (taskData) taskData.filepath = file;
+    if (!taskData || !taskData.interval || !taskData.execute) continue;
+    const intervalId = setInterval(async () => {
+      try {
+        await taskData.execute(client2);
+      } catch (error) {
+        console.error(`[djs-next] Background Task error at ${file}:`, error);
+      }
+    }, taskData.interval);
+    if (!client2._activeTasks) client2._activeTasks = /* @__PURE__ */ new Map();
+    client2._activeTasks.set(file, intervalId);
+    loaded++;
+  }
+  if (loaded > 0) {
+    console.log(`[djs-next] Successfully scheduled ${loaded} background tasks.`);
+  }
+}
+
+// src/client.ts
+import path6 from "path";
+import fs8 from "fs";
+import { pathToFileURL as pathToFileURL6 } from "url";
+
+// src/utils/configLoader.ts
+import path4 from "path";
+import fs6 from "fs";
+import { pathToFileURL as pathToFileURL5 } from "url";
+async function loadConfig() {
+  const exts = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"];
+  const cwd = process.cwd();
+  for (const ext of exts) {
+    const configPath = path4.join(cwd, `djs-next.config${ext}`);
+    if (fs6.existsSync(configPath)) {
+      try {
+        const configModule = await import(pathToFileURL5(configPath).href);
+        return configModule.default || configModule;
+      } catch (err) {
+        console.error(`[djs-next] Error loading config file ${configPath}:`, err);
+        return {};
+      }
+    }
+  }
+  return {};
+}
+function defineConfig(config2) {
+  return config2;
+}
+
+// src/utils/i18n.ts
+import fs7 from "fs";
+import path5 from "path";
+var localesCache = {};
+var defaultLoc = "en";
+function loadLocales(localesDir, defaultLocale) {
+  if (defaultLocale) defaultLoc = defaultLocale;
+  if (!fs7.existsSync(localesDir)) return;
+  const files = fs7.readdirSync(localesDir);
+  for (const file of files) {
+    if (file.endsWith(".json")) {
+      const lang = file.replace(".json", "");
+      const content = fs7.readFileSync(path5.join(localesDir, file), "utf8");
+      try {
+        localesCache[lang] = JSON.parse(content);
+      } catch (e) {
+        console.error(`[djs-next] Failed to parse locale file: ${file}`, e);
+      }
+    }
+  }
+}
+function translate(key, locale = defaultLoc, variables) {
+  const dict = localesCache[locale] || localesCache[defaultLoc] || {};
+  const keys = key.split(".");
+  let value = dict;
+  for (const k of keys) {
+    if (value && typeof value === "object") {
+      value = value[k];
+    } else {
+      value = void 0;
+      break;
+    }
+  }
+  if (typeof value !== "string") {
+    return key;
+  }
+  if (variables) {
+    for (const [varKey, varValue] of Object.entries(variables)) {
+      value = value.replace(new RegExp(`{{s*${varKey}s*}}`, "g"), String(varValue));
+    }
+  }
+  return value;
+}
+function getLocalesCache() {
+  return localesCache;
+}
+
+// src/plugins/dnxt.ts
+import { exec } from "child_process";
+import util from "util";
+import os from "os";
+var execAsync = util.promisify(exec);
+async function handleDNXT(message, client, prefix = "dnxt") {
+  if (message.author.bot) return;
+  if (!client["_developers"].includes(message.author.id)) return;
+  if (!message.content.startsWith(prefix)) return;
+  const args = message.content.slice(prefix.length).trim().split(/ +/);
+  const command = args.shift()?.toLowerCase();
+  if (!command) {
+    const mem = process.memoryUsage();
+    const discordJsVersion = __require("discord.js/package.json").version;
+    const botPing = client.ws.ping;
+    const text = `Module was loaded <t:${Math.floor((Date.now() - client.uptime) / 1e3)}:R>.
+DNXT framework plugin, discord.js \`${discordJsVersion}\`, \`Node.js ${process.version}\` on \`${os.type()}\`.
+Latencies: \`${botPing}ms\` websocket ping.
+Memory: \`${(mem.rss / 1024 / 1024).toFixed(2)} MB\` physical, \`${(mem.heapUsed / 1024 / 1024).toFixed(2)} MB\` heap.
+System: \`${os.cpus().length}\` thread(s), \`${(os.uptime() / 60 / 60).toFixed(2)}\` hrs system uptime.`;
+    await message.reply(text);
+    return;
+  }
+  if (command === "js" || command === "eval" || command === "py") {
+    let code = args.join(" ");
+    if (code.startsWith("```js") || code.startsWith("```py")) code = code.replace(/^```[a-z]*|```$/g, "");
+    else if (code.startsWith("```")) code = code.replace(/^```|```$/g, "");
+    if (!code) return void await message.reply("\u274C Please provide code to evaluate.");
+    try {
+      const start = process.hrtime.bigint();
+      const { commands, components, config } = client;
+      let evaled = await eval(`(async () => { ${code} })()`);
+      const end = process.hrtime.bigint();
+      const timeMs = Number(end - start) / 1e6;
+      if (typeof evaled !== "string") evaled = util.inspect(evaled, { depth: 1 });
+      await sendPaginatedText(message, `\u2705 **Evaluated in ${timeMs.toFixed(3)}ms**
+`, evaled, "js");
+    } catch (err) {
+      await sendPaginatedText(message, `\u274C **Evaluation Error**
+`, err.message, "js");
+    }
+    return;
+  }
+  if (command === "sh" || command === "shell" || command === "git") {
+    const cmd = command === "git" ? "git " + args.join(" ") : args.join(" ");
+    if (!cmd) return void await message.reply("\u274C Please provide a command to execute.");
+    try {
+      const start2 = process.hrtime.bigint();
+      const { stdout, stderr } = await execAsync(cmd);
+      const end2 = process.hrtime.bigint();
+      const timeMs2 = Number(end2 - start2) / 1e6;
+      const result = stdout || stderr || "No output.";
+      await sendPaginatedText(message, `\u2705 **Executed in ${timeMs2.toFixed(3)}ms**
+`, result, "sh");
+    } catch (err) {
+      await sendPaginatedText(message, `\u274C **Shell Error**
+`, err.message, "sh");
+    }
+    return;
+  }
+  if (command === "reload" || command === "load") {
+    const target = args[0]?.toLowerCase();
+    try {
+      if (target === "commands" && client["_commandsDir"]) {
+        client.commands.clear();
+        client.commands = await loadAndDeployCommands(client["_commandsDir"], client.token, client["_clientId"], client["_guildId"]);
+        await message.reply("\u2705 Reloaded commands.");
+      } else if (target === "events" && client["_eventsDir"]) {
+        client.removeAllListeners();
+        client["attachCoreListeners"]();
+        await loadEvents(client, client["_eventsDir"]);
+        await message.reply("\u2705 Reloaded events.");
+      } else if (target === "components" && client["_componentsDir"]) {
+        client.components.clear();
+        client.components = await loadComponents(client["_componentsDir"]);
+        await message.reply("\u2705 Reloaded components.");
+      } else if (target === "locales" && client["_localesDir"]) {
+        loadLocales(client["_localesDir"], client.config.defaultLocale);
+        await message.reply("\u2705 Reloaded locales.");
+      } else if (target === "all" || !target) {
+        client.removeAllListeners();
+        client["attachCoreListeners"]();
+        client.commands.clear();
+        client.components.clear();
+        if (client["_eventsDir"]) await loadEvents(client, client["_eventsDir"]);
+        if (client["_componentsDir"]) client.components = await loadComponents(client["_componentsDir"]);
+        if (client["_localesDir"]) loadLocales(client["_localesDir"], client.config.defaultLocale);
+        if (client["_commandsDir"]) client.commands = await loadAndDeployCommands(client["_commandsDir"], client.token, client["_clientId"], client["_guildId"]);
+        await message.reply("\u2705 Reloaded all framework modules.");
+      } else {
+        await message.reply("\u274C Unknown target. Valid targets: `commands, events, components, locales, all`");
+      }
+    } catch (err) {
+      await message.reply(`\u274C **Reload Error:** ${err.message}`);
+    }
+    return;
+  }
+  if (command === "cat") {
+    const fs9 = await import("fs");
+    const path7 = await import("path");
+    const file = args.join(" ");
+    if (!file) return void await message.reply("\u274C Please provide a file to read.");
+    try {
+      const content = fs9.readFileSync(path7.resolve(process.cwd(), file), "utf8");
+      await sendPaginatedText(message, `\u{1F4C4} **${file}**
+`, content, file.split(".").pop() || "");
+    } catch (e) {
+      await message.reply(`\u274C **Error reading file:** ${e.message}`);
+    }
+    return;
+  }
+  if (command === "su" || command === "sudo") {
+    const targetUserId = args.shift();
+    const cmd = args.join(" ");
+    if (!targetUserId || !cmd) return void await message.reply(`\u274C Usage: ${prefix} su <user_id> <command>`);
+    try {
+      const targetUser = await client.users.fetch(targetUserId.replace(/<@!?|>/g, ""));
+      if (!targetUser) throw new Error("User not found.");
+      const mockMessage = Object.assign(Object.create(Object.getPrototypeOf(message)), message);
+      mockMessage.author = targetUser;
+      if (message.guild) {
+        mockMessage.member = await message.guild.members.fetch(targetUser.id).catch(() => null);
+      }
+      mockMessage.content = cmd;
+      client.emit("messageCreate", mockMessage);
+      await message.reply(`\u2705 Invoked \`${cmd}\` as **${targetUser.tag}**.`);
+    } catch (e) {
+      await message.reply(`\u274C **Sudo Error:** ${e.message}`);
+    }
+    return;
+  }
+  if (command === "source" || command === "src") {
+    const target = args.join(" ");
+    if (!target) return void await message.reply("\u274C Please provide a command name.");
+    const cmdData = client.commands.get(target);
+    if (!cmdData || !cmdData.filepath) return void await message.reply("\u274C Command not found or has no associated filepath.");
+    try {
+      const fs9 = await import("fs");
+      const content = fs9.readFileSync(cmdData.filepath, "utf8");
+      await sendPaginatedText(message, `\u{1F4C4} **Source of \`${target}\`**
+`, content, cmdData.filepath.split(".").pop() || "");
+    } catch (e) {
+      await message.reply(`\u274C **Error reading source:** ${e.message}`);
+    }
+    return;
+  }
+  if (command === "curl") {
+    const url = args[0];
+    if (!url) return void await message.reply("\u274C Please provide a URL.");
+    try {
+      const res = await fetch(url);
+      const text = await res.text();
+      await sendPaginatedText(message, `\u{1F310} **Fetched from \`${url}\`**
+`, text, "html");
+    } catch (e) {
+      await message.reply(`\u274C **Curl Error:** ${e.message}`);
+    }
+    return;
+  }
+  if (command === "debug") {
+    let code = args.join(" ");
+    if (code.startsWith("```js") || code.startsWith("```py")) code = code.replace(/^```[a-z]*|```$/g, "");
+    else if (code.startsWith("```")) code = code.replace(/^```|```$/g, "");
+    if (!code) return void await message.reply("\u274C Please provide code to debug.");
+    try {
+      const startMem = process.memoryUsage().heapUsed;
+      const start = process.hrtime.bigint();
+      const { commands, components, config } = client;
+      let evaled = await eval(`(async () => { ${code} })()`);
+      const end = process.hrtime.bigint();
+      const endMem = process.memoryUsage().heapUsed;
+      const timeMs = Number(end - start) / 1e6;
+      const memDiff = (endMem - startMem) / 1024 / 1024;
+      if (typeof evaled !== "string") evaled = util.inspect(evaled, { depth: 1 });
+      await sendPaginatedText(message, `\u23F1\uFE0F **Debug Execution**
+Time: \`${timeMs.toFixed(3)}ms\` | Heap Delta: \`${memDiff.toFixed(3)}MB\`
+`, evaled, "js");
+    } catch (err) {
+      await sendPaginatedText(message, `\u274C **Debug Error**
+`, err.message, "js");
+    }
+    return;
+  }
+  if (command === "in") {
+    const channelId = args.shift()?.replace(/<#|>/g, "");
+    const cmd = args.join(" ");
+    if (!channelId || !cmd) return void await message.reply(`\u274C Usage: ${prefix} in <channel> <command>`);
+    try {
+      const targetChannel = await client.channels.fetch(channelId);
+      if (!targetChannel || !targetChannel.isTextBased()) throw new Error("Invalid Text Channel.");
+      const mockMessage = Object.assign(Object.create(Object.getPrototypeOf(message)), message);
+      mockMessage.channel = targetChannel;
+      mockMessage.channelId = targetChannel.id;
+      mockMessage.content = cmd;
+      client.emit("messageCreate", mockMessage);
+      await message.reply(`\u2705 Redirected execution to <#${targetChannel.id}>.`);
+    } catch (e) {
+      await message.reply(`\u274C **In Error:** ${e.message}`);
+    }
+    return;
+  }
+  if (command === "tasks") {
+    const tasks = client._activeTasks;
+    if (!tasks || tasks.size === 0) return void await message.reply("No active background tasks running.");
+    let text = `\u2699\uFE0F **Active Background Tasks (${tasks.size})**
+`;
+    for (const [name] of tasks.entries()) {
+      text += `- \`${name.split("/").pop()}\`
+`;
+    }
+    await sendPaginatedText(message, "", text, "");
+    return;
+  }
+  if (command === "cancel") {
+    const target = args.join(" ");
+    if (!target) return void await message.reply(`\u274C Usage: ${prefix} cancel <task_name>`);
+    const tasks = client._activeTasks;
+    if (!tasks) return void await message.reply("No active tasks to cancel.");
+    let found = false;
+    for (const [name, intervalId] of tasks.entries()) {
+      if (name.includes(target)) {
+        clearInterval(intervalId);
+        tasks.delete(name);
+        found = true;
+        await message.reply(`\u2705 Cancelled background task: \`${name.split("/").pop()}\``);
+        break;
+      }
+    }
+    if (!found) await message.reply("\u274C Task not found.");
+    return;
+  }
+  if (command === "sync") {
+    try {
+      await message.reply("\u{1F504} Force syncing slash commands...");
+      await loadAndDeployCommands(client._commandsDir, client.token, client._clientId, client._guildId);
+      await message.reply("\u2705 Slash commands synchronized globally/locally.");
+    } catch (e) {
+      await message.reply(`\u274C **Sync Error:** ${e.message}`);
+    }
+    return;
+  }
+  if (command === "sql") {
+    const query = args.join(" ");
+    if (!query) return void await message.reply(`\u274C Usage: ${prefix} sql <query>`);
+    try {
+      let res;
+      if (client.db && typeof client.db.$queryRawUnsafe === "function") {
+        res = await client.db.$queryRawUnsafe(query);
+      } else if (client.db && typeof client.db.query === "function") {
+        res = await client.db.query(query);
+      } else {
+        return void await message.reply("\u274C Your configured `client.db` does not expose a recognized raw SQL execution method (`$queryRawUnsafe` or `query`).");
+      }
+      const inspect = util.inspect(res, { depth: 2 });
+      await sendPaginatedText(message, `\u{1F5C4}\uFE0F **SQL Query**
+`, inspect, "js");
+    } catch (e) {
+      await message.reply(`\u274C **SQL Error:** ${e.message}`);
+    }
+    return;
+  }
+  if (command === "vc" || command === "voice") {
+    if (!message.guild) return void await message.reply("\u274C This command must be used in a server.");
+    const me = message.guild.members.me;
+    if (!me?.voice?.channel) return void await message.reply("\u274C Bot is not currently in a voice channel.");
+    const text = `\u{1F399}\uFE0F **Voice Debugger**
+Channel: <#${me.voice.channel.id}> (\`${me.voice.channel.id}\`)
+Muted: ${me.voice.mute} | Deafened: ${me.voice.deaf}
+Session ID: \`${me.voice.sessionId || "None"}\``;
+    await message.reply(text);
+    return;
+  }
+  await message.reply(`\u2753 Unknown ${prefix} command. Available: \`js, sh, git, cat, curl, su, in, source, debug, reload, tasks, cancel, sync, sql, vc\``);
+}
+async function sendPaginatedText(message2, header, content, language = "") {
+  const maxLength = 1900;
+  if (content.length <= maxLength) {
+    await message2.reply(`${header}\`\`\`${language}
+${content}
+\`\`\``);
+    return;
+  }
+  const chunks = [];
+  for (let i = 0; i < content.length; i += maxLength) {
+    chunks.push(content.substring(i, i + maxLength));
+  }
+  let index = 0;
+  const reply = await message2.reply(`${header}\`\`\`${language}
+${chunks[index]}
+\`\`\`
+*Page 1 of ${chunks.length}*`);
+  await reply.react("\u25C0\uFE0F");
+  await reply.react("\u25B6\uFE0F");
+  await reply.react("\u23F9\uFE0F");
+  const collector = reply.createReactionCollector({
+    filter: (reaction, user) => ["\u25C0\uFE0F", "\u25B6\uFE0F", "\u23F9\uFE0F"].includes(reaction.emoji.name) && user.id === message2.author.id,
+    time: 12e4
+  });
+  collector.on("collect", async (reaction, user) => {
+    await reaction.users.remove(user.id).catch(() => null);
+    if (reaction.emoji.name === "\u25C0\uFE0F") {
+      index = index > 0 ? index - 1 : index;
+    } else if (reaction.emoji.name === "\u25B6\uFE0F") {
+      index = index < chunks.length - 1 ? index + 1 : index;
+    } else if (reaction.emoji.name === "\u23F9\uFE0F") {
+      collector.stop();
+      return;
+    }
+    await reply.edit(`${header}\`\`\`${language}
+${chunks[index]}
+\`\`\`
+*Page ${index + 1} of ${chunks.length}*`);
+  });
+  collector.on("end", () => {
+    reply.reactions.removeAll().catch(() => null);
+  });
+}
+
+// src/client.ts
+var DJSNextClient = class extends Client {
+  commands;
+  components;
+  cooldowns;
+  config = {};
+  t = translate;
+  db;
+  _commandsDir;
+  _eventsDir;
+  _componentsDir;
+  _tasksDir;
+  _localesDir;
+  _clientId;
+  _guildId;
+  _developers;
+  _middleware;
+  constructor(options) {
+    super(options);
+    this.commands = new Collection3();
+    this.components = new Collection3();
+    this.cooldowns = new Collection3();
+    this._commandsDir = options.commandsDir ? path6.resolve(process.cwd(), options.commandsDir) : void 0;
+    this._eventsDir = options.eventsDir ? path6.resolve(process.cwd(), options.eventsDir) : void 0;
+    this._componentsDir = options.componentsDir ? path6.resolve(process.cwd(), options.componentsDir) : void 0;
+    this._tasksDir = options.tasksDir ? path6.resolve(process.cwd(), options.tasksDir) : void 0;
+    this._clientId = options.clientId;
+    this._guildId = options.guildId;
+    this._developers = options.developers || [];
+    this._middleware = options.middleware;
+    this.attachCoreListeners();
+  }
+  attachCoreListeners() {
+    this.on("interactionCreate", async (interaction) => {
+      if (this._middleware) {
+        try {
+          const shouldContinue = await this._middleware(interaction, this);
+          if (!shouldContinue) return;
+        } catch (error) {
+          console.error(`[djs-next] Middleware error:`, error);
+          return;
+        }
+      }
+      if (interaction.isChatInputCommand()) {
+        let commandKey = interaction.commandName;
+        const group = interaction.options.getSubcommandGroup(false);
+        const sub = interaction.options.getSubcommand(false);
+        if (group) commandKey += ` ${group}`;
+        if (sub) commandKey += ` ${sub}`;
+        const command2 = this.commands.get(commandKey);
+        if (!command2 || !command2.execute) return;
+        if (command2.developerOnly && !this._developers.includes(interaction.user.id)) {
+          return interaction.reply({ content: "Only developers can use this command.", ephemeral: true });
+        }
+        if (command2.guildOnly && !interaction.inGuild()) {
+          return interaction.reply({ content: "This command can only be used in a server.", ephemeral: true });
+        }
+        if (command2.userPermissions && interaction.memberPermissions) {
+          const missing = interaction.memberPermissions.missing(command2.userPermissions);
+          if (missing.length > 0) {
+            return interaction.reply({ content: `You are missing permissions: \`${missing.join(", ")}\``, ephemeral: true });
+          }
+        }
+        if (command2.botPermissions && interaction.guild?.members.me?.permissions) {
+          const missing = interaction.guild.members.me.permissions.missing(command2.botPermissions);
+          if (missing.length > 0) {
+            return interaction.reply({ content: `I am missing permissions to run this: \`${missing.join(", ")}\``, ephemeral: true });
+          }
+        }
+        if (command2.cooldown) {
+          if (!this.cooldowns.has(commandKey)) this.cooldowns.set(commandKey, new Collection3());
+          const now = Date.now();
+          const timestamps = this.cooldowns.get(commandKey);
+          const cooldownAmount = command2.cooldown * 1e3;
+          if (timestamps.has(interaction.user.id)) {
+            const expirationTime = timestamps.get(interaction.user.id) + cooldownAmount;
+            if (now < expirationTime) {
+              return interaction.reply({
+                content: `Please wait, you are on a cooldown. You can use it again <t:${Math.round(expirationTime / 1e3)}:R>.`,
+                ephemeral: true
+              });
+            }
+          }
+          timestamps.set(interaction.user.id, now);
+          setTimeout(() => timestamps.delete(interaction.user.id), cooldownAmount);
+        }
+        try {
+          await command2.execute(interaction, this);
+        } catch (error) {
+          console.error(`[djs-next] Error executing command: "${commandKey}"`, error);
+          const msg = { content: "We ran into an internal error executing this command. The developers have been notified.", ephemeral: true };
+          if (interaction.replied || interaction.deferred) await interaction.followUp(msg).catch(() => null);
+          else await interaction.reply(msg).catch(() => null);
+        }
+      }
+      if (interaction.isAutocomplete()) {
+        let commandKey = interaction.commandName;
+        const group = interaction.options.getSubcommandGroup(false);
+        const sub = interaction.options.getSubcommand(false);
+        if (group) commandKey += ` ${group}`;
+        if (sub) commandKey += ` ${sub}`;
+        const command2 = this.commands.get(commandKey);
+        if (command2 && command2.autocomplete) {
+          try {
+            await command2.autocomplete(interaction, this);
+          } catch (error) {
+            console.error(`[djs-next] Error executing autocomplete for: "${commandKey}"`, error);
+          }
+        }
+      }
+      if (interaction.isMessageComponent() || interaction.isModalSubmit()) {
+        if (interaction.customId === "djs_prev" || interaction.customId === "djs_next") return;
+        let component = this.components.get(interaction.customId);
+        let params = {};
+        if (!component) {
+          for (const [key, comp] of this.components) {
+            if (!key.includes("[")) continue;
+            const escapedKey = key.replace(/[.*+?^${}()|\\-]/g, "\\$&");
+            const regexStr = "^" + escapedKey.replace(/\\\[([^\]]+)\\\]/g, "(?<$1>.+)") + "$";
+            const match = interaction.customId.match(new RegExp(regexStr));
+            if (match) {
+              component = comp;
+              if (match.groups) params = match.groups;
+              break;
+            }
+          }
+        }
+        if (component) {
+          try {
+            await component.execute(interaction, this, params);
+          } catch (error) {
+            console.error(`[djs-next] Error executing component: "${interaction.customId}"`, error);
+            const msg = { content: "We ran into an internal error executing this component.", ephemeral: true };
+            if (interaction.replied || interaction.deferred) await interaction.followUp(msg).catch(() => null);
+            else await interaction.reply(msg).catch(() => null);
+          }
+        }
+      }
+    });
+  }
+  async start(token) {
+    if (!token) throw new Error("[djs-next] A token must be provided to start the bot.");
+    this.config = await loadConfig();
+    this._guildId = this._guildId || this.config.devGuildId;
+    if (!this._commandsDir && this.config.directories?.commands) this._commandsDir = path6.resolve(process.cwd(), this.config.directories.commands);
+    if (!this._eventsDir && this.config.directories?.events) this._eventsDir = path6.resolve(process.cwd(), this.config.directories.events);
+    if (!this._componentsDir && this.config.directories?.components) this._componentsDir = path6.resolve(process.cwd(), this.config.directories.components);
+    if (!this._tasksDir && this.config.directories?.tasks) this._tasksDir = path6.resolve(process.cwd(), this.config.directories.tasks);
+    if (!this._localesDir && this.config.directories?.locales) this._localesDir = path6.resolve(process.cwd(), this.config.directories.locales);
+    if (this._localesDir) loadLocales(this._localesDir, this.config.defaultLocale);
+    if (!this._middleware) {
+      const exts = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"];
+      const cwd = process.cwd();
+      for (const ext of exts) {
+        const mwPath = path6.join(cwd, `middleware${ext}`);
+        if (fs8.existsSync(mwPath)) {
+          try {
+            const mwModule = await import(pathToFileURL6(mwPath).href);
+            this._middleware = mwModule.default?.middleware || mwModule.middleware || mwModule.default || mwModule;
+            if (this._middleware) {
+              console.log(`[djs-next] Loaded global middleware.`);
+              break;
+            }
+          } catch (err) {
+            console.error(`[djs-next] Error loading middleware file ${mwPath}:`, err);
+          }
+        }
+      }
+    }
+    if (this._eventsDir) await loadEvents(this, this._eventsDir);
+    if (this._componentsDir) this.components = await loadComponents(this._componentsDir);
+    if (this._tasksDir) await loadTasks(this, this._tasksDir);
+    if (this._commandsDir) {
+      if (!this._clientId) throw new Error("[djs-next] You must provide a clientId to deploy commands.");
+      this.commands = await loadAndDeployCommands(this._commandsDir, token, this._clientId, this._guildId);
+    }
+    await this.login(token);
+    console.log(`[djs-next] Bot is ready and logged in as ${this.user?.tag}!`);
+  }
+  enableDevTools(prefix2 = "dnxt") {
+    if (prefix2 !== "dnxt" && prefix2 !== "nxt") {
+      throw new Error(`[djs-next] Developer Tools prefix must be either 'dnxt' or 'nxt'. Received: ${prefix2}`);
+    }
+    this.on("messageCreate", async (message2) => {
+      await handleDNXT(message2, this, prefix2);
+    });
+    console.log(`[djs-next] \u{1F6E0}\uFE0F Developer Tools enabled. Use "${prefix2}" in chat. Ensure MessageContent intent is enabled!`);
+  }
+  async enableHMR() {
+    try {
+      const chokidar = await import("chokidar");
+      console.log(`[djs-next] \u{1F504} HMR Enabled. Watching for file changes...`);
+      const watcher = chokidar.watch([
+        this._commandsDir,
+        this._eventsDir,
+        this._componentsDir,
+        this._localesDir
+      ].filter(Boolean), { ignoreInitial: true });
+      watcher.on("change", async (filePath) => {
+        console.log(`[djs-next] \u267B\uFE0F File changed: ${filePath}. Reloading...`);
+        this.removeAllListeners();
+        this.commands.clear();
+        this.components.clear();
+        this.attachCoreListeners();
+        if (this._eventsDir) await loadEvents(this, this._eventsDir);
+        if (this._componentsDir) this.components = await loadComponents(this._componentsDir);
+        if (this._commandsDir && this._clientId) {
+          this.commands = await loadAndDeployCommands(this._commandsDir, this.token, this._clientId, this._guildId);
+        }
+        if (this._localesDir) loadLocales(this._localesDir, this.config.defaultLocale);
+        console.log(`[djs-next] \u2705 Hot Reload complete.`);
+      });
+    } catch (e) {
+      console.warn(`[djs-next] chokidar not installed. HMR is disabled. Please run "npm install chokidar" to use this feature.`);
+    }
+  }
+};
+
+// src/utils/paginate.ts
+import {
+  ActionRowBuilder,
+  ButtonBuilder,
+  ButtonStyle
+} from "discord.js";
+async function paginate(interaction, pages, time = 6e4) {
+  if (!interaction.deferred && !interaction.replied) {
+    await interaction.deferReply();
+  }
+  if (pages.length === 1) {
+    return interaction.editReply({ embeds: [pages[0]], components: [] });
+  }
+  let index = 0;
+  const prevButton = new ButtonBuilder().setCustomId("djs_prev").setLabel("Previous").setStyle(ButtonStyle.Primary).setDisabled(true);
+  const nextButton = new ButtonBuilder().setCustomId("djs_next").setLabel("Next").setStyle(ButtonStyle.Primary);
+  const row = new ActionRowBuilder().addComponents(prevButton, nextButton);
+  const message2 = await interaction.editReply({
+    embeds: [pages[index]],
+    components: [row]
+  });
+  const collector = message2.createMessageComponentCollector({
+    filter: (i) => i.user.id === interaction.user.id,
+    time
+  });
+  collector.on("collect", async (i) => {
+    if (i.customId === "djs_prev") {
+      index = index > 0 ? index - 1 : index;
+    } else if (i.customId === "djs_next") {
+      index = index < pages.length - 1 ? index + 1 : index;
+    }
+    prevButton.setDisabled(index === 0);
+    nextButton.setDisabled(index === pages.length - 1);
+    await i.update({
+      embeds: [pages[index]],
+      components: [new ActionRowBuilder().addComponents(prevButton, nextButton)]
+    });
+  });
+  collector.on("end", async () => {
+    prevButton.setDisabled(true);
+    nextButton.setDisabled(true);
+    await interaction.editReply({
+      components: [new ActionRowBuilder().addComponents(prevButton, nextButton)]
+    }).catch(() => {
+    });
+  });
+}
+
+// src/index.ts
+export * from "discord.js";
+export {
+  DJSNextClient,
+  defineConfig,
+  getLocalesCache,
+  loadConfig,
+  loadLocales,
+  paginate,
+  translate
+};
+//# sourceMappingURL=index.mjs.map