xernerx 4.4.4 → 4.4.6

package/dist/client/XernerxClient.js

@@ -12,39 +12,39 @@ export default class XernerxClient extends Client {
         super(discordOptions);
         this.settings = z
             .object({
-                local: z.string().optional(),
-                global: z.boolean().default(false),
-                ownerId: z.string().or(z.array(z.string())).default([]),
-                permissions: z
-                    .object({
-                        client: z.array(z.string()).default([]),
-                        user: z.array(z.string()).default([]),
-                        dm: z.boolean().default(false),
-                    })
-                    .optional(),
-                ignore: z
-                    .object({
-                        owner: z.boolean().default(false),
-                        users: z.array(z.string()),
-                        channels: z.array(z.string()),
-                        guilds: z.array(z.string()),
-                    })
-                    .optional(),
-                log: z
-                    .object({
-                        ready: z.boolean().default(false),
-                        info: z.boolean().default(false),
-                        error: z.boolean().default(false),
-                        table: z.array(z.string()).or(z.null()).default(null),
-                    })
-                    .optional(),
-                cooldown: z
-                    .object({
-                        command: z.number().default(0),
-                        cache: z.number().default(0),
-                    })
-                    .optional(),
+            local: z.string().optional(),
+            global: z.boolean().default(false),
+            ownerId: z.string().or(z.array(z.string())).default([]),
+            permissions: z
+                .object({
+                client: z.array(z.string()).default([]),
+                user: z.array(z.string()).default([]),
+                dm: z.boolean().default(false),
             })
+                .optional(),
+            ignore: z
+                .object({
+                owner: z.boolean().default(false),
+                users: z.array(z.string()),
+                channels: z.array(z.string()),
+                guilds: z.array(z.string()),
+            })
+                .optional(),
+            log: z
+                .object({
+                ready: z.boolean().default(false),
+                info: z.boolean().default(false),
+                error: z.boolean().default(false),
+                table: z.array(z.string()).or(z.null()).default(null),
+            })
+                .optional(),
+            cooldown: z
+                .object({
+                command: z.number().default(0),
+                cache: z.number().default(0),
+            })
+                .optional(),
+        })
             .parse(xernerxOptions);
         this.config = config || null;
         this.commands = {

package/dist/client/XernerxShardClient.js

@@ -7,13 +7,13 @@ export default class XernerxShardClient extends ShardingManager {
         this.user = null;
         this.on('shardCreate', async (shard) => {
             shard.on('ready', async () => {
-                const guilds = await shard.fetchClientValue('guilds.cache');
+                const guilds = (await shard.fetchClientValue('guilds.cache'));
                 const guildCount = guilds.length;
                 const userCount = guilds.map((guild) => guild.memberCount).length ? guilds.map((guild) => guild.memberCount).reduce((a, b) => (a += b)) : 0;
                 this.stats.guildCount += Number(guildCount);
                 this.stats.userCount += Number(userCount);
                 this.stats.shardCount++;
-                this.user = await shard.fetchClientValue('user');
+                this.user = (await shard.fetchClientValue('user'));
             });
             new XernerxLog({ settings: xernerxOptions }).info(`Launching shard ${shard.id} for ${this.user?.tag}!`);
         });
@@ -21,9 +21,7 @@ export default class XernerxShardClient extends ShardingManager {
             const collector = setInterval(() => {
                 const index = shards.size - 1;
                 if (shards.get(index)?.ready) {
-                    new XernerxLog({ settings: xernerxOptions }).info(
-                        `Launched all ${this.stats.shardCount} shards for ${this.user?.tag}, watching ${this.stats.guildCount} guilds, and ${this.stats.userCount} users!`
-                    );
+                    new XernerxLog({ settings: xernerxOptions }).info(`Launched all ${this.stats.shardCount} shards for ${this.user?.tag}, watching ${this.stats.guildCount} guilds, and ${this.stats.userCount} users!`);
                     clearInterval(collector);
                 }
             }, 1000);

package/dist/functions/deploy.js

@@ -5,29 +5,32 @@ const commands = { slash: [], context: [] };
 export default function deploy(client, type) {
     client.prependOnceListener('ready', (client) => {
         commands[type] = client.commands[type].map((command) => command.data.toJSON());
-        if (!(!!client.modules.options.slash && !!client.modules.options.context && commands.slash.length > 0 && commands.context.length > 0)) return;
+        if (!(!!client.modules.options.slash && !!client.modules.options.context && commands.slash.length > 0 && commands.context.length > 0))
+            return;
         try {
             if (client.settings.global) {
                 put(client, client.settings.global, [...commands.slash, ...commands.context]);
                 put(client, !client.settings.global, []);
-            } else {
+            }
+            else {
                 put(client, !client.settings.global, [...commands.slash, ...commands.context]);
                 put(client, client.settings.global, []);
             }
-        } catch (error) {
+        }
+        catch (error) {
             new XernerxLog(client).error(`An error occurred while deploying the interaction commands!`, error);
-        } finally {
-            new XernerxLog(client).info(
-                `Deployed ${[client.commands.message.size, client.commands.slash.size, client.commands.context.size].reduce((a, b) => (a += b))} Commands ${
-                    client.settings.global ? 'globally' : 'locally'
-                }.`
-            );
+        }
+        finally {
+            new XernerxLog(client).info(`Deployed ${[client.commands.message.size, client.commands.slash.size, client.commands.context.size].reduce((a, b) => (a += b))} Commands ${client.settings.global ? 'globally' : 'locally'}.`);
         }
     });
 }
 function put(client, global, body) {
     const rest = new REST({ version: GatewayVersion }).setToken(client.token);
-    if (!global && !client.settings?.local) throw new XernerxError(`No guild ID provided as local guild!`);
-    if (!global && client.settings?.local) rest.put(Routes.applicationGuildCommands(client.user?.id, client.settings.local), { body });
-    else rest.put(Routes.applicationCommands(client.user?.id), { body });
+    if (!global && !client.settings?.local)
+        throw new XernerxError(`No guild ID provided as local guild!`);
+    if (!global && client.settings?.local)
+        rest.put(Routes.applicationGuildCommands(client.user?.id, client.settings.local), { body });
+    else
+        rest.put(Routes.applicationCommands(client.user?.id), { body });
 }

package/dist/functions/load.js

@@ -7,7 +7,8 @@ export default async function load(client, path, type) {
         file.client = client;
         fileSave(client, file, type);
         return file;
-    } catch (error) {
+    }
+    catch (error) {
         new XernerxLog(client).error(`Couldn't load ${type} ${path.match(/\w*\.js$/gim)?.at(0) || path}`, error);
     }
 }

package/dist/functions/reload.js

@@ -1,10 +1,10 @@
 var FileTypes;
 (function (FileTypes) {
-    FileTypes['message'] = 'MessageCommand';
-    FileTypes['slash'] = 'SlashCommand';
-    FileTypes['context'] = 'ContextCommand';
-    FileTypes['event'] = 'Event';
-    FileTypes['inhibitor'] = 'Inhibitor';
+    FileTypes["message"] = "MessageCommand";
+    FileTypes["slash"] = "SlashCommand";
+    FileTypes["context"] = "ContextCommand";
+    FileTypes["event"] = "Event";
+    FileTypes["inhibitor"] = "Inhibitor";
 })(FileTypes || (FileTypes = {}));
 export default function reload(client, type) {
     const files = [];
@@ -31,9 +31,12 @@ export default function reload(client, type) {
         filedata.fileType = FileTypes[type];
         filedata.filePath = file;
         filedata.client = client;
-        if (type === 'message' || type === 'slash' || type === 'context') client.commands[type].set(filedata.name, filedata);
-        if (type === 'event') client.events.set(filedata.name, filedata);
-        if (type === 'inhibitor') client.inhibitors.set(filedata.name, filedata);
+        if (type === 'message' || type === 'slash' || type === 'context')
+            client.commands[type].set(filedata.name, filedata);
+        if (type === 'event')
+            client.events.set(filedata.name, filedata);
+        if (type === 'inhibitor')
+            client.inhibitors.set(filedata.name, filedata);
         return filedata;
     });
 }

package/dist/functions/sendWebhook.js

@@ -6,7 +6,8 @@ export default async function sendWebhook(url, body) {
         },
         body: JSON.stringify(body),
     });
-    if (response.status === 204) return true;
+    if (response.status === 204)
+        return true;
     const data = await response.json();
     return data;
 }

package/dist/functions/setPresence.d.ts

@@ -1,3 +1,3 @@
 import XernerxClient from '../main.js';
 import { PresenceOptions } from '../types/interfaces.js';
-export default function setPresence(client: XernerxClient, options: PresenceOptions): import('discord.js').ClientPresence | undefined;
+export default function setPresence(client: XernerxClient, options: PresenceOptions): import("discord.js").ClientPresence | undefined;

package/dist/functions/setPresence.js

@@ -1,15 +1,14 @@
 export default function setPresence(client, options) {
-    const presence = () =>
-        client.user?.setPresence({
-            activities: [
-                {
-                    name: options.text,
-                    type: options.type,
-                    url: options.url,
-                },
-            ],
-            status: options.status,
-        });
+    const presence = () => client.user?.setPresence({
+        activities: [
+            {
+                name: options.text,
+                type: options.type,
+                url: options.url,
+            },
+        ],
+        status: options.status,
+    });
     let response = presence();
     if (options.interval)
         setInterval(() => {

package/dist/handlers/CommandHandler.js

@@ -15,26 +15,28 @@ 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),
-                    })
-                    .default({}),
-                handleEdits: z.boolean().default(false),
-                handleDeletes: z.boolean().default(false),
-                handleTyping: z.boolean().default(false),
-                logging: z.boolean().default(false),
+            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),
+        })
             .parse(options);
         this.client.modules.options.message = options;
         const files = this.readdir(options.directory);
@@ -63,27 +65,28 @@ 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),
-                    })
-                    .default({}),
+            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({}),
+        })
             .parse(options);
         this.client.modules.options.slash = options;
         const files = this.readdir(options.directory);
@@ -100,27 +103,28 @@ 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),
-                    })
-                    .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({}),
+            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({}),
+        })
             .parse(options);
         this.client.modules.options.context = options;
         const files = this.readdir(options.directory);
@@ -138,14 +142,18 @@ 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();
@@ -156,24 +164,25 @@ 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
@@ -194,9 +203,12 @@ 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,
@@ -210,20 +222,25 @@ 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) {
@@ -231,19 +248,25 @@ 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);
         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);
         }

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);

package/dist/handlers/ExtensionHandler.js

@@ -7,12 +7,14 @@ 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) {
                 new XernerxLog(this.client).error(`An error occurred while loading ${extension.name}`, error);
             }
         });

package/dist/handlers/Handler.js

@@ -13,7 +13,8 @@ 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 [];
@@ -24,13 +25,22 @@ 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));
         }
     }
 }

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);

package/dist/handlers/WebhookHandler.d.ts

@@ -2,6 +2,8 @@ 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;
 }

package/dist/handlers/WebhookHandler.js

@@ -11,13 +11,9 @@ 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;
             };
         });
     }
@@ -42,7 +38,8 @@ 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);
         }