@wq2/brigadier-ts 1.0.0

package/src/arguments/BoolArgumentType.ts

@@ -0,0 +1,28 @@
+import {
+    ArgumentType,
+    StringReader,
+    CommandContext,
+    SuggestionsBuilder,
+    Suggestions
+} from "..";
+
+export class BoolArgumentType extends ArgumentType<boolean> {
+
+    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();
+    }
+}
+
+export function bool(): BoolArgumentType {
+    return new BoolArgumentType();
+}

package/src/arguments/FloatArgumentType.ts

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

package/src/arguments/IntegerArgumentType.ts

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

package/src/arguments/LongArgumentType.ts

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

package/src/arguments/NumberArgumentType.ts

@@ -0,0 +1,39 @@
+import { ArgumentType, StringReader, CommandErrorType } from "..";
+
+export abstract class NumberArgumentType<N extends number | BigInt = number> extends ArgumentType<N> {
+    private minimum: N;
+    private maximum: N;
+
+    constructor(minimum: N, maximum: N) {
+        super();
+        this.minimum = minimum;
+        this.maximum = maximum;
+    }
+
+    getMinimum(): N {
+        return this.minimum;
+    }
+
+    getMaximum(): N {
+        return this.maximum;
+    }
+
+    parse(reader: StringReader): N {
+        const start = reader.getCursor();
+        const result = this.readNumber(reader);
+        if (result < this.minimum) {
+            reader.setCursor(start);
+            throw this.getTooSmallError().createWithContext(reader, result, this.minimum);
+        } else if (result > this.maximum) {
+            reader.setCursor(start);
+            throw this.getTooBigError().createWithContext(reader, result, this.maximum);
+        }
+        return result;
+    }
+
+    abstract readNumber(reader: StringReader): N;
+
+    abstract getTooSmallError(): CommandErrorType;
+
+    abstract getTooBigError(): CommandErrorType;
+}

package/src/arguments/StringArgumentType.ts

@@ -0,0 +1,40 @@
+import { ArgumentType, StringReader } from "..";
+
+type StringType = "single_word" | "quotable_phrase" | "greedy_phrase";
+
+export class StringArgumentType extends ArgumentType<string> {
+    private type: StringType;
+
+    constructor(type: StringType) {
+        super();
+        this.type = type;
+    }
+
+    getType(): StringType {
+        return this.type;
+    }
+
+    parse(reader: StringReader): string {
+        if (this.type === "greedy_phrase") {
+            const text = reader.getRemaining();
+            reader.setCursor(reader.getTotalLength());
+            return text;
+        } else if (this.type === "single_word") {
+            return reader.readUnquotedString();
+        } else {
+            return reader.readString();
+        }
+    }
+}
+
+export function word(): StringArgumentType {
+    return new StringArgumentType("single_word");
+}
+
+export function string(): StringArgumentType {
+    return new StringArgumentType("quotable_phrase");
+}
+
+export function greedyString(): StringArgumentType {
+    return new StringArgumentType("greedy_phrase");
+}

package/src/builder/ArgumentBuilder.ts

@@ -0,0 +1,82 @@
+import {
+    CommandNode,
+    RootCommandNode,
+    Command,
+    Predicate,
+    CommandContext
+} from "..";
+
+export type RedirectModifier<S> = (context: CommandContext<S>) => S | S[];
+
+export abstract class ArgumentBuilder<S, T extends ArgumentBuilder<S, T>> {
+    private arguments: RootCommandNode<S>;
+    private command: Command<S>;
+    private requirement: Predicate<S>;
+    private target: CommandNode<S>;
+    private modifier: RedirectModifier<S>;
+    private forks: boolean;
+
+    constructor() {
+        this.arguments = new RootCommandNode();
+        this.requirement = async s => true;
+    }
+
+    abstract getThis(): T;
+
+    then(argument: ArgumentBuilder<S, any> | CommandNode<S>): T {
+        const child = argument instanceof CommandNode ? argument : argument.build();
+        this.arguments.addChild(child);
+        return this.getThis();
+    }
+
+    executes(command: Command<S>): T {
+        this.command = command;
+        return this.getThis();
+    }
+
+    requires(requirement: Predicate<S>): T {
+        this.requirement = requirement;
+        return this.getThis();
+    }
+
+    redirect(target: CommandNode<S>, modifier: RedirectModifier<S> = null): T {
+        return this.forward(target, modifier, false)
+    }
+
+    fork(target: CommandNode<S>, modifier: RedirectModifier<S>): T {
+        return this.forward(target, modifier, true);
+    }
+
+    forward(target: CommandNode<S>, modifier: RedirectModifier<S>, forks: boolean): T {
+        this.target = target;
+        this.modifier = modifier;
+        this.forks = forks;
+        return this.getThis();
+    }
+
+    getArguments(): CommandNode<S>[] {
+        return this.arguments.getChildren();
+    }
+
+    getCommand(): Command<S> {
+        return this.command;
+    }
+
+    getRequirement(): Predicate<S> {
+        return this.requirement;
+    }
+
+    getRedirect(): CommandNode<S> {
+        return this.target;
+    }
+
+    getRedirectModifier(): RedirectModifier<S> {
+        return this.modifier;
+    }
+
+    isFork(): boolean {
+        return this.forks;
+    }
+
+    abstract build(): CommandNode<S>;
+}

package/src/builder/LiteralArgumentBuilder.ts

@@ -0,0 +1,30 @@
+import { ArgumentBuilder, LiteralCommandNode } from "..";
+
+export class LiteralArgumentBuilder<S> extends ArgumentBuilder<S, LiteralArgumentBuilder<S>> {
+    private literal: string;
+
+    constructor(literal: string) {
+        super();
+        this.literal = literal
+    }
+
+    getThis(): LiteralArgumentBuilder<S> {
+        return this;
+    }
+
+    getLiteral(): string {
+        return this.literal;
+    }
+    
+    build(): LiteralCommandNode<S> {
+        const result = new LiteralCommandNode<S>(this.getLiteral(), this.getCommand(), this.getRequirement(), this.getRedirect(), this.getRedirectModifier(), this.isFork());
+        for (const argument of this.getArguments()) {
+            result.addChild(argument);
+        }
+        return result;
+    }
+}
+
+export function literal<S = any>(name: string): LiteralArgumentBuilder<S> {
+    return new LiteralArgumentBuilder(name);
+}

package/src/builder/RequiredArgumentBuilder.ts

@@ -0,0 +1,40 @@
+import { 
+    ArgumentBuilder,
+    ArgumentType,
+    ArgumentCommandNode
+} from "..";
+
+export class RequiredArgumentBuilder<S, T> extends ArgumentBuilder<S, RequiredArgumentBuilder<S, T>> {
+    private name: string;
+    private type: ArgumentType<T>;
+
+    constructor(name: string, type: ArgumentType<T>) {
+        super();
+        this.name = name;
+        this.type = type;
+    }
+
+    getThis(): RequiredArgumentBuilder<S, T> {
+        return this;
+    }
+
+    getName(): string {
+        return this.name;
+    }
+
+    getType(): ArgumentType<T> {
+        return this.type;
+    }
+    
+    build(): ArgumentCommandNode<S, T> {
+        const result = new ArgumentCommandNode(this.getName(), this.getType(), this.getCommand(), this.getRequirement(), this.getRedirect(), this.getRedirectModifier(), this.isFork());
+        for (const argument of this.getArguments()) {
+            result.addChild(argument);
+        }
+        return result;
+    }
+}
+
+export function argument<S = any, T = any>(name: string, type: ArgumentType<T>): RequiredArgumentBuilder<S, T> {
+    return new RequiredArgumentBuilder(name, type);
+}

package/src/context/CommandContext.ts

@@ -0,0 +1,94 @@
+import { Command,
+    CommandNode,
+    StringRange,
+    ParsedArgument,
+    ParsedCommandNode,
+    RedirectModifier
+} from "..";
+
+export class CommandContext<S> {
+    private source: S;
+    private input: string;
+    private arguments: Map<string, ParsedArgument<any>>; 
+    private nodes: ParsedCommandNode<S>[];
+    private command: Command<S>;
+    private rootNode: CommandNode<S>;
+    private child: CommandContext<S>;
+    private range: StringRange;
+    private modifier: RedirectModifier<S>;
+    private forks: boolean;
+
+    constructor(source: S, input: string, parsedArguments: Map<string, ParsedArgument<any>>, command: Command<S>, rootNode: CommandNode<S>, nodes: ParsedCommandNode<S>[], range: StringRange, child: CommandContext<S>, modifier: RedirectModifier<S>, forks: boolean) {
+        this.source = source;
+        this.input = input;
+        this.arguments = parsedArguments;
+        this.command = command;
+        this.rootNode = rootNode;
+        this.nodes = nodes;
+        this.range = range;
+        this.child = child;
+        this.modifier = modifier;
+        this.forks = forks;
+    }
+
+    copyFor(source: S): CommandContext<S> {
+        if (this.source === source) {
+            return this;
+        }
+        return new CommandContext<S>(source, this.input, this.arguments, this.command, this.rootNode, this.nodes, this.range, this.child, this.modifier, this.forks);
+    }
+
+    getChild(): CommandContext<S> {
+        return this.child;
+    }
+
+    getLastChild(): CommandContext<S> {
+        let result: CommandContext<S> = this;
+        while (result.getChild() != null) {
+            result = result.getChild();
+        }
+        return result;
+    }
+
+    getCommand(): Command<S> {
+        return this.command;
+    }
+
+    getSource(): S {
+        return this.source;
+    }
+
+    getRootNode(): CommandNode<S> {
+        return this.rootNode;
+    }
+
+    get(name: string): any {
+        const argument = this.arguments.get(name);
+        // TODO: Throw exception when argument is null
+        return argument.getResult();
+    }
+
+    getRedirectModifier(): RedirectModifier<S> {
+        return this.modifier;
+    }
+
+    getRange(): StringRange {
+        return this.range;
+    }
+
+    getInput(): string {
+        return this.input;
+    }
+
+    getNodes(): ParsedCommandNode<S>[] {
+        return this.nodes;
+    }
+
+    hasNodes(): boolean {
+        return this.nodes.length !== 0;
+    }
+
+    isForked(): boolean {
+        return this.forks;
+    }
+}

package/src/context/CommandContextBuilder.ts

@@ -0,0 +1,148 @@
+import {
+    CommandNode,
+    CommandDispatcher,
+    Command,
+    CommandContext,
+    StringRange,
+    ParsedCommandNode,
+    ParsedArgument,
+    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");
+    }
+}

package/src/context/ParsedArgument.ts

@@ -0,0 +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;
+    }
+
+    getRange(): StringRange {
+        return this.range;
+    }
+
+    getResult(): T {
+        return this.result;
+    }
+}

package/src/context/ParsedCommandNode.ts

@@ -0,0 +1,19 @@
+import { 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;
+    }
+
+    getNode(): CommandNode<S> {
+        return this.node;
+    }
+
+    getRange(): StringRange {
+        return this.range;
+    }
+}

package/src/context/StringRange.ts

@@ -0,0 +1,35 @@
+export class StringRange {
+    private start: number;
+    private end: number;
+
+    constructor(start: number, end: number) {
+        this.start = start;
+        this.end = end;
+    }
+
+    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)
+    }
+
+    getStart(): number {
+        return this.start;
+    }
+
+    getEnd(): number {
+        return this.end;
+    }
+
+    isEmpty(): boolean {
+        return this.start === this.end;
+    }
+
+    getLength(): number {
+        return this.end - this.start;
+    }
+}

package/src/context/SuggestionContext.ts

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

package/src/exceptions/CommandErrorType.ts

@@ -0,0 +1,20 @@
+import { CommandSyntaxError, StringReader } from "..";
+
+type CommandErrorFunction = (...args: any[]) => string;
+
+export class CommandErrorType {
+    private func: CommandErrorFunction
+    constructor(func: CommandErrorFunction) {
+        this.func = func;
+    }
+
+    create(...args: any[]): 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());
+    }
+}