xernerx 4.1.0 → 4.2.1

package/dist/mjs/build/SlashCommandBuilder.js

@@ -0,0 +1,121 @@
+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/mjs/client/XernerxClient.d.ts

@@ -0,0 +1,28 @@
+import { Client, Collection } from 'discord.js';
+import ExtensionBuilder from 'xernerx-extension-builder';
+import { ClientUtil } from '../utils/ClientUtil.js';
+import { ClientOptions, DiscordOptions, ExtensionOptions, HandlerOptions } from '../types/options.js';
+import { ClientCache, ClientCommands, ClientModules } from '../types/interfaces.js';
+import EventBuilder from '../build/EventBuilder.js';
+import InhibitorBuilder from '../build/InhibitorBuilder.js';
+/**
+ * @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: ClientOptions;
+    commands: ClientCommands;
+    cache: ClientCache;
+    modules: ClientModules;
+    util: ClientUtil;
+    handlerOptions: HandlerOptions;
+    events: Collection<string, EventBuilder>;
+    extensions: Record<string, ExtensionBuilder>;
+    inhibitors: Collection<string, InhibitorBuilder>;
+    config: object;
+    constructor(discordOptions: DiscordOptions, clientOptions: ClientOptions, config?: object);
+    register(token: string): void;
+    loadAllExtensions(options: ExtensionOptions): Promise<void>;
+}

package/dist/mjs/client/XernerxClient.js

@@ -0,0 +1,108 @@
+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/mjs/handlers/CommandHandler.d.ts

@@ -0,0 +1,27 @@
+import XernerxClient from '../client/XernerxClient.js';
+import { Handler } from './Handler.js';
+import { ContextCommandHandlerOptions, MessageCommandHandlerOptions, SlashCommandHandlerOptions } from '../types/options.js';
+/**
+ * @description - The command handler.
+ * @param {XernerxClient} client - The XernerxClient.
+ */
+export default class CommandHandler {
+    client: XernerxClient;
+    handler: Handler;
+    constructor(client: XernerxClient);
+    /**
+     * @description - The message command loader.
+     * @param {MessageCommandOptions} options - message command loader options.
+     */
+    loadAllMessageCommands(options: MessageCommandHandlerOptions): void;
+    /**
+     * @description - The slash command loader.
+     * @param {SlashCommandOptions} options - slash command loader options.
+     */
+    loadAllSlashCommands(options: SlashCommandHandlerOptions): void;
+    /**
+     * @description - The context command loader.
+     * @param {ContextCommandOptions} options - context command loader options.
+     */
+    loadAllContextCommands(options: ContextCommandHandlerOptions): void;
+}

package/dist/mjs/handlers/CommandHandler.js

@@ -0,0 +1,42 @@
+import { Handler } from './Handler.js';
+import { CommandsDeploy, ContextCommandEvents, MessageCommandEvents, SlashCommandEvents } from '../models/Events.js';
+/**
+ * @description - The command handler.
+ * @param {XernerxClient} client - The XernerxClient.
+ */
+export default class CommandHandler {
+    client;
+    handler;
+    constructor(client) {
+        this.client = client;
+        this.handler = new Handler(client);
+        new CommandsDeploy(this.client).deploy();
+    }
+    /**
+     * @description - The message command loader.
+     * @param {MessageCommandOptions} options - message command loader options.
+     */
+    loadAllMessageCommands(options) {
+        this.handler.loadAllMessageCommands(options);
+        const events = new MessageCommandEvents(this.client);
+        events.messageCreate();
+        events.messageUpdate();
+        events.messageDelete();
+    }
+    /**
+     * @description - The slash command loader.
+     * @param {SlashCommandOptions} options - slash command loader options.
+     */
+    loadAllSlashCommands(options) {
+        this.handler.loadAllSlashCommands(options);
+        new SlashCommandEvents(this.client).slashCreate();
+    }
+    /**
+     * @description - The context command loader.
+     * @param {ContextCommandOptions} options - context command loader options.
+     */
+    loadAllContextCommands(options) {
+        this.handler.loadAllContextCommands(options);
+        new ContextCommandEvents(this.client).contextCreate();
+    }
+}

package/dist/mjs/handlers/EventHandler.d.ts

@@ -0,0 +1,13 @@
+import XernerxClient from '../client/XernerxClient.js';
+import { EventHandlerOptions } from '../types/options.js';
+import { Handler } from './Handler.js';
+export default class EventHandler {
+    client: XernerxClient;
+    handler: Handler;
+    constructor(client: XernerxClient);
+    /**
+     * @description - The event loader
+     * @param {EventLoadOptions} options - message command options
+     */
+    loadAllEvents(options: EventHandlerOptions): void;
+}

package/dist/mjs/handlers/EventHandler.js

@@ -0,0 +1,16 @@
+import { Handler } from './Handler.js';
+export default class EventHandler {
+    client;
+    handler;
+    constructor(client) {
+        this.client = client;
+        this.handler = new Handler(client);
+    }
+    /**
+     * @description - The event loader
+     * @param {EventLoadOptions} options - message command options
+     */
+    loadAllEvents(options) {
+        return this.handler.loadAllEvents(options);
+    }
+}

package/dist/mjs/handlers/Handler.d.ts

@@ -0,0 +1,57 @@
+import XernerxClient from '../client/XernerxClient.js';
+import { ContextCommandHandlerOptions, EventHandlerOptions, InhibitorHandlerOptions, MessageCommandHandlerOptions, SlashCommandHandlerOptions } from '../types/options.js';
+/**
+ * @description - The Handler class.
+ * @param {XernerxClient} client - The XernerxClient.
+ */
+export declare class Handler {
+    private client;
+    commands: object[];
+    readyTimestamp: number;
+    constructor(client: XernerxClient);
+    /**
+     * @description - The loader for the message commands.
+     * @param {MessageCommandOptions} options - The options for the message command loader.
+     */
+    loadAllMessageCommands(options: MessageCommandHandlerOptions): void;
+    /**
+     * @description - The loader for the slash commands.
+     * @param {SlashCommandOptions} options - The options for the slash command loader.
+     */
+    loadAllSlashCommands(options: SlashCommandHandlerOptions): void;
+    /**
+     * @description - The loader for the context commands.
+     * @param {ContextCommandOptions} options - The options for the context command loader.
+     */
+    loadAllContextCommands(options: ContextCommandHandlerOptions): void;
+    /**
+     * @description - The loader for the events.
+     * @param {EventLoadOptions} options - The options for the event loader.
+     */
+    loadAllEvents(options: EventHandlerOptions): void;
+    /**
+     * @description - The loader for the inhibitors.
+     * @param {InhibitorLoadOptions} options - The options for the inhibitor loader.
+     */
+    loadAllInhibitors(options: InhibitorHandlerOptions): void;
+    /**
+     * @description - a reader for directories
+     * @param {string} dir - the directory to look for.
+     * @returns array of files.
+     */
+    private readdir;
+    /**
+     * @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
+     */
+    private load;
+    /**
+     * @description the event emitter to emit all events.
+     * @param {object} event - the event to be emitted.
+     * @returns void
+     */
+    private emitter;
+}

package/dist/mjs/handlers/Handler.js

@@ -0,0 +1,260 @@
+import fs from 'fs';
+import * as path from 'path';
+import { CommandType } from '../types/enums.js';
+import { s } from '@sapphire/shapeshift';
+import { Style } from 'dumfunctions';
+// TODO - Add reload<handlerFunction>
+// TODO - Add unload<handlerFunction>
+// TODO - Rename load<handlerFunction>
+// TODO - Update validator to zod
+/**
+ * @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);
+                });
+        }
+    }
+}