reciple 1.5.1 → 1.5.4

package/bin/index.d.ts

@@ -5,6 +5,7 @@ export * from './reciple/classes/Config';
 export * from './reciple/classes/builders/InteractionCommandBuilder';
 export * from './reciple/classes/builders/MessageCommandBuilder';
 export * from './reciple/classes/builders/MessageCommandOptionBuilder';
+export * from './reciple/classes/builders/MessageCommandOptions';
 export * from './reciple/hasPermissions';
 export * from './reciple/flags';
 export * from './reciple/isIgnoredChannel';

package/bin/index.js

@@ -25,6 +25,7 @@ __exportStar(require("./reciple/classes/Config"), exports);
 __exportStar(require("./reciple/classes/builders/InteractionCommandBuilder"), exports);
 __exportStar(require("./reciple/classes/builders/MessageCommandBuilder"), exports);
 __exportStar(require("./reciple/classes/builders/MessageCommandOptionBuilder"), exports);
+__exportStar(require("./reciple/classes/builders/MessageCommandOptions"), exports);
 __exportStar(require("./reciple/hasPermissions"), exports);
 __exportStar(require("./reciple/flags"), exports);
 __exportStar(require("./reciple/isIgnoredChannel"), exports);

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

@@ -45,8 +45,8 @@ export declare class RecipleClient extends Client {
     addModule(script: RecipleScript, registerCommands?: boolean): Promise<void>;
     addCommand(command: recipleCommandBuilders): RecipleClient;
     addCommandListeners(): RecipleClient;
-    messageCommandExecute(message: Message): Promise<void>;
-    interactionCommandExecute(interaction: Interaction): Promise<void>;
-    getMessage<T = any>(messageKey: string, defaultMessage?: T): T;
+    messageCommandExecute(message: Message, prefix?: string): Promise<void | RecipleMessageCommandExecute>;
+    interactionCommandExecute(interaction: Interaction): Promise<void | RecipleInteractionCommandExecute>;
+    getMessage<T = unknown>(messageKey: string, defaultMessage?: T): T;
     private _commandExecuteError;
 }

package/bin/reciple/classes/Client.js

@@ -24,6 +24,7 @@ const version_1 = require("../version");
 const logger_1 = require("../logger");
 const discord_js_1 = require("discord.js");
 const modules_1 = require("../modules");
+const MessageCommandOptions_1 = require("./builders/MessageCommandOptions");
 class RecipleClient extends discord_js_1.Client {
     constructor(options) {
         super(options);
@@ -95,7 +96,7 @@ class RecipleClient extends discord_js_1.Client {
             this.commands.INTERACTION_COMMANDS[command.name] = command;
         }
         else {
-            this.logger.error(`Command "${(_a = command.name) !== null && _a !== void 0 ? _a : 'unknown'}" has an invalid builder.`);
+            this.logger.error(`Unknow command "${(_a = typeof command) !== null && _a !== void 0 ? _a : 'unknown'}".`);
         }
         return this;
     }
@@ -106,12 +107,12 @@ class RecipleClient extends discord_js_1.Client {
             this.on('interactionCreate', (interaction) => { this.interactionCommandExecute(interaction); });
         return this;
     }
-    messageCommandExecute(message) {
+    messageCommandExecute(message, prefix) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            if (!message.content || !this.config.commands.messageCommand.enabled)
+            if (!message.content)
                 return;
-            const parseCommand = (0, fallout_utility_1.getCommand)(message.content, this.config.prefix || '!', this.config.commands.messageCommand.commandArgumentSeparator || ' ');
+            const parseCommand = (0, fallout_utility_1.getCommand)(message.content, prefix || this.config.prefix || '!', this.config.commands.messageCommand.commandArgumentSeparator || ' ');
             if (!(parseCommand === null || parseCommand === void 0 ? void 0 : parseCommand.command) || !parseCommand)
                 return;
             const command = this.commands.MESSAGE_COMMANDS[parseCommand.command.toLowerCase()];
@@ -124,33 +125,36 @@ class RecipleClient extends discord_js_1.Client {
                     || (0, isIgnoredChannel_1.isIgnoredChannel)(message.channelId, this.config.ignoredChannels))
                     return;
                 const commandOptions = command.getCommandOptionValues(parseCommand);
-                if (commandOptions.some(o => o.invalid)) {
-                    yield message.reply(this.getMessage('invalidArguments', 'Invalid argument(s) given.'));
-                    return;
-                }
-                if (commandOptions.some(o => o.missing)) {
-                    yield message.reply(this.getMessage('notEnoughArguments', 'Not enough arguments.'));
-                    return;
+                if (command.validateOptions) {
+                    if (commandOptions.some(o => o.invalid)) {
+                        yield message.reply(this.getMessage('invalidArguments', 'Invalid argument(s) given.')).catch(err => this.logger.debug(err));
+                        return;
+                    }
+                    if (commandOptions.some(o => o.missing)) {
+                        yield message.reply(this.getMessage('notEnoughArguments', 'Not enough arguments.')).catch(err => this.logger.debug(err));
+                        return;
+                    }
                 }
                 const options = {
                     message: message,
-                    options: commandOptions,
+                    options: new MessageCommandOptions_1.MessageCommandOptions(commandOptions),
                     command: parseCommand,
                     builder: command,
                     client: this
                 };
                 yield Promise.resolve(command.execute(options)).catch(err => this._commandExecuteError(err, options));
                 this.emit('recipleMessageCommandCreate', options);
+                return options;
             }
             else {
-                yield message.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch((err) => this.logger.error(err));
+                yield message.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch(err => this.logger.debug(err));
             }
         });
     }
     interactionCommandExecute(interaction) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            if (!interaction || !interaction.isCommand() || !this.config.commands.interactionCommand.enabled)
+            if (!interaction || !interaction.isCommand())
                 return;
             const command = this.commands.INTERACTION_COMMANDS[interaction.commandName];
             if (!command)
@@ -168,9 +172,10 @@ class RecipleClient extends discord_js_1.Client {
                 };
                 yield Promise.resolve(command.execute(options)).catch(err => this._commandExecuteError(err, options));
                 this.emit('recipleInteractionCommandCreate', options);
+                return options;
             }
             else {
-                yield interaction.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch((err) => this.logger.error(err));
+                yield interaction.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch(err => this.logger.debug(err));
             }
         });
     }
@@ -187,12 +192,12 @@ class RecipleClient extends discord_js_1.Client {
             if (command === null || command === void 0 ? void 0 : command.message) {
                 if (!this.config.commands.messageCommand.replyOnError)
                     return;
-                yield command.message.reply(this.getMessage('error', 'An error occurred.')).catch((e) => this.logger.error(e));
+                yield command.message.reply(this.getMessage('error', 'An error occurred.')).catch(err => this.logger.debug(err));
             }
             else if (command === null || command === void 0 ? void 0 : command.interaction) {
                 if (!this.config.commands.interactionCommand.replyOnError)
                     return;
-                yield command.interaction.followUp(this.getMessage('error', 'An error occurred.')).catch((e) => this.logger.error(e));
+                yield command.interaction.followUp(this.getMessage('error', 'An error occurred.')).catch(err => this.logger.debug(err));
             }
         });
     }

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

@@ -8,7 +8,7 @@ export interface RecipleInteractionCommandExecute {
     client: RecipleClient;
 }
 export declare class InteractionCommandBuilder extends SlashCommandBuilder {
-    readonly builder: string;
+    readonly builder = "INTERACTION_COMMAND";
     requiredPermissions: (PermissionFlags | PermissionString)[];
     allowExecuteInDM: boolean;
     execute: (options: RecipleInteractionCommandExecute) => void;

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

@@ -2,10 +2,11 @@ import { MessageCommandOptionBuilder } from './MessageCommandOptionBuilder';
 import { Message, PermissionFlags, PermissionString } from 'discord.js';
 import { Command } from 'fallout-utility';
 import { RecipleClient } from '../Client';
+import { MessageCommandOptions } from './MessageCommandOptions';
 export declare type CommandMessage = Command;
 export interface RecipleMessageCommandExecute {
     message: Message;
-    options: MessageCommandValidatedOption[];
+    options: MessageCommandOptions;
     command: CommandMessage;
     builder: MessageCommandBuilder;
     client: RecipleClient;
@@ -18,7 +19,7 @@ export interface MessageCommandValidatedOption {
     missing: boolean;
 }
 export declare class MessageCommandBuilder {
-    readonly builder: string;
+    readonly builder = "MESSAGE_COMMAND";
     name: string;
     description: string;
     options: MessageCommandOptionBuilder[];

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

@@ -72,7 +72,7 @@ class MessageCommandBuilder {
         const required = this.options.filter(o => o.required);
         const optional = this.options.filter(o => !o.required);
         const allOptions = [...required, ...optional];
-        let result = [];
+        const result = [];
         let i = 0;
         for (const option of allOptions) {
             const arg = args[i];

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

@@ -0,0 +1,6 @@
+import { MessageCommandValidatedOption } from './MessageCommandBuilder';
+export declare class MessageCommandOptions extends Array<MessageCommandValidatedOption> {
+    constructor(options: MessageCommandValidatedOption[]);
+    get(name: string, requied: true): MessageCommandValidatedOption;
+    get(name: string, requied?: boolean): MessageCommandValidatedOption | null;
+}

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageCommandOptions = void 0;
+class MessageCommandOptions extends Array {
+    constructor(options) {
+        super();
+        this.push(...options);
+    }
+    get(name, required) {
+        const option = this.find(o => o.name == name);
+        if (!option && required || (option === null || option === void 0 ? void 0 : option.value) == undefined && required)
+            throw new TypeError(`Can't find option named ${name}`);
+        return option !== null && option !== void 0 ? option : null;
+    }
+}
+exports.MessageCommandOptions = MessageCommandOptions;

package/bin/reciple/modules.js

@@ -18,7 +18,7 @@ const version_1 = require("./version");
 const wildcard_match_1 = __importDefault(require("wildcard-match"));
 const path_1 = __importDefault(require("path"));
 function loadModules(client) {
-    var _a;
+    var _a, _b;
     return __awaiter(this, void 0, void 0, function* () {
         const response = { commands: [], modules: [] };
         const modulesDir = client.config.modulesFolder || './modules';
@@ -30,17 +30,17 @@ function loadModules(client) {
             return file.endsWith('.js') && (!file.startsWith('_') && !file.startsWith('.')) && !ignoredFiles.some(f => (0, wildcard_match_1.default)(f)(file));
         });
         for (const script of scripts) {
-            const modulePath = path_1.default.resolve(modulesDir, script);
+            const modulePath = path_1.default.join(process.cwd(), modulesDir, script);
             const commands = [];
             let module_;
             try {
                 const reqMod = require(modulePath);
-                module_ = !!(reqMod === null || reqMod === void 0 ? void 0 : reqMod.default) ? reqMod.default : reqMod;
+                module_ = typeof (reqMod === null || reqMod === void 0 ? void 0 : reqMod.default) != 'undefined' ? reqMod.default : reqMod;
                 if (!((_a = module_.versions) === null || _a === void 0 ? void 0 : _a.length))
                     throw new Error('Module does not have supported versions.');
                 const versions = typeof module_.versions === 'object' ? module_.versions : [module_.versions];
                 if (!versions.some(v => (0, version_1.isSupportedVersion)(v, version_1.version)))
-                    throw new Error('Module versions is not defined or unsupported.');
+                    throw new Error((_b = 'Module versions is not defined or unsupported; supported versions: ' + module_.versions) !== null && _b !== void 0 ? _b : 'none' + '; current version: ' + version_1.version);
                 if (!(yield Promise.resolve(module_.onStart(client))))
                     throw new Error(script + ' onStart is not defined or returned false.');
                 if (module_.commands) {
@@ -55,13 +55,13 @@ function loadModules(client) {
                 logger.error(error);
                 continue;
             }
-            response.commands = response.commands.concat(commands.filter((c) => {
+            response.commands.push(...commands.filter((c) => {
                 if (!c.name) {
-                    logger.error(`A message command name is not defined in ${script}`);
+                    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)) {
-                    logger.error(`A message command option name is not defined in ${script}`);
+                    logger.error(`A ${c.builder} option name is not defined in ${script}`);
                     return false;
                 }
                 return true;

package/bin/reciple/registerInteractionCommands.js

@@ -24,7 +24,7 @@ function registerInteractionCommands(client, cmds, overwriteGuilds) {
                     undefined)) !== null && _d !== void 0 ? _d : cmd.requiredPermissions;
                 cmd.setRequiredPermissions(permissions);
                 client.commands.INTERACTION_COMMANDS[cmd.name] = cmd;
-                client.logger.debug(`Set required permissions for ${cmd.name} to ${permissions.join(', ')}`);
+                client.logger.debug(`Set required permissions for ${cmd.name}`);
                 return cmd.toJSON();
             }
             return c.toJSON();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reciple",
-  "version": "1.5.1",
+  "version": "1.5.4",
   "description": "A Discord.js bot",
   "author": "FalloutStudios",
   "license": "GPL-3.0",