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

package/src/build/XernerxSlashCommandBuilder.ts

@@ -0,0 +1,290 @@
+/** @format */
+
+import { z } from 'zod';
+import {
+	ApplicationIntegrationType,
+	ChannelType,
+	InteractionContextType,
+	Locale,
+	PermissionFlags,
+	PermissionFlagsBits,
+	Permissions,
+	RestOrArray,
+	SlashCommandBooleanOption,
+	SlashCommandBuilder,
+	SlashCommandChannelOption,
+	SlashCommandIntegerOption,
+	SlashCommandMentionableOption,
+	SlashCommandNumberOption,
+	SlashCommandRoleOption,
+	SlashCommandStringOption,
+	SlashCommandSubcommandBuilder,
+	SlashCommandSubcommandGroupBuilder,
+	SlashCommandUserOption,
+} from 'discord.js';
+
+import { XernerxWarn } from '../tools/XernerxWarn.js';
+import {
+	XernerxSlashCommandBuilderGroup,
+	XernerxSlashCommandBuilderOption,
+	XernerxSlashCommandBuilderOptions,
+	XernerxSlashCommandBuilderSubcommand,
+} from '../interfaces/XernerxSlashCommandBuilderOptions.js';
+import { XernerxBaseBuilder } from './XernerxBaseBuilder.js';
+import { XernerxSlashCommand, XernerxSlashCommandAutocomplete } from '../interfaces/XernerxSlashCommand.js';
+
+export class XernerxSlashCommandBuilder extends XernerxBaseBuilder {
+	// Discord
+	declare public readonly name: string;
+	declare public readonly description: string;
+	declare public readonly integration: RestOrArray<InteractionContextType>;
+	declare public readonly data: SlashCommandBuilder;
+	declare public readonly options: Array<XernerxSlashCommandBuilderOption>;
+	declare public readonly subcommands: Array<XernerxSlashCommandBuilderSubcommand>;
+	declare public readonly groups: Array<XernerxSlashCommandBuilderGroup>;
+
+	// Xernerx
+	declare public readonly premium?: boolean;
+	declare public readonly defer?: boolean;
+	declare public readonly deploy?: { global?: boolean; guilds?: Array<string> | string };
+	declare public readonly info?: string;
+	declare public readonly usage?: string;
+	declare public readonly category?: string;
+	declare public readonly cooldown?: number;
+	declare public readonly permissions: { client: Permissions | number | bigint | null; user: Permissions | number | bigint | null };
+	declare public readonly strict?: { owner?: boolean; users?: Array<string>; channels?: Array<string>; guilds?: Array<string>; types?: ChannelType };
+	declare public readonly ignore?: { owner?: boolean; users?: Array<string>; channels?: Array<string>; guilds?: Array<string>; types?: ChannelType };
+
+	// Static
+	declare public readonly filetype: 'XernerxSlashCommand';
+
+	constructor(id: string, options: XernerxSlashCommandBuilderOptions) {
+		super(id, options);
+
+		options = z
+			.object({
+				// Discord
+				name: z.string(),
+				locales: z.record(z.string(), z.object({ name: z.string(), description: z.string() })).optional(),
+				description: z.string(),
+				contexts: z.array(z.custom<keyof typeof InteractionContextType>()).default(['Guild']),
+				integration: z.array(z.custom<keyof typeof ApplicationIntegrationType>()).default(['GuildInstall']),
+				nsfw: z.boolean().default(false),
+				options: z.any(),
+				subcommands: z.any(),
+				groups: z.any(),
+
+				// Xernerx
+				premium: z.boolean().default(false),
+				defer: z.boolean().default(false),
+				deploy: z.object({ global: z.boolean().default(true), guilds: z.string().or(z.array(z.string())).default([]) }).optional(),
+				info: z.string().optional(),
+				usage: z.string().optional(),
+				category: z.string().optional(),
+				cooldown: z.number().min(0).default(0),
+				strict: z
+					.object({
+						owner: z.boolean().default(false),
+						users: z.array(z.string()).default([]),
+						channels: z.array(z.string()).default([]),
+						guilds: z.array(z.string()).default([]),
+						types: z.enum(ChannelType).optional(),
+					})
+					.optional(),
+				ignore: z
+					.object({
+						owner: z.boolean().default(false),
+						users: z.array(z.string()).default([]),
+						channels: z.array(z.string()).default([]),
+						guilds: z.array(z.string()).default([]),
+						types: z.enum(ChannelType).optional(),
+					})
+					.optional(),
+				permissions: z
+					.object({
+						client: z
+							.union([z.array(z.custom<keyof PermissionFlags>()), z.number(), z.bigint()])
+							.nullable()
+							.default(null),
+						user: z
+							.union([z.array(z.custom<keyof PermissionFlags>()), z.number(), z.bigint()])
+							.nullable()
+							.default(null),
+					})
+					.default({ client: null, user: null }),
+			})
+			.parse(options);
+
+		this.name = options.name;
+
+		this.description = options.description;
+
+		this.info = options.info;
+
+		this.usage = options.usage;
+
+		this.category = options.category;
+
+		this.cooldown = options.cooldown;
+
+		this.premium = options.premium || false;
+
+		this.defer = options.defer;
+
+		this.deploy = {
+			global: options.deploy?.global ?? true,
+			guilds: typeof options.deploy?.guilds == 'string' ? [options.deploy.guilds] : options.deploy?.guilds || [],
+		};
+
+		this.filetype = 'XernerxSlashCommand';
+
+		this.permissions = options.permissions as typeof this.permissions;
+
+		this.strict = options.strict;
+
+		this.ignore = options.ignore;
+
+		this.data = new SlashCommandBuilder();
+
+		this.data.setName(this.name);
+
+		this.data.setDescription(this.description);
+
+		this.data.setContexts(...(options.contexts?.map((context) => InteractionContextType[context as keyof typeof InteractionContextType]) || [InteractionContextType.Guild]));
+
+		this.data.setIntegrationTypes(
+			...(options.integration?.map((integration) => ApplicationIntegrationType[integration as keyof typeof ApplicationIntegrationType]) || [ApplicationIntegrationType.GuildInstall])
+		);
+
+		if (Array.isArray(options.permissions?.user))
+			this.data.setDefaultMemberPermissions(options.permissions?.user?.map((permission) => PermissionFlagsBits[permission as keyof PermissionFlags]).reduce((a, b) => (a += b)));
+		else this.data.setDefaultMemberPermissions(options.permissions?.user || null);
+
+		this.data.setNSFW(options.nsfw || false);
+
+		for (const locale of Object.entries(options.locales || [])) {
+			this.data.setNameLocalization(locale[0] as Locale, locale[1].name);
+			this.data.setDescriptionLocalization(locale[0] as Locale, locale[1].description);
+		}
+
+		if (options.options && options?.options?.length > 0) {
+			this.addArguments(this.data, options.options);
+
+			this.options = options.options;
+		}
+
+		if (options.subcommands && options?.subcommands?.length > 0) {
+			this.addSubcommands(this.data, options.subcommands);
+
+			this.subcommands = options.subcommands;
+		}
+
+		if (options.groups && options?.groups?.length > 0) {
+			this.addSubcommandGroups(options.groups);
+
+			this.groups = options.groups;
+		}
+
+		this.client = this.client;
+	}
+
+	/**
+	 * Handles the autocomplete functionality for a slash command.
+	 *
+	 * @param args - The arguments for the autocomplete function, which include the context and options for the command.
+	 * @returns A promise that resolves to either void or any value, depending on the implementation.
+	 */
+	public async autocomplete(args: XernerxSlashCommandAutocomplete): Promise<void | any> {}
+
+	/**
+	 * Evaluates conditions for executing a slash command.
+	 *
+	 * @param args - The arguments for the conditions function, which include the context and options for the command.
+	 * @returns A promise that resolves to either void or any value, depending on the implementation.
+	 */
+	public async conditions(args: XernerxSlashCommand): Promise<void | any> {}
+
+	/**
+	 * Executes the slash command.
+	 *
+	 * @param args - The arguments for the exec function, which include the context and options for the command.
+	 * @returns A promise that resolves to either void or any value, depending on the implementation.
+	 */
+	public async exec(args: XernerxSlashCommand): Promise<void | any> {
+		new XernerxWarn(`${this.id} has no exec function, command will not respond.`);
+	}
+
+	private addArguments(command: SlashCommandBuilder | SlashCommandSubcommandBuilder, args: Array<XernerxSlashCommandBuilderOption>) {
+		for (const argument of args) {
+			let slashCommandArgumentType: string = `${argument.type.charAt(0).toUpperCase()}${argument.type.slice(1).toLowerCase()}`;
+
+			(command[`add${slashCommandArgumentType as UpperCasedSlashCommandArgumentOptions}Option`] as Function)((option: SlashCommandOption) => {
+				option
+					.setName(argument.name)
+					.setDescription(argument.description)
+					.setRequired(argument.required || false);
+
+				for (const locale of Object.entries(argument.locales || [])) {
+					option.setNameLocalization(locale[0] as Locale, locale[1].name);
+					option.setDescriptionLocalization(locale[0] as Locale, locale[1].description);
+				}
+
+				if (slashCommandArgumentType === 'String') {
+					if (argument.choices) {
+						for (const choice of argument.choices) {
+							const locales = choice?.locales;
+
+							(option as SlashCommandStringOption).addChoices({ ...choice, name_localizations: locales });
+						}
+					}
+
+					if (argument.maxLength) (option as SlashCommandStringOption).setMaxLength(argument.maxLength);
+					if (argument.minLength) (option as SlashCommandStringOption).setMinLength(argument.minLength);
+
+					(option as SlashCommandStringOption).setAutocomplete(argument.autocomplete || false);
+				}
+
+				return option;
+			});
+		}
+	}
+
+	private addSubcommands(method: SlashCommandBuilder | SlashCommandSubcommandGroupBuilder, subcommands: Array<XernerxSlashCommandBuilderSubcommand>) {
+		for (const subcommand of subcommands) {
+			let sub = new SlashCommandSubcommandBuilder().setName(subcommand.name).setDescription(subcommand.description);
+
+			for (const locale of Object.entries(subcommand.locales || [])) {
+				sub.setNameLocalization(locale[0] as Locale, locale[1].name);
+				sub.setDescriptionLocalization(locale[0] as Locale, locale[1].description);
+			}
+
+			if (subcommand.options && subcommand?.options?.length > 0) this.addArguments(sub, subcommand.options);
+
+			method.addSubcommand(sub);
+		}
+	}
+
+	/**
+	 * Adds subcommand groups to the slash command builder.
+	 *
+	 * @param groups - An array of subcommand groups to be added. Each group contains a name, description, locales, and subcommands.
+	 */
+	private addSubcommandGroups(groups: Array<XernerxSlashCommandBuilderGroup>) {
+		for (const group of groups) {
+			let subcommandGroup = new SlashCommandSubcommandGroupBuilder().setName(group.name).setDescription(group.description);
+
+			for (const locale of Object.entries(group.locales || [])) {
+				subcommandGroup.setNameLocalization(locale[0] as Locale, locale[1].name);
+				subcommandGroup.setDescriptionLocalization(locale[0] as Locale, locale[1].description);
+			}
+
+			if (group.subcommands?.length > 0) this.addSubcommands(subcommandGroup, group.subcommands);
+
+			this.data.addSubcommandGroup(subcommandGroup);
+		}
+	}
+}
+
+type UpperCasedSlashCommandArgumentOptions = 'Attachment' | 'Boolean' | 'Channel' | 'Integer' | 'Mentionable' | 'Number' | 'Role' | 'String' | 'User';
+type SlashCommandOption = SlashCommandOptionChoices | SlashCommandBooleanOption | SlashCommandUserOption | SlashCommandChannelOption | SlashCommandRoleOption | SlashCommandMentionableOption;
+type SlashCommandOptionChoices = SlashCommandStringOption | SlashCommandNumberOption | SlashCommandIntegerOption;

package/src/client/XernerxClient.ts

@@ -1,151 +1,173 @@
-/** @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`);
-			}
-		});
-	}
-}
+/** @format */
+
+import { Client, ClientOptions, Collection, RESTGetAPISKUsResult } from 'discord.js';
+import sharpyy from 'sharpyy';
+import { ClusterClient, DjsDiscordClient, getInfo } from 'discord-hybrid-sharding';
+import z from 'zod';
+
+import { XernerxClientOptions } from '../interfaces/XernerxClientOptions.js';
+import { XernerxInfo } from '../tools/XernerxInfo.js';
+import { XernerxClientStats } from '../interfaces/XernerxClientStats.js';
+import { XernerxInitial } from '../tools/XernerxInitial.js';
+import { XernerxError } from '../tools/XernerxError.js';
+import { XernerxSuccess } from '../tools/XernerxSuccess.js';
+import { XernerxMonitisation } from '../model/XernerxMonitisation.js';
+import { EventHandler } from '../handler/EventHandler.js';
+import { XernerxEventBuilder } from '../build/XernerxEventBuilder.js';
+import { CommandHandler } from '../handler/CommandHandler.js';
+import { XernerxMessageCommandBuilder } from '../build/XernerxMessageCommandBuilder.js';
+import { XernerxMessageCommandHandlerOptions } from '../interfaces/XernerxMessageCommandHandlerOptions.js';
+import { XernerxSlashCommandHandlerOptions } from '../interfaces/XernerxSlashCommandHandlerOptions.js';
+import { XernerxSlashCommandBuilder } from '../build/XernerxSlashCommandBuilder.js';
+
+export class XernerxClient extends Client {
+	// Config
+	declare public readonly token: string;
+	declare public readonly sharded: boolean;
+	declare public readonly settings: XernerxClientOptions;
+	declare public readonly premium: {
+		owners?: boolean;
+		consume?: boolean;
+		synchronize?: boolean;
+	};
+
+	// Setup
+	declare public readonly monitisation: { skus: RESTGetAPISKUsResult };
+	declare public readonly stats: XernerxClientStats;
+	declare public readonly cluster: ClusterClient | null;
+	declare public readonly cache: { messages: Collection<string, string>; slash: Collection<string, string> };
+	declare public readonly handler: { message: XernerxMessageCommandHandlerOptions; slash: XernerxSlashCommandHandlerOptions };
+
+	// Collections
+	declare public readonly commands: {
+		message: Collection<string, XernerxMessageCommandBuilder>;
+		slash: Collection<string, XernerxSlashCommandBuilder>;
+	};
+	declare public readonly events: Collection<string, XernerxEventBuilder>;
+
+	// Handlers
+	declare public readonly modules: { eventHandler: EventHandler; commandHandler: CommandHandler };
+
+	constructor(options: ClientOptions & XernerxClientOptions) {
+		try {
+			options.shards = getInfo().SHARD_LIST;
+			options.shardCount = getInfo().TOTAL_SHARDS;
+		} catch {
+			new XernerxInitial('Client');
+		}
+
+		super(options);
+
+		this.settings = z
+			.object({
+				token: z.string(),
+				global: z.boolean().default(false),
+				guildId: z.string().or(z.array(z.string()).max(5)).default([]),
+				owners: z.string().or(z.array(z.string()).max(5)).default([]),
+				premium: z
+					.object({
+						owners: z.boolean().default(true),
+						consume: z.boolean().default(true),
+						synchronize: z.boolean().default(true),
+					})
+					.optional(),
+			})
+			.parse(options);
+
+		this.sharded = options.shardCount ? true : false;
+		this.token = options.token as string;
+
+		this.settings.guildId = typeof this.settings.guildId == 'string' ? [this.settings.guildId] : this.settings.guildId;
+		this.settings.owners = typeof this.settings.owners == 'string' ? [this.settings.owners] : this.settings.owners;
+
+		this.premium = this.settings.premium || {
+			owners: true,
+			consume: true,
+			synchronize: true,
+		};
+
+		delete this.settings.premium;
+
+		this.monitisation = { skus: [] };
+
+		this.stats = {
+			onlineSince: Number(new Date()),
+			guildCount: null,
+			userCount: null,
+			shardCount: null,
+			voteCount: null,
+			shard: null,
+		};
+
+		this.cache = { messages: new Collection(), slash: new Collection() };
+
+		this.handler = {
+			message: { directory: null },
+			slash: { directory: null },
+		};
+
+		this.commands = { message: new Collection(), slash: new Collection() };
+
+		this.events = new Collection();
+
+		if (this.sharded) this.cluster = new ClusterClient(this as unknown as DjsDiscordClient);
+
+		this.modules = { eventHandler: new EventHandler(this), commandHandler: new CommandHandler(this) };
+	}
+
+	/**
+	 * Connects the client to Discord and initializes various client statistics and handlers.
+	 *
+	 * @returns A promise that resolves when the client successfully logs in, or rejects with an error message if the login fails.
+	 */
+	async connect() {
+		new XernerxInfo(`${this.cluster ? `${sharpyy(`Shard ${this.cluster.id}`, 'txCyan')} | ` : ''}Connecting...`);
+
+		this.on('clientReady', async (client) => {
+			this.monitisation.skus = await new XernerxMonitisation(client).sku();
+
+			/** When the client is sharded */
+			if (this.sharded && this.cluster) {
+				this.stats.shard = {
+					shardId: this.cluster.id,
+					onlineSince: Number(new Date()),
+					guildCount: null,
+					userCount: null,
+				};
+
+				setInterval(async () => {
+					if (!this.cluster || !this.stats.shard) return;
+
+					this.stats.guildCount = (await this.cluster.broadcastEval('this.guilds.cache.size')).reduce((a, b) => a + b, 0);
+					this.stats.userCount = (await this.cluster.broadcastEval('this.guilds.cache.map((a) => a.memberCount).reduce((a, b) => a + b, 0)')).reduce((a, b) => a + b, 0);
+					this.stats.shardCount = getInfo().TOTAL_SHARDS;
+					this.stats.shard.guildCount = client.guilds.cache.size;
+					this.stats.voteCount = 0;
+					this.stats.shard.userCount = client.guilds.cache.map((a) => a.memberCount).reduce((a, b) => a + b, 0);
+				}, 1000);
+
+				await new Promise((resolve) => setTimeout(resolve, 2000));
+
+				new XernerxSuccess(
+					`${sharpyy(`Shard ${this.cluster.id}`, 'txCyan')} | Signed in as ${sharpyy(client.user?.tag, 'txBlue')}, watching ${sharpyy(String(this.stats.shard?.guildCount?.toLocaleString()), 'txCyan')} guilds and users: ${sharpyy(String(this.stats.shard?.userCount?.toLocaleString()), 'txCyan')}`
+				);
+			} else {
+				/** When the client is standalone */
+				setInterval(() => {
+					this.stats.guildCount = client.guilds.cache.size;
+					this.stats.userCount = client.guilds.cache.map((a) => a.memberCount).reduce((a, b) => a + b, 0);
+					this.stats.voteCount = 0;
+					this.stats.shardCount = 0;
+				}, 1000);
+
+				await new Promise((resolve) => setTimeout(resolve, 2000));
+
+				new XernerxSuccess(
+					`Signed in as ${sharpyy(client.user?.tag, 'txBlue')}, watching ${sharpyy(String(this.stats.guildCount?.toLocaleString()), 'txCyan')} guilds and users: ${sharpyy(String(this.stats.userCount?.toLocaleString()), 'txCyan')}`
+				);
+			}
+		});
+
+		return await this.login(this.token).catch((error) => new XernerxError(error.message, 1));
+	}
+}