xernerx 4.4.3 → 4.4.5

package/dist/types/types.d.ts

@@ -0,0 +1,181 @@
+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 EventType = DiscordEventType | 'webhookInit' | 'webhookPost' | 'webhookError';
+export type XernerxInteraction = XernerxSlashInteraction | 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/types/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/ClientUtil.d.ts

@@ -0,0 +1,10 @@
+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>;
+    resolveGuild(query: string | Record<string, string>): Promise<import('discord.js').Guild | null>;
+}

package/dist/utils/ClientUtil.js

@@ -0,0 +1,30 @@
+import setPresence from '../functions/setPresence.js';
+import Util from './Util.js';
+export default class ClientUtil extends Util {
+    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;
+        }
+    }
+    async resolveGuild(query) {
+        if (typeof query == 'object') query = query.id;
+        try {
+            let guild = this.client.guilds.cache.find((guild) => guild.name.toLowerCase() == query.toLowerCase()) || null;
+            if (!guild) guild = (await this.client.guilds.fetch(query)) || null;
+            return guild;
+        } catch {
+            return null;
+        }
+    }
+}

package/dist/utils/InteractionUtil.d.ts

@@ -0,0 +1,10 @@
+import { MessagePayload } from 'discord.js';
+import XernerxClient from '../client/XernerxClient.js';
+import { XernerxInteraction } from '../types/types.js';
+import Util from './Util.js';
+export default class InteractionUtil extends Util {
+    private interaction;
+    constructor(client: XernerxClient, interaction: XernerxInteraction);
+    reply(content: MessagePayload): Promise<import('discord.js').Message<boolean> | import('discord.js').InteractionResponse<boolean>>;
+    delay(time: number): Promise<unknown>;
+}

package/dist/utils/InteractionUtil.js

@@ -0,0 +1,15 @@
+import delay from '../functions/delay.js';
+import Util from './Util.js';
+export default class InteractionUtil extends Util {
+    interaction;
+    constructor(client, interaction) {
+        super(client);
+        this.interaction = interaction;
+    }
+    async reply(content) {
+        return await (this.interaction.replied || this.interaction.deferred ? this.interaction.editReply(content) : this.interaction.reply(content));
+    }
+    async delay(time) {
+        return await delay(time);
+    }
+}

package/dist/utils/MessageUtil.d.ts

@@ -0,0 +1,15 @@
+import { MessagePayload, User } from 'discord.js';
+import XernerxClient from '../client/XernerxClient.js';
+import { XernerxMessage } from '../types/extenders.js';
+import Util from './Util.js';
+export default class MessageUtil extends Util {
+    private readonly message;
+    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>;
+    delay(time: number): Promise<unknown>;
+}

package/dist/utils/MessageUtil.js

@@ -0,0 +1,46 @@
+import { ChannelType } from 'discord.js';
+import delay from '../functions/delay.js';
+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,
+        };
+    }
+    async reply(content) {
+        if (this.client.cache.messages.has(this.message.id)) {
+            const id = this.client.cache.messages.get(this.message.id);
+            if (!id) return;
+            const msg = await this.message.channel.messages.fetch(id);
+            msg.edit(content);
+            return msg;
+        }
+        const msg = await this.message.reply(content);
+        this.client.cache.messages.set(this.message.id, msg.id);
+        return msg;
+    }
+    async webhookReply(content, url, user) {
+        if (this.message.channel.type === ChannelType.DM) throw new XernerxError(`Can't use this method in DM Channels`);
+        const channel = this.message.channel;
+        let webhook;
+        if (!url) {
+            webhook = await channel.createWebhook({
+                name: user?.username || this.client.user?.username,
+                avatar: user?.avatarURL() || this.client.user?.avatarURL(),
+            });
+        }
+        if (!webhook) webhook = { url };
+        await sendWebhook(webhook.url, content);
+        if (!url) webhook.delete();
+        return;
+    }
+    async delay(time) {
+        return await delay(time);
+    }
+}

package/dist/utils/Util.d.ts

@@ -0,0 +1,5 @@
+import XernerxClient from '../client/XernerxClient.js';
+export default class Util {
+    client: XernerxClient;
+    constructor(client: XernerxClient);
+}

package/dist/utils/Util.js

@@ -0,0 +1,6 @@
+export default class Util {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+}

package/dist/validators/commandValidation.d.ts

@@ -0,0 +1,6 @@
+import ContextCommandBuilder from '../build/ContextCommandBuilder.js';
+import MessageCommandBuilder from '../build/MessageCommandBuilder.js';
+import SlashCommandBuilder from '../build/SlashCommandBuilder.js';
+import { XernerxMessage } from '../types/extenders.js';
+import { XernerxInteraction } from '../types/types.js';
+export default function commandValidation(event: XernerxInteraction | XernerxMessage, command: MessageCommandBuilder | SlashCommandBuilder | ContextCommandBuilder): Promise<boolean>;

package/dist/validators/commandValidation.js

@@ -0,0 +1,49 @@
+import { ChannelType, PermissionFlagsBits } from 'discord.js';
+export default async function commandValidation(event, command) {
+    const client = event.client;
+    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),
+        });
+        setTimeout(() => {
+            client.cache.cooldowns.delete(`${event.user.id}-${command.name}`);
+        }, command.cooldown || 0);
+    } else {
+        const user = client.cache.cooldowns.get(`${event.user.id}-${command.name}`);
+        const time = (user?.createdTimestamp || 0) - Number(Date.now());
+        return emit(event, `Command on cooldown, ${time}`);
+    }
+    if ((command.ignore?.channels?.length || 0) > 0 && command.ignore?.channels?.includes(event.channel?.id)) return true;
+    if ((command.ignore?.guilds?.length || 0) > 0 && command.ignore?.guilds?.includes(event.guild?.id)) return true;
+    if ((command.ignore?.users?.length || 0) > 0 && command.ignore?.users?.includes(event.user.id)) return true;
+    if (command.strict?.owner && !client.settings.ownerId.includes(event.user.id)) return await emit(event, 'Command is a developer 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');
+    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');
+    if ((command.strict?.users?.length || 0) > 0 && !command.strict?.users?.includes(event.user.id)) return await emit(event, 'Command cannot be ran by you');
+    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 false;
+}
+async function emit(event, reason) {
+    event.client.emit('commandBlock', event, reason);
+    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/validators/inhibitorValidations.d.ts

@@ -0,0 +1,18 @@
+import { ContextCommandBuilder, MessageCommandBuilder, SlashCommandBuilder } from '../main.js';
+import { XernerxMessage } from '../types/extenders.js';
+import { InhibitorType, XernerxInteraction } from '../types/types.js';
+export declare function inhibitorValidation(event: XernerxMessage | XernerxInteraction, cmd?: ContextCommandBuilder | MessageCommandBuilder | SlashCommandBuilder): Promise<boolean>;
+export declare function inhibitorArguments(
+    event: XernerxMessage | XernerxInteraction,
+    cmd: ContextCommandBuilder | MessageCommandBuilder | SlashCommandBuilder | null,
+    type: InhibitorType
+):
+    | import('discord.js').Guild
+    | import('discord.js').GuildMember
+    | import('discord.js').TextBasedChannel
+    | import('discord.js').User
+    | SlashCommandBuilder
+    | ContextCommandBuilder
+    | MessageCommandBuilder
+    | import('../main.js').APIInteractionGuildMember
+    | null;

package/dist/validators/inhibitorValidations.js

@@ -0,0 +1,34 @@
+export async function inhibitorValidation(event, cmd) {
+    const client = event.client;
+    const inhibits = [];
+    for (const [name, inhibitor] of client.inhibitors) {
+        if (Boolean(await inhibitor.check(event, await inhibitorArguments(event, cmd || null, inhibitor.type)))) {
+            inhibits.push(name);
+        }
+    }
+    return !!inhibits.length;
+}
+export function inhibitorArguments(event, cmd, type) {
+    switch (type) {
+        case 'channel':
+            return event.channel || null;
+        case 'command':
+            return cmd;
+        case 'contextCommand':
+            return cmd;
+        case 'guild':
+            return event.guild || null;
+        case 'interaction':
+            return null;
+        case 'member':
+            return event.member || null;
+        case 'message':
+            return null;
+        case 'messageCommand':
+            return cmd;
+        case 'slashCommand':
+            return cmd;
+        case 'user':
+            return event.user;
+    }
+}

package/package.json

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