@pikokr/command.ts 3.0.0-dev.a94f324 → 3.0.0-dev.ca01eb5

package/dist/structures/Module.js

@@ -12,6 +12,15 @@ class Module {
     get argumentConverters() {
         return Reflect.getMetadata(constants_1.KArgumentConverters, this) || [];
     }
+    get slashArgumentConverters() {
+        return Reflect.getMetadata(constants_1.KSlashArgumentConverters, this) || [];
+    }
+    get slashCommands() {
+        return Reflect.getMetadata(constants_1.KSlashCommands, this) || [];
+    }
+    get path() {
+        return Reflect.getMetadata(constants_1.KModulePath, this);
+    }
     load() { }
     unload() { }
     beforeReload() { }

package/dist/structures/Registry.d.ts

@@ -1,17 +1,27 @@
 import { CommandClient } from './CommandClient';
 import { Module } from './Module';
-import { Command } from '../command';
+import { Command, SlashArgumentConverter } from '../command';
 import { Collection } from 'discord.js';
-import { ArgumentConverter } from '../command/ArgumentConverter';
+import { ArgumentConverter } from '../command';
+import { SlashCommand } from '../slashCommand';
 export declare class Registry {
     client: CommandClient;
     constructor(client: CommandClient);
     modules: Collection<symbol, Module>;
     get commands(): Command[];
     get argumentConverters(): ArgumentConverter[];
+    get slashArgumentConverters(): SlashArgumentConverter[];
+    get slashCommands(): SlashCommand[];
     registerModule(module: Module): Module;
-    loadModulesIn(dir: string, absolute?: boolean): void;
-    loadModule(file: string, absolute?: boolean): Module;
-    unregisterModule(module: Module): Module;
-    unloadModule(module: Module): void;
+    loadModulesIn(dir: string, absolute?: boolean): Promise<void>;
+    loadModule(file: string, absolute?: boolean): Promise<Module>;
+    syncCommands(): Promise<void>;
+    unregisterModule(module: Module): Promise<Module>;
+    unloadModule(module: Module): Promise<void>;
+    reloadModule(module: Module): Promise<boolean>;
+    reloadAll(): Promise<{
+        path: string;
+        success: boolean;
+        error?: Error | undefined;
+    }[]>;
 }

package/dist/structures/Registry.js

@@ -1,4 +1,13 @@
 "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 };
 };
@@ -10,6 +19,7 @@ const path_1 = __importDefault(require("path"));
 const error_1 = require("../error");
 const discord_js_1 = require("discord.js");
 const walk_sync_1 = __importDefault(require("walk-sync"));
+const v9_1 = require("discord-api-types/v9");
 class Registry {
     constructor(client) {
         this.client = client;
@@ -29,6 +39,20 @@ class Registry {
         }
         return result;
     }
+    get slashArgumentConverters() {
+        const result = [];
+        for (const [, module] of this.modules) {
+            result.push(...module.slashArgumentConverters);
+        }
+        return result;
+    }
+    get slashCommands() {
+        const result = [];
+        for (const [, module] of this.modules) {
+            result.push(...module.slashCommands);
+        }
+        return result;
+    }
     registerModule(module) {
         this.modules.set(Symbol(module.constructor.name), module);
         const list = [];
@@ -41,53 +65,119 @@ class Registry {
         return module;
     }
     loadModulesIn(dir, absolute = false) {
-        let p = absolute ? dir : path_1.default.join(require.main.path, dir);
-        for (const i of walk_sync_1.default(p)) {
-            this.loadModule(path_1.default.join(p, i), true);
-        }
+        return __awaiter(this, void 0, void 0, function* () {
+            let p = absolute ? dir : path_1.default.join(require.main.path, dir);
+            for (const i of walk_sync_1.default(p)) {
+                yield this.loadModule(path_1.default.join(p, i), true);
+            }
+        });
     }
     loadModule(file, absolute = false) {
-        let p = absolute ? file : path_1.default.join(require.main.path, file);
-        let m;
-        try {
-            m = require(p);
-        }
-        catch (e) {
-            throw new error_1.ModuleLoadError(p);
-        }
-        if (m.loaded)
-            throw new Error('MODULE_ALREADY_LOADED');
-        if (!m.install)
-            throw new error_1.InvalidModuleError('Install function not found.');
-        const mod = m.install(this.client);
-        if (!(mod instanceof Module_1.Module))
-            throw new error_1.InvalidTargetError();
-        Reflect.defineMetadata(constants_1.KModulePath, require.resolve(p), mod);
-        this.registerModule(mod);
-        mod.load();
-        m.loaded = true;
-        return mod;
+        return __awaiter(this, void 0, void 0, function* () {
+            let p = absolute ? file : path_1.default.join(require.main.path, file);
+            let m;
+            try {
+                m = require(p);
+            }
+            catch (e) {
+                throw new error_1.ModuleLoadError(p);
+            }
+            if (m.loaded)
+                throw new Error('MODULE_ALREADY_LOADED');
+            if (!m.install)
+                throw new error_1.InvalidModuleError('Install function not found.');
+            const mod = m.install(this.client);
+            if (!(mod instanceof Module_1.Module))
+                throw new error_1.InvalidTargetError();
+            Reflect.defineMetadata(constants_1.KModulePath, require.resolve(p), mod);
+            this.registerModule(mod);
+            yield mod.load();
+            m.loaded = true;
+            return mod;
+        });
+    }
+    syncCommands() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const commands = this.slashCommands.filter((x) => !x.guild);
+            const guild = this.client.options.slashCommands.guild;
+            if (guild) {
+                const syncForGuild = (g) => __awaiter(this, void 0, void 0, function* () {
+                    yield this.client.rest.put(v9_1.Routes.applicationGuildCommands(this.client.client.application.id, g.id), {
+                        body: commands.map((x) => x.commandBuilder.toJSON()),
+                    });
+                });
+                if (typeof guild === 'string') {
+                    yield syncForGuild(yield this.client.client.guilds.fetch(guild));
+                }
+                else {
+                    for (const g of guild) {
+                        yield syncForGuild(yield this.client.client.guilds.fetch(g));
+                    }
+                }
+            }
+            else {
+                yield this.client.rest.put(v9_1.Routes.applicationCommands(this.client.client.application.id), {
+                    body: commands.map((x) => x.commandBuilder.toJSON()),
+                });
+            }
+        });
     }
     unregisterModule(module) {
-        if (Reflect.getMetadata(constants_1.KBuiltInModule, module))
-            throw new Error('Built-in modules cannot be unloaded');
-        const symbol = this.modules.findKey((x) => x === module);
-        if (!symbol)
+        return __awaiter(this, void 0, void 0, function* () {
+            if (Reflect.getMetadata(constants_1.KBuiltInModule, module))
+                throw new Error('Built-in modules cannot be unloaded');
+            const symbol = this.modules.findKey((x) => x === module);
+            if (!symbol)
+                return module;
+            yield module.unload();
+            const list = Reflect.getMetadata(constants_1.KListenerExecuteCache, module);
+            for (const listener of list) {
+                this.client.client.removeListener(listener.event, listener.execute);
+            }
+            this.modules.delete(symbol);
             return module;
-        module.unload();
-        const list = Reflect.getMetadata(constants_1.KListenerExecuteCache, module);
-        for (const listener of list) {
-            this.client.client.removeListener(listener.event, listener.execute);
-        }
-        this.modules.delete(symbol);
-        return module;
+        });
     }
     unloadModule(module) {
-        const p = Reflect.getMetadata(constants_1.KModulePath, module);
-        if (!p)
-            throw new error_1.InvalidModuleError('This module is not loaded by loadModule.');
-        this.unregisterModule(module);
-        delete require.cache[p];
+        return __awaiter(this, void 0, void 0, function* () {
+            const p = Reflect.getMetadata(constants_1.KModulePath, module);
+            if (!p)
+                throw new error_1.InvalidModuleError('This module is not loaded by loadModule.');
+            yield this.unregisterModule(module);
+            delete require.cache[p];
+        });
+    }
+    reloadModule(module) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield module.beforeReload();
+            const p = Reflect.getMetadata(constants_1.KModulePath, module);
+            yield this.unloadModule(module);
+            const mod = yield this.loadModule(p, true);
+            yield mod.afterReload();
+            return true;
+        });
+    }
+    reloadAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = [];
+            for (const [, module] of this.modules.filter((x) => !!x.path)) {
+                try {
+                    yield this.reloadModule(module);
+                    results.push({
+                        path: module.path,
+                        success: false,
+                    });
+                }
+                catch (e) {
+                    results.push({
+                        error: e,
+                        path: module.path,
+                        success: false,
+                    });
+                }
+            }
+            return results;
+        });
     }
 }
 exports.Registry = Registry;

package/dist/typings.d.ts

@@ -0,0 +1,18 @@
+import type { Command } from './command';
+import { CommandClient } from './structures';
+import { SlashCommand } from './slashCommand';
+declare module 'discord.js' {
+    interface Message {
+        data: {
+            command: Command;
+            prefix: string;
+            cts: CommandClient;
+        };
+    }
+    interface CommandInteraction {
+        data: {
+            command: SlashCommand;
+            cts: CommandClient;
+        };
+    }
+}

package/dist/typings.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "@pikokr/command.ts",
   "description": "Discord.js command framework for typescript.",
-  "version": "3.0.0-dev.a94f324",
+  "version": "3.0.0-dev.ca01eb5",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "license": "MIT",
   "devDependencies": {
+    "@discordjs/builders": "^0.6.0",
+    "@discordjs/rest": "^0.1.0-canary.0",
     "@types/lodash": "^4.14.172",
     "discord.js": "^13.1.0",
     "prettier": "^2.2.1",
@@ -14,6 +16,7 @@
   },
   "dependencies": {
     "@types/node": "^14.14.37",
+    "discord-api-types": "^0.23.1",
     "lodash": "^4.17.21",
     "reflect-metadata": "^0.1.13",
     "typescript": "^4.2.3",

package/src/builtinModules/BuiltinCommandConverters.ts

@@ -1,8 +1,16 @@
 import { BuiltInModule } from './BuiltInModule'
 import { argumentConverter } from '../command'
-import { Message } from 'discord.js'
+import { Client, GuildMember, Message, User } from 'discord.js'
+import { CommandClient } from '../structures'
 
 export class BuiltinCommandConverters extends BuiltInModule {
+  client: Client
+
+  constructor(private cts: CommandClient) {
+    super()
+    this.client = cts.client
+  }
+
   @argumentConverter(Message, false)
   message(msg: Message) {
     return msg
@@ -12,4 +20,37 @@ export class BuiltinCommandConverters extends BuiltInModule {
   string(msg: Message, arg: string) {
     return arg
   }
+
+  getUserIDByMention(mention: string): `${bigint}` | undefined {
+    if (!mention) return
+    if (mention.startsWith('<@') && mention.endsWith('>')) {
+      mention = mention.slice(2, -1)
+      if (mention.startsWith('!')) {
+        mention = mention.slice(1)
+      }
+      return mention as `${bigint}`
+    }
+  }
+
+  @argumentConverter(User)
+  user(value: string): User | null {
+    const id = this.getUserIDByMention(value)
+    if (!id) return null
+    const user = this.client.users.cache.get(id)
+    return user || null
+  }
+
+  @argumentConverter(GuildMember)
+  member(value: string, msg: Message): GuildMember | undefined {
+    const id = this.getUserIDByMention(value)
+    if (!id) return
+    const user = msg.guild?.members.cache.get(id)
+    return user || undefined
+  }
+
+  @argumentConverter(Number)
+  number(value: string) {
+    const n = Number(value)
+    return isNaN(n) ? undefined : n
+  }
 }

package/src/builtinModules/BuiltinSlashCommandConverters.ts

@@ -0,0 +1,18 @@
+import { BuiltInModule } from './BuiltInModule'
+import { slashArgumentConverter } from '../command'
+import { Client, CommandInteraction } from 'discord.js'
+import { CommandClient } from '../structures'
+
+export class BuiltinSlashCommandConverters extends BuiltInModule {
+  client: Client
+
+  constructor(private cts: CommandClient) {
+    super()
+    this.client = cts.client
+  }
+
+  @slashArgumentConverter(CommandInteraction)
+  message(interaction: CommandInteraction) {
+    return interaction
+  }
+}

package/src/builtinModules/CommandHandler.ts

@@ -1,14 +1,14 @@
 import { BuiltInModule } from './BuiltInModule'
 import { Registry } from '../structures'
 import { listener } from '../listener'
-import { Message } from 'discord.js'
+import { CommandInteraction, GuildMember, Interaction, Message, Role, User } from 'discord.js'
 import { CommandClient } from '../structures'
 import { Command } from '../command'
-import { ArgumentConverterNotFound, ArgumentNotProvided } from '../error'
+import { ArgumentConverterNotFound, ArgumentNotProvided, CommandCheckFailed, SlashArgumentConverterNotFound, SlashCommandCheckFailed } from '../error'
 import { CommandNotFound } from '../error/CommandNotFound'
 
 export class CommandHandler extends BuiltInModule {
-  private client: CommandClient
+  private readonly client: CommandClient
 
   constructor(private registry: Registry) {
     super()
@@ -17,87 +17,179 @@ export class CommandHandler extends BuiltInModule {
 
   @listener('messageCreate')
   async message(msg: Message) {
-    const error = (error: Error) =>
-      this.client.client.emit('commandError', error, msg)
-
-    const prefixList: string[] | string =
-      typeof this.client.options.command.prefix === 'string'
-        ? this.client.options.command.prefix
-        : typeof this.client.options.command.prefix === 'function'
-        ? await this.client.options.command.prefix(msg)
-        : this.client.options.command.prefix
-    let prefix: string
-    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
-    }
+    const error = (error: Error) => this.client.client.emit('commandError', error, msg)
+
+    try {
+      const prefixList: string[] | string =
+        typeof this.client.options.command.prefix === 'string'
+          ? this.client.options.command.prefix
+          : typeof this.client.options.command.prefix === 'function'
+          ? await this.client.options.command.prefix(msg)
+          : this.client.options.command.prefix
+      let prefix: string
+      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
+      if (!msg.content.startsWith(prefix)) return
 
-    const args = msg.content.slice(prefix.length).split(' ')
+      const args = msg.content.slice(prefix.length).split(' ')
 
-    const command = args.shift()
+      const command = args.shift()
 
-    if (!command) return
+      if (!command) return
+
+      let cmd: Command | null = null
+
+      for (const c of this.registry.commands) {
+        if (c.name === command) {
+          cmd = c
+          break
+        }
+        if ((typeof c.aliases === 'function' ? await c.aliases(msg) : c.aliases).includes(command)) {
+          cmd = c
+          break
+        }
+      }
 
-    let cmd: Command | null = null
+      if (!cmd) return error(new CommandNotFound(command))
 
-    for (const c of this.registry.commands) {
-      if (c.name === command) {
-        cmd = c
-        break
+      msg.data = {
+        cts: this.client,
+        command: cmd,
+        prefix: prefix,
       }
-      if (
-        (typeof c.aliases === 'function'
-          ? await c.aliases(msg)
-          : c.aliases
-        ).includes(command)
-      ) {
-        cmd = c
-        break
+
+      const module = this.registry.modules.find((x) => x.commands.includes(cmd!))
+
+      if (!module) return
+
+      const argList: any[] = []
+
+      for (const check of cmd.checks) {
+        if (!(await check(msg))) return error(new 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 ArgumentConverterNotFound(argType, msg))
+
+        if (converter.withoutParameter) {
+          argList.push(await converter.execute(module, msg))
+          continue
+        }
+        const arg = args.shift()
+        if (argType.optional && !arg) {
+          break
+        }
+        if (!arg) {
+          return error(new ArgumentNotProvided(i, cmd, msg))
+        }
+        const executed = await converter.execute(module, msg, arg)
+        if (!executed === undefined) {
+          return error(new ArgumentNotProvided(i, cmd, msg))
+        }
+        argList.push(executed)
       }
+
+      try {
+        await cmd.execute(module, argList)
+      } catch (e: any) {
+        return error(e)
+      }
+    } catch (e) {
+      return error(e)
     }
+  }
 
-    if (!cmd) return error(new CommandNotFound(command))
+  private async command(i: CommandInteraction) {
+    const error = (error: Error) => this.client.client.emit('slashCommandError', error, i)
+    try {
+      const cmd = this.registry.slashCommands.find((x) => x.commandBuilder.name === i.commandName)
 
-    const module = this.registry.modules.find((x) => x.commands.includes(cmd!))
+      const module = this.registry.modules.find((x) => x.slashCommands.includes(cmd!))
 
-    if (!module) return
+      if (!module) return
 
-    const argList: any[] = []
+      const argList: any[] = []
 
-    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 (!cmd)
+        return i.reply({
+          content: 'Unknown command.',
+          ephemeral: true,
+        })
 
-      if (!converter) return error(new ArgumentConverterNotFound(argType, msg))
+      i.data = {
+        cts: this.client,
+        command: cmd,
+      }
 
-      if (converter.withoutParameter) {
-        argList.push(await converter.execute(module, msg))
-        continue
+      for (const check of cmd.checks) {
+        if (!(await check(i))) return error(new SlashCommandCheckFailed(i, cmd))
       }
-      const arg = args.shift()
-      if (argType.optional && !arg) {
-        break
+
+      for (let j = 0; j < cmd.params.length; j++) {
+        const argType = cmd.params[j]
+        const converter = this.registry.slashArgumentConverters.find((x) => x.type === argType.type)
+
+        if (argType.name) {
+          switch (argType.type) {
+            case String:
+              argList.push(i.options.getString(argType.name, false) || undefined)
+              break
+            case Role:
+              argList.push(i.options.getRole(argType.name, false) || undefined)
+              break
+            case User:
+              argList.push(i.options.getUser(argType.name, false) || undefined)
+              break
+            case GuildMember:
+              argList.push(i.options.getMember(argType.name, false) || undefined)
+              break
+            case Boolean:
+              argList.push(i.options.getBoolean(argType.name, false) || undefined)
+              break
+            case Number:
+              argList.push(i.options.getNumber(argType.name, false) || i.options.getInteger(argType.name, false) || undefined)
+          }
+          continue
+        }
+
+        if (!converter) return error(new SlashArgumentConverterNotFound(argType, i))
+
+        argList.push(await converter.execute(module, i))
       }
-      if (!arg) {
-        return error(new ArgumentNotProvided(i, msg))
+
+      try {
+        await cmd.execute(module, argList)
+      } catch (e: any) {
+        return error(e)
       }
-      argList.push(await converter.execute(module, msg, arg))
+    } catch (e) {
+      return error(e)
     }
+  }
 
-    try {
-      cmd.execute(module, argList)
-    } catch (e: any) {
-      return error(e)
+  @listener('interactionCreate')
+  async interaction(i: Interaction) {
+    if (i.isCommand()) {
+      await this.command(i)
     }
   }
 }

package/src/builtinModules/index.ts

@@ -1,2 +1,3 @@
 export * from './CommandHandler'
 export * from './BuiltinCommandConverters'
+export * from './BuiltinSlashCommandConverters'

package/src/command/ArgumentConverter.ts

@@ -1,14 +1,18 @@
 import { Module } from '../structures'
-import { Message } from 'discord.js'
+import { CommandInteraction, Message } from 'discord.js'
 
 export class ArgumentConverter {
   execute(module: Module, msg: Message, arg?: string) {
     return this.run.apply(module, [msg, arg])
   }
 
-  constructor(
-    public type: object,
-    private run: Function,
-    public withoutParameter: boolean,
-  ) {}
+  constructor(public type: object, private run: Function, public withoutParameter: boolean) {}
+}
+
+export class SlashArgumentConverter {
+  execute(module: Module, interaction: CommandInteraction) {
+    return this.run.apply(module, [interaction])
+  }
+
+  constructor(public type: object, private run: Function) {}
 }