reciple 1.7.1-pre.0 → 2.0.0-pre.1

package/bin/index.d.ts

@@ -1,10 +1,10 @@
 export * from './reciple/classes/RecipleClient';
 export * from './reciple/classes/RecipleConfig';
+export * from './reciple/classes/MessageCommandOptionManager';
 export * from './reciple/classes/builders/InteractionCommandBuilder';
 export * from './reciple/classes/builders/MessageCommandBuilder';
 export * from './reciple/classes/builders/MessageCommandOptionBuilder';
-export * from './reciple/classes/builders/MessageCommandOptions';
-export * from './reciple/hasPermissions';
+export * from './reciple/permissions';
 export * from './reciple/flags';
 export * from './reciple/isIgnoredChannel';
 export * from './reciple/logger';

package/bin/index.js

@@ -16,11 +16,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./reciple/classes/RecipleClient"), exports);
 __exportStar(require("./reciple/classes/RecipleConfig"), exports);
+__exportStar(require("./reciple/classes/MessageCommandOptionManager"), exports);
 __exportStar(require("./reciple/classes/builders/InteractionCommandBuilder"), exports);
 __exportStar(require("./reciple/classes/builders/MessageCommandBuilder"), exports);
 __exportStar(require("./reciple/classes/builders/MessageCommandOptionBuilder"), exports);
-__exportStar(require("./reciple/classes/builders/MessageCommandOptions"), exports);
-__exportStar(require("./reciple/hasPermissions"), exports);
+__exportStar(require("./reciple/permissions"), exports);
 __exportStar(require("./reciple/flags"), exports);
 __exportStar(require("./reciple/isIgnoredChannel"), exports);
 __exportStar(require("./reciple/logger"), exports);

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

@@ -0,0 +1,21 @@
+import { Guild, TextBasedChannel, User } from 'discord.js';
+import { RecipleCommandBuilders } from '../modules';
+export interface CooledDownUser {
+    user: User;
+    command: string;
+    type: RecipleCommandBuilders["builder"];
+    guild?: Guild | null;
+    channel?: TextBasedChannel;
+    expireTime: number;
+}
+export declare class CommandCooldownManager extends Array<CooledDownUser> {
+    /**
+     * Alias for `CommandCooldownManager#push()`
+     */
+    add(...options: CooledDownUser[]): number;
+    remove(options: Partial<CooledDownUser>, limit?: number): void;
+    isCooledDown(options: Partial<Omit<CooledDownUser, 'expireTime'>>): boolean;
+    clean(options?: Partial<Omit<CooledDownUser, 'expireTime'>>): void;
+    get(options: Partial<Omit<CooledDownUser, 'expireTime'>>): CooledDownUser | undefined;
+    static checkOptions(options: Partial<Omit<CooledDownUser, 'expireTime'>>, data: CooledDownUser): boolean;
+}

package/bin/reciple/classes/CommandCooldownManager.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandCooldownManager = void 0;
+class CommandCooldownManager extends Array {
+    /**
+     * Alias for `CommandCooldownManager#push()`
+     */
+    add(...options) {
+        return this.push(...options);
+    }
+    remove(options, limit = 0) {
+        if (!Object.keys(options).length)
+            throw new TypeError('Provide atleast one option to remove cooldown data.');
+        let i = 0;
+        for (const index in this) {
+            if (!CommandCooldownManager.checkOptions(options, this[index]))
+                continue;
+            if (options.expireTime && this[index].expireTime > Date.now())
+                continue;
+            if (limit && i >= limit)
+                continue;
+            this.splice(Number(index));
+            i++;
+        }
+    }
+    isCooledDown(options) {
+        const data = this.get(options);
+        if (!data)
+            return false;
+        this.remove(Object.assign(Object.assign({}, data), { channel: undefined, guild: undefined, type: undefined, command: undefined }));
+        if (data.expireTime < Date.now())
+            return false;
+        return true;
+    }
+    clean(options) {
+        for (const index in this) {
+            if (options && !CommandCooldownManager.checkOptions(options, this[index]))
+                return;
+            if (this[index].expireTime > Date.now())
+                return;
+            this.slice(Number(index));
+        }
+    }
+    get(options) {
+        return this.find(data => CommandCooldownManager.checkOptions(options, data));
+    }
+    static checkOptions(options, data) {
+        var _a, _b;
+        if ((options === null || options === void 0 ? void 0 : options.user) && options.user.id !== data.user.id)
+            return false;
+        if ((options === null || options === void 0 ? void 0 : options.guild) && options.guild.id !== ((_a = data.guild) === null || _a === void 0 ? void 0 : _a.id))
+            return false;
+        if ((options === null || options === void 0 ? void 0 : options.channel) && options.channel.id !== ((_b = data.channel) === null || _b === void 0 ? void 0 : _b.id))
+            return false;
+        if ((options === null || options === void 0 ? void 0 : options.command) && options.command !== data.command)
+            return false;
+        if ((options === null || options === void 0 ? void 0 : options.type) && options.type !== data.type)
+            return false;
+        return true;
+    }
+}
+exports.CommandCooldownManager = CommandCooldownManager;

package/bin/reciple/classes/{builders/MessageCommandOptions.d.ts → MessageCommandOptionManager.d.ts}

@@ -1,5 +1,5 @@
-import { MessageCommandValidatedOption } from './MessageCommandBuilder';
-export declare class MessageCommandOptions extends Array<MessageCommandValidatedOption> {
+import { MessageCommandValidatedOption } from './builders/MessageCommandBuilder';
+export declare class MessageCommandOptionManager extends Array<MessageCommandValidatedOption> {
     constructor(options: MessageCommandValidatedOption[]);
     /**
      * Get the option info

package/bin/reciple/classes/{builders/MessageCommandOptions.js → MessageCommandOptionManager.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessageCommandOptions = void 0;
-class MessageCommandOptions extends Array {
+exports.MessageCommandOptionManager = void 0;
+class MessageCommandOptionManager extends Array {
     constructor(options) {
         super();
         this.push(...options);
@@ -20,4 +20,4 @@ class MessageCommandOptions extends Array {
         return (_a = option === null || option === void 0 ? void 0 : option.value) !== null && _a !== void 0 ? _a : null;
     }
 }
-exports.MessageCommandOptions = MessageCommandOptions;
+exports.MessageCommandOptionManager = MessageCommandOptionManager;

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

@@ -1,10 +1,38 @@
-import { InteractionCommandBuilder, RecipleInteractionCommandExecute } from './builders/InteractionCommandBuilder';
-import { interactionCommandBuilders } from '../registerInteractionCommands';
-import { MessageCommandBuilder, RecipleMessageCommandExecute } from './builders/MessageCommandBuilder';
+import { InteractionCommandBuilder, RecipleInteractionCommandExecuteData } from './builders/InteractionCommandBuilder';
+import { InteractionBuilder } from '../registerInteractionCommands';
+import { MessageCommandBuilder, RecipleMessageCommandExecuteData } from './builders/MessageCommandBuilder';
+import { MessageCommandOptionManager } from './MessageCommandOptionManager';
 import { Logger as ILogger } from 'fallout-utility';
 import { Config } from './RecipleConfig';
+import { CommandCooldownManager, CooledDownUser } from './CommandCooldownManager';
 import { ApplicationCommandDataResolvable, Awaitable, Client, ClientEvents, ClientOptions, CommandInteraction, Interaction, Message } from 'discord.js';
-import { recipleCommandBuilders, RecipleModule, RecipleScript } from '../modules';
+import { RecipleCommandBuilders, RecipleModule, RecipleScript } from '../modules';
+export declare type CommandHaltReason<Builder extends RecipleCommandBuilders> = RecipleHaltedCommandData<Builder>["reason"];
+export declare type RecipleHaltedCommandData<Builder extends RecipleCommandBuilders> = CommandErrorData<Builder> | CommandCooldownData<Builder> | CommandInvalidArguments<Builder> | CommandMissingArguments<Builder> | CommandMissingMemberPermissions<Builder> | CommandMissingBotPermissions<Builder>;
+export interface CommandHaltBaseData<Builder extends RecipleCommandBuilders> {
+    executeData: Builder extends InteractionCommandBuilder ? RecipleInteractionCommandExecuteData : RecipleMessageCommandExecuteData;
+}
+export interface CommandErrorData<Builder extends RecipleCommandBuilders> extends CommandHaltBaseData<Builder> {
+    reason: 'ERROR';
+    error: any;
+}
+export interface CommandCooldownData<Builder extends RecipleCommandBuilders> extends CommandHaltBaseData<Builder>, CooledDownUser {
+    reason: 'COOLDOWN';
+}
+export interface CommandInvalidArguments<Builder extends RecipleCommandBuilders> extends CommandHaltBaseData<Builder> {
+    reason: 'INVALID_ARGUMENTS';
+    invalidArguments: MessageCommandOptionManager;
+}
+export interface CommandMissingArguments<Builder extends RecipleCommandBuilders> extends CommandHaltBaseData<Builder> {
+    reason: 'MISSING_ARGUMENTS';
+    missingArguments: MessageCommandOptionManager;
+}
+export interface CommandMissingMemberPermissions<Builder extends RecipleCommandBuilders> extends CommandHaltBaseData<Builder> {
+    reason: 'MISSING_MEMBER_PERMISSIONS';
+}
+export interface CommandMissingBotPermissions<Builder extends RecipleCommandBuilders> extends CommandHaltBaseData<Builder> {
+    reason: 'MISSING_BOT_PERMISSIONS';
+}
 export interface RecipleClientOptions extends ClientOptions {
     config?: Config;
 }
@@ -17,8 +45,8 @@ export interface RecipleClientCommands {
     };
 }
 export interface RecipleClientEvents extends ClientEvents {
-    recipleMessageCommandCreate: [command: RecipleMessageCommandExecute];
-    recipleInteractionCommandCreate: [command: RecipleInteractionCommandExecute];
+    recipleMessageCommandCreate: [executeData: RecipleMessageCommandExecuteData];
+    recipleInteractionCommandCreate: [executeData: RecipleInteractionCommandExecuteData];
     recipleReplyError: [error: unknown];
 }
 export interface RecipleClient<Ready extends boolean = boolean> extends Client<Ready> {
@@ -37,7 +65,8 @@ export interface RecipleClient<Ready extends boolean = boolean> extends Client<R
 export declare class RecipleClient<Ready extends boolean = boolean> extends Client<Ready> {
     config: Config;
     commands: RecipleClientCommands;
-    otherApplicationCommandData: (interactionCommandBuilders | ApplicationCommandDataResolvable)[];
+    otherApplicationCommandData: (InteractionBuilder | ApplicationCommandDataResolvable)[];
+    commandCooldowns: CommandCooldownManager;
     modules: RecipleModule[];
     logger: ILogger;
     version: string;
@@ -57,7 +86,7 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
     /**
      * Add interaction or message command to client
      */
-    addCommand(command: recipleCommandBuilders): RecipleClient<Ready>;
+    addCommand(command: RecipleCommandBuilders): RecipleClient<Ready>;
     /**
      * Listed to command executions
      */
@@ -65,11 +94,11 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
     /**
      * Execute a Message command
      */
-    messageCommandExecute(message: Message, prefix?: string): Promise<void | RecipleMessageCommandExecute>;
+    messageCommandExecute(message: Message, prefix?: string): Promise<void | RecipleMessageCommandExecuteData>;
     /**
      * Execute an Interaction command
      */
-    interactionCommandExecute(interaction: Interaction | CommandInteraction): Promise<void | RecipleInteractionCommandExecute>;
+    interactionCommandExecute(interaction: Interaction | CommandInteraction): Promise<void | RecipleInteractionCommandExecuteData>;
     /**
      * Get a message from config
      */

package/bin/reciple/classes/RecipleClient.js

@@ -17,15 +17,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RecipleClient = void 0;
 const registerInteractionCommands_1 = require("../registerInteractionCommands");
+const MessageCommandOptionManager_1 = require("./MessageCommandOptionManager");
 const fallout_utility_1 = require("fallout-utility");
+const RecipleConfig_1 = require("./RecipleConfig");
 const isIgnoredChannel_1 = require("../isIgnoredChannel");
-const hasPermissions_1 = require("../hasPermissions");
+const CommandCooldownManager_1 = require("./CommandCooldownManager");
+const permissions_1 = require("../permissions");
 const version_1 = require("../version");
 const logger_1 = require("../logger");
-const RecipleConfig_1 = require("./RecipleConfig");
 const discord_js_1 = require("discord.js");
 const modules_1 = require("../modules");
-const MessageCommandOptions_1 = require("./builders/MessageCommandOptions");
+;
 class RecipleClient extends discord_js_1.Client {
     constructor(options) {
         var _a, _b, _c;
@@ -33,6 +35,7 @@ class RecipleClient extends discord_js_1.Client {
         this.config = RecipleConfig_1.RecipleConfig.getDefaultConfig();
         this.commands = { MESSAGE_COMMANDS: {}, INTERACTION_COMMANDS: {} };
         this.otherApplicationCommandData = [];
+        this.commandCooldowns = new CommandCooldownManager_1.CommandCooldownManager();
         this.modules = [];
         this.version = version_1.version;
         this.logger = (0, logger_1.logger)(!!((_a = options.config) === null || _a === void 0 ? void 0 : _a.fileLogging.stringifyLoggedJSON), !!((_b = options.config) === null || _b === void 0 ? void 0 : _b.fileLogging.debugmode));
@@ -71,7 +74,7 @@ class RecipleClient extends discord_js_1.Client {
                             this.logger.error(`Error loading ${(_a = module_.info.filename) !== null && _a !== void 0 ? _a : 'unknown module'}:`);
                             this.logger.error(err);
                         }
-                        this.modules = this.modules.filter((r, i) => i.toString() !== m.toString());
+                        this.modules = this.modules.filter((_r, i) => i.toString() !== m.toString());
                     });
                 }
                 if (typeof ((_b = module_.script) === null || _b === void 0 ? void 0 : _b.commands) !== 'undefined') {
@@ -155,36 +158,69 @@ class RecipleClient extends discord_js_1.Client {
             const command = this.findCommand(parseCommand.command, 'MESSAGE_COMMAND');
             if (!command)
                 return;
-            if ((0, hasPermissions_1.hasPermissions)(command.name, (_a = message.member) === null || _a === void 0 ? void 0 : _a.permissions, this.config.permissions.messageCommands, command)) {
+            const commandOptions = command.getCommandOptionValues(parseCommand);
+            const executeData = {
+                message: message,
+                options: new MessageCommandOptionManager_1.MessageCommandOptionManager(commandOptions),
+                command: parseCommand,
+                builder: command,
+                client: this
+            };
+            if ((0, permissions_1.userHasCommandPermissions)(command.name, (_a = message.member) === null || _a === void 0 ? void 0 : _a.permissions, this.config.permissions.messageCommands, command)) {
                 if (!command.allowExecuteInDM && message.channel.type === 'DM'
                     || !command.allowExecuteByBots
                         && (message.author.bot || message.author.system)
                     || (0, isIgnoredChannel_1.isIgnoredChannel)(message.channelId, this.config.ignoredChannels))
                     return;
-                const commandOptions = command.getCommandOptionValues(parseCommand);
                 if (command.validateOptions) {
                     if (commandOptions.some(o => o.invalid)) {
-                        yield message.reply(this.getMessage('invalidArguments', 'Invalid argument(s) given.')).catch(er => this.replyError(er));
+                        if (!(command === null || command === void 0 ? void 0 : command.halt) || !(yield command.halt({ executeData, reason: 'INVALID_ARGUMENTS', 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)) {
-                        yield message.reply(this.getMessage('notEnoughArguments', 'Not enough arguments.')).catch(er => this.replyError(er));
+                        if (!command.halt || !(yield command.halt({ executeData, reason: 'MISSING_ARGUMENTS', missingArguments: new MessageCommandOptionManager_1.MessageCommandOptionManager(executeData.options.filter(o => o.missing)) }))) {
+                            message.reply(this.getMessage('notEnoughArguments', 'Not enough arguments.')).catch(er => this.replyError(er));
+                        }
                         return;
                     }
                 }
-                const options = {
-                    message: message,
-                    options: new MessageCommandOptions_1.MessageCommandOptions(commandOptions),
-                    command: parseCommand,
-                    builder: command,
-                    client: this
+                if (message.guild && !(0, permissions_1.botHasExecutePermissions)(message.guild, command.requiredBotPermissions)) {
+                    if (!command.halt || !(yield command.halt({ executeData, reason: 'MISSING_BOT_PERMISSIONS' }))) {
+                        message.reply(this.getMessage('insufficientBotPerms', 'Insufficient bot permissions.')).catch(er => this.replyError(er));
+                    }
+                    return;
+                }
+                const userCooldown = {
+                    user: message.author,
+                    command: command.name,
+                    channel: message.channel,
+                    guild: message.guild,
+                    type: 'MESSAGE_COMMAND'
                 };
-                yield Promise.resolve(command.execute(options)).catch(err => this._commandExecuteError(err, options));
-                this.emit('recipleMessageCommandCreate', options);
-                return options;
+                if (command.cooldown && !this.commandCooldowns.isCooledDown(userCooldown)) {
+                    this.commandCooldowns.add(Object.assign(Object.assign({}, userCooldown), { expireTime: Date.now() + command.cooldown }));
+                }
+                else if (command.cooldown) {
+                    if (!command.halt || !(yield command.halt(Object.assign({ executeData, reason: '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;
+                }
+                try {
+                    yield Promise.resolve(command.execute(executeData)).catch((err) => __awaiter(this, void 0, void 0, function* () { return !command.halt || !(yield command.halt({ executeData, reason: 'ERROR', error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
+                    this.emit('recipleMessageCommandCreate', executeData);
+                    return executeData;
+                }
+                catch (err) {
+                    if (!command.halt || !(yield command.halt({ executeData, reason: 'ERROR', error: err }))) {
+                        this._commandExecuteError(err, executeData);
+                    }
+                }
             }
-            else {
-                yield message.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this.replyError(er));
+            else if (!command.halt || !(yield command.halt({ executeData, reason: 'MISSING_MEMBER_PERMISSIONS' }))) {
+                message.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this.replyError(er));
             }
         });
     }
@@ -192,27 +228,55 @@ class RecipleClient extends discord_js_1.Client {
      * Execute an Interaction command
      */
     interactionCommandExecute(interaction) {
-        var _a;
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             if (!interaction || !interaction.isCommand() || !this.isReady())
                 return;
             const command = this.findCommand(interaction.commandName, 'INTERACTION_COMMAND');
             if (!command)
                 return;
-            if ((0, hasPermissions_1.hasPermissions)(command.name, (_a = interaction.memberPermissions) !== null && _a !== void 0 ? _a : undefined, this.config.permissions.interactionCommands, command)) {
+            const executeData = {
+                interaction: interaction,
+                builder: command,
+                client: this
+            };
+            if ((0, permissions_1.userHasCommandPermissions)(command.name, (_a = interaction.memberPermissions) !== null && _a !== void 0 ? _a : undefined, this.config.permissions.interactionCommands, command)) {
                 if (!command || (0, isIgnoredChannel_1.isIgnoredChannel)(interaction.channelId, this.config.ignoredChannels))
                     return;
-                const options = {
-                    interaction: interaction,
-                    command: command,
-                    builder: command,
-                    client: this
+                if (interaction.guild && (0, permissions_1.botHasExecutePermissions)(interaction.guild, command.requiredBotPermissions)) {
+                    if (!command.halt || !(yield command.halt({ executeData, reason: 'MISSING_BOT_PERMISSIONS' }))) {
+                        yield interaction.reply(this.getMessage('insufficientBotPerms', 'Insufficient bot permissions.')).catch(er => this.replyError(er));
+                    }
+                    return;
+                }
+                const userCooldown = {
+                    user: interaction.user,
+                    command: command.name,
+                    channel: (_b = interaction.channel) !== null && _b !== void 0 ? _b : undefined,
+                    guild: interaction.guild,
+                    type: 'INTERACTION_COMMAND'
                 };
-                yield Promise.resolve(command.execute(options)).catch(err => this._commandExecuteError(err, options));
-                this.emit('recipleInteractionCommandCreate', options);
-                return options;
+                if (command.cooldown && !this.commandCooldowns.isCooledDown(userCooldown)) {
+                    this.commandCooldowns.add(Object.assign(Object.assign({}, userCooldown), { expireTime: Date.now() + command.cooldown }));
+                }
+                else if (command.cooldown) {
+                    if (!command.halt || !(yield command.halt(Object.assign({ executeData, reason: '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;
+                }
+                try {
+                    yield Promise.resolve(command.execute(executeData)).catch((err) => __awaiter(this, void 0, void 0, function* () { return !command.halt || !(yield command.halt({ executeData, reason: 'ERROR', error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
+                    this.emit('recipleInteractionCommandCreate', executeData);
+                    return executeData;
+                }
+                catch (err) {
+                    if (!command.halt || !(yield command.halt({ executeData, reason: 'ERROR', error: err }))) {
+                        this._commandExecuteError(err, executeData);
+                    }
+                }
             }
-            else {
+            else if (!command.halt || !(yield command.halt({ executeData, reason: 'MISSING_MEMBER_PERMISSIONS' }))) {
                 yield interaction.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this.replyError(er));
             }
         });

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

@@ -1,7 +1,7 @@
-import { ClientOptions, PermissionFlags, PermissionString } from 'discord.js';
+import { ClientOptions, PermissionResolvable } from 'discord.js';
 export interface ConfigCommandPermissions {
     command: string;
-    permissions: (PermissionFlags | PermissionString)[];
+    permissions: PermissionResolvable[];
 }
 export interface Config {
     token: string;
@@ -11,12 +11,14 @@ export interface Config {
             enabled: boolean;
             replyOnError: boolean;
             allowCommandAlias: boolean;
+            enableCooldown: boolean;
             commandArgumentSeparator: string;
         };
         interactionCommand: {
             enabled: boolean;
             replyOnError: boolean;
             registerCommands: boolean;
+            enableCooldown: boolean;
             setRequiredPermissions: boolean;
             guilds: string[] | string;
         };

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

@@ -1,23 +1,34 @@
-import { CommandInteraction, PermissionFlags, PermissionString } from 'discord.js';
+import { Awaitable, CommandInteraction, PermissionResolvable } from 'discord.js';
+import { RecipleClient, RecipleHaltedCommandData } from '../RecipleClient';
 import { SlashCommandBuilder } from '@discordjs/builders';
-import { RecipleClient } from '../RecipleClient';
-export interface RecipleInteractionCommandExecute {
+export interface RecipleInteractionCommandExecuteData {
     interaction: CommandInteraction;
-    command: InteractionCommandBuilder;
     builder: InteractionCommandBuilder;
     client: RecipleClient<true>;
 }
 export declare class InteractionCommandBuilder extends SlashCommandBuilder {
     readonly builder = "INTERACTION_COMMAND";
-    requiredPermissions: (PermissionFlags | PermissionString)[];
+    cooldown: number;
+    requiredBotPermissions: PermissionResolvable[];
+    RequiredUserPermissions: PermissionResolvable[];
     allowExecuteInDM: boolean;
-    execute: (options: RecipleInteractionCommandExecute) => void;
+    halt?: (haltData: RecipleHaltedCommandData<InteractionCommandBuilder>) => Awaitable<boolean>;
+    execute: (executeData: RecipleInteractionCommandExecuteData) => Awaitable<void>;
     /**
-     * Set required permissions before executing the command
+     * Sets the execute cooldown for this command.
+     * - `0` means no cooldown
      */
-    setRequiredPermissions(requiredPermissions: (keyof PermissionFlags)[]): InteractionCommandBuilder;
+    setCooldown(cooldown: number): InteractionCommandBuilder;
+    /**
+     * Set required permissions to execute the command
+     */
+    setRequiredMemberPermissions(...permissions: PermissionResolvable[]): InteractionCommandBuilder;
+    /**
+     * Function when the command is interupted before execution
+     */
+    setHalt(halt?: (haltData: RecipleHaltedCommandData<InteractionCommandBuilder>) => Awaitable<boolean>): InteractionCommandBuilder;
     /**
      * Function when the command is executed
      */
-    setExecute(execute: (options: RecipleInteractionCommandExecute) => void): InteractionCommandBuilder;
+    setExecute(execute: (executeData: RecipleInteractionCommandExecuteData) => void): InteractionCommandBuilder;
 }

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

@@ -6,17 +6,32 @@ class InteractionCommandBuilder extends builders_1.SlashCommandBuilder {
     constructor() {
         super(...arguments);
         this.builder = 'INTERACTION_COMMAND';
-        this.requiredPermissions = [];
+        this.cooldown = 0;
+        this.requiredBotPermissions = [];
+        this.RequiredUserPermissions = [];
         this.allowExecuteInDM = true;
         this.execute = () => { };
     }
     /**
-     * Set required permissions before executing the command
+     * Sets the execute cooldown for this command.
+     * - `0` means no cooldown
      */
-    setRequiredPermissions(requiredPermissions) {
-        if (!requiredPermissions || !Array.isArray(requiredPermissions))
-            throw new Error('requiredPermissions must be an array.');
-        this.requiredPermissions = requiredPermissions;
+    setCooldown(cooldown) {
+        this.cooldown = cooldown;
+        return this;
+    }
+    /**
+     * Set required permissions to execute the command
+     */
+    setRequiredMemberPermissions(...permissions) {
+        this.RequiredUserPermissions = permissions;
+        return this;
+    }
+    /**
+     * Function when the command is interupted before execution
+     */
+    setHalt(halt) {
+        this.halt = halt ? halt : undefined;
         return this;
     }
     /**

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

@@ -1,11 +1,11 @@
 import { MessageCommandOptionBuilder } from './MessageCommandOptionBuilder';
-import { Message, PermissionFlags, PermissionString } from 'discord.js';
+import { RecipleClient, RecipleHaltedCommandData } from '../RecipleClient';
+import { MessageCommandOptionManager } from '../MessageCommandOptionManager';
+import { Awaitable, Message, PermissionResolvable } from 'discord.js';
 import { Command as CommandMessage } from 'fallout-utility';
-import { RecipleClient } from '../RecipleClient';
-import { MessageCommandOptions } from './MessageCommandOptions';
-export interface RecipleMessageCommandExecute {
+export interface RecipleMessageCommandExecuteData {
     message: Message;
-    options: MessageCommandOptions;
+    options: MessageCommandOptionManager;
     command: CommandMessage;
     builder: MessageCommandBuilder;
     client: RecipleClient<true>;
@@ -20,14 +20,17 @@ export interface MessageCommandValidatedOption {
 export declare class MessageCommandBuilder {
     readonly builder = "MESSAGE_COMMAND";
     name: string;
+    cooldown: number;
     description: string;
     aliases: string[];
     options: MessageCommandOptionBuilder[];
     validateOptions: boolean;
-    requiredPermissions: (PermissionFlags | PermissionString)[];
+    requiredBotPermissions: PermissionResolvable[];
+    RequiredUserPermissions: PermissionResolvable[];
     allowExecuteInDM: boolean;
     allowExecuteByBots: boolean;
-    execute: (options: RecipleMessageCommandExecute) => void;
+    halt?: (haltData: RecipleHaltedCommandData<MessageCommandBuilder>) => Awaitable<boolean>;
+    execute: (executeData: RecipleMessageCommandExecuteData) => void;
     /**
      * Sets the command name
      */
@@ -36,14 +39,23 @@ export declare class MessageCommandBuilder {
      * Sets the command description
      */
     setDescription(description: string): MessageCommandBuilder;
+    /**
+     * Sets the execute cooldown for this command.
+     * - `0` means no cooldown
+     */
+    setCooldown(cooldown: number): MessageCommandBuilder;
     /**
      * Add aliases to the command
      */
     addAliases(...aliases: string[]): MessageCommandBuilder;
     /**
-     * Sets the default required permissions to execute this command
+     * Set required per
+     */
+    setRequiredBotPermissions(...permissions: PermissionResolvable[]): MessageCommandBuilder;
+    /**
+     * Set required user permissions to execute the command
      */
-    setRequiredPermissions(permissions: (PermissionFlags | PermissionString)[]): MessageCommandBuilder;
+    setRequiredMemberPermissions(...permissions: PermissionResolvable[]): MessageCommandBuilder;
     /**
      * Set if command can be executed in dms
      */
@@ -52,10 +64,14 @@ export declare class MessageCommandBuilder {
      * Allow command to be executed by bots
      */
     setAllowExecuteByBots(allowExecuteByBots: boolean): MessageCommandBuilder;
+    /**
+     * Function when the command is interupted before execution
+     */
+    setHalt(halt?: (haltData: RecipleHaltedCommandData<MessageCommandBuilder>) => Awaitable<boolean>): MessageCommandBuilder;
     /**
      * Function when the command is executed
      */
-    setExecute(execute: (options: RecipleMessageCommandExecute) => void): MessageCommandBuilder;
+    setExecute(execute: (executeData: RecipleMessageCommandExecuteData) => void): MessageCommandBuilder;
     /**
      * Add option to the command
      */

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

@@ -6,11 +6,13 @@ class MessageCommandBuilder {
     constructor() {
         this.builder = 'MESSAGE_COMMAND';
         this.name = '';
+        this.cooldown = 0;
         this.description = '';
         this.aliases = [];
         this.options = [];
         this.validateOptions = false;
-        this.requiredPermissions = [];
+        this.requiredBotPermissions = [];
+        this.RequiredUserPermissions = [];
         this.allowExecuteInDM = true;
         this.allowExecuteByBots = false;
         this.execute = () => { };
@@ -33,6 +35,14 @@ class MessageCommandBuilder {
         this.description = description;
         return this;
     }
+    /**
+     * Sets the execute cooldown for this command.
+     * - `0` means no cooldown
+     */
+    setCooldown(cooldown) {
+        this.cooldown = cooldown;
+        return this;
+    }
     /**
      * Add aliases to the command
      */
@@ -47,12 +57,17 @@ class MessageCommandBuilder {
         return this;
     }
     /**
-     * Sets the default required permissions to execute this command
+     * Set required per
+     */
+    setRequiredBotPermissions(...permissions) {
+        this.requiredBotPermissions = permissions;
+        return this;
+    }
+    /**
+     * Set required user permissions to execute the command
      */
-    setRequiredPermissions(permissions) {
-        if (!permissions || !Array.isArray(permissions))
-            throw new TypeError('permissions must be an array.');
-        this.requiredPermissions = permissions;
+    setRequiredMemberPermissions(...permissions) {
+        this.RequiredUserPermissions = permissions;
         return this;
     }
     /**
@@ -73,6 +88,13 @@ class MessageCommandBuilder {
         this.allowExecuteByBots = allowExecuteByBots;
         return this;
     }
+    /**
+     * Function when the command is interupted before execution
+     */
+    setHalt(halt) {
+        this.halt = halt ? halt : undefined;
+        return this;
+    }
     /**
      * Function when the command is executed
      */

package/bin/reciple/modules.d.ts

@@ -1,15 +1,15 @@
-import { InteractionCommandBuilder, RecipleInteractionCommandExecute } from './classes/builders/InteractionCommandBuilder';
-import { MessageCommandBuilder, RecipleMessageCommandExecute } from './classes/builders/MessageCommandBuilder';
+import { InteractionCommandBuilder, RecipleInteractionCommandExecuteData } from './classes/builders/InteractionCommandBuilder';
+import { MessageCommandBuilder, RecipleMessageCommandExecuteData } from './classes/builders/MessageCommandBuilder';
 import { RecipleClient } from './classes/RecipleClient';
-export declare type recipleCommandBuilders = MessageCommandBuilder | InteractionCommandBuilder;
-export declare type recipleCommandBuildersExecute = RecipleInteractionCommandExecute | RecipleMessageCommandExecute;
-export declare type loadedModules = {
-    commands: recipleCommandBuilders[];
+export declare type RecipleCommandBuilders = MessageCommandBuilder | InteractionCommandBuilder;
+export declare type RecipleCommandBuildersExecuteData = RecipleInteractionCommandExecuteData | RecipleMessageCommandExecuteData;
+export declare type LoadedModules = {
+    commands: RecipleCommandBuilders[];
     modules: RecipleModule[];
 };
 export declare class RecipleScript {
     versions: string | string[];
-    commands?: recipleCommandBuilders[];
+    commands?: RecipleCommandBuilders[];
     onLoad?(reciple: RecipleClient): void | Promise<void>;
     onStart(reciple: RecipleClient): boolean | Promise<boolean>;
 }
@@ -24,4 +24,4 @@ export interface RecipleModule {
 /**
  * Load modules from folder
  */
-export declare function loadModules(client: RecipleClient, folder?: string): Promise<loadedModules>;
+export declare function loadModules(client: RecipleClient, folder?: string): Promise<LoadedModules>;

package/bin/reciple/permissions.d.ts

@@ -0,0 +1,8 @@
+import { RecipleCommandBuilders } from './modules';
+import { Config } from './classes/RecipleConfig';
+import { Guild, PermissionResolvable, Permissions } from 'discord.js';
+/**
+ * Check if the user has permissions to execute the given command name
+ */
+export declare function userHasCommandPermissions(commandName: string, memberPermissions?: Permissions, configConmmandPermissions?: Config['permissions']['messageCommands'] | Config['permissions']['interactionCommands'], builder?: RecipleCommandBuilders): boolean;
+export declare function botHasExecutePermissions(guild?: Guild, requiredPermissions?: PermissionResolvable[]): boolean;

package/bin/reciple/permissions.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.botHasExecutePermissions = exports.userHasCommandPermissions = void 0;
+/**
+ * Check if the user has permissions to execute the given command name
+ */
+function userHasCommandPermissions(commandName, memberPermissions, configConmmandPermissions, builder) {
+    var _a, _b;
+    if (!(configConmmandPermissions === null || configConmmandPermissions === void 0 ? void 0 : configConmmandPermissions.enabled))
+        return true;
+    const command = (_a = configConmmandPermissions.commands.find(c => c.command.toLowerCase() === commandName.toLowerCase())) !== null && _a !== void 0 ? _a : { permissions: (_b = builder === null || builder === void 0 ? void 0 : builder.RequiredUserPermissions) !== null && _b !== void 0 ? _b : [] };
+    if (!command.permissions.length)
+        return true;
+    return memberPermissions ? memberPermissions.has(command.permissions) : false;
+}
+exports.userHasCommandPermissions = userHasCommandPermissions;
+function botHasExecutePermissions(guild, requiredPermissions) {
+    var _a;
+    if (!(requiredPermissions === null || requiredPermissions === void 0 ? void 0 : requiredPermissions.length))
+        return true;
+    return (guild === null || guild === void 0 ? void 0 : guild.me) ? (_a = guild.me) === null || _a === void 0 ? void 0 : _a.permissions.has(requiredPermissions) : false;
+}
+exports.botHasExecutePermissions = botHasExecutePermissions;

package/bin/reciple/registerInteractionCommands.d.ts

@@ -2,8 +2,8 @@ import { InteractionCommandBuilder } from './classes/builders/InteractionCommand
 import { ApplicationCommandDataResolvable } from 'discord.js';
 import { RecipleClient } from './classes/RecipleClient';
 import { ContextMenuCommandBuilder, SlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandOptionsOnlyBuilder, SlashCommandSubcommandGroupBuilder, SlashCommandSubcommandsOnlyBuilder } from '@discordjs/builders';
-export declare type interactionCommandBuilders = InteractionCommandBuilder | ContextMenuCommandBuilder | SlashCommandBuilder | SlashCommandSubcommandBuilder | SlashCommandOptionsOnlyBuilder | SlashCommandSubcommandGroupBuilder | SlashCommandSubcommandsOnlyBuilder;
+export declare type InteractionBuilder = InteractionCommandBuilder | ContextMenuCommandBuilder | SlashCommandBuilder | SlashCommandSubcommandBuilder | SlashCommandOptionsOnlyBuilder | SlashCommandSubcommandGroupBuilder | SlashCommandSubcommandsOnlyBuilder;
 /**
  * Register interaction commands
  */
-export declare function registerInteractionCommands(client: RecipleClient, cmds?: (interactionCommandBuilders | ApplicationCommandDataResolvable)[], overwriteGuilds?: string | string[]): Promise<void>;
+export declare function registerInteractionCommands(client: RecipleClient, cmds?: (InteractionBuilder | ApplicationCommandDataResolvable)[], overwriteGuilds?: string | string[]): Promise<void>;

package/bin/reciple/registerInteractionCommands.js

@@ -24,8 +24,8 @@ function registerInteractionCommands(client, cmds, overwriteGuilds) {
             if ((cmd === null || cmd === void 0 ? void 0 : cmd.builder) === 'INTERACTION_COMMAND' && client.config.commands.interactionCommand.setRequiredPermissions) {
                 const permissions = (_d = (((_a = client.config.permissions) === null || _a === void 0 ? void 0 : _a.interactionCommands.enabled) ?
                     (_c = (_b = client.config.permissions) === null || _b === void 0 ? void 0 : _b.interactionCommands.commands.find(cmd_ => cmd_.command.toLowerCase() === cmd.name.toLowerCase())) === null || _c === void 0 ? void 0 : _c.permissions :
-                    undefined)) !== null && _d !== void 0 ? _d : cmd.requiredPermissions;
-                cmd.setRequiredPermissions(permissions);
+                    undefined)) !== null && _d !== void 0 ? _d : cmd.requiredBotPermissions;
+                cmd.setRequiredMemberPermissions(permissions);
                 client.commands.INTERACTION_COMMANDS[cmd.name] = cmd;
                 if (client.isClientLogsEnabled())
                     client.logger.debug(`Set required permissions for ${cmd.name}`);

package/bin/reciple/version.js

@@ -8,7 +8,7 @@ const semver_1 = __importDefault(require("semver"));
 /**
  * Current reciple version
  */
-exports.version = require('../../package.json').version;
+exports.version = `${semver_1.default.coerce(require('../../package.json').version)}`;
 /**
  * Check if the version is valid
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reciple",
-  "version": "1.7.1-pre.0",
+  "version": "2.0.0-pre.1",
   "description": "A Discord.js bot",
   "author": "FalloutStudios",
   "homepage": "https://falloutstudios.github.io/Reciple",
@@ -21,11 +21,11 @@
   ],
   "scripts": {
     "clean": "rm -rf bin",
-    "build": "yarn run clean && npx tsc && yarn run reinstall && yarn run build:docs",
-    "build:publish": "yarn run build && yarn publish",
-    "build:pub-prerelease": "yarn run build && yarn publish --tag beta",
+    "build": "yarn run clean && npx tsc && yarn run reinstall",
+    "build:publish": "yarn run build && yarn publish && yarn run publish:docs",
+    "build:pub-prerelease": "yarn run build && yarn publish --tag pre",
     "reinstall": "npm un reciple -g && npm i ./ -g",
-    "postpublish": "yarn run build:docs && yarn run update:docs",
+    "publish:docs": "yarn run build:docs && yarn run update:docs",
     "test": "yarn run build && yarn run test:start",
     "test:start": "cd test && npx reciple",
     "build:docs": "cd docs && yarn run build",

package/resource/reciple.yml

@@ -13,8 +13,10 @@ commands:
     enabled: true
     # reply when an error occured
     replyOnError: false
+    # Enable the use of command cooldowns
+    enableCooldown: false
     # Allow executing commands via aliases
-    allowCommandAlias: false
+    allowCommandAlias: true
     # command argument separator
     commandArgumentSeparator: ' '
   interactionCommand:
@@ -22,6 +24,8 @@ commands:
     enabled: true
     # reply when an error occured
     replyOnError: false
+    # Enable the use of command cooldowns
+    enableCooldown: false
     # register interaction commands on bot ready
     registerCommands: true
     # set required permissions for interaction commands

package/bin/reciple/hasPermissions.d.ts

@@ -1,7 +0,0 @@
-import { Permissions } from 'discord.js';
-import { recipleCommandBuilders } from './modules';
-import { Config } from './classes/RecipleConfig';
-/**
- * Check if the user has permissions to execute the given command name
- */
-export declare function hasPermissions(commandName: string, memberPermissions?: Permissions, configConmmandPermissions?: Config['permissions']['messageCommands'] | Config['permissions']['interactionCommands'], builder?: recipleCommandBuilders): boolean;

package/bin/reciple/hasPermissions.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasPermissions = void 0;
-/**
- * Check if the user has permissions to execute the given command name
- */
-function hasPermissions(commandName, memberPermissions, configConmmandPermissions, builder) {
-    var _a, _b;
-    if (!(configConmmandPermissions === null || configConmmandPermissions === void 0 ? void 0 : configConmmandPermissions.enabled))
-        return true;
-    const command = (_a = configConmmandPermissions.commands.find(c => c.command.toLowerCase() === commandName.toLowerCase())) !== null && _a !== void 0 ? _a : { permissions: (_b = builder === null || builder === void 0 ? void 0 : builder.requiredPermissions) !== null && _b !== void 0 ? _b : [] };
-    if (!command.permissions.length)
-        return true;
-    return memberPermissions ? memberPermissions.has(command.permissions) : false;
-}
-exports.hasPermissions = hasPermissions;