Index

Modules: dimscmd, dimscmd/commandOptions, dimscmd/common, dimscmd/discordUtils, dimscmd/interactionUtils, dimscmd/macroUtils, dimscmd/scanner, dimscmd/utils.

API symbols

addAlias:

• dimscmd: proc addAlias(group: CommandGroup; commandName: string; aliases: openArray[string])

addChat:

• dimscmd: macro addChat(router: CommandHandler; name: string; handler: untyped): untyped

addChatAlias:

• dimscmd: proc addChatAlias(router: CommandHandler; commandName: string; aliases: openArray[string])

addSlash:

• dimscmd: macro addSlash(router: CommandHandler; name: string; parameters: varargs[untyped]): untyped

addSlashAlias:

• dimscmd: proc addSlashAlias(router: CommandHandler; commandName: string; aliases: openArray[string])

aliases:

• common: proc aliases(command: Command): seq[string]

Array:

• common: ProcParameterSetting.Array

ChatCommandProc:

• common: type ChatCommandProc

chatCommandsAll:

• common: proc chatCommandsAll(cmd: CommandHandler): seq[Command]

checkSlashName:

• utils: proc checkSlashName(name: string): bool

Command:

• common: type Command

CommandGroup:

• common: type CommandGroup

CommandHandler:

• common: type CommandHandler

CommandScanner:

• scanner: type CommandScanner

CommandType:

• common: enum CommandType

ctChatCommand:

• common: CommandType.ctChatCommand

ctSlashCommand:

• common: CommandType.ctSlashCommand

defaultHelpMessage:

• dimscmd: proc defaultHelpMessage(m: Message; handler: CommandHandler; commandName: string): owned( Future[void])

Enum:

• common: ProcParameterSetting.Enum

EnumOption:

• common: object EnumOption

flatten:

• common: proc flatten(group: CommandGroup; name = ""): seq[Command]

Future:

• common: ProcParameterSetting.Future

get:

• common: proc get(root: CommandGroup; key: openArray[string]): Command
• interactionUtils: proc get(scnr: InteractionScanner; kind: typedesc[bool]; key: string): Option[bool]
• interactionUtils: proc get(scnr: InteractionScanner; kind: typedesc[GuildChannel]; key: string): Future[ Option[GuildChannel]]
• interactionUtils: proc get(scnr: InteractionScanner; kind: typedesc[int]; key: string): Option[int]
• interactionUtils: proc get(scnr: InteractionScanner; kind: typedesc[Role]; key: string): Future[ Option[Role]]
• interactionUtils: proc get(scnr: InteractionScanner; kind: typedesc[string]; key: string): Option[ string]
• interactionUtils: proc get[T: enum](scnr: InteractionScanner; kind: typedesc[T]; key: string): Option[T]
• interactionUtils: proc get(scnr: InteractionScanner; kind: typedesc[User]; key: string): Future[ Option[User]]

getCommandOption:

• commandOptions: proc getCommandOption(parameter: ProcParameter): ApplicationCommandOptionType

getDoc:

• macroUtils: proc getDoc(prc: NimNode): string

getGroup:

• common: proc getGroup(root: CommandGroup; key: openArray[string]): CommandGroup

getGuildID:

• common: proc getGuildID(root: CommandGroup): string

getGuildRole:

• discordUtils: proc getGuildRole(api: RestApi; gid, id: string): Future[Role]

getParameterDescription:

• macroUtils: proc getParameterDescription(prc: NimNode; name: string): string

getParameters:

• macroUtils: proc getParameters(parameters: NimNode): seq[ProcParameter]

getParamTypes:

• macroUtils: proc getParamTypes(prc: NimNode): seq[NimNode]

getScannerCall:

• dimscmd: proc getScannerCall(parameter: ProcParameter; scanner: NimNode; getInner = false): NimNode

getTail:

• interactionUtils: proc getTail(data: ApplicationCommandInteractionData): InteractionCommandData

getWords:

• interactionUtils: proc getWords(i: Interaction): seq[string]
• utils: proc getWords(input: string): seq[string]

handleInteraction:

• dimscmd: proc handleInteraction(router: CommandHandler; s: Shard; i: Interaction): Future[bool]

handleMessage:

• dimscmd: proc handleMessage(router: CommandHandler; prefixes: seq[string]; msg: Message): Future[ bool]
• dimscmd: proc handleMessage(router: CommandHandler; prefixes: seq[string]; s: Shard; msg: Message): Future[bool]
• dimscmd: proc handleMessage(router: CommandHandler; prefix: string; msg: Message): Future[bool]
• dimscmd: proc handleMessage(handler: CommandHandler; prefix: string; s: Shard; msg: Message): Future[ bool]

HandlerProcs:

• common: type HandlerProcs

has:

• common: proc has(root: CommandGroup; key: openArray[string]): bool

hasMore:

• scanner: proc hasMore(scanner: CommandScanner): bool

input:

• scanner: proc input(scanner: CommandScanner): string

InteractionScanner:

• interactionUtils: object InteractionScanner

leafName:

• utils: proc leafName(input: string): string

map:

• common: proc map(root: CommandGroup; cmd: Command)
• common: proc map(root: CommandGroup; key: openArray[string]; cmd: Command)

mapAltPath:

• common: proc mapAltPath(root: CommandGroup; a, b: openArray[string])

matchIdent:

• utils: macro matchIdent(id: string; body: untyped): untyped

name:

• common: proc name(command: Command): string

newGroup:

• common: proc newGroup(cmd: Command): CommandGroup
• common: proc newGroup(name: string; description: string; children: seq[CommandGroup] = @[]): CommandGroup

newHandler:

• dimscmd: proc newHandler(discord: DiscordClient; msgVariable = "msg"; defaultGuildID = ""): CommandHandler

newInteractionGetter:

• interactionUtils: proc newInteractionGetter(i: Interaction; api: RestApi): InteractionScanner

newScanner:

• scanner: proc newScanner(api: RestApi; msg: Message): CommandScanner
• scanner: proc newScanner(input: string; api: RestApi = nil): CommandScanner

next:

• scanner: proc next(scanner: CommandScanner; kind: typedesc[Future[GuildChannel] | GuildChannel]): Future[GuildChannel]
• scanner: proc next(scanner: CommandScanner; kind: typedesc[Future[Role] | Role]): Future[Role]
• scanner: proc next(scanner: CommandScanner; kind: typedesc[Future[User] | User]): Future[User]
• scanner: proc next[T, size: static[int]](scanner: CommandScanner; kind: typedesc[array[size, auto]]): array
• scanner: proc next(scanner: CommandScanner; kind: typedesc[bool]): bool
• scanner: proc next[T](scanner: CommandScanner; kind: typedesc[Future[Option[T]]]): Future[ Option[T]]
• scanner: proc next[T](scanner: CommandScanner; kind: typedesc[Future[seq[T]]]): Future[seq[T]]
• scanner: proc next(scanner: CommandScanner; kind: typedesc[int]): int
• scanner: proc next[T](scanner: CommandScanner; kind: typedesc[Option[T]]): Option[T]
• scanner: proc next[T](scanner: CommandScanner; kind: typedesc[seq[T]]): seq[T]
• scanner: proc next(scanner: CommandScanner; kind: typedesc[string]): string
• scanner: proc next[T: enum](scanner: CommandScanner; kind: typedesc[T]): T
• scanner: proc next[T: range](scanner: CommandScanner; kind: typedesc[T]): T

nextToken:

• scanner: proc nextToken(scanner: CommandScanner): string

nextWord:

• utils: proc nextWord(input: string; output: var string; start = 0): int

normaliseParameterName:

• interactionUtils: proc normaliseParameterName(name: string): string

Optional:

• common: ProcParameterSetting.Optional

parseUntil:

• scanner: proc parseUntil(scanner: CommandScanner; until: char): string

print:

• common: proc print(group: CommandGroup; depth = 1)

ProcParameter:

• common: object ProcParameter

ProcParameterSetting:

• common: enum ProcParameterSetting

raiseScannerError:

• scanner: template raiseScannerError(msg: string)

register:

• dimscmd: proc register(router: CommandHandler; name: string; handler: ChatCommandProc)
• dimscmd: proc register(router: CommandHandler; name: string; handler: SlashCommandProc)

registerCommands:

• dimscmd: proc registerCommands(handler: CommandHandler): owned(Future[void])

ScannerError:

• scanner: object ScannerError

scanProc:

• scanner: macro scanProc(prc: untyped): untyped

Sequence:

• common: ProcParameterSetting.Sequence

skipPast:

• scanner: proc skipPast(scanner: CommandScanner; tokens: seq[string])
• scanner: proc skipPast(scanner: CommandScanner; token: string)

skipWhitespace:

• scanner: proc skipWhitespace(scanner: CommandScanner)

SlashCommandProc:

• common: type SlashCommandProc

slashCommandsAll:

• common: proc slashCommandsAll(cmd: CommandHandler): seq[Command]

toApplicationCommand:

• commandOptions: proc toApplicationCommand(command: Command): ApplicationCommand
• commandOptions: proc toApplicationCommand(group: CommandGroup): ApplicationCommand

toChoices:

• commandOptions: proc toChoices(options: seq[EnumOption]): seq[ApplicationCommandOptionChoice]

toOptions:

• commandOptions: proc toOptions(parameters: seq[ProcParameter]): seq[ApplicationCommandOption]