xernerx 3.4.3 → 3.5.1

package/dist/build/MessageCommandBuilder.js

@@ -1,78 +1,90 @@
-import { s } from '@sapphire/shapeshift';
-import XernerxClient from '../client/XernerxClient.js';
-/**
- * @description - The command builder for message commands.
- * @param {String} id - The unique ID of the command.
- * @param {MessageCommandOptions} options - The command options.
- */
-export default class MessageCommandBuilder {
-    id;
-    name;
-    aliases;
-    description;
-    info;
-    category;
-    prefix;
-    regex;
-    owner;
-    channelType;
-    separator;
-    cooldown;
-    ignoreOwner;
-    channels;
-    guilds;
-    userPermissions;
-    clientPermissions;
-    args;
-    client;
-    constructor(id, options) {
-        this.id = id;
-        s.object({
-            name: s.string,
-            aliases: s.union(s.array(s.string).unique, s.string).optional,
-            description: s.string.optional,
-            info: s.string.optional,
-            category: s.string.optional,
-            prefix: s.union(s.array(s.string).unique, s.string).optional,
-            owner: s.boolean.optional,
-            channelType: s.union(s.number, s.array(s.number)).optional,
-            separator: s.string.optional,
-            cooldown: s.number.optional,
-            ignoreOwner: s.boolean.optional,
-            channels: s.array(s.string).unique.optional,
-            guilds: s.array(s.string).unique.optional,
-            userPermissions: s.array(s.bigint).unique.optional,
-            clientPermissions: s.array(s.bigint).unique.optional,
-        }).parse(options);
-        this.name = options.name;
-        this.aliases = options.aliases;
-        this.description = options.description;
-        this.info = options.info;
-        this.category = options.category;
-        this.prefix = options.prefix ? (Array.isArray(options.prefix) ? options.prefix : [options.prefix]) : [];
-        this.regex = options.regex;
-        this.owner = options.owner || false;
-        this.channelType = options.channelType;
-        this.separator = options.separator || ' ';
-        this.cooldown = options.cooldown || 0;
-        this.ignoreOwner = options.ignoreOwner || false;
-        this.channels = options.channels || [];
-        this.guilds = options.guilds || [];
-        this.userPermissions = options.userPermissions || [];
-        this.clientPermissions = options.clientPermissions || [];
-        this.args = options.args || [];
-        this.client = XernerxClient;
-    }
-    /**
-     * @param {Message} message - The Discord message event data.
-     * @param {object} args - The arguments you created.
-     * @description make any preconditions here.
-     */
-    async conditions(message, args) { }
-    /**
-     * @param {Message} message - The Discord message event data.
-     * @param {object} args - The arguments you created.
-     * @description Make your custom command here.
-     */
-    async exec(message, args) { }
-}
+import { z } from 'zod';
+import XernerxClient from '../client/XernerxClient.js';
+/**
+ * @description - The command builder for message commands.
+ * @param {String} id - The unique ID of the command.
+ * @param {MessageCommandOptions} options - The command options.
+ */
+export default class MessageCommandBuilder {
+    id;
+    name;
+    aliases;
+    separator;
+    description;
+    info;
+    category;
+    prefix;
+    regex;
+    channelType;
+    ignore;
+    strict;
+    permissions;
+    cooldown;
+    args;
+    client;
+    constructor(id, options) {
+        this.id = id;
+        z.object({
+            name: z.string(),
+            aliases: z.array(z.string()).optional(),
+            separator: z.string().min(1).max(1).optional(),
+            description: z.string().optional(),
+            info: z.string().optional(),
+            category: z.string().optional(),
+            prefix: z.array(z.string()).or(z.string()).optional(),
+            regex: z.unknown(),
+            channelType: z.array(z.number()).or(z.number()).optional(),
+            cooldown: z.number().optional(),
+            ignore: z
+                .object({
+                owners: z.boolean().optional(),
+                users: z.array(z.string()).or(z.string()).optional(),
+                channels: z.array(z.string()).or(z.string()).optional(),
+                guilds: z.array(z.string()).or(z.string()).optional(),
+            })
+                .optional(),
+            strict: z
+                .object({
+                owners: z.boolean().optional(),
+                users: z.array(z.string()).or(z.string()).optional(),
+                channels: z.array(z.string()).or(z.string()).optional(),
+                guilds: z.array(z.string()).or(z.string()).optional(),
+            })
+                .optional(),
+            permissions: z
+                .object({
+                client: z.array(z.string()).optional(),
+                users: z.array(z.string()).optional(),
+                dm: z.boolean().optional(),
+            })
+                .optional(),
+        }).parse(options);
+        this.name = options.name;
+        this.aliases = options.aliases;
+        this.separator = options.separator || ' ';
+        this.description = options.description;
+        this.info = options.info;
+        this.category = options.category;
+        this.prefix = options.prefix ? (Array.isArray(options.prefix) ? options.prefix : [options.prefix]) : [];
+        this.regex = options.regex;
+        this.channelType = options.channelType;
+        this.ignore = options.ignore;
+        this.strict = options.strict;
+        this.permissions = options.permissions;
+        this.cooldown = options.cooldown || 0;
+        this.args = options.args || [];
+        this.client = XernerxClient;
+    }
+    /**
+     * @param {Message} message - The Discord message event data.
+     * @param {object} args - The arguments you created.
+     * @description make any preconditions here.
+     */
+    async conditions(message, args) { }
+    /**
+     * @param {Message} message - The Discord message event data.
+     * @param {object} args - The arguments you created.
+     * @description Make your custom command here.
+     */
+    async exec(message, args) { }
+}

package/dist/build/SlashCommandBuilder.d.ts

@@ -1,40 +1,58 @@
-import Discord, { ChannelType, Interaction } from 'discord.js';
-import { SlashCommandOptions } from '../types/options.js';
-import XernerxClient from '../client/XernerxClient.js';
-/**
- * @description - The command builder for slash commands.
- * @param {String} id - The unique ID of the command.
- * @param {SlashCommandOptions} options - The command options.
- */
-export default class SlashCommandBuilder {
-    id: string;
-    data: Discord.SlashCommandBuilder;
-    name: string;
-    description: string;
-    info?: string;
-    category?: string;
-    owner?: boolean;
-    channelType?: ChannelType | ChannelType[];
-    separator?: string;
-    cooldown?: number;
-    ignoreOwner?: boolean;
-    channels?: string[];
-    guilds?: string[];
-    userPermissions?: bigint[];
-    clientPermissions?: bigint[];
-    args?: object[];
-    subcommands?: object[];
-    groups?: object[];
-    defer?: {
-        reply?: boolean;
-        ephemeral?: boolean;
-        fetchReply?: boolean;
-    };
-    client: XernerxClient | object;
-    constructor(id: string, options: SlashCommandOptions);
-    conditions(interaction: Interaction): Promise<void>;
-    exec(interaction: Interaction): Promise<void>;
-    private addArgs;
-    private addSubcommands;
-    private addSubcommandGroups;
-}
+import Discord, { Interaction } from 'discord.js';
+import { SlashCommandOptions } from '../types/options.js';
+import XernerxClient from '../client/XernerxClient.js';
+/**
+ * @description - The command builder for slash commands.
+ * @param {String} id - The unique ID of the command.
+ * @param {SlashCommandOptions} options - The command options.
+ */
+export default class SlashCommandBuilder {
+    id: string;
+    data: Discord.SlashCommandBuilder;
+    name: string;
+    description: string;
+    info: string | undefined;
+    category: string | undefined;
+    channelType: Discord.ChannelType | undefined;
+    cooldown: number | undefined;
+    ignore: {
+        owner?: boolean | undefined;
+        users?: string[] | undefined;
+        channels?: string[] | undefined;
+        guilds?: string[] | undefined;
+    } | undefined;
+    strict: {
+        owner?: boolean | undefined;
+        users?: string[] | undefined;
+        channels?: string[] | undefined;
+        guilds?: string[] | undefined;
+    } | undefined;
+    permissions: {
+        client?: string[] | undefined;
+        users?: string[] | undefined;
+        dm?: boolean | undefined;
+    };
+    args?: object[];
+    subcommands?: object[];
+    groups?: object[];
+    defer: {
+        reply?: boolean | undefined;
+        ephemeral?: boolean | undefined;
+        fetchReply?: boolean | undefined;
+    } | undefined;
+    client: typeof XernerxClient;
+    constructor(id: string, options: SlashCommandOptions);
+    /**
+     * TODO - update description
+     * @param interaction
+     */
+    conditions(interaction: Interaction): Promise<void>;
+    /**
+     * TODO - update description
+     * @param interaction
+     */
+    exec(interaction: Interaction): Promise<void>;
+    private addArgs;
+    private addSubcommands;
+    private addSubcommandGroups;
+}

package/dist/build/SlashCommandBuilder.js

@@ -1,118 +1,125 @@
-import Discord, { SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder, } from 'discord.js';
-import { s } from '@sapphire/shapeshift';
-import XernerxError from '../tools/XernerxError.js';
-import XernerxClient from '../client/XernerxClient.js';
-/**
- * @description - The command builder for slash commands.
- * @param {String} id - The unique ID of the command.
- * @param {SlashCommandOptions} options - The command options.
- */
-export default class SlashCommandBuilder {
-    id;
-    data;
-    name;
-    description;
-    info;
-    category;
-    owner;
-    channelType;
-    separator;
-    cooldown;
-    ignoreOwner;
-    channels;
-    guilds;
-    userPermissions;
-    clientPermissions;
-    args;
-    subcommands;
-    groups;
-    defer;
-    client;
-    constructor(id, options) {
-        this.id = id;
-        this.data = new Discord.SlashCommandBuilder().setName(options.name).setDescription(options.description);
-        if (options.args && options?.args?.length > 0) {
-            this.addArgs(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);
-        }
-        s.object({
-            info: s.string.optional,
-            category: s.string.optional,
-            owner: s.boolean.optional,
-            channelType: s.union(s.number, s.array(s.number)).optional,
-            separator: s.string.optional,
-            cooldown: s.number.optional,
-            ignoreOwner: s.boolean.optional,
-            channels: s.array(s.string).optional,
-            guilds: s.array(s.string).optional,
-            userPermissions: s.array(s.bigint).optional,
-            clientPermissions: s.array(s.bigint).optional,
-            defer: s.object({
-                reply: s.boolean.optional,
-                ephemeral: s.boolean.optional,
-                fetchReply: s.boolean.optional,
-            }).optional,
-        });
-        this.name = options.name;
-        this.description = options.description;
-        this.info = options.info;
-        this.category = options.category;
-        this.owner = options.owner;
-        this.channelType = options.channelType;
-        this.separator = options.separator;
-        this.cooldown = options.cooldown;
-        this.ignoreOwner = options.ignoreOwner;
-        this.channels = options.channels;
-        this.guilds = options.guilds;
-        this.userPermissions = options.userPermissions;
-        this.clientPermissions = options.clientPermissions;
-        this.defer = options.defer;
-        this.client = XernerxClient;
-        this.conditions = this.conditions;
-        this.exec = this.exec;
-    }
-    async conditions(interaction) { }
-    async exec(interaction) { }
-    addArgs(command, args) {
-        const types = ['boolean', 'integer', 'number', 'string', 'user', 'role', 'channel', 'mentionable'];
-        for (const argument of args) {
-            if (!types.includes(argument.type.toLowerCase()))
-                throw new XernerxError(`Expected one of ${types.join(', ')}, received ${argument.type} instead.`);
-            let slashArgumentType = `${argument.type.slice(0, 1).toUpperCase()}${argument.type
-                .slice(1)
-                .toLowerCase()}`;
-            command[`add${slashArgumentType}Option`]((option) => {
-                option
-                    .setName(argument.name)
-                    .setDescription(argument.description)
-                    .setRequired(argument.required || false);
-                if (argument.choices)
-                    option.setChoices(...argument?.choices);
-                return option;
-            });
-        }
-    }
-    addSubcommands(method, subcommands) {
-        for (const subcommand of subcommands) {
-            let sub = new SlashCommandSubcommandBuilder().setName(subcommand.name).setDescription(subcommand.description);
-            if (subcommand.args?.length > 0)
-                this.addArgs(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);
-        }
-    }
-}
+import Discord, { SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder } from 'discord.js';
+import { z } from 'zod';
+import XernerxError from '../tools/XernerxError.js';
+import XernerxClient from '../client/XernerxClient.js';
+/**
+ * @description - The command builder for slash commands.
+ * @param {String} id - The unique ID of the command.
+ * @param {SlashCommandOptions} options - The command options.
+ */
+export default class SlashCommandBuilder {
+    id;
+    data;
+    name;
+    description;
+    info;
+    category;
+    channelType;
+    cooldown;
+    ignore;
+    strict;
+    permissions;
+    args;
+    subcommands;
+    groups;
+    defer;
+    client;
+    constructor(id, options) {
+        this.id = id;
+        this.data = new Discord.SlashCommandBuilder().setName(options.name).setDescription(options.description);
+        if (options.args && options?.args?.length > 0) {
+            this.addArgs(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);
+        }
+        z.object({
+            description: z.string(),
+            info: z.string(),
+            category: z.string(),
+            channelType: z.array(z.number()).or(z.number()),
+            cooldown: z.number(),
+            ignore: z.object({
+                owner: z.boolean(),
+                users: z.array(z.string()),
+                channels: z.array(z.string()),
+                guilds: z.array(z.string()),
+            }),
+            strict: z.object({
+                owner: z.boolean(),
+                users: z.array(z.string()),
+                channels: z.array(z.string()),
+                guilds: z.array(z.string()),
+            }),
+            permissions: z.object({
+                client: z.array(z.string()),
+                users: z.array(z.string()),
+                dm: z.boolean(),
+            }),
+            defer: z.object({
+                reply: z.boolean(),
+                ephemeral: z.boolean(),
+                fetch: z.boolean(),
+            }),
+        })
+            .deepPartial()
+            .parse(options);
+        this.name = options.name;
+        this.description = options.description;
+        this.info = options.info;
+        this.category = options.category;
+        this.channelType = options.channelType;
+        this.cooldown = options.cooldown;
+        this.ignore = options.ignore;
+        this.strict = options.strict;
+        this.permissions = options.permissions;
+        this.defer = options.defer;
+        this.client = XernerxClient;
+    }
+    /**
+     * TODO - update description
+     * @param interaction
+     */
+    async conditions(interaction) { }
+    /**
+     * TODO - update description
+     * @param interaction
+     */
+    async exec(interaction) { }
+    addArgs(command, args) {
+        const types = ['boolean', 'integer', 'number', 'string', 'user', 'role', 'channel', 'mentionable'];
+        for (const argument of args) {
+            if (!types.includes(argument.type.toLowerCase()))
+                throw new XernerxError(`Expected one of ${types.join(', ')}, received ${argument.type} instead.`);
+            let slashArgumentType = `${argument.type.slice(0, 1).toUpperCase()}${argument.type.slice(1).toLowerCase()}`;
+            command[`add${slashArgumentType}Option`]((option) => {
+                option
+                    .setName(argument.name)
+                    .setDescription(argument.description)
+                    .setRequired(argument.required || false);
+                if (argument.choices)
+                    option.setChoices(...argument?.choices);
+                return option;
+            });
+        }
+    }
+    addSubcommands(method, subcommands) {
+        for (const subcommand of subcommands) {
+            let sub = new SlashCommandSubcommandBuilder().setName(subcommand.name).setDescription(subcommand.description);
+            if (subcommand.args?.length > 0)
+                this.addArgs(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);
+        }
+    }
+}

package/dist/client/XernerxClient.d.ts

@@ -1,28 +1,28 @@
-import { Client, Collection } from 'discord.js';
-import ExtensionBuilder from 'xernerx-extension-builder';
-import { ClientUtil } from '../utils/ClientUtil.js';
-import { ClientOptions, DiscordOptions, ExtensionOptions, HandlerOptions } from '../types/options.js';
-import { ClientCache, ClientCommands, ClientModules } from '../types/interfaces.js';
-import EventBuilder from '../build/EventBuilder.js';
-import InhibitorBuilder from '../build/InhibitorBuilder.js';
-/**
- * @description - The Client.
- * @param {DiscordOptions} discordOptions - The options for discord.js.
- * @param {ClientOptions} clientOptions - The options for the Xernerx Client.
- * @extends {Client}
- */
-export default class XernerxClient extends Client {
-    settings: ClientOptions;
-    commands: ClientCommands;
-    cache: ClientCache;
-    modules: ClientModules;
-    util: ClientUtil;
-    handlerOptions: HandlerOptions;
-    events: Collection<string, EventBuilder>;
-    extensions: Record<string, ExtensionBuilder>;
-    inhibitors: Collection<string, InhibitorBuilder>;
-    config: object;
-    constructor(discordOptions: DiscordOptions, clientOptions: ClientOptions, config?: object);
-    register(token: string): void;
-    loadAllExtensions(options: ExtensionOptions): Promise<void>;
-}
+import { Client, Collection } from 'discord.js';
+import ExtensionBuilder from 'xernerx-extension-builder';
+import { ClientUtil } from '../utils/ClientUtil.js';
+import { ClientOptions, DiscordOptions, ExtensionOptions, HandlerOptions } from '../types/options.js';
+import { ClientCache, ClientCommands, ClientModules } from '../types/interfaces.js';
+import EventBuilder from '../build/EventBuilder.js';
+import InhibitorBuilder from '../build/InhibitorBuilder.js';
+/**
+ * @description - The Client.
+ * @param {DiscordOptions} discordOptions - The options for discord.js.
+ * @param {ClientOptions} clientOptions - The options for the Xernerx Client.
+ * @extends {Client}
+ */
+export default class XernerxClient extends Client {
+    settings: ClientOptions;
+    commands: ClientCommands;
+    cache: ClientCache;
+    modules: ClientModules;
+    util: ClientUtil;
+    handlerOptions: HandlerOptions;
+    events: Collection<string, EventBuilder>;
+    extensions: Record<string, ExtensionBuilder>;
+    inhibitors: Collection<string, InhibitorBuilder>;
+    config: object;
+    constructor(discordOptions: DiscordOptions, clientOptions: ClientOptions, config?: object);
+    register(token: string): void;
+    loadAllExtensions(options: ExtensionOptions): Promise<void>;
+}