@trioforge/brigadier 0.0.0-stage → 0.1.0

package/out/exceptions.luau

@@ -0,0 +1,415 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _java = TS.import(script, script.Parent, "java")
+local formatDouble = _java.formatDouble
+local formatFloat = _java.formatFloat
+local formatInteger = _java.formatInteger
+local rethrow = _java.rethrow
+local str = _java.str
+local substring = _java.substring
+local LiteralMessage = TS.import(script, script.Parent, "literal-message").LiteralMessage
+-- A marker, as in Java: any value that names a kind of syntax error.
+local CommandSyntaxException
+do
+	CommandSyntaxException = setmetatable({}, {
+		__tostring = function()
+			return "CommandSyntaxException"
+		end,
+	})
+	CommandSyntaxException.__index = CommandSyntaxException
+	function CommandSyntaxException.new(...)
+		local self = setmetatable({}, CommandSyntaxException)
+		return self:constructor(...) or self
+	end
+	function CommandSyntaxException:constructor(exceptionType, message, input, cursor)
+		self.exceptionType = exceptionType
+		self.message = message
+		self.input = input
+		local _result
+		if input == nil then
+			_result = -1
+		else
+			local _condition = cursor
+			if _condition == nil then
+				_condition = -1
+			end
+			_result = _condition
+		end
+		self.cursor = _result
+		if CommandSyntaxException.ENABLE_COMMAND_STACK_TRACES then
+			self.stackTrace = debug.traceback(nil, 2)
+		end
+	end
+	function CommandSyntaxException:getMessage()
+		local message = self.message:getString()
+		local context = self:getContext()
+		if context ~= nil then
+			message ..= ` at position {self.cursor}: {context}`
+		end
+		return message
+	end
+	function CommandSyntaxException:getRawMessage()
+		return self.message
+	end
+	function CommandSyntaxException:getContext()
+		local input = self.input
+		if input == nil or self.cursor < 0 then
+			return nil
+		end
+		local cursor = math.min(#input, self.cursor)
+		local builder = ""
+		if cursor > CommandSyntaxException.CONTEXT_AMOUNT then
+			builder ..= "..."
+		end
+		builder ..= substring(input, math.max(0, cursor - CommandSyntaxException.CONTEXT_AMOUNT), cursor)
+		builder ..= "<--[HERE]"
+		return builder
+	end
+	function CommandSyntaxException:getType()
+		return self.exceptionType
+	end
+	function CommandSyntaxException:getInput()
+		return self.input
+	end
+	function CommandSyntaxException:getCursor()
+		return self.cursor
+	end
+	function CommandSyntaxException:getStackTrace()
+		return self.stackTrace
+	end
+	function CommandSyntaxException:toString()
+		return `com.mojang.brigadier.exceptions.CommandSyntaxException: {self:getMessage()}`
+	end
+	function CommandSyntaxException:__tostring()
+		return self:toString()
+	end
+	CommandSyntaxException.CONTEXT_AMOUNT = 10
+	CommandSyntaxException.ENABLE_COMMAND_STACK_TRACES = true
+end
+-- Runs `body`, handing a CommandSyntaxException it throws to `onSyntaxException`. Java catches only that checked
+-- exception, so any other error propagates unchanged.
+local function catchSyntax(body, onSyntaxException)
+	local _exitType, _returns = TS.try(function()
+		return TS.TRY_RETURN, { body() }
+	end, function(err)
+		if TS.instanceof(err, CommandSyntaxException) then
+			return TS.TRY_RETURN, { onSyntaxException(err) }
+		end
+		return TS.TRY_RETURN, { rethrow(err) }
+	end)
+	if _exitType then
+		return unpack(_returns)
+	end
+end
+local SimpleCommandExceptionType
+do
+	SimpleCommandExceptionType = setmetatable({}, {
+		__tostring = function()
+			return "SimpleCommandExceptionType"
+		end,
+	})
+	SimpleCommandExceptionType.__index = SimpleCommandExceptionType
+	function SimpleCommandExceptionType.new(...)
+		local self = setmetatable({}, SimpleCommandExceptionType)
+		return self:constructor(...) or self
+	end
+	function SimpleCommandExceptionType:constructor(message)
+		self.message = message
+	end
+	function SimpleCommandExceptionType:create()
+		return CommandSyntaxException.new(self, self.message)
+	end
+	function SimpleCommandExceptionType:createWithContext(reader)
+		return CommandSyntaxException.new(self, self.message, reader:getString(), reader:getCursor())
+	end
+	function SimpleCommandExceptionType:toString()
+		return self.message:getString()
+	end
+	function SimpleCommandExceptionType:__tostring()
+		return self:toString()
+	end
+end
+local DynamicCommandExceptionType
+do
+	DynamicCommandExceptionType = setmetatable({}, {
+		__tostring = function()
+			return "DynamicCommandExceptionType"
+		end,
+	})
+	DynamicCommandExceptionType.__index = DynamicCommandExceptionType
+	function DynamicCommandExceptionType.new(...)
+		local self = setmetatable({}, DynamicCommandExceptionType)
+		return self:constructor(...) or self
+	end
+	function DynamicCommandExceptionType:constructor(fn)
+		self.fn = fn
+	end
+	function DynamicCommandExceptionType:create(arg)
+		return CommandSyntaxException.new(self, self.fn(arg))
+	end
+	function DynamicCommandExceptionType:createWithContext(reader, arg)
+		return CommandSyntaxException.new(self, self.fn(arg), reader:getString(), reader:getCursor())
+	end
+end
+local Dynamic2CommandExceptionType
+do
+	Dynamic2CommandExceptionType = setmetatable({}, {
+		__tostring = function()
+			return "Dynamic2CommandExceptionType"
+		end,
+	})
+	Dynamic2CommandExceptionType.__index = Dynamic2CommandExceptionType
+	function Dynamic2CommandExceptionType.new(...)
+		local self = setmetatable({}, Dynamic2CommandExceptionType)
+		return self:constructor(...) or self
+	end
+	function Dynamic2CommandExceptionType:constructor(fn)
+		self.fn = fn
+	end
+	function Dynamic2CommandExceptionType:create(a, b)
+		return CommandSyntaxException.new(self, self.fn(a, b))
+	end
+	function Dynamic2CommandExceptionType:createWithContext(reader, a, b)
+		return CommandSyntaxException.new(self, self.fn(a, b), reader:getString(), reader:getCursor())
+	end
+end
+local Dynamic3CommandExceptionType
+do
+	Dynamic3CommandExceptionType = setmetatable({}, {
+		__tostring = function()
+			return "Dynamic3CommandExceptionType"
+		end,
+	})
+	Dynamic3CommandExceptionType.__index = Dynamic3CommandExceptionType
+	function Dynamic3CommandExceptionType.new(...)
+		local self = setmetatable({}, Dynamic3CommandExceptionType)
+		return self:constructor(...) or self
+	end
+	function Dynamic3CommandExceptionType:constructor(fn)
+		self.fn = fn
+	end
+	function Dynamic3CommandExceptionType:create(a, b, c)
+		return CommandSyntaxException.new(self, self.fn(a, b, c))
+	end
+	function Dynamic3CommandExceptionType:createWithContext(reader, a, b, c)
+		return CommandSyntaxException.new(self, self.fn(a, b, c), reader:getString(), reader:getCursor())
+	end
+end
+local Dynamic4CommandExceptionType
+do
+	Dynamic4CommandExceptionType = setmetatable({}, {
+		__tostring = function()
+			return "Dynamic4CommandExceptionType"
+		end,
+	})
+	Dynamic4CommandExceptionType.__index = Dynamic4CommandExceptionType
+	function Dynamic4CommandExceptionType.new(...)
+		local self = setmetatable({}, Dynamic4CommandExceptionType)
+		return self:constructor(...) or self
+	end
+	function Dynamic4CommandExceptionType:constructor(fn)
+		self.fn = fn
+	end
+	function Dynamic4CommandExceptionType:create(a, b, c, d)
+		return CommandSyntaxException.new(self, self.fn(a, b, c, d))
+	end
+	function Dynamic4CommandExceptionType:createWithContext(reader, a, b, c, d)
+		return CommandSyntaxException.new(self, self.fn(a, b, c, d), reader:getString(), reader:getCursor())
+	end
+end
+local DynamicNCommandExceptionType
+do
+	DynamicNCommandExceptionType = setmetatable({}, {
+		__tostring = function()
+			return "DynamicNCommandExceptionType"
+		end,
+	})
+	DynamicNCommandExceptionType.__index = DynamicNCommandExceptionType
+	function DynamicNCommandExceptionType.new(...)
+		local self = setmetatable({}, DynamicNCommandExceptionType)
+		return self:constructor(...) or self
+	end
+	function DynamicNCommandExceptionType:constructor(fn)
+		self.fn = fn
+	end
+	function DynamicNCommandExceptionType:create(_a, ...)
+		local args = { ... }
+		return CommandSyntaxException.new(self, self.fn(args))
+	end
+	function DynamicNCommandExceptionType:createWithContext(reader, ...)
+		local args = { ... }
+		return CommandSyntaxException.new(self, self.fn(args), reader:getString(), reader:getCursor())
+	end
+end
+local function literal(text)
+	return LiteralMessage.new(text)
+end
+local DOUBLE_TOO_SMALL = Dynamic2CommandExceptionType.new(function(found, min)
+	return literal(`Double must not be less than {formatDouble(min)}, found {formatDouble(found)}`)
+end)
+local DOUBLE_TOO_BIG = Dynamic2CommandExceptionType.new(function(found, max)
+	return literal(`Double must not be more than {formatDouble(max)}, found {formatDouble(found)}`)
+end)
+local FLOAT_TOO_SMALL = Dynamic2CommandExceptionType.new(function(found, min)
+	return literal(`Float must not be less than {formatFloat(min)}, found {formatFloat(found)}`)
+end)
+local FLOAT_TOO_BIG = Dynamic2CommandExceptionType.new(function(found, max)
+	return literal(`Float must not be more than {formatFloat(max)}, found {formatFloat(found)}`)
+end)
+local INTEGER_TOO_SMALL = Dynamic2CommandExceptionType.new(function(found, min)
+	return literal(`Integer must not be less than {formatInteger(min)}, found {formatInteger(found)}`)
+end)
+local INTEGER_TOO_BIG = Dynamic2CommandExceptionType.new(function(found, max)
+	return literal(`Integer must not be more than {formatInteger(max)}, found {formatInteger(found)}`)
+end)
+local LONG_TOO_SMALL = Dynamic2CommandExceptionType.new(function(found, min)
+	return literal(`Long must not be less than {formatInteger(min)}, found {formatInteger(found)}`)
+end)
+local LONG_TOO_BIG = Dynamic2CommandExceptionType.new(function(found, max)
+	return literal(`Long must not be more than {formatInteger(max)}, found {formatInteger(found)}`)
+end)
+local LITERAL_INCORRECT = DynamicCommandExceptionType.new(function(expected)
+	return literal(`Expected literal {str(expected)}`)
+end)
+local READER_EXPECTED_START_OF_QUOTE = SimpleCommandExceptionType.new(literal("Expected quote to start a string"))
+local READER_EXPECTED_END_OF_QUOTE = SimpleCommandExceptionType.new(literal("Unclosed quoted string"))
+local READER_INVALID_ESCAPE = DynamicCommandExceptionType.new(function(character)
+	return literal(`Invalid escape sequence '{str(character)}' in quoted string`)
+end)
+local READER_INVALID_BOOL = DynamicCommandExceptionType.new(function(value)
+	return literal(`Invalid bool, expected true or false but found '{str(value)}'`)
+end)
+local READER_INVALID_INT = DynamicCommandExceptionType.new(function(value)
+	return literal(`Invalid integer '{str(value)}'`)
+end)
+local READER_EXPECTED_INT = SimpleCommandExceptionType.new(literal("Expected integer"))
+local READER_INVALID_LONG = DynamicCommandExceptionType.new(function(value)
+	return literal(`Invalid long '{str(value)}'`)
+end)
+local READER_EXPECTED_LONG = SimpleCommandExceptionType.new(literal("Expected long"))
+local READER_INVALID_DOUBLE = DynamicCommandExceptionType.new(function(value)
+	return literal(`Invalid double '{str(value)}'`)
+end)
+local READER_EXPECTED_DOUBLE = SimpleCommandExceptionType.new(literal("Expected double"))
+local READER_INVALID_FLOAT = DynamicCommandExceptionType.new(function(value)
+	return literal(`Invalid float '{str(value)}'`)
+end)
+local READER_EXPECTED_FLOAT = SimpleCommandExceptionType.new(literal("Expected float"))
+local READER_EXPECTED_BOOL = SimpleCommandExceptionType.new(literal("Expected bool"))
+local READER_EXPECTED_SYMBOL = DynamicCommandExceptionType.new(function(symbol)
+	return literal(`Expected '{str(symbol)}'`)
+end)
+local DISPATCHER_UNKNOWN_COMMAND = SimpleCommandExceptionType.new(literal("Unknown command"))
+local DISPATCHER_UNKNOWN_ARGUMENT = SimpleCommandExceptionType.new(literal("Incorrect argument for command"))
+local DISPATCHER_EXPECTED_ARGUMENT_SEPARATOR = SimpleCommandExceptionType.new(literal("Expected whitespace to end one argument, but found trailing data"))
+local DISPATCHER_PARSE_EXCEPTION = DynamicCommandExceptionType.new(function(message)
+	return literal(`Could not parse command: {str(message)}`)
+end)
+local BuiltInExceptions
+do
+	BuiltInExceptions = setmetatable({}, {
+		__tostring = function()
+			return "BuiltInExceptions"
+		end,
+	})
+	BuiltInExceptions.__index = BuiltInExceptions
+	function BuiltInExceptions.new(...)
+		local self = setmetatable({}, BuiltInExceptions)
+		return self:constructor(...) or self
+	end
+	function BuiltInExceptions:constructor()
+	end
+	function BuiltInExceptions:doubleTooLow()
+		return DOUBLE_TOO_SMALL
+	end
+	function BuiltInExceptions:doubleTooHigh()
+		return DOUBLE_TOO_BIG
+	end
+	function BuiltInExceptions:floatTooLow()
+		return FLOAT_TOO_SMALL
+	end
+	function BuiltInExceptions:floatTooHigh()
+		return FLOAT_TOO_BIG
+	end
+	function BuiltInExceptions:integerTooLow()
+		return INTEGER_TOO_SMALL
+	end
+	function BuiltInExceptions:integerTooHigh()
+		return INTEGER_TOO_BIG
+	end
+	function BuiltInExceptions:longTooLow()
+		return LONG_TOO_SMALL
+	end
+	function BuiltInExceptions:longTooHigh()
+		return LONG_TOO_BIG
+	end
+	function BuiltInExceptions:literalIncorrect()
+		return LITERAL_INCORRECT
+	end
+	function BuiltInExceptions:readerExpectedStartOfQuote()
+		return READER_EXPECTED_START_OF_QUOTE
+	end
+	function BuiltInExceptions:readerExpectedEndOfQuote()
+		return READER_EXPECTED_END_OF_QUOTE
+	end
+	function BuiltInExceptions:readerInvalidEscape()
+		return READER_INVALID_ESCAPE
+	end
+	function BuiltInExceptions:readerInvalidBool()
+		return READER_INVALID_BOOL
+	end
+	function BuiltInExceptions:readerInvalidInt()
+		return READER_INVALID_INT
+	end
+	function BuiltInExceptions:readerExpectedInt()
+		return READER_EXPECTED_INT
+	end
+	function BuiltInExceptions:readerInvalidLong()
+		return READER_INVALID_LONG
+	end
+	function BuiltInExceptions:readerExpectedLong()
+		return READER_EXPECTED_LONG
+	end
+	function BuiltInExceptions:readerInvalidDouble()
+		return READER_INVALID_DOUBLE
+	end
+	function BuiltInExceptions:readerExpectedDouble()
+		return READER_EXPECTED_DOUBLE
+	end
+	function BuiltInExceptions:readerInvalidFloat()
+		return READER_INVALID_FLOAT
+	end
+	function BuiltInExceptions:readerExpectedFloat()
+		return READER_EXPECTED_FLOAT
+	end
+	function BuiltInExceptions:readerExpectedBool()
+		return READER_EXPECTED_BOOL
+	end
+	function BuiltInExceptions:readerExpectedSymbol()
+		return READER_EXPECTED_SYMBOL
+	end
+	function BuiltInExceptions:dispatcherUnknownCommand()
+		return DISPATCHER_UNKNOWN_COMMAND
+	end
+	function BuiltInExceptions:dispatcherUnknownArgument()
+		return DISPATCHER_UNKNOWN_ARGUMENT
+	end
+	function BuiltInExceptions:dispatcherExpectedArgumentSeparator()
+		return DISPATCHER_EXPECTED_ARGUMENT_SEPARATOR
+	end
+	function BuiltInExceptions:dispatcherParseException()
+		return DISPATCHER_PARSE_EXCEPTION
+	end
+end
+CommandSyntaxException.BUILT_IN_EXCEPTIONS = BuiltInExceptions.new()
+return {
+	catchSyntax = catchSyntax,
+	CommandSyntaxException = CommandSyntaxException,
+	SimpleCommandExceptionType = SimpleCommandExceptionType,
+	DynamicCommandExceptionType = DynamicCommandExceptionType,
+	Dynamic2CommandExceptionType = Dynamic2CommandExceptionType,
+	Dynamic3CommandExceptionType = Dynamic3CommandExceptionType,
+	Dynamic4CommandExceptionType = Dynamic4CommandExceptionType,
+	DynamicNCommandExceptionType = DynamicNCommandExceptionType,
+	BuiltInExceptions = BuiltInExceptions,
+}

package/out/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./arguments";
+export * from "./command";
+export * from "./command-dispatcher";
+export * from "./context";
+export { BuiltInExceptions, type BuiltInExceptionProvider, type CommandExceptionType, CommandSyntaxException, Dynamic2CommandExceptionType, Dynamic3CommandExceptionType, Dynamic4CommandExceptionType, DynamicCommandExceptionType, DynamicNCommandExceptionType, SimpleCommandExceptionType, } from "./exceptions";
+export { IllegalArgumentException, IllegalStateException, IndexOutOfBoundsException, RuntimeException, StringIndexOutOfBoundsException, UnsupportedOperationException, } from "./java";
+export * from "./literal-message";
+export * from "./string-reader";
+export * from "./suggestion";
+export * from "./tree";

package/out/init.luau

@@ -0,0 +1,44 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local exports = {}
+for _k, _v in TS.import(script, script, "arguments") or {} do
+	exports[_k] = _v
+end
+for _k, _v in TS.import(script, script, "command") or {} do
+	exports[_k] = _v
+end
+for _k, _v in TS.import(script, script, "command-dispatcher") or {} do
+	exports[_k] = _v
+end
+for _k, _v in TS.import(script, script, "context") or {} do
+	exports[_k] = _v
+end
+local _exceptions = TS.import(script, script, "exceptions")
+exports.BuiltInExceptions = _exceptions.BuiltInExceptions
+exports.CommandSyntaxException = _exceptions.CommandSyntaxException
+exports.Dynamic2CommandExceptionType = _exceptions.Dynamic2CommandExceptionType
+exports.Dynamic3CommandExceptionType = _exceptions.Dynamic3CommandExceptionType
+exports.Dynamic4CommandExceptionType = _exceptions.Dynamic4CommandExceptionType
+exports.DynamicCommandExceptionType = _exceptions.DynamicCommandExceptionType
+exports.DynamicNCommandExceptionType = _exceptions.DynamicNCommandExceptionType
+exports.SimpleCommandExceptionType = _exceptions.SimpleCommandExceptionType
+local _java = TS.import(script, script, "java")
+exports.IllegalArgumentException = _java.IllegalArgumentException
+exports.IllegalStateException = _java.IllegalStateException
+exports.IndexOutOfBoundsException = _java.IndexOutOfBoundsException
+exports.RuntimeException = _java.RuntimeException
+exports.StringIndexOutOfBoundsException = _java.StringIndexOutOfBoundsException
+exports.UnsupportedOperationException = _java.UnsupportedOperationException
+for _k, _v in TS.import(script, script, "literal-message") or {} do
+	exports[_k] = _v
+end
+for _k, _v in TS.import(script, script, "string-reader") or {} do
+	exports[_k] = _v
+end
+for _k, _v in TS.import(script, script, "suggestion") or {} do
+	exports[_k] = _v
+end
+for _k, _v in TS.import(script, script, "tree") or {} do
+	exports[_k] = _v
+end
+return exports

package/out/java.d.ts

@@ -0,0 +1,40 @@
+export declare class RuntimeException {
+    private readonly message?;
+    protected readonly simpleName: string;
+    constructor(message?: string | undefined);
+    getMessage(): string | undefined;
+    toString(): string;
+}
+export declare class IllegalArgumentException extends RuntimeException {
+    protected readonly simpleName: string;
+    toString(): string;
+}
+export declare class IllegalStateException extends RuntimeException {
+    protected readonly simpleName: string;
+    toString(): string;
+}
+export declare class UnsupportedOperationException extends RuntimeException {
+    protected readonly simpleName: string;
+    toString(): string;
+}
+export declare class IndexOutOfBoundsException extends RuntimeException {
+    protected readonly simpleName: string;
+    toString(): string;
+}
+export declare class StringIndexOutOfBoundsException extends IndexOutOfBoundsException {
+    protected readonly simpleName: string;
+    toString(): string;
+}
+export declare function rethrow(err: unknown): never;
+export declare function str(value: unknown): string;
+export declare function substring(text: string, beginIndex: number, endIndex?: number): string;
+export declare function charAt(text: string, index: number): string;
+export declare function startsWith(text: string, prefix: string): boolean;
+export declare function toLowerCase(text: string): string;
+export declare function compareStrings(a: string, b: string): number;
+export declare function objectsEquals(a: unknown, b: unknown): boolean;
+export declare function stableSort<T extends defined>(list: T[], compare: (a: T, b: T) => number): void;
+export declare function formatInteger(value: number): string;
+export declare function toFloat(value: number): number;
+export declare function formatDouble(value: number): string;
+export declare function formatFloat(value: number): string;