reciple 4.0.0 → 4.1.0

package/bin/reciple/classes/RecipleClient.js

@@ -171,7 +171,7 @@ class RecipleClient extends discord_js_1.Client {
             const command = this.findCommand(parseCommand.command, builders_1.CommandBuilderType.MessageCommand);
             if (!command)
                 return;
-            const commandOptions = (0, MessageCommandBuilder_1.validateMessageCommandOptions)(command, parseCommand);
+            const commandOptions = yield (0, MessageCommandBuilder_1.validateMessageCommandOptions)(command, parseCommand);
             const executeData = {
                 message: message,
                 options: commandOptions,

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

@@ -72,7 +72,7 @@ export declare class RecipleConfig {
     /**
      * Parse the config file
      */
-    parseConfig(): RecipleConfig;
+    parseConfig(): this;
     /**
      * Returns the parsed config file
      */

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

@@ -1,9 +1,8 @@
+import { CommandBuilderType, CommandExecuteFunction, CommandHaltFunction } from '../../types/builders';
 import { MessageCommandOptionManager } from '../MessageCommandOptionManager';
 import { MessageCommandOptionBuilder } from './MessageCommandOptionBuilder';
-import { Awaitable, Message, PermissionResolvable } from 'discord.js';
 import { Command as CommandMessage } from 'fallout-utility';
-import { CommandBuilderType } from '../../types/builders';
-import { HaltedCommandData } from '../../types/commands';
+import { Message, PermissionResolvable } from 'discord.js';
 import { RecipleClient } from '../RecipleClient';
 /**
  * Execute data for message command
@@ -40,68 +39,68 @@ export declare class MessageCommandBuilder {
     requiredMemberPermissions: PermissionResolvable[];
     allowExecuteInDM: boolean;
     allowExecuteByBots: boolean;
-    halt?: (haltData: HaltedCommandData<MessageCommandBuilder>) => Awaitable<boolean | void>;
-    execute: (executeData: MessageCommandExecuteData) => void;
+    halt?: CommandHaltFunction<this>;
+    execute: CommandExecuteFunction<this>;
     /**
      * Sets the command name
      * @param name Command name
      */
-    setName(name: string): MessageCommandBuilder;
+    setName(name: string): this;
     /**
      * Sets the command description
      * @param description Command description
      */
-    setDescription(description: string): MessageCommandBuilder;
+    setDescription(description: string): this;
     /**
      * Sets the execute cooldown for this command.
      * - `0` means no cooldown
      * @param cooldown Command cooldown in milliseconds
      */
-    setCooldown(cooldown: number): MessageCommandBuilder;
+    setCooldown(cooldown: number): this;
     /**
      * Add aliases to the command
      * @param aliases Command aliases
      */
-    addAliases(...aliases: string[]): MessageCommandBuilder;
+    addAliases(...aliases: string[]): this;
     /**
      * Set required bot permissions to execute the command
      * @param permissions Bot's required permissions
      */
-    setRequiredBotPermissions(...permissions: PermissionResolvable[]): MessageCommandBuilder;
+    setRequiredBotPermissions(...permissions: PermissionResolvable[]): this;
     /**
      * Set required permissions to execute the command
      * @param permissions User's return permissions
      */
-    setRequiredMemberPermissions(...permissions: PermissionResolvable[]): MessageCommandBuilder;
+    setRequiredMemberPermissions(...permissions: PermissionResolvable[]): this;
     /**
      * Set if command can be executed in dms
      * @param allowExecuteInDM `true` if the command can execute in DMs
      */
-    setAllowExecuteInDM(allowExecuteInDM: boolean): MessageCommandBuilder;
+    setAllowExecuteInDM(allowExecuteInDM: boolean): this;
     /**
      * Allow command to be executed by bots
      * @param allowExecuteByBots `true` if the command can be executed by bots
      */
-    setAllowExecuteByBots(allowExecuteByBots: boolean): MessageCommandBuilder;
+    setAllowExecuteByBots(allowExecuteByBots: boolean): this;
     /**
      * Function when the command is interupted
      * @param halt Function to execute when command is halted
      */
-    setHalt(halt?: (haltData: HaltedCommandData<MessageCommandBuilder>) => Awaitable<boolean | void>): MessageCommandBuilder;
+    setHalt(halt?: CommandHaltFunction<this>): this;
     /**
      * Function when the command is executed
      * @param execute Function to execute when the command is called
      */
-    setExecute(execute: (executeData: MessageCommandExecuteData) => void): MessageCommandBuilder;
+    setExecute(execute: CommandExecuteFunction<this>): this;
     /**
      * Add option to the command
      * @param option Message option builder
      */
-    addOption(option: MessageCommandOptionBuilder | ((constructor: MessageCommandOptionBuilder) => MessageCommandOptionBuilder)): MessageCommandBuilder;
+    addOption(option: MessageCommandOptionBuilder | ((constructor: MessageCommandOptionBuilder) => MessageCommandOptionBuilder)): this;
     /**
      * Validate options before executing
      * @param validateOptions `true` if the command options needs to be validated before executing
      */
-    setValidateOptions(validateOptions: boolean): MessageCommandBuilder;
+    setValidateOptions(validateOptions: boolean): this;
 }
-export declare function validateMessageCommandOptions(builder: MessageCommandBuilder, options: CommandMessage): MessageCommandOptionManager;
+export declare function validateMessageCommandOptions(builder: MessageCommandBuilder, options: CommandMessage): Promise<MessageCommandOptionManager>;

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

@@ -1,9 +1,18 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateMessageCommandOptions = exports.MessageCommandBuilder = void 0;
+const builders_1 = require("../../types/builders");
 const MessageCommandOptionManager_1 = require("../MessageCommandOptionManager");
 const MessageCommandOptionBuilder_1 = require("./MessageCommandOptionBuilder");
-const builders_1 = require("../../types/builders");
 /**
  * Reciple builder for message command
  */
@@ -147,36 +156,38 @@ class MessageCommandBuilder {
 }
 exports.MessageCommandBuilder = MessageCommandBuilder;
 function validateMessageCommandOptions(builder, options) {
-    const args = options.args || [];
-    const required = builder.options.filter(o => o.required);
-    const optional = builder.options.filter(o => !o.required);
-    const allOptions = [...required, ...optional];
-    const result = [];
-    let i = 0;
-    for (const option of allOptions) {
-        const arg = args[i];
-        const value = {
-            name: option.name,
-            value: arg !== null && arg !== void 0 ? arg : undefined,
-            required: option.required,
-            invalid: false,
-            missing: false
-        };
-        if (arg == undefined && option.required) {
-            value.missing = true;
+    return __awaiter(this, void 0, void 0, function* () {
+        const args = options.args || [];
+        const required = builder.options.filter(o => o.required);
+        const optional = builder.options.filter(o => !o.required);
+        const allOptions = [...required, ...optional];
+        const result = [];
+        let i = 0;
+        for (const option of allOptions) {
+            const arg = args[i];
+            const value = {
+                name: option.name,
+                value: arg !== null && arg !== void 0 ? arg : undefined,
+                required: option.required,
+                invalid: false,
+                missing: false
+            };
+            if (arg == undefined && option.required) {
+                value.missing = true;
+                result.push(value);
+                continue;
+            }
+            if (arg == undefined && !option.required) {
+                result.push(value);
+                continue;
+            }
+            const validate = option.validator ? yield Promise.resolve(option.validator(arg)) : true;
+            if (!validate)
+                value.invalid = true;
             result.push(value);
-            continue;
+            i++;
         }
-        if (arg == undefined && !option.required) {
-            result.push(value);
-            continue;
-        }
-        const validate = option.validator ? option.validator(arg) : true;
-        if (!validate)
-            value.invalid = true;
-        result.push(value);
-        i++;
-    }
-    return new MessageCommandOptionManager_1.MessageCommandOptionManager(...result);
+        return new MessageCommandOptionManager_1.MessageCommandOptionManager(...result);
+    });
 }
 exports.validateMessageCommandOptions = validateMessageCommandOptions;

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

@@ -1,3 +1,4 @@
+import { Awaitable } from 'discord.js';
 /**
  * Option builder for MessageCommandBuilder
  */
@@ -5,25 +6,25 @@ export declare class MessageCommandOptionBuilder {
     name: string;
     description: string;
     required: boolean;
-    validator: (value: string) => boolean;
+    validator: (value: string) => Awaitable<boolean>;
     /**
      * Set command option name
      * @param name Option name
      */
-    setName(name: string): MessageCommandOptionBuilder;
+    setName(name: string): this;
     /**
      * Set command option description
      * @param description Option description
      */
-    setDescription(description: string): MessageCommandOptionBuilder;
+    setDescription(description: string): this;
     /**
      * Set if this option is required
      * @param required `true` if this option is required
      */
-    setRequired(required: boolean): MessageCommandOptionBuilder;
+    setRequired(required: boolean): this;
     /**
      * Set your custom function to validate given value for this option
      * @param validator Custom function to validate value given for this option
      */
-    setValidator(validator: (value: string) => boolean): MessageCommandOptionBuilder;
+    setValidator(validator: (value: string) => Awaitable<boolean>): this;
 }

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

@@ -1,7 +1,6 @@
-import { CommandBuilderType } from '../../types/builders';
-import { HaltedCommandData } from '../../types/commands';
+import { CommandBuilderType, CommandExecuteFunction, CommandHaltFunction } from '../../types/builders';
 import { RecipleClient } from '../RecipleClient';
-import { Awaitable, ChatInputCommandInteraction, PermissionResolvable, SlashCommandBuilder as DiscordJsSlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder, SlashCommandSubcommandsOnlyBuilder as DiscordJsSlashCommandSubcommandsOnlyBuilder } from 'discord.js';
+import { ChatInputCommandInteraction, PermissionResolvable, SlashCommandBuilder as DiscordJsSlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder, SlashCommandSubcommandsOnlyBuilder as DiscordJsSlashCommandSubcommandsOnlyBuilder } from 'discord.js';
 /**
  * Execute data for interaction command
  */
@@ -25,32 +24,32 @@ export declare class SlashCommandBuilder extends DiscordJsSlashCommandBuilder {
     requiredBotPermissions: PermissionResolvable[];
     requiredMemberPermissions: PermissionResolvable[];
     allowExecuteInDM: boolean;
-    halt?: (haltData: HaltedCommandData<SlashCommandBuilder>) => Awaitable<boolean | void>;
-    execute: (executeData: SlashCommandExecuteData) => Awaitable<void>;
+    halt?: CommandHaltFunction<this>;
+    execute: CommandExecuteFunction<this>;
     /**
      * Sets the execute cooldown for this command.
      * - `0` means no cooldown
      * @param cooldown Command cooldown in milliseconds
      */
-    setCooldown(cooldown: number): SlashCommandBuilder;
+    setCooldown(cooldown: number): this;
     /**
      * Set required bot permissions to execute the command
      * @param permissions Bot's required permissions
      */
-    setRequiredBotPermissions(...permissions: PermissionResolvable[]): SlashCommandBuilder;
+    setRequiredBotPermissions(...permissions: PermissionResolvable[]): this;
     /**
      * Set required permissions to execute the command
      * @param permissions User's return permissions
      */
-    setRequiredMemberPermissions(...permissions: PermissionResolvable[]): SlashCommandBuilder;
+    setRequiredMemberPermissions(...permissions: PermissionResolvable[]): this;
     /**
      * Function when the command is interupted
      * @param halt Function to execute when command is halted
      */
-    setHalt(halt?: (haltData: HaltedCommandData<SlashCommandBuilder>) => Awaitable<boolean | void>): SlashCommandBuilder;
+    setHalt(halt?: CommandHaltFunction<this>): this;
     /**
      * Function when the command is executed
      * @param execute Function to execute when the command is called
      */
-    setExecute(execute: (executeData: SlashCommandExecuteData) => void): SlashCommandBuilder;
+    setExecute(execute: CommandExecuteFunction<this>): this;
 }

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

@@ -1,5 +1,7 @@
+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
  */
@@ -8,6 +10,14 @@ export declare type CommandBuilder = MessageCommandBuilder | SlashCommandBuilder
  * Reciple command builders execute data
  */
 export declare type CommandBuilderExecuteData = SlashCommandExecuteData | MessageCommandExecuteData;
+/**
+ * Reciple command halt function
+ */
+export declare type CommandHaltFunction<Builder extends CommandBuilder> = (haltData: HaltedCommandData<Builder>) => Awaitable<boolean | null | undefined | void>;
+/**
+ * Reciple command execute function
+ */
+export declare type CommandExecuteFunction<Builder extends CommandBuilder> = (executeData: Builder extends MessageCommandBuilder ? MessageCommandExecuteData : SlashCommandExecuteData) => Awaitable<void>;
 /**
  * Types of Reciple command builders
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reciple",
-  "version": "4.0.0",
+  "version": "4.1.0",
   "bin": "bin/bin.js",
   "license": "GPL-3.0",
   "main": "bin/index.js",