xernerx 3.2.6 → 3.3.1

package/README.md

@@ -11,7 +11,7 @@ Xernerx is a class based discord.js framework. \[BETA\]
 > - Inhibitor handler
 > - Custom utilities
 > - Message command handles
-> - Webhook handler for Top.gg
+> - Extension support
 
 You can checkout the docs [here](https://thedummi.github.io/xernerx/home.html)
 

package/dist/build/ContextCommand.d.ts

@@ -6,7 +6,7 @@ import { XernerxClient } from "../main.js";
  * @param {String} id - The unique ID of the command.
  * @param {ContextCommandOptions} options - The command options.
  */
-export declare class ContextCommand {
+export default class ContextCommandBuilder {
     id: string;
     data: ContextMenuCommandBuilder;
     description?: string;

package/dist/build/ContextCommand.js

@@ -6,7 +6,7 @@ import { XernerxClient } from "../main.js";
  * @param {String} id - The unique ID of the command.
  * @param {ContextCommandOptions} options - The command options.
  */
-export class ContextCommand {
+export default class ContextCommandBuilder {
     id;
     data;
     description;

package/dist/build/ContextCommandBuilder.d.ts

@@ -0,0 +1,40 @@
+import { ChannelType, ContextMenuCommandBuilder, Interaction } from "discord.js";
+import { XernerxClient } from "../main.js";
+import { ContextCommandOptions } from "../types/options.js";
+/**
+ * @description The command builder for context commands.
+ * @param {String} id - The unique ID of the command.
+ * @param {ContextCommandOptions} options - The command options.
+ */
+export default class ContextCommandBuilder {
+    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;
+    };
+    client: XernerxClient | object;
+    constructor(id: string, options: ContextCommandOptions);
+    /**
+     * @param {Interaction} interaction - The Discord interaction event data.
+     * @description make any preconditions here.
+     */
+    conditions(interaction: Interaction): Promise<void>;
+    /**
+     * @param {Interaction} interaction - The Discord interaction event data.
+     * @description Make your custom command here.
+     */
+    exec(interaction: Interaction): Promise<void>;
+}

package/dist/build/ContextCommandBuilder.js

@@ -0,0 +1,84 @@
+import { ContextMenuCommandBuilder, } from "discord.js";
+import { s } from "@sapphire/shapeshift";
+import { XernerxClient } from "../main.js";
+/**
+ * @description The command builder for context commands.
+ * @param {String} id - The unique ID of the command.
+ * @param {ContextCommandOptions} options - The command options.
+ */
+export default class ContextCommandBuilder {
+    id;
+    data;
+    description;
+    info;
+    category;
+    owner;
+    channelType;
+    cooldown;
+    ignoreOwner;
+    channels;
+    guilds;
+    userPermissions;
+    clientPermissions;
+    defer;
+    client;
+    constructor(id, options) {
+        this.id = id;
+        this.data = new ContextMenuCommandBuilder();
+        if (options.name)
+            this.data.setName(options.name);
+        if (options.type)
+            this.data.setType(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;
+        this.client = XernerxClient;
+        this.conditions = this.conditions;
+        this.exec = this.exec;
+    }
+    /**
+     * @param {Interaction} interaction - The Discord interaction event data.
+     * @description make any preconditions here.
+     */
+    async conditions(interaction) { }
+    /**
+     * @param {Interaction} interaction - The Discord interaction event data.
+     * @description Make your custom command here.
+     */
+    async exec(interaction) { }
+}

package/dist/build/Event.d.ts

@@ -1,7 +1,7 @@
 import { EventOptions } from "../interfaces/HandlerInterfaces.js";
 import { XernerxClient } from "../main.js";
 /**
- * @description - The event builder for any events.
+ * @description - The event builder for  events.
  * @param {String} id - The unique ID of the event.
  * @param {EventOptions} options - The event options.
  */

package/dist/build/Event.js

@@ -1,7 +1,7 @@
 import { s } from "@sapphire/shapeshift";
 import { XernerxClient } from "../main.js";
 /**
- * @description - The event builder for any events.
+ * @description - The event builder for  events.
  * @param {String} id - The unique ID of the event.
  * @param {EventOptions} options - The event options.
  */

package/dist/build/EventBuilder.d.ts

@@ -0,0 +1,17 @@
+import { XernerxClient } from "../main.js";
+import { EventOptions } from "../types/options.js";
+/**
+ * @description - The event builder for  events.
+ * @param {String} id - The unique ID of the event.
+ * @param {EventOptions} options - The event options.
+ */
+export default class EventBuilder {
+    id: string;
+    name: string;
+    emitter?: string;
+    type?: string;
+    once?: boolean;
+    client: XernerxClient | object;
+    constructor(id: string, options: EventOptions);
+    run(): Promise<void>;
+}

package/dist/build/EventBuilder.js

@@ -0,0 +1,35 @@
+import { s } from "@sapphire/shapeshift";
+import { XernerxClient } from "../main.js";
+/**
+ * @description - The event builder for  events.
+ * @param {String} id - The unique ID of the event.
+ * @param {EventOptions} options - The event options.
+ */
+export default class EventBuilder {
+    id;
+    name;
+    emitter;
+    type;
+    once;
+    client;
+    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;
+        this.client = XernerxClient;
+        this.run = this.run;
+    }
+    async run() {
+        /**
+         * @description run your custom event here.
+         */
+    }
+}

package/dist/build/ExtensionBuilder.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A class constructor you can use to make any extension work.
+ */
+export default class ExtensionBuilder {
+    name: string;
+    constructor(name: string);
+}

package/dist/build/ExtensionBuilder.js

@@ -0,0 +1,9 @@
+/**
+ * A class constructor you can use to make any extension work.
+ */
+export default class ExtensionBuilder {
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+}

package/dist/build/Inhibitor.d.ts

@@ -11,5 +11,8 @@ export declare class Inhibitor {
     type: string;
     client: XernerxClient | object;
     constructor(id: string, options: InhibitorOptions);
+    /**
+     *
+     */
     check(): Promise<void>;
 }

package/dist/build/Inhibitor.js

@@ -21,5 +21,8 @@ export class Inhibitor {
         this.client = XernerxClient;
         this.check = this.check;
     }
+    /**
+     *
+     */
     async check() { }
 }

package/dist/build/InhibitorBuilder.d.ts

@@ -0,0 +1,19 @@
+import { InhibitorType, XernerxClient } from "../main.js";
+import { InhibitorOptions, MessageArgOptions, SlashArgOptions } from "../types/options.js";
+import { XernerxInteraction, XernerxMessage } from "../types/types.js";
+/**
+ * @description - The inhibitor builder for inhibitors.
+ * @param {String} id - The unique ID of the inhibitor.
+ * @param {InhibitorOptions} options - The inhibitor options.
+ */
+export default class InhibitorBuilder {
+    id: string;
+    name: string;
+    type: InhibitorType;
+    client: XernerxClient | object;
+    constructor(id: string, options: InhibitorOptions);
+    /**
+     *
+     */
+    check(interaction: XernerxInteraction | XernerxMessage, args: SlashArgOptions | MessageArgOptions): Promise<void>;
+}

package/dist/build/InhibitorBuilder.js

@@ -0,0 +1,28 @@
+import { s } from "@sapphire/shapeshift";
+import { XernerxClient } from "../main.js";
+/**
+ * @description - The inhibitor builder for inhibitors.
+ * @param {String} id - The unique ID of the inhibitor.
+ * @param {InhibitorOptions} options - The inhibitor options.
+ */
+export default class InhibitorBuilder {
+    id;
+    name;
+    type;
+    client;
+    constructor(id, options) {
+        this.id = id;
+        s.object({
+            name: s.string,
+            type: s.string,
+        }).parse(options);
+        this.name = options.name;
+        this.type = options.type;
+        this.client = XernerxClient;
+        this.check = this.check;
+    }
+    /**
+     *
+     */
+    async check(interaction, args) { }
+}

package/dist/build/MessageCommand.d.ts

@@ -6,7 +6,7 @@ import { XernerxClient } from "../main.js";
  * @param {String} id - The unique ID of the command.
  * @param {MessageCommandOptions} options - The command options.
  */
-export declare class MessageCommand {
+export default class MessageCommandBuilder {
     id: string;
     name: string;
     aliases?: string[];
@@ -23,7 +23,7 @@ export declare class MessageCommand {
     guilds?: string[];
     userPermissions?: bigint[];
     clientPermissions?: bigint[];
-    args: object;
+    args?: object;
     client: XernerxClient | object;
     constructor(id: string, options: MessageCommandOptions);
     /**

package/dist/build/MessageCommand.js

@@ -5,7 +5,7 @@ import { XernerxClient } from "../main.js";
  * @param {String} id - The unique ID of the command.
  * @param {MessageCommandOptions} options - The command options.
  */
-export class MessageCommand {
+export default class MessageCommandBuilder {
     id;
     name;
     aliases;

package/dist/build/MessageCommandBuilder.d.ts

@@ -0,0 +1,42 @@
+import { Message, ChannelType } from "discord.js";
+import { XernerxClient } from "../main.js";
+import { MessageArgOptions, MessageCommandOptions } from "../types/options.js";
+/**
+ * @description - The command builder for message commands.
+ * @param {String} id - The unique ID of the command.
+ * @param {MessageCommandOptions} options - The command options.
+ */
+export default class MessageCommandBuilder {
+    id: string;
+    name: string;
+    aliases?: string[];
+    description?: string;
+    info?: string;
+    category?: string;
+    prefix?: string | string[];
+    regex?: string;
+    owner?: boolean;
+    channelType?: ChannelType | ChannelType[];
+    separator?: string;
+    cooldown?: number;
+    ignoreOwner?: boolean;
+    channels?: string[];
+    guilds?: string[];
+    userPermissions?: bigint[];
+    clientPermissions?: bigint[];
+    args?: Array<MessageArgOptions>;
+    client: XernerxClient | 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: MessageArgOptions): Promise<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: MessageArgOptions): Promise<void>;
+}

package/dist/build/MessageCommandBuilder.js

@@ -0,0 +1,80 @@
+import { s } from "@sapphire/shapeshift";
+import { XernerxClient } from "../main.js";
+/**
+ * @description - The command builder for message commands.
+ * @param {String} id - The unique ID of the command.
+ * @param {MessageCommandOptions} options - The command options.
+ */
+export default class MessageCommandBuilder {
+    id;
+    name;
+    aliases;
+    description;
+    info;
+    category;
+    prefix;
+    regex;
+    owner;
+    channelType;
+    separator;
+    cooldown;
+    ignoreOwner;
+    channels;
+    guilds;
+    userPermissions;
+    clientPermissions;
+    args;
+    client;
+    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.regex = options.regex;
+        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;
+        this.client = XernerxClient;
+        this.conditions = this.conditions;
+        this.exec = this.exec;
+    }
+    /**
+     * @param {Message} message - The Discord message event data.
+     * @param {object} args - The arguments you created.
+     * @description make any preconditions here.
+     */
+    async conditions(message, args) { }
+    /**
+     * @param {Message} message - The Discord message event data.
+     * @param {object} args - The arguments you created.
+     * @description Make your custom command here.
+     */
+    async exec(message, args) { }
+}

package/dist/build/SlashCommand.d.ts

@@ -1,15 +1,15 @@
 import { SlashCommandOptions } from "../interfaces/CommandInterfaces.js";
-import { ChannelType, Interaction, SlashCommandBuilder } from "discord.js";
+import Discord, { ChannelType, Interaction } from "discord.js";
 import { XernerxClient } from "../main.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 {
+export default class SlashCommandBuilder {
     #private;
     id: string;
-    data: SlashCommandBuilder;
+    data: Discord.SlashCommandBuilder;
     info?: string;
     category?: string;
     owner?: boolean;

package/dist/build/SlashCommand.js

@@ -1,4 +1,4 @@
-import { SlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder, } from "discord.js";
+import Discord, { SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder, } from "discord.js";
 import { s } from "@sapphire/shapeshift";
 import { XernerxClient } from "../main.js";
 import XernerxError from "../tools/XernerxError.js";
@@ -7,7 +7,7 @@ import XernerxError from "../tools/XernerxError.js";
  * @param {String} id - The unique ID of the command.
  * @param {SlashCommandOptions} options - The command options.
  */
-export class SlashCommand {
+export default class SlashCommandBuilder {
     id;
     data;
     info;
@@ -28,7 +28,7 @@ export class SlashCommand {
     client;
     constructor(id, options) {
         this.id = id;
-        this.data = new SlashCommandBuilder()
+        this.data = new Discord.SlashCommandBuilder()
             .setName(options.name)
             .setDescription(options.description);
         if (options.args && options?.args?.length > 0) {

package/dist/build/SlashCommandBuilder.d.ts

@@ -0,0 +1,36 @@
+import Discord, { ChannelType, Interaction } from 'discord.js';
+import { XernerxClient } from '../main.js';
+import { SlashCommandOptions } from '../types/options.js';
+/**
+ * @description - The command builder for slash commands.
+ * @param {String} id - The unique ID of the command.
+ * @param {SlashCommandOptions} options - The command options.
+ */
+export default class SlashCommandBuilder {
+    #private;
+    id: string;
+    data: Discord.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;
+    };
+    client: XernerxClient | object;
+    constructor(id: string, options: SlashCommandOptions);
+    conditions(interaction: Interaction): Promise<void>;
+    exec(interaction: Interaction): Promise<void>;
+}

package/dist/build/SlashCommandBuilder.js

@@ -0,0 +1,110 @@
+import Discord, { SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder } from 'discord.js';
+import { s } from '@sapphire/shapeshift';
+import { XernerxClient } from '../main.js';
+import XernerxError from '../tools/XernerxError.js';
+/**
+ * @description - The command builder for slash commands.
+ * @param {String} id - The unique ID of the command.
+ * @param {SlashCommandOptions} options - The command options.
+ */
+export default class SlashCommandBuilder {
+    id;
+    data;
+    info;
+    category;
+    owner;
+    channelType;
+    separator;
+    cooldown;
+    ignoreOwner;
+    channels;
+    guilds;
+    userPermissions;
+    clientPermissions;
+    args;
+    subcommands;
+    groups;
+    defer;
+    client;
+    constructor(id, options) {
+        this.id = id;
+        this.data = new Discord.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;
+        this.client = XernerxClient;
+        this.conditions = this.conditions;
+        this.exec = this.exec;
+    }
+    async conditions(interaction) { }
+    async exec(interaction) { }
+    #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 XernerxError(`Expected one of ${types.join(', ')}, received ${argument.type} instead.`);
+            let slashArgumentType = `${argument.type.slice(0, 1).toUpperCase()}${argument.type.slice(1).toLowerCase()}`;
+            command[`add${slashArgumentType}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/build/XernerxExtension.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A class constructor you can use to make any extension work.
+ */
+export default class XernerxExtension {
+    name: string;
+    constructor(name: string);
+}