xernerx 4.7.0 → 4.8.0

package/dist/build/XernerxContextCommand.d.ts

@@ -2,6 +2,7 @@
 import { ContextMenuCommandBuilder } from 'discord.js';
 import { XernerxMessageContextInteraction, XernerxUserContextInteraction, XernerxClientType } from '../types/extenders.js';
 import { ContextCommandArguments, ContextCommandOptions } from '../types/interfaces.js';
+import InteractionUtil from '../utils/InteractionUtil.js';
 export default class XernerxContextCommand {
     readonly id: string;
     readonly data: ContextMenuCommandBuilder;
@@ -29,8 +30,8 @@ export default class XernerxContextCommand {
         voice?: boolean | undefined;
     } | undefined;
     readonly permissions: {
-        user?: string[] | import("../main.js").PermissionNames[] | undefined;
-        client?: string[] | import("../main.js").PermissionNames[] | undefined;
+        user?: string[] | import("../main.js").PermissionNames[] | null | undefined;
+        client?: string[] | import("../main.js").PermissionNames[] | null | undefined;
         dm?: boolean | undefined;
     } | undefined;
     readonly defer: {
@@ -41,6 +42,7 @@ export default class XernerxContextCommand {
     readonly filetype: 'ContextCommand';
     readonly filepath: string;
     readonly client: XernerxClientType;
+    util: InteractionUtil;
     constructor(id: string, options: ContextCommandOptions);
     /**
      * @description the execution of the command

package/dist/build/XernerxContextCommand.js

@@ -79,8 +79,8 @@ export default class XernerxContextCommand {
                 .default({}),
             permissions: z
                 .object({
-                user: z.array(z.string()).default([]),
-                client: z.array(z.string()).default([]),
+                user: z.array(z.string()).or(z.null()).default(null),
+                client: z.array(z.string()).or(z.null()).default(null),
                 dm: z.boolean().default(true),
             })
                 .default({}),
@@ -107,6 +107,7 @@ export default class XernerxContextCommand {
         this.permissions = options.permissions;
         this.defer = options.defer;
         this.client = this.client;
+        this.util = this.util;
     }
     /**
      * @description the execution of the command

package/dist/build/XernerxMessageCommand.d.ts

@@ -1,6 +1,7 @@
 /** @format */
 import { XernerxClientType, XernerxMessage } from '../types/extenders.js';
 import { MessageCommandArguments, MessageCommandOptions } from '../types/interfaces.js';
+import MessageUtil from '../utils/MessageUtil.js';
 export default class XernerxMessageCommand {
     readonly id: string;
     readonly name: string;
@@ -32,13 +33,14 @@ export default class XernerxMessageCommand {
         voice?: boolean | undefined;
     } | undefined;
     readonly permissions: {
-        user?: string[] | import("../main.js").PermissionNames[] | undefined;
-        client?: string[] | import("../main.js").PermissionNames[] | undefined;
+        user?: string[] | import("../main.js").PermissionNames[] | null | undefined;
+        client?: string[] | import("../main.js").PermissionNames[] | null | undefined;
         dm?: boolean | undefined;
     } | undefined;
     readonly filetype: 'MessageCommand';
     readonly filepath: string;
     readonly client: XernerxClientType;
+    util: MessageUtil;
     constructor(id: string, options: MessageCommandOptions);
     /**
      * @description Checks for conditions before running the command

package/dist/build/XernerxMessageCommand.js

@@ -77,8 +77,8 @@ export default class XernerxMessageCommand {
                 .default({}),
             permissions: z
                 .object({
-                user: z.array(z.string()).default([]),
-                client: z.array(z.string()).default([]),
+                user: z.array(z.string()).or(z.null()).default(null),
+                client: z.array(z.string()).or(z.null()).default(null),
                 dm: z.boolean().default(true),
             })
                 .default({}),
@@ -99,6 +99,7 @@ export default class XernerxMessageCommand {
         this.separator = options.separator;
         this.permissions = options.permissions;
         this.client = this.client;
+        this.util = this.util;
     }
     /**
      * @description Checks for conditions before running the command

package/dist/build/XernerxSlashCommand.d.ts

@@ -3,6 +3,7 @@ import Discord from 'discord.js';
 import { XernerxClientType, XernerxMessageContextInteraction, XernerxSlashInteraction, XernerxUserContextInteraction } from '../types/extenders.js';
 import { SlashCommandArguments, SlashCommandOptions } from '../types/interfaces.js';
 import { XernerxInteraction } from '../types/types.js';
+import InteractionUtil from '../utils/InteractionUtil.js';
 export default class XernerxSlashCommand {
     readonly id: string;
     readonly data: Discord.SlashCommandBuilder;
@@ -29,8 +30,8 @@ export default class XernerxSlashCommand {
         voice?: boolean | undefined;
     } | undefined;
     readonly permissions: {
-        user?: string[] | import("../main.js").PermissionNames[] | undefined;
-        client?: string[] | import("../main.js").PermissionNames[] | undefined;
+        user?: string[] | import("../main.js").PermissionNames[] | null | undefined;
+        client?: string[] | import("../main.js").PermissionNames[] | null | undefined;
         dm?: boolean | undefined;
     } | undefined;
     readonly defer: {
@@ -41,6 +42,7 @@ export default class XernerxSlashCommand {
     readonly filetype: 'SlashCommand';
     readonly filepath: string;
     readonly client: XernerxClientType;
+    util: InteractionUtil;
     constructor(id: string, options: SlashCommandOptions);
     /**
      * @description autocomplete let's you add choices to string option arguments

package/dist/build/XernerxSlashCommand.js

@@ -88,8 +88,8 @@ export default class XernerxSlashCommand {
                 .default({}),
             permissions: z
                 .object({
-                user: z.array(z.string()).default([]),
-                client: z.array(z.string()).default([]),
+                user: z.array(z.string()).or(z.null()).default(null),
+                client: z.array(z.string()).or(z.null()).default(null),
                 dm: z.boolean().default(true),
             })
                 .default({}),
@@ -115,6 +115,7 @@ export default class XernerxSlashCommand {
         this.permissions = options.permissions;
         this.defer = options.defer;
         this.client = this.client;
+        this.util = this.util;
     }
     /**
      * @description autocomplete let's you add choices to string option arguments

package/dist/client/XernerxClient.d.ts

@@ -3,14 +3,15 @@ import { Client, ClientOptions, Collection } from 'discord.js';
 import { XernerxOptions, ModuleOptions, XernerxCommands, XernerxCache } from '../types/interfaces.js';
 import ClientUtil from '../utils/ClientUtil.js';
 import { XernerxInhibitor, XernerxEvent } from '../main.js';
-export default class XernerxClient<T = unknown> extends Client {
+import Cooldowns from '../models/Cooldowns.js';
+export default class XernerxClient extends Client {
     readonly settings: {
         ownerId: (string | string[]) & (string | string[] | undefined);
         local: string;
         global?: boolean | undefined;
         permissions?: {
-            client: string[];
-            user: string[];
+            user: string[] | null;
+            client: string[] | null;
             dm: boolean;
         } | undefined;
         ignore?: {
@@ -32,9 +33,10 @@ export default class XernerxClient<T = unknown> extends Client {
         cooldown?: {
             command: number;
             cache: number;
+            collections: string[];
         } | undefined;
     };
-    readonly config: NonNullable<T> | null;
+    readonly config: {} | null;
     readonly commands: XernerxCommands;
     readonly events: Collection<string, XernerxEvent>;
     readonly inhibitors: Collection<string, XernerxInhibitor>;
@@ -42,6 +44,7 @@ export default class XernerxClient<T = unknown> extends Client {
     readonly util: ClientUtil;
     readonly stats: Record<string, number>;
     readonly cache: XernerxCache;
-    constructor(discordOptions: ClientOptions, xernerxOptions: XernerxOptions, config?: T);
+    readonly cooldowns: Cooldowns;
+    constructor(discordOptions: ClientOptions, xernerxOptions: XernerxOptions, config?: unknown);
     connect(token: string): Promise<string>;
 }

package/dist/client/XernerxClient.js

@@ -9,6 +9,7 @@ import XernerxLog from '../tools/XernerxLog.js';
 import ClientUtil from '../utils/ClientUtil.js';
 import ExtensionHandler from '../handlers/ExtensionHandler.js';
 import deploy from '../functions/deploy.js';
+import Cooldowns from '../models/Cooldowns.js';
 export default class XernerxClient extends Client {
     constructor(discordOptions, xernerxOptions, config) {
         super(discordOptions);
@@ -19,8 +20,8 @@ export default class XernerxClient extends Client {
             ownerId: z.string().or(z.array(z.string())).default([]),
             permissions: z
                 .object({
-                client: z.array(z.string()).default([]),
-                user: z.array(z.string()).default([]),
+                client: z.array(z.string()).or(z.null()).default(null),
+                user: z.array(z.string()).or(z.null()).default(null),
                 dm: z.boolean().default(false),
             })
                 .optional(),
@@ -49,6 +50,7 @@ export default class XernerxClient extends Client {
                 .object({
                 command: z.number().default(0),
                 cache: z.number().default(0),
+                collections: z.array(z.string()).default(['commands']),
             })
                 .optional(),
         })
@@ -80,6 +82,7 @@ export default class XernerxClient extends Client {
             messages: new Collection(),
             cooldowns: new Collection(),
         };
+        this.cooldowns = new Cooldowns(this, xernerxOptions.cooldown?.collections);
         return this;
     }
     async connect(token) {

package/dist/functions/load.js

@@ -6,6 +6,7 @@ export default async function load(client, path, type) {
         file.filetype = type;
         file.filepath = path;
         file.client = client;
+        file.util = {};
         fileSave(client, file, type);
         return file;
     }

package/dist/functions/reload.d.ts

@@ -1,3 +1,3 @@
 /** @format */
-import XernerxClient from '../client/XernerxClient.js';
-export default function reload(client: XernerxClient, type: 'message' | 'slash' | 'context' | 'event' | 'inhibitor'): Promise<any>[];
+import { XernerxClient } from '../main.js';
+export default function reload(client: XernerxClient, type: 'commands' | 'context' | 'message' | 'slash' | 'events' | 'inhibitors'): Promise<true | void | null>;

package/dist/functions/reload.js

@@ -1,43 +1,30 @@
 /** @format */
-var filetypes;
-(function (filetypes) {
-    filetypes["message"] = "MessageCommand";
-    filetypes["slash"] = "SlashCommand";
-    filetypes["context"] = "ContextCommand";
-    filetypes["event"] = "Event";
-    filetypes["inhibitor"] = "Inhibitor";
-})(filetypes || (filetypes = {}));
-export default function reload(client, type) {
-    const files = [];
-    if (type === 'message' || type === 'slash' || type === 'context') {
-        for (const [name] of client.commands[type]) {
-            files.push(client.commands[type].get(name).filepath);
+import * as path from 'path';
+import * as fs from 'fs';
+import load from './load.js';
+export default async function reload(client, type) {
+    switch (type) {
+        case 'message': {
+            client.commands.message.clear();
+            if (!client.modules.options.message)
+                return null;
+            const directory = path.resolve(client.modules.options.message?.directory);
+            for (const file of fs.readdirSync(directory)) {
+                load(client, `${directory}\\${file}`, 'MessageCommand');
+            }
+            return true;
         }
-        client.commands[type].sweep(() => true);
-    }
-    if (type === 'event') {
-        for (const [name] of client.events) {
-            files.push(client.events.get(name).filepath);
+        case 'slash': {
+            return client.commands.slash.clear();
         }
-        client.events.sweep(() => true);
-    }
-    if (type === 'inhibitor') {
-        for (const [name] of client.inhibitors) {
-            files.push(client.inhibitors.get(name).filepath);
+        case 'context': {
+            return client.commands.context.clear();
+        }
+        case 'events': {
+            return client.events.clear();
+        }
+        case 'inhibitors': {
+            return client.inhibitors.clear();
         }
-        client.inhibitors.sweep(() => true);
     }
-    return files.map(async (file) => {
-        let filedata = new (await import(`file://${file}`)).default();
-        filedata.filetype = filetypes[type];
-        filedata.filepath = file;
-        filedata.client = client;
-        if (type === 'message' || type === 'slash' || type === 'context')
-            client.commands[type].set(filedata.name, filedata);
-        if (type === 'event')
-            client.events.set(filedata.name, filedata);
-        if (type === 'inhibitor')
-            client.inhibitors.set(filedata.name, filedata);
-        return filedata;
-    });
 }

package/dist/handlers/CommandHandler.d.ts

@@ -3,10 +3,11 @@ import XernerxClient from '../client/XernerxClient.js';
 import { ContextHandlerOptions, MessageHandlerOptions, SlashHandlerOptions } from '../types/interfaces.js';
 import Handler from './Handler.js';
 export default class CommandHandler extends Handler {
+    readonly readyTimestamp: number;
     constructor(client: XernerxClient);
     loadMessageCommands(options: MessageHandlerOptions): Promise<void>;
-    loadSlashCommands(options: SlashHandlerOptions): void;
-    loadContextCommands(options: ContextHandlerOptions): void;
+    loadSlashCommands(options: SlashHandlerOptions): Promise<void>;
+    loadContextCommands(options: ContextHandlerOptions): Promise<void>;
     private messageCommandRun;
     private slashCommandRun;
     private contextCommandRun;

package/dist/handlers/CommandHandler.js

@@ -14,8 +14,10 @@ import { Style } from 'dumfunctions';
 export default class CommandHandler extends Handler {
     constructor(client) {
         super(client);
+        this.readyTimestamp = Number(Date.now());
     }
     async loadMessageCommands(options) {
+        const commands = [];
         if (!this.client.options.intents.has(GatewayIntentBits.MessageContent))
             new XernerxLog(this.client).warn(`Message commands might not work as you're missing the intent MessageContent!`);
         if (!this.client.options.intents.has(GatewayIntentBits.GuildMessages))
@@ -28,8 +30,8 @@ export default class CommandHandler extends Handler {
             cooldown: z.number().default(0),
             permissions: z
                 .object({
-                user: z.array(z.string()).default([]),
-                client: z.array(z.string()).default([]),
+                user: z.array(z.string()).or(z.null()).default(null),
+                client: z.array(z.string()).or(z.null()).default(null),
                 dm: z.boolean().default(true),
             })
                 .default({}),
@@ -45,8 +47,9 @@ export default class CommandHandler extends Handler {
             const filepath = `${path.resolve(options.directory)}\\${file}`;
             const command = await this.load(filepath, 'MessageCommand');
             this._checks(command);
+            commands.push(command.id);
         }
-        new XernerxLog(this.client).info(`Loaded ${Style.log(String(files.length), { color: Style.TextColor.Cyan })} Message Commands.`);
+        new XernerxLog(this.client).info(`Loaded ${Style.log(String(files.length), { color: Style.TextColor.Cyan })} Message Commands: ${commands.map((command) => Style.log(command, { color: Style.TextColor.LightYellow })).join(', ')}`);
         this.emit({
             name: 'messageCreate',
             filetype: 'MessageCommand',
@@ -64,9 +67,10 @@ export default class CommandHandler extends Handler {
         });
     }
     // public reloadMessageCommands() {
-    //     return reload(this.client, 'message');
+    // 	return reload(this.client, 'message');
     // }
-    loadSlashCommands(options) {
+    async loadSlashCommands(options) {
+        const commands = [];
         if (!this.client.settings.local)
             new XernerxLog(this.client).warn(`Slash commands might not work as you haven't specified a local guild ID.`);
         options = z
@@ -75,8 +79,8 @@ export default class CommandHandler extends Handler {
             cooldown: z.number().default(0),
             permissions: z
                 .object({
-                user: z.array(z.string()).default([]),
-                client: z.array(z.string()).default([]),
+                user: z.array(z.string()).or(z.null()).default(null),
+                client: z.array(z.string()).or(z.null()).default(null),
                 dm: z.boolean().default(true),
             })
                 .default({}),
@@ -94,16 +98,18 @@ export default class CommandHandler extends Handler {
         const files = this.readdir(options.directory);
         for (const file of files) {
             const filepath = `${path.resolve(options.directory)}\\${file}`;
-            this.load(filepath, 'SlashCommand');
+            const command = await this.load(filepath, 'SlashCommand');
+            commands.push(command.id);
         }
-        new XernerxLog(this.client).info(`Loaded ${Style.log(String(files.length), { color: Style.TextColor.Cyan })} Slash Commands.`);
+        new XernerxLog(this.client).info(`Loaded ${Style.log(String(files.length), { color: Style.TextColor.Cyan })} Slash Commands: ${commands.map((command) => Style.log(command, { color: Style.TextColor.LightYellow })).join(', ')}`);
         this.emit({
             name: 'interactionCreate',
             filetype: 'SlashCommand',
             run: (interaction) => this.slashCommandRun(interaction),
         });
     }
-    loadContextCommands(options) {
+    async loadContextCommands(options) {
+        const commands = [];
         if (!this.client.settings.local)
             new XernerxLog(this.client).warn(`Context commands might not work as you haven't specified a local guild ID.`);
         options = z
@@ -112,8 +118,8 @@ export default class CommandHandler extends Handler {
             cooldown: z.number().default(0),
             permissions: z
                 .object({
-                user: z.array(z.string()).default([]),
-                client: z.array(z.string()).default([]),
+                user: z.array(z.string()).or(z.null()).default(null),
+                client: z.array(z.string()).or(z.null()).default(null),
                 dm: z.boolean().default(true),
             })
                 .default({}),
@@ -131,9 +137,10 @@ export default class CommandHandler extends Handler {
         const files = this.readdir(options.directory);
         for (const file of files) {
             const filepath = `${path.resolve(options.directory)}\\${file}`;
-            this.load(filepath, 'ContextCommand');
+            const command = await this.load(filepath, 'ContextCommand');
+            commands.push(command.id);
         }
-        new XernerxLog(this.client).info(`Loaded ${Style.log(String(files.length), { color: Style.TextColor.Cyan })} Context Commands.`);
+        new XernerxLog(this.client).info(`Loaded ${Style.log(String(files.length), { color: Style.TextColor.Cyan })} Context Commands: ${commands.map((command) => Style.log(command, { color: Style.TextColor.LightYellow })).join(', ')}`);
         this.emit({
             name: 'interactionCreate',
             filetype: 'ContextCommand',
@@ -231,12 +238,15 @@ export default class CommandHandler extends Handler {
                 return;
             if (!cmd)
                 return await this.client.emit('commandNotFound', message, commandName, filetype);
+            await this.client.emit('commandStart', message, cmd, filetype);
+            const args = await messageArguments(message, cmd, commandPrefix);
             message.util.parsed = {
                 alias: commandAlias,
                 prefix: commandPrefix,
+                args: args.args,
             };
-            this.client.emit('commandStart', message, cmd, filetype);
-            return await this.exec(cmd, message, await messageArguments(message, cmd, commandPrefix), filetype);
+            cmd.util = message.util;
+            return await this.exec(cmd, message, args, filetype);
         }
     }
     async slashCommandRun(interaction) {
@@ -260,8 +270,14 @@ export default class CommandHandler extends Handler {
                 resolve(true);
         })
             .then(async () => {
-            this.client.emit('commandStart', interaction, filetype);
-            return await this.exec(cmd, interaction, await interactionArguments(interaction, cmd), filetype);
+            await this.client.emit('commandStart', interaction, filetype);
+            const args = await interactionArguments(interaction, cmd);
+            interaction.util.parsed = {
+                alias: interaction.commandName + (args.group || '') + (args.subcommand || ''),
+                args: args.args,
+            };
+            cmd.util = interaction.util;
+            return await this.exec(cmd, interaction, args, filetype);
         })
             .catch((error) => this.client.emit('commandError', interaction, error, cmd, filetype));
     }
@@ -276,8 +292,14 @@ export default class CommandHandler extends Handler {
             cmd = this.client.commands.context.get(interaction.commandName);
         if (!cmd)
             return this.client.emit('commandNotFound', interaction, interaction.commandName, filetype);
-        this.client.emit('commandStart', interaction, filetype);
-        return await this.exec(cmd, interaction, await interactionArguments(interaction, cmd), filetype);
+        await this.client.emit('commandStart', interaction, filetype);
+        const args = await interactionArguments(interaction, cmd);
+        interaction.util.parsed = {
+            alias: interaction.commandName,
+            args: args,
+        };
+        cmd.util = interaction.util;
+        return await this.exec(cmd, interaction, args, filetype);
     }
     async exec(cmd, event, args, type) {
         try {

package/dist/handlers/EventHandler.d.ts

@@ -3,6 +3,7 @@ import XernerxClient from '../client/XernerxClient.js';
 import { EventHandlerOptions } from '../types/interfaces.js';
 import Handler from './Handler.js';
 export default class EventHandler extends Handler {
+    readonly readyTimestamp: number;
     constructor(client: XernerxClient);
     loadEvents(options: EventHandlerOptions): Promise<void>;
 }

package/dist/handlers/EventHandler.js

@@ -7,8 +7,10 @@ import { Style } from 'dumfunctions';
 export default class EventHandler extends Handler {
     constructor(client) {
         super(client);
+        this.readyTimestamp = Number(Date.now());
     }
     async loadEvents(options) {
+        const events = [];
         options = z
             .object({
             directory: z.string(),
@@ -18,9 +20,10 @@ export default class EventHandler extends Handler {
         const files = this.readdir(options.directory);
         for (const file of files) {
             const filepath = `${path.resolve(options.directory)}\\${file}`;
-            const data = await this.load(filepath, 'Event');
-            this.emit(data);
+            const event = await this.load(filepath, 'Event');
+            this.emit(event);
+            events.push(event.id);
         }
-        new XernerxLog(this.client).info(`Loaded ${Style.log(String(this.client.events.size), { color: Style.TextColor.Cyan })} Events.`);
+        new XernerxLog(this.client).info(`Loaded ${Style.log(String(this.client.events.size), { color: Style.TextColor.Cyan })} Events: ${events.map((event) => Style.log(event, { color: Style.TextColor.LightYellow })).join(', ')}`);
     }
 }

package/dist/handlers/ExtensionHandler.d.ts

@@ -3,6 +3,7 @@ import XernerxExtensionBuilder from 'xernerx-extension-builder';
 import XernerxClient from '../client/XernerxClient.js';
 import Handler from './Handler.js';
 export default class ExtensionHandler extends Handler {
+    readonly readyTimestamp: number;
     constructor(client: XernerxClient);
     loadExtensions(...extensions: Array<XernerxExtensionBuilder>): void;
 }

package/dist/handlers/ExtensionHandler.js

@@ -5,6 +5,7 @@ import { Style } from 'dumfunctions';
 export default class ExtensionHandler extends Handler {
     constructor(client) {
         super(client);
+        this.readyTimestamp = Number(Date.now());
     }
     loadExtensions(...extensions) {
         const active = extensions.map((extension) => {
@@ -17,9 +18,12 @@ export default class ExtensionHandler extends Handler {
                 return extension.name;
             }
             catch (error) {
-                return new XernerxLog(this.client).error(`An error occurred while loading ${Style.log(extension.name, { color: Style.TextColor.Blue })}`, error);
+                return new XernerxLog(this.client).error(`An error occurred while loading ${Style.log(extension.name, { color: Style.TextColor.Red })}`, error);
             }
         });
-        new XernerxLog(this.client).info(`Loaded ${Style.log(String(extensions.length), { color: Style.TextColor.Cyan })} Extensions: ${active.filter((e) => e).join(', ')}`);
+        new XernerxLog(this.client).info(`Loaded ${Style.log(String(extensions.length), { color: Style.TextColor.Cyan })} Extensions: ${active
+            .filter((e) => e)
+            .map((event) => Style.log(event, { color: Style.TextColor.LightYellow }))
+            .join(', ')}`);
     }
 }

package/dist/handlers/Handler.d.ts

@@ -5,9 +5,8 @@ import XernerxSlashCommand from '../build/XernerxSlashCommand.js';
 import XernerxContextCommand from '../build/XernerxContextCommand.js';
 import { filetype } from '../types/types.js';
 export default class Handler {
-    readonly client: XernerxClient<unknown>;
+    readonly client: XernerxClient;
     readonly files: Array<MessageCommandBuilder | XernerxSlashCommand | XernerxContextCommand>;
-    readonly readyTimestamp: number;
     constructor(client: XernerxClient);
     readdir(dir: string): string[];
     load(filepath: string, type: filetype): Promise<any>;

package/dist/handlers/Handler.js

@@ -5,11 +5,9 @@ import load from '../functions/load.js';
 export default class Handler {
     client;
     files;
-    readyTimestamp;
     constructor(client) {
         this.client = client;
         this.files = [];
-        this.readyTimestamp = Number(Date.now());
     }
     readdir(dir) {
         try {

package/dist/handlers/InhibitorHandler.d.ts

@@ -3,6 +3,7 @@ import XernerxClient from '../client/XernerxClient.js';
 import Handler from './Handler.js';
 import { InhibitorHandlerOptions } from '../types/interfaces.js';
 export default class InhibitorHandler extends Handler {
+    readonly readyTimestamp: number;
     constructor(client: XernerxClient);
     loadInhibitors(options: InhibitorHandlerOptions): Promise<void>;
 }

package/dist/handlers/InhibitorHandler.js

@@ -7,8 +7,10 @@ import { Style } from 'dumfunctions';
 export default class InhibitorHandler extends Handler {
     constructor(client) {
         super(client);
+        this.readyTimestamp = Number(Date.now());
     }
     async loadInhibitors(options) {
+        const inhibitors = [];
         options = z
             .object({
             directory: z.string(),
@@ -18,9 +20,12 @@ export default class InhibitorHandler extends Handler {
         const files = this.readdir(options.directory);
         for (const file of files) {
             const filepath = `${path.resolve(options.directory)}\\${file}`;
-            const data = await this.load(filepath, 'Inhibitor');
-            this.emit(data);
+            const inhibitor = await this.load(filepath, 'Inhibitor');
+            this.emit(inhibitor);
+            inhibitors.push(inhibitor.id);
         }
-        new XernerxLog(this.client).info(`Loaded ${Style.log(String(this.client.inhibitors.size), { color: Style.TextColor.Cyan })} Inhibitors.`);
+        new XernerxLog(this.client).info(`Loaded ${Style.log(String(this.client.inhibitors.size), { color: Style.TextColor.Cyan })} Inhibitors: ${inhibitors
+            .map((inhibitor) => Style.log(inhibitor, { color: Style.TextColor.LightYellow }))
+            .join(', ')}`);
     }
 }

package/dist/handlers/WebhookHandler.d.ts

@@ -2,6 +2,7 @@
 import XernerxClient from '../client/XernerxClient.js';
 import Handler from './Handler.js';
 export default class WebhookHandler extends Handler {
+    readonly readyTimestamp: number;
     constructor(client: XernerxClient);
     loadWebhooks(options: {
         token: string;

package/dist/handlers/WebhookHandler.js

@@ -4,6 +4,7 @@ import Handler from './Handler.js';
 export default class WebhookHandler extends Handler {
     constructor(client) {
         super(client);
+        this.readyTimestamp = Number(Date.now());
     }
     async loadWebhooks(options) {
         this.client.once('ready', async (client) => {

package/dist/main.d.ts

@@ -8,6 +8,7 @@ import XernerxContextCommand from './build/XernerxContextCommand.js';
 import XernerxEvent from './build/XernerxEvent.js';
 import XernerxInhibitor from './build/XernerxInhibitor.js';
 import XernerxLog from './tools/XernerxLog.js';
+export { XernerxIntents as XernerxIntents } from './tools/XernerxIntents.js';
 export * from 'discord.js';
 export * from 'dumfunctions';
 import XernerxExtension from 'xernerx-extension-builder';
@@ -15,10 +16,6 @@ export * from './types/types.js';
 export * from './types/extenders.js';
 export * from './types/interfaces.js';
 import Discord from 'discord.js';
-declare const XernerxIntents: {
-    Default: string[];
-    All: string[];
-};
 export default XernerxClient;
 export { 
 /**
@@ -40,4 +37,4 @@ version,
 /**
  ** Tools
  */
-XernerxLog, XernerxIntents, };
+XernerxLog, };

package/dist/main.js

@@ -10,6 +10,7 @@ import XernerxContextCommand from './build/XernerxContextCommand.js';
 import XernerxEvent from './build/XernerxEvent.js';
 import XernerxInhibitor from './build/XernerxInhibitor.js';
 import XernerxLog from './tools/XernerxLog.js';
+export { XernerxIntents as XernerxIntents } from './tools/XernerxIntents.js';
 export * from 'discord.js';
 export * from 'dumfunctions';
 import XernerxExtension from 'xernerx-extension-builder';
@@ -17,29 +18,6 @@ export * from './types/types.js';
 export * from './types/extenders.js';
 export * from './types/interfaces.js';
 import Discord from 'discord.js';
-const XernerxIntents = {
-    Default: [
-        'Guilds',
-        'GuildModeration',
-        'GuildBans',
-        'GuildEmojisAndStickers',
-        'GuildIntegrations',
-        'GuildWebhooks',
-        'GuildInvites',
-        'GuildVoiceStates',
-        'GuildMessages',
-        'GuildMessageReactions',
-        'GuildMessageTyping',
-        'DirectMessages',
-        'DirectMessageReactions',
-        'DirectMessageTyping',
-        'GuildScheduledEvents',
-        'AutoModerationConfiguration',
-        'AutoModerationExecution',
-    ],
-    All: [''],
-};
-XernerxIntents.All = [...XernerxIntents.Default, 'GuildMembers', 'GuildPresences', 'MessageContent'];
 export default XernerxClient;
 export { 
 /**
@@ -61,4 +39,4 @@ version,
 /**
  ** Tools
  */
-XernerxLog, XernerxIntents, };
+XernerxLog, };

package/dist/models/Cooldowns.d.ts

@@ -0,0 +1,11 @@
+/** @format */
+import { Collection } from 'discord.js';
+import XernerxClient from '../main.js';
+export default class Cooldowns {
+    private readonly _client;
+    readonly collections: Record<string, Collection<string, unknown>>;
+    constructor(client: XernerxClient, collections?: Array<string>);
+    add(collection: keyof typeof this.collections, id: string, value: unknown): string | Collection<string, unknown>;
+    delete(collection: keyof typeof this.collections, id: string): string | boolean;
+    has(id: string): Record<string, Collection<string, unknown>>;
+}

package/dist/models/Cooldowns.js

@@ -0,0 +1,33 @@
+/** @format */
+import { Collection } from 'discord.js';
+export default class Cooldowns {
+    constructor(client, collections = []) {
+        this._client = client;
+        this.collections = {
+            commands: new Collection(),
+        };
+        for (const collection of collections) {
+            this.collections[collection] = new Collection();
+        }
+    }
+    add(collection, id, value) {
+        if (!this.collections[collection])
+            return `${collection} collection does not exist!`;
+        return this.collections[collection].set(id, value);
+    }
+    delete(collection, id) {
+        if (!this.collections[collection])
+            return `${collection} collection does not exist!`;
+        return this.collections[collection].delete(id);
+    }
+    has(id) {
+        const collected = {};
+        for (const [name, collection] of Object.entries(this.collections)) {
+            if (collection.has(id))
+                collected[name] = collection;
+            else
+                continue;
+        }
+        return collected;
+    }
+}

package/dist/tools/XernerxIntents.d.ts

@@ -0,0 +1,5 @@
+/** @format */
+export declare const XernerxIntents: {
+    Default: string[];
+    All: string[];
+};

package/dist/tools/XernerxIntents.js

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

package/dist/tools/XernerxLog.js

@@ -9,7 +9,6 @@ export default class XernerxLog {
             this.warnLog = true;
         }
         else {
-            client.settings.log = client.settings.log;
             this.errorLog = client.settings.log?.error;
             this.infoLog = client.settings.log?.info;
             this.warnLog = client.settings.log?.warn;

package/dist/types/extenders.d.ts

@@ -1,8 +1,8 @@
 /** @format */
-import { ChatInputCommandInteraction, Client, Collection, DMChannel, Guild, GuildChannel, GuildMember, Message, MessageContextMenuCommandInteraction, User, UserContextMenuCommandInteraction } from 'discord.js';
+import { ChatInputCommandInteraction, Collection, DMChannel, Guild, GuildChannel, GuildMember, Message, MessageContextMenuCommandInteraction, User, UserContextMenuCommandInteraction } from 'discord.js';
 import InteractionUtil from '../utils/InteractionUtil.js';
 import MessageUtil from '../utils/MessageUtil.js';
-import { ModuleOptions, XernerxCache, XernerxCommands, XernerxEvent, XernerxInhibitor, XernerxOptions } from '../main.js';
+import { ModuleOptions, XernerxCache, XernerxCommands, XernerxEvent, XernerxInhibitor, XernerxClient } from '../main.js';
 import ClientUtil from '../utils/ClientUtil.js';
 export interface XernerxUser extends User {
     owner: boolean;
@@ -35,20 +35,23 @@ export interface XernerxMessageContextInteraction extends MessageContextMenuComm
     user: XernerxUser;
     util: InteractionUtil;
 }
-export interface XernerxClientType extends Client {
-    config: unknown | null;
+export interface XernerxClientType extends XernerxClient {
     commands: XernerxCommands;
     events: Collection<string, XernerxEvent>;
     inhibitors: Collection<string, XernerxInhibitor>;
     modules: ModuleOptions;
     util: ClientUtil;
-    settings: XernerxOptions;
     stats: {
         guildCount: number;
         userCount: number;
         shardId: number;
         shardCount: number;
     };
+    cooldown: {
+        default: number;
+        cache: number;
+        collections: Array<string>;
+    };
     cache: XernerxCache;
     connect: () => Promise<string>;
 }

package/dist/types/interfaces.d.ts

@@ -15,8 +15,8 @@ export interface XernerxOptions {
     global?: boolean;
     ownerId?: string | Array<string>;
     permissions?: {
-        client?: Array<string>;
-        user?: Array<string>;
+        user?: Array<PermissionNames> | Array<string> | null;
+        client?: Array<PermissionNames> | Array<string> | null;
         dm?: boolean;
     };
     ignore?: {
@@ -38,6 +38,7 @@ export interface XernerxOptions {
     cooldown?: {
         command?: number;
         cache?: number;
+        collections?: Array<string>;
     };
 }
 export interface ModuleOptions {
@@ -83,8 +84,8 @@ interface CommandHandlerOptions {
     directory: string;
     cooldown?: number;
     permissions?: {
-        user?: Array<string>;
-        client?: Array<string>;
+        user?: Array<PermissionNames> | Array<string> | null;
+        client?: Array<PermissionNames> | Array<string> | null;
         dm?: boolean;
     };
 }
@@ -139,8 +140,8 @@ interface CommandOptions {
         voice?: boolean;
     };
     permissions?: {
-        user?: Array<PermissionNames> | Array<string>;
-        client?: Array<PermissionNames> | Array<string>;
+        user?: Array<PermissionNames> | Array<string> | null;
+        client?: Array<PermissionNames> | Array<string> | null;
         dm?: boolean;
     };
 }

package/dist/utils/InteractionUtil.d.ts

@@ -1,12 +1,16 @@
 /** @format */
 import { EmbedBuilder, InteractionEditReplyOptions, InteractionReplyOptions, MessagePayload } from 'discord.js';
 import XernerxClient from '../client/XernerxClient.js';
-import { PaginatorOptions } from '../types/interfaces.js';
+import { ContextCommandArguments, PaginatorOptions, SlashCommandArguments } from '../types/interfaces.js';
 import { XernerxInteraction } from '../types/types.js';
 import Util from './Util.js';
 import { XernerxMessageContextInteraction, XernerxSlashInteraction, XernerxUserContextInteraction } from '../types/extenders.js';
 export default class InteractionUtil extends Util {
-    private interaction;
+    private readonly interaction;
+    parsed: {
+        alias: string | null;
+        args: (SlashCommandArguments | ContextCommandArguments<'message' | 'user'>) | null;
+    };
     constructor(client: XernerxClient, interaction: XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>);
     send(content: any): Promise<import("discord.js").Message<false> | import("discord.js").Message<true> | undefined>;
     reply(content: string | MessagePayload | InteractionReplyOptions | InteractionEditReplyOptions): Promise<import("discord.js").InteractionResponse<boolean> | import("discord.js").Message<boolean>>;

package/dist/utils/InteractionUtil.js

@@ -3,10 +3,13 @@ import { ActionRowBuilder, ButtonBuilder, ButtonStyle, StringSelectMenuBuilder }
 import Util from './Util.js';
 import XernerxError from '../tools/XernerxError.js';
 export default class InteractionUtil extends Util {
-    interaction;
     constructor(client, interaction) {
         super(client);
         this.interaction = interaction;
+        this.parsed = {
+            alias: null,
+            args: null,
+        };
     }
     async send(content) {
         if (!content)

package/dist/utils/MessageUtil.d.ts

@@ -7,8 +7,9 @@ import { PaginatorOptions } from '../main.js';
 export default class MessageUtil extends Util {
     private readonly message;
     parsed: {
-        alias: null | string;
-        prefix: null | string;
+        alias: string | null;
+        prefix: string | null;
+        args: Record<string, unknown> | null;
     };
     constructor(client: XernerxClient, message: XernerxMessage);
     send(content: any): Promise<import("discord.js").Message<boolean> | null>;

package/dist/utils/MessageUtil.js

@@ -4,13 +4,13 @@ import Util from './Util.js';
 import sendWebhook from '../functions/sendWebhook.js';
 import XernerxError from '../tools/XernerxError.js';
 export default class MessageUtil extends Util {
-    message;
     constructor(client, message) {
         super(client);
         this.message = message;
         this.parsed = {
             alias: null,
             prefix: null,
+            args: null,
         };
     }
     async send(content) {

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<unknown>;
+    readonly client: XernerxClient;
     readonly text: XernerxText;
     constructor(client: XernerxClient);
     delay(time: number): Promise<unknown>;

package/dist/validators/commandValidation.js

@@ -1,27 +1,47 @@
 /** @format */
 import { ChannelType, PermissionFlagsBits } from 'discord.js';
+var CommandTypes;
+(function (CommandTypes) {
+    CommandTypes["SlashCommand"] = "slash";
+    CommandTypes["MessageCommand"] = "message";
+    CommandTypes["ContextCommand"] = "context";
+})(CommandTypes || (CommandTypes = {}));
 export default async function commandValidation(event, command) {
     const client = event.client;
-    if (command.ignore?.owner && client.settings.ownerId.includes(event.user.id))
+    if (command.ignore?.owner && client.settings.ownerId?.includes(event.user.id))
         return false;
-    if (!client.cache.cooldowns.has(`${event.user.id}-${command.name}`)) {
-        client.cache.cooldowns.set(`${event.user.id}-${command.name}`, {
-            id: event.user.id,
-            command: command.name,
-            createdTimestamp: Number(Date.now()) + (command.cooldown || 0),
-        });
+    const cooldownTime = command.cooldown || client.modules.options?.[CommandTypes[command.filetype]]?.cooldown || client.cooldown?.default || 0;
+    const cooldown = {
+        id: event.user.id,
+        command: command.name,
+        createdTimestamp: Number(Date.now()) + cooldownTime,
+    };
+    const clientPermissions = command.permissions?.client || client.modules.options?.[CommandTypes[command.filetype]]?.permissions?.client || client.settings.permissions?.client || [];
+    const userPermissions = command.permissions?.user || client.modules.options?.[CommandTypes[command.filetype]]?.permissions?.user || client.settings.permissions?.user || [];
+    if (!client.cooldowns.collections.commands.has(`${event.user.id}-${command.name}`)) {
+        client.cooldowns.collections.commands.set(`${event.user.id}-${command.name}`, cooldown);
         setTimeout(() => {
-            client.cache.cooldowns.delete(`${event.user.id}-${command.name}`);
-        }, command.cooldown || 0);
+            client.cooldowns.collections.commands.delete(`${event.user.id}-${command.name}`);
+        }, cooldownTime);
     }
     else {
-        const user = client.cache.cooldowns.get(`${event.user.id}-${command.name}`);
+        const user = client.cooldowns.collections.commands.get(`${event.user.id}-${command.name}`);
         const time = (user?.createdTimestamp || 0) - Number(Date.now());
-        return emit(event, `Command on cooldown, ${time}`);
+        return emit(event, {
+            reason: 'cooldown',
+            message: `You are on cooldown for \`${command.name}\`, wait another \`${Math.round(time / 10) / 100}s\``,
+            startedAt: user.createdTimestamp,
+            endsAt: user.createdTimestamp + time,
+            time,
+        }, command);
     }
     if (command.channel && event.channel?.type !== undefined && event.channel?.type >= 0) {
         if (!command.channel.includes(ChannelType[event.channel?.type]))
-            return await emit(event, `Command can only be used in ${command.channel.join(', ')} channels`);
+            return await emit(event, {
+                reason: 'invalidChannel',
+                message: `\`${command.name}\` can only be used in ${command.channel.join(', ')} channels`,
+                channels: command.channel,
+            }, command);
     }
     if ((command.ignore?.channels?.length || 0) > 0 && command.ignore?.channels?.includes(event.channel?.id))
         return true;
@@ -30,29 +50,75 @@ export default async function commandValidation(event, command) {
     if ((command.ignore?.users?.length || 0) > 0 && command.ignore?.users?.includes(event.user.id))
         return true;
     if (command.ignore?.voice && event.member?.voice?.channel)
-        return await emit(event, 'Command cannot be ran while in voice chat');
+        return await emit(event, {
+            reason: 'inVoice',
+            message: `\`${command.name}\` cannot be ran while in voice chat`,
+        }, command);
     if (command.strict?.owner && !client.settings.ownerId.includes(event.user.id))
-        return await emit(event, 'Command is a developer command');
+        return await emit(event, {
+            reason: 'notADeveloper',
+            message: `\`${command.name}\` is a developer command`,
+            owners: client.settings.ownerId,
+        }, command);
     if ((command.strict?.channels?.length || 0) > 0 && !command.strict?.channels?.includes(event.channel?.id))
-        return await emit(event, 'Command cannot be ran in this channel');
+        return await emit(event, {
+            reason: 'channelRestricted',
+            message: `\`${command.name}\` cannot be ran in this channel`,
+            channels: command.strict?.channels,
+        }, command);
     if ((command.strict?.guilds?.length || 0) > 0 && !command.strict?.guilds?.includes(event.guild?.id))
-        return await emit(event, 'Command cannot be ran in this guild');
+        return await emit(event, {
+            reason: 'guildRestricted',
+            message: `\`${command.name}\` cannot be ran in this guild`,
+            guilds: command.strict?.guilds,
+        }, command);
     if ((command.strict?.users?.length || 0) > 0 && !command.strict?.users?.includes(event.user.id))
-        return await emit(event, 'Command cannot be ran by you');
+        return await emit(event, {
+            reason: 'userRestricted',
+            message: `\`${command.name}\` cannot be ran by you`,
+            users: command.strict?.users,
+        }, command);
     if (command.strict?.voice && !event.member?.voice?.channel)
-        return await emit(event, 'Command cannot be ran while not in voice chat');
+        return await emit(event, {
+            reason: 'voiceRestricted',
+            message: `\`${command.name}\` cannot be ran while not in voice chat`,
+        }, command);
     if (command.permissions?.dm == false && event.channel?.type === ChannelType.DM)
-        return await emit(event, "Can't use in a DM Channel");
-    if (command.permissions?.user) {
-        if (!(event.member?.permissions).has(toBigInt(command.permissions.user)))
-            return await emit(event, 'Missing User Permissions');
+        return await emit(event, {
+            reason: 'DMRestricted',
+            message: `\`${command.name}\` can't be used in a DM Channel`,
+        }, command);
+    if (userPermissions) {
+        const missing = userPermissions.map((permission) => ((event.member?.permissions).has(toBigInt([permission])) ? null : permission)).filter((x) => x);
+        const desired = (event.member?.permissions).has(toBigInt(userPermissions));
+        if (!desired)
+            return await emit(event, {
+                reason: 'missingUserPermissions',
+                message: `You are missing the following permissions to run \`${command.name}\`:\n${missing.map((permission) => `> - ${permission}`).join('\n')}`,
+                required: userPermissions,
+                missing,
+            }, command);
+    }
+    if (clientPermissions) {
+        const missing = clientPermissions.map((permission) => (event.guild?.members.me?.permissions.has(toBigInt([permission])) ? null : permission)).filter((x) => x);
+        const desired = event.guild?.members.me?.permissions?.has(toBigInt(clientPermissions));
+        if (!desired)
+            return await emit(event, {
+                reason: 'missingClientPermissions',
+                message: `I am missing the following permissions to run \`${command.name}\`:\n${missing.map((permission) => `> - ${permission}`).join('\n')}`,
+                required: clientPermissions,
+                missing,
+            }, command);
     }
     if ((!command.global || !client.settings.global) && client.settings.local !== event.guild?.id)
-        return await emit(event, 'Command is not globally deployed');
+        return await emit(event, {
+            reason: 'local',
+            message: `\`${command.name}\` is not globally deployed`,
+        }, command);
     return false;
 }
-async function emit(event, reason) {
-    event.client.emit('commandBlock', event, reason);
+async function emit(event, info, command) {
+    event.client.emit('commandBlock', event, info, command);
     return true;
 }
 function toBigInt(permissions) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "xernerx",
-	"version": "4.7.0",
+	"version": "4.8.0",
 	"description": "A bot framework for discord.js.",
 	"main": "dist/main.js",
 	"type": "module",
@@ -44,7 +44,7 @@
 		"discord.js": "14.13.0",
 		"dumfunctions": "2.1.2",
 		"xernerx-extension-builder": "0.0.16",
-		"zod": "3.22.0"
+		"zod": "3.22.2"
 	},
 	"devDependencies": {
 		"prettier": "3.0.0",