xernerx 0.1.120-beta.2 → 0.1.120-beta.21

package/src/client/XernerxShardClient.ts

@@ -0,0 +1,89 @@
+/** @format */
+
+import { Cluster, ClusterManager, ClusterManagerOptions } from 'discord-hybrid-sharding';
+import sharpyy from 'sharpyy';
+import fs from 'fs';
+
+import { XernerxInfo } from '../tools/XernerxInfo.js';
+import { XernerxError } from '../tools/XernerxError.js';
+import { XernerxSuccess } from '../tools/XernerxSuccess.js';
+import { XernerxShardClientOptions } from '../interfaces/XernerxShardClientOptions.js';
+import { XernerxInitial } from '../tools/XernerxInitial.js';
+
+export class XernerxShardClient extends ClusterManager {
+	declare public readonly onlineShards: Set<Cluster>;
+	declare public readonly stats: {
+		onlineSince: number | null;
+		guildCount: number | null;
+		userCount: number | null;
+		shardCount: number | null;
+		voteCount: number | null;
+		shards: [] | null;
+	};
+	constructor(options: ClusterManagerOptions & XernerxShardClientOptions) {
+		new XernerxInitial('ShardClient');
+
+		try {
+			new XernerxInfo(`Loading ShardClient from ${sharpyy(options.file, 'bgGray')}`);
+			(fs.readFileSync(options.file), 'utf-8');
+			new XernerxSuccess(`ShardClient loaded successfully`);
+		} catch {
+			new XernerxError(`File ${sharpyy(options.file, 'bgGray')} not found.`, 1);
+		}
+
+		super(options.file, options);
+
+		this.onlineShards = new Set();
+
+		this.stats = {
+			onlineSince: Number(new Date()),
+			guildCount: null,
+			userCount: null,
+			shardCount: null,
+			voteCount: null,
+			shards: [],
+		};
+
+		this.on('clusterCreate', (cluster) => {
+			new XernerxInfo(`${sharpyy(`Shard ${cluster.id}`, 'txCyan')} | Creating...`);
+
+			cluster.on('ready', () => {
+				this.onlineShards.add(cluster);
+
+				if (this.onlineShards.size == (this.totalClusters || this.totalShards)) this.#update();
+			});
+
+			cluster.on('disconnect', () => {
+				this.onlineShards.delete(cluster);
+			});
+
+			cluster.on('death', (error) => {
+				this.onlineShards.delete(cluster);
+			});
+		});
+
+		this.spawn({ timeout: -1 });
+	}
+
+	async #update() {
+		await new Promise((resolve) => setTimeout(resolve, 1000));
+
+		setInterval(async () => {
+			const stats = await this.fetchClientValues('stats');
+
+			const shards = await this.fetchClientValues('stats.shard');
+
+			this.stats.guildCount = stats[0].guildCount;
+			this.stats.userCount = stats[0].userCount;
+			this.stats.shardCount = stats[0].shardCount;
+			this.stats.voteCount = stats[0].voteCount;
+			this.stats.shards = shards;
+		}, 1000);
+
+		await new Promise((resolve) => setTimeout(resolve, 4000));
+
+		new XernerxSuccess(
+			`All Shards are online! Watching ${sharpyy(String(this.stats.guildCount?.toLocaleString()), 'txCyan')} guilds and users: ${sharpyy(String(this.stats.userCount?.toLocaleString()), 'txCyan')}, and ${sharpyy(String(this.stats.shardCount?.toLocaleString()), 'txCyan')} shards.`
+		);
+	}
+}

package/src/events/clientReady.ts

@@ -0,0 +1,96 @@
+/** @format */
+
+import { Client, GatewayVersion, REST, Routes } from 'discord.js';
+
+import { XernerxEventBuilder } from '../build/XernerxEventBuilder.js';
+import { XernerxClient } from '../client/XernerxClient.js';
+import { XernerxSlashCommandBuilder } from '../build/XernerxSlashCommandBuilder.js';
+import { XernerxError } from '../tools/XernerxError.js';
+import { XernerxSuccess } from '../tools/XernerxSuccess.js';
+import { XernerxInfo } from '../tools/XernerxInfo.js';
+import { XernerxUser } from '../model/XernerxUser.js';
+
+export class XernerxClientReadyEvent extends XernerxEventBuilder {
+	declare private readonly commands: {
+		global: Array<XernerxSlashCommandBuilder>;
+		local: Array<XernerxSlashCommandBuilder>;
+	};
+
+	constructor() {
+		super('XernerxClientReadyEvent', {
+			name: 'clientReady',
+			emitter: 'client',
+			once: true,
+		});
+
+		this.commands = {
+			global: [],
+			local: [],
+		};
+	}
+
+	override async run(client: XernerxClient) {
+		// premium for owners
+
+		if (client.settings.owners?.length) {
+			const owners = [];
+
+			if (client.premium?.synchronize) new XernerxInfo(`Synchronizing entitlements for premium owners...`);
+
+			for (const owner of client.settings.owners) {
+				const user = await client.users.fetch(owner);
+
+				new XernerxUser(client as Client<true>, user).synchronize();
+
+				owners.push(user);
+			}
+
+			if (client.premium?.synchronize) new XernerxSuccess(`Successfully synchronized entitlements for ${owners.map((owner) => owner.username).join(',')}`);
+		}
+
+		// interaction commands
+		try {
+			const commands = [...client.commands.slash].map(([, command]) => command);
+
+			if (!client.settings.global) {
+				this.commands.global = [];
+				this.commands.local = commands;
+			} else {
+				this.commands.global = commands.filter((command) => command.deploy?.global);
+				this.commands.local = commands.filter((command) => !command.deploy?.global);
+			}
+
+			this.put(client);
+
+			new XernerxSuccess(`Successfully deployed slash commands ${client.settings.global ? 'globally' : 'locally'}`);
+		} catch (error) {
+			new XernerxError((error as Error).message);
+		}
+	}
+
+	async put(client: XernerxClient) {
+		const rest = new REST({ version: GatewayVersion }).setToken(client.token);
+
+		if (this.commands.global.length) {
+			if (!client.settings.global) return new XernerxInfo('Loading commands locally');
+
+			await rest.put(Routes.applicationCommands(client.user?.id as string), { body: this.commands.global.map((command) => command.data.toJSON()) });
+		}
+
+		if (this.commands.local.length) {
+			const guilds: { [index: string]: Array<XernerxSlashCommandBuilder> } = {};
+
+			for (const command of this.commands.local) {
+				(command.deploy?.guilds as Array<string>)?.map((id) => (guilds[id] ? guilds[id].push(command) : (guilds[id] = [command])));
+			}
+
+			if (!client.settings.guildId?.length && !Object.keys(guilds).length) return new XernerxError('Cannot locally deploy slash commands without a guild ID');
+
+			(client.settings.guildId as Array<string>).map((id: string) => (guilds[id] ? guilds[id] : (guilds[id] = this.commands.local)));
+
+			for (const [guildId, commands] of Object.entries(guilds)) {
+				await rest.put(Routes.applicationGuildCommands(client.user?.id as string, guildId), { body: commands.map((command) => command.data.toJSON()) });
+			}
+		}
+	}
+}

package/src/events/entitlementCreate.ts

@@ -0,0 +1,15 @@
+/** @format */
+
+import { XernerxEventBuilder } from '../build/XernerxEventBuilder.js';
+
+export class XernerxEntitlementCreateEvent extends XernerxEventBuilder {
+	constructor() {
+		super('XernerxEntitlementCreateEvent', {
+			name: 'entitlementCreate',
+			emitter: 'client',
+			once: false,
+		});
+	}
+
+	override async run(a: any, b: any, c: any) {}
+}

package/src/events/interactionCreate.ts

@@ -0,0 +1,36 @@
+/** @format */
+
+import { Interaction } from 'discord.js';
+
+import { XernerxEventBuilder } from '../build/XernerxEventBuilder.js';
+import { XernerxUser } from '../model/XernerxUser.js';
+import { XernerxClient } from '../client/XernerxClient.js';
+import { XernerxInteractionUtil } from '../util/XernerxInteractionUtil.js';
+
+export class XernerxInteractionCreateEvent extends XernerxEventBuilder {
+	constructor() {
+		super('XernerxInteractionCreateEvent', {
+			name: 'interactionCreate',
+			emitter: 'client',
+			once: false,
+		});
+	}
+
+	override async run(interaction: Interaction) {
+		this.client = interaction.client as XernerxClient;
+
+		interaction.user = new XernerxUser(interaction.client, interaction.user);
+
+		interaction.util = new XernerxInteractionUtil(this.client as Interaction['client'], interaction);
+
+		if (interaction.isChatInputCommand()) return await interaction.client.emit('slashCommandInteraction', interaction);
+
+		if (interaction.isContextMenuCommand()) return await interaction.client.emit('contextCommandInteraction', interaction);
+
+		if (interaction.isAnySelectMenu()) return await interaction.client.emit('selectMenuInteraction', interaction);
+
+		if (interaction.isButton()) return await interaction.client.emit('buttonInteraction', interaction);
+
+		if (interaction.isModalSubmit()) return await interaction.client.emit('modalInteraction', interaction);
+	}
+}

package/src/events/messageCreate.ts

@@ -0,0 +1,60 @@
+/** @format */
+
+import { Message } from 'discord.js';
+
+import { XernerxEventBuilder } from '../build/XernerxEventBuilder.js';
+import { XernerxUser } from '../model/XernerxUser.js';
+import { XernerxMessageUtil } from '../util/XernerxMessageUtil.js';
+
+export class XernerxMessageCreateEvent extends XernerxEventBuilder {
+	constructor() {
+		super('XernerxMessageCreateEvent', {
+			name: 'messageCreate',
+			emitter: 'client',
+			once: false,
+		});
+	}
+
+	override async run(message: Message) {
+		this.client = message.client;
+
+		message.user = new XernerxUser(message.client, message.author);
+
+		message.util = new XernerxMessageUtil(this.client as Message['client'], message);
+
+		if (!message.content) return;
+		if (this.client.handler.message.ignore?.bots && message.author.bot) return;
+		if (this.client.handler.message.ignore?.self && message.author.id === this.client.user?.id) return;
+		if (this.client.handler.message.ignore?.system && message.system) return;
+
+		if (!message.util.parsed.command) return;
+
+		const command = this.client.commands.message.get(message.util.parsed.command);
+
+		if (!command) return;
+
+		if (
+			this.client.handler.message.mention &&
+			!message.util.parsed.mention &&
+			!command?.prefix.includes(message.util.parsed.prefix as string) &&
+			!this.client.handler.message.prefix?.includes(message.util.parsed.prefix as string)
+		)
+			return;
+
+		// validation
+
+		// args
+
+		// inhibitors
+
+		try {
+			await message.client.emit('commandStart', message, {}, command);
+
+			await command?.exec(message, message.util.args);
+
+			await message.client.emit('commandFinish', message, {}, command);
+		} catch (error) {
+			await message.client.emit('commandError', message, {}, command, error as Error);
+		}
+	}
+}

package/src/events/messageDelete.ts

@@ -0,0 +1,41 @@
+/** @format */
+
+import { Message } from 'discord.js';
+
+import { XernerxEventBuilder } from '../build/XernerxEventBuilder.js';
+import { XernerxUser } from '../model/XernerxUser.js';
+import { XernerxMessageUtil } from '../util/XernerxMessageUtil.js';
+
+export class XernerxMessageDeleteEvent extends XernerxEventBuilder {
+	constructor() {
+		super('XernerxMessageDeleteEvent', {
+			name: 'messageDelete',
+			emitter: 'client',
+			once: false,
+		});
+	}
+
+	override async run(message: Message) {
+		this.client = message.client;
+
+		message.user = new XernerxUser(message.client, message.author);
+
+		message.util = new XernerxMessageUtil(this.client as Message['client'], message);
+
+		if (!this.client.handler.message.handleDeletions) return;
+
+		if (!this.client.cache.messages.has(message.id)) return;
+
+		const id = this.client.cache.messages.get(message.id);
+
+		if (!id) return;
+
+		try {
+			const msg = await message.channel.messages.fetch(id);
+
+			await msg.delete();
+		} catch (error) {
+			await this.client.emit('commandDelete', message, error as Error);
+		}
+	}
+}

package/src/events/messageUpdate.ts

@@ -0,0 +1,60 @@
+/** @format */
+
+import { Message } from 'discord.js';
+
+import { XernerxEventBuilder } from '../build/XernerxEventBuilder.js';
+import { XernerxUser } from '../model/XernerxUser.js';
+import { XernerxMessageUtil } from '../util/XernerxMessageUtil.js';
+
+export class XernerxMessageUpdateEvent extends XernerxEventBuilder {
+	constructor() {
+		super('XernerxMessageUpdateEvent', {
+			name: 'messageUpdate',
+			emitter: 'client',
+			once: false,
+		});
+	}
+
+	override async run(oldMessage: Message, message: Message) {
+		this.client = message.client;
+
+		message.user = new XernerxUser(message.client, message.author);
+
+		message.util = new XernerxMessageUtil(this.client as Message['client'], message);
+
+		if (!message.content) return;
+		if (this.client.handler.message.ignore?.bots && message.author.bot) return;
+		if (this.client.handler.message.ignore?.self && message.author.id === this.client.user?.id) return;
+		if (this.client.handler.message.ignore?.system && message.system) return;
+
+		if (!message.util.parsed.command) return;
+
+		const command = this.client.commands.message.get(message.util.parsed.command);
+
+		if (!command) return;
+
+		if (
+			this.client.handler.message.mention &&
+			!message.util.parsed.mention &&
+			!command?.prefix.includes(message.util.parsed.prefix as string) &&
+			!this.client.handler.message.prefix?.includes(message.util.parsed.prefix as string)
+		)
+			return;
+
+		// validation
+
+		// args
+
+		// inhibitors
+
+		try {
+			await message.client.emit('commandStart', message, {}, command);
+
+			await command?.exec(message, message.util.args);
+
+			await message.client.emit('commandFinish', message, {}, command);
+		} catch (error) {
+			await message.client.emit('commandError', message, {}, command, error as Error);
+		}
+	}
+}

package/src/events/slashCommandInteraction.ts

@@ -0,0 +1,55 @@
+/** @format */
+
+import { AutocompleteInteraction, ChatInputCommandInteraction } from 'discord.js';
+
+import { XernerxEventBuilder } from '../build/XernerxEventBuilder.js';
+import { XernerxInteractionArguments } from '../model/XernerxInteractionArguments.js';
+import { XernerxSlashCommandValidator } from '../validators/XernerxSlashCommandValidator.js';
+
+export class XernerxSlashCommandInteractionEvent extends XernerxEventBuilder {
+	constructor() {
+		super('XernerxSlashCommandInteractionEvent', {
+			name: 'slashCommandInteraction',
+			emitter: 'client',
+			once: false,
+		});
+	}
+
+	override async run(interaction: ChatInputCommandInteraction) {
+		const command = interaction.client.commands.slash.get(interaction.commandName);
+
+		if (!command) return;
+
+		// inhibitors
+
+		new Promise(async (resolve) => {
+			if (interaction.isAutocomplete()) {
+				const focused = (interaction as AutocompleteInteraction).options.getFocused(true);
+				const options = (interaction as AutocompleteInteraction).options;
+
+				await command.autocomplete({ interaction, focused, options });
+			} else resolve(true);
+		}).then(async () => {
+			const args = new XernerxInteractionArguments(interaction, command);
+			const options = { options: args.options(), subcommand: args.subcommand(), group: args.subcommand() };
+
+			try {
+				await interaction.client.emit('commandStart', interaction, options, command);
+
+				const validation = new XernerxSlashCommandValidator(interaction, command);
+
+				if (!(await validation.validate())) return;
+
+				if (command.defer) await interaction.deferReply();
+
+				if (await command.conditions({ interaction, ...options, command })) return;
+
+				await command.exec({ interaction, ...options, command });
+
+				await interaction.client.emit('commandFinish', interaction, options, command);
+			} catch (error) {
+				await interaction.client.emit('commandError', interaction, options, command, error as Error);
+			}
+		});
+	}
+}

package/src/handler/CommandHandler.ts

@@ -0,0 +1,132 @@
+/** @format */
+
+import sharpyy from 'sharpyy';
+import { z } from 'zod';
+
+import { XernerxClient } from '../client/XernerxClient.js';
+import { Handler } from './Handler.js';
+import { XernerxMessageCreateEvent } from '../events/messageCreate.js';
+import { XernerxMessageUpdateEvent } from '../events/messageUpdate.js';
+import { XernerxMessageDeleteEvent } from '../events/messageDelete.js';
+import { XernerxInteractionCreateEvent } from '../events/interactionCreate.js';
+import { XernerxSuccess } from '../tools/XernerxSuccess.js';
+import { XernerxWarn } from '../tools/XernerxWarn.js';
+import { XernerxError } from '../tools/XernerxError.js';
+import { XernerxMessageCommandHandlerOptions } from '../interfaces/XernerxMessageCommandHandlerOptions.js';
+import { XernerxSlashCommandHandlerOptions } from '../interfaces/XernerxSlashCommandHandlerOptions.js';
+import { XernerxEventBuilder } from '../build/XernerxEventBuilder.js';
+import { XernerxClientReadyEvent } from '../events/clientReady.js';
+import { XernerxSlashCommandInteractionEvent } from '../events/slashCommandInteraction.js';
+import { XernerxEntitlementCreateEvent } from '../events/entitlementCreate.js';
+
+export class CommandHandler extends Handler {
+	constructor(client: XernerxClient) {
+		super(client);
+
+		this.loadEvents(XernerxEntitlementCreateEvent, XernerxClientReadyEvent);
+	}
+
+	/**
+	 * Loads a message command from a specified file.
+	 *
+	 * @param file - The path to the file containing the message command to be loaded.
+	 * @returns A promise that resolves when the file has been successfully loaded.
+	 */
+	public async loadMessageCommand(file: string) {
+		return await this.loadFile(file);
+	}
+
+	/**
+	 * Loads message commands based on the provided options.
+	 *
+	 * @param options - Configuration options for loading message commands, including directory, prefix, mention, separator, handleEdits, handleDeletions, and ignore settings.
+	 * @returns A promise that resolves when all message commands have been successfully loaded.
+	 */
+	public async loadMessageCommands(options: XernerxMessageCommandHandlerOptions) {
+		const config = z
+			.object({
+				directory: z.string(),
+				prefix: z.union([z.string(), z.array(z.string())]).default([]),
+				mention: z.boolean().default(false),
+				seperator: z.string().default(' '),
+				handleEdits: z.boolean().default(false),
+				handleDeletions: z.boolean().default(false),
+				ignore: z
+					.object({
+						system: z.boolean().default(true),
+						bots: z.boolean().default(true),
+						self: z.boolean().default(true),
+					})
+					.default({ system: true, bots: true, self: true }),
+			})
+			.parse(options);
+
+		typeof config.prefix == 'string' ? (config.prefix = [config.prefix]) : config.prefix;
+
+		this.client.handler.message = config;
+
+		const files = this.loadFiles(config.directory);
+
+		this.loadEvents(XernerxMessageCreateEvent, XernerxMessageUpdateEvent, XernerxMessageDeleteEvent);
+
+		if (!this.client.options.intents.has('GuildMessages')) new XernerxError(`Missing ${sharpyy('GuildMessages', 'txYellow')} intent, message commands will not work.`);
+		if (!this.client.options.intents.has('MessageContent') && !config.mention)
+			new XernerxError(`Missing ${sharpyy('MessageContent', 'txYellow')} intent and bot mention is turned off, message commands will not work.`);
+		if (!this.client.options.intents.has('MessageContent') && config.mention)
+			new XernerxWarn(`Missing ${sharpyy('MessageContent', 'txYellow')} intent, message commands can only be triggered by @mention.`);
+
+		for (const file of files) {
+			await this.loadMessageCommand(file);
+		}
+
+		new XernerxSuccess(`Loaded message commands: ${this.client.commands.message.map((command) => sharpyy(command.id, 'txYellow')).join(', ')}`);
+	}
+
+	/**
+	 * Loads a slash command from a specified file.
+	 *
+	 * @param file - The path to the file containing the slash command to be loaded.
+	 * @returns A promise that resolves when the file has been successfully loaded.
+	 */
+	public async loadSlashCommand(file: string) {
+		return await this.loadFile(file);
+	}
+
+	/**
+	 * Loads slash commands based on the provided options.
+	 *
+	 * @param options - Configuration options for loading slash commands, including the directory where the command files are located.
+	 * @returns A promise that resolves when all slash commands have been successfully loaded.
+	 */
+	public async loadSlashCommands(options: XernerxSlashCommandHandlerOptions) {
+		const config = z
+			.object({
+				directory: z.string(),
+			})
+			.parse(options);
+
+		this.client.handler.slash = config;
+
+		const files = this.loadFiles(config.directory);
+
+		for (const file of files) {
+			await this.loadSlashCommand(file);
+		}
+
+		this.loadEvents(XernerxInteractionCreateEvent, XernerxSlashCommandInteractionEvent);
+
+		new XernerxSuccess(`Loaded slash commands: ${this.client.commands.slash.map((command) => sharpyy(command.id, 'txYellow')).join(', ')}`);
+	}
+
+	/**
+	 * Loads and imports event files based on the provided event classes.
+	 *
+	 * @param args - An array of event classes extending XernerxEventBuilder. Each class represents an event to be loaded and imported.
+	 * @returns A promise that resolves when all specified events have been successfully imported.
+	 */
+	private async loadEvents(...args: Array<typeof XernerxEventBuilder>) {
+		for (const event of args) {
+			this.importFile(new event('', { name: '' }));
+		}
+	}
+}

package/src/handler/EventHandler.ts

@@ -0,0 +1,45 @@
+/** @format */
+
+import sharpyy from 'sharpyy';
+
+import { XernerxClient } from '../client/XernerxClient.js';
+import { Handler } from './Handler.js';
+import { XernerxSuccess } from '../tools/XernerxSuccess.js';
+
+export class EventHandler extends Handler {
+	constructor(client: XernerxClient) {
+		super(client);
+	}
+
+	/**
+	 * Loads a single event file.
+	 *
+	 * @param file - The path to the event file to be loaded.
+	 * @returns A promise that resolves when the event file has been successfully loaded.
+	 */
+	public async loadEvent(file: string) {
+		return this.loadFile(file);
+	}
+
+	/**
+	 * Loads all event files from the specified directory and initializes them.
+	 *
+	 * @param options - An object containing options for loading events.
+	 * @param options.directory - The directory path where event files are located.
+	 * @returns A promise that resolves when all events have been loaded.
+	 */
+	public async loadEvents(options: { directory: string }) {
+		const files = this.loadFiles(options.directory);
+
+		for (const file of files) {
+			await this.loadEvent(file);
+		}
+
+		new XernerxSuccess(
+			`Loaded events: ${this.client.events
+				.filter((event) => !event.id.startsWith('Xernerx'))
+				.map((event) => sharpyy(event.id, 'txYellow'))
+				.join(', ')}`
+		);
+	}
+}