npm - reciple - Versions diffs - 3.0.0-pre.1 → 3.0.0 - Mend

reciple 3.0.0-pre.1 → 3.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (20) hide show

package/bin/reciple/classes/CommandCooldownManager.d.ts +2 -2
package/bin/reciple/classes/RecipleClient.d.ts +11 -10
package/bin/reciple/classes/RecipleClient.js +56 -42
package/bin/reciple/classes/RecipleConfig.d.ts +10 -12
package/bin/reciple/classes/builders/InteractionCommandBuilder.d.ts +2 -1
package/bin/reciple/classes/builders/InteractionCommandBuilder.js +2 -1
package/bin/reciple/classes/builders/MessageCommandBuilder.d.ts +2 -1
package/bin/reciple/classes/builders/MessageCommandBuilder.js +2 -1
package/bin/reciple/modules.js +4 -2
package/bin/reciple/permissions.d.ts +1 -1
package/bin/reciple/registerInteractionCommands.d.ts +4 -5
package/bin/reciple/registerInteractionCommands.js +21 -18
package/bin/reciple/types/builders.d.ts +4 -0
package/bin/reciple/types/builders.js +6 -0
package/bin/reciple/types/commands.d.ts +15 -8
package/bin/reciple/types/commands.js +10 -0
package/bin/reciple/types/paramOptions.d.ts +32 -0
package/bin/reciple/types/paramOptions.js +2 -0
package/package.json +13 -5
package/resource/reciple.yml +24 -24

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

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -11,12 +11,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RecipleClient = void 0;
+const builders_1 = require("../types/builders");
 const registerInteractionCommands_1 = require("../registerInteractionCommands");
 const permissions_1 = require("../permissions");
 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");
@@ -27,7 +29,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 +42,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 +81,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 +97,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 +116,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 +129,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 +158,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,7 +172,7 @@ 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 ((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)
@@ -168,20 +180,20 @@ class RecipleClient extends discord_js_1.Client {
                     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 +203,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));
             }
         });
@@ -226,7 +239,7 @@ class RecipleClient extends discord_js_1.Client {
         return __awaiter(this, void 0, void 0, function* () {
             if (!interaction || interaction.type !== discord_js_1.InteractionType.ApplicationCommand || !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 +247,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 ((0, permissions_1.userHasCommandPermissions)(command.name, (_a = interaction.memberPermissions) !== null && _a !== void 0 ? _a : undefined, this.config.commands.interactionCommand.permissions, command)) {
                 if (!command || (0, isIgnoredChannel_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 +261,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 +299,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 +327,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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -2,13 +2,14 @@ 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[];

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

@@ -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 CHANGED Viewed

@@ -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;

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

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -4,5 +4,5 @@ import { Config } from './classes/RecipleConfig';
 /**
  * Check if the user has permissions to execute the given command name
  */
-export declare function userHasCommandPermissions(commandName: string, memberPermissions?: PermissionsBitField, 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;
 export declare function botHasExecutePermissions(guild?: Guild, requiredPermissions?: PermissionResolvable[]): boolean;

package/bin/reciple/registerInteractionCommands.d.ts CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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;
+        let { client, guilds } = options;
+        guilds = typeof guilds == 'string' ? [guilds] : 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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

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

package/package.json CHANGED Viewed

@@ -1,12 +1,19 @@
 {
   "name": "reciple",
-  "version": "3.0.0-pre.1",
+  "version": "3.0.0",
   "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": {
@@ -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": "^14.0.2",
+    "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 CHANGED Viewed

@@ -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
@@ -74,13 +71,16 @@ fileLogging:
   logFilePath: './logs/latest.log'
 # Client options
-# Use an intent calculator like https://discord-intents-calculator.vercel.app/ to get valid intents
 client:
-  intents: 33283
+  intents:
+    - '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.'