xernerx 4.2.1 → 4.3.0

package/dist/mjs/utils/CommandUtil.js

@@ -1,232 +0,0 @@
-import { ActionRowBuilder, ButtonBuilder, ButtonStyle, EmbedBuilder, StringSelectMenuBuilder } from 'discord.js';
-import XernerxError from '../tools/XernerxError.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 XernerxError(`Expected embeds to be of type array, received ${typeof embeds} instead.`);
-        if (embeds.length > 25) throw new XernerxError(`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 StringSelectMenuBuilder().setCustomId(options.id).setMaxValues(1).setMinValues(1).setPlaceholder('Select a page.').addOptions({ label: 'index', value: '0' });
-            embeds.map((embed, i = 0) => {
-                options?.component?.addOptions({
-                    label: embed.data.title || 'No Name',
-                    description: embed.data.description || `Page ${i}`,
-                    value: String(i + 1),
-                });
-            });
-            options.row.addComponents(options.component);
-        }
-        embeds.unshift(options.index);
-        const content = {
-            embeds: [options.index],
-            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(() => {
-            const collector = this.interaction.channel
-                .createMessageComponentCollector({
-                    filter: options?.filter,
-                    time: options?.time || 60000,
-                })
-                .on('collect', (interaction) => {
-                    if (!interaction.customId.startsWith(this.interaction.id)) return;
-                    interaction.update({
-                        embeds: [embeds[parseInt(interaction.values[0])]],
-                    });
-                })
-                .on('end', () => {
-                    this.interaction.editReply({ components: [] });
-                });
-        });
-    }
-    buttonPaginator(embeds, options) {
-        if (!Array.isArray(embeds)) throw new XernerxError(`Expected embeds to be of type array, received ${typeof embeds} instead.`);
-        if (embeds.length <= 0) throw new XernerxError(`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/dist/mjs/validators/CommandValidations.d.ts

@@ -1,12 +0,0 @@
-import { Interaction } from 'discord.js';
-import ContextCommandBuilder from '../build/ContextCommandBuilder.js';
-import MessageCommandBuilder from '../build/MessageCommandBuilder.js';
-import SlashCommandBuilder from '../build/SlashCommandBuilder.js';
-import XernerxClient from '../client/XernerxClient.js';
-import { XernerxMessage } from '../types/types.js';
-export default function commandValidation(
-    action: XernerxMessage | Interaction,
-    command: SlashCommandBuilder | MessageCommandBuilder | ContextCommandBuilder | any,
-    client: XernerxClient,
-    res?: boolean
-): boolean;

package/dist/mjs/validators/CommandValidations.js

@@ -1,166 +0,0 @@
-import { Message } from 'discord.js';
-import { CommandType } from '../types/enums.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.ignore?.owner) && 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, command, '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, command, 'Not the correct channel', command.channelType);
-        }
-    } else if (command.channels?.length > 0 && !command.channels.includes(action.channel?.id)) {
-        res = true;
-        emit(client, action, command, 'Not a whitelisted channel', command.channels);
-    } else if (command.guilds?.length > 0 && !command.guilds.includes(action.guild?.id)) {
-        res = true;
-        emit(client, action, command, 'Not a whitelisted guild', command.guilds);
-    } else if (command.channelType && command.channelType !== action.channel?.type) {
-        res = true;
-        emit(client, action, command, 'Not the correct type of channel', command.channelType);
-    } else if (action?.guild && (command.permissions?.user || client.settings.permissions?.user)) {
-        const permissions = command.permissions?.user || client?.settings?.permissions?.user?.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, command, 'Missing User Permissions', missing);
-        }
-    } else if (action?.guild && (command.permissions?.client || client.settings.permissions?.client)) {
-        const permissions = command.permissions?.client || client?.settings?.permissions?.client?.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, command, 'Missing Client Permissions', missing);
-        }
-    }
-    return res;
-}
-function emit(client, action, command, reason, extra) {
-    return client.emit('commandBlock', action, command, 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/mjs/validators/InhibitorValidations.d.ts

@@ -1,11 +0,0 @@
-import XernerxClient from '../client/XernerxClient.js';
-import { XernerxInteraction, XernerxMessage } from '../types/types.js';
-export declare class InhibitorValidation {
-    client: XernerxClient;
-    action: XernerxMessage | XernerxInteraction;
-    command: string;
-    inhibited: Record<string, string | void>;
-    constructor(client: XernerxClient, action: XernerxMessage | XernerxInteraction, command: string);
-    inhibit(): Promise<Record<string, string | void> | undefined>;
-    private args;
-}

package/dist/mjs/validators/InhibitorValidations.js

@@ -1,36 +0,0 @@
-import { InhibitorType } from '../types/enums.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);
-    }
-}