xernerx 4.5.23 → 4.5.26

package/dist/handlers/CommandHandler.d.ts

@@ -3,13 +3,13 @@ import XernerxClient from '../client/XernerxClient.js';
 import { ContextHandlerOptions, MessageHandlerOptions, SlashHandlerOptions } from '../types/interfaces.js';
 import Handler from './Handler.js';
 export default class CommandHandler extends Handler {
-	constructor(client: XernerxClient);
-	loadMessageCommands(options: MessageHandlerOptions): void;
-	loadSlashCommands(options: SlashHandlerOptions): void;
-	loadContextCommands(options: ContextHandlerOptions): void;
-	private messageCommandRun;
-	private slashCommandRun;
-	private contextCommandRun;
-	private exec;
+    constructor(client: XernerxClient);
+    loadMessageCommands(options: MessageHandlerOptions): void;
+    loadSlashCommands(options: SlashHandlerOptions): void;
+    loadContextCommands(options: ContextHandlerOptions): void;
+    private messageCommandRun;
+    private slashCommandRun;
+    private contextCommandRun;
+    private exec;
 }
-//# sourceMappingURL=CommandHandler.d.ts.map
+//# sourceMappingURL=CommandHandler.d.ts.map

package/dist/handlers/CommandHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CommandHandler.d.ts","sourceRoot":"","sources":["../../src/handlers/CommandHandler.ts"],"names":[],"mappings":"AAAA,cAAc;AAMd,OAAO,aAAa,MAAM,4BAA4B,CAAC;AACvD,OAAO,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAC3G,OAAO,OAAO,MAAM,cAAc,CAAC;AAenC,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,OAAO;gBACtC,MAAM,EAAE,aAAa;IAI1B,mBAAmB,CAAC,OAAO,EAAE,qBAAqB;IA2DlD,iBAAiB,CAAC,OAAO,EAAE,mBAAmB;IA4C9C,mBAAmB,CAAC,OAAO,EAAE,qBAAqB;YA4C3C,iBAAiB;YAwHjB,eAAe;YA+Bf,iBAAiB;YAoBjB,IAAI;CAoBlB"}
+{"version":3,"file":"CommandHandler.d.ts","sourceRoot":"","sources":["../../src/handlers/CommandHandler.ts"],"names":[],"mappings":"AAAA,cAAc;AAMd,OAAO,aAAa,MAAM,4BAA4B,CAAC;AACvD,OAAO,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAC3G,OAAO,OAAO,MAAM,cAAc,CAAC;AAenC,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,OAAO;gBACtC,MAAM,EAAE,aAAa;IAI1B,mBAAmB,CAAC,OAAO,EAAE,qBAAqB;IA2DlD,iBAAiB,CAAC,OAAO,EAAE,mBAAmB;IA4C9C,mBAAmB,CAAC,OAAO,EAAE,qBAAqB;YA4C3C,iBAAiB;YA8HjB,eAAe;YA+Bf,iBAAiB;YAoBjB,IAAI;CAoBlB"}

package/dist/handlers/CommandHandler.js

@@ -12,253 +12,285 @@ import { interactionArguments, messageArguments } from '../models/Arguments.js';
 import { inhibitorValidation } from '../validators/inhibitorValidations.js';
 import { Style } from 'dumfunctions';
 export default class CommandHandler extends Handler {
-	constructor(client) {
-		super(client);
-	}
-	loadMessageCommands(options) {
-		if (!this.client.options.intents.has(GatewayIntentBits.MessageContent)) new XernerxLog(this.client).warn(`Message commands might not work as you're missing the intent MessageContent!`);
-		if (!this.client.options.intents.has(GatewayIntentBits.GuildMessages)) new XernerxLog(this.client).warn(`Message commands might not work as you're missing the intent GuildMessages!`);
-		options = z
-			.object({
-				directory: z.string(),
-				prefix: z.string().or(z.array(z.string())),
-				allowMention: z.boolean().default(false),
-				cooldown: z.number().default(0),
-				permissions: z
-					.object({
-						user: z.array(z.string()).default([]),
-						client: z.array(z.string()).default([]),
-						dm: z.boolean().default(true),
-					})
-					.default({}),
-				handleEdits: z.boolean().default(false),
-				handleDeletes: z.boolean().default(false),
-				handleTyping: z.boolean().default(false),
-				logging: z.boolean().default(false),
-			})
-			.parse(options);
-		this.client.modules.options.message = options;
-		const files = this.readdir(options.directory);
-		for (const file of files) {
-			const filepath = `${path.resolve(options.directory)}\\${file}`;
-			this.load(filepath, 'MessageCommand');
-		}
-		new XernerxLog(this.client).info(`Loaded ${Style.log(String(files.length), { color: Style.TextColor.Cyan })} Message Commands.`);
-		this.emit({
-			name: 'messageCreate',
-			filetype: 'MessageCommand',
-			run: (message) => this.messageCommandRun(message),
-		});
-		this.emit({
-			name: 'messageUpdate',
-			filetype: 'MessageCommand',
-			run: (message, message2) => this.messageCommandRun(message, message2),
-		});
-		this.emit({
-			name: 'messageDelete',
-			filetype: 'MessageCommand',
-			run: (message) => this.messageCommandRun(message, 'delete'),
-		});
-	}
-	// public reloadMessageCommands() {
-	//     return reload(this.client, 'message');
-	// }
-	loadSlashCommands(options) {
-		if (!this.client.settings.local) new XernerxLog(this.client).warn(`Slash commands might not work as you haven't specified a local guild ID.`);
-		options = z
-			.object({
-				directory: z.string(),
-				cooldown: z.number().default(0),
-				permissions: z
-					.object({
-						user: z.array(z.string()).default([]),
-						client: z.array(z.string()).default([]),
-						dm: z.boolean().default(true),
-					})
-					.default({}),
-				logging: z.boolean().default(false),
-				defer: z
-					.object({
-						reply: z.boolean().default(false),
-						ephemeral: z.boolean().default(false),
-						fetchReply: z.boolean().default(false),
-					})
-					.default({}),
-			})
-			.parse(options);
-		this.client.modules.options.slash = options;
-		const files = this.readdir(options.directory);
-		for (const file of files) {
-			const filepath = `${path.resolve(options.directory)}\\${file}`;
-			this.load(filepath, 'SlashCommand');
-		}
-		new XernerxLog(this.client).info(`Loaded ${Style.log(String(files.length), { color: Style.TextColor.Cyan })} Slash Commands.`);
-		this.emit({
-			name: 'interactionCreate',
-			filetype: 'SlashCommand',
-			run: (interaction) => this.slashCommandRun(interaction),
-		});
-	}
-	loadContextCommands(options) {
-		if (!this.client.settings.local) new XernerxLog(this.client).warn(`Context commands might not work as you haven't specified a local guild ID.`);
-		options = z
-			.object({
-				directory: z.string(),
-				cooldown: z.number().default(0),
-				permissions: z
-					.object({
-						user: z.array(z.string()).default([]),
-						client: z.array(z.string()).default([]),
-						dm: z.boolean().default(true),
-					})
-					.default({}),
-				logging: z.boolean().default(false),
-				defer: z
-					.object({
-						reply: z.boolean().default(false),
-						ephemeral: z.boolean().default(false),
-						fetchReply: z.boolean().default(false),
-					})
-					.default({}),
-			})
-			.parse(options);
-		this.client.modules.options.context = options;
-		const files = this.readdir(options.directory);
-		for (const file of files) {
-			const filepath = `${path.resolve(options.directory)}\\${file}`;
-			this.load(filepath, 'ContextCommand');
-		}
-		new XernerxLog(this.client).info(`Loaded ${Style.log(String(files.length), { color: Style.TextColor.Cyan })} Context Commands.`);
-		this.emit({
-			name: 'interactionCreate',
-			filetype: 'ContextCommand',
-			run: (interaction) => this.contextCommandRun(interaction),
-		});
-	}
-	async messageCommandRun(message, message2) {
-		const filetype = 'MessageCommand';
-		if (message.author.id === this.client.user?.id && this.client.settings.ignore?.self) return;
-		else if (message.author.bot && this.client.settings.ignore?.bots) return;
-		if (message.system && this.client.settings.ignore?.system) return;
-		message.util = new MessageUtil(this.client, message);
-		message.user = await xernerxUser(message, this.client);
-		if (typeof message2 === 'object') message = message2;
-		if (message2 === 'delete' && this.client.modules.options.message?.handleDeletes) {
-			if (!this.client.cache.messages.has(message.id)) return;
-			const id = this.client.cache.messages.get(message.id);
-			if (!id) return;
-			(async () => {
-				const msg = await message.channel.messages.fetch(id);
-				await msg.delete();
-				this.client.cache.messages.delete(message.id);
-			})();
-			return;
-		}
-		if (message.content && this.client.modules.options.message) {
-			const commands = this.client.commands.message;
-			const prefixes = Array.isArray(this.client.modules.options.message.prefix) ? this.client.modules.options.message.prefix : [this.client.modules.options.message.prefix];
-			let commandName = null,
-				cmd,
-				commandAlias = null,
-				commandPrefix = null;
-			commands.map((command) => {
-				let prefix = null;
-				if (command.regex && message.content.match(command.regex)) {
-					const [match] = message.content.match(command.regex) || [null];
-					if (match) commandName = command.name;
-				}
-				const cp = Array.isArray(command.prefix) ? command.prefix : [command.prefix];
-				prefixes.map((p) => {
-					if (message.content.startsWith(p)) prefix = p;
-				});
-				cp.map((p) => {
-					if (message.content.startsWith(p)) prefix = p;
-				});
-				if (!prefix) return;
-				if (!commandName)
-					commandName =
-						message.content
-							.replace(prefix, '')
-							.split(command.separator || / +/)
-							.shift()
-							?.trim()
-							?.toLowerCase() || '';
-				if (!this.client.commands.message.has(commandName) && command.aliases?.includes(commandName)) {
-					commandAlias = commandName;
-					commandName = command.name;
-				}
-				commandAlias = commandAlias ? commandAlias : commandName;
-				commandPrefix = prefix;
-			});
-			if (!cmd && this.client.modules.options.message.allowMention) {
-				if (message.mentions.users.has(this.client.user?.id) || message.mentions.repliedUser?.id === this.client.user?.id) {
-					commandName = message.content.replace(`<@${this.client.user?.id}>`, '').trim().split(/ +/).shift()?.toLowerCase() || null;
-					commands.map((command) => {
-						if (command.aliases?.includes(commandName)) {
-							commandName = command.name;
-							return (commandAlias = commandName);
-						}
-					});
-					commandPrefix = `<@${this.client.user?.id}>`;
-				}
-			}
-			if (this.client.commands.message.has(commandName)) {
-				if (this.client.modules.options.message?.handleTyping) message.channel.sendTyping();
-				cmd = this.client.commands.message.get(commandName);
-			}
-			if (!commandPrefix || !commandName) return;
-			if (!cmd) return await this.client.emit('commandNotFound', message, commandName, filetype);
-			if (await inhibitorValidation(message, cmd)) return;
-			message.util.parsed = {
-				alias: commandAlias,
-				prefix: commandPrefix,
-			};
-			this.client.emit('commandStart', message, cmd, filetype);
-			return await this.exec(cmd, message, await messageArguments(message, cmd, commandPrefix), filetype);
-		}
-	}
-	async slashCommandRun(interaction) {
-		const filetype = 'SlashCommand';
-		interaction.util = new InteractionUtil(this.client, interaction);
-		interaction.user = await xernerxUser(interaction, this.client);
-		let cmd = null;
-		if (this.client.commands.slash.has(interaction.commandName)) cmd = this.client.commands.slash.get(interaction.commandName);
-		if (await inhibitorValidation(interaction, cmd)) return;
-		if (!cmd) return this.client.emit('commandNotFound', interaction, interaction.commandName, filetype);
-		new Promise(async (resolve) => {
-			if (interaction.isAutocomplete()) {
-				const focused = interaction.options.getFocused(true);
-				const options = interaction.options;
-				await cmd.autocomplete(interaction, focused, options);
-			} else resolve(true);
-		})
-			.then(async () => {
-				this.client.emit('commandStart', interaction, filetype);
-				return await this.exec(cmd, interaction, await interactionArguments(interaction, cmd), filetype);
-			})
-			.catch((error) => this.client.emit('commandError', interaction, error, cmd, filetype));
-	}
-	async contextCommandRun(interaction) {
-		const filetype = 'ContextCommand';
-		interaction.util = new InteractionUtil(this.client, interaction);
-		interaction.user = await xernerxUser(interaction, this.client);
-		let cmd;
-		if (this.client.commands.context.has(interaction.commandName)) cmd = this.client.commands.context.get(interaction.commandName);
-		if (await inhibitorValidation(interaction, cmd)) return;
-		if (!cmd) return this.client.emit('commandNotFound', interaction, interaction.commandName, filetype);
-		this.client.emit('commandStart', interaction, filetype);
-		return await this.exec(cmd, interaction, await interactionArguments(interaction, cmd), filetype);
-	}
-	async exec(cmd, event, args, type) {
-		try {
-			if (await commandValidation(event, cmd)) return;
-			if (cmd.conditions && (await cmd.conditions(event, args))) return;
-			await cmd.exec(event, args);
-			return await this.client.emit('commandFinish', event, type);
-		} catch (error) {
-			new XernerxLog(this.client).error(`An error occurred executing ${Style.log(cmd.name, { color: Style.TextColor.Blue })}`, error);
-			return await this.client.emit('commandError', event, error, cmd, type);
-		}
-	}
+    constructor(client) {
+        super(client);
+    }
+    loadMessageCommands(options) {
+        if (!this.client.options.intents.has(GatewayIntentBits.MessageContent))
+            new XernerxLog(this.client).warn(`Message commands might not work as you're missing the intent MessageContent!`);
+        if (!this.client.options.intents.has(GatewayIntentBits.GuildMessages))
+            new XernerxLog(this.client).warn(`Message commands might not work as you're missing the intent GuildMessages!`);
+        options = z
+            .object({
+            directory: z.string(),
+            prefix: z.string().or(z.array(z.string())),
+            allowMention: z.boolean().default(false),
+            cooldown: z.number().default(0),
+            permissions: z
+                .object({
+                user: z.array(z.string()).default([]),
+                client: z.array(z.string()).default([]),
+                dm: z.boolean().default(true),
+            })
+                .default({}),
+            handleEdits: z.boolean().default(false),
+            handleDeletes: z.boolean().default(false),
+            handleTyping: z.boolean().default(false),
+            logging: z.boolean().default(false),
+        })
+            .parse(options);
+        this.client.modules.options.message = options;
+        const files = this.readdir(options.directory);
+        for (const file of files) {
+            const filepath = `${path.resolve(options.directory)}\\${file}`;
+            this.load(filepath, 'MessageCommand');
+        }
+        new XernerxLog(this.client).info(`Loaded ${Style.log(String(files.length), { color: Style.TextColor.Cyan })} Message Commands.`);
+        this.emit({
+            name: 'messageCreate',
+            filetype: 'MessageCommand',
+            run: (message) => this.messageCommandRun(message),
+        });
+        this.emit({
+            name: 'messageUpdate',
+            filetype: 'MessageCommand',
+            run: (message, message2) => this.messageCommandRun(message, message2),
+        });
+        this.emit({
+            name: 'messageDelete',
+            filetype: 'MessageCommand',
+            run: (message) => this.messageCommandRun(message, 'delete'),
+        });
+    }
+    // public reloadMessageCommands() {
+    //     return reload(this.client, 'message');
+    // }
+    loadSlashCommands(options) {
+        if (!this.client.settings.local)
+            new XernerxLog(this.client).warn(`Slash commands might not work as you haven't specified a local guild ID.`);
+        options = z
+            .object({
+            directory: z.string(),
+            cooldown: z.number().default(0),
+            permissions: z
+                .object({
+                user: z.array(z.string()).default([]),
+                client: z.array(z.string()).default([]),
+                dm: z.boolean().default(true),
+            })
+                .default({}),
+            logging: z.boolean().default(false),
+            defer: z
+                .object({
+                reply: z.boolean().default(false),
+                ephemeral: z.boolean().default(false),
+                fetchReply: z.boolean().default(false),
+            })
+                .default({}),
+        })
+            .parse(options);
+        this.client.modules.options.slash = options;
+        const files = this.readdir(options.directory);
+        for (const file of files) {
+            const filepath = `${path.resolve(options.directory)}\\${file}`;
+            this.load(filepath, 'SlashCommand');
+        }
+        new XernerxLog(this.client).info(`Loaded ${Style.log(String(files.length), { color: Style.TextColor.Cyan })} Slash Commands.`);
+        this.emit({
+            name: 'interactionCreate',
+            filetype: 'SlashCommand',
+            run: (interaction) => this.slashCommandRun(interaction),
+        });
+    }
+    loadContextCommands(options) {
+        if (!this.client.settings.local)
+            new XernerxLog(this.client).warn(`Context commands might not work as you haven't specified a local guild ID.`);
+        options = z
+            .object({
+            directory: z.string(),
+            cooldown: z.number().default(0),
+            permissions: z
+                .object({
+                user: z.array(z.string()).default([]),
+                client: z.array(z.string()).default([]),
+                dm: z.boolean().default(true),
+            })
+                .default({}),
+            logging: z.boolean().default(false),
+            defer: z
+                .object({
+                reply: z.boolean().default(false),
+                ephemeral: z.boolean().default(false),
+                fetchReply: z.boolean().default(false),
+            })
+                .default({}),
+        })
+            .parse(options);
+        this.client.modules.options.context = options;
+        const files = this.readdir(options.directory);
+        for (const file of files) {
+            const filepath = `${path.resolve(options.directory)}\\${file}`;
+            this.load(filepath, 'ContextCommand');
+        }
+        new XernerxLog(this.client).info(`Loaded ${Style.log(String(files.length), { color: Style.TextColor.Cyan })} Context Commands.`);
+        this.emit({
+            name: 'interactionCreate',
+            filetype: 'ContextCommand',
+            run: (interaction) => this.contextCommandRun(interaction),
+        });
+    }
+    async messageCommandRun(message, message2) {
+        const filetype = 'MessageCommand';
+        if (message.author.id === this.client.user?.id && this.client.settings.ignore?.self)
+            return;
+        else if (message.author.bot && this.client.settings.ignore?.bots)
+            return;
+        if (message.system && this.client.settings.ignore?.system)
+            return;
+        message.util = new MessageUtil(this.client, message);
+        message.user = await xernerxUser(message, this.client);
+        if (typeof message2 === 'object')
+            message = message2;
+        if (message2 === 'delete' && this.client.modules.options.message?.handleDeletes) {
+            if (!this.client.cache.messages.has(message.id))
+                return;
+            const id = this.client.cache.messages.get(message.id);
+            if (!id)
+                return;
+            (async () => {
+                const msg = await message.channel.messages.fetch(id);
+                await msg.delete();
+                this.client.cache.messages.delete(message.id);
+            })();
+            return;
+        }
+        if (message.content && this.client.modules.options.message) {
+            const commands = this.client.commands.message;
+            const prefixes = Array.isArray(this.client.modules.options.message.prefix) ? this.client.modules.options.message.prefix : [this.client.modules.options.message.prefix];
+            let commandName = null, cmd, commandAlias = null, commandPrefix = null;
+            commands.map((command) => {
+                let prefix = null;
+                if (command.regex && message.content.match(command.regex)) {
+                    const [match] = message.content.match(command.regex) || [null];
+                    if (match)
+                        commandName = command.name;
+                }
+                const cp = Array.isArray(command.prefix) ? command.prefix : [command.prefix];
+                prefixes.map((p) => {
+                    if (message.content.startsWith(p))
+                        prefix = p;
+                });
+                cp.map((p) => {
+                    if (message.content.startsWith(p))
+                        prefix = p;
+                });
+                if (!prefix)
+                    return;
+                if (!commandName)
+                    commandName =
+                        message.content
+                            .replace(prefix, '')
+                            .split(command.separator || / +/)
+                            .shift()
+                            ?.trim()
+                            ?.toLowerCase() || '';
+                if (!this.client.commands.message.has(commandName) && command.aliases?.includes(commandName)) {
+                    commandAlias = commandName;
+                    commandName = command.name;
+                }
+                commandAlias = commandAlias ? commandAlias : commandName;
+                commandPrefix = prefix;
+            });
+            if (!cmd && this.client.modules.options.message.allowMention) {
+                if (message.mentions.users.has(this.client.user?.id) || message.mentions.repliedUser?.id === this.client.user?.id) {
+                    commandName =
+                        message.content
+                            .replace(`<@${this.client.user?.id}>`, '')
+                            .trim()
+                            .split(/ +/)
+                            .shift()
+                            ?.toLowerCase() || null;
+                    commands.map((command) => {
+                        if (command.aliases?.includes(commandName)) {
+                            commandName = command.name;
+                            return (commandAlias = commandName);
+                        }
+                    });
+                    commandPrefix = `<@${this.client.user?.id}>`;
+                }
+            }
+            if (this.client.commands.message.has(commandName)) {
+                if (this.client.modules.options.message?.handleTyping)
+                    message.channel.sendTyping();
+                cmd = this.client.commands.message.get(commandName);
+            }
+            if (!commandPrefix || !commandName)
+                return;
+            if (!cmd)
+                return await this.client.emit('commandNotFound', message, commandName, filetype);
+            if (await inhibitorValidation(message, cmd))
+                return;
+            message.util.parsed = {
+                alias: commandAlias,
+                prefix: commandPrefix,
+            };
+            this.client.emit('commandStart', message, cmd, filetype);
+            return await this.exec(cmd, message, await messageArguments(message, cmd, commandPrefix), filetype);
+        }
+    }
+    async slashCommandRun(interaction) {
+        const filetype = 'SlashCommand';
+        interaction.util = new InteractionUtil(this.client, interaction);
+        interaction.user = await xernerxUser(interaction, this.client);
+        let cmd = null;
+        if (this.client.commands.slash.has(interaction.commandName))
+            cmd = this.client.commands.slash.get(interaction.commandName);
+        if (await inhibitorValidation(interaction, cmd))
+            return;
+        if (!cmd)
+            return this.client.emit('commandNotFound', interaction, interaction.commandName, filetype);
+        new Promise(async (resolve) => {
+            if (interaction.isAutocomplete()) {
+                const focused = interaction.options.getFocused(true);
+                const options = interaction.options;
+                await cmd.autocomplete(interaction, focused, options);
+            }
+            else
+                resolve(true);
+        })
+            .then(async () => {
+            this.client.emit('commandStart', interaction, filetype);
+            return await this.exec(cmd, interaction, await interactionArguments(interaction, cmd), filetype);
+        })
+            .catch((error) => this.client.emit('commandError', interaction, error, cmd, filetype));
+    }
+    async contextCommandRun(interaction) {
+        const filetype = 'ContextCommand';
+        interaction.util = new InteractionUtil(this.client, interaction);
+        interaction.user = await xernerxUser(interaction, this.client);
+        let cmd;
+        if (this.client.commands.context.has(interaction.commandName))
+            cmd = this.client.commands.context.get(interaction.commandName);
+        if (await inhibitorValidation(interaction, cmd))
+            return;
+        if (!cmd)
+            return this.client.emit('commandNotFound', interaction, interaction.commandName, filetype);
+        this.client.emit('commandStart', interaction, filetype);
+        return await this.exec(cmd, interaction, await interactionArguments(interaction, cmd), filetype);
+    }
+    async exec(cmd, event, args, type) {
+        try {
+            if (await commandValidation(event, cmd))
+                return;
+            if (cmd.conditions && (await cmd.conditions(event, args)))
+                return;
+            await cmd.exec(event, args);
+            return await this.client.emit('commandFinish', event, type);
+        }
+        catch (error) {
+            new XernerxLog(this.client).error(`An error occurred executing ${Style.log(cmd.name, { color: Style.TextColor.Blue })}`, error);
+            return await this.client.emit('commandError', event, error, cmd, type);
+        }
+    }
 }
-//# sourceMappingURL=CommandHandler.js.map
+//# sourceMappingURL=CommandHandler.js.map