reciple 6.0.0-dev.7 → 6.0.0-dev.9

package/dist/cjs/bin.js

@@ -36,11 +36,13 @@ if (!client.isClientLogsSilent)
     client.addCommandListeners();
     await client.modules.startModules(await client.modules.getModulesFromFiles({
         files: await client.modules.getModuleFiles(),
-    }), true, true);
+    }));
     client.on('ready', async () => {
-        await client.modules.loadModules(client.modules.modules.toJSON());
+        await client.modules.loadModules(client.modules.modules.toJSON(), true);
+        if (!client.isClientLogsSilent)
+            client.logger.log(`Loaded ${client.commands.slashCommands.size} slash commands`, `Loaded ${client.commands.messageCommands.size} message commands`);
         if (client.config.commands.slashCommand.registerCommands)
-            client.commands.registerApplicationCommands();
+            await client.commands.registerApplicationCommands();
         if (!client.isClientLogsSilent)
             client.logger.warn(`Logged in as ${client.user?.tag || 'Unknown'}!`);
         client.on('cacheSweep', () => client.cooldowns.clean());

package/dist/cjs/index.js

@@ -18,9 +18,9 @@ __exportStar(require("./reciple/classes/builders/MessageCommandBuilder"), export
 __exportStar(require("./reciple/classes/builders/MessageCommandOptionBuilder"), exports);
 __exportStar(require("./reciple/classes/builders/SlashCommandBuilder"), exports);
 __exportStar(require("./reciple/classes/managers/ApplicationCommandManager"), exports);
-__exportStar(require("./reciple/classes/managers/CommandCooldownManager"), exports);
 __exportStar(require("./reciple/classes/managers/ClientCommandManager"), exports);
 __exportStar(require("./reciple/classes/managers/ClientModuleManager"), exports);
+__exportStar(require("./reciple/classes/managers/CommandCooldownManager"), exports);
 __exportStar(require("./reciple/classes/managers/MessageCommandOptionManager"), exports);
 __exportStar(require("./reciple/classes/RecipleClient"), exports);
 __exportStar(require("./reciple/classes/RecipleConfig"), exports);

package/dist/cjs/reciple/classes/RecipleClient.js

@@ -12,9 +12,9 @@ const CommandCooldownManager_1 = require("./managers/CommandCooldownManager");
 const permissions_1 = require("../permissions");
 const MessageCommandOptionManager_1 = require("./managers/MessageCommandOptionManager");
 const ApplicationCommandManager_1 = require("./managers/ApplicationCommandManager");
-const builders_1 = require("../types/builders");
 const ClientCommandManager_1 = require("./managers/ClientCommandManager");
 const ClientModuleManager_1 = require("./managers/ClientModuleManager");
+const builders_1 = require("../types/builders");
 const RecipleConfig_1 = require("./RecipleConfig");
 const fallout_utility_1 = require("fallout-utility");
 const util_1 = require("../util");
@@ -68,7 +68,7 @@ class RecipleClient extends discord_js_1.Client {
             return;
         if (!this.config.commands.slashCommand.acceptRepliedInteractions && (interaction.replied || interaction.deferred))
             return;
-        const command = this.commands.get(interaction.commandName, builders_1.CommandBuilderType.SlashCommand);
+        const command = this.commands.get(interaction.commandName, builders_1.CommandType.SlashCommand);
         if (!command)
             return;
         const executeData = {
@@ -97,7 +97,7 @@ class RecipleClient extends discord_js_1.Client {
                 command: command.name,
                 channel: interaction.channel ?? undefined,
                 guild: interaction.guild,
-                type: builders_1.CommandBuilderType.SlashCommand,
+                type: builders_1.CommandType.SlashCommand,
             };
             if (this.config.commands.slashCommand.enableCooldown && command.cooldown && !this.cooldowns.isCooledDown(userCooldown)) {
                 this.cooldowns.add({
@@ -135,7 +135,7 @@ class RecipleClient extends discord_js_1.Client {
         const parseCommand = (0, fallout_utility_1.getCommand)(message.content, prefix || this.config.commands.messageCommand.prefix || '!', this.config.commands.messageCommand.commandArgumentSeparator || ' ');
         if (!parseCommand || !parseCommand?.command)
             return;
-        const command = this.commands.get(parseCommand.command, builders_1.CommandBuilderType.MessageCommand);
+        const command = this.commands.get(parseCommand.command, builders_1.CommandType.MessageCommand);
         if (!command)
             return;
         const commandOptions = await (0, MessageCommandBuilder_1.validateMessageCommandOptions)(command, parseCommand);
@@ -189,7 +189,7 @@ class RecipleClient extends discord_js_1.Client {
                 command: command.name,
                 channel: message.channel,
                 guild: message.guild,
-                type: builders_1.CommandBuilderType.MessageCommand,
+                type: builders_1.CommandType.MessageCommand,
             };
             if (this.config.commands.messageCommand.enableCooldown && command.cooldown && !this.cooldowns.isCooledDown(userCooldown)) {
                 this.cooldowns.add({
@@ -234,7 +234,7 @@ class RecipleClient extends discord_js_1.Client {
     async _haltCommand(command, haltData) {
         try {
             const haltResolved = (command.halt
-                ? await Promise.resolve(command.type == builders_1.CommandBuilderType.SlashCommand ? command.halt(haltData) : command.halt(haltData)).catch(err => {
+                ? await Promise.resolve(command.type == builders_1.CommandType.SlashCommand ? command.halt(haltData) : command.halt(haltData)).catch(err => {
                     console.log(err);
                 })
                 : false) || false;
@@ -251,7 +251,7 @@ class RecipleClient extends discord_js_1.Client {
     }
     async _executeCommand(command, executeData) {
         try {
-            await Promise.resolve(command.type === builders_1.CommandBuilderType.SlashCommand ? command.execute(executeData) : command.execute(executeData))
+            await Promise.resolve(command.type === builders_1.CommandType.SlashCommand ? command.execute(executeData) : command.execute(executeData))
                 .then(() => this.emit('recipleCommandExecute', executeData))
                 .catch(async (err) => !(await this._haltCommand(command, {
                 executeData: executeData,
@@ -279,7 +279,7 @@ class RecipleClient extends discord_js_1.Client {
      */
     async _commandExecuteError(err, command) {
         if (!this.isClientLogsSilent) {
-            this.logger.error(`An error occured executing ${command.builder.type == builders_1.CommandBuilderType.MessageCommand ? 'message' : 'slash'} command "${command.builder.name}"`);
+            this.logger.error(`An error occured executing ${command.builder.type == builders_1.CommandType.MessageCommand ? 'message' : 'slash'} command "${command.builder.name}"`);
             this.logger.error(err);
         }
         if (!err || !command)

package/dist/cjs/reciple/classes/RecipleModule.js

@@ -19,29 +19,29 @@ class RecipleModule {
     get displayName() {
         return this.filePath ?? this.id;
     }
-    async start(resolveCommands = true) {
-        if (resolveCommands)
-            this.resolveCommands();
+    async start() {
         return Promise.resolve(this.script.onStart(this.client));
     }
-    async load() {
+    async load(resolveCommands = true) {
         if (typeof this.script.onLoad === 'function')
-            this.script.onLoad(this.client);
+            await this.script.onLoad(this.client);
+        if (resolveCommands)
+            this.resolveCommands();
     }
     async unLoad(reason) {
         if (typeof this.script.onUnLoad === 'function')
-            this.script.onUnLoad(reason, this.client);
+            await this.script.onUnLoad(reason, this.client);
     }
     async registerSlashCommands(...guilds) {
         for (const command of this.commands.toJSON()) {
-            if (command.type !== builders_1.CommandBuilderType.SlashCommand)
+            if (command.type !== builders_1.CommandType.SlashCommand)
                 continue;
             await this.client.applicationCommands.add(command, (0, discord_js_1.normalizeArray)(guilds));
         }
     }
     async unregisterSlashCommands(...guilds) {
         for (const builder of this.commands.toJSON()) {
-            if (builder.type !== builders_1.CommandBuilderType.SlashCommand)
+            if (builder.type !== builders_1.CommandType.SlashCommand)
                 continue;
             if ((0, discord_js_1.normalizeArray)(guilds).length) {
                 for (const guild of (0, discord_js_1.normalizeArray)(guilds)) {
@@ -58,7 +58,7 @@ class RecipleModule {
     }
     async updateSlashCommands(...guilds) {
         for (const builder of this.commands.toJSON()) {
-            if (builder.type !== builders_1.CommandBuilderType.SlashCommand)
+            if (builder.type !== builders_1.CommandType.SlashCommand)
                 continue;
             if ((0, discord_js_1.normalizeArray)(guilds).length) {
                 for (const guild of (0, discord_js_1.normalizeArray)(guilds)) {
@@ -77,9 +77,9 @@ class RecipleModule {
         if (!Array.isArray(this.script?.commands))
             return this.commands;
         for (const command of this.script.commands) {
-            if (command?.type !== builders_1.CommandBuilderType.SlashCommand && command?.type !== builders_1.CommandBuilderType.MessageCommand)
+            if (command?.type !== builders_1.CommandType.SlashCommand && command?.type !== builders_1.CommandType.MessageCommand)
                 continue;
-            const builder = command.type === builders_1.CommandBuilderType.SlashCommand ? SlashCommandBuilder_1.SlashCommandBuilder.resolveSlashCommand(command) : MessageCommandBuilder_1.MessageCommandBuilder.resolveMessageCommand(command);
+            const builder = command.type === builders_1.CommandType.SlashCommand ? SlashCommandBuilder_1.SlashCommandBuilder.resolveSlashCommand(command) : MessageCommandBuilder_1.MessageCommandBuilder.resolveMessageCommand(command);
             if (!(0, util_1.validateCommandBuilder)(builder))
                 throw new Error('Invalid command builder, no name or contains option(s) without name');
             this.commands.set(command.name, builder);

package/dist/cjs/reciple/classes/builders/MessageCommandBuilder.js

@@ -10,7 +10,7 @@ const MessageCommandOptionBuilder_1 = require("./MessageCommandOptionBuilder");
  */
 class MessageCommandBuilder {
     constructor(data) {
-        this.type = builders_1.CommandBuilderType.MessageCommand;
+        this.type = builders_1.CommandType.MessageCommand;
         this.name = '';
         this.description = '';
         this.cooldown = 0;

package/dist/cjs/reciple/classes/builders/SlashCommandBuilder.js

@@ -10,7 +10,7 @@ const discord_js_1 = require("discord.js");
 class SlashCommandBuilder extends discord_js_1.SlashCommandBuilder {
     constructor(data) {
         super();
-        this.type = builders_1.CommandBuilderType.SlashCommand;
+        this.type = builders_1.CommandType.SlashCommand;
         this.cooldown = 0;
         this.requiredBotPermissions = [];
         this.requiredMemberPermissions = [];
@@ -182,10 +182,7 @@ class SlashCommandBuilder extends discord_js_1.SlashCommandBuilder {
             default:
                 throw new TypeError('Unknown option data');
         }
-        if (!(builder instanceof discord_js_1.SlashCommandSubcommandBuilder) &&
-            !(builder instanceof discord_js_1.SlashCommandSubcommandGroupBuilder) &&
-            option.type !== discord_js_1.ApplicationCommandOptionType.Subcommand &&
-            option.type !== discord_js_1.ApplicationCommandOptionType.SubcommandGroup) {
+        if (!(builder instanceof discord_js_1.SlashCommandSubcommandBuilder) && !(builder instanceof discord_js_1.SlashCommandSubcommandGroupBuilder) && option.type !== discord_js_1.ApplicationCommandOptionType.Subcommand && option.type !== discord_js_1.ApplicationCommandOptionType.SubcommandGroup) {
             builder.setRequired(option.required ?? false);
         }
         return builder

package/dist/cjs/reciple/classes/managers/ApplicationCommandManager.js

@@ -109,7 +109,7 @@ class ApplicationCommandManager {
         const commands = guild ? this.client.guilds.resolve(guild)?.commands.cache : this.client.application?.commands.cache;
         if (!commands)
             throw new Error('Guild not found in cache');
-        return commands.find(cmd => typeof command === 'string' ? cmd.id === command || cmd.name === command : cmd.name === command.name || (command instanceof discord_js_1.ApplicationCommand && cmd.id === command.id));
+        return commands.find(cmd => (typeof command === 'string' ? cmd.id === command || cmd.name === command : cmd.name === command.name || (command instanceof discord_js_1.ApplicationCommand && cmd.id === command.id)));
     }
     async fetch(commandId, guild) {
         const manager = guild ? this.client.guilds.resolve(guild)?.commands : this.client.application?.commands;
@@ -122,9 +122,7 @@ class ApplicationCommandManager {
             if (cmd?.toJSON === undefined)
                 return cmd;
             if (SlashCommandBuilder_1.SlashCommandBuilder.isSlashCommandBuilder(cmd) && this.client.config.commands.slashCommand.setRequiredPermissions) {
-                const permissions = setPermissions || this.client.config.commands.slashCommand.permissions.enabled
-                    ? this.client.config.commands.slashCommand.permissions.commands.find(cmd_ => cmd_.command.toLowerCase() === cmd.name.toLowerCase())?.permissions
-                    : undefined;
+                const permissions = setPermissions || this.client.config.commands.slashCommand.permissions.enabled ? this.client.config.commands.slashCommand.permissions.commands.find(cmd_ => cmd_.command.toLowerCase() === cmd.name.toLowerCase())?.permissions : undefined;
                 if (permissions) {
                     cmd.setRequiredMemberPermissions(...permissions);
                     if (!this.client.isClientLogsSilent)

package/dist/cjs/reciple/classes/managers/ClientCommandManager.js

@@ -23,10 +23,10 @@ class ClientCommandManager {
      */
     add(...commands) {
         for (const command of (0, discord_js_1.normalizeArray)(commands)) {
-            if (command.type === builders_1.CommandBuilderType.SlashCommand) {
+            if (command.type === builders_1.CommandType.SlashCommand) {
                 this.slashCommands.set(command.name, SlashCommandBuilder_1.SlashCommandBuilder.resolveSlashCommand(command));
             }
-            else if (command.type === builders_1.CommandBuilderType.MessageCommand) {
+            else if (command.type === builders_1.CommandType.MessageCommand) {
                 this.messageCommands.set(command.name, MessageCommandBuilder_1.MessageCommandBuilder.resolveMessageCommand(command));
             }
             else {
@@ -37,11 +37,10 @@ class ClientCommandManager {
     }
     get(command, type) {
         switch (type) {
-            case builders_1.CommandBuilderType.SlashCommand:
+            case builders_1.CommandType.SlashCommand:
                 return this.slashCommands.get(command);
-            case builders_1.CommandBuilderType.MessageCommand:
-                return (this.messageCommands.get(command.toLowerCase()) ??
-                    (this.client.config.commands.messageCommand.allowCommandAlias ? this.messageCommands.find(c => c.aliases.some(a => a == command?.toLowerCase())) : undefined));
+            case builders_1.CommandType.MessageCommand:
+                return this.messageCommands.get(command.toLowerCase()) ?? (this.client.config.commands.messageCommand.allowCommandAlias ? this.messageCommands.find(c => c.aliases.some(a => a == command?.toLowerCase())) : undefined);
             default:
                 throw new TypeError('Unknown command type');
         }

package/dist/cjs/reciple/classes/managers/ClientModuleManager.js

@@ -40,13 +40,13 @@ class ClientModuleManager {
         this.client = options.client;
         options.modules?.forEach(m => (m instanceof RecipleModule_1.RecipleModule ? m : new RecipleModule_1.RecipleModule({ client: this.client, script: m })));
     }
-    async startModules(modules, addModuleCommandsToClient = true, ignoreErrors = true) {
+    async startModules(modules, ignoreErrors = true) {
         for (const module_ of modules) {
             if (!this.client.isClientLogsSilent)
                 this.client.logger.log(`Starting module '${module_}'`);
             try {
                 let error;
-                const start = await module_.start(true).catch(err => {
+                const start = await module_.start().catch(err => {
                     error = err;
                     return false;
                 });
@@ -58,9 +58,6 @@ class ClientModuleManager {
                     continue;
                 }
                 this.modules.set(module_.id, module_);
-                if (addModuleCommandsToClient) {
-                    this.client.commands.add(module_.commands.toJSON());
-                }
             }
             catch (err) {
                 if (!ignoreErrors)
@@ -71,7 +68,7 @@ class ClientModuleManager {
         }
         return modules;
     }
-    async loadModules(modules, ignoreErrors = true) {
+    async loadModules(modules, addModuleCommandsToClient = true, ignoreErrors = true) {
         for (const module_ of this.modules.toJSON()) {
             try {
                 await module_.load().catch(err => {
@@ -79,6 +76,9 @@ class ClientModuleManager {
                 });
                 if (!this.client.isClientLogsSilent)
                     this.client.logger.log(`Loaded module '${module_}'`);
+                if (addModuleCommandsToClient) {
+                    this.client.commands.add(module_.commands.toJSON());
+                }
             }
             catch (err) {
                 if (!ignoreErrors)

package/dist/cjs/reciple/types/builders.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommandBuilderType = void 0;
+exports.CommandType = void 0;
 /**
  * Types of command builders
  */
-var CommandBuilderType;
-(function (CommandBuilderType) {
-    CommandBuilderType[CommandBuilderType["MessageCommand"] = 0] = "MessageCommand";
-    CommandBuilderType[CommandBuilderType["SlashCommand"] = 1] = "SlashCommand";
-})(CommandBuilderType = exports.CommandBuilderType || (exports.CommandBuilderType = {}));
+var CommandType;
+(function (CommandType) {
+    CommandType[CommandType["MessageCommand"] = 0] = "MessageCommand";
+    CommandType[CommandType["SlashCommand"] = 1] = "SlashCommand";
+})(CommandType = exports.CommandType || (exports.CommandType = {}));

package/dist/cjs/reciple/util.js

@@ -31,7 +31,7 @@ exports.deprecationWarning = deprecationWarning;
 function validateCommandBuilder(command) {
     if (!command.name)
         return false;
-    if (command.type === builders_1.CommandBuilderType.MessageCommand && command.options.length && command.options.some(o => !o.name))
+    if (command.type === builders_1.CommandType.MessageCommand && command.options.length && command.options.some(o => !o.name))
         return false;
     return true;
 }

package/dist/types/index.d.ts

@@ -2,9 +2,9 @@ export * from './reciple/classes/builders/MessageCommandBuilder';
 export * from './reciple/classes/builders/MessageCommandOptionBuilder';
 export * from './reciple/classes/builders/SlashCommandBuilder';
 export * from './reciple/classes/managers/ApplicationCommandManager';
-export * from './reciple/classes/managers/CommandCooldownManager';
 export * from './reciple/classes/managers/ClientCommandManager';
 export * from './reciple/classes/managers/ClientModuleManager';
+export * from './reciple/classes/managers/CommandCooldownManager';
 export * from './reciple/classes/managers/MessageCommandOptionManager';
 export * from './reciple/classes/RecipleClient';
 export * from './reciple/classes/RecipleConfig';

package/dist/types/reciple/classes/RecipleModule.d.ts

@@ -45,8 +45,8 @@ export declare class RecipleModule<M = unknown> {
     metadata?: M;
     get displayName(): string;
     constructor(options: RecipleModuleOptions<M>);
-    start(resolveCommands?: boolean): Promise<boolean>;
-    load(): Promise<void>;
+    start(): Promise<boolean>;
+    load(resolveCommands?: boolean): Promise<void>;
     unLoad(reason?: any): Promise<void>;
     registerSlashCommands(...guilds: RestOrArray<GuildResolvable>): Promise<void>;
     unregisterSlashCommands(...guilds: RestOrArray<GuildResolvable>): Promise<void>;

package/dist/types/reciple/classes/builders/MessageCommandBuilder.d.ts

@@ -1,4 +1,4 @@
-import { CommandBuilderType, CommandHaltFunction, CommandExecuteFunction, SharedCommandBuilderProperties, MessageCommandData } from '../../types/builders';
+import { CommandType, CommandHaltFunction, CommandExecuteFunction, SharedCommandBuilderProperties, MessageCommandData } from '../../types/builders';
 import { Message, PermissionResolvable, RestOrArray } from 'discord.js';
 import { BaseCommandExecuteData, CommandHaltData } from '../../types/commands';
 import { MessageCommandOptionManager } from '../managers/MessageCommandOptionManager';
@@ -53,20 +53,20 @@ export interface MessageCommandValidatedOption {
 /**
  * Halt data for message command
  */
-export declare type MessageCommandHaltData<T = unknown> = CommandHaltData<CommandBuilderType.MessageCommand, T>;
+export declare type MessageCommandHaltData<T = unknown> = CommandHaltData<CommandType.MessageCommand, T>;
 /**
  * Message command halt function
  */
-export declare type MessageCommandHaltFunction<T = unknown> = CommandHaltFunction<CommandBuilderType.MessageCommand, T>;
+export declare type MessageCommandHaltFunction<T = unknown> = CommandHaltFunction<CommandType.MessageCommand, T>;
 /**
  * Message command execute function
  */
-export declare type MessageCommandExecuteFunction<T = unknown> = CommandExecuteFunction<CommandBuilderType.MessageCommand, T>;
+export declare type MessageCommandExecuteFunction<T = unknown> = CommandExecuteFunction<CommandType.MessageCommand, T>;
 /**
  * Reciple builder for message command
  */
 export declare class MessageCommandBuilder<T = unknown> implements SharedCommandBuilderProperties<T> {
-    readonly type = CommandBuilderType.MessageCommand;
+    readonly type = CommandType.MessageCommand;
     name: string;
     description: string;
     cooldown: number;

package/dist/types/reciple/classes/builders/SlashCommandBuilder.d.ts

@@ -1,4 +1,4 @@
-import { CommandBuilderType, CommandHaltFunction, CommandExecuteFunction, SharedCommandBuilderProperties, AnySlashCommandBuilder, SlashCommandData, AnySlashCommandOptionData, AnySlashCommandOptionBuilder } from '../../types/builders';
+import { CommandType, CommandHaltFunction, CommandExecuteFunction, SharedCommandBuilderProperties, AnySlashCommandBuilder, SlashCommandData, AnySlashCommandOptionData, AnySlashCommandOptionBuilder } from '../../types/builders';
 import { BaseCommandExecuteData, CommandHaltData } from '../../types/commands';
 import { ChatInputCommandInteraction, PermissionResolvable, RestOrArray, SlashCommandBuilder as DiscordJsSlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder, SlashCommandBooleanOption, SlashCommandUserOption, SlashCommandChannelOption, SlashCommandRoleOption, SlashCommandAttachmentOption, SlashCommandMentionableOption, SlashCommandStringOption, SlashCommandIntegerOption, SlashCommandNumberOption, SharedSlashCommandOptions } from 'discord.js';
 /**
@@ -17,15 +17,15 @@ export interface SlashCommandExecuteData<T = unknown> extends BaseCommandExecute
 /**
  * Slash command halt data
  */
-export declare type SlashCommandHaltData<T = unknown> = CommandHaltData<CommandBuilderType.SlashCommand, T>;
+export declare type SlashCommandHaltData<T = unknown> = CommandHaltData<CommandType.SlashCommand, T>;
 /**
  * Slash command halt function
  */
-export declare type SlashCommandHaltFunction<T = unknown> = CommandHaltFunction<CommandBuilderType.SlashCommand, T>;
+export declare type SlashCommandHaltFunction<T = unknown> = CommandHaltFunction<CommandType.SlashCommand, T>;
 /**
  * Slash command execute function
  */
-export declare type SlashCommandExecuteFunction<T = unknown> = CommandExecuteFunction<CommandBuilderType.SlashCommand, T>;
+export declare type SlashCommandExecuteFunction<T = unknown> = CommandExecuteFunction<CommandType.SlashCommand, T>;
 export declare type SlashCommandSubcommandsOnlyBuilder<T = unknown> = Omit<SlashCommandBuilder<T>, 'addBooleanOption' | 'addUserOption' | 'addChannelOption' | 'addRoleOption' | 'addAttachmentOption' | 'addMentionableOption' | 'addStringOption' | 'addIntegerOption' | 'addNumberOption'>;
 export declare type SlashCommandOptionsOnlyBuilder<T = unknown> = Omit<SlashCommandBuilder<T>, 'addSubcommand' | 'addSubcommandGroup'>;
 export interface SlashCommandBuilder<T = unknown> extends DiscordJsSlashCommandBuilder {
@@ -45,7 +45,7 @@ export interface SlashCommandBuilder<T = unknown> extends DiscordJsSlashCommandB
  * Reciple builder for slash command
  */
 export declare class SlashCommandBuilder<T = unknown> extends DiscordJsSlashCommandBuilder implements SharedCommandBuilderProperties<T> {
-    readonly type = CommandBuilderType.SlashCommand;
+    readonly type = CommandType.SlashCommand;
     cooldown: number;
     requiredBotPermissions: PermissionResolvable[];
     requiredMemberPermissions: PermissionResolvable[];

package/dist/types/reciple/classes/managers/ClientCommandManager.d.ts

@@ -1,5 +1,5 @@
 import { ApplicationCommandData, Collection, GuildResolvable, RestOrArray } from 'discord.js';
-import { AnyCommandBuilder, AnyCommandData, AnySlashCommandBuilder, CommandBuilderType, MessageCommandData, SlashCommandData } from '../../types/builders';
+import { AnyCommandBuilder, AnyCommandData, AnySlashCommandBuilder, CommandType, MessageCommandData, SlashCommandData } from '../../types/builders';
 import { MessageCommandBuilder } from '../builders/MessageCommandBuilder';
 import { SlashCommandBuilder } from '../builders/SlashCommandBuilder';
 import { RecipleClient } from '../RecipleClient';
@@ -27,8 +27,8 @@ export declare class ClientCommandManager {
      * @param type Command type
      */
     get(command: string, type?: undefined): AnyCommandBuilder | undefined;
-    get(command: string, type?: CommandBuilderType.MessageCommand): MessageCommandBuilder | undefined;
-    get(command: string, type?: CommandBuilderType.SlashCommand): SlashCommandBuilder | undefined;
+    get(command: string, type?: CommandType.MessageCommand): MessageCommandBuilder | undefined;
+    get(command: string, type?: CommandType.SlashCommand): SlashCommandBuilder | undefined;
     /**
      * Register application commands
      * @param guilds Register application commands to guilds

package/dist/types/reciple/classes/managers/ClientModuleManager.d.ts

@@ -10,8 +10,8 @@ export declare class ClientModuleManager {
     readonly client: RecipleClient;
     readonly modules: Collection<string, RecipleModule>;
     constructor(options: ClientModuleManagerOptions);
-    startModules(modules: RecipleModule[], addModuleCommandsToClient?: boolean, ignoreErrors?: boolean): Promise<RecipleModule[]>;
-    loadModules(modules: RecipleModule[], ignoreErrors?: boolean): Promise<RecipleModule[]>;
+    startModules(modules: RecipleModule[], ignoreErrors?: boolean): Promise<RecipleModule[]>;
+    loadModules(modules: RecipleModule[], addModuleCommandsToClient?: boolean, ignoreErrors?: boolean): Promise<RecipleModule[]>;
     unLoadModules(modules: RecipleModule[], removeUnloadedModules?: boolean, ignoreErrors?: boolean): Promise<RecipleModule[]>;
     getModulesFromFiles(options: ClientModuleManagerGetModulesFromFilesOptions): Promise<RecipleModule[]>;
     static validateScript(script: unknown): script is RecipleScript;

package/dist/types/reciple/classes/managers/CommandCooldownManager.d.ts

@@ -1,5 +1,5 @@
 import { Guild, RestOrArray, TextBasedChannel, User } from 'discord.js';
-import { CommandBuilderType } from '../../types/builders';
+import { CommandType } from '../../types/builders';
 /**
  * cooled-down user object interface
  */
@@ -15,7 +15,7 @@ export interface CooledDownUser {
     /**
      * Command type
      */
-    type: CommandBuilderType;
+    type: CommandType;
     /**
      * In guild
      */

package/dist/types/reciple/types/builders.d.ts

@@ -25,11 +25,11 @@ export declare type AnyCommandExecuteFunction<T = unknown> = SlashCommandExecute
 /**
  * Command halt function
  */
-export declare type CommandHaltFunction<T extends CommandBuilderType, M = unknown> = (haltData: T extends CommandBuilderType.SlashCommand ? SlashCommandHaltData<M> : T extends CommandBuilderType.MessageCommand ? MessageCommandHaltData<M> : SlashCommandHaltData<M> | MessageCommandHaltData<M>) => Awaitable<boolean | null | undefined | void>;
+export declare type CommandHaltFunction<T extends CommandType, M = unknown> = (haltData: T extends CommandType.SlashCommand ? SlashCommandHaltData<M> : T extends CommandType.MessageCommand ? MessageCommandHaltData<M> : SlashCommandHaltData<M> | MessageCommandHaltData<M>) => Awaitable<boolean | null | undefined | void>;
 /**
  * Command execute function
  */
-export declare type CommandExecuteFunction<T extends CommandBuilderType, M = unknown> = (executeData: T extends CommandBuilderType.SlashCommand ? SlashCommandExecuteData<M> : T extends CommandBuilderType.MessageCommand ? MessageCommandExecuteData<M> : SlashCommandExecuteData<M> | MessageCommandExecuteData<M>) => Awaitable<void>;
+export declare type CommandExecuteFunction<T extends CommandType, M = unknown> = (executeData: T extends CommandType.SlashCommand ? SlashCommandExecuteData<M> : T extends CommandType.MessageCommand ? MessageCommandExecuteData<M> : SlashCommandExecuteData<M> | MessageCommandExecuteData<M>) => Awaitable<void>;
 /**
  * Message command options resolvable
  */
@@ -53,7 +53,7 @@ export declare type AnySlashCommandOptionsOnlyOptionBuilder = SlashCommandAttach
 /**
  * Types of command builders
  */
-export declare enum CommandBuilderType {
+export declare enum CommandType {
     MessageCommand = 0,
     SlashCommand = 1
 }
@@ -61,7 +61,7 @@ export declare enum CommandBuilderType {
  * Shared command builder methods and properties
  */
 export interface SharedCommandBuilderProperties<T = unknown> {
-    readonly type: CommandBuilderType;
+    readonly type: CommandType;
     cooldown: number;
     requiredBotPermissions: PermissionResolvable[];
     requiredMemberPermissions: PermissionResolvable[];
@@ -111,7 +111,7 @@ export interface SharedCommandDataProperties {
  * Slash command object data interface
  */
 export interface SlashCommandData<T = unknown> extends SharedCommandDataProperties, Partial<Omit<SharedCommandBuilderProperties<T>, 'setCooldown' | 'setRequiredBotPermissions' | 'setRequiredMemberPermissions' | 'setHalt' | 'setExecute' | 'setMetadata' | 'halt' | 'execute'>> {
-    type: CommandBuilderType.SlashCommand;
+    type: CommandType.SlashCommand;
     nameLocalizations?: LocalizationMap;
     descriptionLocalizations?: LocalizationMap;
     options?: (AnySlashCommandOptionData | AnySlashCommandOptionBuilder)[];
@@ -179,7 +179,7 @@ export interface SlashCommandSubCommandGroupData extends SharedCommandDataProper
  * Message command object data interface
  */
 export interface MessageCommandData<T = unknown> extends SharedCommandDataProperties, Partial<Omit<SharedCommandBuilderProperties<T>, 'setCooldown' | 'setRequiredBotPermissions' | 'setRequiredMemberPermissions' | 'setHalt' | 'setExecute' | 'setMetadata' | 'halt' | 'execute'>> {
-    type: CommandBuilderType.MessageCommand;
+    type: CommandType.MessageCommand;
     aliases?: string[];
     validateOptions?: boolean;
     allowExecuteInDM?: boolean;

package/dist/types/reciple/types/commands.d.ts

@@ -3,7 +3,7 @@ import { SlashCommandExecuteData, SlashCommandHaltData } from '../classes/builde
 import { MessageCommandOptionManager } from '../classes/managers/MessageCommandOptionManager';
 import { CooledDownUser } from '../classes/managers/CommandCooldownManager';
 import { RecipleClient } from '../classes/RecipleClient';
-import { CommandBuilderType } from '../types/builders';
+import { CommandType } from '../types/builders';
 /**
  * Any command halt data
  */
@@ -11,7 +11,7 @@ export declare type AnyCommandHaltData<T = unknown> = SlashCommandHaltData<T> |
 /**
  * command halt data
  */
-export declare type CommandHaltData<T extends CommandBuilderType, M = unknown> = CommandErrorData<T, M> | CommandCooldownData<T, M> | (T extends CommandBuilderType.SlashCommand ? never : CommandInvalidArguments<T, M> | CommandMissingArguments<T, M>) | CommandMissingMemberPermissions<T, M> | CommandMissingBotPermissions<T, M>;
+export declare type CommandHaltData<T extends CommandType, M = unknown> = CommandErrorData<T, M> | CommandCooldownData<T, M> | (T extends CommandType.SlashCommand ? never : CommandInvalidArguments<T, M> | CommandMissingArguments<T, M>) | CommandMissingMemberPermissions<T, M> | CommandMissingBotPermissions<T, M>;
 /**
  * Any command execute data
  */
@@ -28,7 +28,7 @@ export interface BaseCommandExecuteData {
 /**
  * Command halt reason base
  */
-export interface BaseCommandHaltData<T extends CommandBuilderType, M = unknown> {
+export interface BaseCommandHaltData<T extends CommandType, M = unknown> {
     /**
      * Halt reason
      */
@@ -36,36 +36,36 @@ export interface BaseCommandHaltData<T extends CommandBuilderType, M = unknown>
     /**
      * Command execute da6a
      */
-    executeData: T extends CommandBuilderType.SlashCommand ? SlashCommandExecuteData<M> : T extends CommandBuilderType.MessageCommand ? MessageCommandExecuteData<M> : AnyCommandExecuteData<M>;
+    executeData: T extends CommandType.SlashCommand ? SlashCommandExecuteData<M> : T extends CommandType.MessageCommand ? MessageCommandExecuteData<M> : AnyCommandExecuteData<M>;
 }
-export interface CommandErrorData<T extends CommandBuilderType, M = unknown> extends BaseCommandHaltData<T, M> {
+export interface CommandErrorData<T extends CommandType, M = unknown> extends BaseCommandHaltData<T, M> {
     reason: CommandHaltReason.Error;
     /**
      * Caught error
      */
     error: any;
 }
-export interface CommandCooldownData<T extends CommandBuilderType, M = unknown> extends BaseCommandHaltData<T, M>, CooledDownUser {
+export interface CommandCooldownData<T extends CommandType, M = unknown> extends BaseCommandHaltData<T, M>, CooledDownUser {
     reason: CommandHaltReason.Cooldown;
 }
-export interface CommandInvalidArguments<T extends CommandBuilderType, M = unknown> extends BaseCommandHaltData<T, M> {
+export interface CommandInvalidArguments<T extends CommandType, M = unknown> extends BaseCommandHaltData<T, M> {
     reason: CommandHaltReason.InvalidArguments;
     /**
      * Arguments that are invalid
      */
     invalidArguments: MessageCommandOptionManager;
 }
-export interface CommandMissingArguments<T extends CommandBuilderType, M = unknown> extends BaseCommandHaltData<T, M> {
+export interface CommandMissingArguments<T extends CommandType, M = unknown> extends BaseCommandHaltData<T, M> {
     reason: CommandHaltReason.MissingArguments;
     /**
      * Arguments that are missing
      */
     missingArguments: MessageCommandOptionManager;
 }
-export interface CommandMissingMemberPermissions<T extends CommandBuilderType, M = unknown> extends BaseCommandHaltData<T, M> {
+export interface CommandMissingMemberPermissions<T extends CommandType, M = unknown> extends BaseCommandHaltData<T, M> {
     reason: CommandHaltReason.MissingMemberPermissions;
 }
-export interface CommandMissingBotPermissions<T extends CommandBuilderType, M = unknown> extends BaseCommandHaltData<T, M> {
+export interface CommandMissingBotPermissions<T extends CommandType, M = unknown> extends BaseCommandHaltData<T, M> {
     reason: CommandHaltReason.MissingBotPermissions;
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reciple",
-  "version": "6.0.0-dev.7",
+  "version": "6.0.0-dev.9",
   "bin": "./dist/cjs/bin.js",
   "license": "GPL-3.0",
   "main": "./dist/cjs/index.js",
@@ -26,14 +26,15 @@
     "url": "https://github.com/FalloutStudios/reciple/issues"
   },
   "scripts": {
-    "format": "yarn prettier --write src",
-    "clean": "yarn exec rimraf dist",
-    "build": "yarn clean && yarn exec tsc",
-    "build:publish": "yarn format && yarn build && yarn docs && yarn npm publish",
-    "build:publish-dev": "yarn format && yarn build && yarn npm publish --tag dev",
-    "test": "yarn build && yarn workspace test start",
-    "docs": "yarn exec docgen --typescript true -c ./docs/index.json -o ./docs/docs.json -i src/index.ts",
-    "watch": "yarn exec tsc --watch --noEmit"
+    "format": "npx prettier --write src",
+    "clean": "npx rimraf dist",
+    "build": "npm run clean && npx tsc",
+    "build:publish": "npm run format && npm run build && npx docs && npm publish",
+    "build:publish-dev": "npm run format && npm run build && npm publish --tag dev",
+    "test": "npm run build && npm run start -w test",
+    "docs": "npx docgen --typescript true -c ./docs/index.json -o ./docs/docs.json -i src/index.ts",
+    "watch": "npx tsc --watch --noEmit",
+    "husky:install": "npx husky install"
   },
   "repository": {
     "type": "git",
@@ -63,6 +64,7 @@
     "@types/node": "^18.11.0",
     "@types/semver": "^7.3.12",
     "discord.js": "^14.6.0",
+    "husky": "^8.0.1",
     "prettier": "2.7.1",
     "rimraf": "^3.0.2",
     "typescript": "^4.8.4"
@@ -72,6 +74,5 @@
   },
   "workspaces": [
     "test"
-  ],
-  "packageManager": "yarn@3.2.2"
-}
+  ]
+}

package/docs/README.md

@@ -1 +0,0 @@
-# [VIEW DOCS](https://reciple.js.org/#/docs)