@pikokr/command.ts 3.0.1-dev.4d426ce → 3.0.3

package/dist/defaultModules/BuiltInConverters.js

@@ -0,0 +1,72 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuiltInConverters = void 0;
+const __1 = require("..");
+const discord_js_1 = require("discord.js");
+/**
+ * Built-In module which is enabled by default.
+ */
+class BuiltInConverters extends __1.Module {
+    constructor(client) {
+        super(__filename);
+        this.client = client;
+    }
+    getUserIDByMention(mention) {
+        if (!mention)
+            return;
+        if (mention.startsWith('<@') && mention.endsWith('>')) {
+            mention = mention.slice(2, -1);
+            if (mention.startsWith('!')) {
+                mention = mention.slice(1);
+            }
+            return mention;
+        }
+    }
+    user(value) {
+        const id = this.getUserIDByMention(value);
+        if (!id)
+            return null;
+        const user = this.client.users.cache.get(id);
+        return user || null;
+    }
+    member(value, msg) {
+        var _a;
+        const id = this.getUserIDByMention(value);
+        if (!id)
+            return null;
+        const user = (_a = msg.guild) === null || _a === void 0 ? void 0 : _a.members.cache.get(id);
+        return user || null;
+    }
+    number(value) {
+        const n = Number(value);
+        return isNaN(n) ? null : n;
+    }
+}
+__decorate([
+    __1.argConverter(discord_js_1.User),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Object)
+], BuiltInConverters.prototype, "user", null);
+__decorate([
+    __1.argConverter(discord_js_1.GuildMember),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, discord_js_1.Message]),
+    __metadata("design:returntype", Object)
+], BuiltInConverters.prototype, "member", null);
+__decorate([
+    __1.argConverter(Number),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", void 0)
+], BuiltInConverters.prototype, "number", null);
+exports.BuiltInConverters = BuiltInConverters;

package/dist/defaultModules/CommandHandler.d.ts

@@ -0,0 +1,11 @@
+import { Interaction, Message } from 'discord.js';
+import { CommandClient, Module } from '../structures';
+/**
+ * Built-In module which is enabled by default.
+ */
+export declare class CommandHandler extends Module {
+    private client;
+    constructor(client: CommandClient);
+    onMessage(msg: Message): Promise<boolean | undefined>;
+    interaction(i: Interaction): Promise<boolean | undefined>;
+}

package/dist/defaultModules/CommandHandler.js

@@ -0,0 +1,178 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandHandler = void 0;
+const discord_js_1 = require("discord.js");
+const structures_1 = require("../structures");
+const listener_1 = require("../listener");
+const error_1 = require("../error");
+/**
+ * Built-In module which is enabled by default.
+ */
+class CommandHandler extends structures_1.Module {
+    constructor(client) {
+        super(__filename);
+        this.client = client;
+    }
+    onMessage(msg) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.client.commandOptions.commands.allowSelf &&
+                msg.author.id === this.client.user.id)
+                return;
+            if (!this.client.commandOptions.commands.allowBots && msg.author.bot)
+                return;
+            const prefixFunction = this.client.commandOptions.prefix;
+            const prefix = typeof prefixFunction === 'function'
+                ? yield prefixFunction(msg)
+                : prefixFunction;
+            const { content } = msg;
+            if (!content.startsWith(prefix))
+                return;
+            const args = content.slice(prefix.length).split(' ');
+            const command = args.shift();
+            if (!command)
+                return;
+            const cmd = this.client.registry.commandManager.commandList.find((x) => x.name.toLowerCase() === command.toLowerCase() ||
+                x.aliases.map((r) => r.toLowerCase()).includes(command));
+            if (!cmd)
+                return;
+            if (cmd.ownerOnly) {
+                if (!this.client.owners.includes(msg.author.id))
+                    return this.client.emit('commandError', new error_1.OwnerOnlyCommand(cmd, msg), msg, cmd);
+            }
+            if (!((_b = (_a = msg.guild) === null || _a === void 0 ? void 0 : _a.me) === null || _b === void 0 ? void 0 : _b.permissionsIn(msg.channel.id).has(cmd.clientPermissions))) {
+                return this.client.emit('commandError', new error_1.MissingClientPermissions(cmd, cmd.clientPermissions, msg), msg, cmd);
+            }
+            if (!((_c = msg.member) === null || _c === void 0 ? void 0 : _c.permissionsIn(msg.channel.id).has(cmd.clientPermissions))) {
+                return this.client.emit('commandError', new error_1.MissingUserPermissions(cmd, cmd.clientPermissions, msg), msg, cmd);
+            }
+            const checks = cmd.checks;
+            for (const check of checks) {
+                try {
+                    if (!(yield check(msg))) {
+                        return this.client.emit('commandError', new error_1.CheckFailedError(cmd), msg, cmd);
+                    }
+                }
+                catch (_d) {
+                    return;
+                }
+            }
+            const commandArgs = cmd.args;
+            const parsedArgs = [];
+            for (const i in commandArgs) {
+                const v = args.shift();
+                const arg = commandArgs[i];
+                if (arg.rest) {
+                    parsedArgs.push([v, ...args].join(' '));
+                    break;
+                }
+                if (!arg.optional && !v) {
+                    return this.client.emit('commandError', new Error(`An argument is required but not provided.`), msg, cmd);
+                }
+                if (arg.optional && !v) {
+                    break;
+                }
+                if (arg.type === String) {
+                    parsedArgs[i] = v;
+                    continue;
+                }
+                const converter = this.client.registry.commandManager.argConverterList.find((x) => x.type === arg.type);
+                if (converter) {
+                    try {
+                        parsedArgs[i] = yield converter.convert.apply(converter.module, [
+                            v,
+                            msg,
+                        ]);
+                        if (!parsedArgs[i]) {
+                            return this.client.emit('commandError', new Error('Argument converter returned no result.'), msg, cmd);
+                        }
+                    }
+                    catch (e) {
+                        return this.client.emit('commandError', e, msg, cmd);
+                    }
+                }
+                else {
+                    return this.client.emit('commandError', new Error(`No converter found for type ${arg.type.constructor.name}.`), msg, cmd);
+                }
+            }
+            const executeArgs = [];
+            if (cmd.usesCtx) {
+                executeArgs[0] = new structures_1.Context(msg, prefix);
+            }
+            else {
+                executeArgs[0] = msg;
+            }
+            executeArgs.push(...parsedArgs);
+            try {
+                cmd.execute.apply(cmd.module, executeArgs);
+            }
+            catch (e) {
+                this.client.emit('commandError', e, msg, cmd);
+            }
+        });
+    }
+    interaction(i) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.client.commandOptions.slashCommands.guild &&
+                typeof this.client.commandOptions.slashCommands.guild ===
+                    'string'
+                ? this.client.commandOptions.slashCommands.guild !== i.guildId
+                : !this.client.commandOptions.slashCommands.guild.includes(i.guildId))
+                return;
+            if (!i.isCommand())
+                return;
+            const cmd = i.command;
+            const command = this.client.registry.slashCommandManager.commandList.find((x) => x.name === cmd.name);
+            if (!command)
+                return;
+            if (!((_b = (_a = i.guild) === null || _a === void 0 ? void 0 : _a.me) === null || _b === void 0 ? void 0 : _b.permissionsIn(i.channel.id).has(command.clientPermissions))) {
+                return this.client.emit('slashCommandError', new error_1.MissingSlashClientPermissions(command, command.clientPermissions, i), i, cmd);
+            }
+            if (!((_c = i.member) === null || _c === void 0 ? void 0 : _c.permissionsIn(i.channel.id).has(command.clientPermissions))) {
+                return this.client.emit('slashCommandError', new error_1.MissingSlashUserPermissions(command, command.clientPermissions, i), i, cmd);
+            }
+            if (command.ownerOnly) {
+                if (!this.client.owners.includes(i.user.id))
+                    return this.client.emit('slashCommandError', new error_1.OwnerOnlySlashCommand(command, i), i, cmd);
+            }
+            try {
+                yield command.execute.apply(command.module, [i, i.options]);
+            }
+            catch (e) {
+                return this.client.emit('slashCommandError', e, i, cmd);
+            }
+        });
+    }
+}
+__decorate([
+    listener_1.listener('messageCreate'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [discord_js_1.Message]),
+    __metadata("design:returntype", Promise)
+], CommandHandler.prototype, "onMessage", null);
+__decorate([
+    listener_1.listener('interactionCreate'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [discord_js_1.Interaction]),
+    __metadata("design:returntype", Promise)
+], CommandHandler.prototype, "interaction", null);
+exports.CommandHandler = CommandHandler;

package/dist/defaultModules/index.d.ts

@@ -0,0 +1,2 @@
+export * from './CommandHandler';
+export * from './BuiltInConverters';

package/dist/defaultModules/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./CommandHandler"), exports);
+__exportStar(require("./BuiltInConverters"), exports);

package/dist/error/CheckFailedError.d.ts

@@ -0,0 +1,5 @@
+import { Command } from '../types';
+export declare class CheckFailedError extends Error {
+    command: Command;
+    constructor(command: Command);
+}

package/dist/error/CheckFailedError.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckFailedError = void 0;
+class CheckFailedError extends Error {
+    constructor(command) {
+        super();
+        this.command = command;
+    }
+}
+exports.CheckFailedError = CheckFailedError;

package/dist/error/Permissions.d.ts

@@ -0,0 +1,36 @@
+import { Command, SlashCommand } from '../types';
+import { CommandInteraction, Message, PermissionResolvable } from 'discord.js';
+export declare class MissingUserPermissions extends Error {
+    command: Command;
+    missingPermissions: PermissionResolvable;
+    msg: Message;
+    constructor(command: Command, missingPermissions: PermissionResolvable, msg: Message);
+}
+export declare class MissingClientPermissions extends Error {
+    command: Command;
+    missingPermissions: PermissionResolvable;
+    msg: Message;
+    constructor(command: Command, missingPermissions: PermissionResolvable, msg: Message);
+}
+export declare class MissingSlashUserPermissions extends Error {
+    command: SlashCommand;
+    missingPermissions: PermissionResolvable;
+    interaction: CommandInteraction;
+    constructor(command: SlashCommand, missingPermissions: PermissionResolvable, interaction: CommandInteraction);
+}
+export declare class MissingSlashClientPermissions extends Error {
+    command: SlashCommand;
+    missingPermissions: PermissionResolvable;
+    interaction: CommandInteraction;
+    constructor(command: SlashCommand, missingPermissions: PermissionResolvable, interaction: CommandInteraction);
+}
+export declare class OwnerOnlyCommand extends Error {
+    command: Command;
+    msg: Message;
+    constructor(command: Command, msg: Message);
+}
+export declare class OwnerOnlySlashCommand extends Error {
+    command: SlashCommand;
+    interaction: CommandInteraction;
+    constructor(command: SlashCommand, interaction: CommandInteraction);
+}

package/dist/error/Permissions.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OwnerOnlySlashCommand = exports.OwnerOnlyCommand = exports.MissingSlashClientPermissions = exports.MissingSlashUserPermissions = exports.MissingClientPermissions = exports.MissingUserPermissions = void 0;
+class MissingUserPermissions extends Error {
+    constructor(command, missingPermissions, msg) {
+        super();
+        this.command = command;
+        this.missingPermissions = missingPermissions;
+        this.msg = msg;
+    }
+}
+exports.MissingUserPermissions = MissingUserPermissions;
+class MissingClientPermissions extends Error {
+    constructor(command, missingPermissions, msg) {
+        super();
+        this.command = command;
+        this.missingPermissions = missingPermissions;
+        this.msg = msg;
+    }
+}
+exports.MissingClientPermissions = MissingClientPermissions;
+class MissingSlashUserPermissions extends Error {
+    constructor(command, missingPermissions, interaction) {
+        super();
+        this.command = command;
+        this.missingPermissions = missingPermissions;
+        this.interaction = interaction;
+    }
+}
+exports.MissingSlashUserPermissions = MissingSlashUserPermissions;
+class MissingSlashClientPermissions extends Error {
+    constructor(command, missingPermissions, interaction) {
+        super();
+        this.command = command;
+        this.missingPermissions = missingPermissions;
+        this.interaction = interaction;
+    }
+}
+exports.MissingSlashClientPermissions = MissingSlashClientPermissions;
+class OwnerOnlyCommand extends Error {
+    constructor(command, msg) {
+        super();
+        this.command = command;
+        this.msg = msg;
+    }
+}
+exports.OwnerOnlyCommand = OwnerOnlyCommand;
+class OwnerOnlySlashCommand extends Error {
+    constructor(command, interaction) {
+        super();
+        this.command = command;
+        this.interaction = interaction;
+    }
+}
+exports.OwnerOnlySlashCommand = OwnerOnlySlashCommand;

package/dist/listener/ListenerManager.d.ts

@@ -0,0 +1,25 @@
+import { Collection } from 'discord.js';
+import { Module } from '../structures';
+import { Listener } from '../types';
+import { CommandClient } from '../structures';
+/**
+ * Listener handler
+ */
+export declare class ListenerManager {
+    private client;
+    /**
+     * Collection of listeners.
+     */
+    listeners: Collection<Module, Listener[]>;
+    constructor(client: CommandClient);
+    /**
+     * This method is run by Registry. You don't have to run it manually.
+     * @param module
+     */
+    register(module: Module): void;
+    /**
+     * This method is run by Registry. You don't have to run it manually.
+     * @param module
+     */
+    unregister(module: Module): void;
+}

package/dist/listener/ListenerManager.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListenerManager = void 0;
+const discord_js_1 = require("discord.js");
+const constants_1 = require("../constants");
+/**
+ * Listener handler
+ */
+class ListenerManager {
+    constructor(client) {
+        this.client = client;
+        /**
+         * Collection of listeners.
+         */
+        this.listeners = new discord_js_1.Collection();
+    }
+    /**
+     * This method is run by Registry. You don't have to run it manually.
+     * @param module
+     */
+    register(module) {
+        const meta = Reflect.getMetadata(constants_1.LISTENERS_KEY, module);
+        if (!meta)
+            return;
+        const listenersList = [];
+        this.listeners.forEach((value) => listenersList.push(...value.map((x) => x.id)));
+        if (meta.find((x) => listenersList.find((y) => y === x.id)))
+            throw new Error('해당 ID의 리스너가 이미 존재합니다.');
+        const listeners = meta.map((x) => ({
+            id: x.id,
+            module,
+            event: x.event,
+            wrapper: (...args) => Reflect.get(module, x.key).apply(module, args),
+        }));
+        listeners.forEach((listener) => this.client.on(listener.event, listener.wrapper));
+        this.listeners.set(module, listeners);
+    }
+    /**
+     * This method is run by Registry. You don't have to run it manually.
+     * @param module
+     */
+    unregister(module) {
+        const listeners = this.listeners.get(module);
+        if (!listeners)
+            return;
+        for (const listener of listeners) {
+            this.client.removeListener(listener.event, listener.wrapper);
+        }
+        this.listeners.delete(module);
+    }
+}
+exports.ListenerManager = ListenerManager;

package/dist/slashCommand/SlashCommandManager.d.ts

@@ -0,0 +1,33 @@
+import { Module, Registry } from '../structures';
+import { Collection } from 'discord.js';
+import { SlashCommand } from '../types';
+/**
+ * Slash Command Manager.
+ */
+export declare class SlashCommandManager {
+    private registry;
+    constructor(registry: Registry);
+    /**
+     * Collection of slash commands
+     */
+    commands: Collection<Module, SlashCommand[]>;
+    /**
+     * Get List of slash commands
+     */
+    get commandList(): SlashCommand[];
+    /**
+     * Auto-Refresh slash command list if `autoRegister` config enabled on client
+     */
+    refreshCommands(): Promise<void>;
+    private registerCommands;
+    /**
+     * This method is run by Registry. You don't have to run it manually.
+     * @param module
+     */
+    register(module: Module): void;
+    /**
+     * This method is run by Registry. You don't have to run it manually.
+     * @param module
+     */
+    unregister(module: Module): void;
+}

package/dist/slashCommand/SlashCommandManager.js

@@ -0,0 +1,138 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlashCommandManager = void 0;
+const discord_js_1 = require("discord.js");
+const constants_1 = require("../constants");
+/**
+ * Slash Command Manager.
+ */
+class SlashCommandManager {
+    constructor(registry) {
+        this.registry = registry;
+        /**
+         * Collection of slash commands
+         */
+        this.commands = new discord_js_1.Collection();
+    }
+    /**
+     * Get List of slash commands
+     */
+    get commandList() {
+        const result = [];
+        this.commands.forEach((x) => result.push(...x));
+        return result;
+    }
+    /**
+     * Auto-Refresh slash command list if `autoRegister` config enabled on client
+     */
+    refreshCommands() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const c = this.registry.client;
+            const app = c.application;
+            if (c.commandOptions.slashCommands.autoRegister) {
+                console.log('[command.ts] Updating commands...');
+                if ('guild' in c.commandOptions.slashCommands) {
+                    const processForGuild = (guildID) => __awaiter(this, void 0, void 0, function* () {
+                        console.log(`[command.ts] Target Guild ID: ${guildID}`);
+                        const guild = c.guilds.cache.get(guildID);
+                        if (!guild)
+                            return console.log(`[command.ts] ${guildID} Command creation cancelled.`);
+                        yield guild.commands.set(this.commandList.map((x) => ({
+                            name: x.name,
+                            description: x.description,
+                            options: x.options,
+                            defaultPermission: !x.ownerOnly,
+                        })));
+                        for (const [, command] of guild.commands.cache.filter((x) => {
+                            var _a;
+                            return ((_a = this.commandList.find((y) => x.name === y.name)) === null || _a === void 0 ? void 0 : _a.ownerOnly) ||
+                                false;
+                        })) {
+                            yield command.permissions.set({
+                                permissions: this.registry.client.owners.map((x) => ({
+                                    type: 'USER',
+                                    id: x,
+                                    permission: true,
+                                })),
+                            });
+                        }
+                    });
+                    const g = c.commandOptions.slashCommands.guild;
+                    if (typeof g === 'string') {
+                        yield processForGuild(g);
+                    }
+                    else {
+                        yield Promise.all(g.map((x) => processForGuild(x)));
+                    }
+                }
+                else {
+                    console.log(`[command.ts] Target: Global`);
+                    yield app.commands.set(this.commandList.map((x) => ({
+                        name: x.name,
+                        description: x.description,
+                        options: x.options,
+                        defaultPermission: !x.ownerOnly,
+                    })));
+                    for (const [, command] of app.commands.cache.filter((x) => { var _a; return ((_a = this.commandList.find((y) => x.name === y.name)) === null || _a === void 0 ? void 0 : _a.ownerOnly) || false; })) {
+                        yield command.permissions.set({
+                            permissions: this.registry.client.owners.map((x) => ({
+                                type: 'USER',
+                                id: x,
+                                permission: true,
+                            })),
+                            guild: this.registry.client.commandOptions.slashCommands
+                                .ownerCommandGuild,
+                        });
+                    }
+                }
+            }
+        });
+    }
+    registerCommands(module) {
+        const decorators = Reflect.getMetadata(constants_1.SLASH_COMMANDS_KEY, module);
+        if (!decorators)
+            return;
+        const ownerOnlyKeys = Reflect.getMetadata(constants_1.COMMANDS_OWNER_ONLY_KEY, module) || new Set();
+        const commands = decorators.map((v) => {
+            const checks = Reflect.getMetadata(constants_1.COMMANDS_CHECK_KEY, module, v.key) || [];
+            const userPerms = Reflect.getMetadata(constants_1.COMMANDS_USER_PERMISSIONS_KEY, module, v.key) || { permissions: [] };
+            const clientPerms = Reflect.getMetadata(constants_1.COMMANDS_CLIENT_PERMISSIONS_KEY, module, v.key) || { permissions: [] };
+            return {
+                module: module,
+                name: v.name,
+                execute: Reflect.get(module, v.key),
+                description: v.description,
+                options: v.options,
+                userPermissions: userPerms.permissions,
+                clientPermissions: clientPerms.permissions,
+                checks,
+                ownerOnly: ownerOnlyKeys.has(v.key),
+            };
+        });
+        this.commands.set(module, commands);
+    }
+    /**
+     * This method is run by Registry. You don't have to run it manually.
+     * @param module
+     */
+    register(module) {
+        this.registerCommands(module);
+    }
+    /**
+     * This method is run by Registry. You don't have to run it manually.
+     * @param module
+     */
+    unregister(module) {
+        this.commands.delete(module);
+    }
+}
+exports.SlashCommandManager = SlashCommandManager;

package/dist/structures/Context.d.ts

@@ -0,0 +1,9 @@
+import { Message } from 'discord.js';
+/**
+ * Command Context class
+ */
+export declare class Context {
+    msg: Message;
+    prefix: string;
+    constructor(msg: Message, prefix: string);
+}

package/dist/structures/Context.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = void 0;
+/**
+ * Command Context class
+ */
+class Context {
+    constructor(msg, prefix) {
+        this.msg = msg;
+        this.prefix = prefix;
+    }
+}
+exports.Context = Context;