@pikokr/command.ts 3.2.4-dev.434c22e → 4.0.0-dev.fddc66b

package/src/applicationCommand/AppCommand.ts

@@ -0,0 +1,32 @@
+/*
+ * 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/{slashCommand → applicationCommand}/decorator.ts

@@ -1,15 +1,19 @@
-import { Collection, Snowflake } from 'discord.js'
+/*
+ * Copyright (c) 2022 pikokr. Licensed under the MIT license
+ */
+
+import { ApplicationCommandDataResolvable, Collection, Snowflake } from 'discord.js'
 import { checkTarget } from '../utils'
-import { KSlashCommandOptions, KSlashCommands } from '../constants'
+import { KSlashCommandOptions, KApplicationCommands } from '../constants'
 import { Module } from '../structures'
-import { SlashCommand } from './SlashCommand'
-import { SlashCommandBuilder } from '@discordjs/builders'
+import { AppCommand } from './AppCommand'
 
-type SlashOptions = {
+type ApplicationCommandOptions = {
   guild: Snowflake | Snowflake[]
+  optionTypes?: any[]
 }
 
-export const slashCommand = (opt: Partial<SlashOptions> & { command: SlashCommandBuilder | Omit<SlashCommandBuilder, 'addSubcommand' | 'addSubcommandGroup'> }) => {
+export const applicationCommand = (opt: Partial<ApplicationCommandOptions> & { command: ApplicationCommandDataResolvable }) => {
   return (
     target: Object,
     propertyKey: string,
@@ -17,13 +21,13 @@ export const slashCommand = (opt: Partial<SlashOptions> & { command: SlashComman
   ) => {
     checkTarget(target)
 
-    let properties: SlashCommand[] = Reflect.getMetadata(KSlashCommands, target)
+    let properties: AppCommand[] = Reflect.getMetadata(KApplicationCommands, target)
 
-    const params: any[] = Reflect.getMetadata('design:paramtypes', target, propertyKey)
+    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 SlashCommand(
+    const command = new AppCommand(
       opt.command,
       Reflect.get(target, propertyKey),
       target as Module,
@@ -39,7 +43,7 @@ export const slashCommand = (opt: Partial<SlashOptions> & { command: SlashComman
       properties.push(command)
     } else {
       properties = [command]
-      Reflect.defineMetadata(KSlashCommands, properties, target)
+      Reflect.defineMetadata(KApplicationCommands, properties, target)
     }
   }
 }

package/src/applicationCommand/index.ts

@@ -0,0 +1,6 @@
+/*
+ * Copyright (c) 2022 pikokr. Licensed under the MIT license
+ */
+
+export * from './decorator'
+export * from './AppCommand'

package/src/builtinModules/BuiltInModule.ts

@@ -1,3 +1,7 @@
+/*
+ * Copyright (c) 2022 pikokr. Licensed under the MIT license
+ */
+
 import { Module } from '../structures'
 import { KBuiltInModule } from '../constants'
 

package/src/builtinModules/BuiltinApplicationCommandConverters.ts

@@ -0,0 +1,16 @@
+/*
+ * 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,3 +1,7 @@
+/*
+ * 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'

package/src/builtinModules/CommandHandler.ts

@@ -1,11 +1,28 @@
+/*
+ * Copyright (c) 2022 pikokr. Licensed under the MIT license
+ */
+
 import { BuiltInModule } from './BuiltInModule'
 import { Registry } from '../structures'
 import { listener } from '../listener'
-import { CommandInteraction, GuildMember, Interaction, Message, Role, User } from 'discord.js'
+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, SlashArgumentConverterNotFound, SlashCommandCheckFailed } from '../error'
+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
@@ -15,6 +32,7 @@ export class CommandHandler extends BuiltInModule {
     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)
@@ -129,36 +147,47 @@ export class CommandHandler extends BuiltInModule {
       return error(e)
     }
   }
+  // endregion
 
+  // region slash command handler
   private async command(i: CommandInteraction) {
-    const error = (error: Error) => this.client.client.emit('slashCommandError', error, i)
+    const error = (error: Error) => this.client.client.emit('applicationCommandError', error, i)
     try {
-      const cmd = this.registry.slashCommands.find((x) => x.commandBuilder.name === i.commandName)
+      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.slashCommands.includes(cmd!))
+      const module = this.registry.modules.find((x) => x.applicationCommands.includes(cmd))
 
       if (!module) return
 
       const argList: any[] = []
 
-      if (!cmd)
-        return i.reply({
-          content: 'Unknown command.',
-          ephemeral: true,
-        })
-
       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 SlashCommandCheckFailed(i, cmd))
+        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.slashArgumentConverters.find((x) => x.type === argType.type)
+        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) {
@@ -195,16 +224,119 @@ export class CommandHandler extends BuiltInModule {
           continue
         }
 
-        if (!converter) return error(new SlashArgumentConverterNotFound(argType, i))
+        if (!converter) return error(new ApplicationCommandArgumentConverterNotFound(argType, i))
 
         argList.push(await converter.execute(module, i))
       }
 
-      try {
-        await cmd.execute(module, argList)
-      } catch (e: any) {
-        return error(e)
+      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)
     }
@@ -212,8 +344,28 @@ export class CommandHandler extends BuiltInModule {
 
   @listener('interactionCreate')
   async interaction(i: Interaction) {
-    if (i.isCommand()) {
-      await this.command(i)
+    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,3 +1,7 @@
+/*
+ * Copyright (c) 2022 pikokr. Licensed under the MIT license
+ */
+
 export * from './CommandHandler'
 export * from './BuiltinCommandConverters'
-export * from './BuiltinSlashCommandConverters'
+export * from './BuiltinApplicationCommandConverters'

package/src/command/ArgumentConverter.ts

@@ -1,5 +1,9 @@
+/*
+ * Copyright (c) 2022 pikokr. Licensed under the MIT license
+ */
+
 import { Module } from '../structures'
-import { CommandInteraction, Message } from 'discord.js'
+import { CommandInteraction, ContextMenuInteraction, Message } from 'discord.js'
 
 export class ArgumentConverter {
   execute(module: Module, msg: Message, arg?: string) {
@@ -9,8 +13,8 @@ export class ArgumentConverter {
   constructor(public type: object, private run: Function, public withoutParameter: boolean) {}
 }
 
-export class SlashArgumentConverter {
-  execute(module: Module, interaction: CommandInteraction) {
+export class ApplicationCommandArgumentConverter {
+  execute(module: Module, interaction: CommandInteraction | ContextMenuInteraction) {
     return this.run.apply(module, [interaction])
   }
 

package/src/command/Command.ts

@@ -1,5 +1,9 @@
+/*
+ * Copyright (c) 2022 pikokr. Licensed under the MIT license
+ */
+
 import { Module } from '../structures'
-import { CommandInteraction, Message } from 'discord.js'
+import { CommandInteraction, ContextMenuInteraction, Message, MessageComponentInteraction } from 'discord.js'
 import { KCommandChecks } from '../constants'
 
 export type Argument = {
@@ -9,7 +13,7 @@ export type Argument = {
 }
 
 export type CheckFunction = (msg: Message) => boolean | Promise<boolean>
-export type SlashCheckFunction = (i: CommandInteraction) => boolean | Promise<boolean>
+export type ApplicationCommandCheckFunction = (i: CommandInteraction | MessageComponentInteraction | ContextMenuInteraction) => boolean | Promise<boolean>
 
 export class Command {
   execute(module: Module, args: any[]) {

package/src/command/cooldown/adapter.ts

@@ -1,3 +1,7 @@
+/*
+ * Copyright (c) 2022 pikokr. Licensed under the MIT license
+ */
+
 import { Collection } from 'discord.js'
 
 export interface CoolDownAdapter {

package/src/command/cooldown/decorator.ts

@@ -1,3 +1,7 @@
+/*
+ * Copyright (c) 2022 pikokr. Licensed under the MIT license
+ */
+
 import { createCheckDecorator } from '../utils'
 import { CoolDownType } from './type'
 import { DMChannel, GuildMember, TextChannel } from 'discord.js'

package/src/command/cooldown/error.ts

@@ -1,3 +1,7 @@
+/*
+ * Copyright (c) 2022 pikokr. Licensed under the MIT license
+ */
+
 export class CoolDownError extends Error {
   constructor(public endsAt: Date) {
     super()

package/src/command/cooldown/index.ts

@@ -1,3 +1,7 @@
+/*
+ * Copyright (c) 2022 pikokr. Licensed under the MIT license
+ */
+
 export * from './decorator'
 export * from './adapter'
 export * from './decorator'

package/src/command/cooldown/type.ts

@@ -1,3 +1,7 @@
+/*
+ * Copyright (c) 2022 pikokr. Licensed under the MIT license
+ */
+
 export enum CoolDownType {
   USER,
   CHANNEL,

package/src/command/decorator.ts

@@ -1,7 +1,11 @@
+/*
+ * Copyright (c) 2022 pikokr. Licensed under the MIT license
+ */
+
 import { KArgumentConverters, KCommands, KOptionals, KRest, KSlashArgumentConverters } from '../constants'
 import { Command } from './Command'
 import { checkTarget } from '../utils'
-import { ArgumentConverter, SlashArgumentConverter } from './ArgumentConverter'
+import { ArgumentConverter, ApplicationCommandArgumentConverter } from './ArgumentConverter'
 import { Module } from '../structures'
 import { createCheckDecorator } from './utils'
 import { GuildMember, Message, PermissionResolvable, Permissions, TextChannel } from 'discord.js'
@@ -10,6 +14,7 @@ import { ClientPermissionRequired, DMOnlyCommandError, GuildOnlyCommandError, Ow
 type CommandOptions = {
   name: string
   aliases: string[] | ((msg: Message) => string[])
+  optionTypes?: any[]
 }
 
 export const command = (options: Partial<CommandOptions> = {}) => {
@@ -22,7 +27,7 @@ export const command = (options: Partial<CommandOptions> = {}) => {
 
     let properties: Command[] = Reflect.getMetadata(KCommands, target)
 
-    const params: any[] = Reflect.getMetadata('design:paramtypes', target, propertyKey)
+    const params: any[] = options.optionTypes ?? Reflect.getMetadata('design:paramtypes', target, propertyKey)
 
     const optionals: number = Reflect.getMetadata(KOptionals, target, propertyKey) || -1
 
@@ -71,7 +76,7 @@ export const argumentConverter = (type: object, requireParameter = true) => {
   }
 }
 
-export const slashArgumentConverter = (type: object) => {
+export const applicationCommandArgumentConverter = (type: object) => {
   return (
     target: Object,
     propertyKey: string,
@@ -79,9 +84,9 @@ export const slashArgumentConverter = (type: object) => {
   ) => {
     checkTarget(target)
 
-    let properties: SlashArgumentConverter[] = Reflect.getMetadata(KSlashArgumentConverters, target)
+    let properties: ApplicationCommandArgumentConverter[] = Reflect.getMetadata(KSlashArgumentConverters, target)
 
-    const converter = new SlashArgumentConverter(type, Reflect.get(target, propertyKey))
+    const converter = new ApplicationCommandArgumentConverter(type, Reflect.get(target, propertyKey))
 
     if (properties) {
       properties.push(converter)

package/src/command/index.ts

@@ -1,3 +1,7 @@
+/*
+ * Copyright (c) 2022 pikokr. Licensed under the MIT license
+ */
+
 export * from './Command'
 export * from './decorator'
 export * from './ArgumentConverter'

package/src/command/utils.ts

@@ -1,10 +1,14 @@
-import { CommandInteraction, Message } from 'discord.js'
-import type { CheckFunction, SlashCheckFunction } from './Command'
-import { KCommandChecks, KSlashCommandChecks } from '../constants'
+/*
+ * Copyright (c) 2022 pikokr. Licensed under the MIT license
+ */
+
+import { CommandInteraction, ContextMenuInteraction, Message, MessageComponentInteraction } from 'discord.js'
+import type { CheckFunction, ApplicationCommandCheckFunction } from './Command'
+import { KCommandChecks, KApplicationCommandChecks } from '../constants'
 
 export const createCheckDecorator = (
   execute: ((msg: Message) => boolean | Promise<boolean>) | null,
-  slashExecute?: (i: CommandInteraction) => boolean | Promise<boolean>,
+  executeApplicationCommand?: (i: CommandInteraction | MessageComponentInteraction | ContextMenuInteraction) => boolean | Promise<boolean>,
 ): MethodDecorator => {
   return (target, propertyKey) => {
     if (execute) {
@@ -16,13 +20,13 @@ export const createCheckDecorator = (
         Reflect.defineMetadata(KCommandChecks, properties, target, propertyKey)
       }
     }
-    if (slashExecute) {
-      let properties: SlashCheckFunction[] = Reflect.getMetadata(KSlashCommandChecks, target, propertyKey)
+    if (executeApplicationCommand) {
+      let properties: ApplicationCommandCheckFunction[] = Reflect.getMetadata(KApplicationCommandChecks, target, propertyKey)
       if (properties) {
-        properties.push(slashExecute)
+        properties.push(executeApplicationCommand)
       } else {
-        properties = [slashExecute]
-        Reflect.defineMetadata(KSlashCommandChecks, properties, target, propertyKey)
+        properties = [executeApplicationCommand]
+        Reflect.defineMetadata(KApplicationCommandChecks, properties, target, propertyKey)
       }
     }
   }

package/src/constants.ts

@@ -1,6 +1,10 @@
+/*
+ * Copyright (c) 2022 pikokr. Licensed under the MIT license
+ */
+
 export const KCommands = Symbol('Command.TS Commands')
 
-export const KSlashCommands = Symbol('Command.TS Slash Commands')
+export const KApplicationCommands = Symbol('Command.TS Slash Commands')
 
 export const KSlashCommandOptions = Symbol('Command.TS Slash Command Options')
 
@@ -22,4 +26,6 @@ export const KSlashArgumentConverters = Symbol('Command.TS Slash Argument Conver
 
 export const KCommandChecks = Symbol('Command.TS Command Checks')
 
-export const KSlashCommandChecks = Symbol('Command.TS Slash Command Checks')
+export const KApplicationCommandChecks = Symbol('Command.TS Slash Command Checks')
+
+export const KMessageComponentHandlers = Symbol('Command.TS Message Component Handlers')

package/src/error/ArgumentConverterNotFound.ts

@@ -1,14 +1,18 @@
-import { CommandInteraction, Message } from 'discord.js'
+/*
+ * Copyright (c) 2022 pikokr. Licensed under the MIT license
+ */
+
+import { CommandInteraction, ContextMenuInteraction, Message } from 'discord.js'
 import type { Argument } from '../command'
-import type { SlashArgument } from '../slashCommand'
+import type { AppCommandArgument } from '../applicationCommand'
 
 export class ArgumentConverterNotFound extends Error {
   constructor(public type: Argument, public msg: Message) {
     super(`Argument converter ${type.type.name} not found.`)
   }
 }
-export class SlashArgumentConverterNotFound extends Error {
-  constructor(public type: SlashArgument, public interaction: CommandInteraction) {
+export class ApplicationCommandArgumentConverterNotFound extends Error {
+  constructor(public type: AppCommandArgument, public interaction: CommandInteraction | ContextMenuInteraction) {
     super(`Argument converter ${type.type.name} not found.`)
   }
 }

package/src/error/ArgumentNotProvided.ts

@@ -1,3 +1,7 @@
+/*
+ * Copyright (c) 2022 pikokr. Licensed under the MIT license
+ */
+
 import { Message } from 'discord.js'
 import { Command } from '../command'
 

package/src/error/CommandCheckFailed.ts

@@ -1,6 +1,10 @@
-import { CommandInteraction, Message } from 'discord.js'
+/*
+ * Copyright (c) 2022 pikokr. Licensed under the MIT license
+ */
+
+import { CommandInteraction, ContextMenuInteraction, Message, MessageComponentInteraction } from 'discord.js'
 import { Command } from '../command'
-import { SlashCommand } from '../slashCommand'
+import { AppCommand } from '../applicationCommand'
 
 export class CommandCheckFailed extends Error {
   constructor(public msg: Message, public command: Command) {
@@ -8,8 +12,8 @@ export class CommandCheckFailed extends Error {
   }
 }
 
-export class SlashCommandCheckFailed extends Error {
-  constructor(public interaction: CommandInteraction, public command: SlashCommand) {
+export class ApplicationCommandCheckFailed extends Error {
+  constructor(public interaction: CommandInteraction | MessageComponentInteraction | ContextMenuInteraction, public command: AppCommand) {
     super()
   }
 }

package/src/error/CommandNotFound.ts

@@ -1,3 +1,7 @@
+/*
+ * Copyright (c) 2022 pikokr. Licensed under the MIT license
+ */
+
 import { Message } from 'discord.js'
 
 export class CommandNotFound extends Error {

package/src/error/InvalidTargetError.ts

@@ -1,3 +1,7 @@
+/*
+ * Copyright (c) 2022 pikokr. Licensed under the MIT license
+ */
+
 export class InvalidTargetError extends Error {
   constructor() {
     super('Class does not extend "Module" class.')