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

package/dist/lib/bin.mjs

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+import { RecipleClient } from './reciple/classes/RecipleClient.js';
+import { RecipleConfig } from './reciple/classes/RecipleConfig.js';
+import { rawVersion } from './reciple/version.js';
+import { existsSync, mkdirSync, readdirSync } from 'fs';
+import { cwd, flags } from './reciple/flags.js';
+import { input } from 'fallout-utility';
+import { path } from './reciple/util.js';
+import chalk from 'chalk';
+import 'dotenv/config';
+import { inspect } from 'util';
+const allowedFiles = ['node_modules', 'reciple.yml', 'package.json'];
+const configPath = path.join(cwd, 'reciple.yml');
+if (!existsSync(cwd))
+    mkdirSync(cwd, { recursive: true });
+if (readdirSync(cwd).filter(f => !f.startsWith('.') && allowedFiles.indexOf(f)).length > 0 && !existsSync(flags.config ?? configPath)) {
+    const ask = (flags.yes ? 'y' : null) ?? 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(flags.config ?? configPath).parseConfig();
+}
+catch (err) {
+    console.error(`${chalk.bold.red('Config Error')}: ${inspect(err)}`);
+    process.exit(1);
+}
+const config = configParser.getConfig();
+const client = new RecipleClient({ config: config, cwd, ...config.client });
+/**
+ * Start
+ */
+if (!client.isClientLogsSilent)
+    client.logger.info('Starting Reciple client v' + rawVersion);
+client.addCommandListeners();
+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();
+    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.applicationCommands.size)) {
+        await client.commands.registerApplicationCommands();
+    }
+    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);
+});

package/dist/lib/esm.mjs

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

package/dist/{cjs → lib}/index.js

@@ -14,21 +14,22 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./reciple/classes/builders/MessageCommandBuilder"), exports);
-__exportStar(require("./reciple/classes/builders/MessageCommandOptionBuilder"), exports);
-__exportStar(require("./reciple/classes/builders/SlashCommandBuilder"), exports);
-__exportStar(require("./reciple/classes/managers/ApplicationCommandManager"), exports);
-__exportStar(require("./reciple/classes/managers/CommandCooldownManager"), exports);
-__exportStar(require("./reciple/classes/managers/ClientCommandManager"), exports);
-__exportStar(require("./reciple/classes/managers/ClientModuleManager"), exports);
-__exportStar(require("./reciple/classes/managers/MessageCommandOptionManager"), exports);
-__exportStar(require("./reciple/classes/RecipleClient"), exports);
-__exportStar(require("./reciple/classes/RecipleConfig"), exports);
-__exportStar(require("./reciple/types/builders"), exports);
-__exportStar(require("./reciple/types/commands"), exports);
-__exportStar(require("./reciple/types/paramOptions"), exports);
+__exportStar(require("./reciple/classes/builders/MessageCommandBuilder.js"), exports);
+__exportStar(require("./reciple/classes/builders/MessageCommandOptionBuilder.js"), exports);
+__exportStar(require("./reciple/classes/builders/SlashCommandBuilder.js"), exports);
+__exportStar(require("./reciple/classes/managers/ApplicationCommandManager.js"), exports);
+__exportStar(require("./reciple/classes/managers/CommandManager.js"), exports);
+__exportStar(require("./reciple/classes/managers/ModuleManager.js"), exports);
+__exportStar(require("./reciple/classes/managers/CommandCooldownManager.js"), exports);
+__exportStar(require("./reciple/classes/managers/MessageCommandOptionManager.js"), exports);
+__exportStar(require("./reciple/classes/RecipleClient.js"), exports);
+__exportStar(require("./reciple/classes/RecipleConfig.js"), exports);
+__exportStar(require("./reciple/classes/RecipleModule.js"), exports);
+__exportStar(require("./reciple/types/builders.js"), exports);
+__exportStar(require("./reciple/types/commands.js"), exports);
+__exportStar(require("./reciple/types/builders.js"), exports);
+__exportStar(require("./reciple/types/builders.js"), exports);
 __exportStar(require("./reciple/flags"), exports);
-__exportStar(require("./reciple/logger"), exports);
-__exportStar(require("./reciple/permissions"), exports);
-__exportStar(require("./reciple/util"), exports);
-__exportStar(require("./reciple/version"), exports);
+__exportStar(require("./reciple/permissions.js"), exports);
+__exportStar(require("./reciple/util.js"), exports);
+__exportStar(require("./reciple/version.js"), exports);

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

@@ -1,7 +1,4 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RecipleClient = void 0;
 const MessageCommandBuilder_1 = require("./builders/MessageCommandBuilder");
@@ -12,15 +9,14 @@ const CommandCooldownManager_1 = require("./managers/CommandCooldownManager");
 const permissions_1 = require("../permissions");
 const MessageCommandOptionManager_1 = require("./managers/MessageCommandOptionManager");
 const ApplicationCommandManager_1 = require("./managers/ApplicationCommandManager");
+const CommandManager_1 = require("./managers/CommandManager");
 const builders_1 = require("../types/builders");
-const ClientCommandManager_1 = require("./managers/ClientCommandManager");
-const ClientModuleManager_1 = require("./managers/ClientModuleManager");
+const ModuleManager_1 = require("./managers/ModuleManager");
 const RecipleConfig_1 = require("./RecipleConfig");
 const fallout_utility_1 = require("fallout-utility");
-const logger_1 = require("../logger");
-const version_1 = require("../version");
+const util_1 = require("../util");
+const version_js_1 = require("../version.js");
 const flags_1 = require("../flags");
-const path_1 = __importDefault(require("path"));
 class RecipleClient extends discord_js_1.Client {
     /**
      * @param options Client options
@@ -28,18 +24,19 @@ class RecipleClient extends discord_js_1.Client {
     constructor(options) {
         super(options);
         this.config = RecipleConfig_1.RecipleConfig.getDefaultConfig();
-        this.commands = new ClientCommandManager_1.ClientCommandManager({
+        this.commands = new CommandManager_1.CommandManager({
             client: this,
         });
         this.cooldowns = new CommandCooldownManager_1.CommandCooldownManager();
-        this.modules = new ClientModuleManager_1.ClientModuleManager({
+        this.modules = new ModuleManager_1.ModuleManager({
             client: this,
         });
-        this.version = version_1.version;
-        this.logger = (0, logger_1.createLogger)(!!options.config?.fileLogging.stringifyLoggedJSON, options.config?.fileLogging.debugmode);
+        this.version = version_js_1.version;
+        this.logger = (0, util_1.createLogger)(!!options.config?.fileLogging.stringifyLoggedJSON, options.config?.fileLogging.debugmode);
         this.config = { ...this.config, ...(options.config ?? {}) };
         if (this.config.fileLogging.enabled)
-            this.logger.logFile(path_1.default.join(flags_1.cwd, this.config.fileLogging.logFilePath ?? 'logs/latest.log'), false);
+            this.logger.logFile(util_1.path.join(flags_1.cwd, this.config.fileLogging.logFilePath ?? 'logs/latest.log'), false);
+        this.cwd = options.cwd ?? process.cwd();
         this.applicationCommands = new ApplicationCommandManager_1.ApplicationCommandManager(this);
     }
     get isClientLogsSilent() {
@@ -68,7 +65,7 @@ class RecipleClient extends discord_js_1.Client {
             return;
         if (!this.config.commands.slashCommand.acceptRepliedInteractions && (interaction.replied || interaction.deferred))
             return;
-        const command = this.commands.get(interaction.commandName, builders_1.CommandBuilderType.SlashCommand);
+        const command = this.commands.get(interaction.commandName, builders_1.CommandType.SlashCommand);
         if (!command)
             return;
         const executeData = {
@@ -97,7 +94,7 @@ class RecipleClient extends discord_js_1.Client {
                 command: command.name,
                 channel: interaction.channel ?? undefined,
                 guild: interaction.guild,
-                type: builders_1.CommandBuilderType.SlashCommand,
+                type: builders_1.CommandType.SlashCommand,
             };
             if (this.config.commands.slashCommand.enableCooldown && command.cooldown && !this.cooldowns.isCooledDown(userCooldown)) {
                 this.cooldowns.add({
@@ -135,7 +132,7 @@ class RecipleClient extends discord_js_1.Client {
         const parseCommand = (0, fallout_utility_1.getCommand)(message.content, prefix || this.config.commands.messageCommand.prefix || '!', this.config.commands.messageCommand.commandArgumentSeparator || ' ');
         if (!parseCommand || !parseCommand?.command)
             return;
-        const command = this.commands.get(parseCommand.command, builders_1.CommandBuilderType.MessageCommand);
+        const command = this.commands.get(parseCommand.command, builders_1.CommandType.MessageCommand);
         if (!command)
             return;
         const commandOptions = await (0, MessageCommandBuilder_1.validateMessageCommandOptions)(command, parseCommand);
@@ -189,7 +186,7 @@ class RecipleClient extends discord_js_1.Client {
                 command: command.name,
                 channel: message.channel,
                 guild: message.guild,
-                type: builders_1.CommandBuilderType.MessageCommand,
+                type: builders_1.CommandType.MessageCommand,
             };
             if (this.config.commands.messageCommand.enableCooldown && command.cooldown && !this.cooldowns.isCooledDown(userCooldown)) {
                 this.cooldowns.add({
@@ -234,7 +231,7 @@ class RecipleClient extends discord_js_1.Client {
     async _haltCommand(command, haltData) {
         try {
             const haltResolved = (command.halt
-                ? await Promise.resolve(command.type == builders_1.CommandBuilderType.SlashCommand ? command.halt(haltData) : command.halt(haltData)).catch(err => {
+                ? await Promise.resolve(command.type == builders_1.CommandType.SlashCommand ? command.halt(haltData) : command.halt(haltData)).catch(err => {
                     console.log(err);
                 })
                 : false) || false;
@@ -251,7 +248,7 @@ class RecipleClient extends discord_js_1.Client {
     }
     async _executeCommand(command, executeData) {
         try {
-            await Promise.resolve(command.type === builders_1.CommandBuilderType.SlashCommand ? command.execute(executeData) : command.execute(executeData))
+            await Promise.resolve(command.type === builders_1.CommandType.SlashCommand ? command.execute(executeData) : command.execute(executeData))
                 .then(() => this.emit('recipleCommandExecute', executeData))
                 .catch(async (err) => !(await this._haltCommand(command, {
                 executeData: executeData,
@@ -279,7 +276,7 @@ class RecipleClient extends discord_js_1.Client {
      */
     async _commandExecuteError(err, command) {
         if (!this.isClientLogsSilent) {
-            this.logger.error(`An error occured executing ${command.builder.type == builders_1.CommandBuilderType.MessageCommand ? 'message' : 'slash'} command "${command.builder.name}"`);
+            this.logger.error(`An error occured executing ${command.builder.type == builders_1.CommandType.MessageCommand ? 'message' : 'slash'} command "${command.builder.name}"`);
             this.logger.error(err);
         }
         if (!err || !command)

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

@@ -8,7 +8,7 @@ const fs_1 = require("fs");
 const version_1 = require("../version");
 const fallout_utility_1 = require("fallout-utility");
 const flags_1 = require("../flags");
-const path_1 = __importDefault(require("path"));
+const util_1 = require("../util");
 const yaml_1 = __importDefault(require("yaml"));
 /**
  * Create/parse reciple config
@@ -19,7 +19,7 @@ class RecipleConfig {
      */
     constructor(configPath) {
         this.config = RecipleConfig.getDefaultConfig();
-        this.configPath = path_1.default.join(flags_1.cwd, 'reciple.yml');
+        this.configPath = util_1.path.join(process.cwd(), 'reciple.yml');
         if (!configPath)
             throw new Error('Config path is not defined');
         this.configPath = configPath;
@@ -62,17 +62,17 @@ class RecipleConfig {
     }
     /**
      * Parse token from config
-     * @param askIfNull Ask for token if the token is null/undefined
+     * @param askIfEmpty Ask for token if the token is undefined
      */
-    parseToken(askIfNull = true) {
-        let token = flags_1.token || this.config?.token || null;
+    parseToken(askIfEmpty = true) {
+        let token = flags_1.token || this.config?.token || undefined;
         if (!token)
-            return token || (askIfNull ? this._askToken() : null);
+            return token || (askIfEmpty ? this._askToken() : null);
         const envToken = token.toString().split(':');
         if (envToken.length === 2 && envToken[0].toLocaleLowerCase() === 'env' && envToken[1]) {
-            token = process.env[envToken[1]] || null;
+            token = process.env[envToken[1]] || undefined;
         }
-        return token || (askIfNull ? this._askToken() : null);
+        return token || (askIfEmpty == null ? this._askToken() : null);
     }
     /**
      * Check if the config version is supported
@@ -98,9 +98,9 @@ class RecipleConfig {
      */
     static getDefaultConfig() {
         if (!(0, fs_1.existsSync)(this.defaultConfigPath))
-            throw new Error('Default config file does not exists.');
+            throw new Error(`Default config file does not exists: ${this.defaultConfigPath}`);
         return yaml_1.default.parse((0, fs_1.readFileSync)(this.defaultConfigPath, 'utf-8'));
     }
 }
 exports.RecipleConfig = RecipleConfig;
-RecipleConfig.defaultConfigPath = path_1.default.join(__dirname, '../../../../resource/reciple.yml');
+RecipleConfig.defaultConfigPath = util_1.path.join(__dirname, '../../../../resource/reciple.yml');

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

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

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

@@ -10,7 +10,7 @@ const MessageCommandOptionBuilder_1 = require("./MessageCommandOptionBuilder");
  */
 class MessageCommandBuilder {
     constructor(data) {
-        this.type = builders_1.CommandBuilderType.MessageCommand;
+        this.type = builders_1.CommandType.MessageCommand;
         this.name = '';
         this.description = '';
         this.cooldown = 0;

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

@@ -10,7 +10,7 @@ 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 = [];
@@ -182,10 +182,7 @@ class SlashCommandBuilder extends discord_js_1.SlashCommandBuilder {
             default:
                 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

@@ -8,122 +8,163 @@ class ApplicationCommandManager {
         this.client = client;
     }
     get commands() {
-        return this.client.application?.commands;
+        return [...this.client.commands.additionalApplicationCommands, ...this.client.commands.slashCommands.toJSON()];
     }
-    async set(commands, guilds) {
+    get size() {
+        return this.commands.length;
+    }
+    /**
+     * 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())
             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);
+            await this.client.application.commands.set(commands);
             if (!this.client.isClientLogsSilent)
-                this.client.logger.log(`Registered ${this.client.commands.applicationCommandsSize} application command(s) globally...`);
+                this.client.logger.log(`Registered ${this.client.applicationCommands.size} application command(s) globally...`);
         }
         else {
-            this.client.application.commands.set(commands, guild);
+            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.applicationCommands.size} application command(s) to guild ${guild}`);
         }
     }
-    async add(command, guilds) {
+    /**
+     * 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())
             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);
+            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);
+            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) {
+    /**
+     * 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())
             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);
+            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);
+            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) {
+    /**
+     * 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())
             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);
+            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);
+            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 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));
+        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)
                 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.isClientLogsSilent)