reciple 5.6.0 → 6.0.0-dev.2

package/dist/types/reciple/classes/builders/MessageCommandBuilder.d.ts

@@ -1,7 +1,7 @@
 import { CommandBuilderType, CommandHaltFunction, CommandExecuteFunction, SharedCommandBuilderProperties, MessageCommandData } from '../../types/builders';
 import { Message, PermissionResolvable, RestOrArray } from 'discord.js';
 import { BaseCommandExecuteData, CommandHaltData } from '../../types/commands';
-import { MessageCommandOptionManager } from '../MessageCommandOptionManager';
+import { MessageCommandOptionManager } from '../managers/MessageCommandOptionManager';
 import { MessageCommandOptionBuilder } from './MessageCommandOptionBuilder';
 import { Command } from 'fallout-utility';
 /**
@@ -80,7 +80,7 @@ export declare class MessageCommandBuilder<T = unknown> implements SharedCommand
     halt?: MessageCommandHaltFunction<T>;
     execute: MessageCommandExecuteFunction<T>;
     metadata?: T;
-    constructor(data?: Partial<Omit<MessageCommandData<T>, "type">>);
+    constructor(data?: Partial<Omit<MessageCommandData<T>, 'type'>>);
     /**
      * Sets the command name
      * @param name Command name

package/dist/types/reciple/classes/builders/SlashCommandBuilder.d.ts

@@ -26,20 +26,20 @@ export declare type SlashCommandHaltFunction<T = unknown> = CommandHaltFunction<
  * Slash command execute function
  */
 export declare type SlashCommandExecuteFunction<T = unknown> = CommandExecuteFunction<CommandBuilderType.SlashCommand, T>;
-export declare type SlashCommandSubcommandsOnlyBuilder<T = unknown> = Omit<SlashCommandBuilder<T>, "addBooleanOption" | "addUserOption" | "addChannelOption" | "addRoleOption" | "addAttachmentOption" | "addMentionableOption" | "addStringOption" | "addIntegerOption" | "addNumberOption">;
-export declare type SlashCommandOptionsOnlyBuilder<T = unknown> = Omit<SlashCommandBuilder<T>, "addSubcommand" | "addSubcommandGroup">;
+export declare type SlashCommandSubcommandsOnlyBuilder<T = unknown> = Omit<SlashCommandBuilder<T>, 'addBooleanOption' | 'addUserOption' | 'addChannelOption' | 'addRoleOption' | 'addAttachmentOption' | 'addMentionableOption' | 'addStringOption' | 'addIntegerOption' | 'addNumberOption'>;
+export declare type SlashCommandOptionsOnlyBuilder<T = unknown> = Omit<SlashCommandBuilder<T>, 'addSubcommand' | 'addSubcommandGroup'>;
 export interface SlashCommandBuilder<T = unknown> extends DiscordJsSlashCommandBuilder {
     addSubcommandGroup(input: SlashCommandSubcommandGroupBuilder | ((subcommandGroup: SlashCommandSubcommandGroupBuilder) => SlashCommandSubcommandGroupBuilder)): SlashCommandSubcommandsOnlyBuilder;
     addSubcommand(input: SlashCommandSubcommandBuilder | ((subcommandGroup: SlashCommandSubcommandBuilder) => SlashCommandSubcommandBuilder)): SlashCommandSubcommandsOnlyBuilder;
-    addBooleanOption(input: SlashCommandBooleanOption | ((builder: SlashCommandBooleanOption) => SlashCommandBooleanOption)): Omit<this, "addSubcommand" | "addSubcommandGroup">;
-    addUserOption(input: SlashCommandUserOption | ((builder: SlashCommandUserOption) => SlashCommandUserOption)): Omit<this, "addSubcommand" | "addSubcommandGroup">;
-    addChannelOption(input: SlashCommandChannelOption | ((builder: SlashCommandChannelOption) => SlashCommandChannelOption)): Omit<this, "addSubcommand" | "addSubcommandGroup">;
-    addRoleOption(input: SlashCommandRoleOption | ((builder: SlashCommandRoleOption) => SlashCommandRoleOption)): Omit<this, "addSubcommand" | "addSubcommandGroup">;
-    addAttachmentOption(input: SlashCommandAttachmentOption | ((builder: SlashCommandAttachmentOption) => SlashCommandAttachmentOption)): Omit<this, "addSubcommand" | "addSubcommandGroup">;
-    addMentionableOption(input: SlashCommandMentionableOption | ((builder: SlashCommandMentionableOption) => SlashCommandMentionableOption)): Omit<this, "addSubcommand" | "addSubcommandGroup">;
-    addStringOption(input: SlashCommandStringOption | Omit<SlashCommandStringOption, 'setAutocomplete'> | Omit<SlashCommandStringOption, 'addChoices'> | ((builder: SlashCommandStringOption) => SlashCommandStringOption | Omit<SlashCommandStringOption, 'setAutocomplete'> | Omit<SlashCommandStringOption, 'addChoices'>)): Omit<this, "addSubcommand" | "addSubcommandGroup">;
-    addIntegerOption(input: SlashCommandIntegerOption | Omit<SlashCommandIntegerOption, 'setAutocomplete'> | Omit<SlashCommandIntegerOption, 'addChoices'> | ((builder: SlashCommandIntegerOption) => SlashCommandIntegerOption | Omit<SlashCommandIntegerOption, 'setAutocomplete'> | Omit<SlashCommandIntegerOption, 'addChoices'>)): Omit<this, "addSubcommand" | "addSubcommandGroup">;
-    addNumberOption(input: SlashCommandNumberOption | Omit<SlashCommandNumberOption, 'setAutocomplete'> | Omit<SlashCommandNumberOption, 'addChoices'> | ((builder: SlashCommandNumberOption) => SlashCommandNumberOption | Omit<SlashCommandNumberOption, 'setAutocomplete'> | Omit<SlashCommandNumberOption, 'addChoices'>)): Omit<this, "addSubcommand" | "addSubcommandGroup">;
+    addBooleanOption(input: SlashCommandBooleanOption | ((builder: SlashCommandBooleanOption) => SlashCommandBooleanOption)): Omit<this, 'addSubcommand' | 'addSubcommandGroup'>;
+    addUserOption(input: SlashCommandUserOption | ((builder: SlashCommandUserOption) => SlashCommandUserOption)): Omit<this, 'addSubcommand' | 'addSubcommandGroup'>;
+    addChannelOption(input: SlashCommandChannelOption | ((builder: SlashCommandChannelOption) => SlashCommandChannelOption)): Omit<this, 'addSubcommand' | 'addSubcommandGroup'>;
+    addRoleOption(input: SlashCommandRoleOption | ((builder: SlashCommandRoleOption) => SlashCommandRoleOption)): Omit<this, 'addSubcommand' | 'addSubcommandGroup'>;
+    addAttachmentOption(input: SlashCommandAttachmentOption | ((builder: SlashCommandAttachmentOption) => SlashCommandAttachmentOption)): Omit<this, 'addSubcommand' | 'addSubcommandGroup'>;
+    addMentionableOption(input: SlashCommandMentionableOption | ((builder: SlashCommandMentionableOption) => SlashCommandMentionableOption)): Omit<this, 'addSubcommand' | 'addSubcommandGroup'>;
+    addStringOption(input: SlashCommandStringOption | Omit<SlashCommandStringOption, 'setAutocomplete'> | Omit<SlashCommandStringOption, 'addChoices'> | ((builder: SlashCommandStringOption) => SlashCommandStringOption | Omit<SlashCommandStringOption, 'setAutocomplete'> | Omit<SlashCommandStringOption, 'addChoices'>)): Omit<this, 'addSubcommand' | 'addSubcommandGroup'>;
+    addIntegerOption(input: SlashCommandIntegerOption | Omit<SlashCommandIntegerOption, 'setAutocomplete'> | Omit<SlashCommandIntegerOption, 'addChoices'> | ((builder: SlashCommandIntegerOption) => SlashCommandIntegerOption | Omit<SlashCommandIntegerOption, 'setAutocomplete'> | Omit<SlashCommandIntegerOption, 'addChoices'>)): Omit<this, 'addSubcommand' | 'addSubcommandGroup'>;
+    addNumberOption(input: SlashCommandNumberOption | Omit<SlashCommandNumberOption, 'setAutocomplete'> | Omit<SlashCommandNumberOption, 'addChoices'> | ((builder: SlashCommandNumberOption) => SlashCommandNumberOption | Omit<SlashCommandNumberOption, 'setAutocomplete'> | Omit<SlashCommandNumberOption, 'addChoices'>)): Omit<this, 'addSubcommand' | 'addSubcommandGroup'>;
 }
 /**
  * Reciple builder for slash command
@@ -52,7 +52,7 @@ export declare class SlashCommandBuilder<T = unknown> extends DiscordJsSlashComm
     halt?: SlashCommandHaltFunction<T>;
     execute: SlashCommandExecuteFunction<T>;
     metadata?: T;
-    constructor(data?: Partial<Omit<SlashCommandData<T>, "type">>);
+    constructor(data?: Partial<Omit<SlashCommandData<T>, 'type'>>);
     setCooldown(cooldown: number): this;
     setRequiredBotPermissions(...permissions: RestOrArray<PermissionResolvable>): this;
     setRequiredMemberPermissions(...permissions: RestOrArray<PermissionResolvable>): this;

package/dist/types/reciple/classes/managers/ApplicationCommandManager.d.ts

@@ -0,0 +1,20 @@
+import { ApplicationCommand, ApplicationCommandData, ContextMenuCommandBuilder, GuildResolvable, RESTPostAPIApplicationCommandsJSONBody, SlashCommandBuilder as DiscordJsSlashCommandBuilder } from 'discord.js';
+import { AnySlashCommandBuilder } from '../../types/builders';
+import { RecipleClient } from '../RecipleClient';
+export declare type ApplicationCommandBuilder = AnySlashCommandBuilder | ContextMenuCommandBuilder | DiscordJsSlashCommandBuilder;
+export declare class ApplicationCommandManager {
+    readonly client: RecipleClient;
+    get commands(): import("discord.js").ApplicationCommandManager<ApplicationCommand<{
+        guild: GuildResolvable;
+    }>, {
+        guild: GuildResolvable;
+    }, null> | undefined;
+    constructor(client: RecipleClient);
+    set(commands: (ApplicationCommandBuilder | ApplicationCommandData)[], guilds?: GuildResolvable[]): Promise<void>;
+    add(command: ApplicationCommandBuilder | ApplicationCommandData, guilds?: GuildResolvable[]): Promise<void>;
+    remove(command: string | ApplicationCommand, guilds?: GuildResolvable[]): Promise<void>;
+    edit(command: string | ApplicationCommand, newCommand: ApplicationCommandBuilder | ApplicationCommandData, guilds?: GuildResolvable[]): Promise<void>;
+    get(command: ApplicationCommandData | ApplicationCommandBuilder | string, guild?: GuildResolvable): ApplicationCommand | undefined;
+    fetch(commandId: string, guild?: GuildResolvable): Promise<ApplicationCommand>;
+    protected parseCommands(commands: (ApplicationCommandData | ApplicationCommandBuilder | RESTPostAPIApplicationCommandsJSONBody)[], setPermissions?: boolean): (ApplicationCommandData | RESTPostAPIApplicationCommandsJSONBody)[];
+}

package/dist/types/reciple/classes/managers/ClientCommandManager.d.ts

@@ -0,0 +1,37 @@
+import { ApplicationCommandData, Collection, GuildResolvable, RestOrArray } from 'discord.js';
+import { AnyCommandBuilder, AnyCommandData, AnySlashCommandBuilder, CommandBuilderType, MessageCommandData, SlashCommandData } from '../../types/builders';
+import { MessageCommandBuilder } from '../builders/MessageCommandBuilder';
+import { SlashCommandBuilder } from '../builders/SlashCommandBuilder';
+import { RecipleClient } from '../RecipleClient';
+import { ApplicationCommandBuilder } from './ApplicationCommandManager';
+export interface ClientCommandManagerOptions {
+    client: RecipleClient;
+    messageCommands?: (MessageCommandBuilder | MessageCommandData)[];
+    slashCommands?: (AnySlashCommandBuilder | SlashCommandData)[];
+}
+export declare class ClientCommandManager {
+    readonly client: RecipleClient;
+    readonly slashCommands: Collection<string, AnySlashCommandBuilder>;
+    readonly messageCommands: Collection<string, MessageCommandBuilder>;
+    readonly additionalApplicationCommands: (ApplicationCommandBuilder | ApplicationCommandData)[];
+    get applicationCommandsSize(): number;
+    constructor(options: ClientCommandManagerOptions);
+    /**
+     * Add command to command manager
+     * @param commands Any command data or builder
+     */
+    add(...commands: RestOrArray<AnyCommandBuilder | AnyCommandData>): this;
+    /**
+     * Get command builder by name or alias if it's a message command
+     * @param command Command name
+     * @param type Command type
+     */
+    get(command: string, type?: undefined): AnyCommandBuilder | undefined;
+    get(command: string, type?: CommandBuilderType.MessageCommand): MessageCommandBuilder | undefined;
+    get(command: string, type?: CommandBuilderType.SlashCommand): SlashCommandBuilder | undefined;
+    /**
+     * Register application commands
+     * @param guilds Register application commands to guilds
+     */
+    registerApplicationCommands(...guilds: RestOrArray<GuildResolvable>): Promise<this>;
+}

package/dist/types/reciple/classes/managers/ClientModuleManager.d.ts

@@ -0,0 +1,79 @@
+import { Collection, GuildResolvable, RestOrArray } from 'discord.js';
+import { AnyCommandBuilder, AnyCommandData } from '../../types/builders';
+import { ModuleManagerResolveFilesOptions } from '../../types/paramOptions';
+import { RecipleClient } from '../RecipleClient';
+/**
+ * Reciple script object
+ */
+export interface RecipleScript {
+    /**
+     * Supported reciple versions
+     */
+    versions: string | string[];
+    /**
+     * Module commands
+     */
+    commands?: (AnyCommandBuilder | AnyCommandData)[];
+    /**
+     * Action on module start
+     * @param client Bot client
+     */
+    onStart(client: RecipleClient<false>): boolean | Promise<boolean>;
+    /**
+     * Action on bot ready
+     * @param client Bot client
+     */
+    onLoad?(client: RecipleClient<true>): void | Promise<void>;
+}
+/**
+ * Reciple module object
+ */
+export interface RecipleModule {
+    /**
+     * Module Id
+     */
+    id: string;
+    /**
+     * Module script
+     */
+    script: RecipleScript;
+    /**
+     * Module local information
+     */
+    info: {
+        /**
+         * Module file name
+         */
+        filename?: string;
+        /**
+         * Module local file path
+         */
+        path?: string;
+    };
+}
+export interface ResolvedModule extends RecipleModule {
+    commands: AnyCommandBuilder[];
+}
+export interface ResolvedScriptCommands {
+    script: RecipleScript;
+    commands: AnyCommandBuilder[];
+}
+export interface ClientModuleManagerOptions {
+    client: RecipleClient;
+    modules?: (RecipleModule & {
+        id?: string;
+    })[];
+}
+export declare class ClientModuleManager {
+    readonly client: RecipleClient;
+    readonly modules: Collection<string, ResolvedModule>;
+    constructor(options: ClientModuleManagerOptions);
+    startModulesFromFiles(options: ModuleManagerResolveFilesOptions): Promise<ResolvedModule[]>;
+    resolveModulesFromFiles(options: ModuleManagerResolveFilesOptions): Promise<ResolvedModule[]>;
+    resolveScriptCommands(...modules: RestOrArray<RecipleScript>): ResolvedScriptCommands[];
+    loadAll(registerApplicationCommands?: boolean, ...registerApplicationCommandsGuilds: RestOrArray<GuildResolvable>): Promise<void>;
+    startModule(mod: ResolvedModule): Promise<void>;
+    resolveModule(mod: RecipleModule, disabeVersionCheck?: boolean): ResolvedModule;
+    getModuleFiles(...folders: RestOrArray<string>): Promise<string[]>;
+    static getModuleDisplayId(mod: RecipleModule): string;
+}

package/dist/types/reciple/classes/{CommandCooldownManager.d.ts → managers/CommandCooldownManager.d.ts}

@@ -1,5 +1,5 @@
 import { Guild, RestOrArray, TextBasedChannel, User } from 'discord.js';
-import { CommandBuilderType } from '../types/builders';
+import { CommandBuilderType } from '../../types/builders';
 /**
  * cooled-down user object interface
  */
@@ -43,8 +43,9 @@ export declare class CommandCooldownManager extends Array<CooledDownUser> {
      * Remove cooldown from specific user, channel or guild
      * @param options Remove cooldown data options
      * @param limit Remove cooldown data limit
+     * @returns Returns the removed values
      */
-    remove(options: Partial<CooledDownUser>, limit?: number): void;
+    remove(options: Partial<CooledDownUser>, limit?: number): CooledDownUser[];
     /**
      * Check if the given user is cooled-down
      * @param options Options to identify if user is on cooldown

package/dist/types/reciple/classes/{MessageCommandOptionManager.d.ts → managers/MessageCommandOptionManager.d.ts}

@@ -1,4 +1,4 @@
-import { MessageCommandValidatedOption } from './builders/MessageCommandBuilder';
+import { MessageCommandValidatedOption } from '../builders/MessageCommandBuilder';
 import { RestOrArray } from 'discord.js';
 /**
  * Validated message options manager

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

@@ -88,12 +88,12 @@ export interface SharedCommandBuilderProperties<T = unknown> {
      * Function when the command is interupted
      * @param halt Function to execute when command is halted
      */
-    setHalt(halt?: this["halt"]): this;
+    setHalt(halt?: this['halt']): this;
     /**
      * Function when the command is executed
      * @param execute Function to execute when the command is called
      */
-    setExecute(execute: this["execute"]): this;
+    setExecute(execute: this['execute']): this;
     /**
      * Set a command metadata
      * @param metadata Command metadata
@@ -110,7 +110,7 @@ export interface SharedCommandDataProperties {
 /**
  * Slash command object data interface
  */
-export interface SlashCommandData<T = unknown> extends SharedCommandDataProperties, Partial<Omit<SharedCommandBuilderProperties<T>, "setCooldown" | "setRequiredBotPermissions" | "setRequiredMemberPermissions" | "setHalt" | "setExecute" | "setMetadata" | "halt" | "execute">> {
+export interface SlashCommandData<T = unknown> extends SharedCommandDataProperties, Partial<Omit<SharedCommandBuilderProperties<T>, 'setCooldown' | 'setRequiredBotPermissions' | 'setRequiredMemberPermissions' | 'setHalt' | 'setExecute' | 'setMetadata' | 'halt' | 'execute'>> {
     type: CommandBuilderType.SlashCommand;
     nameLocalizations?: LocalizationMap;
     descriptionLocalizations?: LocalizationMap;
@@ -124,7 +124,7 @@ export interface SlashCommandData<T = unknown> extends SharedCommandDataProperti
     halt?: SlashCommandHaltFunction<T>;
     execute: SlashCommandExecuteFunction<T>;
 }
-export interface SharedSlashCommandOptionData<V = string | number> extends SharedCommandDataProperties, Pick<SlashCommandData, "nameLocalizations" | "descriptionLocalizations"> {
+export interface SharedSlashCommandOptionData<V = string | number> extends SharedCommandDataProperties, Pick<SlashCommandData, 'nameLocalizations' | 'descriptionLocalizations'> {
     choices?: {
         name: string;
         nameLocalizations?: LocalizationMap;
@@ -133,13 +133,13 @@ export interface SharedSlashCommandOptionData<V = string | number> extends Share
     autocomplete?: boolean;
     required?: boolean;
 }
-export interface SlashCommandAttachmentOptionData extends Omit<SharedSlashCommandOptionData, "choices" | "autocomplete"> {
+export interface SlashCommandAttachmentOptionData extends Omit<SharedSlashCommandOptionData, 'choices' | 'autocomplete'> {
     type: ApplicationCommandOptionType.Attachment;
 }
-export interface SlashCommandBooleanOptionData extends Omit<SharedSlashCommandOptionData, "choices" | "autocomplete"> {
+export interface SlashCommandBooleanOptionData extends Omit<SharedSlashCommandOptionData, 'choices' | 'autocomplete'> {
     type: ApplicationCommandOptionType.Boolean;
 }
-export interface SlashCommandChannelOptionData extends Omit<SharedSlashCommandOptionData, "choices" | "autocomplete"> {
+export interface SlashCommandChannelOptionData extends Omit<SharedSlashCommandOptionData, 'choices' | 'autocomplete'> {
     type: ApplicationCommandOptionType.Channel;
     channelTypes?: ApplicationCommandOptionAllowedChannelTypes[];
 }
@@ -148,7 +148,7 @@ export interface SlashCommandIntegerOptionData extends SharedSlashCommandOptionD
     minValue?: number;
     maxValue?: number;
 }
-export interface SlashCommandMentionableOptionData extends Omit<SharedSlashCommandOptionData, "choices" | "autocomplete"> {
+export interface SlashCommandMentionableOptionData extends Omit<SharedSlashCommandOptionData, 'choices' | 'autocomplete'> {
     type: ApplicationCommandOptionType.Mentionable;
 }
 export interface SlashCommandNumberOptionData extends SharedSlashCommandOptionData<number> {
@@ -156,7 +156,7 @@ export interface SlashCommandNumberOptionData extends SharedSlashCommandOptionDa
     minValue?: number;
     maxValue?: number;
 }
-export interface SlashCommandRoleOptionData extends Omit<SharedSlashCommandOptionData, "choices" | "autocomplete"> {
+export interface SlashCommandRoleOptionData extends Omit<SharedSlashCommandOptionData, 'choices' | 'autocomplete'> {
     type: ApplicationCommandOptionType.Role;
 }
 export interface SlashCommandStringOptionData extends SharedSlashCommandOptionData<string> {
@@ -164,21 +164,21 @@ export interface SlashCommandStringOptionData extends SharedSlashCommandOptionDa
     minLength?: number;
     maxLength?: number;
 }
-export interface SlashCommandUserOptionData extends Omit<SharedSlashCommandOptionData, "choices" | "autocomplete"> {
+export interface SlashCommandUserOptionData extends Omit<SharedSlashCommandOptionData, 'choices' | 'autocomplete'> {
     type: ApplicationCommandOptionType.User;
 }
-export interface SlashCommandSubCommandData extends SharedCommandDataProperties, Pick<SlashCommandData, "nameLocalizations" | "descriptionLocalizations"> {
+export interface SlashCommandSubCommandData extends SharedCommandDataProperties, Pick<SlashCommandData, 'nameLocalizations' | 'descriptionLocalizations'> {
     type: ApplicationCommandOptionType.Subcommand;
     options: (AnySlashCommandOptionsOnlyOptionData | AnySlashCommandOptionsOnlyOptionBuilder)[];
 }
-export interface SlashCommandSubCommandGroupData extends SharedCommandDataProperties, Pick<SlashCommandData, "nameLocalizations" | "descriptionLocalizations"> {
+export interface SlashCommandSubCommandGroupData extends SharedCommandDataProperties, Pick<SlashCommandData, 'nameLocalizations' | 'descriptionLocalizations'> {
     type: ApplicationCommandOptionType.SubcommandGroup;
     options: (SlashCommandSubCommandData | SlashCommandSubcommandBuilder)[];
 }
 /**
  * Message command object data interface
  */
-export interface MessageCommandData<T = unknown> extends SharedCommandDataProperties, Partial<Omit<SharedCommandBuilderProperties<T>, "setCooldown" | "setRequiredBotPermissions" | "setRequiredMemberPermissions" | "setHalt" | "setExecute" | "setMetadata" | "halt" | "execute">> {
+export interface MessageCommandData<T = unknown> extends SharedCommandDataProperties, Partial<Omit<SharedCommandBuilderProperties<T>, 'setCooldown' | 'setRequiredBotPermissions' | 'setRequiredMemberPermissions' | 'setHalt' | 'setExecute' | 'setMetadata' | 'halt' | 'execute'>> {
     type: CommandBuilderType.MessageCommand;
     aliases?: string[];
     validateOptions?: boolean;

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

@@ -1,7 +1,7 @@
 import { MessageCommandExecuteData, MessageCommandHaltData } from '../classes/builders/MessageCommandBuilder';
 import { SlashCommandExecuteData, SlashCommandHaltData } from '../classes/builders/SlashCommandBuilder';
-import { MessageCommandOptionManager } from '../classes/MessageCommandOptionManager';
-import { CooledDownUser } from '../classes/CommandCooldownManager';
+import { MessageCommandOptionManager } from '../classes/managers/MessageCommandOptionManager';
+import { CooledDownUser } from '../classes/managers/CommandCooldownManager';
 import { RecipleClient } from '../classes/RecipleClient';
 import { CommandBuilderType } from '../types/builders';
 /**

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

@@ -1,8 +1,6 @@
-import { ApplicationCommandBuilder } from '../registerApplicationCommands';
-import { ApplicationCommandData, PermissionsBitField } from 'discord.js';
+import { RecipleModule, RecipleScript } from '../classes/managers/ClientModuleManager';
 import { ConfigCommandPermissions } from '../classes/RecipleConfig';
-import { RecipleModule, RecipleScript } from '../modules';
-import { RecipleClient } from '../classes/RecipleClient';
+import { PermissionsBitField } from 'discord.js';
 import { AnyCommandBuilder } from './builders';
 export interface RecipleClientAddModuleOptions {
     /**
@@ -16,21 +14,7 @@ export interface RecipleClientAddModuleOptions {
     /**
      * Module optional info
      */
-    moduleInfo?: RecipleModule["info"];
-}
-export interface RegisterApplicationCommandsOptions {
-    /**
-     * Bot client
-     */
-    client: RecipleClient;
-    /**
-     * Commands to register
-     */
-    commands: (ApplicationCommandData | ApplicationCommandBuilder)[];
-    /**
-     * Set guild to not register commands globally
-     */
-    guilds?: string | string[];
+    moduleInfo?: RecipleModule['info'];
 }
 export interface UserHasCommandPermissionsOptions {
     /**
@@ -49,3 +33,8 @@ export interface UserHasCommandPermissionsOptions {
         commands: ConfigCommandPermissions[];
     };
 }
+export interface ModuleManagerResolveFilesOptions {
+    files: string[];
+    disabeVersionCheck?: boolean;
+    dontSkipError?: boolean;
+}

package/dist/types/reciple/util.d.ts

@@ -1,3 +1,4 @@
+import { AnyCommandBuilder } from './types/builders';
 /**
  * Check if an object is a class
  * @param object Object to identify
@@ -8,3 +9,4 @@ export declare function isClass<T = any>(object: any): object is T;
  * @param content Warning content
  */
 export declare function deprecationWarning(content: string | Error): void;
+export declare function validateCommandBuilder(command: AnyCommandBuilder): boolean;

package/package.json

@@ -1,19 +1,23 @@
 {
   "name": "reciple",
-  "version": "5.6.0",
-  "bin": "dist/cjs/bin.js",
+  "version": "6.0.0-dev.2",
+  "bin": "./dist/cjs/bin.js",
   "license": "GPL-3.0",
-  "main": "dist/cjs/index.js",
-  "typings": "dist/types/index.d.ts",
+  "main": "./dist/cjs/index.js",
+  "types": "./dist/types/index.d.ts",
+  "module": "./dist/mjs/index.js",
   "author": "FalloutStudios",
   "description": "Handler for Discord.js",
   "homepage": "https://reciple.js.org",
+  "exports": {
+    "require": "./dist/cjs/index.js",
+    "import": "./dist/mjs/index.js",
+    "types": "./dist/types/index.d.ts"
+  },
   "keywords": [
     "Discord",
     "Discord.js handler",
-    "Reciple",
-    "Slash command handler",
-    "Message command handler"
+    "Reciple"
   ],
   "contributors": [
     "GhexterCortes"
@@ -22,10 +26,11 @@
     "url": "https://github.com/FalloutStudios/reciple/issues"
   },
   "scripts": {
+    "format": "yarn prettier --write src",
     "clean": "yarn exec rimraf dist",
-    "build": "yarn clean && yarn exec tsc",
+    "build": "yarn clean && yarn format && yarn exec tsc",
     "build:publish": "yarn build && yarn docs && yarn npm publish",
-    "build:publish-prerelease": "yarn build && yarn npm publish --tag pre",
+    "build:publish-dev": "yarn build && yarn npm publish --tag dev",
     "test": "yarn build && yarn workspace test start",
     "docs": "yarn exec docgen --typescript true -c ./docs/index.json -o ./docs/docs.json -i src/index.ts",
     "watch": "yarn exec tsc --watch --noEmit"
@@ -41,7 +46,6 @@
   "files": [
     "dist",
     "resource",
-    "package.json",
     "LICENSE",
     "README.md"
   ],
@@ -49,21 +53,22 @@
     "chalk": "4.1.2",
     "commander": "^9.4.1",
     "dotenv": "^16.0.3",
-    "fallout-utility": "^1.5.2",
-    "semver": "^7.3.8",
+    "fallout-utility": "^1.5.4",
+    "semver": "^7.3.7",
     "wildcard-match": "^5.1.2",
-    "yaml": "^2.1.3"
+    "yaml": "^2.1.1"
   },
   "devDependencies": {
     "@discordjs/docgen": "^0.12.1",
-    "@types/node": "^18.8.3",
+    "@types/node": "^18.11.0",
     "@types/semver": "^7.3.12",
-    "discord.js": "^14.5.0",
+    "discord.js": "^14.6.0",
+    "prettier": "2.7.1",
     "rimraf": "^3.0.2",
     "typescript": "^4.8.4"
   },
   "peerDependencies": {
-    "discord.js": "^14.1.0"
+    "discord.js": "^14.5.0"
   },
   "workspaces": [
     "test"

package/dist/cjs/reciple/modules.js

@@ -1,113 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getModules = void 0;
-const builders_1 = require("./types/builders");
-const MessageCommandBuilder_1 = require("./classes/builders/MessageCommandBuilder");
-const SlashCommandBuilder_1 = require("./classes/builders/SlashCommandBuilder");
-const discord_js_1 = require("discord.js");
-const version_1 = require("./version");
-const fs_1 = require("fs");
-const wildcard_match_1 = __importDefault(require("wildcard-match"));
-const flags_1 = require("./flags");
-const path_1 = __importDefault(require("path"));
-/**
- * Load modules from folder
- * @param client Reciple client
- * @param folder Modules folder
- */
-async function getModules(client, folder) {
-    const response = { commands: [], modules: [] };
-    const modulesDir = folder || path_1.default.join(flags_1.cwd, 'modules');
-    if (!(0, fs_1.existsSync)(modulesDir))
-        (0, fs_1.mkdirSync)(modulesDir, { recursive: true });
-    const ignoredFiles = (client.config.ignoredFiles || []).map(file => file.endsWith('.js') ? file : `${file}.js`);
-    const scripts = (0, fs_1.readdirSync)(modulesDir).filter(file => {
-        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.join(modulesDir, script);
-        const commands = [];
-        let module_;
-        try {
-            const reqMod = await Promise.resolve().then(() => __importStar(require(modulePath)));
-            module_ = reqMod?.default !== undefined ? reqMod.default : reqMod;
-            if (typeof module_ !== 'object')
-                throw new Error(`Module ${modulePath} is not an object`);
-            if (!client.config.disableVersionCheck && !module_?.versions?.length)
-                throw new Error(`${modulePath} does not have supported versions.`);
-            const versions = (0, discord_js_1.normalizeArray)([module_.versions]);
-            if (!client.config.disableVersionCheck && !versions.some(v => (0, version_1.isSupportedVersion)(v, version_1.version)))
-                throw new Error(`${modulePath} is unsupported; current version: ${version_1.version}; module supported versions: ` + versions.join(', ') ?? 'none');
-            if (!await Promise.resolve(module_.onStart(client)).catch(() => false))
-                throw new Error(script + ' onStart returned false or undefined.');
-            if (module_.commands) {
-                for (const command of module_.commands) {
-                    if (command.type === builders_1.CommandBuilderType.MessageCommand) {
-                        commands.push(MessageCommandBuilder_1.MessageCommandBuilder.resolveMessageCommand(command));
-                    }
-                    else if (command.type === builders_1.CommandBuilderType.SlashCommand) {
-                        commands.push(SlashCommandBuilder_1.SlashCommandBuilder.resolveSlashCommand(command));
-                    }
-                }
-            }
-        }
-        catch (error) {
-            if (client.isClientLogsEnabled()) {
-                client.logger.error(`Failed to load module ${script}`);
-                client.logger.error(error);
-            }
-            continue;
-        }
-        response.commands.push(...commands.filter((c) => {
-            if (!c.name) {
-                if (client.isClientLogsEnabled())
-                    client.logger.error(`A ${builders_1.CommandBuilderType[c.type]} command name is not defined in ${modulePath}`);
-                return false;
-            }
-            if (c.type === builders_1.CommandBuilderType.MessageCommand && c.options.length && c.options.some(o => !o.name)) {
-                if (client.isClientLogsEnabled())
-                    client.logger.error(`A ${builders_1.CommandBuilderType[c.type]} option name is not defined in ${modulePath}`);
-                return false;
-            }
-            return true;
-        }));
-        response.modules.push({
-            script: module_,
-            info: {
-                filename: script,
-                versions: (0, discord_js_1.normalizeArray)([module_.versions]),
-                path: modulePath
-            }
-        });
-        if (client.isClientLogsEnabled())
-            client.logger.info(`Loaded module ${modulePath}`);
-    }
-    return response;
-}
-exports.getModules = getModules;

package/dist/cjs/reciple/registerApplicationCommands.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerApplicationCommands = void 0;
-const discord_js_1 = require("discord.js");
-const SlashCommandBuilder_1 = require("./classes/builders/SlashCommandBuilder");
-/**
- * Register application commands
- * @param options Register application commands options
- */
-async function registerApplicationCommands(options) {
-    const client = options.client;
-    const guilds = (0, discord_js_1.normalizeArray)([options.guilds]);
-    const commands = options.commands ?? client.commands.slashCommands.toJSON().map(cmd => {
-        if (cmd?.toJSON === undefined)
-            return (cmd);
-        if (SlashCommandBuilder_1.SlashCommandBuilder.isSlashCommandBuilder(cmd) && client.config.commands.slashCommand.setRequiredPermissions) {
-            const permissions = client.config.commands.slashCommand.permissions.enabled
-                ? client.config.commands.slashCommand.permissions.commands.find(cmd_ => cmd_.command.toLowerCase() === cmd.name.toLowerCase())?.permissions
-                : undefined;
-            if (permissions) {
-                cmd.setRequiredMemberPermissions(...permissions);
-                if (client.isClientLogsEnabled())
-                    client.logger.debug(`Set required permissions for ${cmd.name}`);
-            }
-        }
-        return cmd.toJSON();
-    }) ?? [];
-    if (!client.isReady())
-        throw new Error('Client is not ready');
-    if (!guilds || !guilds?.length) {
-        client.application?.commands.set(commands).then(() => {
-            if (client.isClientLogsEnabled())
-                client.logger.warn('No guilds were specified for application commands. Registered application commands globally.');
-        });
-    }
-    else {
-        if (client.isClientLogsEnabled())
-            client.logger.warn(`Registering ${commands.length} application commands to ${guilds.length} guild(s).`);
-        for (const guild of guilds) {
-            if (!guild)
-                continue;
-            client.application?.commands.set(commands, guild).then(() => {
-                if (client.isClientLogsEnabled())
-                    client.logger.warn(`Registered ${commands.length} application command(s) for ${guild}.`);
-            });
-        }
-    }
-}
-exports.registerApplicationCommands = registerApplicationCommands;