xernerx 4.7.1 → 4.8.1

package/dist/build/XernerxContextCommand.d.ts

@@ -2,6 +2,7 @@
 import { ContextMenuCommandBuilder } from 'discord.js';
 import { XernerxMessageContextInteraction, XernerxUserContextInteraction, XernerxClientType } from '../types/extenders.js';
 import { ContextCommandArguments, ContextCommandOptions } from '../types/interfaces.js';
+import InteractionUtil from '../utils/InteractionUtil.js';
 export default class XernerxContextCommand {
     readonly id: string;
     readonly data: ContextMenuCommandBuilder;
@@ -41,6 +42,7 @@ export default class XernerxContextCommand {
     readonly filetype: 'ContextCommand';
     readonly filepath: string;
     readonly client: XernerxClientType;
+    util: InteractionUtil;
     constructor(id: string, options: ContextCommandOptions);
     /**
      * @description the execution of the command

package/dist/build/XernerxContextCommand.js

@@ -107,6 +107,7 @@ export default class XernerxContextCommand {
         this.permissions = options.permissions;
         this.defer = options.defer;
         this.client = this.client;
+        this.util = this.util;
     }
     /**
      * @description the execution of the command

package/dist/build/XernerxMessageCommand.d.ts

@@ -1,6 +1,7 @@
 /** @format */
 import { XernerxClientType, XernerxMessage } from '../types/extenders.js';
 import { MessageCommandArguments, MessageCommandOptions } from '../types/interfaces.js';
+import MessageUtil from '../utils/MessageUtil.js';
 export default class XernerxMessageCommand {
     readonly id: string;
     readonly name: string;
@@ -39,6 +40,7 @@ export default class XernerxMessageCommand {
     readonly filetype: 'MessageCommand';
     readonly filepath: string;
     readonly client: XernerxClientType;
+    util: MessageUtil;
     constructor(id: string, options: MessageCommandOptions);
     /**
      * @description Checks for conditions before running the command

package/dist/build/XernerxMessageCommand.js

@@ -99,6 +99,7 @@ export default class XernerxMessageCommand {
         this.separator = options.separator;
         this.permissions = options.permissions;
         this.client = this.client;
+        this.util = this.util;
     }
     /**
      * @description Checks for conditions before running the command

package/dist/build/XernerxSlashCommand.d.ts

@@ -3,6 +3,7 @@ import Discord from 'discord.js';
 import { XernerxClientType, XernerxMessageContextInteraction, XernerxSlashInteraction, XernerxUserContextInteraction } from '../types/extenders.js';
 import { SlashCommandArguments, SlashCommandOptions } from '../types/interfaces.js';
 import { XernerxInteraction } from '../types/types.js';
+import InteractionUtil from '../utils/InteractionUtil.js';
 export default class XernerxSlashCommand {
     readonly id: string;
     readonly data: Discord.SlashCommandBuilder;
@@ -41,6 +42,7 @@ export default class XernerxSlashCommand {
     readonly filetype: 'SlashCommand';
     readonly filepath: string;
     readonly client: XernerxClientType;
+    util: InteractionUtil;
     constructor(id: string, options: SlashCommandOptions);
     /**
      * @description autocomplete let's you add choices to string option arguments

package/dist/build/XernerxSlashCommand.js

@@ -115,6 +115,7 @@ export default class XernerxSlashCommand {
         this.permissions = options.permissions;
         this.defer = options.defer;
         this.client = this.client;
+        this.util = this.util;
     }
     /**
      * @description autocomplete let's you add choices to string option arguments

package/dist/client/XernerxClient.d.ts

@@ -10,8 +10,8 @@ export default class XernerxClient extends Client {
         local: string;
         global?: boolean | undefined;
         permissions?: {
-            client: string[] | null;
             user: string[] | null;
+            client: string[] | null;
             dm: boolean;
         } | undefined;
         ignore?: {

package/dist/functions/load.js

@@ -6,6 +6,7 @@ export default async function load(client, path, type) {
         file.filetype = type;
         file.filepath = path;
         file.client = client;
+        file.util = {};
         fileSave(client, file, type);
         return file;
     }

package/dist/functions/reload.d.ts

@@ -1,3 +1,3 @@
 /** @format */
-import XernerxClient from '../client/XernerxClient.js';
-export default function reload(client: XernerxClient, type: 'message' | 'slash' | 'context' | 'event' | 'inhibitor'): Promise<any>[];
+import { XernerxClient } from '../main.js';
+export default function reload(client: XernerxClient, type: 'commands' | 'context' | 'message' | 'slash' | 'events' | 'inhibitors'): Promise<true | void | null>;

package/dist/functions/reload.js

@@ -1,43 +1,30 @@
 /** @format */
-var filetypes;
-(function (filetypes) {
-    filetypes["message"] = "MessageCommand";
-    filetypes["slash"] = "SlashCommand";
-    filetypes["context"] = "ContextCommand";
-    filetypes["event"] = "Event";
-    filetypes["inhibitor"] = "Inhibitor";
-})(filetypes || (filetypes = {}));
-export default function reload(client, type) {
-    const files = [];
-    if (type === 'message' || type === 'slash' || type === 'context') {
-        for (const [name] of client.commands[type]) {
-            files.push(client.commands[type].get(name).filepath);
+import * as path from 'path';
+import * as fs from 'fs';
+import load from './load.js';
+export default async function reload(client, type) {
+    switch (type) {
+        case 'message': {
+            client.commands.message.clear();
+            if (!client.modules.options.message)
+                return null;
+            const directory = path.resolve(client.modules.options.message?.directory);
+            for (const file of fs.readdirSync(directory)) {
+                load(client, `${directory}\\${file}`, 'MessageCommand');
+            }
+            return true;
         }
-        client.commands[type].sweep(() => true);
-    }
-    if (type === 'event') {
-        for (const [name] of client.events) {
-            files.push(client.events.get(name).filepath);
+        case 'slash': {
+            return client.commands.slash.clear();
         }
-        client.events.sweep(() => true);
-    }
-    if (type === 'inhibitor') {
-        for (const [name] of client.inhibitors) {
-            files.push(client.inhibitors.get(name).filepath);
+        case 'context': {
+            return client.commands.context.clear();
+        }
+        case 'events': {
+            return client.events.clear();
+        }
+        case 'inhibitors': {
+            return client.inhibitors.clear();
         }
-        client.inhibitors.sweep(() => true);
     }
-    return files.map(async (file) => {
-        let filedata = new (await import(`file://${file}`)).default();
-        filedata.filetype = filetypes[type];
-        filedata.filepath = file;
-        filedata.client = client;
-        if (type === 'message' || type === 'slash' || type === 'context')
-            client.commands[type].set(filedata.name, filedata);
-        if (type === 'event')
-            client.events.set(filedata.name, filedata);
-        if (type === 'inhibitor')
-            client.inhibitors.set(filedata.name, filedata);
-        return filedata;
-    });
 }

package/dist/handlers/CommandHandler.d.ts

@@ -3,10 +3,11 @@ 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 {
+    readonly readyTimestamp: number;
     constructor(client: XernerxClient);
     loadMessageCommands(options: MessageHandlerOptions): Promise<void>;
-    loadSlashCommands(options: SlashHandlerOptions): void;
-    loadContextCommands(options: ContextHandlerOptions): void;
+    loadSlashCommands(options: SlashHandlerOptions): Promise<void>;
+    loadContextCommands(options: ContextHandlerOptions): Promise<void>;
     private messageCommandRun;
     private slashCommandRun;
     private contextCommandRun;

package/dist/handlers/CommandHandler.js

@@ -14,8 +14,10 @@ import { Style } from 'dumfunctions';
 export default class CommandHandler extends Handler {
     constructor(client) {
         super(client);
+        this.readyTimestamp = Number(Date.now());
     }
     async loadMessageCommands(options) {
+        const commands = [];
         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))
@@ -45,8 +47,9 @@ export default class CommandHandler extends Handler {
             const filepath = `${path.resolve(options.directory)}\\${file}`;
             const command = await this.load(filepath, 'MessageCommand');
             this._checks(command);
+            commands.push(command.id);
         }
-        new XernerxLog(this.client).info(`Loaded ${Style.log(String(files.length), { color: Style.TextColor.Cyan })} Message Commands.`);
+        new XernerxLog(this.client).info(`Loaded ${Style.log(String(files.length), { color: Style.TextColor.Cyan })} Message Commands: ${commands.map((command) => Style.log(command, { color: Style.TextColor.LightYellow })).join(', ')}`);
         this.emit({
             name: 'messageCreate',
             filetype: 'MessageCommand',
@@ -64,9 +67,10 @@ export default class CommandHandler extends Handler {
         });
     }
     // public reloadMessageCommands() {
-    //     return reload(this.client, 'message');
+    // 	return reload(this.client, 'message');
     // }
-    loadSlashCommands(options) {
+    async loadSlashCommands(options) {
+        const commands = [];
         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
@@ -94,16 +98,18 @@ export default class CommandHandler extends Handler {
         const files = this.readdir(options.directory);
         for (const file of files) {
             const filepath = `${path.resolve(options.directory)}\\${file}`;
-            this.load(filepath, 'SlashCommand');
+            const command = await this.load(filepath, 'SlashCommand');
+            commands.push(command.id);
         }
-        new XernerxLog(this.client).info(`Loaded ${Style.log(String(files.length), { color: Style.TextColor.Cyan })} Slash Commands.`);
+        new XernerxLog(this.client).info(`Loaded ${Style.log(String(files.length), { color: Style.TextColor.Cyan })} Slash Commands: ${commands.map((command) => Style.log(command, { color: Style.TextColor.LightYellow })).join(', ')}`);
         this.emit({
             name: 'interactionCreate',
             filetype: 'SlashCommand',
             run: (interaction) => this.slashCommandRun(interaction),
         });
     }
-    loadContextCommands(options) {
+    async loadContextCommands(options) {
+        const commands = [];
         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
@@ -131,9 +137,10 @@ export default class CommandHandler extends Handler {
         const files = this.readdir(options.directory);
         for (const file of files) {
             const filepath = `${path.resolve(options.directory)}\\${file}`;
-            this.load(filepath, 'ContextCommand');
+            const command = await this.load(filepath, 'ContextCommand');
+            commands.push(command.id);
         }
-        new XernerxLog(this.client).info(`Loaded ${Style.log(String(files.length), { color: Style.TextColor.Cyan })} Context Commands.`);
+        new XernerxLog(this.client).info(`Loaded ${Style.log(String(files.length), { color: Style.TextColor.Cyan })} Context Commands: ${commands.map((command) => Style.log(command, { color: Style.TextColor.LightYellow })).join(', ')}`);
         this.emit({
             name: 'interactionCreate',
             filetype: 'ContextCommand',
@@ -231,12 +238,15 @@ export default class CommandHandler extends Handler {
                 return;
             if (!cmd)
                 return await this.client.emit('commandNotFound', message, commandName, filetype);
+            await this.client.emit('commandStart', message, cmd);
+            const args = await messageArguments(message, cmd, commandPrefix);
             message.util.parsed = {
                 alias: commandAlias,
                 prefix: commandPrefix,
+                args: args.args,
             };
-            this.client.emit('commandStart', message, cmd, filetype);
-            return await this.exec(cmd, message, await messageArguments(message, cmd, commandPrefix), filetype);
+            cmd.util = message.util;
+            return await this.exec(cmd, message, args, filetype);
         }
     }
     async slashCommandRun(interaction) {
@@ -260,8 +270,14 @@ export default class CommandHandler extends Handler {
                 resolve(true);
         })
             .then(async () => {
-            this.client.emit('commandStart', interaction, filetype);
-            return await this.exec(cmd, interaction, await interactionArguments(interaction, cmd), filetype);
+            await this.client.emit('commandStart', interaction);
+            const args = await interactionArguments(interaction, cmd);
+            interaction.util.parsed = {
+                alias: [interaction.commandName, args.group || '', args.subcommand || ''].join(' '),
+                args: args.args,
+            };
+            cmd.util = interaction.util;
+            return await this.exec(cmd, interaction, args, filetype);
         })
             .catch((error) => this.client.emit('commandError', interaction, error, cmd, filetype));
     }
@@ -276,8 +292,14 @@ export default class CommandHandler extends Handler {
             cmd = this.client.commands.context.get(interaction.commandName);
         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);
+        await this.client.emit('commandStart', interaction);
+        const args = await interactionArguments(interaction, cmd);
+        interaction.util.parsed = {
+            alias: interaction.commandName,
+            args: args,
+        };
+        cmd.util = interaction.util;
+        return await this.exec(cmd, interaction, args, filetype);
     }
     async exec(cmd, event, args, type) {
         try {
@@ -299,7 +321,7 @@ export default class CommandHandler extends Handler {
                 return;
             await cmd.exec(event, args);
             await inhibitorValidation(event, args, cmd, 'post');
-            return await this.client.emit('commandFinish', event, type);
+            return await this.client.emit('commandFinish', event, cmd);
         }
         catch (error) {
             new XernerxLog(this.client).error(`An error occurred executing ${Style.log(cmd.name, { color: Style.TextColor.Blue })}`, error);

package/dist/handlers/EventHandler.d.ts

@@ -3,6 +3,7 @@ import XernerxClient from '../client/XernerxClient.js';
 import { EventHandlerOptions } from '../types/interfaces.js';
 import Handler from './Handler.js';
 export default class EventHandler extends Handler {
+    readonly readyTimestamp: number;
     constructor(client: XernerxClient);
     loadEvents(options: EventHandlerOptions): Promise<void>;
 }

package/dist/handlers/EventHandler.js

@@ -7,8 +7,10 @@ import { Style } from 'dumfunctions';
 export default class EventHandler extends Handler {
     constructor(client) {
         super(client);
+        this.readyTimestamp = Number(Date.now());
     }
     async loadEvents(options) {
+        const events = [];
         options = z
             .object({
             directory: z.string(),
@@ -18,9 +20,10 @@ export default class EventHandler extends Handler {
         const files = this.readdir(options.directory);
         for (const file of files) {
             const filepath = `${path.resolve(options.directory)}\\${file}`;
-            const data = await this.load(filepath, 'Event');
-            this.emit(data);
+            const event = await this.load(filepath, 'Event');
+            this.emit(event);
+            events.push(event.id);
         }
-        new XernerxLog(this.client).info(`Loaded ${Style.log(String(this.client.events.size), { color: Style.TextColor.Cyan })} Events.`);
+        new XernerxLog(this.client).info(`Loaded ${Style.log(String(this.client.events.size), { color: Style.TextColor.Cyan })} Events: ${events.map((event) => Style.log(event, { color: Style.TextColor.LightYellow })).join(', ')}`);
     }
 }

package/dist/handlers/ExtensionHandler.d.ts

@@ -3,6 +3,7 @@ import XernerxExtensionBuilder from 'xernerx-extension-builder';
 import XernerxClient from '../client/XernerxClient.js';
 import Handler from './Handler.js';
 export default class ExtensionHandler extends Handler {
+    readonly readyTimestamp: number;
     constructor(client: XernerxClient);
     loadExtensions(...extensions: Array<XernerxExtensionBuilder>): void;
 }

package/dist/handlers/ExtensionHandler.js

@@ -5,6 +5,7 @@ import { Style } from 'dumfunctions';
 export default class ExtensionHandler extends Handler {
     constructor(client) {
         super(client);
+        this.readyTimestamp = Number(Date.now());
     }
     loadExtensions(...extensions) {
         const active = extensions.map((extension) => {
@@ -17,9 +18,12 @@ export default class ExtensionHandler extends Handler {
                 return extension.name;
             }
             catch (error) {
-                return new XernerxLog(this.client).error(`An error occurred while loading ${Style.log(extension.name, { color: Style.TextColor.Blue })}`, error);
+                return new XernerxLog(this.client).error(`An error occurred while loading ${Style.log(extension.name, { color: Style.TextColor.Red })}`, error);
             }
         });
-        new XernerxLog(this.client).info(`Loaded ${Style.log(String(extensions.length), { color: Style.TextColor.Cyan })} Extensions: ${active.filter((e) => e).join(', ')}`);
+        new XernerxLog(this.client).info(`Loaded ${Style.log(String(extensions.length), { color: Style.TextColor.Cyan })} Extensions: ${active
+            .filter((e) => e)
+            .map((event) => Style.log(event, { color: Style.TextColor.LightYellow }))
+            .join(', ')}`);
     }
 }

package/dist/handlers/Handler.d.ts

@@ -7,7 +7,6 @@ import { filetype } from '../types/types.js';
 export default class Handler {
     readonly client: XernerxClient;
     readonly files: Array<MessageCommandBuilder | XernerxSlashCommand | XernerxContextCommand>;
-    readonly readyTimestamp: number;
     constructor(client: XernerxClient);
     readdir(dir: string): string[];
     load(filepath: string, type: filetype): Promise<any>;

package/dist/handlers/Handler.js

@@ -5,11 +5,9 @@ import load from '../functions/load.js';
 export default class Handler {
     client;
     files;
-    readyTimestamp;
     constructor(client) {
         this.client = client;
         this.files = [];
-        this.readyTimestamp = Number(Date.now());
     }
     readdir(dir) {
         try {

package/dist/handlers/InhibitorHandler.d.ts

@@ -3,6 +3,7 @@ import XernerxClient from '../client/XernerxClient.js';
 import Handler from './Handler.js';
 import { InhibitorHandlerOptions } from '../types/interfaces.js';
 export default class InhibitorHandler extends Handler {
+    readonly readyTimestamp: number;
     constructor(client: XernerxClient);
     loadInhibitors(options: InhibitorHandlerOptions): Promise<void>;
 }

package/dist/handlers/InhibitorHandler.js

@@ -7,8 +7,10 @@ import { Style } from 'dumfunctions';
 export default class InhibitorHandler extends Handler {
     constructor(client) {
         super(client);
+        this.readyTimestamp = Number(Date.now());
     }
     async loadInhibitors(options) {
+        const inhibitors = [];
         options = z
             .object({
             directory: z.string(),
@@ -18,9 +20,12 @@ export default class InhibitorHandler extends Handler {
         const files = this.readdir(options.directory);
         for (const file of files) {
             const filepath = `${path.resolve(options.directory)}\\${file}`;
-            const data = await this.load(filepath, 'Inhibitor');
-            this.emit(data);
+            const inhibitor = await this.load(filepath, 'Inhibitor');
+            this.emit(inhibitor);
+            inhibitors.push(inhibitor.id);
         }
-        new XernerxLog(this.client).info(`Loaded ${Style.log(String(this.client.inhibitors.size), { color: Style.TextColor.Cyan })} Inhibitors.`);
+        new XernerxLog(this.client).info(`Loaded ${Style.log(String(this.client.inhibitors.size), { color: Style.TextColor.Cyan })} Inhibitors: ${inhibitors
+            .map((inhibitor) => Style.log(inhibitor, { color: Style.TextColor.LightYellow }))
+            .join(', ')}`);
     }
 }

package/dist/handlers/WebhookHandler.d.ts

@@ -2,6 +2,7 @@
 import XernerxClient from '../client/XernerxClient.js';
 import Handler from './Handler.js';
 export default class WebhookHandler extends Handler {
+    readonly readyTimestamp: number;
     constructor(client: XernerxClient);
     loadWebhooks(options: {
         token: string;

package/dist/handlers/WebhookHandler.js

@@ -4,6 +4,7 @@ import Handler from './Handler.js';
 export default class WebhookHandler extends Handler {
     constructor(client) {
         super(client);
+        this.readyTimestamp = Number(Date.now());
     }
     async loadWebhooks(options) {
         this.client.once('ready', async (client) => {

package/dist/utils/InteractionUtil.d.ts

@@ -1,12 +1,16 @@
 /** @format */
 import { EmbedBuilder, InteractionEditReplyOptions, InteractionReplyOptions, MessagePayload } from 'discord.js';
 import XernerxClient from '../client/XernerxClient.js';
-import { PaginatorOptions } from '../types/interfaces.js';
+import { ContextCommandArguments, PaginatorOptions, SlashCommandArguments } from '../types/interfaces.js';
 import { XernerxInteraction } from '../types/types.js';
 import Util from './Util.js';
 import { XernerxMessageContextInteraction, XernerxSlashInteraction, XernerxUserContextInteraction } from '../types/extenders.js';
 export default class InteractionUtil extends Util {
-    private interaction;
+    private readonly interaction;
+    parsed: {
+        alias: string | null;
+        args: (SlashCommandArguments | ContextCommandArguments<'message' | 'user'>) | null;
+    };
     constructor(client: XernerxClient, interaction: XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>);
     send(content: any): Promise<import("discord.js").Message<false> | import("discord.js").Message<true> | undefined>;
     reply(content: string | MessagePayload | InteractionReplyOptions | InteractionEditReplyOptions): Promise<import("discord.js").InteractionResponse<boolean> | import("discord.js").Message<boolean>>;

package/dist/utils/InteractionUtil.js

@@ -3,10 +3,13 @@ import { ActionRowBuilder, ButtonBuilder, ButtonStyle, StringSelectMenuBuilder }
 import Util from './Util.js';
 import XernerxError from '../tools/XernerxError.js';
 export default class InteractionUtil extends Util {
-    interaction;
     constructor(client, interaction) {
         super(client);
         this.interaction = interaction;
+        this.parsed = {
+            alias: null,
+            args: null,
+        };
     }
     async send(content) {
         if (!content)

package/dist/utils/MessageUtil.d.ts

@@ -7,8 +7,9 @@ import { PaginatorOptions } from '../main.js';
 export default class MessageUtil extends Util {
     private readonly message;
     parsed: {
-        alias: null | string;
-        prefix: null | string;
+        alias: string | null;
+        prefix: string | null;
+        args: Record<string, unknown> | null;
     };
     constructor(client: XernerxClient, message: XernerxMessage);
     send(content: any): Promise<import("discord.js").Message<boolean> | null>;

package/dist/utils/MessageUtil.js

@@ -4,13 +4,13 @@ import Util from './Util.js';
 import sendWebhook from '../functions/sendWebhook.js';
 import XernerxError from '../tools/XernerxError.js';
 export default class MessageUtil extends Util {
-    message;
     constructor(client, message) {
         super(client);
         this.message = message;
         this.parsed = {
             alias: null,
             prefix: null,
+            args: null,
         };
     }
     async send(content) {

package/dist/validators/commandValidation.js

@@ -89,25 +89,25 @@ export default async function commandValidation(event, command) {
             message: `\`${command.name}\` can't be used in a DM Channel`,
         }, command);
     if (userPermissions) {
-        const missing = userPermissions.map(permission => (event.member?.permissions).has(toBigInt([permission])) ? null : permission).filter(x => x);
+        const missing = userPermissions.map((permission) => ((event.member?.permissions).has(toBigInt([permission])) ? null : permission)).filter((x) => x);
         const desired = (event.member?.permissions).has(toBigInt(userPermissions));
         if (!desired)
             return await emit(event, {
                 reason: 'missingUserPermissions',
-                message: `You are missing the following permissions to run \`${command.name}\`:\n${missing.map(permission => `> - ${permission}`).join('\n')}`,
+                message: `You are missing the following permissions to run \`${command.name}\`:\n${missing.map((permission) => `> - ${permission}`).join('\n')}`,
                 required: userPermissions,
-                missing
+                missing,
             }, command);
     }
     if (clientPermissions) {
-        const missing = clientPermissions.map(permission => event.guild?.members.me?.permissions.has(toBigInt([permission])) ? null : permission).filter(x => x);
-        const desired = (event.guild?.members.me?.permissions)?.has(toBigInt(clientPermissions));
+        const missing = clientPermissions.map((permission) => (event.guild?.members.me?.permissions.has(toBigInt([permission])) ? null : permission)).filter((x) => x);
+        const desired = event.guild?.members.me?.permissions?.has(toBigInt(clientPermissions));
         if (!desired)
             return await emit(event, {
                 reason: 'missingClientPermissions',
-                message: `I am missing the following permissions to run \`${command.name}\`:\n${missing.map(permission => `> - ${permission}`).join('\n')}`,
+                message: `I am missing the following permissions to run \`${command.name}\`:\n${missing.map((permission) => `> - ${permission}`).join('\n')}`,
                 required: clientPermissions,
-                missing
+                missing,
             }, command);
     }
     if ((!command.global || !client.settings.global) && client.settings.local !== event.guild?.id)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "xernerx",
-	"version": "4.7.1",
+	"version": "4.8.1",
 	"description": "A bot framework for discord.js.",
 	"main": "dist/main.js",
 	"type": "module",

package/dist/build/ContextCommandBuilder.d.ts

@@ -1,43 +0,0 @@
-import { ContextMenuCommandBuilder } from 'discord.js';
-import XernerxClient from '../client/XernerxClient.js';
-import { XernerxMessageContextInteraction, XernerxUserContextInteraction } from '../types/extenders.js';
-import { ContextCommandArguments, ContextCommandOptions } from '../types/interfaces.js';
-export default class ContextCommandBuilder {
-    readonly id: string;
-    readonly data: ContextMenuCommandBuilder;
-    readonly name: string;
-    readonly type: 'user' | 'message';
-    readonly description: string | null | undefined;
-    readonly usage: string | null | undefined;
-    readonly info: string | null | undefined;
-    readonly category: string | null | undefined;
-    readonly cooldown: number | null | undefined;
-    readonly ignore: {
-        owner?: boolean | undefined;
-        users?: string[] | undefined;
-        channels?: string[] | undefined;
-        guilds?: string[] | undefined;
-    } | undefined;
-    readonly strict: {
-        owner?: boolean | undefined;
-        users?: string[] | undefined;
-        channels?: string[] | undefined;
-        guilds?: string[] | undefined;
-    } | undefined;
-    readonly permissions: {
-        user?: string[] | import("../main.js").PermissionNames[] | undefined;
-        client?: string[] | import("../main.js").PermissionNames[] | undefined;
-        dm?: boolean | undefined;
-    } | undefined;
-    readonly defer: {
-        reply?: boolean | undefined;
-        ephemeral?: boolean | undefined;
-        fetchReply?: boolean | undefined;
-    } | undefined;
-    readonly fileType: 'ContextCommand';
-    readonly filePath: string;
-    readonly client: typeof XernerxClient;
-    constructor(id: string, options: ContextCommandOptions);
-    exec<T>(interaction: XernerxUserContextInteraction | XernerxMessageContextInteraction, args: ContextCommandArguments<'user' | 'message'>): Promise<void | any | T>;
-}
-//# sourceMappingURL=ContextCommandBuilder.d.ts.map

package/dist/build/ContextCommandBuilder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ContextCommandBuilder.d.ts","sourceRoot":"","sources":["../../src/build/ContextCommandBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAGvD,OAAO,aAAa,MAAM,4BAA4B,CAAC;AACvD,OAAO,EAAE,gCAAgC,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAC;AACxG,OAAO,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAExF,MAAM,CAAC,OAAO,OAAO,qBAAqB;IACtC,SAAwB,EAAE,SAAC;IAC3B,SAAwB,IAAI,4BAAC;IAC7B,SAAwB,IAAI,SAAC;IAC7B,SAAwB,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACjD,SAAwB,WAAW,4BAAC;IACpC,SAAwB,KAAK,4BAAC;IAC9B,SAAwB,IAAI,4BAAC;IAC7B,SAAwB,QAAQ,4BAAC;IACjC,SAAwB,QAAQ,4BAAC;IACjC,SAAwB,MAAM;;;;;kBAAC;IAC/B,SAAwB,MAAM;;;;;kBAAC;IAC/B,SAAwB,WAAW;;;;kBAAC;IACpC,SAAwB,KAAK;;;;kBAAC;IAC9B,SAAwB,QAAQ,EAAE,gBAAgB,CAAC;IACnD,SAAwB,QAAQ,EAAE,MAAM,CAAC;IACzC,SAAwB,MAAM,uBAAC;gBAEZ,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,qBAAqB;IAgFhD,IAAI,CAAC,CAAC,EAAE,WAAW,EAAE,6BAA6B,GAAG,gCAAgC,EAAE,IAAI,EAAE,uBAAuB,CAAC,MAAM,GAAG,SAAS,CAAC,GAAG,OAAO,CAAC,IAAI,GAAG,GAAG,GAAG,CAAC,CAAC;CAClL"}