@wq2/brigadier-ts 1.0.2 → 1.0.4

package/src/builder/ArgumentBuilder.ts

@@ -1,10 +1,8 @@
-import {
-	CommandNode,
-	RootCommandNode,
-	type Command,
-	type Predicate,
-	type CommandContext,
-} from "..";
+import type { Command } from "../Command";
+import type { CommandContext } from "../context/CommandContext";
+import type { Predicate } from "../Predicate";
+import { CommandNode } from "../tree/CommandNode";
+import { RootCommandNode } from "../tree/RootCommandNode";
 
 export type RedirectModifier<S> = (context: CommandContext<S>) => S | S[];
 
@@ -24,7 +22,9 @@ export abstract class ArgumentBuilder<S, T extends ArgumentBuilder<S, T>> {
 	abstract getThis(): T;
 
 	// biome-ignore lint/suspicious/noThenProperty: proof?
-	then(argument: ArgumentBuilder<S, any> | CommandNode<S>): T {
+	then<A extends ArgumentBuilder<S, A>>(
+		argument: ArgumentBuilder<S, A> | CommandNode<S>,
+	): T {
 		const child = argument instanceof CommandNode ? argument : argument.build();
 		this.arguments.addChild(child);
 		return this.getThis();

package/src/builder/LiteralArgumentBuilder.ts

@@ -1,4 +1,5 @@
-import { ArgumentBuilder, LiteralCommandNode } from "..";
+import { LiteralCommandNode } from "../tree/LiteralCommandNode";
+import { ArgumentBuilder } from "./ArgumentBuilder";
 
 export class LiteralArgumentBuilder<S> extends ArgumentBuilder<
 	S,
@@ -35,6 +36,6 @@ export class LiteralArgumentBuilder<S> extends ArgumentBuilder<
 	}
 }
 
-export function literal<S = any>(name: string): LiteralArgumentBuilder<S> {
+export function literal<S = unknown>(name: string): LiteralArgumentBuilder<S> {
 	return new LiteralArgumentBuilder(name);
 }

package/src/builder/RequiredArgumentBuilder.ts

@@ -1,4 +1,6 @@
-import { ArgumentBuilder, type ArgumentType, ArgumentCommandNode } from "..";
+import type { ArgumentType } from "../arguments/ArgumentType";
+import { ArgumentCommandNode } from "../tree/ArgumentCommandNode";
+import { ArgumentBuilder } from "./ArgumentBuilder";
 
 export class RequiredArgumentBuilder<S, T> extends ArgumentBuilder<
 	S,
@@ -42,7 +44,7 @@ export class RequiredArgumentBuilder<S, T> extends ArgumentBuilder<
 	}
 }
 
-export function argument<S = any, T = any>(
+export function argument<S = unknown, T = unknown>(
 	name: string,
 	type: ArgumentType<T>,
 ): RequiredArgumentBuilder<S, T> {

package/src/context/CommandContext.ts

@@ -1,16 +1,14 @@
-import type {
-	Command,
-	CommandNode,
-	StringRange,
-	ParsedArgument,
-	ParsedCommandNode,
-	RedirectModifier,
-} from "..";
+import type { RedirectModifier } from "../builder/ArgumentBuilder";
+import type { Command } from "../Command";
+import type { CommandNode } from "../tree/CommandNode";
+import type { ParsedArgument } from "./ParsedArgument";
+import type { ParsedCommandNode } from "./ParsedCommandNode";
+import type { StringRange } from "./StringRange";
 
 export class CommandContext<S> {
 	private source: S;
 	private input: string;
-	private arguments: Map<string, ParsedArgument<any>>;
+	private arguments: Map<string, ParsedArgument<unknown>>;
 	private nodes: ParsedCommandNode<S>[];
 	private command: Command<S>;
 	private rootNode: CommandNode<S>;
@@ -22,7 +20,7 @@ export class CommandContext<S> {
 	constructor(
 		source: S,
 		input: string,
-		parsedArguments: Map<string, ParsedArgument<any>>,
+		parsedArguments: Map<string, ParsedArgument<unknown>>,
 		command: Command<S>,
 		rootNode: CommandNode<S>,
 		nodes: ParsedCommandNode<S>[],
@@ -85,10 +83,10 @@ export class CommandContext<S> {
 		return this.rootNode;
 	}
 
-	get(name: string): any {
+	get<R = unknown>(name: string): R {
 		const argument = this.arguments.get(name);
 		// TODO: Throw exception when argument is null
-		return argument.getResult();
+		return argument.getResult() as R;
 	}
 
 	getRedirectModifier(): RedirectModifier<S> {

package/src/context/CommandContextBuilder.ts

@@ -1,18 +1,16 @@
-import {
-	type CommandNode,
-	type CommandDispatcher,
-	type Command,
-	CommandContext,
-	StringRange,
-	ParsedCommandNode,
-	type ParsedArgument,
-	type RedirectModifier,
-	SuggestionContext,
-} from "..";
+import type { RedirectModifier } from "../builder/ArgumentBuilder";
+import type { Command } from "../Command";
+import type { CommandDispatcher } from "../CommandDispatcher";
+import type { CommandNode } from "../tree/CommandNode";
+import { CommandContext } from "./CommandContext";
+import type { ParsedArgument } from "./ParsedArgument";
+import { ParsedCommandNode } from "./ParsedCommandNode";
+import { StringRange } from "./StringRange";
+import { SuggestionContext } from "./SuggestionContext";
 
 export class CommandContextBuilder<S> {
 	private source: S;
-	private arguments: Map<string, ParsedArgument<any>>;
+	private arguments: Map<string, ParsedArgument<unknown>>;
 	private rootNode: CommandNode<S>;
 	private dispatcher: CommandDispatcher<S>;
 	private command: Command<S>;
@@ -51,13 +49,13 @@ export class CommandContextBuilder<S> {
 
 	withArgument(
 		name: string,
-		argument: ParsedArgument<any>,
+		argument: ParsedArgument<unknown>,
 	): CommandContextBuilder<S> {
 		this.arguments.set(name, argument);
 		return this;
 	}
 
-	getArguments(): Map<string, ParsedArgument<any>> {
+	getArguments(): Map<string, ParsedArgument<unknown>> {
 		return this.arguments;
 	}
 

package/src/context/ParsedArgument.ts

@@ -1,4 +1,4 @@
-import { StringRange } from "..";
+import { StringRange } from "./StringRange";
 
 export class ParsedArgument<T> {
 	private range: StringRange;

package/src/context/ParsedCommandNode.ts

@@ -1,4 +1,5 @@
-import type { CommandNode, StringRange } from "..";
+import type { CommandNode } from "../tree/CommandNode";
+import type { StringRange } from "./StringRange";
 
 export class ParsedCommandNode<S> {
 	private node: CommandNode<S>;

package/src/context/SuggestionContext.ts

@@ -1,4 +1,4 @@
-import type { CommandNode } from "..";
+import type { CommandNode } from "../tree/CommandNode";
 
 export class SuggestionContext<S> {
 	parent: CommandNode<S>;

package/src/exceptions/CommandErrorType.ts

@@ -1,6 +1,7 @@
-import { CommandSyntaxError, type StringReader } from "..";
+import type { StringReader } from "../StringReader";
+import { CommandSyntaxError } from "./CommandSyntaxError";
 
-type CommandErrorFunction = (...args: any[]) => string;
+type CommandErrorFunction = <A = unknown>(...args: A[]) => string;
 
 export class CommandErrorType {
 	private func: CommandErrorFunction;

package/src/exceptions/CommandSyntaxError.ts

@@ -1,4 +1,4 @@
-import { CommandErrorType } from "..";
+import { CommandErrorType } from "./CommandErrorType";
 
 const CONTEXT_AMOUNT = 10;
 

package/src/index.ts

@@ -1,30 +1,30 @@
-export * from "./Command";
-export * from "./Predicate";
-export * from "./context/StringRange";
-export * from "./exceptions/CommandErrorType";
-export * from "./exceptions/CommandSyntaxError";
-export * from "./StringReader";
-export * from "./suggestion/Suggestion";
-export * from "./suggestion/Suggestions";
-export * from "./suggestion/SuggestionsBuilder";
-export * from "./tree/CommandNode";
-export * from "./tree/LiteralCommandNode";
-export * from "./tree/ArgumentCommandNode";
-export * from "./tree/RootCommandNode";
 export * from "./arguments/ArgumentType";
-export * from "./arguments/NumberArgumentType";
+export * from "./arguments/BoolArgumentType";
 export * from "./arguments/FloatArgumentType";
 export * from "./arguments/IntegerArgumentType";
 export * from "./arguments/LongArgumentType";
-export * from "./arguments/BoolArgumentType";
+export * from "./arguments/NumberArgumentType";
 export * from "./arguments/StringArgumentType";
 export * from "./builder/ArgumentBuilder";
 export * from "./builder/LiteralArgumentBuilder";
 export * from "./builder/RequiredArgumentBuilder";
-export * from "./context/ParsedArgument";
-export * from "./context/ParsedCommandNode";
+export * from "./Command";
+export * from "./CommandDispatcher";
 export * from "./context/CommandContext";
 export * from "./context/CommandContextBuilder";
+export * from "./context/ParsedArgument";
+export * from "./context/ParsedCommandNode";
+export * from "./context/StringRange";
 export * from "./context/SuggestionContext";
+export * from "./exceptions/CommandErrorType";
+export * from "./exceptions/CommandSyntaxError";
 export * from "./ParseResults";
-export * from "./CommandDispatcher";
+export * from "./Predicate";
+export * from "./StringReader";
+export * from "./suggestion/Suggestion";
+export * from "./suggestion/Suggestions";
+export * from "./suggestion/SuggestionsBuilder";
+export * from "./tree/ArgumentCommandNode";
+export * from "./tree/CommandNode";
+export * from "./tree/LiteralCommandNode";
+export * from "./tree/RootCommandNode";

package/src/suggestion/Suggestion.ts

@@ -1,4 +1,4 @@
-import type { StringRange } from "..";
+import type { StringRange } from "../context/StringRange";
 
 export class Suggestion {
 	private range: StringRange;

package/src/suggestion/Suggestions.ts

@@ -1,4 +1,5 @@
-import { StringRange, type Suggestion } from "..";
+import { StringRange } from "../context/StringRange";
+import type { Suggestion } from "./Suggestion";
 
 export class Suggestions {
 	static EMPTY = new Suggestions(StringRange.at(0), []);

package/src/suggestion/SuggestionsBuilder.ts

@@ -1,4 +1,6 @@
-import { Suggestion, Suggestions, StringRange } from "..";
+import { StringRange } from "../context/StringRange";
+import { Suggestion } from "./Suggestion";
+import { Suggestions } from "./Suggestions";
 
 export class SuggestionsBuilder {
 	private input: string;

package/src/tree/ArgumentCommandNode.ts

@@ -1,20 +1,20 @@
-import {
-	type ArgumentType,
-	CommandNode,
-	type StringReader,
-	type Command,
-	type CommandContext,
-	type CommandContextBuilder,
-	type Predicate,
-	type RedirectModifier,
-	ParsedArgument,
-	type Suggestions,
-	type SuggestionsBuilder,
-} from "..";
+import type { ArgumentType } from "../arguments/ArgumentType";
+import type { RedirectModifier } from "../builder/ArgumentBuilder";
+import type { Command } from "../Command";
+import type { CommandContext } from "../context/CommandContext";
+import type { CommandContextBuilder } from "../context/CommandContextBuilder";
+import { ParsedArgument } from "../context/ParsedArgument";
+import type { Predicate } from "../Predicate";
+import type { StringReader } from "../StringReader";
+import type { Suggestions } from "../suggestion/Suggestions";
+import type { SuggestionsBuilder } from "../suggestion/SuggestionsBuilder";
+import { CommandNode } from "./CommandNode";
+import CommandNodeThing from "./internal2";
 
 export class ArgumentCommandNode<S, T> extends CommandNode<S> {
 	name: string;
 	type: ArgumentType<T>;
+	_thing: CommandNodeThing = CommandNodeThing.ARGUMENT;
 
 	constructor(
 		name: string,

package/src/tree/CommandNode.ts

@@ -1,25 +1,30 @@
-import {
-	type StringReader,
-	type Command,
-	LiteralCommandNode,
-	ArgumentCommandNode,
-	type CommandContext,
-	type CommandContextBuilder,
-	type Predicate,
-	type RedirectModifier,
-	type SuggestionsBuilder,
-	type Suggestions,
-} from "..";
+import type { ArgumentCommandNode, LiteralCommandNode } from "..";
+import type { RedirectModifier } from "../builder/ArgumentBuilder";
+import type { Command } from "../Command";
+import type { CommandContext } from "../context/CommandContext";
+import type { CommandContextBuilder } from "../context/CommandContextBuilder";
+import type { Predicate } from "../Predicate";
+import type { StringReader } from "../StringReader";
+import type { Suggestions } from "../suggestion/Suggestions";
+import type { SuggestionsBuilder } from "../suggestion/SuggestionsBuilder";
+import CommandNodeThing from "./internal2";
 
 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 arguments: Map<string, ArgumentCommandNode<S, unknown>>;
 	private command: Command<S>;
 	private requirement: Predicate<S>;
 	private redirect: CommandNode<S>;
 	private modifier: RedirectModifier<S>;
 	private forks: boolean;
+	/**
+	 * This is used for detecting what type of command node this is, without having circular dependencies.
+	 * @internal
+	 * @hidden
+	 * @protected
+	 */
+	_thing: CommandNodeThing = CommandNodeThing.UNSPECIFIED;
 
 	constructor(
 		command: Command<S>,
@@ -77,10 +82,13 @@ export abstract class CommandNode<S> {
 			});
 		} 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);
+			if (node._thing === CommandNodeThing.LITERAL) {
+				this.literals.set(node.getName(), node as LiteralCommandNode<S>);
+			} else if (node._thing === CommandNodeThing.ARGUMENT) {
+				this.arguments.set(
+					node.getName(),
+					node as ArgumentCommandNode<S, unknown>,
+				);
 			}
 		}
 	}

package/src/tree/LiteralCommandNode.ts

@@ -1,19 +1,19 @@
-import {
-	CommandNode,
-	type StringReader,
-	type Command,
-	StringRange,
-	type CommandContext,
-	type CommandContextBuilder,
-	type Predicate,
-	type RedirectModifier,
-	CommandSyntaxError,
-	Suggestions,
-	type SuggestionsBuilder,
-} from "..";
+import type { RedirectModifier } from "../builder/ArgumentBuilder";
+import type { Command } from "../Command";
+import type { CommandContext } from "../context/CommandContext";
+import type { CommandContextBuilder } from "../context/CommandContextBuilder";
+import { StringRange } from "../context/StringRange";
+import { CommandSyntaxError } from "../exceptions/CommandSyntaxError";
+import type { Predicate } from "../Predicate";
+import type { StringReader } from "../StringReader";
+import { Suggestions } from "../suggestion/Suggestions";
+import type { SuggestionsBuilder } from "../suggestion/SuggestionsBuilder";
+import { CommandNode } from "./CommandNode";
+import CommandNodeThing from "./internal2";
 
 export class LiteralCommandNode<S> extends CommandNode<S> {
 	private literal: string;
+	_thing: CommandNodeThing = CommandNodeThing.LITERAL;
 
 	constructor(
 		literal: string,

package/src/tree/RootCommandNode.ts

@@ -1,11 +1,9 @@
-import {
-	CommandNode,
-	type StringReader,
-	type CommandContextBuilder,
-	type CommandContext,
-	Suggestions,
-	type SuggestionsBuilder,
-} from "..";
+import type { CommandContext } from "../context/CommandContext";
+import type { CommandContextBuilder } from "../context/CommandContextBuilder";
+import type { StringReader } from "../StringReader";
+import { Suggestions } from "../suggestion/Suggestions";
+import type { SuggestionsBuilder } from "../suggestion/SuggestionsBuilder";
+import { CommandNode } from "./CommandNode";
 
 export class RootCommandNode<S> extends CommandNode<S> {
 	constructor() {

package/src/tree/internal.ts

@@ -0,0 +1,9 @@
+import type { ArgumentCommandNode } from "./ArgumentCommandNode";
+import type { CommandNode } from "./CommandNode";
+import CommandNodeThing from "./internal2";
+
+export function isArgumentNode<A>(
+	n: CommandNode<A>,
+): n is ArgumentCommandNode<A, unknown> {
+	return n._thing === CommandNodeThing.ARGUMENT;
+}

package/src/tree/internal2.ts

@@ -0,0 +1,6 @@
+export enum CommandNodeThing {
+	UNSPECIFIED,
+	ARGUMENT,
+	LITERAL,
+}
+export default CommandNodeThing;

package/test/Arguments.test.ts

@@ -1,11 +1,10 @@
 import {
 	argument,
-	bool,
 	CommandDispatcher,
 	FloatArgumentType,
 	IntegerArgumentType,
-	literal,
 	LongArgumentType,
+	literal,
 } from "../src";
 
 describe("Arguments", () => {
@@ -14,7 +13,7 @@ describe("Arguments", () => {
 		dispatcher.register(
 			literal("foo").then(
 				argument("bar", new IntegerArgumentType()).executes(
-					async (ctx) => ctx.get("bar") * 2,
+					async (ctx) => ctx.get<number>("bar") * 2,
 				),
 			),
 		);
@@ -27,7 +26,7 @@ describe("Arguments", () => {
 		dispatcher.register(
 			literal("foo").then(
 				argument("bar", new LongArgumentType()).executes(
-					async (ctx) => ctx.get("bar").toString().length,
+					async (ctx) => ctx.get<bigint>("bar").toString().length,
 				),
 			),
 		);