xernerx 4.14.0 → 4.15.0

package/dist/mjs/types/interfaces.d.ts

@@ -0,0 +1,256 @@
+/** @format */
+import { ActivityType, ChannelType, Collection, PresenceStatusData } from 'discord.js';
+import CommandHandler from '../handlers/CommandHandler.js';
+import EventHandler from '../handlers/EventHandler.js';
+import InhibitorHandler from '../handlers/InhibitorHandler.js';
+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 ExtensionHandler from '../handlers/ExtensionHandler.js';
+import { XernerxMessage, XernerxUser } from './extenders.js';
+export interface XernerxOptions {
+    local: string;
+    global?: boolean;
+    ownerId?: string | Array<string>;
+    ceaseless?: boolean;
+    permissions?: {
+        user?: Array<PermissionNames> | Array<string> | null;
+        client?: Array<PermissionNames> | Array<string> | null;
+        dm?: boolean;
+    };
+    ignore?: {
+        owner?: boolean;
+        self?: boolean;
+        bots?: boolean;
+        system?: boolean;
+        users?: Array<string>;
+        channels?: Array<string>;
+        guilds?: Array<string>;
+    };
+    log?: {
+        ready?: boolean;
+        info?: boolean;
+        warn?: boolean;
+        error?: boolean;
+        table?: Array<'name' | 'aliases' | 'description' | 'filetype' | 'category'>;
+    };
+    cooldown?: {
+        command?: number;
+        cache?: number;
+        collections?: Array<string>;
+    };
+}
+export interface ModuleOptions {
+    options: {
+        message?: MessageHandlerOptions;
+        slash?: SlashHandlerOptions;
+        context?: ContextHandlerOptions;
+        events?: EventHandlerOptions;
+        inhibitors?: InhibitorHandlerOptions;
+    };
+    commandHandler: CommandHandler;
+    eventHandler: EventHandler;
+    inhibitorHandler: InhibitorHandler;
+    integrationHandler: IntegrationHandler;
+    extensionHandler: ExtensionHandler;
+}
+export interface XernerxCommands {
+    message: Collection<string, MessageCommandBuilder>;
+    slash: Collection<string, XernerxSlashCommand>;
+    context: Collection<string, XernerxContextCommand>;
+}
+export interface DBLOptions {
+    topgg: {
+        token: string;
+    };
+    dbl: {
+        token: string;
+    };
+    config: {
+        emits: boolean;
+        logs: boolean;
+    };
+}
+export interface XernerxCache {
+    messages: Collection<string, string>;
+    cooldowns: Collection<string, {
+        id: string;
+        command: string;
+        createdTimestamp: number;
+    }>;
+}
+interface CommandHandlerOptions {
+    directory: string;
+    cooldown?: number;
+    permissions?: {
+        user?: Array<PermissionNames> | Array<string> | null;
+        client?: Array<PermissionNames> | Array<string> | null;
+        dm?: boolean;
+    };
+}
+export interface MessageHandlerOptions extends CommandHandlerOptions {
+    prefix: string | Array<string>;
+    allowMention?: boolean;
+    handleEdits?: boolean;
+    handleDeletes?: boolean;
+    handleTyping?: boolean;
+}
+export interface SlashHandlerOptions extends CommandHandlerOptions {
+    defer?: {
+        reply?: boolean;
+        ephemeral?: boolean;
+        fetchReply?: boolean;
+    };
+}
+export interface ContextHandlerOptions extends CommandHandlerOptions {
+    defer?: {
+        reply?: boolean;
+        ephemeral?: boolean;
+        fetchReply?: boolean;
+    };
+}
+export interface EventHandlerOptions {
+    directory: string;
+}
+export interface InhibitorHandlerOptions {
+    directory: string;
+}
+interface CommandOptions {
+    name: string;
+    description?: string | null;
+    usage?: string | null;
+    info?: string | null;
+    category?: string | null;
+    cooldown?: number | null;
+    global?: boolean;
+    channel?: Array<keyof typeof ChannelType> | keyof typeof ChannelType | null;
+    ignore?: {
+        owner?: boolean;
+        users?: Array<string>;
+        channels?: Array<string>;
+        guilds?: Array<string>;
+        voice?: boolean;
+    };
+    strict?: {
+        owner?: boolean;
+        users?: Array<string>;
+        channels?: Array<string>;
+        guilds?: Array<string>;
+        voice?: boolean;
+    };
+    permissions?: {
+        user?: Array<PermissionNames> | Array<string> | null;
+        client?: Array<PermissionNames> | Array<string> | null;
+        dm?: boolean;
+    };
+}
+export interface MessageCommandOptions extends CommandOptions {
+    aliases?: Array<string>;
+    separator?: string;
+    prefix?: Array<string> | string;
+    regex?: RegExp;
+    channelType?: Array<ChannelType>;
+    args?: Array<MessageCommandArgumentOptions>;
+    flags?: Array<MessageCommandFlagOptions>;
+}
+export interface MessageCommandArgumentOptions {
+    type: MessageCommandArgumentType;
+    name: string;
+    content?: Array<string>;
+    match?: string | Array<string>;
+    description?: string;
+    default?: string | Function;
+    separator?: string | RegExp;
+    prompt?: {
+        reply?: string;
+        send?: string;
+    };
+}
+export interface MessageCommandFlagOptions {
+    name: string;
+    match: string;
+}
+export interface MessageCommandArguments {
+    args: Record<string, unknown> | null;
+    flags: Record<string, boolean> | null;
+}
+export interface SlashCommandOptions extends CommandOptions {
+    description: string;
+    nameLocalizations?: Record<Locales, string | null> | null;
+    descriptionLocalizations?: Record<Locales, string | null> | null;
+    defer?: {
+        reply?: boolean;
+        ephemeral?: boolean;
+        fetchReply?: boolean;
+    };
+    args?: Array<SlashCommandArgumentOptions>;
+    subcommands?: Array<SlashCommandSubcommandOptions>;
+    groups?: Array<SlashCommandGroupOptions>;
+}
+export interface ContextCommandOptions extends CommandOptions {
+    type: 'user' | 'message';
+    nameLocalizations?: Record<Locales, string | null> | null;
+    defer?: {
+        reply?: boolean;
+        ephemeral?: boolean;
+        fetchReply?: boolean;
+    };
+}
+export interface SlashCommandArgumentOptions {
+    type: SlashCommandArgumentType;
+    name: string;
+    description: string;
+    required?: boolean;
+    autocomplete?: boolean;
+    choices?: Array<Record<string, string>>;
+}
+export interface SlashCommandSubcommandOptions {
+    name: string;
+    description: string;
+    args?: Array<SlashCommandArgumentOptions>;
+}
+export interface SlashCommandGroupOptions {
+    name: string;
+    description: string;
+    subcommands: Array<SlashCommandSubcommandOptions>;
+}
+export interface SlashCommandArguments<T = SlashCommandArgumentType> {
+    args: Record<string, any>;
+    subcommand: string;
+    group: string;
+}
+export interface XernerxEventOptions {
+    name: XernerxEventType;
+    emitter?: 'client' | 'process';
+    type?: 'discord' | 'node';
+    once?: boolean;
+}
+export interface XernerxInhibitorOptions {
+    name: string;
+    type: InhibitorType;
+}
+export interface PresenceOptions {
+    text: string;
+    type?: keyof typeof ActivityType;
+    url: string;
+    status?: PresenceStatusData;
+    interval?: number;
+}
+export type ContextCommandArguments<T extends 'user' | 'message'> = T extends 'user' ? XernerxUser : XernerxMessage;
+export interface PaginatorOptions {
+    type?: 'button' | 'select-menu' | 'combined';
+    buttons?: Array<string>;
+    description?: boolean;
+    placeholder?: string;
+    index?: number;
+    send?: boolean;
+    filter?: Function;
+    time?: number;
+}
+export interface ResolveCommandOptions {
+    type?: 'MessageCommand' | 'SlashCommand' | 'ContextCommand' | 'Interaction';
+    name?: string;
+}
+export {};

package/dist/mjs/types/types.d.ts

@@ -0,0 +1,14 @@
+/** @format */
+import { SlashCommandBooleanOption, SlashCommandChannelOption, SlashCommandIntegerOption, SlashCommandMentionableOption, SlashCommandNumberOption, SlashCommandRoleOption, SlashCommandStringOption, SlashCommandUserOption } from 'discord.js';
+import { XernerxMessageContextInteraction, XernerxSlashInteraction, XernerxUserContextInteraction } from './extenders.js';
+export type filetype = 'MessageCommand' | 'SlashCommand' | 'ContextCommand' | 'Event' | 'Inhibitor';
+export type Locales = 'en-US' | 'en-GB' | 'bg' | 'zh-CN' | 'zh-TW' | 'hr' | 'cs' | 'da' | 'nl' | 'fi' | 'fr' | 'de' | 'el' | 'hi' | 'hu' | 'it' | 'ja' | 'ko' | 'lt' | 'no' | 'pl' | 'pt-BR' | 'ro' | 'ru' | 'es-ES' | 'sv-SE' | 'th' | 'tr' | 'uk' | 'vi';
+export type SlashCommandArgumentType = 'attachment' | 'boolean' | 'channel' | 'integer' | 'mentionable' | 'number' | 'role' | 'string' | 'user';
+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/mjs/utils/ClientUtil.d.ts

@@ -0,0 +1,19 @@
+/** @format */
+import { Collection } from 'discord.js';
+import XernerxClient from '../client/XernerxClient.js';
+import { PresenceOptions, ResolveCommandOptions } from '../types/interfaces.js';
+import Util from './Util.js';
+import XernerxContextCommand from '../build/XernerxContextCommand.js';
+import XernerxMessageCommand from '../build/XernerxMessageCommand.js';
+import XernerxSlashCommand from '../build/XernerxSlashCommand.js';
+export default class ClientUtil extends Util {
+    hasVoted: Function;
+    constructor(client: XernerxClient);
+    setPresence(options: PresenceOptions): import("discord.js").ClientPresence | undefined;
+    private resolveCooldown;
+    resolveCommand(options: ResolveCommandOptions): XernerxSlashCommand | XernerxContextCommand | XernerxMessageCommand | Collection<string, XernerxSlashCommand | XernerxContextCommand | XernerxMessageCommand>;
+    resolveChannel(query: string | Record<string, string>): Promise<import("discord.js").Channel | null>;
+    resolveGuild(query: string | Record<string, string>): Promise<import("discord.js").Guild | null>;
+    uptime(timestamp?: number | null): string;
+    commands(): (XernerxSlashCommand | XernerxContextCommand | XernerxMessageCommand)[];
+}

package/dist/{utils → mjs/utils}/ClientUtil.js

@@ -75,4 +75,7 @@ export default class ClientUtil extends Util {
         else
             return `${seconds}s`;
     }
+    commands() {
+        return [...this.client.commands.context.toJSON(), ...this.client.commands.slash.toJSON(), ...this.client.commands.message.toJSON()];
+    }
 }

package/dist/mjs/utils/InteractionUtil.d.ts

@@ -0,0 +1,25 @@
+/** @format */
+import { EmbedBuilder, InteractionEditReplyOptions, InteractionReplyOptions, MessageCreateOptions, MessagePayload } from 'discord.js';
+import XernerxClient from '../client/XernerxClient.js';
+import { ContextCommandArguments, PaginatorOptions, SlashCommandArguments } from '../types/interfaces.js';
+import { PermissionNames, XernerxInteraction } from '../types/types.js';
+import Util from './Util.js';
+import { XernerxMessageContextInteraction, XernerxSlashInteraction, XernerxUser, XernerxUserContextInteraction } from '../types/extenders.js';
+type MimicOptions = {
+    timeout: number;
+};
+export default class InteractionUtil extends Util {
+    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>>;
+    mimic(user: XernerxUser | string, interaction: MessageCreateOptions, options: MimicOptions): Promise<void>;
+    paginator(embeds: Array<EmbedBuilder>, options?: PaginatorOptions): Promise<void | import("discord.js").Message<false> | import("discord.js").Message<true>>;
+    commands(): import("@discordjs/collection").Collection<string, import("../main.js").XernerxSlashCommand> | import("@discordjs/collection").Collection<string, import("../main.js").XernerxContextCommand>;
+    permissionCheck(type: 'user' | 'client', permissions: Array<PermissionNames>): boolean;
+}
+export {};

package/dist/{utils → mjs/utils}/InteractionUtil.js

@@ -1,7 +1,8 @@
 /** @format */
-import { ActionRowBuilder, ButtonBuilder, ButtonStyle, StringSelectMenuBuilder, } from 'discord.js';
+import { ActionRowBuilder, ButtonBuilder, ButtonStyle, InteractionType, StringSelectMenuBuilder, } from 'discord.js';
 import Util from './Util.js';
 import XernerxError from '../tools/XernerxError.js';
+import { Style } from 'dumfunctions';
 export default class InteractionUtil extends Util {
     constructor(client, interaction) {
         super(client);
@@ -38,8 +39,6 @@ export default class InteractionUtil extends Util {
             webhook.delete().catch(() => true);
         }, options.timeout);
     }
-    // @ts-ignore
-    commandName() { }
     async paginator(embeds, options = {}) {
         let buttonRow, menuRow;
         if (embeds.length <= 0)
@@ -120,4 +119,35 @@ export default class InteractionUtil extends Util {
                 });
             });
     }
+    commands() {
+        if (this.interaction.type == InteractionType.ApplicationCommand)
+            return this.client.commands.slash;
+        else
+            return this.client.commands.context;
+    }
+    permissionCheck(type, permissions) {
+        console.log(type);
+        const missing = [];
+        for (const permission of permissions) {
+            if (type == 'user') {
+                this.interaction.memberPermissions?.has(Style.pascalCase(permission, true)) ? null : missing.push(permission);
+            }
+            if (type == 'client') {
+                this.interaction.guild?.members.me?.permissionsIn(this.interaction.channel?.id).has(Style.pascalCase(permission, true)) ? null : missing.push(permission);
+            }
+        }
+        const command = this.commands().toJSON().find((cmd) => cmd.name == this.parsed.alias?.split(/ +/)[0]);
+        console.log(type);
+        if (missing.length) {
+            this.client.emit(`commandBlock`, this.interaction, {
+                reason: `missing${Style.pascalCase(type)}Permissions`,
+                message: `${type == 'user' ? 'You are' : 'I am'} missing the following permissions to run \`${command?.name}\`:\n${missing.map((permission) => `> - ${permission}`).join('\n')}`,
+                required: permissions,
+                missing,
+            }, command || null);
+            return false;
+        }
+        else
+            return true;
+    }
 }

package/dist/mjs/utils/MessageUtil.d.ts

@@ -0,0 +1,26 @@
+/** @format */
+import { EmbedBuilder, MessageCreateOptions, MessageEditOptions, MessagePayload, MessageReplyOptions } from 'discord.js';
+import XernerxClient from '../client/XernerxClient.js';
+import { XernerxMessage, XernerxUser } from '../types/extenders.js';
+import Util from './Util.js';
+import { PaginatorOptions } from '../types/interfaces.js';
+import { PermissionNames } from '../main.js';
+type MimicOptions = {
+    timeout: number;
+};
+export default class MessageUtil extends Util {
+    private readonly message;
+    parsed: {
+        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>;
+    reply(content: string | MessagePayload | MessageReplyOptions | MessageEditOptions): Promise<import("discord.js").Message<boolean> | null>;
+    mimic(user: XernerxUser | string, message: MessageCreateOptions, options: MimicOptions): Promise<void>;
+    paginator(embeds: Array<EmbedBuilder>, options?: PaginatorOptions): Promise<void | import("discord.js").Message<boolean> | null>;
+    commands(): import("@discordjs/collection").Collection<string, import("../main.js").XernerxMessageCommand>;
+    permissionCheck(type: 'user' | 'client', permissions: Array<PermissionNames>): boolean;
+}
+export {};

package/dist/{utils → mjs/utils}/MessageUtil.js

@@ -2,6 +2,7 @@
 import { ActionRowBuilder, ButtonBuilder, ButtonStyle, StringSelectMenuBuilder, } from 'discord.js';
 import Util from './Util.js';
 import XernerxError from '../tools/XernerxError.js';
+import { Style } from 'dumfunctions';
 export default class MessageUtil extends Util {
     constructor(client, message) {
         super(client);
@@ -135,4 +136,32 @@ export default class MessageUtil extends Util {
                 });
             });
     }
+    commands() {
+        return this.client.commands.message;
+    }
+    permissionCheck(type, permissions) {
+        console.log(type);
+        const missing = [];
+        for (const permission of permissions) {
+            if (type == 'user') {
+                this.message.member?.permissionsIn(this.message.channel.id).has(Style.pascalCase(permission, true)) ? null : missing.push(permission);
+            }
+            if (type == 'client') {
+                this.message.guild?.members.me?.permissionsIn(this.message.channel.id).has(Style.pascalCase(permission, true)) ? null : missing.push(permission);
+            }
+        }
+        const command = this.commands().find((cmd) => cmd.name == this.parsed.alias || cmd.aliases?.includes(this.parsed.alias));
+        console.log(type);
+        if (missing.length) {
+            this.client.emit(`commandBlock`, this.message, {
+                reason: `missing${Style.pascalCase(type)}Permissions`,
+                message: `${type == 'user' ? 'You are' : 'I am'} missing the following permissions to run \`${command?.name}\`:\n${missing.map((permission) => `> - ${permission}`).join('\n')}`,
+                required: permissions,
+                missing,
+            }, command || null);
+            return false;
+        }
+        else
+            return true;
+    }
 }

package/dist/mjs/utils/Util.d.ts

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

package/dist/mjs/validators/commandValidation.d.ts

@@ -0,0 +1,7 @@
+/** @format */
+import XernerxContextCommand from '../build/XernerxContextCommand.js';
+import MessageCommandBuilder from '../build/XernerxMessageCommand.js';
+import XernerxSlashCommand from '../build/XernerxSlashCommand.js';
+import { XernerxMessage, XernerxSlashInteraction, XernerxUserContextInteraction } from '../types/extenders.js';
+import { XernerxInteraction } from '../types/types.js';
+export default function commandValidation(event: XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxUserContextInteraction> | XernerxMessage, command: MessageCommandBuilder | XernerxSlashCommand | XernerxContextCommand): Promise<boolean>;

package/dist/{validators → mjs/validators}/commandValidation.js

@@ -1,5 +1,6 @@
 /** @format */
-import { ChannelType, PermissionFlagsBits } from 'discord.js';
+import { ChannelType } from 'discord.js';
+import { Style } from 'dumfunctions';
 var CommandTypes;
 (function (CommandTypes) {
     CommandTypes["SlashCommand"] = "slash";
@@ -88,10 +89,10 @@ export default async function commandValidation(event, command) {
             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)
+    if (userPermissions.length) {
+        const missing = [];
+        userPermissions.map((permission) => event.guild?.members.me?.permissionsIn(event.channel?.id).has(Style.pascalCase(permission, true)) ? null : missing.push(permission));
+        if (missing.length)
             return await emit(event, {
                 reason: 'missingUserPermissions',
                 message: `You are missing the following permissions to run \`${command.name}\`:\n${missing.map((permission) => `> - ${permission}`).join('\n')}`,
@@ -99,10 +100,10 @@ export default async function commandValidation(event, command) {
                 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)
+    if (clientPermissions.length) {
+        const missing = [];
+        clientPermissions.map((permission) => event.guild?.members.me?.permissionsIn(event.channel?.id).has(Style.pascalCase(permission, true)) ? null : missing.push(permission));
+        if (missing.length)
             return await emit(event, {
                 reason: 'missingClientPermissions',
                 message: `I am missing the following permissions to run \`${command.name}\`:\n${missing.map((permission) => `> - ${permission}`).join('\n')}`,
@@ -121,16 +122,3 @@ async function emit(event, info, command) {
     event.client.emit('commandBlock', event, info, command);
     return true;
 }
-function toBigInt(permissions) {
-    let bigIntPermissions = 0n;
-    permissions.map((permission) => {
-        permission =
-            PermissionFlagsBits[permission
-                .split(/ +/)
-                .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-                .join('')];
-        if (typeof permission === 'bigint')
-            bigIntPermissions += permission;
-    });
-    return bigIntPermissions;
-}

package/dist/mjs/validators/inhibitorValidations.d.ts

@@ -0,0 +1,9 @@
+/** @format */
+import { ContextCommandArguments, MessageCommandArguments, SlashCommandArguments } from '../types/interfaces.js';
+import XernerxContextCommand from '../build/XernerxContextCommand.js';
+import XernerxMessageCommand from '../build/XernerxMessageCommand.js';
+import XernerxSlashCommand from '../build/XernerxSlashCommand.js';
+import { XernerxMessage, XernerxMessageContextInteraction, XernerxSlashInteraction, XernerxUserContextInteraction } from '../types/extenders.js';
+import { InhibitorType, XernerxInteraction } from '../types/types.js';
+export declare function inhibitorValidation(event: XernerxMessage | XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>, args?: SlashCommandArguments | MessageCommandArguments | ContextCommandArguments<'user' | 'message'> | null, cmd?: XernerxContextCommand | XernerxMessageCommand | XernerxSlashCommand, type?: 'pre' | 'check' | 'post'): Promise<boolean>;
+export declare function inhibitorArguments(event: XernerxMessage | XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>, cmd: XernerxContextCommand | XernerxMessageCommand | XernerxSlashCommand | null, type: InhibitorType): import("../types/extenders.js").XernerxUser | import("discord.js").GuildMember | import("discord.js").Guild | import("discord.js").TextBasedChannel | XernerxSlashCommand | XernerxContextCommand | XernerxMessageCommand | import("discord.js").APIInteractionGuildMember | null | undefined;

package/package.json

@@ -1,8 +1,9 @@
 {
 	"name": "xernerx",
-	"version": "4.14.0",
+	"version": "4.15.0",
 	"description": "A bot framework for discord.js.",
-	"main": "dist/main.js",
+	"main": "dist/cjs/main.js",
+	"module": "dist/mjs/main.js",
 	"type": "module",
 	"keywords": [
 		"discord.js",
@@ -30,7 +31,9 @@
 		"site": "git add docs && npm run commit && git push",
 		"write": "npm i && npm run build && npm run format",
 		"format": "npx prettier --write src dist",
-		"build": "tsc && npm run format"
+		"build": "npm run build:esm && npm run build:cjs && npm run format",
+		"build:esm": "tsc",
+		"build:cjs": "tsc --module CommonJS --outDir dist/cjs"
 	},
 	"repository": {
 		"type": "git",
@@ -42,7 +45,7 @@
 	"dependencies": {
 		"dbl-sdk": "^2.0.3",
 		"discord.js": "^14.14.1",
-		"dumfunctions": "2.1.2",
+		"dumfunctions": "^2.1.6",
 		"xernerx-extension-builder": "0.0.16",
 		"zod": "^3.22.4"
 	},

package/dist/functions/sendWebhook.d.ts

@@ -1,4 +0,0 @@
-/** @format */
-/// <reference types="node" resolution-mode="require"/>
-import { MessagePayload } from 'discord.js';
-export default function sendWebhook(url: URL, body: MessagePayload): Promise<unknown>;

package/dist/functions/sendWebhook.js

@@ -1,14 +0,0 @@
-/** @format */
-export default async function sendWebhook(url, body) {
-    const response = await fetch(url, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify(body),
-    });
-    if (response.status === 204)
-        return true;
-    const data = await response.json();
-    return data;
-}

package/dist/handlers/WebhookHandler.js

@@ -1,10 +0,0 @@
-/** @format */
-// import XernerxLog from '../tools/XernerxLog.js';
-import Handler from './Handler.js';
-export default class IntegrationHandler extends Handler {
-    constructor(client) {
-        super(client);
-        this.readyTimestamp = Number(Date.now());
-    }
-    async loadIntegrations(options) { }
-}

package/dist/{client → cjs/client}/XernerxClient.d.ts

@@ -17,19 +17,19 @@ export default class XernerxClient extends Client {
             dm: boolean;
         } | undefined;
         ignore?: {
+            system: boolean;
+            users: string[];
             owner: boolean;
             self: boolean;
             bots: boolean;
-            system: boolean;
-            users: string[];
             channels: string[];
             guilds: string[];
         } | undefined;
         log?: boolean | {
+            warn: boolean;
             error: boolean;
             ready: boolean;
             info: boolean;
-            warn: boolean;
             table: string[] | null;
         } | undefined;
         cooldown?: {