xernerx 4.4.2 → 4.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "xernerx",
-    "version": "4.4.2",
+    "version": "4.4.3",
     "description": "A bot framework for discord.js.",
     "main": "dist/main.js",
     "type": "module",
@@ -37,7 +37,7 @@
     },
     "dependencies": {
         "dbl-sdk": "^1.2.0",
-        "discord.js": "^14.9.0",
+        "discord.js": "^14.11.0",
         "dumfunctions": "^2.1.2",
         "xernerx-extension-builder": "^0.0.16",
         "zod": "^3.21.4"

package/dist/build/ContextCommandBuilder.d.ts

@@ -1,48 +0,0 @@
-import { ContextMenuCommandBuilder } from 'discord.js';
-import XernerxClient from '../client/XernerxClient.js';
-import { XernerxMessageContextInteraction, XernerxUserContextInteraction } from '../types/extenders.js';
-import { ContextCommandOptions } from '../types/interfaces.js';
-export default class ContextCommandBuilder {
-    readonly id: string;
-    readonly data: ContextMenuCommandBuilder;
-    readonly name: string;
-    readonly type: 'message' | 'user';
-    readonly description: string | null | undefined;
-    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 client: typeof XernerxClient;
-    constructor(id: string, options: ContextCommandOptions);
-    exec(interaction: XernerxUserContextInteraction | XernerxMessageContextInteraction): Promise<void>;
-}

package/dist/build/ContextCommandBuilder.js

@@ -1,67 +0,0 @@
-import { ContextMenuCommandBuilder } from 'discord.js';
-import { z } from 'zod';
-import XernerxClient from '../client/XernerxClient.js';
-export default class ContextCommandBuilder {
-    constructor(id, options) {
-        this.id = id;
-        this.data = new ContextMenuCommandBuilder();
-        this.data.setName(options.name);
-        this.data.setNameLocalizations(options.nameLocalizations || null);
-        this.data.setType(options.type === 'user' ? 2 : 3);
-        this.data.setDMPermission(options.permissions?.dm || null);
-        options = z
-            .object({
-                name: z.string(),
-                type: z.enum(['user', 'message']),
-                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),
-                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.type = options.type;
-        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 exec(interaction) {}
-}

package/dist/build/EventBuilder.d.ts

@@ -1,22 +0,0 @@
-import XernerxClient from '../client/XernerxClient.js';
-import { EventBuilderOptions } from '../types/interfaces.js';
-import { EventType } from '../types/types.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 EventBuilder {
-    readonly id: string;
-    readonly name: EventType;
-    readonly emitter?: 'client' | 'process' | string;
-    readonly type?: 'discord' | string;
-    readonly once?: boolean;
-    readonly client: typeof XernerxClient;
-    constructor(id: string, options: EventBuilderOptions);
-    /**
-     * @description run your custom event here.
-     * TODO - update description
-     */
-    run<T>(...args: T[]): Promise<void>;
-}

package/dist/build/EventBuilder.js

@@ -1,29 +0,0 @@
-import { z } from 'zod';
-import XernerxClient from '../client/XernerxClient.js';
-// import { EventOptions } from '../types/options.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 EventBuilder {
-    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 = XernerxClient;
-    }
-    /**
-     * @description run your custom event here.
-     * TODO - update description
-     */
-    async run(...args) {}
-}

package/dist/build/InhibitorBuilder.d.ts

@@ -1,17 +0,0 @@
-import XernerxClient from '../client/XernerxClient.js';
-import { InhibitorBuilderOptions } from '../types/interfaces.js';
-import { InhibitorType, XernerxInteraction } from '../types/types.js';
-import { XernerxMessage } from '../types/extenders.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 InhibitorBuilder {
-    readonly id: string;
-    readonly name: string;
-    readonly type: InhibitorType;
-    readonly client: typeof XernerxClient;
-    constructor(id: string, options: InhibitorBuilderOptions);
-    check<T>(action: XernerxInteraction | XernerxMessage, args: T): Promise<void>;
-}

package/dist/build/InhibitorBuilder.js

@@ -1,22 +0,0 @@
-import { z } from 'zod';
-import XernerxClient from '../client/XernerxClient.js';
-// import { InhibitorOptions, MessageArgumentOptions, SlashArgumentOptions } from '../types/options.js';
-// import { XernerxInteraction, XernerxMessage } from '../types/types.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 InhibitorBuilder {
-    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 = XernerxClient;
-    }
-    async check(action, args) {}
-}

package/dist/build/MessageCommandBuilder.d.ts

@@ -1,45 +0,0 @@
-import XernerxClient from '../client/XernerxClient.js';
-import { XernerxMessage } from '../types/extenders.js';
-import { MessageCommandArguments, MessageCommandOptions } from '../types/interfaces.js';
-export default class MessageCommandBuilder {
-    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 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 client: typeof XernerxClient;
-    constructor(id: string, options: MessageCommandOptions);
-    conditions(message: XernerxMessage, args: MessageCommandArguments): Promise<void>;
-    exec(message: XernerxMessage, args: MessageCommandArguments): Promise<void>;
-}

package/dist/build/MessageCommandBuilder.js

@@ -1,60 +0,0 @@
-import { z } from 'zod';
-import XernerxClient from '../client/XernerxClient.js';
-export default class MessageCommandBuilder {
-    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 = XernerxClient;
-    }
-    async conditions(message, args) {}
-    async exec(message, args) {}
-}

package/dist/build/SlashCommandBuilder.d.ts

@@ -1,52 +0,0 @@
-import Discord from 'discord.js';
-import XernerxClient from '../client/XernerxClient.js';
-import { XernerxSlashInteraction } from '../types/extenders.js';
-import { SlashCommandArguments, SlashCommandOptions } from '../types/interfaces.js';
-export default class SlashCommandBuilder {
-    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 client: typeof XernerxClient;
-    constructor(id: string, options: SlashCommandOptions);
-    autocomplete<T>(interaction: XernerxSlashInteraction, focused: T, options: Array<T>): Promise<void>;
-    conditions(interaction: XernerxSlashInteraction, args: SlashCommandArguments): Promise<void>;
-    exec(interaction: XernerxSlashInteraction, args: SlashCommandArguments): Promise<void>;
-    private addArguments;
-    private addSubcommands;
-    private addSubcommandGroups;
-}

package/dist/build/SlashCommandBuilder.js

@@ -1,113 +0,0 @@
-import Discord, { SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder } from 'discord.js';
-import { z } from 'zod';
-import XernerxClient from '../client/XernerxClient.js';
-export default class SlashCommandBuilder {
-    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) {}
-    async exec(interaction, args) {}
-    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?.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,55 +0,0 @@
-import { Client, ClientOptions, Collection } from 'discord.js';
-import { XernerxOptions, ModuleOptions, XernerxCommands, XernerxCache } from '../types/interfaces.js';
-import ClientUtil from '../utils/ClientUtil.js';
-import { InhibitorBuilder, EventBuilder } from '../main.js';
-export default class XernerxClient extends Client {
-    readonly settings: {
-        ownerId: (string | string[]) & (string | string[] | undefined);
-        global: boolean;
-        local?: string | 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: Record<string, unknown> | null;
-    readonly commands: XernerxCommands;
-    readonly events: Collection<string, EventBuilder>;
-    readonly inhibitors: Collection<string, InhibitorBuilder>;
-    readonly modules: ModuleOptions;
-    readonly util: ClientUtil;
-    readonly stats: {
-        guildCount: number;
-        userCount: number;
-        shardId: number;
-        shardCount: number;
-    };
-    readonly cache: XernerxCache;
-    constructor(discordOptions: ClientOptions, xernerxOptions: XernerxOptions, config?: Record<string, unknown>);
-    connect(token: string): void;
-}

package/dist/client/XernerxClient.js

@@ -1,82 +0,0 @@
-import { Client, Collection } from 'discord.js';
-import { z } from 'zod';
-import CommandHandler from '../handlers/CommandHandler.js';
-import EventHandler from '../handlers/EventHandler.js';
-import InhibitorHandler from '../handlers/InhibitorHandler.js';
-import WebhookHandler from '../handlers/WebhookHandler.js';
-import XernerxLog from '../tools/XernerxLog.js';
-import ClientUtil from '../utils/ClientUtil.js';
-import ExtensionHandler from '../handlers/ExtensionHandler.js';
-export default class XernerxClient extends Client {
-    constructor(discordOptions, xernerxOptions, config) {
-        super(discordOptions);
-        this.settings = z
-            .object({
-                local: z.string().optional(),
-                global: z.boolean().default(false),
-                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()),
-                        channels: z.array(z.string()),
-                        guilds: z.array(z.string()),
-                    })
-                    .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;
-    }
-    connect(token) {
-        this.login(token);
-        new XernerxLog(this).ready();
-    }
-}

package/dist/client/XernerxShardClient.d.ts

@@ -1,16 +0,0 @@
-import { ShardingManager, ShardingManagerOptions, ClientUser } from 'discord.js';
-interface XernerxOptions {
-    log?: {
-        ready?: 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);
-}
-export {};