reciple 4.1.2 → 5.0.0-pre.3

package/bin/bin.js

@@ -46,6 +46,9 @@ if (config.fileLogging.clientLogs)
         var _e;
         if (client.isClientLogsEnabled())
             client.logger.warn(`Logged in as ${((_e = client.user) === null || _e === void 0 ? void 0 : _e.tag) || 'Unknown'}!`);
+        client.on('cacheSweep', () => {
+            client.cooldowns.clean();
+        });
         yield client.loadModules();
         client.addCommandListeners();
     }));

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

@@ -1,7 +1,7 @@
 import { MessageCommandBuilder, MessageCommandExecuteData } from './builders/MessageCommandBuilder';
-import { ApplicationCommandBuilder } from '../registerApplicationCommands';
-import { CommandBuilder, CommandBuilderType } from '../types/builders';
 import { SlashCommandBuilder, SlashCommandExecuteData } from './builders/SlashCommandBuilder';
+import { ApplicationCommandBuilder } from '../registerApplicationCommands';
+import { AnyCommandBuilder, CommandBuilderType } from '../types/builders';
 import { CommandCooldownManager } from './CommandCooldownManager';
 import { RecipleClientAddModuleOptions } from '../types/paramOptions';
 import { Logger as ILogger } from 'fallout-utility';
@@ -53,7 +53,7 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
     config: Config;
     commands: RecipleClientCommands;
     otherApplicationCommandData: (ApplicationCommandBuilder | ApplicationCommandData)[];
-    commandCooldowns: CommandCooldownManager;
+    cooldowns: CommandCooldownManager;
     modules: RecipleModule[];
     logger: ILogger;
     version: string;
@@ -79,7 +79,7 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
      * Add slash or message command to client
      * @param command Slash/Message command builder
      */
-    addCommand(command: CommandBuilder): RecipleClient<Ready>;
+    addCommand(command: AnyCommandBuilder): RecipleClient<Ready>;
     /**
      * Listed to command executions
      */

package/bin/reciple/classes/RecipleClient.js

@@ -11,9 +11,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RecipleClient = void 0;
 const MessageCommandBuilder_1 = require("./builders/MessageCommandBuilder");
-const permissions_1 = require("../permissions");
+const SlashCommandBuilder_1 = require("./builders/SlashCommandBuilder");
 const registerApplicationCommands_1 = require("../registerApplicationCommands");
 const builders_1 = require("../types/builders");
+const permissions_1 = require("../permissions");
 const CommandCooldownManager_1 = require("./CommandCooldownManager");
 const MessageCommandOptionManager_1 = require("./MessageCommandOptionManager");
 const commands_1 = require("../types/commands");
@@ -33,7 +34,7 @@ class RecipleClient extends discord_js_1.Client {
         this.config = RecipleConfig_1.RecipleConfig.getDefaultConfig();
         this.commands = { messageCommands: {}, slashCommands: {} };
         this.otherApplicationCommandData = [];
-        this.commandCooldowns = new CommandCooldownManager_1.CommandCooldownManager();
+        this.cooldowns = new CommandCooldownManager_1.CommandCooldownManager();
         this.modules = [];
         this.version = version_1.version;
         this.logger = (0, logger_1.createLogger)(!!((_a = options.config) === null || _a === void 0 ? void 0 : _a.fileLogging.stringifyLoggedJSON), (_b = options.config) === null || _b === void 0 ? void 0 : _b.fileLogging.debugmode);
@@ -134,10 +135,10 @@ class RecipleClient extends discord_js_1.Client {
      */
     addCommand(command) {
         var _a;
-        if (command.builder === builders_1.CommandBuilderType.MessageCommand) {
+        if (command.type === builders_1.CommandBuilderType.MessageCommand) {
             this.commands.messageCommands[command.name] = command;
         }
-        else if (command.builder === builders_1.CommandBuilderType.SlashCommand) {
+        else if (command.type === builders_1.CommandBuilderType.SlashCommand) {
             this.commands.slashCommands[command.name] = command;
         }
         else if (this.isClientLogsEnabled()) {
@@ -184,27 +185,24 @@ class RecipleClient extends discord_js_1.Client {
                 memberPermissions: (_a = message.member) === null || _a === void 0 ? void 0 : _a.permissions,
                 commandPermissions: this.config.commands.messageCommand.permissions
             })) {
-                if (!command.allowExecuteInDM && message.channel.type === discord_js_1.ChannelType.DM
-                    || !command.allowExecuteByBots
-                        && (message.author.bot || message.author.system)
-                    || (0, permissions_1.isIgnoredChannel)(message.channelId, this.config.ignoredChannels))
+                if (!command.allowExecuteInDM && message.channel.type === discord_js_1.ChannelType.DM || !command.allowExecuteByBots && (message.author.bot || message.author.system))
                     return;
                 if (command.validateOptions) {
                     if (commandOptions.some(o => o.invalid)) {
-                        if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.InvalidArguments, invalidArguments: new MessageCommandOptionManager_1.MessageCommandOptionManager(...executeData.options.filter(o => o.invalid)) }))) {
+                        if (!(yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.InvalidArguments, invalidArguments: new MessageCommandOptionManager_1.MessageCommandOptionManager(...executeData.options.filter(o => o.invalid)) }))) {
                             message.reply(this.getMessage('invalidArguments', 'Invalid argument(s) given.')).catch(er => this._replyError(er));
                         }
                         return;
                     }
                     if (commandOptions.some(o => o.missing)) {
-                        if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.MissingArguments, missingArguments: new MessageCommandOptionManager_1.MessageCommandOptionManager(...executeData.options.filter(o => o.missing)) }))) {
+                        if (!(yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.MissingArguments, missingArguments: new MessageCommandOptionManager_1.MessageCommandOptionManager(...executeData.options.filter(o => o.missing)) }))) {
                             message.reply(this.getMessage('missingArguments', 'Not enough arguments.')).catch(er => this._replyError(er));
                         }
                         return;
                     }
                 }
                 if (message.guild && !(0, permissions_1.botHasExecutePermissions)(message.guild, command.requiredBotPermissions)) {
-                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.MissingBotPermissions }))) {
+                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.MissingBotPermissions }))) {
                         message.reply(this.getMessage('insufficientBotPerms', 'Insufficient bot permissions.')).catch(er => this._replyError(er));
                     }
                     return;
@@ -216,11 +214,11 @@ class RecipleClient extends discord_js_1.Client {
                     guild: message.guild,
                     type: builders_1.CommandBuilderType.MessageCommand
                 };
-                if (this.config.commands.messageCommand.enableCooldown && command.cooldown && !this.commandCooldowns.isCooledDown(userCooldown)) {
-                    this.commandCooldowns.add(Object.assign(Object.assign({}, userCooldown), { expireTime: Date.now() + command.cooldown }));
+                if (this.config.commands.messageCommand.enableCooldown && command.cooldown && !this.cooldowns.isCooledDown(userCooldown)) {
+                    this.cooldowns.add(Object.assign(Object.assign({}, userCooldown), { expireTime: Date.now() + command.cooldown }));
                 }
                 else if (this.config.commands.messageCommand.enableCooldown && command.cooldown) {
-                    if (!(yield this._haltCommand(command, Object.assign({ executeData, reason: commands_1.HaltedCommandReason.Cooldown }, this.commandCooldowns.get(userCooldown))))) {
+                    if (!(yield this._haltCommand(command, Object.assign({ executeData, reason: commands_1.CommandHaltReason.Cooldown }, this.cooldowns.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;
@@ -228,16 +226,16 @@ class RecipleClient extends discord_js_1.Client {
                 try {
                     yield Promise.resolve(command.execute(executeData))
                         .then(() => this.emit('recipleMessageCommandCreate', executeData))
-                        .catch((err) => __awaiter(this, void 0, void 0, function* () { return (yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.Error, error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
+                        .catch((err) => __awaiter(this, void 0, void 0, function* () { return (yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.Error, error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
                     return executeData;
                 }
                 catch (err) {
-                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.Error, error: err }))) {
+                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.Error, error: err }))) {
                         this._commandExecuteError(err, executeData);
                     }
                 }
             }
-            else if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.MissingMemberPermissions }))) {
+            else if (!(yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.MissingMemberPermissions }))) {
                 message.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this._replyError(er));
             }
         });
@@ -264,10 +262,10 @@ class RecipleClient extends discord_js_1.Client {
                 memberPermissions: (_a = interaction.memberPermissions) !== null && _a !== void 0 ? _a : undefined,
                 commandPermissions: this.config.commands.slashCommand.permissions
             })) {
-                if (!command || (0, permissions_1.isIgnoredChannel)(interaction.channelId, this.config.ignoredChannels))
+                if (!command)
                     return;
                 if (interaction.guild && !(0, permissions_1.botHasExecutePermissions)(interaction.guild, command.requiredBotPermissions)) {
-                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.MissingBotPermissions }))) {
+                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.MissingBotPermissions }))) {
                         yield interaction.reply(this.getMessage('insufficientBotPerms', 'Insufficient bot permissions.')).catch(er => this._replyError(er));
                     }
                     return;
@@ -279,11 +277,11 @@ class RecipleClient extends discord_js_1.Client {
                     guild: interaction.guild,
                     type: builders_1.CommandBuilderType.SlashCommand
                 };
-                if (this.config.commands.slashCommand.enableCooldown && command.cooldown && !this.commandCooldowns.isCooledDown(userCooldown)) {
-                    this.commandCooldowns.add(Object.assign(Object.assign({}, userCooldown), { expireTime: Date.now() + command.cooldown }));
+                if (this.config.commands.slashCommand.enableCooldown && command.cooldown && !this.cooldowns.isCooledDown(userCooldown)) {
+                    this.cooldowns.add(Object.assign(Object.assign({}, userCooldown), { expireTime: Date.now() + command.cooldown }));
                 }
                 else if (this.config.commands.slashCommand.enableCooldown && command.cooldown) {
-                    if (!(yield this._haltCommand(command, Object.assign({ executeData, reason: commands_1.HaltedCommandReason.Cooldown }, this.commandCooldowns.get(userCooldown))))) {
+                    if (!(yield this._haltCommand(command, Object.assign({ executeData, reason: commands_1.CommandHaltReason.Cooldown }, this.cooldowns.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;
@@ -291,16 +289,16 @@ class RecipleClient extends discord_js_1.Client {
                 try {
                     yield Promise.resolve(command.execute(executeData))
                         .then(() => this.emit('recipleInteractionCommandCreate', executeData))
-                        .catch((err) => __awaiter(this, void 0, void 0, function* () { return (yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.Error, error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
+                        .catch((err) => __awaiter(this, void 0, void 0, function* () { return (yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.Error, error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
                     return executeData;
                 }
                 catch (err) {
-                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.Error, error: err }))) {
+                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.Error, error: err }))) {
                         this._commandExecuteError(err, executeData);
                     }
                 }
             }
-            else if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.MissingMemberPermissions }))) {
+            else if (!(yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.MissingMemberPermissions }))) {
                 yield interaction.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this._replyError(er));
             }
         });
@@ -345,7 +343,7 @@ class RecipleClient extends discord_js_1.Client {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 return (_a = (command.halt
-                    ? yield (command.builder == builders_1.CommandBuilderType.SlashCommand
+                    ? yield (command.type == builders_1.CommandBuilderType.SlashCommand
                         ? Promise.resolve(command.halt(haltData))
                         : Promise.resolve(command.halt(haltData))).catch(err => { throw err; })
                     : false)) !== null && _a !== void 0 ? _a : false;
@@ -367,17 +365,17 @@ class RecipleClient extends discord_js_1.Client {
     _commandExecuteError(err, command) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.isClientLogsEnabled()) {
-                this.logger.error(`An error occured executing ${command.builder.builder == builders_1.CommandBuilderType.MessageCommand ? 'message' : 'slash'} command "${command.builder.name}"`);
+                this.logger.error(`An error occured executing ${command.builder.type == builders_1.CommandBuilderType.MessageCommand ? 'message' : 'slash'} command "${command.builder.name}"`);
                 this.logger.error(err);
             }
             if (!err || !command)
                 return;
-            if (command === null || command === void 0 ? void 0 : command.message) {
+            if (MessageCommandBuilder_1.MessageCommandBuilder.isMessageCommandExecuteData(command)) {
                 if (!this.config.commands.messageCommand.replyOnError)
                     return;
                 yield command.message.reply(this.getMessage('error', 'An error occurred.')).catch(er => this._replyError(er));
             }
-            else if (command === null || command === void 0 ? void 0 : command.interaction) {
+            else if (SlashCommandBuilder_1.SlashCommandBuilder.isSlashCommandExecuteData(command)) {
                 if (!this.config.commands.slashCommand.replyOnError)
                     return;
                 yield command.interaction.followUp(this.getMessage('error', 'An error occurred.')).catch(er => this._replyError(er));

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

@@ -37,11 +37,6 @@ export interface Config {
             };
         };
     };
-    ignoredChannels: {
-        enabled: boolean;
-        convertToAllowList: boolean;
-        channels: string[];
-    };
     fileLogging: {
         enabled: boolean;
         debugmode: boolean;

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

@@ -1,8 +1,9 @@
-import { CommandBuilderType, CommandExecuteFunction, CommandHaltFunction } from '../../types/builders';
+import { CommandBuilderType, AnyCommandExecuteData, CommandHaltFunction, CommandExecuteFunction } from '../../types/builders';
 import { MessageCommandOptionManager } from '../MessageCommandOptionManager';
 import { MessageCommandOptionBuilder } from './MessageCommandOptionBuilder';
 import { Command as CommandMessage } from 'fallout-utility';
 import { Message, PermissionResolvable } from 'discord.js';
+import { CommandHaltData } from '../../types/commands';
 import { RecipleClient } from '../RecipleClient';
 /**
  * Execute data for message command
@@ -24,11 +25,23 @@ export interface MessageCommandValidatedOption {
     invalid: boolean;
     missing: boolean;
 }
+/**
+ * Message command halt data
+ */
+export declare type MessageCommandHaltData = CommandHaltData<CommandBuilderType.MessageCommand>;
+/**
+ * Message command halt function
+ */
+export declare type MessageCommandHaltFunction = CommandHaltFunction<CommandBuilderType.MessageCommand>;
+/**
+ * Message command execute function
+ */
+export declare type MessageCommandExecuteFunction = CommandExecuteFunction<CommandBuilderType.MessageCommand>;
 /**
  * Reciple builder for message command
  */
 export declare class MessageCommandBuilder {
-    readonly builder = CommandBuilderType.MessageCommand;
+    readonly type = CommandBuilderType.MessageCommand;
     name: string;
     cooldown: number;
     description: string;
@@ -39,8 +52,8 @@ export declare class MessageCommandBuilder {
     requiredMemberPermissions: PermissionResolvable[];
     allowExecuteInDM: boolean;
     allowExecuteByBots: boolean;
-    halt?: CommandHaltFunction<this>;
-    execute: CommandExecuteFunction<this>;
+    halt?: MessageCommandHaltFunction;
+    execute: MessageCommandExecuteFunction;
     /**
      * Sets the command name
      * @param name Command name
@@ -86,12 +99,12 @@ export declare class MessageCommandBuilder {
      * Function when the command is interupted
      * @param halt Function to execute when command is halted
      */
-    setHalt(halt?: CommandHaltFunction<this>): this;
+    setHalt(halt?: this["halt"]): this;
     /**
      * Function when the command is executed
      * @param execute Function to execute when the command is called
      */
-    setExecute(execute: CommandExecuteFunction<this>): this;
+    setExecute(execute: this["execute"]): this;
     /**
      * Add option to the command
      * @param option Message option builder
@@ -102,5 +115,13 @@ export declare class MessageCommandBuilder {
      * @param validateOptions `true` if the command options needs to be validated before executing
      */
     setValidateOptions(validateOptions: boolean): this;
+    /**
+     * Is a message command builder
+     */
+    static isMessageCommandBuilder(builder: any): builder is MessageCommandBuilder;
+    /**
+     * Is a message command execute data
+     */
+    static isMessageCommandExecuteData(executeData: AnyCommandExecuteData): executeData is MessageCommandExecuteData;
 }
 export declare function validateMessageCommandOptions(builder: MessageCommandBuilder, options: CommandMessage): Promise<MessageCommandOptionManager>;

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

@@ -18,7 +18,7 @@ const MessageCommandOptionBuilder_1 = require("./MessageCommandOptionBuilder");
  */
 class MessageCommandBuilder {
     constructor() {
-        this.builder = builders_1.CommandBuilderType.MessageCommand;
+        this.type = builders_1.CommandBuilderType.MessageCommand;
         this.name = '';
         this.cooldown = 0;
         this.description = '';
@@ -153,6 +153,18 @@ class MessageCommandBuilder {
         this.validateOptions = validateOptions;
         return this;
     }
+    /**
+     * Is a message command builder
+     */
+    static isMessageCommandBuilder(builder) {
+        return builder instanceof MessageCommandBuilder;
+    }
+    /**
+     * Is a message command execute data
+     */
+    static isMessageCommandExecuteData(executeData) {
+        return executeData.builder !== undefined && this.isMessageCommandBuilder(executeData.builder);
+    }
 }
 exports.MessageCommandBuilder = MessageCommandBuilder;
 function validateMessageCommandOptions(builder, options) {

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

@@ -1,4 +1,5 @@
-import { CommandBuilderType, CommandExecuteFunction, CommandHaltFunction } from '../../types/builders';
+import { CommandBuilderType, AnyCommandExecuteData, CommandHaltFunction, CommandExecuteFunction } from '../../types/builders';
+import { CommandHaltData } from '../../types/commands';
 import { RecipleClient } from '../RecipleClient';
 import { ChatInputCommandInteraction, PermissionResolvable, SlashCommandBuilder as DiscordJsSlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder, SlashCommandSubcommandsOnlyBuilder as DiscordJsSlashCommandSubcommandsOnlyBuilder } from 'discord.js';
 /**
@@ -15,17 +16,29 @@ export interface SlashCommandBuilder extends DiscordJsSlashCommandBuilder {
     addSubcommandGroup(input: SlashCommandSubcommandGroupBuilder | ((subcommandGroup: SlashCommandSubcommandGroupBuilder) => SlashCommandSubcommandGroupBuilder)): SlashCommandSubcommandsOnlyBuilder;
     addSubcommand(input: SlashCommandSubcommandBuilder | ((subcommandGroup: SlashCommandSubcommandBuilder) => SlashCommandSubcommandBuilder)): SlashCommandSubcommandsOnlyBuilder;
 }
+/**
+ * Slash command halt data
+ */
+export declare type SlashCommandHaltData = CommandHaltData<CommandBuilderType.SlashCommand>;
+/**
+ * Slash command halt function
+ */
+export declare type SlashCommandHaltFunction = CommandHaltFunction<CommandBuilderType.SlashCommand>;
+/**
+ * Slash command execute function
+ */
+export declare type SlashCommandExecuteFunction = CommandExecuteFunction<CommandBuilderType.SlashCommand>;
 /**
  * Reciple builder for interaction/slash command
  */
 export declare class SlashCommandBuilder extends DiscordJsSlashCommandBuilder {
-    readonly builder = CommandBuilderType.SlashCommand;
+    readonly type = CommandBuilderType.SlashCommand;
     cooldown: number;
     requiredBotPermissions: PermissionResolvable[];
     requiredMemberPermissions: PermissionResolvable[];
     allowExecuteInDM: boolean;
-    halt?: CommandHaltFunction<this>;
-    execute: CommandExecuteFunction<this>;
+    halt?: SlashCommandHaltFunction;
+    execute: SlashCommandExecuteFunction;
     /**
      * Sets the execute cooldown for this command.
      * - `0` means no cooldown
@@ -46,10 +59,18 @@ export declare class SlashCommandBuilder extends DiscordJsSlashCommandBuilder {
      * Function when the command is interupted
      * @param halt Function to execute when command is halted
      */
-    setHalt(halt?: CommandHaltFunction<this>): this;
+    setHalt(halt?: this["halt"]): this;
     /**
      * Function when the command is executed
      * @param execute Function to execute when the command is called
      */
-    setExecute(execute: CommandExecuteFunction<this>): this;
+    setExecute(execute: this["execute"]): this;
+    /**
+     * Is a slash command builder
+     */
+    static isSlashCommandBuilder(builder: any): builder is SlashCommandBuilder;
+    /**
+     * Is a slash command execute data
+     */
+    static isSlashCommandExecuteData(executeData: AnyCommandExecuteData): executeData is SlashCommandExecuteData;
 }

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

@@ -9,7 +9,7 @@ const discord_js_1 = require("discord.js");
 class SlashCommandBuilder extends discord_js_1.SlashCommandBuilder {
     constructor() {
         super(...arguments);
-        this.builder = builders_1.CommandBuilderType.SlashCommand;
+        this.type = builders_1.CommandBuilderType.SlashCommand;
         this.cooldown = 0;
         this.requiredBotPermissions = [];
         this.requiredMemberPermissions = [];
@@ -59,5 +59,17 @@ class SlashCommandBuilder extends discord_js_1.SlashCommandBuilder {
         this.execute = execute;
         return this;
     }
+    /**
+     * Is a slash command builder
+     */
+    static isSlashCommandBuilder(builder) {
+        return builder instanceof SlashCommandBuilder;
+    }
+    /**
+     * Is a slash command execute data
+     */
+    static isSlashCommandExecuteData(executeData) {
+        return executeData.builder !== undefined && this.isSlashCommandBuilder(executeData.builder);
+    }
 }
 exports.SlashCommandBuilder = SlashCommandBuilder;

package/bin/reciple/flags.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.token = exports.flags = void 0;
+const version_1 = require("./version");
 const commander_1 = require("commander");
 /**
  * Used flags
@@ -8,7 +9,7 @@ const commander_1 = require("commander");
 exports.flags = new commander_1.Command()
     .name('reciple')
     .description('Reciple.js - Discord.js handler cli')
-    .version(`v${require('../../package.json').version}`, '-v, --version')
+    .version(`v${version_1.rawVersion}`, '-v, --version')
     .option('-t, --token <token>', 'Replace used bot token')
     .option('-c, --config <config>', 'Change path to config file')
     .option('-D, --debugmode', 'Enabled debug mode')

package/bin/reciple/modules.d.ts

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

package/bin/reciple/modules.js

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

package/bin/reciple/permissions.d.ts

@@ -1,6 +1,5 @@
 import { UserHasCommandPermissionsOptions } from './types/paramOptions';
 import { Guild, PermissionResolvable } from 'discord.js';
-import { Config } from './classes/RecipleConfig';
 /**
  * Check if the user has permissions to execute the given command name
  * @param options options
@@ -12,9 +11,3 @@ export declare function userHasCommandPermissions(options: UserHasCommandPermiss
  * @param requiredPermissions Required guild bot permissions
  */
 export declare function botHasExecutePermissions(guild?: Guild, requiredPermissions?: PermissionResolvable[]): boolean;
-/**
- * Check if the channel id is ignored in config file
- * @param channelId Check if channel id is in ignore list
- * @param ignoredChannelsConfig Ignored channels config
- */
-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.isIgnoredChannel = exports.botHasExecutePermissions = exports.userHasCommandPermissions = void 0;
+exports.botHasExecutePermissions = exports.userHasCommandPermissions = void 0;
 /**
  * Check if the user has permissions to execute the given command name
  * @param options options
@@ -26,18 +26,3 @@ function botHasExecutePermissions(guild, requiredPermissions) {
     return (guild === null || guild === void 0 ? void 0 : guild.members.me) ? guild.members.me.permissions.has(requiredPermissions) : false;
 }
 exports.botHasExecutePermissions = botHasExecutePermissions;
-/**
- * Check if the channel id is ignored in config file
- * @param channelId Check if channel id is in ignore list
- * @param ignoredChannelsConfig Ignored channels config
- */
-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/types/builders.d.ts

@@ -1,23 +1,26 @@
+import { MessageCommandBuilder, MessageCommandExecuteData, MessageCommandHaltData, MessageCommandHaltFunction } from '../classes/builders/MessageCommandBuilder';
+import { SlashCommandBuilder, SlashCommandExecuteData, SlashCommandHaltData, SlashCommandHaltFunction } from '../classes/builders/SlashCommandBuilder';
 import { Awaitable } from 'discord.js';
-import { MessageCommandBuilder, MessageCommandExecuteData } from '../classes/builders/MessageCommandBuilder';
-import { SlashCommandBuilder, SlashCommandExecuteData } from '../classes/builders/SlashCommandBuilder';
-import { HaltedCommandData } from './commands';
 /**
- * Reciple command builders
+ * Any Reciple command builders
  */
-export declare type CommandBuilder = MessageCommandBuilder | SlashCommandBuilder;
+export declare type AnyCommandBuilder = SlashCommandBuilder | MessageCommandBuilder;
 /**
- * Reciple command builders execute data
+ * Any Reciple command execute data
  */
-export declare type CommandBuilderExecuteData = SlashCommandExecuteData | MessageCommandExecuteData;
+export declare type AnyCommandExecuteData = SlashCommandExecuteData | MessageCommandExecuteData;
+/**
+ * Any Reciple command halt functions
+ */
+export declare type AnyCommandHaltFunction = SlashCommandHaltFunction | MessageCommandHaltFunction;
 /**
  * Reciple command halt function
  */
-export declare type CommandHaltFunction<Builder extends CommandBuilder> = (haltData: HaltedCommandData<Builder>) => Awaitable<boolean | null | undefined | void>;
+export declare type CommandHaltFunction<T extends CommandBuilderType> = (haltData: T extends CommandBuilderType.SlashCommand ? SlashCommandHaltData : MessageCommandHaltData) => Awaitable<boolean | null | undefined | void>;
 /**
  * Reciple command execute function
  */
-export declare type CommandExecuteFunction<Builder extends CommandBuilder> = (executeData: Builder extends MessageCommandBuilder ? MessageCommandExecuteData : SlashCommandExecuteData) => Awaitable<void>;
+export declare type CommandExecuteFunction<T extends CommandBuilderType> = (executeData: T extends CommandBuilderType.SlashCommand ? SlashCommandExecuteData : MessageCommandExecuteData) => Awaitable<void>;
 /**
  * Types of Reciple command builders
  */

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

@@ -1,40 +1,47 @@
-import { MessageCommandExecuteData } from '../classes/builders/MessageCommandBuilder';
-import { SlashCommandBuilder, SlashCommandExecuteData } from '../classes/builders/SlashCommandBuilder';
+import { MessageCommandExecuteData, MessageCommandHaltData } from '../classes/builders/MessageCommandBuilder';
+import { SlashCommandExecuteData, SlashCommandHaltData } from '../classes/builders/SlashCommandBuilder';
 import { MessageCommandOptionManager } from '../classes/MessageCommandOptionManager';
+import { CommandBuilderType, AnyCommandExecuteData } from '../types/builders';
 import { CooledDownUser } from '../classes/CommandCooldownManager';
-import { CommandBuilder } from '../types/builders';
 /**
- * Halted command's data
+ * Any reciple halted command data
  */
-export declare type HaltedCommandData<Builder extends CommandBuilder = CommandBuilder> = CommandErrorData<Builder> | CommandCooldownData<Builder> | (Builder extends SlashCommandBuilder ? never : CommandInvalidArguments<Builder> | CommandMissingArguments<Builder>) | CommandMissingMemberPermissions<Builder> | CommandMissingBotPermissions<Builder>;
-export interface CommandHaltBaseData<Builder extends CommandBuilder> {
-    executeData: Builder extends SlashCommandBuilder ? SlashCommandExecuteData : MessageCommandExecuteData;
+export declare type AnyCommandHaltData = SlashCommandHaltData | MessageCommandHaltData;
+/**
+ * Halted command data
+ */
+export declare type CommandHaltData<T extends CommandBuilderType> = CommandErrorData<T> | CommandCooldownData<T> | (T extends CommandBuilderType.SlashCommand ? never : CommandInvalidArguments<T> | CommandMissingArguments<T>) | CommandMissingMemberPermissions<T> | CommandMissingBotPermissions<T>;
+/**
+ * Command halt reason base interface
+ */
+export interface CommandHaltReasonBase<T extends CommandBuilderType> {
+    executeData: T extends CommandBuilderType.SlashCommand ? SlashCommandExecuteData : T extends CommandBuilderType.MessageCommand ? MessageCommandExecuteData : AnyCommandExecuteData;
 }
-export interface CommandErrorData<Builder extends CommandBuilder> extends CommandHaltBaseData<Builder> {
-    reason: HaltedCommandReason.Error;
+export interface CommandErrorData<T extends CommandBuilderType> extends CommandHaltReasonBase<T> {
+    reason: CommandHaltReason.Error;
     error: any;
 }
-export interface CommandCooldownData<Builder extends CommandBuilder> extends CommandHaltBaseData<Builder>, CooledDownUser {
-    reason: HaltedCommandReason.Cooldown;
+export interface CommandCooldownData<T extends CommandBuilderType> extends CommandHaltReasonBase<T>, CooledDownUser {
+    reason: CommandHaltReason.Cooldown;
 }
-export interface CommandInvalidArguments<Builder extends CommandBuilder> extends CommandHaltBaseData<Builder> {
-    reason: HaltedCommandReason.InvalidArguments;
+export interface CommandInvalidArguments<T extends CommandBuilderType> extends CommandHaltReasonBase<T> {
+    reason: CommandHaltReason.InvalidArguments;
     invalidArguments: MessageCommandOptionManager;
 }
-export interface CommandMissingArguments<Builder extends CommandBuilder> extends CommandHaltBaseData<Builder> {
-    reason: HaltedCommandReason.MissingArguments;
+export interface CommandMissingArguments<T extends CommandBuilderType> extends CommandHaltReasonBase<T> {
+    reason: CommandHaltReason.MissingArguments;
     missingArguments: MessageCommandOptionManager;
 }
-export interface CommandMissingMemberPermissions<Builder extends CommandBuilder> extends CommandHaltBaseData<Builder> {
-    reason: HaltedCommandReason.MissingMemberPermissions;
+export interface CommandMissingMemberPermissions<T extends CommandBuilderType> extends CommandHaltReasonBase<T> {
+    reason: CommandHaltReason.MissingMemberPermissions;
 }
-export interface CommandMissingBotPermissions<Builder extends CommandBuilder> extends CommandHaltBaseData<Builder> {
-    reason: HaltedCommandReason.MissingBotPermissions;
+export interface CommandMissingBotPermissions<T extends CommandBuilderType> extends CommandHaltReasonBase<T> {
+    reason: CommandHaltReason.MissingBotPermissions;
 }
 /**
  * Command halt reasons
  */
-export declare enum HaltedCommandReason {
+export declare enum CommandHaltReason {
     Error = 0,
     Cooldown = 1,
     InvalidArguments = 2,

package/bin/reciple/types/commands.js

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

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

@@ -3,7 +3,7 @@ import { ApplicationCommandData, PermissionsBitField } from 'discord.js';
 import { RecipleModule, RecipleScript } from '../modules';
 import { RecipleClient } from '../classes/RecipleClient';
 import { Config } from '../classes/RecipleConfig';
-import { CommandBuilder } from './builders';
+import { AnyCommandBuilder } from './builders';
 export interface RecipleClientAddModuleOptions {
     /**
      * The Module script
@@ -33,7 +33,7 @@ export interface RegisterApplicationCommandsOptions {
     guilds?: string | string[];
 }
 export interface UserHasCommandPermissionsOptions {
-    builder: CommandBuilder;
+    builder: AnyCommandBuilder;
     memberPermissions?: PermissionsBitField;
     commandPermissions?: Config["commands"]["slashCommand"]["permissions"] | Config["commands"]["messageCommand"]["permissions"];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reciple",
-  "version": "4.1.2",
+  "version": "5.0.0-pre.3",
   "bin": "bin/bin.js",
   "license": "GPL-3.0",
   "main": "bin/index.js",

package/resource/reciple.yml

@@ -49,16 +49,6 @@ commands:
           permissions: ['Administrator']
 
 
-# Ignored channel IDs
-ignoredChannels:
-  # enable ignored channels
-  enabled: false
-  # convert to only allowed channels
-  convertToAllowList: false
-  # channel IDs
-  channels: []
-
-
 # Logger options
 fileLogging:
   # enable console output to file