@wq2/brigadier-ts 1.0.0 → 1.0.2

package/src/ParseResults.ts

@@ -1,30 +1,34 @@
-import {
-    CommandContextBuilder,
-    StringReader,
-    CommandNode,
-    CommandSyntaxError
+import type {
+	CommandContextBuilder,
+	StringReader,
+	CommandNode,
+	CommandSyntaxError,
 } from ".";
 
 export class ParseResults<S> {
-    private context: CommandContextBuilder<S>;
-    private reader: StringReader;
-    private errors: Map<CommandNode<S>, CommandSyntaxError>;
+	private context: CommandContextBuilder<S>;
+	private reader: StringReader;
+	private errors: Map<CommandNode<S>, CommandSyntaxError>;
 
-    constructor(context: CommandContextBuilder<S>, reader: StringReader, errors: Map<CommandNode<S>, CommandSyntaxError>) {
-        this.context = context;
-        this.reader = reader;
-        this.errors = errors;
-    }
+	constructor(
+		context: CommandContextBuilder<S>,
+		reader: StringReader,
+		errors: Map<CommandNode<S>, CommandSyntaxError>,
+	) {
+		this.context = context;
+		this.reader = reader;
+		this.errors = errors;
+	}
 
-    getContext(): CommandContextBuilder<S> {
-        return this.context;
-    }
+	getContext(): CommandContextBuilder<S> {
+		return this.context;
+	}
 
-    getReader(): StringReader {
-        return this.reader;
-    }
+	getReader(): StringReader {
+		return this.reader;
+	}
 
-    getErrors(): Map<CommandNode<S>, CommandSyntaxError> {
-        return this.errors;
-    }
+	getErrors(): Map<CommandNode<S>, CommandSyntaxError> {
+		return this.errors;
+	}
 }

package/src/StringReader.ts

@@ -1,197 +1,216 @@
 import { CommandSyntaxError } from "./exceptions/CommandSyntaxError";
 
 export class StringReader {
-    private string: string;
-    private cursor: number;
-
-    constructor(string: string | StringReader) {
-        if (string instanceof StringReader) {
-            this.string = string.getString();
-            this.cursor = string.getCursor();
-        } else {
-            this.string = string;
-            this.cursor = 0;
-        }
-    }
-
-    getString(): string {
-        return this.string;
-    }
-
-    getCursor(): number {
-        return this.cursor;
-    }
-
-    setCursor(cursor: number): void {
-        this.cursor = cursor;
-    }
-
-    getRemainingLength(): number {
-        return this.string.length - this.cursor;
-    }
-
-    getTotalLength(): number {
-        return this.string.length;
-    }
-
-    getRead(): string {
-        return this.string.substring(0, this.cursor);
-    }
-
-    getRemaining(): string {
-        return this.string.substring(this.cursor);
-    }
-
-    canRead(length = 1): boolean {
-        return this.cursor + length <= this.string.length;
-    }
-
-    peek(offset = 0): string {
-        return this.string.charAt(this.cursor + offset);
-    }
-
-    read(): string {
-        const char =  this.string.charAt(this.cursor);
-        this.cursor += 1;
-        return char;
-    }
-
-    skip(): void {
-        this.cursor += 1;
-    }
-
-    isAllowedNumber(c: string): boolean {
-        return c >= "0" && c <= "9" || c === "." || c === "-";
-    }
-
-    readInt(): number {
-        const start = this.cursor;
-        while (this.canRead() && this.isAllowedNumber(this.peek())) {
-            this.skip();
-        }
-        const number = this.string.substring(start, this.cursor);
-        if (number.length === 0) {
-            throw CommandSyntaxError.READER_EXPECTED_INT.createWithContext(this);
-        }
-        try {
-            const value = Number(number);
-            if (isNaN(value) || !Number.isInteger(value)) {
-                throw new Error()
-            }
-            return value
-        } catch (e) {
-            this.cursor = start;
-            throw CommandSyntaxError.READER_INVALID_INT.createWithContext(this, number);
-        }
-    }
-
-    readLong(): BigInt {
-        const start = this.cursor;
-        while (this.canRead() && this.isAllowedNumber(this.peek())) {
-            this.skip();
-        }
-        const number = this.string.substring(start, this.cursor);
-        if (number.length === 0) {
-            throw CommandSyntaxError.READER_EXPECTED_INT.createWithContext(this);
-        }
-        try {
-            return BigInt(number);
-        } catch (e) {
-            this.cursor = start;
-            throw CommandSyntaxError.READER_INVALID_INT.createWithContext(this, number);
-        }
-    }
-
-    readFloat(): number {
-        const start = this.cursor;
-        while (this.canRead() && this.isAllowedNumber(this.peek())) {
-            this.skip();
-        }
-        const number = this.string.substring(start, this.cursor);
-        if (number.length === 0) {
-            throw CommandSyntaxError.READER_EXPECTED_FLOAT.createWithContext(this);
-        }
-        try {
-            const value = Number(number);
-            if (isNaN(value)) {
-                throw new Error()
-            }
-            return value
-        } catch (e) {
-            this.cursor = start;
-            throw CommandSyntaxError.READER_INVALID_FLOAT.createWithContext(this, number);
-        }
-    }
-
-    isAllowedInUnquotedString(c: string): boolean {
-        return c >= "0" && c <= "9"
-            || c >= "A" && c <= "Z"
-            || c >= "a" && c <= "z"
-            || c == "_" || c == "-"
-            || c == "." || c == "+";
-    }
-
-    isQuotedStringStart(c: string): boolean {
-        return c === "'" || c === "\"";
-    }
-
-    readUnquotedString(): string {
-        const start = this.cursor;
-        while (this.canRead() && this.isAllowedInUnquotedString(this.peek())) {
-            this.skip();
-        }
-        return this.string.substring(start, this.cursor);
-    }
-
-    readStringUntil(terminator: string): string {
-        let result = [];
-        let escaped = false;
-        while (this.canRead()) {
-            const c = this.read();
-            if (escaped) {
-                if (c === terminator || c === "\\") {
-                    result.push(c);
-                    escaped = false;
-                } else {
-                    this.setCursor(this.cursor - 1);
-                    throw CommandSyntaxError.READER_INVALID_ESCAPE.createWithContext(this, c);
-                }
-            } else if (c === "\\") {
-                escaped = true;
-            } else if (c === terminator) {
-                return result.join("");
-            } else {
-                result.push(c);
-            }
-        }
-        throw CommandSyntaxError.READER_EXPECTED_END_OF_QUOTE.createWithContext(this);
-    }
-
-    readString(): string {
-        if (!this.canRead()) {
-            return "";
-        }
-        const next = this.peek();
-        if (this.isQuotedStringStart(next)) {
-            this.skip();
-            return this.readStringUntil(next);
-        }
-        return this.readUnquotedString();
-    }
-
-    readBoolean(): boolean {
-        const start = this.cursor;
-        const value = this.readUnquotedString();
-        if (value.length === 0) {
-            throw CommandSyntaxError.READER_EXPECTED_BOOL.createWithContext(this);
-        }
-        if (value === "true") {
-            return true
-        } else if (value === "false") {
-            return false
-        } else {
-            throw CommandSyntaxError.READER_INVALID_BOOL.createWithContext(this, value);
-        }
-    }
-
+	private string: string;
+	private cursor: number;
+
+	constructor(string: string | StringReader) {
+		if (string instanceof StringReader) {
+			this.string = string.getString();
+			this.cursor = string.getCursor();
+		} else {
+			this.string = string;
+			this.cursor = 0;
+		}
+	}
+
+	getString(): string {
+		return this.string;
+	}
+
+	getCursor(): number {
+		return this.cursor;
+	}
+
+	setCursor(cursor: number): void {
+		this.cursor = cursor;
+	}
+
+	getRemainingLength(): number {
+		return this.string.length - this.cursor;
+	}
+
+	getTotalLength(): number {
+		return this.string.length;
+	}
+
+	getRead(): string {
+		return this.string.substring(0, this.cursor);
+	}
+
+	getRemaining(): string {
+		return this.string.substring(this.cursor);
+	}
+
+	canRead(length = 1): boolean {
+		return this.cursor + length <= this.string.length;
+	}
+
+	peek(offset = 0): string {
+		return this.string.charAt(this.cursor + offset);
+	}
+
+	read(): string {
+		const char = this.string.charAt(this.cursor);
+		this.cursor += 1;
+		return char;
+	}
+
+	skip(): void {
+		this.cursor += 1;
+	}
+
+	isAllowedNumber(c: string): boolean {
+		return (c >= "0" && c <= "9") || c === "." || c === "-";
+	}
+
+	readInt(): number {
+		const start = this.cursor;
+		while (this.canRead() && this.isAllowedNumber(this.peek())) {
+			this.skip();
+		}
+		const number = this.string.substring(start, this.cursor);
+		if (number.length === 0) {
+			throw CommandSyntaxError.READER_EXPECTED_INT.createWithContext(this);
+		}
+		try {
+			const value = Number(number);
+			if (Number.isNaN(value) || !Number.isInteger(value)) {
+				throw new Error();
+			}
+			return value;
+		} catch (_) {
+			this.cursor = start;
+			throw CommandSyntaxError.READER_INVALID_INT.createWithContext(
+				this,
+				number,
+			);
+		}
+	}
+
+	readLong(): bigint {
+		const start = this.cursor;
+		while (this.canRead() && this.isAllowedNumber(this.peek())) {
+			this.skip();
+		}
+		const number = this.string.substring(start, this.cursor);
+		if (number.length === 0) {
+			throw CommandSyntaxError.READER_EXPECTED_INT.createWithContext(this);
+		}
+		try {
+			return BigInt(number);
+		} catch (_) {
+			this.cursor = start;
+			throw CommandSyntaxError.READER_INVALID_INT.createWithContext(
+				this,
+				number,
+			);
+		}
+	}
+
+	readFloat(): number {
+		const start = this.cursor;
+		while (this.canRead() && this.isAllowedNumber(this.peek())) {
+			this.skip();
+		}
+		const number = this.string.substring(start, this.cursor);
+		if (number.length === 0) {
+			throw CommandSyntaxError.READER_EXPECTED_FLOAT.createWithContext(this);
+		}
+		try {
+			const value = Number(number);
+			if (Number.isNaN(value)) {
+				throw new Error();
+			}
+			return value;
+		} catch (_e) {
+			this.cursor = start;
+			throw CommandSyntaxError.READER_INVALID_FLOAT.createWithContext(
+				this,
+				number,
+			);
+		}
+	}
+
+	isAllowedInUnquotedString(c: string): boolean {
+		return (
+			(c >= "0" && c <= "9") ||
+			(c >= "A" && c <= "Z") ||
+			(c >= "a" && c <= "z") ||
+			c === "_" ||
+			c === "-" ||
+			c === "." ||
+			c === "+"
+		);
+	}
+
+	isQuotedStringStart(c: string): boolean {
+		return c === "'" || c === '"';
+	}
+
+	readUnquotedString(): string {
+		const start = this.cursor;
+		while (this.canRead() && this.isAllowedInUnquotedString(this.peek())) {
+			this.skip();
+		}
+		return this.string.substring(start, this.cursor);
+	}
+
+	readStringUntil(terminator: string): string {
+		const result = [];
+		let escaped = false;
+		while (this.canRead()) {
+			const c = this.read();
+			if (escaped) {
+				if (c === terminator || c === "\\") {
+					result.push(c);
+					escaped = false;
+				} else {
+					this.setCursor(this.cursor - 1);
+					throw CommandSyntaxError.READER_INVALID_ESCAPE.createWithContext(
+						this,
+						c,
+					);
+				}
+			} else if (c === "\\") {
+				escaped = true;
+			} else if (c === terminator) {
+				return result.join("");
+			} else {
+				result.push(c);
+			}
+		}
+		throw CommandSyntaxError.READER_EXPECTED_END_OF_QUOTE.createWithContext(
+			this,
+		);
+	}
+
+	readString(): string {
+		if (!this.canRead()) {
+			return "";
+		}
+		const next = this.peek();
+		if (this.isQuotedStringStart(next)) {
+			this.skip();
+			return this.readStringUntil(next);
+		}
+		return this.readUnquotedString();
+	}
+
+	readBoolean(): boolean {
+		const value = this.readUnquotedString();
+		if (value.length === 0) {
+			throw CommandSyntaxError.READER_EXPECTED_BOOL.createWithContext(this);
+		}
+		if (value === "true") {
+			return true;
+		} else if (value === "false") {
+			return false;
+		} else {
+			throw CommandSyntaxError.READER_INVALID_BOOL.createWithContext(
+				this,
+				value,
+			);
+		}
+	}
 }

package/src/arguments/ArgumentType.ts

@@ -1,14 +1,19 @@
 import {
-    StringReader,
-    CommandContext,
-    Suggestions,
-    SuggestionsBuilder
+	type StringReader,
+	type CommandContext,
+	Suggestions,
+	type SuggestionsBuilder,
 } from "..";
 
 export abstract class ArgumentType<T> {
-    abstract parse(reader: StringReader): T;
+	abstract parse(reader: StringReader): T;
 
-    listSuggestions(context: CommandContext<any>, builder: SuggestionsBuilder): Promise<Suggestions> {
-        return Suggestions.empty();
-    }
+	listSuggestions(
+		// biome-ignore lint/correctness/noUnusedFunctionParameters: optional override
+		context: CommandContext<any>,
+		// biome-ignore lint/correctness/noUnusedFunctionParameters: optional override
+		builder: SuggestionsBuilder,
+	): Promise<Suggestions> {
+		return Suggestions.empty();
+	}
 }

package/src/arguments/BoolArgumentType.ts

@@ -1,28 +1,29 @@
-import {
-    ArgumentType,
-    StringReader,
-    CommandContext,
-    SuggestionsBuilder,
-    Suggestions
-} from "..";
+import { ArgumentType } from "./ArgumentType";
+import type { StringReader } from "../StringReader";
+import type { CommandContext } from "../context/CommandContext";
+import type { SuggestionsBuilder } from "../suggestion/SuggestionsBuilder";
+import type { Suggestions } from "../suggestion/Suggestions";
 
 export class BoolArgumentType extends ArgumentType<boolean> {
+	parse(reader: StringReader): boolean {
+		return reader.readBoolean();
+	}
 
-    parse(reader: StringReader): boolean {
-        return reader.readBoolean();
-    }
-
-    listSuggestions(context: CommandContext<any>, builder: SuggestionsBuilder): Promise<Suggestions> {
-        if ("true".startsWith(builder.getRemaining().toLowerCase())) {
-            builder.suggest("true");
-        }
-        if ("false".startsWith(builder.getRemaining().toLowerCase())) {
-            builder.suggest("false");
-        }
-        return builder.buildPromise();
-    }
+	listSuggestions(
+		// biome-ignore lint/correctness/noUnusedFunctionParameters: optional override
+		context: CommandContext<any>,
+		builder: SuggestionsBuilder,
+	): Promise<Suggestions> {
+		if ("true".startsWith(builder.getRemaining().toLowerCase())) {
+			builder.suggest("true");
+		}
+		if ("false".startsWith(builder.getRemaining().toLowerCase())) {
+			builder.suggest("false");
+		}
+		return builder.buildPromise();
+	}
 }
 
 export function bool(): BoolArgumentType {
-    return new BoolArgumentType();
+	return new BoolArgumentType();
 }

package/src/arguments/FloatArgumentType.ts

@@ -1,20 +1,19 @@
-import { StringReader, NumberArgumentType, CommandSyntaxError } from "..";
+import { type StringReader, NumberArgumentType, CommandSyntaxError } from "..";
 
 export class FloatArgumentType extends NumberArgumentType {
+	constructor(minimum = -Infinity, maximum = Infinity) {
+		super(minimum, maximum);
+	}
 
-    constructor(minimum = -Infinity, maximum = Infinity) {
-        super(minimum, maximum);
-    }
+	readNumber(reader: StringReader): number {
+		return reader.readFloat();
+	}
 
-    readNumber(reader: StringReader): number {
-        return reader.readFloat();
-    }
+	getTooSmallError() {
+		return CommandSyntaxError.FLOAT_TOO_SMALL;
+	}
 
-    getTooSmallError() {
-        return CommandSyntaxError.FLOAT_TOO_SMALL;
-    }
-
-    getTooBigError() {
-        return CommandSyntaxError.FLOAT_TOO_BIG;
-    }
+	getTooBigError() {
+		return CommandSyntaxError.FLOAT_TOO_BIG;
+	}
 }

package/src/arguments/IntegerArgumentType.ts

@@ -1,20 +1,19 @@
-import { StringReader, NumberArgumentType, CommandSyntaxError } from "..";
+import { type StringReader, NumberArgumentType, CommandSyntaxError } from "..";
 
 export class IntegerArgumentType extends NumberArgumentType {
+	constructor(minimum = -2147483648, maximum = 2147483647) {
+		super(minimum, maximum);
+	}
 
-    constructor(minimum = -2147483648, maximum = 2147483647) {
-        super(minimum, maximum);
-    }
+	readNumber(reader: StringReader): number {
+		return reader.readInt();
+	}
 
-    readNumber(reader: StringReader): number {
-        return reader.readInt();
-    }
-    
-    getTooSmallError() {
-        return CommandSyntaxError.INTEGER_TOO_SMALL;
-    }
+	getTooSmallError() {
+		return CommandSyntaxError.INTEGER_TOO_SMALL;
+	}
 
-    getTooBigError() {
-        return CommandSyntaxError.INTEGER_TOO_BIG;
-    }
+	getTooBigError() {
+		return CommandSyntaxError.INTEGER_TOO_BIG;
+	}
 }

package/src/arguments/LongArgumentType.ts

@@ -1,23 +1,22 @@
-import { StringReader, NumberArgumentType, CommandSyntaxError } from "..";
+import { type StringReader, NumberArgumentType, CommandSyntaxError } from "..";
 
-export class LongArgumentType extends NumberArgumentType<BigInt> {
+export class LongArgumentType extends NumberArgumentType<bigint> {
+	private static readonly MIN = -9223372036854775808n;
+	private static readonly MAX = 9223372036854775807n;
 
-    private static readonly MIN = BigInt("-9223372036854775808")
-    private static readonly MAX = BigInt("9223372036854775807")
+	constructor(minimum = LongArgumentType.MIN, maximum = LongArgumentType.MAX) {
+		super(minimum, maximum);
+	}
 
-    constructor(minimum = LongArgumentType.MIN, maximum = LongArgumentType.MAX) {
-        super(minimum, maximum);
-    }
+	readNumber(reader: StringReader): bigint {
+		return reader.readLong();
+	}
 
-    readNumber(reader: StringReader): BigInt {
-        return reader.readLong();
-    }
+	getTooSmallError() {
+		return CommandSyntaxError.LONG_TOO_SMALL;
+	}
 
-    getTooSmallError() {
-        return CommandSyntaxError.LONG_TOO_SMALL;
-    }
-
-    getTooBigError() {
-        return CommandSyntaxError.LONG_TOO_BIG;
-    }
+	getTooBigError() {
+		return CommandSyntaxError.LONG_TOO_BIG;
+	}
 }