xernerx 4.2.0 → 4.2.1

package/dist/mjs/models/Events.js

@@ -0,0 +1,295 @@
+import { GatewayVersion, InteractionType, REST, Routes } from 'discord.js';
+import { InteractionCommandUtil, MessageCommandUtil } from '../utils/CommandUtil.js';
+import { InteractionArguments, messageArguments } from './CommandArguments.js';
+import commandValidation from '../validators/CommandValidations.js';
+import { Style } from 'dumfunctions';
+import { InhibitorValidation } from '../validators/InhibitorValidations.js';
+export class MessageCommandEvents {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    messageCreate() {
+        this.client.on('messageCreate', async (message) => {
+            if (!message.author.bot) {
+                let command = undefined,
+                    px = undefined;
+                message.author.isOwner = this.client.util.isOwner(message.author.id);
+                message.util = new MessageCommandUtil(this.client, message);
+                const commands = this.client.commands.message;
+                commands
+                    .filter((c) => !c.regex)
+                    .map(async (cmd) => {
+                        if (cmd.prefix) {
+                            cmd.prefix.map((prefix) => {
+                                if (message.content.startsWith(prefix)) {
+                                    command = message.content.replace(prefix, '').split(/ +/).shift();
+                                    px = prefix;
+                                }
+                            });
+                        }
+                        if (this.client.handlerOptions.message?.prefix) {
+                            const prefix = Array.isArray(this.client.handlerOptions.message.prefix) ? this.client.handlerOptions.message.prefix : [this.client.handlerOptions.message.prefix];
+                            prefix.map((prefix) => {
+                                if (message.content.startsWith(prefix)) {
+                                    command = message.content.replace(prefix, '').split(/ +/).shift();
+                                    px = prefix;
+                                }
+                            });
+                        }
+                        if (this.client.handlerOptions.message?.allowMention) {
+                            if (message.mentions.users.has(this.client.user?.id) || message.mentions.repliedUser?.id === this.client.user?.id) {
+                                command = message.content.replace(`<@${this.client.user?.id}>`, '').trim().split(/ +/).shift();
+                                px = 'MentionPrefix';
+                            }
+                        }
+                        const prefix = Array.isArray(this.client.handlerOptions.message?.prefix) ? this.client.handlerOptions.message?.prefix : [this.client.handlerOptions.message?.prefix];
+                        if (
+                            (cmd.name.toLowerCase() == command?.toLowerCase() || cmd.aliases?.map((c) => c.toLowerCase())?.includes(command?.toLowerCase())) &&
+                            (cmd.prefix.includes(px) || prefix?.includes(px) || px === 'MentionPrefix')
+                        ) {
+                            try {
+                                if (this.client.handlerOptions.message?.handleTyping) message.channel.sendTyping();
+                                const inhibitor = new InhibitorValidation(this.client, message, command);
+                                if (commandValidation(message, cmd, this.client)) return;
+                                if (await inhibitor.inhibit()) return;
+                                if (cmd.conditions && (await cmd.conditions(message, await messageArguments(message, cmd)))) return;
+                                await cmd.exec(message, await messageArguments(message, cmd));
+                                this.client.emit('commandRun', message, cmd);
+                            } catch (error) {
+                                return this.client.emit('commandError', message, error, cmd);
+                            }
+                        }
+                    });
+            }
+        });
+    }
+    messageUpdate() {
+        this.client.on('messageUpdate', async (old, message) => {
+            message = message;
+            if (!message.author?.bot) {
+                let command = undefined,
+                    px = undefined;
+                if (message.author) message.author.isOwner = this.client.util.isOwner(message.author.id);
+                message.util = new MessageCommandUtil(this.client, message);
+                const commands = this.client.commands.message;
+                commands
+                    .filter((c) => !c.regex)
+                    .map(async (cmd) => {
+                        if (cmd.prefix) {
+                            cmd.prefix.map((prefix) => {
+                                if (message?.content?.startsWith(prefix)) {
+                                    command = message.content.replace(prefix, '').split(/ +/).shift();
+                                    px = prefix;
+                                }
+                            });
+                        }
+                        if (this.client.handlerOptions.message?.prefix) {
+                            const prefix = Array.isArray(this.client.handlerOptions.message.prefix) ? this.client.handlerOptions.message.prefix : [this.client.handlerOptions.message.prefix];
+                            prefix.map((prefix) => {
+                                if (message?.content?.startsWith(prefix)) {
+                                    command = message.content.replace(prefix, '').split(/ +/).shift();
+                                    px = prefix;
+                                }
+                            });
+                        }
+                        if (this.client.handlerOptions.message?.allowMention) {
+                            if (message.mentions.users.has(this.client.user?.id || '') || message.mentions.repliedUser?.id === this.client.user?.id) {
+                                command = message?.content?.replace(`<@${this.client.user?.id}>`, '').trim().split(/ +/).shift();
+                                px = 'MentionPrefix';
+                            }
+                        }
+                        const prefix = Array.isArray(this.client.handlerOptions.message?.prefix) ? this.client.handlerOptions.message?.prefix : [this.client.handlerOptions.message?.prefix];
+                        if (
+                            (cmd.name.toLowerCase() == command?.toLowerCase() || cmd.aliases?.map((c) => c.toLowerCase())?.includes(command?.toLowerCase())) &&
+                            (cmd.prefix.includes(px) || prefix?.includes(px) || px === 'MentionPrefix')
+                        ) {
+                            try {
+                                if (this.client.handlerOptions.message?.handleTyping) message.channel.sendTyping();
+                                message = message;
+                                const inhibitor = new InhibitorValidation(this.client, message, command);
+                                if (commandValidation(message, cmd, this.client)) return;
+                                if (await inhibitor.inhibit()) return;
+                                if (cmd.conditions && (await cmd.conditions(message, await messageArguments(message, cmd)))) return;
+                                await cmd.exec(message, await messageArguments(message, cmd));
+                                this.client.emit('commandRun', message, cmd);
+                            } catch (error) {
+                                return this.client.emit('commandError', message, error, cmd);
+                            }
+                        }
+                    });
+            }
+        });
+    }
+    messageDelete() {
+        this.client.on('messageDelete', async (message) => {
+            if (this.client.cache.messages.has(message.id) && this.client.handlerOptions.message?.handleDeletes) {
+                try {
+                    if (this.client.handlerOptions.message?.handleTyping) message.channel.sendTyping();
+                    const msg = this.client.cache.messages.get(message.id);
+                    const response = await message.channel.messages.fetch(msg?.response);
+                    await response.delete();
+                } catch (error) {
+                    this.client.emit('commandError', message, error, null);
+                }
+            }
+        });
+    }
+}
+export class SlashCommandEvents {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    slashCreate() {
+        this.client.on('interactionCreate', async (interaction) => {
+            interaction.util = new InteractionCommandUtil(this.client, interaction);
+            interaction.user.isOwner = this.client.util.isOwner(interaction.user.id);
+            if (interaction.type === InteractionType.ApplicationCommand) {
+                if (this.client.commands.slash.has(interaction.commandName)) {
+                    let command = this.client.commands.slash.get(interaction.commandName);
+                    const argumentsInfo = new InteractionArguments(interaction);
+                    try {
+                        const inhibitor = new InhibitorValidation(this.client, interaction, command);
+                        if (await inhibitor.inhibit()) return;
+                        if (commandValidation(interaction, command, this.client)) return;
+                        if (command.defer?.reply !== false && this.client.handlerOptions.slash?.defer?.reply)
+                            await interaction.deferReply({
+                                ephemeral: this.client.handlerOptions.slash?.defer?.ephemeral,
+                                fetchReply: this.client.handlerOptions.slash?.defer?.fetchReply,
+                            });
+                        if (!(interaction.deferred || interaction.replied) && command.defer?.reply)
+                            await interaction.deferReply({
+                                ephemeral: command.defer?.ephemeral,
+                                fetchReply: command.defer?.fetchReply,
+                            });
+                        if (
+                            command.conditions &&
+                            (await command.conditions(interaction, {
+                                group: argumentsInfo.group(),
+                                subcommand: argumentsInfo.subcommand(),
+                                args: await argumentsInfo.arguments(),
+                            }))
+                        )
+                            return;
+                        await command.exec(interaction, {
+                            group: argumentsInfo.group(),
+                            subcommand: argumentsInfo.subcommand(),
+                            args: await argumentsInfo.arguments(),
+                        });
+                        this.client.emit('commandRun', interaction, command);
+                    } catch (error) {
+                        this.client.emit('commandError', interaction, error, command);
+                    }
+                }
+            }
+        });
+    }
+}
+export class ContextCommandEvents {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    contextCreate() {
+        this.client.on('interactionCreate', async (interaction) => {
+            interaction.util = new InteractionCommandUtil(this.client, interaction);
+            interaction.user.isOwner = this.client.util.isOwner(interaction.user.id);
+            if (interaction.type === InteractionType.ApplicationCommand) {
+                if (this.client.commands.context.has(interaction.commandName)) {
+                    let command = this.client.commands.context.get(interaction.commandName);
+                    try {
+                        const inhibitor = new InhibitorValidation(this.client, interaction, command);
+                        if (commandValidation(interaction, command, this.client)) return;
+                        if (await inhibitor.inhibit()) return;
+                        if (command.conditions && (await command.conditions(interaction))) return;
+                        if (command.defer?.reply !== false && this.client.handlerOptions.context?.defer?.reply)
+                            await interaction.deferReply({
+                                ephemeral: this.client.handlerOptions.context?.defer?.ephemeral,
+                                fetchReply: this.client.handlerOptions.context?.defer?.fetchReply,
+                            });
+                        if (!(interaction.deferred || interaction.replied) && command.defer?.reply)
+                            await interaction.deferReply({
+                                ephemeral: command.defer?.ephemeral,
+                                fetchReply: command.defer?.fetchReply,
+                            });
+                        let args = {};
+                        if (command.type === 3) args = await interaction.channel.messages.fetch(interaction.targetId);
+                        if (command.type === 2) args = await this.client.users.fetch(interaction.targetId);
+                        await command.exec(interaction, args);
+                        this.client.emit('commandRun', interaction, command);
+                    } catch (error) {
+                        this.client.emit('commandError', interaction, error, command);
+                    }
+                }
+            }
+        });
+    }
+}
+export class CommandsDeploy {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    deploy() {
+        this.client.once('ready', async (client) => {
+            const slashCommands = [],
+                contextCommands = [];
+            this.client.commands.context.map((command) => (command.data ? contextCommands.push(command.data.toJSON()) : null));
+            this.client.commands.slash.map((command) => (command.data ? slashCommands.push(command.data.toJSON()) : null));
+            try {
+                const global = {
+                    slash: this.client.handlerOptions.slash?.global,
+                    context: this.client.handlerOptions.context?.global,
+                };
+                const guild = {
+                    slash: this.client.handlerOptions.slash?.guildId,
+                    context: this.client.handlerOptions.context?.guildId,
+                };
+                if (!guild.slash && !guild.context) return;
+                if (global.slash && global.context) {
+                    if (guild.slash !== guild.context)
+                        console.info(
+                            Style.log(
+                                `Xernerx | Warning: slash and context commands are both set to global, but don't have a matching guildId, using ${
+                                    (await this.client.guilds.fetch(this.client.handlerOptions.slash?.guildId)).name
+                                }!`,
+                                { color: Style.TextColor.Red }
+                            )
+                        );
+                    this.put('global', guild.slash, [...contextCommands, ...slashCommands]);
+                    this.put('guild', guild.slash, []);
+                }
+                if (global.slash && global.context === false) {
+                    this.put('global', guild.slash, slashCommands);
+                }
+                if (global.slash === false && global.context) {
+                    this.put('global', guild.context, contextCommands);
+                }
+                if (global.slash === false && global.context === false) {
+                    this.put('guild', guild.slash, [...contextCommands, ...slashCommands]);
+                }
+                if (this.client.handlerOptions.context?.logging || this.client.handlerOptions.slash?.logging)
+                    console.info(
+                        Style.log(
+                            `Xernerx | Deployed ${slashCommands.length} slash commands ${global.slash ? 'globally' : 'locally'} and ${contextCommands.length} context commands ${
+                                global.context ? 'globally' : 'locally'
+                            }.`,
+                            { color: Style.TextColor.Purple }
+                        )
+                    );
+            } catch (error) {
+                console.error(
+                    Style.log(`Xernerx | Couldn't deploy interaction commands because <${error}>.`, {
+                        color: Style.BackgroundColor.Red,
+                    })
+                );
+            }
+        });
+    }
+    put(type, guild, body) {
+        const rest = new REST({ version: GatewayVersion }).setToken(this.client.token);
+        if (type === 'guild') rest.put(Routes.applicationGuildCommands(this.client.user?.id, guild), { body });
+        else rest.put(Routes.applicationCommands(this.client.user?.id), { body });
+    }
+}

package/dist/mjs/models/Extensions.d.ts

@@ -0,0 +1,7 @@
+import XernerxExtensionBuilder from 'xernerx-extension-builder';
+import XernerxClient from '../client/XernerxClient.js';
+export default class Extensions {
+    client: XernerxClient;
+    constructor(client: XernerxClient);
+    load(extensions: Array<XernerxExtensionBuilder>, logging?: boolean): Promise<void>;
+}

package/dist/mjs/models/Extensions.js

@@ -0,0 +1,23 @@
+import { Style } from 'dumfunctions';
+export default class Extensions {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async load(extensions, logging = false) {
+        const exts = [];
+        extensions.map((extension) => {
+            try {
+                this.client.extensions[extension.name] = extension;
+                exts.push(extension.name);
+            } catch (error) {
+                console.error(
+                    Style.log(`Xernerx | An error occurred trying to load ${extension.name}, error: <${error}>`, {
+                        color: Style.BackgroundColor.Red,
+                    })
+                );
+            }
+        });
+        if (logging) console.info(Style.log(`Xernerx | Loaded ${exts.length} extensions: ${exts.join(', ')}`, { color: Style.TextColor.Cyan }));
+    }
+}

package/dist/mjs/tools/XernerxError.d.ts

@@ -0,0 +1,5 @@
+export default class XernerxError {
+    name: string;
+    message: string;
+    constructor(message?: string);
+}

package/dist/mjs/tools/XernerxError.js

@@ -0,0 +1,8 @@
+export default class XernerxError {
+    name;
+    message;
+    constructor(message) {
+        this.name = 'XernerxError';
+        this.message = message || '';
+    }
+}

package/dist/mjs/tools/package.d.ts

@@ -0,0 +1,49 @@
+declare const _default: {
+    name: string;
+    version: string;
+    type: string;
+    description: string;
+    main: string;
+    keywords: string[];
+    author: string;
+    license: string;
+    homepage: string;
+    packageManager: string;
+    exports: {
+        import: string;
+        require: string;
+        types: string;
+        node: null;
+        default: null;
+    };
+    scripts: {
+        start: string;
+        patch: string;
+        minor: string;
+        major: string;
+        site: string;
+        commit: string;
+        write: string;
+        build: string;
+    };
+    repository: {
+        type: string;
+        url: string;
+    };
+    bugs: {
+        url: string;
+    };
+    dependencies: {
+        '@sapphire/shapeshift': string;
+        'discord.js': string;
+        dumfunctions: string;
+        'xernerx-extension-builder': string;
+        zod: string;
+    };
+    devDependencies: {
+        prettier: string;
+        tsup: string;
+        typescript: string;
+    };
+};
+export default _default;

package/dist/mjs/tools/package.js

@@ -0,0 +1,48 @@
+export default {
+    name: 'xernerx',
+    version: '3.5.1',
+    type: 'module',
+    description: 'A bot framework for discord.js.',
+    main: 'dist/main.js',
+    keywords: ['discord.js', 'discord', 'framework', 'mjs', 'esm', 'cjs', 'ts'],
+    author: 'Dummi',
+    license: 'MIT',
+    homepage: 'https://xernerx.github.io/xernerx/home.html',
+    packageManager: 'npm@8.5.5',
+    exports: {
+        import: './dist/main.js',
+        require: './dist/main.cjs',
+        types: './types',
+        node: null,
+        default: null,
+    },
+    scripts: {
+        start: 'npm i && npm fund && npm audit fix --force && npm link && tsc -w',
+        patch: 'npm run write && git add . && npm run commit && npm version patch && npm publish && git push',
+        minor: 'npm run write && git add . && npm run commit && npm version minor && npm publish && git push',
+        major: 'npm run write && git add . && npm run commit && npm version major && npm publish && git push',
+        site: 'git add docs && npm run commit && git push',
+        commit: 'node ../.scripts/commit.js',
+        write: 'npm run build && node ../.scripts/rewritePackage.js ',
+        build: 'tsc && npx tsup src/main.ts && npx prettier --write src',
+    },
+    repository: {
+        type: 'git',
+        url: 'git+https://github.com/xernerx/xernerx.git',
+    },
+    bugs: {
+        url: 'https://github.com/xernerx/xernerx/issues',
+    },
+    dependencies: {
+        '@sapphire/shapeshift': '^3.8.1',
+        'discord.js': '^14.7.1',
+        dumfunctions: '^2.1.1',
+        'xernerx-extension-builder': '^0.0.5',
+        zod: '^3.20.6',
+    },
+    devDependencies: {
+        prettier: '^2.8.4',
+        tsup: '^6.6.0',
+        typescript: '^4.9.5',
+    },
+};

package/dist/mjs/types/enums.d.ts

@@ -0,0 +1,44 @@
+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';

package/dist/mjs/types/enums.js

@@ -0,0 +1,35 @@
+export var InhibitorType;
+(function (InhibitorType) {
+    InhibitorType['Member'] = 'Member';
+    InhibitorType['User'] = 'User';
+    InhibitorType['Guild'] = 'Guild';
+    InhibitorType['SlashCommand'] = 'SlashCommand';
+    InhibitorType['MessageCommand'] = 'MessageCommand';
+    InhibitorType['ContextCommand'] = 'ContextCommand';
+    InhibitorType['Command'] = 'Command';
+    InhibitorType['Message'] = 'Message';
+    InhibitorType['Interaction'] = 'Interaction';
+    InhibitorType['Channel'] = 'Channel';
+})((InhibitorType = InhibitorType || (InhibitorType = {})));
+export var CommandType;
+(function (CommandType) {
+    CommandType['Message'] = 'MessageCommand';
+    CommandType['Slash'] = 'SlashCommand';
+    CommandType['Context'] = 'ContextCommand';
+    CommandType['Event'] = 'Event';
+    CommandType['Inhibitor'] = 'Inhibitor';
+    CommandType['MessageCommand'] = 'MessageCommand';
+    CommandType['SlashCommand'] = 'SlashCommand';
+    CommandType['ContextCommand'] = 'ContextCommand';
+})((CommandType = CommandType || (CommandType = {})));
+export var ContextCommandType;
+(function (ContextCommandType) {
+    ContextCommandType[(ContextCommandType['Message'] = 3)] = 'Message';
+    ContextCommandType[(ContextCommandType['User'] = 2)] = 'User';
+})((ContextCommandType = ContextCommandType || (ContextCommandType = {})));
+export var EventEmitterType;
+(function (EventEmitterType) {
+    EventEmitterType['Client'] = 'client';
+    EventEmitterType['Rest'] = 'rest';
+    EventEmitterType['Process'] = 'process';
+})((EventEmitterType = EventEmitterType || (EventEmitterType = {})));

package/dist/mjs/types/interfaces.d.ts

@@ -0,0 +1,25 @@
+import { Collection } from 'discord.js';
+import CommandHandler from '../handlers/CommandHandler.js';
+import EventHandler from '../handlers/EventHandler.js';
+import InhibitorHandler from '../handlers/InhibitorHandler.js';
+import MessageCommandBuilder from '../build/MessageCommandBuilder.js';
+import ContextCommandBuilder from '../build/ContextCommandBuilder.js';
+import SlashCommandBuilder from '../build/SlashCommandBuilder.js';
+export interface ClientCommands {
+    message: Collection<string, MessageCommandBuilder>;
+    slash: Collection<string, SlashCommandBuilder>;
+    context: Collection<string, ContextCommandBuilder>;
+}
+export interface ClientCache {
+    messages: Collection<string, object>;
+    cooldowns: Collection<string, object>;
+    messageCommands: Collection<string, object>;
+    slashCommands: Collection<string, object>;
+    contextCommands: Collection<string, object>;
+    commands: Collection<string, object>;
+}
+export interface ClientModules {
+    commandHandler: CommandHandler;
+    eventHandler: EventHandler;
+    inhibitorHandler: InhibitorHandler;
+}

package/dist/mjs/types/interfaces.js

@@ -0,0 +1 @@
+export {};