@wq2/brigadier-ts 1.0.0 → 1.0.2

package/src/tree/CommandNode.ts

@@ -1,105 +1,114 @@
 import {
-    StringReader,
-    Command,
-    LiteralCommandNode,
-    ArgumentCommandNode,
-    CommandContext,
-    CommandContextBuilder,
-    Predicate,
-    RedirectModifier,
-    SuggestionsBuilder,
-    Suggestions
-} from '..';
+	type StringReader,
+	type Command,
+	LiteralCommandNode,
+	ArgumentCommandNode,
+	type CommandContext,
+	type CommandContextBuilder,
+	type Predicate,
+	type RedirectModifier,
+	type SuggestionsBuilder,
+	type Suggestions,
+} from "..";
 
 export abstract class CommandNode<S> {
-    private children: Map<string, CommandNode<S>>;
-    private literals: Map<string, LiteralCommandNode<S>>;
-    private arguments: Map<string, ArgumentCommandNode<S, any>>;
-    private command: Command<S>;
-    private requirement: Predicate<S>;
-    private redirect: CommandNode<S>;
-    private modifier: RedirectModifier<S>;
-    private forks: boolean;
+	private children: Map<string, CommandNode<S>>;
+	private literals: Map<string, LiteralCommandNode<S>>;
+	private arguments: Map<string, ArgumentCommandNode<S, any>>;
+	private command: Command<S>;
+	private requirement: Predicate<S>;
+	private redirect: CommandNode<S>;
+	private modifier: RedirectModifier<S>;
+	private forks: boolean;
 
-    constructor(command: Command<S>, requirement: Predicate<S>, redirect: CommandNode<S>, modifier: RedirectModifier<S>, forks: boolean) {
-        this.children = new Map();
-        this.literals = new Map();
-        this.arguments = new Map();
-        this.command = command;
-        this.requirement = requirement;
-        this.redirect = redirect;
-        this.modifier = modifier;
-        this.forks = forks;
-    }
+	constructor(
+		command: Command<S>,
+		requirement: Predicate<S>,
+		redirect: CommandNode<S>,
+		modifier: RedirectModifier<S>,
+		forks: boolean,
+	) {
+		this.children = new Map();
+		this.literals = new Map();
+		this.arguments = new Map();
+		this.command = command;
+		this.requirement = requirement;
+		this.redirect = redirect;
+		this.modifier = modifier;
+		this.forks = forks;
+	}
 
-    getCommand(): Command<S> {
-        return this.command;
-    }
+	getCommand(): Command<S> {
+		return this.command;
+	}
 
-    getChildren(): CommandNode<S>[] {
-        return Array.from(this.children.values());
-    }
+	getChildren(): CommandNode<S>[] {
+		return Array.from(this.children.values());
+	}
 
-    getChild(name: string): CommandNode<S> {
-        return this.children.get(name);
-    }
+	getChild(name: string): CommandNode<S> {
+		return this.children.get(name);
+	}
 
-    getRedirect(): CommandNode<S> {
-        return this.redirect;
-    }
+	getRedirect(): CommandNode<S> {
+		return this.redirect;
+	}
 
-    getRedirectModifier(): RedirectModifier<S> {
-        return this.modifier;
-    }
+	getRedirectModifier(): RedirectModifier<S> {
+		return this.modifier;
+	}
 
-    isFork(): boolean {
-        return this.forks;
-    }
+	isFork(): boolean {
+		return this.forks;
+	}
 
-    canUse(source: S) {
-        return this.requirement(source);
-    }
+	canUse(source: S) {
+		return this.requirement(source);
+	}
 
-    addChild(node: CommandNode<S>): void {
-        const child = this.children.get(node.getName());
-        if (child != null) {
-            if (node.getCommand() != null) {
-                child.command = node.getCommand();
-            }
-            node.getChildren().forEach((grandChild) => {
-                child.addChild(grandChild);
-            });
-        } else {
-            this.children.set(node.getName(), node);
-            if (node instanceof LiteralCommandNode) {
-                this.literals.set(node.getName(), node);
-            } else if (node instanceof ArgumentCommandNode) {
-                this.arguments.set(node.getName(), node);
-            }
-        }
-    }
+	addChild(node: CommandNode<S>): void {
+		const child = this.children.get(node.getName());
+		if (child != null) {
+			if (node.getCommand() != null) {
+				child.command = node.getCommand();
+			}
+			node.getChildren().forEach((grandChild) => {
+				child.addChild(grandChild);
+			});
+		} else {
+			this.children.set(node.getName(), node);
+			if (node instanceof LiteralCommandNode) {
+				this.literals.set(node.getName(), node);
+			} else if (node instanceof ArgumentCommandNode) {
+				this.arguments.set(node.getName(), node);
+			}
+		}
+	}
 
-    abstract parse(reader: StringReader, context: CommandContextBuilder<S>): void;
+	abstract parse(reader: StringReader, context: CommandContextBuilder<S>): void;
 
-    abstract getName(): string;
+	abstract getName(): string;
 
-    abstract getUsageText(): string;
+	abstract getUsageText(): string;
 
-    abstract listSuggestions(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions>;
+	abstract listSuggestions(
+		context: CommandContext<S>,
+		builder: SuggestionsBuilder,
+	): Promise<Suggestions>;
 
-    getRelevantNodes(input: StringReader): CommandNode<S>[] {
-        if (this.literals.size > 0) {
-            const cursor = input.getCursor();
-            while (input.canRead() && input.peek() != " ") {
-                input.skip();
-            }
-            const text = input.getString().substring(cursor, input.getCursor());
-            input.setCursor(cursor);
-            const literal = this.literals.get(text);
-            if (literal != null) {
-                return [literal];
-            }
-        }
-        return Array.from(this.arguments.values());
-    }
+	getRelevantNodes(input: StringReader): CommandNode<S>[] {
+		if (this.literals.size > 0) {
+			const cursor = input.getCursor();
+			while (input.canRead() && input.peek() !== " ") {
+				input.skip();
+			}
+			const text = input.getString().substring(cursor, input.getCursor());
+			input.setCursor(cursor);
+			const literal = this.literals.get(text);
+			if (literal != null) {
+				return [literal];
+			}
+		}
+		return Array.from(this.arguments.values());
+	}
 }

package/src/tree/LiteralCommandNode.ts

@@ -1,64 +1,85 @@
-import { 
-    CommandNode,
-    StringReader,
-    Command,
-    StringRange,
-    CommandContext,
-    CommandContextBuilder,
-    Predicate,
-    RedirectModifier,
-    CommandSyntaxError,
-    Suggestions,
-    SuggestionsBuilder
-} from '..';
+import {
+	CommandNode,
+	type StringReader,
+	type Command,
+	StringRange,
+	type CommandContext,
+	type CommandContextBuilder,
+	type Predicate,
+	type RedirectModifier,
+	CommandSyntaxError,
+	Suggestions,
+	type SuggestionsBuilder,
+} from "..";
 
 export class LiteralCommandNode<S> extends CommandNode<S> {
-    private literal: string;
-    
-    constructor(literal: string, command: Command<S>, requirement: Predicate<S>, redirect: CommandNode<S>, modifier: RedirectModifier<S>, forks: boolean) {
-        super(command, requirement, redirect, modifier, forks);
-        this.literal = literal;
-    }
+	private literal: string;
 
-    parse(reader: StringReader, contextBuilder: CommandContextBuilder<S>): void {
-        const start = reader.getCursor();
-        const end = this.parseInternal(reader);
-        if (end > -1) {
-            contextBuilder.withNode(this, new StringRange(start, end));
-            return;
-        }
-        throw CommandSyntaxError.LITERAL_INCORRECT.createWithContext(reader, this.literal);
-    }
+	constructor(
+		literal: string,
+		command: Command<S>,
+		requirement: Predicate<S>,
+		redirect: CommandNode<S>,
+		modifier: RedirectModifier<S>,
+		forks: boolean,
+	) {
+		super(command, requirement, redirect, modifier, forks);
+		this.literal = literal;
+	}
 
-    private parseInternal(reader: StringReader): number {
-        const start = reader.getCursor();
-        if (reader.canRead(this.literal.length)) {
-            const end = start + this.literal.length;
-            if (reader.getString().substr(start, this.literal.length) === this.literal) {
-                reader.setCursor(end);
-                if (!reader.canRead() || reader.peek() == " ") {
-                    return end;
-                } else {
-                    reader.setCursor(start);
-                }
-            }
-        }
-        return -1;
-    }
-    
-    getName(): string {
-        return this.literal;
-    }
+	parse(reader: StringReader, contextBuilder: CommandContextBuilder<S>): void {
+		const start = reader.getCursor();
+		const end = this.parseInternal(reader);
+		if (end > -1) {
+			contextBuilder.withNode(this, new StringRange(start, end));
+			return;
+		}
+		throw CommandSyntaxError.LITERAL_INCORRECT.createWithContext(
+			reader,
+			this.literal,
+		);
+	}
 
-    getUsageText(): string {
-        return this.literal;
-    }
+	private parseInternal(reader: StringReader): number {
+		const start = reader.getCursor();
+		if (reader.canRead(this.literal.length)) {
+			const end = start + this.literal.length;
+			if (
+				reader.getString().substring(start, this.literal.length) ===
+				this.literal
+			) {
+				reader.setCursor(end);
+				if (!reader.canRead() || reader.peek() === " ") {
+					return end;
+				} else {
+					reader.setCursor(start);
+				}
+			}
+		}
+		return -1;
+	}
 
-    listSuggestions(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions> {
-        if (this.literal.toLowerCase().startsWith(builder.getRemaining().toLowerCase())) {
-            return builder.suggest(this.literal).buildPromise();
-        } else {
-            return Suggestions.empty();
-        }
-    }
+	getName(): string {
+		return this.literal;
+	}
+
+	getUsageText(): string {
+		return this.literal;
+	}
+
+	listSuggestions(
+		// biome-ignore lint/correctness/noUnusedFunctionParameters: yes
+		context: CommandContext<S>,
+		builder: SuggestionsBuilder,
+	): Promise<Suggestions> {
+		if (
+			this.literal
+				.toLowerCase()
+				.startsWith(builder.getRemaining().toLowerCase())
+		) {
+			return builder.suggest(this.literal).buildPromise();
+		} else {
+			return Suggestions.empty();
+		}
+	}
 }

package/src/tree/RootCommandNode.ts

@@ -1,30 +1,40 @@
-import { 
-    CommandNode,
-    StringReader,
-    CommandContextBuilder,
-    CommandContext,
-    Suggestions,
-    SuggestionsBuilder
-} from '..';
+import {
+	CommandNode,
+	type StringReader,
+	type CommandContextBuilder,
+	type CommandContext,
+	Suggestions,
+	type SuggestionsBuilder,
+} from "..";
 
 export class RootCommandNode<S> extends CommandNode<S> {
+	constructor() {
+		super(
+			null,
+			async (_) => true,
+			null,
+			(_) => null,
+			false,
+		);
+	}
 
-    constructor() {
-        super(null, async c => true, null, c => null, false);
-    }
+	// biome-ignore lint/correctness/noUnusedFunctionParameters: no-op
+	parse(reader: StringReader, contextBuilder: CommandContextBuilder<S>): void {}
 
-    parse(reader: StringReader, contextBuilder: CommandContextBuilder<S>): void {
-    }
+	getName(): string {
+		return "";
+	}
 
-    getName(): string {
-        return "";
-    }
+	getUsageText(): string {
+		return "";
+	}
 
-    getUsageText(): string {
-        return "";
-    }
-
-    listSuggestions(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions> {
-        return Suggestions.empty();
-    }
+	listSuggestions(
+		// biome-ignore lint/correctness/noUnusedFunctionParameters: no-op
+		context: CommandContext<S>,
+		// biome-ignore lint/correctness/noUnusedFunctionParameters: no-op
+		builder: SuggestionsBuilder,
+	): Promise<Suggestions> {
+		return Suggestions.empty();
+	}
 }

package/test/Arguments.test.ts

@@ -1,36 +1,50 @@
-import { argument, CommandDispatcher, FloatArgumentType, IntegerArgumentType, literal, LongArgumentType } from '../src'
+import {
+	argument,
+	bool,
+	CommandDispatcher,
+	FloatArgumentType,
+	IntegerArgumentType,
+	literal,
+	LongArgumentType,
+} from "../src";
 
-describe('Arguments', () => {
-	test('Integer', async () => {
-		const dispatcher = new CommandDispatcher()
-		dispatcher.register(literal('foo')
-			.then(argument('bar', new IntegerArgumentType())
-				.executes(async ctx => ctx.get('bar') * 2)
-			)
-		)
-		const result = await dispatcher.execute('foo 6', undefined)
-		expect(result).toEqual(12)
-	})
+describe("Arguments", () => {
+	test("Integer", async () => {
+		const dispatcher = new CommandDispatcher();
+		dispatcher.register(
+			literal("foo").then(
+				argument("bar", new IntegerArgumentType()).executes(
+					async (ctx) => ctx.get("bar") * 2,
+				),
+			),
+		);
+		const result = await dispatcher.execute("foo 6", undefined);
+		expect(result).toEqual(12);
+	});
 
-	test('Long', async () => {
-		const dispatcher = new CommandDispatcher()
-		dispatcher.register(literal('foo')
-			.then(argument('bar', new LongArgumentType())
-				.executes(async ctx => ctx.get('bar').toString().length)
-			)
-		)
-		const result = await dispatcher.execute('foo 123456789012345', undefined)
-		expect(result).toEqual(15)
-	})
+	test("Long", async () => {
+		const dispatcher = new CommandDispatcher();
+		dispatcher.register(
+			literal("foo").then(
+				argument("bar", new LongArgumentType()).executes(
+					async (ctx) => ctx.get("bar").toString().length,
+				),
+			),
+		);
+		const result = await dispatcher.execute("foo 123456789012345", undefined);
+		expect(result).toEqual(15);
+	});
 
-	test('Float', async () => {
-		const dispatcher = new CommandDispatcher()
-		dispatcher.register(literal('foo')
-			.then(argument('bar', new FloatArgumentType())
-				.executes(async ctx => Math.floor(ctx.get('bar')))
-			)
-		)
-		const result = await dispatcher.execute('foo 6.2', undefined)
-		expect(result).toEqual(6)
-	})
-})
+	test("Float", async () => {
+		const dispatcher = new CommandDispatcher();
+		dispatcher.register(
+			literal("foo").then(
+				argument("bar", new FloatArgumentType()).executes(async (ctx) =>
+					Math.floor(ctx.get("bar")),
+				),
+			),
+		);
+		const result = await dispatcher.execute("foo 6.2", undefined);
+		expect(result).toEqual(6);
+	});
+});

package/test/CommandDispatcher.test.ts

@@ -1,25 +1,21 @@
-import { CommandDispatcher, literal } from '../src'
+import { CommandDispatcher, literal } from "../src";
 
-describe('CommandDispatcher', () => {
-	test('create', () => {
-		const dispatcher = new CommandDispatcher()
-	})
+describe("CommandDispatcher", () => {
+	test("create", () => {
+		new CommandDispatcher();
+	});
 
-	test('execute', async () => {
-		const dispatcher = new CommandDispatcher()
-		dispatcher.register(literal('foo')
-			.executes(async () => 2)
-		)
-		const result = await dispatcher.execute('foo', undefined)
-		expect(result).toEqual(2)
-	})
+	test("execute", async () => {
+		const dispatcher = new CommandDispatcher();
+		dispatcher.register(literal("foo").executes(async () => 2));
+		const result = await dispatcher.execute("foo", undefined);
+		expect(result).toEqual(2);
+	});
 
-	test('execute (zero result)', async () => {
-		const dispatcher = new CommandDispatcher()
-		dispatcher.register(literal('foo')
-			.executes(async () => 0)
-		)
-		const result = await dispatcher.execute('foo', undefined)
-		expect(result).toEqual(0)
-	})
-})
+	test("execute (zero result)", async () => {
+		const dispatcher = new CommandDispatcher();
+		dispatcher.register(literal("foo").executes(async () => 0));
+		const result = await dispatcher.execute("foo", undefined);
+		expect(result).toEqual(0);
+	});
+});

package/test/StringReader.test.ts

@@ -1,47 +1,47 @@
-import { StringReader } from '../src/StringReader'
-
-describe('StringReader', () => {
-	test('readInt', () => {
-		const reader = new StringReader('5')
-		const value = reader.readInt()
-		expect(value).toEqual(5)
-	})
-
-	test('readInt (trailing)', () => {
-		const reader = new StringReader('5a')
-		const value = reader.readInt()
-		expect(value).toEqual(5)
-		expect(reader.getCursor()).toEqual(1)
-	})
-
-	test('readInt (NaN)', () => {
-		const reader = new StringReader('5-')
-		expect(() => reader.readInt()).toThrow('Invalid integer')
-	})
-
-	test('readInt (invalid)', () => {
-		const reader = new StringReader('a')
-		expect(() => reader.readInt()).toThrow('Expected integer')
-	})
-
-	test('readInt (float)', () => {
-		const reader = new StringReader('1.3')
-		expect(() => reader.readInt()).toThrow('Invalid integer')
-	})
-
-	test('readFloat', () => {
-		const reader = new StringReader('1.3')
-		const value = reader.readFloat()
-		expect(value).toEqual(1.3)
-	})
-
-	test('readFloat (NaN)', () => {
-		const reader = new StringReader('1.3-')
-		expect(() => reader.readFloat()).toThrow('Invalid float')
-	})
-
-	test('readFloat (invalid)', () => {
-		const reader = new StringReader('sw')
-		expect(() => reader.readFloat()).toThrow('Expected float')
-	})
-})
+import { StringReader } from "../src/StringReader";
+
+describe("StringReader", () => {
+	test("readInt", () => {
+		const reader = new StringReader("5");
+		const value = reader.readInt();
+		expect(value).toEqual(5);
+	});
+
+	test("readInt (trailing)", () => {
+		const reader = new StringReader("5a");
+		const value = reader.readInt();
+		expect(value).toEqual(5);
+		expect(reader.getCursor()).toEqual(1);
+	});
+
+	test("readInt (NaN)", () => {
+		const reader = new StringReader("5-");
+		expect(() => reader.readInt()).toThrow("Invalid integer");
+	});
+
+	test("readInt (invalid)", () => {
+		const reader = new StringReader("a");
+		expect(() => reader.readInt()).toThrow("Expected integer");
+	});
+
+	test("readInt (float)", () => {
+		const reader = new StringReader("1.3");
+		expect(() => reader.readInt()).toThrow("Invalid integer");
+	});
+
+	test("readFloat", () => {
+		const reader = new StringReader("1.3");
+		const value = reader.readFloat();
+		expect(value).toEqual(1.3);
+	});
+
+	test("readFloat (NaN)", () => {
+		const reader = new StringReader("1.3-");
+		expect(() => reader.readFloat()).toThrow("Invalid float");
+	});
+
+	test("readFloat (invalid)", () => {
+		const reader = new StringReader("sw");
+		expect(() => reader.readFloat()).toThrow("Expected float");
+	});
+});

package/tsconfig.json

@@ -1,16 +1,11 @@
 {
-    "compilerOptions": {
-        "target": "es5",
-        "module": "commonjs",
-        "lib": [ "es2015", "dom" ],
-        "declaration": true,
-        "outDir": "dist"
-    },
-    "include": [
-        "src"
-    ],
-    "exclude": [
-        "node_modules",
-        "dist"
-    ]
+	"compilerOptions": {
+		"target": "es2020",
+		"module": "commonjs",
+		"lib": ["ES2020", "dom"],
+		"declaration": true,
+		"outDir": "dist"
+	},
+	"include": ["src"],
+	"exclude": ["node_modules", "dist"]
 }