djs-builder 0.5.42 → 0.6.0

package/handler/helper.js

@@ -0,0 +1,277 @@
+const { EmbedBuilder, WebhookClient } = require("discord.js");
+const Table = require("cli-table3");
+const chalk = require("chalk");
+const path = require("path");
+const fs = require("fs");
+const axios = require("axios");
+
+async function cooldowns(client, name, time, user) {
+  const cooldownKey = `${name}_${user.id}`;
+  const now = Date.now();
+
+  if (!client.cooldowns) client.cooldowns = new Map();
+
+  if (client.cooldowns.has(cooldownKey)) {
+    const expirationTime = client.cooldowns.get(cooldownKey);
+    if (now < expirationTime) {
+      const remaining = ((expirationTime - now) / 1000).toFixed(1);
+      return {
+        text: `⏳ انتظر ${remaining} ثانية قبل استخدام هذا الأمر مرة أخرى.`,
+        type: true,
+      };
+    }
+  }
+
+  client.cooldowns.set(cooldownKey, now + time * 1000);
+
+  setTimeout(() => client.cooldowns.delete(cooldownKey), time * 1000);
+
+  return {
+    type: false,
+  };
+}
+
+async function readFile(dir) {
+  if (!path.isAbsolute(dir)) {
+    dir = path.join(process.cwd(), dir);
+  }
+
+  let final_file_data = [];
+
+  const files = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (const file of files) {
+    const file_path = path.join(dir, file.name);
+
+    if (file.isDirectory()) {
+      const nested = await readFile(file_path);
+      final_file_data = final_file_data.concat(nested);
+    } else {
+      final_file_data.push({
+        name: file.name,
+        path: file_path,
+      });
+    }
+  }
+
+  return final_file_data;
+}
+
+async function terminalInfo(client, options, data) {
+  const firstTable = new Table({
+    head: [chalk.bold.blue("🧩 Info"), chalk.bold.green("📌 Value")],
+    colWidths: [30, 50],
+  });
+
+  const secondTable = new Table({
+    head: [chalk.bold.magenta("👤 Setting"), chalk.bold.cyan("🔧 Detail")],
+    colWidths: [30, 50],
+  });
+
+  const rowColors = [
+    chalk.cyanBright,
+    chalk.greenBright,
+    chalk.magentaBright,
+    chalk.blueBright,
+    chalk.yellowBright,
+    chalk.redBright,
+    chalk.whiteBright,
+    chalk.gray,
+    chalk.white,
+    chalk.green,
+  ];
+
+  firstTable.push(
+    [rowColors[0]("Name"), rowColors[0](client.user.username)],
+    [rowColors[1]("Users"), rowColors[1](client.users.cache.size)],
+    [rowColors[2]("Guilds"), rowColors[2](client.guilds.cache.size)],
+    [rowColors[3]("Channels"), rowColors[3](client.channels.cache.size)],
+    [rowColors[4]("Prefix Commands"), rowColors[4](data.prefix)],
+    [rowColors[5]("Slash Commands"), rowColors[5](data.slash)],
+    [rowColors[6]("Total Commands"), rowColors[6](data.slash + data.prefix)],
+    [rowColors[7]("Events"), rowColors[7](data.event)],
+    [rowColors[8]("Started At"), rowColors[8](new Date().toLocaleString())]
+  );
+
+  secondTable.push(
+    [rowColors[0]("Bot Owner"), rowColors[0](client.owner.id)],
+    [
+      rowColors[1]("Bot Invite"),
+      rowColors[1](
+        `https://discord.com/oauth2/authorize?client_id=${client.user.id}&permissions=8&integration_type=0&scope=bot`
+      ),
+    ],
+    [
+      rowColors[2]("Bot Status"),
+      rowColors[2](options.Status.status || "Not Defined"),
+    ],
+    [
+      rowColors[5]("Bot Activity"),
+      rowColors[5](
+        options.Status.activities
+          ? Array.isArray(options.Status.activities)
+            ? options.Status.activities[0]
+            : options.Status.activities
+          : "Not Defined"
+      ),
+    ]
+  );
+
+  if (options.database?.url) {
+    const result = await data_conecter(options.database.url);
+    if (result) {
+      secondTable.push([chalk.cyan("Database"), rowColors[9]("Connected")]);
+    }
+  }
+
+  console.log(chalk.bold.green("\n✅ Bot Information:\n"));
+  console.log(firstTable.toString());
+
+  console.log(chalk.bold.blue("\n⚙️ Developer Settings:\n"));
+  console.log(secondTable.toString());
+}
+
+async function data_conecter(url) {
+  try {
+    const mongoose = require("mongoose");
+    await mongoose.connect(url);
+    return true;
+  } catch (error) {
+    console.error("❌ فشل الاتصال بقاعدة البيانات:", error);
+    return false;
+  }
+}
+
+async function set_anticrash(data) {
+  const webhookURL = data.url,
+    id = data.mention_id;
+  if (!webhookURL)
+    return console.log(chalk.red("❌ Webhook URL is not defined."));
+
+  const crash = new WebhookClient({ url: webhookURL });
+
+  const types = {
+    error: {
+      title: "❌ Error",
+      color: "Red",
+    },
+    warn: {
+      title: "⚠️ Warning",
+      color: "Yellow",
+    },
+    info: {
+      title: "ℹ️ Info",
+      color: "Blue",
+    },
+  };
+
+  const send = async (error, type = "info") => {
+    const embed = new EmbedBuilder()
+      .setTitle(types[type].title)
+      .setDescription(`\`\`\`\n${error}\n\`\`\``)
+      .setColor(types[type].color)
+      .setTimestamp();
+
+    try {
+      await crash.send({
+        content: id ? `<@${id}>` : "",
+        embeds: [embed],
+      });
+      console.log(error);
+    } catch (e) {
+      console.error(chalk.red("❌ Error sending message to webhook:"), e);
+      console.log(error);
+    }
+  };
+
+  process.on("unhandledRejection", (error) => send(error, "error"));
+  process.on("uncaughtException", (error) => send(error, "error"));
+  process.on("uncaughtExceptionMonitor", (error) => send(error, "error"));
+  process.on("unhandledRejectionMonitor", (error) => send(error, "error"));
+  process.on("warning", (error) => send(error, "warn"));
+}
+
+async function cmd_log(client, data, commandName, channelId) {
+  const isSlash = !!data.user;
+  const user = isSlash ? data.user : data.author;
+  const channel = data.guild ? data.channel : "DM";
+  const messageUrl = data.message?.url || "—";
+
+  const logChannel = client.channels.cache.get(channelId);
+  if (!logChannel) return;
+
+  const embed = new EmbedBuilder()
+    .setTitle(isSlash ? "📘 Slash Command Log" : "📗 Prefix Command Log")
+    .setColor(isSlash ? "Green" : "Blue")
+    .addFields(
+      { name: "📝 Command", value: `\`${commandName}\``, inline: true },
+      {
+        name: "👤 User",
+        value: `${user.tag || user.username} (${user.id})`,
+        inline: true,
+      },
+      { name: "💬 Channel", value: `${channel}`, inline: true },
+      { name: "🔗 Message", value: `[Link](${messageUrl})`, inline: true },
+      {
+        name: "🕒 Date",
+        value: `<t:${Math.floor(Date.now() / 1000)}:F>`,
+        inline: true,
+      }
+    )
+    .setTimestamp();
+
+  logChannel.send({ embeds: [embed] }).catch(console.error);
+}
+
+//////////////////////////////////* Check update 🔼
+
+async function update(client, id, webhookURL) {
+  const { version, note: localNote } = require("../package.json");
+
+  const { data } = await axios.get(
+    `https://registry.npmjs.org/testsss-akazaz-lib/latest`
+  );
+  const new_version = data.version;
+  const note = data.discription || "";
+
+  if (
+    client.djs_builder_version &&
+    client.djs_builder_version === new_version
+  ) {
+    return;
+  }
+
+  if (new_version !== version) {
+    console.log(
+      chalk.yellow(
+        `⚠️ New version available: ${new_version} (Your version: ${version})`
+      )
+    );
+
+    const crash = new WebhookClient({ url: webhookURL });
+
+    const embed = new EmbedBuilder()
+      .setTitle("🎉 New version available")
+      .setDescription(
+        `${note}\n\n**Your version:** ${version} ⏰\n**New version:** ${new_version} 🚀\n- Try running \`npm i testsss-akazaz-lib@latest\` to update. ❤`
+      )
+      .setColor("Yellow")
+      .setTimestamp();
+
+    await crash.send({ content: `<@${id}>`, embeds: [embed] }).catch((e) => {});
+  } else if (note && note !== localNote) {
+    console.log(chalk.cyan("📝 New note available without version change:"));
+    console.log(note);
+  }
+
+  client.djs_builder_version = new_version;
+}
+
+module.exports = {
+  cooldowns,
+  readFile,
+  terminalInfo,
+  set_anticrash,
+  cmd_log,
+  update,
+};

package/handler/starter.js

@@ -0,0 +1,335 @@
+const {
+  readFile,
+  cooldowns,
+  terminalInfo,
+  set_anticrash,
+  cmd_log,
+  update
+} = require("./helper");
+let termenal = {
+  prefix: 0,
+  slash: 0,
+  event: 0,
+};
+
+async function starter(client, options) {
+  //////////////////////////////////////////! mine data !////////////////////////////////////////////////////////
+  const token = options.bot.token;
+  const ownerId = options.bot.ownerId;
+  const Status = options.Status || null;
+  const prefix = options.prefix || null;
+  const slash = options.slash || null;
+  const events = options.events || null;
+  const anticrash = options.anticrash || null;
+  const terminal_info = options.terminal || null;
+
+  if (terminal_info) {
+    console.log("🚀 Bot is starting...");
+  }
+
+  //////////////////////////////////////////* status set !////////////////////////////////////////////////////////
+  client.login(token);
+  client.once("ready", () => {
+    if (Status) {
+      const activities = Array.isArray(Status.activities)
+        ? Status.activities
+        : [Status.activities];
+      const type = Status.type ?? 0;
+      const time = Status.time ?? 20000;
+      const presence = Status.status ?? "online";
+
+      let index = 0;
+
+      if (Status.url) {
+        setInterval(() => {
+          client.user.setPresence({
+            activities: [
+              { name: activities[index], type },
+              { type: 1, url: Status.url },
+            ],
+            status: presence,
+          });
+        }, 60 * 1000);
+      } else {
+        client.user.setPresence({
+          activities: [{ name: activities[index], type }],
+          status: presence,
+        });
+      }
+
+      if (activities.length > 1) {
+        setInterval(() => {
+          index = (index + 1) % activities.length;
+          client.user.setPresence({
+            activities: [{ name: activities[index], type }],
+            status: presence,
+          });
+        }, time);
+      }
+    }
+  });
+
+  //////////////////////////////////////////? Prefix Loader ////////////////////////////////////////////////////////
+
+  if (prefix) {
+    const prefix_files = await readFile(prefix.path);
+    client.prefixCommands = new Map();
+
+    for (const file of prefix_files) {
+      const command = require(file.path);
+
+      if (!command.name || typeof command.run !== "function") continue;
+
+      const commandWithMeta = {
+        ...command,
+        file_path: file.path,
+      };
+
+      client.prefixCommands.set(command.name, commandWithMeta);
+
+      if (Array.isArray(command.aliases)) {
+        for (const alias of command.aliases) {
+          client.prefixCommands.set(alias, commandWithMeta);
+        }
+      }
+
+      termenal.prefix++;
+    }
+  }
+
+  //////////////////////////////////////////? Slash Loader ////////////////////////////////////////////////////////
+
+  if (slash) {
+    const slash_files = await readFile(slash.path);
+    const validSlashCommands = slash_files
+      .map((f) => require(f.path))
+      .filter((cmd) => cmd.data && typeof cmd.run === "function");
+
+    client.slashCommands = new Map(
+      validSlashCommands.map((cmd) => [cmd.data.name, cmd])
+    );
+
+    termenal.slash = validSlashCommands.length;
+  }
+
+  //////////////////////////////////////////? Event Loader ////////////////////////////////////////////////////////
+
+  if (events) {
+    const event_files = await readFile(events.path);
+    for (const file of event_files) {
+      const event = require(file.path);
+
+      if (!event.name || typeof event.run !== "function") continue;
+
+      if (event.once) {
+        client.once(event.name, (...args) => {
+          if (typeof event.run === "function") {
+            event.run(...args);
+          } else if (typeof event.exports === "function") {
+            event.exports(...args);
+          }
+        });
+      } else {
+        client.on(event.name, (...args) => {
+          if (typeof event.run === "function") {
+            event.run(...args, client);
+          } else if (typeof event.exports === "function") {
+            event.exports(...args, client);
+          }
+        });
+      }
+
+      termenal.event++;
+    }
+  }
+
+  //////////////////////////////////////////* prefix run !////////////////////////////////////////////////////////
+
+  client.on("messageCreate", async (message) => {
+    if(!prefix) return
+    if (message.author.bot) return;
+
+    const content = message.content.trim();
+
+    let command_name = null;
+    let pre = false;
+
+    if (prefix && content.startsWith(prefix.prefix)) {
+      command_name = content.slice(prefix.prefix.length).split(/\s+/)[0];
+      pre = true;
+    } else {
+      command_name = content.split(/\s+/)[0];
+    }
+
+    if (!command_name) return;
+    const command = client.prefixCommands.get(command_name);
+
+    if (!command) return;
+
+    const cooldown = await cooldowns(
+      client,
+      command.name,
+      command.cooldown || 0,
+      message.author
+    );
+    if (cooldown.type) return message.reply(cooldown.text);
+
+    if (!pre && !command.fastUse) return;
+
+    if (command.guildOnly && !message.guild) return;
+    if (command.dmOnly && message.guild) return;
+    if (
+      command.devOnly &&
+      client.ownerId &&
+      message.author.id !== client.ownerId
+    )
+      return;
+    if (
+      command.ownerOnly &&
+      message.guild &&
+      message.author.id !== message.guild.ownerId
+    )
+      return;
+
+    if (
+      command.Permissions &&
+      message.member &&
+      !command.Permissions.every((perm) => message.member.permissions.has(perm))
+    )
+      return;
+
+    const args = content.split(/\s+/).slice(1);
+
+    if (options.prefix.log) {
+      await cmd_log(client, message, command.name, message.channel.id);
+    }
+
+    try {
+      if (typeof command.run === "function") {
+        await command.run(client ,message, args);
+      } else if (typeof command.exports === "function") {
+        await command.exports(client, message, args);
+      }
+    } catch (e) {
+      console.error(`❌ Error in command ${command.name}:`, e);
+    }
+  });
+
+  //////////////////////////////////////////* slash run !////////////////////////////////////////////////////////
+
+  client.on("interactionCreate", async (interaction) => {
+    if (!interaction.isCommand()) return;
+
+    const command = client.slashCommands.get(interaction.commandName);
+    if (!command) return;
+
+    if (command.cooldown) {
+      const cooldown = await cooldowns(
+        client,
+        command.name,
+        command.cooldown,
+        interaction.user
+      );
+      if (cooldown.type) return interaction.reply(cooldown.text);
+    }
+
+    if (
+      command.ownerOnly &&
+      interaction.guild &&
+      interaction.user.id !== interaction.guild.ownerId
+    ) {
+      return interaction.reply({
+        content: "`❌` هذا الأمر محصور لصاحب السيرفر فقط!",
+        ephemeral: true,
+      });
+    }
+
+    if (
+      command.devOnly &&
+      client.ownerId &&
+      interaction.user.id !== client.ownerId
+    ) {
+      return interaction.reply({
+        content: "`❌` هذا الأمر محصور لصاحب البوت فقط!",
+        ephemeral: true,
+      });
+    }
+
+    if (command.guildOnly && !interaction.guild) {
+      return interaction.reply({
+        content: "`❌` هذا الأمر محصور لسيرفرات فقط!",
+        ephemeral: true,
+      });
+    }
+
+    if (command.dmOnly && interaction.guild) {
+      return interaction.reply({
+        content: "`❌` هذا الأمر محصور لمحادثات الخاصة فقط!",
+        ephemeral: true,
+      });
+    }
+
+    if (
+      command.Permissions &&
+      interaction.member &&
+      !command.Permissions.every((perm) =>
+        interaction.member.permissions.has(perm)
+      )
+    ) {
+      return interaction.reply({
+        content: "`❌` أنت لا تملك صلاحيات كافية لتنفيذ هذا الأمر.",
+        ephemeral: true,
+      });
+    }
+
+    if (options.slash.log) {
+      await cmd_log(client, interaction, command.name, interaction.channelId);
+    }
+    try {
+      if (typeof command.run === "function") {
+        await command.run(interaction, client);
+      } else if (typeof command.exports === "function") {
+        await command.exports(interaction, client);
+      }
+    } catch (error) {
+      console.error(error);
+      if (interaction.replied || interaction.deferred) {
+        await interaction.followUp({
+          content: "`❌` حدث خطأ أثناء تنفيذ الأمر.",
+          ephemeral: true,
+        });
+      } else {
+        await interaction.reply({
+          content: "`❌` حدث خطأ أثناء تنفيذ الأمر.",
+          ephemeral: true,
+        });
+      }
+    }
+  });
+
+  if (anticrash) {
+    await set_anticrash(anticrash);
+  }
+
+  client.once("ready", async () => {
+    if (ownerId) client.owner = await client.users.fetch(ownerId);
+
+    if (terminal_info) {
+      await terminalInfo(client, options, termenal);
+    }
+  });
+
+
+
+setInterval(() => {
+  update(client,ownerId, anticrash.url);
+}, 1000 * 60 * 60);
+
+
+
+}
+
+const { Wait, CreateBar, CreateRow } = require("../function/function");
+const { log } = require("../function/log");
+
+module.exports = { starter , log, Wait, CreateBar, CreateRow };

package/package.json

@@ -1,48 +1,16 @@
+
 {
   "name": "djs-builder",
-  "version": "0.5.42",
+  "version": "0.6.0",
   "description": "Discord.js bot builder. Supports Ts and Js.",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "scripts": {
-    "dev": "ts-node lib/index.ts",
-    "start": "node dist/index.js",
-    "build": "tsc --build --force"
-  },
-  "author": "zenith-79",
-  "license": "MIT",
-  "keywords": [
-    "discord",
-    "discord bots",
-    "discord.js",
-    "bots",
-    "bot builder",
-    "handler",
-    "slash",
-    "prefix",
-    "slash commands",
-    "prefix commands",
-    "commands",
-    "events",
-    "logger",
-    "database",
-    "verse",
-    "mongodb"
-  ],
+  "main": "handler/starter.js",
   "dependencies": {
-    "@napi-rs/canvas": "^0.1.55",
-    "@types/figlet": "^1.5.8",
-    "cli-table": "^0.3.11",
-    "colorette": "^2.0.20",
-    "discord.js": "^14.15.3",
-    "djs-builder": "^0.4.10",
-    "figlet": "^1.7.0",
-    "mongodb": "^6.5.0",
-    "verse.db": "^2.0.4"
-  },
-  "devDependencies": {
-    "@types/cli-table": "^0.3.4",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.4.5"
+    "axios": "^1.11.0",
+    "chalk": "^4.1.2",
+    "cli-table3": "^0.6.5",
+    "discord-inviter": "^0.9.3",
+    "discord.js": "^14.21.0",
+    "mongoose": "^8.17.0",
+    "testsss-akazaz-lib": "^0.0.13"
   }
 }