cluaupp 0.1.0

package/runtime/Cmdr/_impl/BuiltInTypes/Primitives.luau

@@ -0,0 +1,145 @@
+const TRUTHY_VALUES = { "true", "t", "yes", "y", "on", "enable", "enabled", "1", "+" }
+const FALSY_VALUES = { "false", "f", "no", "n", "off", "disable", "disabled", "0", "-" }
+
+type NumberTransformer = {
+	Transform: (text: string) -> number?,
+	Validate: (value: number?) -> (boolean, string?),
+	Parse: (value: number) -> number,
+}
+
+const stringType = {
+	Validate = function(value: unknown): (boolean, string?)
+		return value ~= nil
+	end,
+
+	Parse = function(value: unknown): string
+		return tostring(value)
+	end,
+}
+
+const numberType: NumberTransformer = {
+	Transform = function(text: string): number?
+		return tonumber(text)
+	end,
+
+	Validate = function(value: number?): (boolean, string?)
+		return value ~= nil
+	end,
+
+	Parse = function(value: number): number
+		return value
+	end,
+}
+
+const intType: NumberTransformer = {
+	Transform = function(text: string): number?
+		return tonumber(text)
+	end,
+
+	Validate = function(value: number?): (boolean, string?)
+		return value ~= nil and value == math.floor(value), "Only whole numbers are valid."
+	end,
+
+	Parse = function(value: number): number
+		return value
+	end,
+}
+
+const positiveIntType: NumberTransformer = {
+	Transform = function(text: string): number?
+		return tonumber(text)
+	end,
+
+	Validate = function(value: number?): (boolean, string?)
+		return value ~= nil and value == math.floor(value) and value > 0, "Only positive whole numbers are valid."
+	end,
+
+	Parse = function(value: number): number
+		return value
+	end,
+}
+
+const nonNegativeIntType: NumberTransformer = {
+	Transform = function(text: string): number?
+		return tonumber(text)
+	end,
+
+	Validate = function(value: number?): (boolean, string?)
+		return value ~= nil and value == math.floor(value) and value >= 0, "Only non-negative whole numbers are valid."
+	end,
+
+	Parse = function(value: number): number
+		return value
+	end,
+}
+
+const byteType: NumberTransformer = {
+	Transform = function(text: string): number?
+		return tonumber(text)
+	end,
+
+	Validate = function(value: number?): (boolean, string?)
+		return value ~= nil and value == math.floor(value) and value >= 0 and value <= 255, "Only bytes are valid."
+	end,
+
+	Parse = function(value: number): number
+		return value
+	end,
+}
+
+const digitType: NumberTransformer = {
+	Transform = function(text: string): number?
+		return tonumber(text)
+	end,
+
+	Validate = function(value: number?): (boolean, string?)
+		return value ~= nil and value == math.floor(value) and value >= 0 and value <= 9, "Only digits are valid."
+	end,
+
+	Parse = function(value: number): number
+		return value
+	end,
+}
+
+return function(registry: any)
+	const truthy: { [string]: boolean } = registry.Cmdr.Util.MakeDictionary(TRUTHY_VALUES)
+	const falsy: { [string]: boolean } = registry.Cmdr.Util.MakeDictionary(FALSY_VALUES)
+
+	const boolType = {
+		Transform = function(text: string): string
+			return text:lower()
+		end,
+
+		Validate = function(value: string): (boolean, string?)
+			return truthy[value] ~= nil or falsy[value] ~= nil, "Please use true/yes/on or false/no/off."
+		end,
+
+		Parse = function(value: string): boolean?
+			if truthy[value] then
+				return true
+			elseif falsy[value] then
+				return false
+			end
+
+			return nil
+		end,
+	}
+
+	registry:RegisterType("string", stringType)
+	registry:RegisterType("number", numberType)
+	registry:RegisterType("integer", intType)
+	registry:RegisterType("positiveInteger", positiveIntType)
+	registry:RegisterType("nonNegativeInteger", nonNegativeIntType)
+	registry:RegisterType("byte", byteType)
+	registry:RegisterType("digit", digitType)
+	registry:RegisterType("boolean", boolType)
+
+	registry:RegisterType("strings", registry.Cmdr.Util.MakeListableType(stringType))
+	registry:RegisterType("numbers", registry.Cmdr.Util.MakeListableType(numberType))
+	registry:RegisterType("integers", registry.Cmdr.Util.MakeListableType(intType))
+	registry:RegisterType("positiveIntegers", registry.Cmdr.Util.MakeListableType(positiveIntType))
+	registry:RegisterType("nonNegativeIntegers", registry.Cmdr.Util.MakeListableType(nonNegativeIntType))
+	registry:RegisterType("bytes", registry.Cmdr.Util.MakeListableType(byteType))
+	registry:RegisterType("digits", registry.Cmdr.Util.MakeListableType(digitType))
+	registry:RegisterType("booleans", registry.Cmdr.Util.MakeListableType(boolType))
+end

package/runtime/Cmdr/_impl/BuiltInTypes/StoredKey.luau

@@ -0,0 +1,33 @@
+const VALID_STORED_KEY_NAME_PATTERNS: { string } = {
+	"^%a[%w_]*$",
+	"^%$%a[%w_]*$",
+	"^%.%a[%w_]*$",
+	"^%$%.%a[%w_]*$",
+}
+
+return function(registry: any)
+	const storedKeyType = {
+		Autocomplete = function(text: string): { string }
+			const store = registry:GetStore("vars_used") or {}
+			const find = registry.Cmdr.Util.MakeFuzzyFinder(registry.Cmdr.Util.DictionaryKeys(store))
+			return find(text)
+		end,
+
+		Validate = function(text: string): (boolean, string?)
+			for _, pattern: string in ipairs(VALID_STORED_KEY_NAME_PATTERNS) do
+				if text:match(pattern) then
+					return true
+				end
+			end
+
+			return false, "Key names must start with an optional modifier: . $ or $. and must begin with a letter."
+		end,
+
+		Parse = function(text: string): string
+			return text
+		end,
+	}
+
+	registry:RegisterType("storedKey", storedKeyType)
+	registry:RegisterType("storedKeys", registry.Cmdr.Util.MakeListableType(storedKeyType))
+end

package/runtime/Cmdr/_impl/BuiltInTypes/Team.luau

@@ -0,0 +1,49 @@
+const Teams = game:GetService("Teams")
+
+return function(registry: any)
+	const teamType = {
+		Transform = function(text: string): { Team }
+			const findTeam = registry.Cmdr.Util.MakeFuzzyFinder(Teams:GetTeams())
+			return findTeam(text)
+		end,
+
+		Validate = function(teams: { Team }): (boolean, string?)
+			return #teams > 0, "No team with that name could be found."
+		end,
+
+		Autocomplete = function(teams: { Team }): { string }
+			return registry.Cmdr.Util.GetNames(teams)
+		end,
+
+		Parse = function(teams: { Team }): Team?
+			return teams[1]
+		end,
+	}
+
+	const teamPlayersType = {
+		Listable = true,
+		Transform = teamType.Transform,
+		Validate = teamType.Validate,
+		Autocomplete = teamType.Autocomplete,
+		Parse = function(teams: { Team }): { Player }
+			return teams[1]:GetPlayers()
+		end,
+	}
+
+	const teamColorType = {
+		Transform = teamType.Transform,
+		Validate = teamType.Validate,
+		Autocomplete = teamType.Autocomplete,
+		Parse = function(teams: { Team }): BrickColor?
+			return teams[1].TeamColor
+		end,
+	}
+
+	registry:RegisterType("team", teamType)
+	registry:RegisterType("teams", registry.Cmdr.Util.MakeListableType(teamType))
+
+	registry:RegisterType("teamPlayers", teamPlayersType)
+
+	registry:RegisterType("teamColor", teamColorType)
+	registry:RegisterType("teamColors", registry.Cmdr.Util.MakeListableType(teamColorType))
+end

package/runtime/Cmdr/_impl/BuiltInTypes/Type.luau

@@ -0,0 +1,23 @@
+return function(registry: any)
+	const typeType = {
+		Transform = function(text: string): { string }
+			const findType = registry.Cmdr.Util.MakeFuzzyFinder(registry:GetTypeNames())
+			return findType(text)
+		end,
+
+		Validate = function(types: { string }): (boolean, string?)
+			return #types > 0, "No type with that name could be found."
+		end,
+
+		Autocomplete = function(types: { string }): { string }
+			return types
+		end,
+
+		Parse = function(types: { string }): string?
+			return types[1]
+		end,
+	}
+
+	registry:RegisterType("type", typeType)
+	registry:RegisterType("types", registry.Cmdr.Util.MakeListableType(typeType))
+end

package/runtime/Cmdr/_impl/BuiltInTypes/URL.luau

@@ -0,0 +1,18 @@
+return function(registry: any)
+	const urlType = {
+		Validate = function(text: string): (boolean, string?)
+			if text:match("^https?://.+$") then
+				return true
+			end
+
+			return false, "URLs must begin with http:// or https://"
+		end,
+
+		Parse = function(text: string): string
+			return text
+		end,
+	}
+
+	registry:RegisterType("url", urlType)
+	registry:RegisterType("urls", registry.Cmdr.Util.MakeListableType(urlType))
+end

package/runtime/Cmdr/_impl/BuiltInTypes/UserInput.luau

@@ -0,0 +1,32 @@
+const combinedInputEnums: { EnumItem } = {}
+for _, enum: Enum.UserInputType in ipairs(Enum.UserInputType:GetEnumItems()) do
+	combinedInputEnums[#combinedInputEnums + 1] = enum
+end
+
+for _, enum: Enum.KeyCode in ipairs(Enum.KeyCode:GetEnumItems()) do
+	combinedInputEnums[#combinedInputEnums + 1] = enum
+end
+
+return function(registry: any)
+	const userInputType = {
+		Transform = function(text: string): { EnumItem }
+			const findEnum = registry.Cmdr.Util.MakeFuzzyFinder(combinedInputEnums)
+			return findEnum(text)
+		end,
+
+		Validate = function(enums: { EnumItem }): (boolean, string?)
+			return #enums > 0
+		end,
+
+		Autocomplete = function(enums: { EnumItem }): { string }
+			return registry.Cmdr.Util.GetNames(enums)
+		end,
+
+		Parse = function(enums: { EnumItem }): EnumItem?
+			return enums[1]
+		end,
+	}
+
+	registry:RegisterType("userInput", userInputType)
+	registry:RegisterType("userInputs", registry.Cmdr.Util.MakeListableType(userInputType))
+end

package/runtime/Cmdr/_impl/BuiltInTypes/Vector.luau

@@ -0,0 +1,58 @@
+const AXES: { string } = { "X", "Y", "Z" }
+
+const function validateVector(value: number?, index: number): (boolean, string?)
+	if value == nil then
+		return false, `Invalid or missing number at position {index} in Vector type.`
+	end
+
+	return true
+end
+
+return function(registry: any)
+	const vector3Type = registry.Cmdr.Util.MakeSequenceType({
+		ValidateEach = validateVector,
+		TransformEach = tonumber,
+		Constructor = Vector3.new,
+		Length = 3,
+	})
+
+	const vector2Type = registry.Cmdr.Util.MakeSequenceType({
+		ValidateEach = validateVector,
+		TransformEach = tonumber,
+		Constructor = Vector2.new,
+		Length = 2,
+	})
+
+	const positionVector3Type = registry.Cmdr.Util.MakeSequenceType({
+		Transform = function(text: string, executor: Player): { number? }
+			const character = executor.Character
+			const currentPosition = if character then character:GetPivot().Position else Vector3.zero
+
+			return registry.Cmdr.Util.Map(
+				registry.Cmdr.Util.SplitPrioritizedDelimeter(text, { ",", "%s" }),
+				function(value: string, index: number): number?
+					if value:sub(1, 1) ~= "~" then
+						return tonumber(value)
+					end
+
+					const axis = AXES[index]
+					const currentComponent = if axis then currentPosition[axis] else 0
+					const offset = tonumber(value:sub(2))
+					return if value == "~" then currentComponent elseif offset then currentComponent + offset else nil
+				end
+			)
+		end,
+		ValidateEach = validateVector,
+		Constructor = Vector3.new,
+		Length = 3,
+	})
+
+	registry:RegisterType("vector3", vector3Type)
+	registry:RegisterType("vector3s", registry.Cmdr.Util.MakeListableType(vector3Type))
+
+	registry:RegisterType("vector2", vector2Type)
+	registry:RegisterType("vector2s", registry.Cmdr.Util.MakeListableType(vector2Type))
+
+	registry:RegisterType("positionVector3", positionVector3Type)
+	registry:RegisterType("positionVector3s", registry.Cmdr.Util.MakeListableType(positionVector3Type))
+end

package/runtime/Cmdr/_impl/CmdrClient/CmdrInterface/AutoComplete.luau

@@ -0,0 +1,240 @@
+const VALID_TEXT_COLOR = Color3.fromRGB(255, 255, 255)
+const INVALID_TEXT_COLOR = Color3.fromRGB(255, 73, 73)
+const TEXT_MEASUREMENT_SIZE = Vector2.new(1000, 1000)
+
+--[=[
+	@class AutoComplete
+	@ignore
+	Handles the Cmdr suggestions interface.
+]=]
+
+return function(CmdrClient)
+	const autoCompleteFrame = CmdrClient.Gui:WaitForChild("Autocomplete") :: ScrollingFrame
+	const defaultBarThickness = autoCompleteFrame.ScrollBarThickness
+
+	const AutoComplete = {
+		_autoItem = autoCompleteFrame:WaitForChild("TextButton") :: TextButton,
+		_title = autoCompleteFrame:WaitForChild("Title") :: TextLabel,
+		_description = autoCompleteFrame:WaitForChild("Description") :: TextLabel,
+		_entry = CmdrClient.Gui.Frame:WaitForChild("Entry") :: Frame,
+
+		Items = {},
+		SelectedItem = 1,
+
+		Prefix = "",
+		LastItem = false,
+
+		Command = nil,
+		Arg = nil,
+		NumArgs = nil,
+		IsPartial = false,
+	}
+
+	-- Updates the size of the container.
+	const function updateContainerSize()
+		const titleWidth = AutoComplete._title.Field.TextBounds.X
+		const typeWidth = AutoComplete._title.Field.Type.TextBounds.X
+		const frameWidth = autoCompleteFrame.Size.X.Offset
+
+		const availableHeight = autoCompleteFrame.Parent.AbsoluteSize.Y - autoCompleteFrame.AbsolutePosition.Y - 10
+		const contentHeight = autoCompleteFrame.UIListLayout.AbsoluteContentSize.Y
+
+		const xOffset = math.max(titleWidth + typeWidth, frameWidth)
+		const yOffset = math.min(contentHeight, availableHeight)
+		autoCompleteFrame.Size = UDim2.fromOffset(xOffset, yOffset)
+	end
+
+	--[=[
+		@within AutoComplete
+		@private
+
+		Updates the position of the container.
+	]=]
+	function AutoComplete:_updateContainerPosition(offset: number?)
+		const entryPosition = self._entry.TextBox.AbsolutePosition
+		const xOffset = if offset then entryPosition.X - 10 + offset else entryPosition.X
+		const yOffset = entryPosition.Y + 30
+		autoCompleteFrame.Position = UDim2.fromOffset(xOffset, yOffset)
+	end
+
+	--[=[
+		@within AutoComplete
+		@private
+
+		Sets the text of the provided object.
+	]=]
+	function AutoComplete:_setText(object: GuiObject, textObject: TextLabel, text: string?, sizeFromContents: boolean)
+		object.Visible = text ~= nil
+		textObject.Text = text or ""
+
+		if sizeFromContents then
+			const textSize = CmdrClient.Util.GetTextSize(text or "", textObject, TEXT_MEASUREMENT_SIZE)
+			textObject.Size = UDim2.new(0, textSize.X, object.Size.Y.Scale, object.Size.Y.Offset)
+		end
+	end
+
+	--[=[
+		@within AutoComplete
+		@private
+
+		Updates the displayed auto completion info.
+	]=]
+	function AutoComplete:_updateInfoDisplay(options: any)
+		const typeName = options.type and `{options.type:sub(1, 1):upper()}{options.type:sub(2)}`
+		const typeText = typeName and `: {typeName}`
+		self:_setText(self._title, self._title.Field, options.name, true)
+		self:_setText(self._title.Field.Type, self._title.Field.Type, typeText)
+		self:_setText(self._description, self._description.Label, options.description)
+
+		self._description.Label.TextColor3 = if options.invalid then INVALID_TEXT_COLOR else VALID_TEXT_COLOR
+		self._description.Size = UDim2.new(1, 0, 0, 40)
+
+		while not self._description.Label.TextFits do
+			self._description.Size = self._description.Size + UDim2.fromOffset(0, 2)
+
+			if self._description.Size.Y.Offset > 500 then
+				break
+			end
+		end
+
+		task.wait()
+		updateContainerSize()
+		autoCompleteFrame.ScrollBarThickness = defaultBarThickness
+	end
+
+	--[=[
+		@within AutoComplete
+		Shows the autocomplete menu.
+	]=]
+	function AutoComplete:Show(items: any, options: any)
+		options = options or {}
+
+		for _, item in ipairs(self.Items) do
+			if item.gui then
+				item.gui:Destroy()
+			end
+		end
+
+		self.SelectedItem = 1
+		self.Items = items
+
+		self.Prefix = options.prefix or ""
+		self.LastItem = options.isLast or false
+
+		self.Command = options.command
+		self.Arg = options.arg
+		self.NumArgs = options.numArgs
+		self.IsPartial = options.isPartial
+
+		local autocompleteWidth = 200
+		autoCompleteFrame.ScrollBarThickness = 0
+
+		for index, item in ipairs(items) do
+			const typedText = item[1]
+			const suggestionText = item[2]
+			const button = self._autoItem:Clone()
+			button.Name = `{typedText}{suggestionText}`
+			button.BackgroundTransparency = if index == self.SelectedItem then 0.5 else 1
+
+			local start, stop = suggestionText:lower():find(typedText:lower(), 1, true)
+			if not start then
+				start = 1
+				stop = #suggestionText
+			end
+
+			const prefix = suggestionText:sub(1, start - 1)
+			const suffix = suggestionText:sub(stop + 1)
+			button.Typed.Text = `{(" "):rep(start - 1)}{typedText}`
+			button.Suggest.Text = `{prefix}{(" "):rep(#typedText)}{suffix}`
+
+			button.LayoutOrder = index
+			button.Parent = autoCompleteFrame
+
+			const maxBounds = math.max(button.Typed.TextBounds.X, button.Suggest.TextBounds.X) + 20
+			autocompleteWidth = math.max(autocompleteWidth, maxBounds)
+
+			item.gui = button
+		end
+
+		const text = self._entry.TextBox.Text
+		const words = CmdrClient.Util.SplitString(text)
+		if text:sub(#text, #text) == " " and not options.at then
+			words[#words + 1] = "e"
+		end
+
+		table.remove(words, #words)
+
+		const positionOffset = (options.at or (#table.concat(words, " ") + 1)) * 7
+		const sizeOffset = UDim2.fromOffset(autocompleteWidth, autoCompleteFrame.UIListLayout.AbsoluteContentSize.Y)
+		self:_updateContainerPosition(positionOffset)
+		autoCompleteFrame.Size = sizeOffset
+		autoCompleteFrame.Visible = true
+
+		self:_updateInfoDisplay(if self.Items[1] and self.Items[1].options then self.Items[1].options else options)
+	end
+
+	--[=[
+		@within AutoComplete
+		Returns the selected autocomplete item.
+	]=]
+	function AutoComplete:GetSelectedItem()
+		if not autoCompleteFrame.Visible then
+			return nil
+		end
+
+		return self.Items[self.SelectedItem]
+	end
+
+	--[=[
+		@within AutoComplete
+		Hides the autocomplete menu.
+	]=]
+	function AutoComplete:Hide()
+		autoCompleteFrame.Visible = false
+	end
+
+	--[=[
+		@within AutoComplete
+		Returns whether autocomplete is visible.
+	]=]
+	function AutoComplete:IsVisible()
+		return autoCompleteFrame.Visible
+	end
+
+	--[=[
+		@within AutoComplete
+		Changes the current selection.
+	]=]
+	function AutoComplete:Select(delta: number)
+		if not autoCompleteFrame.Visible then
+			return
+		end
+
+		self.SelectedItem += delta
+
+		if self.SelectedItem > #self.Items then
+			self.SelectedItem = 1
+		elseif self.SelectedItem < 1 then
+			self.SelectedItem = #self.Items
+		end
+
+		for index, item in ipairs(self.Items) do
+			item.gui.BackgroundTransparency = if index == self.SelectedItem then 0.5 else 1
+		end
+
+		const headerHeight = self._title.Size.Y.Offset + self._description.Size.Y.Offset
+		const itemPosition = self.SelectedItem * self._autoItem.Size.Y.Offset
+		const ySize = headerHeight + itemPosition - autoCompleteFrame.Size.Y.Offset
+		autoCompleteFrame.CanvasPosition = Vector2.new(0, math.max(0, ySize))
+
+		const selectedItem = self.Items[self.SelectedItem]
+		if selectedItem and selectedItem.options then
+			self:_updateInfoDisplay(selectedItem.options)
+		end
+	end
+
+	AutoComplete._autoItem.Parent = nil
+	autoCompleteFrame:GetPropertyChangedSignal("AbsoluteSize"):Connect(updateContainerSize)
+
+	return AutoComplete
+end