xernerx 2.7.4 → 3.0.0

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2022 Dummi
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2022 Dummi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/build/ContextCommand.d.ts

@@ -0,0 +1,39 @@
+import { ChannelType, ContextMenuCommandBuilder, Interaction } from "discord.js";
+import { ContextCommandOptions } from "../interfaces/CommandInterfaces.js";
+/**
+ * @description The command builder for context commands.
+ * @param {String} id - The unique ID of the command.
+ * @param {ContextCommandOptions} options - The command options.
+ */
+export declare class ContextCommand {
+    #private;
+    id: string;
+    data: ContextMenuCommandBuilder;
+    description?: string;
+    info?: string;
+    category?: string;
+    owner?: boolean;
+    channelType?: ChannelType;
+    cooldown?: number;
+    ignoreOwner?: boolean;
+    channels?: string[];
+    guilds?: string[];
+    userPermissions?: bigint[];
+    clientPermissions?: bigint[];
+    defer?: {
+        reply?: boolean;
+        ephemeral?: boolean;
+        fetchReply?: boolean;
+    };
+    constructor(id: string, options: ContextCommandOptions);
+    /**
+     * @param {Interaction} interaction - The Discord interaction event data.
+     * @description make any preconditions here.
+     */
+    conditions(interaction: Interaction): void;
+    /**
+     * @param {Interaction} interaction - The Discord interaction event data.
+     * @description Make your custom command here.
+     */
+    exec(interaction: Interaction): void;
+}

package/dist/build/ContextCommand.js

@@ -0,0 +1,86 @@
+import { ContextMenuCommandBuilder, } from "discord.js";
+import { s } from "@sapphire/shapeshift";
+/**
+ * @description The command builder for context commands.
+ * @param {String} id - The unique ID of the command.
+ * @param {ContextCommandOptions} options - The command options.
+ */
+export class ContextCommand {
+    id;
+    data;
+    description;
+    info;
+    category;
+    owner;
+    channelType;
+    cooldown;
+    ignoreOwner;
+    channels;
+    guilds;
+    userPermissions;
+    clientPermissions;
+    defer;
+    constructor(id, options) {
+        this.id = id;
+        this.data = new ContextMenuCommandBuilder();
+        if (options.name)
+            this.data.setName(options.name);
+        if (options.type)
+            this.data.setType(this.#types(options.type));
+        if (options.defaultMemberPermissions)
+            this.data.setDefaultMemberPermissions(options.defaultMemberPermissions);
+        if (options.DMPermission)
+            this.data.setDMPermission(options.DMPermission);
+        if (options.nameLocalization)
+            this.data.setNameLocalization(options.nameLocalization.locale, options.nameLocalization.localizedName);
+        if (options.nameLocalizations)
+            this.data.setNameLocalizations(options.nameLocalizations);
+        s.object({
+            description: s.string.optional,
+            info: s.string.optional,
+            category: s.string.optional,
+            owner: s.boolean.optional,
+            // channelType?: ChannelType,
+            cooldown: s.number.optional,
+            ignoreOwner: s.boolean.optional,
+            channels: s.array(s.string).optional,
+            guilds: s.array(s.string).optional,
+            userPermissions: s.array(s.bigint).optional,
+            clientPermissions: s.array(s.bigint).optional,
+            defer: s.object({
+                reply: s.boolean.optional,
+                ephemeral: s.boolean.optional,
+                fetchReply: s.boolean.optional,
+            }).optional,
+        }).parse(options);
+        this.description = options.description;
+        this.info = options.info;
+        this.category = options.category;
+        this.owner = options.owner;
+        this.channelType = options.channelType;
+        this.cooldown = options.cooldown;
+        this.ignoreOwner = options.ignoreOwner;
+        this.channels = options.channels;
+        this.guilds = options.guilds;
+        this.userPermissions = options.userPermissions;
+        this.clientPermissions = options.clientPermissions;
+        this.defer = options.defer;
+    }
+    /**
+     * @param {Interaction} interaction - The Discord interaction event data.
+     * @description make any preconditions here.
+     */
+    conditions(interaction) { }
+    /**
+     * @param {Interaction} interaction - The Discord interaction event data.
+     * @description Make your custom command here.
+     */
+    exec(interaction) { }
+    #types(type) {
+        if (String(type)?.toLowerCase() === "message")
+            type = 3;
+        if (String(type)?.toLowerCase() === "user")
+            type = 2;
+        return type;
+    }
+}

package/dist/build/Event.d.ts

@@ -0,0 +1,15 @@
+import { EventOptions } from "../interfaces/HandlerInterfaces.js";
+/**
+ * @description - The event builder for any events.
+ * @param {String} id - The unique ID of the event.
+ * @param {EventOptions} options - The event options.
+ */
+export declare class Event {
+    id: string;
+    name: string;
+    emitter?: string;
+    type?: string;
+    once?: boolean;
+    constructor(id: string, options: EventOptions);
+    run(): void;
+}

package/dist/build/Event.js

@@ -0,0 +1,31 @@
+import { s } from "@sapphire/shapeshift";
+/**
+ * @description - The event builder for any events.
+ * @param {String} id - The unique ID of the event.
+ * @param {EventOptions} options - The event options.
+ */
+export class Event {
+    id;
+    name;
+    emitter;
+    type;
+    once;
+    constructor(id, options) {
+        this.id = id;
+        s.object({
+            name: s.string,
+            emitter: s.string.optional,
+            type: s.string.optional,
+            once: s.boolean.optional,
+        }).parse(options);
+        this.name = options.name;
+        this.emitter = options.emitter || "client";
+        this.type = options.type || "discord";
+        this.once = options.once || false;
+    }
+    run() {
+        /**
+         * @description run your custom event here.
+         */
+    }
+}

package/dist/build/Inhibitor.d.ts

@@ -0,0 +1,12 @@
+import { InhibitorOptions } from "../interfaces/HandlerInterfaces.js";
+/**
+ * @description - The inhibitor builder for inhibitors.
+ * @param {String} id - The unique ID of the inhibitor.
+ * @param {InhibitorOptions} options - The inhibitor options.
+ */
+export declare class Inhibitor {
+    id: string;
+    name: string;
+    type: string;
+    constructor(id: string, options: InhibitorOptions);
+}

package/dist/build/Inhibitor.js

@@ -0,0 +1,20 @@
+import { s } from "@sapphire/shapeshift";
+/**
+ * @description - The inhibitor builder for inhibitors.
+ * @param {String} id - The unique ID of the inhibitor.
+ * @param {InhibitorOptions} options - The inhibitor options.
+ */
+export class Inhibitor {
+    id;
+    name;
+    type;
+    constructor(id, options) {
+        this.id = id;
+        s.object({
+            name: s.string,
+            type: s.string,
+        }).parse(options);
+        this.name = options.name;
+        this.type = options.type;
+    }
+}

package/dist/build/MessageCommand.d.ts

@@ -0,0 +1,39 @@
+import { MessageCommandOptions } from "../interfaces/CommandInterfaces.js";
+import { Message, ChannelType } from "discord.js";
+/**
+ * @description - The command builder for message commands.
+ * @param {String} id - The unique ID of the command.
+ * @param {MessageCommandOptions} options - The command options.
+ */
+export declare class MessageCommand {
+    id: string;
+    name: string;
+    aliases?: string[];
+    description?: string;
+    info?: string;
+    category?: string;
+    prefix?: string | string[];
+    owner?: boolean;
+    channelType?: ChannelType | ChannelType[];
+    separator?: string;
+    cooldown?: number;
+    ignoreOwner?: boolean;
+    channels?: string[];
+    guilds?: string[];
+    userPermissions?: bigint[];
+    clientPermissions?: bigint[];
+    args: object;
+    constructor(id: string, options: MessageCommandOptions);
+    /**
+     * @param {Message} message - The Discord message event data.
+     * @param {object} args - The arguments you created.
+     * @description make any preconditions here.
+     */
+    conditions(message: Message, args: object): void;
+    /**
+     * @param {Message} message - The Discord message event data.
+     * @param {object} args - The arguments you created.
+     * @description Make your custom command here.
+     */
+    exec(message: Message, args: object): void;
+}

package/dist/build/MessageCommand.js

@@ -0,0 +1,77 @@
+import { s } from "@sapphire/shapeshift";
+/**
+ * @description - The command builder for message commands.
+ * @param {String} id - The unique ID of the command.
+ * @param {MessageCommandOptions} options - The command options.
+ */
+export class MessageCommand {
+    id;
+    name;
+    aliases;
+    description;
+    info;
+    category;
+    prefix;
+    owner;
+    channelType;
+    separator;
+    cooldown;
+    ignoreOwner;
+    channels;
+    guilds;
+    userPermissions;
+    clientPermissions;
+    args;
+    constructor(id, options) {
+        this.id = id;
+        s.object({
+            name: s.string,
+            aliases: s.union(s.array(s.string).unique, s.string).optional,
+            description: s.string.optional,
+            info: s.string.optional,
+            category: s.string.optional,
+            prefix: s.union(s.array(s.string).unique, s.string).optional,
+            owner: s.boolean.optional,
+            // channelType: s.union(s.enum(ChannelType),s.array(s.enum(ChannelType)).unique).optional,
+            separator: s.string.optional,
+            cooldown: s.number.optional,
+            ignoreOwner: s.boolean.optional,
+            channels: s.array(s.string).unique.optional,
+            guilds: s.array(s.string).unique.optional,
+            userPermissions: s.array(s.bigint).unique.optional,
+            clientPermissions: s.array(s.bigint).unique.optional,
+        }).parse(options);
+        this.name = options.name;
+        this.aliases = options.aliases;
+        this.description = options.description;
+        this.info = options.info;
+        this.category = options.category;
+        this.prefix = options.prefix
+            ? Array.isArray(options.prefix)
+                ? options.prefix
+                : [options.prefix]
+            : [];
+        this.owner = options.owner || false;
+        this.channelType = options.channelType;
+        this.separator = options.separator || " ";
+        this.cooldown = options.cooldown || 0;
+        this.ignoreOwner = options.ignoreOwner || false;
+        this.channels = options.channels || [];
+        this.guilds = options.guilds || [];
+        this.userPermissions = options.userPermissions || [];
+        this.clientPermissions = options.clientPermissions || [];
+        this.args = options.args;
+    }
+    /**
+     * @param {Message} message - The Discord message event data.
+     * @param {object} args - The arguments you created.
+     * @description make any preconditions here.
+     */
+    conditions(message, args) { }
+    /**
+     * @param {Message} message - The Discord message event data.
+     * @param {object} args - The arguments you created.
+     * @description Make your custom command here.
+     */
+    exec(message, args) { }
+}

package/dist/build/SlashCommand.d.ts

@@ -0,0 +1,32 @@
+import { SlashCommandOptions } from "../interfaces/CommandInterfaces.js";
+import { ChannelType, SlashCommandBuilder } from "discord.js";
+/**
+ * @description - The command builder for slash commands.
+ * @param {String} id - The unique ID of the command.
+ * @param {SlashCommandOptions} options - The command options.
+ */
+export declare class SlashCommand {
+    #private;
+    id: string;
+    data: SlashCommandBuilder;
+    info?: string;
+    category?: string;
+    owner?: boolean;
+    channelType?: ChannelType;
+    separator?: string;
+    cooldown?: number;
+    ignoreOwner?: boolean;
+    channels?: string[];
+    guilds?: string[];
+    userPermissions?: bigint[];
+    clientPermissions?: bigint[];
+    args?: object[];
+    subcommands?: object[];
+    groups?: object[];
+    defer?: {
+        reply?: boolean;
+        ephemeral?: boolean;
+        fetchReply?: boolean;
+    };
+    constructor(id: string, options: SlashCommandOptions);
+}

package/dist/build/SlashCommand.js

@@ -0,0 +1,119 @@
+import { SlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder, } from "discord.js";
+import { s } from "@sapphire/shapeshift";
+/**
+ * @description - The command builder for slash commands.
+ * @param {String} id - The unique ID of the command.
+ * @param {SlashCommandOptions} options - The command options.
+ */
+export class SlashCommand {
+    id;
+    data;
+    info;
+    category;
+    owner;
+    channelType;
+    separator;
+    cooldown;
+    ignoreOwner;
+    channels;
+    guilds;
+    userPermissions;
+    clientPermissions;
+    args;
+    subcommands;
+    groups;
+    defer;
+    constructor(id, options) {
+        this.id = id;
+        this.data = new SlashCommandBuilder()
+            .setName(options.name)
+            .setDescription(options.description);
+        if (options.args && options?.args?.length > 0) {
+            this.#addArgs(this.data, options.args);
+        }
+        if (options.subcommands && options?.subcommands?.length > 0) {
+            this.#addSubcommands(this.data, options.subcommands);
+        }
+        if (options.groups && options?.groups?.length > 0) {
+            this.#addSubcommandGroups(options.groups);
+        }
+        s.object({
+            info: s.string.optional,
+            category: s.string.optional,
+            owner: s.boolean.optional,
+            // channelType: s.ChannelType.optional,
+            separator: s.string.optional,
+            cooldown: s.number.optional,
+            ignoreOwner: s.boolean.optional,
+            channels: s.array(s.string).optional,
+            guilds: s.array(s.string).optional,
+            userPermissions: s.array(s.bigint).optional,
+            clientPermissions: s.array(s.bigint).optional,
+            defer: s.object({
+                reply: s.boolean.optional,
+                ephemeral: s.boolean.optional,
+                fetchReply: s.boolean.optional,
+            }).optional,
+        });
+        this.info = options.info;
+        this.category = options.category;
+        this.owner = options.owner;
+        this.channelType = options.channelType;
+        this.separator = options.separator;
+        this.cooldown = options.cooldown;
+        this.ignoreOwner = options.ignoreOwner;
+        this.channels = options.channels;
+        this.guilds = options.guilds;
+        this.userPermissions = options.userPermissions;
+        this.clientPermissions = options.clientPermissions;
+        this.defer = options.defer;
+    }
+    #addArgs(command, args) {
+        const types = [
+            "boolean",
+            "integer",
+            "number",
+            "string",
+            "user",
+            "role",
+            "channel",
+            "mentionable",
+        ];
+        for (const argument of args) {
+            if (!types.includes(argument.type.toLowerCase()))
+                throw new Error(`Expected one of ${types.join(", ")}, received ${argument.type} instead.`);
+            let niceType = `${argument.type
+                .slice(0, 1)
+                .toUpperCase()}${argument.type.slice(1).toLowerCase()}`;
+            command[`add${niceType}Option`]((option) => {
+                option
+                    .setName(argument.name)
+                    .setDescription(argument.description)
+                    .setRequired(argument.required || false);
+                if (argument.choices)
+                    option.setChoices(...argument?.choices);
+                return option;
+            });
+        }
+    }
+    #addSubcommands(method, subcommands) {
+        for (const subcommand of subcommands) {
+            let sub = new SlashCommandSubcommandBuilder()
+                .setName(subcommand.name)
+                .setDescription(subcommand.description);
+            if (subcommand.args?.length > 0)
+                this.#addArgs(sub, subcommand.args);
+            method.addSubcommand(sub);
+        }
+    }
+    #addSubcommandGroups(groups) {
+        for (const group of groups) {
+            let subcommandGroup = new SlashCommandSubcommandGroupBuilder()
+                .setName(group.name)
+                .setDescription(group.description);
+            if (group.subcommands?.length > 0)
+                this.#addSubcommands(subcommandGroup, group.subcommands);
+            this.data.addSubcommandGroup(subcommandGroup);
+        }
+    }
+}

package/dist/client/XernerxClient.d.ts

@@ -0,0 +1,22 @@
+import { Client, Collection } from "discord.js";
+import { ClientUtil } from "../utils/ClientUtil.js";
+import { DiscordOptions, ClientOptions, Commands, Cache, Modules, HandlerOptions } from "../interfaces/ClientInterfaces.js";
+/**
+ * @description - The Client.
+ * @param {DiscordOptions} discordOptions - The options for discord.js.
+ * @param {ClientOptions} clientOptions - The options for the Xernerx Client.
+ * @extends {Client}
+ */
+export default class XernerxClient extends Client {
+    settings: ClientOptions;
+    commands: Commands;
+    cache: Cache;
+    modules: Modules;
+    util: ClientUtil;
+    handlerOptions: HandlerOptions;
+    events: Collection<string, object>;
+    inhibitors: Collection<string, object>;
+    config: object;
+    constructor(discordOptions: DiscordOptions, clientOptions: ClientOptions, config?: object);
+    register(token: string): void;
+}

package/dist/client/XernerxClient.js

@@ -0,0 +1,76 @@
+import { Client, Collection } from "discord.js";
+import { s } from "@sapphire/shapeshift";
+import CommandHandler from "../handlers/CommandHandler.js";
+import EventHandler from "../handlers/EventHandler.js";
+import InhibitorHandler from "../handlers/InhibitorHandler.js";
+import { ClientUtil } from "../utils/ClientUtil.js";
+import { logStyle } from "../models/Functions.js";
+/**
+ * @description - The Client.
+ * @param {DiscordOptions} discordOptions - The options for discord.js.
+ * @param {ClientOptions} clientOptions - The options for the Xernerx Client.
+ * @extends {Client}
+ */
+export default class XernerxClient extends Client {
+    settings;
+    commands;
+    cache;
+    modules;
+    util;
+    handlerOptions;
+    events;
+    inhibitors;
+    config;
+    constructor(discordOptions, clientOptions, config) {
+        super(discordOptions);
+        this.settings = s
+            .object({
+            ownerId: s.union(s.array(s.string).unique, s.string).default([]),
+            clientPermissions: s.array(s.bigint).default([]),
+            userPermissions: s.array(s.bigint).default([]),
+            ignoreOwner: s.boolean.default(false),
+            logging: s.boolean.optional,
+            cooldown: s.object({
+                default: s.number.default(0),
+                cache: s.number.default(0),
+            }).optional,
+        })
+            .parse(clientOptions);
+        this.config = config || {};
+        this.commands = {
+            message: new Collection(),
+            slash: new Collection(),
+            context: new Collection(),
+        };
+        this.events = new Collection();
+        this.inhibitors = new Collection();
+        this.cache = {
+            messages: new Collection(),
+            cooldowns: new Collection(),
+            messageCommands: new Collection(),
+            slashCommands: new Collection(),
+            contextCommands: new Collection(),
+            commands: new Collection(),
+        };
+        this.modules = {
+            commandHandler: new CommandHandler(this),
+            eventHandler: new EventHandler(this),
+            inhibitorHandler: new InhibitorHandler(this),
+        };
+        this.util = new ClientUtil(this);
+        this.handlerOptions = {};
+        if (this.settings.logging) {
+            this.once("ready", async (client) => {
+                const size = (await client.guilds.fetch()).size;
+                console.info(logStyle(`Xernerx | ${client.user.tag} signed in watching ${size} server${size > 1 ? "s" : ""}. ${(this.handlerOptions.slash || this.handlerOptions.context)
+                    ?.guildId
+                    ? `Using ${(await this.guilds.fetch((this.handlerOptions.slash ||
+                        this.handlerOptions.context)?.guildId || "0")).name} as local guild.`
+                    : ""}`, "text", "purple"));
+            });
+        }
+    }
+    register(token) {
+        this.login(token);
+    }
+}

package/dist/handlers/CommandHandler.d.ts

@@ -0,0 +1,27 @@
+import { ContextCommandOptions, SlashCommandOptions, MessageCommandOptions } from "../interfaces/HandlerInterfaces.js";
+import XernerxClient from "../client/XernerxClient.js";
+import { Handler } from "./Handler.js";
+/**
+ * @description - The command handler.
+ * @param {XernerxClient} client - The XernerxClient.
+ */
+export default class CommandHandler {
+    client: XernerxClient;
+    handler: Handler;
+    constructor(client: XernerxClient);
+    /**
+     * @description - The message command loader.
+     * @param {MessageCommandOptions} options - message command loader options.
+     */
+    loadAllMessageCommands(options: MessageCommandOptions): void;
+    /**
+     * @description - The slash command loader.
+     * @param {SlashCommandOptions} options - slash command loader options.
+     */
+    loadAllSlashCommands(options: SlashCommandOptions): void;
+    /**
+     * @description - The context command loader.
+     * @param {ContextCommandOptions} options - context command loader options.
+     */
+    loadAllContextCommands(options: ContextCommandOptions): void;
+}