@wq2/brigadier-ts 1.0.0 → 1.0.2

package/src/context/CommandContextBuilder.ts

@@ -1,148 +1,174 @@
 import {
-    CommandNode,
-    CommandDispatcher,
-    Command,
-    CommandContext,
-    StringRange,
-    ParsedCommandNode,
-    ParsedArgument,
-    RedirectModifier,
-    SuggestionContext
+	type CommandNode,
+	type CommandDispatcher,
+	type Command,
+	CommandContext,
+	StringRange,
+	ParsedCommandNode,
+	type ParsedArgument,
+	type RedirectModifier,
+	SuggestionContext,
 } from "..";
 
 export class CommandContextBuilder<S> {
-    private source: S;
-    private arguments: Map<string, ParsedArgument<any>>;
-    private rootNode: CommandNode<S>;
-    private dispatcher: CommandDispatcher<S>;
-    private command: Command<S>;
-    private child: CommandContextBuilder<S>;
-    private range: StringRange;
-    private nodes: ParsedCommandNode<S>[];
-    private modifier: RedirectModifier<S>;
-    private forks: boolean;
-
-    constructor(dispatcher: CommandDispatcher<S>, source: S, rootNode: CommandNode<S>, start: number) {
-        this.dispatcher = dispatcher;
-        this.source = source;
-        this.rootNode = rootNode;
-        this.range = StringRange.at(start);
-        this.nodes = [];
-        this.arguments = new Map();
-    }
-
-    withSource(source: S): CommandContextBuilder<S> {
-        this.source = source;
-        return this;
-    }
-
-    getSource(): S {
-        return this.source;
-    }
-
-    getRootNode(): CommandNode<S> {
-        return this.rootNode;
-    }
-
-    withArgument(name: string, argument: ParsedArgument<any>): CommandContextBuilder<S> {
-        this.arguments.set(name, argument);
-        return this;
-    }
-
-    getArguments(): Map<string, ParsedArgument<any>> {
-        return this.arguments;
-    }
-
-    withChild(child: CommandContextBuilder<S>): CommandContextBuilder<S> {
-        this.child = child;
-        return this;
-    }
-
-    getChild(): CommandContextBuilder<S> {
-        return this.child;
-    }
-
-    getLastChild(): CommandContextBuilder<S> {
-        let result: CommandContextBuilder<S> = this;
-        while (result.getChild() != null) {
-            result = result.getChild();
-        }
-        return result;
-    }
-
-    withCommand(command: Command<S>): CommandContextBuilder<S> {
-        this.command = command;
-        return this;
-    }
-
-    getCommand(): Command<S> {
-        return this.command;
-    }
-
-    withNode(node: CommandNode<S>, range: StringRange): CommandContextBuilder<S> {
-        this.nodes.push(new ParsedCommandNode<S>(node, range));
-        this.range = StringRange.encompassing(this.range, range);
-        this.modifier = node.getRedirectModifier();
-        this.forks = node.isFork();
-        return this;
-    }
-
-    getNodes(): ParsedCommandNode<S>[] {
-        return this.nodes;
-    }
-
-    copy(): CommandContextBuilder<S> {
-        const copy = new CommandContextBuilder<S>(this.dispatcher, this.source, this.rootNode, this.range.getStart());
-        copy.command = this.command;
-        copy.child = this.child;
-        copy.range = this.range;
-        copy.nodes.push(...this.nodes);
-        this.arguments.forEach((v, k) => {
-            copy.arguments.set(k, v);
-        });
-        return copy;
-
-    }
-
-    build(input: string): CommandContext<S> {
-        const child = this.child == null ? null : this.child.build(input);
-        return new CommandContext(this.source, input, this.arguments, this.command, this.rootNode, this.nodes, this.range, child, this.modifier, this.forks);
-    }
-
-    getDispatcher(): CommandDispatcher<S> {
-        return this.dispatcher;
-    }
-
-    getRange(): StringRange {
-        return this.range;
-    }
-
-    findSuggestionContext(cursor: number): SuggestionContext<S> {
-        if (this.range.getStart() <= cursor) {
-            if (this.range.getEnd() < cursor) {
-                if (this.child != null) {
-                    return this.child.findSuggestionContext(cursor);
-                } else if (this.nodes.length > 0) {
-                    const last = this.nodes[this.nodes.length - 1];
-                    return new SuggestionContext(last.getNode(), last.getRange().getEnd() + 1);
-                } else {
-                    return new SuggestionContext(this.rootNode, this.range.getStart());
-                }
-            } else {
-                let prev = this.rootNode;
-                for (const node of this.nodes) {
-                    const nodeRange = node.getRange();
-                    if (nodeRange.getStart() <= cursor && cursor <= nodeRange.getEnd()) {
-                        return new SuggestionContext(prev, nodeRange.getStart());
-                    }
-                    prev = node.getNode();
-                }
-                if (prev === null) {
-                    throw new Error("Can't find node before cursor");
-                }
-                return new SuggestionContext(prev, this.range.getStart());
-            }
-        }
-        throw new Error("Can't find node before cursor");
-    }
+	private source: S;
+	private arguments: Map<string, ParsedArgument<any>>;
+	private rootNode: CommandNode<S>;
+	private dispatcher: CommandDispatcher<S>;
+	private command: Command<S>;
+	private child: CommandContextBuilder<S>;
+	private range: StringRange;
+	private nodes: ParsedCommandNode<S>[];
+	private modifier: RedirectModifier<S>;
+	private forks: boolean;
+
+	constructor(
+		dispatcher: CommandDispatcher<S>,
+		source: S,
+		rootNode: CommandNode<S>,
+		start: number,
+	) {
+		this.dispatcher = dispatcher;
+		this.source = source;
+		this.rootNode = rootNode;
+		this.range = StringRange.at(start);
+		this.nodes = [];
+		this.arguments = new Map();
+	}
+
+	withSource(source: S): CommandContextBuilder<S> {
+		this.source = source;
+		return this;
+	}
+
+	getSource(): S {
+		return this.source;
+	}
+
+	getRootNode(): CommandNode<S> {
+		return this.rootNode;
+	}
+
+	withArgument(
+		name: string,
+		argument: ParsedArgument<any>,
+	): CommandContextBuilder<S> {
+		this.arguments.set(name, argument);
+		return this;
+	}
+
+	getArguments(): Map<string, ParsedArgument<any>> {
+		return this.arguments;
+	}
+
+	withChild(child: CommandContextBuilder<S>): CommandContextBuilder<S> {
+		this.child = child;
+		return this;
+	}
+
+	getChild(): CommandContextBuilder<S> {
+		return this.child;
+	}
+
+	getLastChild(): CommandContextBuilder<S> {
+		let result: CommandContextBuilder<S> = this;
+		while (result.getChild() != null) {
+			result = result.getChild();
+		}
+		return result;
+	}
+
+	withCommand(command: Command<S>): CommandContextBuilder<S> {
+		this.command = command;
+		return this;
+	}
+
+	getCommand(): Command<S> {
+		return this.command;
+	}
+
+	withNode(node: CommandNode<S>, range: StringRange): CommandContextBuilder<S> {
+		this.nodes.push(new ParsedCommandNode<S>(node, range));
+		this.range = StringRange.encompassing(this.range, range);
+		this.modifier = node.getRedirectModifier();
+		this.forks = node.isFork();
+		return this;
+	}
+
+	getNodes(): ParsedCommandNode<S>[] {
+		return this.nodes;
+	}
+
+	copy(): CommandContextBuilder<S> {
+		const copy = new CommandContextBuilder<S>(
+			this.dispatcher,
+			this.source,
+			this.rootNode,
+			this.range.getStart(),
+		);
+		copy.command = this.command;
+		copy.child = this.child;
+		copy.range = this.range;
+		copy.nodes.push(...this.nodes);
+		this.arguments.forEach((v, k) => {
+			copy.arguments.set(k, v);
+		});
+		return copy;
+	}
+
+	build(input: string): CommandContext<S> {
+		const child = this.child == null ? null : this.child.build(input);
+		return new CommandContext(
+			this.source,
+			input,
+			this.arguments,
+			this.command,
+			this.rootNode,
+			this.nodes,
+			this.range,
+			child,
+			this.modifier,
+			this.forks,
+		);
+	}
+
+	getDispatcher(): CommandDispatcher<S> {
+		return this.dispatcher;
+	}
+
+	getRange(): StringRange {
+		return this.range;
+	}
+
+	findSuggestionContext(cursor: number): SuggestionContext<S> {
+		if (this.range.getStart() <= cursor) {
+			if (this.range.getEnd() < cursor) {
+				if (this.child != null) {
+					return this.child.findSuggestionContext(cursor);
+				} else if (this.nodes.length > 0) {
+					const last = this.nodes[this.nodes.length - 1];
+					return new SuggestionContext(
+						last.getNode(),
+						last.getRange().getEnd() + 1,
+					);
+				} else {
+					return new SuggestionContext(this.rootNode, this.range.getStart());
+				}
+			} else {
+				let prev = this.rootNode;
+				for (const node of this.nodes) {
+					const nodeRange = node.getRange();
+					if (nodeRange.getStart() <= cursor && cursor <= nodeRange.getEnd()) {
+						return new SuggestionContext(prev, nodeRange.getStart());
+					}
+					prev = node.getNode();
+				}
+				if (prev === null) {
+					throw new Error("Can't find node before cursor");
+				}
+				return new SuggestionContext(prev, this.range.getStart());
+			}
+		}
+		throw new Error("Can't find node before cursor");
+	}
 }

package/src/context/ParsedArgument.ts

@@ -1,19 +1,19 @@
 import { StringRange } from "..";
 
 export class ParsedArgument<T> {
-    private range: StringRange;
-    private result: T;
-    
-    constructor(start: number, end: number, result: T) {
-        this.range = new StringRange(start, end);
-        this.result = result;
-    }
+	private range: StringRange;
+	private result: T;
 
-    getRange(): StringRange {
-        return this.range;
-    }
+	constructor(start: number, end: number, result: T) {
+		this.range = new StringRange(start, end);
+		this.result = result;
+	}
 
-    getResult(): T {
-        return this.result;
-    }
+	getRange(): StringRange {
+		return this.range;
+	}
+
+	getResult(): T {
+		return this.result;
+	}
 }

package/src/context/ParsedCommandNode.ts

@@ -1,19 +1,19 @@
-import { CommandNode, StringRange } from "..";
+import type { CommandNode, StringRange } from "..";
 
 export class ParsedCommandNode<S> {
-    private node: CommandNode<S>;
-    private range: StringRange;
-    
-    constructor(node: CommandNode<S>, range: StringRange) {
-        this.node = node;
-        this.range = range;
-    }
+	private node: CommandNode<S>;
+	private range: StringRange;
 
-    getNode(): CommandNode<S> {
-        return this.node;
-    }
+	constructor(node: CommandNode<S>, range: StringRange) {
+		this.node = node;
+		this.range = range;
+	}
 
-    getRange(): StringRange {
-        return this.range;
-    }
+	getNode(): CommandNode<S> {
+		return this.node;
+	}
+
+	getRange(): StringRange {
+		return this.range;
+	}
 }

package/src/context/StringRange.ts

@@ -1,35 +1,35 @@
 export class StringRange {
-    private start: number;
-    private end: number;
+	private start: number;
+	private end: number;
 
-    constructor(start: number, end: number) {
-        this.start = start;
-        this.end = end;
-    }
+	constructor(start: number, end: number) {
+		this.start = start;
+		this.end = end;
+	}
 
-    static at(pos: number): StringRange {
-        return new StringRange(pos, pos);
-    }
+	static at(pos: number): StringRange {
+		return new StringRange(pos, pos);
+	}
 
-    static encompassing(a: StringRange, b: StringRange): StringRange {
-        const start = Math.min(a.getStart(), b.getStart());
-        const end = Math.max(a.getEnd(), b.getEnd());
-        return new StringRange(start, end)
-    }
+	static encompassing(a: StringRange, b: StringRange): StringRange {
+		const start = Math.min(a.getStart(), b.getStart());
+		const end = Math.max(a.getEnd(), b.getEnd());
+		return new StringRange(start, end);
+	}
 
-    getStart(): number {
-        return this.start;
-    }
+	getStart(): number {
+		return this.start;
+	}
 
-    getEnd(): number {
-        return this.end;
-    }
+	getEnd(): number {
+		return this.end;
+	}
 
-    isEmpty(): boolean {
-        return this.start === this.end;
-    }
+	isEmpty(): boolean {
+		return this.start === this.end;
+	}
 
-    getLength(): number {
-        return this.end - this.start;
-    }
+	getLength(): number {
+		return this.end - this.start;
+	}
 }

package/src/context/SuggestionContext.ts

@@ -1,11 +1,11 @@
-import { CommandNode } from "..";
+import type { CommandNode } from "..";
 
 export class SuggestionContext<S> {
-    parent: CommandNode<S>;
-    startPos: number;
+	parent: CommandNode<S>;
+	startPos: number;
 
-    constructor(parent: CommandNode<S>, startPos: number) {
-        this.parent = parent;
-        this.startPos = startPos;
-    }
+	constructor(parent: CommandNode<S>, startPos: number) {
+		this.parent = parent;
+		this.startPos = startPos;
+	}
 }

package/src/exceptions/CommandErrorType.ts

@@ -1,20 +1,27 @@
-import { CommandSyntaxError, StringReader } from "..";
+import { CommandSyntaxError, type StringReader } from "..";
 
 type CommandErrorFunction = (...args: any[]) => string;
 
 export class CommandErrorType {
-    private func: CommandErrorFunction
-    constructor(func: CommandErrorFunction) {
-        this.func = func;
-    }
+	private func: CommandErrorFunction;
+	constructor(func: CommandErrorFunction) {
+		this.func = func;
+	}
 
-    create(...args: any[]): CommandSyntaxError {
-        const message = this.func(...args);
-        return new CommandSyntaxError(message);
-    }
+	create(...args: unknown[]): CommandSyntaxError {
+		const message = this.func(...args);
+		return new CommandSyntaxError(message);
+	}
 
-    createWithContext(reader: StringReader, ...args: any[]): CommandSyntaxError {
-        const message = this.func(...args);
-        return new CommandSyntaxError(message, reader.getString(), reader.getCursor());
-    }
+	createWithContext(
+		reader: StringReader,
+		...args: unknown[]
+	): CommandSyntaxError {
+		const message = this.func(...args);
+		return new CommandSyntaxError(
+			message,
+			reader.getString(),
+			reader.getCursor(),
+		);
+	}
 }

package/src/exceptions/CommandSyntaxError.ts

@@ -3,46 +3,87 @@ import { CommandErrorType } from "..";
 const CONTEXT_AMOUNT = 10;
 
 export class CommandSyntaxError extends Error {
-    private input: string;
-    private cursor: number;
+	private input: string;
+	private cursor: number;
 
-    constructor(message: string, input?: string, cursor?: number) {
-        super(message);
-        Object.setPrototypeOf(this, CommandSyntaxError.prototype);
-        this.input = input;
-        this.cursor = cursor;
+	constructor(message: string, input?: string, cursor?: number) {
+		super(message);
+		Object.setPrototypeOf(this, CommandSyntaxError.prototype);
+		this.input = input;
+		this.cursor = cursor;
 
-        if (input && cursor >= 0) {
-            this.message += ` at position ${cursor}: `;
-            const cursor2 = Math.min(this.input.length, this.cursor);
-            this.message += cursor > CONTEXT_AMOUNT ? "..." : "";
-            this.message += this.input.substring(Math.max(0, cursor2 - CONTEXT_AMOUNT), cursor2);
-            this.message += "<--[HERE]";
-        }
-    }
+		if (input && cursor >= 0) {
+			this.message += ` at position ${cursor}: `;
+			const cursor2 = Math.min(this.input.length, this.cursor);
+			this.message += cursor > CONTEXT_AMOUNT ? "..." : "";
+			this.message += this.input.substring(
+				Math.max(0, cursor2 - CONTEXT_AMOUNT),
+				cursor2,
+			);
+			this.message += "<--[HERE]";
+		}
+	}
 
-    static DOUBLE_TOO_SMALL = new CommandErrorType((found, min) => `Double must not be less than ${min}, found ${found}`);
-    static DOUBLE_TOO_BIG = new CommandErrorType((found, max) => `Double must not be more than ${max}, found ${found}`);
-    static FLOAT_TOO_SMALL = new CommandErrorType((found, min) => `Float must not be less than ${min}, found ${found}`);
-    static FLOAT_TOO_BIG = new CommandErrorType((found, max) => `Float must not be more than ${max}, found ${found}`);
-    static INTEGER_TOO_SMALL = new CommandErrorType((found, min) => `Integer must not be less than ${min}, found ${found}`);
-    static INTEGER_TOO_BIG = new CommandErrorType((found, max) => `Integer must not be more than ${max}, found ${found}`);
-    static LONG_TOO_SMALL = new CommandErrorType((found, min) => `Long must not be less than ${min}, found ${found}`);
-    static LONG_TOO_BIG = new CommandErrorType((found, max) => `Long must not be more than ${max}, found ${found}`);
-    static LITERAL_INCORRECT = new CommandErrorType((expected) => `Expected literal ${expected}`);
+	static DOUBLE_TOO_SMALL = new CommandErrorType(
+		(found, min) => `Double must not be less than ${min}, found ${found}`,
+	);
+	static DOUBLE_TOO_BIG = new CommandErrorType(
+		(found, max) => `Double must not be more than ${max}, found ${found}`,
+	);
+	static FLOAT_TOO_SMALL = new CommandErrorType(
+		(found, min) => `Float must not be less than ${min}, found ${found}`,
+	);
+	static FLOAT_TOO_BIG = new CommandErrorType(
+		(found, max) => `Float must not be more than ${max}, found ${found}`,
+	);
+	static INTEGER_TOO_SMALL = new CommandErrorType(
+		(found, min) => `Integer must not be less than ${min}, found ${found}`,
+	);
+	static INTEGER_TOO_BIG = new CommandErrorType(
+		(found, max) => `Integer must not be more than ${max}, found ${found}`,
+	);
+	static LONG_TOO_SMALL = new CommandErrorType(
+		(found, min) => `Long must not be less than ${min}, found ${found}`,
+	);
+	static LONG_TOO_BIG = new CommandErrorType(
+		(found, max) => `Long must not be more than ${max}, found ${found}`,
+	);
+	static LITERAL_INCORRECT = new CommandErrorType(
+		(expected) => `Expected literal ${expected}`,
+	);
 
-    static READER_EXPECTED_START_OF_QUOTE = new CommandErrorType(() => `Expected quote to start a string`);
-    static READER_EXPECTED_END_OF_QUOTE = new CommandErrorType(() => `Unclosed quoted string`);
-    static READER_INVALID_ESCAPE = new CommandErrorType((character) => `Invalid escape sequence '${character}' in quoted string`);
-    static READER_INVALID_BOOL = new CommandErrorType((value) => `Invalid bool, expected true or false but found '${value}'`);
-    static READER_EXPECTED_BOOL = new CommandErrorType(() => `Expected bool`);
-    static READER_INVALID_INT = new CommandErrorType((value) => `Invalid integer '${value}'`);
-    static READER_EXPECTED_INT = new CommandErrorType(() => `Expected integer`);
-    static READER_INVALID_FLOAT = new CommandErrorType((value) => `Invalid float '${value}'`);
-    static READER_EXPECTED_FLOAT = new CommandErrorType(() => `Expected float`);
+	static READER_EXPECTED_START_OF_QUOTE = new CommandErrorType(
+		() => `Expected quote to start a string`,
+	);
+	static READER_EXPECTED_END_OF_QUOTE = new CommandErrorType(
+		() => `Unclosed quoted string`,
+	);
+	static READER_INVALID_ESCAPE = new CommandErrorType(
+		(character) => `Invalid escape sequence '${character}' in quoted string`,
+	);
+	static READER_INVALID_BOOL = new CommandErrorType(
+		(value) => `Invalid bool, expected true or false but found '${value}'`,
+	);
+	static READER_EXPECTED_BOOL = new CommandErrorType(() => `Expected bool`);
+	static READER_INVALID_INT = new CommandErrorType(
+		(value) => `Invalid integer '${value}'`,
+	);
+	static READER_EXPECTED_INT = new CommandErrorType(() => `Expected integer`);
+	static READER_INVALID_FLOAT = new CommandErrorType(
+		(value) => `Invalid float '${value}'`,
+	);
+	static READER_EXPECTED_FLOAT = new CommandErrorType(() => `Expected float`);
 
-    static DISPATCHER_UNKNOWN_COMMAND = new CommandErrorType(() => `Unknown Command`);
-    static DISPATCHER_UNKNOWN_ARGUMENT = new CommandErrorType(() => `Incorrect argument for command`);
-    static DISPATCHER_EXPECTED_ARGUMENT_SEPARATOR = new CommandErrorType(() => `Expected whitespace to end one argument, but found trailing data`);
-    static DISPATCHER_PARSE_ERROR = new CommandErrorType((message) => `Could not parse command: ${message}`);
+	static DISPATCHER_UNKNOWN_COMMAND = new CommandErrorType(
+		() => `Unknown Command`,
+	);
+	static DISPATCHER_UNKNOWN_ARGUMENT = new CommandErrorType(
+		() => `Incorrect argument for command`,
+	);
+	static DISPATCHER_EXPECTED_ARGUMENT_SEPARATOR = new CommandErrorType(
+		() => `Expected whitespace to end one argument, but found trailing data`,
+	);
+	static DISPATCHER_PARSE_ERROR = new CommandErrorType(
+		(message) => `Could not parse command: ${message}`,
+	);
 }