reciple 6.0.0-dev.1 → 6.0.0-dev.12

package/dist/{cjs → lib}/reciple/classes/builders/SlashCommandBuilder.js

@@ -10,11 +10,13 @@ const discord_js_1 = require("discord.js");
 class SlashCommandBuilder extends discord_js_1.SlashCommandBuilder {
     constructor(data) {
         super();
-        this.type = builders_1.CommandBuilderType.SlashCommand;
+        this.type = builders_1.CommandType.SlashCommand;
         this.cooldown = 0;
         this.requiredBotPermissions = [];
         this.requiredMemberPermissions = [];
-        this.execute = () => { };
+        this.execute = () => {
+            /* Execute */
+        };
         // TODO: WTH
         if (data?.name !== undefined)
             this.setName(data.name);
@@ -58,9 +60,7 @@ class SlashCommandBuilder extends discord_js_1.SlashCommandBuilder {
     }
     setRequiredMemberPermissions(...permissions) {
         this.requiredMemberPermissions = (0, discord_js_1.normalizeArray)(permissions);
-        this.setDefaultMemberPermissions(this.requiredMemberPermissions.length
-            ? new discord_js_1.PermissionsBitField(this.requiredMemberPermissions).bitfield
-            : undefined);
+        this.setDefaultMemberPermissions(this.requiredMemberPermissions.length ? new discord_js_1.PermissionsBitField(this.requiredMemberPermissions).bitfield : undefined);
         return this;
     }
     setHalt(halt) {
@@ -135,13 +135,10 @@ class SlashCommandBuilder extends discord_js_1.SlashCommandBuilder {
                 builder = new discord_js_1.SlashCommandBooleanOption();
                 break;
             case discord_js_1.ApplicationCommandOptionType.Channel:
-                builder = new discord_js_1.SlashCommandChannelOption()
-                    .addChannelTypes(...(option.channelTypes ?? []));
+                builder = new discord_js_1.SlashCommandChannelOption().addChannelTypes(...(option.channelTypes ?? []));
                 break;
             case discord_js_1.ApplicationCommandOptionType.Integer:
-                builder = new discord_js_1.SlashCommandIntegerOption()
-                    .addChoices(...(option.choices ?? []))
-                    .setAutocomplete(!!option.autocomplete);
+                builder = new discord_js_1.SlashCommandIntegerOption().addChoices(...(option.choices ?? [])).setAutocomplete(!!option.autocomplete);
                 if (option.maxValue)
                     builder.setMaxValue(option.maxValue);
                 if (option.minValue)
@@ -151,9 +148,7 @@ class SlashCommandBuilder extends discord_js_1.SlashCommandBuilder {
                 builder = new discord_js_1.SlashCommandMentionableOption();
                 break;
             case discord_js_1.ApplicationCommandOptionType.Number:
-                builder = new discord_js_1.SlashCommandNumberOption()
-                    .addChoices(...(option.choices ?? []))
-                    .setAutocomplete(!!option.autocomplete);
+                builder = new discord_js_1.SlashCommandNumberOption().addChoices(...(option.choices ?? [])).setAutocomplete(!!option.autocomplete);
                 if (option.maxValue)
                     builder.setMaxValue(option.maxValue);
                 if (option.minValue)
@@ -163,9 +158,7 @@ class SlashCommandBuilder extends discord_js_1.SlashCommandBuilder {
                 builder = new discord_js_1.SlashCommandRoleOption();
                 break;
             case discord_js_1.ApplicationCommandOptionType.String:
-                builder = new discord_js_1.SlashCommandStringOption()
-                    .addChoices(...(option.choices ?? []))
-                    .setAutocomplete(!!option.autocomplete);
+                builder = new discord_js_1.SlashCommandStringOption().addChoices(...(option.choices ?? [])).setAutocomplete(!!option.autocomplete);
                 if (option.maxLength)
                     builder.setMaxLength(option.maxLength);
                 if (option.minLength)
@@ -183,17 +176,13 @@ class SlashCommandBuilder extends discord_js_1.SlashCommandBuilder {
             case discord_js_1.ApplicationCommandOptionType.SubcommandGroup:
                 builder = new discord_js_1.SlashCommandSubcommandGroupBuilder();
                 for (const subCommandData of option.options) {
-                    builder.addSubcommand(subCommandData instanceof discord_js_1.SlashCommandSubcommandBuilder
-                        ? subCommandData
-                        : this.resolveOption(subCommandData));
+                    builder.addSubcommand(subCommandData instanceof discord_js_1.SlashCommandSubcommandBuilder ? subCommandData : this.resolveOption(subCommandData));
                 }
                 break;
             default:
-                throw new TypeError("Unknown option data");
+                throw new TypeError('Unknown option data');
         }
-        if (!(builder instanceof discord_js_1.SlashCommandSubcommandBuilder) && !(builder instanceof discord_js_1.SlashCommandSubcommandGroupBuilder)
-            &&
-                option.type !== discord_js_1.ApplicationCommandOptionType.Subcommand && option.type !== discord_js_1.ApplicationCommandOptionType.SubcommandGroup) {
+        if (!(builder instanceof discord_js_1.SlashCommandSubcommandBuilder) && !(builder instanceof discord_js_1.SlashCommandSubcommandGroupBuilder) && option.type !== discord_js_1.ApplicationCommandOptionType.Subcommand && option.type !== discord_js_1.ApplicationCommandOptionType.SubcommandGroup) {
             builder.setRequired(option.required ?? false);
         }
         return builder

package/dist/{cjs → lib}/reciple/classes/managers/ApplicationCommandManager.js

@@ -7,98 +7,101 @@ 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;
         }
         let guild = guilds?.shift();
         guild = guild ? this.client.guilds.resolveId(guild) || undefined : undefined;
         if (!guild) {
-            this.client.application.commands.set(commands);
-            if (this.client.isClientLogsEnabled())
+            await this.client.application.commands.set(commands);
+            if (!this.client.isClientLogsSilent)
                 this.client.logger.log(`Registered ${this.client.commands.applicationCommandsSize} application command(s) globally...`);
         }
         else {
-            this.client.application.commands.set(commands, guild);
-            if (this.client.isClientLogsEnabled())
+            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}...`);
         }
     }
-    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;
         }
         let guild = guilds?.shift();
         guild = guild ? this.client.guilds.resolveId(guild) || undefined : undefined;
         if (!guild) {
-            this.client.application.commands.create(command);
-            if (this.client.isClientLogsEnabled())
+            await this.client.application.commands.create(command);
+            if (!this.client.isClientLogsSilent)
                 this.client.logger.log(`Created application command '${command.name}' globally`);
         }
         else {
-            this.client.application.commands.create(command, guild);
-            if (this.client.isClientLogsEnabled())
+            await this.client.application.commands.create(command, guild);
+            if (!this.client.isClientLogsSilent)
                 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;
         }
         let guild = guilds?.shift();
         guild = guild ? this.client.guilds.resolveId(guild) || undefined : undefined;
         if (!guild) {
-            this.client.application.commands.delete(command);
-            if (this.client.isClientLogsEnabled())
+            await this.client.application.commands.delete(command);
+            if (!this.client.isClientLogsSilent)
                 this.client.logger.log(`Removed application command '${typeof command === 'string' ? command : command.name}' globally`);
         }
         else {
-            this.client.application.commands.delete(command, guild);
-            if (this.client.isClientLogsEnabled())
+            await this.client.application.commands.delete(command, guild);
+            if (!this.client.isClientLogsSilent)
                 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;
         }
         let guild = guilds?.shift();
         guild = guild ? this.client.guilds.resolveId(guild) || undefined : undefined;
         if (!guild) {
-            this.client.application.commands.edit(command, newCommand);
-            if (this.client.isClientLogsEnabled())
+            await this.client.application.commands.edit(command, newCommand);
+            if (!this.client.isClientLogsSilent)
                 this.client.logger.log(`Removed application command '${typeof command === 'string' ? command : command.name}' globally`);
         }
         else {
-            this.client.application.commands.edit(command, newCommand, guild);
-            if (this.client.isClientLogsEnabled())
+            await this.client.application.commands.edit(command, newCommand, guild);
+            if (!this.client.isClientLogsSilent)
                 this.client.logger.log(`Removed application command '${typeof command === 'string' ? command : command.name}' from guild ${guild}`);
         }
     }
@@ -106,9 +109,7 @@ class ApplicationCommandManager {
         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)));
+        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)));
     }
     async fetch(commandId, guild) {
         const manager = guild ? this.client.guilds.resolve(guild)?.commands : this.client.application?.commands;
@@ -119,14 +120,12 @@ class ApplicationCommandManager {
     parseCommands(commands, setPermissions = true) {
         return commands.map(cmd => {
             if (cmd?.toJSON === undefined)
-                return (cmd);
+                return cmd;
             if (SlashCommandBuilder_1.SlashCommandBuilder.isSlashCommandBuilder(cmd) && this.client.config.commands.slashCommand.setRequiredPermissions) {
-                const permissions = (setPermissions || this.client.config.commands.slashCommand.permissions.enabled)
-                    ? this.client.config.commands.slashCommand.permissions.commands.find(cmd_ => cmd_.command.toLowerCase() === cmd.name.toLowerCase())?.permissions
-                    : undefined;
+                const permissions = setPermissions || this.client.config.commands.slashCommand.permissions.enabled ? this.client.config.commands.slashCommand.permissions.commands.find(cmd_ => cmd_.command.toLowerCase() === cmd.name.toLowerCase())?.permissions : undefined;
                 if (permissions) {
                     cmd.setRequiredMemberPermissions(...permissions);
-                    if (this.client.isClientLogsEnabled())
+                    if (!this.client.isClientLogsSilent)
                         this.client.logger.debug(`Set required permissions for ${cmd.name}`);
                 }
             }

package/dist/{cjs → lib}/reciple/classes/managers/ClientCommandManager.js

@@ -14,31 +14,33 @@ class ClientCommandManager {
         options.slashCommands?.forEach(e => this.slashCommands.set(e.name, SlashCommandBuilder_1.SlashCommandBuilder.resolveSlashCommand(e)));
         options.messageCommands?.forEach(e => this.messageCommands.set(e.name, MessageCommandBuilder_1.MessageCommandBuilder.resolveMessageCommand(e)));
     }
-    get applicationCommandsSize() { return this.client.commands.slashCommands.size + this.client.commands.additionalApplicationCommands.length; }
+    get applicationCommandsSize() {
+        return this.client.commands.slashCommands.size + this.client.commands.additionalApplicationCommands.length;
+    }
     /**
      * Add command to command manager
      * @param commands Any command data or builder
      */
     add(...commands) {
         for (const command of (0, discord_js_1.normalizeArray)(commands)) {
-            if (command.type === builders_1.CommandBuilderType.SlashCommand) {
+            if (command.type === builders_1.CommandType.SlashCommand) {
                 this.slashCommands.set(command.name, SlashCommandBuilder_1.SlashCommandBuilder.resolveSlashCommand(command));
             }
-            else if (command.type === builders_1.CommandBuilderType.MessageCommand) {
+            else if (command.type === builders_1.CommandType.MessageCommand) {
                 this.messageCommands.set(command.name, MessageCommandBuilder_1.MessageCommandBuilder.resolveMessageCommand(command));
             }
+            else {
+                throw new Error(`Unknown reciple command type`);
+            }
         }
         return this;
     }
     get(command, type) {
         switch (type) {
-            case builders_1.CommandBuilderType.SlashCommand:
+            case builders_1.CommandType.SlashCommand:
                 return this.slashCommands.get(command);
-            case builders_1.CommandBuilderType.MessageCommand:
-                return this.messageCommands.get(command.toLowerCase())
-                    ?? (this.client.config.commands.messageCommand.allowCommandAlias
-                        ? this.messageCommands.find(c => c.aliases.some(a => a == command?.toLowerCase()))
-                        : undefined);
+            case builders_1.CommandType.MessageCommand:
+                return this.messageCommands.get(command.toLowerCase()) ?? (this.client.config.commands.messageCommand.allowCommandAlias ? this.messageCommands.find(c => c.aliases.some(a => a == command?.toLowerCase())) : undefined);
             default:
                 throw new TypeError('Unknown command type');
         }
@@ -49,13 +51,11 @@ class ClientCommandManager {
      */
     async registerApplicationCommands(...guilds) {
         guilds = (0, discord_js_1.normalizeArray)(guilds);
-        guilds = guilds.length
-            ? guilds
-            : (0, discord_js_1.normalizeArray)([this.client.config.commands.slashCommand.guilds]);
-        if (this.client.isClientLogsEnabled())
+        guilds = guilds.length ? guilds : (0, discord_js_1.normalizeArray)([this.client.config.commands.slashCommand.guilds]);
+        if (!this.client.isClientLogsSilent)
             this.client.logger.log(`Regestering ${this.applicationCommandsSize} application command(s) ${!guilds.length ? 'globaly' : 'to ' + guilds.length + ' guilds'}...`);
         await this.client.applicationCommands.set([...this.slashCommands.toJSON(), ...this.additionalApplicationCommands], guilds);
-        this.client.emit('RegisterApplicationCommands');
+        this.client.emit('recipleRegisterApplicationCommands');
         return this;
     }
 }

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

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientModuleManager = void 0;
+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 RecipleModule_1 = require("../RecipleModule");
+class ClientModuleManager {
+    constructor(options) {
+        this.modules = new discord_js_1.Collection();
+        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) {
+            if (!this.client.isClientLogsSilent)
+                this.client.logger.log(`Starting module '${module_}'`);
+            try {
+                let error;
+                const start = await module_.start().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_);
+            }
+            catch (err) {
+                if (!ignoreErrors)
+                    throw err;
+                if (!this.client.isClientLogsSilent)
+                    this.client.logger.error(`Failed to start module '${module_}': `, err);
+            }
+        }
+        return modules;
+    }
+    async loadModules(modules, addModuleCommandsToClient = true, ignoreErrors = true) {
+        for (const module_ of this.modules.toJSON()) {
+            try {
+                await module_.load().catch(err => {
+                    throw err;
+                });
+                if (!this.client.isClientLogsSilent)
+                    this.client.logger.log(`Loaded module '${module_}'`);
+                if (addModuleCommandsToClient) {
+                    this.client.commands.add(module_.commands);
+                }
+            }
+            catch (err) {
+                if (!ignoreErrors)
+                    throw err;
+                if (!this.client.isClientLogsSilent)
+                    this.client.logger.error(`Failed to load module '${module_}': `, err);
+            }
+        }
+        return modules;
+    }
+    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);
+            }
+        }
+        return modules;
+    }
+    async getModulesFromFiles(options) {
+        const modules = [];
+        for (const file of options.files) {
+            try {
+                const resolveFile = await import(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);
+            }
+        }
+        return modules;
+    }
+    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 getModulePaths(options) {
+        const modules = [];
+        for (const dir of options?.folders ?? (0, discord_js_1.normalizeArray)([this.client.config.modulesFolder])) {
+            if (!(0, fs_1.existsSync)(dir))
+                (0, fs_1.mkdirSync)(dir, { recursive: true });
+            if (!(0, fs_1.lstatSync)(dir).isDirectory())
+                continue;
+            modules.push(...(0, fs_1.readdirSync)(dir)
+                .map(file => path_1.default.join(flags_1.cwd, dir, file))
+                .filter(file => (options?.filter ? options.filter(file) : file.endsWith('.js'))));
+        }
+        return modules.filter(file => !(options?.ignoredFiles ?? this.client.config.ignoredFiles).some(ignored => (0, wildcard_match_1.default)(ignored)(path_1.default.basename(file))));
+    }
+}
+exports.ClientModuleManager = ClientModuleManager;

package/dist/{cjs → lib}/reciple/classes/managers/CommandCooldownManager.js

@@ -47,7 +47,13 @@ class CommandCooldownManager extends Array {
         const data = this.get(options);
         if (!data)
             return false;
-        this.remove({ ...data, channel: undefined, guild: undefined, type: undefined, command: undefined });
+        this.remove({
+            ...data,
+            channel: undefined,
+            guild: undefined,
+            type: undefined,
+            command: undefined,
+        });
         if (data.expireTime < Date.now())
             return false;
         return true;

package/dist/{cjs → lib}/reciple/flags.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cwd = exports.token = exports.flags = exports.commander = void 0;
-const version_1 = require("./version");
+const version_js_1 = require("./version.js");
 const commander_1 = require("commander");
 /**
  * Commander
@@ -9,7 +9,7 @@ const commander_1 = require("commander");
 exports.commander = new commander_1.Command()
     .name('reciple')
     .description('Reciple.js - Discord.js handler cli')
-    .version(`v${version_1.rawVersion}`, '-v, --version')
+    .version(`v${version_js_1.rawVersion}`, '-v, --version')
     .argument('[current-working-directory]', 'Change the current working directory')
     .option('-t, --token <token>', 'Replace used bot token')
     .option('-c, --config <config>', 'Change path to config file')

package/dist/{cjs → lib}/reciple/permissions.js

@@ -7,10 +7,9 @@ const discord_js_1 = require("discord.js");
  * @param options options
  */
 function userHasCommandPermissions(options) {
-    const command = (options.commandPermissions?.enabled
-        ? options.commandPermissions?.commands.find(c => c.command.toLowerCase() === options.builder.name.toLowerCase())
-        : null)
-        ?? { permissions: options.builder.requiredMemberPermissions };
+    const command = (options.commandPermissions?.enabled ? options.commandPermissions?.commands.find(c => c.command.toLowerCase() === options.builder.name.toLowerCase()) : null) ?? {
+        permissions: options.builder.requiredMemberPermissions,
+    };
     if (!command.permissions.length)
         return true;
     return options.memberPermissions ? options.memberPermissions.has(command.permissions) : false;

package/dist/lib/reciple/types/builders.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandType = void 0;
+/**
+ * Types of command builders
+ */
+var CommandType;
+(function (CommandType) {
+    CommandType[CommandType["MessageCommand"] = 0] = "MessageCommand";
+    CommandType[CommandType["SlashCommand"] = 1] = "SlashCommand";
+})(CommandType = exports.CommandType || (exports.CommandType = {}));

package/dist/lib/reciple/util.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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
+ * @param object Object to identify
+ */
+function isClass(object) {
+    const isClassConstructor = object.constructor && object.constructor.toString().substring(0, 5) === 'class';
+    if (object.prototype === undefined)
+        return isClassConstructor;
+    const isPrototypeClassConstructor = object.prototype.constructor && object.prototype.constructor.toString && object.prototype.constructor.toString().substring(0, 5) === 'class';
+    return isClassConstructor || isPrototypeClassConstructor;
+}
+exports.isClass = isClass;
+/**
+ * Emit process warning about deprecated method/function
+ * @param content Warning content
+ */
+function deprecationWarning(content) {
+    process.emitWarning(content, 'DeprecationWarning');
+}
+exports.deprecationWarning = deprecationWarning;
+function validateCommandBuilder(command) {
+    if (!command.name)
+        return false;
+    if (command.type === builders_1.CommandType.MessageCommand && command.options.length && command.options.some(o => !o.name))
+        return false;
+    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/{cjs → lib}/reciple/version.js

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSupportedVersion = exports.parseVersion = exports.isValidVersion = exports.rawVersion = exports.version = void 0;
 const semver_1 = __importDefault(require("semver"));
-// TODO: ESM support
 /**
  * Current reciple version
  */

package/dist/types/esm.d.mts

@@ -0,0 +1 @@
+export * from './index.js';

package/dist/types/index.d.ts

@@ -1,18 +1,18 @@
-export * from './reciple/classes/builders/MessageCommandBuilder';
-export * from './reciple/classes/builders/MessageCommandOptionBuilder';
-export * from './reciple/classes/builders/SlashCommandBuilder';
-export * from './reciple/classes/managers/ApplicationCommandManager';
-export * from './reciple/classes/managers/CommandCooldownManager';
-export * from './reciple/classes/managers/ClientCommandManager';
-export * from './reciple/classes/managers/MessageCommandOptionManager';
-export * from './reciple/classes/RecipleClient';
-export * from './reciple/classes/RecipleConfig';
-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/modules';
-export * from './reciple/permissions';
-export * from './reciple/util';
-export * from './reciple/version';
+export * from './reciple/classes/builders/MessageCommandBuilder.js';
+export * from './reciple/classes/builders/MessageCommandOptionBuilder.js';
+export * from './reciple/classes/builders/SlashCommandBuilder.js';
+export * from './reciple/classes/managers/ApplicationCommandManager.js';
+export * from './reciple/classes/managers/ClientCommandManager.js';
+export * from './reciple/classes/managers/ClientModuleManager.js';
+export * from './reciple/classes/managers/CommandCooldownManager.js';
+export * from './reciple/classes/managers/MessageCommandOptionManager.js';
+export * from './reciple/classes/RecipleClient.js';
+export * from './reciple/classes/RecipleConfig.js';
+export * from './reciple/classes/RecipleModule.js';
+export * from './reciple/types/builders.js';
+export * from './reciple/types/commands.js';
+export * from './reciple/types/builders.js';
+export * from './reciple/types/builders.js';
+export * from './reciple/permissions.js';
+export * from './reciple/util.js';
+export * from './reciple/version.js';