@pikokr/command.ts 3.0.0-dev.7170769 → 3.0.0-dev.85a29c3

package/.prettierrc

@@ -3,5 +3,6 @@
   "trailingComma": "all",
   "bracketSpacing": true,
   "endOfLine": "lf",
-  "singleQuote": true
+  "singleQuote": true,
+  "printWidth": 180
 }

package/README.md

@@ -2,6 +2,8 @@
 
 Command framework for discord.js
 
+[Discord](https://discord.gg/EEhcPzsGHV)
+
 # 진행상황 / Progress
 
-https://command-ts.notion.site/d660d95d1bb244ff94738d32745a272d?v=89dbd88b8ea04d22b8d2fc0f0962b8d3
+https://pikokr.notion.site/b11137d4e879413a849fdf453c74bf39?v=f12235b64e4d438182b32e436f6b3bb9

package/dist/builtinModules/BuiltInModule.d.ts

@@ -0,0 +1,4 @@
+import { Module } from '../structures';
+export declare class BuiltInModule extends Module {
+    constructor();
+}

package/dist/builtinModules/BuiltInModule.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuiltInModule = void 0;
+const structures_1 = require("../structures");
+const constants_1 = require("../constants");
+class BuiltInModule extends structures_1.Module {
+    constructor() {
+        super();
+        Reflect.defineMetadata(constants_1.KBuiltInModule, true, this);
+    }
+}
+exports.BuiltInModule = BuiltInModule;

package/dist/builtinModules/BuiltinCommandConverters.d.ts

@@ -0,0 +1,14 @@
+import { BuiltInModule } from './BuiltInModule';
+import { Client, GuildMember, Message, User } from 'discord.js';
+import { CommandClient } from '../structures';
+export declare class BuiltinCommandConverters extends BuiltInModule {
+    private cts;
+    client: Client;
+    constructor(cts: CommandClient);
+    message(msg: Message): Message;
+    string(msg: Message, arg: string): string;
+    getUserIDByMention(mention: string): `${bigint}` | undefined;
+    user(value: string): User | null;
+    member(value: string, msg: Message): GuildMember | undefined;
+    number(value: string): number | undefined;
+}

package/dist/builtinModules/BuiltinCommandConverters.js

@@ -0,0 +1,89 @@
+"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.BuiltinCommandConverters = void 0;
+const BuiltInModule_1 = require("./BuiltInModule");
+const command_1 = require("../command");
+const discord_js_1 = require("discord.js");
+class BuiltinCommandConverters extends BuiltInModule_1.BuiltInModule {
+    constructor(cts) {
+        super();
+        this.cts = cts;
+        this.client = cts.client;
+    }
+    message(msg) {
+        return msg;
+    }
+    string(msg, arg) {
+        return arg;
+    }
+    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;
+        const user = (_a = msg.guild) === null || _a === void 0 ? void 0 : _a.members.cache.get(id);
+        return user || undefined;
+    }
+    number(value) {
+        const n = Number(value);
+        return isNaN(n) ? undefined : n;
+    }
+}
+__decorate([
+    command_1.argumentConverter(discord_js_1.Message, false),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [discord_js_1.Message]),
+    __metadata("design:returntype", void 0)
+], BuiltinCommandConverters.prototype, "message", null);
+__decorate([
+    command_1.argumentConverter(String),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [discord_js_1.Message, String]),
+    __metadata("design:returntype", void 0)
+], BuiltinCommandConverters.prototype, "string", null);
+__decorate([
+    command_1.argumentConverter(discord_js_1.User),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Object)
+], BuiltinCommandConverters.prototype, "user", null);
+__decorate([
+    command_1.argumentConverter(discord_js_1.GuildMember),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, discord_js_1.Message]),
+    __metadata("design:returntype", Object)
+], BuiltinCommandConverters.prototype, "member", null);
+__decorate([
+    command_1.argumentConverter(Number),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", void 0)
+], BuiltinCommandConverters.prototype, "number", null);
+exports.BuiltinCommandConverters = BuiltinCommandConverters;

package/dist/builtinModules/CommandHandler.d.ts

@@ -0,0 +1,9 @@
+import { BuiltInModule } from './BuiltInModule';
+import { Registry } from '../structures';
+import { Message } from 'discord.js';
+export declare class CommandHandler extends BuiltInModule {
+    private registry;
+    private client;
+    constructor(registry: Registry);
+    message(msg: Message): Promise<boolean | undefined>;
+}

package/dist/builtinModules/CommandHandler.js

@@ -0,0 +1,134 @@
+"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 BuiltInModule_1 = require("./BuiltInModule");
+const listener_1 = require("../listener");
+const discord_js_1 = require("discord.js");
+const error_1 = require("../error");
+const CommandNotFound_1 = require("../error/CommandNotFound");
+class CommandHandler extends BuiltInModule_1.BuiltInModule {
+    constructor(registry) {
+        super();
+        this.registry = registry;
+        this.client = registry.client;
+    }
+    message(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const error = (error) => this.client.client.emit('commandError', error, msg);
+            try {
+                const prefixList = typeof this.client.options.command.prefix === 'string'
+                    ? this.client.options.command.prefix
+                    : typeof this.client.options.command.prefix === 'function'
+                        ? yield this.client.options.command.prefix(msg)
+                        : this.client.options.command.prefix;
+                let prefix;
+                if (typeof prefixList === 'object') {
+                    const res = prefixList.find((x) => msg.content.includes(x));
+                    if (!res)
+                        return;
+                    prefix = res;
+                }
+                else {
+                    if (!msg.content.includes(prefixList))
+                        return;
+                    prefix = prefixList;
+                }
+                if (!msg.content.startsWith(prefix))
+                    return;
+                const args = msg.content.slice(prefix.length).split(' ');
+                const command = args.shift();
+                if (!command)
+                    return;
+                let cmd = null;
+                for (const c of this.registry.commands) {
+                    if (c.name === command) {
+                        cmd = c;
+                        break;
+                    }
+                    if ((typeof c.aliases === 'function' ? yield c.aliases(msg) : c.aliases).includes(command)) {
+                        cmd = c;
+                        break;
+                    }
+                }
+                if (!cmd)
+                    return error(new CommandNotFound_1.CommandNotFound(command));
+                msg.data = {
+                    cts: this.client,
+                    command: cmd,
+                    prefix: prefix,
+                };
+                const module = this.registry.modules.find((x) => x.commands.includes(cmd));
+                if (!module)
+                    return;
+                const argList = [];
+                for (const check of cmd.checks) {
+                    if (!(yield check(msg)))
+                        return error(new error_1.CommandCheckFailed(msg, cmd));
+                }
+                for (let i = 0; i < cmd.argTypes.length; i++) {
+                    const argType = cmd.argTypes[i];
+                    const converter = this.registry.argumentConverters.find((x) => x.type === argType.type);
+                    if (argType.rest) {
+                        const i = args.join(' ');
+                        if (!i)
+                            break;
+                        argList.push(i);
+                        break;
+                    }
+                    if (!converter)
+                        return error(new error_1.ArgumentConverterNotFound(argType, msg));
+                    if (converter.withoutParameter) {
+                        argList.push(yield converter.execute(module, msg));
+                        continue;
+                    }
+                    const arg = args.shift();
+                    if (argType.optional && !arg) {
+                        break;
+                    }
+                    if (!arg) {
+                        return error(new error_1.ArgumentNotProvided(i, cmd, msg));
+                    }
+                    const executed = yield converter.execute(module, msg, arg);
+                    if (!executed === undefined) {
+                        return error(new error_1.ArgumentNotProvided(i, cmd, msg));
+                    }
+                    argList.push(executed);
+                }
+                try {
+                    cmd.execute(module, argList);
+                }
+                catch (e) {
+                    return error(e);
+                }
+            }
+            catch (e) {
+                return error(e);
+            }
+        });
+    }
+}
+__decorate([
+    listener_1.listener('messageCreate'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [discord_js_1.Message]),
+    __metadata("design:returntype", Promise)
+], CommandHandler.prototype, "message", null);
+exports.CommandHandler = CommandHandler;

package/dist/builtinModules/index.d.ts

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

package/dist/builtinModules/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("./BuiltinCommandConverters"), exports);

package/dist/command/ArgumentConverter.d.ts

@@ -0,0 +1,9 @@
+import { Module } from '../structures';
+import { Message } from 'discord.js';
+export declare class ArgumentConverter {
+    type: object;
+    private run;
+    withoutParameter: boolean;
+    execute(module: Module, msg: Message, arg?: string): any;
+    constructor(type: object, run: Function, withoutParameter: boolean);
+}

package/dist/command/ArgumentConverter.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArgumentConverter = void 0;
+class ArgumentConverter {
+    constructor(type, run, withoutParameter) {
+        this.type = type;
+        this.run = run;
+        this.withoutParameter = withoutParameter;
+    }
+    execute(module, msg, arg) {
+        return this.run.apply(module, [msg, arg]);
+    }
+}
+exports.ArgumentConverter = ArgumentConverter;

package/dist/command/Command.d.ts

@@ -1,10 +1,19 @@
 import { Module } from '../structures';
+import { Message } from 'discord.js';
+export declare type Argument = {
+    optional: boolean;
+    type: any;
+    rest: boolean;
+};
+export declare type CheckFunction = (msg: Message) => boolean | Promise<boolean>;
 export declare class Command {
-    module: Module;
     private run;
-    argTypes: any[];
+    argTypes: Argument[];
     name: string;
-    aliases: string[];
-    execute(args: string[]): any;
-    constructor(module: Module, run: Function, argTypes: any[], name: string, aliases: string[]);
+    aliases: string[] | ((msg: Message) => string[]);
+    module: Module;
+    key: symbol | string;
+    execute(module: Module, args: any[]): any;
+    get checks(): CheckFunction[];
+    constructor(run: Function, argTypes: Argument[], name: string, aliases: string[] | ((msg: Message) => string[]), module: Module, key: symbol | string);
 }

package/dist/command/Command.js

@@ -1,16 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Command = void 0;
+const constants_1 = require("../constants");
 class Command {
-    constructor(module, run, argTypes, name, aliases) {
-        this.module = module;
+    constructor(run, argTypes, name, aliases, module, key) {
         this.run = run;
         this.argTypes = argTypes;
         this.name = name;
         this.aliases = aliases;
+        this.module = module;
+        this.key = key;
+    }
+    execute(module, args) {
+        return this.run.apply(module, args);
     }
-    execute(args) {
-        return this.run.call(this.module, args);
+    get checks() {
+        return Reflect.getMetadata(constants_1.KCommandChecks, this.module, this.key) || [];
     }
 }
 exports.Command = Command;

package/dist/command/decorator.d.ts

@@ -1,6 +1,15 @@
+import { Message, PermissionResolvable } from 'discord.js';
 declare type CommandOptions = {
     name: string;
-    aliases: string[];
+    aliases: string[] | ((msg: Message) => string[]);
 };
-export declare const command: (options: Partial<CommandOptions>) => (target: Object, propertyKey: string) => void;
+export declare const command: (options?: Partial<CommandOptions>) => (target: Object, propertyKey: string) => void;
+export declare const argumentConverter: (type: object, requireParameter?: boolean) => (target: Object, propertyKey: string) => void;
+export declare const optional: ParameterDecorator;
+export declare const rest: ParameterDecorator;
+export declare const ownerOnly: MethodDecorator;
+export declare const guildOnly: MethodDecorator;
+export declare const dmOnly: MethodDecorator;
+export declare const requireUserPermissions: (permission: PermissionResolvable) => MethodDecorator;
+export declare const requireClientPermissions: (permission: PermissionResolvable) => MethodDecorator;
 export {};

package/dist/command/decorator.js

@@ -1,20 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.command = void 0;
+exports.requireClientPermissions = exports.requireUserPermissions = exports.dmOnly = exports.guildOnly = exports.ownerOnly = exports.rest = exports.optional = exports.argumentConverter = exports.command = void 0;
 const constants_1 = require("../constants");
-const structures_1 = require("../structures");
-const error_1 = require("../error");
 const Command_1 = require("./Command");
-const checkTarget = (target) => {
-    if (!(target instanceof structures_1.Module))
-        throw new error_1.InvalidTargetError();
-};
-const command = (options) => {
+const utils_1 = require("../utils");
+const ArgumentConverter_1 = require("./ArgumentConverter");
+const utils_2 = require("./utils");
+const discord_js_1 = require("discord.js");
+const error_1 = require("../error");
+const command = (options = {}) => {
     return (target, propertyKey) => {
-        checkTarget(target);
+        utils_1.checkTarget(target);
         let properties = Reflect.getMetadata(constants_1.KCommands, target);
         const params = Reflect.getMetadata('design:paramtypes', target, propertyKey);
-        const command = new Command_1.Command(target, Reflect.get(target, propertyKey), params, options.name || propertyKey, options.aliases || []);
+        const optionals = Reflect.getMetadata(constants_1.KOptionals, target, propertyKey) || -1;
+        const rest = Reflect.getMetadata(constants_1.KRest, target, propertyKey) || -1;
+        const command = new Command_1.Command(Reflect.get(target, propertyKey), params.map((x, i) => ({
+            type: x,
+            optional: optionals === -1 ? false : optionals <= i,
+            rest: rest === -1 ? false : rest === i,
+        })), options.name || propertyKey, options.aliases || [], target, propertyKey);
         if (properties) {
             properties.push(command);
         }
@@ -25,3 +30,54 @@ const command = (options) => {
     };
 };
 exports.command = command;
+const argumentConverter = (type, requireParameter = true) => {
+    return (target, propertyKey) => {
+        utils_1.checkTarget(target);
+        let properties = Reflect.getMetadata(constants_1.KArgumentConverters, target);
+        const converter = new ArgumentConverter_1.ArgumentConverter(type, Reflect.get(target, propertyKey), !requireParameter);
+        if (properties) {
+            properties.push(converter);
+        }
+        else {
+            properties = [converter];
+            Reflect.defineMetadata(constants_1.KArgumentConverters, properties, target);
+        }
+    };
+};
+exports.argumentConverter = argumentConverter;
+const optional = (target, propertyKey, parameterIndex) => {
+    utils_1.checkTarget(target);
+    Reflect.defineMetadata(constants_1.KOptionals, parameterIndex, target, propertyKey);
+};
+exports.optional = optional;
+const rest = (target, propertyKey, parameterIndex) => {
+    utils_1.checkTarget(target);
+    const params = Reflect.getMetadata('design:paramtypes', target, propertyKey);
+    if (params.length - 1 !== parameterIndex)
+        throw new Error('Rest decorator must be used at last argument.');
+    if (params[parameterIndex] !== String)
+        throw new Error('Rest argument type must be "String"');
+    Reflect.defineMetadata(constants_1.KRest, parameterIndex, target, propertyKey);
+};
+exports.rest = rest;
+exports.ownerOnly = utils_2.createCheckDecorator((msg) => msg.data.cts.owners.includes(msg.author.id));
+exports.guildOnly = utils_2.createCheckDecorator((msg) => !!msg.guild);
+exports.dmOnly = utils_2.createCheckDecorator((msg) => !msg.guild);
+const requireUserPermissions = (permission) => utils_2.createCheckDecorator((msg) => {
+    if (!msg.guild || !msg.member)
+        throw new Error('This command must be used in serer.');
+    if (msg.member.permissionsIn(msg.channel).has(permission)) {
+        return true;
+    }
+    throw new error_1.UserPermissionRequired(msg.member, new discord_js_1.Permissions(permission));
+});
+exports.requireUserPermissions = requireUserPermissions;
+const requireClientPermissions = (permission) => utils_2.createCheckDecorator((msg) => {
+    if (!msg.guild)
+        throw new Error('This command must be used in serer.');
+    if (msg.guild.me.permissionsIn(msg.channel).has(permission)) {
+        return true;
+    }
+    throw new error_1.ClientPermissionRequired(new discord_js_1.Permissions(permission));
+});
+exports.requireClientPermissions = requireClientPermissions;

package/dist/command/index.d.ts

@@ -1,2 +1,4 @@
 export * from './Command';
 export * from './decorator';
+export * from './ArgumentConverter';
+export * from './utils';

package/dist/command/index.js

@@ -12,3 +12,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./Command"), exports);
 __exportStar(require("./decorator"), exports);
+__exportStar(require("./ArgumentConverter"), exports);
+__exportStar(require("./utils"), exports);

package/dist/command/utils.d.ts

@@ -0,0 +1,2 @@
+import { Message } from 'discord.js';
+export declare const createCheckDecorator: (execute: (msg: Message) => boolean | Promise<boolean>) => MethodDecorator;

package/dist/command/utils.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCheckDecorator = void 0;
+const constants_1 = require("../constants");
+const createCheckDecorator = (execute) => {
+    return (target, propertyKey) => {
+        let properties = Reflect.getMetadata(constants_1.KCommandChecks, target, propertyKey);
+        if (properties) {
+            properties.push(execute);
+        }
+        else {
+            properties = [execute];
+            Reflect.defineMetadata(constants_1.KCommandChecks, properties, target, propertyKey);
+        }
+    };
+};
+exports.createCheckDecorator = createCheckDecorator;

package/dist/constants.d.ts

@@ -1,2 +1,9 @@
 export declare const KCommands: unique symbol;
+export declare const KListeners: unique symbol;
 export declare const KModulePath: unique symbol;
+export declare const KListenerExecuteCache: unique symbol;
+export declare const KBuiltInModule: unique symbol;
+export declare const KOptionals: unique symbol;
+export declare const KRest: unique symbol;
+export declare const KArgumentConverters: unique symbol;
+export declare const KCommandChecks: unique symbol;

package/dist/constants.js

@@ -1,5 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KModulePath = exports.KCommands = void 0;
-exports.KCommands = Symbol('Command.TS Command');
+exports.KCommandChecks = exports.KArgumentConverters = exports.KRest = exports.KOptionals = exports.KBuiltInModule = exports.KListenerExecuteCache = exports.KModulePath = exports.KListeners = exports.KCommands = void 0;
+exports.KCommands = Symbol('Command.TS Commands');
+exports.KListeners = Symbol('Command.TS Listeners');
 exports.KModulePath = Symbol('Command.TS Module Path');
+exports.KListenerExecuteCache = Symbol('Command.TS Module Identifier');
+exports.KBuiltInModule = Symbol('Command.TS Built-In Module');
+exports.KOptionals = Symbol('Command.TS Optional Parameters');
+exports.KRest = Symbol('Command.TS Rest Parameter');
+exports.KArgumentConverters = Symbol('Command.TS Argument Converter');
+exports.KCommandChecks = Symbol('Command.TS Command Checks');

package/dist/error/ArgumentConverterNotFound.d.ts

@@ -0,0 +1,7 @@
+import { Message } from 'discord.js';
+import type { Argument } from '../command';
+export declare class ArgumentConverterNotFound extends Error {
+    type: Argument;
+    msg: Message;
+    constructor(type: Argument, msg: Message);
+}

package/dist/error/ArgumentConverterNotFound.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArgumentConverterNotFound = void 0;
+class ArgumentConverterNotFound extends Error {
+    constructor(type, msg) {
+        super(`Argument converter ${type.type.name} not found.`);
+        this.type = type;
+        this.msg = msg;
+    }
+}
+exports.ArgumentConverterNotFound = ArgumentConverterNotFound;

package/dist/error/ArgumentNotProvided.d.ts

@@ -0,0 +1,8 @@
+import { Message } from 'discord.js';
+import { Command } from '../command';
+export declare class ArgumentNotProvided extends Error {
+    index: number;
+    command: Command;
+    msg: Message;
+    constructor(index: number, command: Command, msg: Message);
+}

package/dist/error/ArgumentNotProvided.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArgumentNotProvided = void 0;
+class ArgumentNotProvided extends Error {
+    constructor(index, command, msg) {
+        super(`Required argument #${index} not provided.`);
+        this.index = index;
+        this.command = command;
+        this.msg = msg;
+    }
+}
+exports.ArgumentNotProvided = ArgumentNotProvided;

package/dist/error/CommandCheckFailed.d.ts

@@ -0,0 +1,7 @@
+import { Message } from 'discord.js';
+import { Command } from '../command';
+export declare class CommandCheckFailed extends Error {
+    msg: Message;
+    command: Command;
+    constructor(msg: Message, command: Command);
+}

package/dist/error/CommandCheckFailed.js

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

package/dist/error/CommandNotFound.d.ts

@@ -0,0 +1,4 @@
+export declare class CommandNotFound extends Error {
+    commandName: string;
+    constructor(commandName: string);
+}

package/dist/error/CommandNotFound.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandNotFound = void 0;
+class CommandNotFound extends Error {
+    constructor(commandName) {
+        super(`Command ${commandName} not found.`);
+        this.commandName = commandName;
+    }
+}
+exports.CommandNotFound = CommandNotFound;