xernerx 4.17.9 → 5.0.2

package/dist/client/XernerxClient.js

@@ -1,109 +0,0 @@
-/** @format */
-import { Client, Collection } from 'discord.js';
-import { z } from 'zod';
-import * as clack from '@clack/prompts';
-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 XernerxLog from '../tools/XernerxLog.js';
-import ClientUtil from '../utils/ClientUtil.js';
-import ExtensionHandler from '../handlers/ExtensionHandler.js';
-import deploy from '../functions/deploy.js';
-import Cooldowns from '../models/Cooldowns.js';
-export default class XernerxClient extends Client {
-    constructor(discordOptions, xernerxOptions, config) {
-        super(discordOptions);
-        clack.intro('Xernerx');
-        this.settings = z
-            .object({
-            local: z.string(),
-            global: z.boolean().default(false).optional(),
-            debug: z.boolean().default(false).optional(),
-            ownerId: z.string().or(z.array(z.string())).default([]),
-            ceaseless: z.boolean().default(false),
-            permissions: z
-                .object({
-                client: z.array(z.string()).or(z.null()).default(null),
-                user: z.array(z.string()).or(z.null()).default(null),
-                dm: z.boolean().default(false),
-            })
-                .optional(),
-            ignore: z
-                .object({
-                owner: z.boolean().default(false),
-                self: z.boolean().default(true),
-                bots: z.boolean().default(true),
-                system: z.boolean().default(true),
-                users: z.array(z.string()).default([]),
-                channels: z.array(z.string()).default([]),
-                guilds: z.array(z.string()).default([]),
-            })
-                .optional(),
-            log: z
-                .object({
-                ready: z.boolean().default(false),
-                info: z.boolean().default(false),
-                warn: z.boolean().default(false),
-                error: z.boolean().default(false),
-                table: z.array(z.string()).or(z.null()).default(null),
-                format: z.array(z.string()).or(z.null()).default(null),
-            })
-                .or(z.boolean())
-                .optional(),
-            cooldown: z
-                .object({
-                command: z.number().default(0),
-                cache: z.number().default(0),
-                collections: z.array(z.string()).default(['commands']),
-            })
-                .optional(),
-        })
-            .parse(xernerxOptions);
-        this.config = config;
-        this.commands = {
-            message: new Collection(),
-            slash: new Collection(),
-            context: new Collection(),
-        };
-        this.events = new Collection();
-        this.inhibitors = new Collection();
-        this.util = new ClientUtil(this);
-        this.stats = {
-            guildCount: this.guilds.cache.size,
-            userCount: 0,
-            shardId: 0,
-            shardCount: this.options.shardCount || 1,
-            voteCount: 0,
-        };
-        this.dbl = {};
-        this.cache = {
-            messages: new Collection(),
-            cooldowns: new Collection(),
-        };
-        this.cooldowns = new Cooldowns(this, xernerxOptions.cooldown?.collections);
-        this.modules = {
-            options: {},
-            commandHandler: new CommandHandler(this),
-            eventHandler: new EventHandler(this),
-            inhibitorHandler: new InhibitorHandler(this),
-            integrationHandler: new IntegrationHandler(this),
-            extensionHandler: new ExtensionHandler(this),
-        };
-        this.store = {};
-    }
-    async connect(token) {
-        if (this.settings.debug)
-            new XernerxLog(this).debug(`Connecting to discord using token ${token}...`);
-        const login = await this.login(token).catch(() => {
-            new XernerxLog(this).error('An invalid token was provided. Please make sure to provide a valid Discord bot token.');
-        });
-        if (this.settings.debug)
-            new XernerxLog(this).debug(`Connected to discord using token ${token}`);
-        deploy(this);
-        new XernerxLog(this).ready();
-        const spinner = clack.spinner();
-        spinner.start();
-        return login;
-    }
-}

package/dist/client/XernerxShardClient.d.ts

@@ -1,21 +0,0 @@
-/** @format */
-import { ShardingManager, ShardingManagerOptions, ClientUser } from 'discord.js';
-interface XernerxOptions {
-    log?: {
-        info?: boolean;
-    };
-    timeout?: number;
-}
-export default class XernerxShardClient extends ShardingManager {
-    readonly stats: {
-        guildCount: number;
-        userCount: number;
-        shardCount: number;
-        voteCount: number;
-        shards: {};
-    };
-    user: ClientUser | null;
-    spawner: Promise<import("discord.js").Collection<number, import("discord.js").Shard>>;
-    constructor(file: string, discordOptions: ShardingManagerOptions, xernerxOptions?: XernerxOptions, data?: unknown);
-}
-export {};

package/dist/client/XernerxShardClient.js

@@ -1,54 +0,0 @@
-/** @format */
-import { ShardingManager } from 'discord.js';
-import { Style } from 'dumfunctions';
-import XernerxLog from '../tools/XernerxLog.js';
-export default class XernerxShardClient extends ShardingManager {
-    constructor(file, discordOptions, xernerxOptions, data = {}) {
-        super(file, discordOptions);
-        this.stats = { guildCount: 0, userCount: 0, shardCount: 0, voteCount: 0, shards: {} };
-        this.user = null;
-        new XernerxLog(true).info('Starting sharding process...');
-        this.on('shardCreate', async (shard) => {
-            shard
-                .on('ready', async () => {
-                await new Promise((resolve) => setTimeout(resolve, 250));
-                const stats = (await shard.fetchClientValue('stats'));
-                this.stats.shards[String(shard.id)] = stats;
-                this.user = (await shard.fetchClientValue('user'));
-                this.stats.guildCount += stats.guildCount;
-                this.stats.userCount += stats.userCount;
-                this.stats.shardCount++;
-                this.stats.voteCount = stats.voteCount;
-                shard.send({ type: 'xernerx', data: { shardId: shard.id, sharded: true } });
-                shard.send({ type: 'client', data });
-                new XernerxLog({ settings: xernerxOptions }).info(`Launched shard ${Style.log(String(shard.id), { color: Style.TextColor.Cyan })} for ${Style.log(this.user?.tag, { color: Style.TextColor.Blue })}! ${xernerxOptions?.timeout ? `Automatically killing in ${Style.log(String(xernerxOptions.timeout), { color: Style.TextColor.Cyan })}ms.` : ''}`);
-            })
-                .on('error', (error) => {
-                new XernerxLog({ settings: xernerxOptions }).info(`An error occurred in ${Style.log(String(shard.id), { color: Style.TextColor.Cyan })} for ${Style.log(String(this.user?.tag), { color: Style.TextColor.Blue })}! ${error}`);
-            });
-            if (xernerxOptions?.timeout)
-                setTimeout(() => {
-                    new XernerxLog({ settings: xernerxOptions }).warn(`Automatically killing shard ${Style.log(String(shard.id), { color: Style.TextColor.Cyan })} on ${Style.log(String(shard.manager.user?.tag), {
-                        color: Style.TextColor.Blue,
-                    })}!`);
-                    shard.kill();
-                }, xernerxOptions.timeout);
-        });
-        const spawn = this.spawn();
-        this.spawner = spawn;
-        spawn.then(async (shards) => {
-            const collector = setInterval(() => {
-                const index = shards.size - 1;
-                if (shards.get(index)?.ready) {
-                    clearInterval(collector);
-                    new XernerxLog({ settings: xernerxOptions }).info(`All Shards launched for ${Style.log(String(this.user?.tag), {
-                        color: Style.TextColor.Blue,
-                    })} with a total of ${Style.log(String(this.stats.shardCount), { color: Style.TextColor.Cyan })} shard${this.stats.shardCount > 1 ? 's' : ''}, watching ${Style.log(String(this.stats.guildCount), {
-                        color: Style.TextColor.Cyan,
-                    })} guild${this.stats.guildCount > 1 ? 's' : ''}, and ${Style.log(String(this.stats.userCount), { color: Style.TextColor.Cyan })} user${this.stats.userCount > 1 ? 's' : ''}!`);
-                }
-            }, 1000);
-        });
-        return this;
-    }
-}

package/dist/functions/deploy.d.ts

@@ -1,3 +0,0 @@
-/** @format */
-import XernerxClient from '../client/XernerxClient.js';
-export default function deploy(client: XernerxClient): void;

package/dist/functions/deploy.js

@@ -1,63 +0,0 @@
-/** @format */
-import { GatewayVersion, REST, Routes } from 'discord.js';
-import { Style } from 'dumfunctions';
-import XernerxLog from '../tools/XernerxLog.js';
-import XernerxError from '../tools/XernerxError.js';
-const globalCommands = [];
-const localCommands = [];
-export default function deploy(client) {
-    const commands = [];
-    function stats() {
-        client.stats.guildCount = client.guilds.cache.size;
-        client.stats.userCount = client.guilds.cache.map((g) => g.memberCount || g.approximateMemberCount || 0).reduce((a, b) => (a += b), 0);
-    }
-    process.on('message', (message) => {
-        if (message.type == 'xernerx')
-            client.stats.shardId = message?.data?.shardId;
-        if (message.type == 'client')
-            client.data = message.data;
-    });
-    client.on('messageCreate', stats);
-    client.on('interactionCreate', stats);
-    client.once('ready', (client) => {
-        stats();
-        client.commands.slash.map((command) => commands.push(command));
-        client.commands.context.map((command) => commands.push(command));
-        client.commands.message.map((command) => commands.push(command));
-        if (client.commands.slash.size)
-            client.commands.slash.map((command) => (command.global ? globalCommands.push(command.data.toJSON()) : localCommands.push(command.data.toJSON())));
-        if (client.commands.context.size)
-            client.commands.context.map((command) => (command.global ? globalCommands.push(command.data.toJSON()) : localCommands.push(command.data.toJSON())));
-        if (!globalCommands.length && !localCommands.length && !client.commands.message.size)
-            return;
-        try {
-            if (client.settings.global) {
-                put(client, client.settings.global, globalCommands);
-                put(client, !client.settings.global, localCommands);
-            }
-            else {
-                put(client, !client.settings.global, [...globalCommands, ...localCommands]);
-                put(client, client.settings.global, []);
-            }
-        }
-        catch (error) {
-            new XernerxLog(client).error(`An error occurred while deploying the commands!`, error);
-        }
-        finally {
-            new XernerxLog(client).info(`Deployed ${Style.log(String(commands.filter((command) => command.global).length), {
-                color: Style.TextColor.Cyan,
-            })} Commands ${client.settings.global
-                ? Style.log('globally', { color: Style.TextColor.Green })
-                : `${Style.log('locally', { color: Style.TextColor.Red })} in ${Style.log(client.guilds.cache.get(client.settings.local)?.name, { color: Style.TextColor.Blue })}`}.`);
-        }
-    });
-}
-function put(client, global, body) {
-    const rest = new REST({ version: GatewayVersion }).setToken(client.token);
-    if (!global && !client.settings?.local)
-        throw new XernerxError(`No guild ID provided as local guild!`);
-    if (!global && client.settings?.local)
-        return rest.put(Routes.applicationGuildCommands(client.user?.id, client.settings.local), { body });
-    else
-        return rest.put(Routes.applicationCommands(client.user?.id), { body });
-}

package/dist/functions/load.d.ts

@@ -1,4 +0,0 @@
-/** @format */
-import XernerxClient from '../client/XernerxClient.js';
-import { filetype } from '../types/types.js';
-export default function load(client: XernerxClient, path: string, type: filetype): Promise<any>;

package/dist/functions/load.js

@@ -1,35 +0,0 @@
-/** @format */
-import XernerxLog from '../tools/XernerxLog.js';
-export default async function load(client, path, type) {
-    try {
-        let file = new (await import(`file://${path}`)).default();
-        file.filetype = type;
-        file.filepath = path;
-        file.client = client;
-        file.util = {};
-        fileSave(client, file, type);
-        return file;
-    }
-    catch (error) {
-        new XernerxLog(client).error(`Couldn't load ${type} ${path.match(/\w*\.js$/gim)?.at(0) || path}`, error);
-    }
-}
-function fileSave(client, file, type) {
-    switch (type) {
-        case 'MessageCommand':
-            client.commands.message.set(file.name, file);
-            break;
-        case 'SlashCommand':
-            client.commands.slash.set(file.name, file);
-            break;
-        case 'ContextCommand':
-            client.commands.context.set(file.name, file);
-            break;
-        case 'Inhibitor':
-            client.inhibitors.set(file.name, file);
-            break;
-        case 'Event':
-            client.events.set(file.name, file);
-            break;
-    }
-}

package/dist/functions/reload.d.ts

@@ -1,3 +0,0 @@
-/** @format */
-import XernerxClient from '../client/XernerxClient.js';
-export default function reload(client: XernerxClient, type: 'commands' | 'context' | 'message' | 'slash' | 'events' | 'inhibitors'): Promise<true | void | null>;

package/dist/functions/reload.js

@@ -1,30 +0,0 @@
-/** @format */
-import * as path from 'path';
-import * as fs from 'fs';
-import load from './load.js';
-export default async function reload(client, type) {
-    switch (type) {
-        case 'message': {
-            client.commands.message.clear();
-            if (!client.modules.options.message)
-                return null;
-            const directory = path.resolve(client.modules.options.message?.directory);
-            for (const file of fs.readdirSync(directory)) {
-                load(client, `${directory}\\${file}`, 'MessageCommand');
-            }
-            return true;
-        }
-        case 'slash': {
-            return client.commands.slash.clear();
-        }
-        case 'context': {
-            return client.commands.context.clear();
-        }
-        case 'events': {
-            return client.events.clear();
-        }
-        case 'inhibitors': {
-            return client.inhibitors.clear();
-        }
-    }
-}

package/dist/functions/setPresence.d.ts

@@ -1,4 +0,0 @@
-/** @format */
-import XernerxClient from '../client/XernerxClient.js';
-import { PresenceOptions } from '../types/interfaces.js';
-export default function setPresence(client: XernerxClient, options: PresenceOptions): import("discord.js").ClientPresence | undefined;

package/dist/functions/setPresence.js

@@ -1,21 +0,0 @@
-/** @format */
-import { ActivityType } from 'discord.js';
-import { Style } from 'dumfunctions';
-export default function setPresence(client, options) {
-    const presence = () => client.user?.setPresence({
-        activities: [
-            {
-                name: options.text,
-                type: ActivityType[Style.titleCase(options.type || 'Custom')],
-                url: options.url,
-            },
-        ],
-        status: options.status,
-    });
-    let response = presence();
-    if (options.interval)
-        setInterval(() => {
-            response = presence();
-        }, options.interval);
-    return response;
-}

package/dist/handlers/CommandHandler.d.ts

@@ -1,16 +0,0 @@
-/** @format */
-import XernerxClient from '../client/XernerxClient.js';
-import { ContextHandlerOptions, MessageHandlerOptions, SlashHandlerOptions } from '../types/interfaces.js';
-import Handler from './Handler.js';
-export default class CommandHandler extends Handler {
-    readonly readyTimestamp: number;
-    constructor(client: XernerxClient);
-    loadMessageCommands(options: MessageHandlerOptions): Promise<void>;
-    loadSlashCommands(options: SlashHandlerOptions): Promise<void>;
-    loadContextCommands(options: ContextHandlerOptions): Promise<void>;
-    private messageCommandRun;
-    private slashCommandRun;
-    private contextCommandRun;
-    private exec;
-    private _checks;
-}