reciple 6.0.0-dev.2 → 6.0.0-dev.20

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

@@ -1,5 +1,5 @@
 import { Guild, RestOrArray, TextBasedChannel, User } from 'discord.js';
-import { CommandBuilderType } from '../../types/builders';
+import { CommandType } from '../../types/builders';
 /**
  * cooled-down user object interface
  */
@@ -15,7 +15,7 @@ export interface CooledDownUser {
     /**
      * Command type
      */
-    type: CommandBuilderType;
+    type: CommandType;
     /**
      * In guild
      */

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

@@ -1,21 +1,20 @@
 import { ApplicationCommandData, Collection, GuildResolvable, RestOrArray } from 'discord.js';
-import { AnyCommandBuilder, AnyCommandData, AnySlashCommandBuilder, CommandBuilderType, MessageCommandData, SlashCommandData } from '../../types/builders';
+import { AnyCommandBuilder, AnyCommandData, AnySlashCommandBuilder, CommandType, 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 {
+export interface CommandManagerOptions {
     client: RecipleClient;
     messageCommands?: (MessageCommandBuilder | MessageCommandData)[];
     slashCommands?: (AnySlashCommandBuilder | SlashCommandData)[];
 }
-export declare class ClientCommandManager {
+export declare class CommandManager {
     readonly client: RecipleClient;
     readonly slashCommands: Collection<string, AnySlashCommandBuilder>;
     readonly messageCommands: Collection<string, MessageCommandBuilder>;
     readonly additionalApplicationCommands: (ApplicationCommandBuilder | ApplicationCommandData)[];
-    get applicationCommandsSize(): number;
-    constructor(options: ClientCommandManagerOptions);
+    constructor(options: CommandManagerOptions);
     /**
      * Add command to command manager
      * @param commands Any command data or builder
@@ -27,8 +26,8 @@ export declare class ClientCommandManager {
      * @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;
+    get(command: string, type?: CommandType.MessageCommand): MessageCommandBuilder | undefined;
+    get(command: string, type?: CommandType.SlashCommand): SlashCommandBuilder | undefined;
     /**
      * Register application commands
      * @param guilds Register application commands to guilds

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

@@ -0,0 +1,49 @@
+import { Collection } from 'discord.js';
+import { ModuleManagerGetModulePathsOptions, ModuleManagerLoadModulesOptions, ModuleManagerResolveModuleFilesOptions, ModuleManagerStartModulesOptions, ModuleManagerUnloadModulesOptions } from '../../types/paramOptions';
+import { RecipleClient } from '../RecipleClient';
+import { RecipleModule, RecipleScript } from '../RecipleModule';
+export interface ModuleManagerOptions {
+    client: RecipleClient;
+    modules?: (RecipleModule | RecipleScript)[];
+}
+export declare class ModuleManager {
+    readonly client: RecipleClient;
+    readonly modules: Collection<string, RecipleModule>;
+    constructor(options: ModuleManagerOptions);
+    /**
+     * Start modules
+     * @param options start modules options
+     * @returns started modules
+     */
+    startModules(options: ModuleManagerStartModulesOptions): Promise<RecipleModule[]>;
+    /**
+     * Load modules
+     * @param options load modules options
+     * @returns loaded modules
+     */
+    loadModules(options?: ModuleManagerLoadModulesOptions): Promise<RecipleModule[]>;
+    /**
+     * Unload modules
+     * @param options unload modules options
+     * @returns unloaded modules
+     */
+    unloadModules(options?: ModuleManagerUnloadModulesOptions): Promise<RecipleModule[]>;
+    /**
+     * Resolve modules from file paths
+     * @param options resolve module files options
+     * @returns resolved modules
+     */
+    resolveModuleFiles(options: ModuleManagerResolveModuleFilesOptions): 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?: ModuleManagerGetModulePathsOptions): Promise<string[]>;
+}

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

@@ -25,11 +25,11 @@ export declare type AnyCommandExecuteFunction<T = unknown> = SlashCommandExecute
 /**
  * Command halt function
  */
-export declare type CommandHaltFunction<T extends CommandBuilderType, M = unknown> = (haltData: T extends CommandBuilderType.SlashCommand ? SlashCommandHaltData<M> : T extends CommandBuilderType.MessageCommand ? MessageCommandHaltData<M> : SlashCommandHaltData<M> | MessageCommandHaltData<M>) => Awaitable<boolean | null | undefined | void>;
+export declare type CommandHaltFunction<T extends CommandType, M = unknown> = (haltData: T extends CommandType.SlashCommand ? SlashCommandHaltData<M> : T extends CommandType.MessageCommand ? MessageCommandHaltData<M> : SlashCommandHaltData<M> | MessageCommandHaltData<M>) => Awaitable<boolean | null | undefined | void>;
 /**
  * Command execute function
  */
-export declare type CommandExecuteFunction<T extends CommandBuilderType, M = unknown> = (executeData: T extends CommandBuilderType.SlashCommand ? SlashCommandExecuteData<M> : T extends CommandBuilderType.MessageCommand ? MessageCommandExecuteData<M> : SlashCommandExecuteData<M> | MessageCommandExecuteData<M>) => Awaitable<void>;
+export declare type CommandExecuteFunction<T extends CommandType, M = unknown> = (executeData: T extends CommandType.SlashCommand ? SlashCommandExecuteData<M> : T extends CommandType.MessageCommand ? MessageCommandExecuteData<M> : SlashCommandExecuteData<M> | MessageCommandExecuteData<M>) => Awaitable<void>;
 /**
  * Message command options resolvable
  */
@@ -53,15 +53,15 @@ export declare type AnySlashCommandOptionsOnlyOptionBuilder = SlashCommandAttach
 /**
  * Types of command builders
  */
-export declare enum CommandBuilderType {
-    MessageCommand = 0,
-    SlashCommand = 1
+export declare enum CommandType {
+    SlashCommand = 1,
+    MessageCommand = 2
 }
 /**
  * Shared command builder methods and properties
  */
 export interface SharedCommandBuilderProperties<T = unknown> {
-    readonly type: CommandBuilderType;
+    readonly type: CommandType;
     cooldown: number;
     requiredBotPermissions: PermissionResolvable[];
     requiredMemberPermissions: PermissionResolvable[];
@@ -111,7 +111,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'>> {
-    type: CommandBuilderType.SlashCommand;
+    type: CommandType.SlashCommand;
     nameLocalizations?: LocalizationMap;
     descriptionLocalizations?: LocalizationMap;
     options?: (AnySlashCommandOptionData | AnySlashCommandOptionBuilder)[];
@@ -179,7 +179,7 @@ export interface SlashCommandSubCommandGroupData extends SharedCommandDataProper
  * Message command object data interface
  */
 export interface MessageCommandData<T = unknown> extends SharedCommandDataProperties, Partial<Omit<SharedCommandBuilderProperties<T>, 'setCooldown' | 'setRequiredBotPermissions' | 'setRequiredMemberPermissions' | 'setHalt' | 'setExecute' | 'setMetadata' | 'halt' | 'execute'>> {
-    type: CommandBuilderType.MessageCommand;
+    type: CommandType.MessageCommand;
     aliases?: string[];
     validateOptions?: boolean;
     allowExecuteInDM?: boolean;

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

@@ -3,7 +3,7 @@ import { SlashCommandExecuteData, SlashCommandHaltData } from '../classes/builde
 import { MessageCommandOptionManager } from '../classes/managers/MessageCommandOptionManager';
 import { CooledDownUser } from '../classes/managers/CommandCooldownManager';
 import { RecipleClient } from '../classes/RecipleClient';
-import { CommandBuilderType } from '../types/builders';
+import { CommandType } from '../types/builders';
 /**
  * Any command halt data
  */
@@ -11,7 +11,7 @@ export declare type AnyCommandHaltData<T = unknown> = SlashCommandHaltData<T> |
 /**
  * command halt data
  */
-export declare type CommandHaltData<T extends CommandBuilderType, M = unknown> = CommandErrorData<T, M> | CommandCooldownData<T, M> | (T extends CommandBuilderType.SlashCommand ? never : CommandInvalidArguments<T, M> | CommandMissingArguments<T, M>) | CommandMissingMemberPermissions<T, M> | CommandMissingBotPermissions<T, M>;
+export declare type CommandHaltData<T extends CommandType, M = unknown> = CommandErrorHaltData<T, M> | CommandCooldownHaltData<T, M> | (T extends CommandType.SlashCommand ? never : CommandInvalidArgumentsHaltData<T, M> | CommandMissingArgumentsHaltData<T, M>) | CommandMissingMemberPermissionsHaltData<T, M> | CommandMissingBotPermissionsHaltData<T, M>;
 /**
  * Any command execute data
  */
@@ -28,7 +28,7 @@ export interface BaseCommandExecuteData {
 /**
  * Command halt reason base
  */
-export interface BaseCommandHaltData<T extends CommandBuilderType, M = unknown> {
+export interface BaseCommandHaltData<T extends CommandType, M = unknown> {
     /**
      * Halt reason
      */
@@ -36,46 +36,46 @@ export interface BaseCommandHaltData<T extends CommandBuilderType, M = unknown>
     /**
      * Command execute da6a
      */
-    executeData: T extends CommandBuilderType.SlashCommand ? SlashCommandExecuteData<M> : T extends CommandBuilderType.MessageCommand ? MessageCommandExecuteData<M> : AnyCommandExecuteData<M>;
+    executeData: T extends CommandType.SlashCommand ? SlashCommandExecuteData<M> : T extends CommandType.MessageCommand ? MessageCommandExecuteData<M> : AnyCommandExecuteData<M>;
 }
-export interface CommandErrorData<T extends CommandBuilderType, M = unknown> extends BaseCommandHaltData<T, M> {
+export interface CommandErrorHaltData<T extends CommandType, M = unknown> extends BaseCommandHaltData<T, M> {
     reason: CommandHaltReason.Error;
     /**
      * Caught error
      */
     error: any;
 }
-export interface CommandCooldownData<T extends CommandBuilderType, M = unknown> extends BaseCommandHaltData<T, M>, CooledDownUser {
+export interface CommandCooldownHaltData<T extends CommandType, M = unknown> extends BaseCommandHaltData<T, M>, CooledDownUser {
     reason: CommandHaltReason.Cooldown;
 }
-export interface CommandInvalidArguments<T extends CommandBuilderType, M = unknown> extends BaseCommandHaltData<T, M> {
+export interface CommandInvalidArgumentsHaltData<T extends CommandType, M = unknown> extends BaseCommandHaltData<T, M> {
     reason: CommandHaltReason.InvalidArguments;
     /**
      * Arguments that are invalid
      */
     invalidArguments: MessageCommandOptionManager;
 }
-export interface CommandMissingArguments<T extends CommandBuilderType, M = unknown> extends BaseCommandHaltData<T, M> {
+export interface CommandMissingArgumentsHaltData<T extends CommandType, M = unknown> extends BaseCommandHaltData<T, M> {
     reason: CommandHaltReason.MissingArguments;
     /**
      * Arguments that are missing
      */
     missingArguments: MessageCommandOptionManager;
 }
-export interface CommandMissingMemberPermissions<T extends CommandBuilderType, M = unknown> extends BaseCommandHaltData<T, M> {
+export interface CommandMissingMemberPermissionsHaltData<T extends CommandType, M = unknown> extends BaseCommandHaltData<T, M> {
     reason: CommandHaltReason.MissingMemberPermissions;
 }
-export interface CommandMissingBotPermissions<T extends CommandBuilderType, M = unknown> extends BaseCommandHaltData<T, M> {
+export interface CommandMissingBotPermissionsHaltData<T extends CommandType, M = unknown> extends BaseCommandHaltData<T, M> {
     reason: CommandHaltReason.MissingBotPermissions;
 }
 /**
  * Command halt reasons
  */
 export declare enum CommandHaltReason {
-    Error = 0,
-    Cooldown = 1,
-    InvalidArguments = 2,
-    MissingArguments = 3,
-    MissingMemberPermissions = 4,
-    MissingBotPermissions = 5
+    Error = 1,
+    Cooldown = 2,
+    InvalidArguments = 3,
+    MissingArguments = 4,
+    MissingMemberPermissions = 5,
+    MissingBotPermissions = 6
 }

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

@@ -1,21 +1,7 @@
-import { RecipleModule, RecipleScript } from '../classes/managers/ClientModuleManager';
 import { ConfigCommandPermissions } from '../classes/RecipleConfig';
-import { PermissionsBitField } from 'discord.js';
+import { Awaitable, 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'];
-}
+import { RecipleModule } from '../classes/RecipleModule';
 export interface UserHasCommandPermissionsOptions {
     /**
      * Command builder
@@ -33,8 +19,83 @@ export interface UserHasCommandPermissionsOptions {
         commands: ConfigCommandPermissions[];
     };
 }
-export interface ModuleManagerResolveFilesOptions {
+export interface ModuleManagerResolveModuleFilesOptions {
+    /**
+     * 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 ModuleManagerGetModulePathsOptions {
+    /**
+     * 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 ModuleManagerStartModulesOptions {
+    /**
+     * Modules to start
+     */
+    modules: RecipleModule[];
+    /**
+     * Add modules to Client modules collection
+     * @default true
+     */
+    addToModulesCollection?: boolean;
+    /**
+     * Ignore errors
+     * @default true
+     */
+    ignoreErrors?: boolean;
+}
+export interface ModuleManagerLoadModulesOptions {
+    /**
+     * Modules to execute `load` method
+     */
+    modules?: RecipleModule[];
+    /**
+     * Add commands to client
+     * @default true
+     */
+    resolveCommands?: boolean;
+    /**
+     * Ignore errors
+     * @default true
+     */
+    ignoreErrors?: boolean;
+}
+export interface ModuleManagerUnloadModulesOptions {
+    /**
+     * Modules to execute `unload` method
+     */
+    modules?: RecipleModule[];
+    /**
+     * Reason for unloading modules
+     */
+    reason?: string;
+    /**
+     * Ignore errors
+     * @default true
+     */
+    ignoreErrors?: boolean;
 }

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

@@ -1,3 +1,6 @@
+/// <reference types="node" />
+import { Logger } from 'fallout-utility';
+import { default as _path } from 'path';
 import { AnyCommandBuilder } from './types/builders';
 /**
  * Check if an object is a class
@@ -10,3 +13,11 @@ 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;
+export declare const path: _path.PlatformPath;

package/package.json

@@ -1,18 +1,26 @@
 {
   "name": "reciple",
-  "version": "6.0.0-dev.2",
-  "bin": "./dist/cjs/bin.js",
+  "version": "6.0.0-dev.20",
+  "bin": "./dist/lib/bin.mjs",
   "license": "GPL-3.0",
-  "main": "./dist/cjs/index.js",
+  "type": "commonjs",
+  "main": "./dist/lib/index.js",
   "types": "./dist/types/index.d.ts",
-  "module": "./dist/mjs/index.js",
+  "module": "./dist/lib/esm.mjs",
   "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"
+    ".": {
+      "import": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/lib/esm.mjs"
+      },
+      "require": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/lib/index.js"
+      }
+    }
   },
   "keywords": [
     "Discord",
@@ -26,14 +34,14 @@
     "url": "https://github.com/FalloutStudios/reciple/issues"
   },
   "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",
-    "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"
+    "format": "npx prettier --write src",
+    "clean": "npx rimraf dist",
+    "build": "npm run clean && npx tsc",
+    "build:publish": "npm run format && npm run build && npm run docs && npm publish",
+    "build:publish-dev": "npm run format && npm run build && npm publish --tag dev",
+    "test": "npm run build && npm install && npm run start -w test",
+    "docs": "npx docgen --typescript true -c ./docs/index.json -o ./docs/docs.json -i src/index.ts",
+    "watch": "npx tsc --watch --noEmit"
   },
   "repository": {
     "type": "git",
@@ -53,7 +61,7 @@
     "chalk": "4.1.2",
     "commander": "^9.4.1",
     "dotenv": "^16.0.3",
-    "fallout-utility": "^1.5.4",
+    "fallout-utility": "^1.5.13",
     "semver": "^7.3.7",
     "wildcard-match": "^5.1.2",
     "yaml": "^2.1.1"
@@ -72,6 +80,5 @@
   },
   "workspaces": [
     "test"
-  ],
-  "packageManager": "yarn@3.2.2"
-}
+  ]
+}

package/resource/reciple.yml

@@ -4,20 +4,24 @@ token: TOKEN
 
 # Commands options
 commands:
-  # message command options
-  messageCommand:
-    # enable message commands
+  # Interaction command options
+  slashCommand:
+    # enable interaction commands
     enabled: true
-    # command prefix
-    prefix: '!'
     # reply when an error occured
     replyOnError: false
     # enable the use of command cooldowns
     enableCooldown: true
-    # allow executing commands via aliases
-    allowCommandAlias: true
-    # command argument separator
-    commandArgumentSeparator: ' '
+    # register interaction commands on bot ready
+    registerCommands: true
+    # allow register empty list of application commands
+    allowRegisterEmptyCommandList: true
+    # set required permissions for interaction commands
+    setRequiredPermissions: true
+    # accept replied or deffered command interaction
+    acceptRepliedInteractions: false
+    # register commands to specific guild(s) empty to make it global
+    guilds: []
     # overwrite command permissions
     permissions:
       # enable overwriten command permissions
@@ -27,22 +31,20 @@ commands:
           permissions:
             - Administrator
 
-  # Interaction command options
-  slashCommand:
-    # enable interaction commands
+  # message command options
+  messageCommand:
+    # enable message commands
     enabled: true
+    # command prefix
+    prefix: '!'
     # reply when an error occured
     replyOnError: false
     # enable the use of command cooldowns
     enableCooldown: true
-    # register interaction commands on bot ready
-    registerCommands: true
-    # set required permissions for interaction commands
-    setRequiredPermissions: true
-    # accept replied or deffered command interaction
-    acceptRepliedInteractions: false
-    # register commands to specific guild(s) empty to make it global
-    guilds: []
+    # allow executing commands via aliases
+    allowCommandAlias: true
+    # command argument separator
+    commandArgumentSeparator: ' '
     # overwrite command permissions
     permissions:
       # enable overwriten command permissions
@@ -52,7 +54,6 @@ commands:
           permissions:
             - Administrator
 
-
 # Logger options
 fileLogging:
   # enable console output to file
@@ -93,7 +94,9 @@ messages:
     ephemeral: true
 
 # Ignored Files
-ignoredFiles: []
+ignoredFiles:
+  - '_*'
+  - '.*'
 
 
 ####################################################

package/dist/cjs/bin.js

@@ -1,50 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const RecipleClient_1 = require("./reciple/classes/RecipleClient");
-const RecipleConfig_1 = require("./reciple/classes/RecipleConfig");
-const version_1 = require("./reciple/version");
-const fs_1 = require("fs");
-const flags_1 = require("./reciple/flags");
-const fallout_utility_1 = require("fallout-utility");
-const chalk_1 = __importDefault(require("chalk"));
-require("dotenv/config");
-const path_1 = __importDefault(require("path"));
-const allowedFiles = ['node_modules', 'reciple.yml', 'package.json'];
-const configPath = path_1.default.join(flags_1.cwd, './reciple.yml');
-if ((0, fs_1.readdirSync)(flags_1.cwd).filter(f => !f.startsWith('.') && allowedFiles.indexOf(f)).length > 0 && !(0, fs_1.existsSync)(flags_1.flags.config ?? configPath)) {
-    const ask = (flags_1.flags.yes ? 'y' : null) ?? (0, fallout_utility_1.input)('This directory does not contain reciple.yml. Would you like to init axis here? [y/n] ') ?? '';
-    if (ask.toString().toLowerCase() !== 'y')
-        process.exit(0);
-}
-let configParser;
-try {
-    configParser = new RecipleConfig_1.RecipleConfig(flags_1.flags.config ?? configPath).parseConfig();
-}
-catch (err) {
-    console.error(`${chalk_1.default.bold.red('Config Error')}: ${chalk_1.default.white(err.message)}`);
-    process.exit(1);
-}
-const config = configParser.getConfig();
-const client = new RecipleClient_1.RecipleClient({ config: config, ...config.client });
-if (!client.isClientLogsSilent)
-    client.logger.info('Starting Reciple client v' + version_1.rawVersion);
-(async () => {
-    client.addCommandListeners();
-    await client.modules.startModulesFromFiles({
-        files: await client.modules.getModuleFiles(),
-    });
-    client.on('ready', async () => {
-        await client.modules.loadAll(true);
-        if (!client.isClientLogsSilent)
-            client.logger.warn(`Logged in as ${client.user?.tag || 'Unknown'}!`);
-        client.on('cacheSweep', () => client.cooldowns.clean());
-    });
-    client.login(config.token).catch(err => {
-        if (!client.isClientLogsSilent)
-            client.logger.error(err);
-    });
-})();