@wq2/brigadier-ts 1.0.0 → 1.0.2

package/src/arguments/NumberArgumentType.ts

@@ -1,39 +1,49 @@
-import { ArgumentType, StringReader, CommandErrorType } from "..";
-
-export abstract class NumberArgumentType<N extends number | BigInt = number> extends ArgumentType<N> {
-    private minimum: N;
-    private maximum: N;
-
-    constructor(minimum: N, maximum: N) {
-        super();
-        this.minimum = minimum;
-        this.maximum = maximum;
-    }
-
-    getMinimum(): N {
-        return this.minimum;
-    }
-
-    getMaximum(): N {
-        return this.maximum;
-    }
-
-    parse(reader: StringReader): N {
-        const start = reader.getCursor();
-        const result = this.readNumber(reader);
-        if (result < this.minimum) {
-            reader.setCursor(start);
-            throw this.getTooSmallError().createWithContext(reader, result, this.minimum);
-        } else if (result > this.maximum) {
-            reader.setCursor(start);
-            throw this.getTooBigError().createWithContext(reader, result, this.maximum);
-        }
-        return result;
-    }
-
-    abstract readNumber(reader: StringReader): N;
-
-    abstract getTooSmallError(): CommandErrorType;
-
-    abstract getTooBigError(): CommandErrorType;
+import { ArgumentType, type StringReader, type CommandErrorType } from "..";
+
+export abstract class NumberArgumentType<
+	N extends number | bigint = number,
+> extends ArgumentType<N> {
+	private minimum: N;
+	private maximum: N;
+
+	constructor(minimum: N, maximum: N) {
+		super();
+		this.minimum = minimum;
+		this.maximum = maximum;
+	}
+
+	getMinimum(): N {
+		return this.minimum;
+	}
+
+	getMaximum(): N {
+		return this.maximum;
+	}
+
+	parse(reader: StringReader): N {
+		const start = reader.getCursor();
+		const result = this.readNumber(reader);
+		if (result < this.minimum) {
+			reader.setCursor(start);
+			throw this.getTooSmallError().createWithContext(
+				reader,
+				result,
+				this.minimum,
+			);
+		} else if (result > this.maximum) {
+			reader.setCursor(start);
+			throw this.getTooBigError().createWithContext(
+				reader,
+				result,
+				this.maximum,
+			);
+		}
+		return result;
+	}
+
+	abstract readNumber(reader: StringReader): N;
+
+	abstract getTooSmallError(): CommandErrorType;
+
+	abstract getTooBigError(): CommandErrorType;
 }

package/src/arguments/StringArgumentType.ts

@@ -1,40 +1,40 @@
-import { ArgumentType, StringReader } from "..";
+import { ArgumentType, type StringReader } from "..";
 
 type StringType = "single_word" | "quotable_phrase" | "greedy_phrase";
 
 export class StringArgumentType extends ArgumentType<string> {
-    private type: StringType;
-
-    constructor(type: StringType) {
-        super();
-        this.type = type;
-    }
-
-    getType(): StringType {
-        return this.type;
-    }
-
-    parse(reader: StringReader): string {
-        if (this.type === "greedy_phrase") {
-            const text = reader.getRemaining();
-            reader.setCursor(reader.getTotalLength());
-            return text;
-        } else if (this.type === "single_word") {
-            return reader.readUnquotedString();
-        } else {
-            return reader.readString();
-        }
-    }
+	private type: StringType;
+
+	constructor(type: StringType) {
+		super();
+		this.type = type;
+	}
+
+	getType(): StringType {
+		return this.type;
+	}
+
+	parse(reader: StringReader): string {
+		if (this.type === "greedy_phrase") {
+			const text = reader.getRemaining();
+			reader.setCursor(reader.getTotalLength());
+			return text;
+		} else if (this.type === "single_word") {
+			return reader.readUnquotedString();
+		} else {
+			return reader.readString();
+		}
+	}
 }
 
 export function word(): StringArgumentType {
-    return new StringArgumentType("single_word");
+	return new StringArgumentType("single_word");
 }
 
 export function string(): StringArgumentType {
-    return new StringArgumentType("quotable_phrase");
+	return new StringArgumentType("quotable_phrase");
 }
 
 export function greedyString(): StringArgumentType {
-    return new StringArgumentType("greedy_phrase");
+	return new StringArgumentType("greedy_phrase");
 }

package/src/builder/ArgumentBuilder.ts

@@ -1,82 +1,87 @@
 import {
-    CommandNode,
-    RootCommandNode,
-    Command,
-    Predicate,
-    CommandContext
+	CommandNode,
+	RootCommandNode,
+	type Command,
+	type Predicate,
+	type CommandContext,
 } from "..";
 
 export type RedirectModifier<S> = (context: CommandContext<S>) => S | S[];
 
 export abstract class ArgumentBuilder<S, T extends ArgumentBuilder<S, T>> {
-    private arguments: RootCommandNode<S>;
-    private command: Command<S>;
-    private requirement: Predicate<S>;
-    private target: CommandNode<S>;
-    private modifier: RedirectModifier<S>;
-    private forks: boolean;
-
-    constructor() {
-        this.arguments = new RootCommandNode();
-        this.requirement = async s => true;
-    }
-
-    abstract getThis(): T;
-
-    then(argument: ArgumentBuilder<S, any> | CommandNode<S>): T {
-        const child = argument instanceof CommandNode ? argument : argument.build();
-        this.arguments.addChild(child);
-        return this.getThis();
-    }
-
-    executes(command: Command<S>): T {
-        this.command = command;
-        return this.getThis();
-    }
-
-    requires(requirement: Predicate<S>): T {
-        this.requirement = requirement;
-        return this.getThis();
-    }
-
-    redirect(target: CommandNode<S>, modifier: RedirectModifier<S> = null): T {
-        return this.forward(target, modifier, false)
-    }
-
-    fork(target: CommandNode<S>, modifier: RedirectModifier<S>): T {
-        return this.forward(target, modifier, true);
-    }
-
-    forward(target: CommandNode<S>, modifier: RedirectModifier<S>, forks: boolean): T {
-        this.target = target;
-        this.modifier = modifier;
-        this.forks = forks;
-        return this.getThis();
-    }
-
-    getArguments(): CommandNode<S>[] {
-        return this.arguments.getChildren();
-    }
-
-    getCommand(): Command<S> {
-        return this.command;
-    }
-
-    getRequirement(): Predicate<S> {
-        return this.requirement;
-    }
-
-    getRedirect(): CommandNode<S> {
-        return this.target;
-    }
-
-    getRedirectModifier(): RedirectModifier<S> {
-        return this.modifier;
-    }
-
-    isFork(): boolean {
-        return this.forks;
-    }
-
-    abstract build(): CommandNode<S>;
+	private arguments: RootCommandNode<S>;
+	private command: Command<S>;
+	private requirement: Predicate<S>;
+	private target: CommandNode<S>;
+	private modifier: RedirectModifier<S>;
+	private forks: boolean;
+
+	constructor() {
+		this.arguments = new RootCommandNode();
+		this.requirement = async (_) => true;
+	}
+
+	abstract getThis(): T;
+
+	// biome-ignore lint/suspicious/noThenProperty: proof?
+	then(argument: ArgumentBuilder<S, any> | CommandNode<S>): T {
+		const child = argument instanceof CommandNode ? argument : argument.build();
+		this.arguments.addChild(child);
+		return this.getThis();
+	}
+
+	executes(command: Command<S>): T {
+		this.command = command;
+		return this.getThis();
+	}
+
+	requires(requirement: Predicate<S>): T {
+		this.requirement = requirement;
+		return this.getThis();
+	}
+
+	redirect(target: CommandNode<S>, modifier: RedirectModifier<S> = null): T {
+		return this.forward(target, modifier, false);
+	}
+
+	fork(target: CommandNode<S>, modifier: RedirectModifier<S>): T {
+		return this.forward(target, modifier, true);
+	}
+
+	forward(
+		target: CommandNode<S>,
+		modifier: RedirectModifier<S>,
+		forks: boolean,
+	): T {
+		this.target = target;
+		this.modifier = modifier;
+		this.forks = forks;
+		return this.getThis();
+	}
+
+	getArguments(): CommandNode<S>[] {
+		return this.arguments.getChildren();
+	}
+
+	getCommand(): Command<S> {
+		return this.command;
+	}
+
+	getRequirement(): Predicate<S> {
+		return this.requirement;
+	}
+
+	getRedirect(): CommandNode<S> {
+		return this.target;
+	}
+
+	getRedirectModifier(): RedirectModifier<S> {
+		return this.modifier;
+	}
+
+	isFork(): boolean {
+		return this.forks;
+	}
+
+	abstract build(): CommandNode<S>;
 }

package/src/builder/LiteralArgumentBuilder.ts

@@ -1,30 +1,40 @@
 import { ArgumentBuilder, LiteralCommandNode } from "..";
 
-export class LiteralArgumentBuilder<S> extends ArgumentBuilder<S, LiteralArgumentBuilder<S>> {
-    private literal: string;
+export class LiteralArgumentBuilder<S> extends ArgumentBuilder<
+	S,
+	LiteralArgumentBuilder<S>
+> {
+	private literal: string;
 
-    constructor(literal: string) {
-        super();
-        this.literal = literal
-    }
+	constructor(literal: string) {
+		super();
+		this.literal = literal;
+	}
 
-    getThis(): LiteralArgumentBuilder<S> {
-        return this;
-    }
+	getThis(): LiteralArgumentBuilder<S> {
+		return this;
+	}
 
-    getLiteral(): string {
-        return this.literal;
-    }
-    
-    build(): LiteralCommandNode<S> {
-        const result = new LiteralCommandNode<S>(this.getLiteral(), this.getCommand(), this.getRequirement(), this.getRedirect(), this.getRedirectModifier(), this.isFork());
-        for (const argument of this.getArguments()) {
-            result.addChild(argument);
-        }
-        return result;
-    }
+	getLiteral(): string {
+		return this.literal;
+	}
+
+	build(): LiteralCommandNode<S> {
+		const result = new LiteralCommandNode<S>(
+			this.getLiteral(),
+			this.getCommand(),
+			this.getRequirement(),
+			this.getRedirect(),
+			this.getRedirectModifier(),
+			this.isFork(),
+		);
+		for (const argument of this.getArguments()) {
+			result.addChild(argument);
+		}
+		return result;
+	}
 }
 
 export function literal<S = any>(name: string): LiteralArgumentBuilder<S> {
-    return new LiteralArgumentBuilder(name);
+	return new LiteralArgumentBuilder(name);
 }

package/src/builder/RequiredArgumentBuilder.ts

@@ -1,40 +1,50 @@
-import { 
-    ArgumentBuilder,
-    ArgumentType,
-    ArgumentCommandNode
-} from "..";
+import { ArgumentBuilder, type ArgumentType, ArgumentCommandNode } from "..";
 
-export class RequiredArgumentBuilder<S, T> extends ArgumentBuilder<S, RequiredArgumentBuilder<S, T>> {
-    private name: string;
-    private type: ArgumentType<T>;
+export class RequiredArgumentBuilder<S, T> extends ArgumentBuilder<
+	S,
+	RequiredArgumentBuilder<S, T>
+> {
+	private name: string;
+	private type: ArgumentType<T>;
 
-    constructor(name: string, type: ArgumentType<T>) {
-        super();
-        this.name = name;
-        this.type = type;
-    }
+	constructor(name: string, type: ArgumentType<T>) {
+		super();
+		this.name = name;
+		this.type = type;
+	}
 
-    getThis(): RequiredArgumentBuilder<S, T> {
-        return this;
-    }
+	getThis(): RequiredArgumentBuilder<S, T> {
+		return this;
+	}
 
-    getName(): string {
-        return this.name;
-    }
+	getName(): string {
+		return this.name;
+	}
 
-    getType(): ArgumentType<T> {
-        return this.type;
-    }
-    
-    build(): ArgumentCommandNode<S, T> {
-        const result = new ArgumentCommandNode(this.getName(), this.getType(), this.getCommand(), this.getRequirement(), this.getRedirect(), this.getRedirectModifier(), this.isFork());
-        for (const argument of this.getArguments()) {
-            result.addChild(argument);
-        }
-        return result;
-    }
+	getType(): ArgumentType<T> {
+		return this.type;
+	}
+
+	build(): ArgumentCommandNode<S, T> {
+		const result = new ArgumentCommandNode(
+			this.getName(),
+			this.getType(),
+			this.getCommand(),
+			this.getRequirement(),
+			this.getRedirect(),
+			this.getRedirectModifier(),
+			this.isFork(),
+		);
+		for (const argument of this.getArguments()) {
+			result.addChild(argument);
+		}
+		return result;
+	}
 }
 
-export function argument<S = any, T = any>(name: string, type: ArgumentType<T>): RequiredArgumentBuilder<S, T> {
-    return new RequiredArgumentBuilder(name, type);
+export function argument<S = any, T = any>(
+	name: string,
+	type: ArgumentType<T>,
+): RequiredArgumentBuilder<S, T> {
+	return new RequiredArgumentBuilder(name, type);
 }

package/src/context/CommandContext.ts

@@ -1,94 +1,117 @@
-import { Command,
-    CommandNode,
-    StringRange,
-    ParsedArgument,
-    ParsedCommandNode,
-    RedirectModifier
+import type {
+	Command,
+	CommandNode,
+	StringRange,
+	ParsedArgument,
+	ParsedCommandNode,
+	RedirectModifier,
 } from "..";
 
 export class CommandContext<S> {
-    private source: S;
-    private input: string;
-    private arguments: Map<string, ParsedArgument<any>>; 
-    private nodes: ParsedCommandNode<S>[];
-    private command: Command<S>;
-    private rootNode: CommandNode<S>;
-    private child: CommandContext<S>;
-    private range: StringRange;
-    private modifier: RedirectModifier<S>;
-    private forks: boolean;
+	private source: S;
+	private input: string;
+	private arguments: Map<string, ParsedArgument<any>>;
+	private nodes: ParsedCommandNode<S>[];
+	private command: Command<S>;
+	private rootNode: CommandNode<S>;
+	private child: CommandContext<S>;
+	private range: StringRange;
+	private modifier: RedirectModifier<S>;
+	private forks: boolean;
 
-    constructor(source: S, input: string, parsedArguments: Map<string, ParsedArgument<any>>, command: Command<S>, rootNode: CommandNode<S>, nodes: ParsedCommandNode<S>[], range: StringRange, child: CommandContext<S>, modifier: RedirectModifier<S>, forks: boolean) {
-        this.source = source;
-        this.input = input;
-        this.arguments = parsedArguments;
-        this.command = command;
-        this.rootNode = rootNode;
-        this.nodes = nodes;
-        this.range = range;
-        this.child = child;
-        this.modifier = modifier;
-        this.forks = forks;
-    }
+	constructor(
+		source: S,
+		input: string,
+		parsedArguments: Map<string, ParsedArgument<any>>,
+		command: Command<S>,
+		rootNode: CommandNode<S>,
+		nodes: ParsedCommandNode<S>[],
+		range: StringRange,
+		child: CommandContext<S>,
+		modifier: RedirectModifier<S>,
+		forks: boolean,
+	) {
+		this.source = source;
+		this.input = input;
+		this.arguments = parsedArguments;
+		this.command = command;
+		this.rootNode = rootNode;
+		this.nodes = nodes;
+		this.range = range;
+		this.child = child;
+		this.modifier = modifier;
+		this.forks = forks;
+	}
 
-    copyFor(source: S): CommandContext<S> {
-        if (this.source === source) {
-            return this;
-        }
-        return new CommandContext<S>(source, this.input, this.arguments, this.command, this.rootNode, this.nodes, this.range, this.child, this.modifier, this.forks);
-    }
+	copyFor(source: S): CommandContext<S> {
+		if (this.source === source) {
+			return this;
+		}
+		return new CommandContext<S>(
+			source,
+			this.input,
+			this.arguments,
+			this.command,
+			this.rootNode,
+			this.nodes,
+			this.range,
+			this.child,
+			this.modifier,
+			this.forks,
+		);
+	}
 
-    getChild(): CommandContext<S> {
-        return this.child;
-    }
+	getChild(): CommandContext<S> {
+		return this.child;
+	}
 
-    getLastChild(): CommandContext<S> {
-        let result: CommandContext<S> = this;
-        while (result.getChild() != null) {
-            result = result.getChild();
-        }
-        return result;
-    }
+	getLastChild(): CommandContext<S> {
+		let result: CommandContext<S> = this;
+		while (result.getChild() != null) {
+			result = result.getChild();
+		}
+		return result;
+	}
 
-    getCommand(): Command<S> {
-        return this.command;
-    }
+	getCommand(): Command<S> {
+		return this.command;
+	}
 
-    getSource(): S {
-        return this.source;
-    }
+	getSource(): S {
+		return this.source;
+	}
 
-    getRootNode(): CommandNode<S> {
-        return this.rootNode;
-    }
+	getRootNode(): CommandNode<S> {
+		return this.rootNode;
+	}
 
-    get(name: string): any {
-        const argument = this.arguments.get(name);
-        // TODO: Throw exception when argument is null
-        return argument.getResult();
-    }
+	get(name: string): any {
+		const argument = this.arguments.get(name);
+		// TODO: Throw exception when argument is null
+		return argument.getResult();
+	}
 
-    getRedirectModifier(): RedirectModifier<S> {
-        return this.modifier;
-    }
+	getRedirectModifier(): RedirectModifier<S> {
+		return this.modifier;
+	}
 
-    getRange(): StringRange {
-        return this.range;
-    }
+	getRange(): StringRange {
+		return this.range;
+	}
 
-    getInput(): string {
-        return this.input;
-    }
+	getInput(): string {
+		return this.input;
+	}
 
-    getNodes(): ParsedCommandNode<S>[] {
-        return this.nodes;
-    }
+	getNodes(): ParsedCommandNode<S>[] {
+		return this.nodes;
+	}
 
-    hasNodes(): boolean {
-        return this.nodes.length !== 0;
-    }
+	hasNodes(): boolean {
+		return this.nodes.length !== 0;
+	}
 
-    isForked(): boolean {
-        return this.forks;
-    }
+	isForked(): boolean {
+		return this.forks;
+	}
 }