xernerx 4.4.3 → 4.4.4

package/dist/handlers/WebhookHandler.js

@@ -0,0 +1,50 @@
+import XernerxLog from '../tools/XernerxLog.js';
+import Handler from './Handler.js';
+export default class WebhookHandler extends Handler {
+    constructor(client) {
+        super(client);
+    }
+    async loadWebhooks(options) {
+        this.client.once('ready', async (client) => {
+            this.post(options.token);
+            setInterval(() => {
+                this.post(client.token);
+            }, 60000 * 30);
+            this.client.util.hasVoted = async (userId) => {
+                return !!(
+                    await (
+                        await fetch(`https://top.gg/api/bots/${this.client.user?.id}/check?userId=${userId}`, {
+                            headers: { Authorization: options.token, 'Content-Type': 'application/json' },
+                        })
+                    ).json()
+                ).voted;
+            };
+        });
+    }
+    async post(token) {
+        const guilds = await this.client.guilds.fetch();
+        this.client.stats.guildCount = this.client.guilds.cache.size;
+        this.client.stats.userCount = (await Promise.all(guilds.map(async (guild) => (await this.client.guilds.fetch(guild.id)).memberCount))).reduce((a, b) => (a += b));
+        this.client.stats.shardId = this.client.options.shards?.at(0) || 0;
+        this.client.stats.shardCount = this.client.options.shardCount || this.client.options.shards?.length || 1;
+        try {
+            new XernerxLog(this.client).info(`Posted Stats to Top.gg!`);
+            this.client.emit('webhookCreate', this.client, this.client.stats);
+            return await fetch(`https://top.gg/api/bots/stats`, {
+                method: 'POST',
+                headers: {
+                    Authorization: token,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    server_count: this.client.stats.guildCount,
+                    shard_id: this.client.stats.shardId,
+                    shard_count: this.client.stats.shardCount,
+                }),
+            });
+        } catch (error) {
+            new XernerxLog(this.client).error(`An error occurred while posting stats to Top.gg`, error);
+            return this.client.emit('webhookError', this.client, this.client.stats);
+        }
+    }
+}

package/dist/main.d.ts

@@ -0,0 +1,42 @@
+import XernerxClient from './client/XernerxClient.js';
+import XernerxShardClient from './client/XernerxShardClient.js';
+import MessageCommandBuilder from './build/MessageCommandBuilder.js';
+import SlashCommandBuilder from './build/SlashCommandBuilder.js';
+import ContextCommandBuilder from './build/ContextCommandBuilder.js';
+import EventBuilder from './build/EventBuilder.js';
+import InhibitorBuilder from './build/InhibitorBuilder.js';
+import XernerxLog from './tools/XernerxLog.js';
+export * from 'discord.js';
+export * from 'dumfunctions';
+import ExtensionBuilder from 'xernerx-extension-builder';
+import Discord from 'discord.js';
+declare const version: any;
+export default XernerxClient;
+export {
+    /**
+     ** Clients
+     */
+    XernerxClient,
+    XernerxShardClient,
+    /**
+     ** Builders
+     */
+    MessageCommandBuilder,
+    SlashCommandBuilder,
+    ContextCommandBuilder,
+    EventBuilder,
+    InhibitorBuilder,
+    ExtensionBuilder,
+    /**
+     ** Imported exports
+     */
+    Discord,
+    /**
+     ** Properties
+     */
+    version,
+    /**
+     ** Tools
+     */
+    XernerxLog,
+};

package/dist/main.js

@@ -0,0 +1,43 @@
+import * as fs from 'fs';
+import XernerxClient from './client/XernerxClient.js';
+import XernerxShardClient from './client/XernerxShardClient.js';
+import MessageCommandBuilder from './build/MessageCommandBuilder.js';
+import SlashCommandBuilder from './build/SlashCommandBuilder.js';
+import ContextCommandBuilder from './build/ContextCommandBuilder.js';
+import EventBuilder from './build/EventBuilder.js';
+import InhibitorBuilder from './build/InhibitorBuilder.js';
+import XernerxLog from './tools/XernerxLog.js';
+export * from 'discord.js';
+export * from 'dumfunctions';
+import ExtensionBuilder from 'xernerx-extension-builder';
+import Discord from 'discord.js';
+const version = JSON.parse(fs.readFileSync('node_modules/xernerx/package.json', 'utf-8')).version;
+export default XernerxClient;
+export {
+    /**
+     ** Clients
+     */
+    XernerxClient,
+    XernerxShardClient,
+    /**
+     ** Builders
+     */
+    MessageCommandBuilder,
+    SlashCommandBuilder,
+    ContextCommandBuilder,
+    EventBuilder,
+    InhibitorBuilder,
+    ExtensionBuilder,
+    /**
+     ** Imported exports
+     */
+    Discord,
+    /**
+     ** Properties
+     */
+    version,
+    /**
+     ** Tools
+     */
+    XernerxLog,
+};

package/dist/models/Arguments.d.ts

@@ -0,0 +1,15 @@
+import SlashCommandBuilder from '../build/SlashCommandBuilder.js';
+import ContextCommandBuilder from '../build/ContextCommandBuilder.js';
+import MessageCommandBuilder from '../build/MessageCommandBuilder.js';
+import { XernerxMessage } from '../types/extenders.js';
+import { MessageCommandArguments } from '../types/interfaces.js';
+import { XernerxInteraction } from '../types/types.js';
+export declare function messageArguments(message: XernerxMessage, command: MessageCommandBuilder): Promise<MessageCommandArguments>;
+export declare function interactionArguments(
+    interaction: XernerxInteraction | any,
+    command: ContextCommandBuilder | SlashCommandBuilder
+): Promise<{
+    args: any;
+    group: any;
+    subcommand: any;
+}>;

package/dist/models/Arguments.js

@@ -0,0 +1,129 @@
+export async function messageArguments(message, command) {
+    const separator = command.separator || ' ',
+        content = message.content.split(separator).slice(1);
+    let args = {},
+        flags = {};
+    if (command.flags)
+        command.flags.map((flag) => {
+            if (!flags) flags = {};
+            if (content.includes(flag.match)) flags[flag.name] = true;
+            else flags[flag.name] = false;
+            const index = content.indexOf(flag.match);
+            if (index > 0) content.splice(index, 1);
+        });
+    if (command.args)
+        for (const argument of command.args) {
+            const element = content.at(0) || null;
+            if (!element) {
+                if (typeof argument.default === 'function') args[argument.name] = argument.default(message);
+                args[argument.name] = argument.default || null;
+                continue;
+            }
+            if (argument.type === 'option') argument.match?.includes(element) ? (args[argument.name] = element) : (args[argument.name] = null);
+            if (argument.type === 'number') args[argument.name] = parseInt(element);
+            if (argument.type === 'integer') args[argument.name] = parseInt(element);
+            if (argument.type === 'boolean') args[argument.name] = element === 'true' ? true : false;
+            if (argument.type === 'confirm') args[argument.name] = element === 'yes' ? 'yes' : 'no';
+            if (argument.type === 'string') args[argument.name] = element;
+            if (argument.type === 'channel') {
+                try {
+                    const channel = await message.client.channels.fetch(element);
+                    args[argument.name] = channel;
+                } catch (e) {
+                    args[argument.name] = null;
+                }
+            }
+            if (argument.type === 'guild') {
+                try {
+                    const guild = await message.client.guilds.fetch(element);
+                    args[argument.name] = guild;
+                } catch (e) {
+                    args[argument.name] = null;
+                }
+            }
+            if (argument.type === 'mentionable') {
+                (
+                    await Promise.all(
+                        [message.guild?.roles, message.client.users, message.client.guilds, message.client.channels, message.guild?.members, message.channel.messages].map((req) =>
+                            req
+                                ? req
+                                      .fetch(element)
+                                      .then((r) => r)
+                                      .catch(() => null)
+                                : null
+                        )
+                    )
+                ).map((mentionable) => {
+                    if (!args) args = {};
+                    if (mentionable) return (args[argument.name] = mentionable);
+                    else args[argument.name] = null;
+                });
+            }
+            if (argument.type === 'role') {
+                try {
+                    const role = await message.guild?.roles.fetch(element);
+                    args[argument.name] = role;
+                } catch (e) {
+                    args[argument.name] = null;
+                }
+            }
+            if (argument.type === 'user') {
+                try {
+                    const user = await message.client.users.fetch(element);
+                    args[argument.name] = user;
+                } catch (e) {
+                    args[argument.name] = null;
+                }
+            }
+            if (argument.type === 'member') {
+                try {
+                    const member = await message.guild?.members.fetch(element);
+                    args[argument.name] = member;
+                } catch (e) {
+                    args[argument.name] = null;
+                }
+            }
+            if (argument.type === 'message') {
+                try {
+                    const msg = await message.channel?.messages.fetch(element);
+                    args[argument.name] = msg;
+                } catch (e) {
+                    args[argument.name] = null;
+                }
+            }
+            if (argument.type === 'list') {
+                let separator = String(argument.separator) || ',';
+                if (separator.startsWith('/') && separator.endsWith('/')) separator = separator.replace(/^\/|\/$/gim, '');
+                const items = content.join(' ').split(new RegExp(' *' + separator + ' *', 'gi'));
+                if (!argument.content) args[argument.name] = items;
+                else {
+                    const contents = argument.content.map((content) => content.toLowerCase()),
+                        itemList = [];
+                    items.map((item) => (contents.includes(item.toLowerCase()) ? itemList.push(argument.content?.at(contents.indexOf(item.toLowerCase()))) : null));
+                    args[argument.name] = itemList;
+                    break;
+                }
+            }
+            if (argument.type === 'rest') {
+                args[argument.name] = content.join(separator);
+                break;
+            }
+            content.splice(0, 1);
+        }
+    if (!command.flags) flags = null;
+    if (!command.args) args = null;
+    return { args, flags };
+}
+export async function interactionArguments(interaction, command) {
+    const options = {};
+    let args = interaction?.options?._hoistedOptions,
+        group = interaction?.options?._group,
+        subcommand = interaction?.options?._subcommand;
+    if (interaction.options._hoistedOptions) {
+        for (const option of interaction.options._hoistedOptions) {
+            options[option.name] = option.member || option.channel || option.user || option.role || option.value;
+        }
+        args = options;
+    }
+    return { args, group, subcommand };
+}

package/dist/tools/XernerxError.d.ts

@@ -0,0 +1,6 @@
+export default class XernerxError {
+    name: string;
+    message: string | null;
+    stack: {} | undefined;
+    constructor(message?: string, error?: Error | unknown);
+}

package/dist/tools/XernerxError.js

@@ -0,0 +1,10 @@
+export default class XernerxError {
+    name;
+    message;
+    stack;
+    constructor(message, error) {
+        this.name = 'XernerxError';
+        this.message = message || null;
+        this.stack = error || new Error().stack;
+    }
+}

package/dist/tools/XernerxLog.d.ts

@@ -0,0 +1,14 @@
+import XernerxError from './XernerxError.js';
+import XernerxClient from '../client/XernerxClient.js';
+export default class XernerxLog {
+    private readonly client;
+    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;
+    error(message: string, error?: XernerxError | unknown): void | null;
+    ready(): void;
+}

package/dist/tools/XernerxLog.js

@@ -0,0 +1,48 @@
+import { Style } from 'dumfunctions';
+export default class XernerxLog {
+    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;
+    }
+    warn(message) {
+        return this.infoLog ? console.warn(`${Style.log('⚠️  | Xernerx', { color: Style.TextColor.Yellow })} | ${message}`) : null;
+    }
+    error(message, error) {
+        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.info(
+                `${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

@@ -0,0 +1,28 @@
+import { ChatInputCommandInteraction, DMChannel, Guild, GuildChannel, GuildMember, Message, MessageContextMenuCommandInteraction, User, UserContextMenuCommandInteraction } from 'discord.js';
+import InteractionUtil from '../utils/InteractionUtil.js';
+import MessageUtil from '../utils/MessageUtil.js';
+export interface XernerxUser extends User {
+    owner: boolean;
+    voted: boolean | null;
+}
+export interface XernerxMember extends GuildMember {
+    username: string;
+}
+export interface XernerxGuild extends Guild {}
+export interface XernerxGuildChannel extends GuildChannel {}
+export interface XernerxDMChannel extends DMChannel {}
+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 {};

package/dist/types/extenders.js

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

package/dist/types/interfaces.d.ts

@@ -0,0 +1,236 @@
+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 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 {
+    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 {
+    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;
+    usage?: 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 | 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<{
+        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: 'client' | 'process';
+    type: 'discord';
+    once: boolean;
+}
+export interface InhibitorBuilderOptions {
+    name: string;
+    type: InhibitorType;
+}
+export interface PresenceOptions {
+    text: string;
+    type?: ActivityType.Playing | ActivityType.Streaming | ActivityType.Listening | ActivityType.Watching | ActivityType.Competing;
+    url: string;
+    status?: PresenceStatusData;
+    interval?: number;
+}
+export {};

package/dist/types/interfaces.js

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