cluaupp 1.0.0 → 1.4.0

package/runtime/Cmdr/BuiltInCommands/help.luau

@@ -1,96 +0,0 @@
-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

@@ -1,258 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,111 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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