@trioforge/brigadier 0.0.0-stage → 0.1.0

package/out/string-reader.luau

@@ -0,0 +1,271 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local CommandSyntaxException = TS.import(script, script.Parent, "exceptions").CommandSyntaxException
+local _java = TS.import(script, script.Parent, "java")
+local charAt = _java.charAt
+local substring = _java.substring
+local toFloat = _java.toFloat
+local SYNTAX_ESCAPE = "\\"
+local SYNTAX_DOUBLE_QUOTE = '"'
+local SYNTAX_SINGLE_QUOTE = "'"
+local INT_MIN = -2147483648
+local INT_MAX = 2147483647
+-- Character.isWhitespace for the one-byte characters it accepts.
+local function isWhitespace(c)
+	local code = string.byte(c)
+	return code ~= nil and ((code >= 9 and code <= 13) or (code >= 28 and code <= 32))
+end
+-- Integer.parseInt and Long.parseLong: an optional sign, then decimal digits that fit the type.
+local function parseWholeNumber(text, minDigits, maxDigits)
+	local sign, digits = string.match(text, "^([+-]?)(%d+)$")
+	if not (type(digits) == "string") then
+		return nil
+	end
+	local significant = (string.match(digits, "^0*(%d-)$"))
+	local limit = if sign == "-" then minDigits else maxDigits
+	if #significant > #limit or (#significant == #limit and significant > limit) then
+		return nil
+	end
+	-- Adding zero turns "-0" into 0, which is what an int holds.
+	return tonumber(text) + 0
+end
+local function parseInt(text)
+	local value = parseWholeNumber(text, "2147483648", "2147483647")
+	if value == nil or value < INT_MIN or value > INT_MAX then
+		return nil
+	end
+	return value
+end
+local function parseLong(text)
+	return parseWholeNumber(text, "9223372036854775808", "9223372036854775807")
+end
+-- Double.parseDouble for what isAllowedNumber lets through: an optional minus, then digits with at most one point.
+local function parseDouble(text)
+	local body = string.match(text, "^%-?([%d%.]+)$")
+	if not (type(body) == "string") or (string.find(body, "%d")) == nil then
+		return nil
+	end
+	local _, points = string.gsub(body, "%.", "")
+	if points > 1 then
+		return nil
+	end
+	return tonumber(text)
+end
+-- Float.parseFloat rounds the decimal straight to a float. Rounding through a double first differs only for
+-- decimals within half a double ulp of the midpoint between two floats.
+local function parseFloat(text)
+	local value = parseDouble(text)
+	return if value == nil then nil else toFloat(value)
+end
+local StringReader
+do
+	StringReader = setmetatable({}, {
+		__tostring = function()
+			return "StringReader"
+		end,
+	})
+	StringReader.__index = StringReader
+	function StringReader.new(...)
+		local self = setmetatable({}, StringReader)
+		return self:constructor(...) or self
+	end
+	function StringReader:constructor(other)
+		local _other = other
+		if type(_other) == "string" then
+			self.text = other
+			self.cursor = 0
+		else
+			self.text = other.text
+			self.cursor = other.cursor
+		end
+	end
+	function StringReader:isAllowedNumber(c)
+		return (c >= "0" and c <= "9") or c == "." or c == "-"
+	end
+	function StringReader:isQuotedStringStart(c)
+		return c == SYNTAX_DOUBLE_QUOTE or c == SYNTAX_SINGLE_QUOTE
+	end
+	function StringReader:isAllowedInUnquotedString(c)
+		return (c >= "0" and c <= "9") or (c >= "A" and c <= "Z") or (c >= "a" and c <= "z") or c == "_" or c == "-" or c == "." or c == "+"
+	end
+	function StringReader:getString()
+		return self.text
+	end
+	function StringReader:setCursor(cursor)
+		self.cursor = cursor
+	end
+	function StringReader:getRemainingLength()
+		return #self.text - self.cursor
+	end
+	function StringReader:getTotalLength()
+		return #self.text
+	end
+	function StringReader:getCursor()
+		return self.cursor
+	end
+	function StringReader:getRead()
+		return substring(self.text, 0, self.cursor)
+	end
+	function StringReader:getRemaining()
+		return substring(self.text, self.cursor)
+	end
+	function StringReader:canRead(length)
+		if length == nil then
+			length = 1
+		end
+		return self.cursor + length <= #self.text
+	end
+	function StringReader:peek(offset)
+		if offset == nil then
+			offset = 0
+		end
+		return charAt(self.text, self.cursor + offset)
+	end
+	function StringReader:read()
+		local c = charAt(self.text, self.cursor)
+		self.cursor += 1
+		return c
+	end
+	function StringReader:skip()
+		self.cursor += 1
+	end
+	function StringReader:skipWhitespace()
+		while self:canRead() and isWhitespace(self:peek()) do
+			self:skip()
+		end
+	end
+	function StringReader:readNumber()
+		local start = self.cursor
+		while self:canRead() and StringReader:isAllowedNumber(self:peek()) do
+			self:skip()
+		end
+		return substring(self.text, start, self.cursor)
+	end
+	function StringReader:readInt()
+		local start = self.cursor
+		local text = self:readNumber()
+		if text == "" then
+			error(CommandSyntaxException.BUILT_IN_EXCEPTIONS:readerExpectedInt():createWithContext(self))
+		end
+		local value = parseInt(text)
+		if value == nil then
+			self.cursor = start
+			error(CommandSyntaxException.BUILT_IN_EXCEPTIONS:readerInvalidInt():createWithContext(self, text))
+		end
+		return value
+	end
+	function StringReader:readLong()
+		local start = self.cursor
+		local text = self:readNumber()
+		if text == "" then
+			error(CommandSyntaxException.BUILT_IN_EXCEPTIONS:readerExpectedLong():createWithContext(self))
+		end
+		local value = parseLong(text)
+		if value == nil then
+			self.cursor = start
+			error(CommandSyntaxException.BUILT_IN_EXCEPTIONS:readerInvalidLong():createWithContext(self, text))
+		end
+		return value
+	end
+	function StringReader:readDouble()
+		local start = self.cursor
+		local text = self:readNumber()
+		if text == "" then
+			error(CommandSyntaxException.BUILT_IN_EXCEPTIONS:readerExpectedDouble():createWithContext(self))
+		end
+		local value = parseDouble(text)
+		if value == nil then
+			self.cursor = start
+			error(CommandSyntaxException.BUILT_IN_EXCEPTIONS:readerInvalidDouble():createWithContext(self, text))
+		end
+		return value
+	end
+	function StringReader:readFloat()
+		local start = self.cursor
+		local text = self:readNumber()
+		if text == "" then
+			error(CommandSyntaxException.BUILT_IN_EXCEPTIONS:readerExpectedFloat():createWithContext(self))
+		end
+		local value = parseFloat(text)
+		if value == nil then
+			self.cursor = start
+			error(CommandSyntaxException.BUILT_IN_EXCEPTIONS:readerInvalidFloat():createWithContext(self, text))
+		end
+		return value
+	end
+	function StringReader:readUnquotedString()
+		local start = self.cursor
+		while self:canRead() and StringReader:isAllowedInUnquotedString(self:peek()) do
+			self:skip()
+		end
+		return substring(self.text, start, self.cursor)
+	end
+	function StringReader:readQuotedString()
+		if not self:canRead() then
+			return ""
+		end
+		local nextChar = self:peek()
+		if not StringReader:isQuotedStringStart(nextChar) then
+			error(CommandSyntaxException.BUILT_IN_EXCEPTIONS:readerExpectedStartOfQuote():createWithContext(self))
+		end
+		self:skip()
+		return self:readStringUntil(nextChar)
+	end
+	function StringReader:readStringUntil(terminator)
+		local result = {}
+		local escaped = false
+		while self:canRead() do
+			local c = self:read()
+			if escaped then
+				if c == terminator or c == SYNTAX_ESCAPE then
+					table.insert(result, c)
+					escaped = false
+				else
+					self:setCursor(self:getCursor() - 1)
+					error(CommandSyntaxException.BUILT_IN_EXCEPTIONS:readerInvalidEscape():createWithContext(self, c))
+				end
+			elseif c == SYNTAX_ESCAPE then
+				escaped = true
+			elseif c == terminator then
+				return table.concat(result, "")
+			else
+				table.insert(result, c)
+			end
+		end
+		error(CommandSyntaxException.BUILT_IN_EXCEPTIONS:readerExpectedEndOfQuote():createWithContext(self))
+	end
+	function StringReader:readString()
+		if not self:canRead() then
+			return ""
+		end
+		local nextChar = self:peek()
+		if StringReader:isQuotedStringStart(nextChar) then
+			self:skip()
+			return self:readStringUntil(nextChar)
+		end
+		return self:readUnquotedString()
+	end
+	function StringReader:readBoolean()
+		local start = self.cursor
+		local value = self:readString()
+		if value == "" then
+			error(CommandSyntaxException.BUILT_IN_EXCEPTIONS:readerExpectedBool():createWithContext(self))
+		end
+		if value == "true" then
+			return true
+		elseif value == "false" then
+			return false
+		end
+		self.cursor = start
+		error(CommandSyntaxException.BUILT_IN_EXCEPTIONS:readerInvalidBool():createWithContext(self, value))
+	end
+	function StringReader:expect(c)
+		if not self:canRead() or self:peek() ~= c then
+			error(CommandSyntaxException.BUILT_IN_EXCEPTIONS:readerExpectedSymbol():createWithContext(self, c))
+		end
+		self:skip()
+	end
+end
+return {
+	StringReader = StringReader,
+}

package/out/suggestion.d.ts

@@ -0,0 +1,60 @@
+import { StringRange } from "./context";
+import type { Message } from "./literal-message";
+export declare class Suggestion {
+    protected readonly range: StringRange;
+    protected readonly text: string;
+    protected readonly tooltip?: Message | undefined;
+    constructor(range: StringRange, text: string, tooltip?: Message | undefined);
+    getRange(): StringRange;
+    getText(): string;
+    getTooltip(): Message | undefined;
+    apply(input: string): string;
+    equals(other: unknown): boolean;
+    toString(): string;
+    compareTo(other: Suggestion): number;
+    compareToIgnoreCase(other: Suggestion): number;
+    expand(command: string, range: StringRange): Suggestion;
+}
+export declare class IntegerSuggestion extends Suggestion {
+    private readonly value;
+    constructor(range: StringRange, value: number, tooltip?: Message);
+    getValue(): number;
+    equals(other: unknown): boolean;
+    toString(): string;
+    compareTo(other: Suggestion): number;
+    compareToIgnoreCase(other: Suggestion): number;
+}
+export declare class Suggestions {
+    private readonly range;
+    private readonly suggestions;
+    private static readonly EMPTY;
+    constructor(range: StringRange, suggestions: readonly Suggestion[]);
+    static empty(): Promise<Suggestions>;
+    static merge(command: string, input: readonly Suggestions[]): Suggestions;
+    static create(command: string, suggestions: readonly Suggestion[]): Suggestions;
+    getRange(): StringRange;
+    getList(): readonly Suggestion[];
+    isEmpty(): boolean;
+    equals(other: unknown): boolean;
+    toString(): string;
+}
+export declare class SuggestionsBuilder {
+    private readonly input;
+    private readonly inputLowerCase;
+    private readonly start;
+    private readonly remaining;
+    private readonly remainingLowerCase;
+    private readonly result;
+    constructor(input: string, start: number);
+    constructor(input: string, inputLowerCase: string, start: number);
+    getInput(): string;
+    getStart(): number;
+    getRemaining(): string;
+    getRemainingLowerCase(): string;
+    build(): Suggestions;
+    buildFuture(): Promise<Suggestions>;
+    suggest(textOrValue: string | number, tooltip?: Message): this;
+    add(other: SuggestionsBuilder): this;
+    createOffset(start: number): SuggestionsBuilder;
+    restart(): SuggestionsBuilder;
+}

package/out/suggestion.luau

@@ -0,0 +1,340 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local StringRange = TS.import(script, script.Parent, "context").StringRange
+local _java = TS.import(script, script.Parent, "java")
+local compareStrings = _java.compareStrings
+local formatInteger = _java.formatInteger
+local objectsEquals = _java.objectsEquals
+local stableSort = _java.stableSort
+local substring = _java.substring
+local toLowerCase = _java.toLowerCase
+local function describeTooltip(tooltip)
+	return if tooltip == nil then "null" else tostring(tooltip)
+end
+local Suggestion
+do
+	Suggestion = setmetatable({}, {
+		__tostring = function()
+			return "Suggestion"
+		end,
+	})
+	Suggestion.__index = Suggestion
+	function Suggestion.new(...)
+		local self = setmetatable({}, Suggestion)
+		return self:constructor(...) or self
+	end
+	function Suggestion:constructor(range, text, tooltip)
+		self.range = range
+		self.text = text
+		self.tooltip = tooltip
+	end
+	function Suggestion:getRange()
+		return self.range
+	end
+	function Suggestion:getText()
+		return self.text
+	end
+	function Suggestion:getTooltip()
+		return self.tooltip
+	end
+	function Suggestion:apply(input)
+		if self.range:getStart() == 0 and self.range:getEnd() == #input then
+			return self.text
+		end
+		local result = ""
+		if self.range:getStart() > 0 then
+			result ..= substring(input, 0, self.range:getStart())
+		end
+		result ..= self.text
+		if self.range:getEnd() < #input then
+			result ..= substring(input, self.range:getEnd())
+		end
+		return result
+	end
+	function Suggestion:equals(other)
+		if rawequal(self, other) then
+			return true
+		end
+		if not (TS.instanceof(other, Suggestion)) then
+			return false
+		end
+		return objectsEquals(self.range, other.range) and objectsEquals(self.text, other.text) and objectsEquals(self.tooltip, other.tooltip)
+	end
+	function Suggestion:toString()
+		return `Suggestion\{range={self.range}, text='{self.text}', tooltip='{describeTooltip(self.tooltip)}'\}`
+	end
+	function Suggestion:compareTo(other)
+		return compareStrings(self.text, other:getText())
+	end
+	function Suggestion:compareToIgnoreCase(other)
+		return compareStrings(string.lower(self.text), string.lower(other:getText()))
+	end
+	function Suggestion:expand(command, range)
+		if range:equals(self.range) then
+			return self
+		end
+		local result = ""
+		if range:getStart() < self.range:getStart() then
+			result ..= substring(command, range:getStart(), self.range:getStart())
+		end
+		result ..= self.text
+		if range:getEnd() > self.range:getEnd() then
+			result ..= substring(command, self.range:getEnd(), range:getEnd())
+		end
+		return Suggestion.new(range, result, self.tooltip)
+	end
+	function Suggestion:__tostring()
+		return self:toString()
+	end
+end
+local IntegerSuggestion
+do
+	local super = Suggestion
+	IntegerSuggestion = setmetatable({}, {
+		__tostring = function()
+			return "IntegerSuggestion"
+		end,
+		__index = super,
+	})
+	IntegerSuggestion.__index = IntegerSuggestion
+	function IntegerSuggestion.new(...)
+		local self = setmetatable({}, IntegerSuggestion)
+		return self:constructor(...) or self
+	end
+	function IntegerSuggestion:constructor(range, value, tooltip)
+		super.constructor(self, range, formatInteger(value), tooltip)
+		self.value = value
+	end
+	function IntegerSuggestion:getValue()
+		return self.value
+	end
+	function IntegerSuggestion:equals(other)
+		if rawequal(self, other) then
+			return true
+		end
+		if not (TS.instanceof(other, IntegerSuggestion)) then
+			return false
+		end
+		return self.value == other.value and super.equals(self, other)
+	end
+	function IntegerSuggestion:toString()
+		return `IntegerSuggestion\{value={formatInteger(self.value)}, range={self.range}, text='{self.text}', tooltip='{describeTooltip(self.tooltip)}'\}`
+	end
+	function IntegerSuggestion:compareTo(other)
+		if TS.instanceof(other, IntegerSuggestion) then
+			return if self.value < other.value then -1 elseif self.value == other.value then 0 else 1
+		end
+		return super.compareTo(self, other)
+	end
+	function IntegerSuggestion:compareToIgnoreCase(other)
+		return self:compareTo(other)
+	end
+	function IntegerSuggestion:__tostring()
+		return self:toString()
+	end
+end
+-- A HashSet<Suggestion> keeps the first of each group of equal suggestions. Equal suggestions share their range,
+-- text and class, so those key the buckets that `equals` searches.
+local function addToSet(set, buckets, suggestion)
+	local clazz = getmetatable(suggestion)
+	local byKey = buckets[clazz]
+	if byKey == nil then
+		byKey = {}
+		local _buckets = buckets
+		local _byKey = byKey
+		_buckets[clazz] = _byKey
+	end
+	local range = suggestion:getRange()
+	local key = `{range:getStart()}:{range:getEnd()}:{suggestion:getText()}`
+	local bucket = byKey[key]
+	if bucket == nil then
+		bucket = {}
+		local _byKey = byKey
+		local _bucket = bucket
+		_byKey[key] = _bucket
+	end
+	for _, existing in bucket do
+		if existing:equals(suggestion) then
+			return nil
+		end
+	end
+	local _bucket = bucket
+	local _suggestion = suggestion
+	table.insert(_bucket, _suggestion)
+	local _set = set
+	local _suggestion_1 = suggestion
+	table.insert(_set, _suggestion_1)
+end
+local Suggestions
+do
+	Suggestions = setmetatable({}, {
+		__tostring = function()
+			return "Suggestions"
+		end,
+	})
+	Suggestions.__index = Suggestions
+	function Suggestions.new(...)
+		local self = setmetatable({}, Suggestions)
+		return self:constructor(...) or self
+	end
+	function Suggestions:constructor(range, suggestions)
+		self.range = range
+		self.suggestions = suggestions
+	end
+	function Suggestions:empty()
+		return TS.Promise.resolve(Suggestions.EMPTY)
+	end
+	function Suggestions:merge(command, input)
+		if #input == 0 then
+			return Suggestions.EMPTY
+		elseif #input == 1 then
+			return input[1]
+		end
+		local texts = {}
+		local buckets = {}
+		for _, suggestions in input do
+			for _1, suggestion in suggestions:getList() do
+				addToSet(texts, buckets, suggestion)
+			end
+		end
+		return Suggestions:create(command, texts)
+	end
+	function Suggestions:create(command, suggestions)
+		if #suggestions == 0 then
+			return Suggestions.EMPTY
+		end
+		local start = math.huge
+		local finish = -math.huge
+		for _, suggestion in suggestions do
+			start = math.min(suggestion:getRange():getStart(), start)
+			finish = math.max(suggestion:getRange():getEnd(), finish)
+		end
+		local range = StringRange.new(start, finish)
+		local texts = {}
+		local buckets = {}
+		for _, suggestion in suggestions do
+			addToSet(texts, buckets, suggestion:expand(command, range))
+		end
+		stableSort(texts, function(a, b)
+			return a:compareToIgnoreCase(b)
+		end)
+		return Suggestions.new(range, texts)
+	end
+	function Suggestions:getRange()
+		return self.range
+	end
+	function Suggestions:getList()
+		return self.suggestions
+	end
+	function Suggestions:isEmpty()
+		return #self.suggestions == 0
+	end
+	function Suggestions:equals(other)
+		if rawequal(self, other) then
+			return true
+		end
+		if not (TS.instanceof(other, Suggestions)) then
+			return false
+		end
+		return objectsEquals(self.range, other.range) and objectsEquals(self.suggestions, other.suggestions)
+	end
+	function Suggestions:toString()
+		local _exp = self.suggestions
+		-- ▼ ReadonlyArray.map ▼
+		local _newValue = table.create(#_exp)
+		local _callback = function(suggestion)
+			return tostring(suggestion)
+		end
+		for _k, _v in _exp do
+			_newValue[_k] = _callback(_v, _k - 1, _exp)
+		end
+		-- ▲ ReadonlyArray.map ▲
+		local parts = _newValue
+		return `Suggestions\{range={self.range}, suggestions=[{table.concat(parts, ", ")}]\}`
+	end
+	function Suggestions:__tostring()
+		return self:toString()
+	end
+	Suggestions.EMPTY = Suggestions.new(StringRange:at(0), {})
+end
+local SuggestionsBuilder
+do
+	SuggestionsBuilder = setmetatable({}, {
+		__tostring = function()
+			return "SuggestionsBuilder"
+		end,
+	})
+	SuggestionsBuilder.__index = SuggestionsBuilder
+	function SuggestionsBuilder.new(...)
+		local self = setmetatable({}, SuggestionsBuilder)
+		return self:constructor(...) or self
+	end
+	function SuggestionsBuilder:constructor(input, inputLowerCaseOrStart, start)
+		self.input = input
+		self.result = {}
+		local _inputLowerCaseOrStart = inputLowerCaseOrStart
+		if type(_inputLowerCaseOrStart) == "number" then
+			self.inputLowerCase = toLowerCase(input)
+			self.start = inputLowerCaseOrStart
+		else
+			self.inputLowerCase = inputLowerCaseOrStart
+			self.start = start
+		end
+		self.remaining = substring(input, self.start)
+		self.remainingLowerCase = substring(self.inputLowerCase, self.start)
+	end
+	function SuggestionsBuilder:getInput()
+		return self.input
+	end
+	function SuggestionsBuilder:getStart()
+		return self.start
+	end
+	function SuggestionsBuilder:getRemaining()
+		return self.remaining
+	end
+	function SuggestionsBuilder:getRemainingLowerCase()
+		return self.remainingLowerCase
+	end
+	function SuggestionsBuilder:build()
+		return Suggestions:create(self.input, self.result)
+	end
+	function SuggestionsBuilder:buildFuture()
+		return TS.Promise.resolve(self:build())
+	end
+	function SuggestionsBuilder:suggest(textOrValue, tooltip)
+		local range = StringRange:between(self.start, #self.input)
+		local _textOrValue = textOrValue
+		if type(_textOrValue) == "number" then
+			local _result = self.result
+			local _integerSuggestion = IntegerSuggestion.new(range, textOrValue, tooltip)
+			table.insert(_result, _integerSuggestion)
+			return self
+		end
+		if textOrValue == self.remaining then
+			return self
+		end
+		local _result = self.result
+		local _suggestion = Suggestion.new(range, textOrValue, tooltip)
+		table.insert(_result, _suggestion)
+		return self
+	end
+	function SuggestionsBuilder:add(other)
+		for _, suggestion in other.result do
+			local _exp = self.result
+			table.insert(_exp, suggestion)
+		end
+		return self
+	end
+	function SuggestionsBuilder:createOffset(start)
+		return SuggestionsBuilder.new(self.input, self.inputLowerCase, start)
+	end
+	function SuggestionsBuilder:restart()
+		return self:createOffset(self.start)
+	end
+end
+return {
+	Suggestion = Suggestion,
+	IntegerSuggestion = IntegerSuggestion,
+	Suggestions = Suggestions,
+	SuggestionsBuilder = SuggestionsBuilder,
+}