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

package/dist/argumentConverter/decorator.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Argument Converter decorator
+ * @param type
+ */
+export declare function argConverter(type: Function): MethodDecorator;

package/dist/argumentConverter/decorator.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.argConverter = void 0;
+const structures_1 = require("../structures");
+const constants_1 = require("../constants");
+/**
+ * Argument Converter decorator
+ * @param type
+ */
+function argConverter(type) {
+    return (target, propertyKey) => {
+        if (!(target instanceof structures_1.Module)) {
+            throw new TypeError('Class does not extend `Module` class.');
+        }
+        const meta = {
+            type,
+            key: propertyKey,
+        };
+        const metas = Reflect.getMetadata(constants_1.ARG_CONVERTER_KEY, target) || [];
+        metas.push(meta);
+        Reflect.defineMetadata(constants_1.ARG_CONVERTER_KEY, metas, target);
+    };
+}
+exports.argConverter = argConverter;

package/dist/argumentConverter/index.d.ts

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

package/dist/argumentConverter/index.js

@@ -0,0 +1,13 @@
+"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("./decorator"), exports);

package/dist/command/CommandManager.d.ts

@@ -0,0 +1,16 @@
+import { Module } from '../structures';
+import { Collection } from 'discord.js';
+import { ArgConverter, Command } from '../types';
+/**
+ * Command Manager
+ */
+export declare class CommandManager {
+    commands: Collection<Module, Command[]>;
+    argumentConverters: Collection<Module, ArgConverter[]>;
+    get commandList(): Command[];
+    get argConverterList(): ArgConverter[];
+    private registerCommands;
+    registerArgConverter(module: Module): void;
+    register(module: Module): void;
+    unregister(module: Module): void;
+}

package/dist/command/CommandManager.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandManager = void 0;
+const discord_js_1 = require("discord.js");
+const constants_1 = require("../constants");
+/**
+ * Command Manager
+ */
+class CommandManager {
+    constructor() {
+        this.commands = new discord_js_1.Collection();
+        this.argumentConverters = new discord_js_1.Collection();
+    }
+    get commandList() {
+        const result = [];
+        this.commands.forEach((x) => result.push(...x));
+        return result;
+    }
+    get argConverterList() {
+        const result = [];
+        this.argumentConverters.forEach((x) => result.push(...x));
+        return result;
+    }
+    registerCommands(module) {
+        const decorators = Reflect.getMetadata(constants_1.COMMANDS_KEY, module);
+        const ownerOnlyKeys = Reflect.getMetadata(constants_1.COMMANDS_OWNER_ONLY_KEY, module) || new Set();
+        if (!decorators)
+            return;
+        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 {
+                usesCtx: v.usesCtx,
+                args: v.args,
+                brief: v.brief,
+                description: v.description,
+                module: module,
+                name: v.name,
+                execute: Reflect.get(module, v.key),
+                aliases: v.aliases,
+                ownerOnly: ownerOnlyKeys.has(v.key),
+                checks,
+                userPermissions: userPerms.permissions,
+                clientPermissions: clientPerms.permissions,
+            };
+        });
+        this.commands.set(module, commands);
+    }
+    registerArgConverter(module) {
+        const decorators = Reflect.getMetadata(constants_1.ARG_CONVERTER_KEY, module);
+        if (!decorators)
+            return;
+        const converters = decorators.map((v) => ({
+            convert: Reflect.get(module, v.key),
+            type: v.type,
+            module: module,
+        }));
+        this.argumentConverters.set(module, converters);
+    }
+    register(module) {
+        this.registerArgConverter(module);
+        this.registerCommands(module);
+    }
+    unregister(module) {
+        this.commands.delete(module);
+    }
+}
+exports.CommandManager = CommandManager;

package/dist/debugTool/DebugModule.d.ts

@@ -0,0 +1,7 @@
+import { Context } from '../index';
+/**
+ * Debug Module
+ */
+export declare class DebugModule {
+    static run(ctx: Context): Promise<void>;
+}

package/dist/debugTool/DebugModule.js

@@ -0,0 +1,56 @@
+"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 __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 __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.DebugModule = void 0;
+const commands_1 = __importStar(require("./commands"));
+/**
+ * Debug Module
+ */
+class DebugModule {
+    static run(ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const args = ctx.msg.content.slice(ctx.prefix.length).split(' ');
+            args.shift();
+            const commandName = args.shift();
+            const command = commands_1.default.find((x) => x.name === commandName);
+            if (!commandName || !command) {
+                yield commands_1.Default.execute(ctx.msg);
+                return;
+            }
+            try {
+                yield command.execute(ctx.msg, args);
+            }
+            catch (_a) {
+                yield ctx.msg.reply('Command failed.');
+            }
+        });
+    }
+}
+exports.DebugModule = DebugModule;

package/dist/debugTool/commands/default.d.ts

@@ -0,0 +1,7 @@
+import { Message } from 'discord.js';
+/**
+ * Show available commands in debug module
+ */
+export declare const Default: {
+    execute: (msg: Message) => Promise<Message>;
+};

package/dist/debugTool/commands/default.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Default = void 0;
+const index_1 = __importDefault(require("./index"));
+/**
+ * Show available commands in debug module
+ */
+exports.Default = {
+    execute: (msg) => {
+        let str = 'Available commands: ' +
+            index_1.default.map((x) => '`' + x.name + '`').join(', ');
+        return msg.reply(str);
+    },
+};

package/dist/debugTool/commands/eval.d.ts

@@ -0,0 +1,9 @@
+import { Message } from 'discord.js';
+declare const _default: {
+    name: string;
+    execute: (msg: Message, args: string[]) => Promise<void>;
+};
+/**
+ * Evaluate javascript/typescript code
+ */
+export default _default;

package/dist/debugTool/commands/eval.js

@@ -0,0 +1,103 @@
+"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 __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 __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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const discord_js_1 = require("discord.js");
+const typescript_1 = __importDefault(require("typescript"));
+const util = __importStar(require("util"));
+/**
+ * Evaluate javascript/typescript code
+ */
+exports.default = {
+    name: 'eval',
+    execute: (msg, args) => __awaiter(void 0, void 0, void 0, function* () {
+        let script = args.join(' ');
+        let transpiler = (code) => code;
+        if (script.startsWith('```') && script.endsWith('```')) {
+            script = script.slice(3, script.length - 3);
+            if (script.startsWith('ts') || script.startsWith('typescript')) {
+                script = script.slice(2);
+                transpiler = (code) => typescript_1.default.transpile(code);
+            }
+        }
+        const code = transpiler(script);
+        return new Promise((resolve) => resolve(eval(code)))
+            .then((v) => {
+            let returns = v;
+            if (typeof v !== 'string') {
+                returns = util.inspect(v, {
+                    compact: true,
+                });
+            }
+            returns = returns.split(msg.client.token).join('[secret]');
+            return returns;
+        })
+            .catch((reason) => {
+            return reason.stack;
+        })
+            .then((res) => __awaiter(void 0, void 0, void 0, function* () {
+            const s = `${res}`;
+            let m;
+            const components = [
+                new discord_js_1.MessageActionRow().addComponents(new discord_js_1.MessageButton({
+                    customId: 'delete',
+                    style: 'DANGER',
+                    emoji: '🗑️',
+                })),
+            ];
+            if (s.split('\n').length > 1) {
+                m = yield msg.reply({
+                    files: [new discord_js_1.MessageAttachment(Buffer.from(s), 'out.txt')],
+                    components,
+                });
+            }
+            else {
+                m = yield msg.reply({
+                    content: s,
+                    components,
+                });
+            }
+            try {
+                yield m.awaitMessageComponent({
+                    componentType: 'BUTTON',
+                    filter: (i) => i.customId === 'delete' && i.user.id === msg.author.id,
+                });
+                yield m.delete();
+            }
+            catch (_a) {
+                yield m.edit({
+                    components: [],
+                });
+            }
+        }));
+    }),
+};

package/dist/debugTool/commands/index.d.ts

@@ -0,0 +1,6 @@
+export * from './default';
+declare const _default: {
+    name: string;
+    execute: (msg: import("discord.js").Message, args: string[]) => Promise<void>;
+}[];
+export default _default;

package/dist/debugTool/commands/index.js

@@ -0,0 +1,21 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const eval_1 = __importDefault(require("./eval"));
+const load_1 = __importDefault(require("./load"));
+const reload_1 = __importDefault(require("./reload"));
+const unload_1 = __importDefault(require("./unload"));
+__exportStar(require("./default"), exports);
+exports.default = [eval_1.default, load_1.default, reload_1.default, unload_1.default];

package/dist/debugTool/commands/load.d.ts

@@ -0,0 +1,9 @@
+import { Message } from 'discord.js';
+declare const _default: {
+    name: string;
+    execute: (msg: Message, args: string[]) => Promise<void>;
+};
+/**
+ * Load module
+ */
+export default _default;

package/dist/debugTool/commands/load.js

@@ -0,0 +1,36 @@
+"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 });
+/**
+ * Load module
+ */
+exports.default = {
+    name: 'load',
+    execute: (msg, args) => __awaiter(void 0, void 0, void 0, function* () {
+        const client = msg.client;
+        let result = '```\n';
+        let success = 0;
+        let failed = 0;
+        for (const arg of args) {
+            try {
+                yield client.registry.loadModule(arg);
+                result += `✅ ${module.constructor.name}(${arg}) - Successful\n`;
+                success++;
+            }
+            catch (e) {
+                result += `🚫 ${arg} - ${e.message}\n`;
+                failed++;
+            }
+        }
+        result += `\`\`\`\n${success} successful, ${failed} failed.`;
+        yield msg.reply(result);
+    }),
+};

package/dist/debugTool/commands/reload.d.ts

@@ -0,0 +1,9 @@
+import { Message } from 'discord.js';
+declare const _default: {
+    name: string;
+    execute: (msg: Message, args: string[]) => Promise<void>;
+};
+/**
+ * Reload module
+ */
+export default _default;

package/dist/debugTool/commands/reload.js

@@ -0,0 +1,54 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+/**
+ * Reload module
+ */
+exports.default = {
+    name: 'reload',
+    execute: (msg, args) => __awaiter(void 0, void 0, void 0, function* () {
+        const client = msg.client;
+        let result = '```\n';
+        let success = 0;
+        let failed = 0;
+        let all = false;
+        if (args[0] === '~' || !args.length) {
+            args = client.registry.modules
+                .filter((x) => require(x.__path).loaded)
+                .map((x) => x.__path);
+            all = true;
+        }
+        for (const arg of args) {
+            try {
+                const module = client.registry.modules.find((x) => x.__path ===
+                    require.resolve(all ? arg : path_1.default.join(client.rootPath, arg)));
+                if (!module) {
+                    result += `🚫 ${arg} - Not Found\n`;
+                    failed++;
+                    continue;
+                }
+                yield client.registry.reloadModule(module);
+                result += `✅ ${module.constructor.name}(${arg}) - Successful\n`;
+                success++;
+            }
+            catch (e) {
+                result += `🚫 ${arg} - ${e.message}\n`;
+                failed++;
+            }
+        }
+        result += `\`\`\`\n${success} successful, ${failed} failed.`;
+        yield msg.reply(result);
+    }),
+};

package/dist/debugTool/commands/unload.d.ts

@@ -0,0 +1,9 @@
+import { Message } from 'discord.js';
+declare const _default: {
+    name: string;
+    execute: (msg: Message, args: string[]) => Promise<void>;
+};
+/**
+ * Unload module
+ */
+export default _default;

package/dist/debugTool/commands/unload.js

@@ -0,0 +1,54 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+/**
+ * Unload module
+ */
+exports.default = {
+    name: 'unload',
+    execute: (msg, args) => __awaiter(void 0, void 0, void 0, function* () {
+        const client = msg.client;
+        let result = '```\n';
+        let success = 0;
+        let failed = 0;
+        let all = false;
+        if (args[0] === '~') {
+            args = client.registry.modules
+                .filter((x) => require(x.__path).loaded)
+                .map((x) => x.__path && require(x.__path).loaded);
+            all = true;
+        }
+        for (const arg of args) {
+            const module = client.registry.modules.find((x) => x.__path ===
+                require.resolve(all ? arg : path_1.default.join(client.rootPath, arg)));
+            if (!module) {
+                result += `🚫 ${arg} - Not Found\n`;
+                failed++;
+                continue;
+            }
+            try {
+                yield client.registry.unloadModule(module);
+                result += `✅ ${module.constructor.name}(${arg}) - Successful\n`;
+                success++;
+            }
+            catch (e) {
+                result += `🚫 ${arg} - ${e.message}\n`;
+                failed++;
+            }
+        }
+        result += `\`\`\`\n${success} successful, ${failed} failed.`;
+        yield msg.reply(result);
+    }),
+};

package/dist/debugTool/index.d.ts

@@ -0,0 +1,20 @@
+import { DebugModule } from './DebugModule';
+export { DebugModule };
+export declare const debugCommands: {
+    load: {
+        name: string;
+        execute: (msg: import("discord.js").Message, args: string[]) => Promise<void>;
+    };
+    unload: {
+        name: string;
+        execute: (msg: import("discord.js").Message, args: string[]) => Promise<void>;
+    };
+    reload: {
+        name: string;
+        execute: (msg: import("discord.js").Message, args: string[]) => Promise<void>;
+    };
+    eval: {
+        name: string;
+        execute: (msg: import("discord.js").Message, args: string[]) => Promise<void>;
+    };
+};

package/dist/debugTool/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debugCommands = exports.DebugModule = void 0;
+const DebugModule_1 = require("./DebugModule");
+Object.defineProperty(exports, "DebugModule", { enumerable: true, get: function () { return DebugModule_1.DebugModule; } });
+const load_1 = __importDefault(require("./commands/load"));
+const unload_1 = __importDefault(require("./commands/unload"));
+const reload_1 = __importDefault(require("./commands/reload"));
+const eval_1 = __importDefault(require("./commands/eval"));
+exports.debugCommands = {
+    load: load_1.default,
+    unload: unload_1.default,
+    reload: reload_1.default,
+    eval: eval_1.default,
+};

package/dist/defaultModules/BuiltInConverters.d.ts

@@ -0,0 +1,13 @@
+import { CommandClient, Module } from '..';
+import { GuildMember, Message, User } from 'discord.js';
+/**
+ * Built-In module which is enabled by default.
+ */
+export declare class BuiltInConverters extends Module {
+    private client;
+    constructor(client: CommandClient);
+    getUserIDByMention(mention: string): `${bigint}` | undefined;
+    user(value: string): User | null;
+    member(value: string, msg: Message): GuildMember | null;
+    number(value: string): number | null;
+}