@pikokr/command.ts 5.0.0-dev.6057824 → 5.0.0-dev.610cc76

package/src/core/utils/checks.ts

@@ -0,0 +1,27 @@
+/*
+* File: checks.ts
+* 
+* Copyright (c) 2022-2022 pikokr
+* 
+* Licensed under MIT License. Please see more defails in LICENSE file.
+*/
+
+import { BaseInteraction, Interaction, Message } from 'discord.js'
+import { createComponentHook } from '../hooks'
+import { ComponentHookFn } from '../hooks/componentHook'
+import { CommandClient } from '../structures'
+import { OwnerOnlyError } from './errors'
+
+export const createCheckDecorator = (fn: ComponentHookFn) => createComponentHook('beforeCall', fn)
+
+export const ownerOnly = createCheckDecorator(async (client: CommandClient, i: Interaction | Message) => {
+  let isOwner = false
+
+  if (i instanceof BaseInteraction) {
+    isOwner = client.owners.has(i.user.id)
+  } else if (i instanceof Message) {
+    isOwner = client.owners.has(i.author.id)
+  }
+
+  if (!isOwner) throw new OwnerOnlyError()
+})

package/src/core/utils/errors.ts

@@ -0,0 +1,9 @@
+/*
+* File: errors.ts
+* 
+* Copyright (c) 2022-2022 pikokr
+* 
+* Licensed under MIT License. Please see more defails in LICENSE file.
+*/
+
+export class OwnerOnlyError {}

package/src/core/utils/index.ts

@@ -0,0 +1,10 @@
+/*
+* File: index.ts
+* 
+* Copyright (c) 2022-2022 pikokr
+* 
+* Licensed under MIT License. Please see more defails in LICENSE file.
+*/
+
+export * from './checks'
+export * from './errors'

package/src/index.ts

@@ -1,10 +1,11 @@
-/*
- * File: index.ts
- *
- * Copyright (c) 2022-2022 pikokr
- *
- * Licensed under MIT License. Please see more defails in LICENSE file.
- */
-
-export * from './core'
-export * from './applicationCommand'
+/*
+* File: index.ts
+* 
+* Copyright (c) 2022-2022 pikokr
+* 
+* Licensed under MIT License. Please see more defails in LICENSE file.
+*/
+
+export * from './core'
+export * from './applicationCommand'
+export * from './textCommand'

package/src/textCommand/TextCommand.ts

@@ -0,0 +1,20 @@
+/*
+* File: TextCommand.ts
+* 
+* Copyright (c) 2022-2022 pikokr
+* 
+* Licensed under MIT License. Please see more defails in LICENSE file.
+*/
+
+import { createComponentDecorator } from '../core/components/decoratorCreator'
+import { BaseComponent } from '../core/components/BaseComponent'
+
+type TextCommandOptions = {
+  name: string
+  aliases?: string
+  description?: string
+}
+
+export class TextCommandComponent extends BaseComponent<TextCommandOptions> {}
+
+export const command = createComponentDecorator(TextCommandComponent)

package/src/textCommand/TextCommandExtension.ts

@@ -0,0 +1,128 @@
+/*
+* File: TextCommandExtension.ts
+* 
+* Copyright (c) 2022-2022 pikokr
+* 
+* Licensed under MIT License. Please see more defails in LICENSE file.
+*/
+
+import { listener } from '../core/listener'
+import { Message } from 'discord.js'
+import { CTSExtension } from '../core/extensions/CTSExtension'
+import { TextCommandComponent } from './TextCommand'
+import { TextCommandRestOption } from './parameters'
+import { argConverter } from '../core'
+
+export type TextCommandConfig = {
+  prefix: string | string[] | ((msg: Message) => Promise<string | string[]> | string | string[])
+}
+
+export class TextCommandExtension extends CTSExtension {
+  constructor(private config: TextCommandConfig) {
+    super()
+  }
+
+  private async processPrefix(msg: Message): Promise<number | null> {
+    const content = msg.content
+    let prefix = this.config.prefix
+
+    if (typeof prefix === 'function') {
+      prefix = await prefix(msg)
+    }
+
+    if (typeof prefix === 'string') {
+      if (content.startsWith(prefix)) return prefix.length
+      return null
+    }
+
+    if (prefix instanceof Array) {
+      const p = prefix.find((x) => content.startsWith(x))
+
+      if (p) return p.length
+      return null
+    }
+
+    return null
+  }
+
+  @listener({ event: 'messageCreate', emitter: 'discord' })
+  private async messageCreate(msg: Message) {
+    const startIndex = await this.processPrefix(msg)
+
+    if (!startIndex) return
+
+    const content = msg.content.slice(startIndex)
+
+    const commands: TextCommandComponent[] = []
+
+    const extensions = new Map<TextCommandComponent, object>()
+
+    for (const ext of this.commandClient.registry.extensions) {
+      for (const cmd of this.commandClient.registry.getComponentsWithType(ext, TextCommandComponent)) {
+        commands.push(cmd)
+        extensions.set(cmd, ext)
+      }
+    }
+
+    let commandNameLength = 0
+
+    const command = commands.find((x) => {
+      const names = [x.options.name]
+
+      if (x.options.aliases) {
+        names.push(...x.options.aliases)
+      }
+
+      for (const name of names) {
+        if (content.startsWith(name)) {
+          if (content.length === name.length) {
+            commandNameLength = name.length
+            return true
+          }
+          commandNameLength = name.length
+          return content.startsWith(name + ' ')
+        }
+      }
+
+      return false
+    })
+
+    if (!command) return
+
+    const ext = extensions.get(command)
+
+    if (!ext) return
+
+    const args: unknown[] = []
+
+    let argStrings = content.slice(commandNameLength + 1).split(/ /g)
+
+    await this.convertArguments(TextCommandComponent, args, command.argTypes, async (arg, i, converter) => {
+      if (converter.options.parameterless) return [msg]
+
+      if (arg.decorators.find((x) => x.constructor === TextCommandRestOption)) {
+        const text = argStrings.join(' ')
+        argStrings = []
+        return [text, msg]
+      }
+      return [argStrings.shift(), msg]
+    })
+
+    await command.execute(ext, args, [msg])
+  }
+
+  @argConverter({ component: TextCommandComponent, type: Message, parameterless: true })
+  async mesage(msg: Message) {
+    return msg
+  }
+
+  @argConverter({ component: TextCommandComponent, type: String })
+  async str(value: string) {
+    return value
+  }
+
+  @argConverter({ component: TextCommandComponent, type: Number })
+  async num(value: string) {
+    return Number(value)
+  }
+}

package/src/textCommand/index.ts

@@ -0,0 +1,11 @@
+/*
+* File: index.ts
+* 
+* Copyright (c) 2022-2022 pikokr
+* 
+* Licensed under MIT License. Please see more defails in LICENSE file.
+*/
+
+export * from './TextCommand'
+export type { TextCommandConfig } from './TextCommandExtension'
+export * from './parameters'

package/src/textCommand/parameters.ts

@@ -0,0 +1,14 @@
+/*
+ * File: parameters.ts
+ *
+ * Copyright (c) 2022-2022 pikokr
+ *
+ * Licensed under MIT License. Please see more defails in LICENSE file.
+ */
+
+import { ComponentArgumentDecorator } from '../core'
+import { createArgumentDecorator } from '../core'
+
+export class TextCommandRestOption extends ComponentArgumentDecorator<void> {}
+
+export const rest = createArgumentDecorator(TextCommandRestOption)

package/test/index.ts

@@ -1,10 +1,16 @@
-import { ApplicationCommandOptionType, ApplicationCommandType, Client } from 'discord.js'
-import { applicationCommand, CommandClient, moduleHook, option, Registry } from '../src'
-import { listener } from '../src/core/listener'
+/*
+ * File: index.ts
+ *
+ * Copyright (c) 2022-2022 pikokr
+ *
+ * Licensed under MIT License. Please see more defails in LICENSE file.
+ */
+
+import { ApplicationCommandOptionType, ApplicationCommandType, ChatInputCommandInteraction, Client, Message } from 'discord.js'
+import { applicationCommand, CommandClient, moduleHook, option, ownerOnly, listener, Extension, command, rest } from '../src'
 import 'dotenv/config'
 import { Logger } from 'tslog'
 import chalk from 'chalk'
-import { Extension } from '../src/core/extensions'
 
 class Test extends Extension {
   @applicationCommand({
@@ -12,8 +18,11 @@ class Test extends Extension {
     name: 'test',
     description: 'wow this is test',
   })
-  async testCommand() {}
+  async testCommand(i: ChatInputCommandInteraction) {
+    i.reply('Wow')
+  }
 
+  @ownerOnly
   @applicationCommand({
     type: ApplicationCommandType.ChatInput,
     name: 'test2',
@@ -24,9 +33,13 @@ class Test extends Extension {
       name: 'sans',
       description: '와',
       type: ApplicationCommandOptionType.String,
+      required: true,
     })
     wa: string,
-  ) {}
+    i: ChatInputCommandInteraction,
+  ) {
+    i.reply(wa)
+  }
 
   @moduleHook('load')
   load() {
@@ -39,14 +52,21 @@ class Test extends Extension {
   }
 
   @listener({ event: 'ready' })
-  testEvent() {
+  async testEvent() {
     this.logger.info(`Login: ${chalk.green(client.user!.tag)}`)
+    await this.commandClient.fetchOwners()
+  }
+
+  @command({ name: 'test' })
+  async test(msg: Message, @rest() sans: string) {
+    console.log(sans)
+    await msg.reply('Wow')
   }
 }
 
 const ext = new Test()
 
-const client = new Client({ intents: [] })
+const client = new Client({ intents: ['GuildMessages', 'MessageContent', 'DirectMessages', 'Guilds'] })
 
 const logger = new Logger({ dateTimeTimezone: Intl.DateTimeFormat().resolvedOptions().timeZone })
 
@@ -59,6 +79,10 @@ const run = async () => {
     guilds: ['832938554438844438'],
   })
 
+  await cc.enableTextCommandsExtension({
+    prefix: '.',
+  })
+
   await registry.registerModule(ext)
 
   await client.login(process.env.TOKEN)

package/tsup.config.ts

@@ -1,11 +1,11 @@
-/*
- * File: tsup.config.ts
- *
- * Copyright (c) 2022-2022 pikokr
- *
- * Licensed under MIT License. Please see more defails in LICENSE file.
- */
-
+/*
+* File: tsup.config.ts
+* 
+* Copyright (c) 2022-2022 pikokr
+* 
+* Licensed under MIT License. Please see more defails in LICENSE file.
+*/
+
 import { defineConfig } from 'tsup'
 
 export default defineConfig({

package/src/core/extensions/ApplicationCommand.ts

@@ -1,80 +0,0 @@
-import chalk from 'chalk'
-import { ApplicationCommandData, ApplicationCommandType, GuildAuditLogs, Interaction, Snowflake } from 'discord.js'
-import { ApplicationCommandComponent } from '../../applicationCommand'
-import { ApplicationCommandOption } from '../../applicationCommand/ApplicationCommandOption'
-import { moduleHook } from '../hooks'
-import { listener } from '../listener'
-import { CommandClient } from '../structures'
-import { Extension } from './Extension'
-
-export type ApplicationCommandExtensionConfig = {
-  guilds?: Snowflake[]
-}
-
-export class ApplicationCommandExtension extends Extension {
-  constructor(public config: ApplicationCommandExtensionConfig) {
-    super()
-  }
-
-  @listener({ event: 'interactionCreate' })
-  async interactionCreate(i: Interaction) {
-    console.log(i)
-  }
-
-  @moduleHook('load')
-  async load() {}
-
-  async sync() {
-    const client = CommandClient.getFromModule(this)
-
-    this.logger.info('Trying to sync commands...')
-
-    const commands: ApplicationCommandData[] = []
-
-    for (const command of client.registry.getComponentsWithTypeGlobal(ApplicationCommandComponent)) {
-      const cmd: ApplicationCommandData = { ...command.options }
-
-      if (cmd.type === ApplicationCommandType.ChatInput) {
-        cmd.options = []
-
-        for (const [, arg] of command.argTypes) {
-          const option = arg.decorators.find((x) => x.constructor === ApplicationCommandOption) as ApplicationCommandOption
-
-          if (option) {
-            cmd.options.push(option.options)
-          }
-        }
-      }
-
-      commands.push(cmd)
-    }
-
-    this.logger.info(`Processing ${chalk.green(commands.length)} commands(${commands.map((x) => chalk.blue(x.name)).join(', ')})`)
-
-    if (this.config.guilds) {
-      for (const guild of this.config.guilds) {
-        try {
-          const g = await this.client.guilds.fetch(guild)
-          await g.fetch()
-          this.logger.info(`Registering commands for guild ${chalk.green(g.name)}(${chalk.blue(g.id)})`)
-
-          await g.commands.set(commands)
-
-          this.logger.info(`Successfully registered commands for guild ${chalk.green(g.name)}(${chalk.blue(g.id)})`)
-        } catch (e) {
-          this.logger.error(`Failed to register commands to guild ${chalk.green(guild)}: ${(e as Error).message}`)
-        }
-      }
-    } else {
-      try {
-        this.logger.info(`Registering commands globally...`)
-
-        await this.client.application!.commands.set(commands)
-
-        this.logger.info('Successfully registered commands.')
-      } catch (e) {
-        this.logger.error(`Failed to register commands to global: ${(e as Error).message}`)
-      }
-    }
-  }
-}