xernerx 0.1.120-beta.1

package/src/client/XernerxClient.ts

@@ -0,0 +1,151 @@
+/** @format */
+
+import * as Discord from 'discord.js';
+import { z } from 'zod';
+
+import { start } from '../util/prompts.js';
+import { XernerxStats } from '../types/interfaces.js';
+import { CommandHandler } from '../handlers/CommandHandler.js';
+import { XernerxMessageCommand } from '../base/XernerxMessageCommand.js';
+import { XernerxSlashCommand } from '../main.js';
+import { XernerxContextCommand } from '../base/XernerxContextCommand.js';
+import { XernerxEvent } from '../base/XernerxEvent.js';
+import { XernerxInhibitor } from '../base/XernerxInhibitor.js';
+import XernerxLog from '../tools/XernerxLog.js';
+import sharpyy from 'sharpyy';
+import { ClientUtil } from '../util/ClientUtil.js';
+
+export class XernerxClient<T = {}> extends Discord.Client {
+	public declare readonly settings;
+	public declare readonly stats: XernerxStats;
+	public declare readonly modules: {
+		commandHandler: CommandHandler;
+		options: {
+			message?: { global?: boolean };
+			slash?: { global?: boolean };
+			context?: { global?: boolean };
+		};
+	};
+	public declare readonly util: ClientUtil;
+	public declare readonly commands;
+	public declare readonly events;
+	public declare readonly inhibitors;
+
+	constructor(DiscordOptions: any, XernerxOptions: any, config: T) {
+		super(DiscordOptions);
+
+		this.settings = z
+			.object({
+				// required settings
+				token: z.string(),
+
+				// optional settings
+				global: z.boolean().default(false),
+				owners: z.array(z.string()).default([]),
+				guilds: z.array(z.string()).default([]),
+
+				// dev settings
+				debug: z.boolean().default(false),
+			})
+			.parse({ ...XernerxOptions, ...config });
+
+		this.stats = {
+			guilds: null,
+			users: null,
+			shardId: null,
+			shardCount: null,
+			shards: null,
+			voteCount: null,
+			votes: null,
+		};
+
+		this.util = new ClientUtil(this);
+
+		start(this);
+
+		this.modules = {
+			commandHandler: new CommandHandler(this),
+
+			options: {},
+		};
+
+		this.commands = {
+			message: new Discord.Collection() as Discord.Collection<string, XernerxMessageCommand>,
+			slash: new Discord.Collection() as Discord.Collection<string, XernerxSlashCommand>,
+			context: new Discord.Collection() as Discord.Collection<string, XernerxContextCommand>,
+			stats: {
+				slash: {
+					local: 0,
+					global: 0,
+				},
+				message: {
+					local: 0,
+					global: 0,
+				},
+				context: {
+					local: 0,
+					global: 0,
+				},
+			},
+		};
+
+		this.events = new Discord.Collection() as Discord.Collection<string, XernerxEvent>;
+		this.inhibitors = new Discord.Collection() as Discord.Collection<string, XernerxInhibitor>;
+
+		this.connect();
+	}
+
+	private async connect() {
+		// slash cmds
+		this.deploy();
+
+		// login
+		this.login(this.settings.token);
+	}
+
+	private async deploy() {
+		this.once('ready', async (client) => {
+			const commands: { local: Array<XernerxSlashCommand | XernerxContextCommand>; global: Array<XernerxSlashCommand | XernerxContextCommand> } = { local: [], global: [] };
+
+			if (this.settings.global) {
+				if (!this.modules.options.slash?.global) commands.global.push(...(this.commands.slash as any));
+				else {
+					commands.global.push(...(this.commands.slash.filter((c) => c.global) as any));
+
+					commands.local.push(...(this.commands.slash.filter((c) => !c.global) as any));
+				}
+
+				if (!this.modules.options.context?.global) commands.global.push(...(this.commands.context as any));
+				else {
+					commands.global.push(...(this.commands.context.filter((c) => c.global) as any));
+
+					commands.local.push(...(this.commands.context.filter((c) => !c.global) as any));
+				}
+			} else commands.local.push(...(this.commands.context as any), ...(this.commands.slash as any));
+
+			for (const id of this.settings.guilds) {
+				const guild = await this.guilds.fetch(id);
+
+				if (!commands.local.length) break;
+
+				if (this.settings.debug) XernerxLog.debug(`Attempting to deploy commands to guild: ${sharpyy(guild.name, 'txBlue')}`);
+
+				this.rest.put(Discord.Routes.applicationGuildCommands(client.user.id, id), { body: (commands.local as any).map(([id, command]: any) => command.toJSON()) });
+
+				await XernerxLog.box(
+					(commands.local as any).map(([id]: [string]) => sharpyy(id, 'txYellow')).join(', '),
+					'red',
+					`Deployed ${sharpyy('local', 'txRed', 'bold')} commands in ${sharpyy(guild.name, 'txBlue')}`
+				);
+			}
+
+			if (this.settings.global) {
+				if (this.settings.debug) XernerxLog.debug(`Attempting to deploy commands globally`);
+
+				this.rest.put(Discord.Routes.applicationCommands(client.user.id), { body: [] });
+
+				await XernerxLog.box((commands.global as any).map(([id]: [string]) => sharpyy(id, 'txYellow')).join(', '), 'green', `Deployed ${sharpyy('global', 'txGreen', 'bold')} commands`);
+			}
+		});
+	}
+}

package/src/handlers/CommandHandler.ts

@@ -0,0 +1,31 @@
+/** @format */
+
+import { XernerxClient } from '../client/XernerxClient.js';
+import { XernerxContextCommandHandlerOptions, XernerxMessageCommandHandlerOptions, XernerxSlashCommandHandlerOptions } from '../types/interfaces.js';
+import { Handler } from './Handler.js';
+import path from 'path';
+
+export class CommandHandler extends Handler {
+	constructor(client: XernerxClient) {
+		super(client);
+	}
+
+	protected async loadSlashCommands(options: XernerxSlashCommandHandlerOptions) {
+		if (!this.client.modules.options.slash) this.client.modules.options.slash = {};
+		this.client.modules.options.slash.global = options.global ?? this.client.settings.global;
+
+		for (const file of await this.readdir(options.directory)) {
+			const command = await this.load(path.resolve(`${options.directory}/${file}`));
+
+			if (!command) continue;
+
+			if (command.filetype == 'XernerxMessageCommand' || command.filetype == 'XernerxSlashCommand' || command.filetype == 'XernerxContextCommand') {
+				if (!this.client.modules.options.slash.global) this.client.commands.stats.slash.local++;
+				else if (!command.global) this.client.commands.stats.slash.local++;
+				else this.client.commands.stats.slash.global++;
+			}
+		}
+	}
+	protected async loadMessageCommands(options: XernerxMessageCommandHandlerOptions) {}
+	protected async loadContextCommands(options: XernerxContextCommandHandlerOptions) {}
+}

package/src/handlers/Handler.ts

@@ -0,0 +1,57 @@
+/** @format */
+// import * as inquirer from '@inquirer/prompts';
+// import { link } from 'sharpyy';
+
+import { XernerxClient } from '../client/XernerxClient.js';
+import * as fs from 'fs';
+import * as path from 'path';
+
+import { XernerxFile } from '../types/types.js';
+import XernerxLog from '../tools/XernerxLog.js';
+import { link } from 'sharpyy';
+
+export class Handler {
+	public declare readonly client: XernerxClient;
+
+	constructor(client: XernerxClient) {
+		this.client = client;
+	}
+
+	protected async readdir(directory: string) {
+		const dirpath = path.resolve(directory);
+
+		if (this.client.settings.debug) XernerxLog.debug(`Attempting to read directory ${link(directory, new URL(dirpath))}`);
+
+		try {
+			const files = fs.readdirSync(dirpath);
+
+			return files.filter((file) => file.endsWith('.js') || file.endsWith('.mjs') || file.endsWith('.cjs'));
+		} catch (error) {
+			XernerxLog.error(`Error reading directory ${link(directory, new URL(dirpath))}:`, error as Error);
+			return [];
+		}
+	}
+
+	protected async load(filepath: string) {
+		if (this.client.settings.debug) XernerxLog.debug(`Attempting to load ${link(filepath, new URL(filepath))}`);
+
+		try {
+			const file = ((await import(`file://${filepath}`))?.default || (await import(`file://${filepath}`))) as XernerxFile;
+
+			const openFile = new (file as any)() as XernerxFile;
+
+			const [collection, group] = openFile.collection.split('.');
+
+			group
+				? this.client[group as 'commands'][collection as 'message' | 'slash' | 'context'].set(openFile._id, openFile as never)
+				: this.client[collection as 'events' | 'inhibitors'].set(openFile._id, openFile as never);
+
+			if (this.client.settings.debug) XernerxLog.debug(`Loaded ${link(openFile._id, new URL(filepath))}`);
+
+			return openFile as XernerxFile;
+		} catch (error) {
+			XernerxLog.error(`Error loading ${link(filepath, new URL(filepath))}:`, error as Error);
+			return null;
+		}
+	}
+}

package/src/main.ts

@@ -0,0 +1,5 @@
+/** @format */
+
+export * from './client/XernerxClient.js';
+export * from './base/XernerxSlashCommand.js';
+export * from './tools/XernerxLog.js';

package/src/tools/XernerxLog.ts

@@ -0,0 +1,58 @@
+/** @format */
+
+import sharpyy, { link } from 'sharpyy';
+
+export default new (class XernerxLog {
+	public declare readonly baseText;
+
+	constructor() {
+		this.baseText = `${sharpyy('XERNERX', 'txRainbow', 'bold')} | ${new Date()
+			.toLocaleTimeString()
+			.split(/ /gim)
+			.map((str) =>
+				str
+					.split(':')
+					.map((str) => (isNaN(Number(str)) ? str : sharpyy(str, 'txCyan')))
+					.join(':')
+			)
+			.join(' ')} | ${sharpyy(String(Math.round(process.memoryUsage().rss / 10000) / 100), 'txCyan')}mb |`;
+	}
+
+	info(message: string) {
+		return console.info(`✔️  |`, this.baseText, message);
+	}
+
+	async error(message: string, error?: Error) {
+		const { default: boxen } = await import('boxen');
+
+		const errorMessage = boxen(error?.stack as string, { padding: 1, margin: 1, borderStyle: 'round', borderColor: 'red' });
+
+		if (error) return console.error(`❗ |`, this.baseText, message, errorMessage);
+		else return console.error(`❗ |`, this.baseText, message);
+	}
+
+	warn(message: string, url?: URL) {
+		console.warn(`⚠️  |`, this.baseText, message, url ? `Read more here ${link('here', url)}` : '');
+	}
+
+	debug(message: string) {
+		return console.debug(`🐛 |`, this.baseText, message);
+	}
+
+	async box(message: string, color?: string, title?: string) {
+		const { default: boxen } = await import('boxen');
+
+		const time = new Date()
+			.toLocaleTimeString()
+			.split(/ /gim)
+			.map((str) =>
+				str
+					.split(':')
+					.map((str) => (isNaN(Number(str)) ? str : sharpyy(str, 'txCyan')))
+					.join(':')
+			)
+			.join(' ');
+
+		return console.info(boxen(message, { padding: 1, margin: 1, borderStyle: 'round', borderColor: color, title: `${time} - ${sharpyy('XERNERX', 'txRainbow', 'bold')} - ${title || ''}` }));
+	}
+})();

package/src/types/interfaces.ts

@@ -0,0 +1,25 @@
+/** @format */
+
+export interface XernerxStats {
+	guilds: null | number;
+	users: null | number;
+	shardId: null | number;
+	shardCount: null | number;
+	shards: null | number;
+	voteCount: null | number;
+	votes: null | number;
+}
+
+export interface XernerxSlashCommandHandlerOptions {
+	directory: string;
+	global: boolean;
+}
+
+export interface XernerxMessageCommandHandlerOptions {
+	directory: string;
+	global: boolean;
+}
+export interface XernerxContextCommandHandlerOptions {
+	directory: string;
+	global: boolean;
+}

package/src/types/types.ts

@@ -0,0 +1,29 @@
+/** @format */
+
+import { XernerxContextCommand } from '../base/XernerxContextCommand.js';
+import { XernerxEvent } from '../base/XernerxEvent.js';
+import { XernerxInhibitor } from '../base/XernerxInhibitor.js';
+import { XernerxMessageCommand } from '../base/XernerxMessageCommand.js';
+import { XernerxSlashCommand } from '../base/XernerxSlashCommand.js';
+
+export type XernerxFileType = 'XernerxSlashCommand' | 'XernerxMessageCommand' | 'XernerxContextCommand' | 'XernerxEvent' | 'XernerxInhibitor';
+
+export type XernerxFile<T = XernerxFileType> = T extends 'XernerxSlashCommand'
+	? XernerxSlashCommand
+	: T extends 'XernerxMessageCommand'
+		? XernerxMessageCommand
+		: T extends 'XernerxContextCommand'
+			? XernerxContextCommand
+			: T extends 'XernerxEvent'
+				? XernerxEvent
+				: T extends 'XernerxInhibitor'
+					? XernerxInhibitor
+					: XernerxSlashCommand | XernerxMessageCommand | XernerxSlashCommand | XernerxEvent | XernerxInhibitor;
+
+export type XernerxCommand<T = XernerxFileType> = T extends 'XernerxSlashCommand'
+	? XernerxSlashCommand
+	: T extends 'XernerxMessageCommand'
+		? XernerxMessageCommand
+		: T extends 'XernerxContextCommand'
+			? XernerxContextCommand
+			: XernerxSlashCommand | XernerxMessageCommand | XernerxContextCommand;

package/src/util/ClientUtil.ts

@@ -0,0 +1,29 @@
+/** @format */
+
+import { XernerxClient } from '../main.js';
+import { Util } from './Util.js';
+
+export class ClientUtil extends Util {
+	constructor(client: XernerxClient) {
+		super(client);
+	}
+
+	public uptime(timestamp?: number | null) {
+		if (!timestamp) timestamp = this.client.uptime || 0;
+		let totalSeconds = timestamp / 1000;
+		let years = Math.floor(totalSeconds / 31536000);
+		totalSeconds %= 31536000;
+		let days = Math.floor(totalSeconds / 86400);
+		totalSeconds %= 86400;
+		let hours = Math.floor(totalSeconds / 3600);
+		totalSeconds %= 3600;
+		let minutes = Math.floor(totalSeconds / 60);
+		let seconds = Math.floor(totalSeconds % 60);
+
+		if (years >= 1) return `${years}y ${days}d ${hours}h ${minutes}m`;
+		else if (days >= 1) return `${days}d ${hours}h ${minutes}m`;
+		else if (hours >= 1) return `${hours}h ${minutes}m`;
+		else if (minutes >= 1) return `${minutes}m ${seconds}s`;
+		else return `${seconds}s`;
+	}
+}

package/src/util/Util.ts

@@ -0,0 +1,11 @@
+/** @format */
+
+import { XernerxClient } from '../main.js';
+
+export class Util {
+	public declare readonly client: XernerxClient;
+
+	constructor(client: XernerxClient) {
+		this.client = client;
+	}
+}

package/src/util/prompts.ts

@@ -0,0 +1,120 @@
+/** @format */
+
+import sharpyy from 'sharpyy';
+import { Color } from 'ora';
+
+import { XernerxClient } from '../client/XernerxClient.js';
+import XernerxLog from '../tools/XernerxLog.js';
+
+let init = false;
+
+export async function start(client: XernerxClient) {
+	if (init) return;
+
+	if (client.settings.debug) XernerxLog.info('Debug mode enabled, preventing console clear and logging all handlings...');
+	else console.clear();
+
+	const { default: ora, spinners } = await import('ora');
+	const { default: boxen } = await import('boxen');
+
+	console.info(
+		boxen(sharpyy('XERNERX', 'txRainbow', 'bold', 'underlines'), {
+			padding: 1,
+			margin: 1,
+			borderStyle: 'round',
+			height: 3,
+			align: 'center',
+			borderColor: 'magenta',
+			fullscreen: (width, height) => [width - 5, height],
+		})
+	);
+
+	if (!client.options.intents.has('Guilds'))
+		XernerxLog.warn('Your bot is signed in without the Guilds intent, this may cause issues with the bot.', new URL('https://discord.com/developers/docs/topics/gateway#gateway-intents'));
+
+	const spinner = ora();
+
+	spinner.spinner = spinners.dots12;
+
+	spinner.start();
+
+	let index = 0;
+
+	setInterval(async () => {
+		// Update Discord stats
+		calculateStats(client);
+
+		// Update commandline
+
+		const time = new Date()
+				.toLocaleTimeString()
+				.split(/ /gim)
+				.map((str) =>
+					str
+						.split(':')
+						.map((str) => (isNaN(Number(str)) ? str : sharpyy(str, 'txCyan')))
+						.join(':')
+				)
+				.join(' '),
+			ram = `${sharpyy(String(Math.round(process.memoryUsage().rss / 10000) / 100), 'txCyan')}mb`;
+
+		const colors = ['red', 'green', 'yellow', 'blue', 'magenta', 'cyan'];
+
+		const baseText = `${sharpyy('XERNERX', 'txRainbow', 'bold')} | ${time} | ${ram} | `;
+
+		if (client.user) {
+			spinner.color = colors[index] as Color;
+
+			const counts = {
+				local: client.commands.stats.slash.local + client.commands.stats.message.local + client.commands.stats.context.local,
+				global: client.commands.stats.slash.global + client.commands.stats.message.global + client.commands.stats.context.global,
+			};
+
+			spinner.text = boxen(
+				Object.entries({
+					'Name': sharpyy(client.user.tag, 'txBlue'),
+					'Status': `${sharpyy('Online', 'txGreen')} | ${client.settings.global ? sharpyy('Global', 'txGreen') : sharpyy('Local', 'txRed')}`,
+					'Uptime': client.util
+						.uptime(client.uptime)
+						.split('')
+						.map((c) => (isNaN(Number(c)) ? c : sharpyy(c, 'txCyan')))
+						.join(''),
+					'Commands': client.settings.global ? `${counts.local ? `local: ${counts.local}` : ''}|${counts.global ? `global: ${counts.global}` : ''}` : counts.local + counts.global,
+					'RAM Usage': ram,
+					'Guilds': (await Promise.all(client.settings.guilds.map(async (id) => sharpyy((await client.guilds.fetch(id))?.name || id, 'txBlue')))).join(', '),
+					'Owners': (await Promise.all(client.settings.owners.map(async (id) => sharpyy((await client.users.fetch(id))?.username || id, 'txBlue')))).join(', '),
+					'GuildCount': sharpyy(String(client.stats.guilds), 'txCyan'),
+					'UserCount': sharpyy(String(client.stats.users), 'txCyan'),
+					'ShardCount': sharpyy(String(client.stats.shardCount), 'txCyan'),
+				})
+					.map(([key, value]) => `${key}: ${value}`)
+					.join('\n'),
+				{
+					padding: 1,
+					margin: 1,
+					borderStyle: 'round',
+					borderColor: 'magenta',
+					title: time + ' - ' + sharpyy('XERNERX', 'txRainbow', 'bold') + '\x1B[35m',
+					height: 15,
+					fullscreen: (width, height) => [width - 5, height],
+				}
+			);
+		} else {
+			spinner.color = 'green';
+
+			spinner.text = baseText + `Connecting to Discord${index == 0 ? '.' : index == 1 ? '..' : index == 2 ? '...' : ''}`;
+		}
+
+		index++;
+
+		if (index == colors.length - 1) index = 0;
+	}, 250);
+
+	init = true;
+}
+
+function calculateStats(client: XernerxClient) {
+	client.stats.guilds = client.guilds.cache.size;
+	client.stats.users = client.users.cache.size;
+	client.stats.shardCount = client.options.shardCount || null;
+}