xernerx 3.5.1 → 3.6.0

package/dist/mjs/main.js

@@ -0,0 +1,112 @@
+'use strict';
+var __createBinding =
+    (this && this.__createBinding) ||
+    (Object.create
+        ? function (o, m, k, k2) {
+              if (k2 === undefined) k2 = k;
+              var desc = Object.getOwnPropertyDescriptor(m, k);
+              if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+                  desc = {
+                      enumerable: true,
+                      get: function () {
+                          return m[k];
+                      },
+                  };
+              }
+              Object.defineProperty(o, k2, desc);
+          }
+        : function (o, m, k, k2) {
+              if (k2 === undefined) k2 = k;
+              o[k2] = m[k];
+          });
+var __exportStar =
+    (this && this.__exportStar) ||
+    function (m, exports) {
+        for (var p in m) if (p !== 'default' && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+    };
+var __importDefault =
+    (this && this.__importDefault) ||
+    function (mod) {
+        return mod && mod.__esModule ? mod : { default: mod };
+    };
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.xernerxVersion =
+    exports.XernerxError =
+    exports.ExtensionBuilder =
+    exports.InhibitorBuilder =
+    exports.SlashCommandBuilder =
+    exports.ContextCommandBuilder =
+    exports.MessageCommandBuilder =
+    exports.EventBuilder =
+    exports.ContextCommandType =
+    exports.InhibitorType =
+    exports.EventEmitterType =
+    exports.CommandType =
+    exports.XernerxClient =
+        void 0;
+__exportStar(require('discord.js'), exports);
+__exportStar(require('dumfunctions'), exports);
+const xernerx_extension_builder_1 = __importDefault(require('xernerx-extension-builder'));
+exports.ExtensionBuilder = xernerx_extension_builder_1.default;
+const XernerxClient_js_1 = __importDefault(require('./client/XernerxClient.js'));
+exports.XernerxClient = XernerxClient_js_1.default;
+const EventBuilder_js_1 = __importDefault(require('./build/EventBuilder.js'));
+exports.EventBuilder = EventBuilder_js_1.default;
+const InhibitorBuilder_js_1 = __importDefault(require('./build/InhibitorBuilder.js'));
+exports.InhibitorBuilder = InhibitorBuilder_js_1.default;
+const MessageCommandBuilder_js_1 = __importDefault(require('./build/MessageCommandBuilder.js'));
+exports.MessageCommandBuilder = MessageCommandBuilder_js_1.default;
+const ContextCommandBuilder_js_1 = __importDefault(require('./build/ContextCommandBuilder.js'));
+exports.ContextCommandBuilder = ContextCommandBuilder_js_1.default;
+const SlashCommandBuilder_js_1 = __importDefault(require('./build/SlashCommandBuilder.js'));
+exports.SlashCommandBuilder = SlashCommandBuilder_js_1.default;
+const enums_js_1 = require('./types/enums.js');
+Object.defineProperty(exports, 'CommandType', {
+    enumerable: true,
+    get: function () {
+        return enums_js_1.CommandType;
+    },
+});
+Object.defineProperty(exports, 'EventEmitterType', {
+    enumerable: true,
+    get: function () {
+        return enums_js_1.EventEmitterType;
+    },
+});
+Object.defineProperty(exports, 'ContextCommandType', {
+    enumerable: true,
+    get: function () {
+        return enums_js_1.ContextCommandType;
+    },
+});
+Object.defineProperty(exports, 'InhibitorType', {
+    enumerable: true,
+    get: function () {
+        return enums_js_1.InhibitorType;
+    },
+});
+const XernerxError_js_1 = __importDefault(require('./tools/XernerxError.js'));
+exports.XernerxError = XernerxError_js_1.default;
+const package_js_1 = __importDefault(require('./tools/package.js'));
+const xernerxVersion = package_js_1.default.version;
+exports.xernerxVersion = xernerxVersion;
+exports.default = {
+    // Client
+    Client: XernerxClient_js_1.default,
+    XernerxClient: XernerxClient_js_1.default,
+    // Enums
+    CommandType: enums_js_1.CommandType,
+    EventEmitterType: enums_js_1.EventEmitterType,
+    InhibitorType: enums_js_1.InhibitorType,
+    ContextCommandType: enums_js_1.ContextCommandType,
+    // Builds
+    EventBuilder: EventBuilder_js_1.default,
+    MessageCommandBuilder: MessageCommandBuilder_js_1.default,
+    ContextCommandBuilder: ContextCommandBuilder_js_1.default,
+    SlashCommandBuilder: SlashCommandBuilder_js_1.default,
+    InhibitorBuilder: InhibitorBuilder_js_1.default,
+    ExtensionBuilder: xernerx_extension_builder_1.default,
+    XernerxError: XernerxError_js_1.default,
+    // Constants
+    version: xernerxVersion,
+};

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

@@ -0,0 +1,17 @@
+import MessageCommandBuilder from '../build/MessageCommandBuilder.js';
+import { XernerxInteraction, XernerxMessage } from '../types/types.js';
+export declare class InteractionArguments {
+    interaction: XernerxInteraction;
+    constructor(interaction: XernerxInteraction);
+    group(): string | undefined;
+    subcommand(): string | undefined;
+    arguments(): Record<string, object>;
+}
+interface Flag {
+    flags: Record<string, string | boolean>;
+}
+interface Argument {
+    [index: string]: string | number | null;
+}
+export declare function messageArguments(message: XernerxMessage, command: MessageCommandBuilder): Promise<import('discord.js').Message<boolean> | Flag | Argument | undefined>;
+export {};

package/dist/mjs/models/CommandArguments.js

@@ -0,0 +1,106 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.messageArguments = exports.InteractionArguments = void 0;
+class InteractionArguments {
+    interaction;
+    constructor(interaction) {
+        this.interaction = interaction;
+    }
+    group() {
+        return this.interaction?.options?._group;
+    }
+    subcommand() {
+        return this.interaction?.options?._subcommand;
+    }
+    arguments() {
+        const options = {};
+        if (this.interaction?.options?._hoistedOptions) {
+            for (const option of this.interaction.options._hoistedOptions) {
+                options[option.name] = option.channel || option.user || option.role || option.value;
+            }
+        }
+        return options;
+    }
+}
+exports.InteractionArguments = InteractionArguments;
+async function messageArguments(message, command) {
+    let args = { flags: {} },
+        separator = command.separator || ' ',
+        i = 0;
+    if (!command.args) return;
+    command.args
+        .filter((c) => c.type == 'flag')
+        .map((flag) => {
+            args = args;
+            for (const flg of message.content.matchAll(flag.match)) {
+                if (flag.match == flg) {
+                    message.content = message.content.replace(flag.match, '');
+                    args.flags[flag.name] = true;
+                }
+            }
+            if (!args.flags[flag.name]) args.flags[flag.name] = false;
+        });
+    for (const argument of command.args) {
+        args = args;
+        let content = message.content
+            .split(/ +/)
+            .slice(1)
+            .join(separator)
+            .replace(new RegExp(`${separator}${separator}+`, 'g'), separator)
+            .split(separator)
+            .slice(i);
+        if (content.join(separator) != '' && argument.type !== 'flag') {
+            if (argument?.content?.includes(content[0])) {
+                args[argument.name] = content[0];
+            } else if (argument.type == 'string') {
+                args[argument.name] = content[0];
+            } else if (argument.type == 'number') {
+                args[argument.name] = parseInt(content[0]);
+            } else if (argument.type == 'boolean') {
+                if (content[0]?.toLowerCase() != 'true' && content[0]?.toLowerCase() != 'false') content[0] = null;
+                args[argument.name] = content[0];
+            } else if (argument.type == 'user') {
+                let user = message.client.users.cache.find((u) => u?.username?.toLowerCase()?.includes(content[0])) || null;
+                try {
+                    user = (await message.client.users.fetch(user?.id || content[0].replace(/<@!?|>/g, ''))) || null;
+                } catch (e) {
+                    user = null;
+                }
+                args[argument.name] = user;
+            } else if (argument.type == 'role') {
+                let role = message.guild?.roles.cache.find((r) => r?.name?.toLowerCase()?.includes(content[0])) || null;
+                try {
+                    role = (await message.guild?.roles.fetch(role?.id || content[0].replace(/<@&?|>/g, ''))) || null;
+                } catch (e) {
+                    role = null;
+                }
+                args[argument.name] = role;
+            } else if (argument.type == 'member') {
+                let member = message.guild?.members.cache.find((m) => m?.nickname?.toLowerCase()?.includes(content[0]) || m?.user?.username?.toLowerCase()?.includes(content[0])) || null;
+                try {
+                    member = (await message.guild?.members.fetch(member?.id || content[0].replace(/<@!?|>/g, ''))) || null;
+                } catch (e) {
+                    member = null;
+                }
+                args[argument.name] = member;
+            } else if (argument.type == 'channel') {
+                let channel = message.guild?.channels.cache.find((c) => c?.name?.toLowerCase()?.includes(content[0]));
+                try {
+                    channel = await message.client.channels.fetch(channel?.id || content[0].replace(/<#|>/g, ''));
+                } catch (e) {
+                    channel = null;
+                }
+                args[argument.name] = channel;
+            } else if (argument.type == 'rest') {
+                args[argument.name] = content.join(separator);
+                break;
+            } else if (argument.prompt) {
+                if (argument.prompt.reply) return message.util?.reply(argument.prompt.reply);
+                else if (argument.prompt.send) return message.channel.send(argument.prompt.send);
+            } else args[argument.name] = typeof argument.default == 'function' ? argument.default(message) : argument.default;
+            i++;
+        } else args[argument.name] = typeof argument.default == 'function' ? argument.default(message) : argument.default;
+    }
+    return args;
+}
+exports.messageArguments = messageArguments;

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

@@ -0,0 +1,24 @@
+import XernerxClient from '../client/XernerxClient.js';
+export declare class MessageCommandEvents {
+    client: XernerxClient;
+    constructor(client: XernerxClient);
+    messageCreate(): void;
+    messageUpdate(): void;
+    messageDelete(): void;
+}
+export declare class SlashCommandEvents {
+    client: XernerxClient;
+    constructor(client: XernerxClient);
+    slashCreate(): void;
+}
+export declare class ContextCommandEvents {
+    client: XernerxClient;
+    constructor(client: XernerxClient);
+    contextCreate(): void;
+}
+export declare class CommandsDeploy {
+    private client;
+    constructor(client: XernerxClient);
+    deploy(): void;
+    private put;
+}

package/dist/mjs/models/Events.js

@@ -0,0 +1,309 @@
+'use strict';
+var __importDefault =
+    (this && this.__importDefault) ||
+    function (mod) {
+        return mod && mod.__esModule ? mod : { default: mod };
+    };
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.CommandsDeploy = exports.ContextCommandEvents = exports.SlashCommandEvents = exports.MessageCommandEvents = void 0;
+const discord_js_1 = require('discord.js');
+const CommandUtil_js_1 = require('../utils/CommandUtil.js');
+const CommandArguments_js_1 = require('./CommandArguments.js');
+const CommandValidations_js_1 = __importDefault(require('../validators/CommandValidations.js'));
+const dumfunctions_1 = require('dumfunctions');
+const InhibitorValidations_js_1 = require('../validators/InhibitorValidations.js');
+const XernerxUser_js_1 = __importDefault(require('./XernerxUser.js'));
+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 = await (0, XernerxUser_js_1.default)(message);
+                message.util = new CommandUtil_js_1.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 InhibitorValidations_js_1.InhibitorValidation(this.client, message, command);
+                                if ((0, CommandValidations_js_1.default)(message, cmd, this.client)) return;
+                                if (await inhibitor.inhibit()) return;
+                                if (cmd.conditions && (await cmd.conditions(message, await (0, CommandArguments_js_1.messageArguments)(message, cmd)))) return;
+                                await cmd.exec(message, await (0, CommandArguments_js_1.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;
+                message.author = await (0, XernerxUser_js_1.default)(message);
+                message.util = new CommandUtil_js_1.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 InhibitorValidations_js_1.InhibitorValidation(this.client, message, command);
+                                if ((0, CommandValidations_js_1.default)(message, cmd, this.client)) return;
+                                if (await inhibitor.inhibit()) return;
+                                if (cmd.conditions && (await cmd.conditions(message, await (0, CommandArguments_js_1.messageArguments)(message, cmd)))) return;
+                                await cmd.exec(message, await (0, CommandArguments_js_1.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();
+                    message.author = await (0, XernerxUser_js_1.default)(message);
+                    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);
+                }
+            }
+        });
+    }
+}
+exports.MessageCommandEvents = MessageCommandEvents;
+class SlashCommandEvents {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    slashCreate() {
+        this.client.on('interactionCreate', async (interaction) => {
+            interaction.util = new CommandUtil_js_1.InteractionCommandUtil(this.client, interaction);
+            interaction.author = await (0, XernerxUser_js_1.default)(interaction);
+            if (interaction.type === discord_js_1.InteractionType.ApplicationCommand) {
+                if (this.client.commands.slash.has(interaction.commandName)) {
+                    let command = this.client.commands.slash.get(interaction.commandName);
+                    const argumentsInfo = new CommandArguments_js_1.InteractionArguments(interaction);
+                    try {
+                        const inhibitor = new InhibitorValidations_js_1.InhibitorValidation(this.client, interaction, command);
+                        if (await inhibitor.inhibit()) return;
+                        if ((0, CommandValidations_js_1.default)(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);
+                    }
+                }
+            }
+        });
+    }
+}
+exports.SlashCommandEvents = SlashCommandEvents;
+class ContextCommandEvents {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    contextCreate() {
+        this.client.on('interactionCreate', async (interaction) => {
+            interaction.util = new CommandUtil_js_1.InteractionCommandUtil(this.client, interaction);
+            interaction.author = await (0, XernerxUser_js_1.default)(interaction);
+            if (interaction.type === discord_js_1.InteractionType.ApplicationCommand) {
+                if (this.client.commands.context.has(interaction.commandName)) {
+                    let command = this.client.commands.context.get(interaction.commandName);
+                    try {
+                        const inhibitor = new InhibitorValidations_js_1.InhibitorValidation(this.client, interaction, command);
+                        if ((0, CommandValidations_js_1.default)(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);
+                    }
+                }
+            }
+        });
+    }
+}
+exports.ContextCommandEvents = ContextCommandEvents;
+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(
+                            dumfunctions_1.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: dumfunctions_1.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(
+                        dumfunctions_1.Style.log(
+                            `Xernerx | Deployed ${slashCommands.length} slash commands ${global.slash ? 'globally' : 'locally'} and ${contextCommands.length} context commands ${
+                                global.context ? 'globally' : 'locally'
+                            }.`,
+                            { color: dumfunctions_1.Style.TextColor.Purple }
+                        )
+                    );
+            } catch (error) {
+                console.error(
+                    dumfunctions_1.Style.log(`Xernerx | Couldn't deploy interaction commands because <${error}>.`, {
+                        color: dumfunctions_1.Style.BackgroundColor.Red,
+                    })
+                );
+            }
+        });
+    }
+    put(type, guild, body) {
+        const rest = new discord_js_1.REST({ version: discord_js_1.GatewayVersion }).setToken(this.client.token);
+        if (type === 'guild') rest.put(discord_js_1.Routes.applicationGuildCommands(this.client.user?.id, guild), { body });
+        else rest.put(discord_js_1.Routes.applicationCommands(this.client.user?.id), { body });
+    }
+}
+exports.CommandsDeploy = CommandsDeploy;

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,26 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+const dumfunctions_1 = require('dumfunctions');
+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(
+                    dumfunctions_1.Style.log(`Xernerx | An error occurred trying to load ${extension.name}, error: <${error}>`, {
+                        color: dumfunctions_1.Style.BackgroundColor.Red,
+                    })
+                );
+            }
+        });
+        if (logging) console.info(dumfunctions_1.Style.log(`Xernerx | Loaded ${exts.length} extensions: ${exts.join(', ')}`, { color: dumfunctions_1.Style.TextColor.Cyan }));
+    }
+}
+exports.default = Extensions;

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

@@ -0,0 +1,2 @@
+import { XernerxUser } from '../types/types.js';
+export default function XernerxUser(interaction: any): Promise<XernerxUser>;

package/dist/mjs/models/XernerxUser.js

@@ -0,0 +1,12 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+const dbl_sdk_1 = require('dbl-sdk');
+async function XernerxUser(interaction) {
+    const user = interaction.user || interaction.author;
+    user.owner = interaction.client.util.isOwner(user.id);
+    user.voter = interaction.client.handlerOptions?.webhook?.topgg?.token
+        ? await (0, dbl_sdk_1.hasVoted)(user.id, interaction.client.user.id, interaction.client.handlerOptions.webhook.topgg.token, 'top.gg')
+        : false;
+    return user;
+}
+exports.default = XernerxUser;

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,11 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+class XernerxError {
+    name;
+    message;
+    constructor(message) {
+        this.name = 'XernerxError';
+        this.message = message || '';
+    }
+}
+exports.default = XernerxError;