reciple 5.6.0 → 6.0.0-dev.10

package/dist/cjs/reciple/classes/builders/MessageCommandBuilder.js

@@ -3,14 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateMessageCommandOptions = exports.MessageCommandBuilder = void 0;
 const builders_1 = require("../../types/builders");
 const discord_js_1 = require("discord.js");
-const MessageCommandOptionManager_1 = require("../MessageCommandOptionManager");
+const MessageCommandOptionManager_1 = require("../managers/MessageCommandOptionManager");
 const MessageCommandOptionBuilder_1 = require("./MessageCommandOptionBuilder");
 /**
  * Reciple builder for message command
  */
 class MessageCommandBuilder {
     constructor(data) {
-        this.type = builders_1.CommandBuilderType.MessageCommand;
+        this.type = builders_1.CommandType.MessageCommand;
         this.name = '';
         this.description = '';
         this.cooldown = 0;
@@ -21,7 +21,9 @@ class MessageCommandBuilder {
         this.requiredMemberPermissions = [];
         this.allowExecuteInDM = true;
         this.allowExecuteByBots = false;
-        this.execute = () => { };
+        this.execute = () => {
+            /* Execute */
+        };
         if (data?.name !== undefined)
             this.setName(data.name);
         if (data?.description !== undefined)
@@ -47,7 +49,7 @@ class MessageCommandBuilder {
         if (data?.validateOptions !== undefined)
             this.setValidateOptions(true);
         if (data?.options !== undefined)
-            this.options = data.options.map(o => o instanceof MessageCommandOptionBuilder_1.MessageCommandOptionBuilder ? o : new MessageCommandOptionBuilder_1.MessageCommandOptionBuilder(o));
+            this.options = data.options.map(o => (o instanceof MessageCommandOptionBuilder_1.MessageCommandOptionBuilder ? o : new MessageCommandOptionBuilder_1.MessageCommandOptionBuilder(o)));
     }
     /**
      * Sets the command name
@@ -218,7 +220,7 @@ async function validateMessageCommandOptions(builder, options) {
             value: arg ?? undefined,
             required: option.required,
             invalid: false,
-            missing: false
+            missing: false,
         };
         if (arg == undefined && option.required) {
             value.missing = true;

package/dist/cjs/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/reciple/classes/managers/ApplicationCommandManager.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationCommandManager = void 0;
+const discord_js_1 = require("discord.js");
+const SlashCommandBuilder_1 = require("../builders/SlashCommandBuilder");
+class ApplicationCommandManager {
+    constructor(client) {
+        this.client = client;
+    }
+    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);
+            }
+            return;
+        }
+        let guild = guilds?.shift();
+        guild = guild ? this.client.guilds.resolveId(guild) || undefined : undefined;
+        if (!guild) {
+            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 {
+            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) {
+        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);
+            }
+            return;
+        }
+        let guild = guilds?.shift();
+        guild = guild ? this.client.guilds.resolveId(guild) || undefined : undefined;
+        if (!guild) {
+            await this.client.application.commands.create(command);
+            if (!this.client.isClientLogsSilent)
+                this.client.logger.log(`Created application command '${command.name}' globally`);
+        }
+        else {
+            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) {
+        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);
+            }
+            return;
+        }
+        let guild = guilds?.shift();
+        guild = guild ? this.client.guilds.resolveId(guild) || undefined : undefined;
+        if (!guild) {
+            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 {
+            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) {
+        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);
+            }
+            return;
+        }
+        let guild = guilds?.shift();
+        guild = guild ? this.client.guilds.resolveId(guild) || undefined : undefined;
+        if (!guild) {
+            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 {
+            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}`);
+        }
+    }
+    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)));
+    }
+    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);
+    }
+    parseCommands(commands, setPermissions = true) {
+        return commands.map(cmd => {
+            if (cmd?.toJSON === undefined)
+                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;
+                if (permissions) {
+                    cmd.setRequiredMemberPermissions(...permissions);
+                    if (!this.client.isClientLogsSilent)
+                        this.client.logger.debug(`Set required permissions for ${cmd.name}`);
+                }
+            }
+            return cmd.toJSON();
+        });
+    }
+}
+exports.ApplicationCommandManager = ApplicationCommandManager;

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientCommandManager = void 0;
+const discord_js_1 = require("discord.js");
+const builders_1 = require("../../types/builders");
+const MessageCommandBuilder_1 = require("../builders/MessageCommandBuilder");
+const SlashCommandBuilder_1 = require("../builders/SlashCommandBuilder");
+class ClientCommandManager {
+    constructor(options) {
+        this.slashCommands = new discord_js_1.Collection();
+        this.messageCommands = new discord_js_1.Collection();
+        this.additionalApplicationCommands = [];
+        this.client = options.client;
+        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;
+    }
+    /**
+     * 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.CommandType.SlashCommand) {
+                this.slashCommands.set(command.name, SlashCommandBuilder_1.SlashCommandBuilder.resolveSlashCommand(command));
+            }
+            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.CommandType.SlashCommand:
+                return this.slashCommands.get(command);
+            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');
+        }
+    }
+    /**
+     * Register application commands
+     * @param guilds Register application commands to guilds
+     */
+    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.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('recipleRegisterApplicationCommands');
+        return this;
+    }
+}
+exports.ClientCommandManager = ClientCommandManager;

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

@@ -0,0 +1,167 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 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);
+            }
+        }
+        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 getModuleFiles(...folders) {
+        const modules = [];
+        for (const dir of (0, discord_js_1.normalizeArray)(folders).length ? (0, discord_js_1.normalizeArray)(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 => file.endsWith('.js') || file.endsWith('.cjs')));
+        }
+        return modules.filter(file => !this.client.config.ignoredFiles.some(ignored => (0, wildcard_match_1.default)(ignored)(path_1.default.basename(file))));
+    }
+}
+exports.ClientModuleManager = ClientModuleManager;

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

@@ -20,21 +20,24 @@ class CommandCooldownManager extends Array {
      * Remove cooldown from specific user, channel or guild
      * @param options Remove cooldown data options
      * @param limit Remove cooldown data limit
+     * @returns Returns the removed values
      */
     remove(options, limit = 0) {
         if (!Object.keys(options).length)
             throw new TypeError('Provide atleast one option to remove cooldown data.');
+        const removed = [];
         let i = 0;
-        for (const index in this) {
-            if (!CommandCooldownManager.checkOptions(options, this[index]))
+        for (let i = 0; i < this.length; i++) {
+            if (!CommandCooldownManager.checkOptions(options, this[i]))
                 continue;
-            if (options.expireTime && this[index].expireTime > Date.now())
+            if (options.expireTime && this[i].expireTime > Date.now())
                 continue;
             if (limit && i >= limit)
                 continue;
-            this.splice(Number(index));
-            i++;
+            removed.push(this[i]);
+            this.splice(Number(i));
         }
+        return removed;
     }
     /**
      * Check if the given user is cooled-down
@@ -44,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/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/cjs/reciple/types/builders.js

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

package/dist/cjs/reciple/util.js

@@ -1,6 +1,13 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-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
  * @param object Object to identify
@@ -21,3 +28,39 @@ 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/types/index.d.ts

@@ -1,17 +1,18 @@
-export * from './reciple/classes/CommandCooldownManager';
-export * from './reciple/classes/MessageCommandOptionManager';
-export * from './reciple/classes/RecipleClient';
-export * from './reciple/classes/RecipleConfig';
 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/ClientCommandManager';
+export * from './reciple/classes/managers/ClientModuleManager';
+export * from './reciple/classes/managers/CommandCooldownManager';
+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/modules';
 export * from './reciple/permissions';
-export * from './reciple/registerApplicationCommands';
 export * from './reciple/util';
 export * from './reciple/version';