xernerx 3.5.2 → 4.0.0

package/dist/{mjs/build/EventBuilder.d.ts → build copy/EventBuilder.d.ts }

@@ -7,10 +7,10 @@ import { EventOptions } from '../types/options.js';
  */
 export default class EventBuilder {
     id: string;
-    name: string;
-    emitter: string;
-    type: string;
-    once: boolean;
+    name: any;
+    emitter: any;
+    type: any;
+    once: any;
     client: typeof XernerxClient;
     constructor(id: string, options: EventOptions);
     /**

package/dist/build copy/EventBuilder.js

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import XernerxClient from '../client/XernerxClient.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 {
+    id;
+    name;
+    emitter;
+    type;
+    once;
+    client;
+    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() {}
+}

package/dist/{cjs/build/InhibitorBuilder.d.ts → build copy/InhibitorBuilder.d.ts }

@@ -8,8 +8,8 @@ import { XernerxInteraction, XernerxMessage } from '../types/types.js';
  */
 export default class InhibitorBuilder {
     id: string;
-    name: string;
-    type: import('../main.js').InhibitorType;
+    name: any;
+    type: any;
     client: typeof XernerxClient;
     constructor(id: string, options: InhibitorOptions);
     /**

package/dist/build copy/InhibitorBuilder.js

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import XernerxClient from '../client/XernerxClient.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 {
+    id;
+    name;
+    type;
+    client;
+    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;
+    }
+    /**
+     * TODO - update description
+     */
+    async check(interaction, args) {}
+}

package/dist/{cjs/build/MessageCommandBuilder.d.ts → build copy/MessageCommandBuilder.d.ts }

@@ -8,40 +8,20 @@ import { XernerxMessage } from '../types/types.js';
  */
 export default class MessageCommandBuilder {
     id: string;
-    name: string;
-    aliases: string[] | undefined;
-    separator: string;
-    description: string | undefined;
-    info: string | undefined;
-    category: string | undefined;
-    prefix: string[];
-    regex: string | undefined;
-    channelType: 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;
-              user?: string[] | undefined;
-              dm?: boolean | undefined;
-          }
-        | undefined;
-    cooldown: number;
-    args: MessageArgumentOptions[];
+    name: any;
+    aliases: any;
+    separator: any;
+    description: any;
+    info: any;
+    category: any;
+    prefix: any;
+    regex: any;
+    channelType: any;
+    ignore: any;
+    strict: any;
+    permissions: any;
+    cooldown: any;
+    args: any;
     client: typeof XernerxClient;
     constructor(id: string, options: MessageCommandOptions);
     /**

package/dist/build copy/MessageCommandBuilder.js

@@ -0,0 +1,90 @@
+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 copy/SlashCommandBuilder.d.ts

@@ -0,0 +1,41 @@
+import * as Discord from 'discord.js';
+import { 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: any;
+    description: any;
+    info: any;
+    category: any;
+    channelType: any;
+    cooldown: any;
+    ignore: any;
+    strict: any;
+    permissions: any;
+    args?: object[];
+    subcommands?: object[];
+    groups?: object[];
+    defer: any;
+    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 copy/SlashCommandBuilder.js

@@ -0,0 +1,122 @@
+import * as Discord from 'discord.js';
+import { 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/DBLClient.d.ts

@@ -0,0 +1,8 @@
+import { DBL } from 'dbl-sdk';
+import XernerxClient from './XernerxClient.js';
+import { DBLOptions } from '../types/interfaces.js';
+export default class DBLClient {
+    dbl: DBL | null;
+    readonly client: XernerxClient;
+    constructor(client: any, options: DBLOptions);
+}

package/dist/client/DBLClient.js

@@ -0,0 +1,15 @@
+import { DBL, hasVoted } from 'dbl-sdk';
+import XernerxLog from '../tools/XernerxLog.js';
+export default class DBLClient {
+    dbl;
+    client;
+    constructor(client, options) {
+        this.dbl = null;
+        this.client = client;
+        this.client.once('ready', (client) => {
+            this.dbl = new DBL(client, options);
+            new XernerxLog(this.client).info(`Loaded webhooks!`);
+            this.client.util.hasVoted = (userId) => hasVoted(userId, client.user.id, this.dbl?.options.topgg?.token, 'top.gg');
+        });
+    }
+}

package/dist/client/Top.ggClient.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/client/Top.ggClient.js

@@ -0,0 +1 @@
+export {};

package/dist/client/XernerxClient.d.ts

@@ -0,0 +1,54 @@
+import { Client, ClientOptions, Collection } from 'discord.js';
+import { XernerxOptions, ModuleOptions, XernerxCommands, XernerxCache } from '../types/interfaces.js';
+import ClientUtil from '../utils/ClientUtil.js';
+import { InhibitorBuilder } from '../main.js';
+export default class XernerxClient extends Client {
+    readonly settings: {
+        ownerId: (string | string[]) & (string | string[] | undefined);
+        local: string;
+        global: boolean;
+        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;
+              }
+            | undefined;
+        cooldown?:
+            | {
+                  command: number;
+                  cache: number;
+              }
+            | undefined;
+    };
+    readonly config: unknown;
+    readonly commands: XernerxCommands;
+    readonly events: Collection<unknown, unknown>;
+    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: unknown);
+    connect(token: string): void;
+}

package/dist/client/XernerxClient.js

@@ -0,0 +1,90 @@
+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 {
+    settings;
+    config;
+    commands;
+    events;
+    inhibitors;
+    modules;
+    util;
+    stats;
+    cache;
+    constructor(discordOptions, xernerxOptions, config) {
+        super(discordOptions);
+        this.settings = z
+            .object({
+                local: z.string(),
+                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),
+                    })
+                    .optional(),
+                cooldown: z
+                    .object({
+                        command: z.number().default(0),
+                        cache: z.number().default(0),
+                    })
+                    .optional(),
+            })
+            .parse(xernerxOptions);
+        this.config = config;
+        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: 0,
+            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/events/messageCreate.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/events/messageCreate.js

@@ -0,0 +1 @@
+export {};

package/dist/functions/AsyncFunctions.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/functions/AsyncFunctions.js

@@ -0,0 +1 @@
+export {};

package/dist/functions/delay.d.ts

@@ -0,0 +1 @@
+export default function delay(time: number): Promise<unknown>;

package/dist/functions/delay.js

@@ -0,0 +1,3 @@
+export default async function delay(time) {
+    return await new Promise((resolve) => setTimeout(resolve, time));
+}

package/dist/functions/deploy.d.ts

@@ -0,0 +1,2 @@
+import XernerxClient from '../client/XernerxClient.js';
+export default function deploy(client: XernerxClient, type: 'slash' | 'context'): void;

package/dist/functions/deploy.js

@@ -0,0 +1,29 @@
+import { GatewayVersion, REST, Routes } from 'discord.js';
+import XernerxLog from '../tools/XernerxLog.js';
+const commands = { slash: [], context: [], retries: 0 };
+export default function deploy(client, type) {
+    client.prependOnceListener('ready', (client) => {
+        commands[type] = client.commands[type].map((command) => command.data.toJSON());
+        if (commands.retries % 2) {
+            try {
+                if (client.settings.global) {
+                    put(client, client.settings.global, [...commands.slash, ...commands.context]);
+                    put(client, !client.settings.global, []);
+                } else {
+                    put(client, !client.settings.global, [...commands.slash, ...commands.context]);
+                    put(client, client.settings.global, []);
+                }
+            } catch (error) {
+                new XernerxLog(client).error(`An error occurred while deploying the interaction commands!`, error);
+            } finally {
+                new XernerxLog(client).info(`Deployed All Commands ${client.settings.global ? 'globally' : 'locally'}.`);
+            }
+        }
+        commands.retries++;
+    });
+}
+function put(client, global, body) {
+    const rest = new REST({ version: GatewayVersion }).setToken(client.token);
+    if (!global) rest.put(Routes.applicationGuildCommands(client.user?.id, client.settings.local), { body });
+    else rest.put(Routes.applicationCommands(client.user?.id), { body });
+}

package/dist/functions/getPermissionBitField.d.ts

@@ -0,0 +1,2 @@
+import { PermissionNames } from '../types/types.js';
+export default function getPermissionBitField(...permissions: Array<PermissionNames | bigint>): bigint;

package/dist/functions/getPermissionBitField.js

@@ -0,0 +1,17 @@
+import { PermissionFlagsBits } from 'discord.js';
+export default function getPermissionBitField(...permissions) {
+    const bigIntPerms = [0n];
+    permissions.map((permission) => {
+        if (typeof permission === 'string') {
+            permission =
+                PermissionFlagsBits[
+                    permission
+                        .split(/ +/)
+                        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+                        .join('')
+                ];
+        }
+        bigIntPerms.push(permission);
+    });
+    return bigIntPerms.reduce((a, b) => (a += b));
+}

package/dist/functions/hasVoted.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/functions/hasVoted.js

@@ -0,0 +1 @@
+export {};

package/dist/functions/isOwner.d.ts

@@ -0,0 +1,3 @@
+import XernerxClient from '../client/XernerxClient.js';
+import { XernerxUser } from '../types/extenders.js';
+export default function isOwner(user: Pick<XernerxUser, 'id'>, client: XernerxClient): boolean;

package/dist/functions/isOwner.js

@@ -0,0 +1,3 @@
+export default function isOwner(user, client) {
+    return client.settings.ownerId.includes(user.id);
+}