xernerx 4.5.23 → 4.5.26

package/dist/build/XernerxMessageCommand.js

@@ -2,74 +2,74 @@
 import { z } from 'zod';
 import { XernerxLog } from '../main.js';
 export default class XernerxMessageCommand {
-	constructor(id, options) {
-		this.id = id;
-		this.regex = options.regex;
-		this.args = options.args;
-		this.flags = options.flags;
-		options = z
-			.object({
-				name: z.string(),
-				aliases: z.array(z.string()).default([]),
-				description: z.string().or(z.null()).default(null),
-				usage: z.string().or(z.null()).default(null),
-				info: z.string().or(z.null()).default(null),
-				category: z.string().or(z.null()).default(null),
-				cooldown: z.number().or(z.null()).default(null),
-				prefix: z.array(z.string()).or(z.string()).default([]),
-				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([]),
-					})
-					.default({}),
-				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([]),
-					})
-					.default({}),
-				permissions: z
-					.object({
-						user: z.array(z.string()).default([]),
-						client: z.array(z.string()).default([]),
-						dm: z.boolean().default(true),
-					})
-					.default({}),
-			})
-			.parse(options);
-		this.name = options.name;
-		this.aliases = options.aliases;
-		this.prefix = options.prefix;
-		this.description = options.description;
-		this.usage = options.usage;
-		this.info = options.info;
-		this.category = options.category;
-		this.cooldown = options.cooldown;
-		this.ignore = options.ignore;
-		this.strict = options.strict;
-		this.separator = options.separator;
-		this.permissions = options.permissions;
-		this.client = this.client;
-	}
-	/**
-	 * @description Checks for conditions before running the command
-	 * @param message - The message event emitted on this command
-	 * @param options - The args and flags parsed on this command
-	 */
-	async conditions(message, { args, flags }) {}
-	/**
-	 * @description Runs the execution rule
-	 * @param message - The message event emitted on this command
-	 * @param options - The args and flags parsed on this command
-	 */
-	async exec(message, { args, flags }) {
-		new XernerxLog(this.client).error(`${this.id} doesn't have an execution rule.`);
-		return await this.client.emit('commandError', message, `${this.id} doesn't have an execution rule.`, this, this.filetype);
-	}
+    constructor(id, options) {
+        this.id = id;
+        this.regex = options.regex;
+        this.args = options.args;
+        this.flags = options.flags;
+        options = z
+            .object({
+            name: z.string(),
+            aliases: z.array(z.string()).default([]),
+            description: z.string().or(z.null()).default(null),
+            usage: z.string().or(z.null()).default(null),
+            info: z.string().or(z.null()).default(null),
+            category: z.string().or(z.null()).default(null),
+            cooldown: z.number().or(z.null()).default(null),
+            prefix: z.array(z.string()).or(z.string()).default([]),
+            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([]),
+            })
+                .default({}),
+            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([]),
+            })
+                .default({}),
+            permissions: z
+                .object({
+                user: z.array(z.string()).default([]),
+                client: z.array(z.string()).default([]),
+                dm: z.boolean().default(true),
+            })
+                .default({}),
+        })
+            .parse(options);
+        this.name = options.name;
+        this.aliases = options.aliases;
+        this.prefix = options.prefix;
+        this.description = options.description;
+        this.usage = options.usage;
+        this.info = options.info;
+        this.category = options.category;
+        this.cooldown = options.cooldown;
+        this.ignore = options.ignore;
+        this.strict = options.strict;
+        this.separator = options.separator;
+        this.permissions = options.permissions;
+        this.client = this.client;
+    }
+    /**
+     * @description Checks for conditions before running the command
+     * @param message - The message event emitted on this command
+     * @param options - The args and flags parsed on this command
+     */
+    async conditions(message, { args, flags }) { }
+    /**
+     * @description Runs the execution rule
+     * @param message - The message event emitted on this command
+     * @param options - The args and flags parsed on this command
+     */
+    async exec(message, { args, flags }) {
+        new XernerxLog(this.client).error(`${this.id} doesn't have an execution rule.`);
+        return await this.client.emit('commandError', message, `${this.id} doesn't have an execution rule.`, this, this.filetype);
+    }
 }
-//# sourceMappingURL=XernerxMessageCommand.js.map
+//# sourceMappingURL=XernerxMessageCommand.js.map

package/dist/build/XernerxSlashCommand.d.ts

@@ -4,75 +4,61 @@ import { XernerxClientType, XernerxMessageContextInteraction, XernerxSlashIntera
 import { SlashCommandArguments, SlashCommandOptions } from '../types/interfaces.js';
 import { XernerxInteraction } from '../types/types.js';
 export default class XernerxSlashCommand {
-	readonly id: string;
-	readonly data: Discord.SlashCommandBuilder;
-	readonly name: string;
-	readonly description: string;
-	readonly usage: string | null | undefined;
-	readonly info: string | null | undefined;
-	readonly category: string | null | undefined;
-	readonly cooldown: number | null | undefined;
-	readonly ignore:
-		| {
-				owner?: boolean | undefined;
-				users?: string[] | undefined;
-				channels?: string[] | undefined;
-				guilds?: string[] | undefined;
-		  }
-		| undefined;
-	readonly strict:
-		| {
-				owner?: boolean | undefined;
-				users?: string[] | undefined;
-				channels?: string[] | undefined;
-				guilds?: string[] | undefined;
-		  }
-		| undefined;
-	readonly permissions:
-		| {
-				user?: string[] | import('../main.js').PermissionNames[] | undefined;
-				client?: string[] | import('../main.js').PermissionNames[] | undefined;
-				dm?: boolean | undefined;
-		  }
-		| undefined;
-	readonly defer:
-		| {
-				reply?: boolean | undefined;
-				ephemeral?: boolean | undefined;
-				fetchReply?: boolean | undefined;
-		  }
-		| undefined;
-	readonly filetype: 'SlashCommand';
-	readonly filepath: string;
-	readonly client: XernerxClientType;
-	constructor(id: string, options: SlashCommandOptions);
-	/**
-	 * @description autocomplete let's you add choices to string option arguments
-	 * @param interaction - The interaction event emitted on this command
-	 * @param focused - The command option that is in focus
-	 * @param options - The full list of options on the command
-	 */
-	autocomplete<T>(interaction: XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>, focused: T, options: T[]): Promise<void | any | T>;
-	/**
-	 * @description Checks for conditions before running the command
-	 * @param interaction - The interaction event emitted on this command
-	 * @param options - The args, group and subcommand parsed on this command
-	 */
-	conditions<T>(
-		interaction: XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>,
-		{ args, subcommand, group }: SlashCommandArguments
-	): Promise<void | any | T>;
-	/**
-	 * @description Runs the execution rule
-	 * @param interaction - The interaction event emitted on this command
-	 * @param options - The args, group and subcommand parsed on this command
-	 */
-	exec<T>(
-		interaction: XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>,
-		{ args, subcommand, group }: SlashCommandArguments
-	): Promise<void | any | T>;
-	private addArguments;
-	private addSubcommands;
-	private addSubcommandGroups;
+    readonly id: string;
+    readonly data: Discord.SlashCommandBuilder;
+    readonly name: string;
+    readonly description: string;
+    readonly usage: string | null | undefined;
+    readonly info: string | null | undefined;
+    readonly category: string | null | undefined;
+    readonly cooldown: number | null | undefined;
+    readonly ignore: {
+        owner?: boolean | undefined;
+        users?: string[] | undefined;
+        channels?: string[] | undefined;
+        guilds?: string[] | undefined;
+    } | undefined;
+    readonly strict: {
+        owner?: boolean | undefined;
+        users?: string[] | undefined;
+        channels?: string[] | undefined;
+        guilds?: string[] | undefined;
+    } | undefined;
+    readonly permissions: {
+        user?: string[] | import("../main.js").PermissionNames[] | undefined;
+        client?: string[] | import("../main.js").PermissionNames[] | undefined;
+        dm?: boolean | undefined;
+    } | undefined;
+    readonly defer: {
+        reply?: boolean | undefined;
+        ephemeral?: boolean | undefined;
+        fetchReply?: boolean | undefined;
+    } | undefined;
+    readonly filetype: 'SlashCommand';
+    readonly filepath: string;
+    readonly client: XernerxClientType;
+    constructor(id: string, options: SlashCommandOptions);
+    /**
+     * @description autocomplete let's you add choices to string option arguments
+     * @param interaction - The interaction event emitted on this command
+     * @param focused - The command option that is in focus
+     * @param options - The full list of options on the command
+     */
+    autocomplete<T>(interaction: XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>, focused: T, options: T[]): Promise<void | any | T>;
+    /**
+     * @description Checks for conditions before running the command
+     * @param interaction - The interaction event emitted on this command
+     * @param options - The args, group and subcommand parsed on this command
+     */
+    conditions<T>(interaction: XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>, { args, subcommand, group }: SlashCommandArguments): Promise<void | any | T>;
+    /**
+     * @description Runs the execution rule
+     * @param interaction - The interaction event emitted on this command
+     * @param options - The args, group and subcommand parsed on this command
+     */
+    exec<T>(interaction: XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>, { args, subcommand, group }: SlashCommandArguments): Promise<void | any | T>;
+    private addArguments;
+    private addSubcommands;
+    private addSubcommandGroups;
 }
-//# sourceMappingURL=XernerxSlashCommand.d.ts.map
+//# sourceMappingURL=XernerxSlashCommand.d.ts.map

package/dist/build/XernerxSlashCommand.js

@@ -3,132 +3,132 @@ import Discord, { SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuil
 import { z } from 'zod';
 import { XernerxLog } from '../main.js';
 export default class XernerxSlashCommand {
-	constructor(id, options) {
-		this.id = id;
-		this.data = new Discord.SlashCommandBuilder();
-		this.data.setName(options.name);
-		this.data.setNameLocalizations(options.nameLocalizations || null);
-		this.data.setDescription(options.description);
-		this.data.setDescriptionLocalizations(options.descriptionLocalizations || null);
-		this.data.setDMPermission(options.permissions?.dm || null);
-		if (options.args && options?.args?.length > 0) {
-			this.addArguments(this.data, options.args);
-		}
-		if (options.subcommands && options?.subcommands?.length > 0) {
-			this.addSubcommands(this.data, options.subcommands);
-		}
-		if (options.groups && options?.groups?.length > 0) {
-			this.addSubcommandGroups(options.groups);
-		}
-		options = z
-			.object({
-				name: z.string(),
-				description: z.string(),
-				usage: z.string().or(z.null()).default(null),
-				info: z.string().or(z.null()).default(null),
-				category: z.string().or(z.null()).default(null),
-				number: z.number().or(z.null()).default(null),
-				channelType: z.array(z.number()).or(z.null()).default(null),
-				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([]),
-					})
-					.default({}),
-				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([]),
-					})
-					.default({}),
-				permissions: z
-					.object({
-						user: z.array(z.string()).default([]),
-						client: z.array(z.string()).default([]),
-						dm: z.boolean().default(true),
-					})
-					.default({}),
-				defer: z
-					.object({
-						reply: z.boolean().default(false),
-						ephemeral: z.boolean().default(false),
-						fetch: z.boolean().default(false),
-					})
-					.default({}),
-			})
-			.parse(options);
-		this.name = options.name;
-		this.description = options.description;
-		this.usage = options.usage;
-		this.info = options.info;
-		this.category = options.category;
-		this.cooldown = options.cooldown;
-		this.ignore = options.ignore;
-		this.strict = options.strict;
-		this.permissions = options.permissions;
-		this.defer = options.defer;
-		this.client = this.client;
-	}
-	/**
-	 * @description autocomplete let's you add choices to string option arguments
-	 * @param interaction - The interaction event emitted on this command
-	 * @param focused - The command option that is in focus
-	 * @param options - The full list of options on the command
-	 */
-	async autocomplete(interaction, focused, options) {}
-	/**
-	 * @description Checks for conditions before running the command
-	 * @param interaction - The interaction event emitted on this command
-	 * @param options - The args, group and subcommand parsed on this command
-	 */
-	async conditions(interaction, { args, subcommand, group }) {}
-	/**
-	 * @description Runs the execution rule
-	 * @param interaction - The interaction event emitted on this command
-	 * @param options - The args, group and subcommand parsed on this command
-	 */
-	async exec(interaction, { args, subcommand, group }) {
-		new XernerxLog(this.client).error(`${this.id} doesn't have an execution rule.`);
-		return await this.client.emit('commandError', interaction, `${this.id} doesn't have an execution rule.`, this, this.filetype);
-	}
-	addArguments(command, args) {
-		for (const argument of args) {
-			let slashCommandArgumentType = `${argument.type.charAt(0).toUpperCase()}${argument.type.slice(1).toLowerCase()}`;
-			command[`add${slashCommandArgumentType}Option`]((option) => {
-				option
-					.setName(argument.name)
-					.setDescription(argument.description)
-					.setRequired(argument.required || false);
-				if (slashCommandArgumentType === 'String') {
-					if (argument.choices)
-						option.setChoices(
-							...argument.choices.map((choices) => {
-								return { name: Object.keys(choices).at(0), value: Object.values(choices).at(0) };
-							})
-						);
-					option.setAutocomplete(argument.autocomplete || false);
-				}
-				return option;
-			});
-		}
-	}
-	addSubcommands(method, subcommands) {
-		for (const subcommand of subcommands) {
-			let sub = new SlashCommandSubcommandBuilder().setName(subcommand.name).setDescription(subcommand.description);
-			if (subcommand.args && subcommand?.args?.length > 0) this.addArguments(sub, subcommand.args);
-			method.addSubcommand(sub);
-		}
-	}
-	addSubcommandGroups(groups) {
-		for (const group of groups) {
-			let subcommandGroup = new SlashCommandSubcommandGroupBuilder().setName(group.name).setDescription(group.description);
-			if (group.subcommands?.length > 0) this.addSubcommands(subcommandGroup, group.subcommands);
-			this.data.addSubcommandGroup(subcommandGroup);
-		}
-	}
+    constructor(id, options) {
+        this.id = id;
+        this.data = new Discord.SlashCommandBuilder();
+        this.data.setName(options.name);
+        this.data.setNameLocalizations(options.nameLocalizations || null);
+        this.data.setDescription(options.description);
+        this.data.setDescriptionLocalizations(options.descriptionLocalizations || null);
+        this.data.setDMPermission(options.permissions?.dm || null);
+        if (options.args && options?.args?.length > 0) {
+            this.addArguments(this.data, options.args);
+        }
+        if (options.subcommands && options?.subcommands?.length > 0) {
+            this.addSubcommands(this.data, options.subcommands);
+        }
+        if (options.groups && options?.groups?.length > 0) {
+            this.addSubcommandGroups(options.groups);
+        }
+        options = z
+            .object({
+            name: z.string(),
+            description: z.string(),
+            usage: z.string().or(z.null()).default(null),
+            info: z.string().or(z.null()).default(null),
+            category: z.string().or(z.null()).default(null),
+            number: z.number().or(z.null()).default(null),
+            channelType: z.array(z.number()).or(z.null()).default(null),
+            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([]),
+            })
+                .default({}),
+            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([]),
+            })
+                .default({}),
+            permissions: z
+                .object({
+                user: z.array(z.string()).default([]),
+                client: z.array(z.string()).default([]),
+                dm: z.boolean().default(true),
+            })
+                .default({}),
+            defer: z
+                .object({
+                reply: z.boolean().default(false),
+                ephemeral: z.boolean().default(false),
+                fetch: z.boolean().default(false),
+            })
+                .default({}),
+        })
+            .parse(options);
+        this.name = options.name;
+        this.description = options.description;
+        this.usage = options.usage;
+        this.info = options.info;
+        this.category = options.category;
+        this.cooldown = options.cooldown;
+        this.ignore = options.ignore;
+        this.strict = options.strict;
+        this.permissions = options.permissions;
+        this.defer = options.defer;
+        this.client = this.client;
+    }
+    /**
+     * @description autocomplete let's you add choices to string option arguments
+     * @param interaction - The interaction event emitted on this command
+     * @param focused - The command option that is in focus
+     * @param options - The full list of options on the command
+     */
+    async autocomplete(interaction, focused, options) { }
+    /**
+     * @description Checks for conditions before running the command
+     * @param interaction - The interaction event emitted on this command
+     * @param options - The args, group and subcommand parsed on this command
+     */
+    async conditions(interaction, { args, subcommand, group }) { }
+    /**
+     * @description Runs the execution rule
+     * @param interaction - The interaction event emitted on this command
+     * @param options - The args, group and subcommand parsed on this command
+     */
+    async exec(interaction, { args, subcommand, group }) {
+        new XernerxLog(this.client).error(`${this.id} doesn't have an execution rule.`);
+        return await this.client.emit('commandError', interaction, `${this.id} doesn't have an execution rule.`, this, this.filetype);
+    }
+    addArguments(command, args) {
+        for (const argument of args) {
+            let slashCommandArgumentType = `${argument.type.charAt(0).toUpperCase()}${argument.type.slice(1).toLowerCase()}`;
+            command[`add${slashCommandArgumentType}Option`]((option) => {
+                option
+                    .setName(argument.name)
+                    .setDescription(argument.description)
+                    .setRequired(argument.required || false);
+                if (slashCommandArgumentType === 'String') {
+                    if (argument.choices)
+                        option.setChoices(...argument.choices.map((choices) => {
+                            return { name: Object.keys(choices).at(0), value: Object.values(choices).at(0) };
+                        }));
+                    option.setAutocomplete(argument.autocomplete || false);
+                }
+                return option;
+            });
+        }
+    }
+    addSubcommands(method, subcommands) {
+        for (const subcommand of subcommands) {
+            let sub = new SlashCommandSubcommandBuilder().setName(subcommand.name).setDescription(subcommand.description);
+            if (subcommand.args && subcommand?.args?.length > 0)
+                this.addArguments(sub, subcommand.args);
+            method.addSubcommand(sub);
+        }
+    }
+    addSubcommandGroups(groups) {
+        for (const group of groups) {
+            let subcommandGroup = new SlashCommandSubcommandGroupBuilder().setName(group.name).setDescription(group.description);
+            if (group.subcommands?.length > 0)
+                this.addSubcommands(subcommandGroup, group.subcommands);
+            this.data.addSubcommandGroup(subcommandGroup);
+        }
+    }
 }
-//# sourceMappingURL=XernerxSlashCommand.js.map
+//# sourceMappingURL=XernerxSlashCommand.js.map

package/dist/client/XernerxClient.d.ts

@@ -4,52 +4,44 @@ import { XernerxOptions, ModuleOptions, XernerxCommands, XernerxCache } from '..
 import ClientUtil from '../utils/ClientUtil.js';
 import { XernerxInhibitor, XernerxEvent } from '../main.js';
 export default class XernerxClient<T = unknown> extends Client {
-	readonly settings: {
-		ownerId: (string | string[]) & (string | string[] | undefined);
-		local: string;
-		global?: boolean | undefined;
-		permissions?:
-			| {
-					client: string[];
-					user: string[];
-					dm: boolean;
-			  }
-			| undefined;
-		ignore?:
-			| {
-					owner: boolean;
-					self: boolean;
-					bots: boolean;
-					system: boolean;
-					users: string[];
-					channels: string[];
-					guilds: string[];
-			  }
-			| undefined;
-		log?:
-			| {
-					ready: boolean;
-					error: boolean;
-					info: boolean;
-					table: string[] | null;
-			  }
-			| undefined;
-		cooldown?:
-			| {
-					command: number;
-					cache: number;
-			  }
-			| undefined;
-	};
-	readonly config: NonNullable<T> | null;
-	readonly commands: XernerxCommands;
-	readonly events: Collection<string, XernerxEvent>;
-	readonly inhibitors: Collection<string, XernerxInhibitor>;
-	readonly modules: ModuleOptions;
-	readonly util: ClientUtil;
-	readonly stats: Record<string, number>;
-	readonly cache: XernerxCache;
-	constructor(discordOptions: ClientOptions, xernerxOptions: XernerxOptions, config?: T);
-	connect(token: string): Promise<string>;
+    readonly settings: {
+        ownerId: (string | string[]) & (string | string[] | undefined);
+        local: string;
+        global?: boolean | undefined;
+        permissions?: {
+            client: string[];
+            user: string[];
+            dm: boolean;
+        } | undefined;
+        ignore?: {
+            owner: boolean;
+            self: boolean;
+            bots: boolean;
+            system: boolean;
+            users: string[];
+            channels: string[];
+            guilds: string[];
+        } | undefined;
+        log?: {
+            ready: boolean;
+            error: boolean;
+            info: boolean;
+            table: string[] | null;
+        } | undefined;
+        cooldown?: {
+            command: number;
+            cache: number;
+        } | undefined;
+    };
+    readonly config: NonNullable<T> | null;
+    readonly commands: XernerxCommands;
+    readonly events: Collection<string, XernerxEvent>;
+    readonly inhibitors: Collection<string, XernerxInhibitor>;
+    readonly modules: ModuleOptions;
+    readonly util: ClientUtil;
+    readonly stats: Record<string, number>;
+    readonly cache: XernerxCache;
+    constructor(discordOptions: ClientOptions, xernerxOptions: XernerxOptions, config?: T);
+    connect(token: string): Promise<string>;
 }
-//# sourceMappingURL=XernerxClient.d.ts.map
+//# sourceMappingURL=XernerxClient.d.ts.map