xernerx 4.17.0 → 4.17.2

package/dist/build/XernerxEvent.d.ts

@@ -1,25 +1,21 @@
 /** @format */
 import { XernerxEventOptions } from '../types/interfaces.js';
-import { XernerxEventType } from '../types/types.js';
-import { XernerxClientType } from '../types/extenders.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 {
+export default class XernerxEvent<Event extends keyof XernerxClientEvents> {
     readonly id: string;
-    readonly name: XernerxEventType | string;
-    readonly emitter?: 'client' | 'process' | string;
-    readonly type?: 'discord' | 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);
-    /**
-     * @description run your custom event here.
-     * @param any - there can be all kinds of parameters on events.
-     */
-    run(...args: any): Promise<any>;
+    run(...args: XernerxClientEvents[Event]): Promise<Awaitable<any>>;
 }

package/dist/build/XernerxEvent.js

@@ -21,10 +21,6 @@ export default class XernerxEvent {
         this.once = options.once || false;
         this.client = this.client;
     }
-    /**
-     * @description run your custom event here.
-     * @param any - there can be all kinds of parameters on events.
-     */
     async run(...args) {
         return new XernerxLog(this.client).error(`${this.id} doesn't have a run rule.`);
     }

package/dist/build/XernerxMessageCommand.d.ts

@@ -34,11 +34,7 @@ export default class XernerxMessageCommand {
     } | undefined;
     readonly permissions: {
         user?: string[] | import("../main.js").PermissionNames[] | null | undefined;
-        client?: string[] | import("../main.js").PermissionNames[] | null | undefined; /**
-         * @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
-         */
+        client?: string[] | import("../main.js").PermissionNames[] | null | undefined;
         dm?: boolean | undefined;
     } | undefined;
     readonly filetype: 'MessageCommand';

package/dist/build/XernerxMessageCommand.js

@@ -114,6 +114,6 @@ export default class XernerxMessageCommand {
      */
     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, this.filetype);
+        return await this.client.emit('commandError', message, `${this.id} doesn't have an execution rule.`, this);
     }
 }

package/dist/build/XernerxSlashCommand.js

@@ -27,6 +27,7 @@ export default class XernerxSlashCommand {
             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
@@ -137,7 +138,7 @@ export default class XernerxSlashCommand {
      */
     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, this.filetype);
+        return await this.client.emit('commandError', interaction, `${this.id} doesn't have an execution rule.`, this);
     }
     addArguments(command, args) {
         for (const argument of args) {

package/dist/client/XernerxClient.d.ts

@@ -1,11 +1,12 @@
 /** @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 extends Client {
+export default class XernerxClient<T = unknown> extends Client {
     readonly settings: {
         ownerId: (string | string[]) & (string | string[] | undefined);
         local: string;
@@ -39,9 +40,9 @@ export default class XernerxClient extends Client {
             collections: string[];
         } | undefined;
     };
-    readonly config: {} | null;
+    readonly config: T;
     readonly commands: XernerxCommands;
-    readonly events: Collection<string, XernerxEvent>;
+    readonly events: Collection<string, XernerxEvent<keyof XernerxClientEvents>>;
     readonly inhibitors: Collection<string, XernerxInhibitor>;
     readonly modules: ModuleOptions;
     readonly util: ClientUtil;
@@ -49,6 +50,6 @@ export default class XernerxClient extends Client {
     readonly cache: XernerxCache;
     readonly cooldowns: Cooldowns;
     readonly dbl: any;
-    constructor(discordOptions: ClientOptions, xernerxOptions: XernerxOptions, config?: unknown);
+    constructor(discordOptions: ClientOptions, xernerxOptions: XernerxOptions, config?: T);
     connect(token: string): Promise<string>;
 }

package/dist/client/XernerxClient.js

@@ -57,7 +57,7 @@ export default class XernerxClient extends Client {
                 .optional(),
         })
             .parse(xernerxOptions);
-        this.config = config || null;
+        this.config = config;
         this.commands = {
             message: new Collection(),
             slash: new Collection(),
@@ -87,7 +87,6 @@ export default class XernerxClient extends Client {
             integrationHandler: new IntegrationHandler(this),
             extensionHandler: new ExtensionHandler(this),
         };
-        return this;
     }
     async connect(token) {
         const login = this.login(token);

package/dist/handlers/CommandHandler.js

@@ -42,7 +42,7 @@ export default class CommandHandler extends Handler {
         })
             .parse(options);
         this.client.modules.options.message = options;
-        const files = this.readdir(options.directory);
+        const files = this.readdir(options.directory, 'MessageCommands');
         for (const file of files) {
             const filepath = `${path.resolve(options.directory)}\\${file}`;
             const command = await this.load(filepath, 'MessageCommand');
@@ -107,7 +107,7 @@ export default class CommandHandler extends Handler {
         })
             .parse(options);
         this.client.modules.options.slash = options;
-        const files = this.readdir(options.directory);
+        const files = this.readdir(options.directory, 'SlashCommands');
         for (const file of files) {
             const filepath = `${path.resolve(options.directory)}\\${file}`;
             const command = await this.load(filepath, 'SlashCommand');
@@ -146,7 +146,7 @@ export default class CommandHandler extends Handler {
         })
             .parse(options);
         this.client.modules.options.context = options;
-        const files = this.readdir(options.directory);
+        const files = this.readdir(options.directory, 'ContextCommands');
         for (const file of files) {
             const filepath = `${path.resolve(options.directory)}\\${file}`;
             const command = await this.load(filepath, 'ContextCommand');
@@ -291,7 +291,7 @@ export default class CommandHandler extends Handler {
             cmd.util = interaction.util;
             return await this.exec(cmd, interaction, args, filetype);
         })
-            .catch((error) => this.client.emit('commandError', interaction, error, cmd, filetype));
+            .catch((error) => this.client.emit('commandError', interaction, error, cmd));
     }
     async contextCommandRun(interaction) {
         const filetype = 'ContextCommand';
@@ -337,7 +337,7 @@ export default class CommandHandler extends Handler {
         }
         catch (error) {
             new XernerxLog(this.client).error(`An error occurred executing ${Style.log(cmd.name, { color: Style.TextColor.Blue })}`, error);
-            return await this.client.emit('commandError', event, error, cmd, type);
+            return await this.client.emit('commandError', event, error, cmd);
         }
     }
     _checks(command) {

package/dist/handlers/EventHandler.js

@@ -17,7 +17,7 @@ export default class EventHandler extends Handler {
         })
             .parse(options);
         this.client.modules.options.events = options;
-        const files = this.readdir(options.directory);
+        const files = this.readdir(options.directory, 'Events');
         for (const file of files) {
             const filepath = `${path.resolve(options.directory)}\\${file}`;
             const event = await this.load(filepath, 'Event');

package/dist/handlers/Handler.d.ts

@@ -4,11 +4,20 @@ import MessageCommandBuilder from '../build/XernerxMessageCommand.js';
 import XernerxSlashCommand from '../build/XernerxSlashCommand.js';
 import XernerxContextCommand from '../build/XernerxContextCommand.js';
 import { filetype } from '../types/types.js';
+import { XernerxClientEvents, XernerxEvent, XernerxInhibitor } from '../main.js';
 export default class Handler {
-    readonly client: XernerxClient;
+    readonly client: XernerxClient<unknown>;
     readonly files: Array<MessageCommandBuilder | XernerxSlashCommand | XernerxContextCommand>;
     constructor(client: XernerxClient);
-    readdir(dir: string): string[];
+    readdir(dir: string, type: string): string[];
     load(filepath: string, type: filetype): Promise<any>;
-    emit<T extends Record<string, string | boolean | Function | void>>(event: T): Promise<void>;
+    /**
+     * Emits a file that has been loaded into the handler.
+     * @param file - The file to emit.
+     */
+    emit<File extends {
+        name: string;
+        filetype: 'MessageCommand' | 'SlashCommand' | 'ContextCommand';
+        run: Function;
+    } | XernerxInhibitor | XernerxEvent<keyof XernerxClientEvents>>(file: File): Promise<void>;
 }

package/dist/handlers/Handler.js

@@ -2,6 +2,8 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import load from '../functions/load.js';
+import { Style } from '../main.js';
+import XernerxLog from '../tools/XernerxLog.js';
 export default class Handler {
     client;
     files;
@@ -9,12 +11,12 @@ export default class Handler {
         this.client = client;
         this.files = [];
     }
-    readdir(dir) {
+    readdir(dir, type) {
         try {
             return fs.readdirSync(path.resolve(dir)).filter((file) => file.endsWith('.js'));
         }
         catch (error) {
-            console.error(error);
+            new XernerxLog(this.client).error(`Cannot load ${type.toLowerCase()}, there is no such directory ${Style.log(dir, { color: Style.BackgroundColor.Grey })}.`);
         }
         return [];
     }
@@ -23,23 +25,32 @@ export default class Handler {
         this.files.push(file);
         return file;
     }
-    async emit(event) {
-        if (!event?.filetype)
+    /**
+     * Emits a file that has been loaded into the handler.
+     * @param file - The file to emit.
+     */
+    async emit(file) {
+        if (!file?.filetype)
             return;
-        if (event.filetype === 'Event') {
-            if (event.emitter === 'client')
-                event.once
-                    ? this.client.once(event.name, (...args) => event.run(...args))
-                    : this.client.on(event.name, (...args) => event.run(...args));
-            else if (event.emitter === 'process')
-                event.once
-                    ? process.once(event.name, (...args) => event.run(...args))
-                    : process.on(event.name, (...args) => event.run(...args));
+        if (file.filetype === 'Inhibitor')
+            return;
+        if (file.filetype === 'Event' && file.emitter) {
+            if (file.emitter === 'client') {
+                this.client[file.once ? 'once' : 'on'](file.name, (...args) => file.run(...args));
+            }
+            else if (file.emitter === 'process') {
+                process[file.once ? 'once' : 'on'](file.name, (...args) => file.run(...args));
+            }
+            else if (file.emitter === 'rest') {
+                this.client.rest[file.once ? 'once' : 'on'](file.name, (...args) => file.run(...args));
+            }
+            else {
+                // @ts-expect-error
+                this.client[file.emitter][file.once ? 'once' : 'on'](file.name, (...args) => file.run(...args));
+            }
         }
-        if (['MessageCommand', 'SlashCommand', 'ContextCommand'].includes(event.filetype)) {
-            event.once
-                ? this.client.once(event.name, (...args) => event.run(...args))
-                : this.client.on(event.name, (...args) => event.run(...args));
+        else {
+            this.client.on(file.name, (...args) => file.run(...args));
         }
     }
 }

package/dist/handlers/InhibitorHandler.js

@@ -17,7 +17,7 @@ export default class InhibitorHandler extends Handler {
         })
             .parse(options);
         this.client.modules.options.inhibitors = options;
-        const files = this.readdir(options.directory);
+        const files = this.readdir(options.directory, 'Inhibitors');
         for (const file of files) {
             const filepath = `${path.resolve(options.directory)}\\${file}`;
             const inhibitor = await this.load(filepath, 'Inhibitor');

package/dist/tools/XernerxIntents.d.ts

@@ -1,5 +1,6 @@
 /** @format */
+import { GatewayIntentBits } from 'discord.js';
 export declare const XernerxIntents: {
-    Default: string[];
-    All: string[];
+    Default: GatewayIntentBits[];
+    All: GatewayIntentBits[];
 };

package/dist/tools/XernerxIntents.js

@@ -1,24 +1,26 @@
 /** @format */
+import { GatewayIntentBits } from 'discord.js';
 export const XernerxIntents = {
     Default: [
-        'Guilds',
-        'GuildModeration',
-        'GuildBans',
-        'GuildEmojisAndStickers',
-        'GuildIntegrations',
-        'GuildWebhooks',
-        'GuildInvites',
-        'GuildVoiceStates',
-        'GuildMessages',
-        'GuildMessageReactions',
-        'GuildMessageTyping',
-        'DirectMessages',
-        'DirectMessageReactions',
-        'DirectMessageTyping',
-        'GuildScheduledEvents',
-        'AutoModerationConfiguration',
-        'AutoModerationExecution',
+        GatewayIntentBits.Guilds,
+        GatewayIntentBits.GuildModeration,
+        GatewayIntentBits.GuildBans,
+        GatewayIntentBits.GuildModeration,
+        GatewayIntentBits.GuildEmojisAndStickers,
+        GatewayIntentBits.GuildIntegrations,
+        GatewayIntentBits.GuildWebhooks,
+        GatewayIntentBits.GuildInvites,
+        GatewayIntentBits.GuildVoiceStates,
+        GatewayIntentBits.GuildMessages,
+        GatewayIntentBits.GuildMessageReactions,
+        GatewayIntentBits.GuildMessageTyping,
+        GatewayIntentBits.DirectMessages,
+        GatewayIntentBits.DirectMessageReactions,
+        GatewayIntentBits.DirectMessageTyping,
+        GatewayIntentBits.GuildScheduledEvents,
+        GatewayIntentBits.AutoModerationConfiguration,
+        GatewayIntentBits.AutoModerationExecution,
     ],
-    All: [''],
+    All: [GatewayIntentBits.GuildMembers, GatewayIntentBits.GuildPresences, GatewayIntentBits.MessageContent],
 };
-XernerxIntents.All = [...XernerxIntents.Default, 'GuildMembers', 'GuildPresences', 'MessageContent'];
+XernerxIntents.All.push(...XernerxIntents.Default);

package/dist/types/extenders.d.ts

@@ -1,5 +1,5 @@
 /** @format */
-import { ChatInputCommandInteraction, Collection, DMChannel, Guild, GuildChannel, GuildMember, Message, MessageContextMenuCommandInteraction, User, UserContextMenuCommandInteraction } from 'discord.js';
+import { ChatInputCommandInteraction, Collection, DMChannel, Guild, GuildChannel, GuildMember, Message, MessageContextMenuCommandInteraction, User, UserContextMenuCommandInteraction, ClientEvents } from 'discord.js';
 import InteractionUtil from '../utils/InteractionUtil.js';
 import MessageUtil from '../utils/MessageUtil.js';
 import { ModuleOptions, XernerxCache, XernerxCommands } from '../types/interfaces.js';
@@ -7,6 +7,8 @@ import XernerxEvent from '../build/XernerxEvent.js';
 import XernerxInhibitor from '../build/XernerxInhibitor.js';
 import XernerxClient from '../client/XernerxClient.js';
 import ClientUtil from '../utils/ClientUtil.js';
+import { XernerxContextCommand, XernerxMessageCommand, XernerxSlashCommand } from '../main.js';
+import XernerxError from '../tools/XernerxError.js';
 export interface XernerxUser extends User {
     owner: boolean;
     voted: boolean | null;
@@ -40,7 +42,7 @@ export interface XernerxMessageContextInteraction extends MessageContextMenuComm
 }
 export interface XernerxClientType extends XernerxClient {
     commands: XernerxCommands;
-    events: Collection<string, XernerxEvent>;
+    events: Collection<string, XernerxEvent<keyof XernerxClientEvents>>;
     inhibitors: Collection<string, XernerxInhibitor>;
     modules: ModuleOptions;
     util: ClientUtil;
@@ -58,4 +60,17 @@ export interface XernerxClientType extends XernerxClient {
     cache: XernerxCache;
     connect: () => Promise<string>;
 }
+interface CommandBlockInfo {
+    reason: string;
+    message: string;
+    required: Array<string> | string;
+    missing: Array<string> | string;
+}
+export interface XernerxClientEvents extends ClientEvents {
+    commandBlock: [event: XernerxMessage | XernerxSlashInteraction, info: CommandBlockInfo, command: XernerxSlashCommand | XernerxMessageCommand | XernerxContextCommand];
+    commandError: [event: XernerxMessage | XernerxSlashInteraction, error: XernerxError, command: XernerxSlashCommand | XernerxMessageCommand | XernerxContextCommand];
+    commandStart: [event: XernerxMessage | XernerxSlashInteraction, command: XernerxSlashCommand | XernerxMessageCommand | XernerxContextCommand];
+    commandFinish: [event: XernerxMessage | XernerxSlashInteraction, command: XernerxSlashCommand | XernerxMessageCommand | XernerxContextCommand];
+    commandNotFound: [event: XernerxMessage | XernerxSlashInteraction, commandName: string, filetype: 'MessageCommand' | 'SlashCommand' | 'ContextCommand'];
+}
 export {};

package/dist/types/interfaces.d.ts

@@ -7,9 +7,9 @@ import IntegrationHandler from '../handlers/IntegrationHandler.js';
 import XernerxContextCommand from '../build/XernerxContextCommand.js';
 import MessageCommandBuilder from '../build/XernerxMessageCommand.js';
 import XernerxSlashCommand from '../build/XernerxSlashCommand.js';
-import { Locales, MessageCommandArgumentType, PermissionNames, SlashCommandArgumentType, XernerxEventType, InhibitorType } from './types.js';
+import { Locales, MessageCommandArgumentType, PermissionNames, SlashCommandArgumentType, InhibitorType } from './types.js';
 import ExtensionHandler from '../handlers/ExtensionHandler.js';
-import { XernerxMessage, XernerxUser } from './extenders.js';
+import { XernerxClientEvents, XernerxMessage, XernerxUser } from './extenders.js';
 export interface XernerxOptions {
     local: string;
     global?: boolean;
@@ -223,7 +223,7 @@ export interface SlashCommandArguments<T = SlashCommandArgumentType> {
     group: string;
 }
 export interface XernerxEventOptions {
-    name: XernerxEventType;
+    name: keyof XernerxClientEvents;
     emitter?: 'client' | 'process';
     type?: 'discord' | 'node';
     once?: boolean;

package/dist/types/types.d.ts

@@ -7,8 +7,6 @@ export type SlashCommandArgumentType = 'attachment' | 'boolean' | 'channel' | 'i
 export type SlashCommandOptionChoices = SlashCommandStringOption | SlashCommandNumberOption | SlashCommandIntegerOption;
 export type SlashCommandOption = SlashCommandOptionChoices | SlashCommandBooleanOption | SlashCommandUserOption | SlashCommandChannelOption | SlashCommandRoleOption | SlashCommandMentionableOption;
 export type MessageCommandArgumentType = 'string' | 'number' | 'boolean' | 'confirm' | 'channel' | 'guild' | 'integer' | 'mentionable' | 'role' | 'user' | 'message' | 'member' | 'list' | 'option' | 'rest';
-export type DiscordEventType = 'applicationCommandPermissionsUpdate' | 'autoModerationActionExecution' | 'autoModerationRuleCreate' | 'autoModerationRuleDelete' | 'autoModerationRuleUpdate' | 'ready' | 'guildCreate' | 'guildDelete' | 'guildUpdate' | 'guildUnavailable' | 'guildMemberAdd' | 'guildMemberRemove' | 'guildMemberUpdate' | 'guildMemberAvailable' | 'guildMembersChunk' | 'guildIntegrationsUpdate' | 'roleCreate' | 'roleDelete' | 'inviteCreate' | 'inviteDelete' | 'roleUpdate' | 'emojiCreate' | 'emojiDelete' | 'emojiUpdate' | 'guildBanAdd' | 'guildBanRemove' | 'channelCreate' | 'channelDelete' | 'channelUpdate' | 'channelPinsUpdate' | 'messageCreate' | 'messageDelete' | 'messageUpdate' | 'messageDeleteBulk' | 'messageReactionAdd' | 'messageReactionRemove' | 'messageReactionRemoveAll' | 'messageReactionRemoveEmoji' | 'threadCreate' | 'threadDelete' | 'threadUpdate' | 'threadListSync' | 'threadMemberUpdate' | 'threadMembersUpdate' | 'userUpdate' | 'presenceUpdate' | 'voiceServerUpdate' | 'voiceStateUpdate' | 'typingStart' | 'webhookUpdate' | 'interactionCreate' | 'error' | 'warn' | 'debug' | 'cacheSweep' | 'shardDisconnect' | 'shardError' | 'shardReconnecting' | 'shardReady' | 'shardResume' | 'invalidated' | 'raw' | 'stageInstanceCreate' | 'stageInstanceUpdate' | 'stageInstanceDelete' | 'stickerCreate' | 'stickerDelete' | 'stickerUpdate' | 'guildScheduledEventCreate' | 'guildScheduledEventUpdate' | 'guildScheduledEventDelete' | 'guildScheduledEventUserAdd' | 'guildScheduledEventUserRemove';
-export type XernerxEventType = DiscordEventType | 'webhookCreate' | 'webhookError' | 'commandBlock' | 'commandError' | 'commandStart' | 'commandFinish' | 'commandCooldown';
 export type XernerxInteraction<T extends XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction> = T extends XernerxSlashInteraction ? XernerxSlashInteraction : T extends XernerxUserContextInteraction ? XernerxUserContextInteraction : XernerxMessageContextInteraction;
 export type PermissionNames = 'create instant invite' | 'kick members' | 'ban members' | 'administrator' | 'manage channels' | 'manage guild' | 'add reactions' | 'view audit log' | 'priority speaker' | 'stream' | 'view channel' | 'send messages' | 'send tts messages' | 'manage messages' | 'embed links' | 'attach files' | 'read message history' | 'mention everyone' | 'use external emojis' | 'view guild insights' | 'connect' | 'speak' | 'mute members' | 'deafen members' | 'move members' | 'use vad' | 'change nickname' | 'manage nicknames' | 'manage roles' | 'manage webhooks' | 'manage emojis and stickers' | 'use application commands' | 'request to speak' | 'manage events' | 'manage threads' | 'create public threads' | 'create private threads' | 'use external stickers' | 'send messages in threads' | 'start embedded activities' | 'moderate members';
 export type InhibitorType = '*' | 'message' | 'interaction' | 'command' | 'channel' | 'user' | 'member' | 'guild' | 'contextCommand' | 'messageCommand' | 'slashCommand';

package/dist/utils/Util.d.ts

@@ -2,7 +2,7 @@
 import XernerxClient from '../client/XernerxClient.js';
 import XernerxText from '../tools/XernerxText.js';
 export default class Util {
-    readonly client: XernerxClient;
+    readonly client: XernerxClient<unknown>;
     readonly text: XernerxText;
     constructor(client: XernerxClient);
     delay(time: number): Promise<unknown>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "xernerx",
-	"version": "4.17.0",
+	"version": "4.17.2",
 	"description": "A bot framework for discord.js.",
 	"main": "dist/main.js",
 	"type": "module",