@pikokr/command.ts 4.0.5 → 5.0.0-dev.6057824

package/src/core/index.ts

@@ -0,0 +1,3 @@
+export * from './components'
+export * from './structures'
+export * from './hooks'

package/src/core/listener/index.ts

@@ -0,0 +1,20 @@
+import { BaseComponent, createComponentDecorator } from '../components'
+
+export class ListenerComponent extends BaseComponent<{ emitter: string; event: string }, { emitter?: string; event: string }> {
+  defaultOptions() {
+    return { emitter: 'discord' }
+  }
+
+  constructor(options: ListenerComponent['options'], method: Function, argTypes: unknown[]) {
+    super(
+      {
+        event: options.event,
+        emitter: options.emitter ?? 'discord',
+      },
+      method,
+      argTypes,
+    )
+  }
+}
+
+export const listener = createComponentDecorator(ListenerComponent)

package/src/core/structures/CommandClient.ts

@@ -0,0 +1,36 @@
+import chalk from 'chalk'
+import { Client } from 'discord.js'
+import EventEmitter from 'events'
+import { Logger } from 'tslog'
+import { ApplicationCommandExtension, ApplicationCommandExtensionConfig } from '../extensions/ApplicationCommand'
+import { CommandClientSymbol } from '../symbols'
+import { Registry } from './Registry'
+
+export class CommandClient extends EventEmitter {
+  ctsLogger: Logger
+  registry: Registry
+
+  constructor(public discord: Client, public logger: Logger = new Logger({ dateTimeTimezone: Intl.DateTimeFormat().resolvedOptions().timeZone })) {
+    super()
+
+    this.ctsLogger = logger.getChildLogger({ prefix: [chalk.blue('[command.ts]')], displayFilePath: 'hidden', displayFunctionName: false })
+
+    this.registry = new Registry(this.ctsLogger, this)
+
+    this.registry.registerEventEmitter('cts', this)
+    this.registry.registerEventEmitter('discord', this.discord)
+  }
+
+  async enableApplicationCommandsExtension(config: ApplicationCommandExtensionConfig) {
+    await this.registry.registerModule(new ApplicationCommandExtension(config))
+    this.ctsLogger.info('Application command extension enabled.')
+  }
+
+  getApplicationCommandsExtension() {
+    return this.registry.extensions.find((x) => x.constructor === ApplicationCommandExtension) as ApplicationCommandExtension | undefined
+  }
+
+  static getFromModule(ext: object): CommandClient {
+    return Reflect.getMetadata(CommandClientSymbol, ext)
+  }
+}

package/src/core/structures/Registry.ts

@@ -0,0 +1,101 @@
+import chalk from 'chalk'
+import { Collection } from 'discord.js'
+import EventEmitter from 'events'
+import _ from 'lodash'
+import { Logger } from 'tslog'
+import { BaseComponent, getComponentStore } from '../components'
+import { getModuleHookStore } from '../hooks'
+import { ListenerComponent } from '../listener'
+import { CommandClientSymbol } from '../symbols'
+import { CommandClient } from './CommandClient'
+
+export class Registry {
+  extensions: object[] = []
+
+  emitters: Collection<string, EventEmitter> = new Collection()
+
+  logger: Logger
+
+  constructor(logger: Logger, public client: CommandClient) {
+    this.logger = logger.getChildLogger({
+      prefix: [chalk.green('[Registry]')],
+    })
+  }
+
+  getComponentsWithTypeGlobal<T extends typeof BaseComponent<Config>, Config>(type: T): InstanceType<T>[] {
+    const result: InstanceType<T>[] = []
+
+    for (const ext of this.extensions) {
+      result.push(...this.getComponentsWithType(ext, type))
+    }
+
+    return result
+  }
+
+  getComponentsWithType<T extends typeof BaseComponent<Config>, Config>(ext: object, type: T): InstanceType<T>[] {
+    const componentStore = getComponentStore(ext)
+
+    return Array.from(componentStore.filter((x) => (x.constructor as unknown) === type).values() as Iterable<InstanceType<T>>)
+  }
+
+  registerEventListeners(ext: object) {
+    const listeners = this.getComponentsWithType(ext, ListenerComponent)
+
+    for (const listener of listeners) {
+      const emitter = this.emitters.get(listener.options.emitter)
+
+      if (emitter) {
+        const bound = listener.method.bind(ext)
+
+        Reflect.defineMetadata('bound', bound, listener)
+
+        emitter.addListener(listener.options.event, bound)
+      }
+    }
+  }
+
+  unregisterEventListeners(ext: object) {
+    const listeners = this.getComponentsWithType(ext, ListenerComponent)
+
+    for (const listener of listeners) {
+      const emitter = this.emitters.get(listener.options.emitter)
+      const bound = Reflect.getMetadata('bound', listener)
+
+      if (emitter && bound) {
+        emitter.removeListener(listener.options.event, bound)
+      }
+    }
+  }
+
+  async registerModule(ext: object) {
+    Reflect.defineMetadata(CommandClientSymbol, this.client, ext)
+
+    this.registerEventListeners(ext)
+    await this.runModuleHook(ext, 'load')
+    this.extensions.push(ext)
+    this.logger.info(`Module registered: ${chalk.green(ext.constructor.name)}`)
+  }
+
+  async unregisterModule(ext: object) {
+    this.unregisterEventListeners(ext)
+    await this.runModuleHook(ext, 'unload')
+    _.remove(this.extensions, (x) => x === ext)
+    this.logger.info(`Module unregistered: ${chalk.green(ext.constructor.name)}`)
+  }
+
+  runModuleHook(ext: object, hookName: string, ...args: unknown[]) {
+    const hooks = getModuleHookStore(ext)
+
+    const functions = hooks.get(hookName)
+
+    if (functions) {
+      for (const fn of functions) {
+        fn.call(ext, ...args)
+      }
+    }
+  }
+
+  registerEventEmitter(name: string, emitter: EventEmitter) {
+    this.emitters.set(name, emitter)
+  }
+}

package/src/core/structures/index.ts

@@ -0,0 +1,2 @@
+export * from './Registry'
+export * from './CommandClient'

package/src/core/symbols.ts

@@ -0,0 +1,4 @@
+export const ComponentStoreSymbol = Symbol()
+export const ComponentArgStoreSymbol = Symbol()
+export const ModuleHookStoreSymbol = Symbol()
+export const CommandClientSymbol = Symbol()

package/src/index.ts

@@ -1,16 +1,10 @@
 /*
- * Copyright (c) 2022 pikokr. Licensed under the MIT license
+ * File: index.ts
+ *
+ * Copyright (c) 2022-2022 pikokr
+ *
+ * Licensed under MIT License. Please see more defails in LICENSE file.
  */
 
-import 'reflect-metadata'
-import './typings'
-
-export * from './interface'
-export * from './structures'
-export * from './error'
-export * from './command'
-export * from './listener'
-export * from './builtinModules/BuiltInModule'
+export * from './core'
 export * from './applicationCommand'
-export * from './messageComponents'
-export * from './error'

package/test/index.ts

@@ -1,30 +1,69 @@
-/*
- * Copyright (c) 2022 pikokr. Licensed under the MIT license
- */
+import { ApplicationCommandOptionType, ApplicationCommandType, Client } from 'discord.js'
+import { applicationCommand, CommandClient, moduleHook, option, Registry } from '../src'
+import { listener } from '../src/core/listener'
+import 'dotenv/config'
+import { Logger } from 'tslog'
+import chalk from 'chalk'
+import { Extension } from '../src/core/extensions'
 
-import { Client, Intents, IntentsString } from 'discord.js'
-import { CommandClient } from '../src'
+class Test extends Extension {
+  @applicationCommand({
+    type: ApplicationCommandType.ChatInput,
+    name: 'test',
+    description: 'wow this is test',
+  })
+  async testCommand() {}
 
-const config = require('./config.json')
+  @applicationCommand({
+    type: ApplicationCommandType.ChatInput,
+    name: 'test2',
+    description: 'wow this is test wow',
+  })
+  async test2(
+    @option({
+      name: 'sans',
+      description: '와',
+      type: ApplicationCommandOptionType.String,
+    })
+    wa: string,
+  ) {}
 
-const client = new Client({
-  intents: Object.keys(Intents.FLAGS) as IntentsString[],
-})
+  @moduleHook('load')
+  load() {
+    this.logger.info('Load')
+  }
 
-const cts = new CommandClient({
-  owners: 'auto',
-  client,
-  command: {
-    prefix: '!',
-  },
-  applicationCommands: {
-    autoSync: true,
-    guild: '832938554438844438',
-  },
-})
+  @moduleHook('unload')
+  unload() {
+    this.logger.info('Unload')
+  }
 
-require('./modules/test')
+  @listener({ event: 'ready' })
+  testEvent() {
+    this.logger.info(`Login: ${chalk.green(client.user!.tag)}`)
+  }
+}
 
-cts.registry.loadModulesIn('modules')
+const ext = new Test()
 
-client.login(config.token)
+const client = new Client({ intents: [] })
+
+const logger = new Logger({ dateTimeTimezone: Intl.DateTimeFormat().resolvedOptions().timeZone })
+
+const cc = new CommandClient(client, logger)
+
+const registry = cc.registry
+
+const run = async () => {
+  await cc.enableApplicationCommandsExtension({
+    guilds: ['832938554438844438'],
+  })
+
+  await registry.registerModule(ext)
+
+  await client.login(process.env.TOKEN)
+
+  await cc.getApplicationCommandsExtension()!.sync()
+}
+
+run()

package/tsconfig.json

@@ -15,11 +15,10 @@
     "declaration": true,
     /* Generates corresponding '.d.ts' file. */
     // "declarationMap": true,                      /* Generates a sourcemap for each corresponding '.d.ts' file. */
-     "sourceMap": true,                           /* Generates corresponding '.map' file. */
+    "sourceMap": true /* Generates corresponding '.map' file. */,
     // "outFile": "./",                             /* Concatenate and emit output to single file. */
     "outDir": "./dist",
     /* Redirect output structure to the directory. */
-    "rootDir": "./src",
     /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
     // "composite": true,                           /* Enable project compilation */
     // "tsBuildInfoFile": "./",                     /* Specify file to store incremental compilation information */
@@ -31,6 +30,7 @@
 
     /* Strict Type-Checking Options */
     "strict": true,
+
     /* Enable all strict type-checking options. */
     // "noImplicitAny": true,                       /* Raise error on expressions and declarations with an implied 'any' type. */
     // "strictNullChecks": true,                    /* Enable strict null checks. */
@@ -79,5 +79,5 @@
     "forceConsistentCasingInFileNames": true
     /* Disallow inconsistently-cased references to the same file. */
   },
-  "exclude": ["test", "node_modules", "dist", "tsup.config.ts", "scripts"]
+  "exclude": ["node_modules"]
 }

package/tsconfig.prod.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "scripts", "test", "tsup.config.ts"],
+  "include": ["src"],
+  "compilerOptions": {
+    "rootDir": "./src",
+  }
+}

package/tsup.config.ts

@@ -1,5 +1,9 @@
 /*
- * Copyright (c) 2022 pikokr. Licensed under the MIT license
+ * File: tsup.config.ts
+ *
+ * Copyright (c) 2022-2022 pikokr
+ *
+ * Licensed under MIT License. Please see more defails in LICENSE file.
  */
 
 import { defineConfig } from 'tsup'
@@ -11,4 +15,5 @@ export default defineConfig({
   clean: true,
   dts: true,
   minify: true,
+  tsconfig: 'tsconfig.prod.json',
 })

package/src/applicationCommand/AppCommand.ts

@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2022 pikokr. Licensed under the MIT license
- */
-
-import { Module } from '../structures'
-import { ApplicationCommandDataResolvable, Snowflake } from 'discord.js'
-import { KApplicationCommandChecks } from '../constants'
-import { ApplicationCommandCheckFunction } from '../command'
-
-export type AppCommandArgument = {
-  type: any
-  name?: string
-}
-
-export class AppCommand {
-  get checks(): ApplicationCommandCheckFunction[] {
-    return Reflect.getMetadata(KApplicationCommandChecks, this.module, this.key) || []
-  }
-
-  execute(module: Module, args: any[]) {
-    return this.run.apply(module, args)
-  }
-
-  constructor(
-    public command: ApplicationCommandDataResolvable,
-    private run: Function,
-    public module: Module,
-    public params: AppCommandArgument[],
-    public guild: Snowflake | Snowflake[] | undefined,
-    private key: string | symbol,
-  ) {}
-}

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
-  }
-}