@tb-chan/arguments

Overview

This package aims to help Discord bots developers to implement arguments handling. FOR INTERNAL USES ONLY

References

• An input argument can only be in a word. There are 2 main concepts in this package: Resolver and Strategy
• Resolver transforms a string into a desired output of a certain data type.
• Strategy works with multiple resolved value from Resolver to make up the argument.

For example, take this message: tbcommand foo bar 42:
And our command is expecting these arguments:

• A string argument of at least 2 words
• A number argument

An argument is only considered a word, so there will actually be 2 string arguments foo bar here. A strategy will put up those 2 resolved value into 1 final argument.

Usage

Do note that this is an ES package. Full usage example:

import { processArgs, parseInput, type Command, MessageArgumentType } from '@tb-chan/arguments';
import { Client } from 'discord.js';

const client = new Client({ intents: ['GuildMessages', 'Guilds'] });
const myCommand: Command = {
	name: 'mycommand',
	arguments: {
		foo: {
			name: 'foo',
			type: MessageArgumentType.String,
			required: true
		}
	}
};

client.on('messageCreate', (message) => {
    // For example, message.content is 'tbmycommand bar'
	const args = parseInput(message.content, 'tb');
	if (!args) return;

	const result = processArgs({
		command: myCommand,
		args: args,
		resolvable: { guild: message.guild!, message }
	});

    console.log(result); // { foo: 'bar' }
});

Documentations

function parseInput(input: string, prefix: string): Args | null

Initially parse the input of a string into Args for resolving.

function processArgs({ command, args, resolvable, state }: ProcessArgsOption): Promise<Record<string, any>>

Process the parsed Args into complete arguments.

type ResolverParam = {
	[key in keyof typeof Resolver]: key extends number
		? Parameters<(typeof Resolver)[key]>[1] extends undefined
			? never
			: Parameters<(typeof Resolver)[key]>[1]
		: never;
};
type ProcessArgsOption<T extends Command = Command> = {
	command: T;
	args: Args;
	resolvable: Partial<UnionToIntersection<ValuesType<ResolverParam>>>;
	state?: Record<string, any>;
};

command: The command arguments data to work with.
args: The resolved Args from parseInput()
state: The object to save processing results on. Default: {}
resolvable: You may provide the additional arguments for some specific Resolvers here.

Built-in