xernerx 3.3.7 → 3.4.0

package/dist/build/XSlashCommandBuilder.js

@@ -0,0 +1,114 @@
+import Discord, { SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder, } from 'discord.js';
+import { s } from '@sapphire/shapeshift';
+import XernerxError from '../tools/XernerxError.js';
+import XernerxClient from '../client/XernerxClient.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.union(s.number, s.array(s.number)).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/client/XernerxClient.d.ts

@@ -24,5 +24,5 @@ export default class XernerxClient extends Client {
     config: object;
     constructor(discordOptions: DiscordOptions, clientOptions: ClientOptions, config?: object);
     register(token: string): void;
-    loadExtensions(options: ExtensionOptions): Promise<void>;
+    loadAllExtensions(options: ExtensionOptions): Promise<void>;
 }

package/dist/client/XernerxClient.js

@@ -70,12 +70,11 @@ export default class XernerxClient extends Client {
                     : ''}`, { color: Style.TextColor.Purple }));
             });
         }
-        this.register = this.register;
     }
     register(token) {
         this.login(token);
     }
-    loadExtensions(options) {
+    loadAllExtensions(options) {
         const extensions = new Extensions(this);
         return extensions.load(options.extensions, options.logging || false);
     }

package/dist/handlers/CommandHandler.d.ts

@@ -1,13 +1,12 @@
-import XernerxClient from "../client/XernerxClient.js";
-import { Handler } from "./Handler.js";
-import { ContextCommandHandlerOptions, MessageCommandHandlerOptions, SlashCommandHandlerOptions } from "../types/options.js";
+import XernerxClient from '../client/XernerxClient.js';
+import { ContextCommandHandlerOptions, MessageCommandHandlerOptions, SlashCommandHandlerOptions } from '../types/options.js';
 /**
  * @description - The command handler.
  * @param {XernerxClient} client - The XernerxClient.
  */
 export default class CommandHandler {
-    client: XernerxClient;
-    handler: Handler;
+    private client;
+    private handler;
     constructor(client: XernerxClient);
     /**
      * @description - The message command loader.

package/dist/handlers/CommandHandler.js

@@ -1,5 +1,5 @@
-import { Handler } from "./Handler.js";
-import { CommandsDeploy, ContextCommandEvents, MessageCommandEvents, SlashCommandEvents, } from "../models/Events.js";
+import { Handler } from './Handler.js';
+import { CommandsDeploy, ContextCommandEvents, MessageCommandEvents, SlashCommandEvents } from '../models/Events.js';
 /**
  * @description - The command handler.
  * @param {XernerxClient} client - The XernerxClient.

package/dist/handlers/EventHandler.d.ts

@@ -1,9 +1,8 @@
-import XernerxClient from "../client/XernerxClient.js";
-import { EventHandlerOptions } from "../types/options.js";
-import { Handler } from "./Handler.js";
+import XernerxClient from '../client/XernerxClient.js';
+import { EventHandlerOptions } from '../types/options.js';
 export default class EventHandler {
-    client: XernerxClient;
-    handler: Handler;
+    private client;
+    private handler;
     constructor(client: XernerxClient);
     /**
      * @description - The event loader

package/dist/handlers/EventHandler.js

@@ -1,4 +1,4 @@
-import { Handler } from "./Handler.js";
+import { Handler } from './Handler.js';
 export default class EventHandler {
     client;
     handler;

package/dist/handlers/Handler.d.ts

@@ -1,14 +1,13 @@
-import XernerxClient from "../client/XernerxClient.js";
-import { ContextCommandHandlerOptions, EventHandlerOptions, InhibitorHandlerOptions, MessageCommandHandlerOptions, SlashCommandHandlerOptions } from "../types/options.js";
+import XernerxClient from '../client/XernerxClient.js';
+import { ContextCommandHandlerOptions, EventHandlerOptions, InhibitorHandlerOptions, MessageCommandHandlerOptions, SlashCommandHandlerOptions } from '../types/options.js';
 /**
  * @description - The Handler class.
  * @param {XernerxClient} client - The XernerxClient.
  */
 export declare class Handler {
-    #private;
-    client: XernerxClient;
-    commands: object[];
-    readyTimestamp: number;
+    private client;
+    private commands;
+    private readyTimestamp;
     constructor(client: XernerxClient);
     /**
      * @description - The loader for the message commands.
@@ -35,4 +34,24 @@ export declare class Handler {
      * @param {InhibitorLoadOptions} options - The options for the inhibitor loader.
      */
     loadAllInhibitors(options: InhibitorHandlerOptions): void;
+    /**
+     * @description - a reader for directories
+     * @param {string} dir - the directory to look for.
+     * @returns array of files.
+     */
+    private readdir;
+    /**
+     * @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
+     */
+    private load;
+    /**
+     * @description the event emitter to emit all events.
+     * @param {object} event - the event to be emitted.
+     * @returns void
+     */
+    private emitter;
 }

package/dist/handlers/Handler.js

@@ -1,7 +1,7 @@
-import fs from "node:fs";
-import * as path from "path";
-import { CommandType } from "../types/enums.js";
-import { s } from "@sapphire/shapeshift";
+import fs from 'node:fs';
+import * as path from 'path';
+import { CommandType } from '../types/enums.js';
+import { s } from '@sapphire/shapeshift';
 import { Style } from 'dumfunctions';
 /**
  * @description - The Handler class.
@@ -35,13 +35,15 @@ export class Handler {
             logging: s.boolean.default(false),
         })
             .parse(options);
-        const files = this.#readdir(options.directory), loaded = [];
+        const files = this.readdir(options.directory), loaded = [];
         for (const file of files) {
-            this.#load(options.directory, file, CommandType.MessageCommand);
-            loaded.push(file.replace(".js", ""));
+            this.load(options.directory, file, CommandType.MessageCommand);
+            loaded.push(file.replace('.js', ''));
         }
         if (this.client.handlerOptions.message?.logging)
-            console.info(Style.log(`Xernerx | Loaded ${loaded.length} message commands: ${loaded.join(", ")}.`, { color: Style.TextColor.Cyan }));
+            console.info(Style.log(`Xernerx | Loaded ${loaded.length} message commands: ${loaded.join(', ')}.`, {
+                color: Style.TextColor.Cyan,
+            }));
     }
     /**
      * @description - The loader for the slash commands.
@@ -64,13 +66,15 @@ export class Handler {
             }).optional,
         })
             .parse(options);
-        const files = this.#readdir(options.directory), loaded = [];
+        const files = this.readdir(options.directory), loaded = [];
         for (const file of files) {
-            this.#load(options.directory, file, CommandType.SlashCommand);
-            loaded.push(file.replace(".js", ""));
+            this.load(options.directory, file, CommandType.SlashCommand);
+            loaded.push(file.replace('.js', ''));
         }
         if (this.client.handlerOptions.slash?.logging)
-            console.info(Style.log(`Xernerx | Loaded ${loaded.length} slash commands: ${loaded.join(", ")}.`, { color: Style.TextColor.Cyan }));
+            console.info(Style.log(`Xernerx | Loaded ${loaded.length} slash commands: ${loaded.join(', ')}.`, {
+                color: Style.TextColor.Cyan,
+            }));
     }
     /**
      * @description - The loader for the context commands.
@@ -93,13 +97,15 @@ export class Handler {
             }).optional,
         })
             .parse(options);
-        const files = this.#readdir(options.directory), loaded = [];
+        const files = this.readdir(options.directory), loaded = [];
         for (const file of files) {
-            this.#load(options.directory, file, CommandType.ContextCommand);
-            loaded.push(file.replace(".js", ""));
+            this.load(options.directory, file, CommandType.ContextCommand);
+            loaded.push(file.replace('.js', ''));
         }
         if (this.client.handlerOptions.context?.logging)
-            console.info(Style.log(`Xernerx | Loaded ${loaded.length} context commands: ${loaded.join(", ")}.`, { color: Style.TextColor.Cyan }));
+            console.info(Style.log(`Xernerx | Loaded ${loaded.length} context commands: ${loaded.join(', ')}.`, {
+                color: Style.TextColor.Cyan,
+            }));
     }
     /**
      * @description - The loader for the events.
@@ -112,25 +118,25 @@ export class Handler {
             logging: s.boolean.default(false),
         })
             .parse(options);
-        const files = this.#readdir(options.directory), loaded = [];
+        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;
+                    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);
+                    this.emitter(event);
                 }
                 catch (error) {
                     console.error(Style.log(`Xernerx | Couldn't load ${file} because <${error}>`, { color: Style.BackgroundColor.Red }));
                 }
-                loaded.push(file.replace(".js", ""));
+                loaded.push(file.replace('.js', ''));
             }
             if (this.client.handlerOptions.events?.logging)
-                console.info(Style.log(`Xernerx | Loaded ${loaded.length} events: ${loaded.join(", ")}.`, { color: Style.TextColor.Cyan }));
+                console.info(Style.log(`Xernerx | Loaded ${loaded.length} events: ${loaded.join(', ')}.`, { color: Style.TextColor.Cyan }));
         })();
     }
     /**
@@ -144,24 +150,24 @@ export class Handler {
             logging: s.boolean.default(false),
         })
             .parse(options);
-        const files = this.#readdir(options.directory), loaded = [];
+        const files = this.readdir(options.directory), loaded = [];
         for (const file of files) {
-            this.#load(options.directory, file, CommandType.Inhibitor);
-            loaded.push(file.replace(".js", ""));
+            this.load(options.directory, file, CommandType.Inhibitor);
+            loaded.push(file.replace('.js', ''));
         }
         if (this.client.handlerOptions.inhibitors?.logging)
-            console.info(Style.log(`Xernerx | Loaded ${loaded.length} inhibitors: ${loaded.join(", ")}.`, { color: Style.TextColor.Cyan }));
+            console.info(Style.log(`Xernerx | Loaded ${loaded.length} inhibitors: ${loaded.join(', ')}.`, {
+                color: Style.TextColor.Cyan,
+            }));
     }
     /**
      * @description - a reader for directories
      * @param {string} dir - the directory to look for.
      * @returns array of files.
      */
-    #readdir(dir) {
+    readdir(dir) {
         try {
-            return fs
-                .readdirSync(path.resolve(dir))
-                .filter((file) => file.endsWith(".js"));
+            return fs.readdirSync(path.resolve(dir)).filter((file) => file.endsWith('.js'));
         }
         catch (error) {
             console.error(Style.log(`Xernerx | Couldn't read ${dir} because <${error}>.`, { color: Style.BackgroundColor.Red }));
@@ -175,11 +181,10 @@ export class Handler {
      * @param {string} type - the type of file.
      * @returns undefined
      */
-    async #load(dir, file, type) {
+    async load(dir, file, type) {
         try {
             dir.split(/\//).shift();
-            let command = (await import("file://" + `${path.resolve(dir)}/${file}`))
-                .default;
+            let command = (await import('file://' + `${path.resolve(dir)}/${file}`)).default;
             command = new command();
             command.client = this.client;
             command.commandType = type;
@@ -209,9 +214,9 @@ export class Handler {
      * @param {object} event - the event to be emitted.
      * @returns void
      */
-    #emitter(event) {
+    emitter(event) {
         const client = this.client;
-        if (event.emitter === "client") {
+        if (event.emitter === 'client') {
             if (event.once)
                 client.once(event.name, (...args) => {
                     event.run(...args);
@@ -221,7 +226,7 @@ export class Handler {
                     event.run(...args);
                 });
         }
-        else if (event.emitter === "rest") {
+        else if (event.emitter === 'rest') {
             if (event.once)
                 client.once(event.name, (...args) => {
                     event.run(...args);
@@ -231,7 +236,7 @@ export class Handler {
                     event.run(...args);
                 });
         }
-        else if (event.emitter === "process") {
+        else if (event.emitter === 'process') {
             if (event.once)
                 process.once(event.name, (...args) => {
                     event.run(...args);

package/dist/handlers/InhibitorHandler.d.ts

@@ -1,13 +1,12 @@
 import XernerxClient from '../client/XernerxClient.js';
 import { InhibitorHandlerOptions } from '../types/options.js';
-import { Handler } from './Handler.js';
 /**
  * @description - Inhibitor loader.
  * @param {XernerxClient} client - The XernerxClient.
  */
 export default class InhibitorHandler {
-    client: XernerxClient;
-    handler: Handler;
+    private client;
+    private handler;
     constructor(client: XernerxClient);
     /**
      * @description - The loader for all inhibitors.

package/dist/main.d.ts

@@ -1,5 +1,6 @@
-import Discord from 'discord.js';
-import DumFunctions from 'dumfunctions';
+export * from 'discord.js';
+export * from 'dumfunctions';
+import ExtensionBuilder from 'xernerx-extension-builder';
 import XernerxClient from './client/XernerxClient.js';
 import EventBuilder from './build/EventBuilder.js';
 import InhibitorBuilder from './build/InhibitorBuilder.js';
@@ -8,75 +9,8 @@ import ContextCommandBuilder from './build/ContextCommandBuilder.js';
 import SlashCommandBuilder from './build/SlashCommandBuilder.js';
 import { CommandType, EventEmitterType, ContextCommandType, InhibitorType } from './types/enums.js';
 import XernerxError from './tools/XernerxError.js';
-import ExtensionBuilder from 'xernerx-extension-builder';
-declare const version: string;
+declare const xernerxVersion: string;
 declare const _default: {
-    Discord: typeof Discord;
-    DumFunctions: {
-        Math: {
-            E: number;
-            LN10: number;
-            LN2: number;
-            LOG10E: number;
-            LOG2E: number;
-            PI: number;
-            SQRT1_2: number;
-            SQRT2: number;
-            abs(number: number): number;
-            acos(number: number): number;
-            acosh(number: number): number;
-            asin(number: number): number;
-            asinh(number: number): number;
-            atan(number: number): number;
-            atan2(x: number, y: number): number;
-            atanh(number: number): number;
-            cbrt(number: number): number;
-            ceil(number: number): number;
-            clz32(number: number): number;
-            cos(number: number): number;
-            cosh(number: number): number;
-            dif(...numbers: number[]): number;
-            exp(number: number): number;
-            expm1(number: number): number;
-            floor(number: number): number;
-            fround(number: number): number;
-            hypot(number: number): number;
-            imul(x: number, y: number): number;
-            log(number: number): number;
-            log10(number: number): number;
-            log1p(number: number): number;
-            log2(number: number): number;
-            max(...numbers: number[]): number;
-            min(...numbers: number[]): number;
-            pow(x: number, y: number): number;
-            random(x?: number | undefined, y?: number | undefined): number;
-            round(number: number): number;
-            shuffle(...numbers: number[]): number | number[];
-            sign(number: number): number;
-            sin(number: number): number;
-            sinh(number: number): number;
-            sum(...numbers: number[]): number;
-            sqrt(number: number): number;
-            tan(number: number): number;
-            tanh(number: number): number;
-            trunc(number: number): number;
-        };
-        Random: {
-            number(min: number, max: number): number;
-            element(array: object | unknown[]): any;
-            "__#1916@#color"(): void;
-        };
-        Style: {
-            TextStyle: typeof import("dumfunctions/dist/models/Style.js").TextStyle;
-            TextColor: typeof import("dumfunctions/dist/models/Style.js").TextColor;
-            BackgroundColor: typeof import("dumfunctions/dist/models/Style.js").BackgroundColor;
-            titleCase(string: string, lowercase?: boolean | undefined): string;
-            pascalCase(string: string, lowercase?: boolean | undefined): string;
-            stringCase(string: string, lowercase?: boolean | undefined): string;
-            phraseCase(string: string, lowercase?: boolean | undefined): string;
-            log(text: string, options: import("dumfunctions/dist/models/Style.js").LogOptions): string;
-        };
-    };
     Client: typeof XernerxClient;
     XernerxClient: typeof XernerxClient;
     CommandType: typeof CommandType;
@@ -93,4 +27,4 @@ declare const _default: {
     version: string;
 };
 export default _default;
-export { Discord, DumFunctions, XernerxClient, CommandType, EventEmitterType, InhibitorType, ContextCommandType, EventBuilder, MessageCommandBuilder, ContextCommandBuilder, SlashCommandBuilder, InhibitorBuilder, ExtensionBuilder, XernerxError, version, };
+export { XernerxClient, CommandType, EventEmitterType, InhibitorType, ContextCommandType, EventBuilder, MessageCommandBuilder, ContextCommandBuilder, SlashCommandBuilder, InhibitorBuilder, ExtensionBuilder, XernerxError, xernerxVersion, };

package/dist/main.js

@@ -1,5 +1,6 @@
-import Discord from 'discord.js';
-import DumFunctions from 'dumfunctions';
+export * from 'discord.js';
+export * from 'dumfunctions';
+import ExtensionBuilder from 'xernerx-extension-builder';
 import XernerxClient from './client/XernerxClient.js';
 import EventBuilder from './build/EventBuilder.js';
 import InhibitorBuilder from './build/InhibitorBuilder.js';
@@ -8,13 +9,9 @@ import ContextCommandBuilder from './build/ContextCommandBuilder.js';
 import SlashCommandBuilder from './build/SlashCommandBuilder.js';
 import { CommandType, EventEmitterType, ContextCommandType, InhibitorType } from './types/enums.js';
 import XernerxError from './tools/XernerxError.js';
-import ExtensionBuilder from 'xernerx-extension-builder';
 import pkg from './tools/package.js';
-const version = pkg.version;
+const xernerxVersion = pkg.version;
 export default {
-    // Imported methods
-    Discord,
-    DumFunctions,
     // Client
     Client: XernerxClient,
     XernerxClient,
@@ -32,11 +29,9 @@ export default {
     ExtensionBuilder,
     XernerxError,
     // Constants
-    version,
+    version: xernerxVersion,
 };
 export { 
-// Imported methods
-Discord, DumFunctions, 
 // Client
 XernerxClient, 
 // Enums
@@ -44,4 +39,4 @@ CommandType, EventEmitterType, InhibitorType, ContextCommandType,
 // Builds
 EventBuilder, MessageCommandBuilder, ContextCommandBuilder, SlashCommandBuilder, InhibitorBuilder, ExtensionBuilder, XernerxError, 
 // Constants
-version, };
+xernerxVersion, };

package/dist/models/CommandArguments.d.ts

@@ -1,7 +1,7 @@
-import { MessageCommandBuilder } from '../main.js';
+import MessageCommandBuilder from '../build/MessageCommandBuilder.js';
 import { XernerxInteraction, XernerxMessage } from '../types/types.js';
 export declare class InteractionArguments {
-    interaction: XernerxInteraction;
+    private interaction;
     constructor(interaction: XernerxInteraction);
     group(): string | undefined;
     subcommand(): string | undefined;

package/dist/models/CommandArguments.js

@@ -81,9 +81,11 @@ export async function messageArguments(message, command) {
                 args[argument.name] = role;
             }
             else if (argument.type == 'member') {
-                let member = message.guild?.members.cache.find((m) => m?.nickname?.toLowerCase()?.includes(content[0]) || m?.user?.username?.toLowerCase()?.includes(content[0])) || null;
+                let member = message.guild?.members.cache.find((m) => m?.nickname?.toLowerCase()?.includes(content[0]) ||
+                    m?.user?.username?.toLowerCase()?.includes(content[0])) || null;
                 try {
-                    member = (await message.guild?.members.fetch(member?.id || content[0].replace(/<@!?|>/g, ''))) || null;
+                    member =
+                        (await message.guild?.members.fetch(member?.id || content[0].replace(/<@!?|>/g, ''))) || null;
                 }
                 catch (e) {
                     member = null;

package/dist/models/Events.d.ts

@@ -1,24 +1,24 @@
 import XernerxClient from '../client/XernerxClient.js';
 export declare class MessageCommandEvents {
-    client: XernerxClient;
+    private client;
     constructor(client: XernerxClient);
     messageCreate(): void;
     messageUpdate(): void;
     messageDelete(): void;
 }
 export declare class SlashCommandEvents {
-    client: XernerxClient;
+    private client;
     constructor(client: XernerxClient);
     slashCreate(): void;
 }
 export declare class ContextCommandEvents {
-    client: XernerxClient;
+    private client;
     constructor(client: XernerxClient);
     contextCreate(): void;
 }
 export declare class CommandsDeploy {
-    client: XernerxClient;
+    private client;
     constructor(client: XernerxClient);
     deploy(): void;
-    put(type: string, guild: string, body: Array<object>): void;
+    private put;
 }