reciple 4.0.0-pre.1 → 4.0.0-pre.2

package/bin/bin.js

@@ -12,7 +12,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _a, _b;
+var _a, _b, _c;
 Object.defineProperty(exports, "__esModule", { value: true });
 const RecipleClient_1 = require("./reciple/classes/RecipleClient");
 const RecipleConfig_1 = require("./reciple/classes/RecipleConfig");
@@ -26,15 +26,15 @@ if (flags_1.flags.version) {
     console.log(`v${version_1.version}`);
     process.exit(0);
 }
-const allowedFiles = ['node_modules', 'reciple.yml', 'package.json', 'package.lock.json', 'modules.yml', '.rmmcache'];
-if ((0, fs_1.readdirSync)('./').filter(f => !f.startsWith('.') && allowedFiles.indexOf(f)).length > 0 && !(0, fs_1.existsSync)('./reciple.yml')) {
-    const ask = (_a = (0, fallout_utility_1.input)('This directory does not contain reciple.yml. Would you like to init axis here? [y/n] ')) !== null && _a !== void 0 ? _a : '';
+const allowedFiles = ['node_modules', 'reciple.yml', 'package.json'];
+if ((0, fs_1.readdirSync)('./').filter(f => !f.startsWith('.') && allowedFiles.indexOf(f)).length > 0 && !(0, fs_1.existsSync)((_a = flags_1.flags.config) !== null && _a !== void 0 ? _a : './reciple.yml')) {
+    const ask = (_b = (0, fallout_utility_1.input)('This directory does not contain reciple.yml. Would you like to init axis here? [y/n] ')) !== null && _b !== void 0 ? _b : '';
     if (ask.toString().toLowerCase() !== 'y')
         process.exit(0);
 }
 let configParser;
 try {
-    configParser = new RecipleConfig_1.RecipleConfig((_b = flags_1.flags.config) !== null && _b !== void 0 ? _b : './reciple.yml').parseConfig();
+    configParser = new RecipleConfig_1.RecipleConfig((_c = flags_1.flags.config) !== null && _c !== void 0 ? _c : './reciple.yml').parseConfig();
 }
 catch (err) {
     console.error(`${chalk_1.default.bold.red('Config Error')}: ${chalk_1.default.white(err.message)}`);
@@ -47,9 +47,9 @@ if (config.fileLogging.clientLogs)
 (() => __awaiter(void 0, void 0, void 0, function* () {
     yield client.startModules();
     client.on('ready', () => __awaiter(void 0, void 0, void 0, function* () {
-        var _c;
+        var _d;
         if (client.isClientLogsEnabled())
-            client.logger.warn(`Logged in as ${((_c = client.user) === null || _c === void 0 ? void 0 : _c.tag) || 'Unknown'}!`);
+            client.logger.warn(`Logged in as ${((_d = client.user) === null || _d === void 0 ? void 0 : _d.tag) || 'Unknown'}!`);
         yield client.loadModules();
         client.addCommandListeners();
     }));

package/bin/index.d.ts

@@ -2,9 +2,9 @@ export * from './reciple/classes/CommandCooldownManager';
 export * from './reciple/classes/MessageCommandOptionManager';
 export * from './reciple/classes/RecipleClient';
 export * from './reciple/classes/RecipleConfig';
-export * from './reciple/classes/builders/SlashCommandBuilder';
 export * from './reciple/classes/builders/MessageCommandBuilder';
 export * from './reciple/classes/builders/MessageCommandOptionBuilder';
+export * from './reciple/classes/builders/SlashCommandBuilder';
 export * from './reciple/types/builders';
 export * from './reciple/types/commands';
 export * from './reciple/types/paramOptions';

package/bin/index.js

@@ -18,9 +18,9 @@ __exportStar(require("./reciple/classes/CommandCooldownManager"), exports);
 __exportStar(require("./reciple/classes/MessageCommandOptionManager"), exports);
 __exportStar(require("./reciple/classes/RecipleClient"), exports);
 __exportStar(require("./reciple/classes/RecipleConfig"), exports);
-__exportStar(require("./reciple/classes/builders/SlashCommandBuilder"), exports);
 __exportStar(require("./reciple/classes/builders/MessageCommandBuilder"), exports);
 __exportStar(require("./reciple/classes/builders/MessageCommandOptionBuilder"), exports);
+__exportStar(require("./reciple/classes/builders/SlashCommandBuilder"), exports);
 __exportStar(require("./reciple/types/builders"), exports);
 __exportStar(require("./reciple/types/commands"), exports);
 __exportStar(require("./reciple/types/paramOptions"), exports);

package/bin/reciple/classes/CommandCooldownManager.d.ts

@@ -1,4 +1,4 @@
-import { RecipleCommandBuilderType } from '../types/builders';
+import { CommandBuilderType } from '../types/builders';
 import { Guild, TextBasedChannel, User } from 'discord.js';
 /**
  * Object interface for cooled-down user
@@ -6,7 +6,7 @@ import { Guild, TextBasedChannel, User } from 'discord.js';
 export interface CooledDownUser {
     user: User;
     command: string;
-    type: RecipleCommandBuilderType;
+    type: CommandBuilderType;
     guild?: Guild | null;
     channel?: TextBasedChannel;
     expireTime: number;

package/bin/reciple/classes/RecipleClient.d.ts

@@ -1,7 +1,7 @@
 import { RecipleModule } from '../modules';
 import { ApplicationCommandBuilder } from '../registerInteractionCommands';
-import { RecipleCommandBuilder, RecipleCommandBuilderType } from '../types/builders';
-import { RecipleAddModuleOptions } from '../types/paramOptions';
+import { CommandBuilder, CommandBuilderType } from '../types/builders';
+import { RecipleClientAddModuleOptions } from '../types/paramOptions';
 import { MessageCommandBuilder, MessageCommandExecuteData } from './builders/MessageCommandBuilder';
 import { SlashCommandBuilder, SlashCommandExecuteData } from './builders/SlashCommandBuilder';
 import { CommandCooldownManager } from './CommandCooldownManager';
@@ -77,12 +77,12 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
      * Add module
      * @param options Module options
      */
-    addModule(options: RecipleAddModuleOptions): Promise<void>;
+    addModule(options: RecipleClientAddModuleOptions): Promise<void>;
     /**
      * Add slash or message command to client
      * @param command Slash/Message command builder
      */
-    addCommand(command: RecipleCommandBuilder): RecipleClient<Ready>;
+    addCommand(command: CommandBuilder): RecipleClient<Ready>;
     /**
      * Listed to command executions
      */
@@ -109,8 +109,8 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
      * @param command Command name
      * @param type Command type
      */
-    findCommand(command: string, type: RecipleCommandBuilderType.MessageCommand): MessageCommandBuilder | undefined;
-    findCommand(command: string, type: RecipleCommandBuilderType.SlashCommand): SlashCommandBuilder | undefined;
+    findCommand(command: string, type: CommandBuilderType.MessageCommand): MessageCommandBuilder | undefined;
+    findCommand(command: string, type: CommandBuilderType.SlashCommand): SlashCommandBuilder | undefined;
     /**
      * Returns true if client logs is enabled
      */

package/bin/reciple/classes/RecipleClient.js

@@ -138,10 +138,10 @@ class RecipleClient extends discord_js_1.Client {
      */
     addCommand(command) {
         var _a;
-        if (command.builder === builders_1.RecipleCommandBuilderType.MessageCommand) {
+        if (command.builder === builders_1.CommandBuilderType.MessageCommand) {
             this.commands.messageCommands[command.name] = command;
         }
-        else if (command.builder === builders_1.RecipleCommandBuilderType.SlashCommand) {
+        else if (command.builder === builders_1.CommandBuilderType.SlashCommand) {
             this.commands.slashCommands[command.name] = command;
         }
         else if (this.isClientLogsEnabled()) {
@@ -172,7 +172,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 === null || parseCommand === void 0 ? void 0 : parseCommand.command))
                 return;
-            const command = this.findCommand(parseCommand.command, builders_1.RecipleCommandBuilderType.MessageCommand);
+            const command = this.findCommand(parseCommand.command, builders_1.CommandBuilderType.MessageCommand);
             if (!command)
                 return;
             const commandOptions = (0, MessageCommandBuilder_1.validateMessageCommandOptions)(command, parseCommand);
@@ -195,20 +195,20 @@ class RecipleClient extends discord_js_1.Client {
                     return;
                 if (command.validateOptions) {
                     if (commandOptions.some(o => o.invalid)) {
-                        if (!(yield this._haltCommand(command, { executeData, reason: commands_1.RecipleHaltedCommandReason.InvalidArguments, invalidArguments: new MessageCommandOptionManager_1.MessageCommandOptionManager(executeData.options.filter(o => o.invalid)) }))) {
+                        if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.InvalidArguments, invalidArguments: new MessageCommandOptionManager_1.MessageCommandOptionManager(executeData.options.filter(o => o.invalid)) }))) {
                             message.reply(this.getMessage('invalidArguments', 'Invalid argument(s) given.')).catch(er => this._replyError(er));
                         }
                         return;
                     }
                     if (commandOptions.some(o => o.missing)) {
-                        if (!(yield this._haltCommand(command, { executeData, reason: commands_1.RecipleHaltedCommandReason.MissingArguments, missingArguments: new MessageCommandOptionManager_1.MessageCommandOptionManager(executeData.options.filter(o => o.missing)) }))) {
+                        if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.MissingArguments, missingArguments: new MessageCommandOptionManager_1.MessageCommandOptionManager(executeData.options.filter(o => o.missing)) }))) {
                             message.reply(this.getMessage('missingArguments', 'Not enough arguments.')).catch(er => this._replyError(er));
                         }
                         return;
                     }
                 }
                 if (message.guild && !(0, permissions_1.botHasExecutePermissions)(message.guild, command.requiredBotPermissions)) {
-                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.RecipleHaltedCommandReason.MissingBotPermissions }))) {
+                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.MissingBotPermissions }))) {
                         message.reply(this.getMessage('insufficientBotPerms', 'Insufficient bot permissions.')).catch(er => this._replyError(er));
                     }
                     return;
@@ -218,13 +218,13 @@ class RecipleClient extends discord_js_1.Client {
                     command: command.name,
                     channel: message.channel,
                     guild: message.guild,
-                    type: builders_1.RecipleCommandBuilderType.MessageCommand
+                    type: builders_1.CommandBuilderType.MessageCommand
                 };
                 if (this.config.commands.messageCommand.enableCooldown && command.cooldown && !this.commandCooldowns.isCooledDown(userCooldown)) {
                     this.commandCooldowns.add(Object.assign(Object.assign({}, userCooldown), { expireTime: Date.now() + command.cooldown }));
                 }
                 else if (this.config.commands.messageCommand.enableCooldown && command.cooldown) {
-                    if (!(yield this._haltCommand(command, Object.assign({ executeData, reason: commands_1.RecipleHaltedCommandReason.Cooldown }, this.commandCooldowns.get(userCooldown))))) {
+                    if (!(yield this._haltCommand(command, Object.assign({ executeData, reason: commands_1.HaltedCommandReason.Cooldown }, this.commandCooldowns.get(userCooldown))))) {
                         yield message.reply(this.getMessage('cooldown', 'You cannot execute this command right now due to the cooldown.')).catch(er => this._replyError(er));
                     }
                     return;
@@ -232,16 +232,16 @@ class RecipleClient extends discord_js_1.Client {
                 try {
                     yield Promise.resolve(command.execute(executeData))
                         .then(() => this.emit('recipleMessageCommandCreate', executeData))
-                        .catch((err) => __awaiter(this, void 0, void 0, function* () { return (yield this._haltCommand(command, { executeData, reason: commands_1.RecipleHaltedCommandReason.Error, error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
+                        .catch((err) => __awaiter(this, void 0, void 0, function* () { return (yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.Error, error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
                     return executeData;
                 }
                 catch (err) {
-                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.RecipleHaltedCommandReason.Error, error: err }))) {
+                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.Error, error: err }))) {
                         this._commandExecuteError(err, executeData);
                     }
                 }
             }
-            else if (!(yield this._haltCommand(command, { executeData, reason: commands_1.RecipleHaltedCommandReason.MissingMemberPermissions }))) {
+            else if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.MissingMemberPermissions }))) {
                 message.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this._replyError(er));
             }
         });
@@ -255,7 +255,7 @@ class RecipleClient extends discord_js_1.Client {
         return __awaiter(this, void 0, void 0, function* () {
             if (!interaction || interaction.type !== discord_js_1.InteractionType.ApplicationCommand || !interaction.isChatInputCommand() || !this.isReady())
                 return;
-            const command = this.findCommand(interaction.commandName, builders_1.RecipleCommandBuilderType.SlashCommand);
+            const command = this.findCommand(interaction.commandName, builders_1.CommandBuilderType.SlashCommand);
             if (!command)
                 return;
             const executeData = {
@@ -271,7 +271,7 @@ class RecipleClient extends discord_js_1.Client {
                 if (!command || (0, permissions_1.isIgnoredChannel)(interaction.channelId, this.config.ignoredChannels))
                     return;
                 if (interaction.guild && !(0, permissions_1.botHasExecutePermissions)(interaction.guild, command.requiredBotPermissions)) {
-                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.RecipleHaltedCommandReason.MissingBotPermissions }))) {
+                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.MissingBotPermissions }))) {
                         yield interaction.reply(this.getMessage('insufficientBotPerms', 'Insufficient bot permissions.')).catch(er => this._replyError(er));
                     }
                     return;
@@ -281,13 +281,13 @@ class RecipleClient extends discord_js_1.Client {
                     command: command.name,
                     channel: (_b = interaction.channel) !== null && _b !== void 0 ? _b : undefined,
                     guild: interaction.guild,
-                    type: builders_1.RecipleCommandBuilderType.SlashCommand
+                    type: builders_1.CommandBuilderType.SlashCommand
                 };
                 if (this.config.commands.slashCommand.enableCooldown && command.cooldown && !this.commandCooldowns.isCooledDown(userCooldown)) {
                     this.commandCooldowns.add(Object.assign(Object.assign({}, userCooldown), { expireTime: Date.now() + command.cooldown }));
                 }
                 else if (this.config.commands.slashCommand.enableCooldown && command.cooldown) {
-                    if (!(yield this._haltCommand(command, Object.assign({ executeData, reason: commands_1.RecipleHaltedCommandReason.Cooldown }, this.commandCooldowns.get(userCooldown))))) {
+                    if (!(yield this._haltCommand(command, Object.assign({ executeData, reason: commands_1.HaltedCommandReason.Cooldown }, this.commandCooldowns.get(userCooldown))))) {
                         yield interaction.reply(this.getMessage('cooldown', 'You cannot execute this command right now due to the cooldown.')).catch(er => this._replyError(er));
                     }
                     return;
@@ -295,16 +295,16 @@ class RecipleClient extends discord_js_1.Client {
                 try {
                     yield Promise.resolve(command.execute(executeData))
                         .then(() => this.emit('recipleInteractionCommandCreate', executeData))
-                        .catch((err) => __awaiter(this, void 0, void 0, function* () { return (yield this._haltCommand(command, { executeData, reason: commands_1.RecipleHaltedCommandReason.Error, error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
+                        .catch((err) => __awaiter(this, void 0, void 0, function* () { return (yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.Error, error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
                     return executeData;
                 }
                 catch (err) {
-                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.RecipleHaltedCommandReason.Error, error: err }))) {
+                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.Error, error: err }))) {
                         this._commandExecuteError(err, executeData);
                     }
                 }
             }
-            else if (!(yield this._haltCommand(command, { executeData, reason: commands_1.RecipleHaltedCommandReason.MissingMemberPermissions }))) {
+            else if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.MissingMemberPermissions }))) {
                 yield interaction.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this._replyError(er));
             }
         });
@@ -321,9 +321,9 @@ class RecipleClient extends discord_js_1.Client {
     findCommand(command, type) {
         var _a;
         switch (type) {
-            case builders_1.RecipleCommandBuilderType.SlashCommand:
+            case builders_1.CommandBuilderType.SlashCommand:
                 return this.commands.slashCommands[command];
-            case builders_1.RecipleCommandBuilderType.MessageCommand:
+            case builders_1.CommandBuilderType.MessageCommand:
                 return (_a = this.commands.messageCommands[command.toLowerCase()]) !== null && _a !== void 0 ? _a : (this.config.commands.messageCommand.allowCommandAlias
                     ? Object.values(this.commands.messageCommands).find(c => c.aliases.some(a => a == (command === null || command === void 0 ? void 0 : command.toLowerCase())))
                     : undefined);
@@ -349,7 +349,7 @@ class RecipleClient extends discord_js_1.Client {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 return (_a = (command.halt
-                    ? yield (command.builder == builders_1.RecipleCommandBuilderType.SlashCommand
+                    ? yield (command.builder == builders_1.CommandBuilderType.SlashCommand
                         ? Promise.resolve(command.halt(haltData))
                         : Promise.resolve(command.halt(haltData))).catch(err => { throw err; })
                     : false)) !== null && _a !== void 0 ? _a : false;
@@ -371,7 +371,7 @@ class RecipleClient extends discord_js_1.Client {
     _commandExecuteError(err, command) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.isClientLogsEnabled()) {
-                this.logger.error(`An error occured executing ${command.builder.builder == builders_1.RecipleCommandBuilderType.MessageCommand ? 'message' : 'slash'} command "${command.builder.name}"`);
+                this.logger.error(`An error occured executing ${command.builder.builder == builders_1.CommandBuilderType.MessageCommand ? 'message' : 'slash'} command "${command.builder.name}"`);
                 this.logger.error(err);
             }
             if (!err || !command)

package/bin/reciple/classes/builders/MessageCommandBuilder.d.ts

@@ -1,5 +1,5 @@
-import { RecipleCommandBuilderType } from '../../types/builders';
-import { RecipleHaltedCommandData } from '../../types/commands';
+import { CommandBuilderType } from '../../types/builders';
+import { HaltedCommandData } from '../../types/commands';
 import { MessageCommandOptionManager } from '../MessageCommandOptionManager';
 import { RecipleClient } from '../RecipleClient';
 import { MessageCommandOptionBuilder } from './MessageCommandOptionBuilder';
@@ -29,7 +29,7 @@ export interface MessageCommandValidatedOption {
  * Reciple builder for message command
  */
 export declare class MessageCommandBuilder {
-    readonly builder = RecipleCommandBuilderType.MessageCommand;
+    readonly builder = CommandBuilderType.MessageCommand;
     name: string;
     cooldown: number;
     description: string;
@@ -40,7 +40,7 @@ export declare class MessageCommandBuilder {
     requiredMemberPermissions: PermissionResolvable[];
     allowExecuteInDM: boolean;
     allowExecuteByBots: boolean;
-    halt?: (haltData: RecipleHaltedCommandData<MessageCommandBuilder>) => Awaitable<boolean | void>;
+    halt?: (haltData: HaltedCommandData<MessageCommandBuilder>) => Awaitable<boolean | void>;
     execute: (executeData: MessageCommandExecuteData) => void;
     /**
      * Sets the command name
@@ -87,7 +87,7 @@ export declare class MessageCommandBuilder {
      * Function when the command is interupted
      * @param halt Function to execute when command is halted
      */
-    setHalt(halt?: (haltData: RecipleHaltedCommandData<MessageCommandBuilder>) => Awaitable<boolean | void>): MessageCommandBuilder;
+    setHalt(halt?: (haltData: HaltedCommandData<MessageCommandBuilder>) => Awaitable<boolean | void>): MessageCommandBuilder;
     /**
      * Function when the command is executed
      * @param execute Function to execute when the command is called

package/bin/reciple/classes/builders/MessageCommandBuilder.js

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

package/bin/reciple/classes/builders/SlashCommandBuilder.d.ts

@@ -1,5 +1,5 @@
-import { RecipleCommandBuilderType } from '../../types/builders';
-import { RecipleHaltedCommandData } from '../../types/commands';
+import { CommandBuilderType } from '../../types/builders';
+import { HaltedCommandData } from '../../types/commands';
 import { RecipleClient } from '../RecipleClient';
 import { Awaitable, ChatInputCommandInteraction, PermissionResolvable, SlashCommandBuilder as DiscordJsSlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder, SlashCommandSubcommandsOnlyBuilder as DiscordJsSlashCommandSubcommandsOnlyBuilder } from 'discord.js';
 /**
@@ -20,12 +20,12 @@ export interface SlashCommandBuilder extends DiscordJsSlashCommandBuilder {
  * Reciple builder for interaction/slash command
  */
 export declare class SlashCommandBuilder extends DiscordJsSlashCommandBuilder {
-    readonly builder = RecipleCommandBuilderType.SlashCommand;
+    readonly builder = CommandBuilderType.SlashCommand;
     cooldown: number;
     requiredBotPermissions: PermissionResolvable[];
     requiredMemberPermissions: PermissionResolvable[];
     allowExecuteInDM: boolean;
-    halt?: (haltData: RecipleHaltedCommandData<SlashCommandBuilder>) => Awaitable<boolean | void>;
+    halt?: (haltData: HaltedCommandData<SlashCommandBuilder>) => Awaitable<boolean | void>;
     execute: (executeData: SlashCommandExecuteData) => Awaitable<void>;
     /**
      * Sets the execute cooldown for this command.
@@ -47,7 +47,7 @@ export declare class SlashCommandBuilder extends DiscordJsSlashCommandBuilder {
      * Function when the command is interupted
      * @param halt Function to execute when command is halted
      */
-    setHalt(halt?: (haltData: RecipleHaltedCommandData<SlashCommandBuilder>) => Awaitable<boolean | void>): SlashCommandBuilder;
+    setHalt(halt?: (haltData: HaltedCommandData<SlashCommandBuilder>) => Awaitable<boolean | void>): SlashCommandBuilder;
     /**
      * Function when the command is executed
      * @param execute Function to execute when the command is called

package/bin/reciple/classes/builders/SlashCommandBuilder.js

@@ -9,7 +9,7 @@ const discord_js_1 = require("discord.js");
 class SlashCommandBuilder extends discord_js_1.SlashCommandBuilder {
     constructor() {
         super(...arguments);
-        this.builder = builders_1.RecipleCommandBuilderType.SlashCommand;
+        this.builder = builders_1.CommandBuilderType.SlashCommand;
         this.cooldown = 0;
         this.requiredBotPermissions = [];
         this.requiredMemberPermissions = [];

package/bin/reciple/logger.d.ts

@@ -6,11 +6,3 @@ import { Logger } from 'fallout-utility';
  * @param colorizeMessage add logger colours to messages
  */
 export declare function createLogger(stringifyJSON: boolean, debugmode?: boolean, colorizeMessage?: boolean): Logger;
-/**
- * Create new logger
- * @deprecated Use `createLogger` instead
- * @param stringifyJSON stringify json objects in console
- * @param debugmode display debug messages
- * @param colorizeMessage add logger colours to messages
- */
-export declare function logger(stringifyJSON: boolean, debugmode?: boolean, colorizeMessage?: boolean): Logger;

package/bin/reciple/logger.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.logger = exports.createLogger = void 0;
+exports.createLogger = void 0;
 const flags_1 = require("./flags");
 const chalk_1 = __importDefault(require("chalk"));
 const fallout_utility_1 = require("fallout-utility");
@@ -34,16 +34,3 @@ function createLogger(stringifyJSON, debugmode = false, colorizeMessage = true)
     });
 }
 exports.createLogger = createLogger;
-/**
- * Create new logger
- * @deprecated Use `createLogger` instead
- * @param stringifyJSON stringify json objects in console
- * @param debugmode display debug messages
- * @param colorizeMessage add logger colours to messages
- */
-// TODO: Remove this on next major release
-function logger(stringifyJSON, debugmode = false, colorizeMessage = true) {
-    process.emitWarning('logger() is deprecated use createLogger() instead', 'DeprecationWarning');
-    return createLogger(stringifyJSON, debugmode, colorizeMessage);
-}
-exports.logger = logger;

package/bin/reciple/modules.d.ts

@@ -1,15 +1,15 @@
 import { RecipleClient } from './classes/RecipleClient';
-import { RecipleCommandBuilder } from './types/builders';
+import { CommandBuilder } from './types/builders';
 export declare type LoadedModules = {
-    commands: RecipleCommandBuilder[];
+    commands: CommandBuilder[];
     modules: RecipleModule[];
 };
 /**
  * Reciple script object interface
  */
-export declare class RecipleScript {
+export interface RecipleScript {
     versions: string | string[];
-    commands?: RecipleCommandBuilder[];
+    commands?: CommandBuilder[];
     onLoad?(reciple: RecipleClient): void | Promise<void>;
     onStart(reciple: RecipleClient): boolean | Promise<boolean>;
 }

package/bin/reciple/modules.js

@@ -50,7 +50,7 @@ function loadModules(client, folder) {
                     throw new Error(script + ' onStart is not defined or returned false.');
                 if (module_.commands) {
                     for (const command of module_.commands) {
-                        if (command.builder === builders_1.RecipleCommandBuilderType.MessageCommand || command.builder === builders_1.RecipleCommandBuilderType.SlashCommand) {
+                        if (command.builder === builders_1.CommandBuilderType.MessageCommand || command.builder === builders_1.CommandBuilderType.SlashCommand) {
                             commands.push(command);
                         }
                     }
@@ -69,7 +69,7 @@ function loadModules(client, folder) {
                         client.logger.error(`A ${c.builder} command name is not defined in ${script}`);
                     return false;
                 }
-                if (c.builder === builders_1.RecipleCommandBuilderType.MessageCommand && c.options.length && c.options.some(o => !o.name)) {
+                if (c.builder === builders_1.CommandBuilderType.MessageCommand && c.options.length && c.options.some(o => !o.name)) {
                     if (client.isClientLogsEnabled())
                         client.logger.error(`A ${c.builder} option name is not defined in ${script}`);
                     return false;

package/bin/reciple/permissions.d.ts

@@ -1,11 +1,11 @@
 import { Config } from './classes/RecipleConfig';
-import { RecipleUserHasCommandPermissionsOptions } from './types/paramOptions';
+import { UserHasCommandPermissionsOptions } from './types/paramOptions';
 import { Guild, PermissionResolvable } from 'discord.js';
 /**
  * Check if the user has permissions to execute the given command name
  * @param options options
  */
-export declare function userHasCommandPermissions(options: RecipleUserHasCommandPermissionsOptions): boolean;
+export declare function userHasCommandPermissions(options: UserHasCommandPermissionsOptions): boolean;
 /**
  * Check if the bot has the required permissions in a guild
  * @param guild Guild

package/bin/reciple/registerInteractionCommands.d.ts

@@ -1,9 +1,9 @@
 import { SlashCommandBuilder } from './classes/builders/SlashCommandBuilder';
-import { RecipleRegisterApplicationCommandsOptions } from './types/paramOptions';
+import { RegisterApplicationCommandsOptions } from './types/paramOptions';
 import { ContextMenuCommandBuilder, SlashCommandBuilder as DiscordJsSlashCommandBuilder } from 'discord.js';
 export declare type ApplicationCommandBuilder = SlashCommandBuilder | ContextMenuCommandBuilder | DiscordJsSlashCommandBuilder;
 /**
  * Register application commands
  * @param options Register application commands options
  */
-export declare function registerApplicationCommands(options: RecipleRegisterApplicationCommandsOptions): Promise<void>;
+export declare function registerApplicationCommands(options: RegisterApplicationCommandsOptions): Promise<void>;

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

@@ -3,15 +3,15 @@ import { SlashCommandBuilder, SlashCommandExecuteData } from '../classes/builder
 /**
  * Reciple command builders
  */
-export declare type RecipleCommandBuilder = MessageCommandBuilder | SlashCommandBuilder;
+export declare type CommandBuilder = MessageCommandBuilder | SlashCommandBuilder;
 /**
  * Reciple command builders execute data
  */
-export declare type RecipleCommandBuildersExecuteData = SlashCommandExecuteData | MessageCommandExecuteData;
+export declare type CommandBuilderExecuteData = SlashCommandExecuteData | MessageCommandExecuteData;
 /**
  * Types of Reciple command builders
  */
-export declare enum RecipleCommandBuilderType {
+export declare enum CommandBuilderType {
     MessageCommand = 0,
     SlashCommand = 1
 }

package/bin/reciple/types/builders.js

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

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

@@ -2,39 +2,39 @@ import { MessageCommandExecuteData } from '../classes/builders/MessageCommandBui
 import { SlashCommandBuilder, SlashCommandExecuteData } from '../classes/builders/SlashCommandBuilder';
 import { CooledDownUser } from '../classes/CommandCooldownManager';
 import { MessageCommandOptionManager } from '../classes/MessageCommandOptionManager';
-import { RecipleCommandBuilder } from '../types/builders';
+import { CommandBuilder } from '../types/builders';
 /**
  * Halted command's data
  */
-export declare type RecipleHaltedCommandData<Builder extends RecipleCommandBuilder = RecipleCommandBuilder> = RecipleCommandErrorData<Builder> | RecipleCommandCooldownData<Builder> | (Builder extends SlashCommandBuilder ? never : RecipleCommandInvalidArguments<Builder> | RecipleCommandMissingArguments<Builder>) | RecipleCommandMissingMemberPermissions<Builder> | RecipleCommandMissingBotPermissions<Builder>;
-export interface RecipleCommandHaltBaseData<Builder extends RecipleCommandBuilder> {
+export declare type HaltedCommandData<Builder extends CommandBuilder = CommandBuilder> = CommandErrorData<Builder> | CommandCooldownData<Builder> | (Builder extends SlashCommandBuilder ? never : CommandInvalidArguments<Builder> | CommandMissingArguments<Builder>) | CommandMissingMemberPermissions<Builder> | CommandMissingBotPermissions<Builder>;
+export interface CommandHaltBaseData<Builder extends CommandBuilder> {
     executeData: Builder extends SlashCommandBuilder ? SlashCommandExecuteData : MessageCommandExecuteData;
 }
-export interface RecipleCommandErrorData<Builder extends RecipleCommandBuilder> extends RecipleCommandHaltBaseData<Builder> {
-    reason: RecipleHaltedCommandReason.Error;
+export interface CommandErrorData<Builder extends CommandBuilder> extends CommandHaltBaseData<Builder> {
+    reason: HaltedCommandReason.Error;
     error: any;
 }
-export interface RecipleCommandCooldownData<Builder extends RecipleCommandBuilder> extends RecipleCommandHaltBaseData<Builder>, CooledDownUser {
-    reason: RecipleHaltedCommandReason.Cooldown;
+export interface CommandCooldownData<Builder extends CommandBuilder> extends CommandHaltBaseData<Builder>, CooledDownUser {
+    reason: HaltedCommandReason.Cooldown;
 }
-export interface RecipleCommandInvalidArguments<Builder extends RecipleCommandBuilder> extends RecipleCommandHaltBaseData<Builder> {
-    reason: RecipleHaltedCommandReason.InvalidArguments;
+export interface CommandInvalidArguments<Builder extends CommandBuilder> extends CommandHaltBaseData<Builder> {
+    reason: HaltedCommandReason.InvalidArguments;
     invalidArguments: MessageCommandOptionManager;
 }
-export interface RecipleCommandMissingArguments<Builder extends RecipleCommandBuilder> extends RecipleCommandHaltBaseData<Builder> {
-    reason: RecipleHaltedCommandReason.MissingArguments;
+export interface CommandMissingArguments<Builder extends CommandBuilder> extends CommandHaltBaseData<Builder> {
+    reason: HaltedCommandReason.MissingArguments;
     missingArguments: MessageCommandOptionManager;
 }
-export interface RecipleCommandMissingMemberPermissions<Builder extends RecipleCommandBuilder> extends RecipleCommandHaltBaseData<Builder> {
-    reason: RecipleHaltedCommandReason.MissingMemberPermissions;
+export interface CommandMissingMemberPermissions<Builder extends CommandBuilder> extends CommandHaltBaseData<Builder> {
+    reason: HaltedCommandReason.MissingMemberPermissions;
 }
-export interface RecipleCommandMissingBotPermissions<Builder extends RecipleCommandBuilder> extends RecipleCommandHaltBaseData<Builder> {
-    reason: RecipleHaltedCommandReason.MissingBotPermissions;
+export interface CommandMissingBotPermissions<Builder extends CommandBuilder> extends CommandHaltBaseData<Builder> {
+    reason: HaltedCommandReason.MissingBotPermissions;
 }
 /**
  * Command halt reasons
  */
-export declare enum RecipleHaltedCommandReason {
+export declare enum HaltedCommandReason {
     Error = 0,
     Cooldown = 1,
     InvalidArguments = 2,

package/bin/reciple/types/commands.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RecipleHaltedCommandReason = void 0;
+exports.HaltedCommandReason = void 0;
 /**
  * Command halt reasons
  */
-var RecipleHaltedCommandReason;
-(function (RecipleHaltedCommandReason) {
-    RecipleHaltedCommandReason[RecipleHaltedCommandReason["Error"] = 0] = "Error";
-    RecipleHaltedCommandReason[RecipleHaltedCommandReason["Cooldown"] = 1] = "Cooldown";
-    RecipleHaltedCommandReason[RecipleHaltedCommandReason["InvalidArguments"] = 2] = "InvalidArguments";
-    RecipleHaltedCommandReason[RecipleHaltedCommandReason["MissingArguments"] = 3] = "MissingArguments";
-    RecipleHaltedCommandReason[RecipleHaltedCommandReason["MissingMemberPermissions"] = 4] = "MissingMemberPermissions";
-    RecipleHaltedCommandReason[RecipleHaltedCommandReason["MissingBotPermissions"] = 5] = "MissingBotPermissions";
-})(RecipleHaltedCommandReason = exports.RecipleHaltedCommandReason || (exports.RecipleHaltedCommandReason = {}));
+var HaltedCommandReason;
+(function (HaltedCommandReason) {
+    HaltedCommandReason[HaltedCommandReason["Error"] = 0] = "Error";
+    HaltedCommandReason[HaltedCommandReason["Cooldown"] = 1] = "Cooldown";
+    HaltedCommandReason[HaltedCommandReason["InvalidArguments"] = 2] = "InvalidArguments";
+    HaltedCommandReason[HaltedCommandReason["MissingArguments"] = 3] = "MissingArguments";
+    HaltedCommandReason[HaltedCommandReason["MissingMemberPermissions"] = 4] = "MissingMemberPermissions";
+    HaltedCommandReason[HaltedCommandReason["MissingBotPermissions"] = 5] = "MissingBotPermissions";
+})(HaltedCommandReason = exports.HaltedCommandReason || (exports.HaltedCommandReason = {}));

package/bin/reciple/types/paramOptions.d.ts

@@ -2,9 +2,9 @@ import { RecipleClient } from '../classes/RecipleClient';
 import { Config } from '../classes/RecipleConfig';
 import { RecipleModule, RecipleScript } from '../modules';
 import { ApplicationCommandBuilder } from '../registerInteractionCommands';
-import { RecipleCommandBuilder } from './builders';
+import { CommandBuilder } from './builders';
 import { ApplicationCommandData, PermissionsBitField } from 'discord.js';
-export interface RecipleAddModuleOptions {
+export interface RecipleClientAddModuleOptions {
     /**
      * The Module script
      */
@@ -18,7 +18,7 @@ export interface RecipleAddModuleOptions {
      */
     moduleInfo?: RecipleModule["info"];
 }
-export interface RecipleRegisterApplicationCommandsOptions {
+export interface RegisterApplicationCommandsOptions {
     /**
      * Bot client
      */
@@ -32,8 +32,8 @@ export interface RecipleRegisterApplicationCommandsOptions {
      */
     guilds?: string | string[];
 }
-export interface RecipleUserHasCommandPermissionsOptions {
-    builder: RecipleCommandBuilder;
+export interface UserHasCommandPermissionsOptions {
+    builder: CommandBuilder;
     memberPermissions?: PermissionsBitField;
     commandPermissions?: Config["commands"]["slashCommand"]["permissions"] | Config["commands"]["messageCommand"]["permissions"];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reciple",
-  "version": "4.0.0-pre.1",
+  "version": "4.0.0-pre.2",
   "bin": "bin/bin.js",
   "license": "GPL-3.0",
   "main": "bin/index.js",
@@ -19,7 +19,7 @@
     "url": "https://github.com/FalloutStudios/reciple/issues"
   },
   "scripts": {
-    "clean": "rm -rf bin",
+    "clean": "yarn exec rimraf bin",
     "build": "yarn clean && yarn exec tsc",
     "build:publish": "yarn build && yarn npm publish && yarn build:docs && yarn publish:docs",
     "build:pub-prerelease": "yarn build && yarn npm publish --tag pre",
@@ -59,6 +59,7 @@
     "@types/node": "^18.6.1",
     "@types/semver": "^7.3.10",
     "discord.js": "^14.0.3",
+    "rimraf": "^3.0.2",
     "typedoc": "^0.23.9",
     "typedoc-plugin-discord-types": "^1.0.2",
     "typedoc-plugin-djs-links": "^1.2.0",