xernerx 3.5.0 → 3.5.2

package/dist/cjs/build/ContextCommandBuilder.js

@@ -0,0 +1,97 @@
+'use strict';
+var __importDefault =
+    (this && this.__importDefault) ||
+    function (mod) {
+        return mod && mod.__esModule ? mod : { default: mod };
+    };
+Object.defineProperty(exports, '__esModule', { value: true });
+const discord_js_1 = require('discord.js');
+const zod_1 = require('zod');
+const XernerxClient_js_1 = __importDefault(require('../client/XernerxClient.js'));
+/**
+ * @description The command builder for context commands.
+ * @param {String} id - The unique ID of the command.
+ * @param {ContextCommandOptions} options - The command options.
+ */
+class ContextCommandBuilder {
+    id;
+    data;
+    name;
+    type;
+    description;
+    info;
+    category;
+    channelType;
+    cooldown;
+    ignore;
+    strict;
+    permissions;
+    defer;
+    client;
+    constructor(id, options) {
+        this.id = id;
+        this.data = new discord_js_1.ContextMenuCommandBuilder();
+        if (options.name) this.data.setName(options.name);
+        if (options.type) this.data.setType(options.type);
+        if (options.permissions?.users) this.data.setDefaultMemberPermissions(options.permissions?.users);
+        if (options.permissions?.dm === false) this.data.setDMPermission(options.permissions?.dm);
+        if (options.nameLocalizations) this.data.setNameLocalizations(options.nameLocalizations);
+        zod_1.z
+            .object({
+                description: zod_1.z.string(),
+                info: zod_1.z.string(),
+                category: zod_1.z.string(),
+                channelType: zod_1.z.array(zod_1.z.number()).or(zod_1.z.number()),
+                cooldown: zod_1.z.number(),
+                ignore: zod_1.z.object({
+                    owner: zod_1.z.boolean(),
+                    users: zod_1.z.array(zod_1.z.string()),
+                    channels: zod_1.z.array(zod_1.z.string()),
+                    guilds: zod_1.z.array(zod_1.z.string()),
+                }),
+                strict: zod_1.z.object({
+                    owner: zod_1.z.boolean(),
+                    users: zod_1.z.array(zod_1.z.string()),
+                    channels: zod_1.z.array(zod_1.z.string()),
+                    guilds: zod_1.z.array(zod_1.z.string()),
+                }),
+                permissions: zod_1.z.object({
+                    client: zod_1.z.array(zod_1.z.string()),
+                    users: zod_1.z.array(zod_1.z.string()),
+                    dm: zod_1.z.boolean(),
+                }),
+                defer: zod_1.z.object({
+                    reply: zod_1.z.boolean(),
+                    ephemeral: zod_1.z.boolean(),
+                    fetch: zod_1.z.boolean(),
+                }),
+            })
+            .deepPartial()
+            .parse(options);
+        this.name = options.name;
+        this.type = options.type;
+        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_js_1.default;
+    }
+    /**
+     * @param {Interaction} interaction - The Discord interaction event data.
+     * @description make any preconditions here.
+     * TODO - update description
+     */
+    async conditions(interaction, args) {}
+    /**
+     * @param {Interaction} interaction - The Discord interaction event data.
+     * @description Make your custom command here.
+     * TODO - update description
+     */
+    async exec(interaction, args) {}
+}
+exports.default = ContextCommandBuilder;

package/dist/cjs/build/EventBuilder.js

@@ -0,0 +1,44 @@
+'use strict';
+var __importDefault =
+    (this && this.__importDefault) ||
+    function (mod) {
+        return mod && mod.__esModule ? mod : { default: mod };
+    };
+Object.defineProperty(exports, '__esModule', { value: true });
+const zod_1 = require('zod');
+const XernerxClient_js_1 = __importDefault(require('../client/XernerxClient.js'));
+/**
+ * @description - The event builder for  events.
+ * @param {String} id - The unique ID of the event.
+ * @param {EventOptions} options - The event options.
+ */
+class EventBuilder {
+    id;
+    name;
+    emitter;
+    type;
+    once;
+    client;
+    constructor(id, options) {
+        this.id = id;
+        zod_1.z
+            .object({
+                name: zod_1.z.string(),
+                emitter: zod_1.z.string().optional(),
+                type: zod_1.z.string().optional(),
+                once: zod_1.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_js_1.default;
+    }
+    /**
+     * @description run your custom event here.
+     * TODO - update description
+     */
+    async run() {}
+}
+exports.default = EventBuilder;

package/dist/cjs/build/InhibitorBuilder.js

@@ -0,0 +1,37 @@
+'use strict';
+var __importDefault =
+    (this && this.__importDefault) ||
+    function (mod) {
+        return mod && mod.__esModule ? mod : { default: mod };
+    };
+Object.defineProperty(exports, '__esModule', { value: true });
+const zod_1 = require('zod');
+const XernerxClient_js_1 = __importDefault(require('../client/XernerxClient.js'));
+/**
+ * @description - The inhibitor builder for inhibitors.
+ * @param {String} id - The unique ID of the inhibitor.
+ * @param {InhibitorOptions} options - The inhibitor options.
+ */
+class InhibitorBuilder {
+    id;
+    name;
+    type;
+    client;
+    constructor(id, options) {
+        this.id = id;
+        zod_1.z
+            .object({
+                name: zod_1.z.string(),
+                type: zod_1.z.string(),
+            })
+            .parse(options);
+        this.name = options.name;
+        this.type = options.type;
+        this.client = XernerxClient_js_1.default;
+    }
+    /**
+     * TODO - update description
+     */
+    async check(interaction, args) {}
+}
+exports.default = InhibitorBuilder;

package/dist/cjs/build/MessageCommandBuilder.js

@@ -0,0 +1,100 @@
+'use strict';
+var __importDefault =
+    (this && this.__importDefault) ||
+    function (mod) {
+        return mod && mod.__esModule ? mod : { default: mod };
+    };
+Object.defineProperty(exports, '__esModule', { value: true });
+const zod_1 = require('zod');
+const XernerxClient_js_1 = __importDefault(require('../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.
+ */
+class MessageCommandBuilder {
+    id;
+    name;
+    aliases;
+    separator;
+    description;
+    info;
+    category;
+    prefix;
+    regex;
+    channelType;
+    ignore;
+    strict;
+    permissions;
+    cooldown;
+    args;
+    client;
+    constructor(id, options) {
+        this.id = id;
+        zod_1.z
+            .object({
+                name: zod_1.z.string(),
+                aliases: zod_1.z.array(zod_1.z.string()).optional(),
+                separator: zod_1.z.string().min(1).max(1).optional(),
+                description: zod_1.z.string().optional(),
+                info: zod_1.z.string().optional(),
+                category: zod_1.z.string().optional(),
+                prefix: zod_1.z.array(zod_1.z.string()).or(zod_1.z.string()).optional(),
+                regex: zod_1.z.unknown(),
+                channelType: zod_1.z.array(zod_1.z.number()).or(zod_1.z.number()).optional(),
+                cooldown: zod_1.z.number().optional(),
+                ignore: zod_1.z
+                    .object({
+                        owners: zod_1.z.boolean().optional(),
+                        users: zod_1.z.array(zod_1.z.string()).or(zod_1.z.string()).optional(),
+                        channels: zod_1.z.array(zod_1.z.string()).or(zod_1.z.string()).optional(),
+                        guilds: zod_1.z.array(zod_1.z.string()).or(zod_1.z.string()).optional(),
+                    })
+                    .optional(),
+                strict: zod_1.z
+                    .object({
+                        owners: zod_1.z.boolean().optional(),
+                        users: zod_1.z.array(zod_1.z.string()).or(zod_1.z.string()).optional(),
+                        channels: zod_1.z.array(zod_1.z.string()).or(zod_1.z.string()).optional(),
+                        guilds: zod_1.z.array(zod_1.z.string()).or(zod_1.z.string()).optional(),
+                    })
+                    .optional(),
+                permissions: zod_1.z
+                    .object({
+                        client: zod_1.z.array(zod_1.z.string()).optional(),
+                        users: zod_1.z.array(zod_1.z.string()).optional(),
+                        dm: zod_1.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_js_1.default;
+    }
+    /**
+     * @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) {}
+}
+exports.default = MessageCommandBuilder;

package/{types → dist/cjs}/build/SlashCommandBuilder.d.ts

@@ -1,4 +1,5 @@
-import Discord, { Interaction } from 'discord.js';
+import * as Discord from 'discord.js';
+import { Interaction } from 'discord.js';
 import { SlashCommandOptions } from '../types/options.js';
 import XernerxClient from '../client/XernerxClient.js';
 /**

package/dist/cjs/build/SlashCommandBuilder.js

@@ -0,0 +1,169 @@
+'use strict';
+var __createBinding =
+    (this && this.__createBinding) ||
+    (Object.create
+        ? function (o, m, k, k2) {
+              if (k2 === undefined) k2 = k;
+              var desc = Object.getOwnPropertyDescriptor(m, k);
+              if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+                  desc = {
+                      enumerable: true,
+                      get: function () {
+                          return m[k];
+                      },
+                  };
+              }
+              Object.defineProperty(o, k2, desc);
+          }
+        : function (o, m, k, k2) {
+              if (k2 === undefined) k2 = k;
+              o[k2] = m[k];
+          });
+var __setModuleDefault =
+    (this && this.__setModuleDefault) ||
+    (Object.create
+        ? function (o, v) {
+              Object.defineProperty(o, 'default', { enumerable: true, value: v });
+          }
+        : function (o, v) {
+              o['default'] = v;
+          });
+var __importStar =
+    (this && this.__importStar) ||
+    function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k in mod) if (k !== 'default' && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+var __importDefault =
+    (this && this.__importDefault) ||
+    function (mod) {
+        return mod && mod.__esModule ? mod : { default: mod };
+    };
+Object.defineProperty(exports, '__esModule', { value: true });
+const Discord = __importStar(require('discord.js'));
+const discord_js_1 = require('discord.js');
+const zod_1 = require('zod');
+const XernerxError_js_1 = __importDefault(require('../tools/XernerxError.js'));
+const XernerxClient_js_1 = __importDefault(require('../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.
+ */
+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);
+        }
+        zod_1.z
+            .object({
+                description: zod_1.z.string(),
+                info: zod_1.z.string(),
+                category: zod_1.z.string(),
+                channelType: zod_1.z.array(zod_1.z.number()).or(zod_1.z.number()),
+                cooldown: zod_1.z.number(),
+                ignore: zod_1.z.object({
+                    owner: zod_1.z.boolean(),
+                    users: zod_1.z.array(zod_1.z.string()),
+                    channels: zod_1.z.array(zod_1.z.string()),
+                    guilds: zod_1.z.array(zod_1.z.string()),
+                }),
+                strict: zod_1.z.object({
+                    owner: zod_1.z.boolean(),
+                    users: zod_1.z.array(zod_1.z.string()),
+                    channels: zod_1.z.array(zod_1.z.string()),
+                    guilds: zod_1.z.array(zod_1.z.string()),
+                }),
+                permissions: zod_1.z.object({
+                    client: zod_1.z.array(zod_1.z.string()),
+                    users: zod_1.z.array(zod_1.z.string()),
+                    dm: zod_1.z.boolean(),
+                }),
+                defer: zod_1.z.object({
+                    reply: zod_1.z.boolean(),
+                    ephemeral: zod_1.z.boolean(),
+                    fetch: zod_1.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_js_1.default;
+    }
+    /**
+     * 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_js_1.default(`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 discord_js_1.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 discord_js_1.SlashCommandSubcommandGroupBuilder().setName(group.name).setDescription(group.description);
+            if (group.subcommands?.length > 0) this.addSubcommands(subcommandGroup, group.subcommands);
+            this.data.addSubcommandGroup(subcommandGroup);
+        }
+    }
+}
+exports.default = SlashCommandBuilder;

package/dist/cjs/client/XernerxClient.js

@@ -0,0 +1,116 @@
+'use strict';
+var __importDefault =
+    (this && this.__importDefault) ||
+    function (mod) {
+        return mod && mod.__esModule ? mod : { default: mod };
+    };
+Object.defineProperty(exports, '__esModule', { value: true });
+const discord_js_1 = require('discord.js');
+const zod_1 = require('zod');
+const dumfunctions_1 = require('dumfunctions');
+const ClientUtil_js_1 = require('../utils/ClientUtil.js');
+const CommandHandler_js_1 = __importDefault(require('../handlers/CommandHandler.js'));
+const EventHandler_js_1 = __importDefault(require('../handlers/EventHandler.js'));
+const InhibitorHandler_js_1 = __importDefault(require('../handlers/InhibitorHandler.js'));
+const Extensions_js_1 = __importDefault(require('../models/Extensions.js'));
+// TODO - Add commandNotFound as an event to the client.
+/**
+ * @description - The Client.
+ * @param {DiscordOptions} discordOptions - The options for discord.js.
+ * @param {ClientOptions} clientOptions - The options for the Xernerx Client.
+ * @extends {Client}
+ */
+class XernerxClient extends discord_js_1.Client {
+    settings;
+    commands;
+    cache;
+    modules;
+    util;
+    handlerOptions;
+    events;
+    extensions;
+    inhibitors;
+    config;
+    constructor(discordOptions, clientOptions, config) {
+        super(discordOptions);
+        this.settings = zod_1.z
+            .object({
+                ownerId: zod_1.z.string().or(zod_1.z.array(zod_1.z.string())).default([]),
+                permissions: zod_1.z
+                    .object({
+                        client: zod_1.z.array(zod_1.z.string()).default([]),
+                        user: zod_1.z.array(zod_1.z.string()).default([]),
+                        dm: zod_1.z.boolean().default(false),
+                    })
+                    .optional(),
+                ignore: zod_1.z
+                    .object({
+                        owner: zod_1.z.boolean().default(false),
+                        users: zod_1.z.array(zod_1.z.string()),
+                        channels: zod_1.z.array(zod_1.z.string()),
+                        guilds: zod_1.z.array(zod_1.z.string()),
+                    })
+                    .optional(),
+                log: zod_1.z
+                    .object({
+                        ready: zod_1.z.boolean().default(false),
+                        error: zod_1.z.boolean().default(false),
+                    })
+                    .optional(),
+                cooldown: zod_1.z
+                    .object({
+                        command: zod_1.z.number().default(0),
+                        cache: zod_1.z.number().default(0),
+                    })
+                    .optional(),
+            })
+            .parse(clientOptions);
+        this.config = config || {};
+        this.commands = {
+            message: new discord_js_1.Collection(),
+            slash: new discord_js_1.Collection(),
+            context: new discord_js_1.Collection(),
+        };
+        this.events = new discord_js_1.Collection();
+        this.inhibitors = new discord_js_1.Collection();
+        this.cache = {
+            messages: new discord_js_1.Collection(),
+            cooldowns: new discord_js_1.Collection(),
+            messageCommands: new discord_js_1.Collection(),
+            slashCommands: new discord_js_1.Collection(),
+            contextCommands: new discord_js_1.Collection(),
+            commands: new discord_js_1.Collection(),
+        };
+        this.modules = {
+            commandHandler: new CommandHandler_js_1.default(this),
+            eventHandler: new EventHandler_js_1.default(this),
+            inhibitorHandler: new InhibitorHandler_js_1.default(this),
+        };
+        this.extensions = {};
+        this.util = new ClientUtil_js_1.ClientUtil(this);
+        this.handlerOptions = {};
+        if (this.settings?.log?.ready) {
+            this.once('ready', async (client) => {
+                const size = (await client.guilds.fetch()).size;
+                console.info(
+                    dumfunctions_1.Style.log(
+                        `Xernerx | ${client.user.tag} signed in watching ${size} server${size > 1 ? 's' : ''}. ${
+                            (this.handlerOptions.slash || this.handlerOptions.context)?.guildId
+                                ? `Using ${(await this.guilds.fetch((this.handlerOptions.slash || this.handlerOptions.context)?.guildId || '0')).name} as local guild.`
+                                : ''
+                        }`,
+                        { color: dumfunctions_1.Style.TextColor.Purple }
+                    )
+                );
+            });
+        }
+    }
+    register(token) {
+        this.login(token);
+    }
+    loadAllExtensions(options) {
+        const extensions = new Extensions_js_1.default(this);
+        return extensions.load(options.extensions, options.logging || false);
+    }
+}
+exports.default = XernerxClient;

package/dist/{handlers → cjs/handlers}/CommandHandler.js

@@ -1,16 +1,18 @@
-import { Handler } from './Handler.js';
-import { CommandsDeploy, ContextCommandEvents, MessageCommandEvents, SlashCommandEvents } from '../models/Events.js';
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+const Handler_js_1 = require('./Handler.js');
+const Events_js_1 = require('../models/Events.js');
 /**
  * @description - The command handler.
  * @param {XernerxClient} client - The XernerxClient.
  */
-export default class CommandHandler {
+class CommandHandler {
     client;
     handler;
     constructor(client) {
         this.client = client;
-        this.handler = new Handler(client);
-        new CommandsDeploy(this.client).deploy();
+        this.handler = new Handler_js_1.Handler(client);
+        new Events_js_1.CommandsDeploy(this.client).deploy();
     }
     /**
      * @description - The message command loader.
@@ -18,7 +20,7 @@ export default class CommandHandler {
      */
     loadAllMessageCommands(options) {
         this.handler.loadAllMessageCommands(options);
-        const events = new MessageCommandEvents(this.client);
+        const events = new Events_js_1.MessageCommandEvents(this.client);
         events.messageCreate();
         events.messageUpdate();
         events.messageDelete();
@@ -29,7 +31,7 @@ export default class CommandHandler {
      */
     loadAllSlashCommands(options) {
         this.handler.loadAllSlashCommands(options);
-        new SlashCommandEvents(this.client).slashCreate();
+        new Events_js_1.SlashCommandEvents(this.client).slashCreate();
     }
     /**
      * @description - The context command loader.
@@ -37,6 +39,7 @@ export default class CommandHandler {
      */
     loadAllContextCommands(options) {
         this.handler.loadAllContextCommands(options);
-        new ContextCommandEvents(this.client).contextCreate();
+        new Events_js_1.ContextCommandEvents(this.client).contextCreate();
     }
 }
+exports.default = CommandHandler;

package/dist/{handlers → cjs/handlers}/EventHandler.js

@@ -1,10 +1,12 @@
-import { Handler } from './Handler.js';
-export default class EventHandler {
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+const Handler_js_1 = require('./Handler.js');
+class EventHandler {
     client;
     handler;
     constructor(client) {
         this.client = client;
-        this.handler = new Handler(client);
+        this.handler = new Handler_js_1.Handler(client);
     }
     /**
      * @description - The event loader
@@ -14,3 +16,4 @@ export default class EventHandler {
         return this.handler.loadAllEvents(options);
     }
 }
+exports.default = EventHandler;