reciple 6.0.0-dev.14 → 6.0.0-dev.16

package/dist/lib/bin.mjs

@@ -32,13 +32,22 @@ const client = new RecipleClient({ config: config, ...config.client });
 if (!client.isClientLogsSilent)
     client.logger.info('Starting Reciple client v' + rawVersion);
 client.addCommandListeners();
-await client.modules.startModules(await client.modules.getModulesFromFiles({
-    files: await client.modules.getModulePaths({
-        filter: file => file.endsWith('.js') || file.endsWith('.cjs') || file.endsWith('.mjs'),
+await client.modules.startModules({
+    modules: await client.modules.resolveModuleFiles({
+        files: await client.modules.getModulePaths({
+            filter: file => file.endsWith('.js') || file.endsWith('.cjs') || file.endsWith('.mjs'),
+        }),
     }),
-}));
+});
 client.on('ready', async () => {
-    await client.modules.loadModules(client.modules.modules.toJSON(), true);
+    await client.modules.loadModules();
+    const unloadModulesAndStopProcess = async (signal) => {
+        await client.modules.unloadModules({ reason: 'ProcessExit' });
+        client.logger.warn(`Exitting process${signal === 'SIGINT' ? ': keyboard interrupt' : signal === 'SIGTERM' ? ': terminate' : signal}`);
+        process.exit();
+    };
+    process.once('SIGINT', signal => unloadModulesAndStopProcess(signal));
+    process.once('SIGTERM', signal => unloadModulesAndStopProcess(signal));
     if (!client.isClientLogsSilent)
         client.logger.log(`Loaded ${client.commands.slashCommands.size} slash commands`, `Loaded ${client.commands.messageCommands.size} message commands`);
     if (client.config.commands.slashCommand.registerCommands && (client.config.commands.slashCommand.allowRegisterEmptyCommandList || client.commands.applicationCommandsSize)) {

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

@@ -28,9 +28,9 @@ class RecipleModule {
         if (resolveCommands)
             this.resolveCommands();
     }
-    async unLoad(reason) {
-        if (typeof this.script.onUnLoad === 'function')
-            await this.script.onUnLoad(reason, this.client);
+    async unload(reason) {
+        if (typeof this.script.onUnload === 'function')
+            await this.script.onUnload(reason, this.client);
     }
     async registerSlashCommands(...guilds) {
         for (const command of this.commands) {

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

@@ -7,6 +7,11 @@ class ApplicationCommandManager {
     constructor(client) {
         this.client = client;
     }
+    /**
+     * Sets application commands globally or in guilds
+     * @param commands Application commands
+     * @param guilds set only to guilds
+     */
     async set(commands, ...guilds) {
         guilds = (0, discord_js_1.normalizeArray)(guilds);
         if (!this.client.isReady())
@@ -27,9 +32,14 @@ class ApplicationCommandManager {
         else {
             await this.client.application.commands.set(commands, guild);
             if (!this.client.isClientLogsSilent)
-                this.client.logger.log(`Registered ${this.client.commands.applicationCommandsSize} application command(s) to guild ${guild}...`);
+                this.client.logger.log(`Registered ${this.client.commands.applicationCommandsSize} application command(s) to guild ${guild}`);
         }
     }
+    /**
+     * Add command globally or in guilds
+     * @param command Application command
+     * @param guilds add only in guilds
+     */
     async add(command, ...guilds) {
         guilds = (0, discord_js_1.normalizeArray)(guilds);
         if (!this.client.isReady())
@@ -55,6 +65,11 @@ class ApplicationCommandManager {
                 this.client.logger.log(`Created application command '${command.name}' to guild ${guild}`);
         }
     }
+    /**
+     * Remove application command globally or in guilds
+     * @param command id of application commmand or ApplicationCommand class
+     * @param guilds Remove from guilds
+     */
     async remove(command, ...guilds) {
         guilds = (0, discord_js_1.normalizeArray)(guilds);
         if (!this.client.isReady())
@@ -80,6 +95,12 @@ class ApplicationCommandManager {
                 this.client.logger.log(`Removed application command '${typeof command === 'string' ? command : command.name}' from guild ${guild}`);
         }
     }
+    /**
+     * Edit application command globally or in guilds
+     * @param command id of application command or ApplicationCommand class
+     * @param newCommand new application command data
+     * @param guilds Edit only from guilds
+     */
     async edit(command, newCommand, ...guilds) {
         guilds = (0, discord_js_1.normalizeArray)(guilds);
         if (!this.client.isReady())
@@ -105,18 +126,33 @@ class ApplicationCommandManager {
                 this.client.logger.log(`Removed application command '${typeof command === 'string' ? command : command.name}' from guild ${guild}`);
         }
     }
+    /**
+     * Get application command from cache by application command data, builder, id, or name globally or from guid
+     * @param command application command data, builder, id, or name
+     * @param guild get command from guild
+     */
     get(command, guild) {
         const commands = guild ? this.client.guilds.resolve(guild)?.commands.cache : this.client.application?.commands.cache;
         if (!commands)
             throw new Error('Guild not found in cache');
         return commands.find(cmd => (typeof command === 'string' ? cmd.id === command || cmd.name === command : cmd.name === command.name || (command instanceof discord_js_1.ApplicationCommand && cmd.id === command.id)));
     }
+    /**
+     * Fetch application command by id globally or from guild
+     * @param commandId command id
+     * @param guild fetch from guild
+     */
     async fetch(commandId, guild) {
         const manager = guild ? this.client.guilds.resolve(guild)?.commands : this.client.application?.commands;
         if (!manager)
             throw new Error('Guild not found in cache');
         return manager.fetch(commandId);
     }
+    /**
+     * Parse application command builders to command data
+     * @param commands Application command builders
+     * @param setPermissions set slash commands permissions
+     */
     parseCommands(commands, setPermissions = true) {
         return commands.map(cmd => {
             if (cmd?.toJSON === undefined)

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

@@ -17,8 +17,14 @@ class ClientModuleManager {
         this.client = options.client;
         options.modules?.forEach(m => (m instanceof RecipleModule_1.RecipleModule ? m : new RecipleModule_1.RecipleModule({ client: this.client, script: m })));
     }
-    async startModules(modules, ignoreErrors = true) {
-        for (const module_ of modules) {
+    /**
+     * Start modules
+     * @param options start modules options
+     * @returns started modules
+     */
+    async startModules(options) {
+        const startedModules = [];
+        for (const module_ of options.modules) {
             if (!this.client.isClientLogsSilent)
                 this.client.logger.log(`Starting module '${module_}'`);
             try {
@@ -34,64 +40,88 @@ class ClientModuleManager {
                         this.client.logger.error(`Module '${module_}' returned false onStart`);
                     continue;
                 }
-                this.modules.set(module_.id, module_);
+                if (options.addToModulesCollection !== false)
+                    this.modules.set(module_.id, module_);
+                startedModules.push(module_);
             }
             catch (err) {
-                if (!ignoreErrors)
+                if (options?.ignoreErrors === false)
                     throw err;
                 if (!this.client.isClientLogsSilent)
                     this.client.logger.error(`Failed to start module '${module_}': `, err);
             }
         }
-        return modules;
+        return startedModules;
     }
-    async loadModules(modules, addModuleCommandsToClient = true, ignoreErrors = true) {
-        for (const module_ of this.modules.toJSON()) {
+    /**
+     * Load modules
+     * @param options load modules options
+     * @returns loaded modules
+     */
+    async loadModules(options) {
+        const loadedModules = [];
+        for (const module_ of options?.modules ?? this.modules.toJSON()) {
             try {
                 await module_.load().catch(err => {
                     throw err;
                 });
-                if (!this.client.isClientLogsSilent)
-                    this.client.logger.log(`Loaded module '${module_}'`);
-                if (addModuleCommandsToClient) {
+                if (options?.resolveCommands !== false) {
+                    module_.resolveCommands();
                     this.client.commands.add(module_.commands);
                 }
+                loadedModules.push(module_);
+                if (!this.client.isClientLogsSilent)
+                    this.client.logger.log(`Loaded module '${module_}'`);
             }
             catch (err) {
-                if (!ignoreErrors)
+                if (options?.ignoreErrors === false)
                     throw err;
                 if (!this.client.isClientLogsSilent)
                     this.client.logger.error(`Failed to load module '${module_}': `, err);
             }
         }
-        return modules;
+        return loadedModules;
     }
-    async unLoadModules(modules, removeUnloadedModules = true, ignoreErrors = true) {
-        for (const module_ of this.modules.toJSON()) {
+    /**
+     * Unload modules
+     * @param options unload modules options
+     * @returns unloaded modules
+     */
+    async unloadModules(options) {
+        const unloadedModules = [];
+        for (const module_ of options?.modules ?? this.modules.toJSON()) {
             try {
-                await module_.unLoad().catch(err => {
+                await module_.unload().catch(err => {
                     throw err;
                 });
-                if (removeUnloadedModules)
-                    this.modules.delete(module_.id);
+                unloadedModules.push(module_);
                 if (!this.client.isClientLogsSilent)
                     this.client.logger.log(`Unloaded module '${module_}'`);
             }
             catch (err) {
-                if (!ignoreErrors)
+                if (options?.ignoreErrors === false)
                     throw err;
                 if (!this.client.isClientLogsSilent)
                     this.client.logger.error(`Failed to unLoad module '${module_}': `, err);
             }
         }
-        return modules;
+        return unloadedModules;
     }
-    async getModulesFromFiles(options) {
+    /**
+     * Resolve modules from file paths
+     * @param options resolve module files options
+     * @returns resolved modules
+     */
+    async resolveModuleFiles(options) {
         const modules = [];
         for (const file of options.files) {
             try {
                 const resolveFile = await import(file);
-                let script = resolveFile?.default ?? resolveFile;
+                let script = resolveFile instanceof RecipleModule_1.RecipleModule || ClientModuleManager.validateScript(resolveFile)
+                    ? resolveFile
+                    : resolveFile?.default?.default instanceof RecipleModule_1.RecipleModule || ClientModuleManager.validateScript(resolveFile?.default?.default)
+                        ? resolveFile.default.default
+                        : resolveFile?.default;
                 if (script instanceof RecipleModule_1.RecipleModule) {
                     modules.push(script);
                     continue;
@@ -105,7 +135,7 @@ class ClientModuleManager {
                 }));
             }
             catch (err) {
-                if (options.dontSkipError)
+                if (options.ignoreErrors === false)
                     throw err;
                 if (!this.client.isClientLogsSilent)
                     this.client.logger.error(`Can't resolve module from: ${file}`, err);
@@ -113,6 +143,11 @@ class ClientModuleManager {
         }
         return modules;
     }
+    /**
+     * Validate module script
+     * @param script module script
+     * @returns `true` if script is valid
+     */
     static validateScript(script) {
         const s = script;
         if (typeof s !== 'object')
@@ -123,10 +158,15 @@ class ClientModuleManager {
             return false;
         if (s.onLoad && typeof s.onLoad !== 'function')
             return false;
-        if (s.onUnLoad && typeof s.onUnLoad !== 'function')
+        if (s.onUnload && typeof s.onUnload !== 'function')
             return false;
         return true;
     }
+    /**
+     * Get module file paths from folders
+     * @param options get module paths options
+     * @returns module paths
+     */
     async getModulePaths(options) {
         const modules = [];
         for (const dir of options?.folders ?? (0, discord_js_1.normalizeArray)([this.client.config.modulesFolder])) {

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

@@ -28,7 +28,7 @@ export interface RecipleScript {
      * @param reason Unload reason
      * @param client Bot client
      */
-    onUnLoad?(reason: unknown, client: RecipleClient<true>): void | Promise<void>;
+    onUnload?(reason: unknown, client: RecipleClient<true>): void | Promise<void>;
 }
 export interface RecipleModuleOptions<M = unknown> {
     client: RecipleClient;
@@ -47,7 +47,7 @@ export declare class RecipleModule<M = unknown> {
     constructor(options: RecipleModuleOptions<M>);
     start(): Promise<boolean>;
     load(resolveCommands?: boolean): Promise<void>;
-    unLoad(reason?: any): 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>;

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

@@ -5,11 +5,47 @@ export declare type ApplicationCommandBuilder = AnySlashCommandBuilder | Context
 export declare class ApplicationCommandManager {
     readonly client: RecipleClient;
     constructor(client: RecipleClient);
+    /**
+     * Sets application commands globally or in guilds
+     * @param commands Application commands
+     * @param guilds set only to guilds
+     */
     set(commands: (ApplicationCommandBuilder | ApplicationCommandData)[], ...guilds: RestOrArray<GuildResolvable>): Promise<void>;
+    /**
+     * Add command globally or in guilds
+     * @param command Application command
+     * @param guilds add only in guilds
+     */
     add(command: ApplicationCommandBuilder | ApplicationCommandData, ...guilds: RestOrArray<GuildResolvable>): Promise<void>;
+    /**
+     * Remove application command globally or in guilds
+     * @param command id of application commmand or ApplicationCommand class
+     * @param guilds Remove from guilds
+     */
     remove(command: string | ApplicationCommand, ...guilds: RestOrArray<GuildResolvable>): Promise<void>;
+    /**
+     * Edit application command globally or in guilds
+     * @param command id of application command or ApplicationCommand class
+     * @param newCommand new application command data
+     * @param guilds Edit only from guilds
+     */
     edit(command: string | ApplicationCommand, newCommand: ApplicationCommandBuilder | ApplicationCommandData, ...guilds: RestOrArray<GuildResolvable>): Promise<void>;
+    /**
+     * Get application command from cache by application command data, builder, id, or name globally or from guid
+     * @param command application command data, builder, id, or name
+     * @param guild get command from guild
+     */
     get(command: ApplicationCommandData | ApplicationCommandBuilder | string, guild?: GuildResolvable): ApplicationCommand | undefined;
+    /**
+     * Fetch application command by id globally or from guild
+     * @param commandId command id
+     * @param guild fetch from guild
+     */
     fetch(commandId: string, guild?: GuildResolvable): Promise<ApplicationCommand>;
+    /**
+     * Parse application command builders to command data
+     * @param commands Application command builders
+     * @param setPermissions set slash commands permissions
+     */
     protected parseCommands(commands: (ApplicationCommandData | ApplicationCommandBuilder | RESTPostAPIApplicationCommandsJSONBody)[], setPermissions?: boolean): (ApplicationCommandData | RESTPostAPIApplicationCommandsJSONBody)[];
 }

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

@@ -1,5 +1,5 @@
 import { Collection } from 'discord.js';
-import { ClientModuleManagerGetModulePathsOptions, ClientModuleManagerGetModulesFromFilesOptions } from '../../types/paramOptions';
+import { ClientModuleManagerGetModulePathsOptions, ClientModuleManagerLoadModulesOptions, ClientModuleManagerResolveModuleFilesOptions, ClientModuleManagerStartModulesOptions, ClientModuleManagerUnloadModulesOptions } from '../../types/paramOptions';
 import { RecipleClient } from '../RecipleClient';
 import { RecipleModule, RecipleScript } from '../RecipleModule';
 export interface ClientModuleManagerOptions {
@@ -10,10 +10,40 @@ export declare class ClientModuleManager {
     readonly client: RecipleClient;
     readonly modules: Collection<string, RecipleModule>;
     constructor(options: ClientModuleManagerOptions);
-    startModules(modules: RecipleModule[], ignoreErrors?: boolean): Promise<RecipleModule[]>;
-    loadModules(modules: RecipleModule[], addModuleCommandsToClient?: boolean, ignoreErrors?: boolean): Promise<RecipleModule[]>;
-    unLoadModules(modules: RecipleModule[], removeUnloadedModules?: boolean, ignoreErrors?: boolean): Promise<RecipleModule[]>;
-    getModulesFromFiles(options: ClientModuleManagerGetModulesFromFilesOptions): Promise<RecipleModule[]>;
+    /**
+     * Start modules
+     * @param options start modules options
+     * @returns started modules
+     */
+    startModules(options: ClientModuleManagerStartModulesOptions): Promise<RecipleModule[]>;
+    /**
+     * Load modules
+     * @param options load modules options
+     * @returns loaded modules
+     */
+    loadModules(options?: ClientModuleManagerLoadModulesOptions): Promise<RecipleModule[]>;
+    /**
+     * Unload modules
+     * @param options unload modules options
+     * @returns unloaded modules
+     */
+    unloadModules(options?: ClientModuleManagerUnloadModulesOptions): Promise<RecipleModule[]>;
+    /**
+     * Resolve modules from file paths
+     * @param options resolve module files options
+     * @returns resolved modules
+     */
+    resolveModuleFiles(options: ClientModuleManagerResolveModuleFilesOptions): Promise<RecipleModule[]>;
+    /**
+     * Validate module script
+     * @param script module script
+     * @returns `true` if script is valid
+     */
     static validateScript(script: unknown): script is RecipleScript;
+    /**
+     * Get module file paths from folders
+     * @param options get module paths options
+     * @returns module paths
+     */
     getModulePaths(options?: ClientModuleManagerGetModulePathsOptions): Promise<string[]>;
 }

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

@@ -1,6 +1,7 @@
 import { ConfigCommandPermissions } from '../classes/RecipleConfig';
 import { Awaitable, PermissionsBitField } from 'discord.js';
 import { AnyCommandBuilder } from './builders';
+import { RecipleModule } from '../classes/RecipleModule';
 export interface UserHasCommandPermissionsOptions {
     /**
      * Command builder
@@ -18,13 +19,83 @@ export interface UserHasCommandPermissionsOptions {
         commands: ConfigCommandPermissions[];
     };
 }
-export interface ClientModuleManagerGetModulesFromFilesOptions {
+export interface ClientModuleManagerResolveModuleFilesOptions {
+    /**
+     * valid reciple module (ESM or CJS) Javascript file paths
+     */
     files: string[];
+    /**
+     * Allow loading unsupported module versions
+     * @default false
+     */
     disabeVersionCheck?: boolean;
-    dontSkipError?: boolean;
+    /**
+     * Ignore errors
+     * @dafault true
+     */
+    ignoreErrors?: boolean;
 }
 export interface ClientModuleManagerGetModulePathsOptions {
+    /**
+     * Get javascript module file paths from folders
+     */
     folders?: string[];
+    /**
+     * Add ignored files (wildcard)
+     * @example _*.js // Ignores _module.js and _hi.js
+     */
     ignoredFiles?: string[];
+    /**
+     * Filter found javascript files
+     * @param file Loaded javascript file
+     * @returns `true` if the path is acceptable
+     */
     filter?: (file: string) => Awaitable<boolean>;
 }
+export interface ClientModuleManagerStartModulesOptions {
+    /**
+     * Modules to start
+     */
+    modules: RecipleModule[];
+    /**
+     * Add modules to Client modules collection
+     * @default true
+     */
+    addToModulesCollection?: boolean;
+    /**
+     * Ignore errors
+     * @default true
+     */
+    ignoreErrors?: boolean;
+}
+export interface ClientModuleManagerLoadModulesOptions {
+    /**
+     * Modules to execute `load` method
+     */
+    modules?: RecipleModule[];
+    /**
+     * Add commands to client
+     * @default true
+     */
+    resolveCommands?: boolean;
+    /**
+     * Ignore errors
+     * @default true
+     */
+    ignoreErrors?: boolean;
+}
+export interface ClientModuleManagerUnloadModulesOptions {
+    /**
+     * Modules to execute `unload` method
+     */
+    modules?: RecipleModule[];
+    /**
+     * Reason for unloading modules
+     */
+    reason?: string;
+    /**
+     * Ignore errors
+     * @default true
+     */
+    ignoreErrors?: boolean;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reciple",
-  "version": "6.0.0-dev.14",
+  "version": "6.0.0-dev.16",
   "bin": "./dist/lib/bin.mjs",
   "license": "GPL-3.0",
   "type": "commonjs",