cluaupp 0.1.0

package/runtime/Cmdr/BuiltInCommands/help.luau

@@ -0,0 +1,96 @@
+const COMMAND_COLOR = Color3.fromRGB(230, 126, 34)
+const TEXT_COLOR = Color3.fromRGB(230, 230, 230)
+
+const ARGUMENT_SHORTHANDS = [[
+Argument Shorthands
+-------------------
+.   Me/Self
+*   All/Everyone
+**  Others
+?   Random
+?N  List of N random values
+]]
+
+const TIPS = [[
+Tips
+----
+• Use the Tab key to autocomplete commands and suggestions
+• Easily select and copy command output
+]]
+
+return {
+	Name = "help",
+	Aliases = { "cmds", "commands" },
+	Description = "Displays a list of all commands, or inspects one command.",
+	Group = "Help",
+
+	Args = {
+		{
+			Type = "command",
+			Name = "Command",
+			Description = "The command to view information on.",
+			Optional = true,
+		},
+	},
+
+	ClientRun = function(context: any, commandName: string?): string
+		const registry = context.Cmdr.Registry
+		if commandName then
+			const command = registry:GetCommand(commandName)
+			context:Reply(`Command: {command.Name}`, COMMAND_COLOR)
+
+			if command.Aliases and #command.Aliases > 0 then
+				context:Reply(`Aliases: {table.concat(command.Aliases, ", ")}`, TEXT_COLOR)
+			end
+
+			if command.Description then
+				context:Reply(`Description: {command.Description}`, TEXT_COLOR)
+			end
+
+			if command.Group then
+				context:Reply(`Group: {command.Group}`, TEXT_COLOR)
+			end
+
+			if command.Args then
+				for index, argument in ipairs(command.Args) do
+					if type(argument) == "table" then
+						const optional = if argument.Optional then "?" else ""
+
+						context:Reply(`#{index} {argument.Name}{optional}: {argument.Type} - {argument.Description}`)
+					else
+						context:Reply(`#{index} Unknown (inline argument)`)
+					end
+				end
+			end
+		else
+			context:Reply(ARGUMENT_SHORTHANDS)
+			context:Reply(TIPS)
+
+			const commands = registry:GetCommands()
+			table.sort(commands, function(a, b)
+				if a.Group and b.Group then
+					return a.Group < b.Group
+				end
+
+				return a.Group ~= nil
+			end)
+
+			local lastGroup
+			for _, command in ipairs(commands) do
+				if command._isHidden then
+					continue
+				end
+
+				const group = command.Group or "No Group"
+				if lastGroup ~= group then
+					context:Reply(`\n{group}\n{("-"):rep(#group)}`)
+					lastGroup = group
+				end
+
+				context:Reply(if command.Description then `{command.Name} - {command.Description}` else command.Name)
+			end
+		end
+
+		return ""
+	end,
+}

package/runtime/Cmdr/BuiltInTypes/BrickColor.luau

@@ -0,0 +1,258 @@
+const BRICK_COLOR_NAMES = {
+	"White",
+	"Grey",
+	"Light yellow",
+	"Brick yellow",
+	"Light green (Mint)",
+	"Light reddish violet",
+	"Pastel Blue",
+	"Light orange brown",
+	"Nougat",
+	"Bright red",
+	"Med. reddish violet",
+	"Bright blue",
+	"Bright yellow",
+	"Earth orange",
+	"Black",
+	"Dark grey",
+	"Dark green",
+	"Medium green",
+	"Lig. Yellowich orange",
+	"Bright green",
+	"Dark orange",
+	"Light bluish violet",
+	"Transparent",
+	"Tr. Red",
+	"Tr. Lg blue",
+	"Tr. Blue",
+	"Tr. Yellow",
+	"Light blue",
+	"Tr. Flu. Reddish orange",
+	"Tr. Green",
+	"Tr. Flu. Green",
+	"Phosph. White",
+	"Light red",
+	"Medium red",
+	"Medium blue",
+	"Light grey",
+	"Bright violet",
+	"Br. yellowish orange",
+	"Bright orange",
+	"Bright bluish green",
+	"Earth yellow",
+	"Bright bluish violet",
+	"Tr. Brown",
+	"Medium bluish violet",
+	"Tr. Medi. reddish violet",
+	"Med. yellowish green",
+	"Med. bluish green",
+	"Light bluish green",
+	"Br. yellowish green",
+	"Lig. yellowish green",
+	"Med. yellowish orange",
+	"Br. reddish orange",
+	"Bright reddish violet",
+	"Light orange",
+	"Tr. Bright bluish violet",
+	"Gold",
+	"Dark nougat",
+	"Silver",
+	"Neon orange",
+	"Neon green",
+	"Sand blue",
+	"Sand violet",
+	"Medium orange",
+	"Sand yellow",
+	"Earth blue",
+	"Earth green",
+	"Tr. Flu. Blue",
+	"Sand blue metallic",
+	"Sand violet metallic",
+	"Sand yellow metallic",
+	"Dark grey metallic",
+	"Black metallic",
+	"Light grey metallic",
+	"Sand green",
+	"Sand red",
+	"Dark red",
+	"Tr. Flu. Yellow",
+	"Tr. Flu. Red",
+	"Gun metallic",
+	"Red flip/flop",
+	"Yellow flip/flop",
+	"Silver flip/flop",
+	"Curry",
+	"Fire Yellow",
+	"Flame yellowish orange",
+	"Reddish brown",
+	"Flame reddish orange",
+	"Medium stone grey",
+	"Royal blue",
+	"Dark Royal blue",
+	"Bright reddish lilac",
+	"Dark stone grey",
+	"Lemon metalic",
+	"Light stone grey",
+	"Dark Curry",
+	"Faded green",
+	"Turquoise",
+	"Light Royal blue",
+	"Medium Royal blue",
+	"Rust",
+	"Brown",
+	"Reddish lilac",
+	"Lilac",
+	"Light lilac",
+	"Bright purple",
+	"Light purple",
+	"Light pink",
+	"Light brick yellow",
+	"Warm yellowish orange",
+	"Cool yellow",
+	"Dove blue",
+	"Medium lilac",
+	"Slime green",
+	"Smoky grey",
+	"Dark blue",
+	"Parsley green",
+	"Steel blue",
+	"Storm blue",
+	"Lapis",
+	"Dark indigo",
+	"Sea green",
+	"Shamrock",
+	"Fossil",
+	"Mulberry",
+	"Forest green",
+	"Cadet blue",
+	"Electric blue",
+	"Eggplant",
+	"Moss",
+	"Artichoke",
+	"Sage green",
+	"Ghost grey",
+	"Lilac",
+	"Plum",
+	"Olivine",
+	"Laurel green",
+	"Quill grey",
+	"Crimson",
+	"Mint",
+	"Baby blue",
+	"Carnation pink",
+	"Persimmon",
+	"Maroon",
+	"Gold",
+	"Daisy orange",
+	"Pearl",
+	"Fog",
+	"Salmon",
+	"Terra Cotta",
+	"Cocoa",
+	"Wheat",
+	"Buttermilk",
+	"Mauve",
+	"Sunrise",
+	"Tawny",
+	"Rust",
+	"Cashmere",
+	"Khaki",
+	"Lily white",
+	"Seashell",
+	"Burgundy",
+	"Cork",
+	"Burlap",
+	"Beige",
+	"Oyster",
+	"Pine Cone",
+	"Fawn brown",
+	"Hurricane grey",
+	"Cloudy grey",
+	"Linen",
+	"Copper",
+	"Dirt brown",
+	"Bronze",
+	"Flint",
+	"Dark taupe",
+	"Burnt Sienna",
+	"Institutional white",
+	"Mid gray",
+	"Really black",
+	"Really red",
+	"Deep orange",
+	"Alder",
+	"Dusty Rose",
+	"Olive",
+	"New Yeller",
+	"Really blue",
+	"Navy blue",
+	"Deep blue",
+	"Cyan",
+	"CGA brown",
+	"Magenta",
+	"Pink",
+	"Deep orange",
+	"Teal",
+	"Toothpaste",
+	"Lime green",
+	"Camo",
+	"Grime",
+	"Lavender",
+	"Pastel light blue",
+	"Pastel orange",
+	"Pastel violet",
+	"Pastel blue-green",
+	"Pastel green",
+	"Pastel yellow",
+	"Pastel brown",
+	"Royal purple",
+	"Hot pink",
+}
+
+return function(registry: any)
+	const brickColorFinder = registry.Cmdr.Util.MakeFuzzyFinder(BRICK_COLOR_NAMES)
+	const brickColorType = {
+		Prefixes = "% teamColor",
+
+		Transform = function(text: string): { [number]: BrickColor }
+			const brickColors = {}
+
+			for index: number, name: string in pairs(brickColorFinder(text)) do
+				brickColors[index] = BrickColor.new(name :: any) --< BrickColor.new gets overloaded
+			end
+
+			return brickColors
+		end,
+
+		Validate = function(brickColors: { [number]: BrickColor }): (boolean, string?)
+			return #brickColors > 0, "No valid brick colors with that name could be found."
+		end,
+
+		Autocomplete = function(brickColors: { [number]: BrickColor }): { string }
+			return registry.Cmdr.Util.GetNames(brickColors)
+		end,
+
+		Parse = function(brickColors: { [number]: BrickColor }): BrickColor
+			return brickColors[1]
+		end,
+	}
+
+	const brickColor3Type = {
+		Transform = brickColorType.Transform,
+		Validate = brickColorType.Validate,
+		Autocomplete = brickColorType.Autocomplete,
+
+		Parse = function(brickColors: { [number]: BrickColor }): Color3
+			return brickColors[1].Color
+		end,
+	}
+
+	registry:RegisterType("brickColor", brickColorType)
+	registry:RegisterType(
+		"brickColors",
+		registry.Cmdr.Util.MakeListableType(brickColorType, { Prefixes = "% teamColors" })
+	)
+
+	registry:RegisterType("brickColor3", brickColor3Type)
+	registry:RegisterType("brickColor3s", registry.Cmdr.Util.MakeListableType(brickColor3Type))
+end

package/runtime/Cmdr/BuiltInTypes/Color3.luau

@@ -0,0 +1,59 @@
+const function parseHexDigit(x: string?): number?
+	if not x then
+		return nil
+	end
+
+	if #x == 1 then
+		x = `{x}{x}`
+	end
+
+	return tonumber(x, 16)
+end
+
+return function(registry: any)
+	const color3Type = registry.Cmdr.Util.MakeSequenceType({
+		Prefixes = "# hexColor3 ! brickColor3",
+		ValidateEach = function(value: number?, index: number): (boolean, string?)
+			if value == nil then
+				return false, `Invalid or missing number at position {index} in Color3 type.`
+			elseif value < 0 or value > 255 then
+				return false, `Number out of acceptable range 0-255 at position {index} in Color3 type.`
+			elseif value % 1 ~= 0 then
+				return false, `Number is not an integer at position {index} in Color3 type.`
+			end
+
+			return true
+		end,
+
+		TransformEach = function(value: string): number?
+			return tonumber(value)
+		end,
+
+		Constructor = Color3.fromRGB,
+		Length = 3,
+	})
+
+	const hexColor3Type = {
+		Transform = function(text: string): (number?, number?, number?)
+			const r, g, b = text:match("^#?(%x%x?)(%x%x?)(%x%x?)$")
+			return registry.Cmdr.Util.Each(parseHexDigit, r, g, b)
+		end,
+
+		Validate = function(r: number?, g: number?, b: number?): (boolean, string?)
+			return r ~= nil and g ~= nil and b ~= nil, "Invalid hex color"
+		end,
+
+		Parse = function(r: number, g: number, b: number): Color3
+			return Color3.fromRGB(r, g, b)
+		end,
+	}
+
+	registry:RegisterType("color3", color3Type)
+	registry:RegisterType(
+		"color3s",
+		registry.Cmdr.Util.MakeListableType(color3Type, { Prefixes = "# hexColor3s ! brickColor3s" })
+	)
+
+	registry:RegisterType("hexColor3", hexColor3Type)
+	registry:RegisterType("hexColor3s", registry.Cmdr.Util.MakeListableType(hexColor3Type))
+end

package/runtime/Cmdr/BuiltInTypes/Command.luau

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

package/runtime/Cmdr/BuiltInTypes/Duration.luau

@@ -0,0 +1,111 @@
+const UNIT_SECONDS: { [string]: number } = {
+	Years = 31556926,
+	Months = 2629744,
+	Weeks = 604800,
+	Days = 86400,
+	Hours = 3600,
+	Minutes = 60,
+	Seconds = 1,
+}
+
+const unitNames: { string } = {}
+for unitName: string in pairs(UNIT_SECONDS) do
+	unitNames[#unitNames + 1] = unitName
+end
+
+const function mapUnits(units: { string }, rawText: string, lastNumber: number?, startIndex: number?): { string }
+	const start: number = startIndex or 1
+	const results: { string } = {}
+
+	for index: number, unit: string in ipairs(units) do
+		results[index] = `{rawText}{if lastNumber == 1 then unit:sub(start, #unit - 1) else unit:sub(start)}`
+	end
+
+	return results
+end
+
+return function(registry: any)
+	const unitFinder = registry.Cmdr.Util.MakeFuzzyFinder(unitNames)
+	const function stringToSecondDuration(text: string): (number?, number?, boolean?)
+		if text == nil or text == "" then
+			return nil
+		end
+
+		const number = tonumber(text)
+		if number == 0 then
+			return 0, 0, true
+		end
+
+		const numberOnly = text:gsub("-?%d+%a+", "")
+		const missingUnit = numberOnly:match("-?%d+")
+
+		if missingUnit then
+			return nil, tonumber(missingUnit), true
+		end
+
+		local seconds: number = 0
+		local lastNumber: number?
+
+		for component: string in text:gmatch("-?%d+%a+") do
+			const rawNumber, rawUnit = component:match("(-?%d+)(%a+)")
+			if rawNumber == nil or rawUnit == nil then
+				continue
+			end
+
+			lastNumber = tonumber(rawNumber)
+
+			const matches: { string } = unitFinder(rawUnit, false, true)
+
+			if #matches == 0 then
+				return nil, lastNumber
+			end
+
+			const unit: number = if rawUnit:lower() == "m" then 60 else UNIT_SECONDS[matches[1]]
+			seconds += unit * (lastNumber :: number)
+		end
+
+		if seconds == 0 then
+			return nil
+		end
+
+		return seconds, lastNumber
+	end
+
+	const durationType = {
+		Transform = function(text: string): (string, number?, number?, boolean?)
+			return text, stringToSecondDuration(text)
+		end,
+
+		Validate = function(_, duration: number?): (boolean, string?)
+			return duration ~= nil, "Invalid duration format. Example: 1d6h, 30m, 10s."
+		end,
+
+		Autocomplete = function(
+			rawText: string,
+			duration: number?,
+			lastNumber: number?,
+			missingUnit: boolean?
+		): { string }
+			local results: { string } = {}
+			if missingUnit then
+				const units: { string } = unitFinder("", false, true)
+				results = mapUnits(units, rawText, lastNumber)
+			elseif duration ~= nil then
+				const endingUnit = rawText:match("^.*-?%d+(%a+)%s?$")
+				const matches: { string } = unitFinder(endingUnit, false, true)
+
+				results = mapUnits(matches, rawText, lastNumber, #endingUnit + 1)
+				table.sort(results)
+			end
+
+			return results
+		end,
+
+		Parse = function(_, duration: number): number
+			return duration
+		end,
+	}
+
+	registry:RegisterType("duration", durationType)
+	registry:RegisterType("durations", registry.Cmdr.Util.MakeListableType(durationType))
+end

package/runtime/Cmdr/BuiltInTypes/JSON.luau

@@ -0,0 +1,13 @@
+const HttpService = game:GetService("HttpService")
+
+return function(registry: any)
+	registry:RegisterType("json", {
+		Validate = function(text: string): boolean
+			return pcall(HttpService.JSONDecode, HttpService, text)
+		end,
+
+		Parse = function(text: string): { [string]: any } | any
+			return HttpService:JSONDecode(text)
+		end,
+	})
+end

package/runtime/Cmdr/BuiltInTypes/MathOperator.luau

@@ -0,0 +1,43 @@
+return function(registry: any)
+	registry:RegisterType(
+		"mathOperator",
+		registry.Cmdr.Util.MakeEnumType("Math Operator", {
+			{
+				Name = "+",
+				Perform = function(a: number, b: number): number
+					return a + b
+				end,
+			},
+			{
+				Name = "-",
+				Perform = function(a: number, b: number): number
+					return a - b
+				end,
+			},
+			{
+				Name = "*",
+				Perform = function(a: number, b: number): number
+					return a * b
+				end,
+			},
+			{
+				Name = "/",
+				Perform = function(a: number, b: number): number
+					return a / b
+				end,
+			},
+			{
+				Name = "**",
+				Perform = function(a: number, b: number): number
+					return a ^ b
+				end,
+			},
+			{
+				Name = "%",
+				Perform = function(a: number, b: number): number
+					return a % b
+				end,
+			},
+		})
+	)
+end

package/runtime/Cmdr/BuiltInTypes/Player.luau

@@ -0,0 +1,36 @@
+const Players = game:GetService("Players")
+
+return function(registry: any)
+	const playerType = {
+		Transform = function(text: string): { Player }
+			const findPlayer = registry.Cmdr.Util.MakeFuzzyFinder(Players:GetPlayers())
+			return findPlayer(text)
+		end,
+
+		Validate = function(players: { Player }): (boolean, string?)
+			return #players > 0, "No player with that name could be found."
+		end,
+
+		Autocomplete = function(players: { Player }): { string }
+			return registry.Cmdr.Util.GetNames(players)
+		end,
+
+		Parse = function(players: { Player }): Player?
+			return players[1]
+		end,
+
+		Default = function(player: Player): string
+			return player.Name
+		end,
+
+		ArgumentOperatorAliases = {
+			me = ".",
+			all = "*",
+			others = "**",
+			random = "?",
+		},
+	}
+
+	registry:RegisterType("player", playerType)
+	registry:RegisterType("players", registry.Cmdr.Util.MakeListableType(playerType, { Prefixes = "% teamPlayers" }))
+end

package/runtime/Cmdr/BuiltInTypes/PlayerId.luau

@@ -0,0 +1,66 @@
+const Players = game:GetService("Players")
+
+const nameCache: { [string]: number } = {}
+
+const function getUserId(username: string): number?
+	username = username:match("%(@([^%)]+)%)") or username
+
+	if nameCache[username] then
+		return nameCache[username]
+	elseif Players:FindFirstChild(username) then
+		const player = Players[username] :: Player
+
+		nameCache[username] = player.UserId
+		return player.UserId
+	else
+		const success, userid = pcall(Players.GetUserIdFromNameAsync, Players, username)
+
+		if not success then
+			return nil
+		end
+
+		nameCache[username] = userid
+		return userid
+	end
+end
+
+return function(registry: any)
+	const playerIdType = {
+		DisplayName = "Full Player Name",
+		Prefixes = "# positiveInteger",
+
+		Transform = function(text: string): (string, { Player })
+			const findPlayer = registry.Cmdr.Util.MakeFuzzyFinder(Players:GetPlayers())
+			return text, findPlayer(text)
+		end,
+
+		ValidateOnce = function(text: string): (boolean, string?)
+			return getUserId(text) ~= nil, "No player with that name could be found."
+		end,
+
+		Autocomplete = function(_, players: { Player }): { string }
+			return registry.Cmdr.Util.GetNames(players)
+		end,
+
+		Parse = function(text: string): number?
+			return getUserId(text)
+		end,
+
+		Default = function(player: Player): string
+			return player.Name
+		end,
+
+		ArgumentOperatorAliases = {
+			me = ".",
+			all = "*",
+			others = "**",
+			random = "?",
+		},
+	}
+
+	registry:RegisterType("playerId", playerIdType)
+	registry:RegisterType(
+		"playerIds",
+		registry.Cmdr.Util.MakeListableType(playerIdType, { Prefixes = "# positiveIntegers" })
+	)
+end