xernerx 4.1.0 → 4.2.1

package/dist/mjs/validators/InhibitorValidations.js

@@ -0,0 +1,36 @@
+import { InhibitorType } from '../types/enums.js';
+export class InhibitorValidation {
+    client;
+    action;
+    command;
+    inhibited;
+    constructor(client, action, command) {
+        this.client = client;
+        this.action = action;
+        this.command = command;
+        this.inhibited = {};
+    }
+    async inhibit() {
+        for (const inhibitor of this.client.inhibitors) {
+            const inhibit = inhibitor[1];
+            if (inhibit) this.inhibited[inhibit.name] = await inhibit.check(this.action, this.args(this.action, inhibit.type));
+        }
+        for (const inhibit of Object.values(this.inhibited)) {
+            if (inhibit) return this.inhibited;
+        }
+    }
+    args(action, type) {
+        if (type === InhibitorType.Channel) return action.channel;
+        if (type === InhibitorType.User) return action.author || action.user;
+        if (type === InhibitorType.Guild) return action.guild;
+        if (type === InhibitorType.Member) return action.member;
+        // if (type === InhibitorType.Command)
+        // 	return this.client.util.getAllCommands().filter(this.command.name);
+        // if (type === InhibitorType.MessageCommand)
+        // 	return this.client.util.getAllMessageCommands().find(this.command.name);
+        // if (type === InhibitorType.SlashCommand)
+        // 	return this.client.util.getAllSlashCommands().find(this.command.name);
+        // if (type === InhibitorType.ContextCommand)
+        // 	return this.client.util.getAllContextCommands().find(this.command.name);
+    }
+}

package/dist/tools/XernerxLog.d.ts

@@ -5,6 +5,7 @@ export default class XernerxLog {
     private readonly errorLog;
     private readonly infoLog;
     private readonly readyLog;
+    private readonly tableLog;
     constructor(client: XernerxClient);
     info(message: string, force?: boolean): void | null;
     warn(message: string): void | null;

package/dist/tools/XernerxLog.js

@@ -1,14 +1,11 @@
 import { Style } from 'dumfunctions';
 export default class XernerxLog {
-    client;
-    errorLog;
-    infoLog;
-    readyLog;
     constructor(client) {
         this.client = client;
         this.errorLog = client.settings.log?.error;
         this.infoLog = client.settings.log?.info;
         this.readyLog = client.settings.log?.ready;
+        this.tableLog = client.settings.log?.table;
     }
     info(message, force = false) {
         return this.infoLog || force ? console.info(`${Style.log('✔️  | Xernerx', { color: Style.TextColor.Purple })} | ${message}`) : null;
@@ -20,11 +17,32 @@ export default class XernerxLog {
         return this.errorLog ? console.error(`${Style.log('❗ | Xernerx', { color: Style.TextColor.Red })} | ${message}${error ? ` | ${error.stack}` : ''}`) : null;
     }
     ready() {
-        this.client.prependOnceListener('ready', async (synced) =>
+        this.client.prependOnceListener('ready', async (synced) => {
             this.info(
-                `${synced.user.tag} is now online, watching ${(await this.client.guilds.fetch()).size} guilds, using ${await this.client.guilds.fetch(this.client.settings.local)} as local guild.`,
+                `${synced.user.tag} is now online, watching ${this.client.guilds.cache.size} guilds, using ${
+                    this.client.settings.local ? await this.client.guilds.fetch(this.client.settings.local) : 'none'
+                } as local guild.`,
                 this.readyLog
-            )
-        );
+            );
+            const files = [];
+            for (const [id, data] of this.client.commands.message) {
+                files.push(data);
+            }
+            for (const [id, data] of this.client.commands.slash) {
+                files.push(data);
+            }
+            for (const [id, data] of this.client.commands.context) {
+                files.push(data);
+            }
+            for (const [id, data] of this.client.events) {
+                files.push(data);
+            }
+            for (const [id, data] of this.client.inhibitors) {
+                files.push(data);
+            }
+            if (this.tableLog) {
+                console.table(files, this.tableLog);
+            }
+        });
     }
 }

package/dist/types/extenders.d.ts

@@ -11,13 +11,18 @@ export interface XernerxMember extends GuildMember {
 export interface XernerxGuild extends Guild {}
 export interface XernerxGuildChannel extends GuildChannel {}
 export interface XernerxDMChannel extends DMChannel {}
-interface XernerxCommand {
-    util: InteractionUtil | MessageUtil;
-}
+interface XernerxCommand {}
 export interface XernerxMessage extends Message, XernerxCommand {
     user: XernerxUser;
+    util: MessageUtil;
+}
+export interface XernerxSlashInteraction extends ChatInputCommandInteraction, XernerxCommand {
+    util: InteractionUtil;
+}
+export interface XernerxUserContextInteraction extends UserContextMenuCommandInteraction, XernerxCommand {
+    util: InteractionUtil;
+}
+export interface XernerxMessageContextInteraction extends MessageContextMenuCommandInteraction, XernerxCommand {
+    util: InteractionUtil;
 }
-export interface XernerxSlashInteraction extends ChatInputCommandInteraction, XernerxCommand {}
-export interface XernerxUserContextInteraction extends UserContextMenuCommandInteraction, XernerxCommand {}
-export interface XernerxMessageContextInteraction extends MessageContextMenuCommandInteraction, XernerxCommand {}
 export {};

package/dist/types/interfaces.d.ts

@@ -9,25 +9,29 @@ import SlashCommandBuilder from '../build/SlashCommandBuilder.js';
 import { Locales, MessageCommandArgumentType, PermissionNames, SlashCommandArgumentType, EventType, InhibitorType } from './types.js';
 import ExtensionHandler from '../handlers/ExtensionHandler.js';
 export interface XernerxOptions {
-    ownerId: string;
-    permissions: {
-        client: Array<string>;
-        user: Array<string>;
-        dm: boolean;
-    };
-    ignore: {
-        owner: boolean;
-        users: Array<string>;
-        channels: Array<string>;
-        guilds: Array<string>;
-    };
-    log: {
-        ready: boolean;
-        error: boolean;
-    };
-    cooldown: {
-        command: number;
-        cache: number;
+    local?: string;
+    global?: boolean;
+    ownerId?: string | Array<string>;
+    permissions?: {
+        client?: Array<string>;
+        user?: Array<string>;
+        dm?: boolean;
+    };
+    ignore?: {
+        owner?: boolean;
+        users?: Array<string>;
+        channels?: Array<string>;
+        guilds?: Array<string>;
+    };
+    log?: {
+        ready?: boolean;
+        info?: boolean;
+        error?: boolean;
+        table?: Array<'name' | 'aliases' | 'description' | 'fileType' | 'category'>;
+    };
+    cooldown?: {
+        command?: number;
+        cache?: number;
     };
 }
 export interface ModuleOptions {

package/dist/utils/ClientUtil.d.ts

@@ -1,8 +1,9 @@
-import XernerxClient from '../main.js';
+import XernerxClient from '../client/XernerxClient.js';
 import { PresenceOptions } from '../types/interfaces.js';
 import Util from './Util.js';
 export default class ClientUtil extends Util {
     hasVoted?: Function;
     constructor(client: XernerxClient);
     setPresence(options: PresenceOptions): import('discord.js').ClientPresence | undefined;
+    resolveChannel(query: string | Record<string, string>): Promise<import('discord.js').Channel | null>;
 }

package/dist/utils/ClientUtil.js

@@ -1,11 +1,20 @@
 import setPresence from '../functions/setPresence.js';
 import Util from './Util.js';
 export default class ClientUtil extends Util {
-    hasVoted;
     constructor(client) {
         super(client);
     }
     setPresence(options) {
         return setPresence(this.client, options);
     }
+    async resolveChannel(query) {
+        if (typeof query == 'object') query = query.id;
+        try {
+            let channel = this.client.channels.cache.find((channel) => (channel.name == query.toLowerCase() || channel.id == query.toLowerCase() ? channel : null)) || null;
+            if (!channel) channel = (await this.client.channels.fetch(query)) || null;
+            return channel;
+        } catch {
+            return null;
+        }
+    }
 }

package/dist/utils/MessageUtil.d.ts

@@ -4,7 +4,10 @@ import { XernerxMessage } from '../types/extenders.js';
 import Util from './Util.js';
 export default class MessageUtil extends Util {
     private readonly message;
-    alias: string | null;
+    parsed: {
+        alias: null | string;
+        prefix: null | string;
+    };
     constructor(client: XernerxClient, message: XernerxMessage);
     reply(content: MessagePayload): Promise<import('discord.js').Message<boolean> | undefined>;
     webhookReply(content: MessagePayload, url?: URL, user?: User): Promise<void>;

package/dist/utils/MessageUtil.js

@@ -5,11 +5,13 @@ import sendWebhook from '../functions/sendWebhook.js';
 import XernerxError from '../tools/XernerxError.js';
 export default class MessageUtil extends Util {
     message;
-    alias;
     constructor(client, message) {
         super(client);
         this.message = message;
-        this.alias = null;
+        this.parsed = {
+            alias: null,
+            prefix: null,
+        };
     }
     async reply(content) {
         if (this.client.cache.messages.has(this.message.id)) {

package/package.json

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