@trioforge/brigadier 0.0.0-stage → 0.1.1

package/out/command-dispatcher.luau

@@ -0,0 +1,394 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _context = TS.import(script, script.Parent, "context")
+local CommandContextBuilder = _context.CommandContextBuilder
+local ContextChain = _context.ContextChain
+local CommandSyntaxException = TS.import(script, script.Parent, "exceptions").CommandSyntaxException
+local _java = TS.import(script, script.Parent, "java")
+local rethrow = _java.rethrow
+local stableSort = _java.stableSort
+local substring = _java.substring
+local toLowerCase = _java.toLowerCase
+local StringReader = TS.import(script, script.Parent, "string-reader").StringReader
+local _suggestion = TS.import(script, script.Parent, "suggestion")
+local Suggestions = _suggestion.Suggestions
+local SuggestionsBuilder = _suggestion.SuggestionsBuilder
+local RootCommandNode = TS.import(script, script.Parent, "tree").RootCommandNode
+local ParseResults
+do
+	ParseResults = setmetatable({}, {
+		__tostring = function()
+			return "ParseResults"
+		end,
+	})
+	ParseResults.__index = ParseResults
+	function ParseResults.new(...)
+		local self = setmetatable({}, ParseResults)
+		return self:constructor(...) or self
+	end
+	function ParseResults:constructor(context, reader, exceptions)
+		self.context = context
+		self.reader = reader or StringReader.new("")
+		self.exceptions = exceptions or {}
+	end
+	function ParseResults:getContext()
+		return self.context
+	end
+	function ParseResults:getReader()
+		return self.reader
+	end
+	function ParseResults:getExceptions()
+		return self.exceptions
+	end
+end
+local ARGUMENT_SEPARATOR = " "
+local USAGE_OPTIONAL_OPEN = "["
+local USAGE_OPTIONAL_CLOSE = "]"
+local USAGE_REQUIRED_OPEN = "("
+local USAGE_REQUIRED_CLOSE = ")"
+local USAGE_OR = "|"
+local function ignoreResult()
+end
+-- The message of an error that isn't a CommandSyntaxException, as RuntimeException.getMessage gives it.
+local function messageOf(err)
+	local _err = err
+	local _condition = type(_err) == "table"
+	if _condition then
+		local _getMessage = err.getMessage
+		_condition = type(_getMessage) == "function"
+	end
+	if _condition then
+		return err:getMessage()
+	end
+	return tostring(err)
+end
+local function hasCommandSyntaxExceptions(parse)
+	return not (next(parse:getExceptions()) == nil)
+end
+local function compareParses(a, b)
+	if not a:getReader():canRead() and b:getReader():canRead() then
+		return -1
+	end
+	if a:getReader():canRead() and not b:getReader():canRead() then
+		return 1
+	end
+	if not hasCommandSyntaxExceptions(a) and hasCommandSyntaxExceptions(b) then
+		return -1
+	end
+	if hasCommandSyntaxExceptions(a) and not hasCommandSyntaxExceptions(b) then
+		return 1
+	end
+	return 0
+end
+local CommandDispatcher
+do
+	CommandDispatcher = setmetatable({}, {
+		__tostring = function()
+			return "CommandDispatcher"
+		end,
+	})
+	CommandDispatcher.__index = CommandDispatcher
+	function CommandDispatcher.new(...)
+		local self = setmetatable({}, CommandDispatcher)
+		return self:constructor(...) or self
+	end
+	function CommandDispatcher:constructor(root)
+		self.consumer = ignoreResult
+		self.root = root or RootCommandNode.new()
+	end
+	function CommandDispatcher:register(command)
+		local build = command:build()
+		self.root:addChild(build)
+		return build
+	end
+	function CommandDispatcher:setConsumer(consumer)
+		self.consumer = consumer
+	end
+	function CommandDispatcher:execute(input, source)
+		if TS.instanceof(input, ParseResults) then
+			return self:executeParse(input)
+		end
+		return self:executeParse(self:parse(input, source))
+	end
+	function CommandDispatcher:executeParse(parse)
+		if parse:getReader():canRead() then
+			local exceptions = parse:getExceptions()
+			-- ▼ ReadonlyMap.size ▼
+			local _size = 0
+			for _ in exceptions do
+				_size += 1
+			end
+			-- ▲ ReadonlyMap.size ▲
+			if _size == 1 then
+				for _, exception in exceptions do
+					error(exception)
+				end
+			elseif parse:getContext():getRange():isEmpty() then
+				error(CommandSyntaxException.BUILT_IN_EXCEPTIONS:dispatcherUnknownCommand():createWithContext(parse:getReader()))
+			end
+			error(CommandSyntaxException.BUILT_IN_EXCEPTIONS:dispatcherUnknownArgument():createWithContext(parse:getReader()))
+		end
+		local command = parse:getReader():getString()
+		local original = parse:getContext():build(command)
+		local flatContext = ContextChain:tryFlatten(original)
+		if flatContext == nil then
+			self.consumer(original, false, 0)
+			error(CommandSyntaxException.BUILT_IN_EXCEPTIONS:dispatcherUnknownCommand():createWithContext(parse:getReader()))
+		end
+		return flatContext:executeAll(original:getSource(), self.consumer)
+	end
+	function CommandDispatcher:parse(command, source)
+		local _command = command
+		local reader = if type(_command) == "string" then StringReader.new(command) else command
+		local context = CommandContextBuilder.new(self, source, self.root, reader:getCursor())
+		return self:parseNodes(self.root, reader, context)
+	end
+	function CommandDispatcher:parseNodes(node, originalReader, contextSoFar)
+		local source = contextSoFar:getSource()
+		local errors
+		local potentials
+		local cursor = originalReader:getCursor()
+		for _, child in node:getRelevantNodes(originalReader) do
+			if not child:canUse(source) then
+				continue
+			end
+			local context = contextSoFar:copy()
+			local reader = StringReader.new(originalReader)
+			local exception
+			TS.try(function()
+				child:parse(reader, context)
+				if reader:canRead() and reader:peek() ~= ARGUMENT_SEPARATOR then
+					exception = CommandSyntaxException.BUILT_IN_EXCEPTIONS:dispatcherExpectedArgumentSeparator():createWithContext(reader)
+				end
+			end, function(err)
+				exception = if TS.instanceof(err, CommandSyntaxException) then err else CommandSyntaxException.BUILT_IN_EXCEPTIONS:dispatcherParseException():createWithContext(reader, messageOf(err))
+			end)
+			if exception ~= nil then
+				if errors == nil then
+					errors = {}
+				end
+				local _errors = errors
+				local _exception = exception
+				_errors[child] = _exception
+				reader:setCursor(cursor)
+				continue
+			end
+			context:withCommand(child:getCommand())
+			local redirect = child:getRedirect()
+			if reader:canRead(if redirect == nil then 2 else 1) then
+				reader:skip()
+				if redirect ~= nil then
+					local childContext = CommandContextBuilder.new(self, source, redirect, reader:getCursor())
+					local parse = self:parseNodes(redirect, reader, childContext)
+					context:withChild(parse:getContext())
+					return ParseResults.new(context, parse:getReader(), parse:getExceptions())
+				end
+				local parse = self:parseNodes(child, reader, context)
+				if potentials == nil then
+					potentials = {}
+				end
+				table.insert(potentials, parse)
+			else
+				if potentials == nil then
+					potentials = {}
+				end
+				local _potentials = potentials
+				local _parseResults = ParseResults.new(context, reader, {})
+				table.insert(_potentials, _parseResults)
+			end
+		end
+		if potentials ~= nil then
+			if #potentials > 1 then
+				stableSort(potentials, compareParses)
+			end
+			return potentials[1]
+		end
+		return ParseResults.new(contextSoFar, originalReader, errors or {})
+	end
+	function CommandDispatcher:getAllUsage(node, source, restricted)
+		local result = {}
+		self:getAllUsageRecursive(node, source, result, "", restricted)
+		return result
+	end
+	function CommandDispatcher:getAllUsageRecursive(node, source, result, prefix, restricted)
+		if restricted and not node:canUse(source) then
+			return nil
+		end
+		if node:getCommand() ~= nil then
+			local _result = result
+			local _prefix = prefix
+			table.insert(_result, _prefix)
+		end
+		local redirect = node:getRedirect()
+		if redirect ~= nil then
+			local redirectText = if rawequal(redirect, self.root) then "..." else "-> " .. redirect:getUsageText()
+			local _result = result
+			local _arg0 = if prefix == "" then node:getUsageText() .. ARGUMENT_SEPARATOR .. redirectText else prefix .. ARGUMENT_SEPARATOR .. redirectText
+			table.insert(_result, _arg0)
+		else
+			for _, child in node:getChildren() do
+				self:getAllUsageRecursive(child, source, result, if prefix == "" then child:getUsageText() else prefix .. ARGUMENT_SEPARATOR .. child:getUsageText(), restricted)
+			end
+		end
+	end
+	function CommandDispatcher:getSmartUsage(node, source)
+		local result = {}
+		local optional = node:getCommand() ~= nil
+		for _, child in node:getChildren() do
+			local usage = self:getSmartUsageRecursive(child, source, optional, false)
+			if usage ~= nil then
+				result[child] = usage
+			end
+		end
+		return result
+	end
+	function CommandDispatcher:getSmartUsageRecursive(node, source, optional, deep)
+		if not node:canUse(source) then
+			return nil
+		end
+		local selfUsage = if optional then USAGE_OPTIONAL_OPEN .. node:getUsageText() .. USAGE_OPTIONAL_CLOSE else node:getUsageText()
+		local childOptional = node:getCommand() ~= nil
+		local open = if childOptional then USAGE_OPTIONAL_OPEN else USAGE_REQUIRED_OPEN
+		local close = if childOptional then USAGE_OPTIONAL_CLOSE else USAGE_REQUIRED_CLOSE
+		if not deep then
+			local redirect = node:getRedirect()
+			if redirect ~= nil then
+				local redirectText = if rawequal(redirect, self.root) then "..." else "-> " .. redirect:getUsageText()
+				return selfUsage .. ARGUMENT_SEPARATOR .. redirectText
+			end
+			local _exp = node:getChildren()
+			-- ▼ ReadonlyArray.filter ▼
+			local _newValue = {}
+			local _callback = function(child)
+				return child:canUse(source)
+			end
+			local _length = 0
+			for _k, _v in _exp do
+				if _callback(_v, _k - 1, _exp) == true then
+					_length += 1
+					_newValue[_length] = _v
+				end
+			end
+			-- ▲ ReadonlyArray.filter ▲
+			local children = _newValue
+			if #children == 1 then
+				local usage = self:getSmartUsageRecursive(children[1], source, childOptional, childOptional)
+				if usage ~= nil then
+					return selfUsage .. ARGUMENT_SEPARATOR .. usage
+				end
+			elseif #children > 1 then
+				-- A LinkedHashSet<String>.
+				local childUsage = {}
+				for _, child in children do
+					local usage = self:getSmartUsageRecursive(child, source, childOptional, true)
+					if usage ~= nil and not (table.find(childUsage, usage) ~= nil) then
+						table.insert(childUsage, usage)
+					end
+				end
+				if #childUsage == 1 then
+					local usage = childUsage[1]
+					return selfUsage .. ARGUMENT_SEPARATOR .. (if childOptional then USAGE_OPTIONAL_OPEN .. usage .. USAGE_OPTIONAL_CLOSE else usage)
+				elseif #childUsage > 1 then
+					local builder = open
+					local count = 0
+					for _, child in children do
+						if count > 0 then
+							builder ..= USAGE_OR
+						end
+						builder ..= child:getUsageText()
+						count += 1
+					end
+					if count > 0 then
+						builder ..= close
+						return selfUsage .. ARGUMENT_SEPARATOR .. builder
+					end
+				end
+			end
+		end
+		return selfUsage
+	end
+	function CommandDispatcher:getCompletionSuggestions(parse, cursor)
+		local _condition = cursor
+		if _condition == nil then
+			_condition = parse:getReader():getTotalLength()
+		end
+		local cursorPosition = _condition
+		local context = parse:getContext()
+		local nodeBeforeCursor = context:findSuggestionContext(cursorPosition)
+		local parent = nodeBeforeCursor.parent
+		local start = math.min(nodeBeforeCursor.startPos, cursorPosition)
+		local fullInput = parse:getReader():getString()
+		local truncatedInput = substring(fullInput, 0, cursorPosition)
+		local truncatedInputLowerCase = toLowerCase(truncatedInput)
+		local futures = {}
+		for _, node in parent:getChildren() do
+			local future = Suggestions:empty()
+			TS.try(function()
+				future = node:listSuggestions(nodeBeforeCursor.context:build(truncatedInput), SuggestionsBuilder.new(truncatedInput, truncatedInputLowerCase, start))
+			end, function(err)
+				if not (TS.instanceof(err, CommandSyntaxException)) then
+					rethrow(err)
+				end
+			end)
+			local _future = future
+			table.insert(futures, _future)
+		end
+		-- Promise.all's typings lose the element type of an array that isn't a tuple.
+		return TS.Promise.all(futures):andThen(function(suggestions)
+			return Suggestions:merge(fullInput, suggestions)
+		end)
+	end
+	function CommandDispatcher:getRoot()
+		return self.root
+	end
+	function CommandDispatcher:getPath(target)
+		local nodes = {}
+		local addPaths
+		addPaths = function(node, parents)
+			local _array = {}
+			local _length = #_array
+			local _parentsLength = #parents
+			table.move(parents, 1, _parentsLength, _length + 1, _array)
+			_length += _parentsLength
+			_array[_length + 1] = node
+			local current = _array
+			table.insert(nodes, current)
+			for _, child in node:getChildren() do
+				addPaths(child, current)
+			end
+		end
+		addPaths(self.root, {})
+		for _, list in nodes do
+			if rawequal(list[#list], target) then
+				local result = {}
+				for _1, node in list do
+					if not rawequal(node, self.root) then
+						local _arg0 = node:getName()
+						table.insert(result, _arg0)
+					end
+				end
+				return result
+			end
+		end
+		return {}
+	end
+	function CommandDispatcher:findNode(path)
+		local node = self.root
+		for _, name in path do
+			node = node:getChild(name)
+			if node == nil then
+				return nil
+			end
+		end
+		return node
+	end
+	function CommandDispatcher:findAmbiguities(consumer)
+		self.root:findAmbiguities(consumer)
+	end
+	CommandDispatcher.ARGUMENT_SEPARATOR = ARGUMENT_SEPARATOR
+	CommandDispatcher.ARGUMENT_SEPARATOR_CHAR = ARGUMENT_SEPARATOR
+end
+return {
+	ParseResults = ParseResults,
+	CommandDispatcher = CommandDispatcher,
+}

package/out/command.d.ts

@@ -0,0 +1,13 @@
+import type { CommandContext } from "./context";
+import type { Suggestions, SuggestionsBuilder } from "./suggestion";
+import type { CommandNode } from "./tree";
+export type Command<S> = (context: CommandContext<S>) => number;
+export declare const Command: {
+    readonly SINGLE_SUCCESS: 1;
+};
+export type Predicate<S> = (source: S) => boolean;
+export type RedirectModifier<S> = (context: CommandContext<S>) => readonly S[];
+export type SingleRedirectModifier<S> = (context: CommandContext<S>) => S;
+export type ResultConsumer<S> = (context: CommandContext<S>, success: boolean, result: number) => void;
+export type AmbiguityConsumer<S> = (parent: CommandNode<S>, child: CommandNode<S>, sibling: CommandNode<S>, inputs: readonly string[]) => void;
+export type SuggestionProvider<S> = (context: CommandContext<S>, builder: SuggestionsBuilder) => Promise<Suggestions>;

package/out/command.luau

@@ -0,0 +1,8 @@
+-- Compiled with roblox-ts v3.0.0
+-- Brigadier's functional interfaces are plain functions. Each one may throw a CommandSyntaxException.
+local Command = {
+	SINGLE_SUCCESS = 1,
+}
+return {
+	Command = Command,
+}

package/out/context.d.ts

@@ -0,0 +1,121 @@
+import type { Command, RedirectModifier, ResultConsumer } from "./command";
+import type { CommandDispatcher } from "./command-dispatcher";
+import type { ImmutableStringReader } from "./string-reader";
+import type { CommandNode } from "./tree";
+export declare class StringRange {
+    private readonly start;
+    private readonly finish;
+    constructor(start: number, finish: number);
+    static at(pos: number): StringRange;
+    static between(start: number, finish: number): StringRange;
+    static encompassing(a: StringRange, b: StringRange): StringRange;
+    getStart(): number;
+    getEnd(): number;
+    get(reader: ImmutableStringReader | string): string;
+    isEmpty(): boolean;
+    getLength(): number;
+    equals(other: unknown): boolean;
+    toString(): string;
+}
+export declare class ParsedArgument<T> {
+    private readonly result;
+    private readonly range;
+    constructor(start: number, finish: number, result: T);
+    getRange(): StringRange;
+    getResult(): T;
+    equals(other: unknown): boolean;
+}
+export declare class ParsedCommandNode<S> {
+    private readonly node;
+    private readonly range;
+    constructor(node: CommandNode<S>, range: StringRange);
+    getNode(): CommandNode<S>;
+    getRange(): StringRange;
+    toString(): string;
+    equals(other: unknown): boolean;
+}
+export declare class SuggestionContext<S> {
+    readonly context: CommandContextBuilder<S>;
+    readonly parent: CommandNode<S>;
+    readonly startPos: number;
+    constructor(context: CommandContextBuilder<S>, parent: CommandNode<S>, startPos: number);
+}
+interface Checkable {
+    any: unknown;
+}
+export type ArgumentClass = keyof CheckableTypes | keyof Checkable | (new (...args: never[]) => object);
+export declare class CommandContext<S> {
+    private readonly source;
+    private readonly input;
+    private readonly args;
+    private readonly command;
+    private readonly rootNode;
+    private readonly nodes;
+    private readonly range;
+    private readonly child;
+    private readonly modifier;
+    private readonly forks;
+    constructor(source: S, input: string, args: ReadonlyMap<string, ParsedArgument<unknown>>, command: Command<S> | undefined, rootNode: CommandNode<S>, nodes: readonly ParsedCommandNode<S>[], range: StringRange, child: CommandContext<S> | undefined, modifier: RedirectModifier<S> | undefined, forks: boolean);
+    copyFor(source: S): CommandContext<S>;
+    getChild(): CommandContext<S> | undefined;
+    getLastChild(): CommandContext<S>;
+    getCommand(): Command<S> | undefined;
+    getSource(): S;
+    getArgument<V>(name: string, clazz: ArgumentClass): V;
+    equals(other: unknown): boolean;
+    getRedirectModifier(): RedirectModifier<S> | undefined;
+    getRange(): StringRange;
+    getInput(): string;
+    getRootNode(): CommandNode<S>;
+    getNodes(): readonly ParsedCommandNode<S>[];
+    hasNodes(): boolean;
+    isForked(): boolean;
+}
+export declare class CommandContextBuilder<S> {
+    private readonly dispatcher;
+    private source;
+    private readonly rootNode;
+    private readonly args;
+    private readonly nodes;
+    private command?;
+    private child?;
+    private range;
+    private modifier?;
+    private forks;
+    constructor(dispatcher: CommandDispatcher<S>, source: S, rootNode: CommandNode<S>, start: number);
+    withSource(source: S): this;
+    getSource(): S;
+    getRootNode(): CommandNode<S>;
+    withArgument(name: string, argument: ParsedArgument<unknown>): this;
+    getArguments(): ReadonlyMap<string, ParsedArgument<unknown>>;
+    withCommand(command: Command<S> | undefined): this;
+    withNode(node: CommandNode<S>, range: StringRange): this;
+    copy(): CommandContextBuilder<S>;
+    withChild(child: CommandContextBuilder<S>): this;
+    getChild(): CommandContextBuilder<S> | undefined;
+    getLastChild(): CommandContextBuilder<S>;
+    getCommand(): Command<S> | undefined;
+    getNodes(): readonly ParsedCommandNode<S>[];
+    build(input: string): CommandContext<S>;
+    getDispatcher(): CommandDispatcher<S>;
+    getRange(): StringRange;
+    findSuggestionContext(cursor: number): SuggestionContext<S>;
+}
+export declare class ContextChain<S> {
+    private readonly modifiers;
+    private readonly executable;
+    static readonly Stage: {
+        readonly MODIFY: "MODIFY";
+        readonly EXECUTE: "EXECUTE";
+    };
+    private nextStageCache?;
+    constructor(modifiers: readonly CommandContext<S>[], executable: CommandContext<S>);
+    static tryFlatten<S>(rootContext: CommandContext<S>): ContextChain<S> | undefined;
+    static runModifier<S>(modifier: CommandContext<S>, source: S, resultConsumer: ResultConsumer<S>, forkedMode: boolean): readonly S[];
+    static runExecutable<S>(executable: CommandContext<S>, source: S, resultConsumer: ResultConsumer<S>, forkedMode: boolean): number;
+    executeAll(source: S, resultConsumer: ResultConsumer<S>): number;
+    getStage(): (typeof ContextChain.Stage)[keyof typeof ContextChain.Stage];
+    getTopContext(): CommandContext<S>;
+    nextStage(): ContextChain<S> | undefined;
+}
+export {};