reciple 1.5.4 → 1.6.1

package/bin/bin.js

@@ -12,7 +12,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 var _a, _b;
 Object.defineProperty(exports, "__esModule", { value: true });
 const Config_1 = require("./reciple/classes/Config");
-const Client_1 = require("./reciple/classes/Client");
+const RecipleClient_1 = require("./reciple/classes/RecipleClient");
 const fs_1 = require("fs");
 const version_1 = require("./reciple/version");
 const flags_1 = require("./reciple/flags");
@@ -29,7 +29,7 @@ if ((0, fs_1.readdirSync)('./').filter(f => !f.startsWith('.') && allowedFiles.i
         process.exit(0);
 }
 const config = new Config_1.RecipleConfig((_b = flags_1.flags.config) !== null && _b !== void 0 ? _b : './reciple.yml').parseConfig().getConfig();
-const client = new Client_1.RecipleClient(Object.assign({ config: config }, config.client));
+const client = new RecipleClient_1.RecipleClient(Object.assign({ config: config }, config.client));
 (() => __awaiter(void 0, void 0, void 0, function* () {
     yield client.startModules();
     client.on('ready', () => __awaiter(void 0, void 0, void 0, function* () {

package/bin/index.d.ts

@@ -1,6 +1,6 @@
 import discord from 'discord.js';
 export declare const discordjs: typeof discord;
-export * from './reciple/classes/Client';
+export * from './reciple/classes/RecipleClient';
 export * from './reciple/classes/Config';
 export * from './reciple/classes/builders/InteractionCommandBuilder';
 export * from './reciple/classes/builders/MessageCommandBuilder';

package/bin/index.js

@@ -20,7 +20,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.discordjs = void 0;
 const discord_js_1 = __importDefault(require("discord.js"));
 exports.discordjs = discord_js_1.default;
-__exportStar(require("./reciple/classes/Client"), exports);
+__exportStar(require("./reciple/classes/RecipleClient"), exports);
 __exportStar(require("./reciple/classes/Config"), exports);
 __exportStar(require("./reciple/classes/builders/InteractionCommandBuilder"), exports);
 __exportStar(require("./reciple/classes/builders/MessageCommandBuilder"), exports);

package/bin/reciple/classes/{Client.d.ts → RecipleClient.d.ts}

@@ -3,8 +3,8 @@ import { interactionCommandBuilders } from '../registerInteractionCommands';
 import { MessageCommandBuilder, RecipleMessageCommandExecute } from './builders/MessageCommandBuilder';
 import { Logger as ILogger } from 'fallout-utility';
 import { Config } from './Config';
-import { ApplicationCommandDataResolvable, Awaitable, Client, ClientEvents, ClientOptions, Interaction, Message } from 'discord.js';
-import { recipleCommandBuilders, RecipleScript } from '../modules';
+import { ApplicationCommandDataResolvable, Awaitable, Client, ClientEvents, ClientOptions, CommandInteraction, Interaction, Message } from 'discord.js';
+import { recipleCommandBuilders, RecipleModule, RecipleScript } from '../modules';
 export interface RecipleClientOptions extends ClientOptions {
     config: Config;
 }
@@ -20,7 +20,7 @@ export interface RecipleClientEvents extends ClientEvents {
     recipleMessageCommandCreate: [command: RecipleMessageCommandExecute];
     recipleInteractionCommandCreate: [command: RecipleInteractionCommandExecute];
 }
-export interface RecipleClient extends Client {
+export interface RecipleClient<Ready extends boolean = boolean> extends Client<Ready> {
     on<E extends keyof RecipleClientEvents>(event: E, listener: (...args: RecipleClientEvents[E]) => Awaitable<void>): this;
     on<E extends string | symbol>(event: Exclude<E, keyof RecipleClientEvents>, listener: (...args: any) => Awaitable<void>): this;
     once<E extends keyof RecipleClientEvents>(event: E, listener: (...args: RecipleClientEvents[E]) => Awaitable<void>): this;
@@ -31,22 +31,23 @@ export interface RecipleClient extends Client {
     off<E extends string | symbol>(event: Exclude<E, keyof RecipleClientEvents>, listener: (...args: any) => Awaitable<void>): this;
     removeAllListeners<E extends keyof RecipleClientEvents>(event?: E): this;
     removeAllListeners(event?: string | symbol): this;
+    isReady(): this is RecipleClient<true>;
 }
-export declare class RecipleClient extends Client {
+export declare class RecipleClient<Ready extends boolean = boolean> extends Client<Ready> {
     config: Config;
     commands: RecipleClientCommands;
     otherApplicationCommandData: (interactionCommandBuilders | ApplicationCommandDataResolvable)[];
-    modules: RecipleScript[];
+    modules: RecipleModule[];
     logger: ILogger;
     version: string;
     constructor(options: RecipleClientOptions);
-    startModules(): Promise<RecipleClient>;
-    loadModules(): Promise<RecipleClient>;
+    startModules(): Promise<RecipleClient<Ready>>;
+    loadModules(): Promise<RecipleClient<Ready>>;
     addModule(script: RecipleScript, registerCommands?: boolean): Promise<void>;
-    addCommand(command: recipleCommandBuilders): RecipleClient;
-    addCommandListeners(): RecipleClient;
+    addCommand(command: recipleCommandBuilders): RecipleClient<Ready>;
+    addCommandListeners(): RecipleClient<Ready>;
     messageCommandExecute(message: Message, prefix?: string): Promise<void | RecipleMessageCommandExecute>;
-    interactionCommandExecute(interaction: Interaction): Promise<void | RecipleInteractionCommandExecute>;
+    interactionCommandExecute(interaction: Interaction | CommandInteraction): Promise<void | RecipleInteractionCommandExecute>;
     getMessage<T = unknown>(messageKey: string, defaultMessage?: T): T;
     private _commandExecuteError;
 }

package/bin/reciple/classes/{Client.js → RecipleClient.js}

@@ -46,24 +46,32 @@ class RecipleClient extends discord_js_1.Client {
             const modules = yield (0, modules_1.loadModules)(this);
             if (!modules)
                 throw new Error('Failed to load modules.');
-            this.modules = modules.modules.map(m => m.script);
-            for (const command of modules.commands) {
-                if (!command.name)
-                    continue;
-                this.addCommand(command);
-            }
-            this.logger.info(`${Object.keys(this.commands.MESSAGE_COMMANDS).length} message commands loaded.`);
-            this.logger.info(`${Object.keys(this.commands.INTERACTION_COMMANDS).length} interaction commands loaded.`);
+            this.modules = modules.modules;
             return this;
         });
     }
     loadModules() {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            for (const module_ of this.modules) {
-                if (typeof (module_ === null || module_ === void 0 ? void 0 : module_.onLoad) === 'function')
-                    yield Promise.resolve(module_.onLoad(this));
+            for (let m in this.modules) {
+                const module_ = this.modules[m];
+                if (typeof ((_a = module_.script) === null || _a === void 0 ? void 0 : _a.onLoad) === 'function') {
+                    yield Promise.resolve(module_.script.onLoad(this)).catch(err => {
+                        var _a;
+                        this.logger.error(`Error loading ${(_a = module_.info.filename) !== null && _a !== void 0 ? _a : 'unknown module'}:`);
+                        this.logger.error(err);
+                        this.modules = this.modules.filter((r, i) => i.toString() !== m.toString());
+                    });
+                }
+                if (typeof ((_b = module_.script) === null || _b === void 0 ? void 0 : _b.commands) !== 'undefined') {
+                    for (const command of module_.script.commands) {
+                        this.addCommand(command);
+                    }
+                }
             }
             this.logger.info(`${this.modules.length} modules loaded.`);
+            this.logger.info(`${Object.keys(this.commands.MESSAGE_COMMANDS).length} message commands loaded.`);
+            this.logger.info(`${Object.keys(this.commands.INTERACTION_COMMANDS).length} interaction commands loaded.`);
             if (!this.config.commands.interactionCommand.registerCommands)
                 return this;
             yield (0, registerInteractionCommands_1.registerInteractionCommands)(this, [...Object.values(this.commands.INTERACTION_COMMANDS), ...this.otherApplicationCommandData]);
@@ -73,7 +81,14 @@ class RecipleClient extends discord_js_1.Client {
     addModule(script, registerCommands = true) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            this.modules.push(script);
+            this.modules.push({
+                script,
+                info: {
+                    filename: undefined,
+                    versions: typeof script.versions == 'string' ? [script.versions] : script.versions,
+                    path: undefined
+                }
+            });
             if (typeof (script === null || script === void 0 ? void 0 : script.onLoad) === 'function')
                 yield Promise.resolve(script.onLoad(this));
             this.logger.info(`${this.modules.length} modules loaded.`);
@@ -110,7 +125,7 @@ class RecipleClient extends discord_js_1.Client {
     messageCommandExecute(message, prefix) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            if (!message.content)
+            if (!message.content || !this.isReady())
                 return;
             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)
@@ -154,12 +169,13 @@ class RecipleClient extends discord_js_1.Client {
     interactionCommandExecute(interaction) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            if (!interaction || !interaction.isCommand())
+            if (!interaction || !interaction.isCommand() || !this.isReady())
                 return;
             const command = this.commands.INTERACTION_COMMANDS[interaction.commandName];
             if (!command)
                 return;
             if ((0, hasPermissions_1.hasPermissions)(command.name, (_a = interaction.memberPermissions) !== null && _a !== void 0 ? _a : undefined, this.config.permissions.interactionCommands, command)) {
+                // TODO: Deprecated allowEcuteInDM
                 if (!command.allowExecuteInDM && !interaction.inCachedGuild() || (0, isIgnoredChannel_1.isIgnoredChannel)(interaction.channelId, this.config.ignoredChannels))
                     return;
                 if (!command)
@@ -192,12 +208,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(err => this.logger.debug(err));
+                yield command.message.reply(this.getMessage('error', 'An error occurred.')).catch(e => this.logger.debug(e));
             }
             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(err => this.logger.debug(err));
+                yield command.interaction.followUp(this.getMessage('error', 'An error occurred.')).catch(e => this.logger.debug(e));
             }
         });
     }

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

@@ -1,11 +1,11 @@
 import { CommandInteraction, PermissionFlags, PermissionString } from 'discord.js';
 import { SlashCommandBuilder } from '@discordjs/builders';
-import { RecipleClient } from '../Client';
+import { RecipleClient } from '../RecipleClient';
 export interface RecipleInteractionCommandExecute {
     interaction: CommandInteraction;
     command: InteractionCommandBuilder;
     builder: InteractionCommandBuilder;
-    client: RecipleClient;
+    client: RecipleClient<true>;
 }
 export declare class InteractionCommandBuilder extends SlashCommandBuilder {
     readonly builder = "INTERACTION_COMMAND";
@@ -13,6 +13,10 @@ export declare class InteractionCommandBuilder extends SlashCommandBuilder {
     allowExecuteInDM: boolean;
     execute: (options: RecipleInteractionCommandExecute) => void;
     setRequiredPermissions(requiredPermissions: (keyof PermissionFlags)[]): InteractionCommandBuilder;
+    /**
+     * TODO: Deprecated this
+     * @deprecated use `InteractionCommandBuilder.setDMPermission()` instead
+     */
     setAllowExecuteInDM(allowExecuteInDM: boolean): InteractionCommandBuilder;
     setExecute(execute: (options: RecipleInteractionCommandExecute) => void): InteractionCommandBuilder;
 }

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

@@ -16,6 +16,10 @@ class InteractionCommandBuilder extends builders_1.SlashCommandBuilder {
         this.requiredPermissions = requiredPermissions;
         return this;
     }
+    /**
+     * TODO: Deprecated this
+     * @deprecated use `InteractionCommandBuilder.setDMPermission()` instead
+     */
     setAllowExecuteInDM(allowExecuteInDM) {
         if (typeof allowExecuteInDM !== 'boolean')
             throw new Error('allowExecuteInDM must be a boolean.');

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

@@ -1,7 +1,7 @@
 import { MessageCommandOptionBuilder } from './MessageCommandOptionBuilder';
 import { Message, PermissionFlags, PermissionString } from 'discord.js';
 import { Command } from 'fallout-utility';
-import { RecipleClient } from '../Client';
+import { RecipleClient } from '../RecipleClient';
 import { MessageCommandOptions } from './MessageCommandOptions';
 export declare type CommandMessage = Command;
 export interface RecipleMessageCommandExecute {
@@ -9,7 +9,7 @@ export interface RecipleMessageCommandExecute {
     options: MessageCommandOptions;
     command: CommandMessage;
     builder: MessageCommandBuilder;
-    client: RecipleClient;
+    client: RecipleClient<true>;
 }
 export interface MessageCommandValidatedOption {
     name: string;

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

@@ -3,4 +3,6 @@ export declare class MessageCommandOptions extends Array<MessageCommandValidated
     constructor(options: MessageCommandValidatedOption[]);
     get(name: string, requied: true): MessageCommandValidatedOption;
     get(name: string, requied?: boolean): MessageCommandValidatedOption | null;
+    getValue(name: string, requied: true): string;
+    getValue(name: string, requied?: boolean): string | null;
 }

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

@@ -8,9 +8,16 @@ class MessageCommandOptions extends Array {
     }
     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)
+        if (!(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;
     }
+    getValue(name, requied) {
+        var _a;
+        const option = this.get(name, requied);
+        if (!(option === null || option === void 0 ? void 0 : option.value) && requied)
+            throw new TypeError(`Value of option named ${name} is undefined`);
+        return (_a = option === null || option === void 0 ? void 0 : option.value) !== null && _a !== void 0 ? _a : null;
+    }
 }
 exports.MessageCommandOptions = MessageCommandOptions;

package/bin/reciple/modules.d.ts

@@ -1,6 +1,6 @@
 import { InteractionCommandBuilder, RecipleInteractionCommandExecute } from './classes/builders/InteractionCommandBuilder';
 import { MessageCommandBuilder, RecipleMessageCommandExecute } from './classes/builders/MessageCommandBuilder';
-import { RecipleClient } from './classes/Client';
+import { RecipleClient } from './classes/RecipleClient';
 export declare type recipleCommandBuilders = MessageCommandBuilder | InteractionCommandBuilder;
 export declare type recipleCommandBuildersExecute = RecipleInteractionCommandExecute | RecipleMessageCommandExecute;
 export declare type loadedModules = {
@@ -16,9 +16,9 @@ export declare class RecipleScript {
 export interface RecipleModule {
     script: RecipleScript;
     info: {
-        filename: string;
+        filename?: string;
         versions: string[];
-        path: string;
+        path?: string;
     };
 }
 export declare function loadModules(client: RecipleClient): Promise<loadedModules>;

package/bin/reciple/registerInteractionCommands.d.ts

@@ -1,6 +1,6 @@
 import { InteractionCommandBuilder } from './classes/builders/InteractionCommandBuilder';
 import { ApplicationCommandDataResolvable } from 'discord.js';
-import { RecipleClient } from './classes/Client';
+import { RecipleClient } from './classes/RecipleClient';
 import { ContextMenuCommandBuilder, SlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandOptionsOnlyBuilder, SlashCommandSubcommandGroupBuilder, SlashCommandSubcommandsOnlyBuilder } from '@discordjs/builders';
 export declare type interactionCommandBuilders = InteractionCommandBuilder | ContextMenuCommandBuilder | SlashCommandBuilder | SlashCommandSubcommandBuilder | SlashCommandOptionsOnlyBuilder | SlashCommandSubcommandGroupBuilder | SlashCommandSubcommandsOnlyBuilder;
 export declare function registerInteractionCommands(client: RecipleClient, cmds?: (interactionCommandBuilders | ApplicationCommandDataResolvable)[], overwriteGuilds?: string | string[]): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reciple",
-  "version": "1.5.4",
+  "version": "1.6.1",
   "description": "A Discord.js bot",
   "author": "FalloutStudios",
   "license": "GPL-3.0",
@@ -8,6 +8,9 @@
   "bin": {
     "reciple": "bin/bin.js"
   },
+  "engines": {
+    "node": ">=16.9.0"
+  },
   "files": [
     "bin",
     "resource",
@@ -16,12 +19,11 @@
     "README.md"
   ],
   "scripts": {
-    "clean": "rimraf bin",
-    "compile": "yarn clean && npx tsc",
-    "build": "yarn compile && npm un reciple -g && npm i ./ -g",
-    "build:publish": "yarn run build && yarn run changelog && yarn publish",
-    "test": "cd test && npx reciple",
-    "test:build": "yarn run build && yarn test:run"
+    "clean": "rm -rf bin",
+    "build": "yarn clean && npx tsc && npm un reciple -g && npm i ./ -g",
+    "build:publish": "yarn run build && yarn publish",
+    "test": "yarn run build && yarn test:start",
+    "test:start": "cd test && npx reciple"
   },
   "dependencies": {
     "commander": "^9.3.0",