xernerx 4.14.0 → 4.15.0

package/dist/cjs/functions/deploy.js

@@ -0,0 +1,66 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+const discord_js_1 = require("discord.js");
+const dumfunctions_1 = require("dumfunctions");
+const XernerxLog_js_1 = __importDefault(require("../tools/XernerxLog.js"));
+const XernerxError_js_1 = __importDefault(require("../tools/XernerxError.js"));
+const globalCommands = [];
+const localCommands = [];
+function deploy(client) {
+    const commands = [];
+    function stats() {
+        client.stats.guildCount = client.guilds.cache.size;
+        client.stats.userCount = client.guilds.cache.map((g) => g.memberCount || g.approximateMemberCount || 0).reduce((a, b) => (a += b), 0);
+    }
+    process.on('message', (message) => {
+        if (message.type == 'xernerx')
+            client.stats.shardId = message?.data?.shardId;
+        if (message.type == 'client')
+            client.data = message.data;
+    });
+    client.on('messageCreate', stats);
+    client.on('interactionCreate', stats);
+    client.prependOnceListener('ready', (client) => {
+        stats();
+        client.commands.slash.map((command) => commands.push(command));
+        client.commands.context.map((command) => commands.push(command));
+        client.commands.slash.map((command) => commands.push(command));
+        if (client.commands.slash.size)
+            client.commands.slash.map((command) => (command.global ? globalCommands.push(command.data.toJSON()) : localCommands.push(command.data.toJSON())));
+        if (client.commands.context.size)
+            client.commands.context.map((command) => (command.global ? globalCommands.push(command.data.toJSON()) : localCommands.push(command.data.toJSON())));
+        if (globalCommands.length <= 0 && localCommands.length <= 0)
+            return;
+        try {
+            if (client.settings.global) {
+                put(client, client.settings.global, globalCommands);
+                put(client, !client.settings.global, localCommands);
+            }
+            else {
+                put(client, !client.settings.global, [...globalCommands, ...localCommands]);
+                put(client, client.settings.global, []);
+            }
+        }
+        catch (error) {
+            new XernerxLog_js_1.default(client).error(`An error occurred while deploying the commands!`, error);
+        }
+        finally {
+            new XernerxLog_js_1.default(client).info(`Deployed ${dumfunctions_1.Style.log(String(commands.filter((command) => command.global).length), {
+                color: dumfunctions_1.Style.TextColor.Cyan,
+            })} Commands ${client.settings.global
+                ? dumfunctions_1.Style.log('globally', { color: dumfunctions_1.Style.TextColor.Green })
+                : `${dumfunctions_1.Style.log('locally', { color: dumfunctions_1.Style.TextColor.Red })} in ${dumfunctions_1.Style.log(client.guilds.cache.get(client.settings.local)?.name, { color: dumfunctions_1.Style.TextColor.Blue })}`}.`);
+        }
+    });
+}
+exports.default = deploy;
+function put(client, global, body) {
+    const rest = new discord_js_1.REST({ version: discord_js_1.GatewayVersion }).setToken(client.token);
+    if (!global && !client.settings?.local)
+        throw new XernerxError_js_1.default(`No guild ID provided as local guild!`);
+    if (!global && client.settings?.local)
+        return rest.put(discord_js_1.Routes.applicationGuildCommands(client.user?.id, client.settings.local), { body });
+    else
+        return rest.put(discord_js_1.Routes.applicationCommands(client.user?.id), { body });
+}

package/dist/cjs/functions/load.js

@@ -0,0 +1,38 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+const XernerxLog_js_1 = __importDefault(require("../tools/XernerxLog.js"));
+async function load(client, path, type) {
+    try {
+        let file = new (await import(`file://${path}`)).default();
+        file.filetype = type;
+        file.filepath = path;
+        file.client = client;
+        file.util = {};
+        fileSave(client, file, type);
+        return file;
+    }
+    catch (error) {
+        new XernerxLog_js_1.default(client).error(`Couldn't load ${type} ${path.match(/\w*\.js$/gim)?.at(0) || path}`, error);
+    }
+}
+exports.default = load;
+function fileSave(client, file, type) {
+    switch (type) {
+        case 'MessageCommand':
+            client.commands.message.set(file.name, file);
+            break;
+        case 'SlashCommand':
+            client.commands.slash.set(file.name, file);
+            break;
+        case 'ContextCommand':
+            client.commands.context.set(file.name, file);
+            break;
+        case 'Inhibitor':
+            client.inhibitors.set(file.name, file);
+            break;
+        case 'Event':
+            client.events.set(file.name, file);
+            break;
+    }
+}

package/dist/cjs/functions/reload.js

@@ -0,0 +1,33 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const load_js_1 = __importDefault(require("./load.js"));
+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)) {
+                (0, load_js_1.default)(client, `${directory}\\${file}`, 'MessageCommand');
+            }
+            return true;
+        }
+        case 'slash': {
+            return client.commands.slash.clear();
+        }
+        case 'context': {
+            return client.commands.context.clear();
+        }
+        case 'events': {
+            return client.events.clear();
+        }
+        case 'inhibitors': {
+            return client.inhibitors.clear();
+        }
+    }
+}
+exports.default = reload;

package/dist/cjs/functions/setPresence.js

@@ -0,0 +1,24 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+const discord_js_1 = require("discord.js");
+const dumfunctions_1 = require("dumfunctions");
+function setPresence(client, options) {
+    const presence = () => client.user?.setPresence({
+        activities: [
+            {
+                name: options.text,
+                type: discord_js_1.ActivityType[dumfunctions_1.Style.titleCase(options.type || 'Custom')],
+                url: options.url,
+            },
+        ],
+        status: options.status,
+    });
+    let response = presence();
+    if (options.interval)
+        setInterval(() => {
+            response = presence();
+        }, options.interval);
+    return response;
+}
+exports.default = setPresence;

package/dist/cjs/functions/xernerxUser.js

@@ -0,0 +1,15 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xernerxUser = void 0;
+async function xernerxUser(event, client) {
+    const author = event.author || event.user;
+    author.owner = isOwner(client, author);
+    if (client.dbl.validate)
+        author.voted = await client?.dbl?.validate(author);
+    return author;
+}
+exports.xernerxUser = xernerxUser;
+function isOwner(client, user) {
+    return client.settings.ownerId.includes(user.id);
+}

package/dist/cjs/handlers/CommandHandler.js

@@ -0,0 +1,342 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+const zod_1 = require("zod");
+const path = __importStar(require("path"));
+const discord_js_1 = require("discord.js");
+const Handler_js_1 = __importDefault(require("./Handler.js"));
+const MessageUtil_js_1 = __importDefault(require("../utils/MessageUtil.js"));
+const xernerxUser_js_1 = require("../functions/xernerxUser.js");
+const InteractionUtil_js_1 = __importDefault(require("../utils/InteractionUtil.js"));
+const commandValidation_js_1 = __importDefault(require("../validators/commandValidation.js"));
+const XernerxLog_js_1 = __importDefault(require("../tools/XernerxLog.js"));
+const Arguments_js_1 = require("../models/Arguments.js");
+const inhibitorValidations_js_1 = require("../validators/inhibitorValidations.js");
+const dumfunctions_1 = require("dumfunctions");
+class CommandHandler extends Handler_js_1.default {
+    constructor(client) {
+        super(client);
+        this.readyTimestamp = Number(Date.now());
+    }
+    async loadMessageCommands(options) {
+        const commands = [];
+        if (!this.client.options.intents.has(discord_js_1.GatewayIntentBits.MessageContent))
+            new XernerxLog_js_1.default(this.client).warn(`Message commands might not work as you're missing the intent MessageContent!`);
+        if (!this.client.options.intents.has(discord_js_1.GatewayIntentBits.GuildMessages))
+            new XernerxLog_js_1.default(this.client).warn(`Message commands might not work as you're missing the intent GuildMessages!`);
+        options = zod_1.z
+            .object({
+            directory: zod_1.z.string(),
+            prefix: zod_1.z.string().or(zod_1.z.array(zod_1.z.string())),
+            allowMention: zod_1.z.boolean().default(false),
+            cooldown: zod_1.z.number().default(0),
+            permissions: zod_1.z
+                .object({
+                user: zod_1.z.array(zod_1.z.string()).or(zod_1.z.null()).default(null),
+                client: zod_1.z.array(zod_1.z.string()).or(zod_1.z.null()).default(null),
+                dm: zod_1.z.boolean().default(true),
+            })
+                .default({}),
+            handleEdits: zod_1.z.boolean().default(false),
+            handleDeletes: zod_1.z.boolean().default(false),
+            handleTyping: zod_1.z.boolean().default(false),
+            logging: zod_1.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}`;
+            const command = await this.load(filepath, 'MessageCommand');
+            this._checks(command);
+            commands.push(command.id);
+        }
+        new XernerxLog_js_1.default(this.client).info(`Loaded ${dumfunctions_1.Style.log(String(files.length), { color: dumfunctions_1.Style.TextColor.Cyan })} Message Commands: ${commands.map((command) => dumfunctions_1.Style.log(command, { color: dumfunctions_1.Style.TextColor.LightYellow })).join(', ')}`);
+        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');
+    // }
+    async loadSlashCommands(options) {
+        const commands = [];
+        if (!this.client.settings.local)
+            new XernerxLog_js_1.default(this.client).warn(`Slash commands might not work as you haven't specified a local guild ID.`);
+        options = zod_1.z
+            .object({
+            directory: zod_1.z.string(),
+            cooldown: zod_1.z.number().default(0),
+            permissions: zod_1.z
+                .object({
+                user: zod_1.z.array(zod_1.z.string()).or(zod_1.z.null()).default(null),
+                client: zod_1.z.array(zod_1.z.string()).or(zod_1.z.null()).default(null),
+                dm: zod_1.z.boolean().default(true),
+            })
+                .default({}),
+            logging: zod_1.z.boolean().default(false),
+            defer: zod_1.z
+                .object({
+                reply: zod_1.z.boolean().default(false),
+                ephemeral: zod_1.z.boolean().default(false),
+                fetchReply: zod_1.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}`;
+            const command = await this.load(filepath, 'SlashCommand');
+            commands.push(command.id);
+        }
+        new XernerxLog_js_1.default(this.client).info(`Loaded ${dumfunctions_1.Style.log(String(files.length), { color: dumfunctions_1.Style.TextColor.Cyan })} Slash Commands: ${commands.map((command) => dumfunctions_1.Style.log(command, { color: dumfunctions_1.Style.TextColor.LightYellow })).join(', ')}`);
+        this.emit({
+            name: 'interactionCreate',
+            filetype: 'SlashCommand',
+            run: (interaction) => this.slashCommandRun(interaction),
+        });
+    }
+    async loadContextCommands(options) {
+        const commands = [];
+        if (!this.client.settings.local)
+            new XernerxLog_js_1.default(this.client).warn(`Context commands might not work as you haven't specified a local guild ID.`);
+        options = zod_1.z
+            .object({
+            directory: zod_1.z.string(),
+            cooldown: zod_1.z.number().default(0),
+            permissions: zod_1.z
+                .object({
+                user: zod_1.z.array(zod_1.z.string()).or(zod_1.z.null()).default(null),
+                client: zod_1.z.array(zod_1.z.string()).or(zod_1.z.null()).default(null),
+                dm: zod_1.z.boolean().default(true),
+            })
+                .default({}),
+            logging: zod_1.z.boolean().default(false),
+            defer: zod_1.z
+                .object({
+                reply: zod_1.z.boolean().default(false),
+                ephemeral: zod_1.z.boolean().default(false),
+                fetchReply: zod_1.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}`;
+            const command = await this.load(filepath, 'ContextCommand');
+            commands.push(command.id);
+        }
+        new XernerxLog_js_1.default(this.client).info(`Loaded ${dumfunctions_1.Style.log(String(files.length), { color: dumfunctions_1.Style.TextColor.Cyan })} Context Commands: ${commands.map((command) => dumfunctions_1.Style.log(command, { color: dumfunctions_1.Style.TextColor.LightYellow })).join(', ')}`);
+        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_js_1.default(this.client, message);
+        message.user = await (0, xernerxUser_js_1.xernerxUser)(message, this.client);
+        if (await (0, inhibitorValidations_js_1.inhibitorValidation)(message, undefined, undefined, 'pre'))
+            return;
+        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);
+            await this.client.emit('commandStart', message, cmd);
+            const args = await (0, Arguments_js_1.messageArguments)(message, cmd, commandPrefix);
+            message.util.parsed = {
+                alias: commandAlias,
+                prefix: commandPrefix,
+                args: args.args,
+            };
+            cmd.util = message.util;
+            return await this.exec(cmd, message, args, filetype);
+        }
+    }
+    async slashCommandRun(interaction) {
+        const filetype = 'SlashCommand';
+        interaction.util = new InteractionUtil_js_1.default(this.client, interaction);
+        interaction.user = await (0, xernerxUser_js_1.xernerxUser)(interaction, this.client);
+        if (await (0, inhibitorValidations_js_1.inhibitorValidation)(interaction, undefined, undefined, 'pre'))
+            return;
+        let cmd = null;
+        if (this.client.commands.slash.has(interaction.commandName))
+            cmd = this.client.commands.slash.get(interaction.commandName);
+        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 () => {
+            await this.client.emit('commandStart', interaction);
+            const args = await (0, Arguments_js_1.interactionArguments)(interaction, cmd);
+            interaction.util.parsed = {
+                alias: [interaction.commandName, args.group || null, args.subcommand || null].filter((x) => x).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));
+    }
+    async contextCommandRun(interaction) {
+        const filetype = 'ContextCommand';
+        interaction.util = new InteractionUtil_js_1.default(this.client, interaction);
+        interaction.user = await (0, xernerxUser_js_1.xernerxUser)(interaction, this.client);
+        if (await (0, inhibitorValidations_js_1.inhibitorValidation)(interaction, undefined, undefined, 'pre'))
+            return;
+        let cmd;
+        if (this.client.commands.context.has(interaction.commandName))
+            cmd = this.client.commands.context.get(interaction.commandName);
+        if (!cmd)
+            return this.client.emit('commandNotFound', interaction, interaction.commandName, filetype);
+        await this.client.emit('commandStart', interaction);
+        const args = await (0, Arguments_js_1.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 {
+            if (cmd.filetype == 'SlashCommand' && (cmd?.defer?.reply ?? this.client.modules.options.slash?.defer?.reply)) {
+                await event.deferReply({
+                    ephemeral: cmd.defer?.ephemeral || this.client.modules.options.slash?.defer?.ephemeral || false,
+                });
+            }
+            if (cmd.filetype == 'ContextCommand' && (cmd?.defer?.reply ?? this.client.modules.options.context?.defer?.reply)) {
+                await event.deferReply({
+                    ephemeral: cmd.defer?.ephemeral || this.client.modules.options.context?.defer?.ephemeral || false,
+                });
+            }
+            if (await (0, commandValidation_js_1.default)(event, cmd))
+                return;
+            if (await (0, inhibitorValidations_js_1.inhibitorValidation)(event, args, cmd, 'check'))
+                return;
+            if (cmd.conditions && (await cmd.conditions(event, args)))
+                return;
+            await cmd.exec(event, args);
+            await (0, inhibitorValidations_js_1.inhibitorValidation)(event, args, cmd, 'post');
+            return await this.client.emit('commandFinish', event, cmd);
+        }
+        catch (error) {
+            new XernerxLog_js_1.default(this.client).error(`An error occurred executing ${dumfunctions_1.Style.log(cmd.name, { color: dumfunctions_1.Style.TextColor.Blue })}`, error);
+            return await this.client.emit('commandError', event, error, cmd, type);
+        }
+    }
+    _checks(command) {
+        if ((command.strict?.voice || command.ignore?.voice) && !this.client.options.intents.has('GuildVoiceStates'))
+            new XernerxLog_js_1.default(this.client).warn(`${dumfunctions_1.Style.log(command.id, { color: dumfunctions_1.Style.TextColor.Blue })} options ${dumfunctions_1.Style.log(`Xernerx${command.filetype}#strict#voice`, {
+                color: dumfunctions_1.Style.BackgroundColor.Grey,
+            })} or ${dumfunctions_1.Style.log(`Xernerx${command.filetype}#ignore#voice`, {
+                color: dumfunctions_1.Style.BackgroundColor.Grey,
+            })} will misbehave due to missing the ${dumfunctions_1.Style.log('GuildVoiceStates', { color: dumfunctions_1.Style.TextColor.Yellow })} intent.`);
+    }
+}
+exports.default = CommandHandler;

package/dist/cjs/handlers/EventHandler.js

@@ -0,0 +1,32 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+const zod_1 = require("zod");
+const dumfunctions_1 = require("dumfunctions");
+const path = __importStar(require("path"));
+const Handler_js_1 = __importDefault(require("./Handler.js"));
+const XernerxLog_js_1 = __importDefault(require("../tools/XernerxLog.js"));
+class EventHandler extends Handler_js_1.default {
+    constructor(client) {
+        super(client);
+        this.readyTimestamp = Number(Date.now());
+    }
+    async loadEvents(options) {
+        const events = [];
+        options = zod_1.z
+            .object({
+            directory: zod_1.z.string(),
+        })
+            .parse(options);
+        this.client.modules.options.events = options;
+        const files = this.readdir(options.directory);
+        for (const file of files) {
+            const filepath = `${path.resolve(options.directory)}\\${file}`;
+            const event = await this.load(filepath, 'Event');
+            this.emit(event);
+            events.push(event.id);
+        }
+        new XernerxLog_js_1.default(this.client).info(`Loaded ${dumfunctions_1.Style.log(String(this.client.events.size), { color: dumfunctions_1.Style.TextColor.Cyan })} Events: ${events.map((event) => dumfunctions_1.Style.log(event, { color: dumfunctions_1.Style.TextColor.LightYellow })).join(', ')}`);
+    }
+}
+exports.default = EventHandler;

package/dist/cjs/handlers/ExtensionHandler.js

@@ -0,0 +1,32 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+const dumfunctions_1 = require("dumfunctions");
+const Handler_js_1 = __importDefault(require("./Handler.js"));
+const XernerxLog_js_1 = __importDefault(require("../tools/XernerxLog.js"));
+class ExtensionHandler extends Handler_js_1.default {
+    constructor(client) {
+        super(client);
+        this.readyTimestamp = Number(Date.now());
+    }
+    loadExtensions(...extensions) {
+        const active = extensions.map((extension) => {
+            try {
+                if (extension.main)
+                    extension.main(this.client);
+                if (extension.defer) {
+                    this.client.on('ready', (client) => extension.defer(client));
+                }
+                return extension.name;
+            }
+            catch (error) {
+                return new XernerxLog_js_1.default(this.client).error(`An error occurred while loading ${dumfunctions_1.Style.log(extension.name, { color: dumfunctions_1.Style.TextColor.Red })}`, error);
+            }
+        });
+        new XernerxLog_js_1.default(this.client).info(`Loaded ${dumfunctions_1.Style.log(String(extensions.length), { color: dumfunctions_1.Style.TextColor.Cyan })} Extensions: ${active
+            .filter((e) => e)
+            .map((event) => dumfunctions_1.Style.log(event, { color: dumfunctions_1.Style.TextColor.LightYellow }))
+            .join(', ')}`);
+    }
+}
+exports.default = ExtensionHandler;

package/dist/cjs/handlers/Handler.js

@@ -0,0 +1,48 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const load_js_1 = __importDefault(require("../functions/load.js"));
+class Handler {
+    client;
+    files;
+    constructor(client) {
+        this.client = client;
+        this.files = [];
+    }
+    readdir(dir) {
+        try {
+            return fs.readdirSync(path.resolve(dir)).filter((file) => file.endsWith('.js'));
+        }
+        catch (error) {
+            console.error(error);
+        }
+        return [];
+    }
+    async load(filepath, type) {
+        const file = await (0, load_js_1.default)(this.client, filepath, type);
+        this.files.push(file);
+        return file;
+    }
+    async emit(event) {
+        if (!event?.filetype)
+            return;
+        if (event.filetype === 'Event') {
+            if (event.emitter === 'client')
+                event.once
+                    ? this.client.once(event.name, (...args) => event.run(...args))
+                    : this.client.on(event.name, (...args) => event.run(...args));
+            else if (event.emitter === 'process')
+                event.once
+                    ? process.once(event.name, (...args) => event.run(...args))
+                    : process.on(event.name, (...args) => event.run(...args));
+        }
+        if (['MessageCommand', 'SlashCommand', 'ContextCommand'].includes(event.filetype)) {
+            event.once
+                ? this.client.once(event.name, (...args) => event.run(...args))
+                : this.client.on(event.name, (...args) => event.run(...args));
+        }
+    }
+}
+exports.default = Handler;

package/dist/cjs/handlers/InhibitorHandler.js

@@ -0,0 +1,34 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+const zod_1 = require("zod");
+const path = __importStar(require("path"));
+const dumfunctions_1 = require("dumfunctions");
+const Handler_js_1 = __importDefault(require("./Handler.js"));
+const XernerxLog_js_1 = __importDefault(require("../tools/XernerxLog.js"));
+class InhibitorHandler extends Handler_js_1.default {
+    constructor(client) {
+        super(client);
+        this.readyTimestamp = Number(Date.now());
+    }
+    async loadInhibitors(options) {
+        const inhibitors = [];
+        options = zod_1.z
+            .object({
+            directory: zod_1.z.string(),
+        })
+            .parse(options);
+        this.client.modules.options.inhibitors = options;
+        const files = this.readdir(options.directory);
+        for (const file of files) {
+            const filepath = `${path.resolve(options.directory)}\\${file}`;
+            const inhibitor = await this.load(filepath, 'Inhibitor');
+            this.emit(inhibitor);
+            inhibitors.push(inhibitor.id);
+        }
+        new XernerxLog_js_1.default(this.client).info(`Loaded ${dumfunctions_1.Style.log(String(this.client.inhibitors.size), { color: dumfunctions_1.Style.TextColor.Cyan })} Inhibitors: ${inhibitors
+            .map((inhibitor) => dumfunctions_1.Style.log(inhibitor, { color: dumfunctions_1.Style.TextColor.LightYellow }))
+            .join(', ')}`);
+    }
+}
+exports.default = InhibitorHandler;