xernerx 2.7.4 → 3.0.0

package/dist/handlers/CommandHandler.js

@@ -0,0 +1,42 @@
+import { Handler } from "./Handler.js";
+import { CommandsDeploy, ContextCommandEvents, MessageCommandEvents, SlashCommandEvents, } from "../models/Events.js";
+/**
+ * @description - The command handler.
+ * @param {XernerxClient} client - The XernerxClient.
+ */
+export default class CommandHandler {
+    client;
+    handler;
+    constructor(client) {
+        this.client = client;
+        this.handler = new Handler(client);
+        new CommandsDeploy(this.client).deploy();
+    }
+    /**
+     * @description - The message command loader.
+     * @param {MessageCommandOptions} options - message command loader options.
+     */
+    loadAllMessageCommands(options) {
+        this.handler.loadAllMessageCommands(options);
+        const events = new MessageCommandEvents(this.client);
+        events.messageCreate();
+        events.messageUpdate();
+        events.messageDelete();
+    }
+    /**
+     * @description - The slash command loader.
+     * @param {SlashCommandOptions} options - slash command loader options.
+     */
+    loadAllSlashCommands(options) {
+        this.handler.loadAllSlashCommands(options);
+        new SlashCommandEvents(this.client).slashCreate();
+    }
+    /**
+     * @description - The context command loader.
+     * @param {ContextCommandOptions} options - context command loader options.
+     */
+    loadAllContextCommands(options) {
+        this.handler.loadAllContextCommands(options);
+        new ContextCommandEvents(this.client).contextCreate();
+    }
+}

package/dist/handlers/EventHandler.d.ts

@@ -0,0 +1,13 @@
+import { EventLoadOptions } from "../interfaces/HandlerInterfaces.js";
+import XernerxClient from "../client/XernerxClient.js";
+import { Handler } from "./Handler.js";
+export default class EventHandler {
+    client: XernerxClient;
+    handler: Handler;
+    constructor(client: XernerxClient);
+    /**
+     * @description - The event loader
+     * @param {EventLoadOptions} options - message command options
+     */
+    loadAllEvents(options: EventLoadOptions): void;
+}

package/dist/handlers/EventHandler.js

@@ -0,0 +1,16 @@
+import { Handler } from "./Handler.js";
+export default class EventHandler {
+    client;
+    handler;
+    constructor(client) {
+        this.client = client;
+        this.handler = new Handler(client);
+    }
+    /**
+     * @description - The event loader
+     * @param {EventLoadOptions} options - message command options
+     */
+    loadAllEvents(options) {
+        this.handler.loadAllEvents(options);
+    }
+}

package/dist/handlers/Handler.d.ts

@@ -0,0 +1,37 @@
+import XernerxClient from "../client/XernerxClient.js";
+import { ContextCommandOptions, MessageCommandOptions, SlashCommandOptions, EventLoadOptions, InhibitorLoadOptions } from "../interfaces/HandlerInterfaces.js";
+/**
+ * @description - The Handler class.
+ * @param {XernerxClient} client - The XernerxClient.
+ */
+export declare class Handler {
+    #private;
+    client: XernerxClient;
+    commands: object[];
+    constructor(client: XernerxClient);
+    /**
+     * @description - The loader for the message commands.
+     * @param {MessageCommandOptions} options - The options for the message command loader.
+     */
+    loadAllMessageCommands(options: MessageCommandOptions): void;
+    /**
+     * @description - The loader for the slash commands.
+     * @param {SlashCommandOptions} options - The options for the slash command loader.
+     */
+    loadAllSlashCommands(options: SlashCommandOptions): void;
+    /**
+     * @description - The loader for the context commands.
+     * @param {ContextCommandOptions} options - The options for the context command loader.
+     */
+    loadAllContextCommands(options: ContextCommandOptions): void;
+    /**
+     * @description - The loader for the events.
+     * @param {EventLoadOptions} options - The options for the event loader.
+     */
+    loadAllEvents(options: EventLoadOptions): void;
+    /**
+     * @description - The loader for the inhibitors.
+     * @param {InhibitorLoadOptions} options - The options for the inhibitor loader.
+     */
+    loadAllInhibitors(options: InhibitorLoadOptions): void;
+}

package/dist/handlers/Handler.js

@@ -0,0 +1,242 @@
+import fs from "node:fs";
+import * as path from "path";
+import { CommandType } from "../types/Types.js";
+import { s } from "@sapphire/shapeshift";
+import { logStyle } from "../models/Functions.js";
+/**
+ * @description - The Handler class.
+ * @param {XernerxClient} client - The XernerxClient.
+ */
+export class Handler {
+    client;
+    commands;
+    constructor(client) {
+        this.client = client;
+        this.commands = [];
+    }
+    /**
+     * @description - The loader for the message commands.
+     * @param {MessageCommandOptions} options - The options for the message command loader.
+     */
+    loadAllMessageCommands(options) {
+        this.client.handlerOptions.message = s
+            .object({
+            directory: s.string,
+            prefix: s.union(s.string, s.array(s.string)),
+            allowMention: s.boolean.default(false),
+            cooldown: s.number.default(0),
+            userPermissions: s.array(s.bigint).default([]),
+            clientPermissions: s.array(s.bigint).default([]),
+            handleEdits: s.boolean.default(false),
+            handleDeletes: s.boolean.default(false),
+            logging: s.boolean.default(false),
+        })
+            .parse(options);
+        const files = this.#readdir(options.directory), loaded = [];
+        for (const file of files) {
+            this.#load(options.directory, file, CommandType.MessageCommand);
+            loaded.push(file.replace(".js", ""));
+        }
+        if (this.client.handlerOptions.message.logging)
+            console.info(logStyle(`Xernerx | Loaded ${loaded.length} message commands: ${loaded.join(", ")}.`, "text", "cyan"));
+    }
+    /**
+     * @description - The loader for the slash commands.
+     * @param {SlashCommandOptions} options - The options for the slash command loader.
+     */
+    loadAllSlashCommands(options) {
+        this.client.handlerOptions.slash = s
+            .object({
+            directory: s.string,
+            guildId: s.string,
+            global: s.boolean,
+            cooldown: s.number.default(0),
+            userPermissions: s.array(s.bigint).default([]),
+            clientPermissions: s.array(s.bigint).default([]),
+            logging: s.boolean.default(false),
+            defer: s.object({
+                reply: s.boolean.optional,
+                ephemeral: s.boolean.optional,
+                fetchReply: s.boolean.optional,
+            }).optional,
+        })
+            .parse(options);
+        const files = this.#readdir(options.directory), loaded = [];
+        for (const file of files) {
+            this.#load(options.directory, file, CommandType.SlashCommand);
+            loaded.push(file.replace(".js", ""));
+        }
+        if (this.client.handlerOptions.slash.logging)
+            console.info(logStyle(`Xernerx | Loaded ${loaded.length} slash commands: ${loaded.join(", ")}.`, "text", "cyan"));
+    }
+    /**
+     * @description - The loader for the context commands.
+     * @param {ContextCommandOptions} options - The options for the context command loader.
+     */
+    loadAllContextCommands(options) {
+        this.client.handlerOptions.context = s
+            .object({
+            directory: s.string,
+            guildId: s.string,
+            global: s.boolean,
+            cooldown: s.number.default(0),
+            userPermissions: s.array(s.bigint).default([]),
+            clientPermissions: s.array(s.bigint).default([]),
+            logging: s.boolean.default(false),
+            defer: s.object({
+                reply: s.boolean.optional,
+                ephemeral: s.boolean.optional,
+                fetchReply: s.boolean.optional,
+            }).optional,
+        })
+            .parse(options);
+        const files = this.#readdir(options.directory), loaded = [];
+        for (const file of files) {
+            this.#load(options.directory, file, CommandType.ContextCommand);
+            loaded.push(file.replace(".js", ""));
+        }
+        if (this.client.handlerOptions.context.logging)
+            console.info(logStyle(`Xernerx | Loaded ${loaded.length} context commands: ${loaded.join(", ")}.`, "text", "cyan"));
+    }
+    /**
+     * @description - The loader for the events.
+     * @param {EventLoadOptions} options - The options for the event loader.
+     */
+    loadAllEvents(options) {
+        this.client.handlerOptions.events = s
+            .object({
+            directory: s.string,
+            logging: s.boolean.default(false),
+        })
+            .parse(options);
+        const files = this.#readdir(options.directory), loaded = [];
+        (async () => {
+            for (const file of files) {
+                try {
+                    options.directory.split(/\//).shift();
+                    let event = (await import("file://" + `${path.resolve(options.directory)}/${file}`)).default;
+                    event = new event();
+                    event.client = this.client;
+                    event.commandType = CommandType.Event;
+                    this.client.events.set(event.name, event);
+                    this.#emitter(event);
+                }
+                catch (error) {
+                    console.error(logStyle(`Xernerx | Couldn't load ${file} because <${error}>`, "background", "red"));
+                }
+                loaded.push(file.replace(".js", ""));
+            }
+            if (this.client.handlerOptions.events?.logging)
+                console.info(logStyle(`Xernerx | Loaded ${loaded.length} events: ${loaded.join(", ")}.`, "text", "cyan"));
+        })();
+    }
+    /**
+     * @description - The loader for the inhibitors.
+     * @param {InhibitorLoadOptions} options - The options for the inhibitor loader.
+     */
+    loadAllInhibitors(options) {
+        this.client.handlerOptions.inhibitors = s
+            .object({
+            directory: s.string,
+            logging: s.boolean.default(false),
+        })
+            .parse(options);
+        const files = this.#readdir(options.directory), loaded = [];
+        for (const file of files) {
+            this.#load(options.directory, file, CommandType.Inhibitor);
+            loaded.push(file.replace(".js", ""));
+        }
+        if (this.client.handlerOptions.inhibitors?.logging)
+            console.info(logStyle(`Xernerx | Loaded ${loaded.length} inhibitors: ${loaded.join(", ")}.`, "text", "cyan"));
+    }
+    /**
+     * @description - a reader for directories
+     * @param {string} dir - the directory to look for.
+     * @returns array of files.
+     */
+    #readdir(dir) {
+        try {
+            return fs
+                .readdirSync(path.resolve(dir))
+                .filter((file) => file.endsWith(".js"));
+        }
+        catch (error) {
+            console.error(logStyle(`Xernerx | Couldn't read ${dir} because <${error}>.`, "background", "red"));
+        }
+        return [];
+    }
+    /**
+     * @description file loader.
+     * @param {string} dir - the directory.
+     * @param {string} file - the file in the directory.
+     * @param {string} type - the type of file.
+     * @returns undefined
+     */
+    async #load(dir, file, type) {
+        try {
+            dir.split(/\//).shift();
+            let command = (await import("file://" + `${path.resolve(dir)}/${file}`))
+                .default;
+            command = new command();
+            command.client = this.client;
+            command.commandType = type;
+            command.filepath = `${path.resolve(dir)}\\${file}`;
+            command.file = file;
+            if (type === CommandType.MessageCommand)
+                this.client.commands.message.set(command?.name || command?.name, command);
+            if (type === CommandType.SlashCommand) {
+                this.client.commands.slash.set(command?.data?.name || command?.name, command);
+            }
+            if (type === CommandType.ContextCommand) {
+                this.client.commands.context.set(command?.data?.name || command?.name, command);
+            }
+            if (type === CommandType.Event) {
+                this.client.events.set(command.name, command);
+            }
+            if (type === CommandType.Inhibitor) {
+                this.client.inhibitors.set(command.name, command);
+            }
+        }
+        catch (error) {
+            console.error(logStyle(`Xernerx | Couldn't load ${file} because <${error}>.`, "background", "red"));
+        }
+    }
+    /**
+     * @description the event emitter to emit all events.
+     * @param {object} event - the event to be emitted.
+     * @returns void
+     */
+    #emitter(event) {
+        const client = this.client;
+        if (event.emitter === "client") {
+            if (event.once)
+                client.once(event.name, (...args) => {
+                    event.run(...args);
+                });
+            else
+                client.on(event.name, (...args) => {
+                    event.run(...args);
+                });
+        }
+        else if (event.emitter === "rest") {
+            if (event.once)
+                client.once(event.name, (...args) => {
+                    event.run(...args);
+                });
+            else
+                client.on(event.name, (...args) => {
+                    event.run(...args);
+                });
+        }
+        else if (event.emitter === "process") {
+            if (event.once)
+                process.once(event.name, (...args) => {
+                    event.run(...args);
+                });
+            else
+                process.on(event.name, (...args) => {
+                    event.run(...args);
+                });
+        }
+    }
+}

package/dist/handlers/InhibitorHandler.d.ts

@@ -0,0 +1,18 @@
+import { InhibitorLoadOptions } from "../interfaces/HandlerInterfaces.js";
+import XernerxClient from "../client/XernerxClient.js";
+import { Handler } from "./Handler.js";
+/**
+ * @description - Inhibitor loader.
+ * @param {XernerxClient} client - The XernerxClient.
+ */
+export default class InhibitorHandler {
+    client: XernerxClient;
+    handler: Handler;
+    constructor(client: XernerxClient);
+    /**
+     * @description - The loader for all inhibitors.
+     * @param {InhibitorLoadOptions} options - the inhibitor loader options.
+     * @returns undefined
+     */
+    loadAllInhibitors(options: InhibitorLoadOptions): void;
+}

package/dist/handlers/InhibitorHandler.js

@@ -0,0 +1,21 @@
+import { Handler } from "./Handler.js";
+/**
+ * @description - Inhibitor loader.
+ * @param {XernerxClient} client - The XernerxClient.
+ */
+export default class InhibitorHandler {
+    client;
+    handler;
+    constructor(client) {
+        this.client = client;
+        this.handler = new Handler(client);
+    }
+    /**
+     * @description - The loader for all inhibitors.
+     * @param {InhibitorLoadOptions} options - the inhibitor loader options.
+     * @returns undefined
+     */
+    loadAllInhibitors(options) {
+        this.handler.loadAllInhibitors(options);
+    }
+}

package/dist/interfaces/ClientInterfaces.d.ts

@@ -0,0 +1,58 @@
+import { CacheFactory, Collection, MessageMentionOptions, Partials, PresenceData, RESTOptions, SweeperOptions, WebSocketOptions } from "discord.js";
+import CommandHandler from "../handlers/CommandHandler.js";
+import EventHandler from "../handlers/EventHandler.js";
+import InhibitorHandler from "../handlers/InhibitorHandler.js";
+import { ContextCommandOptions, MessageCommandOptions, SlashCommandOptions, EventLoadOptions, InhibitorLoadOptions } from "./HandlerInterfaces.js";
+import { MessageCommand } from "../build/MessageCommand.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[];
+    clientPermissions?: bigint[];
+    userPermissions?: bigint[];
+    ignoreOwner?: boolean;
+    logging?: boolean;
+    cooldown?: {
+        default?: number;
+        cache?: number;
+    };
+}
+export interface HandlerOptions {
+    message?: MessageCommandOptions;
+    slash?: SlashCommandOptions;
+    context?: ContextCommandOptions;
+    events?: EventLoadOptions;
+    inhibitors?: InhibitorLoadOptions;
+}
+export interface Commands {
+    message: Collection<string, MessageCommand>;
+    slash: Collection<string, object>;
+    context: Collection<string, object>;
+}
+export interface Cache {
+    messages: Collection<string, object>;
+    cooldowns: Collection<string, object>;
+    messageCommands: Collection<string, object>;
+    slashCommands: Collection<string, object>;
+    contextCommands: Collection<string, object>;
+    commands: Collection<string, object>;
+}
+export interface Modules {
+    commandHandler: CommandHandler;
+    eventHandler: EventHandler;
+    inhibitorHandler: InhibitorHandler;
+}

package/dist/interfaces/ClientInterfaces.js

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

package/dist/interfaces/CommandInterfaces.d.ts

@@ -0,0 +1,94 @@
+import { ChannelType, ContextMenuCommandType } from "discord.js";
+export interface MessageCommandOptions {
+    name: string;
+    regex?: string;
+    aliases?: string[];
+    description?: string;
+    prefix?: string | string[];
+    info?: string;
+    category?: string;
+    owner?: boolean;
+    channelType?: ChannelType | ChannelType[];
+    separator?: string;
+    cooldown?: number;
+    ignoreOwner?: boolean;
+    channels?: string[];
+    guilds?: string[];
+    userPermissions?: bigint[];
+    clientPermissions?: bigint[];
+    commandType?: string;
+    args: object[];
+}
+export interface ContextCommandOptions {
+    name: string;
+    type: ContextMenuCommandType | number;
+    description?: string;
+    info?: string;
+    category?: string;
+    owner?: boolean;
+    channelType?: ChannelType;
+    separator?: string;
+    cooldown?: number;
+    ignoreOwner?: boolean;
+    channels?: string[];
+    guilds?: string[];
+    userPermissions?: bigint[];
+    clientPermissions?: bigint[];
+    defaultMemberPermissions?: bigint | number | bigint | null | undefined;
+    DMPermission?: undefined | null | boolean;
+    nameLocalization?: {
+        locale: "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";
+        localizedName: null | string;
+    };
+    nameLocalizations?: null | Partial<Record<"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", null | string>>;
+    commandType?: string;
+    defer?: {
+        reply?: boolean;
+        ephemeral?: boolean;
+        fetchReply?: boolean;
+    };
+}
+export interface SlashArg {
+    type: "string" | "number" | "boolean" | "user" | "channel" | "role" | "mentionable" | "integer";
+    name: string;
+    choices: Array<{
+        name: string;
+        value: string;
+    }>;
+    required: boolean;
+    description: string;
+}
+export interface SlashSubcommand {
+    name: string;
+    description: string;
+    args: Array<SlashArg>;
+}
+export interface SlashGroup {
+    name: string;
+    description: string;
+    subcommands: Array<SlashSubcommand>;
+}
+export interface SlashCommandOptions {
+    name: string;
+    description: string;
+    info?: string;
+    category?: string;
+    owner?: boolean;
+    channelType?: ChannelType;
+    separator?: string;
+    cooldown?: number;
+    ignoreOwner?: boolean;
+    channels?: string[];
+    guilds?: string[];
+    userPermissions?: bigint[];
+    clientPermissions?: bigint[];
+    args?: Array<SlashArg>;
+    subcommands?: Array<SlashSubcommand>;
+    groups?: Array<SlashGroup>;
+    commandType?: string;
+    defer?: {
+        reply?: boolean;
+        ephemeral?: boolean;
+        fetchReply?: boolean;
+    };
+}

package/dist/interfaces/CommandInterfaces.js

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

package/dist/interfaces/HandlerInterfaces.d.ts

@@ -0,0 +1,70 @@
+import { Message, User } from "discord.js";
+import { EventEmitterType } from "../types/Types.js";
+import { MessageCommandUtil } from "../utils/CommandUtil.js";
+export interface MessageCommandOptions {
+    directory: string;
+    prefix: string[] | string;
+    allowMention?: boolean;
+    cooldown?: number;
+    userPermissions?: bigint[];
+    clientPermissions?: bigint[];
+    handleEdits?: boolean;
+    handleDeletes?: boolean;
+    util?: boolean;
+    logging?: boolean;
+}
+export interface SlashCommandOptions {
+    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 ContextCommandOptions {
+    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 EventLoadOptions {
+    directory: string;
+    logging?: boolean;
+}
+export interface EventOptions {
+    name: string;
+    emitter?: EventEmitterType;
+    type?: string;
+    once?: boolean;
+}
+export interface InhibitorLoadOptions {
+    directory: string;
+    logging?: boolean;
+}
+export interface InhibitorOptions {
+    name: string;
+    type: string;
+}
+export interface XernerxMessage extends Message {
+    util?: MessageCommandUtil;
+    response?: string;
+}
+export interface XernerxUser extends User {
+    isOwner: boolean;
+}

package/dist/interfaces/HandlerInterfaces.js

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

package/dist/main.d.ts

@@ -0,0 +1,26 @@
+import Discord from "discord.js";
+import XernerxClient from "./client/XernerxClient.js";
+import { Event } from "./build/Event.js";
+import { Inhibitor } from "./build/Inhibitor.js";
+import { MessageCommand } from "./build/MessageCommand.js";
+import { ContextCommand } from "./build/ContextCommand.js";
+import { SlashCommand } from "./build/SlashCommand.js";
+import { CommandType, EventEmitterType } from "./types/Types.js";
+import { InhibitorType } from "./types/InhibitorTypes.js";
+declare const version: string;
+declare const _default: {
+    Discord: typeof Discord;
+    Client: typeof XernerxClient;
+    XernerxClient: typeof XernerxClient;
+    CommandType: typeof CommandType;
+    EventEmitterType: typeof EventEmitterType;
+    InhibitorType: typeof InhibitorType;
+    Event: typeof Event;
+    MessageCommand: typeof MessageCommand;
+    ContextCommand: typeof ContextCommand;
+    SlashCommand: typeof SlashCommand;
+    Inhibitor: typeof Inhibitor;
+    version: string;
+};
+export default _default;
+export { Discord, XernerxClient, CommandType, EventEmitterType, InhibitorType, Event, MessageCommand, ContextCommand, SlashCommand, Inhibitor, version, };