xernerx 4.5.5 → 4.5.7

package/dist/build/XernerxSlashCommand.d.ts

@@ -1,62 +1,64 @@
+/** @format */
+
 import Discord from 'discord.js';
 import XernerxClient from '../client/XernerxClient.js';
 import { XernerxMessageContextInteraction, XernerxSlashInteraction, XernerxUserContextInteraction } from '../types/extenders.js';
 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('../types/types.js').PermissionNames[] | undefined;
-              client?: string[] | import('../types/types.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: typeof XernerxClient;
-    constructor(id: string, options: SlashCommandOptions);
-    autocomplete<T>(interaction: XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>, focused: T, options: T[]): Promise<void | any | T>;
-    conditions<T>(
-        interaction: XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>,
-        { args, subcommand, group }: SlashCommandArguments
-    ): Promise<void | any | T>;
-    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('../types/types.js').PermissionNames[] | undefined;
+				client?: string[] | import('../types/types.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: typeof XernerxClient;
+	constructor(id: string, options: SlashCommandOptions);
+	autocomplete<T>(interaction: XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>, focused: T, options: T[]): Promise<void | any | T>;
+	conditions<T>(
+		interaction: XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>,
+		{ args, subcommand, group }: SlashCommandArguments
+	): Promise<void | any | T>;
+	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

package/dist/build/XernerxSlashCommand.js

@@ -1,114 +1,116 @@
+/** @format */
+
 import Discord, { SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder } from 'discord.js';
 import { z } from 'zod';
 import XernerxClient from '../client/XernerxClient.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 = XernerxClient;
-    }
-    async autocomplete(interaction, focused, options) {}
-    async conditions(interaction, { args, subcommand, group }) {}
-    async exec(interaction, { args, subcommand, group }) {}
-    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 = XernerxClient;
+	}
+	async autocomplete(interaction, focused, options) {}
+	async conditions(interaction, { args, subcommand, group }) {}
+	async exec(interaction, { args, subcommand, group }) {}
+	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

package/dist/client/XernerxClient.d.ts

@@ -1,51 +1,53 @@
+/** @format */
+
 import { Client, ClientOptions, Collection } from 'discord.js';
 import { XernerxOptions, ModuleOptions, XernerxCommands, XernerxCache } from '../types/interfaces.js';
 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;
-                  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;
+					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

package/dist/client/XernerxClient.js

@@ -1,3 +1,5 @@
+/** @format */
+
 import { Client, Collection } from 'discord.js';
 import { z } from 'zod';
 import CommandHandler from '../handlers/CommandHandler.js';
@@ -9,78 +11,78 @@ import ClientUtil from '../utils/ClientUtil.js';
 import ExtensionHandler from '../handlers/ExtensionHandler.js';
 import deploy from '../functions/deploy.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([]),
-                permissions: z
-                    .object({
-                        client: z.array(z.string()).default([]),
-                        user: z.array(z.string()).default([]),
-                        dm: z.boolean().default(false),
-                    })
-                    .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([]),
-                    })
-                    .optional(),
-                log: z
-                    .object({
-                        ready: z.boolean().default(false),
-                        info: z.boolean().default(false),
-                        error: z.boolean().default(false),
-                        table: z.array(z.string()).or(z.null()).default(null),
-                    })
-                    .optional(),
-                cooldown: z
-                    .object({
-                        command: z.number().default(0),
-                        cache: z.number().default(0),
-                    })
-                    .optional(),
-            })
-            .parse(xernerxOptions);
-        this.config = config || null;
-        this.commands = {
-            message: new Collection(),
-            slash: new Collection(),
-            context: new Collection(),
-        };
-        this.events = new Collection();
-        this.inhibitors = new Collection();
-        this.modules = {
-            options: {},
-            commandHandler: new CommandHandler(this),
-            eventHandler: new EventHandler(this),
-            inhibitorHandler: new InhibitorHandler(this),
-            webhookHandler: new WebhookHandler(this),
-            extensionHandler: new ExtensionHandler(this),
-        };
-        this.util = new ClientUtil(this);
-        this.stats = {
-            guildCount: this.guilds.cache.size,
-            userCount: 0,
-            shardId: 0,
-            shardCount: 1,
-        };
-        this.cache = {
-            messages: new Collection(),
-            cooldowns: new Collection(),
-        };
-        return this;
-    }
-    async connect(token) {
-        const login = this.login(token);
-        deploy(this);
-        new XernerxLog(this).ready();
-        return login;
-    }
+	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([]),
+				permissions: z
+					.object({
+						client: z.array(z.string()).default([]),
+						user: z.array(z.string()).default([]),
+						dm: z.boolean().default(false),
+					})
+					.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([]),
+					})
+					.optional(),
+				log: z
+					.object({
+						ready: z.boolean().default(false),
+						info: z.boolean().default(false),
+						error: z.boolean().default(false),
+						table: z.array(z.string()).or(z.null()).default(null),
+					})
+					.optional(),
+				cooldown: z
+					.object({
+						command: z.number().default(0),
+						cache: z.number().default(0),
+					})
+					.optional(),
+			})
+			.parse(xernerxOptions);
+		this.config = config || null;
+		this.commands = {
+			message: new Collection(),
+			slash: new Collection(),
+			context: new Collection(),
+		};
+		this.events = new Collection();
+		this.inhibitors = new Collection();
+		this.modules = {
+			options: {},
+			commandHandler: new CommandHandler(this),
+			eventHandler: new EventHandler(this),
+			inhibitorHandler: new InhibitorHandler(this),
+			webhookHandler: new WebhookHandler(this),
+			extensionHandler: new ExtensionHandler(this),
+		};
+		this.util = new ClientUtil(this);
+		this.stats = {
+			guildCount: this.guilds.cache.size,
+			userCount: 0,
+			shardId: 0,
+			shardCount: 1,
+		};
+		this.cache = {
+			messages: new Collection(),
+			cooldowns: new Collection(),
+		};
+		return this;
+	}
+	async connect(token) {
+		const login = this.login(token);
+		deploy(this);
+		new XernerxLog(this).ready();
+		return login;
+	}
 }
 //# sourceMappingURL=XernerxClient.js.map

package/dist/client/XernerxShardClient.d.ts

@@ -1,17 +1,19 @@
+/** @format */
+
 import { ShardingManager, ShardingManagerOptions, ClientUser } from 'discord.js';
 interface XernerxOptions {
-    log?: {
-        info?: boolean;
-    };
+	log?: {
+		info?: boolean;
+	};
 }
 export default class XernerxShardClient extends ShardingManager {
-    readonly stats: {
-        guildCount: number;
-        userCount: number;
-        shardCount: number;
-    };
-    user: ClientUser | null;
-    constructor(file: string, discordOptions: ShardingManagerOptions, xernerxOptions?: XernerxOptions);
+	readonly stats: {
+		guildCount: number;
+		userCount: number;
+		shardCount: number;
+	};
+	user: ClientUser | null;
+	constructor(file: string, discordOptions: ShardingManagerOptions, xernerxOptions?: XernerxOptions);
 }
 export {};
 //# sourceMappingURL=XernerxShardClient.d.ts.map