xernerx 4.4.13 → 4.4.14

package/dist/handlers/CommandHandler.js

@@ -15,28 +15,26 @@ export default class CommandHandler extends Handler {
         super(client);
     }
     loadMessageCommands(options) {
-        if (!this.client.options.intents.has(GatewayIntentBits.MessageContent))
-            new XernerxLog(this.client).warn(`Message commands might not work as you're missing the intent MessageContent!`);
-        if (!this.client.options.intents.has(GatewayIntentBits.GuildMessages))
-            new XernerxLog(this.client).warn(`Message commands might not work as you're missing the intent GuildMessages!`);
+        if (!this.client.options.intents.has(GatewayIntentBits.MessageContent)) new XernerxLog(this.client).warn(`Message commands might not work as you're missing the intent MessageContent!`);
+        if (!this.client.options.intents.has(GatewayIntentBits.GuildMessages)) new XernerxLog(this.client).warn(`Message commands might not work as you're missing the intent GuildMessages!`);
         options = z
             .object({
-            directory: z.string(),
-            prefix: z.string().or(z.array(z.string())),
-            allowMention: z.boolean().default(false),
-            cooldown: z.number().default(0),
-            permissions: z
-                .object({
-                user: z.array(z.string()).default([]),
-                client: z.array(z.string()).default([]),
-                dm: z.boolean().default(true),
+                directory: z.string(),
+                prefix: z.string().or(z.array(z.string())),
+                allowMention: z.boolean().default(false),
+                cooldown: z.number().default(0),
+                permissions: z
+                    .object({
+                        user: z.array(z.string()).default([]),
+                        client: z.array(z.string()).default([]),
+                        dm: z.boolean().default(true),
+                    })
+                    .default({}),
+                handleEdits: z.boolean().default(false),
+                handleDeletes: z.boolean().default(false),
+                handleTyping: z.boolean().default(false),
+                logging: z.boolean().default(false),
             })
-                .default({}),
-            handleEdits: z.boolean().default(false),
-            handleDeletes: z.boolean().default(false),
-            handleTyping: z.boolean().default(false),
-            logging: z.boolean().default(false),
-        })
             .parse(options);
         this.client.modules.options.message = options;
         const files = this.readdir(options.directory);
@@ -65,28 +63,27 @@ 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.`);
+        if (!this.client.settings.local) new XernerxLog(this.client).warn(`Slash commands might not work as you haven't specified a local guild ID.`);
         options = z
             .object({
-            directory: z.string(),
-            cooldown: z.number().default(0),
-            permissions: z
-                .object({
-                user: z.array(z.string()).default([]),
-                client: z.array(z.string()).default([]),
-                dm: z.boolean().default(true),
-            })
-                .default({}),
-            logging: z.boolean().default(false),
-            defer: z
-                .object({
-                reply: z.boolean().default(false),
-                ephemeral: z.boolean().default(false),
-                fetchReply: z.boolean().default(false),
+                directory: z.string(),
+                cooldown: z.number().default(0),
+                permissions: z
+                    .object({
+                        user: z.array(z.string()).default([]),
+                        client: z.array(z.string()).default([]),
+                        dm: z.boolean().default(true),
+                    })
+                    .default({}),
+                logging: z.boolean().default(false),
+                defer: z
+                    .object({
+                        reply: z.boolean().default(false),
+                        ephemeral: z.boolean().default(false),
+                        fetchReply: z.boolean().default(false),
+                    })
+                    .default({}),
             })
-                .default({}),
-        })
             .parse(options);
         this.client.modules.options.slash = options;
         const files = this.readdir(options.directory);
@@ -103,28 +100,27 @@ 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.`);
+        if (!this.client.settings.local) new XernerxLog(this.client).warn(`Context commands might not work as you haven't specified a local guild ID.`);
         options = z
             .object({
-            directory: z.string(),
-            cooldown: z.number().default(0),
-            permissions: z
-                .object({
-                user: z.array(z.string()).default([]),
-                client: z.array(z.string()).default([]),
-                dm: z.boolean().default(true),
+                directory: z.string(),
+                cooldown: z.number().default(0),
+                permissions: z
+                    .object({
+                        user: z.array(z.string()).default([]),
+                        client: z.array(z.string()).default([]),
+                        dm: z.boolean().default(true),
+                    })
+                    .default({}),
+                logging: z.boolean().default(false),
+                defer: z
+                    .object({
+                        reply: z.boolean().default(false),
+                        ephemeral: z.boolean().default(false),
+                        fetchReply: z.boolean().default(false),
+                    })
+                    .default({}),
             })
-                .default({}),
-            logging: z.boolean().default(false),
-            defer: z
-                .object({
-                reply: z.boolean().default(false),
-                ephemeral: z.boolean().default(false),
-                fetchReply: z.boolean().default(false),
-            })
-                .default({}),
-        })
             .parse(options);
         this.client.modules.options.context = options;
         const files = this.readdir(options.directory);
@@ -142,18 +138,14 @@ export default class CommandHandler extends Handler {
     }
     async messageCommandRun(message, message2) {
         const filetype = 'MessageCommand';
-        if (message.author.bot)
-            return;
+        if (message.author.bot) return;
         message.util = new MessageUtil(this.client, message);
         message.user = await xernerxUser(message, this.client);
-        if (typeof message2 === 'object')
-            message = message2;
+        if (typeof message2 === 'object') message = message2;
         if (message2 === 'delete') {
-            if (!this.client.cache.messages.has(message.id))
-                return;
+            if (!this.client.cache.messages.has(message.id)) return;
             const id = this.client.cache.messages.get(message.id);
-            if (!id)
-                return;
+            if (!id) return;
             (async () => {
                 const msg = await message.channel.messages.fetch(id);
                 await msg.delete();
@@ -164,25 +156,24 @@ 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 = null, cmd, commandAlias = null, commandPrefix = null;
+            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;
+                    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;
+                    if (message.content.startsWith(p)) prefix = p;
                 });
                 cp.map((p) => {
-                    if (message.content.startsWith(p))
-                        prefix = p;
+                    if (message.content.startsWith(p)) prefix = p;
                 });
-                if (!prefix)
-                    return;
+                if (!prefix) return;
                 if (!commandName)
                     commandName =
                         message.content
@@ -203,12 +194,9 @@ export default class CommandHandler extends Handler {
                     commandName = message.content.replace(`<@${this.client.user?.id}>`, '').trim().split(/ +/).shift()?.toLowerCase() || null;
                 }
             }
-            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, filetype);
+            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, filetype);
             message.util.parsed = {
                 alias: commandAlias,
                 prefix: commandPrefix,
@@ -222,25 +210,20 @@ export default class CommandHandler extends Handler {
         interaction.util = new InteractionUtil(this.client, interaction);
         interaction.user = await xernerxUser(interaction, this.client);
         let cmd = null;
-        if (this.client.commands.slash.has(interaction.commandName))
-            cmd = this.client.commands.slash.get(interaction.commandName);
-        if (await inhibitorValidation(interaction, cmd))
-            return;
-        if (!cmd)
-            return this.client.emit('commandNotFound', interaction);
+        if (this.client.commands.slash.has(interaction.commandName)) cmd = this.client.commands.slash.get(interaction.commandName);
+        if (await inhibitorValidation(interaction, cmd)) return;
+        if (!cmd) return this.client.emit('commandNotFound', interaction);
         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);
+            } else resolve(true);
         })
             .then(async () => {
-            this.client.emit('commandStart', interaction, filetype);
-            await this.exec(cmd, interaction, await interactionArguments(interaction, cmd), filetype);
-        })
+                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) {
@@ -248,28 +231,22 @@ export default class CommandHandler extends Handler {
         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, filetype);
+        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, filetype);
         this.client.emit('commandStart', interaction, filetype);
         return 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;
+            if (await commandValidation(event, cmd)) return;
+            if (cmd.conditions && (await cmd.conditions(event, args))) return;
             cmd.exec(event, args);
             this.client.emit('commandFinish', event, type);
-        }
-        catch (error) {
+        } catch (error) {
             new XernerxLog(this.client).error(`An error occurred executing ${cmd.name}`, error);
             this.client.emit('commandError', event, error, type);
         }
     }
 }
-//# sourceMappingURL=CommandHandler.js.map
+//# sourceMappingURL=CommandHandler.js.map

package/dist/handlers/EventHandler.d.ts

@@ -5,4 +5,4 @@ export default class EventHandler extends Handler {
     constructor(client: XernerxClient);
     loadEvents(options: EventHandlerOptions): Promise<void>;
 }
-//# sourceMappingURL=EventHandler.d.ts.map
+//# sourceMappingURL=EventHandler.d.ts.map

package/dist/handlers/EventHandler.js

@@ -9,8 +9,8 @@ export default class EventHandler extends Handler {
     async loadEvents(options) {
         options = z
             .object({
-            directory: z.string(),
-        })
+                directory: z.string(),
+            })
             .parse(options);
         this.client.modules.options.events = options;
         const files = this.readdir(options.directory);
@@ -22,4 +22,4 @@ export default class EventHandler extends Handler {
         new XernerxLog(this.client).info(`Loaded ${this.client.events.size} Events.`);
     }
 }
-//# sourceMappingURL=EventHandler.js.map
+//# sourceMappingURL=EventHandler.js.map

package/dist/handlers/ExtensionHandler.d.ts

@@ -5,4 +5,4 @@ export default class ExtensionHandler extends Handler {
     constructor(client: XernerxClient);
     loadExtensions(...extensions: Array<XernerxExtensionBuilder>): void;
 }
-//# sourceMappingURL=ExtensionHandler.d.ts.map
+//# sourceMappingURL=ExtensionHandler.d.ts.map

package/dist/handlers/ExtensionHandler.js

@@ -7,18 +7,16 @@ export default class ExtensionHandler extends Handler {
     loadExtensions(...extensions) {
         const active = extensions.map((extension) => {
             try {
-                if (extension.main)
-                    extension.main(this.client);
+                if (extension.main) extension.main(this.client);
                 if (extension.defer) {
                     this.client.on('ready', (client) => extension.defer(client));
                 }
                 return extension.name;
-            }
-            catch (error) {
+            } catch (error) {
                 return new XernerxLog(this.client).error(`An error occurred while loading ${extension.name}`, error);
             }
         });
         new XernerxLog(this.client).info(`Loaded ${extensions.length} Extensions: ${active.filter((e) => e).join(', ')}`);
     }
 }
-//# sourceMappingURL=ExtensionHandler.js.map
+//# sourceMappingURL=ExtensionHandler.js.map

package/dist/handlers/Handler.d.ts

@@ -12,4 +12,4 @@ export default class Handler {
     load(filePath: string, type: FileType): Promise<any>;
     emit<T extends Record<string, string | boolean | Function | void>>(event: T): Promise<void>;
 }
-//# sourceMappingURL=Handler.d.ts.map
+//# sourceMappingURL=Handler.d.ts.map

package/dist/handlers/Handler.js

@@ -13,8 +13,7 @@ export default class Handler {
     readdir(dir) {
         try {
             return fs.readdirSync(path.resolve(dir)).filter((file) => file.endsWith('.js'));
-        }
-        catch (error) {
+        } catch (error) {
             console.error(error);
         }
         return [];
@@ -25,23 +24,14 @@ export default class Handler {
         return file;
     }
     async emit(event) {
-        if (!event?.fileType)
-            return;
+        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 (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));
+            event.once ? this.client.once(event.name, (...args) => event.run(...args)) : this.client.on(event.name, (...args) => event.run(...args));
         }
     }
 }
-//# sourceMappingURL=Handler.js.map
+//# sourceMappingURL=Handler.js.map

package/dist/handlers/InhibitorHandler.d.ts

@@ -5,4 +5,4 @@ export default class InhibitorHandler extends Handler {
     constructor(client: XernerxClient);
     loadInhibitors(options: InhibitorHandlerOptions): Promise<void>;
 }
-//# sourceMappingURL=InhibitorHandler.d.ts.map
+//# sourceMappingURL=InhibitorHandler.d.ts.map

package/dist/handlers/InhibitorHandler.js

@@ -9,8 +9,8 @@ export default class InhibitorHandler extends Handler {
     async loadInhibitors(options) {
         options = z
             .object({
-            directory: z.string(),
-        })
+                directory: z.string(),
+            })
             .parse(options);
         this.client.modules.options.inhibitors = options;
         const files = this.readdir(options.directory);
@@ -22,4 +22,4 @@ export default class InhibitorHandler extends Handler {
         new XernerxLog(this.client).info(`Loaded ${this.client.inhibitors.size} Inhibitors.`);
     }
 }
-//# sourceMappingURL=InhibitorHandler.js.map
+//# sourceMappingURL=InhibitorHandler.js.map

package/dist/handlers/WebhookHandler.d.ts

@@ -2,9 +2,7 @@ import XernerxClient from '../client/XernerxClient.js';
 import Handler from './Handler.js';
 export default class WebhookHandler extends Handler {
     constructor(client: XernerxClient);
-    loadWebhooks(options: {
-        token: string;
-    }): Promise<void>;
+    loadWebhooks(options: { token: string }): Promise<void>;
     private post;
 }
-//# sourceMappingURL=WebhookHandler.d.ts.map
+//# sourceMappingURL=WebhookHandler.d.ts.map

package/dist/handlers/WebhookHandler.js

@@ -11,9 +11,13 @@ export default class WebhookHandler extends Handler {
                 this.post(client.token);
             }, 60000 * 30);
             this.client.util.hasVoted = async (userId) => {
-                return !!(await (await fetch(`https://top.gg/api/bots/${this.client.user?.id}/check?userId=${userId}`, {
-                    headers: { Authorization: options.token, 'Content-Type': 'application/json' },
-                })).json()).voted;
+                return !!(
+                    await (
+                        await fetch(`https://top.gg/api/bots/${this.client.user?.id}/check?userId=${userId}`, {
+                            headers: { Authorization: options.token, 'Content-Type': 'application/json' },
+                        })
+                    ).json()
+                ).voted;
             };
         });
     }
@@ -38,11 +42,10 @@ export default class WebhookHandler extends Handler {
                     shard_count: this.client.stats.shardCount,
                 }),
             });
-        }
-        catch (error) {
+        } catch (error) {
             new XernerxLog(this.client).error(`An error occurred while posting stats to Top.gg`, error);
             return this.client.emit('webhookError', this.client, this.client.stats);
         }
     }
 }
-//# sourceMappingURL=WebhookHandler.js.map
+//# sourceMappingURL=WebhookHandler.js.map

package/dist/main.d.ts

@@ -15,25 +15,32 @@ export * from './types/interfaces.js';
 import Discord from 'discord.js';
 declare const version: any;
 export default XernerxClient;
-export { 
-/**
- ** Clients
- */
-XernerxClient, XernerxShardClient, 
-/**
- ** Builders
- */
-MessageCommandBuilder, SlashCommandBuilder, ContextCommandBuilder, EventBuilder, InhibitorBuilder, ExtensionBuilder, 
-/**
- ** Imported exports
- */
-Discord, 
-/**
- ** Properties
- */
-version, 
-/**
- ** Tools
- */
-XernerxLog, };
-//# sourceMappingURL=main.d.ts.map
+export {
+    /**
+     ** Clients
+     */
+    XernerxClient,
+    XernerxShardClient,
+    /**
+     ** Builders
+     */
+    MessageCommandBuilder,
+    SlashCommandBuilder,
+    ContextCommandBuilder,
+    EventBuilder,
+    InhibitorBuilder,
+    ExtensionBuilder,
+    /**
+     ** Imported exports
+     */
+    Discord,
+    /**
+     ** Properties
+     */
+    version,
+    /**
+     ** Tools
+     */
+    XernerxLog,
+};
+//# sourceMappingURL=main.d.ts.map

package/dist/main.js

@@ -16,25 +16,32 @@ export * from './types/interfaces.js';
 import Discord from 'discord.js';
 const version = JSON.parse(fs.readFileSync('node_modules/xernerx/package.json', 'utf-8')).version;
 export default XernerxClient;
-export { 
-/**
- ** Clients
- */
-XernerxClient, XernerxShardClient, 
-/**
- ** Builders
- */
-MessageCommandBuilder, SlashCommandBuilder, ContextCommandBuilder, EventBuilder, InhibitorBuilder, ExtensionBuilder, 
-/**
- ** Imported exports
- */
-Discord, 
-/**
- ** Properties
- */
-version, 
-/**
- ** Tools
- */
-XernerxLog, };
-//# sourceMappingURL=main.js.map
+export {
+    /**
+     ** Clients
+     */
+    XernerxClient,
+    XernerxShardClient,
+    /**
+     ** Builders
+     */
+    MessageCommandBuilder,
+    SlashCommandBuilder,
+    ContextCommandBuilder,
+    EventBuilder,
+    InhibitorBuilder,
+    ExtensionBuilder,
+    /**
+     ** Imported exports
+     */
+    Discord,
+    /**
+     ** Properties
+     */
+    version,
+    /**
+     ** Tools
+     */
+    XernerxLog,
+};
+//# sourceMappingURL=main.js.map

package/dist/models/Arguments.d.ts

@@ -6,4 +6,4 @@ import { MessageCommandArguments } from '../types/interfaces.js';
 import { XernerxInteraction } from '../types/types.js';
 export declare function messageArguments(message: XernerxMessage, command: MessageCommandBuilder): Promise<MessageCommandArguments>;
 export declare function interactionArguments(interaction: XernerxInteraction | any, command: ContextCommandBuilder | SlashCommandBuilder): Promise<any>;
-//# sourceMappingURL=Arguments.d.ts.map
+//# sourceMappingURL=Arguments.d.ts.map