xernerx 2.7.4 → 3.0.0

package/dist/main.js

@@ -0,0 +1,40 @@
+import Discord from "discord.js";
+import XernerxClient from "./client/XernerxClient.js";
+import { Event } from "./build/Event.js";
+import { Inhibitor } from "./build/Inhibitor.js";
+import { MessageCommand } from "./build/MessageCommand.js";
+import { ContextCommand } from "./build/ContextCommand.js";
+import { SlashCommand } from "./build/SlashCommand.js";
+import { CommandType, EventEmitterType } from "./types/Types.js";
+import { InhibitorType } from "./types/InhibitorTypes.js";
+const version = "3.0.0";
+export default {
+    // Imported methods
+    Discord,
+    // Client
+    Client: XernerxClient,
+    XernerxClient,
+    // Types
+    CommandType,
+    EventEmitterType,
+    InhibitorType,
+    // Builds
+    Event,
+    MessageCommand,
+    ContextCommand,
+    SlashCommand,
+    Inhibitor,
+    // Constants
+    version,
+};
+export { 
+// Imported methods
+Discord, 
+// Client
+XernerxClient, 
+// Types
+CommandType, EventEmitterType, InhibitorType, 
+// Builds
+Event, MessageCommand, ContextCommand, SlashCommand, Inhibitor, 
+// Constants
+version, };

package/dist/models/CommandArguments.d.ts

@@ -0,0 +1,9 @@
+import { Interaction, Message } from "discord.js";
+export declare class CommandArguments {
+    action: any;
+    constructor(action: Message | Interaction);
+    group(): any;
+    subcommand(): any;
+    arguments(): Record<string, object>;
+}
+export declare function messageArgs(message: any, command: any): Promise<any>;

package/dist/models/CommandArguments.js

@@ -0,0 +1,128 @@
+export class CommandArguments {
+    action;
+    constructor(action) {
+        this.action = action;
+    }
+    group() {
+        return this.action?.options?._group;
+    }
+    subcommand() {
+        return this.action?.options?._subcommand;
+    }
+    arguments() {
+        const options = {};
+        if (this.action?.options?._hoistedOptions) {
+            for (const option of this.action.options._hoistedOptions) {
+                options[option.name] =
+                    option.channel || option.user || option.role || option.value;
+            }
+        }
+        return options;
+    }
+}
+export async function messageArgs(message, command) {
+    let args = { flags: {} }, separator = command.separator || " ", i = 0;
+    if (!command.args)
+        return;
+    command.args
+        .filter((c) => c.type == "flag")
+        .map((flag) => {
+        for (const flg of message.content.matchAll(flag.content)) {
+            if (flag.content == flg) {
+                message.content = message.content.replace(flag.content, "");
+                args.flags[flag.name] = true;
+            }
+        }
+        if (!args.flags[flag.name])
+            args.flags[flag.name] = false;
+    });
+    for (const argument of command.args) {
+        let content = message.content
+            .split(/ +/)
+            .slice(1)
+            .join(separator)
+            .replace(new RegExp(`${separator}${separator}+`, "g"), separator)
+            .split(separator)
+            .slice(i);
+        if (content.join(separator) != "" && argument.type !== "flag") {
+            if (argument?.content?.includes(content[0])) {
+                args[argument.name] = content[0];
+            }
+            else if (argument.type == "string") {
+                args[argument.name] = content[0];
+            }
+            else if (argument.type == "number") {
+                args[argument.name] = parseInt(content[0]);
+            }
+            else if (argument.type == "boolean") {
+                if (content[0]?.toLowerCase() != "true" &&
+                    content[0]?.toLowerCase() != "false")
+                    content[0] = undefined;
+                args[argument.name] = content[0];
+            }
+            else if (argument.type == "user") {
+                let user = message.client.users.cache.find((u) => u?.username?.toLowerCase()?.includes(content[0]));
+                try {
+                    user = await message.client.users.fetch(user?.id || content[0].replace(/<@!?|>/g, ""));
+                }
+                catch (e) {
+                    user = new Error("Invalid user snowflake ID");
+                }
+                args[argument.name] = user;
+            }
+            else if (argument.type == "role") {
+                let role = message.guild.roles.cache.find((r) => r?.name?.toLowerCase()?.includes(content[0]));
+                try {
+                    role = await message.guild.roles.fetch(role?.id || content[0].replace(/<@&?|>/g, ""));
+                }
+                catch (e) {
+                    role = new Error("Invalid role snowflake ID");
+                }
+                args[argument.name] = role;
+            }
+            else if (argument.type == "member") {
+                let member = message.guild.members.cache.find((m) => m?.nickname?.toLowerCase()?.includes(content[0]) ||
+                    m?.user?.username?.toLowerCase()?.includes(content[0]));
+                try {
+                    member = await message.guild.members.fetch(member?.id || content[0].replace(/<@!?|>/g, ""));
+                }
+                catch (e) {
+                    member = new Error("Invalid member snowflake ID");
+                }
+                args[argument.name] = member;
+            }
+            else if (argument.type == "channel") {
+                let channel = message.guild.channels.cache.find((c) => c?.name?.toLowerCase()?.includes(content[0]));
+                try {
+                    channel = await message.client.channels.fetch(channel?.id || content[0].replace(/<#|>/g, ""));
+                }
+                catch (e) {
+                    channel = new Error("Invalid channel snowflake ID");
+                }
+                args[argument.name] = channel;
+            }
+            else if (argument.type == "rest") {
+                args[argument.name] = content.join(separator);
+                break;
+            }
+            else if (argument.prompt) {
+                if (argument.prompt.reply)
+                    return message.reply(argument.prompt.reply);
+                else if (argument.prompt.send)
+                    return message.channel.send(argument.prompt.send);
+            }
+            else
+                args[argument.name] =
+                    typeof argument.default == "function"
+                        ? argument.default(message)
+                        : argument.default;
+            i++;
+        }
+        else
+            args[argument.name] =
+                typeof argument.default == "function"
+                    ? argument.default(message)
+                    : argument.default;
+    }
+    return args;
+}

package/dist/models/CommandValidations.d.ts

@@ -0,0 +1,3 @@
+import { Interaction, Message } from "discord.js";
+import { XernerxClient, SlashCommand, MessageCommand, ContextCommand } from "../main.js";
+export default function commandValidation(action: Message | Interaction, command: SlashCommand | MessageCommand | ContextCommand | any, client: XernerxClient, res?: boolean): boolean;

package/dist/models/CommandValidations.js

@@ -0,0 +1,193 @@
+import { Message } from "discord.js";
+import { CommandType } from "../types/Types.js";
+function getUser(from) {
+    if (from instanceof Message)
+        return from.author;
+    else
+        return from.user;
+}
+export default function commandValidation(action, command, client, res = false) {
+    let user = getUser(action);
+    if ((command.ignoreOwner || client.settings.ignoreOwner) &&
+        client.util.isOwner(user.id))
+        return res;
+    else if (inCooldown(user, client, command, action))
+        return true;
+    else if (command.owner && !client.util.isOwner(user.id)) {
+        res = true;
+        emit(client, action, "Not an owner", client.settings.ownerId);
+    }
+    else if (command.channelType?.length > 0 || command.channelType) {
+        if (!Array.isArray(command.channelType))
+            command.channelType = [command.channelType];
+        if (!command?.channelType?.includes(action.channel?.type)) {
+            res = true;
+            emit(client, action, "Not the correct channel", command.channelType);
+        }
+    }
+    else if (command.channels?.length > 0 &&
+        !command.channels.includes(action.channel?.id)) {
+        res = true;
+        emit(client, action, "Not a whitelisted channel", command.channels);
+    }
+    else if (command.guilds?.length > 0 &&
+        !command.guilds.includes(action.guild?.id)) {
+        res = true;
+        emit(client, action, "Not a whitelisted guild", command.guilds);
+    }
+    else if (action?.guild &&
+        (command.userPermissions || client.settings.userPermissions)) {
+        const permissions = command.userPermissions ||
+            client?.settings?.userPermissions?.push(...handlerPermissions(client, command.commandType, "user")), missing = [];
+        if (Array.isArray(permissions))
+            permissions.map((permission) => {
+                if (!(action.member?.permissions).has(permission)) {
+                    missing.push(permission);
+                }
+            });
+        if (missing.length > 0) {
+            res = true;
+            emit(client, action, "Missing User Permissions", missing);
+        }
+    }
+    else if (action?.guild &&
+        (command.clientPermissions || client.settings.clientPermissions)) {
+        const permissions = command.clientPermissions ||
+            client?.settings?.clientPermissions?.push(...handlerPermissions(client, command.commandType, "client")), missing = [];
+        if (Array.isArray(permissions))
+            permissions.map((permission) => {
+                if (!(action.member?.permissions).has(permission)) {
+                    missing.push(permission);
+                }
+            });
+        if (missing.length > 0) {
+            res = true;
+            emit(client, action, "Missing Client Permissions", missing);
+        }
+    }
+    return res;
+}
+function emit(client, action, reason, extra) {
+    return client.emit("commandBlock", action, reason, extra);
+}
+function inCooldown(user, client, command, action) {
+    let res = false, downs = {};
+    const { cooldowns, messageCommands, slashCommands, contextCommands, commands, } = client.cache;
+    if (command.commandType === CommandType.MessageCommand &&
+        client.handlerOptions.message.cooldown) {
+        if (messageCommands.has(user.id)) {
+            const usr = messageCommands.get(user.id);
+            usr.timeRemaining = usr.endsAt - Date.now();
+            downs.message = usr;
+            res = true;
+        }
+        if (!messageCommands.has(user.id)) {
+            messageCommands.set(user.id, toCooldown(action, command, client.handlerOptions.message.cooldown, user.id));
+            setInterval(() => {
+                messageCommands.delete(user.id);
+            }, client.handlerOptions.message.cooldown);
+        }
+    }
+    if (command.commandType === CommandType.SlashCommand &&
+        client.handlerOptions.slash.cooldown) {
+        if (slashCommands.has(user.id)) {
+            const usr = slashCommands.get(user.id);
+            usr.timeRemaining = usr.endsAt - Date.now();
+            downs.slash = usr;
+            res = true;
+        }
+        if (!slashCommands.has(user.id)) {
+            slashCommands.set(user.id, toCooldown(action, command, client.handlerOptions.slash.cooldown, user.id));
+            setInterval(() => {
+                slashCommands.delete(user.id);
+            }, client.handlerOptions.slash.cooldown);
+        }
+    }
+    if (command.commandType === CommandType.ContextCommand &&
+        client.handlerOptions.context.cooldown) {
+        if (contextCommands.has(user.id)) {
+            const usr = contextCommands.get(user.id);
+            usr.timeRemaining = usr.endsAt - Date.now();
+            downs.context = usr;
+            res = true;
+        }
+        if (!contextCommands.has(user.id)) {
+            contextCommands.set(user.id, toCooldown(action, command, client.handlerOptions.context.cooldown, user.id));
+            setInterval(() => {
+                contextCommands.delete(user.id);
+            }, client.handlerOptions.context.cooldown);
+        }
+    }
+    if (client.settings.cooldown.default) {
+        if (cooldowns.has(user.id)) {
+            const usr = cooldowns.get(user.id);
+            usr.timeRemaining = usr.endsAt - Date.now();
+            downs.default = usr;
+            res = true;
+        }
+        if (!cooldowns.has(user.id)) {
+            cooldowns.set(user.id, toCooldown(action, command, client.settings.cooldown.default, user.id));
+            setInterval(() => {
+                cooldowns.delete(user.id);
+            }, client.settings.cooldown.default);
+        }
+    }
+    if (command.cooldown) {
+        const name = user.id +
+            "-" +
+            (command.data?.name || command?.name) +
+            "-" +
+            command.commandType;
+        if (commands.has(name)) {
+            const usr = commands.get(name);
+            usr.timeRemaining = usr.endsAt - Date.now();
+            downs.command = usr;
+            res = true;
+        }
+        if (!commands.has(name)) {
+            commands.set(name, toCooldown(action, command, command.cooldown, name));
+            setInterval(() => {
+                commands.delete(name);
+            }, command.cooldown);
+        }
+    }
+    if (Object.keys(downs).length > 0)
+        client.emit("commandCooldown", action, command, downs);
+    return res;
+}
+function toCooldown(action, command, cooldown, name) {
+    let user = getUser(action);
+    return {
+        name,
+        id: user.id,
+        tag: user.tag,
+        commandType: command.commandType,
+        commandName: command?.data?.name || command?.name,
+        guildId: action?.guild?.id,
+        channelId: action?.channel?.id,
+        startsAt: Number(Date.now()),
+        endsAt: Number(Date.now()) + cooldown,
+    };
+}
+function handlerPermissions(client, commandType, type) {
+    let permissions = [];
+    if (commandType === CommandType.MessageCommand) {
+        if (type === "user")
+            permissions = client.handlerOptions.message?.userPermissions || [];
+        else if (type === "client")
+            permissions = client.handlerOptions.message?.clientPermissions || [];
+    }
+    else if (commandType === CommandType.SlashCommand) {
+        if (type === "user")
+            permissions = client.handlerOptions.slash?.userPermissions || [];
+        else if (type === "client")
+            permissions = client.handlerOptions.slash?.clientPermissions || [];
+    }
+    else if (commandType === CommandType.ContextCommand) {
+        if (type === "user")
+            permissions = client.handlerOptions.context?.userPermissions || [];
+        else if (type === "client")
+            permissions = client.handlerOptions.context?.clientPermissions || [];
+    }
+    return permissions;
+}

package/dist/models/Events.d.ts

@@ -0,0 +1,23 @@
+import XernerxClient from "../client/XernerxClient.js";
+export declare class MessageCommandEvents {
+    client: XernerxClient;
+    constructor(client: XernerxClient);
+    messageCreate(): void;
+    messageUpdate(): void;
+    messageDelete(): void;
+}
+export declare class SlashCommandEvents {
+    client: XernerxClient;
+    constructor(client: XernerxClient);
+    slashCreate(): void;
+}
+export declare class ContextCommandEvents {
+    client: XernerxClient;
+    constructor(client: XernerxClient);
+    contextCreate(): void;
+}
+export declare class CommandsDeploy {
+    client: XernerxClient;
+    constructor(client: XernerxClient);
+    deploy(): void;
+}