xernerx 3.4.3 → 3.5.0

package/dist/build/XMessageCommandBuilder.d.ts

@@ -1,42 +0,0 @@
-import { Message, ChannelType } from 'discord.js';
-import { MessageArgOptions, MessageCommandOptions } from '../types/options.js';
-import XernerxClient from '../client/XernerxClient.js';
-/**
- * @description - The command builder for message commands.
- * @param {String} id - The unique ID of the command.
- * @param {MessageCommandOptions} options - The command options.
- */
-export default class XMessageCommandBuilder {
-    id: string;
-    name: string;
-    aliases?: string[];
-    description?: string;
-    info?: string;
-    category?: string;
-    prefix?: string | string[];
-    regex?: string;
-    owner?: boolean;
-    channelType?: ChannelType | ChannelType[];
-    separator?: string;
-    cooldown?: number;
-    ignoreOwner?: boolean;
-    channels?: string[];
-    guilds?: string[];
-    userPermissions?: bigint[];
-    clientPermissions?: bigint[];
-    args?: Array<MessageArgOptions>;
-    client: XernerxClient | object;
-    constructor(id: string, options: MessageCommandOptions);
-    /**
-     * @param {Message} message - The Discord message event data.
-     * @param {object} args - The arguments you created.
-     * @description make any preconditions here.
-     */
-    conditions(message: Message, args: MessageArgOptions): Promise<void>;
-    /**
-     * @param {Message} message - The Discord message event data.
-     * @param {object} args - The arguments you created.
-     * @description Make your custom command here.
-     */
-    exec(message: Message, args: MessageArgOptions): Promise<void>;
-}

package/dist/build/XMessageCommandBuilder.js

@@ -1,80 +0,0 @@
-import { s } from '@sapphire/shapeshift';
-import XernerxClient from '../client/XernerxClient.js';
-/**
- * @description - The command builder for message commands.
- * @param {String} id - The unique ID of the command.
- * @param {MessageCommandOptions} options - The command options.
- */
-export default class XMessageCommandBuilder {
-    id;
-    name;
-    aliases;
-    description;
-    info;
-    category;
-    prefix;
-    regex;
-    owner;
-    channelType;
-    separator;
-    cooldown;
-    ignoreOwner;
-    channels;
-    guilds;
-    userPermissions;
-    clientPermissions;
-    args;
-    client;
-    constructor(id, options) {
-        this.id = id;
-        s.object({
-            name: s.string,
-            aliases: s.union(s.array(s.string).unique, s.string).optional,
-            description: s.string.optional,
-            info: s.string.optional,
-            category: s.string.optional,
-            prefix: s.union(s.array(s.string).unique, s.string).optional,
-            owner: s.boolean.optional,
-            channelType: s.union(s.number, s.array(s.number)).optional,
-            separator: s.string.optional,
-            cooldown: s.number.optional,
-            ignoreOwner: s.boolean.optional,
-            channels: s.array(s.string).unique.optional,
-            guilds: s.array(s.string).unique.optional,
-            userPermissions: s.array(s.bigint).unique.optional,
-            clientPermissions: s.array(s.bigint).unique.optional,
-        }).parse(options);
-        this.name = options.name;
-        this.aliases = options.aliases;
-        this.description = options.description;
-        this.info = options.info;
-        this.category = options.category;
-        this.prefix = options.prefix ? (Array.isArray(options.prefix) ? options.prefix : [options.prefix]) : [];
-        this.regex = options.regex;
-        this.owner = options.owner || false;
-        this.channelType = options.channelType;
-        this.separator = options.separator || ' ';
-        this.cooldown = options.cooldown || 0;
-        this.ignoreOwner = options.ignoreOwner || false;
-        this.channels = options.channels || [];
-        this.guilds = options.guilds || [];
-        this.userPermissions = options.userPermissions || [];
-        this.clientPermissions = options.clientPermissions || [];
-        this.args = options.args || [];
-        this.client = XernerxClient;
-        this.conditions = this.conditions;
-        this.exec = this.exec;
-    }
-    /**
-     * @param {Message} message - The Discord message event data.
-     * @param {object} args - The arguments you created.
-     * @description make any preconditions here.
-     */
-    async conditions(message, args) { }
-    /**
-     * @param {Message} message - The Discord message event data.
-     * @param {object} args - The arguments you created.
-     * @description Make your custom command here.
-     */
-    async exec(message, args) { }
-}

package/dist/build/XSlashCommandBuilder.d.ts

@@ -1,36 +0,0 @@
-import Discord, { ChannelType, Interaction } from 'discord.js';
-import { SlashCommandOptions } from '../types/options.js';
-import XernerxClient from '../client/XernerxClient.js';
-/**
- * @description - The command builder for slash commands.
- * @param {String} id - The unique ID of the command.
- * @param {SlashCommandOptions} options - The command options.
- */
-export default class SlashCommandBuilder {
-    #private;
-    id: string;
-    data: Discord.SlashCommandBuilder;
-    info?: string;
-    category?: string;
-    owner?: boolean;
-    channelType?: ChannelType | ChannelType[];
-    separator?: string;
-    cooldown?: number;
-    ignoreOwner?: boolean;
-    channels?: string[];
-    guilds?: string[];
-    userPermissions?: bigint[];
-    clientPermissions?: bigint[];
-    args?: object[];
-    subcommands?: object[];
-    groups?: object[];
-    defer?: {
-        reply?: boolean;
-        ephemeral?: boolean;
-        fetchReply?: boolean;
-    };
-    client: XernerxClient | object;
-    constructor(id: string, options: SlashCommandOptions);
-    conditions(interaction: Interaction): Promise<void>;
-    exec(interaction: Interaction): Promise<void>;
-}

package/dist/build/XSlashCommandBuilder.js

@@ -1,114 +0,0 @@
-import Discord, { SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder, } from 'discord.js';
-import { s } from '@sapphire/shapeshift';
-import XernerxError from '../tools/XernerxError.js';
-import XernerxClient from '../client/XernerxClient.js';
-/**
- * @description - The command builder for slash commands.
- * @param {String} id - The unique ID of the command.
- * @param {SlashCommandOptions} options - The command options.
- */
-export default class SlashCommandBuilder {
-    id;
-    data;
-    info;
-    category;
-    owner;
-    channelType;
-    separator;
-    cooldown;
-    ignoreOwner;
-    channels;
-    guilds;
-    userPermissions;
-    clientPermissions;
-    args;
-    subcommands;
-    groups;
-    defer;
-    client;
-    constructor(id, options) {
-        this.id = id;
-        this.data = new Discord.SlashCommandBuilder().setName(options.name).setDescription(options.description);
-        if (options.args && options?.args?.length > 0) {
-            this.#addArgs(this.data, options.args);
-        }
-        if (options.subcommands && options?.subcommands?.length > 0) {
-            this.#addSubcommands(this.data, options.subcommands);
-        }
-        if (options.groups && options?.groups?.length > 0) {
-            this.#addSubcommandGroups(options.groups);
-        }
-        s.object({
-            info: s.string.optional,
-            category: s.string.optional,
-            owner: s.boolean.optional,
-            channelType: s.union(s.number, s.array(s.number)).optional,
-            separator: s.string.optional,
-            cooldown: s.number.optional,
-            ignoreOwner: s.boolean.optional,
-            channels: s.array(s.string).optional,
-            guilds: s.array(s.string).optional,
-            userPermissions: s.array(s.bigint).optional,
-            clientPermissions: s.array(s.bigint).optional,
-            defer: s.object({
-                reply: s.boolean.optional,
-                ephemeral: s.boolean.optional,
-                fetchReply: s.boolean.optional,
-            }).optional,
-        });
-        this.info = options.info;
-        this.category = options.category;
-        this.owner = options.owner;
-        this.channelType = options.channelType;
-        this.separator = options.separator;
-        this.cooldown = options.cooldown;
-        this.ignoreOwner = options.ignoreOwner;
-        this.channels = options.channels;
-        this.guilds = options.guilds;
-        this.userPermissions = options.userPermissions;
-        this.clientPermissions = options.clientPermissions;
-        this.defer = options.defer;
-        this.client = XernerxClient;
-        this.conditions = this.conditions;
-        this.exec = this.exec;
-    }
-    async conditions(interaction) { }
-    async exec(interaction) { }
-    #addArgs(command, args) {
-        const types = ['boolean', 'integer', 'number', 'string', 'user', 'role', 'channel', 'mentionable'];
-        for (const argument of args) {
-            if (!types.includes(argument.type.toLowerCase()))
-                throw new XernerxError(`Expected one of ${types.join(', ')}, received ${argument.type} instead.`);
-            let slashArgumentType = `${argument.type.slice(0, 1).toUpperCase()}${argument.type
-                .slice(1)
-                .toLowerCase()}`;
-            command[`add${slashArgumentType}Option`]((option) => {
-                option
-                    .setName(argument.name)
-                    .setDescription(argument.description)
-                    .setRequired(argument.required || false);
-                if (argument.choices)
-                    option.setChoices(...argument?.choices);
-                return option;
-            });
-        }
-    }
-    #addSubcommands(method, subcommands) {
-        for (const subcommand of subcommands) {
-            let sub = new SlashCommandSubcommandBuilder().setName(subcommand.name).setDescription(subcommand.description);
-            if (subcommand.args?.length > 0)
-                this.#addArgs(sub, subcommand.args);
-            method.addSubcommand(sub);
-        }
-    }
-    #addSubcommandGroups(groups) {
-        for (const group of groups) {
-            let subcommandGroup = new SlashCommandSubcommandGroupBuilder()
-                .setName(group.name)
-                .setDescription(group.description);
-            if (group.subcommands?.length > 0)
-                this.#addSubcommands(subcommandGroup, group.subcommands);
-            this.data.addSubcommandGroup(subcommandGroup);
-        }
-    }
-}

package/dist/models/CommandValidations.d.ts

@@ -1,4 +0,0 @@
-import { Interaction } from 'discord.js';
-import { ContextCommandBuilder, MessageCommandBuilder, SlashCommandBuilder, XernerxClient } from '../main.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/models/CommandValidations.js

@@ -1,183 +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.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, 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.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, command, '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, 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/models/InhibitorValidations.d.ts

@@ -1,12 +0,0 @@
-import { InhibitorType } from "../types/enums.js";
-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>;
-    args(action: XernerxInteraction | XernerxMessage | any, type: InhibitorType): any;
-}

package/dist/models/InhibitorValidations.js

@@ -1,42 +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);
-    }
-}

package/dist/types/enums.d.ts

@@ -1,35 +0,0 @@
-import { SlashCommandStringOption, SlashCommandNumberOption, SlashCommandIntegerOption, SlashCommandBooleanOption, SlashCommandUserOption, SlashCommandChannelOption, SlashCommandRoleOption, SlashCommandMentionableOption } from 'discord.js';
-export declare enum InhibitorType {
-    Member = "Member",
-    User = "User",
-    Guild = "Guild",
-    SlashCommand = "SlashCommand",
-    MessageCommand = "MessageCommand",
-    ContextCommand = "ContextCommand",
-    Command = "Command",
-    Message = "Message",
-    Interaction = "Interaction",
-    Channel = "Channel"
-}
-export declare enum CommandType {
-    Message = "MessageCommand",
-    Slash = "SlashCommand",
-    Context = "ContextCommand",
-    Event = "Event",
-    Inhibitor = "Inhibitor",
-    MessageCommand = "MessageCommand",
-    SlashCommand = "SlashCommand",
-    ContextCommand = "ContextCommand"
-}
-export declare enum ContextCommandType {
-    Message = 3,
-    User = 2
-}
-export declare enum EventEmitterType {
-    Client = "client",
-    Rest = "rest",
-    Process = "process"
-}
-export type SlashCommandOptionChoices = SlashCommandStringOption | SlashCommandNumberOption | SlashCommandIntegerOption;
-export type SlashCommandOption = SlashCommandOptionChoices | SlashCommandBooleanOption | SlashCommandUserOption | SlashCommandChannelOption | SlashCommandRoleOption | SlashCommandMentionableOption;
-export type SlashArgumentTypes = 'String' | 'Number' | 'Boolean' | 'User' | 'Channel' | 'Role' | 'Mentionable' | 'Integer';