xernerx 4.17.4 → 4.17.6

package/dist/client/XernerxClient.js

@@ -1,6 +1,7 @@
 /** @format */
 import { Client, Collection } from 'discord.js';
 import { z } from 'zod';
+import * as clack from '@clack/prompts';
 import CommandHandler from '../handlers/CommandHandler.js';
 import EventHandler from '../handlers/EventHandler.js';
 import InhibitorHandler from '../handlers/InhibitorHandler.js';
@@ -11,92 +12,95 @@ import ExtensionHandler from '../handlers/ExtensionHandler.js';
 import deploy from '../functions/deploy.js';
 import Cooldowns from '../models/Cooldowns.js';
 export default class XernerxClient extends Client {
-    constructor(discordOptions, xernerxOptions, config) {
-        super(discordOptions);
-        this.settings = z
-            .object({
-            local: z.string(),
-            global: z.boolean().default(false).optional(),
-            ownerId: z.string().or(z.array(z.string())).default([]),
-            ceaseless: z.boolean().default(false),
-            permissions: z
-                .object({
-                client: z.array(z.string()).or(z.null()).default(null),
-                user: z.array(z.string()).or(z.null()).default(null),
-                dm: z.boolean().default(false),
-            })
-                .optional(),
-            ignore: z
-                .object({
-                owner: z.boolean().default(false),
-                self: z.boolean().default(true),
-                bots: z.boolean().default(true),
-                system: z.boolean().default(true),
-                users: z.array(z.string()).default([]),
-                channels: z.array(z.string()).default([]),
-                guilds: z.array(z.string()).default([]),
-            })
-                .optional(),
-            log: z
-                .object({
-                ready: z.boolean().default(false),
-                info: z.boolean().default(false),
-                warn: z.boolean().default(false),
-                error: z.boolean().default(false),
-                table: z.array(z.string()).or(z.null()).default(null),
-                format: z.array(z.string()).or(z.null()).default(null),
-            })
-                .or(z.boolean())
-                .optional(),
-            cooldown: z
-                .object({
-                command: z.number().default(0),
-                cache: z.number().default(0),
-                collections: z.array(z.string()).default(['commands']),
-            })
-                .optional(),
-        })
-            .parse(xernerxOptions);
-        this.config = config;
-        this.commands = {
-            message: new Collection(),
-            slash: new Collection(),
-            context: new Collection(),
-        };
-        this.events = new Collection();
-        this.inhibitors = new Collection();
-        this.util = new ClientUtil(this);
-        this.stats = {
-            guildCount: this.guilds.cache.size,
-            userCount: 0,
-            shardId: 0,
-            shardCount: this.options.shardCount || 1,
-            voteCount: 0,
-        };
-        this.dbl = {};
-        this.cache = {
-            messages: new Collection(),
-            cooldowns: new Collection(),
-        };
-        this.cooldowns = new Cooldowns(this, xernerxOptions.cooldown?.collections);
-        this.modules = {
-            options: {},
-            commandHandler: new CommandHandler(this),
-            eventHandler: new EventHandler(this),
-            inhibitorHandler: new InhibitorHandler(this),
-            integrationHandler: new IntegrationHandler(this),
-            extensionHandler: new ExtensionHandler(this),
-        };
-    }
-    async connect(token) {
-        const login = this.login(token); // TODO add thing to catch and have better error message
-        deploy(this);
-        if (this.settings.ceaseless) {
-            process.on('unhandledRejection', (error) => {
-                new XernerxLog(this).error('An uncaught error happpened, this is triggered from the ceaseless setting.', error);
-            });
-        }
-        new XernerxLog(this).ready();
-        return login;
-    }
+	constructor(discordOptions, xernerxOptions, config) {
+		super(discordOptions);
+		clack.intro('Xernerx');
+		this.settings = z
+			.object({
+				local: z.string(),
+				global: z.boolean().default(false).optional(),
+				debug: z.boolean().default(false).optional(),
+				ownerId: z.string().or(z.array(z.string())).default([]),
+				ceaseless: z.boolean().default(false),
+				permissions: z
+					.object({
+						client: z.array(z.string()).or(z.null()).default(null),
+						user: z.array(z.string()).or(z.null()).default(null),
+						dm: z.boolean().default(false),
+					})
+					.optional(),
+				ignore: z
+					.object({
+						owner: z.boolean().default(false),
+						self: z.boolean().default(true),
+						bots: z.boolean().default(true),
+						system: z.boolean().default(true),
+						users: z.array(z.string()).default([]),
+						channels: z.array(z.string()).default([]),
+						guilds: z.array(z.string()).default([]),
+					})
+					.optional(),
+				log: z
+					.object({
+						ready: z.boolean().default(false),
+						info: z.boolean().default(false),
+						warn: z.boolean().default(false),
+						error: z.boolean().default(false),
+						table: z.array(z.string()).or(z.null()).default(null),
+						format: z.array(z.string()).or(z.null()).default(null),
+					})
+					.or(z.boolean())
+					.optional(),
+				cooldown: z
+					.object({
+						command: z.number().default(0),
+						cache: z.number().default(0),
+						collections: z.array(z.string()).default(['commands']),
+					})
+					.optional(),
+			})
+			.parse(xernerxOptions);
+		this.config = config;
+		this.commands = {
+			message: new Collection(),
+			slash: new Collection(),
+			context: new Collection(),
+		};
+		this.events = new Collection();
+		this.inhibitors = new Collection();
+		this.util = new ClientUtil(this);
+		this.stats = {
+			guildCount: this.guilds.cache.size,
+			userCount: 0,
+			shardId: 0,
+			shardCount: this.options.shardCount || 1,
+			voteCount: 0,
+		};
+		this.dbl = {};
+		this.cache = {
+			messages: new Collection(),
+			cooldowns: new Collection(),
+		};
+		this.cooldowns = new Cooldowns(this, xernerxOptions.cooldown?.collections);
+		this.modules = {
+			options: {},
+			commandHandler: new CommandHandler(this),
+			eventHandler: new EventHandler(this),
+			inhibitorHandler: new InhibitorHandler(this),
+			integrationHandler: new IntegrationHandler(this),
+			extensionHandler: new ExtensionHandler(this),
+		};
+	}
+	async connect(token) {
+		if (this.settings.debug) new XernerxLog(this).debug(`Connecting to discord using token ${token}...`);
+		const login = await this.login(token).catch(() => {
+			new XernerxLog(this).error('An invalid token was provided. Please make sure to provide a valid Discord bot token.');
+		});
+		if (this.settings.debug) new XernerxLog(this).debug(`Connected to discord using token ${token}`);
+		deploy(this);
+		new XernerxLog(this).ready();
+		const spinner = clack.spinner();
+		spinner.start();
+		return login;
+	}
 }

package/dist/client/XernerxShardClient.d.ts

@@ -1,21 +1,21 @@
 /** @format */
 import { ShardingManager, ShardingManagerOptions, ClientUser } from 'discord.js';
 interface XernerxOptions {
-    log?: {
-        info?: boolean;
-    };
-    timeout?: number;
+	log?: {
+		info?: boolean;
+	};
+	timeout?: number;
 }
 export default class XernerxShardClient extends ShardingManager {
-    readonly stats: {
-        guildCount: number;
-        userCount: number;
-        shardCount: number;
-        voteCount: number;
-        shards: {};
-    };
-    user: ClientUser | null;
-    spawner: Promise<import("@discordjs/collection").Collection<number, import("discord.js").Shard>>;
-    constructor(file: string, discordOptions: ShardingManagerOptions, xernerxOptions?: XernerxOptions, data?: unknown);
+	readonly stats: {
+		guildCount: number;
+		userCount: number;
+		shardCount: number;
+		voteCount: number;
+		shards: {};
+	};
+	user: ClientUser | null;
+	spawner: Promise<import('discord.js').Collection<number, import('discord.js').Shard>>;
+	constructor(file: string, discordOptions: ShardingManagerOptions, xernerxOptions?: XernerxOptions, data?: unknown);
 }
 export {};

package/dist/client/XernerxShardClient.js

@@ -3,51 +3,65 @@ import { ShardingManager } from 'discord.js';
 import { Style } from 'dumfunctions';
 import XernerxLog from '../tools/XernerxLog.js';
 export default class XernerxShardClient extends ShardingManager {
-    constructor(file, discordOptions, xernerxOptions, data = {}) {
-        super(file, discordOptions);
-        this.stats = { guildCount: 0, userCount: 0, shardCount: 0, voteCount: 0, shards: {} };
-        this.user = null;
-        this.on('shardCreate', async (shard) => {
-            shard
-                .on('ready', async () => {
-                await new Promise((resolve) => setTimeout(resolve, 250));
-                const stats = (await shard.fetchClientValue('stats'));
-                this.stats.shards[String(shard.id)] = stats;
-                this.user = (await shard.fetchClientValue('user'));
-                this.stats.guildCount += stats.guildCount;
-                this.stats.userCount += stats.userCount;
-                this.stats.shardCount++;
-                this.stats.voteCount = stats.voteCount;
-                shard.send({ type: 'xernerx', data: { shardId: shard.id, sharded: true } });
-                shard.send({ type: 'client', data });
-                await new XernerxLog({ settings: xernerxOptions }).info(`Launched shard ${Style.log(String(shard.id), { color: Style.TextColor.Cyan })} for ${Style.log(this.user?.tag, { color: Style.TextColor.Blue })}! ${xernerxOptions?.timeout ? `Automatically killing in ${Style.log(String(xernerxOptions.timeout), { color: Style.TextColor.Cyan })}ms.` : ''}`);
-            })
-                .on('error', (error) => {
-                new XernerxLog({ settings: xernerxOptions }).info(`An error occurred in ${Style.log(String(shard.id), { color: Style.TextColor.Cyan })} for ${Style.log(String(this.user?.tag), { color: Style.TextColor.Blue })}! ${error}`);
-            });
-            if (xernerxOptions?.timeout)
-                setTimeout(() => {
-                    new XernerxLog({ settings: xernerxOptions }).warn(`Automatically killing shard ${Style.log(String(shard.id), { color: Style.TextColor.Cyan })} on ${Style.log(String(shard.manager.user?.tag), {
-                        color: Style.TextColor.Blue,
-                    })}!`);
-                    shard.kill();
-                }, xernerxOptions.timeout);
-        });
-        const spawn = this.spawn();
-        this.spawner = spawn;
-        spawn.then(async (shards) => {
-            const collector = setInterval(() => {
-                const index = shards.size - 1;
-                if (shards.get(index)?.ready) {
-                    clearInterval(collector);
-                    new XernerxLog({ settings: xernerxOptions }).info(`All Shards launched for ${Style.log(String(this.user?.tag), {
-                        color: Style.TextColor.Blue,
-                    })} with a total of ${Style.log(String(this.stats.shardCount), { color: Style.TextColor.Cyan })} shard${this.stats.shardCount > 1 ? 's' : ''}, watching ${Style.log(String(this.stats.guildCount), {
-                        color: Style.TextColor.Cyan,
-                    })} guild${this.stats.guildCount > 1 ? 's' : ''}, and ${Style.log(String(this.stats.userCount), { color: Style.TextColor.Cyan })} user${this.stats.userCount > 1 ? 's' : ''}!`);
-                }
-            }, 1000);
-        });
-        return this;
-    }
+	constructor(file, discordOptions, xernerxOptions, data = {}) {
+		super(file, discordOptions);
+		this.stats = { guildCount: 0, userCount: 0, shardCount: 0, voteCount: 0, shards: {} };
+		this.user = null;
+		new XernerxLog(true).info('Starting sharding process...');
+		this.on('shardCreate', async (shard) => {
+			shard
+				.on('ready', async () => {
+					await new Promise((resolve) => setTimeout(resolve, 250));
+					const stats = await shard.fetchClientValue('stats');
+					this.stats.shards[String(shard.id)] = stats;
+					this.user = await shard.fetchClientValue('user');
+					this.stats.guildCount += stats.guildCount;
+					this.stats.userCount += stats.userCount;
+					this.stats.shardCount++;
+					this.stats.voteCount = stats.voteCount;
+					shard.send({ type: 'xernerx', data: { shardId: shard.id, sharded: true } });
+					shard.send({ type: 'client', data });
+					new XernerxLog({ settings: xernerxOptions }).info(
+						`Launched shard ${Style.log(String(shard.id), { color: Style.TextColor.Cyan })} for ${Style.log(this.user?.tag, { color: Style.TextColor.Blue })}! ${
+							xernerxOptions?.timeout ? `Automatically killing in ${Style.log(String(xernerxOptions.timeout), { color: Style.TextColor.Cyan })}ms.` : ''
+						}`
+					);
+				})
+				.on('error', (error) => {
+					new XernerxLog({ settings: xernerxOptions }).info(
+						`An error occurred in ${Style.log(String(shard.id), { color: Style.TextColor.Cyan })} for ${Style.log(String(this.user?.tag), { color: Style.TextColor.Blue })}! ${error}`
+					);
+				});
+			if (xernerxOptions?.timeout)
+				setTimeout(() => {
+					new XernerxLog({ settings: xernerxOptions }).warn(
+						`Automatically killing shard ${Style.log(String(shard.id), { color: Style.TextColor.Cyan })} on ${Style.log(String(shard.manager.user?.tag), {
+							color: Style.TextColor.Blue,
+						})}!`
+					);
+					shard.kill();
+				}, xernerxOptions.timeout);
+		});
+		const spawn = this.spawn();
+		this.spawner = spawn;
+		spawn.then(async (shards) => {
+			const collector = setInterval(() => {
+				const index = shards.size - 1;
+				if (shards.get(index)?.ready) {
+					clearInterval(collector);
+					new XernerxLog({ settings: xernerxOptions }).info(
+						`All Shards launched for ${Style.log(String(this.user?.tag), {
+							color: Style.TextColor.Blue,
+						})} with a total of ${Style.log(String(this.stats.shardCount), { color: Style.TextColor.Cyan })} shard${this.stats.shardCount > 1 ? 's' : ''}, watching ${Style.log(
+							String(this.stats.guildCount),
+							{
+								color: Style.TextColor.Cyan,
+							}
+						)} guild${this.stats.guildCount > 1 ? 's' : ''}, and ${Style.log(String(this.stats.userCount), { color: Style.TextColor.Cyan })} user${this.stats.userCount > 1 ? 's' : ''}!`
+					);
+				}
+			}, 1000);
+		});
+		return this;
+	}
 }

package/dist/functions/deploy.js

@@ -6,58 +6,51 @@ import XernerxError from '../tools/XernerxError.js';
 const globalCommands = [];
 const localCommands = [];
 export default 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.message.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 && !localCommands.length && !client.commands.message.size)
-            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(client).error(`An error occurred while deploying the commands!`, error);
-        }
-        finally {
-            new XernerxLog(client).info(`Deployed ${Style.log(String(commands.filter((command) => command.global).length), {
-                color: Style.TextColor.Cyan,
-            })} Commands ${client.settings.global
-                ? Style.log('globally', { color: Style.TextColor.Green })
-                : `${Style.log('locally', { color: Style.TextColor.Red })} in ${Style.log(client.guilds.cache.get(client.settings.local)?.name, { color: Style.TextColor.Blue })}`}.`);
-        }
-    });
+	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.once('ready', (client) => {
+		stats();
+		client.commands.slash.map((command) => commands.push(command));
+		client.commands.context.map((command) => commands.push(command));
+		client.commands.message.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 && !localCommands.length && !client.commands.message.size) 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(client).error(`An error occurred while deploying the commands!`, error);
+		} finally {
+			new XernerxLog(client).info(
+				`Deployed ${Style.log(String(commands.filter((command) => command.global).length), {
+					color: Style.TextColor.Cyan,
+				})} Commands ${
+					client.settings.global
+						? Style.log('globally', { color: Style.TextColor.Green })
+						: `${Style.log('locally', { color: Style.TextColor.Red })} in ${Style.log(client.guilds.cache.get(client.settings.local)?.name, { color: Style.TextColor.Blue })}`
+				}.`
+			);
+		}
+	});
 }
 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)
-        return rest.put(Routes.applicationGuildCommands(client.user?.id, client.settings.local), { body });
-    else
-        return rest.put(Routes.applicationCommands(client.user?.id), { 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) return rest.put(Routes.applicationGuildCommands(client.user?.id, client.settings.local), { body });
+	else return rest.put(Routes.applicationCommands(client.user?.id), { body });
 }

package/dist/functions/load.js

@@ -1,35 +1,34 @@
 /** @format */
 import XernerxLog from '../tools/XernerxLog.js';
 export default 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(client).error(`Couldn't load ${type} ${path.match(/\w*\.js$/gim)?.at(0) || path}`, error);
-    }
+	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(client).error(`Couldn't load ${type} ${path.match(/\w*\.js$/gim)?.at(0) || path}`, error);
+	}
 }
 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;
-    }
+	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/functions/reload.js

@@ -3,28 +3,27 @@ import * as path from 'path';
 import * as fs from 'fs';
 import load from './load.js';
 export default 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)) {
-                load(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();
-        }
-    }
+	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)) {
+				load(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();
+		}
+	}
 }

package/dist/functions/setPresence.d.ts

@@ -1,4 +1,4 @@
 /** @format */
 import XernerxClient from '../client/XernerxClient.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

@@ -2,20 +2,21 @@
 import { ActivityType } from 'discord.js';
 import { Style } from 'dumfunctions';
 export default function setPresence(client, options) {
-    const presence = () => client.user?.setPresence({
-        activities: [
-            {
-                name: options.text,
-                type: ActivityType[Style.titleCase(options.type || 'Custom')],
-                url: options.url,
-            },
-        ],
-        status: options.status,
-    });
-    let response = presence();
-    if (options.interval)
-        setInterval(() => {
-            response = presence();
-        }, options.interval);
-    return response;
+	const presence = () =>
+		client.user?.setPresence({
+			activities: [
+				{
+					name: options.text,
+					type: ActivityType[Style.titleCase(options.type || 'Custom')],
+					url: options.url,
+				},
+			],
+			status: options.status,
+		});
+	let response = presence();
+	if (options.interval)
+		setInterval(() => {
+			response = presence();
+		}, options.interval);
+	return response;
 }

package/dist/functions/xernerxUser.js

@@ -1,11 +1,10 @@
 /** @format */
 export 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;
+	const author = event.author || event.user;
+	author.owner = isOwner(client, author);
+	if (client.dbl.validate) author.voted = await client?.dbl?.validate(author);
+	return author;
 }
 function isOwner(client, user) {
-    return client.settings.ownerId.includes(user.id);
+	return client.settings.ownerId.includes(user.id);
 }