xernerx 4.2.0 → 4.2.1

package/dist/cjs/types/options.d.ts

@@ -0,0 +1,241 @@
+import { CacheFactory, ChannelType, ContextMenuCommandType, MessageMentionOptions, Partials, PresenceData, RESTOptions, SweeperOptions, WebSocketOptions } from 'discord.js';
+import XernerxExtensionBuilder from 'xernerx-extension-builder';
+import { InhibitorType } from './enums.js';
+import { EventEmitterType, Localizations, MessageCommandArgsTypes } from './types.js';
+export interface DiscordOptions {
+    shards?: number | number[] | 'auto';
+    closeTimeout?: number;
+    shardCount?: number;
+    makeCache?: CacheFactory;
+    allowedMentions?: MessageMentionOptions;
+    partials?: Array<Partials>;
+    failIfNotExists?: boolean;
+    presence?: PresenceData;
+    intents: number[];
+    waitGuildTimeout?: number;
+    sweepers?: SweeperOptions;
+    ws?: WebSocketOptions;
+    rest?: RESTOptions;
+    jsonTransformer?: (obj: unknown) => unknown;
+}
+export interface ClientOptions {
+    ownerId?: string | 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 HandlerOptions {
+    message?: MessageCommandHandlerOptions;
+    slash?: SlashCommandHandlerOptions;
+    context?: ContextCommandHandlerOptions;
+    events?: EventHandlerOptions;
+    inhibitors?: InhibitorHandlerOptions;
+}
+export interface ExtensionOptions {
+    extensions: Array<XernerxExtensionBuilder>;
+    logging?: boolean;
+}
+export interface MessageCommandOptions {
+    name: string;
+    aliases?: Array<string>;
+    separator?: string;
+    description?: string;
+    info?: string;
+    category?: string;
+    prefix?: Array<string> | string;
+    regex?: string;
+    channelType?: Array<number>;
+    cooldown?: number;
+    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?: {
+        client?: Array<string>;
+        user?: Array<string>;
+        dm?: boolean;
+    };
+    args?: Array<MessageArgumentOptions>;
+}
+export interface ContextCommandOptions {
+    name: string;
+    type: ContextMenuCommandType;
+    nameLocalizations: Record<Localizations, string>;
+    description?: string;
+    info?: string;
+    category?: string;
+    channelType?: Array<number> | number;
+    cooldown?: number;
+    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?: {
+        client?: Array<string>;
+        users?: Array<string>;
+        dm?: boolean;
+    };
+    defer?: {
+        reply?: boolean;
+        ephemeral?: boolean;
+        fetch?: boolean;
+    };
+}
+export interface MessageArgumentOptions {
+    type: MessageCommandArgsTypes;
+    content?: Array<string>;
+    match?: string;
+    name: string;
+    prompt?: {
+        reply: string;
+        send: string;
+    };
+    default?: string | Function;
+}
+export interface SlashArgumentOptions {
+    type: 'string' | 'number' | 'boolean' | 'user' | 'channel' | 'role' | 'mentionable' | 'integer';
+    name: string;
+    choices: Array<{
+        name: string;
+        value: string;
+    }>;
+    required: boolean;
+    description: string;
+}
+export interface SlashSubcommandOptions {
+    name: string;
+    description: string;
+    args: Array<SlashArgumentOptions>;
+}
+export interface SlashGroupOptions {
+    name: string;
+    description: string;
+    subcommands: Array<SlashSubcommandOptions>;
+}
+export interface SlashCommandOptions {
+    name: string;
+    description: string;
+    info?: string;
+    category?: string;
+    owner?: boolean;
+    channelType?: ChannelType;
+    cooldown?: number;
+    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: {
+        client?: Array<string>;
+        users?: Array<string>;
+        dm?: boolean;
+    };
+    defer?: {
+        reply?: boolean;
+        ephemeral?: boolean;
+        fetchReply?: boolean;
+    };
+    args?: Array<SlashArgumentOptions>;
+    subcommands?: Array<SlashSubcommandOptions>;
+    groups?: Array<SlashGroupOptions>;
+}
+export interface MessageCommandHandlerOptions {
+    directory: string;
+    prefix: string[] | string;
+    allowMention?: boolean;
+    cooldown?: number;
+    userPermissions?: bigint[];
+    clientPermissions?: bigint[];
+    handleEdits?: boolean;
+    handleDeletes?: boolean;
+    handleTyping?: boolean;
+    util?: boolean;
+    logging?: boolean;
+}
+export interface SlashCommandHandlerOptions {
+    directory: string;
+    guildId: string;
+    global: boolean;
+    cooldown?: number;
+    userPermissions?: bigint[];
+    clientPermissions?: bigint[];
+    util?: boolean;
+    logging?: boolean;
+    defer?: {
+        reply?: boolean;
+        ephemeral?: boolean;
+        fetchReply?: boolean;
+    };
+}
+export interface ContextCommandHandlerOptions {
+    directory: string;
+    guildId: string;
+    global: boolean;
+    cooldown?: number;
+    userPermissions?: bigint[];
+    clientPermissions?: bigint[];
+    util?: boolean;
+    logging?: boolean;
+    defer?: {
+        reply?: boolean;
+        ephemeral?: boolean;
+        fetchReply?: boolean;
+    };
+}
+export interface EventHandlerOptions {
+    directory: string;
+    logging?: boolean;
+}
+export interface EventOptions {
+    name: string;
+    emitter?: EventEmitterType | string;
+    type?: 'discord' | string;
+    once?: boolean;
+}
+export interface InhibitorHandlerOptions {
+    directory: string;
+    logging?: boolean;
+}
+export interface InhibitorOptions {
+    name: string;
+    type: InhibitorType;
+}

package/dist/cjs/types/options.js

@@ -0,0 +1,2 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/cjs/types/types.d.ts

@@ -0,0 +1,61 @@
+import { TextChannel, Message, User, Guild, GuildMember, Channel, Role, InteractionResponse } from 'discord.js';
+import { InteractionCommandUtil, MessageCommandUtil } from '../utils/CommandUtil.js';
+export interface XernerxMessage extends Message {
+    util?: MessageCommandUtil;
+    response?: string;
+}
+export interface XernerxInteraction extends InteractionResponse {
+    util: InteractionCommandUtil;
+    options?: {
+        _group: string;
+        _subcommand: string;
+        _hoistedOptions: Array<{
+            name: string;
+            channel: Channel;
+            user: XernerxUser;
+            role: XernerxRole;
+            value: string;
+        }>;
+    };
+}
+export interface XernerxUser extends User {
+    isOwner: boolean;
+}
+export interface XernerxRole extends Role {}
+export interface XernerxTextChannel extends TextChannel {}
+export interface XernerxGuild extends Guild {}
+export interface XernerxMember extends GuildMember {}
+export type MessageCommandArgsTypes = 'rest' | 'option' | 'flag' | 'string' | 'number' | 'channel' | 'user' | 'member' | 'boolean' | 'role';
+export type Localizations =
+    | 'id'
+    | 'da'
+    | 'de'
+    | 'en-GB'
+    | 'en-US'
+    | 'es-ES'
+    | 'fr'
+    | 'hr'
+    | 'it'
+    | 'lt'
+    | 'hu'
+    | 'nl'
+    | 'no'
+    | 'pl'
+    | 'pt-BR'
+    | 'ro'
+    | 'fi'
+    | 'sv-SE'
+    | 'vi'
+    | 'tr'
+    | 'cs'
+    | 'el'
+    | 'bg'
+    | 'ru'
+    | 'uk'
+    | 'hi'
+    | 'th'
+    | 'zh-CN'
+    | 'ja'
+    | 'zh-TW'
+    | 'ko';
+export type EventEmitterType = 'client' | 'process';

package/dist/cjs/types/types.js

@@ -0,0 +1,2 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/cjs/utils/ClientUtil.d.ts

@@ -0,0 +1,25 @@
+import { ActivityType, ClientPresenceStatus } from 'discord.js';
+import XernerxClient from '../client/XernerxClient.js';
+interface Presence {
+    text?: string;
+    type?: ActivityType.Playing | ActivityType.Streaming | ActivityType.Listening | ActivityType.Watching | ActivityType.Competing;
+    link?: string;
+    status?: ClientPresenceStatus;
+    interval?: number;
+}
+export declare class ClientUtil {
+    client: XernerxClient;
+    constructor(client: XernerxClient);
+    uptime(timestamp: number | null): string;
+    getSubcommands(name: string): object[];
+    isOwner(userId: string): boolean;
+    getAllCommands(): object[];
+    getAllMessageCommands(): object[];
+    getAllSlashCommands(): object[];
+    getAllContextCommands(): object[];
+    setPresence(options: Presence): void;
+    getCooldowns(id: string, command?: string): any;
+    getCooldownTimers(id: string, command?: string): any;
+    defer(time: number): Promise<unknown>;
+}
+export {};

package/dist/cjs/utils/ClientUtil.js

@@ -0,0 +1,211 @@
+'use strict';
+var __importDefault =
+    (this && this.__importDefault) ||
+    function (mod) {
+        return mod && mod.__esModule ? mod : { default: mod };
+    };
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.ClientUtil = void 0;
+const XernerxError_js_1 = __importDefault(require('../tools/XernerxError.js'));
+class ClientUtil {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    uptime(timestamp) {
+        if (!timestamp) timestamp = this.client.uptime || 0;
+        let totalSeconds = timestamp / 1000;
+        let years = Math.floor(totalSeconds / 31536000);
+        totalSeconds %= 31536000;
+        let days = Math.floor(totalSeconds / 86400);
+        totalSeconds %= 86400;
+        let hours = Math.floor(totalSeconds / 3600);
+        totalSeconds %= 3600;
+        let minutes = Math.floor(totalSeconds / 60);
+        let seconds = Math.floor(totalSeconds % 60);
+        if (years >= 1) return `${years}y ${days}d ${hours}h ${minutes}m`;
+        else if (days >= 1) return `${days}d ${hours}h ${minutes}m`;
+        else if (hours >= 1) return `${hours}h ${minutes}m`;
+        else if (minutes >= 1) return `${minutes}m ${seconds}s`;
+        else return `${seconds}s`;
+    }
+    getSubcommands(name) {
+        if (!name || typeof name !== 'string') throw new XernerxError_js_1.default(`Expected name to be of type string, received ${typeof name} instead!`);
+        const commands = [];
+        this.getAllCommands()
+            .filter((c) => (c.data?.name?.toLowerCase() || c.name?.toLowerCase()) == name?.toLowerCase())
+            .map((c) => {
+                if (c?.data?.options?.length > 0) {
+                    c?.data?.options?.map((option) => {
+                        if (!option?.type) {
+                            if (option?.options?.length > 0) {
+                                option?.options?.map((opt) => {
+                                    if (!opt.type) {
+                                        commands.push({
+                                            name: c.data.name,
+                                            formattedName: `${c.data.name} ${option.name} ${opt.name}`,
+                                            description: opt.description,
+                                            category: c.category || null,
+                                            commandType: c.commandType,
+                                        });
+                                    } else {
+                                        commands.push({
+                                            name: c.data.name,
+                                            formattedName: `${c.data.name} ${option.name}`,
+                                            description: option.description,
+                                            category: c.category || null,
+                                            commandType: c.commandType,
+                                        });
+                                    }
+                                });
+                            } else {
+                                commands.push({
+                                    name: c.data.name,
+                                    formattedName: `${c.data.name} ${option.name}`,
+                                    description: option.description,
+                                    category: c.category || null,
+                                    commandType: c.commandType,
+                                });
+                            }
+                        } else {
+                            commands.push({
+                                name: c.data.name,
+                                formattedName: `${c.data.name}`,
+                                description: c.data.description,
+                                category: c.category || null,
+                                commandType: c.commandType,
+                            });
+                        }
+                    });
+                } else {
+                    commands.push({
+                        name: c.data?.name || c.name,
+                        formattedName: `${c.data?.name || c.name}`,
+                        description: c.data?.description || c.description,
+                        category: c.category || null,
+                        commandType: c.commandType,
+                    });
+                }
+            });
+        return commands;
+    }
+    isOwner(userId) {
+        if (!userId) throw new XernerxError_js_1.default('No ID specified');
+        let owners = this.client.settings.ownerId;
+        if (!owners) return false;
+        if (typeof owners === 'string') owners = [owners];
+        return owners.includes(userId);
+    }
+    getAllCommands() {
+        const cmds = [];
+        for (const commands of Object.values(this.client.commands)) {
+            commands.map((cmd) => cmds.push(cmd));
+        }
+        return cmds;
+    }
+    getAllMessageCommands() {
+        const cmds = [];
+        this.client.commands.message.map((cmd) => cmds.push(cmd));
+        return cmds;
+    }
+    getAllSlashCommands() {
+        const cmds = [];
+        this.client.commands.slash.map((cmd) => cmds.push(cmd));
+        return cmds;
+    }
+    getAllContextCommands() {
+        const cmds = [];
+        this.client.commands.context.map((cmd) => cmds.push(cmd));
+        return cmds;
+    }
+    setPresence(options) {
+        const client = this.client;
+        function pres() {
+            client.user?.setPresence({
+                activities: [
+                    {
+                        name: options.text || undefined,
+                        type: options.type || undefined,
+                        url: options.link || undefined,
+                    },
+                ],
+                status: options.status || undefined,
+            });
+        }
+        pres();
+        if (options.interval) {
+            setInterval(() => {
+                pres();
+            }, options.interval);
+        }
+    }
+    getCooldowns(id, command) {
+        let cooldowns = [];
+        for (const [key, value] of Object.entries(this.client.cache)) {
+            if (!['cooldowns', 'messageCommands', 'slashCommands', 'contextCommands', 'commands'].includes(key)) continue;
+            if (key === 'commands') {
+                if (command) {
+                    value.map((x) => {
+                        const name = x.name.split(/-/);
+                        name.pop();
+                        if (name.join('-') === id + '-' + command) {
+                            cooldowns.push(x);
+                        }
+                    });
+                } else {
+                    value.map((x) => {
+                        if (x.name.split(/-/).shift() === id) {
+                            cooldowns.push(x);
+                        }
+                    });
+                }
+            } else {
+                if (value.has(id)) {
+                    const x = value.get(id);
+                    cooldowns.push(x);
+                }
+            }
+        }
+        return cooldowns;
+    }
+    getCooldownTimers(id, command) {
+        let cooldowns = [];
+        for (const [key, value] of Object.entries(this.client.cache)) {
+            if (!['cooldowns', 'messageCommands', 'slashCommands', 'contextCommands', 'commands'].includes(key)) continue;
+            if (key === 'commands') {
+                if (command) {
+                    value.map((x) => {
+                        const name = x.name.split(/-/);
+                        name.pop();
+                        if (name.join('-') === id + '-' + command) {
+                            cooldowns.push({
+                                [x.commandName]: x.endsAt - Date.now(),
+                            });
+                        }
+                    });
+                } else {
+                    value.map((x) => {
+                        if (x.name.split(/-/).shift() === id) {
+                            cooldowns.push({
+                                [x.commandName]: x.endsAt - Date.now(),
+                            });
+                        }
+                    });
+                }
+            } else {
+                if (value.has(id)) {
+                    const x = value.get(id);
+                    cooldowns.push({ [key]: x.endsAt - Date.now() });
+                }
+            }
+        }
+        const sort = cooldowns.map((x) => Object.entries(x).shift()).sort((a, b) => b[1] - a[1]);
+        cooldowns = [];
+        sort.map(([key, value]) => cooldowns.push({ [key]: value }));
+        return cooldowns;
+    }
+    async defer(time) {
+        return new Promise((resolve) => setTimeout(resolve, time || 0));
+    }
+}
+exports.ClientUtil = ClientUtil;

package/dist/cjs/utils/CommandUtil.d.ts

@@ -0,0 +1,58 @@
+import { ActionRowBuilder, ButtonBuilder, EmbedBuilder, Interaction, Message, MessagePayload, StringSelectMenuBuilder } from 'discord.js';
+import XernerxClient from '../client/XernerxClient.js';
+import { XernerxMessage } from '../types/types.js';
+interface SelectMenuOptions {
+    index?: EmbedBuilder;
+    row?: ActionRowBuilder;
+    component?: StringSelectMenuBuilder;
+    components?: object[];
+    reply?: boolean;
+    id?: string;
+    filter?: Function;
+    time?: number;
+    ephemeral?: boolean;
+}
+interface ButtonOptions {
+    index?: number;
+    buttons?: Array<string>;
+    reply?: boolean;
+    row?: ActionRowBuilder;
+    component?: ButtonBuilder;
+    components?: object[];
+    id?: string;
+    filter?: any;
+    time?: number;
+    ephemeral?: boolean;
+}
+export declare class MessageCommandUtil {
+    client: XernerxClient;
+    message: XernerxMessage;
+    constructor(client: XernerxClient, message: Message & XernerxMessage);
+    reply(content: MessagePayload | string): Promise<Message<boolean> | undefined>;
+    send(content: MessagePayload | string): Promise<Message<true> | Message<false> | undefined>;
+    defer(time: number): Promise<unknown>;
+    getCommands(): import('@discordjs/collection').Collection<string, import('../main.js').MessageCommandBuilder>;
+    getCommandName(): void;
+    selectMenuPaginator(embeds: Array<EmbedBuilder>, options?: SelectMenuOptions): void;
+    buttonPaginator(embeds: Array<EmbedBuilder>, options: ButtonOptions): void;
+    buttonMenuPaginator(embeds: Array<EmbedBuilder>, options: ButtonOptions & SelectMenuOptions): void;
+    isOwner(): boolean;
+    createModal(): void;
+}
+export declare class InteractionCommandUtil {
+    client: XernerxClient;
+    interaction: any;
+    constructor(client: XernerxClient, interaction: Interaction);
+    reply(content: MessagePayload | string): any;
+    defer(time: number): Promise<unknown>;
+    getCommands():
+        | import('@discordjs/collection').Collection<string, import('../main.js').SlashCommandBuilder>
+        | import('@discordjs/collection').Collection<string, import('../main.js').ContextCommandBuilder>;
+    getCommandName(): void;
+    selectMenuPaginator(embeds: Array<EmbedBuilder>, options?: SelectMenuOptions): void;
+    buttonPaginator(embeds: Array<EmbedBuilder>, options: ButtonOptions): void;
+    buttonMenuPaginator(embeds: Array<EmbedBuilder>, options: ButtonOptions & SelectMenuOptions): void;
+    isOwner(): boolean;
+    createModal(): void;
+}
+export {};