@trioforge/brigadier 0.0.0-stage → 0.1.1

package/out/tree.d.ts

@@ -0,0 +1,126 @@
+import type { ArgumentType } from "./arguments";
+import type { AmbiguityConsumer, Command, Predicate, RedirectModifier, SingleRedirectModifier, SuggestionProvider } from "./command";
+import { type CommandContext, type CommandContextBuilder } from "./context";
+import { StringReader } from "./string-reader";
+import { Suggestions, type SuggestionsBuilder } from "./suggestion";
+export declare abstract class CommandNode<S> {
+    private command;
+    private readonly requirement;
+    private readonly redirect;
+    private readonly modifier;
+    private readonly forks;
+    private readonly children;
+    private readonly childList;
+    private readonly literals;
+    private readonly argumentList;
+    protected constructor(command: Command<S> | undefined, requirement: Predicate<S>, redirect: CommandNode<S> | undefined, modifier: RedirectModifier<S> | undefined, forks: boolean);
+    getCommand(): Command<S> | undefined;
+    getChildren(): readonly CommandNode<S>[];
+    getChild(name: string): CommandNode<S> | undefined;
+    getRedirect(): CommandNode<S> | undefined;
+    getRedirectModifier(): RedirectModifier<S> | undefined;
+    canUse(source: S): boolean;
+    addChild(node: CommandNode<S>): void;
+    findAmbiguities(consumer: AmbiguityConsumer<S>): void;
+    abstract isValidInput(input: string): boolean;
+    equals(other: unknown): boolean;
+    getRequirement(): Predicate<S>;
+    abstract getName(): string;
+    abstract getUsageText(): string;
+    abstract parse(reader: StringReader, contextBuilder: CommandContextBuilder<S>): void;
+    abstract listSuggestions(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions>;
+    abstract createBuilder(): ArgumentBuilder<S>;
+    abstract getSortedKey(): string;
+    getRelevantNodes(input: StringReader): readonly CommandNode<S>[];
+    compareTo(other: CommandNode<S>): number;
+    isFork(): boolean;
+    abstract getExamples(): readonly string[];
+}
+export declare class RootCommandNode<S> extends CommandNode<S> {
+    constructor();
+    getName(): string;
+    getUsageText(): string;
+    parse(): void;
+    listSuggestions(): Promise<Suggestions>;
+    isValidInput(): boolean;
+    equals(other: unknown): boolean;
+    createBuilder(): ArgumentBuilder<S>;
+    getSortedKey(): string;
+    getExamples(): readonly string[];
+    toString(): string;
+}
+export declare class LiteralCommandNode<S> extends CommandNode<S> {
+    private readonly literal;
+    private readonly literalLowerCase;
+    constructor(literal: string, command: Command<S> | undefined, requirement: Predicate<S>, redirect: CommandNode<S> | undefined, modifier: RedirectModifier<S> | undefined, forks: boolean);
+    getLiteral(): string;
+    getName(): string;
+    private parseLiteral;
+    parse(reader: StringReader, contextBuilder: CommandContextBuilder<S>): void;
+    listSuggestions(_context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions>;
+    isValidInput(input: string): boolean;
+    equals(other: unknown): boolean;
+    getUsageText(): string;
+    createBuilder(): LiteralArgumentBuilder<S>;
+    getSortedKey(): string;
+    getExamples(): readonly string[];
+    toString(): string;
+}
+export declare class ArgumentCommandNode<S, T> extends CommandNode<S> {
+    private readonly name;
+    private readonly argumentType;
+    private readonly customSuggestions;
+    constructor(name: string, argumentType: ArgumentType<T>, command: Command<S> | undefined, requirement: Predicate<S>, redirect: CommandNode<S> | undefined, modifier: RedirectModifier<S> | undefined, forks: boolean, customSuggestions: SuggestionProvider<S> | undefined);
+    getType(): ArgumentType<T>;
+    getName(): string;
+    getUsageText(): string;
+    getCustomSuggestions(): SuggestionProvider<S> | undefined;
+    parse(reader: StringReader, contextBuilder: CommandContextBuilder<S>): void;
+    listSuggestions(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions>;
+    createBuilder(): RequiredArgumentBuilder<S, T>;
+    isValidInput(input: string): boolean;
+    equals(other: unknown): boolean;
+    getSortedKey(): string;
+    getExamples(): readonly string[];
+    toString(): string;
+}
+export declare abstract class ArgumentBuilder<S> {
+    private readonly args;
+    private command?;
+    private requirement;
+    private target?;
+    private modifier?;
+    private forks;
+    then(argument: ArgumentBuilder<S> | CommandNode<S>): this;
+    getArguments(): readonly CommandNode<S>[];
+    executes(command: Command<S> | undefined): this;
+    getCommand(): Command<S> | undefined;
+    requires(requirement: Predicate<S>): this;
+    getRequirement(): Predicate<S>;
+    redirect(target: CommandNode<S> | undefined, modifier?: SingleRedirectModifier<S>): this;
+    fork(target: CommandNode<S> | undefined, modifier: RedirectModifier<S> | undefined): this;
+    forward(target: CommandNode<S> | undefined, modifier: RedirectModifier<S> | undefined, fork: boolean): this;
+    getRedirect(): CommandNode<S> | undefined;
+    getRedirectModifier(): RedirectModifier<S> | undefined;
+    isFork(): boolean;
+    abstract build(): CommandNode<S>;
+}
+export declare class LiteralArgumentBuilder<S> extends ArgumentBuilder<S> {
+    private readonly literal;
+    constructor(literal: string);
+    getLiteral(): string;
+    build(): LiteralCommandNode<S>;
+}
+export declare function literal<S>(name: string): LiteralArgumentBuilder<S>;
+export declare class RequiredArgumentBuilder<S, T> extends ArgumentBuilder<S> {
+    private readonly name;
+    private readonly argumentType;
+    private suggestionsProvider?;
+    constructor(name: string, argumentType: ArgumentType<T>);
+    suggests(provider: SuggestionProvider<S> | undefined): this;
+    getSuggestionsProvider(): SuggestionProvider<S> | undefined;
+    getType(): ArgumentType<T>;
+    getName(): string;
+    build(): ArgumentCommandNode<S, T>;
+}
+export declare function argument<S, T>(name: string, argumentType: ArgumentType<T>): RequiredArgumentBuilder<S, T>;

package/out/tree.luau

@@ -0,0 +1,579 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _context = TS.import(script, script.Parent, "context")
+local ParsedArgument = _context.ParsedArgument
+local StringRange = _context.StringRange
+local _exceptions = TS.import(script, script.Parent, "exceptions")
+local CommandSyntaxException = _exceptions.CommandSyntaxException
+local catchSyntax = _exceptions.catchSyntax
+local _java = TS.import(script, script.Parent, "java")
+local IllegalStateException = _java.IllegalStateException
+local UnsupportedOperationException = _java.UnsupportedOperationException
+local compareStrings = _java.compareStrings
+local objectsEquals = _java.objectsEquals
+local startsWith = _java.startsWith
+local substring = _java.substring
+local toLowerCase = _java.toLowerCase
+local StringReader = TS.import(script, script.Parent, "string-reader").StringReader
+local Suggestions = TS.import(script, script.Parent, "suggestion").Suggestions
+-- Nodes create builders and builders create nodes, so both live in this module.
+local function always()
+	return true
+end
+local RootCommandNode, LiteralCommandNode, ArgumentCommandNode
+local CommandNode
+do
+	CommandNode = {}
+	function CommandNode:constructor(command, requirement, redirect, modifier, forks)
+		self.command = command
+		self.requirement = requirement
+		self.redirect = redirect
+		self.modifier = modifier
+		self.forks = forks
+		self.children = {}
+		self.childList = {}
+		self.literals = {}
+		self.argumentList = {}
+	end
+	function CommandNode:getCommand()
+		return self.command
+	end
+	function CommandNode:getChildren()
+		return self.childList
+	end
+	function CommandNode:getChild(name)
+		local _children = self.children
+		local _name = name
+		return _children[_name]
+	end
+	function CommandNode:getRedirect()
+		return self.redirect
+	end
+	function CommandNode:getRedirectModifier()
+		return self.modifier
+	end
+	function CommandNode:canUse(source)
+		return self.requirement(source)
+	end
+	function CommandNode:addChild(node)
+		if TS.instanceof(node, RootCommandNode) then
+			error(UnsupportedOperationException.new("Cannot add a RootCommandNode as a child to any other CommandNode"))
+		end
+		local _children = self.children
+		local _arg0 = node:getName()
+		local child = _children[_arg0]
+		if child ~= nil then
+			-- We've found something to merge onto
+			local command = node:getCommand()
+			if command ~= nil then
+				child.command = command
+			end
+			for _, grandchild in node:getChildren() do
+				child:addChild(grandchild)
+			end
+		else
+			local _children_1 = self.children
+			local _arg0_1 = node:getName()
+			local _node = node
+			_children_1[_arg0_1] = _node
+			local _childList = self.childList
+			local _node_1 = node
+			table.insert(_childList, _node_1)
+			if TS.instanceof(node, LiteralCommandNode) then
+				local _literals = self.literals
+				local _arg0_2 = node:getName()
+				local _node_2 = node
+				_literals[_arg0_2] = _node_2
+			elseif TS.instanceof(node, ArgumentCommandNode) then
+				local _argumentList = self.argumentList
+				local _node_2 = node
+				table.insert(_argumentList, _node_2)
+			end
+		end
+	end
+	function CommandNode:findAmbiguities(consumer)
+		local matches = {}
+		for _, child in self.childList do
+			for _1, sibling in self.childList do
+				if rawequal(child, sibling) then
+					continue
+				end
+				for _2, input in child:getExamples() do
+					if sibling:isValidInput(input) and not (table.find(matches, input) ~= nil) then
+						table.insert(matches, input)
+					end
+				end
+				if #matches > 0 then
+					consumer(self, child, sibling, matches)
+					matches = {}
+				end
+			end
+			child:findAmbiguities(consumer)
+		end
+	end
+	function CommandNode:equals(other)
+		if rawequal(self, other) then
+			return true
+		end
+		if not (TS.instanceof(other, CommandNode)) then
+			return false
+		end
+		local that = other
+		for name, node in self.children do
+			local match = that.children[name]
+			if match == nil or not node:equals(match) then
+				return false
+			end
+		end
+		for name in that.children do
+			if not (self.children[name] ~= nil) then
+				return false
+			end
+		end
+		if if self.command ~= nil then not objectsEquals(self.command, that.command) else that.command ~= nil then
+			return false
+		end
+		return true
+	end
+	function CommandNode:getRequirement()
+		return self.requirement
+	end
+	function CommandNode:getRelevantNodes(input)
+		if not (next(self.literals) == nil) then
+			local cursor = input:getCursor()
+			while input:canRead() and input:peek() ~= " " do
+				input:skip()
+			end
+			local text = substring(input:getString(), cursor, input:getCursor())
+			input:setCursor(cursor)
+			local literal = self.literals[text]
+			if literal ~= nil then
+				return { literal }
+			end
+		end
+		return self.argumentList
+	end
+	function CommandNode:compareTo(other)
+		if TS.instanceof(self, LiteralCommandNode) == TS.instanceof(other, LiteralCommandNode) then
+			return compareStrings(self:getSortedKey(), other:getSortedKey())
+		end
+		return if TS.instanceof(other, LiteralCommandNode) then 1 else -1
+	end
+	function CommandNode:isFork()
+		return self.forks
+	end
+end
+local function sourceOfContext(context)
+	return { context:getSource() }
+end
+do
+	local super = CommandNode
+	RootCommandNode = setmetatable({}, {
+		__tostring = function()
+			return "RootCommandNode"
+		end,
+		__index = super,
+	})
+	RootCommandNode.__index = RootCommandNode
+	function RootCommandNode.new(...)
+		local self = setmetatable({}, RootCommandNode)
+		return self:constructor(...) or self
+	end
+	function RootCommandNode:constructor()
+		super.constructor(self, nil, always, nil, sourceOfContext, false)
+	end
+	function RootCommandNode:getName()
+		return ""
+	end
+	function RootCommandNode:getUsageText()
+		return ""
+	end
+	function RootCommandNode:parse()
+	end
+	function RootCommandNode:listSuggestions()
+		return Suggestions:empty()
+	end
+	function RootCommandNode:isValidInput()
+		return false
+	end
+	function RootCommandNode:equals(other)
+		if rawequal(self, other) then
+			return true
+		end
+		if not (TS.instanceof(other, RootCommandNode)) then
+			return false
+		end
+		return super.equals(self, other)
+	end
+	function RootCommandNode:createBuilder()
+		error(IllegalStateException.new("Cannot convert root into a builder"))
+	end
+	function RootCommandNode:getSortedKey()
+		return ""
+	end
+	function RootCommandNode:getExamples()
+		return {}
+	end
+	function RootCommandNode:toString()
+		return "<root>"
+	end
+	function RootCommandNode:__tostring()
+		return self:toString()
+	end
+end
+local literal
+do
+	local super = CommandNode
+	LiteralCommandNode = setmetatable({}, {
+		__tostring = function()
+			return "LiteralCommandNode"
+		end,
+		__index = super,
+	})
+	LiteralCommandNode.__index = LiteralCommandNode
+	function LiteralCommandNode.new(...)
+		local self = setmetatable({}, LiteralCommandNode)
+		return self:constructor(...) or self
+	end
+	function LiteralCommandNode:constructor(literal, command, requirement, redirect, modifier, forks)
+		super.constructor(self, command, requirement, redirect, modifier, forks)
+		self.literal = literal
+		self.literalLowerCase = toLowerCase(literal)
+	end
+	function LiteralCommandNode:getLiteral()
+		return self.literal
+	end
+	function LiteralCommandNode:getName()
+		return self.literal
+	end
+	function LiteralCommandNode:parseLiteral(reader)
+		local start = reader:getCursor()
+		if reader:canRead(#self.literal) then
+			local finish = start + #self.literal
+			if substring(reader:getString(), start, finish) == self.literal then
+				reader:setCursor(finish)
+				if not reader:canRead() or reader:peek() == " " then
+					return finish
+				end
+				reader:setCursor(start)
+			end
+		end
+		return -1
+	end
+	function LiteralCommandNode:parse(reader, contextBuilder)
+		local start = reader:getCursor()
+		local finish = self:parseLiteral(reader)
+		if finish > -1 then
+			contextBuilder:withNode(self, StringRange:between(start, finish))
+			return nil
+		end
+		error(CommandSyntaxException.BUILT_IN_EXCEPTIONS:literalIncorrect():createWithContext(reader, self.literal))
+	end
+	function LiteralCommandNode:listSuggestions(_context, builder)
+		if startsWith(self.literalLowerCase, builder:getRemainingLowerCase()) then
+			return builder:suggest(self.literal):buildFuture()
+		end
+		return Suggestions:empty()
+	end
+	function LiteralCommandNode:isValidInput(input)
+		return self:parseLiteral(StringReader.new(input)) > -1
+	end
+	function LiteralCommandNode:equals(other)
+		if rawequal(self, other) then
+			return true
+		end
+		if not (TS.instanceof(other, LiteralCommandNode)) then
+			return false
+		end
+		if self.literal ~= other.literal then
+			return false
+		end
+		return super.equals(self, other)
+	end
+	function LiteralCommandNode:getUsageText()
+		return self.literal
+	end
+	function LiteralCommandNode:createBuilder()
+		local builder = literal(self.literal)
+		builder:requires(self:getRequirement())
+		builder:forward(self:getRedirect(), self:getRedirectModifier(), self:isFork())
+		local command = self:getCommand()
+		if command ~= nil then
+			builder:executes(command)
+		end
+		return builder
+	end
+	function LiteralCommandNode:getSortedKey()
+		return self.literal
+	end
+	function LiteralCommandNode:getExamples()
+		return { self.literal }
+	end
+	function LiteralCommandNode:toString()
+		return `<literal {self.literal}>`
+	end
+	function LiteralCommandNode:__tostring()
+		return self:toString()
+	end
+end
+local USAGE_ARGUMENT_OPEN = "<"
+local USAGE_ARGUMENT_CLOSE = ">"
+local argument
+do
+	local super = CommandNode
+	ArgumentCommandNode = setmetatable({}, {
+		__tostring = function()
+			return "ArgumentCommandNode"
+		end,
+		__index = super,
+	})
+	ArgumentCommandNode.__index = ArgumentCommandNode
+	function ArgumentCommandNode.new(...)
+		local self = setmetatable({}, ArgumentCommandNode)
+		return self:constructor(...) or self
+	end
+	function ArgumentCommandNode:constructor(name, argumentType, command, requirement, redirect, modifier, forks, customSuggestions)
+		super.constructor(self, command, requirement, redirect, modifier, forks)
+		self.name = name
+		self.argumentType = argumentType
+		self.customSuggestions = customSuggestions
+	end
+	function ArgumentCommandNode:getType()
+		return self.argumentType
+	end
+	function ArgumentCommandNode:getName()
+		return self.name
+	end
+	function ArgumentCommandNode:getUsageText()
+		return USAGE_ARGUMENT_OPEN .. self.name .. USAGE_ARGUMENT_CLOSE
+	end
+	function ArgumentCommandNode:getCustomSuggestions()
+		return self.customSuggestions
+	end
+	function ArgumentCommandNode:parse(reader, contextBuilder)
+		local start = reader:getCursor()
+		local result = self.argumentType:parse(reader, contextBuilder:getSource())
+		local parsed = ParsedArgument.new(start, reader:getCursor(), result)
+		contextBuilder:withArgument(self.name, parsed)
+		contextBuilder:withNode(self, parsed:getRange())
+	end
+	function ArgumentCommandNode:listSuggestions(context, builder)
+		if self.customSuggestions == nil then
+			local _self = self.argumentType
+			local _result = _self.listSuggestions
+			if _result ~= nil then
+				_result = _result(_self, context, builder)
+			end
+			local _condition = _result
+			if _condition == nil then
+				_condition = Suggestions:empty()
+			end
+			return _condition
+		end
+		return self.customSuggestions(context, builder)
+	end
+	function ArgumentCommandNode:createBuilder()
+		local builder = argument(self.name, self.argumentType)
+		builder:requires(self:getRequirement())
+		builder:forward(self:getRedirect(), self:getRedirectModifier(), self:isFork())
+		builder:suggests(self.customSuggestions)
+		local command = self:getCommand()
+		if command ~= nil then
+			builder:executes(command)
+		end
+		return builder
+	end
+	function ArgumentCommandNode:isValidInput(input)
+		return catchSyntax(function()
+			local reader = StringReader.new(input)
+			self.argumentType:parse(reader)
+			return not reader:canRead() or reader:peek() == " "
+		end, function()
+			return false
+		end)
+	end
+	function ArgumentCommandNode:equals(other)
+		if rawequal(self, other) then
+			return true
+		end
+		if not (TS.instanceof(other, ArgumentCommandNode)) then
+			return false
+		end
+		if self.name ~= other.name then
+			return false
+		end
+		if not objectsEquals(self.argumentType, other.argumentType) then
+			return false
+		end
+		return super.equals(self, other)
+	end
+	function ArgumentCommandNode:getSortedKey()
+		return self.name
+	end
+	function ArgumentCommandNode:getExamples()
+		local _self = self.argumentType
+		local _result = _self.getExamples
+		if _result ~= nil then
+			_result = _result(_self)
+		end
+		local _condition = _result
+		if _condition == nil then
+			_condition = {}
+		end
+		return _condition
+	end
+	function ArgumentCommandNode:toString()
+		return `<argument {self.name}:{self.argumentType}>`
+	end
+	function ArgumentCommandNode:__tostring()
+		return self:toString()
+	end
+end
+local ArgumentBuilder
+do
+	ArgumentBuilder = {}
+	function ArgumentBuilder:constructor()
+		self.args = RootCommandNode.new()
+		self.requirement = always
+		self.forks = false
+	end
+	ArgumentBuilder["then"] = function(self, argument)
+		if self.target ~= nil then
+			error(IllegalStateException.new("Cannot add children to a redirected node"))
+		end
+		self.args:addChild(if TS.instanceof(argument, CommandNode) then argument else argument:build())
+		return self
+	end
+	function ArgumentBuilder:getArguments()
+		return self.args:getChildren()
+	end
+	function ArgumentBuilder:executes(command)
+		self.command = command
+		return self
+	end
+	function ArgumentBuilder:getCommand()
+		return self.command
+	end
+	function ArgumentBuilder:requires(requirement)
+		self.requirement = requirement
+		return self
+	end
+	function ArgumentBuilder:getRequirement()
+		return self.requirement
+	end
+	function ArgumentBuilder:redirect(target, modifier)
+		if modifier == nil then
+			return self:forward(target, nil, false)
+		end
+		return self:forward(target, function(context)
+			return { modifier(context) }
+		end, false)
+	end
+	function ArgumentBuilder:fork(target, modifier)
+		return self:forward(target, modifier, true)
+	end
+	function ArgumentBuilder:forward(target, modifier, fork)
+		if #self.args:getChildren() > 0 then
+			error(IllegalStateException.new("Cannot forward a node with children"))
+		end
+		self.target = target
+		self.modifier = modifier
+		self.forks = fork
+		return self
+	end
+	function ArgumentBuilder:getRedirect()
+		return self.target
+	end
+	function ArgumentBuilder:getRedirectModifier()
+		return self.modifier
+	end
+	function ArgumentBuilder:isFork()
+		return self.forks
+	end
+end
+local LiteralArgumentBuilder
+do
+	local super = ArgumentBuilder
+	LiteralArgumentBuilder = setmetatable({}, {
+		__tostring = function()
+			return "LiteralArgumentBuilder"
+		end,
+		__index = super,
+	})
+	LiteralArgumentBuilder.__index = LiteralArgumentBuilder
+	function LiteralArgumentBuilder.new(...)
+		local self = setmetatable({}, LiteralArgumentBuilder)
+		return self:constructor(...) or self
+	end
+	function LiteralArgumentBuilder:constructor(literal)
+		super.constructor(self)
+		self.literal = literal
+	end
+	function LiteralArgumentBuilder:getLiteral()
+		return self.literal
+	end
+	function LiteralArgumentBuilder:build()
+		local result = LiteralCommandNode.new(self.literal, self:getCommand(), self:getRequirement(), self:getRedirect(), self:getRedirectModifier(), self:isFork())
+		for _, child in self:getArguments() do
+			result:addChild(child)
+		end
+		return result
+	end
+end
+function literal(name)
+	return LiteralArgumentBuilder.new(name)
+end
+local RequiredArgumentBuilder
+do
+	local super = ArgumentBuilder
+	RequiredArgumentBuilder = setmetatable({}, {
+		__tostring = function()
+			return "RequiredArgumentBuilder"
+		end,
+		__index = super,
+	})
+	RequiredArgumentBuilder.__index = RequiredArgumentBuilder
+	function RequiredArgumentBuilder.new(...)
+		local self = setmetatable({}, RequiredArgumentBuilder)
+		return self:constructor(...) or self
+	end
+	function RequiredArgumentBuilder:constructor(name, argumentType)
+		super.constructor(self)
+		self.name = name
+		self.argumentType = argumentType
+	end
+	function RequiredArgumentBuilder:suggests(provider)
+		self.suggestionsProvider = provider
+		return self
+	end
+	function RequiredArgumentBuilder:getSuggestionsProvider()
+		return self.suggestionsProvider
+	end
+	function RequiredArgumentBuilder:getType()
+		return self.argumentType
+	end
+	function RequiredArgumentBuilder:getName()
+		return self.name
+	end
+	function RequiredArgumentBuilder:build()
+		local result = ArgumentCommandNode.new(self.name, self.argumentType, self:getCommand(), self:getRequirement(), self:getRedirect(), self:getRedirectModifier(), self:isFork(), self:getSuggestionsProvider())
+		for _, child in self:getArguments() do
+			result:addChild(child)
+		end
+		return result
+	end
+end
+function argument(name, argumentType)
+	return RequiredArgumentBuilder.new(name, argumentType)
+end
+return {
+	literal = literal,
+	argument = argument,
+	CommandNode = CommandNode,
+	RootCommandNode = RootCommandNode,
+	LiteralCommandNode = LiteralCommandNode,
+	ArgumentCommandNode = ArgumentCommandNode,
+	ArgumentBuilder = ArgumentBuilder,
+	LiteralArgumentBuilder = LiteralArgumentBuilder,
+	RequiredArgumentBuilder = RequiredArgumentBuilder,
+}