reciple 2.0.2 → 3.0.1

package/README.md

@@ -17,12 +17,6 @@ To install the bot, run the following command in your terminal:
 ```bash
 npm i reciple
 ```
-```bash
-yarn add reciple
-```
-```bash
-pnpm add reciple
-```
 
 You can initialize the bot to the current directory with the following command in your terminal:
 

package/bin/index.d.ts

@@ -1,14 +1,15 @@
 export * from './reciple/classes/RecipleClient';
 export * from './reciple/classes/RecipleConfig';
+export * from './reciple/classes/CommandCooldownManager';
 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/types/builders';
 export * from './reciple/types/commands';
+export * from './reciple/types/paramOptions';
 export * from './reciple/permissions';
 export * from './reciple/flags';
-export * from './reciple/isIgnoredChannel';
 export * from './reciple/logger';
 export * from './reciple/modules';
 export * from './reciple/registerInteractionCommands';

package/bin/index.js

@@ -16,15 +16,16 @@ 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/CommandCooldownManager"), 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/types/builders"), exports);
 __exportStar(require("./reciple/types/commands"), exports);
+__exportStar(require("./reciple/types/paramOptions"), exports);
 __exportStar(require("./reciple/permissions"), exports);
 __exportStar(require("./reciple/flags"), exports);
-__exportStar(require("./reciple/isIgnoredChannel"), exports);
 __exportStar(require("./reciple/logger"), exports);
 __exportStar(require("./reciple/modules"), exports);
 __exportStar(require("./reciple/registerInteractionCommands"), exports);

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

@@ -1,9 +1,9 @@
+import { RecipleCommandBuilderType } from '../types/builders';
 import { Guild, TextBasedChannel, User } from 'discord.js';
-import { RecipleCommandBuilders } from '../types/builders';
 export interface CooledDownUser {
     user: User;
     command: string;
-    type: RecipleCommandBuilders["builder"];
+    type: RecipleCommandBuilderType;
     guild?: Guild | null;
     channel?: TextBasedChannel;
     expireTime: number;

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

@@ -1,20 +1,21 @@
+import { RecipleCommandBuilders, RecipleCommandBuilderType } from '../types/builders';
 import { InteractionCommandBuilder, RecipleInteractionCommandExecuteData } from './builders/InteractionCommandBuilder';
 import { MessageCommandBuilder, RecipleMessageCommandExecuteData } from './builders/MessageCommandBuilder';
 import { InteractionBuilder } from '../registerInteractionCommands';
-import { RecipleCommandBuilders } from '../types/builders';
 import { CommandCooldownManager } from './CommandCooldownManager';
-import { RecipleModule, RecipleScript } from '../modules';
 import { Logger as ILogger } from 'fallout-utility';
+import { AddModuleOptions } from '../types/paramOptions';
+import { RecipleModule } from '../modules';
 import { Config } from './RecipleConfig';
-import { ApplicationCommandDataResolvable, Awaitable, Client, ClientEvents, ClientOptions, CommandInteraction, Interaction, Message } from 'discord.js';
+import { ApplicationCommandData, Awaitable, Client, ClientEvents, ClientOptions, CommandInteraction, Interaction, Message } from 'discord.js';
 export interface RecipleClientOptions extends ClientOptions {
     config?: Config;
 }
 export interface RecipleClientCommands {
-    MESSAGE_COMMANDS: {
+    messageCommands: {
         [commandName: string]: MessageCommandBuilder;
     };
-    INTERACTION_COMMANDS: {
+    interactionCommands: {
         [commandName: string]: InteractionCommandBuilder;
     };
 }
@@ -39,14 +40,14 @@ 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: (InteractionBuilder | ApplicationCommandDataResolvable)[];
+    otherApplicationCommandData: (InteractionBuilder | ApplicationCommandData)[];
     commandCooldowns: CommandCooldownManager;
     modules: RecipleModule[];
     logger: ILogger;
     version: string;
     constructor(options: RecipleClientOptions);
     /**
-     * Load modules
+     * Load modules from modules folder
      */
     startModules(folder?: string): Promise<RecipleClient<Ready>>;
     /**
@@ -56,7 +57,7 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
     /**
      * Add module
      */
-    addModule(script: RecipleScript, registerCommands?: boolean, info?: RecipleModule['info']): Promise<void>;
+    addModule(options: AddModuleOptions): Promise<void>;
     /**
      * Add interaction or message command to client
      */
@@ -80,8 +81,8 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
     /**
      * Get command builder by name or alias if it's a message command
      */
-    findCommand(command: string, type: MessageCommandBuilder["builder"]): MessageCommandBuilder | undefined;
-    findCommand(command: string, type: InteractionCommandBuilder["builder"]): InteractionCommandBuilder | undefined;
+    findCommand(command: string, type: RecipleCommandBuilderType.MessageCommand): MessageCommandBuilder | undefined;
+    findCommand(command: string, type: RecipleCommandBuilderType.InteractionCommand): InteractionCommandBuilder | undefined;
     /**
      * Returns true if client logs is enabled
      */

package/bin/reciple/classes/RecipleClient.js

@@ -11,14 +11,15 @@ 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 builders_1 = require("../types/builders");
 const permissions_1 = require("../permissions");
+const registerInteractionCommands_1 = require("../registerInteractionCommands");
 const CommandCooldownManager_1 = require("./CommandCooldownManager");
 const MessageCommandOptionManager_1 = require("./MessageCommandOptionManager");
-const modules_1 = require("../modules");
 const fallout_utility_1 = require("fallout-utility");
+const commands_1 = require("../types/commands");
+const modules_1 = require("../modules");
 const RecipleConfig_1 = require("./RecipleConfig");
-const isIgnoredChannel_1 = require("../isIgnoredChannel");
 const version_1 = require("../version");
 const logger_1 = require("../logger");
 const discord_js_1 = require("discord.js");
@@ -27,7 +28,7 @@ class RecipleClient extends discord_js_1.Client {
         var _a, _b, _c;
         super(options);
         this.config = RecipleConfig_1.RecipleConfig.getDefaultConfig();
-        this.commands = { MESSAGE_COMMANDS: {}, INTERACTION_COMMANDS: {} };
+        this.commands = { messageCommands: {}, interactionCommands: {} };
         this.otherApplicationCommandData = [];
         this.commandCooldowns = new CommandCooldownManager_1.CommandCooldownManager();
         this.modules = [];
@@ -40,7 +41,7 @@ class RecipleClient extends discord_js_1.Client {
             this.logger.logFile(this.config.fileLogging.logFilePath, false);
     }
     /**
-     * Load modules
+     * Load modules from modules folder
      */
     startModules(folder) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -79,11 +80,15 @@ class RecipleClient extends discord_js_1.Client {
             }
             if (this.isClientLogsEnabled()) {
                 this.logger.info(`${this.modules.length} modules loaded.`);
-                this.logger.info(`${Object.keys(this.commands.MESSAGE_COMMANDS).length} message commands loaded.`);
-                this.logger.info(`${Object.keys(this.commands.INTERACTION_COMMANDS).length} interaction commands loaded.`);
+                this.logger.info(`${Object.keys(this.commands.messageCommands).length} message commands loaded.`);
+                this.logger.info(`${Object.keys(this.commands.interactionCommands).length} interaction commands loaded.`);
             }
             if (this.config.commands.interactionCommand.registerCommands) {
-                yield (0, registerInteractionCommands_1.registerInteractionCommands)(this, [...Object.values(this.commands.INTERACTION_COMMANDS), ...this.otherApplicationCommandData]);
+                yield (0, registerInteractionCommands_1.registerInteractionCommands)({
+                    client: this,
+                    commands: [...Object.values(this.commands.interactionCommands), ...this.otherApplicationCommandData],
+                    guilds: this.config.commands.interactionCommand.guilds
+                });
             }
             return this;
         });
@@ -91,9 +96,12 @@ class RecipleClient extends discord_js_1.Client {
     /**
      * Add module
      */
-    addModule(script, registerCommands = true, info) {
+    addModule(options) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            const { script } = options;
+            const registerCommands = options.registerInteractionCommands;
+            const info = options.moduleInfo;
             this.modules.push({
                 script,
                 info: Object.assign({ filename: undefined, versions: typeof script.versions == 'string' ? [script.versions] : script.versions, path: undefined }, info)
@@ -107,9 +115,12 @@ class RecipleClient extends discord_js_1.Client {
                     continue;
                 this.addCommand(command);
             }
-            if (!registerCommands || !this.config.commands.interactionCommand.registerCommands)
-                return;
-            yield (0, registerInteractionCommands_1.registerInteractionCommands)(this, [...Object.values(this.commands.INTERACTION_COMMANDS), ...this.otherApplicationCommandData]);
+            if (registerCommands)
+                yield (0, registerInteractionCommands_1.registerInteractionCommands)({
+                    client: this,
+                    commands: [...Object.values(this.commands.interactionCommands), ...this.otherApplicationCommandData],
+                    guilds: this.config.commands.interactionCommand.guilds
+                });
         });
     }
     /**
@@ -117,11 +128,11 @@ class RecipleClient extends discord_js_1.Client {
      */
     addCommand(command) {
         var _a;
-        if (command.builder === 'MESSAGE_COMMAND') {
-            this.commands.MESSAGE_COMMANDS[command.name] = command;
+        if (command.builder === builders_1.RecipleCommandBuilderType.MessageCommand) {
+            this.commands.messageCommands[command.name] = command;
         }
-        else if (command.builder === 'INTERACTION_COMMAND') {
-            this.commands.INTERACTION_COMMANDS[command.name] = command;
+        else if (command.builder === builders_1.RecipleCommandBuilderType.InteractionCommand) {
+            this.commands.interactionCommands[command.name] = command;
         }
         else if (this.isClientLogsEnabled()) {
             this.logger.error(`Unknow command "${(_a = typeof command) !== null && _a !== void 0 ? _a : 'unknown'}".`);
@@ -146,10 +157,10 @@ class RecipleClient extends discord_js_1.Client {
         return __awaiter(this, void 0, void 0, function* () {
             if (!message.content || !this.isReady())
                 return;
-            const parseCommand = (0, fallout_utility_1.getCommand)(message.content, prefix || this.config.prefix || '!', this.config.commands.messageCommand.commandArgumentSeparator || ' ');
+            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, 'MESSAGE_COMMAND');
+            const command = this.findCommand(parseCommand.command, builders_1.RecipleCommandBuilderType.MessageCommand);
             if (!command)
                 return;
             const commandOptions = command.getCommandOptionValues(parseCommand);
@@ -160,28 +171,28 @@ class RecipleClient extends discord_js_1.Client {
                 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'
+            if ((0, permissions_1.userHasCommandPermissions)(command.name, (_a = message.member) === null || _a === void 0 ? void 0 : _a.permissions, this.config.commands.messageCommand.permissions, command)) {
+                if (!command.allowExecuteInDM && message.channel.type === discord_js_1.ChannelType.DM
                     || !command.allowExecuteByBots
                         && (message.author.bot || message.author.system)
-                    || (0, isIgnoredChannel_1.isIgnoredChannel)(message.channelId, this.config.ignoredChannels))
+                    || (0, permissions_1.isIgnoredChannel)(message.channelId, this.config.ignoredChannels))
                     return;
                 if (command.validateOptions) {
                     if (commandOptions.some(o => o.invalid)) {
-                        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)) }))) {
+                        if (!(command === null || command === void 0 ? void 0 : command.halt) || !(yield command.halt({ executeData, reason: commands_1.RecipleHaltedCommandReason.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 (!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));
+                        if (!command.halt || !(yield command.halt({ executeData, reason: commands_1.RecipleHaltedCommandReason.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 (!command.halt || !(yield command.halt({ executeData, reason: 'MISSING_BOT_PERMISSIONS' }))) {
+                    if (!command.halt || !(yield command.halt({ executeData, reason: commands_1.RecipleHaltedCommandReason.MissingBotPermissions }))) {
                         message.reply(this.getMessage('insufficientBotPerms', 'Insufficient bot permissions.')).catch(er => this._replyError(er));
                     }
                     return;
@@ -191,29 +202,30 @@ class RecipleClient extends discord_js_1.Client {
                     command: command.name,
                     channel: message.channel,
                     guild: message.guild,
-                    type: 'MESSAGE_COMMAND'
+                    type: builders_1.RecipleCommandBuilderType.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 (!command.halt || !(yield command.halt(Object.assign({ executeData, reason: 'COOLDOWN' }, this.commandCooldowns.get(userCooldown))))) {
+                    if (!command.halt || !(yield command.halt(Object.assign({ executeData, reason: commands_1.RecipleHaltedCommandReason.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);
+                    yield Promise.resolve(command.execute(executeData))
+                        .then(() => this.emit('recipleMessageCommandCreate', executeData))
+                        .catch((err) => __awaiter(this, void 0, void 0, function* () { return !command.halt || !(yield command.halt({ executeData, reason: commands_1.RecipleHaltedCommandReason.Error, error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
                     return executeData;
                 }
                 catch (err) {
-                    if (!command.halt || !(yield command.halt({ executeData, reason: 'ERROR', error: err }))) {
+                    if (!command.halt || !(yield command.halt({ executeData, reason: commands_1.RecipleHaltedCommandReason.Error, error: err }))) {
                         this._commandExecuteError(err, executeData);
                     }
                 }
             }
-            else if (!command.halt || !(yield command.halt({ executeData, reason: 'MISSING_MEMBER_PERMISSIONS' }))) {
+            else if (!command.halt || !(yield command.halt({ executeData, reason: commands_1.RecipleHaltedCommandReason.MissingMemberPermissions }))) {
                 message.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this._replyError(er));
             }
         });
@@ -224,9 +236,9 @@ class RecipleClient extends discord_js_1.Client {
     interactionCommandExecute(interaction) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            if (!interaction || !interaction.isCommand() || !this.isReady())
+            if (!interaction || interaction.type !== discord_js_1.InteractionType.ApplicationCommand || !this.isReady())
                 return;
-            const command = this.findCommand(interaction.commandName, 'INTERACTION_COMMAND');
+            const command = this.findCommand(interaction.commandName, builders_1.RecipleCommandBuilderType.InteractionCommand);
             if (!command)
                 return;
             const executeData = {
@@ -234,11 +246,11 @@ class RecipleClient extends discord_js_1.Client {
                 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))
+            if ((0, permissions_1.userHasCommandPermissions)(command.name, (_a = interaction.memberPermissions) !== null && _a !== void 0 ? _a : undefined, this.config.commands.interactionCommand.permissions, command)) {
+                if (!command || (0, permissions_1.isIgnoredChannel)(interaction.channelId, this.config.ignoredChannels))
                     return;
                 if (interaction.guild && !(0, permissions_1.botHasExecutePermissions)(interaction.guild, command.requiredBotPermissions)) {
-                    if (!command.halt || !(yield command.halt({ executeData, reason: 'MISSING_BOT_PERMISSIONS' }))) {
+                    if (!command.halt || !(yield command.halt({ executeData, reason: commands_1.RecipleHaltedCommandReason.MissingBotPermissions }))) {
                         yield interaction.reply(this.getMessage('insufficientBotPerms', 'Insufficient bot permissions.')).catch(er => this._replyError(er));
                     }
                     return;
@@ -248,29 +260,30 @@ class RecipleClient extends discord_js_1.Client {
                     command: command.name,
                     channel: (_b = interaction.channel) !== null && _b !== void 0 ? _b : undefined,
                     guild: interaction.guild,
-                    type: 'INTERACTION_COMMAND'
+                    type: builders_1.RecipleCommandBuilderType.InteractionCommand
                 };
                 if (this.config.commands.interactionCommand.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.interactionCommand.enableCooldown && command.cooldown) {
-                    if (!command.halt || !(yield command.halt(Object.assign({ executeData, reason: 'COOLDOWN' }, this.commandCooldowns.get(userCooldown))))) {
+                    if (!command.halt || !(yield command.halt(Object.assign({ executeData, reason: commands_1.RecipleHaltedCommandReason.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);
+                    yield Promise.resolve(command.execute(executeData))
+                        .then(() => this.emit('recipleInteractionCommandCreate', executeData))
+                        .catch((err) => __awaiter(this, void 0, void 0, function* () { return !command.halt || !(yield command.halt({ executeData, reason: commands_1.RecipleHaltedCommandReason.Error, error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
                     return executeData;
                 }
                 catch (err) {
-                    if (!command.halt || !(yield command.halt({ executeData, reason: 'ERROR', error: err }))) {
+                    if (!command.halt || !(yield command.halt({ executeData, reason: commands_1.RecipleHaltedCommandReason.Error, error: err }))) {
                         this._commandExecuteError(err, executeData);
                     }
                 }
             }
-            else if (!command.halt || !(yield command.halt({ executeData, reason: 'MISSING_MEMBER_PERMISSIONS' }))) {
+            else if (!command.halt || !(yield command.halt({ executeData, reason: commands_1.RecipleHaltedCommandReason.MissingMemberPermissions }))) {
                 yield interaction.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this._replyError(er));
             }
         });
@@ -285,11 +298,11 @@ class RecipleClient extends discord_js_1.Client {
     findCommand(command, type) {
         var _a;
         switch (type) {
-            case 'INTERACTION_COMMAND':
-                return this.commands.INTERACTION_COMMANDS[command];
-            case 'MESSAGE_COMMAND':
-                return (_a = this.commands.MESSAGE_COMMANDS[command.toLowerCase()]) !== null && _a !== void 0 ? _a : (this.config.commands.messageCommand.allowCommandAlias
-                    ? Object.values(this.commands.MESSAGE_COMMANDS).find(c => c.aliases.some(a => a == (command === null || command === void 0 ? void 0 : command.toLowerCase())))
+            case builders_1.RecipleCommandBuilderType.InteractionCommand:
+                return this.commands.interactionCommands[command];
+            case builders_1.RecipleCommandBuilderType.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);
             default:
                 throw new TypeError('Unknown command type');
@@ -313,7 +326,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 == 'MESSAGE_COMMAND' ? 'message' : 'interaction'} command "${command.builder.name}"`);
+                this.logger.error(`An error occured executing ${command.builder.builder == builders_1.RecipleCommandBuilderType.MessageCommand ? 'message' : 'interaction'} command "${command.builder.name}"`);
                 this.logger.error(err);
             }
             if (!err || !command)

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

@@ -5,14 +5,18 @@ export interface ConfigCommandPermissions {
 }
 export interface Config {
     token: string;
-    prefix: string;
     commands: {
         messageCommand: {
             enabled: boolean;
+            prefix?: string;
             replyOnError: boolean;
             allowCommandAlias: boolean;
             enableCooldown: boolean;
             commandArgumentSeparator: string;
+            permissions: {
+                enabled: boolean;
+                commands: ConfigCommandPermissions[];
+            };
         };
         interactionCommand: {
             enabled: boolean;
@@ -20,17 +24,11 @@ export interface Config {
             registerCommands: boolean;
             enableCooldown: boolean;
             setRequiredPermissions: boolean;
-            guilds: string[] | string;
-        };
-    };
-    permissions: {
-        messageCommands: {
-            enabled: boolean;
-            commands: ConfigCommandPermissions[];
-        };
-        interactionCommands: {
-            enabled: boolean;
-            commands: ConfigCommandPermissions[];
+            guilds?: string[] | string;
+            permissions: {
+                enabled: boolean;
+                commands: ConfigCommandPermissions[];
+            };
         };
     };
     ignoredChannels: {

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

@@ -2,18 +2,19 @@ import { Awaitable, CommandInteraction, PermissionResolvable } from 'discord.js'
 import { RecipleHaltedCommandData } from '../../types/commands';
 import { SlashCommandBuilder } from '@discordjs/builders';
 import { RecipleClient } from '../RecipleClient';
+import { RecipleCommandBuilderType } from '../../types/builders';
 export interface RecipleInteractionCommandExecuteData {
     interaction: CommandInteraction;
     builder: InteractionCommandBuilder;
     client: RecipleClient<true>;
 }
 export declare class InteractionCommandBuilder extends SlashCommandBuilder {
-    readonly builder = "INTERACTION_COMMAND";
+    readonly builder = RecipleCommandBuilderType.InteractionCommand;
     cooldown: number;
     requiredBotPermissions: PermissionResolvable[];
     RequiredUserPermissions: PermissionResolvable[];
     allowExecuteInDM: boolean;
-    halt?: (haltData: RecipleHaltedCommandData<InteractionCommandBuilder>) => Awaitable<boolean>;
+    halt?: (haltData: RecipleHaltedCommandData<InteractionCommandBuilder>) => Awaitable<boolean | void>;
     execute: (executeData: RecipleInteractionCommandExecuteData) => Awaitable<void>;
     /**
      * Sets the execute cooldown for this command.
@@ -27,7 +28,7 @@ export declare class InteractionCommandBuilder extends SlashCommandBuilder {
     /**
      * Function when the command is interupted before execution
      */
-    setHalt(halt?: (haltData: RecipleHaltedCommandData<InteractionCommandBuilder>) => Awaitable<boolean>): InteractionCommandBuilder;
+    setHalt(halt?: (haltData: RecipleHaltedCommandData<InteractionCommandBuilder>) => Awaitable<boolean | void>): InteractionCommandBuilder;
     /**
      * Function when the command is executed
      */

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

@@ -2,10 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InteractionCommandBuilder = void 0;
 const builders_1 = require("@discordjs/builders");
+const builders_2 = require("../../types/builders");
 class InteractionCommandBuilder extends builders_1.SlashCommandBuilder {
     constructor() {
         super(...arguments);
-        this.builder = 'INTERACTION_COMMAND';
+        this.builder = builders_2.RecipleCommandBuilderType.InteractionCommand;
         this.cooldown = 0;
         this.requiredBotPermissions = [];
         this.RequiredUserPermissions = [];

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

@@ -4,6 +4,7 @@ import { Awaitable, Message, PermissionResolvable } from 'discord.js';
 import { RecipleHaltedCommandData } from '../../types/commands';
 import { Command as CommandMessage } from 'fallout-utility';
 import { RecipleClient } from '../RecipleClient';
+import { RecipleCommandBuilderType } from '../../types/builders';
 export interface RecipleMessageCommandExecuteData {
     message: Message;
     options: MessageCommandOptionManager;
@@ -19,7 +20,7 @@ export interface MessageCommandValidatedOption {
     missing: boolean;
 }
 export declare class MessageCommandBuilder {
-    readonly builder = "MESSAGE_COMMAND";
+    readonly builder = RecipleCommandBuilderType.MessageCommand;
     name: string;
     cooldown: number;
     description: string;
@@ -30,7 +31,7 @@ export declare class MessageCommandBuilder {
     RequiredUserPermissions: PermissionResolvable[];
     allowExecuteInDM: boolean;
     allowExecuteByBots: boolean;
-    halt?: (haltData: RecipleHaltedCommandData<MessageCommandBuilder>) => Awaitable<boolean>;
+    halt?: (haltData: RecipleHaltedCommandData<MessageCommandBuilder>) => Awaitable<boolean | void>;
     execute: (executeData: RecipleMessageCommandExecuteData) => void;
     /**
      * Sets the command name
@@ -68,7 +69,7 @@ export declare class MessageCommandBuilder {
     /**
      * Function when the command is interupted before execution
      */
-    setHalt(halt?: (haltData: RecipleHaltedCommandData<MessageCommandBuilder>) => Awaitable<boolean>): MessageCommandBuilder;
+    setHalt(halt?: (haltData: RecipleHaltedCommandData<MessageCommandBuilder>) => Awaitable<boolean | void>): MessageCommandBuilder;
     /**
      * Function when the command is executed
      */

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

@@ -2,9 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MessageCommandBuilder = void 0;
 const MessageCommandOptionBuilder_1 = require("./MessageCommandOptionBuilder");
+const builders_1 = require("../../types/builders");
 class MessageCommandBuilder {
     constructor() {
-        this.builder = 'MESSAGE_COMMAND';
+        this.builder = builders_1.RecipleCommandBuilderType.MessageCommand;
         this.name = '';
         this.cooldown = 0;
         this.description = '';

package/bin/reciple/modules.js

@@ -13,6 +13,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadModules = void 0;
+const builders_1 = require("./types/builders");
 const fs_1 = require("fs");
 const version_1 = require("./version");
 const wildcard_match_1 = __importDefault(require("wildcard-match"));
@@ -47,8 +48,9 @@ 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 === 'MESSAGE_COMMAND' || command.builder === 'INTERACTION_COMMAND')
+                        if (command.builder === builders_1.RecipleCommandBuilderType.MessageCommand || command.builder === builders_1.RecipleCommandBuilderType.InteractionCommand) {
                             commands.push(command);
+                        }
                     }
                 }
             }
@@ -65,7 +67,7 @@ function loadModules(client, folder) {
                         client.logger.error(`A ${c.builder} command name is not defined in ${script}`);
                     return false;
                 }
-                if (c.builder === 'MESSAGE_COMMAND' && c.options.length && c.options.some(o => !o.name)) {
+                if (c.builder === builders_1.RecipleCommandBuilderType.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,8 +1,15 @@
-import { Guild, PermissionResolvable, Permissions } from 'discord.js';
+import { Guild, PermissionResolvable, PermissionsBitField } from 'discord.js';
 import { RecipleCommandBuilders } from './types/builders';
 import { Config } from './classes/RecipleConfig';
 /**
  * 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 userHasCommandPermissions(commandName: string, memberPermissions?: PermissionsBitField, configConmmandPermissions?: Config['commands']['messageCommand']['permissions'] | Config['commands']['interactionCommand']['permissions'], builder?: RecipleCommandBuilders): boolean;
+/**
+ * Check if the bot has the required permissions in a guild
+ */
 export declare function botHasExecutePermissions(guild?: Guild, requiredPermissions?: PermissionResolvable[]): boolean;
+/**
+ * Check if the channel id is ignored in config file
+ */
+export declare function isIgnoredChannel(channelId: string, ignoredChannelsConfig?: Config["ignoredChannels"]): boolean;

package/bin/reciple/permissions.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.botHasExecutePermissions = exports.userHasCommandPermissions = void 0;
+exports.isIgnoredChannel = exports.botHasExecutePermissions = exports.userHasCommandPermissions = void 0;
 /**
  * Check if the user has permissions to execute the given command name
  */
@@ -14,10 +14,26 @@ function userHasCommandPermissions(commandName, memberPermissions, configConmman
     return memberPermissions ? memberPermissions.has(command.permissions) : false;
 }
 exports.userHasCommandPermissions = userHasCommandPermissions;
+/**
+ * Check if the bot has the required permissions in a guild
+ */
 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;
+    return (guild === null || guild === void 0 ? void 0 : guild.members.me) ? (_a = guild.members.me) === null || _a === void 0 ? void 0 : _a.permissions.has(requiredPermissions) : false;
 }
 exports.botHasExecutePermissions = botHasExecutePermissions;
+/**
+ * Check if the channel id is ignored in config file
+ */
+function isIgnoredChannel(channelId, ignoredChannelsConfig) {
+    if (!(ignoredChannelsConfig === null || ignoredChannelsConfig === void 0 ? void 0 : ignoredChannelsConfig.enabled))
+        return false;
+    if (ignoredChannelsConfig.channels.includes(channelId) && !ignoredChannelsConfig.convertToAllowList)
+        return true;
+    if (!ignoredChannelsConfig.channels.includes(channelId) && ignoredChannelsConfig.convertToAllowList)
+        return true;
+    return false;
+}
+exports.isIgnoredChannel = isIgnoredChannel;

package/bin/reciple/registerInteractionCommands.d.ts

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

package/bin/reciple/registerInteractionCommands.js

@@ -10,33 +10,36 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerInteractionCommands = void 0;
+const InteractionCommandBuilder_1 = require("./classes/builders/InteractionCommandBuilder");
 /**
  * Register interaction commands
  */
-function registerInteractionCommands(client, cmds, overwriteGuilds) {
-    var _a, _b, _c;
+function registerInteractionCommands(options) {
+    var _a, _b, _c, _d;
     return __awaiter(this, void 0, void 0, function* () {
-        const commands = (_a = Object.values(cmds !== null && cmds !== void 0 ? cmds : client.commands.INTERACTION_COMMANDS).map(c => {
-            var _a, _b, _c, _d;
-            if (typeof c.toJSON == 'undefined')
-                return c;
-            const cmd = c;
-            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.requiredBotPermissions;
+        const client = options.client;
+        const guilds = typeof options.guilds == 'string' ? [options.guilds] : options.guilds;
+        const commands = (_b = Object.values((_a = options.commands) !== null && _a !== void 0 ? _a : client.commands.interactionCommands).map(cmd => {
+            var _a, _b;
+            if (typeof (cmd === null || cmd === void 0 ? void 0 : cmd.toJSON) == 'undefined')
+                return cmd;
+            cmd = cmd;
+            if (cmd instanceof InteractionCommandBuilder_1.InteractionCommandBuilder && client.config.commands.interactionCommand.setRequiredPermissions) {
+                const permissions = (_b = (client.config.commands.interactionCommand.permissions.enabled ?
+                    (_a = client.config.commands.interactionCommand.permissions.commands.find(cmd_ => cmd_.command.toLowerCase() === cmd.name.toLowerCase())) === null || _a === void 0 ? void 0 : _a.permissions :
+                    undefined)) !== null && _b !== void 0 ? _b : cmd.requiredBotPermissions;
                 cmd.setRequiredMemberPermissions(permissions);
-                client.commands.INTERACTION_COMMANDS[cmd.name] = cmd;
+                client.commands.interactionCommands[cmd.name] = cmd;
                 if (client.isClientLogsEnabled())
                     client.logger.debug(`Set required permissions for ${cmd.name}`);
                 return cmd.toJSON();
             }
-            return c.toJSON();
-        })) !== null && _a !== void 0 ? _a : [];
-        const configGuilds = overwriteGuilds !== null && overwriteGuilds !== void 0 ? overwriteGuilds : client.config.commands.interactionCommand.guilds;
-        const guilds = typeof configGuilds === 'object' ? configGuilds : [configGuilds];
+            return cmd.toJSON();
+        })) !== null && _b !== void 0 ? _b : [];
+        if (!client.isReady())
+            throw new Error('Client is not ready');
         if (!guilds || !(guilds === null || guilds === void 0 ? void 0 : guilds.length)) {
-            (_b = client.application) === null || _b === void 0 ? void 0 : _b.commands.set(commands).then(() => {
+            (_c = client.application) === null || _c === void 0 ? void 0 : _c.commands.set(commands).then(() => {
                 if (client.isClientLogsEnabled())
                     client.logger.warn('No guilds were specified for interaction commands. Registered interaction commands globally.');
             });
@@ -47,7 +50,7 @@ function registerInteractionCommands(client, cmds, overwriteGuilds) {
             for (const guild of guilds) {
                 if (!guild)
                     continue;
-                (_c = client.application) === null || _c === void 0 ? void 0 : _c.commands.set(commands, guild).then(() => {
+                (_d = client.application) === null || _d === void 0 ? void 0 : _d.commands.set(commands, guild).then(() => {
                     if (client.isClientLogsEnabled())
                         client.logger.warn(`Registered ${commands.length} interaction command(s) for ${guild}.`);
                 });

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

@@ -2,3 +2,7 @@ import { InteractionCommandBuilder, RecipleInteractionCommandExecuteData } from
 import { MessageCommandBuilder, RecipleMessageCommandExecuteData } from '../classes/builders/MessageCommandBuilder';
 export declare type RecipleCommandBuilders = MessageCommandBuilder | InteractionCommandBuilder;
 export declare type RecipleCommandBuildersExecuteData = RecipleInteractionCommandExecuteData | RecipleMessageCommandExecuteData;
+export declare enum RecipleCommandBuilderType {
+    MessageCommand = 0,
+    InteractionCommand = 1
+}

package/bin/reciple/types/builders.js

@@ -1,2 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecipleCommandBuilderType = void 0;
+var RecipleCommandBuilderType;
+(function (RecipleCommandBuilderType) {
+    RecipleCommandBuilderType[RecipleCommandBuilderType["MessageCommand"] = 0] = "MessageCommand";
+    RecipleCommandBuilderType[RecipleCommandBuilderType["InteractionCommand"] = 1] = "InteractionCommand";
+})(RecipleCommandBuilderType = exports.RecipleCommandBuilderType || (exports.RecipleCommandBuilderType = {}));

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

@@ -3,29 +3,36 @@ import { RecipleMessageCommandExecuteData } from '../classes/builders/MessageCom
 import { MessageCommandOptionManager } from '../classes/MessageCommandOptionManager';
 import { CooledDownUser } from '../classes/CommandCooldownManager';
 import { RecipleCommandBuilders } from '../types/builders';
-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 declare type RecipleHaltedCommandData<Builder extends RecipleCommandBuilders> = CommandErrorData<Builder> | CommandCooldownData<Builder> | (Builder extends InteractionCommandBuilder ? never : 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';
+    reason: RecipleHaltedCommandReason.Error;
     error: any;
 }
 export interface CommandCooldownData<Builder extends RecipleCommandBuilders> extends CommandHaltBaseData<Builder>, CooledDownUser {
-    reason: 'COOLDOWN';
+    reason: RecipleHaltedCommandReason.Cooldown;
 }
 export interface CommandInvalidArguments<Builder extends RecipleCommandBuilders> extends CommandHaltBaseData<Builder> {
-    reason: 'INVALID_ARGUMENTS';
+    reason: RecipleHaltedCommandReason.InvalidArguments;
     invalidArguments: MessageCommandOptionManager;
 }
 export interface CommandMissingArguments<Builder extends RecipleCommandBuilders> extends CommandHaltBaseData<Builder> {
-    reason: 'MISSING_ARGUMENTS';
+    reason: RecipleHaltedCommandReason.MissingArguments;
     missingArguments: MessageCommandOptionManager;
 }
 export interface CommandMissingMemberPermissions<Builder extends RecipleCommandBuilders> extends CommandHaltBaseData<Builder> {
-    reason: 'MISSING_MEMBER_PERMISSIONS';
+    reason: RecipleHaltedCommandReason.MissingMemberPermissions;
 }
 export interface CommandMissingBotPermissions<Builder extends RecipleCommandBuilders> extends CommandHaltBaseData<Builder> {
-    reason: 'MISSING_BOT_PERMISSIONS';
+    reason: RecipleHaltedCommandReason.MissingBotPermissions;
+}
+export declare enum RecipleHaltedCommandReason {
+    Error = 0,
+    Cooldown = 1,
+    InvalidArguments = 2,
+    MissingArguments = 3,
+    MissingMemberPermissions = 4,
+    MissingBotPermissions = 5
 }

package/bin/reciple/types/commands.js

@@ -1,2 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecipleHaltedCommandReason = void 0;
+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 = {}));

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

@@ -0,0 +1,32 @@
+import { InteractionBuilder } from '../registerInteractionCommands';
+import { RecipleModule, RecipleScript } from '../modules';
+import { RecipleClient } from '../classes/RecipleClient';
+import { ApplicationCommandData } from 'discord.js';
+export interface AddModuleOptions {
+    /**
+     * The Module script
+     */
+    script: RecipleScript;
+    /**
+     * Register interaction commands if possible
+     */
+    registerInteractionCommands?: boolean;
+    /**
+     * Module optional info
+     */
+    moduleInfo?: RecipleModule["info"];
+}
+export interface RegisterInteractionCommandsOptions {
+    /**
+     * Bot client
+     */
+    client: RecipleClient;
+    /**
+     * Commands to register
+     */
+    commands: (ApplicationCommandData | InteractionBuilder)[];
+    /**
+     * Set guild to not register commands globally
+     */
+    guilds?: string | string[];
+}

package/bin/reciple/types/paramOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,12 +1,19 @@
 {
   "name": "reciple",
-  "version": "2.0.2",
+  "version": "3.0.1",
   "description": "Handler for Discord.js",
   "author": "FalloutStudios",
   "homepage": "https://reciple.js.org",
+  "contributors": [
+    "GhexterCortes <cortesghexter@gmail.com>"
+  ],
   "bugs": {
     "url": "https://github.com/FalloutStudios/reciple/issues"
   },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/FalloutStudios/reciple.git"
+  },
   "license": "GPL-3.0",
   "main": "bin/index.js",
   "bin": {
@@ -36,7 +43,7 @@
   },
   "dependencies": {
     "chalk": "4.1.2",
-    "commander": "^9.3.0",
+    "commander": "^9.4.0",
     "dotenv": "^16.0.1",
     "fallout-utility": "^1.4.2",
     "semver": "^7.3.7",
@@ -44,12 +51,13 @@
     "yaml": "^2.1.1"
   },
   "devDependencies": {
-    "@types/node": "^18.0.3",
+    "@types/node": "^18.0.6",
     "@types/semver": "^7.3.10",
-    "discord.js": "^13.8.1",
+    "discord.js": "^14.0.3",
     "typescript": "^4.7.4"
   },
   "peerDependencies": {
-    "discord.js": "13.8.x"
-  }
+    "discord.js": "14.0.x"
+  },
+  "packageManager": "yarn@1.22.19"
 }

package/resource/reciple.yml

@@ -2,52 +2,49 @@
 # To use env variable as a token just do it like this env:TOKEN_ENV
 token: TOKEN
 
-# Message command prefix
-prefix: '!'
-
 
 # Commands options
 commands:
   messageCommand:
     # enable message commands
     enabled: true
+    # command prefix
+    prefix: '!'
     # reply when an error occured
     replyOnError: false
     # Enable the use of command cooldowns
-    enableCooldown: false
+    enableCooldown: true
     # Allow executing commands via aliases
     allowCommandAlias: true
     # command argument separator
     commandArgumentSeparator: ' '
+    # Overwrite command permissions
+    permissions:
+      # enable overwriten command permissions
+      enabled: false
+      commands:
+        - command: 'example-command'
+          permissions: ['Administrator']
   interactionCommand:
     # enable interaction commands
     enabled: true
     # reply when an error occured
     replyOnError: false
     # Enable the use of command cooldowns
-    enableCooldown: false
+    enableCooldown: true
     # register interaction commands on bot ready
     registerCommands: true
     # set required permissions for interaction commands
     setRequiredPermissions: true
     # register commands to specific guild(s) empty to make it global
     guilds: []
-
-
-# Commands permissions
-permissions:
-  messageCommands:
-    # enable command permissions
-    enabled: true
-    commands:
-      - command: 'stop'
-        permissions: ['ADMINISTRATOR']
-  interactionCommands:
-    # enable command permissions
-    enabled: true
-    commands:
-      - command: 'stop'
-        permissions: ['ADMINISTRATOR']
+    # Overwrite command permissions
+    permissions:
+      # enable overwriten command permissions
+      enabled: false
+      commands:
+        - command: 'example-command'
+          permissions: ['Administrator']
 
 
 # Ignored channel IDs
@@ -76,13 +73,14 @@ fileLogging:
 # Client options
 client:
   intents:
-    - 'GUILDS'
-    - 'GUILD_MEMBERS'
-    - 'GUILD_MESSAGES'
+    - 'Guilds'
+    - 'GuildMembers'
+    - 'GuildMessages'
+    - 'MessageContent'
 
 # Bot replies
 messages:
-  notEnoughArguments: 'Not enough arguments.'
+  missingArguments: 'Not enough arguments.'
   invalidArguments: 'Invalid argument(s) given.'
   insufficientBotPerms:
     content: 'Insufficient bot permissions.'

package/bin/reciple/isIgnoredChannel.d.ts

@@ -1,5 +0,0 @@
-import { Config } from './classes/RecipleConfig';
-/**
- * Check if the channel id is ignored in config file
- */
-export declare function isIgnoredChannel(channelId: string, ignoredChannelsConfig?: Config["ignoredChannels"]): boolean;

package/bin/reciple/isIgnoredChannel.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isIgnoredChannel = void 0;
-/**
- * Check if the channel id is ignored in config file
- */
-function isIgnoredChannel(channelId, ignoredChannelsConfig) {
-    if (!(ignoredChannelsConfig === null || ignoredChannelsConfig === void 0 ? void 0 : ignoredChannelsConfig.enabled))
-        return false;
-    if (ignoredChannelsConfig.channels.includes(channelId) && !ignoredChannelsConfig.convertToAllowList)
-        return true;
-    if (!ignoredChannelsConfig.channels.includes(channelId) && ignoredChannelsConfig.convertToAllowList)
-        return true;
-    return false;
-}
-exports.isIgnoredChannel = isIgnoredChannel;