reciple 6.0.0-dev.6 → 6.0.0-dev.7

package/dist/cjs/bin.js

@@ -34,11 +34,13 @@ if (!client.isClientLogsSilent)
     client.logger.info('Starting Reciple client v' + version_1.rawVersion);
 (async () => {
     client.addCommandListeners();
-    await client.modules.startModulesFromFiles({
+    await client.modules.startModules(await client.modules.getModulesFromFiles({
         files: await client.modules.getModuleFiles(),
-    });
+    }), true, true);
     client.on('ready', async () => {
-        await client.modules.loadAll(true);
+        await client.modules.loadModules(client.modules.modules.toJSON());
+        if (client.config.commands.slashCommand.registerCommands)
+            client.commands.registerApplicationCommands();
         if (!client.isClientLogsSilent)
             client.logger.warn(`Logged in as ${client.user?.tag || 'Unknown'}!`);
         client.on('cacheSweep', () => client.cooldowns.clean());

package/dist/cjs/index.js

@@ -24,11 +24,11 @@ __exportStar(require("./reciple/classes/managers/ClientModuleManager"), exports)
 __exportStar(require("./reciple/classes/managers/MessageCommandOptionManager"), exports);
 __exportStar(require("./reciple/classes/RecipleClient"), exports);
 __exportStar(require("./reciple/classes/RecipleConfig"), exports);
+__exportStar(require("./reciple/classes/RecipleModule"), exports);
 __exportStar(require("./reciple/types/builders"), exports);
 __exportStar(require("./reciple/types/commands"), exports);
 __exportStar(require("./reciple/types/paramOptions"), exports);
 __exportStar(require("./reciple/flags"), exports);
-__exportStar(require("./reciple/logger"), exports);
 __exportStar(require("./reciple/permissions"), exports);
 __exportStar(require("./reciple/util"), exports);
 __exportStar(require("./reciple/version"), exports);

package/dist/cjs/reciple/classes/RecipleClient.js

@@ -17,7 +17,7 @@ const ClientCommandManager_1 = require("./managers/ClientCommandManager");
 const ClientModuleManager_1 = require("./managers/ClientModuleManager");
 const RecipleConfig_1 = require("./RecipleConfig");
 const fallout_utility_1 = require("fallout-utility");
-const logger_1 = require("../logger");
+const util_1 = require("../util");
 const version_1 = require("../version");
 const flags_1 = require("../flags");
 const path_1 = __importDefault(require("path"));
@@ -36,7 +36,7 @@ class RecipleClient extends discord_js_1.Client {
             client: this,
         });
         this.version = version_1.version;
-        this.logger = (0, logger_1.createLogger)(!!options.config?.fileLogging.stringifyLoggedJSON, options.config?.fileLogging.debugmode);
+        this.logger = (0, util_1.createLogger)(!!options.config?.fileLogging.stringifyLoggedJSON, options.config?.fileLogging.debugmode);
         this.config = { ...this.config, ...(options.config ?? {}) };
         if (this.config.fileLogging.enabled)
             this.logger.logFile(path_1.default.join(flags_1.cwd, this.config.fileLogging.logFilePath ?? 'logs/latest.log'), false);

package/dist/cjs/reciple/classes/RecipleModule.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecipleModule = void 0;
+const crypto_1 = require("crypto");
+const discord_js_1 = require("discord.js");
+const builders_1 = require("../types/builders");
+const util_1 = require("../util");
+const MessageCommandBuilder_1 = require("./builders/MessageCommandBuilder");
+const SlashCommandBuilder_1 = require("./builders/SlashCommandBuilder");
+class RecipleModule {
+    constructor(options) {
+        this.commands = new discord_js_1.Collection();
+        this.id = (0, crypto_1.randomUUID)();
+        this.client = options.client;
+        this.script = options.script;
+        this.filePath = options.filePath;
+        this.metadata = options.metadata;
+    }
+    get displayName() {
+        return this.filePath ?? this.id;
+    }
+    async start(resolveCommands = true) {
+        if (resolveCommands)
+            this.resolveCommands();
+        return Promise.resolve(this.script.onStart(this.client));
+    }
+    async load() {
+        if (typeof this.script.onLoad === 'function')
+            this.script.onLoad(this.client);
+    }
+    async unLoad(reason) {
+        if (typeof this.script.onUnLoad === 'function')
+            this.script.onUnLoad(reason, this.client);
+    }
+    async registerSlashCommands(...guilds) {
+        for (const command of this.commands.toJSON()) {
+            if (command.type !== builders_1.CommandBuilderType.SlashCommand)
+                continue;
+            await this.client.applicationCommands.add(command, (0, discord_js_1.normalizeArray)(guilds));
+        }
+    }
+    async unregisterSlashCommands(...guilds) {
+        for (const builder of this.commands.toJSON()) {
+            if (builder.type !== builders_1.CommandBuilderType.SlashCommand)
+                continue;
+            if ((0, discord_js_1.normalizeArray)(guilds).length) {
+                for (const guild of (0, discord_js_1.normalizeArray)(guilds)) {
+                    const command = this.client.applicationCommands.get(builder, guild);
+                    if (command)
+                        await this.client.applicationCommands.remove(command, guild);
+                }
+                continue;
+            }
+            const command = this.client.applicationCommands.get(builder);
+            if (command)
+                await this.client.applicationCommands.remove(command);
+        }
+    }
+    async updateSlashCommands(...guilds) {
+        for (const builder of this.commands.toJSON()) {
+            if (builder.type !== builders_1.CommandBuilderType.SlashCommand)
+                continue;
+            if ((0, discord_js_1.normalizeArray)(guilds).length) {
+                for (const guild of (0, discord_js_1.normalizeArray)(guilds)) {
+                    const command = this.client.applicationCommands.get(builder, guild);
+                    if (command)
+                        await this.client.applicationCommands.edit(command, builder, guild);
+                }
+                continue;
+            }
+            const command = this.client.applicationCommands.get(builder);
+            if (command)
+                await this.client.applicationCommands.edit(command, builder);
+        }
+    }
+    resolveCommands() {
+        if (!Array.isArray(this.script?.commands))
+            return this.commands;
+        for (const command of this.script.commands) {
+            if (command?.type !== builders_1.CommandBuilderType.SlashCommand && command?.type !== builders_1.CommandBuilderType.MessageCommand)
+                continue;
+            const builder = command.type === builders_1.CommandBuilderType.SlashCommand ? SlashCommandBuilder_1.SlashCommandBuilder.resolveSlashCommand(command) : MessageCommandBuilder_1.MessageCommandBuilder.resolveMessageCommand(command);
+            if (!(0, util_1.validateCommandBuilder)(builder))
+                throw new Error('Invalid command builder, no name or contains option(s) without name');
+            this.commands.set(command.name, builder);
+        }
+        this.client.commands.add(this.commands.toJSON());
+        return this.commands;
+    }
+    toString() {
+        return this.displayName;
+    }
+}
+exports.RecipleModule = RecipleModule;

package/dist/cjs/reciple/classes/managers/ApplicationCommandManager.js

@@ -7,15 +7,13 @@ class ApplicationCommandManager {
     constructor(client) {
         this.client = client;
     }
-    get commands() {
-        return this.client.application?.commands;
-    }
-    async set(commands, guilds) {
+    async set(commands, ...guilds) {
+        guilds = (0, discord_js_1.normalizeArray)(guilds);
         if (!this.client.isReady())
             throw new Error('Client is not ready');
         if (guilds && guilds.length > 1) {
             for (const guild of guilds) {
-                await this.set(commands, [guild]);
+                await this.set(commands, guild);
             }
             return;
         }
@@ -32,14 +30,15 @@ class ApplicationCommandManager {
                 this.client.logger.log(`Registered ${this.client.commands.applicationCommandsSize} application command(s) to guild ${guild}...`);
         }
     }
-    async add(command, guilds) {
+    async add(command, ...guilds) {
+        guilds = (0, discord_js_1.normalizeArray)(guilds);
         if (!this.client.isReady())
             throw new Error('Client is not ready');
         if (!command)
             throw new Error('Command is undefined');
         if (guilds && guilds.length > 1) {
             for (const guild of guilds) {
-                await this.add(command, [guild]);
+                await this.add(command, guild);
             }
             return;
         }
@@ -56,14 +55,15 @@ class ApplicationCommandManager {
                 this.client.logger.log(`Created application command '${command.name}' to guild ${guild}`);
         }
     }
-    async remove(command, guilds) {
+    async remove(command, ...guilds) {
+        guilds = (0, discord_js_1.normalizeArray)(guilds);
         if (!this.client.isReady())
             throw new Error('Client is not ready');
         if (!command)
             throw new Error('Command is undefined');
         if (guilds && guilds.length > 1) {
             for (const guild of guilds) {
-                await this.remove(command, [guild]);
+                await this.remove(command, guild);
             }
             return;
         }
@@ -80,14 +80,15 @@ class ApplicationCommandManager {
                 this.client.logger.log(`Removed application command '${typeof command === 'string' ? command : command.name}' from guild ${guild}`);
         }
     }
-    async edit(command, newCommand, guilds) {
+    async edit(command, newCommand, ...guilds) {
+        guilds = (0, discord_js_1.normalizeArray)(guilds);
         if (!this.client.isReady())
             throw new Error('Client is not ready');
         if (!command)
             throw new Error('Command is undefined');
         if (guilds && guilds.length > 1) {
             for (const guild of guilds) {
-                await this.edit(command, newCommand, [guild]);
+                await this.edit(command, newCommand, guild);
             }
             return;
         }

package/dist/cjs/reciple/classes/managers/ClientCommandManager.js

@@ -29,6 +29,9 @@ class ClientCommandManager {
             else if (command.type === builders_1.CommandBuilderType.MessageCommand) {
                 this.messageCommands.set(command.name, MessageCommandBuilder_1.MessageCommandBuilder.resolveMessageCommand(command));
             }
+            else {
+                throw new Error(`Unknown reciple command type`);
+            }
         }
         return this;
     }

package/dist/cjs/reciple/classes/managers/ClientModuleManager.js

@@ -27,151 +27,128 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClientModuleManager = void 0;
-const crypto_1 = require("crypto");
 const discord_js_1 = require("discord.js");
 const fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
+const util_1 = require("util");
 const wildcard_match_1 = __importDefault(require("wildcard-match"));
 const flags_1 = require("../../flags");
-const builders_1 = require("../../types/builders");
-const util_1 = require("../../util");
-const version_1 = require("../../version");
-const MessageCommandBuilder_1 = require("../builders/MessageCommandBuilder");
-const SlashCommandBuilder_1 = require("../builders/SlashCommandBuilder");
+const RecipleModule_1 = require("../RecipleModule");
 class ClientModuleManager {
     constructor(options) {
         this.modules = new discord_js_1.Collection();
         this.client = options.client;
-        options.modules?.forEach(m => {
-            if (!m.id)
-                m.id = (0, crypto_1.randomUUID)();
-            this.modules.set(m.id, this.resolveModule(m));
-        });
+        options.modules?.forEach(m => (m instanceof RecipleModule_1.RecipleModule ? m : new RecipleModule_1.RecipleModule({ client: this.client, script: m })));
     }
-    async startModulesFromFiles(options) {
-        const modules = await this.resolveModulesFromFiles(options);
+    async startModules(modules, addModuleCommandsToClient = true, ignoreErrors = true) {
         for (const module_ of modules) {
+            if (!this.client.isClientLogsSilent)
+                this.client.logger.log(`Starting module '${module_}'`);
             try {
-                await this.startModule(module_);
+                let error;
+                const start = await module_.start(true).catch(err => {
+                    error = err;
+                    return false;
+                });
+                if (error)
+                    throw new Error(`An error occured while loading module '${module_}': \n${(0, util_1.inspect)(error)}`);
+                if (!start) {
+                    if (!this.client.isClientLogsSilent)
+                        this.client.logger.error(`Module '${module_}' returned false onStart`);
+                    continue;
+                }
+                this.modules.set(module_.id, module_);
+                if (addModuleCommandsToClient) {
+                    this.client.commands.add(module_.commands.toJSON());
+                }
             }
             catch (err) {
-                if (options.dontSkipError)
+                if (!ignoreErrors)
                     throw err;
                 if (!this.client.isClientLogsSilent)
-                    this.client.logger.err(`Cannot start module ${ClientModuleManager.getModuleDisplayId(module_)}:`, err);
+                    this.client.logger.error(`Failed to start module '${module_}': `, err);
             }
         }
         return modules;
     }
-    async resolveModulesFromFiles(options) {
-        const modules = [];
-        const isVersionCheckDisabled = options.disabeVersionCheck || this.client.config.disableVersionCheck;
-        for (const file of options.files) {
-            const moduleFileName = path_1.default.basename(file);
-            const moduleDirPath = path_1.default.dirname(file);
-            const id = (0, crypto_1.randomUUID)();
-            let script;
+    async loadModules(modules, ignoreErrors = true) {
+        for (const module_ of this.modules.toJSON()) {
             try {
-                const resolveModuleFile = await Promise.resolve().then(() => __importStar(require(file)));
-                script = resolveModuleFile?.default ?? resolveModuleFile;
-                const module_ = this.resolveModule({
-                    id,
-                    script,
-                    info: {
-                        filename: moduleFileName,
-                        path: moduleDirPath,
-                    },
-                }, isVersionCheckDisabled);
-                modules.push(module_);
+                await module_.load().catch(err => {
+                    throw err;
+                });
                 if (!this.client.isClientLogsSilent)
-                    this.client.logger.log(`Resolved ${file}`);
+                    this.client.logger.log(`Loaded module '${module_}'`);
             }
             catch (err) {
-                if (options.dontSkipError)
+                if (!ignoreErrors)
                     throw err;
                 if (!this.client.isClientLogsSilent)
-                    this.client.logger.err(`Cannot resolve module file ${file}:`, err);
+                    this.client.logger.error(`Failed to load module '${module_}': `, err);
             }
         }
         return modules;
     }
-    resolveScriptCommands(...modules) {
-        const resolvedCommands = [];
-        for (const script of (0, discord_js_1.normalizeArray)(modules)) {
-            const commands = [];
-            if (Array.isArray(script?.commands)) {
-                for (const command of script.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));
-                    }
-                }
+    async unLoadModules(modules, removeUnloadedModules = true, ignoreErrors = true) {
+        for (const module_ of this.modules.toJSON()) {
+            try {
+                await module_.unLoad().catch(err => {
+                    throw err;
+                });
+                if (removeUnloadedModules)
+                    this.modules.delete(module_.id);
+                if (!this.client.isClientLogsSilent)
+                    this.client.logger.log(`Unloaded module '${module_}'`);
+            }
+            catch (err) {
+                if (!ignoreErrors)
+                    throw err;
+                if (!this.client.isClientLogsSilent)
+                    this.client.logger.error(`Failed to unLoad module '${module_}': `, err);
             }
-            const invalidBuilders = commands.some(c => !(0, util_1.validateCommandBuilder)(c));
-            if (invalidBuilders)
-                throw new Error(`Module script commands contains a command builder without name or option name`);
-            resolvedCommands.push({
-                script,
-                commands,
-            });
         }
-        return resolvedCommands;
+        return modules;
     }
-    async loadAll(registerApplicationCommands, ...registerApplicationCommandsGuilds) {
-        await Promise.all(this.modules.map(async (m) => {
-            if (typeof m.script?.onLoad === 'function') {
-                try {
-                    await Promise.resolve(m.script.onLoad(this.client)).catch(err => {
-                        throw err;
-                    });
-                }
-                catch (err) {
-                    this.modules.delete(m.id);
-                    if (!this.client.isClientLogsSilent)
-                        this.client.logger.error(`Error loading ${m.info.filename ?? 'unknown module'}:`, err);
-                    return;
+    async getModulesFromFiles(options) {
+        const modules = [];
+        for (const file of options.files) {
+            try {
+                const resolveFile = await Promise.resolve().then(() => __importStar(require(file)));
+                let script = resolveFile?.default ?? resolveFile;
+                if (script instanceof RecipleModule_1.RecipleModule) {
+                    modules.push(script);
+                    continue;
                 }
+                if (!ClientModuleManager.validateScript(script))
+                    throw new Error(`Invalid module script: ${file}`);
+                modules.push(new RecipleModule_1.RecipleModule({
+                    client: this.client,
+                    script,
+                    filePath: file,
+                }));
+            }
+            catch (err) {
+                if (options.dontSkipError)
+                    throw err;
+                if (!this.client.isClientLogsSilent)
+                    this.client.logger.error(`Can't resolve module from: ${file}`, err);
             }
-            this.client.commands.add(m.commands);
-            if (!this.client.isClientLogsSilent)
-                this.client.logger.log(`Loaded module: ${ClientModuleManager.getModuleDisplayId(m)}`);
-        }));
-        if (!this.client.isClientLogsSilent) {
-            this.client.logger.info(`${this.modules.size} modules loaded.`);
-            this.client.logger.info(`${this.client.commands.messageCommands.size} message commands loaded.`);
-            this.client.logger.info(`${this.client.commands.slashCommands.size} slash commands loaded.`);
         }
-        if (registerApplicationCommands)
-            await this.client.commands.registerApplicationCommands((0, discord_js_1.normalizeArray)(registerApplicationCommandsGuilds));
-    }
-    async startModule(mod) {
-        let err;
-        const identifier = ClientModuleManager.getModuleDisplayId(mod);
-        if (!this.client.isClientLogsSilent)
-            this.client.logger.log(`Starting Module: ${identifier}`);
-        const start = await Promise.resolve(mod.script.onStart(this.client)).catch(e => (err = e));
-        if (err)
-            throw err;
-        if (!start)
-            throw new Error(`Module ${identifier} returned 'false' on start`);
-        this.modules.set(mod.id, mod);
+        return modules;
     }
-    resolveModule(mod, disabeVersionCheck) {
-        const identifier = ClientModuleManager.getModuleDisplayId(mod);
-        if (!disabeVersionCheck && !mod?.script?.versions?.length)
-            throw new Error(`Module ${identifier} does not contain supported versions`);
-        if (typeof mod.script?.onStart !== 'function')
-            throw new Error(`Module ${identifier} does not have a valid 'onStart' method`);
-        const versions = (0, discord_js_1.normalizeArray)([mod.script.versions]);
-        const commands = this.resolveScriptCommands(mod.script)[0].commands;
-        if (!disabeVersionCheck && !versions.some(v => (0, version_1.isSupportedVersion)(v, version_1.version)))
-            throw new Error(`Module ${identifier} does not support 'reciple@${version_1.rawVersion}'`);
-        return {
-            ...mod,
-            commands,
-        };
+    static validateScript(script) {
+        const s = script;
+        if (typeof s !== 'object')
+            return false;
+        if (typeof s.versions !== 'string' && !Array.isArray(s.versions))
+            return false;
+        if (typeof s.onStart !== 'function')
+            return false;
+        if (s.onLoad && typeof s.onLoad !== 'function')
+            return false;
+        if (s.onUnLoad && typeof s.onUnLoad !== 'function')
+            return false;
+        return true;
     }
     async getModuleFiles(...folders) {
         const modules = [];
@@ -186,8 +163,5 @@ class ClientModuleManager {
         }
         return modules.filter(file => !this.client.config.ignoredFiles.some(ignored => (0, wildcard_match_1.default)(ignored)(path_1.default.basename(file))));
     }
-    static getModuleDisplayId(mod) {
-        return mod.info.path && mod.info.filename ? path_1.default.join(mod.info.path, mod.info.filename) : mod.id;
-    }
 }
 exports.ClientModuleManager = ClientModuleManager;

package/dist/cjs/reciple/util.js

@@ -1,6 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateCommandBuilder = exports.deprecationWarning = exports.isClass = void 0;
+exports.createLogger = exports.validateCommandBuilder = exports.deprecationWarning = exports.isClass = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const fallout_utility_1 = require("fallout-utility");
+const flags_1 = require("./flags");
 const builders_1 = require("./types/builders");
 /**
  * Check if an object is a class
@@ -30,3 +36,31 @@ function validateCommandBuilder(command) {
     return true;
 }
 exports.validateCommandBuilder = validateCommandBuilder;
+/**
+ * Create new logger
+ * @param stringifyJSON stringify json objects in console
+ * @param debugmode display debug messages
+ * @param colorizeMessage add logger colours to messages
+ */
+function createLogger(stringifyJSON, debugmode = false, colorizeMessage = true) {
+    return new fallout_utility_1.Logger({
+        stringifyJSON: stringifyJSON,
+        enableDebugMode: flags_1.flags.debugmode ?? debugmode,
+        loggerName: 'Main',
+        prefixes: {
+            [fallout_utility_1.LogLevels.INFO]: (name) => `[${new Date().toLocaleTimeString(undefined, {
+                hour12: false,
+            })}][${(name ? name + '/' : '') + 'INFO'}]`,
+            [fallout_utility_1.LogLevels.WARN]: (name) => `[${chalk_1.default.yellow(new Date().toLocaleTimeString(undefined, { hour12: false }))}][${chalk_1.default.yellow((name ? name + '/' : '') + 'WARN')}]`,
+            [fallout_utility_1.LogLevels.ERROR]: (name) => `[${chalk_1.default.red(new Date().toLocaleTimeString(undefined, { hour12: false }))}][${chalk_1.default.red((name ? name + '/' : '') + 'ERROR')}]`,
+            [fallout_utility_1.LogLevels.DEBUG]: (name) => `[${chalk_1.default.blue(new Date().toLocaleTimeString(undefined, { hour12: false }))}][${chalk_1.default.blue((name ? name + '/' : '') + 'DEBUG')}]`,
+        },
+        colorMessages: {
+            [fallout_utility_1.LogLevels.INFO]: (message) => message,
+            [fallout_utility_1.LogLevels.WARN]: (message) => (!colorizeMessage ? message : chalk_1.default.yellow(message)),
+            [fallout_utility_1.LogLevels.ERROR]: (message) => (!colorizeMessage ? message : chalk_1.default.red(message)),
+            [fallout_utility_1.LogLevels.DEBUG]: (message) => (!colorizeMessage ? message : chalk_1.default.blue(message)),
+        },
+    });
+}
+exports.createLogger = createLogger;

package/dist/types/index.d.ts

@@ -8,11 +8,11 @@ export * from './reciple/classes/managers/ClientModuleManager';
 export * from './reciple/classes/managers/MessageCommandOptionManager';
 export * from './reciple/classes/RecipleClient';
 export * from './reciple/classes/RecipleConfig';
+export * from './reciple/classes/RecipleModule';
 export * from './reciple/types/builders';
 export * from './reciple/types/commands';
 export * from './reciple/types/paramOptions';
 export * from './reciple/flags';
-export * from './reciple/logger';
 export * from './reciple/permissions';
 export * from './reciple/util';
 export * from './reciple/version';

package/dist/types/reciple/classes/RecipleModule.d.ts

@@ -0,0 +1,56 @@
+import { Collection, GuildResolvable, RestOrArray } from 'discord.js';
+import { AnyCommandBuilder, AnyCommandData } from '../types/builders';
+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>;
+    /**
+     * Action when unloading this module
+     * @param reason Unload reason
+     * @param client Bot client
+     */
+    onUnLoad?(reason: unknown, client: RecipleClient<true>): void | Promise<void>;
+}
+export interface RecipleModuleOptions<M = unknown> {
+    client: RecipleClient;
+    script: RecipleScript;
+    filePath?: string;
+    metadata?: M;
+}
+export declare class RecipleModule<M = unknown> {
+    readonly id: string;
+    readonly client: RecipleClient;
+    readonly commands: Collection<string, AnyCommandBuilder>;
+    readonly script: RecipleScript;
+    readonly filePath?: string;
+    metadata?: M;
+    get displayName(): string;
+    constructor(options: RecipleModuleOptions<M>);
+    start(resolveCommands?: boolean): Promise<boolean>;
+    load(): Promise<void>;
+    unLoad(reason?: any): Promise<void>;
+    registerSlashCommands(...guilds: RestOrArray<GuildResolvable>): Promise<void>;
+    unregisterSlashCommands(...guilds: RestOrArray<GuildResolvable>): Promise<void>;
+    updateSlashCommands(...guilds: RestOrArray<GuildResolvable>): Promise<void>;
+    resolveCommands(): Collection<string, AnyCommandBuilder>;
+    toString(): string;
+}

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

@@ -1,19 +1,14 @@
-import { ApplicationCommand, ApplicationCommandData, ContextMenuCommandBuilder, GuildResolvable, RESTPostAPIApplicationCommandsJSONBody, SlashCommandBuilder as DiscordJsSlashCommandBuilder } from 'discord.js';
+import { ApplicationCommand, ApplicationCommandData, ContextMenuCommandBuilder, GuildResolvable, RestOrArray, 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>;
+    set(commands: (ApplicationCommandBuilder | ApplicationCommandData)[], ...guilds: RestOrArray<GuildResolvable>): Promise<void>;
+    add(command: ApplicationCommandBuilder | ApplicationCommandData, ...guilds: RestOrArray<GuildResolvable>): Promise<void>;
+    remove(command: string | ApplicationCommand, ...guilds: RestOrArray<GuildResolvable>): Promise<void>;
+    edit(command: string | ApplicationCommand, newCommand: ApplicationCommandBuilder | ApplicationCommandData, ...guilds: RestOrArray<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/ClientModuleManager.d.ts

@@ -1,79 +1,19 @@
-import { Collection, GuildResolvable, RestOrArray } from 'discord.js';
-import { AnyCommandBuilder, AnyCommandData } from '../../types/builders';
-import { ModuleManagerResolveFilesOptions } from '../../types/paramOptions';
+import { Collection, RestOrArray } from 'discord.js';
+import { ClientModuleManagerGetModulesFromFilesOptions } 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[];
-}
+import { RecipleModule, RecipleScript } from '../RecipleModule';
 export interface ClientModuleManagerOptions {
     client: RecipleClient;
-    modules?: (RecipleModule & {
-        id?: string;
-    })[];
+    modules?: (RecipleModule | RecipleScript)[];
 }
 export declare class ClientModuleManager {
     readonly client: RecipleClient;
-    readonly modules: Collection<string, ResolvedModule>;
+    readonly modules: Collection<string, RecipleModule>;
     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;
+    startModules(modules: RecipleModule[], addModuleCommandsToClient?: boolean, ignoreErrors?: boolean): Promise<RecipleModule[]>;
+    loadModules(modules: RecipleModule[], ignoreErrors?: boolean): Promise<RecipleModule[]>;
+    unLoadModules(modules: RecipleModule[], removeUnloadedModules?: boolean, ignoreErrors?: boolean): Promise<RecipleModule[]>;
+    getModulesFromFiles(options: ClientModuleManagerGetModulesFromFilesOptions): Promise<RecipleModule[]>;
+    static validateScript(script: unknown): script is RecipleScript;
     getModuleFiles(...folders: RestOrArray<string>): Promise<string[]>;
-    static getModuleDisplayId(mod: RecipleModule): string;
 }

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

@@ -1,21 +1,6 @@
-import { RecipleModule, RecipleScript } from '../classes/managers/ClientModuleManager';
 import { ConfigCommandPermissions } from '../classes/RecipleConfig';
 import { PermissionsBitField } from 'discord.js';
 import { AnyCommandBuilder } from './builders';
-export interface RecipleClientAddModuleOptions {
-    /**
-     * The module script
-     */
-    script: RecipleScript;
-    /**
-     * Register application commands if possible
-     */
-    registerApplicationCommands?: boolean;
-    /**
-     * Module optional info
-     */
-    moduleInfo?: RecipleModule['info'];
-}
 export interface UserHasCommandPermissionsOptions {
     /**
      * Command builder
@@ -33,7 +18,7 @@ export interface UserHasCommandPermissionsOptions {
         commands: ConfigCommandPermissions[];
     };
 }
-export interface ModuleManagerResolveFilesOptions {
+export interface ClientModuleManagerGetModulesFromFilesOptions {
     files: string[];
     disabeVersionCheck?: boolean;
     dontSkipError?: boolean;

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

@@ -1,3 +1,4 @@
+import { Logger } from 'fallout-utility';
 import { AnyCommandBuilder } from './types/builders';
 /**
  * Check if an object is a class
@@ -10,3 +11,10 @@ export declare function isClass<T = any>(object: any): object is T;
  */
 export declare function deprecationWarning(content: string | Error): void;
 export declare function validateCommandBuilder(command: AnyCommandBuilder): boolean;
+/**
+ * Create new logger
+ * @param stringifyJSON stringify json objects in console
+ * @param debugmode display debug messages
+ * @param colorizeMessage add logger colours to messages
+ */
+export declare function createLogger(stringifyJSON: boolean, debugmode?: boolean, colorizeMessage?: boolean): Logger;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reciple",
-  "version": "6.0.0-dev.6",
+  "version": "6.0.0-dev.7",
   "bin": "./dist/cjs/bin.js",
   "license": "GPL-3.0",
   "main": "./dist/cjs/index.js",
@@ -28,9 +28,9 @@
   "scripts": {
     "format": "yarn prettier --write src",
     "clean": "yarn exec rimraf dist",
-    "build": "yarn clean && yarn format && yarn exec tsc",
-    "build:publish": "yarn build && yarn docs && yarn npm publish",
-    "build:publish-dev": "yarn build && yarn npm publish --tag dev",
+    "build": "yarn clean && yarn exec tsc",
+    "build:publish": "yarn format && yarn build && yarn docs && yarn npm publish",
+    "build:publish-dev": "yarn format && 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"

package/dist/cjs/reciple/logger.js

@@ -1,37 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createLogger = void 0;
-const fallout_utility_1 = require("fallout-utility");
-const flags_1 = require("./flags");
-const chalk_1 = __importDefault(require("chalk"));
-/**
- * Create new logger
- * @param stringifyJSON stringify json objects in console
- * @param debugmode display debug messages
- * @param colorizeMessage add logger colours to messages
- */
-function createLogger(stringifyJSON, debugmode = false, colorizeMessage = true) {
-    return new fallout_utility_1.Logger({
-        stringifyJSON: stringifyJSON,
-        enableDebugMode: flags_1.flags.debugmode ?? debugmode,
-        loggerName: 'Main',
-        prefixes: {
-            [fallout_utility_1.LogLevels.INFO]: (name) => `[${new Date().toLocaleTimeString(undefined, {
-                hour12: false,
-            })}][${(name ? name + '/' : '') + 'INFO'}]`,
-            [fallout_utility_1.LogLevels.WARN]: (name) => `[${chalk_1.default.yellow(new Date().toLocaleTimeString(undefined, { hour12: false }))}][${chalk_1.default.yellow((name ? name + '/' : '') + 'WARN')}]`,
-            [fallout_utility_1.LogLevels.ERROR]: (name) => `[${chalk_1.default.red(new Date().toLocaleTimeString(undefined, { hour12: false }))}][${chalk_1.default.red((name ? name + '/' : '') + 'ERROR')}]`,
-            [fallout_utility_1.LogLevels.DEBUG]: (name) => `[${chalk_1.default.blue(new Date().toLocaleTimeString(undefined, { hour12: false }))}][${chalk_1.default.blue((name ? name + '/' : '') + 'DEBUG')}]`,
-        },
-        colorMessages: {
-            [fallout_utility_1.LogLevels.INFO]: (message) => message,
-            [fallout_utility_1.LogLevels.WARN]: (message) => (!colorizeMessage ? message : chalk_1.default.yellow(message)),
-            [fallout_utility_1.LogLevels.ERROR]: (message) => (!colorizeMessage ? message : chalk_1.default.red(message)),
-            [fallout_utility_1.LogLevels.DEBUG]: (message) => (!colorizeMessage ? message : chalk_1.default.blue(message)),
-        },
-    });
-}
-exports.createLogger = createLogger;

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

@@ -1,8 +0,0 @@
-import { Logger } from 'fallout-utility';
-/**
- * Create new logger
- * @param stringifyJSON stringify json objects in console
- * @param debugmode display debug messages
- * @param colorizeMessage add logger colours to messages
- */
-export declare function createLogger(stringifyJSON: boolean, debugmode?: boolean, colorizeMessage?: boolean): Logger;