@trioforge/brigadier 0.0.0-stage → 0.1.1

package/out/context.luau

@@ -0,0 +1,576 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local catchSyntax = TS.import(script, script.Parent, "exceptions").catchSyntax
+local _java = TS.import(script, script.Parent, "java")
+local IllegalArgumentException = _java.IllegalArgumentException
+local IllegalStateException = _java.IllegalStateException
+local objectsEquals = _java.objectsEquals
+local substring = _java.substring
+local StringRange
+do
+	StringRange = setmetatable({}, {
+		__tostring = function()
+			return "StringRange"
+		end,
+	})
+	StringRange.__index = StringRange
+	function StringRange.new(...)
+		local self = setmetatable({}, StringRange)
+		return self:constructor(...) or self
+	end
+	function StringRange:constructor(start, finish)
+		self.start = start
+		self.finish = finish
+	end
+	function StringRange:at(pos)
+		return StringRange.new(pos, pos)
+	end
+	function StringRange:between(start, finish)
+		return StringRange.new(start, finish)
+	end
+	function StringRange:encompassing(a, b)
+		return StringRange.new(math.min(a:getStart(), b:getStart()), math.max(a:getEnd(), b:getEnd()))
+	end
+	function StringRange:getStart()
+		return self.start
+	end
+	function StringRange:getEnd()
+		return self.finish
+	end
+	function StringRange:get(reader)
+		local _reader = reader
+		return substring(if type(_reader) == "string" then reader else reader:getString(), self.start, self.finish)
+	end
+	function StringRange:isEmpty()
+		return self.start == self.finish
+	end
+	function StringRange:getLength()
+		return self.finish - self.start
+	end
+	function StringRange:equals(other)
+		if rawequal(self, other) then
+			return true
+		end
+		if not (TS.instanceof(other, StringRange)) then
+			return false
+		end
+		return self.start == other.start and self.finish == other.finish
+	end
+	function StringRange:toString()
+		return `StringRange\{start={self.start}, end={self.finish}\}`
+	end
+	function StringRange:__tostring()
+		return self:toString()
+	end
+end
+local ParsedArgument
+do
+	ParsedArgument = setmetatable({}, {
+		__tostring = function()
+			return "ParsedArgument"
+		end,
+	})
+	ParsedArgument.__index = ParsedArgument
+	function ParsedArgument.new(...)
+		local self = setmetatable({}, ParsedArgument)
+		return self:constructor(...) or self
+	end
+	function ParsedArgument:constructor(start, finish, result)
+		self.result = result
+		self.range = StringRange:between(start, finish)
+	end
+	function ParsedArgument:getRange()
+		return self.range
+	end
+	function ParsedArgument:getResult()
+		return self.result
+	end
+	function ParsedArgument:equals(other)
+		if rawequal(self, other) then
+			return true
+		end
+		if not (TS.instanceof(other, ParsedArgument)) then
+			return false
+		end
+		return objectsEquals(self.range, other.range) and objectsEquals(self.result, other.result)
+	end
+end
+local ParsedCommandNode
+do
+	ParsedCommandNode = setmetatable({}, {
+		__tostring = function()
+			return "ParsedCommandNode"
+		end,
+	})
+	ParsedCommandNode.__index = ParsedCommandNode
+	function ParsedCommandNode.new(...)
+		local self = setmetatable({}, ParsedCommandNode)
+		return self:constructor(...) or self
+	end
+	function ParsedCommandNode:constructor(node, range)
+		self.node = node
+		self.range = range
+	end
+	function ParsedCommandNode:getNode()
+		return self.node
+	end
+	function ParsedCommandNode:getRange()
+		return self.range
+	end
+	function ParsedCommandNode:toString()
+		return `{self.node}@{self.range}`
+	end
+	function ParsedCommandNode:equals(other)
+		if rawequal(self, other) then
+			return true
+		end
+		local _other = other
+		local _condition = not (type(_other) == "table")
+		if not _condition then
+			_condition = getmetatable(other) ~= getmetatable(self)
+		end
+		if _condition then
+			return false
+		end
+		local that = other
+		return objectsEquals(self.node, that.node) and objectsEquals(self.range, that.range)
+	end
+	function ParsedCommandNode:__tostring()
+		return self:toString()
+	end
+end
+local SuggestionContext
+do
+	SuggestionContext = setmetatable({}, {
+		__tostring = function()
+			return "SuggestionContext"
+		end,
+	})
+	SuggestionContext.__index = SuggestionContext
+	function SuggestionContext.new(...)
+		local self = setmetatable({}, SuggestionContext)
+		return self:constructor(...) or self
+	end
+	function SuggestionContext:constructor(context, parent, startPos)
+		self.context = context
+		self.parent = parent
+		self.startPos = startPos
+	end
+end
+-- What Class.isAssignableFrom checks against: a Luau type name such as "number" or "Vector3", "any" for Object,
+-- or a class.
+local function isAssignable(clazz, value)
+	if clazz == "any" then
+		return true
+	end
+	local _clazz = clazz
+	if type(_clazz) == "string" then
+		local _value = value
+		return typeof(_value) == clazz
+	end
+	local _clazz_1 = clazz
+	if type(_clazz_1) == "table" then
+		return TS.instanceof(value, clazz)
+	end
+	error(IllegalArgumentException.new(`Unknown argument class {tostring(clazz)}`))
+end
+local CommandContext
+do
+	CommandContext = setmetatable({}, {
+		__tostring = function()
+			return "CommandContext"
+		end,
+	})
+	CommandContext.__index = CommandContext
+	function CommandContext.new(...)
+		local self = setmetatable({}, CommandContext)
+		return self:constructor(...) or self
+	end
+	function CommandContext:constructor(source, input, args, command, rootNode, nodes, range, child, modifier, forks)
+		self.source = source
+		self.input = input
+		self.args = args
+		self.command = command
+		self.rootNode = rootNode
+		self.nodes = nodes
+		self.range = range
+		self.child = child
+		self.modifier = modifier
+		self.forks = forks
+	end
+	function CommandContext:copyFor(source)
+		if rawequal(self.source, source) then
+			return self
+		end
+		return CommandContext.new(source, self.input, self.args, self.command, self.rootNode, self.nodes, self.range, self.child, self.modifier, self.forks)
+	end
+	function CommandContext:getChild()
+		return self.child
+	end
+	function CommandContext:getLastChild()
+		local result = self.child
+		if result == nil then
+			return self
+		end
+		local child = result:getChild()
+		while child ~= nil do
+			result = child
+			child = result:getChild()
+		end
+		return result
+	end
+	function CommandContext:getCommand()
+		return self.command
+	end
+	function CommandContext:getSource()
+		return self.source
+	end
+	function CommandContext:getArgument(name, clazz)
+		local _args = self.args
+		local _name = name
+		local argument = _args[_name]
+		if argument == nil then
+			error(IllegalArgumentException.new(`No such argument '{name}' exists on this command`))
+		end
+		local result = argument:getResult()
+		if isAssignable(clazz, result) then
+			return result
+		end
+		error(IllegalArgumentException.new(`Argument '{name}' is defined as {typeof(result)}, not {tostring(clazz)}`))
+	end
+	function CommandContext:equals(other)
+		if rawequal(self, other) then
+			return true
+		end
+		if not (TS.instanceof(other, CommandContext)) then
+			return false
+		end
+		local that = other
+		if not objectsEquals(self.args, that.args) then
+			return false
+		end
+		if not self.rootNode:equals(that.rootNode) then
+			return false
+		end
+		if #self.nodes ~= #that.nodes or not objectsEquals(self.nodes, that.nodes) then
+			return false
+		end
+		if if self.command ~= nil then not objectsEquals(self.command, that.command) else that.command ~= nil then
+			return false
+		end
+		if not objectsEquals(self.source, that.source) then
+			return false
+		end
+		if if self.child ~= nil then not self.child:equals(that.child) else that.child ~= nil then
+			return false
+		end
+		return true
+	end
+	function CommandContext:getRedirectModifier()
+		return self.modifier
+	end
+	function CommandContext:getRange()
+		return self.range
+	end
+	function CommandContext:getInput()
+		return self.input
+	end
+	function CommandContext:getRootNode()
+		return self.rootNode
+	end
+	function CommandContext:getNodes()
+		return self.nodes
+	end
+	function CommandContext:hasNodes()
+		return #self.nodes > 0
+	end
+	function CommandContext:isForked()
+		return self.forks
+	end
+end
+local CommandContextBuilder
+do
+	CommandContextBuilder = setmetatable({}, {
+		__tostring = function()
+			return "CommandContextBuilder"
+		end,
+	})
+	CommandContextBuilder.__index = CommandContextBuilder
+	function CommandContextBuilder.new(...)
+		local self = setmetatable({}, CommandContextBuilder)
+		return self:constructor(...) or self
+	end
+	function CommandContextBuilder:constructor(dispatcher, source, rootNode, start)
+		self.dispatcher = dispatcher
+		self.source = source
+		self.rootNode = rootNode
+		self.args = {}
+		self.nodes = {}
+		self.forks = false
+		self.range = StringRange:at(start)
+	end
+	function CommandContextBuilder:withSource(source)
+		self.source = source
+		return self
+	end
+	function CommandContextBuilder:getSource()
+		return self.source
+	end
+	function CommandContextBuilder:getRootNode()
+		return self.rootNode
+	end
+	function CommandContextBuilder:withArgument(name, argument)
+		local _args = self.args
+		local _name = name
+		local _argument = argument
+		_args[_name] = _argument
+		return self
+	end
+	function CommandContextBuilder:getArguments()
+		return self.args
+	end
+	function CommandContextBuilder:withCommand(command)
+		self.command = command
+		return self
+	end
+	function CommandContextBuilder:withNode(node, range)
+		local _nodes = self.nodes
+		local _parsedCommandNode = ParsedCommandNode.new(node, range)
+		table.insert(_nodes, _parsedCommandNode)
+		self.range = StringRange:encompassing(self.range, range)
+		self.modifier = node:getRedirectModifier()
+		self.forks = node:isFork()
+		return self
+	end
+	function CommandContextBuilder:copy()
+		local copy = CommandContextBuilder.new(self.dispatcher, self.source, self.rootNode, self.range:getStart())
+		copy.command = self.command
+		for name, argument in self.args do
+			copy.args[name] = argument
+		end
+		for _, node in self.nodes do
+			local _exp = copy.nodes
+			table.insert(_exp, node)
+		end
+		copy.child = self.child
+		copy.range = self.range
+		copy.forks = self.forks
+		return copy
+	end
+	function CommandContextBuilder:withChild(child)
+		self.child = child
+		return self
+	end
+	function CommandContextBuilder:getChild()
+		return self.child
+	end
+	function CommandContextBuilder:getLastChild()
+		local result = self.child
+		if result == nil then
+			return self
+		end
+		local child = result:getChild()
+		while child ~= nil do
+			result = child
+			child = result:getChild()
+		end
+		return result
+	end
+	function CommandContextBuilder:getCommand()
+		return self.command
+	end
+	function CommandContextBuilder:getNodes()
+		return self.nodes
+	end
+	function CommandContextBuilder:build(input)
+		local _exp = self.source
+		local _exp_1 = input
+		local _exp_2 = self.args
+		local _exp_3 = self.command
+		local _exp_4 = self.rootNode
+		local _exp_5 = self.nodes
+		local _exp_6 = self.range
+		local _result = self.child
+		if _result ~= nil then
+			_result = _result:build(input)
+		end
+		return CommandContext.new(_exp, _exp_1, _exp_2, _exp_3, _exp_4, _exp_5, _exp_6, _result, self.modifier, self.forks)
+	end
+	function CommandContextBuilder:getDispatcher()
+		return self.dispatcher
+	end
+	function CommandContextBuilder:getRange()
+		return self.range
+	end
+	function CommandContextBuilder:findSuggestionContext(cursor)
+		if self.range:getStart() <= cursor then
+			if self.range:getEnd() < cursor then
+				if self.child ~= nil then
+					return self.child:findSuggestionContext(cursor)
+				elseif #self.nodes > 0 then
+					local last = self.nodes[#self.nodes]
+					return SuggestionContext.new(self, last:getNode(), last:getRange():getEnd() + 1)
+				end
+				return SuggestionContext.new(self, self.rootNode, self.range:getStart())
+			end
+			local prev = self.rootNode
+			for _, node in self.nodes do
+				local nodeRange = node:getRange()
+				if nodeRange:getStart() <= cursor and cursor <= nodeRange:getEnd() then
+					return SuggestionContext.new(self, prev, nodeRange:getStart())
+				end
+				prev = node:getNode()
+			end
+			return SuggestionContext.new(self, prev, self.range:getStart())
+		end
+		error(IllegalStateException.new("Can't find node before cursor"))
+	end
+end
+local ContextChain
+do
+	ContextChain = setmetatable({}, {
+		__tostring = function()
+			return "ContextChain"
+		end,
+	})
+	ContextChain.__index = ContextChain
+	function ContextChain.new(...)
+		local self = setmetatable({}, ContextChain)
+		return self:constructor(...) or self
+	end
+	function ContextChain:constructor(modifiers, executable)
+		self.modifiers = modifiers
+		self.executable = executable
+		if executable:getCommand() == nil then
+			error(IllegalArgumentException.new("Last command in chain must be executable"))
+		end
+	end
+	function ContextChain:tryFlatten(rootContext)
+		local modifiers = {}
+		local current = rootContext
+		while true do
+			local child = current:getChild()
+			if child == nil then
+				-- Last entry must be executable command
+				if current:getCommand() == nil then
+					return nil
+				end
+				return ContextChain.new(modifiers, current)
+			end
+			local _current = current
+			table.insert(modifiers, _current)
+			current = child
+		end
+	end
+	function ContextChain:runModifier(modifier, source, resultConsumer, forkedMode)
+		local sourceModifier = modifier:getRedirectModifier()
+		-- Note: source currently in context is irrelevant at this point, since we might have updated it in one of earlier stages
+		if sourceModifier == nil then
+			-- Simple redirect, just propagate source to next node
+			return { source }
+		end
+		local contextToUse = modifier:copyFor(source)
+		return catchSyntax(function()
+			return sourceModifier(contextToUse)
+		end, function(ex)
+			resultConsumer(contextToUse, false, 0)
+			if forkedMode then
+				return {}
+			end
+			error(ex)
+		end)
+	end
+	function ContextChain:runExecutable(executable, source, resultConsumer, forkedMode)
+		local contextToUse = executable:copyFor(source)
+		return catchSyntax(function()
+			local result = executable:getCommand()(contextToUse)
+			resultConsumer(contextToUse, true, result)
+			return if forkedMode then 1 else result
+		end, function(ex)
+			resultConsumer(contextToUse, false, 0)
+			if forkedMode then
+				return 0
+			end
+			error(ex)
+		end)
+	end
+	function ContextChain:executeAll(source, resultConsumer)
+		if #self.modifiers == 0 then
+			-- Fast path - just a single stage
+			return ContextChain:runExecutable(self.executable, source, resultConsumer, false)
+		end
+		local forkedMode = false
+		local currentSources = { source }
+		for _, modifier in self.modifiers do
+			local _condition = forkedMode
+			if not forkedMode then
+				_condition = modifier:isForked()
+			end
+			forkedMode = _condition
+			local nextSources = {}
+			for _1, sourceToRun in currentSources do
+				for _2, nextSource in ContextChain:runModifier(modifier, sourceToRun, resultConsumer, forkedMode) do
+					nextSources[#nextSources + 1] = nextSource
+				end
+			end
+			if #nextSources == 0 then
+				return 0
+			end
+			currentSources = nextSources
+		end
+		local result = 0
+		for _, executionSource in currentSources do
+			result += ContextChain:runExecutable(self.executable, executionSource, resultConsumer, forkedMode)
+		end
+		return result
+	end
+	function ContextChain:getStage()
+		return if #self.modifiers == 0 then ContextChain.Stage.EXECUTE else ContextChain.Stage.MODIFY
+	end
+	function ContextChain:getTopContext()
+		if #self.modifiers == 0 then
+			return self.executable
+		end
+		return self.modifiers[1]
+	end
+	function ContextChain:nextStage()
+		local modifierCount = #self.modifiers
+		if modifierCount == 0 then
+			return nil
+		end
+		if self.nextStageCache == nil then
+			local rest = {}
+			do
+				local index = 1
+				local _shouldIncrement = false
+				while true do
+					if _shouldIncrement then
+						index += 1
+					else
+						_shouldIncrement = true
+					end
+					if not (index < modifierCount) then
+						break
+					end
+					local _arg0 = self.modifiers[index + 1]
+					table.insert(rest, _arg0)
+				end
+			end
+			self.nextStageCache = ContextChain.new(rest, self.executable)
+		end
+		return self.nextStageCache
+	end
+	ContextChain.Stage = {
+		MODIFY = "MODIFY",
+		EXECUTE = "EXECUTE",
+	}
+end
+return {
+	StringRange = StringRange,
+	ParsedArgument = ParsedArgument,
+	ParsedCommandNode = ParsedCommandNode,
+	SuggestionContext = SuggestionContext,
+	CommandContext = CommandContext,
+	CommandContextBuilder = CommandContextBuilder,
+	ContextChain = ContextChain,
+}

package/out/exceptions.d.ts

@@ -0,0 +1,118 @@
+import { type Message } from "./literal-message";
+import type { ImmutableStringReader } from "./string-reader";
+export type CommandExceptionType = object;
+export declare class CommandSyntaxException {
+    private readonly exceptionType;
+    private readonly message;
+    private readonly input?;
+    static readonly CONTEXT_AMOUNT = 10;
+    static ENABLE_COMMAND_STACK_TRACES: boolean;
+    static BUILT_IN_EXCEPTIONS: BuiltInExceptionProvider;
+    private readonly cursor;
+    private readonly stackTrace?;
+    constructor(exceptionType: CommandExceptionType, message: Message, input?: string | undefined, cursor?: number);
+    getMessage(): string;
+    getRawMessage(): Message;
+    getContext(): string | undefined;
+    getType(): CommandExceptionType;
+    getInput(): string | undefined;
+    getCursor(): number;
+    getStackTrace(): string | undefined;
+    toString(): string;
+}
+export declare function catchSyntax<T>(body: () => T, onSyntaxException: (exception: CommandSyntaxException) => T): T;
+export declare class SimpleCommandExceptionType implements CommandExceptionType {
+    private readonly message;
+    constructor(message: Message);
+    create(): CommandSyntaxException;
+    createWithContext(reader: ImmutableStringReader): CommandSyntaxException;
+    toString(): string;
+}
+export declare class DynamicCommandExceptionType implements CommandExceptionType {
+    private readonly fn;
+    constructor(fn: (arg: unknown) => Message);
+    create(arg: unknown): CommandSyntaxException;
+    createWithContext(reader: ImmutableStringReader, arg: unknown): CommandSyntaxException;
+}
+export declare class Dynamic2CommandExceptionType implements CommandExceptionType {
+    private readonly fn;
+    constructor(fn: (a: unknown, b: unknown) => Message);
+    create(a: unknown, b: unknown): CommandSyntaxException;
+    createWithContext(reader: ImmutableStringReader, a: unknown, b: unknown): CommandSyntaxException;
+}
+export declare class Dynamic3CommandExceptionType implements CommandExceptionType {
+    private readonly fn;
+    constructor(fn: (a: unknown, b: unknown, c: unknown) => Message);
+    create(a: unknown, b: unknown, c: unknown): CommandSyntaxException;
+    createWithContext(reader: ImmutableStringReader, a: unknown, b: unknown, c: unknown): CommandSyntaxException;
+}
+export declare class Dynamic4CommandExceptionType implements CommandExceptionType {
+    private readonly fn;
+    constructor(fn: (a: unknown, b: unknown, c: unknown, d: unknown) => Message);
+    create(a: unknown, b: unknown, c: unknown, d: unknown): CommandSyntaxException;
+    createWithContext(reader: ImmutableStringReader, a: unknown, b: unknown, c: unknown, d: unknown): CommandSyntaxException;
+}
+export declare class DynamicNCommandExceptionType implements CommandExceptionType {
+    private readonly fn;
+    constructor(fn: (args: unknown[]) => Message);
+    create(_a: unknown, ...args: unknown[]): CommandSyntaxException;
+    createWithContext(reader: ImmutableStringReader, ...args: unknown[]): CommandSyntaxException;
+}
+export interface BuiltInExceptionProvider {
+    doubleTooLow(): Dynamic2CommandExceptionType;
+    doubleTooHigh(): Dynamic2CommandExceptionType;
+    floatTooLow(): Dynamic2CommandExceptionType;
+    floatTooHigh(): Dynamic2CommandExceptionType;
+    integerTooLow(): Dynamic2CommandExceptionType;
+    integerTooHigh(): Dynamic2CommandExceptionType;
+    longTooLow(): Dynamic2CommandExceptionType;
+    longTooHigh(): Dynamic2CommandExceptionType;
+    literalIncorrect(): DynamicCommandExceptionType;
+    readerExpectedStartOfQuote(): SimpleCommandExceptionType;
+    readerExpectedEndOfQuote(): SimpleCommandExceptionType;
+    readerInvalidEscape(): DynamicCommandExceptionType;
+    readerInvalidBool(): DynamicCommandExceptionType;
+    readerInvalidInt(): DynamicCommandExceptionType;
+    readerExpectedInt(): SimpleCommandExceptionType;
+    readerInvalidLong(): DynamicCommandExceptionType;
+    readerExpectedLong(): SimpleCommandExceptionType;
+    readerInvalidDouble(): DynamicCommandExceptionType;
+    readerExpectedDouble(): SimpleCommandExceptionType;
+    readerInvalidFloat(): DynamicCommandExceptionType;
+    readerExpectedFloat(): SimpleCommandExceptionType;
+    readerExpectedBool(): SimpleCommandExceptionType;
+    readerExpectedSymbol(): DynamicCommandExceptionType;
+    dispatcherUnknownCommand(): SimpleCommandExceptionType;
+    dispatcherUnknownArgument(): SimpleCommandExceptionType;
+    dispatcherExpectedArgumentSeparator(): SimpleCommandExceptionType;
+    dispatcherParseException(): DynamicCommandExceptionType;
+}
+export declare class BuiltInExceptions implements BuiltInExceptionProvider {
+    doubleTooLow(): Dynamic2CommandExceptionType;
+    doubleTooHigh(): Dynamic2CommandExceptionType;
+    floatTooLow(): Dynamic2CommandExceptionType;
+    floatTooHigh(): Dynamic2CommandExceptionType;
+    integerTooLow(): Dynamic2CommandExceptionType;
+    integerTooHigh(): Dynamic2CommandExceptionType;
+    longTooLow(): Dynamic2CommandExceptionType;
+    longTooHigh(): Dynamic2CommandExceptionType;
+    literalIncorrect(): DynamicCommandExceptionType;
+    readerExpectedStartOfQuote(): SimpleCommandExceptionType;
+    readerExpectedEndOfQuote(): SimpleCommandExceptionType;
+    readerInvalidEscape(): DynamicCommandExceptionType;
+    readerInvalidBool(): DynamicCommandExceptionType;
+    readerInvalidInt(): DynamicCommandExceptionType;
+    readerExpectedInt(): SimpleCommandExceptionType;
+    readerInvalidLong(): DynamicCommandExceptionType;
+    readerExpectedLong(): SimpleCommandExceptionType;
+    readerInvalidDouble(): DynamicCommandExceptionType;
+    readerExpectedDouble(): SimpleCommandExceptionType;
+    readerInvalidFloat(): DynamicCommandExceptionType;
+    readerExpectedFloat(): SimpleCommandExceptionType;
+    readerExpectedBool(): SimpleCommandExceptionType;
+    readerExpectedSymbol(): DynamicCommandExceptionType;
+    dispatcherUnknownCommand(): SimpleCommandExceptionType;
+    dispatcherUnknownArgument(): SimpleCommandExceptionType;
+    dispatcherExpectedArgumentSeparator(): SimpleCommandExceptionType;
+    dispatcherParseException(): DynamicCommandExceptionType;
+}