@wq2/brigadier-ts 1.0.0 → 1.0.2

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/FloatArgumentType"
-export * from "./arguments/IntegerArgumentType"
-export * from "./arguments/LongArgumentType"
-export * from "./arguments/BoolArgumentType"
-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 "./context/CommandContext"
-export * from "./context/CommandContextBuilder"
-export * from "./context/SuggestionContext"
-export * from "./ParseResults"
-export * from "./CommandDispatcher"
+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/FloatArgumentType";
+export * from "./arguments/IntegerArgumentType";
+export * from "./arguments/LongArgumentType";
+export * from "./arguments/BoolArgumentType";
+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 "./context/CommandContext";
+export * from "./context/CommandContextBuilder";
+export * from "./context/SuggestionContext";
+export * from "./ParseResults";
+export * from "./CommandDispatcher";

package/src/suggestion/Suggestion.ts

@@ -1,55 +1,55 @@
-import { StringRange } from "..";
+import type { StringRange } from "..";
 
 export class Suggestion {
-    private range: StringRange;
-    private text: string;
-    private tooltip: string;
+	private range: StringRange;
+	private text: string;
+	private tooltip: string;
 
-    constructor(range: StringRange, text: string, tooltip?: string) {
-        this.range = range;
-        this.text = text;
-        this.tooltip = tooltip;
-    }
+	constructor(range: StringRange, text: string, tooltip?: string) {
+		this.range = range;
+		this.text = text;
+		this.tooltip = tooltip;
+	}
 
-    getRange() {
-        return this.range;
-    }
+	getRange() {
+		return this.range;
+	}
 
-    getText() {
-        return this.text;
-    }
+	getText() {
+		return this.text;
+	}
 
-    getTooltip() {
-        return this.tooltip;
-    }
+	getTooltip() {
+		return this.tooltip;
+	}
 
-    apply(input: string): string {
-        if (this.range.getStart() == 0 && this.range.getEnd() === input.length) {
-            return this.text;
-        }
-        let result = "";
-        if (this.range.getStart() > 0) {
-            result += input.substring(0, this.range.getStart());
-        }
-        result += this.text;
-        if (this.range.getEnd() < input.length) {
-            result += input.substring(this.range.getEnd());
-        }
-        return result;
-    }
+	apply(input: string): string {
+		if (this.range.getStart() === 0 && this.range.getEnd() === input.length) {
+			return this.text;
+		}
+		let result = "";
+		if (this.range.getStart() > 0) {
+			result += input.substring(0, this.range.getStart());
+		}
+		result += this.text;
+		if (this.range.getEnd() < input.length) {
+			result += input.substring(this.range.getEnd());
+		}
+		return result;
+	}
 
-    expand(command: string, range: StringRange): Suggestion {
-        if (range === this.range) {
-            return this;
-        }
-        let result = "";
-        if (range.getStart() < this.range.getStart()) {
-            result += command.substring(range.getStart(), this.range.getStart());
-        }
-        result += this.text;
-        if (range.getEnd() > this.range.getEnd()) {
-            result += command.substring(this.range.getEnd(), range.getEnd());
-        }
-        return new Suggestion(range, result, this.tooltip);
-    }
+	expand(command: string, range: StringRange): Suggestion {
+		if (range === this.range) {
+			return this;
+		}
+		let result = "";
+		if (range.getStart() < this.range.getStart()) {
+			result += command.substring(range.getStart(), this.range.getStart());
+		}
+		result += this.text;
+		if (range.getEnd() > this.range.getEnd()) {
+			result += command.substring(this.range.getEnd(), range.getEnd());
+		}
+		return new Suggestion(range, result, this.tooltip);
+	}
 }

package/src/suggestion/Suggestions.ts

@@ -1,60 +1,62 @@
-import { StringRange, Suggestion } from "..";
+import { StringRange, type Suggestion } from "..";
 
 export class Suggestions {
-    static EMPTY = new Suggestions(StringRange.at(0), []);
-
-    private range: StringRange;
-    private suggestions: Suggestion[];
-
-    constructor(range: StringRange, suggestions: Suggestion[]) {
-        this.range = range;
-        this.suggestions = suggestions;
-    }
-
-    getRange(): StringRange {
-        return this.range;
-    }
-
-    getList(): Suggestion[] {
-        return this.suggestions;
-    }
-
-    isEmpty(): boolean {
-        return this.suggestions.length === 0;
-    }
-
-    static empty(): Promise<Suggestions> {
-        return Promise.resolve(Suggestions.EMPTY);
-    }
-
-    static merge(command: string, input: Suggestions[]): Suggestions {
-        if (input.length === 0) {
-            return Suggestions.EMPTY;
-        } else if (input.length === 1) {
-            return input[0];
-        }
-        const texts = new Set<Suggestion>();
-        for (const suggestions of input) {
-            suggestions.getList().forEach(s => texts.add(s))
-        }
-        return Suggestions.create(command, Array.from(texts));
-    }
-
-    static create(command: string, suggestions: Suggestion[]): Suggestions {
-        if (suggestions.length === 0) {
-            return Suggestions.EMPTY;
-        }
-        let start = Infinity;
-        let end = -Infinity;
-        for (const suggestion of suggestions) {
-            start = Math.min(suggestion.getRange().getStart(), start);
-            end = Math.max(suggestion.getRange().getEnd(), end);
-        }
-        const range = new StringRange(start, end);
-        const texts = [];
-        for (const suggestion of suggestions) {
-            texts.push(suggestion.expand(command, range));
-        }
-        return new Suggestions(range, texts.sort());
-    }
+	static EMPTY = new Suggestions(StringRange.at(0), []);
+
+	private range: StringRange;
+	private suggestions: Suggestion[];
+
+	constructor(range: StringRange, suggestions: Suggestion[]) {
+		this.range = range;
+		this.suggestions = suggestions;
+	}
+
+	getRange(): StringRange {
+		return this.range;
+	}
+
+	getList(): Suggestion[] {
+		return this.suggestions;
+	}
+
+	isEmpty(): boolean {
+		return this.suggestions.length === 0;
+	}
+
+	static empty(): Promise<Suggestions> {
+		return Promise.resolve(Suggestions.EMPTY);
+	}
+
+	static merge(command: string, input: Suggestions[]): Suggestions {
+		if (input.length === 0) {
+			return Suggestions.EMPTY;
+		} else if (input.length === 1) {
+			return input[0];
+		}
+		const texts = new Set<Suggestion>();
+		for (const suggestions of input) {
+			suggestions.getList().forEach((s) => {
+				texts.add(s);
+			});
+		}
+		return Suggestions.create(command, Array.from(texts));
+	}
+
+	static create(command: string, suggestions: Suggestion[]): Suggestions {
+		if (suggestions.length === 0) {
+			return Suggestions.EMPTY;
+		}
+		let start = Infinity;
+		let end = -Infinity;
+		for (const suggestion of suggestions) {
+			start = Math.min(suggestion.getRange().getStart(), start);
+			end = Math.max(suggestion.getRange().getEnd(), end);
+		}
+		const range = new StringRange(start, end);
+		const texts = [];
+		for (const suggestion of suggestions) {
+			texts.push(suggestion.expand(command, range));
+		}
+		return new Suggestions(range, texts.sort());
+	}
 }

package/src/suggestion/SuggestionsBuilder.ts

@@ -1,60 +1,62 @@
-import { 
-    Suggestion,
-    Suggestions,
-    StringRange
-} from "..";
+import { Suggestion, Suggestions, StringRange } from "..";
 
 export class SuggestionsBuilder {
-    private input: string;
-    private start: number;
-    private remaining: string;
-    private result: Suggestion[];
-
-    constructor(input: string, start: number) {
-        this.input = input;
-        this.start = start;
-        this.remaining = input.substring(start);
-        this.result = [];
-    }
-
-    getInput(): string {
-        return this.input;
-    }
-
-    getStart(): number {
-        return this.start;
-    }
-
-    getRemaining(): string {
-        return this.remaining;
-    }
-
-    build(): Suggestions {
-        return Suggestions.create(this.input, this.result);
-    }
-
-    buildPromise(): Promise<Suggestions> {
-        return Promise.resolve(this.build());
-    }
-
-    suggest(text: string, tooltip?: string): SuggestionsBuilder {
-        if (text === this.remaining) {
-            return this;
-        }
-        this.result.push(new Suggestion(new StringRange(this.start, this.input.length), text, tooltip))
-        return this;
-    }
-
-    add(other: SuggestionsBuilder): SuggestionsBuilder {
-        this.result.concat(other.result);
-        return this;
-    }
-
-    createOffset(start: number): SuggestionsBuilder {
-        return new SuggestionsBuilder(this.input, start);
-    }
-
-    restart(start: number): SuggestionsBuilder {
-        return new SuggestionsBuilder(this.input, this.start);
-    }
+	private input: string;
+	private start: number;
+	private remaining: string;
+	private result: Suggestion[];
+
+	constructor(input: string, start: number) {
+		this.input = input;
+		this.start = start;
+		this.remaining = input.substring(start);
+		this.result = [];
+	}
+
+	getInput(): string {
+		return this.input;
+	}
+
+	getStart(): number {
+		return this.start;
+	}
+
+	getRemaining(): string {
+		return this.remaining;
+	}
+
+	build(): Suggestions {
+		return Suggestions.create(this.input, this.result);
+	}
+
+	buildPromise(): Promise<Suggestions> {
+		return Promise.resolve(this.build());
+	}
+
+	suggest(text: string, tooltip?: string): SuggestionsBuilder {
+		if (text === this.remaining) {
+			return this;
+		}
+		this.result.push(
+			new Suggestion(
+				new StringRange(this.start, this.input.length),
+				text,
+				tooltip,
+			),
+		);
+		return this;
+	}
+
+	add(other: SuggestionsBuilder): SuggestionsBuilder {
+		this.result.concat(other.result);
+		return this;
+	}
+
+	createOffset(start: number): SuggestionsBuilder {
+		return new SuggestionsBuilder(this.input, start);
+	}
+
+	restart(): SuggestionsBuilder {
+		return new SuggestionsBuilder(this.input, this.start);
+	}
 }

package/src/tree/ArgumentCommandNode.ts

@@ -1,48 +1,59 @@
 import {
-    ArgumentType,
-    CommandNode,
-    StringReader,
-    Command,
-    CommandContext,
-    CommandContextBuilder,
-    Predicate,
-    RedirectModifier,
-    ParsedArgument,
-    Suggestions,
-    SuggestionsBuilder
-} from '..';
+	type ArgumentType,
+	CommandNode,
+	type StringReader,
+	type Command,
+	type CommandContext,
+	type CommandContextBuilder,
+	type Predicate,
+	type RedirectModifier,
+	ParsedArgument,
+	type Suggestions,
+	type SuggestionsBuilder,
+} from "..";
 
 export class ArgumentCommandNode<S, T> extends CommandNode<S> {
-    name: string;
-    type: ArgumentType<T>;
+	name: string;
+	type: ArgumentType<T>;
 
-    constructor(name: string, type: ArgumentType<T>, command: Command<S>, requirement: Predicate<S>, redirect: CommandNode<S>, modifier: RedirectModifier<S>, forks: boolean) {
-        super(command, requirement, redirect, modifier, forks);
-        this.name = name;
-        this.type = type;
-    }
+	constructor(
+		name: string,
+		type: ArgumentType<T>,
+		command: Command<S>,
+		requirement: Predicate<S>,
+		redirect: CommandNode<S>,
+		modifier: RedirectModifier<S>,
+		forks: boolean,
+	) {
+		super(command, requirement, redirect, modifier, forks);
+		this.name = name;
+		this.type = type;
+	}
 
-    getType(): ArgumentType<T> {
-        return this.type;
-    }
+	getType(): ArgumentType<T> {
+		return this.type;
+	}
 
-    parse(reader: StringReader, contextBuilder: CommandContextBuilder<S>): void {
-        const start = reader.getCursor();
-        const result = this.type.parse(reader);
-        const parsed = new ParsedArgument<T>(start, reader.getCursor(), result);
-        contextBuilder.withArgument(this.name, parsed);
-        contextBuilder.withNode(this, parsed.getRange());
-    }
-    
-    getName(): string {
-        return this.name;
-    }
+	parse(reader: StringReader, contextBuilder: CommandContextBuilder<S>): void {
+		const start = reader.getCursor();
+		const result = this.type.parse(reader);
+		const parsed = new ParsedArgument<T>(start, reader.getCursor(), result);
+		contextBuilder.withArgument(this.name, parsed);
+		contextBuilder.withNode(this, parsed.getRange());
+	}
 
-    getUsageText(): string {
-        return "<" + this.name + ">";
-    }
-    
-    listSuggestions(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions> {
-        return Suggestions.empty();
-    }
+	getName(): string {
+		return this.name;
+	}
+
+	getUsageText(): string {
+		return `<${this.name}>`;
+	}
+
+	listSuggestions(
+		context: CommandContext<S>,
+		builder: SuggestionsBuilder,
+	): Promise<Suggestions> {
+		return this.type.listSuggestions(context, builder);
+	}
 }