xernerx 3.6.0 → 4.0.1

package/dist/types/interfaces.d.ts

@@ -0,0 +1,224 @@
+import { ChannelType, Collection } from 'discord.js';
+import CommandHandler from '../handlers/CommandHandler.js';
+import EventHandler from '../handlers/EventHandler.js';
+import InhibitorHandler from '../handlers/InhibitorHandler.js';
+import WebhookHandler from '../handlers/WebhookHandler.js';
+import ContextCommandBuilder from '../build/ContextCommandBuilder.js';
+import MessageCommandBuilder from '../build/MessageCommandBuilder.js';
+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;
+    };
+}
+export interface ModuleOptions {
+    options: {
+        message?: MessageHandlerOptions;
+        slash?: SlashHandlerOptions;
+        context?: ContextHandlerOptions;
+        events?: EventHandlerOptions;
+        inhibitors?: InhibitorHandlerOptions;
+    };
+    commandHandler: CommandHandler;
+    eventHandler: EventHandler;
+    inhibitorHandler: InhibitorHandler;
+    webhookHandler: WebhookHandler;
+    extensionHandler: ExtensionHandler;
+}
+export interface XernerxCommands {
+    message: Collection<string, MessageCommandBuilder>;
+    slash: Collection<string, SlashCommandBuilder>;
+    context: Collection<string, ContextCommandBuilder>;
+}
+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<string>;
+        client?: Array<string>;
+        dm?: boolean;
+    };
+    logging?: 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;
+    info?: string | null;
+    category?: string | null;
+    cooldown?: number | null;
+    ignore?: {
+        owner?: boolean;
+        users?: Array<string>;
+        channels?: Array<string>;
+        guilds?: Array<string>;
+    };
+    strict?: {
+        owner?: boolean;
+        users?: Array<string>;
+        channels?: Array<string>;
+        guilds?: Array<string>;
+    };
+    permissions?: {
+        user?: Array<PermissionNames> | Array<string>;
+        client?: Array<PermissionNames> | Array<string>;
+        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;
+    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<{
+        name: string;
+        value: string;
+    }>;
+}
+export interface SlashCommandSubcommandOptions {
+    name: string;
+    description: string;
+    args: Array<SlashCommandArgumentOptions>;
+}
+export interface SlashCommandGroupOptions {
+    name: string;
+    description: string;
+    subcommands: Array<SlashCommandSubcommandOptions>;
+}
+export interface SlashCommandArguments {
+    args: Record<string, string>;
+    subcommand: Record<string, string>;
+    group: Record<string, string>;
+}
+export interface EventBuilderOptions {
+    name: EventType;
+    emitter: 'discord' | 'process';
+    type: string;
+    once: boolean;
+}
+export interface InhibitorBuilderOptions {
+    name: string;
+    type: InhibitorType;
+}
+export {};

package/dist/types/interfaces.js

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

package/dist/types/options.js

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

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,6 @@
+import XernerxClient from '../main.js';
+import Util from './Util.js';
+export default class ClientUtil extends Util {
+    hasVoted?: Function;
+    constructor(client: XernerxClient);
+}

package/dist/utils/ClientUtil.js

@@ -0,0 +1,7 @@
+import Util from './Util.js';
+export default class ClientUtil extends Util {
+    hasVoted;
+    constructor(client) {
+        super(client);
+    }
+}

package/dist/{cjs/utils → utils}/CommandUtil.js

@@ -1,14 +1,6 @@
-'use strict';
-var __importDefault =
-    (this && this.__importDefault) ||
-    function (mod) {
-        return mod && mod.__esModule ? mod : { default: mod };
-    };
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.InteractionCommandUtil = exports.MessageCommandUtil = void 0;
-const discord_js_1 = require('discord.js');
-const XernerxError_js_1 = __importDefault(require('../tools/XernerxError.js'));
-class MessageCommandUtil {
+import { ActionRowBuilder, ButtonBuilder, ButtonStyle, EmbedBuilder, StringSelectMenuBuilder } from 'discord.js';
+import XernerxError from '../tools/XernerxError.js';
+export class MessageCommandUtil {
     client;
     message;
     constructor(client, message) {
@@ -90,8 +82,7 @@ class MessageCommandUtil {
     }
     createModal() {}
 }
-exports.MessageCommandUtil = MessageCommandUtil;
-class InteractionCommandUtil {
+export class InteractionCommandUtil {
     client;
     interaction;
     constructor(client, interaction) {
@@ -110,12 +101,12 @@ class InteractionCommandUtil {
     }
     getCommandName() {}
     selectMenuPaginator(embeds, options) {
-        if (!Array.isArray(embeds)) throw new XernerxError_js_1.default(`Expected embeds to be of type array, received ${typeof embeds} instead.`);
-        if (embeds.length > 25) throw new XernerxError_js_1.default(`Max select menu length is 25.`);
+        if (!Array.isArray(embeds)) throw new XernerxError(`Expected embeds to be of type array, received ${typeof embeds} instead.`);
+        if (embeds.length > 25) throw new XernerxError(`Max select menu length is 25.`);
         if (typeof options !== 'object') options = {};
         if (!Array.isArray(options.components)) options.components = [];
         if (!options.index) {
-            options.index = new discord_js_1.EmbedBuilder().setTitle('Index').setColor('Random');
+            options.index = new EmbedBuilder().setTitle('Index').setColor('Random');
             for (const embed of embeds) {
                 options.index.addFields([
                     {
@@ -127,14 +118,9 @@ class InteractionCommandUtil {
             }
         }
         if (!options.row) {
-            options.row = new discord_js_1.ActionRowBuilder();
+            options.row = new ActionRowBuilder();
             if (!options.id) options.id = `${this.interaction.id}-menu`;
-            options.component = new discord_js_1.StringSelectMenuBuilder()
-                .setCustomId(options.id)
-                .setMaxValues(1)
-                .setMinValues(1)
-                .setPlaceholder('Select a page.')
-                .addOptions({ label: 'index', value: '0' });
+            options.component = new StringSelectMenuBuilder().setCustomId(options.id).setMaxValues(1).setMinValues(1).setPlaceholder('Select a page.').addOptions({ label: 'index', value: '0' });
             embeds.map((embed, i = 0) => {
                 options?.component?.addOptions({
                     label: embed.data.title || 'No Name',
@@ -168,21 +154,21 @@ class InteractionCommandUtil {
         });
     }
     buttonPaginator(embeds, options) {
-        if (!Array.isArray(embeds)) throw new XernerxError_js_1.default(`Expected embeds to be of type array, received ${typeof embeds} instead.`);
-        if (embeds.length <= 0) throw new XernerxError_js_1.default(`The minimum embeds is 1.`);
+        if (!Array.isArray(embeds)) throw new XernerxError(`Expected embeds to be of type array, received ${typeof embeds} instead.`);
+        if (embeds.length <= 0) throw new XernerxError(`The minimum embeds is 1.`);
         if (typeof options !== 'object') options = {};
         if (!Array.isArray(options.components)) options.components = [];
         if (!options.row) {
-            options.row = new discord_js_1.ActionRowBuilder();
+            options.row = new ActionRowBuilder();
             if (!options.id) options.id = `${this.interaction.id}-menu`;
         }
         if (!options.buttons) options.buttons = ['⏮️', '◀️', '⏹️', '▶️', '⏭️'];
         for (const button of options.buttons) {
             options.row.addComponents(
-                new discord_js_1.ButtonBuilder()
+                new ButtonBuilder()
                     .setCustomId(`${this.interaction.id}-${options.buttons.indexOf(button)}`)
                     .setEmoji(button)
-                    .setStyle(discord_js_1.ButtonStyle.Primary)
+                    .setStyle(ButtonStyle.Primary)
             );
         }
         let embed = embeds[options.index || 0];
@@ -244,4 +230,3 @@ class InteractionCommandUtil {
     }
     createModal() {}
 }
-exports.InteractionCommandUtil = InteractionCommandUtil;

package/dist/utils/InteractionArguments.d.ts

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

package/dist/utils/InteractionArguments.js

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

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,11 @@
+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 message;
+    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,42 @@
+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;
+    }
+    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;
+    }
+}