xernerx 2.7.4 → 3.0.0

package/dist/models/Events.js

@@ -0,0 +1,328 @@
+import { GatewayVersion, InteractionType, REST, Routes, } from "discord.js";
+import { InteractionCommandUtil, MessageCommandUtil, } from "../utils/CommandUtil.js";
+import { CommandArguments, messageArgs } from "./CommandArguments.js";
+import commandValidation from "./CommandValidations.js";
+import { logStyle } from "./Functions.js";
+import { InhibitorValidation } from "./InhibitorValidations.js";
+export class MessageCommandEvents {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    messageCreate() {
+        this.client.on("messageCreate", async (message) => {
+            if (!message.author.bot) {
+                let command = undefined, px = undefined;
+                message.author.isOwner = this.client.util.isOwner(message.author.id);
+                message.util = new MessageCommandUtil(this.client, message);
+                const commands = this.client.commands.message;
+                commands
+                    .filter((c) => !c.regex)
+                    .map(async (cmd) => {
+                    if (cmd.prefix) {
+                        cmd.prefix.map((prefix) => {
+                            if (message.content.startsWith(prefix)) {
+                                command = message.content
+                                    .replace(prefix, "")
+                                    .split(/ +/)
+                                    .shift();
+                                px = prefix;
+                            }
+                        });
+                    }
+                    if (this.client.handlerOptions.message?.prefix) {
+                        const prefix = Array.isArray(this.client.handlerOptions.message.prefix)
+                            ? this.client.handlerOptions.message.prefix
+                            : [this.client.handlerOptions.message.prefix];
+                        prefix.map((prefix) => {
+                            if (message.content.startsWith(prefix)) {
+                                command = message.content
+                                    .replace(prefix, "")
+                                    .split(/ +/)
+                                    .shift();
+                                px = prefix;
+                            }
+                        });
+                    }
+                    if (this.client.handlerOptions.message?.allowMention) {
+                        if (message.mentions.users.has(this.client.user?.id || "") ||
+                            message.mentions.repliedUser?.id === this.client.user?.id) {
+                            command = message.content
+                                .replace(`<@${this.client.user?.id}>`, "")
+                                .trim()
+                                .split(/ +/)
+                                .shift();
+                            px = "MentionPrefix";
+                        }
+                    }
+                    const prefix = Array.isArray(this.client.handlerOptions.message?.prefix)
+                        ? this.client.handlerOptions.message?.prefix
+                        : [this.client.handlerOptions.message?.prefix];
+                    if ((cmd.name.toLowerCase() == command?.toLowerCase() ||
+                        cmd.aliases
+                            ?.map((c) => c.toLowerCase())
+                            ?.includes(command?.toLowerCase())) &&
+                        (cmd.prefix.includes(px) ||
+                            prefix?.includes(px) ||
+                            px === "MentionPrefix")) {
+                        try {
+                            const inhibitor = new InhibitorValidation(this.client, message, command);
+                            if (commandValidation(message, cmd, this.client))
+                                return;
+                            if (await inhibitor.inhibit())
+                                return;
+                            if (cmd.conditions && (await cmd.conditions(message)))
+                                return;
+                            await cmd.exec(message, await messageArgs(message, cmd));
+                            this.client.emit("commandRun", message, cmd);
+                        }
+                        catch (error) {
+                            return this.client.emit("commandError", message, error);
+                        }
+                    }
+                });
+            }
+        });
+    }
+    messageUpdate() {
+        this.client.on("messageUpdate", async (old, message) => {
+            message = message; // could just do this
+            if (!message.author?.bot) {
+                let command = undefined, px = undefined;
+                if (message.author)
+                    message.author.isOwner = this.client.util.isOwner(message.author.id);
+                message.util = new MessageCommandUtil(this.client, message);
+                const commands = this.client.commands.message;
+                commands
+                    .filter((c) => !c.regex)
+                    .map(async (cmd) => {
+                    if (cmd.prefix) {
+                        cmd.prefix.map((prefix) => {
+                            if (message?.content?.startsWith(prefix)) {
+                                command = message.content
+                                    .replace(prefix, "")
+                                    .split(/ +/)
+                                    .shift();
+                                px = prefix;
+                            }
+                        });
+                    }
+                    if (this.client.handlerOptions.message?.prefix) {
+                        const prefix = Array.isArray(this.client.handlerOptions.message.prefix)
+                            ? this.client.handlerOptions.message.prefix
+                            : [this.client.handlerOptions.message.prefix];
+                        prefix.map((prefix) => {
+                            if (message?.content?.startsWith(prefix)) {
+                                command = message.content
+                                    .replace(prefix, "")
+                                    .split(/ +/)
+                                    .shift();
+                                px = prefix;
+                            }
+                        });
+                    }
+                    if (this.client.handlerOptions.message?.allowMention) {
+                        if (message.mentions.users.has(this.client.user?.id || "") ||
+                            message.mentions.repliedUser?.id === this.client.user?.id) {
+                            command = message?.content
+                                ?.replace(`<@${this.client.user?.id}>`, "")
+                                .trim()
+                                .split(/ +/)
+                                .shift();
+                            px = "MentionPrefix";
+                        }
+                    }
+                    const prefix = Array.isArray(this.client.handlerOptions.message?.prefix)
+                        ? this.client.handlerOptions.message?.prefix
+                        : [this.client.handlerOptions.message?.prefix];
+                    if ((cmd.name.toLowerCase() == command?.toLowerCase() ||
+                        cmd.aliases
+                            ?.map((c) => c.toLowerCase())
+                            ?.includes(command?.toLowerCase())) &&
+                        (cmd.prefix.includes(px) ||
+                            prefix?.includes(px) ||
+                            px === "MentionPrefix")) {
+                        try {
+                            const inhibitor = new InhibitorValidation(this.client, message, command);
+                            if (commandValidation(message, cmd, this.client))
+                                return;
+                            if (await inhibitor.inhibit())
+                                return;
+                            if (cmd.conditions && (await cmd.conditions(message)))
+                                return;
+                            await cmd.exec(message, await messageArgs(message, cmd));
+                            this.client.emit("commandRun", message, cmd);
+                        }
+                        catch (error) {
+                            return this.client.emit("commandError", message, error);
+                        }
+                    }
+                });
+            }
+        });
+    }
+    messageDelete() {
+        this.client.on("messageDelete", async (message) => {
+            if (this.client.cache.messages.has(message.id) &&
+                this.client.handlerOptions.message?.handleDeletes) {
+                try {
+                    const msg = this.client.cache.messages.get(message.id);
+                    const response = await message.channel.messages.fetch(msg?.response);
+                    await response.delete();
+                }
+                catch { }
+            }
+        });
+    }
+}
+export class SlashCommandEvents {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    slashCreate() {
+        this.client.on("interactionCreate", async (interaction) => {
+            interaction.util = new InteractionCommandUtil(this.client, interaction);
+            interaction.user.isOwner = this.client.util.isOwner(interaction.user.id);
+            if (interaction.type === InteractionType.ApplicationCommand) {
+                if (this.client.commands.slash.has(interaction.commandName)) {
+                    let command = this.client.commands.slash.get(interaction.commandName);
+                    const argumentsInfo = new CommandArguments(interaction);
+                    try {
+                        const inhibitor = new InhibitorValidation(this.client, interaction, command);
+                        if (await inhibitor.inhibit())
+                            return;
+                        if (commandValidation(interaction, command, this.client))
+                            return;
+                        if (command.defer?.reply !== false &&
+                            this.client.handlerOptions.slash?.defer?.reply) {
+                            await interaction.deferReply({
+                                ephemeral: this.client.handlerOptions.slash?.defer?.ephemeral,
+                                fetchReply: this.client.handlerOptions.slash?.defer?.fetchReply,
+                            });
+                        }
+                        if (!(interaction.deferred || interaction.replied) &&
+                            command.defer?.reply) {
+                            await interaction.deferReply({
+                                ephemeral: command.defer?.ephemeral,
+                                fetchReply: command.defer?.fetchReply,
+                            });
+                        }
+                        if (command.conditions &&
+                            (await command.conditions(interaction, {
+                                group: argumentsInfo.group(),
+                                subcommand: argumentsInfo.subcommand(),
+                                args: await argumentsInfo.arguments(),
+                            })))
+                            return;
+                        await command.exec(interaction, {
+                            group: argumentsInfo.group(),
+                            subcommand: argumentsInfo.subcommand(),
+                            args: await argumentsInfo.arguments(),
+                        });
+                        this.client.emit("commandRun", interaction, command);
+                    }
+                    catch (error) {
+                        this.client.emit("commandError", interaction, error);
+                    }
+                }
+            }
+        });
+    }
+}
+export class ContextCommandEvents {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    contextCreate() {
+        this.client.on("interactionCreate", async (interaction) => {
+            interaction.util = new InteractionCommandUtil(this.client, interaction);
+            interaction.user.isOwner = this.client.util.isOwner(interaction.user.id);
+            if (interaction.type === InteractionType.ApplicationCommand) {
+                if (this.client.commands.context.has(interaction.commandName)) {
+                    let command = this.client.commands.context.get(interaction.commandName);
+                    try {
+                        const inhibitor = new InhibitorValidation(this.client, interaction, command);
+                        if (commandValidation(interaction, command, this.client))
+                            return;
+                        if (await inhibitor.inhibit())
+                            return;
+                        if (command.conditions && (await command.conditions(interaction)))
+                            return;
+                        if (command.defer?.reply !== false &&
+                            this.client.handlerOptions.context?.defer?.reply) {
+                            await interaction.deferReply({
+                                ephemeral: this.client.handlerOptions.context?.defer?.ephemeral,
+                                fetchReply: this.client.handlerOptions.context?.defer?.fetchReply,
+                            });
+                        }
+                        if (!(interaction.deferred || interaction.replied) &&
+                            command.defer?.reply) {
+                            await interaction.deferReply({
+                                ephemeral: command.defer?.ephemeral,
+                                fetchReply: command.defer?.fetchReply,
+                            });
+                        }
+                        await command.exec(interaction);
+                        this.client.emit("commandRun", interaction, command);
+                    }
+                    catch (error) {
+                        this.client.emit("commandError", interaction, error);
+                    }
+                }
+            }
+        });
+    }
+}
+export class CommandsDeploy {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    deploy() {
+        this.client.once("ready", async (client) => {
+            const rest = new REST({ version: GatewayVersion }).setToken(client.token);
+            const commands = [
+                ...this.client.commands.context,
+                ...this.client.commands.slash,
+            ];
+            const deployableCommands = [];
+            commands.map((commands) => commands.map((command) => {
+                if (command?.data) {
+                    deployableCommands.push(command.data.toJSON());
+                }
+            }));
+            try {
+                if (this.client.handlerOptions.context?.global === true ||
+                    this.client.handlerOptions.slash?.global === true) {
+                    rest.put(Routes.applicationCommands(client.user.id), {
+                        body: deployableCommands,
+                    });
+                    rest.put(Routes.applicationGuildCommands(client.user.id, this.client.handlerOptions.slash?.guildId ||
+                        this.client.handlerOptions.context?.guildId ||
+                        ""), {
+                        body: [],
+                    });
+                }
+                if (this.client.handlerOptions.context?.global === false ||
+                    this.client.handlerOptions.slash?.global === false) {
+                    rest.put(Routes.applicationGuildCommands(client.user.id, this.client.handlerOptions.slash?.guildId ||
+                        this.client.handlerOptions.context?.guildId ||
+                        ""), {
+                        body: deployableCommands,
+                    });
+                }
+                if (this.client.handlerOptions.slash?.logging ||
+                    this.client.handlerOptions?.context?.logging)
+                    console.info(logStyle(`Xernerx | Deployed ${deployableCommands.length} of ${commands.length} interaction commands ${this.client.handlerOptions.slash?.global ||
+                        this.client.handlerOptions.context?.global
+                        ? `globally in ${(await this.client.guilds.fetch()).size} server(s), deleted local commands.`
+                        : "locally"}.`, "text", "purple"));
+            }
+            catch (error) {
+                console.error(logStyle(`Xernerx | Couldn't deploy interaction commands because <${error}>.`, "background", "red"));
+            }
+        });
+    }
+}

package/dist/models/Functions.d.ts

@@ -0,0 +1 @@
+export declare function logStyle(text: string, type: string, color: string): string | undefined;

package/dist/models/Functions.js

@@ -0,0 +1,30 @@
+export function logStyle(text, type, color) {
+    if (type.toLowerCase() == "text") {
+        if (color.toLowerCase() == "red")
+            return `\u001b[0;31m${text}\u001b[0;0m`;
+        if (color.toLowerCase() == "green")
+            return `\u001b[0;32m${text}\u001b[0;0m`;
+        if (color.toLowerCase() == "yellow")
+            return `\u001b[0;33m${text}\u001b[0;0m`;
+        if (color.toLowerCase() == "blue")
+            return `\u001b[0;34m${text}\u001b[0;0m`;
+        if (color.toLowerCase() == "purple")
+            return `\u001b[0;35m${text}\u001b[0;0m`;
+        if (color.toLowerCase() == "cyan")
+            return `\u001b[0;36m${text}\u001b[0;0m`;
+    }
+    if (type.toLowerCase() == `background`) {
+        if (color.toLowerCase() == "red")
+            return `\u001b[0;41m${text}\u001b[0;0m`;
+        if (color.toLowerCase() == "green")
+            return `\u001b[0;42m${text}\u001b[0;0m`;
+        if (color.toLowerCase() == "yellow")
+            return `\u001b[0;43m${text}\u001b[0;0m`;
+        if (color.toLowerCase() == "blue")
+            return `\u001b[0;44m${text}\u001b[0;0m`;
+        if (color.toLowerCase() == "purple")
+            return `\u001b[0;45m${text}\u001b[0;0m`;
+        if (color.toLowerCase() == "cyan")
+            return `\u001b[0;46m${text}\u001b[0;0m`;
+    }
+}

package/dist/models/InhibitorValidations.d.ts

@@ -0,0 +1,17 @@
+import { Interaction, Message } from "discord.js";
+import { MessageCommandOptions, SlashCommandOptions, ContextCommandOptions } from "../interfaces/CommandInterfaces.js";
+import { InhibitorType } from "../types/InhibitorTypes.js";
+import XernerxClient from "../client/XernerxClient.js";
+export declare class InhibitorValidation {
+    client: XernerxClient;
+    action: Message | Interaction;
+    command: MessageCommandOptions | SlashCommandOptions | ContextCommandOptions;
+    inhibited: {
+        [index: string]: any;
+    };
+    constructor(client: XernerxClient, action: Message | Interaction, command: any);
+    inhibit(): Promise<{
+        [index: string]: any;
+    } | undefined>;
+    args(action: any, type: InhibitorType): any;
+}

package/dist/models/InhibitorValidations.js

@@ -0,0 +1,42 @@
+import { InhibitorType } from "../types/InhibitorTypes.js";
+export class InhibitorValidation {
+    client;
+    action;
+    command;
+    inhibited;
+    constructor(client, action, command) {
+        this.client = client;
+        this.action = action;
+        this.command = command;
+        this.inhibited = {};
+    }
+    async inhibit() {
+        for (const inhibitor of this.client.inhibitors) {
+            const inhibit = inhibitor[1];
+            if (inhibit)
+                this.inhibited[inhibit.name] = await inhibit.check(this.action, this.args(this.action, inhibit.type));
+        }
+        for (const inhibit of Object.values(this.inhibited)) {
+            if (inhibit)
+                return this.inhibited;
+        }
+    }
+    args(action, type) {
+        if (type === InhibitorType.Channel)
+            return action.channel;
+        if (type === InhibitorType.User)
+            return action.author || action.user;
+        if (type === InhibitorType.Guild)
+            return action.guild;
+        if (type === InhibitorType.Member)
+            return action.member;
+        // if (type === InhibitorType.Command)
+        // 	return this.client.util.getAllCommands().filter(this.command.name);
+        // if (type === InhibitorType.MessageCommand)
+        // 	return this.client.util.getAllMessageCommands().find(this.command.name);
+        // if (type === InhibitorType.SlashCommand)
+        // 	return this.client.util.getAllSlashCommands().find(this.command.name);
+        // if (type === InhibitorType.ContextCommand)
+        // 	return this.client.util.getAllContextCommands().find(this.command.name);
+    }
+}

package/dist/types/EventTypes.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/EventTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/types/InhibitorTypes.d.ts

@@ -0,0 +1,12 @@
+export declare enum InhibitorType {
+    Member = "Member",
+    User = "User",
+    Guild = "Guild",
+    SlashCommand = "SlashCommand",
+    MessageCommand = "MessageCommand",
+    ContextCommand = "ContextCommand",
+    Command = "Command",
+    Message = "Message",
+    Interaction = "Interaction",
+    Channel = "Channel"
+}

package/dist/types/InhibitorTypes.js

@@ -0,0 +1,13 @@
+export var InhibitorType;
+(function (InhibitorType) {
+    InhibitorType["Member"] = "Member";
+    InhibitorType["User"] = "User";
+    InhibitorType["Guild"] = "Guild";
+    InhibitorType["SlashCommand"] = "SlashCommand";
+    InhibitorType["MessageCommand"] = "MessageCommand";
+    InhibitorType["ContextCommand"] = "ContextCommand";
+    InhibitorType["Command"] = "Command";
+    InhibitorType["Message"] = "Message";
+    InhibitorType["Interaction"] = "Interaction";
+    InhibitorType["Channel"] = "Channel";
+})(InhibitorType = InhibitorType || (InhibitorType = {}));

package/dist/types/Types.d.ts

@@ -0,0 +1,24 @@
+import { SlashCommandStringOption, SlashCommandNumberOption, SlashCommandIntegerOption, SlashCommandBooleanOption, SlashCommandUserOption, SlashCommandChannelOption, SlashCommandRoleOption, SlashCommandMentionableOption } from "discord.js";
+export declare enum CommandType {
+    Message = "MessageCommand",
+    Slash = "SlashCommand",
+    Context = "ContextCommand",
+    Event = "Event",
+    Inhibitor = "Inhibitor",
+    MessageCommand = "MessageCommand",
+    SlashCommand = "SlashCommand",
+    ContextCommand = "ContextCommand"
+}
+export declare enum EventEmitterType {
+    Client = "client",
+    Rest = "rest",
+    Process = "process"
+}
+export declare type SlashCommandOptionChoices = SlashCommandStringOption | SlashCommandNumberOption | SlashCommandIntegerOption;
+export declare type SlashCommandOption = SlashCommandOptionChoices | SlashCommandBooleanOption | SlashCommandUserOption | SlashCommandChannelOption | SlashCommandRoleOption | SlashCommandMentionableOption;
+export declare type NiceTypes = "String" | "Number" | "Boolean" | "User" | "Channel" | "Role" | "Mentionable" | "Integer";
+declare const _default: {
+    CommandType: typeof CommandType;
+    EventEmitterType: typeof EventEmitterType;
+};
+export default _default;

package/dist/types/Types.js

@@ -0,0 +1,21 @@
+export var CommandType;
+(function (CommandType) {
+    CommandType["Message"] = "MessageCommand";
+    CommandType["Slash"] = "SlashCommand";
+    CommandType["Context"] = "ContextCommand";
+    CommandType["Event"] = "Event";
+    CommandType["Inhibitor"] = "Inhibitor";
+    CommandType["MessageCommand"] = "MessageCommand";
+    CommandType["SlashCommand"] = "SlashCommand";
+    CommandType["ContextCommand"] = "ContextCommand";
+})(CommandType = CommandType || (CommandType = {}));
+export var EventEmitterType;
+(function (EventEmitterType) {
+    EventEmitterType["Client"] = "client";
+    EventEmitterType["Rest"] = "rest";
+    EventEmitterType["Process"] = "process";
+})(EventEmitterType = EventEmitterType || (EventEmitterType = {}));
+export default {
+    CommandType,
+    EventEmitterType,
+};

package/dist/utils/ClientUtil.d.ts

@@ -0,0 +1,25 @@
+import { ActivityType, ClientPresenceStatus } from "discord.js";
+import XernerxClient from "../client/XernerxClient.js";
+interface Presence {
+    text?: string;
+    type?: ActivityType.Playing | ActivityType.Streaming | ActivityType.Listening | ActivityType.Watching | ActivityType.Competing;
+    link?: string;
+    status?: ClientPresenceStatus;
+    interval?: number;
+}
+export declare class ClientUtil {
+    client: XernerxClient;
+    constructor(client: XernerxClient);
+    uptime(timestamp: number | null): string;
+    getSubcommands(name: string): object[];
+    isOwner(userId: string): boolean;
+    getAllCommands(): object[];
+    getAllMessageCommands(): object[];
+    getAllSlashCommands(): object[];
+    getAllContextCommands(): object[];
+    setPresence(options: Presence): void;
+    getCooldowns(id: string, command?: string): any;
+    getCooldownTimers(id: string, command?: string): any;
+    defer(time: number): Promise<unknown>;
+}
+export {};