xernerx 3.5.0 → 3.5.2

package/dist/build/InhibitorBuilder.js

@@ -1,27 +0,0 @@
-import { z } from 'zod';
-import XernerxClient from '../client/XernerxClient.js';
-/**
- * @description - The inhibitor builder for inhibitors.
- * @param {String} id - The unique ID of the inhibitor.
- * @param {InhibitorOptions} options - The inhibitor options.
- */
-export default class InhibitorBuilder {
-    id;
-    name;
-    type;
-    client;
-    constructor(id, options) {
-        this.id = id;
-        z.object({
-            name: z.string(),
-            type: z.string(),
-        }).parse(options);
-        this.name = options.name;
-        this.type = options.type;
-        this.client = XernerxClient;
-    }
-    /**
-     * TODO - update description
-     */
-    async check(interaction, args) { }
-}

package/dist/build/MessageCommandBuilder.js

@@ -1,90 +0,0 @@
-import { z } from 'zod';
-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 MessageCommandBuilder {
-    id;
-    name;
-    aliases;
-    separator;
-    description;
-    info;
-    category;
-    prefix;
-    regex;
-    channelType;
-    ignore;
-    strict;
-    permissions;
-    cooldown;
-    args;
-    client;
-    constructor(id, options) {
-        this.id = id;
-        z.object({
-            name: z.string(),
-            aliases: z.array(z.string()).optional(),
-            separator: z.string().min(1).max(1).optional(),
-            description: z.string().optional(),
-            info: z.string().optional(),
-            category: z.string().optional(),
-            prefix: z.array(z.string()).or(z.string()).optional(),
-            regex: z.unknown(),
-            channelType: z.array(z.number()).or(z.number()).optional(),
-            cooldown: z.number().optional(),
-            ignore: z
-                .object({
-                owners: z.boolean().optional(),
-                users: z.array(z.string()).or(z.string()).optional(),
-                channels: z.array(z.string()).or(z.string()).optional(),
-                guilds: z.array(z.string()).or(z.string()).optional(),
-            })
-                .optional(),
-            strict: z
-                .object({
-                owners: z.boolean().optional(),
-                users: z.array(z.string()).or(z.string()).optional(),
-                channels: z.array(z.string()).or(z.string()).optional(),
-                guilds: z.array(z.string()).or(z.string()).optional(),
-            })
-                .optional(),
-            permissions: z
-                .object({
-                client: z.array(z.string()).optional(),
-                users: z.array(z.string()).optional(),
-                dm: z.boolean().optional(),
-            })
-                .optional(),
-        }).parse(options);
-        this.name = options.name;
-        this.aliases = options.aliases;
-        this.separator = options.separator || ' ';
-        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.channelType = options.channelType;
-        this.ignore = options.ignore;
-        this.strict = options.strict;
-        this.permissions = options.permissions;
-        this.cooldown = options.cooldown || 0;
-        this.args = options.args || [];
-        this.client = XernerxClient;
-    }
-    /**
-     * @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/SlashCommandBuilder.js

@@ -1,125 +0,0 @@
-import Discord, { SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder } from 'discord.js';
-import { z } from 'zod';
-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;
-    name;
-    description;
-    info;
-    category;
-    channelType;
-    cooldown;
-    ignore;
-    strict;
-    permissions;
-    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);
-        }
-        z.object({
-            description: z.string(),
-            info: z.string(),
-            category: z.string(),
-            channelType: z.array(z.number()).or(z.number()),
-            cooldown: z.number(),
-            ignore: z.object({
-                owner: z.boolean(),
-                users: z.array(z.string()),
-                channels: z.array(z.string()),
-                guilds: z.array(z.string()),
-            }),
-            strict: z.object({
-                owner: z.boolean(),
-                users: z.array(z.string()),
-                channels: z.array(z.string()),
-                guilds: z.array(z.string()),
-            }),
-            permissions: z.object({
-                client: z.array(z.string()),
-                users: z.array(z.string()),
-                dm: z.boolean(),
-            }),
-            defer: z.object({
-                reply: z.boolean(),
-                ephemeral: z.boolean(),
-                fetch: z.boolean(),
-            }),
-        })
-            .deepPartial()
-            .parse(options);
-        this.name = options.name;
-        this.description = options.description;
-        this.info = options.info;
-        this.category = options.category;
-        this.channelType = options.channelType;
-        this.cooldown = options.cooldown;
-        this.ignore = options.ignore;
-        this.strict = options.strict;
-        this.permissions = options.permissions;
-        this.defer = options.defer;
-        this.client = XernerxClient;
-    }
-    /**
-     * TODO - update description
-     * @param interaction
-     */
-    async conditions(interaction) { }
-    /**
-     * TODO - update description
-     * @param 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/client/XernerxClient.js

@@ -1,101 +0,0 @@
-import { Client, Collection } from 'discord.js';
-import { z } from 'zod';
-import { Style } from 'dumfunctions';
-import { ClientUtil } from '../utils/ClientUtil.js';
-import CommandHandler from '../handlers/CommandHandler.js';
-import EventHandler from '../handlers/EventHandler.js';
-import InhibitorHandler from '../handlers/InhibitorHandler.js';
-import Extensions from '../models/Extensions.js';
-// TODO - Add commandNotFound as an event to the client.
-/**
- * @description - The Client.
- * @param {DiscordOptions} discordOptions - The options for discord.js.
- * @param {ClientOptions} clientOptions - The options for the Xernerx Client.
- * @extends {Client}
- */
-export default class XernerxClient extends Client {
-    settings;
-    commands;
-    cache;
-    modules;
-    util;
-    handlerOptions;
-    events;
-    extensions;
-    inhibitors;
-    config;
-    constructor(discordOptions, clientOptions, config) {
-        super(discordOptions);
-        this.settings = z
-            .object({
-            ownerId: z.string().or(z.array(z.string())).default([]),
-            permissions: z
-                .object({
-                client: z.array(z.string()).default([]),
-                user: z.array(z.string()).default([]),
-                dm: z.boolean().default(false),
-            })
-                .optional(),
-            ignore: z
-                .object({
-                owner: z.boolean().default(false),
-                users: z.array(z.string()),
-                channels: z.array(z.string()),
-                guilds: z.array(z.string()),
-            })
-                .optional(),
-            log: z
-                .object({
-                ready: z.boolean().default(false),
-                error: z.boolean().default(false),
-            })
-                .optional(),
-            cooldown: z
-                .object({
-                command: z.number().default(0),
-                cache: z.number().default(0),
-            })
-                .optional(),
-        })
-            .parse(clientOptions);
-        this.config = config || {};
-        this.commands = {
-            message: new Collection(),
-            slash: new Collection(),
-            context: new Collection(),
-        };
-        this.events = new Collection();
-        this.inhibitors = new Collection();
-        this.cache = {
-            messages: new Collection(),
-            cooldowns: new Collection(),
-            messageCommands: new Collection(),
-            slashCommands: new Collection(),
-            contextCommands: new Collection(),
-            commands: new Collection(),
-        };
-        this.modules = {
-            commandHandler: new CommandHandler(this),
-            eventHandler: new EventHandler(this),
-            inhibitorHandler: new InhibitorHandler(this),
-        };
-        this.extensions = {};
-        this.util = new ClientUtil(this);
-        this.handlerOptions = {};
-        if (this.settings?.log?.ready) {
-            this.once('ready', async (client) => {
-                const size = (await client.guilds.fetch()).size;
-                console.info(Style.log(`Xernerx | ${client.user.tag} signed in watching ${size} server${size > 1 ? 's' : ''}. ${(this.handlerOptions.slash || this.handlerOptions.context)?.guildId
-                    ? `Using ${(await this.guilds.fetch((this.handlerOptions.slash || this.handlerOptions.context)?.guildId || '0')).name} as local guild.`
-                    : ''}`, { color: Style.TextColor.Purple }));
-            });
-        }
-    }
-    register(token) {
-        this.login(token);
-    }
-    loadAllExtensions(options) {
-        const extensions = new Extensions(this);
-        return extensions.load(options.extensions, options.logging || false);
-    }
-}

package/dist/handlers/Handler.js

@@ -1,250 +0,0 @@
-import fs from 'fs';
-import * as path from 'path';
-import { CommandType } from '../types/enums.js';
-import { s } from '@sapphire/shapeshift';
-import { Style } from 'dumfunctions';
-/**
- * @description - The Handler class.
- * @param {XernerxClient} client - The XernerxClient.
- */
-export class Handler {
-    client;
-    commands;
-    readyTimestamp;
-    constructor(client) {
-        this.client = client;
-        this.commands = [];
-        this.readyTimestamp = Number(Date.now());
-    }
-    /**
-     * @description - The loader for the message commands.
-     * @param {MessageCommandOptions} options - The options for the message command loader.
-     */
-    loadAllMessageCommands(options) {
-        this.client.handlerOptions.message = s
-            .object({
-            directory: s.string,
-            prefix: s.union(s.string, s.array(s.string)),
-            allowMention: s.boolean.default(false),
-            cooldown: s.number.default(0),
-            userPermissions: s.array(s.bigint).default([]),
-            clientPermissions: s.array(s.bigint).default([]),
-            handleEdits: s.boolean.default(false),
-            handleDeletes: s.boolean.default(false),
-            handleTyping: s.boolean.default(false),
-            logging: s.boolean.default(false),
-        })
-            .parse(options);
-        const files = this.readdir(options.directory), loaded = [];
-        for (const file of files) {
-            this.load(options.directory, file, CommandType.MessageCommand);
-            loaded.push(file.replace('.js', ''));
-        }
-        if (this.client.handlerOptions.message?.logging)
-            console.info(Style.log(`Xernerx | Loaded ${loaded.length} message commands: ${loaded.join(', ')}.`, {
-                color: Style.TextColor.Cyan,
-            }));
-    }
-    /**
-     * @description - The loader for the slash commands.
-     * @param {SlashCommandOptions} options - The options for the slash command loader.
-     */
-    loadAllSlashCommands(options) {
-        this.client.handlerOptions.slash = s
-            .object({
-            directory: s.string,
-            guildId: s.string,
-            global: s.boolean,
-            cooldown: s.number.default(0),
-            userPermissions: s.array(s.bigint).default([]),
-            clientPermissions: s.array(s.bigint).default([]),
-            logging: s.boolean.default(false),
-            defer: s.object({
-                reply: s.boolean.optional,
-                ephemeral: s.boolean.optional,
-                fetchReply: s.boolean.optional,
-            }).optional,
-        })
-            .parse(options);
-        const files = this.readdir(options.directory), loaded = [];
-        for (const file of files) {
-            this.load(options.directory, file, CommandType.SlashCommand);
-            loaded.push(file.replace('.js', ''));
-        }
-        if (this.client.handlerOptions.slash?.logging)
-            console.info(Style.log(`Xernerx | Loaded ${loaded.length} slash commands: ${loaded.join(', ')}.`, {
-                color: Style.TextColor.Cyan,
-            }));
-    }
-    /**
-     * @description - The loader for the context commands.
-     * @param {ContextCommandOptions} options - The options for the context command loader.
-     */
-    loadAllContextCommands(options) {
-        this.client.handlerOptions.context = s
-            .object({
-            directory: s.string,
-            guildId: s.string,
-            global: s.boolean,
-            cooldown: s.number.default(0),
-            userPermissions: s.array(s.bigint).default([]),
-            clientPermissions: s.array(s.bigint).default([]),
-            logging: s.boolean.default(false),
-            defer: s.object({
-                reply: s.boolean.optional,
-                ephemeral: s.boolean.optional,
-                fetchReply: s.boolean.optional,
-            }).optional,
-        })
-            .parse(options);
-        const files = this.readdir(options.directory), loaded = [];
-        for (const file of files) {
-            this.load(options.directory, file, CommandType.ContextCommand);
-            loaded.push(file.replace('.js', ''));
-        }
-        if (this.client.handlerOptions.context?.logging)
-            console.info(Style.log(`Xernerx | Loaded ${loaded.length} context commands: ${loaded.join(', ')}.`, {
-                color: Style.TextColor.Cyan,
-            }));
-    }
-    /**
-     * @description - The loader for the events.
-     * @param {EventLoadOptions} options - The options for the event loader.
-     */
-    loadAllEvents(options) {
-        this.client.handlerOptions.events = s
-            .object({
-            directory: s.string,
-            logging: s.boolean.default(false),
-        })
-            .parse(options);
-        const files = this.readdir(options.directory), loaded = [];
-        (async () => {
-            for (const file of files) {
-                try {
-                    options.directory.split(/\//).shift();
-                    let event = (await import('file://' + `${path.resolve(options.directory)}/${file}`)).default;
-                    event = new event();
-                    event.client = this.client;
-                    event.commandType = CommandType.Event;
-                    this.client.events.set(event.name, event);
-                    this.emitter(event);
-                }
-                catch (error) {
-                    console.error(Style.log(`Xernerx | Couldn't load ${file} because <${error}>`, { color: Style.BackgroundColor.Red }));
-                }
-                loaded.push(file.replace('.js', ''));
-            }
-            if (this.client.handlerOptions.events?.logging)
-                console.info(Style.log(`Xernerx | Loaded ${loaded.length} events: ${loaded.join(', ')}.`, { color: Style.TextColor.Cyan }));
-        })();
-    }
-    /**
-     * @description - The loader for the inhibitors.
-     * @param {InhibitorLoadOptions} options - The options for the inhibitor loader.
-     */
-    loadAllInhibitors(options) {
-        this.client.handlerOptions.inhibitors = s
-            .object({
-            directory: s.string,
-            logging: s.boolean.default(false),
-        })
-            .parse(options);
-        const files = this.readdir(options.directory), loaded = [];
-        for (const file of files) {
-            this.load(options.directory, file, CommandType.Inhibitor);
-            loaded.push(file.replace('.js', ''));
-        }
-        if (this.client.handlerOptions.inhibitors?.logging)
-            console.info(Style.log(`Xernerx | Loaded ${loaded.length} inhibitors: ${loaded.join(', ')}.`, {
-                color: Style.TextColor.Cyan,
-            }));
-    }
-    /**
-     * @description - a reader for directories
-     * @param {string} dir - the directory to look for.
-     * @returns array of files.
-     */
-    readdir(dir) {
-        try {
-            return fs.readdirSync(path.resolve(dir)).filter((file) => file.endsWith('.js'));
-        }
-        catch (error) {
-            console.error(Style.log(`Xernerx | Couldn't read ${dir} because <${error}>.`, { color: Style.BackgroundColor.Red }));
-        }
-        return [];
-    }
-    /**
-     * @description file loader.
-     * @param {string} dir - the directory.
-     * @param {string} file - the file in the directory.
-     * @param {string} type - the type of file.
-     * @returns undefined
-     */
-    async load(dir, file, type) {
-        try {
-            dir.split(/\//).shift();
-            let command = (await import('file://' + `${path.resolve(dir)}/${file}`)).default;
-            command = new command();
-            command.client = this.client;
-            command.commandType = type;
-            command.filepath = `${path.resolve(dir)}\\${file}`;
-            command.file = file;
-            if (type === CommandType.MessageCommand)
-                this.client.commands.message.set(command?.name || command?.name, command);
-            if (type === CommandType.SlashCommand) {
-                this.client.commands.slash.set(command?.data?.name || command?.name, command);
-            }
-            if (type === CommandType.ContextCommand) {
-                this.client.commands.context.set(command?.data?.name || command?.name, command);
-            }
-            if (type === CommandType.Event) {
-                this.client.events.set(command.name, command);
-            }
-            if (type === CommandType.Inhibitor) {
-                this.client.inhibitors.set(command.name, command);
-            }
-        }
-        catch (error) {
-            console.error(Style.log(`Xernerx | Couldn't load ${file} because <${error}>`, { color: Style.BackgroundColor.Red }));
-        }
-    }
-    /**
-     * @description the event emitter to emit all events.
-     * @param {object} event - the event to be emitted.
-     * @returns void
-     */
-    emitter(event) {
-        const client = this.client;
-        if (event.emitter === 'client') {
-            if (event.once)
-                client.once(event.name, (...args) => {
-                    event.run(...args);
-                });
-            else
-                client.on(event.name, (...args) => {
-                    event.run(...args);
-                });
-        }
-        else if (event.emitter === 'rest') {
-            if (event.once)
-                client.once(event.name, (...args) => {
-                    event.run(...args);
-                });
-            else
-                client.on(event.name, (...args) => {
-                    event.run(...args);
-                });
-        }
-        else if (event.emitter === 'process') {
-            if (event.once)
-                process.once(event.name, (...args) => {
-                    event.run(...args);
-                });
-            else
-                process.on(event.name, (...args) => {
-                    event.run(...args);
-                });
-        }
-    }
-}