xernerx 2.7.5 → 3.0.1

package/dist/utils/ClientUtil.js

@@ -0,0 +1,232 @@
+export class ClientUtil {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    uptime(timestamp) {
+        if (!timestamp)
+            timestamp = this.client.uptime || 0;
+        let totalSeconds = timestamp / 1000;
+        let years = Math.floor(totalSeconds / 31536000);
+        totalSeconds %= 31536000;
+        let days = Math.floor(totalSeconds / 86400);
+        totalSeconds %= 86400;
+        let hours = Math.floor(totalSeconds / 3600);
+        totalSeconds %= 3600;
+        let minutes = Math.floor(totalSeconds / 60);
+        let seconds = Math.floor(totalSeconds % 60);
+        if (years >= 1)
+            return `${years}y ${days}d ${hours}h ${minutes}m`;
+        else if (days >= 1)
+            return `${days}d ${hours}h ${minutes}m`;
+        else if (hours >= 1)
+            return `${hours}h ${minutes}m`;
+        else if (minutes >= 1)
+            return `${minutes}m ${seconds}s`;
+        else
+            return `${seconds}s`;
+    }
+    getSubcommands(name) {
+        if (!name || typeof name !== "string")
+            throw new Error(`Expected name to be of type string, received ${typeof name} instead!`);
+        const commands = [];
+        this.getAllCommands()
+            .filter((c) => (c.data?.name?.toLowerCase() || c.name?.toLowerCase()) ==
+            name?.toLowerCase())
+            .map((c) => {
+            if (c?.data?.options?.length > 0) {
+                c?.data?.options?.map((option) => {
+                    if (!option?.type) {
+                        if (option?.options?.length > 0) {
+                            option?.options?.map((opt) => {
+                                if (!opt.type) {
+                                    commands.push({
+                                        name: c.data.name,
+                                        formattedName: `${c.data.name} ${option.name} ${opt.name}`,
+                                        description: opt.description,
+                                        category: c.category || null,
+                                        commandType: c.commandType,
+                                    });
+                                }
+                                else {
+                                    commands.push({
+                                        name: c.data.name,
+                                        formattedName: `${c.data.name} ${option.name}`,
+                                        description: option.description,
+                                        category: c.category || null,
+                                        commandType: c.commandType,
+                                    });
+                                }
+                            });
+                        }
+                        else {
+                            commands.push({
+                                name: c.data.name,
+                                formattedName: `${c.data.name} ${option.name}`,
+                                description: option.description,
+                                category: c.category || null,
+                                commandType: c.commandType,
+                            });
+                        }
+                    }
+                    else {
+                        commands.push({
+                            name: c.data.name,
+                            formattedName: `${c.data.name}`,
+                            description: c.data.description,
+                            category: c.category || null,
+                            commandType: c.commandType,
+                        });
+                    }
+                });
+            }
+            else {
+                commands.push({
+                    name: c.data?.name || c.name,
+                    formattedName: `${c.data?.name || c.name}`,
+                    description: c.data?.description || c.description,
+                    category: c.category || null,
+                    commandType: c.commandType,
+                });
+            }
+        });
+        return commands;
+    }
+    isOwner(userId) {
+        if (!userId)
+            throw new Error("No ID specified");
+        let owners = this.client.settings.ownerId;
+        if (!owners)
+            return false;
+        if (typeof owners === "string")
+            owners = [owners];
+        return owners.includes(userId);
+    }
+    getAllCommands() {
+        const cmds = [];
+        for (const commands of Object.values(this.client.commands)) {
+            commands.map((cmd) => cmds.push(cmd));
+        }
+        return cmds;
+    }
+    getAllMessageCommands() {
+        const cmds = [];
+        this.client.commands.message.map((cmd) => cmds.push(cmd));
+        return cmds;
+    }
+    getAllSlashCommands() {
+        const cmds = [];
+        this.client.commands.slash.map((cmd) => cmds.push(cmd));
+        return cmds;
+    }
+    getAllContextCommands() {
+        const cmds = [];
+        this.client.commands.context.map((cmd) => cmds.push(cmd));
+        return cmds;
+    }
+    setPresence(options) {
+        const client = this.client;
+        function pres() {
+            client.user?.setPresence({
+                activities: [
+                    {
+                        name: options.text || undefined,
+                        type: options.type || undefined,
+                        url: options.link || undefined,
+                    },
+                ],
+                status: options.status || undefined,
+            });
+        }
+        pres();
+        if (options.interval) {
+            setInterval(() => {
+                pres();
+            }, options.interval);
+        }
+    }
+    getCooldowns(id, command) {
+        let cooldowns = [];
+        for (const [key, value] of Object.entries(this.client.cache)) {
+            if (![
+                "cooldowns",
+                "messageCommands",
+                "slashCommands",
+                "contextCommands",
+                "commands",
+            ].includes(key))
+                continue;
+            if (key === "commands") {
+                if (command) {
+                    value.map((x) => {
+                        const name = x.name.split(/-/);
+                        name.pop();
+                        if (name.join("-") === id + "-" + command) {
+                            cooldowns.push(x);
+                        }
+                    });
+                }
+                else {
+                    value.map((x) => {
+                        if (x.name.split(/-/).shift() === id) {
+                            cooldowns.push(x);
+                        }
+                    });
+                }
+            }
+            else {
+                if (value.has(id)) {
+                    const x = value.get(id);
+                    cooldowns.push(x);
+                }
+            }
+        }
+        return cooldowns;
+    }
+    getCooldownTimers(id, command) {
+        let cooldowns = [];
+        for (const [key, value] of Object.entries(this.client.cache)) {
+            if (![
+                "cooldowns",
+                "messageCommands",
+                "slashCommands",
+                "contextCommands",
+                "commands",
+            ].includes(key))
+                continue;
+            if (key === "commands") {
+                if (command) {
+                    value.map((x) => {
+                        const name = x.name.split(/-/);
+                        name.pop();
+                        if (name.join("-") === id + "-" + command) {
+                            cooldowns.push({ [x.commandName]: x.endsAt - Date.now() });
+                        }
+                    });
+                }
+                else {
+                    value.map((x) => {
+                        if (x.name.split(/-/).shift() === id) {
+                            cooldowns.push({ [x.commandName]: x.endsAt - Date.now() });
+                        }
+                    });
+                }
+            }
+            else {
+                if (value.has(id)) {
+                    const x = value.get(id);
+                    cooldowns.push({ [key]: x.endsAt - Date.now() });
+                }
+            }
+        }
+        const sort = cooldowns
+            .map((x) => Object.entries(x).shift())
+            .sort((a, b) => b[1] - a[1]);
+        cooldowns = [];
+        sort.map(([key, value]) => cooldowns.push({ [key]: value }));
+        return cooldowns;
+    }
+    async defer(time) {
+        return new Promise((resolve) => setTimeout(resolve, time || 0));
+    }
+}

package/dist/utils/CommandUtil.d.ts

@@ -0,0 +1,38 @@
+import { ActionRowBuilder, ButtonBuilder, EmbedBuilder, Interaction, Message, MessagePayload } from "discord.js";
+import XernerxClient from "../client/XernerxClient.js";
+import { XernerxMessage } from "../interfaces/HandlerInterfaces.js";
+interface ButtonOptions {
+    index?: number;
+    buttons?: Array<string>;
+    reply?: boolean;
+    row?: ActionRowBuilder;
+    component?: ButtonBuilder;
+    components?: object[];
+    id?: string;
+    filter?: any;
+    time?: number;
+    ephemeral?: boolean;
+}
+export declare class MessageCommandUtil {
+    #private;
+    client: XernerxClient;
+    message: XernerxMessage;
+    constructor(client: XernerxClient, message: Message & XernerxMessage);
+    reply(content: MessagePayload | string): Promise<Message<boolean> | undefined>;
+    send(content: MessagePayload | string): Promise<Message<true> | Message<false> | undefined>;
+    defer(time: number): Promise<unknown>;
+    getCommands(): import("@discordjs/collection").Collection<string, import("../main.js").MessageCommand>;
+    isOwner(): boolean;
+}
+export declare class InteractionCommandUtil {
+    #private;
+    client: XernerxClient;
+    interaction: any;
+    constructor(client: XernerxClient, interaction: Interaction);
+    reply(content: MessagePayload | string): any;
+    defer(time: number): Promise<unknown>;
+    getCommands(): import("@discordjs/collection").Collection<string, object>;
+    buttonPaginator(embeds: Array<EmbedBuilder>, options: ButtonOptions): void;
+    isOwner(): boolean;
+}
+export {};

package/dist/utils/CommandUtil.js

@@ -0,0 +1,238 @@
+import { ActionRowBuilder, ButtonBuilder, ButtonStyle, EmbedBuilder, SelectMenuBuilder, } from "discord.js";
+export class MessageCommandUtil {
+    client;
+    message;
+    constructor(client, message) {
+        this.client = client;
+        this.message = message;
+    }
+    async reply(content) {
+        if (this.client.cache.messages.has(this.message.id))
+            var existingMessage = this.client.cache.messages.get(this.message.id);
+        if (!existingMessage) {
+            const msg = await this.message.reply(content);
+            this.message.response = msg.id;
+            if (this.client.handlerOptions.message?.handleEdits ||
+                this.client.handlerOptions.message?.handleDeletes) {
+                this.client.cache.messages.set(this.message.id, this.message);
+                setInterval(() => {
+                    this.client.cache.messages.delete(this.message.id);
+                }, this.client.settings.cooldown?.cache || 300000);
+            }
+            return msg;
+        }
+        if (existingMessage && this.client.handlerOptions.message?.handleEdits) {
+            try {
+                const msg = await this.message.channel.messages.fetch(existingMessage.response);
+                msg.edit(content);
+                return msg;
+            }
+            catch {
+                const msg = await this.message.reply(content);
+                this.message.response = msg.id;
+                if (this.client.handlerOptions.message?.handleEdits ||
+                    this.client.handlerOptions.message?.handleDeletes) {
+                    this.client.cache.messages.set(this.message.id, this.message);
+                    setInterval(() => {
+                        this.client.cache.messages.delete(this.message.id);
+                    }, this.client.settings.cooldown?.cache || 300000);
+                }
+            }
+        }
+    }
+    async send(content) {
+        if (this.client.cache.messages.has(this.message.id))
+            var existingMessage = this.client.cache.messages.get(this.message.id);
+        if (!existingMessage) {
+            const msg = await this.message.channel.send(content);
+            this.message.response = msg.id;
+            if (this.client.handlerOptions.message?.handleEdits ||
+                this.client.handlerOptions.message?.handleDeletes) {
+                this.client.cache.messages.set(this.message.id, this.message);
+                setInterval(() => {
+                    this.client.cache.messages.delete(this.message.id);
+                }, this.client.settings.cooldown?.cache || 300000);
+            }
+            return msg;
+        }
+        if (existingMessage && this.client.handlerOptions.message?.handleEdits) {
+            try {
+                const msg = await this.message.channel.messages.fetch(existingMessage.response);
+                msg.edit(content);
+                return msg;
+            }
+            catch {
+                const msg = await this.message.channel.send(content);
+                this.message.response = msg.id;
+                if (this.client.handlerOptions.message?.handleEdits ||
+                    this.client.handlerOptions.message?.handleDeletes) {
+                    this.client.cache.messages.set(this.message.id, this.message);
+                    setInterval(() => {
+                        this.client.cache.messages.delete(this.message.id);
+                    }, this.client.settings.cooldown?.cache || 300000);
+                }
+            }
+        }
+    }
+    async defer(time) {
+        return new Promise((resolve) => setTimeout(resolve, time));
+    }
+    getCommands() {
+        return this.client.commands.message;
+    }
+    #getCommandName() { }
+    #selectMenuPaginator(embeds, options) { }
+    #buttonPaginator(embeds, options) { }
+    #buttonMenuPaginator(embeds, options) { }
+    isOwner() {
+        return this.client.util.isOwner(this.message.author.id);
+    }
+    #createModal() { }
+}
+export class InteractionCommandUtil {
+    client;
+    interaction;
+    constructor(client, interaction) {
+        this.client = client;
+        this.interaction = interaction;
+    }
+    reply(content) {
+        return this.interaction.replied || this.interaction.deferred
+            ? this.interaction.editReply(content)
+            : this.interaction.reply(content);
+    }
+    async defer(time) {
+        return new Promise((resolve) => setTimeout(resolve, time));
+    }
+    getCommands() {
+        if (this.interaction.commandType === 1)
+            return this.client.commands.slash;
+        else
+            return this.client.commands.context;
+    }
+    #getCommandName() { }
+    #selectMenuPaginator(embeds, options) {
+        if (!Array.isArray(embeds))
+            throw new Error(`Expected embeds to be of type array, received ${typeof embeds} instead.`);
+        if (embeds.length > 25)
+            throw new Error(`Max select menu length is 25.`);
+        if (typeof options !== "object")
+            options = {};
+        if (!Array.isArray(options.components))
+            options.components = [];
+        if (!options.index) {
+            options.index = new EmbedBuilder().setTitle("Index").setColor("Random");
+            for (const embed of embeds) {
+                options.index.addFields([
+                    {
+                        name: embed.data.title || "No Name",
+                        value: embed.data.description || "Page",
+                        inline: embeds.length > 25 / 2 ? true : false,
+                    },
+                ]);
+            }
+        }
+        if (!options.row) {
+            options.row = new ActionRowBuilder();
+            if (!options.id)
+                options.id = `${this.interaction.id}-menu`;
+            options.component = new SelectMenuBuilder()
+                .setCustomId(options.id)
+                .setMaxValues(1)
+                .setMinValues(1)
+                .setPlaceholder("Select a page.")
+                .addOptions({ label: "index", value: "index" });
+            embeds.map((embed, i = 0) => { });
+            options.row.addComponents(options.component);
+        }
+        const content = {
+            embeds: [options.index],
+            components: [options.component, ...options.components],
+            ephemeral: !!options.ephemeral,
+        };
+        options.reply === undefined || options.reply === true
+            ? this.interaction.util.reply(content)
+            : this.interaction.channel.send(content);
+    }
+    buttonPaginator(embeds, options) {
+        if (!Array.isArray(embeds))
+            throw new Error(`Expected embeds to be of type array, received ${typeof embeds} instead.`);
+        if (embeds.length <= 0)
+            throw new Error(`The minimum embeds is 1.`);
+        if (typeof options !== "object")
+            options = {};
+        if (!Array.isArray(options.components))
+            options.components = [];
+        if (!options.row) {
+            options.row = new ActionRowBuilder();
+            if (!options.id)
+                options.id = `${this.interaction.id}-menu`;
+        }
+        if (!options.buttons)
+            options.buttons = ["⏮️", "◀️", "⏹️", "▶️", "⏭️"];
+        for (const button of options.buttons) {
+            options.row.addComponents(new ButtonBuilder()
+                .setCustomId(`${this.interaction.id}-${options.buttons.indexOf(button)}`)
+                .setEmoji(button)
+                .setStyle(ButtonStyle.Primary));
+        }
+        let embed = embeds[options.index || 0];
+        const content = {
+            embeds: [embed],
+            components: [options.row, ...options.components],
+            ephemeral: !!options.ephemeral,
+        };
+        (options.reply === undefined || options.reply === true
+            ? this.interaction.util.reply(content)
+            : this.interaction.channel.send(content)).then((message) => {
+            const collector = message.channel
+                .createMessageComponentCollector({
+                filter: options.filter,
+                time: options?.time || 60000,
+            })
+                .on("collect", (interaction) => {
+                let stop = false;
+                if (interaction.customId.startsWith(this.interaction.id)) {
+                    switch (Number(interaction.customId.split(/-/).pop())) {
+                        case 0: {
+                            embed = embeds[0];
+                            break;
+                        }
+                        case 1: {
+                            embed =
+                                embeds[embeds.indexOf(embed) >= 1 ? embeds.indexOf(embed) - 1 : 0];
+                            break;
+                        }
+                        case 2: {
+                            collector.stop();
+                            stop = true;
+                            break;
+                        }
+                        case 3: {
+                            embed =
+                                embeds[embeds.indexOf(embed) < embeds.length - 1
+                                    ? embeds.indexOf(embed) + 1
+                                    : embeds.length - 1];
+                            break;
+                        }
+                        case 4: {
+                            embed = embeds[embeds.length - 1];
+                            break;
+                        }
+                    }
+                    stop
+                        ? interaction.update({ embeds: [embed], components: [] })
+                        : interaction.update({ embeds: [embed] });
+                }
+            })
+                .on("end", () => {
+                this.interaction.editReply({ components: [] });
+            });
+        });
+    }
+    #buttonMenuPaginator(embeds, options) { }
+    isOwner() {
+        return this.client.util.isOwner(this.interaction.user.id);
+    }
+    #createModal() { }
+}

package/package.json

@@ -1,8 +1,9 @@
 {
+	"type": "module",
 	"name": "xernerx",
-	"version": "2.7.5",
+	"version": "3.0.1",
 	"description": "A bot framework for discord.js. [BETA]",
-	"main": "main.js",
+	"main": "dist/main.js",
 	"scripts": {
 		"test": "echo Setup a bot then start the bot."
 	},
@@ -17,12 +18,8 @@
 	},
 	"homepage": "https://github.com/TheDummi/xernerx#readme",
 	"dependencies": {
-		"@discordjs/rest": "1.2.0",
-		"@sapphire/shapeshift": "3.6.0",
-		"discord-api-types": "^0.37.11",
-		"discord.js": "^14.5.0",
-		"dumfunctions": "^1.0.7",
-		"i18next": "^21.9.2"
+		"@sapphire/shapeshift": "^3.7.0",
+		"discord.js": "^14.6.0"
 	},
 	"packageManager": "npm@8.5.5"
 }

package/main.js

@@ -1,49 +0,0 @@
-const { Client } = require('./models/Client.js'),
-    { CommandHandler } = require('./models/handlers/CommandHandler.js'),
-    { EventHandler } = require('./models/handlers/EventHandler.js'),
-    { MessageCommand } = require('./models/commands/MessageCommand.js'),
-    { InteractionCommand } = require('./models/commands/InteractionCommand.js'),
-    { Event } = require('./models/commands/Event.js'),
-    { Inhibitor } = require('./models/commands/Inhibitor.js'),
-    { LanguageHandler } = require('./models/handlers/LanguageHandler.js'),
-    { ContextMenuCommand } = require('./models/commands/ContextMenuCommand.js'),
-    pkg = require('./package.json'),
-    Dumfunctions = require('dumfunctions'),
-    Discord = require('discord.js'),
-    i18next = require('i18next');
-
-const exp = {
-    // Client
-    XernerxClient: Client,
-
-    // Handlers
-    CommandHandler,
-    EventHandler,
-    LanguageHandler,
-
-    // Commands
-    MessageCommand,
-    InteractionCommand,
-    ContextMenuCommand,
-
-    // Events
-    Event,
-
-    Inhibitor,
-
-    // Discord
-    Discord,
-    i18next,
-    functions: Dumfunctions,
-
-    // Details
-    version: pkg.version,
-}
-
-for (const [key, val] of Object.entries(Discord)) {
-    if (key == 'version') continue;
-
-    exp[key] = val;
-}
-
-module.exports = exp;

package/models/Client.js

@@ -1,60 +0,0 @@
-const Discord = require('discord.js');
-const { s } = require('@sapphire/shapeshift');
-const { color } = require('./utils/Functions.js');
-const { CommandHandler } = require('./handlers/CommandHandler.js');
-const { EventHandler } = require('./handlers/EventHandler.js');
-const { LanguageHandler } = require('./handlers/LanguageHandler.js');
-const InhibitorHandler = require('./handlers/InhibitorHandler.js');
-const Handler = require('./handlers/Handler.js');
-
-class Client extends Discord.Client {
-    constructor(options = {}, settings = {}, i18next = {}, config = {}) {
-        super(options)
-
-        this.client = new Discord.Client({ intents: options.intents });
-
-        this.client.settings = s.object({
-            guildId: s.string.default(undefined),
-            global: s.boolean.default(false),
-            prefix: s.array(s.string).default([]),
-            mentionPrefix: s.boolean.optional,
-            ownerId: s.array(s.string).default([]),
-            ignoreOwner: s.boolean.default(false),
-            defaultCooldown: s.number.default(0),
-            cacheTime: s.number.default(300000),
-            userPermissions: s.array(s.string).default([]),
-            clientPermissions: s.array(s.string).default([]),
-            logging: s.union(s.boolean, s.array(s.string)).default(false),
-        }).parse(settings);
-
-        this.client.language = i18next;
-
-        this.client.color = color({ client: this.client, options: settings });
-
-        this.client.config = config;
-
-        this.client.data = {
-            messages: {},
-
-            cooldowns: {}
-        };
-
-        this.client.modules = {
-            commandHandler: new CommandHandler({ client: this.client }),
-
-            eventHandler: new EventHandler({ client: this.client }),
-
-            inhibitorHandler: new InhibitorHandler(this.client),
-
-            languageHandler: new LanguageHandler(this.client)
-        }
-
-        this.client.util = {
-            handler: new Handler(this.client)
-        }
-
-        return this.client;
-    }
-}
-
-module.exports = { Client };