@jsprismarine/brigadier 0.2.0-rc.1 → 0.2.1

package/src/lib/exceptions/SimpleCommandExceptionType.ts

@@ -1,26 +0,0 @@
-import Message from "../Message"
-import ImmutableStringReader from "../ImmutableStringReader"
-import CommandExceptionType from "./CommandExceptionType"
-import CommandSyntaxException from "./CommandSyntaxException";
-
-export default class SimpleCommandExceptionType implements CommandExceptionType {
-    
-    private message: Message;
-    
-    public constructor (message: Message) {
-		this.message = message;
-		Error.captureStackTrace(this, SimpleCommandExceptionType)
-    }
-    
-    public create(): CommandSyntaxException {
-        return new CommandSyntaxException(this, this.message)
-    }
-    
-    public createWithContext(reader: ImmutableStringReader): CommandSyntaxException {
-        return new CommandSyntaxException(this, this.message, reader.getString(), reader.getCursor());
-    }
-    
-    public toString(): string {
-        return this.message.getString();
-    }
-}

package/src/lib/suggestion/IntegerSuggestion.ts

@@ -1,46 +0,0 @@
-import Message from "../Message"
-import StringRange from "../context/StringRange"
-import Suggestion from "./Suggestion"
-
-export default class IntegerSuggestion extends Suggestion {
-    
-    private value: number;
-    
-    public constructor (range: StringRange, value: number, tooltip: Message = null) {
-        super(range, value.toString(), tooltip);
-        this.value = value;
-    }
-    
-    public getValue(): number {
-        return this.value;
-    }
-
-    public equals(o: object): boolean {
-        if (this === o) return true;
-        
-        if (!(o instanceof IntegerSuggestion)) return false;
-        
-        return this.value == o.value && super.equals(o);
-    }
-    
-    public toString(): String {
-        return "IntegerSuggestion{" +
-                "value=" + this.value +
-                ", range=" + this.getRange() +
-                ", text='" + this.getText() + '\'' +
-                ", tooltip='" + this.getTooltip() + '\'' +
-                '}';
-    }
-
-    public compareTo(o: Suggestion): number {
-        if (o instanceof IntegerSuggestion) {
-            return this.value < o.value ? 1 : - 1;
-        }
-        
-        return super.compareTo(o);
-    }
-
-    public compareToIgnoreCase(b: Suggestion): number {
-        return this.compareTo(b);
-    }
-}

package/src/lib/suggestion/Suggestion.ts

@@ -1,87 +0,0 @@
-import isEqual from "../util/isEqual"
-import Message from "../Message"
-import StringRange from "../context/StringRange"
-
-export default class Suggestion {
-    
-    private range: StringRange;    
-    private text: string;    
-    private tooltip: Message;
-    
-    public constructor (range: StringRange, text: string, tooltip: Message = null) {
-        this.range = range;
-        this.text = text;
-        this.tooltip = tooltip;
-    }
-    
-    public getRange(): StringRange {
-        return this.range;
-    }
-    
-    public getText(): string {
-        return this.text;
-    }
-    
-    public getTooltip(): Message {
-        return this.tooltip;
-    }
-    
-    public 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;
-    }
-
-    public equals(o: object): boolean {
-        if (this === o) return true;        
-        if (!(o instanceof  Suggestion)) return false;
-        
-        return isEqual(this.range, o.range) && (this.text === o.text) && isEqual(this.tooltip, o.tooltip);
-    }
-    
-    public toString(): String {
-        return "Suggestion{" +
-		"range=" + this.range +
-		", text='" + this.text + '\'' +
-		", tooltip='" + this.tooltip + '\'' +
-		'}';
-    }
-    
-    public compareTo(o: Suggestion): number {
-        return this.text < o.text ? 1 : -1;
-    }
-    
-    public compareToIgnoreCase(b: Suggestion): number {
-        return this.text.toLowerCase() < b.text.toLowerCase() ? 1 : -1;
-    }
-    
-    public expand(command: string, range: StringRange): Suggestion {
-        if (range.equals(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/lib/suggestion/SuggestionProvider.ts

@@ -1,7 +0,0 @@
-import Suggestions from "./Suggestions"
-import SuggestionsBuilder from "./SuggestionsBuilder"
-import CommandContext from "../context/CommandContext"
-
-export default interface SuggestionProvider<S> {    
-    getSuggestions(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions>;
-}

package/src/lib/suggestion/Suggestions.ts

@@ -1,85 +0,0 @@
-import isEqual from "../util/isEqual"
-import StringRange from "../context/StringRange"
-import Suggestion from "./Suggestion"
-
-export default class Suggestions {
-
-    private static EMPTY = new Suggestions(StringRange.at(0), []);
-
-    private range: StringRange;
-
-    private suggestions: Array<Suggestion>;
-
-    public constructor (range: StringRange, suggestions: Array<Suggestion>) {
-        this.range = range;
-        this.suggestions = suggestions;
-    }
-
-    public getRange(): StringRange {
-        return this.range;
-    }
-
-    public getList(): Array<Suggestion> {
-        return this.suggestions;
-    }
-
-    public isEmpty(): boolean {
-        return this.suggestions.length === 0;
-    }
-
-    public equals(o: object): boolean {
-        if (this === o) return true;
-
-        if (!(o instanceof  Suggestions)) return false;
-
-        return this.range.equals(o.range) && isEqual(this.suggestions, o.suggestions);
-    }
-
-    public toString(): String {
-		return "Suggestions{" +
-		"range=" + this.range +
-		", suggestions=" + this.suggestions + '}';
-    }
-
-    public static empty(): Promise<Suggestions> {
-        return Promise.resolve(this.EMPTY);
-    }
-
-    public static merge(command: string, input: Array<Suggestions>): Suggestions {
-        if (input.length === 0) {
-            return this.EMPTY;
-        }
-        else if (input.length === 1) {
-            return input[0];
-        }
-
-        const texts = [];
-        for (let suggestions of input) {
-            texts.push(...suggestions.getList());
-        }
-
-        return Suggestions.create(command, texts);
-    }
-
-    public static create(command: string, suggestions: Array<Suggestion>): Suggestions {
-        if (suggestions.length === 0) {
-            return this.EMPTY;
-        }
-
-        let start = Infinity;
-        let end = -Infinity;
-        for (let suggestion of suggestions) {
-            start = Math.min(suggestion.getRange().getStart(), start);
-            end = Math.max(suggestion.getRange().getEnd(), end);
-        }
-
-        let range = new StringRange(start, end);
-        const texts = [];
-        for (let suggestion of suggestions) {
-            texts.push(suggestion.expand(command, range));
-        }
-
-        const sorted = texts.sort((a, b) => a.compareToIgnoreCase(b));
-        return new Suggestions(range, sorted);
-    }
-}

package/src/lib/suggestion/SuggestionsBuilder.ts

@@ -1,69 +0,0 @@
-import Message from "../Message"
-import StringRange from "../context/StringRange"
-import Suggestion from "./Suggestion"
-import Suggestions from "./Suggestions"
-import IntegerSuggestion from "./IntegerSuggestion"
-
-export default class SuggestionsBuilder {
-    
-    private input: string;
-    
-    private start: number;
-    
-    private remaining: string;
-    
-    private result: Array<Suggestion> = [];
-    
-    public constructor (input: string, start: number) {
-        this.input = input;
-        this.start = start;
-        this.remaining = input.substring(start);
-    }
-    
-    public getInput(): String {
-        return this.input;
-    }
-    
-    public getStart(): number {
-        return this.start;
-    }
-    
-    public getRemaining(): string {
-        return this.remaining;
-    }
-    
-    public build(): Suggestions {
-        return Suggestions.create(this.input, this.result);
-    }
-    
-    public buildPromise(): Promise<Suggestions> {
-        return Promise.resolve(this.build());
-    }
-    
-    public suggest(text: string | number, tooltip: Message = null): SuggestionsBuilder {
-
-		if(typeof text === "number") {
-			this.result.push(new IntegerSuggestion(StringRange.between(this.start, this.input.length), text, tooltip));
-			return this;
-		}
-
-        if (text === this.remaining)
-            return this;
-        
-        this.result.push(new Suggestion(StringRange.between(this.start, this.input.length), text, tooltip));
-        return this;
-    }        
-    
-    public add(other: SuggestionsBuilder): SuggestionsBuilder {
-        this.result.push(...other.result);
-        return this;
-    }
-    
-    public createOffset(start: number): SuggestionsBuilder {
-        return new SuggestionsBuilder(this.input, this.start);
-    }
-    
-    public restart(): SuggestionsBuilder {
-        return new SuggestionsBuilder(this.input, this.start);
-    }
-}

package/src/lib/tree/ArgumentCommandNode.ts

@@ -1,140 +0,0 @@
-import ArgumentType from '../arguments/ArgumentType';
-import Command from '../Command';
-import CommandContext from '../context/CommandContext';
-import CommandContextBuilder from '../context/CommandContextBuilder';
-import CommandNode from './CommandNode';
-import ParsedArgument from '../context/ParsedArgument';
-import Predicate from '../Predicate';
-import RedirectModifier from '../RedirectModifier';
-import RequiredArgumentBuilder from '../builder/RequiredArgumentBuilder';
-import StringReader from '../StringReader';
-import SuggestionProvider from '../suggestion/SuggestionProvider';
-import Suggestions from '../suggestion/Suggestions';
-import SuggestionsBuilder from '../suggestion/SuggestionsBuilder';
-import isEqual from '../util/isEqual';
-
-const USAGE_ARGUMENT_OPEN: string = '<';
-const USAGE_ARGUMENT_CLOSE: string = '>';
-
-export default class ArgumentCommandNode<S, T> extends CommandNode<S> {
-    private name: string;
-    private type: ArgumentType<T>;
-    private customSuggestions: SuggestionProvider<S>;
-
-    public constructor(
-        name: string,
-        type: ArgumentType<T>,
-        command: Command<S>,
-        requirement: Predicate<S>,
-        redirect: CommandNode<S>,
-        modifier: RedirectModifier<S>,
-        forks: boolean,
-        customSuggestions: SuggestionProvider<S>
-    ) {
-        super(command, requirement, redirect, modifier, forks);
-        this.name = name;
-        this.type = type;
-        this.customSuggestions = customSuggestions;
-    }
-
-    public getNodeType(): string {
-        return 'argument';
-    }
-
-    public getType(): ArgumentType<T> {
-        return this.type;
-    }
-
-    public getName(): string {
-        return this.name;
-    }
-
-    public getUsageText(): string {
-        return USAGE_ARGUMENT_OPEN + this.name + USAGE_ARGUMENT_CLOSE;
-    }
-
-    public getCustomSuggestions(): SuggestionProvider<S> {
-        return this.customSuggestions;
-    }
-
-    public parse(
-        reader: StringReader,
-        contextBuilder: CommandContextBuilder<S>
-    ) {
-        let start = reader.getCursor();
-        let result: T = this.type.parse(reader, contextBuilder as any);
-        let parsed: ParsedArgument<S, T> = new ParsedArgument(
-            start,
-            reader.getCursor(),
-            result
-        );
-        contextBuilder.withArgument(this.name, parsed);
-        contextBuilder.withNode(this, parsed.getRange());
-    }
-
-    public listSuggestions(
-        context: CommandContext<S>,
-        builder: SuggestionsBuilder
-    ): Promise<Suggestions> {
-        if (this.customSuggestions == null) {
-            if (typeof this.type.listSuggestions === 'function')
-                return this.type.listSuggestions(context, builder);
-            else return Suggestions.empty();
-        } else {
-            return this.customSuggestions.getSuggestions(context, builder);
-        }
-    }
-
-    public createBuilder(): RequiredArgumentBuilder<S, T> {
-        let builder: RequiredArgumentBuilder<
-            S,
-            T
-        > = RequiredArgumentBuilder.argument(this.name, this.type);
-        builder.requires(this.getRequirement());
-        builder.forward(
-            this.getRedirect(),
-            this.getRedirectModifier(),
-            this.isFork()
-        );
-        builder.suggests(this.customSuggestions);
-        if (this.getCommand() != null) {
-            builder.executes(this.getCommand());
-        }
-
-        return builder;
-    }
-
-    public isValidInput(input: string, context: any): boolean {
-        try {
-            let reader: StringReader = new StringReader(input);
-            this.type.parse(reader, context);
-            return !reader.canRead() || reader.peek() == ' ';
-        } catch (ignored) {}
-
-        return false;
-    }
-
-    public equals(o: object): boolean {
-        if (this === o) return true;
-        if (!(o instanceof ArgumentCommandNode)) return false;
-
-        if (!(this.name === o.name)) return false;
-        if (!isEqual(this.type, o.type)) return false;
-
-        return super.equals(o);
-    }
-
-    public getSortedKey(): string {
-        return this.name;
-    }
-
-    public getExamples(): Iterable<string> {
-        return typeof this.type.getExamples === 'function'
-            ? this.type.getExamples()
-            : [];
-    }
-
-    public toString(): string {
-        return '<argument ' + this.name + ':' + this.type + '>';
-    }
-}

package/src/lib/tree/CommandNode.ts

@@ -1,208 +0,0 @@
-import AmbiguityConsumer from '../AmbiguityConsumer';
-import ArgumentBuilder from '../builder/ArgumentBuilder';
-import Command from '../Command';
-import CommandContext from '../context/CommandContext';
-import CommandContextBuilder from '../context/CommandContextBuilder';
-import Predicate from '../Predicate';
-import RedirectModifier from '../RedirectModifier';
-import StringReader from '../StringReader';
-import Suggestions from '../suggestion/Suggestions';
-import SuggestionsBuilder from '../suggestion/SuggestionsBuilder';
-import isEqual from '../util/isEqual';
-
-abstract class CommandNode<S> {
-    private children: Map<string, CommandNode<S>> = new Map();
-
-    private literals: Map<string, any> = new Map();
-
-    private args: Map<string, any> = new Map();
-
-    private requirement: Predicate<S>;
-
-    private redirect: CommandNode<S>;
-
-    private modifier: RedirectModifier<S>;
-
-    private forks: boolean;
-
-    private command: Command<S>;
-
-    public abstract getNodeType(): string;
-
-    public constructor(
-        command: Command<S>,
-        requirement: Predicate<S>,
-        redirect: CommandNode<S>,
-        modifier: RedirectModifier<S>,
-        forks: boolean
-    ) {
-        this.command = command;
-        this.requirement = requirement || (() => true);
-        this.redirect = redirect;
-        this.modifier = modifier;
-        this.forks = forks;
-    }
-
-    public getCommand(): Command<S> {
-        return this.command;
-    }
-
-    public getChildren(): IterableIterator<CommandNode<S>> {
-        return this.children.values();
-    }
-
-    public getChildrenCount(): number {
-        return this.children.size;
-    }
-
-    public getChild(name: string): CommandNode<S> {
-        return this.children.get(name);
-    }
-
-    public getRedirect(): CommandNode<S> {
-        return this.redirect;
-    }
-
-    public getRedirectModifier(): RedirectModifier<S> {
-        return this.modifier;
-    }
-
-    public canUse(source: S): boolean {
-        return this.requirement(source);
-    }
-
-    public addChild(node: CommandNode<S>) {
-        if (node.getNodeType() === 'root') {
-            throw new Error(
-                'Cannot add a RootCommandNode as a child to any other CommandNode'
-            );
-        }
-
-        let child = this.children.get(node.getName());
-        if (child != null) {
-            //  We've found something to merge onto
-            if (node.getCommand() != null) {
-                child.command = node.getCommand();
-            }
-
-            for (let grandchild of node.getChildren()) {
-                child.addChild(grandchild);
-            }
-        } else {
-            this.children.set(node.getName(), node);
-            if (node.getNodeType() === 'literal') {
-                this.literals.set(node.getName(), node);
-            } else if (node.getNodeType() === 'argument') {
-                this.args.set(node.getName(), node);
-            }
-        }
-
-        this.children = new Map(
-            [...this.children.entries()].sort((a, b) => a[1].compareTo(b[1]))
-        );
-    }
-
-    public findAmbiguities(consumer: AmbiguityConsumer<S>, context: any) {
-        let matches: Array<string> = [];
-        for (let child of this.children.values()) {
-            for (let sibling of this.children.values()) {
-                if (child === sibling) {
-                    continue;
-                }
-
-                for (let input of child.getExamples()) {
-                    if (sibling.isValidInput(input, context)) {
-                        matches.push(input);
-                    }
-                }
-
-                if (matches.length > 0) {
-                    consumer.ambiguous(this, child, sibling, matches);
-                    matches = [];
-                }
-            }
-
-            child.findAmbiguities(consumer, context);
-        }
-    }
-
-    public abstract isValidInput(input: string, context: any): boolean;
-
-    public equals(o: object): boolean {
-        if (this === o) return true;
-        if (!(o instanceof CommandNode)) return false;
-
-        if (this.children.size !== o.children.size) {
-            return false;
-        }
-
-        if (!isEqual(this.children, o.children)) return false;
-
-        if (
-            this.command != null
-                ? !isEqual(this.command, o.command)
-                : o.command != null
-        )
-            return false;
-
-        return true;
-    }
-
-    public getRequirement() {
-        return this.requirement;
-    }
-
-    public abstract getName(): string;
-
-    public abstract getUsageText(): string;
-
-    public abstract parse(
-        reader: StringReader,
-        contextBuilder: CommandContextBuilder<S>
-    ): void;
-
-    public abstract listSuggestions(
-        context: CommandContext<S>,
-        builder: SuggestionsBuilder
-    ): Promise<Suggestions>;
-
-    public abstract createBuilder(): ArgumentBuilder<S, any>;
-
-    public abstract getSortedKey(): string;
-
-    public getRelevantNodes(input: StringReader): Iterable<CommandNode<S>> {
-        if (this.literals.size > 0) {
-            let cursor: number = input.getCursor();
-            while (input.canRead() && input.peek() != ' ') {
-                input.skip();
-            }
-
-            let text = input.getString().substring(cursor, input.getCursor());
-            input.setCursor(cursor);
-            let literal = this.literals.get(text);
-            if (literal != null) {
-                return [literal];
-            } else {
-                return this.args.values();
-            }
-        } else {
-            return this.args.values();
-        }
-    }
-
-    public compareTo(o: CommandNode<S>): number {
-        if (this.getNodeType() === o.getNodeType()) {
-            return this.getSortedKey() > o.getSortedKey() ? 1 : -1;
-        }
-
-        return o.getNodeType() === 'literal' ? 1 : -1;
-    }
-
-    public isFork(): boolean {
-        return this.forks;
-    }
-
-    public abstract getExamples(): Iterable<string>;
-}
-
-export default CommandNode;