@wq2/brigadier-ts 1.0.0

package/.github/workflows/publish.yml

@@ -0,0 +1,49 @@
+name: Publish
+
+on:
+    push:
+      tags:
+        - v*
+    workflow_dispatch:
+        inputs:
+            tag_name:
+                description: Version to publish
+                required: true
+                type: string
+            release_name:
+                description: GitHub Release name
+                required: true
+                type: string
+
+jobs:
+    publish:
+        environment: a
+        runs-on: ubuntu-slim
+        # TODO: also publish to GitHub packages (because why not)
+        permissions:
+            id-token: write # Required for OIDC
+            contents: write
+            packages: write
+
+        steps:
+            - uses: actions/checkout@v6
+            - uses: actions/setup-node@v6
+              with:
+                node-version: '24'
+
+            - name: Install & Build
+              run: npm install && npm run build
+
+            - name: Publish (npm)
+              run: npm publish --registry=https://registry.npmjs.org/ --loglevel info
+              env:
+                GITHUB_TOKEN: ${{ env.GITHUB_TOKEN }}
+                NPM_TOKEN: ${{ env.GITHUB_TOKEN }}
+
+            - name: Create GitHub release
+              uses: softprops/action-gh-release@v2
+              with:
+                tag_name: ${{ github.event.inputs.tag_name || github.ref_name }}
+                name: ${{ github.event.inputs.release_name || github.ref_name }}
+              env:
+                GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/.github/workflows/test.yml

@@ -0,0 +1,23 @@
+name: Test
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v1
+
+    - name: Install
+      run: npm ci
+
+    - name: Build
+      run: npm run build
+
+    - name: Test
+      run: npm run test

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Misode
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,131 @@
+# Brigadier-ts
+
+Fork of [brigadier-ts](https://github.com/misode/brigadier-ts) with some changes:
+
+- (breaking change) Predicates and Commands are async
+- Update branding
+
+(not many, but we'll probably add more later)
+
+## Installation
+
+```
+npm install @wq2/brigadier-ts
+```
+
+## Usage
+
+#### Example using a command source
+
+```js
+import {
+    CommandDispatcher,
+    IntegerArgumentType,
+    literal,
+    argument
+} from "brigadier-ts";
+
+class CommandSource {
+    private a: number;
+    constructor(a: number) {
+        this.a = a;
+    }
+    getA(): number {
+        return this.a;
+    }
+}
+
+const dispatcher = new CommandDispatcher<CommandSource>();
+dispatcher.register(literal("random")
+    .executes(async c => 4)
+);
+dispatcher.register(literal("double")
+    .then(argument("value", new IntegerArgumentType())
+        .executes(async c => 2 * c.get("value"))
+    )
+);
+dispatcher.register(literal("add")
+    .executes(async c => 4 + c.getSource().getA())
+);
+
+console.log(await dispatcher.execute("random", null)); // 4
+console.log(await dispatcher.execute("double 3", null)); // 6
+console.log(await dispatcher.execute("add", new CommandSource(3))); // 7
+```
+
+#### Example using redirection and forking
+
+```ts
+import {
+    CommandDispatcher,
+    IntegerArgumentType,
+    literal,
+    argument
+} from "brigadier-ts";
+
+const dispatcher = new CommandDispatcher<number>();
+const execute = dispatcher.register(literal("execute"));
+
+dispatcher.register(literal("execute")
+    .then(literal("run")
+        .redirect(dispatcher.getRoot())
+    )
+    .then(literal("enumerate")
+        .then(argument("nums", new IntegerArgumentType())
+            .fork(async execute, c => {
+                let list: number[] = [];
+                for (let i = c.get("nums"); i > 0; i--) {
+                    list.push(i);
+                }
+                return list;
+            })
+        )
+    )
+);
+
+dispatcher.register(literal("say")
+    .executes(async c => {
+        console.log(c.getSource());
+    })
+)
+
+console.log(await dispatcher.execute("execute enumerate 5 run say", 0));
+```
+
+#### Example using suggestions and errors
+```ts
+import {
+    CommandDispatcher,
+    IntegerArgumentType,
+    literal,
+    argument
+} from "brigadier-ts";
+
+const dispatcher = new CommandDispatcher<number>();
+dispatcher.register(literal("double")
+    .then(argument("value", new IntegerArgumentType())
+        .executes(async c => 2 * c.get("value"))
+    )
+);
+
+const getFeedback = async (command: string): Promise<string> => {
+    const parseResults = await dispatcher.parse(command, null);
+    if (parseResults.getErrors().size > 0) {
+        return command + " >> " + parseResults.getErrors().values().next().value.message;
+    }
+    const suggestions = await dispatcher.getCompletionSuggestions(parseResults);
+    if (suggestions.getList().length > 0) {
+        const s = suggestions.getList()[0];
+        return command + " >> S " + s.getText() + " (" + s.getRange().getStart() + ", " + s.getRange().getEnd() + ")";
+    }
+    const usage = await dispatcher.getAllUsage(parseResults.getContext().getRootNode(), null, false);
+    if (usage.length > 0) {
+        return command + " >> U " + usage[0];
+    }
+    return command;
+}
+
+getFeedback("dou").then(f => console.log(f)); // dou >> S double
+getFeedback("double").then(f => console.log(f)); // double >> U double <value>
+getFeedback("double ").then(f => console.log(f)); // double  >> Expected integer at position 7: double <--[HERE]
+```

package/dist/Command.d.ts

@@ -0,0 +1,2 @@
+import { CommandContext } from "./";
+export type Command<S> = (c: CommandContext<S>) => Promise<number | void>;

package/dist/Command.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/CommandDispatcher.d.ts

@@ -0,0 +1,20 @@
+import { RootCommandNode, LiteralCommandNode, StringReader, LiteralArgumentBuilder, CommandNode, ParseResults, Suggestions } from ".";
+export declare class CommandDispatcher<S> {
+    private root;
+    private static USAGE_OPTIONAL_OPEN;
+    private static USAGE_OPTIONAL_CLOSE;
+    private static USAGE_REQUIRED_OPEN;
+    private static USAGE_REQUIRED_CLOSE;
+    private static USAGE_OR;
+    constructor();
+    register(command: LiteralArgumentBuilder<S>): LiteralCommandNode<S>;
+    execute(parse: ParseResults<S> | string, source: S): Promise<number>;
+    parse(reader: StringReader | string, source: S): Promise<ParseResults<S>>;
+    private parseNodes;
+    getAllUsage(node: CommandNode<S>, source: S, restricted: boolean): Promise<string[]>;
+    private getAllUsageImpl;
+    getCompletionSuggestions(parse: ParseResults<S>, cursor?: number): Promise<Suggestions>;
+    getSmartUsage(node: CommandNode<S>, source: S): Map<CommandNode<S>, string>;
+    getSmartUsage(node: CommandNode<S>, source: S, optional: boolean, deep: boolean): string;
+    getRoot(): RootCommandNode<S>;
+}

package/dist/CommandDispatcher.js

@@ -0,0 +1,416 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandDispatcher = void 0;
+var _1 = require(".");
+var CommandDispatcher = /** @class */ (function () {
+    function CommandDispatcher() {
+        this.root = new _1.RootCommandNode();
+    }
+    CommandDispatcher.prototype.register = function (command) {
+        var build = command.build();
+        this.root.addChild(build);
+        return build;
+    };
+    CommandDispatcher.prototype.execute = function (parse, source) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result, successfulForks, forked, foundCommand, command, original, contexts, next, size, _loop_1, i;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(typeof (parse) === "string")) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.parse(new _1.StringReader(parse), source)];
+                    case 1:
+                        parse = _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        if (parse.getReader().canRead()) {
+                            if (parse.getErrors().size == 1) {
+                                throw parse.getErrors().values().next();
+                            }
+                            else if (parse.getContext().getRange().isEmpty()) {
+                                throw _1.CommandSyntaxError.DISPATCHER_UNKNOWN_COMMAND.createWithContext(parse.getReader());
+                            }
+                            else {
+                                throw _1.CommandSyntaxError.DISPATCHER_UNKNOWN_ARGUMENT.createWithContext(parse.getReader());
+                            }
+                        }
+                        result = 0;
+                        successfulForks = 0;
+                        forked = false;
+                        foundCommand = false;
+                        command = parse.getReader().getString();
+                        original = parse.getContext().build(command);
+                        contexts = [original];
+                        next = [];
+                        _a.label = 3;
+                    case 3:
+                        if (!(contexts.length > 0)) return [3 /*break*/, 8];
+                        size = contexts.length;
+                        _loop_1 = function (i) {
+                            var context, child, modifier, results, value, e_1;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        context = contexts[i];
+                                        child = context.getChild();
+                                        if (!(child !== null)) return [3 /*break*/, 1];
+                                        forked = forked || context.isForked();
+                                        if (child.hasNodes()) {
+                                            foundCommand = true;
+                                            modifier = context.getRedirectModifier();
+                                            if (modifier === null) {
+                                                next.push(child.copyFor(context.getSource()));
+                                            }
+                                            else {
+                                                try {
+                                                    results = modifier(context);
+                                                    results.forEach(function (source) {
+                                                        next.push(child.copyFor(source));
+                                                    });
+                                                }
+                                                catch (e) {
+                                                    if (!forked)
+                                                        throw e;
+                                                }
+                                            }
+                                        }
+                                        return [3 /*break*/, 5];
+                                    case 1:
+                                        if (!context.getCommand()) return [3 /*break*/, 5];
+                                        foundCommand = true;
+                                        _b.label = 2;
+                                    case 2:
+                                        _b.trys.push([2, 4, , 5]);
+                                        return [4 /*yield*/, context.getCommand()(context)];
+                                    case 3:
+                                        value = _b.sent();
+                                        result += (value || value === 0) ? value : 1;
+                                        successfulForks++;
+                                        return [3 /*break*/, 5];
+                                    case 4:
+                                        e_1 = _b.sent();
+                                        if (!forked)
+                                            throw e_1;
+                                        return [3 /*break*/, 5];
+                                    case 5: return [2 /*return*/];
+                                }
+                            });
+                        };
+                        i = 0;
+                        _a.label = 4;
+                    case 4:
+                        if (!(i < size)) return [3 /*break*/, 7];
+                        return [5 /*yield**/, _loop_1(i)];
+                    case 5:
+                        _a.sent();
+                        _a.label = 6;
+                    case 6:
+                        i++;
+                        return [3 /*break*/, 4];
+                    case 7:
+                        contexts = next;
+                        next = [];
+                        return [3 /*break*/, 3];
+                    case 8:
+                        if (!foundCommand) {
+                            throw _1.CommandSyntaxError.DISPATCHER_UNKNOWN_COMMAND.createWithContext(parse.getReader());
+                        }
+                        return [2 /*return*/, forked ? successfulForks : result];
+                }
+            });
+        });
+    };
+    CommandDispatcher.prototype.parse = function (reader, source) {
+        return __awaiter(this, void 0, void 0, function () {
+            var context;
+            return __generator(this, function (_a) {
+                reader = new _1.StringReader(reader);
+                context = new _1.CommandContextBuilder(this, source, this.root, reader.getCursor());
+                return [2 /*return*/, this.parseNodes(this.root, reader, context)];
+            });
+        });
+    };
+    CommandDispatcher.prototype.parseNodes = function (node, originalReader, contextSoFar) {
+        return __awaiter(this, void 0, void 0, function () {
+            var source, errors, potentials, cursor, _i, _a, child, context, reader, childContext, parse;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        source = contextSoFar.getSource();
+                        errors = new Map();
+                        potentials = [];
+                        cursor = originalReader.getCursor();
+                        _i = 0, _a = node.getRelevantNodes(originalReader);
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < _a.length)) return [3 /*break*/, 8];
+                        child = _a[_i];
+                        return [4 /*yield*/, child.canUse(source)];
+                    case 2:
+                        if (!(_b.sent())) {
+                            return [3 /*break*/, 7];
+                        }
+                        context = contextSoFar.copy();
+                        reader = new _1.StringReader(originalReader);
+                        try {
+                            try {
+                                child.parse(reader, context);
+                            }
+                            catch (e) {
+                                if (e instanceof _1.CommandSyntaxError) {
+                                    throw e;
+                                }
+                                else {
+                                    throw _1.CommandSyntaxError.DISPATCHER_PARSE_ERROR.createWithContext(reader, e.message);
+                                }
+                            }
+                            if (reader.canRead() && reader.peek() !== " ") {
+                                throw _1.CommandSyntaxError.DISPATCHER_EXPECTED_ARGUMENT_SEPARATOR.createWithContext(reader);
+                            }
+                        }
+                        catch (e) {
+                            if (e instanceof _1.CommandSyntaxError) {
+                                errors.set(child, e);
+                                reader.setCursor(cursor);
+                                return [3 /*break*/, 7];
+                            }
+                            else {
+                                throw e;
+                            }
+                        }
+                        context.withCommand(child.getCommand());
+                        if (!reader.canRead(child.getRedirect() === null ? 2 : 1)) return [3 /*break*/, 6];
+                        reader.skip();
+                        if (!child.getRedirect()) return [3 /*break*/, 4];
+                        childContext = new _1.CommandContextBuilder(this, source, child.getRedirect(), reader.getCursor());
+                        return [4 /*yield*/, this.parseNodes(child.getRedirect(), reader, childContext)];
+                    case 3:
+                        parse = _b.sent();
+                        context.withChild(parse.getContext());
+                        return [2 /*return*/, new _1.ParseResults(context, parse.getReader(), parse.getErrors())];
+                    case 4:
+                        potentials.push(this.parseNodes(child, reader, context));
+                        _b.label = 5;
+                    case 5: return [3 /*break*/, 7];
+                    case 6:
+                        potentials.push(new _1.ParseResults(context, reader, new Map()));
+                        _b.label = 7;
+                    case 7:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 8:
+                        if (potentials.length == 0) {
+                            potentials.push(new _1.ParseResults(contextSoFar, originalReader, errors));
+                        }
+                        return [2 /*return*/, potentials[0]];
+                }
+            });
+        });
+    };
+    CommandDispatcher.prototype.getAllUsage = function (node, source, restricted) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        result = [];
+                        return [4 /*yield*/, this.getAllUsageImpl(node, source, result, "", restricted)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    CommandDispatcher.prototype.getAllUsageImpl = function (node, source, result, prefix, restricted) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, redirect, _i, _b, child, newPrefix;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _a = restricted;
+                        if (!_a) return [3 /*break*/, 2];
+                        return [4 /*yield*/, node.canUse(source)];
+                    case 1:
+                        _a = !(_c.sent());
+                        _c.label = 2;
+                    case 2:
+                        if (_a) {
+                            return [2 /*return*/];
+                        }
+                        if (node.getCommand() != null) {
+                            result.push(prefix);
+                        }
+                        if (!(node.getRedirect() != null)) return [3 /*break*/, 3];
+                        redirect = node.getRedirect() === this.root ? "..." : "-> " + node.getRedirect().getUsageText();
+                        result.push(prefix.length === 0 ? node.getUsageText() + " " + redirect : prefix + " " + redirect);
+                        return [3 /*break*/, 7];
+                    case 3:
+                        if (!(node.getChildren().length > 0)) return [3 /*break*/, 7];
+                        _i = 0, _b = node.getChildren();
+                        _c.label = 4;
+                    case 4:
+                        if (!(_i < _b.length)) return [3 /*break*/, 7];
+                        child = _b[_i];
+                        newPrefix = prefix.length === 0 ? child.getUsageText() : prefix + " " + child.getUsageText();
+                        return [4 /*yield*/, this.getAllUsageImpl(child, source, result, newPrefix, restricted)];
+                    case 5:
+                        _c.sent();
+                        _c.label = 6;
+                    case 6:
+                        _i++;
+                        return [3 /*break*/, 4];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    CommandDispatcher.prototype.getCompletionSuggestions = function (parse, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            var context, nodeBeforeCursor, parent, start, fullInput, truncatedInput, promises, _i, _a, node, promise, suggestions;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (cursor === undefined) {
+                            cursor = parse.getReader().getTotalLength();
+                        }
+                        context = parse.getContext();
+                        nodeBeforeCursor = context.findSuggestionContext(cursor);
+                        parent = nodeBeforeCursor.parent;
+                        start = Math.min(nodeBeforeCursor.startPos, cursor);
+                        fullInput = parse.getReader().getString();
+                        truncatedInput = fullInput.substring(0, cursor);
+                        promises = [];
+                        for (_i = 0, _a = parent.getChildren(); _i < _a.length; _i++) {
+                            node = _a[_i];
+                            promise = _1.Suggestions.empty();
+                            try {
+                                promise = node.listSuggestions(context.build(truncatedInput), new _1.SuggestionsBuilder(truncatedInput, start));
+                            }
+                            catch (ignored) {
+                                console.log("???", ignored);
+                            }
+                            promises.push(promise);
+                        }
+                        return [4 /*yield*/, Promise.all(promises)];
+                    case 1:
+                        suggestions = _b.sent();
+                        return [2 /*return*/, _1.Suggestions.merge(fullInput, suggestions)];
+                }
+            });
+        });
+    };
+    CommandDispatcher.prototype.getSmartUsage = function (node, source, optional, deep) {
+        if (optional === undefined && deep === undefined) {
+            var result = new Map();
+            var optional_1 = node.getCommand() !== undefined && node.getCommand() !== null;
+            var children = node.getChildren();
+            for (var index in children) {
+                var child = children[index];
+                var usage = this.getSmartUsage(child, source, optional_1, false);
+                if (usage !== undefined) {
+                    result.set(child, usage);
+                }
+            }
+            return result;
+        }
+        else {
+            if (!node.canUse(source)) {
+                return undefined;
+            }
+            var self_1 = optional ? CommandDispatcher.USAGE_OPTIONAL_OPEN + node.getUsageText() + CommandDispatcher.USAGE_OPTIONAL_CLOSE : node.getUsageText();
+            var childOptional = node.getCommand() !== undefined;
+            var open_1 = childOptional ? CommandDispatcher.USAGE_OPTIONAL_OPEN : CommandDispatcher.USAGE_REQUIRED_OPEN;
+            var close_1 = childOptional ? CommandDispatcher.USAGE_OPTIONAL_CLOSE : CommandDispatcher.USAGE_REQUIRED_CLOSE;
+            if (!deep) {
+                if (node.getRedirect() !== undefined) {
+                    var redirect = node.getRedirect() === this.root ? "..." : "-> " + node.getRedirect().getUsageText();
+                    return self_1 + " " + redirect;
+                }
+                else {
+                    var children = node.getChildren().filter(function (c) { return c.canUse(source); });
+                    if (children.length === 1) {
+                        var usage = String(this.getSmartUsage(children[0], source, childOptional, childOptional));
+                        if (usage !== undefined) {
+                            return self_1 + " " + usage;
+                        }
+                    }
+                    else if (children.length > 1) {
+                        var childUsage = new Set();
+                        for (var index in children) {
+                            var child = children[index];
+                            var usage = this.getSmartUsage(child, source, childOptional, true);
+                            if (usage !== undefined) {
+                                childUsage.add(usage);
+                            }
+                        }
+                        if (childUsage.size === 1) {
+                            var usage = childUsage.values().next().value;
+                            return self_1 + " " + (childOptional ? CommandDispatcher.USAGE_OPTIONAL_OPEN + usage + CommandDispatcher.USAGE_OPTIONAL_CLOSE : usage);
+                        }
+                        else if (childUsage.size > 1) {
+                            var builder = open_1;
+                            for (var index = 0; index < children.length; index++) {
+                                var child = children[index];
+                                if (index > 0) {
+                                    builder += CommandDispatcher.USAGE_OR;
+                                }
+                                builder += child.getUsageText();
+                            }
+                            if (children.length > 0) {
+                                builder += close_1;
+                                return self_1 + " " + builder;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    };
+    CommandDispatcher.prototype.getRoot = function () {
+        return this.root;
+    };
+    CommandDispatcher.USAGE_OPTIONAL_OPEN = "[";
+    CommandDispatcher.USAGE_OPTIONAL_CLOSE = "]";
+    CommandDispatcher.USAGE_REQUIRED_OPEN = "(";
+    CommandDispatcher.USAGE_REQUIRED_CLOSE = ")";
+    CommandDispatcher.USAGE_OR = "|";
+    return CommandDispatcher;
+}());
+exports.CommandDispatcher = CommandDispatcher;