@pikokr/command.ts 4.0.5 → 5.0.0-dev.144e990

package/src/applicationCommand/decorator.ts

@@ -1,62 +0,0 @@
-/*
- * Copyright (c) 2022 pikokr. Licensed under the MIT license
- */
-
-import { ApplicationCommandDataResolvable, Collection, Snowflake } from 'discord.js'
-import { checkTarget } from '../utils'
-import { KSlashCommandOptions, KApplicationCommands } from '../constants'
-import { Module } from '../structures'
-import { AppCommand } from './AppCommand'
-
-type ApplicationCommandOptions = {
-  guild: Snowflake | Snowflake[]
-  optionTypes?: any[]
-}
-
-export const applicationCommand = (opt: Partial<ApplicationCommandOptions> & { command: ApplicationCommandDataResolvable }) => {
-  return (
-    target: Object,
-    propertyKey: string,
-    // descriptor: TypedPropertyDescriptor<any>,
-  ) => {
-    checkTarget(target)
-
-    let properties: AppCommand[] = Reflect.getMetadata(KApplicationCommands, target)
-
-    const params: any[] = opt.optionTypes ?? Reflect.getMetadata('design:paramtypes', target, propertyKey)
-
-    const options: Collection<number, string> = Reflect.getMetadata(KSlashCommandOptions, target, propertyKey) || new Collection<number, string>()
-
-    const command = new AppCommand(
-      opt.command,
-      Reflect.get(target, propertyKey),
-      target as Module,
-      params.map((x, i) => ({
-        type: x,
-        name: options.get(i),
-      })),
-      opt.guild,
-      propertyKey,
-    )
-
-    if (properties) {
-      properties.push(command)
-    } else {
-      properties = [command]
-      Reflect.defineMetadata(KApplicationCommands, properties, target)
-    }
-  }
-}
-
-export const option = (key: string): ParameterDecorator => (target, propertyKey, parameterIndex) => {
-  checkTarget(target)
-
-  let properties: Collection<number, string> = Reflect.getMetadata(KSlashCommandOptions, target, propertyKey)
-
-  if (!properties) {
-    properties = new Collection<number, string>()
-    Reflect.defineMetadata(KSlashCommandOptions, properties, target, propertyKey)
-  }
-
-  properties.set(parameterIndex, key)
-}

package/src/builtinModules/BuiltInModule.ts

@@ -1,13 +0,0 @@
-/*
- * Copyright (c) 2022 pikokr. Licensed under the MIT license
- */
-
-import { Module } from '../structures'
-import { KBuiltInModule } from '../constants'
-
-export class BuiltInModule extends Module {
-  constructor() {
-    super()
-    Reflect.defineMetadata(KBuiltInModule, true, this)
-  }
-}

package/src/builtinModules/BuiltinApplicationCommandConverters.ts

@@ -1,16 +0,0 @@
-/*
- * Copyright (c) 2022 pikokr. Licensed under the MIT license
- */
-
-import { BuiltInModule } from './BuiltInModule'
-import { Client } from 'discord.js'
-import { CommandClient } from '../structures'
-
-export class BuiltinApplicationCommandConverters extends BuiltInModule {
-  client: Client
-
-  constructor(private cts: CommandClient) {
-    super()
-    this.client = cts.client
-  }
-}

package/src/builtinModules/BuiltinCommandConverters.ts

@@ -1,87 +0,0 @@
-/*
- * Copyright (c) 2022 pikokr. Licensed under the MIT license
- */
-
-import { BuiltInModule } from './BuiltInModule'
-import { argumentConverter } from '../command'
-import { Client, GuildMember, Message, User, Role } 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
-  }
-
-  @argumentConverter(String)
-  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(msg: Message, value: string): User | null {
-    let user = this.client.users.cache.get(value)
-    if (user) return user
-    user = this.client.users.cache.find((x) => x.tag === value || x.username === value)
-    if (user) return user
-    const id = this.getUserIDByMention(value)
-    if (!id) return null
-    user = this.client.users.cache.get(id)
-    return user || null
-  }
-
-  @argumentConverter(GuildMember)
-  member(msg: Message, value: string): GuildMember | undefined {
-    let user = msg.guild?.members.cache.get(value)
-    if (!user) return user
-    user = msg.guild?.members.cache.find((x) => x.user.tag === value)
-    if (user) return user
-    const id = this.getUserIDByMention(value)
-    if (!id) return
-    user = msg.guild?.members.cache.get(id)
-    return user || undefined
-  }
-
-  @argumentConverter(Number)
-  number(msg: Message, value: string) {
-    const n = Number(value)
-    return isNaN(n) ? undefined : n
-  }
-
-  getRoleIDByMention(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(Role)
-  role(msg: Message, value: string): Role | undefined {
-    const id = this.getRoleIDByMention(value)
-    if (!id) return
-    const role = msg.guild?.roles.cache.get(id)
-    return role || undefined
-  }
-}

package/src/builtinModules/CommandHandler.ts

@@ -1,363 +0,0 @@
-/*
- * Copyright (c) 2022 pikokr. Licensed under the MIT license
- */
-
-import { BuiltInModule } from './BuiltInModule'
-import { Registry } from '../structures'
-import { listener } from '../listener'
-import {
-  CommandInteraction,
-  CommandInteractionOptionResolver,
-  GuildMember,
-  Interaction,
-  Message,
-  MessageComponentInteraction,
-  MessageContextMenuInteraction,
-  Role,
-  User,
-  UserContextMenuInteraction,
-} from 'discord.js'
-import { CommandClient } from '../structures'
-import { Command } from '../command'
-import { ArgumentConverterNotFound, ArgumentNotProvided, CommandCheckFailed, ApplicationCommandArgumentConverterNotFound, ApplicationCommandCheckFailed } from '../error'
-import { CommandNotFound } from '../error/CommandNotFound'
-import { SlashCommandGlobalCheckError } from '../error/checks/SlashCommandGlobalCheckError'
-import { MessageComponentHandler } from '../messageComponents/base'
-
-export class CommandHandler extends BuiltInModule {
-  private readonly client: CommandClient
-
-  constructor(private registry: Registry) {
-    super()
-    this.client = registry.client
-  }
-
-  // region message command handler
-  @listener('messageCreate')
-  async message(msg: Message) {
-    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
-
-      const args = msg.content.slice(prefix.length).split(' ')
-
-      const command = args.shift()
-
-      if (!command) return
-
-      let cmd: Command | null = null
-
-      for (const c of this.registry.commands) {
-        const aliases = typeof c.aliases === 'function' ? await c.aliases(msg) : c.aliases
-        if ([...aliases, c.name].some((x) => x === command)) {
-          cmd = c
-          break
-        }
-      }
-
-      msg.data = {
-        cts: this.client,
-        command: cmd,
-        prefix: prefix,
-      }
-
-      if (!(await this.client.options.command.check(msg))) {
-        return
-      }
-
-      if (!cmd) return error(new CommandNotFound(command, msg, args))
-
-      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(' ')
-          argList.push(i)
-          break
-        }
-
-        if (!converter) return error(new ArgumentConverterNotFound(argType, msg))
-
-        const converterModule = this.registry.modules.find((x) => x.argumentConverters.includes(converter))
-
-        if (!converterModule) return error(new ArgumentConverterNotFound(argType, msg))
-
-        if (converter.withoutParameter) {
-          argList.push(await converter.execute(converterModule, 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(converterModule, msg, arg)
-        if ((executed === undefined || executed === null) && !argType.optional) {
-          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)
-    }
-  }
-  // endregion
-
-  // region slash command handler
-  private async command(i: CommandInteraction) {
-    const error = (error: Error) => this.client.client.emit('applicationCommandError', error, i)
-    try {
-      const cmd = this.registry.applicationCommands.find((x) => x.command.type === 'CHAT_INPUT' && x.command.name === i.commandName)
-
-      if (!cmd) return
-
-      const module = this.registry.modules.find((x) => x.applicationCommands.includes(cmd))
-
-      if (!module) return
-
-      const argList: any[] = []
-
-      i.data = {
-        cts: this.client,
-        command: cmd,
-      }
-
-      if (!(await this.client.options.slashCommands.check(i))) {
-        return error(new SlashCommandGlobalCheckError(i))
-      }
-      for (const check of cmd.checks) {
-        if (!(await check(i))) return error(new ApplicationCommandCheckFailed(i, cmd))
-      }
-
-      for (let j = 0; j < cmd.params.length; j++) {
-        const argType = cmd.params[j]
-        const converter = this.registry.applicationCommandArgumentConverters.find((x) => x.type === argType.type)
-
-        if (argType.type === CommandInteraction) {
-          argList.push(i)
-          continue
-        }
-
-        if (argType.type === CommandInteractionOptionResolver) {
-          argList.push(i.options)
-          continue
-        }
-
-        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:
-              const opt = i.options.get(argType.name, false)
-              if (!opt) {
-                argList.push(undefined)
-                break
-              }
-              if (opt.type == 'NUMBER') {
-                argList.push(i.options.getNumber(argType.name, false) ?? undefined)
-                break
-              }
-              if (opt.type == 'INTEGER') {
-                argList.push(i.options.getInteger(argType.name, false) ?? undefined)
-                break
-              }
-          }
-          continue
-        }
-
-        if (!converter) return error(new ApplicationCommandArgumentConverterNotFound(argType, i))
-
-        argList.push(await converter.execute(module, i))
-      }
-
-      await cmd.execute(module, argList)
-    } catch (e) {
-      return error(e)
-    }
-  }
-  // endregion
-
-  private async messageComponent(i: MessageComponentInteraction) {
-    const error = (e: any) => this.client.client.emit('messageComponentError', e)
-
-    try {
-      const handlers: MessageComponentHandler[] = []
-
-      for (const handler of this.registry.messageComponentHandlers) {
-        if (handler.componentId === handler.componentId && handler.componentType === i.componentType) {
-          handlers.push(handler)
-        }
-      }
-
-      for (const handler of handlers) {
-        const module = this.registry.modules.find((x) => x.messageComponentHandlers.includes(handler))
-        if (!module) continue
-        await handler.run(module, i)
-      }
-    } catch (e) {
-      error(e)
-    }
-  }
-
-  private async userContextMenu(i: UserContextMenuInteraction) {
-    const error = (error: Error) => this.client.client.emit('applicationCommandError', error, i)
-    try {
-      const cmd = this.registry.applicationCommands.find((x) => x.command.type === 'USER' && x.command.name === i.commandName)
-
-      if (!cmd) return
-
-      const module = this.registry.modules.find((x) => x.applicationCommands.includes(cmd))
-
-      if (!module) return
-
-      i.data = {
-        cts: this.client,
-        command: cmd,
-      }
-
-      for (const check of cmd.checks) {
-        if (!(await check(i))) return error(new ApplicationCommandCheckFailed(i, cmd))
-      }
-
-      let argList: any[] = []
-
-      for (let j = 0; j < cmd.params.length; j++) {
-        const argType = cmd.params[j]
-        const converter = this.registry.applicationCommandArgumentConverters.find((x) => x.type === argType.type)
-
-        if (argType.type === UserContextMenuInteraction) {
-          argList.push(i)
-          continue
-        }
-
-        if (!converter) return error(new ApplicationCommandArgumentConverterNotFound(argType, i))
-
-        argList.push(await converter.execute(module, i))
-      }
-
-      await cmd.execute(module, argList)
-    } catch (e) {
-      return error(e)
-    }
-  }
-
-  private async messageContextMenu(i: MessageContextMenuInteraction) {
-    const error = (error: Error) => this.client.client.emit('applicationCommandError', error, i)
-    try {
-      const cmd = this.registry.applicationCommands.find((x) => x.command.type === 'MESSAGE' && x.command.name === i.commandName)
-
-      if (!cmd) return
-
-      const module = this.registry.modules.find((x) => x.applicationCommands.includes(cmd))
-
-      if (!module) return
-
-      i.data = {
-        cts: this.client,
-        command: cmd,
-      }
-
-      for (const check of cmd.checks) {
-        if (!(await check(i))) return error(new ApplicationCommandCheckFailed(i, cmd))
-      }
-
-      let argList: any[] = []
-
-      for (let j = 0; j < cmd.params.length; j++) {
-        const argType = cmd.params[j]
-        const converter = this.registry.applicationCommandArgumentConverters.find((x) => x.type === argType.type)
-
-        if (argType.type === MessageContextMenuInteraction) {
-          argList.push(i)
-          continue
-        }
-
-        if (!converter) return error(new ApplicationCommandArgumentConverterNotFound(argType, i))
-
-        argList.push(await converter.execute(module, i))
-      }
-
-      await cmd.execute(module, argList)
-    } catch (e) {
-      return error(e)
-    }
-  }
-
-  @listener('interactionCreate')
-  async interaction(i: Interaction) {
-    const error = (e: any) => this.client.client.emit('interactionError', e, i)
-
-    try {
-      await this.client.options.applicationCommands.beforeRunCheck(i)
-      if (i.isCommand()) {
-        await this.command(i)
-        return
-      }
-      if (i.isMessageComponent()) {
-        await this.messageComponent(i)
-        return
-      }
-      if (i.isMessageContextMenu()) {
-        await this.messageContextMenu(i)
-        return
-      }
-      if (i.isUserContextMenu()) {
-        await this.userContextMenu(i)
-        return
-      }
-    } catch (e) {
-      return error(e)
-    }
-  }
-}

package/src/builtinModules/index.ts

@@ -1,7 +0,0 @@
-/*
- * Copyright (c) 2022 pikokr. Licensed under the MIT license
- */
-
-export * from './CommandHandler'
-export * from './BuiltinCommandConverters'
-export * from './BuiltinApplicationCommandConverters'

package/src/command/ArgumentConverter.ts

@@ -1,22 +0,0 @@
-/*
- * Copyright (c) 2022 pikokr. Licensed under the MIT license
- */
-
-import { Module } from '../structures'
-import { CommandInteraction, ContextMenuInteraction, 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) {}
-}
-
-export class ApplicationCommandArgumentConverter {
-  execute(module: Module, interaction: CommandInteraction | ContextMenuInteraction) {
-    return this.run.apply(module, [interaction])
-  }
-
-  constructor(public type: object, private run: Function) {}
-}

package/src/command/Command.ts

@@ -1,35 +0,0 @@
-/*
- * Copyright (c) 2022 pikokr. Licensed under the MIT license
- */
-
-import { Module } from '../structures'
-import { CommandInteraction, ContextMenuInteraction, Message, MessageComponentInteraction } from 'discord.js'
-import { KCommandChecks } from '../constants'
-
-export type Argument = {
-  optional: boolean
-  type: any
-  rest: boolean
-}
-
-export type CheckFunction = (msg: Message) => boolean | Promise<boolean>
-export type ApplicationCommandCheckFunction = (i: CommandInteraction | MessageComponentInteraction | ContextMenuInteraction) => boolean | Promise<boolean>
-
-export class Command {
-  execute(module: Module, args: any[]) {
-    return this.run.apply(module, args)
-  }
-
-  get checks(): CheckFunction[] {
-    return Reflect.getMetadata(KCommandChecks, this.module, this.key) || []
-  }
-
-  constructor(
-    private run: Function,
-    public argTypes: Argument[],
-    public name: string,
-    public aliases: string[] | ((msg: Message) => string[] | Promise<string[]>),
-    public module: Module,
-    public key: symbol | string,
-  ) {}
-}

package/src/command/cooldown/adapter.ts

@@ -1,22 +0,0 @@
-/*
- * Copyright (c) 2022 pikokr. Licensed under the MIT license
- */
-
-import { Collection } from 'discord.js'
-
-export interface CoolDownAdapter {
-  get(id: string): Promise<number | undefined>
-  set(id: string, value: number): Promise<void>
-}
-
-export class DefaultCoolDownAdapter implements CoolDownAdapter {
-  map = new Collection<string, number>()
-  async get(id: string): Promise<number | undefined> {
-    return this.map.get(id)
-  }
-
-  async set(id: string, value: number) {
-    this.map.set(id, value)
-    return
-  }
-}

package/src/command/cooldown/decorator.ts

@@ -1,67 +0,0 @@
-/*
- * Copyright (c) 2022 pikokr. Licensed under the MIT license
- */
-
-import { createCheckDecorator } from '../utils'
-import { CoolDownType } from './type'
-import { DMChannel, GuildMember, TextChannel } from 'discord.js'
-import { CoolDownError } from './error'
-
-export const coolDown = (type: CoolDownType, seconds: number) =>
-  createCheckDecorator(
-    async (msg) => {
-      const a = msg.data.cts.coolDownAdapter
-      const getKey = (): string => {
-        switch (type) {
-          case CoolDownType.USER:
-            return msg.author.id
-          case CoolDownType.GUILD:
-            return (msg.guild || msg.author).id
-          case CoolDownType.CHANNEL:
-            return msg.channel.id
-          case CoolDownType.MEMBER:
-            return `${msg.guild?.id}.${msg.author.id}`
-          case CoolDownType.ROLE:
-            return (msg.channel instanceof DMChannel ? msg.channel : msg.member!.roles.highest).id
-          case CoolDownType.CATEGORY:
-            return ((msg.channel as TextChannel).parent || msg.channel).id
-        }
-      }
-      const key = getKey() + '-command-' + msg.data.command?.name
-      const data = await a.get(key)
-      const now = Date.now()
-      if (!data || !(now - data < seconds * 1000)) {
-        await a.set(key, now)
-        return true
-      }
-      throw new CoolDownError(new Date(data + seconds * 1000))
-    },
-    async (i) => {
-      if (i.isMessageComponent()) return true
-      const a = i.data.cts.coolDownAdapter
-      const getKey = (): string => {
-        switch (type) {
-          case CoolDownType.USER:
-            return i.user.id + '.user'
-          case CoolDownType.GUILD:
-            return (i.guild || i.user).id + '.guild'
-          case CoolDownType.CHANNEL:
-            return i.channel!.id + '.channel'
-          case CoolDownType.MEMBER:
-            return `${i.guild?.id}.${i.user.id}`
-          case CoolDownType.ROLE:
-            return (i.channel instanceof DMChannel ? i.channel : (i.member as GuildMember)!.roles.highest).id + '.role'
-          case CoolDownType.CATEGORY:
-            return ((i.channel as TextChannel).parent || i.channel!).id + '.category'
-        }
-      }
-      const key = getKey() + '-appCommand-' + i.commandName
-      const data = await a.get(key)
-      const now = Date.now()
-      if (!data || !(now - data < seconds * 1000)) {
-        await a.set(key, now)
-        return true
-      }
-      throw new CoolDownError(new Date(data + seconds * 1000))
-    },
-  )