reciple 3.1.4 → 4.0.0-pre.1

package/bin/index.d.ts

@@ -2,7 +2,7 @@ export * from './reciple/classes/CommandCooldownManager';
 export * from './reciple/classes/MessageCommandOptionManager';
 export * from './reciple/classes/RecipleClient';
 export * from './reciple/classes/RecipleConfig';
-export * from './reciple/classes/builders/InteractionCommandBuilder';
+export * from './reciple/classes/builders/SlashCommandBuilder';
 export * from './reciple/classes/builders/MessageCommandBuilder';
 export * from './reciple/classes/builders/MessageCommandOptionBuilder';
 export * from './reciple/types/builders';

package/bin/index.js

@@ -18,7 +18,7 @@ __exportStar(require("./reciple/classes/CommandCooldownManager"), exports);
 __exportStar(require("./reciple/classes/MessageCommandOptionManager"), exports);
 __exportStar(require("./reciple/classes/RecipleClient"), exports);
 __exportStar(require("./reciple/classes/RecipleConfig"), exports);
-__exportStar(require("./reciple/classes/builders/InteractionCommandBuilder"), exports);
+__exportStar(require("./reciple/classes/builders/SlashCommandBuilder"), exports);
 __exportStar(require("./reciple/classes/builders/MessageCommandBuilder"), exports);
 __exportStar(require("./reciple/classes/builders/MessageCommandOptionBuilder"), exports);
 __exportStar(require("./reciple/types/builders"), exports);

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

@@ -2,8 +2,8 @@ import { RecipleModule } from '../modules';
 import { ApplicationCommandBuilder } from '../registerInteractionCommands';
 import { RecipleCommandBuilder, RecipleCommandBuilderType } from '../types/builders';
 import { RecipleAddModuleOptions } from '../types/paramOptions';
-import { InteractionCommandBuilder, InteractionCommandExecuteData } from './builders/InteractionCommandBuilder';
 import { MessageCommandBuilder, MessageCommandExecuteData } from './builders/MessageCommandBuilder';
+import { SlashCommandBuilder, SlashCommandExecuteData } from './builders/SlashCommandBuilder';
 import { CommandCooldownManager } from './CommandCooldownManager';
 import { Config } from './RecipleConfig';
 import { ApplicationCommandData, Awaitable, ChatInputCommandInteraction, Client, ClientEvents, ClientOptions, Interaction, Message } from 'discord.js';
@@ -21,8 +21,8 @@ export interface RecipleClientCommands {
     messageCommands: {
         [commandName: string]: MessageCommandBuilder;
     };
-    interactionCommands: {
-        [commandName: string]: InteractionCommandBuilder;
+    slashCommands: {
+        [commandName: string]: SlashCommandBuilder;
     };
 }
 /**
@@ -30,7 +30,7 @@ export interface RecipleClientCommands {
  */
 export interface RecipleClientEvents extends ClientEvents {
     recipleMessageCommandCreate: [executeData: MessageCommandExecuteData];
-    recipleInteractionCommandCreate: [executeData: InteractionCommandExecuteData];
+    recipleInteractionCommandCreate: [executeData: SlashCommandExecuteData];
     recipleReplyError: [error: unknown];
 }
 /**
@@ -49,6 +49,9 @@ export interface RecipleClient<Ready extends boolean = boolean> extends Client<R
     removeAllListeners(event?: string | symbol): this;
     isReady(): this is RecipleClient<true>;
 }
+/**
+ * The reciple client
+ */
 export declare class RecipleClient<Ready extends boolean = boolean> extends Client<Ready> {
     config: Config;
     commands: RecipleClientCommands;
@@ -67,7 +70,7 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
      */
     startModules(folder?: string): Promise<RecipleClient<Ready>>;
     /**
-     * Execute `onLoad()` from client modules and register interaction commands if enabled
+     * Execute `onLoad()` from client modules and register application commands if enabled
      */
     loadModules(): Promise<RecipleClient<Ready>>;
     /**
@@ -76,8 +79,8 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
      */
     addModule(options: RecipleAddModuleOptions): Promise<void>;
     /**
-     * Add interaction or message command to client
-     * @param command Interaction/Message command builder
+     * Add slash or message command to client
+     * @param command Slash/Message command builder
      */
     addCommand(command: RecipleCommandBuilder): RecipleClient<Ready>;
     /**
@@ -91,10 +94,10 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
      */
     messageCommandExecute(message: Message, prefix?: string): Promise<void | MessageCommandExecuteData>;
     /**
-     * Execute an Interaction command
-     * @param interaction Command Interaction
+     * Execute a slash command
+     * @param interaction Slash command interaction
      */
-    interactionCommandExecute(interaction: Interaction | ChatInputCommandInteraction): Promise<void | InteractionCommandExecuteData>;
+    slashCommandExecute(interaction: Interaction | ChatInputCommandInteraction): Promise<void | SlashCommandExecuteData>;
     /**
      * Get a message from config
      * @param messageKey Config messages key
@@ -107,7 +110,7 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
      * @param type Command type
      */
     findCommand(command: string, type: RecipleCommandBuilderType.MessageCommand): MessageCommandBuilder | undefined;
-    findCommand(command: string, type: RecipleCommandBuilderType.InteractionCommand): InteractionCommandBuilder | undefined;
+    findCommand(command: string, type: RecipleCommandBuilderType.SlashCommand): SlashCommandBuilder | undefined;
     /**
      * Returns true if client logs is enabled
      */
@@ -126,7 +129,7 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
     /**
      * Error message when a command fails to execute
      * @param err Received error
-     * @param command Interaction/Message command execute data
+     * @param command Slash/Message command execute data
      */
     private _commandExecuteError;
 }

package/bin/reciple/classes/RecipleClient.js

@@ -24,6 +24,9 @@ const MessageCommandOptionManager_1 = require("./MessageCommandOptionManager");
 const RecipleConfig_1 = require("./RecipleConfig");
 const discord_js_1 = require("discord.js");
 const fallout_utility_1 = require("fallout-utility");
+/**
+ * The reciple client
+ */
 class RecipleClient extends discord_js_1.Client {
     /**
      * @param options Client options
@@ -32,7 +35,7 @@ class RecipleClient extends discord_js_1.Client {
         var _a, _b, _c;
         super(options);
         this.config = RecipleConfig_1.RecipleConfig.getDefaultConfig();
-        this.commands = { messageCommands: {}, interactionCommands: {} };
+        this.commands = { messageCommands: {}, slashCommands: {} };
         this.otherApplicationCommandData = [];
         this.commandCooldowns = new CommandCooldownManager_1.CommandCooldownManager();
         this.modules = [];
@@ -60,7 +63,7 @@ class RecipleClient extends discord_js_1.Client {
         });
     }
     /**
-     * Execute `onLoad()` from client modules and register interaction commands if enabled
+     * Execute `onLoad()` from client modules and register application commands if enabled
      */
     loadModules() {
         var _a, _b;
@@ -86,13 +89,13 @@ 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.messageCommands).length} message commands loaded.`);
-                this.logger.info(`${Object.keys(this.commands.interactionCommands).length} interaction commands loaded.`);
+                this.logger.info(`${Object.keys(this.commands.slashCommands).length} slash commands loaded.`);
             }
-            if (this.config.commands.interactionCommand.registerCommands) {
-                yield (0, registerInteractionCommands_1.registerInteractionCommands)({
+            if (this.config.commands.slashCommand.registerCommands) {
+                yield (0, registerInteractionCommands_1.registerApplicationCommands)({
                     client: this,
-                    commands: [...Object.values(this.commands.interactionCommands), ...this.otherApplicationCommandData],
-                    guilds: this.config.commands.interactionCommand.guilds
+                    commands: [...Object.values(this.commands.slashCommands), ...this.otherApplicationCommandData],
+                    guilds: this.config.commands.slashCommand.guilds
                 });
             }
             return this;
@@ -106,7 +109,7 @@ class RecipleClient extends discord_js_1.Client {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const { script } = options;
-            const registerCommands = options.registerInteractionCommands;
+            const registerCommands = options.registerApplicationCommands;
             const info = options.moduleInfo;
             this.modules.push({
                 script,
@@ -122,24 +125,24 @@ class RecipleClient extends discord_js_1.Client {
                 this.addCommand(command);
             }
             if (registerCommands)
-                yield (0, registerInteractionCommands_1.registerInteractionCommands)({
+                yield (0, registerInteractionCommands_1.registerApplicationCommands)({
                     client: this,
-                    commands: [...Object.values(this.commands.interactionCommands), ...this.otherApplicationCommandData],
-                    guilds: this.config.commands.interactionCommand.guilds
+                    commands: [...Object.values(this.commands.slashCommands), ...this.otherApplicationCommandData],
+                    guilds: this.config.commands.slashCommand.guilds
                 });
         });
     }
     /**
-     * Add interaction or message command to client
-     * @param command Interaction/Message command builder
+     * Add slash or message command to client
+     * @param command Slash/Message command builder
      */
     addCommand(command) {
         var _a;
         if (command.builder === builders_1.RecipleCommandBuilderType.MessageCommand) {
             this.commands.messageCommands[command.name] = command;
         }
-        else if (command.builder === builders_1.RecipleCommandBuilderType.InteractionCommand) {
-            this.commands.interactionCommands[command.name] = command;
+        else if (command.builder === builders_1.RecipleCommandBuilderType.SlashCommand) {
+            this.commands.slashCommands[command.name] = command;
         }
         else if (this.isClientLogsEnabled()) {
             this.logger.error(`Unknow command "${(_a = typeof command) !== null && _a !== void 0 ? _a : 'unknown'}".`);
@@ -152,8 +155,8 @@ class RecipleClient extends discord_js_1.Client {
     addCommandListeners() {
         if (this.config.commands.messageCommand.enabled)
             this.on('messageCreate', (message) => { this.messageCommandExecute(message); });
-        if (this.config.commands.interactionCommand.enabled)
-            this.on('interactionCreate', (interaction) => { this.interactionCommandExecute(interaction); });
+        if (this.config.commands.slashCommand.enabled)
+            this.on('interactionCreate', (interaction) => { this.slashCommandExecute(interaction); });
         return this;
     }
     /**
@@ -244,26 +247,26 @@ class RecipleClient extends discord_js_1.Client {
         });
     }
     /**
-     * Execute an Interaction command
-     * @param interaction Command Interaction
+     * Execute a slash command
+     * @param interaction Slash command interaction
      */
-    interactionCommandExecute(interaction) {
+    slashCommandExecute(interaction) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             if (!interaction || interaction.type !== discord_js_1.InteractionType.ApplicationCommand || !interaction.isChatInputCommand() || !this.isReady())
                 return;
-            const command = this.findCommand(interaction.commandName, builders_1.RecipleCommandBuilderType.InteractionCommand);
+            const command = this.findCommand(interaction.commandName, builders_1.RecipleCommandBuilderType.SlashCommand);
             if (!command)
                 return;
             const executeData = {
-                interaction: interaction,
+                interaction,
                 builder: command,
                 client: this
             };
             if ((0, permissions_1.userHasCommandPermissions)({
                 builder: command,
                 memberPermissions: (_a = interaction.memberPermissions) !== null && _a !== void 0 ? _a : undefined,
-                commandPermissions: this.config.commands.interactionCommand.permissions
+                commandPermissions: this.config.commands.slashCommand.permissions
             })) {
                 if (!command || (0, permissions_1.isIgnoredChannel)(interaction.channelId, this.config.ignoredChannels))
                     return;
@@ -278,12 +281,12 @@ class RecipleClient extends discord_js_1.Client {
                     command: command.name,
                     channel: (_b = interaction.channel) !== null && _b !== void 0 ? _b : undefined,
                     guild: interaction.guild,
-                    type: builders_1.RecipleCommandBuilderType.InteractionCommand
+                    type: builders_1.RecipleCommandBuilderType.SlashCommand
                 };
-                if (this.config.commands.interactionCommand.enableCooldown && command.cooldown && !this.commandCooldowns.isCooledDown(userCooldown)) {
+                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 }));
                 }
-                else if (this.config.commands.interactionCommand.enableCooldown && command.cooldown) {
+                else if (this.config.commands.slashCommand.enableCooldown && command.cooldown) {
                     if (!(yield this._haltCommand(command, 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));
                     }
@@ -318,8 +321,8 @@ class RecipleClient extends discord_js_1.Client {
     findCommand(command, type) {
         var _a;
         switch (type) {
-            case builders_1.RecipleCommandBuilderType.InteractionCommand:
-                return this.commands.interactionCommands[command];
+            case builders_1.RecipleCommandBuilderType.SlashCommand:
+                return this.commands.slashCommands[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())))
@@ -346,7 +349,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.RecipleCommandBuilderType.InteractionCommand
+                    ? yield (command.builder == builders_1.RecipleCommandBuilderType.SlashCommand
                         ? Promise.resolve(command.halt(haltData))
                         : Promise.resolve(command.halt(haltData))).catch(err => { throw err; })
                     : false)) !== null && _a !== void 0 ? _a : false;
@@ -363,12 +366,12 @@ class RecipleClient extends discord_js_1.Client {
     /**
      * Error message when a command fails to execute
      * @param err Received error
-     * @param command Interaction/Message command execute data
+     * @param command Slash/Message command execute data
      */
     _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.RecipleCommandBuilderType.MessageCommand ? 'message' : 'interaction'} command "${command.builder.name}"`);
+                this.logger.error(`An error occured executing ${command.builder.builder == builders_1.RecipleCommandBuilderType.MessageCommand ? 'message' : 'slash'} command "${command.builder.name}"`);
                 this.logger.error(err);
             }
             if (!err || !command)
@@ -379,7 +382,7 @@ class RecipleClient extends discord_js_1.Client {
                 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) {
-                if (!this.config.commands.interactionCommand.replyOnError)
+                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

@@ -24,7 +24,7 @@ export interface Config {
                 commands: ConfigCommandPermissions[];
             };
         };
-        interactionCommand: {
+        slashCommand: {
             enabled: boolean;
             replyOnError: boolean;
             registerCommands: boolean;
@@ -55,6 +55,7 @@ export interface Config {
     };
     ignoredFiles: string[];
     modulesFolder: string;
+    disableVersionCheck: boolean;
     version: string;
 }
 /**

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

@@ -0,0 +1,56 @@
+import { RecipleCommandBuilderType } from '../../types/builders';
+import { RecipleHaltedCommandData } from '../../types/commands';
+import { RecipleClient } from '../RecipleClient';
+import { Awaitable, ChatInputCommandInteraction, PermissionResolvable, SlashCommandBuilder as DiscordJsSlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder, SlashCommandSubcommandsOnlyBuilder as DiscordJsSlashCommandSubcommandsOnlyBuilder } from 'discord.js';
+/**
+ * Execute data for interaction command
+ */
+export interface SlashCommandExecuteData {
+    interaction: ChatInputCommandInteraction;
+    builder: SlashCommandBuilder;
+    client: RecipleClient<true>;
+}
+export interface SlashCommandSubcommandsOnlyBuilder extends DiscordJsSlashCommandSubcommandsOnlyBuilder, Pick<SlashCommandBuilder, "setCooldown" | "setRequiredBotPermissions" | "setRequiredMemberPermissions" | "setHalt" | "setExecute"> {
+}
+export interface SlashCommandBuilder extends DiscordJsSlashCommandBuilder {
+    addSubcommandGroup(input: SlashCommandSubcommandGroupBuilder | ((subcommandGroup: SlashCommandSubcommandGroupBuilder) => SlashCommandSubcommandGroupBuilder)): SlashCommandSubcommandsOnlyBuilder;
+    addSubcommand(input: SlashCommandSubcommandBuilder | ((subcommandGroup: SlashCommandSubcommandBuilder) => SlashCommandSubcommandBuilder)): SlashCommandSubcommandsOnlyBuilder;
+}
+/**
+ * Reciple builder for interaction/slash command
+ */
+export declare class SlashCommandBuilder extends DiscordJsSlashCommandBuilder {
+    readonly builder = RecipleCommandBuilderType.SlashCommand;
+    cooldown: number;
+    requiredBotPermissions: PermissionResolvable[];
+    requiredMemberPermissions: PermissionResolvable[];
+    allowExecuteInDM: boolean;
+    halt?: (haltData: RecipleHaltedCommandData<SlashCommandBuilder>) => Awaitable<boolean | void>;
+    execute: (executeData: SlashCommandExecuteData) => Awaitable<void>;
+    /**
+     * Sets the execute cooldown for this command.
+     * - `0` means no cooldown
+     * @param cooldown Command cooldown in milliseconds
+     */
+    setCooldown(cooldown: number): SlashCommandBuilder;
+    /**
+     * Set required bot permissions to execute the command
+     * @param permissions Bot's required permissions
+     */
+    setRequiredBotPermissions(...permissions: PermissionResolvable[]): SlashCommandBuilder;
+    /**
+     * Set required permissions to execute the command
+     * @param permissions User's return permissions
+     */
+    setRequiredMemberPermissions(...permissions: PermissionResolvable[]): SlashCommandBuilder;
+    /**
+     * Function when the command is interupted
+     * @param halt Function to execute when command is halted
+     */
+    setHalt(halt?: (haltData: RecipleHaltedCommandData<SlashCommandBuilder>) => Awaitable<boolean | void>): SlashCommandBuilder;
+    /**
+     * Function when the command is executed
+     * @param execute Function to execute when the command is called
+     */
+    setExecute(execute: (executeData: SlashCommandExecuteData) => void): SlashCommandBuilder;
+}

package/bin/reciple/classes/builders/{InteractionCommandBuilder.js → SlashCommandBuilder.js}

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InteractionCommandBuilder = void 0;
+exports.SlashCommandBuilder = void 0;
 const builders_1 = require("../../types/builders");
 const discord_js_1 = require("discord.js");
 /**
  * Reciple builder for interaction/slash command
  */
-class InteractionCommandBuilder extends discord_js_1.SlashCommandBuilder {
+class SlashCommandBuilder extends discord_js_1.SlashCommandBuilder {
     constructor() {
         super(...arguments);
-        this.builder = builders_1.RecipleCommandBuilderType.InteractionCommand;
+        this.builder = builders_1.RecipleCommandBuilderType.SlashCommand;
         this.cooldown = 0;
         this.requiredBotPermissions = [];
         this.requiredMemberPermissions = [];
@@ -60,4 +60,4 @@ class InteractionCommandBuilder extends discord_js_1.SlashCommandBuilder {
         return this;
     }
 }
-exports.InteractionCommandBuilder = InteractionCommandBuilder;
+exports.SlashCommandBuilder = SlashCommandBuilder;

package/bin/reciple/modules.js

@@ -44,13 +44,13 @@ function loadModules(client, folder) {
                 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)))
+                if (!client.config.disableVersionCheck && !versions.some(v => (0, version_1.isSupportedVersion)(v, version_1.version)))
                     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) {
                     for (const command of module_.commands) {
-                        if (command.builder === builders_1.RecipleCommandBuilderType.MessageCommand || command.builder === builders_1.RecipleCommandBuilderType.InteractionCommand) {
+                        if (command.builder === builders_1.RecipleCommandBuilderType.MessageCommand || command.builder === builders_1.RecipleCommandBuilderType.SlashCommand) {
                             commands.push(command);
                         }
                     }

package/bin/reciple/registerInteractionCommands.d.ts

@@ -1,9 +1,9 @@
-import { InteractionCommandBuilder } from './classes/builders/InteractionCommandBuilder';
-import { RecipleRegisterInteractionCommandsOptions } from './types/paramOptions';
-import { ContextMenuCommandBuilder, SlashCommandBuilder } from '@discordjs/builders';
-export declare type ApplicationCommandBuilder = InteractionCommandBuilder | ContextMenuCommandBuilder | SlashCommandBuilder;
+import { SlashCommandBuilder } from './classes/builders/SlashCommandBuilder';
+import { RecipleRegisterApplicationCommandsOptions } from './types/paramOptions';
+import { ContextMenuCommandBuilder, SlashCommandBuilder as DiscordJsSlashCommandBuilder } from 'discord.js';
+export declare type ApplicationCommandBuilder = SlashCommandBuilder | ContextMenuCommandBuilder | DiscordJsSlashCommandBuilder;
 /**
- * Register interaction commands
- * @param options Register interaction commands options
+ * Register application commands
+ * @param options Register application commands options
  */
-export declare function registerInteractionCommands(options: RecipleRegisterInteractionCommandsOptions): Promise<void>;
+export declare function registerApplicationCommands(options: RecipleRegisterApplicationCommandsOptions): Promise<void>;

package/bin/reciple/registerInteractionCommands.js

@@ -9,31 +9,32 @@ 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");
+exports.registerApplicationCommands = void 0;
+const SlashCommandBuilder_1 = require("./classes/builders/SlashCommandBuilder");
 /**
- * Register interaction commands
- * @param options Register interaction commands options
+ * Register application commands
+ * @param options Register application commands options
  */
-function registerInteractionCommands(options) {
+function registerApplicationCommands(options) {
     var _a, _b, _c, _d;
     return __awaiter(this, void 0, void 0, function* () {
         const client = options.client;
         const guilds = typeof options.guilds == 'string' ? [options.guilds] : options.guilds;
-        const commands = (_b = Object.values((_a = options.commands) !== null && _a !== void 0 ? _a : client.commands.interactionCommands).map(cmd => {
+        const commands = (_b = Object.values((_a = options.commands) !== null && _a !== void 0 ? _a : client.commands.slashCommands).map(cmd => {
             var _a;
             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 = 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
+            if (cmd instanceof SlashCommandBuilder_1.SlashCommandBuilder && client.config.commands.slashCommand.setRequiredPermissions) {
+                const permissions = client.config.commands.slashCommand.permissions.enabled
+                    ? (_a = client.config.commands.slashCommand.permissions.commands.find(cmd_ => cmd_.command.toLowerCase() === cmd.name.toLowerCase())) === null || _a === void 0 ? void 0 : _a.permissions
                     : undefined;
-                if (permissions)
+                if (permissions) {
                     cmd.setRequiredMemberPermissions(...permissions);
-                client.commands.interactionCommands[cmd.name] = cmd;
-                if (client.isClientLogsEnabled())
-                    client.logger.debug(`Set required permissions for ${cmd.name}`);
+                    if (client.isClientLogsEnabled())
+                        client.logger.debug(`Set required permissions for ${cmd.name}`);
+                }
+                client.commands.slashCommands[cmd.name] = cmd;
                 return cmd.toJSON();
             }
             return cmd.toJSON();
@@ -43,21 +44,21 @@ function registerInteractionCommands(options) {
         if (!guilds || !(guilds === null || guilds === void 0 ? void 0 : guilds.length)) {
             (_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.');
+                    client.logger.warn('No guilds were specified for application commands. Registered application commands globally.');
             });
         }
         else {
             if (client.isClientLogsEnabled())
-                client.logger.warn(`Registering ${commands.length} interaction commands to ${guilds.length} guild(s).`);
+                client.logger.warn(`Registering ${commands.length} application commands to ${guilds.length} guild(s).`);
             for (const guild of guilds) {
                 if (!guild)
                     continue;
                 (_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}.`);
+                        client.logger.warn(`Registered ${commands.length} application command(s) for ${guild}.`);
                 });
             }
         }
     });
 }
-exports.registerInteractionCommands = registerInteractionCommands;
+exports.registerApplicationCommands = registerApplicationCommands;

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

@@ -1,17 +1,17 @@
-import { InteractionCommandBuilder, InteractionCommandExecuteData } from '../classes/builders/InteractionCommandBuilder';
 import { MessageCommandBuilder, MessageCommandExecuteData } from '../classes/builders/MessageCommandBuilder';
+import { SlashCommandBuilder, SlashCommandExecuteData } from '../classes/builders/SlashCommandBuilder';
 /**
  * Reciple command builders
  */
-export declare type RecipleCommandBuilder = MessageCommandBuilder | InteractionCommandBuilder;
+export declare type RecipleCommandBuilder = MessageCommandBuilder | SlashCommandBuilder;
 /**
  * Reciple command builders execute data
  */
-export declare type RecipleCommandBuildersExecuteData = InteractionCommandExecuteData | MessageCommandExecuteData;
+export declare type RecipleCommandBuildersExecuteData = SlashCommandExecuteData | MessageCommandExecuteData;
 /**
  * Types of Reciple command builders
  */
 export declare enum RecipleCommandBuilderType {
     MessageCommand = 0,
-    InteractionCommand = 1
+    SlashCommand = 1
 }

package/bin/reciple/types/builders.js

@@ -7,5 +7,5 @@ exports.RecipleCommandBuilderType = void 0;
 var RecipleCommandBuilderType;
 (function (RecipleCommandBuilderType) {
     RecipleCommandBuilderType[RecipleCommandBuilderType["MessageCommand"] = 0] = "MessageCommand";
-    RecipleCommandBuilderType[RecipleCommandBuilderType["InteractionCommand"] = 1] = "InteractionCommand";
+    RecipleCommandBuilderType[RecipleCommandBuilderType["SlashCommand"] = 1] = "SlashCommand";
 })(RecipleCommandBuilderType = exports.RecipleCommandBuilderType || (exports.RecipleCommandBuilderType = {}));

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

@@ -1,14 +1,14 @@
-import { InteractionCommandBuilder, InteractionCommandExecuteData } from '../classes/builders/InteractionCommandBuilder';
 import { MessageCommandExecuteData } from '../classes/builders/MessageCommandBuilder';
+import { SlashCommandBuilder, SlashCommandExecuteData } from '../classes/builders/SlashCommandBuilder';
 import { CooledDownUser } from '../classes/CommandCooldownManager';
 import { MessageCommandOptionManager } from '../classes/MessageCommandOptionManager';
 import { RecipleCommandBuilder } from '../types/builders';
 /**
  * Halted command's data
  */
-export declare type RecipleHaltedCommandData<Builder extends RecipleCommandBuilder = RecipleCommandBuilder> = RecipleCommandErrorData<Builder> | RecipleCommandCooldownData<Builder> | (Builder extends InteractionCommandBuilder ? never : RecipleCommandInvalidArguments<Builder> | RecipleCommandMissingArguments<Builder>) | RecipleCommandMissingMemberPermissions<Builder> | RecipleCommandMissingBotPermissions<Builder>;
+export declare type RecipleHaltedCommandData<Builder extends RecipleCommandBuilder = RecipleCommandBuilder> = RecipleCommandErrorData<Builder> | RecipleCommandCooldownData<Builder> | (Builder extends SlashCommandBuilder ? never : RecipleCommandInvalidArguments<Builder> | RecipleCommandMissingArguments<Builder>) | RecipleCommandMissingMemberPermissions<Builder> | RecipleCommandMissingBotPermissions<Builder>;
 export interface RecipleCommandHaltBaseData<Builder extends RecipleCommandBuilder> {
-    executeData: Builder extends InteractionCommandBuilder ? InteractionCommandExecuteData : MessageCommandExecuteData;
+    executeData: Builder extends SlashCommandBuilder ? SlashCommandExecuteData : MessageCommandExecuteData;
 }
 export interface RecipleCommandErrorData<Builder extends RecipleCommandBuilder> extends RecipleCommandHaltBaseData<Builder> {
     reason: RecipleHaltedCommandReason.Error;

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

@@ -10,15 +10,15 @@ export interface RecipleAddModuleOptions {
      */
     script: RecipleScript;
     /**
-     * Register interaction commands if possible
+     * Register application commands if possible
      */
-    registerInteractionCommands?: boolean;
+    registerApplicationCommands?: boolean;
     /**
      * Module optional info
      */
     moduleInfo?: RecipleModule["info"];
 }
-export interface RecipleRegisterInteractionCommandsOptions {
+export interface RecipleRegisterApplicationCommandsOptions {
     /**
      * Bot client
      */
@@ -27,7 +27,7 @@ export interface RecipleRegisterInteractionCommandsOptions {
      * Commands to register
      */
     commands: (ApplicationCommandData | ApplicationCommandBuilder)[];
-    /**PermissionResolvable
+    /**
      * Set guild to not register commands globally
      */
     guilds?: string | string[];
@@ -35,5 +35,5 @@ export interface RecipleRegisterInteractionCommandsOptions {
 export interface RecipleUserHasCommandPermissionsOptions {
     builder: RecipleCommandBuilder;
     memberPermissions?: PermissionsBitField;
-    commandPermissions?: Config["commands"]["interactionCommand"]["permissions"] | Config["commands"]["messageCommand"]["permissions"];
+    commandPermissions?: Config["commands"]["slashCommand"]["permissions"] | Config["commands"]["messageCommand"]["permissions"];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reciple",
-  "version": "3.1.4",
+  "version": "4.0.0-pre.1",
   "bin": "bin/bin.js",
   "license": "GPL-3.0",
   "main": "bin/index.js",
@@ -22,7 +22,7 @@
     "clean": "rm -rf bin",
     "build": "yarn clean && yarn exec tsc",
     "build:publish": "yarn build && yarn npm publish && yarn build:docs && yarn publish:docs",
-    "build:pub-prerelease": "yarn build && yarn publish --tag pre",
+    "build:pub-prerelease": "yarn build && yarn npm publish --tag pre",
     "build:docs": "yarn exec typedoc --tsconfig ./docs/typedoc.json",
     "update:docs": "yarn workspace docs update",
     "test": "yarn build && yarn test:start",
@@ -58,7 +58,6 @@
   "devDependencies": {
     "@types/node": "^18.6.1",
     "@types/semver": "^7.3.10",
-    "better-docs": "^2.7.2",
     "discord.js": "^14.0.3",
     "typedoc": "^0.23.9",
     "typedoc-plugin-discord-types": "^1.0.2",
@@ -67,7 +66,7 @@
     "typescript": "^4.7.4"
   },
   "peerDependencies": {
-    "discord.js": "14.0.x"
+    "discord.js": "^14.0.3"
   },
   "packageManager": "yarn@3.2.2"
 }

package/resource/reciple.yml

@@ -27,7 +27,7 @@ commands:
           permissions: ['Administrator']
 
   # Interaction command options
-  interactionCommand:
+  slashCommand:
     # enable interaction commands
     enabled: true
     # reply when an error occured
@@ -116,5 +116,8 @@ ignoredFiles: []
 # Modules folder
 modulesFolder: 'modules'
 
+# Load modules regardless of its supported versions
+disableVersionCheck: false
+
 # Current version
 version: ^VERSION

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

@@ -1,50 +0,0 @@
-import { RecipleCommandBuilderType } from '../../types/builders';
-import { RecipleHaltedCommandData } from '../../types/commands';
-import { RecipleClient } from '../RecipleClient';
-import { Awaitable, ChatInputCommandInteraction, PermissionResolvable, SlashCommandBuilder } from 'discord.js';
-/**
- * Execute data for interaction command
- */
-export interface InteractionCommandExecuteData {
-    interaction: ChatInputCommandInteraction;
-    builder: InteractionCommandBuilder;
-    client: RecipleClient<true>;
-}
-/**
- * Reciple builder for interaction/slash command
- */
-export declare class InteractionCommandBuilder extends SlashCommandBuilder {
-    readonly builder = RecipleCommandBuilderType.InteractionCommand;
-    cooldown: number;
-    requiredBotPermissions: PermissionResolvable[];
-    requiredMemberPermissions: PermissionResolvable[];
-    allowExecuteInDM: boolean;
-    halt?: (haltData: RecipleHaltedCommandData<InteractionCommandBuilder>) => Awaitable<boolean | void>;
-    execute: (executeData: InteractionCommandExecuteData) => Awaitable<void>;
-    /**
-     * Sets the execute cooldown for this command.
-     * - `0` means no cooldown
-     * @param cooldown Command cooldown in milliseconds
-     */
-    setCooldown(cooldown: number): InteractionCommandBuilder;
-    /**
-     * Set required bot permissions to execute the command
-     * @param permissions Bot's required permissions
-     */
-    setRequiredBotPermissions(...permissions: PermissionResolvable[]): InteractionCommandBuilder;
-    /**
-     * Set required permissions to execute the command
-     * @param permissions User's return permissions
-     */
-    setRequiredMemberPermissions(...permissions: PermissionResolvable[]): InteractionCommandBuilder;
-    /**
-     * Function when the command is interupted
-     * @param halt Function to execute when command is halted
-     */
-    setHalt(halt?: (haltData: RecipleHaltedCommandData<InteractionCommandBuilder>) => Awaitable<boolean | void>): InteractionCommandBuilder;
-    /**
-     * Function when the command is executed
-     * @param execute Function to execute when the command is called
-     */
-    setExecute(execute: (executeData: InteractionCommandExecuteData) => void): InteractionCommandBuilder;
-}