xernerx 4.1.0 → 4.2.1

package/dist/handlers/CommandHandler.js

@@ -63,6 +63,7 @@ export default class CommandHandler extends Handler {
     //     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(),
@@ -99,6 +100,7 @@ export default class CommandHandler extends Handler {
         });
     }
     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(),
@@ -135,6 +137,7 @@ export default class CommandHandler extends Handler {
         });
     }
     async messageCommandRun(message, message2) {
+        const filetype = 'MessageCommand';
         if (message.author.bot) return;
         message.util = new MessageUtil(this.client, message);
         message.user = await xernerxUser(message, this.client);
@@ -153,9 +156,10 @@ export default class CommandHandler extends Handler {
         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,
+            let commandName = null,
                 cmd,
-                alias = null;
+                commandAlias = null,
+                commandPrefix = null;
             commands.map((command) => {
                 let prefix = null;
                 if (command.regex && message.content.match(command.regex)) {
@@ -179,24 +183,30 @@ export default class CommandHandler extends Handler {
                             ?.trim()
                             ?.toLowerCase() || '';
                 if (!this.client.commands.message.has(commandName) && command.aliases?.includes(commandName)) {
-                    alias = 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();
+                    commandName = message.content.replace(`<@${this.client.user?.id}>`, '').trim().split(/ +/).shift()?.toLowerCase() || null;
                 }
             }
-            if (!commandName) commandName = '';
             if (this.client.commands.message.has(commandName)) cmd = this.client.commands.message.get(commandName);
             if (await inhibitorValidation(message, cmd)) return;
-            if (!cmd) return this.client.emit('commandNotFound');
-            message.util.alias = alias === commandName ? null : alias;
-            this.exec(cmd, message, await messageArguments(message, cmd), 'MessageCommand');
+            if (!cmd) return this.client.emit('commandNotFound', message, filetype);
+            message.util.parsed = {
+                alias: commandAlias,
+                prefix: commandPrefix,
+            };
+            this.client.emit('commandStart', message, filetype);
+            this.exec(cmd, message, await messageArguments(message, cmd), filetype);
         }
     }
     async slashCommandRun(interaction) {
+        const filetype = 'SlashCommand';
         interaction.util = new InteractionUtil(this.client, interaction);
         interaction.user = await xernerxUser(interaction, this.client);
         let cmd = null;
@@ -210,24 +220,29 @@ export default class CommandHandler extends Handler {
                 await cmd.autocomplete(interaction, focused, options);
             } else resolve(true);
         })
-            .then(async () => await this.exec(cmd, interaction, await interactionArguments(interaction, cmd), 'SlashCommand'))
-            .catch((error) => this.client.emit('commandError', interaction, error, cmd.filetype));
+            .then(async () => {
+                this.client.emit('commandStart', interaction, filetype);
+                await this.exec(cmd, interaction, await interactionArguments(interaction, cmd), filetype);
+            })
+            .catch((error) => this.client.emit('commandError', interaction, error, 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);
-        this.exec(cmd, interaction, await interactionArguments(interaction, cmd), 'ContextCommand');
+        if (!cmd) return this.client.emit('commandNotFound', interaction, filetype);
+        this.client.emit('commandStart', interaction, filetype);
+        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;
             cmd.exec(event, args);
-            this.client.emit('commandExecute', event, type);
+            this.client.emit('commandFinish', event, type);
         } catch (error) {
             new XernerxLog(this.client).error(`An error occurred executing ${cmd.name}`, error);
             this.client.emit('commandError', event, error, type);

package/dist/main.d.ts

@@ -10,5 +10,5 @@ export * from 'discord.js';
 export * from 'dumfunctions';
 import ExtensionBuilder from 'xernerx-extension-builder';
 import Discord from 'discord.js';
-declare const version = '4.1.0';
+declare const version = '4.2.1';
 export { XernerxClient, MessageCommandBuilder, SlashCommandBuilder, ContextCommandBuilder, EventBuilder, InhibitorBuilder, ExtensionBuilder, Discord, version, XernerxLog };

package/dist/main.js

@@ -10,5 +10,5 @@ export * from 'discord.js';
 export * from 'dumfunctions';
 import ExtensionBuilder from 'xernerx-extension-builder';
 import Discord from 'discord.js';
-const version = '4.1.0';
+const version = '4.2.1';
 export { XernerxClient, MessageCommandBuilder, SlashCommandBuilder, ContextCommandBuilder, EventBuilder, InhibitorBuilder, ExtensionBuilder, Discord, version, XernerxLog };

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

@@ -0,0 +1,68 @@
+import { ContextMenuCommandBuilder, Interaction } from 'discord.js';
+import { ContextCommandOptions } from '../types/options.js';
+import XernerxClient from '../client/XernerxClient.js';
+/**
+ * @description The command builder for context commands.
+ * @param {String} id - The unique ID of the command.
+ * @param {ContextCommandOptions} options - The command options.
+ */
+export default class ContextCommandBuilder {
+    id: string;
+    data: ContextMenuCommandBuilder;
+    name: string;
+    type: import('@discordjs/builders').ContextMenuCommandType;
+    description: string | undefined;
+    info: string | undefined;
+    category: string | undefined;
+    channelType: number | number[] | undefined;
+    cooldown: number | undefined;
+    ignore:
+        | {
+              owner?: boolean | undefined;
+              users?: string[] | undefined;
+              channels?: string[] | undefined;
+              guilds?: string[] | undefined;
+          }
+        | undefined;
+    strict:
+        | {
+              owner?: boolean | undefined;
+              users?: string[] | undefined;
+              channels?: string[] | undefined;
+              guilds?: string[] | undefined;
+          }
+        | undefined;
+    permissions:
+        | {
+              client?: string[] | undefined;
+              users?: string[] | undefined;
+              dm?: boolean | undefined;
+          }
+        | undefined;
+    defer:
+        | {
+              /**
+               * @param {Interaction} interaction - The Discord interaction event data.
+               * @description Make your custom command here.
+               * TODO - update description
+               */
+              reply?: boolean | undefined;
+              ephemeral?: boolean | undefined;
+              fetch?: boolean | undefined;
+          }
+        | undefined;
+    client: typeof XernerxClient;
+    constructor(id: string, options: ContextCommandOptions);
+    /**
+     * @param {Interaction} interaction - The Discord interaction event data.
+     * @description make any preconditions here.
+     * TODO - update description
+     */
+    conditions(interaction: Interaction, args: any): Promise<void>;
+    /**
+     * @param {Interaction} interaction - The Discord interaction event data.
+     * @description Make your custom command here.
+     * TODO - update description
+     */
+    exec(interaction: Interaction, args: any): Promise<void>;
+}

package/dist/mjs/build/ContextCommandBuilder.js

@@ -0,0 +1,88 @@
+import { ContextMenuCommandBuilder } from 'discord.js';
+import { z } from 'zod';
+import XernerxClient from '../client/XernerxClient.js';
+/**
+ * @description The command builder for context commands.
+ * @param {String} id - The unique ID of the command.
+ * @param {ContextCommandOptions} options - The command options.
+ */
+export default class ContextCommandBuilder {
+    id;
+    data;
+    name;
+    type;
+    description;
+    info;
+    category;
+    channelType;
+    cooldown;
+    ignore;
+    strict;
+    permissions;
+    defer;
+    client;
+    constructor(id, options) {
+        this.id = id;
+        this.data = new ContextMenuCommandBuilder();
+        if (options.name) this.data.setName(options.name);
+        if (options.type) this.data.setType(options.type);
+        if (options.permissions?.users) this.data.setDefaultMemberPermissions(options.permissions?.users);
+        if (options.permissions?.dm === false) this.data.setDMPermission(options.permissions?.dm);
+        if (options.nameLocalizations) this.data.setNameLocalizations(options.nameLocalizations);
+        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.type = options.type;
+        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;
+    }
+    /**
+     * @param {Interaction} interaction - The Discord interaction event data.
+     * @description make any preconditions here.
+     * TODO - update description
+     */
+    async conditions(interaction, args) {}
+    /**
+     * @param {Interaction} interaction - The Discord interaction event data.
+     * @description Make your custom command here.
+     * TODO - update description
+     */
+    async exec(interaction, args) {}
+}

package/dist/mjs/build/EventBuilder.d.ts

@@ -0,0 +1,21 @@
+import XernerxClient from '../client/XernerxClient.js';
+import { EventOptions } from '../types/options.js';
+/**
+ * @description - The event builder for  events.
+ * @param {String} id - The unique ID of the event.
+ * @param {EventOptions} options - The event options.
+ */
+export default class EventBuilder {
+    id: string;
+    name: string;
+    emitter: string;
+    type: string;
+    once: boolean;
+    client: typeof XernerxClient;
+    constructor(id: string, options: EventOptions);
+    /**
+     * @description run your custom event here.
+     * TODO - update description
+     */
+    run(): Promise<void>;
+}

package/dist/mjs/build/EventBuilder.js

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import XernerxClient from '../client/XernerxClient.js';
+/**
+ * @description - The event builder for  events.
+ * @param {String} id - The unique ID of the event.
+ * @param {EventOptions} options - The event options.
+ */
+export default class EventBuilder {
+    id;
+    name;
+    emitter;
+    type;
+    once;
+    client;
+    constructor(id, options) {
+        this.id = id;
+        z.object({
+            name: z.string(),
+            emitter: z.string().optional(),
+            type: z.string().optional(),
+            once: z.boolean().optional(),
+        }).parse(options);
+        this.name = options.name;
+        this.emitter = options.emitter || 'client';
+        this.type = options.type || 'discord';
+        this.once = options.once || false;
+        this.client = XernerxClient;
+    }
+    /**
+     * @description run your custom event here.
+     * TODO - update description
+     */
+    async run() {}
+}

package/dist/mjs/build/InhibitorBuilder.d.ts

@@ -0,0 +1,19 @@
+import XernerxClient from '../client/XernerxClient.js';
+import { InhibitorOptions, MessageArgumentOptions, SlashArgumentOptions } from '../types/options.js';
+import { XernerxInteraction, XernerxMessage } from '../types/types.js';
+/**
+ * @description - The inhibitor builder for inhibitors.
+ * @param {String} id - The unique ID of the inhibitor.
+ * @param {InhibitorOptions} options - The inhibitor options.
+ */
+export default class InhibitorBuilder {
+    id: string;
+    name: string;
+    type: import('../main.js').InhibitorType;
+    client: typeof XernerxClient;
+    constructor(id: string, options: InhibitorOptions);
+    /**
+     * TODO - update description
+     */
+    check(interaction: XernerxInteraction | XernerxMessage, args: SlashArgumentOptions | MessageArgumentOptions): Promise<void>;
+}

package/dist/mjs/build/InhibitorBuilder.js

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

package/dist/mjs/build/MessageCommandBuilder.d.ts

@@ -0,0 +1,59 @@
+import { MessageArgumentOptions, MessageCommandOptions } from '../types/options.js';
+import XernerxClient from '../client/XernerxClient.js';
+import { XernerxMessage } from '../types/types.js';
+/**
+ * @description - The command builder for message commands.
+ * @param {String} id - The unique ID of the command.
+ * @param {MessageCommandOptions} options - The command options.
+ */
+export default class MessageCommandBuilder {
+    id: string;
+    name: string;
+    aliases: string[] | undefined;
+    separator: string;
+    description: string | undefined;
+    info: string | undefined;
+    category: string | undefined;
+    prefix: string[];
+    regex: string | undefined;
+    channelType: number[] | undefined;
+    ignore:
+        | {
+              owner?: boolean | undefined;
+              users?: string[] | undefined;
+              channels?: string[] | undefined;
+              guilds?: string[] | undefined;
+          }
+        | undefined;
+    strict:
+        | {
+              owner?: boolean | undefined;
+              users?: string[] | undefined;
+              channels?: string[] | undefined;
+              guilds?: string[] | undefined;
+          }
+        | undefined;
+    permissions:
+        | {
+              client?: string[] | undefined;
+              user?: string[] | undefined;
+              dm?: boolean | undefined;
+          }
+        | undefined;
+    cooldown: number;
+    args: MessageArgumentOptions[];
+    client: typeof XernerxClient;
+    constructor(id: string, options: MessageCommandOptions);
+    /**
+     * @param {Message} message - The Discord message event data.
+     * @param {object} args - The arguments you created.
+     * @description make any preconditions here.
+     */
+    conditions(message: XernerxMessage, args: MessageArgumentOptions): Promise<void>;
+    /**
+     * @param {Message} message - The Discord message event data.
+     * @param {object} args - The arguments you created.
+     * @description Make your custom command here.
+     */
+    exec(message: XernerxMessage, args: MessageArgumentOptions): Promise<void>;
+}

package/dist/mjs/build/MessageCommandBuilder.js

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+import XernerxClient from '../client/XernerxClient.js';
+/**
+ * @description - The command builder for message commands.
+ * @param {String} id - The unique ID of the command.
+ * @param {MessageCommandOptions} options - The command options.
+ */
+export default class MessageCommandBuilder {
+    id;
+    name;
+    aliases;
+    separator;
+    description;
+    info;
+    category;
+    prefix;
+    regex;
+    channelType;
+    ignore;
+    strict;
+    permissions;
+    cooldown;
+    args;
+    client;
+    constructor(id, options) {
+        this.id = id;
+        z.object({
+            name: z.string(),
+            aliases: z.array(z.string()).optional(),
+            separator: z.string().min(1).max(1).optional(),
+            description: z.string().optional(),
+            info: z.string().optional(),
+            category: z.string().optional(),
+            prefix: z.array(z.string()).or(z.string()).optional(),
+            regex: z.unknown(),
+            channelType: z.array(z.number()).or(z.number()).optional(),
+            cooldown: z.number().optional(),
+            ignore: z
+                .object({
+                    owners: z.boolean().optional(),
+                    users: z.array(z.string()).or(z.string()).optional(),
+                    channels: z.array(z.string()).or(z.string()).optional(),
+                    guilds: z.array(z.string()).or(z.string()).optional(),
+                })
+                .optional(),
+            strict: z
+                .object({
+                    owners: z.boolean().optional(),
+                    users: z.array(z.string()).or(z.string()).optional(),
+                    channels: z.array(z.string()).or(z.string()).optional(),
+                    guilds: z.array(z.string()).or(z.string()).optional(),
+                })
+                .optional(),
+            permissions: z
+                .object({
+                    client: z.array(z.string()).optional(),
+                    users: z.array(z.string()).optional(),
+                    dm: z.boolean().optional(),
+                })
+                .optional(),
+        }).parse(options);
+        this.name = options.name;
+        this.aliases = options.aliases;
+        this.separator = options.separator || ' ';
+        this.description = options.description;
+        this.info = options.info;
+        this.category = options.category;
+        this.prefix = options.prefix ? (Array.isArray(options.prefix) ? options.prefix : [options.prefix]) : [];
+        this.regex = options.regex;
+        this.channelType = options.channelType;
+        this.ignore = options.ignore;
+        this.strict = options.strict;
+        this.permissions = options.permissions;
+        this.cooldown = options.cooldown || 0;
+        this.args = options.args || [];
+        this.client = XernerxClient;
+    }
+    /**
+     * @param {Message} message - The Discord message event data.
+     * @param {object} args - The arguments you created.
+     * @description make any preconditions here.
+     */
+    async conditions(message, args) {}
+    /**
+     * @param {Message} message - The Discord message event data.
+     * @param {object} args - The arguments you created.
+     * @description Make your custom command here.
+     */
+    async exec(message, args) {}
+}

package/dist/mjs/build/SlashCommandBuilder.d.ts

@@ -0,0 +1,64 @@
+import Discord, { Interaction } from 'discord.js';
+import { SlashCommandOptions } from '../types/options.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: string;
+    data: Discord.SlashCommandBuilder;
+    name: string;
+    description: string;
+    info: string | undefined;
+    category: string | undefined;
+    channelType: Discord.ChannelType | undefined;
+    cooldown: number | undefined;
+    ignore:
+        | {
+              owner?: boolean | undefined;
+              users?: string[] | undefined;
+              channels?: string[] | undefined;
+              guilds?: string[] | undefined;
+          }
+        | undefined;
+    strict:
+        | {
+              owner?: boolean | undefined;
+              users?: string[] | undefined;
+              channels?: string[] | undefined;
+              guilds?: string[] | undefined;
+          }
+        | undefined;
+    permissions: {
+        client?: string[] | undefined;
+        users?: string[] | undefined;
+        dm?: boolean | undefined;
+    };
+    args?: object[];
+    subcommands?: object[];
+    groups?: object[];
+    defer:
+        | {
+              reply?: boolean | undefined;
+              ephemeral?: boolean | undefined;
+              fetchReply?: boolean | undefined;
+          }
+        | undefined;
+    client: typeof XernerxClient;
+    constructor(id: string, options: SlashCommandOptions);
+    /**
+     * TODO - update description
+     * @param interaction
+     */
+    conditions(interaction: Interaction): Promise<void>;
+    /**
+     * TODO - update description
+     * @param interaction
+     */
+    exec(interaction: Interaction): Promise<void>;
+    private addArgs;
+    private addSubcommands;
+    private addSubcommandGroups;
+}