xernerx 4.17.9 → 5.0.2

package/dist/build/XernerxEvent.d.ts

@@ -1,21 +0,0 @@
-/** @format */
-import { XernerxEventOptions } from '../types/interfaces.js';
-import { XernerxClientEvents, XernerxClientType } from '../types/extenders.js';
-import { Awaitable, RestEvents } from 'discord.js';
-/**
- * @description - The event builder for  events.
- * @param {String} id - The unique ID of the event.
- * @param {EventOptions} options - The event options.
- */
-export default class XernerxEvent<Event extends keyof XernerxClientEvents> {
-    readonly id: string;
-    readonly name: Event | keyof RestEvents | string;
-    readonly emitter?: 'client' | 'process' | 'rest' | string;
-    readonly type?: 'discord' | 'node' | string;
-    readonly once?: boolean;
-    readonly filetype: 'Event';
-    readonly filepath: string;
-    readonly client: XernerxClientType;
-    constructor(id: string, options: XernerxEventOptions);
-    run<T = void>(...args: XernerxClientEvents[Event]): Promise<Awaitable<void | any | T>>;
-}

package/dist/build/XernerxEvent.js

@@ -1,27 +0,0 @@
-/** @format */
-import { z } from 'zod';
-import XernerxLog from '../tools/XernerxLog.js';
-/**
- * @description - The event builder for  events.
- * @param {String} id - The unique ID of the event.
- * @param {EventOptions} options - The event options.
- */
-export default class XernerxEvent {
-    constructor(id, options) {
-        this.id = id;
-        z.object({
-            name: z.string(),
-            emitter: z.string().optional(),
-            type: z.string().optional(),
-            once: z.boolean().optional(),
-        }).parse(options);
-        this.name = options.name;
-        this.emitter = options.emitter || 'client';
-        this.type = options.type || 'discord';
-        this.once = options.once || false;
-        this.client = this.client;
-    }
-    async run(...args) {
-        return new XernerxLog(this.client).error(`${this.id} doesn't have a run rule.`);
-    }
-}

package/dist/build/XernerxInhibitor.d.ts

@@ -1,29 +0,0 @@
-/** @format */
-import { XernerxInhibitorOptions, MessageCommandArguments, SlashCommandArguments, ContextCommandArguments } from '../types/interfaces.js';
-import { InhibitorType, XernerxInteraction } from '../types/types.js';
-import { XernerxClientType, XernerxMessage, XernerxMessageContextInteraction, XernerxSlashInteraction, XernerxUserContextInteraction } from '../types/extenders.js';
-import XernerxContextCommand from '../build/XernerxContextCommand.js';
-import XernerxSlashCommand from '../build/XernerxSlashCommand.js';
-import XernerxMessageCommand from '../build/XernerxMessageCommand.js';
-/**
- * @description - The inhibitor builder for inhibitors.
- * @param {String} id - The unique ID of the inhibitor.
- * @param {InhibitorOptions} options - The inhibitor options.
- */
-export default class XernerxInhibitor {
-    readonly id: string;
-    readonly name: string;
-    readonly type: InhibitorType;
-    readonly filetype: 'Inhibitor';
-    readonly filepath: string;
-    readonly client: XernerxClientType;
-    constructor(id: string, options: XernerxInhibitorOptions);
-    pre(interaction: XernerxMessage | XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>, args: any): void;
-    /**
-     * @description The check rule
-     * @param interaction - The interaction with the inhibitor, can be message and interaction
-     * @param args - The arguments parsed with this command
-     */
-    check<T extends XernerxMessage | XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>>(interaction: XernerxMessage | XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>, args: (T extends XernerxMessage ? MessageCommandArguments : T extends XernerxSlashInteraction ? SlashCommandArguments : T extends XernerxUserContextInteraction ? ContextCommandArguments<'user' | 'message'> : never) | null, command: XernerxSlashCommand | XernerxMessageCommand | XernerxContextCommand): Promise<any>;
-    post<T extends XernerxMessage | XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>>(interaction: XernerxMessage | XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>, args: (T extends XernerxMessage ? MessageCommandArguments : T extends XernerxSlashInteraction ? SlashCommandArguments : T extends XernerxUserContextInteraction ? ContextCommandArguments<'user' | 'message'> : never) | null, command: XernerxSlashCommand | XernerxMessageCommand | XernerxContextCommand): Promise<any>;
-}

package/dist/build/XernerxInhibitor.js

@@ -1,27 +0,0 @@
-/** @format */
-import { z } from 'zod';
-/**
- * @description - The inhibitor builder for inhibitors.
- * @param {String} id - The unique ID of the inhibitor.
- * @param {InhibitorOptions} options - The inhibitor options.
- */
-export default class XernerxInhibitor {
-    constructor(id, options) {
-        this.id = id;
-        z.object({
-            name: z.string(),
-            type: z.string(),
-        }).parse(options);
-        this.name = options.name;
-        this.type = options.type;
-        this.client = this.client;
-    }
-    pre(interaction, args) { }
-    /**
-     * @description The check rule
-     * @param interaction - The interaction with the inhibitor, can be message and interaction
-     * @param args - The arguments parsed with this command
-     */
-    async check(interaction, args, command) { }
-    async post(interaction, args, command) { }
-}

package/dist/build/XernerxMessageCommand.d.ts

@@ -1,58 +0,0 @@
-/** @format */
-import { XernerxClientType, XernerxMessage } from '../types/extenders.js';
-import { MessageCommandArguments, MessageCommandOptions } from '../types/interfaces.js';
-import MessageUtil from '../utils/MessageUtil.js';
-export default class XernerxMessageCommand {
-    readonly id: string;
-    readonly name: string;
-    readonly aliases: string[] | undefined;
-    readonly regex: RegExp | undefined;
-    readonly prefix: string | string[] | undefined;
-    readonly description: string | null | undefined;
-    readonly usage: string | null | undefined;
-    readonly info: string | null | undefined;
-    readonly separator: string | undefined;
-    readonly args: import("../types/interfaces.js").MessageCommandArgumentOptions[] | undefined;
-    readonly flags: import("../types/interfaces.js").MessageCommandFlagOptions[] | undefined;
-    readonly category: string | null | undefined;
-    readonly cooldown: number | null | undefined;
-    readonly channel: ("GuildText" | "DM" | "GuildVoice" | "GroupDM" | "GuildCategory" | "GuildAnnouncement" | "AnnouncementThread" | "PublicThread" | "PrivateThread" | "GuildStageVoice" | "GuildDirectory" | "GuildForum" | "GuildMedia" | "GuildNews" | "GuildNewsThread" | "GuildPublicThread" | "GuildPrivateThread")[] | null;
-    readonly global: boolean | undefined;
-    readonly ignore: {
-        owner?: boolean;
-        users?: Array<string>;
-        channels?: Array<string>;
-        guilds?: Array<string>;
-        voice?: boolean;
-    } | undefined;
-    readonly strict: {
-        owner?: boolean;
-        users?: Array<string>;
-        channels?: Array<string>;
-        guilds?: Array<string>;
-        voice?: boolean;
-    } | undefined;
-    readonly permissions: {
-        user?: Array<import("../main.js").PermissionNames> | Array<string> | null;
-        client?: Array<import("../main.js").PermissionNames> | Array<string> | null;
-        dm?: boolean;
-    } | undefined;
-    readonly filetype: 'MessageCommand';
-    readonly filepath: string;
-    readonly client: XernerxClientType;
-    snowflake: string | null;
-    util: MessageUtil;
-    constructor(id: string, options: MessageCommandOptions);
-    /**
-     * @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
-     */
-    conditions<T = void>(message: XernerxMessage, { args, flags }: MessageCommandArguments): Promise<void | any | T>;
-    /**
-     * @description Runs the execution rule
-     * @param message - The message event emitted on this command
-     * @param options - The args and flags parsed on this command
-     */
-    exec<T = void>(message: XernerxMessage, { args, flags }: MessageCommandArguments): Promise<void | any | T>;
-}

package/dist/build/XernerxMessageCommand.js

@@ -1,119 +0,0 @@
-/** @format */
-import { z } from 'zod';
-import XernerxLog from '../tools/XernerxLog.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),
-            global: z.boolean().default(true),
-            channel: z
-                .array(z.enum([
-                'GuildText',
-                'DM',
-                'GuildVoice',
-                'GroupDM',
-                'GuildCategory',
-                'GuildAnnouncement',
-                'AnnouncementThread',
-                'PublicThread',
-                'PrivateThread',
-                'GuildStageVoice',
-                'GuildDirectory',
-                'GuildForum',
-                'GuildNews',
-                'GuildNewsThread',
-                'GuildPublicThread',
-                'GuildPrivateThread',
-            ]))
-                .or(z.enum([
-                'GuildText',
-                'DM',
-                'GuildVoice',
-                'GroupDM',
-                'GuildCategory',
-                'GuildAnnouncement',
-                'AnnouncementThread',
-                'PublicThread',
-                'PrivateThread',
-                'GuildStageVoice',
-                'GuildDirectory',
-                'GuildForum',
-                'GuildNews',
-                'GuildNewsThread',
-                'GuildPublicThread',
-                'GuildPrivateThread',
-            ]))
-                .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([]),
-                voice: z.boolean().default(false),
-            })
-                .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([]),
-                voice: z.boolean().default(false),
-            })
-                .default({}),
-            permissions: z
-                .object({
-                user: z.array(z.string()).or(z.null()).default(null),
-                client: z.array(z.string()).or(z.null()).default(null),
-                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.channel = options.channel ? (Array.isArray(options.channel) ? options.channel : [options.channel]) : null;
-        this.global = options.global;
-        this.ignore = options.ignore;
-        this.strict = options.strict;
-        this.separator = options.separator;
-        this.permissions = options.permissions;
-        this.client = this.client;
-        this.util = this.util;
-    }
-    /**
-     * @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);
-    }
-}

package/dist/build/XernerxSlashCommand.d.ts

@@ -1,70 +0,0 @@
-/** @format */
-import { AutocompleteFocusedOption, AutocompleteInteraction, SlashCommandBuilder } from 'discord.js';
-import { XernerxClientType, XernerxMessageContextInteraction, XernerxSlashInteraction, XernerxUserContextInteraction } from '../types/extenders.js';
-import { SlashCommandArguments, SlashCommandOptions } from '../types/interfaces.js';
-import { XernerxInteraction } from '../types/types.js';
-import InteractionUtil from '../utils/InteractionUtil.js';
-export default class XernerxSlashCommand {
-    readonly id: string;
-    readonly data: 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 channel: ("GuildText" | "DM" | "GuildVoice" | "GroupDM" | "GuildCategory" | "GuildAnnouncement" | "AnnouncementThread" | "PublicThread" | "PrivateThread" | "GuildStageVoice" | "GuildDirectory" | "GuildForum" | "GuildMedia" | "GuildNews" | "GuildNewsThread" | "GuildPublicThread" | "GuildPrivateThread")[] | null;
-    readonly global: boolean | undefined;
-    readonly ignore: {
-        owner?: boolean;
-        users?: Array<string>;
-        channels?: Array<string>;
-        guilds?: Array<string>;
-        voice?: boolean;
-    } | undefined;
-    readonly strict: {
-        owner?: boolean;
-        users?: Array<string>;
-        channels?: Array<string>;
-        guilds?: Array<string>;
-        voice?: boolean;
-    } | undefined;
-    readonly permissions: {
-        user?: Array<import("../types/types.js").PermissionNames> | Array<string> | null;
-        client?: Array<import("../types/types.js").PermissionNames> | Array<string> | null;
-        dm?: boolean;
-    } | undefined;
-    readonly defer: {
-        reply?: boolean;
-        ephemeral?: boolean;
-        fetchReply?: boolean;
-    } | undefined;
-    readonly filetype: 'SlashCommand';
-    readonly filepath: string;
-    readonly client: XernerxClientType;
-    snowflake: string | null;
-    util: InteractionUtil;
-    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 = void>(interaction: AutocompleteInteraction, focused: AutocompleteFocusedOption, options: any[]): 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 = void>(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 = void>(interaction: XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>, { args, subcommand, group }: SlashCommandArguments): Promise<void | any | T>;
-    private addArguments;
-    private addSubcommands;
-    private addSubcommandGroups;
-}

package/dist/build/XernerxSlashCommand.js

@@ -1,178 +0,0 @@
-/** @format */
-import { SlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder } from 'discord.js';
-import { z } from 'zod';
-import XernerxLog from '../tools/XernerxLog.js';
-export default class XernerxSlashCommand {
-    constructor(id, options) {
-        this.id = id;
-        this.data = new 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),
-            cooldown: z.number().or(z.null()).default(null),
-            number: z.number().or(z.null()).default(null),
-            global: z.boolean().default(true),
-            channel: z
-                .array(z.enum([
-                'GuildText',
-                'DM',
-                'GuildVoice',
-                'GroupDM',
-                'GuildCategory',
-                'GuildAnnouncement',
-                'AnnouncementThread',
-                'PublicThread',
-                'PrivateThread',
-                'GuildStageVoice',
-                'GuildDirectory',
-                'GuildForum',
-                'GuildNews',
-                'GuildNewsThread',
-                'GuildPublicThread',
-                'GuildPrivateThread',
-            ]))
-                .or(z.enum([
-                'GuildText',
-                'DM',
-                'GuildVoice',
-                'GroupDM',
-                'GuildCategory',
-                'GuildAnnouncement',
-                'AnnouncementThread',
-                'PublicThread',
-                'PrivateThread',
-                'GuildStageVoice',
-                'GuildDirectory',
-                'GuildForum',
-                'GuildNews',
-                'GuildNewsThread',
-                'GuildPublicThread',
-                'GuildPrivateThread',
-            ]))
-                .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([]),
-                voice: z.boolean().default(false),
-            })
-                .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([]),
-                voice: z.boolean().default(false),
-            })
-                .default({}),
-            permissions: z
-                .object({
-                user: z.array(z.string()).or(z.null()).default(null),
-                client: z.array(z.string()).or(z.null()).default(null),
-                dm: z.boolean().default(true),
-            })
-                .default({}),
-            defer: z
-                .object({
-                reply: z.boolean().optional(),
-                ephemeral: z.boolean().optional(),
-                fetch: z.boolean().optional(),
-            })
-                .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.channel = options.channel ? (Array.isArray(options.channel) ? options.channel : [options.channel]) : null;
-        this.global = options.global;
-        this.ignore = options.ignore;
-        this.strict = options.strict;
-        this.permissions = options.permissions;
-        this.defer = options.defer;
-        this.client = this.client;
-        this.util = this.util;
-    }
-    /**
-     * @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);
-    }
-    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);
-        }
-    }
-}

package/dist/client/XernerxClient.d.ts

@@ -1,64 +0,0 @@
-/** @format */
-import { Client, ClientOptions, Collection } from 'discord.js';
-import { XernerxOptions, ModuleOptions, XernerxCommands, XernerxCache } from '../types/interfaces.js';
-import { XernerxClientEvents } from '../types/extenders.js';
-import ClientUtil from '../utils/ClientUtil.js';
-import XernerxInhibitor from '../build/XernerxInhibitor.js';
-import XernerxEvent from '../build/XernerxEvent.js';
-import Cooldowns from '../models/Cooldowns.js';
-export default class XernerxClient<T extends object = {
-    [index: string | number]: any;
-}> extends Client {
-    readonly settings: {
-        ownerId: string | string[];
-        local: string;
-        ceaseless: boolean;
-        debug?: boolean | undefined;
-        permissions?: {
-            user: string[] | null;
-            client: string[] | null;
-            dm: boolean;
-        } | undefined;
-        global?: boolean | undefined;
-        ignore?: {
-            system: boolean;
-            users: string[];
-            channels: string[];
-            owner: boolean;
-            self: boolean;
-            bots: boolean;
-            guilds: string[];
-        } | undefined;
-        log?: boolean | {
-            warn: boolean;
-            error: boolean;
-            ready: boolean;
-            info: boolean;
-            table: string[] | null;
-            format: string[] | null;
-        } | undefined;
-        cooldown?: {
-            command: number;
-            cache: number;
-            collections: string[];
-        } | undefined;
-    };
-    readonly config: T;
-    readonly commands: XernerxCommands;
-    readonly events: Collection<string, XernerxEvent<keyof XernerxClientEvents>>;
-    readonly inhibitors: Collection<string, XernerxInhibitor>;
-    readonly modules: ModuleOptions;
-    readonly util: ClientUtil;
-    readonly stats: Record<string, number>;
-    readonly cache: XernerxCache;
-    readonly cooldowns: Cooldowns;
-    store: {
-        front?: any;
-        archive?: any;
-        items?: any;
-    };
-    readonly dbl: any;
-    readonly [index: string]: unknown;
-    constructor(discordOptions: ClientOptions, xernerxOptions: XernerxOptions, config?: T);
-    connect(token: string): Promise<string | void>;
-}