cluaupp 1.4.1 → 1.5.1

package/examples/game/libs/Mint/init.luau

@@ -0,0 +1,279 @@
+--!native
+--!optimize 2
+--!strict
+-- Mint — Cluaupp number display. Schema .mint bakes formatters; this kernel is the fallback.
+-- Codegen (compileMint): Mint.Compact(value, { Fraction, Suffixes = { {threshold, label} } }),
+-- Mint.Percent(value, fraction), Mint.Group(value, fraction). Do not rename those.
+
+local Mint = {}
+
+local DEFAULT_SUFFIXES = {
+	"K",
+	"M",
+	"B",
+	"T",
+	"Qa",
+	"Qi",
+	"Sx",
+	"Sp",
+	"Oc",
+	"No",
+	"Dc",
+	"Ud",
+	"Dd",
+	"Td",
+	"Qad",
+	"Qid",
+	"Sxd",
+	"Spd",
+	"Ocd",
+	"Nod",
+	"Vg",
+	"Uvg",
+	"Dvg",
+	"Tvg",
+	"Qavg",
+	"Qivg",
+	"Sxvg",
+	"Spvg",
+	"Ocvg",
+	"Novg",
+}
+
+export type SuffixPair = { number | string }
+export type SuffixList = { SuffixPair }
+export type CompactOptions = { Fraction: number?, Suffixes: SuffixList? }
+
+local function isFinite(value: number): boolean
+	return value == value and value ~= math.huge and value ~= -math.huge
+end
+
+local function special(value: number): string?
+	if value == value then
+		if value == math.huge then
+			return "∞"
+		end
+		if value == -math.huge then
+			return "-∞"
+		end
+		return nil
+	end
+	return "NaN"
+end
+
+local function group(digits: string): string
+	local sign = ""
+	if string.sub(digits, 1, 1) == "-" then
+		sign = "-"
+		digits = string.sub(digits, 2)
+	end
+	local whole, frac = string.match(digits, "^(%d+)(%.%d+)$")
+	if not whole then
+		whole = digits
+		frac = ""
+	end
+	local built = {}
+	local n = #whole
+	local start = n % 3
+	if start == 0 then
+		start = 3
+	end
+	table.insert(built, string.sub(whole, 1, start))
+	for i = start + 1, n, 3 do
+		table.insert(built, string.sub(whole, i, i + 2))
+	end
+	return sign .. table.concat(built, ",") .. frac
+end
+
+local function trimFraction(value: number, places: number): string
+	if not isFinite(value) then
+		return special(value) :: string
+	end
+	if places <= 0 then
+		return tostring(math.floor(value + (if value >= 0 then 0.5 else -0.5)))
+	end
+	local m = 10 ^ places
+	local rounded = math.floor(value * m + (if value >= 0 then 0.5 else -0.5)) / m
+	local text = string.format("%." .. places .. "f", rounded)
+	text = string.gsub(text, "%.?0+$", "")
+	return text
+end
+
+function Mint.Suffixes(labels: { string }): SuffixList
+	local baked: SuffixList = {}
+	for i, label in labels do
+		table.insert(baked, { 10 ^ (i * 3), label })
+	end
+	return baked
+end
+
+local function defaultSuffixes(): SuffixList
+	return Mint.Suffixes(DEFAULT_SUFFIXES)
+end
+
+local function asSuffixList(suffixes: SuffixList?): SuffixList
+	if suffixes == nil then
+		return defaultSuffixes()
+	end
+	if #suffixes == 0 then
+		return suffixes
+	end
+	if type(suffixes[1]) == "string" then
+		return Mint.Suffixes(suffixes :: any)
+	end
+	return suffixes
+end
+
+function Mint.Group(value: number, fraction: number?): string
+	local text = special(value)
+	if text then
+		return text
+	end
+	local places = fraction or 0
+	return group(trimFraction(value, places))
+end
+
+function Mint.Comma(value: number): string
+	return Mint.Group(value, 0)
+end
+
+function Mint.Compact(value: number, options: (CompactOptions | number)?): string
+	local text = special(value)
+	if text then
+		return text
+	end
+	local sign = if value < 0 then "-" else ""
+	local n = math.abs(value)
+	local fraction = 1
+	local suffixInput: SuffixList? = nil
+	if type(options) == "number" then
+		fraction = options
+	elseif type(options) == "table" then
+		fraction = (options :: CompactOptions).Fraction or 1
+		suffixInput = (options :: CompactOptions).Suffixes
+	end
+	local suffixes = asSuffixList(suffixInput)
+	local chosen: SuffixPair? = nil
+	local best = 0
+	for i = 1, #suffixes do
+		local threshold = suffixes[i][1] :: number
+		if threshold > 0 and n >= threshold and threshold >= best then
+			best = threshold
+			chosen = suffixes[i]
+		end
+	end
+	if not chosen then
+		return sign .. trimFraction(n, fraction)
+	end
+	local scaled = n / (chosen[1] :: number)
+	local places = 10 ^ fraction
+	scaled = math.floor(scaled * places) / places
+	return sign .. trimFraction(scaled, fraction) .. (chosen[2] :: string)
+end
+
+function Mint.Abbreviate(value: number, digits: number?): string
+	return Mint.Compact(value, { Fraction = digits or 1 })
+end
+
+function Mint.Percent(value: number, fraction: number?): string
+	local text = special(value)
+	if text then
+		return text
+	end
+	return trimFraction(value * 100, fraction or 1) .. "%"
+end
+
+function Mint.Scientific(value: number, fraction: number?): string
+	local text = special(value)
+	if text then
+		return text
+	end
+	local places = fraction or 1
+	if value == 0 then
+		return "0e+0"
+	end
+	local sign = if value < 0 then "-" else ""
+	local n = math.abs(value)
+	local exp = math.floor(math.log(n, 10))
+	local mantissa = n / (10 ^ exp)
+	if places <= 0 then
+		mantissa = math.floor(mantissa + 0.5)
+	else
+		local m = 10 ^ places
+		mantissa = math.floor(mantissa * m + 0.5) / m
+	end
+	if mantissa >= 10 then
+		mantissa /= 10
+		exp += 1
+	end
+	local expSign = if exp >= 0 then "+" else ""
+	return sign .. trimFraction(mantissa, places) .. "e" .. expSign .. tostring(exp)
+end
+
+function Mint.To(value: number, fraction: number?): string
+	return Mint.Group(value, fraction)
+end
+
+local function suffixFactor(label: string, suffixes: SuffixList): number?
+	if label == "" then
+		return nil
+	end
+	local lower = string.lower(label)
+	for i = #suffixes, 1, -1 do
+		local pair = suffixes[i]
+		local name = pair[2] :: string
+		if name and string.lower(name) == lower then
+			return pair[1] :: number
+		end
+	end
+	return nil
+end
+
+function Mint.From(text: string, suffixes: SuffixList?): number
+	local trimmed = string.gsub(string.gsub(text, "^%s+", ""), "%s+$", "")
+	if trimmed == "" then
+		return 0 / 0
+	end
+	if trimmed == "NaN" or trimmed == "nan" then
+		return 0 / 0
+	end
+	if trimmed == "∞" or trimmed == "inf" or trimmed == "Inf" or trimmed == "Infinity" then
+		return math.huge
+	end
+	if trimmed == "-∞" or trimmed == "-inf" or trimmed == "-Inf" or trimmed == "-Infinity" then
+		return -math.huge
+	end
+	local percent = false
+	if string.sub(trimmed, -1) == "%" then
+		percent = true
+		trimmed = string.sub(trimmed, 1, -2)
+	end
+	local stripped = string.gsub(trimmed, ",", "")
+	local numberPart, suffixPart = string.match(stripped, "^([%+%-]?%d*%.?%d+[eE][%+%-]?%d+)(.*)$")
+	if not numberPart then
+		numberPart, suffixPart = string.match(stripped, "^([%+%-]?%d*%.?%d+)(.*)$")
+	end
+	if not numberPart then
+		return 0 / 0
+	end
+	local n = tonumber(numberPart)
+	if not n then
+		return 0 / 0
+	end
+	suffixPart = string.gsub(suffixPart or "", "%s+", "")
+	if suffixPart ~= "" then
+		local factor = suffixFactor(suffixPart, asSuffixList(suffixes))
+		if not factor then
+			return 0 / 0
+		end
+		n *= factor
+	end
+	if percent then
+		n /= 100
+	end
+	return n
+end
+
+Mint.Format = Mint.Group
+
+return Mint

package/examples/game/libs/Net/init.luau

@@ -0,0 +1,156 @@
+--!strict
+--[=[
+	@class Net
+	Buffer-packed RemoteEvent / RemoteFunction. Public API is generic; the codec is internal.
+]=]
+local RunService = game:GetService("RunService")
+local ReplicatedStorage = game:GetService("ReplicatedStorage")
+local codec = require(script.src.codec)
+local Ward = require(script.Parent.Ward)
+
+export type Event<T...> = {
+	Fire: (self: Event<T...>, player: Player, T...) -> (),
+	FireAll: (self: Event<T...>, T...) -> (),
+	FireServer: (self: Event<T...>, T...) -> (),
+	On: (self: Event<T...>, callback: (Player?, T...) -> ()) -> RBXScriptConnection,
+}
+
+export type Function<R, T...> = {
+	On: (self: Function<R, T...>, callback: (Player?, T...) -> R) -> (),
+	Invoke: (self: Function<R, T...>, player: Player, T...) -> R,
+	InvokeServer: (self: Function<R, T...>, T...) -> R,
+}
+
+local function folder(): Folder
+	local existing = ReplicatedStorage:FindFirstChild("CluauppNet")
+	if existing and existing:IsA("Folder") then
+		return existing
+	end
+	local created = Instance.new("Folder")
+	created.Name = "CluauppNet"
+	created.Parent = ReplicatedStorage
+	return created
+end
+
+local function remote(kind: "RemoteEvent" | "RemoteFunction", name: string): Instance
+	local parent = folder()
+	local existing = parent:FindFirstChild(name)
+	if existing then
+		return existing
+	end
+	if RunService:IsServer() then
+		local inst = Instance.new(kind)
+		inst.Name = name
+		inst.Parent = parent
+		return inst
+	end
+	return parent:WaitForChild(name)
+end
+
+local Event = {}
+Event.__index = Event
+
+function Event.new<T...>(name: string): Event<T...>
+	return setmetatable({ _name = name, _remote = remote("RemoteEvent", name) :: RemoteEvent }, Event) :: Event<T...>
+end
+
+function Event:Fire<T...>(player: Player, ...: T...)
+	assert(RunService:IsServer(), "Net.Event:Fire is server-only")
+	self._remote:FireClient(player, codec.encode({ ... }))
+end
+
+function Event:FireAll<T...>(...: T...)
+	assert(RunService:IsServer(), "Net.Event:FireAll is server-only")
+	self._remote:FireAllClients(codec.encode({ ... }))
+end
+
+function Event:FireServer<T...>(...: T...)
+	assert(RunService:IsClient(), "Net.Event:FireServer is client-only")
+	self._remote:FireServer(codec.encode({ ... }))
+end
+
+function Event:On<T...>(callback: (Player?, T...) -> ()): RBXScriptConnection
+	if RunService:IsServer() then
+		return self._remote.OnServerEvent:Connect(function(player: Player, payload: buffer)
+			if typeof(payload) ~= "buffer" then
+				Ward.Strike(player, "net:type")
+				return
+			end
+			if not Ward.Packet(player, buffer.len(payload)) then
+				return
+			end
+			if not Ward.Allow(player, "net:" .. self._name, 30, 60) then
+				return
+			end
+			local ok, decoded = pcall(codec.decode, payload)
+			if not ok or typeof(decoded) ~= "table" then
+				Ward.Strike(player, "net:decode")
+				return
+			end
+			callback(player, table.unpack(decoded))
+		end)
+	end
+	return self._remote.OnClientEvent:Connect(function(payload: buffer)
+		callback(nil, table.unpack(codec.decode(payload)))
+	end)
+end
+
+local Fn = {}
+Fn.__index = Fn
+
+function Fn.new<R, T...>(name: string): Function<R, T...>
+	return setmetatable({ _name = name, _remote = remote("RemoteFunction", name) :: RemoteFunction }, Fn) :: Function<R, T...>
+end
+
+function Fn:On<R, T...>(callback: (Player?, T...) -> R)
+	if RunService:IsServer() then
+		self._remote.OnServerInvoke = function(player: Player, payload: buffer)
+			if typeof(payload) ~= "buffer" then
+				Ward.Strike(player, "net:fn-type")
+				return codec.encode({})
+			end
+			if not Ward.Packet(player, buffer.len(payload)) then
+				return codec.encode({})
+			end
+			if not Ward.Allow(player, "netfn:" .. self._name, 10, 20) then
+				return codec.encode({})
+			end
+			local ok, decoded = pcall(codec.decode, payload)
+			if not ok or typeof(decoded) ~= "table" then
+				Ward.Strike(player, "net:fn-decode")
+				return codec.encode({})
+			end
+			return codec.encode({ callback(player, table.unpack(decoded)) })
+		end
+	else
+		self._remote.OnClientInvoke = function(payload: buffer)
+			return codec.encode({ callback(nil, table.unpack(codec.decode(payload))) })
+		end
+	end
+end
+
+function Fn:Invoke<R, T...>(player: Player, ...: T...): R
+	assert(RunService:IsServer(), "Net.Function:Invoke is server-only")
+	local reply = self._remote:InvokeClient(player, codec.encode({ ... }))
+	return table.unpack(codec.decode(reply)) :: R
+end
+
+function Fn:InvokeServer<R, T...>(...: T...): R
+	assert(RunService:IsClient(), "Net.Function:InvokeServer is client-only")
+	local reply = self._remote:InvokeServer(codec.encode({ ... }))
+	return table.unpack(codec.decode(reply)) :: R
+end
+
+local Net = {}
+
+function Net.Event<T...>(name: string): Event<T...>
+	return Event.new(name)
+end
+
+function Net.Function<R, T...>(name: string): Function<R, T...>
+	return Fn.new(name)
+end
+
+export type Net = typeof(Net)
+
+return Net

package/examples/game/libs/Net/src/codec.luau

@@ -0,0 +1,224 @@
+--!nonstrict
+-- Buffer codec for Net. Tagged values — never JSON on the hot path.
+
+local Players = game:GetService("Players")
+
+local TAG_NIL = 0
+local TAG_BOOL = 1
+local TAG_NUM = 2
+local TAG_STR = 3
+local TAG_V3 = 4
+local TAG_CF = 5
+local TAG_COL = 6
+local TAG_PLAYER = 7
+local TAG_TABLE = 8
+local TAG_V2 = 9
+local TAG_UDIM = 10
+local TAG_UDIM2 = 11
+
+local MAX_DEPTH = 16
+
+local estimate: (any, number) -> number
+local writeValue: (buffer, number, any, number) -> number
+local readValue: (buffer, number) -> (any, number)
+
+estimate = function(value, depth: number): number
+	if depth > MAX_DEPTH then
+		return 1
+	end
+	local kind = typeof(value)
+	if value == nil then
+		return 1
+	elseif kind == "boolean" then
+		return 2
+	elseif kind == "number" then
+		return 9
+	elseif kind == "string" then
+		return 5 + #value
+	elseif kind == "Vector3" then
+		return 25
+	elseif kind == "Vector2" then
+		return 17
+	elseif kind == "CFrame" then
+		return 1 + 96
+	elseif kind == "Color3" then
+		return 25
+	elseif kind == "UDim" then
+		return 13
+	elseif kind == "UDim2" then
+		return 25
+	elseif kind == "Instance" and value:IsA("Player") then
+		return 9
+	elseif kind == "table" then
+		local size = 5
+		for key, child in value do
+			size += estimate(key, depth + 1) + estimate(child, depth + 1)
+		end
+		return size
+	end
+	return 1
+end
+
+writeValue = function(buf: buffer, offset: number, value, depth: number): number
+	if depth > MAX_DEPTH then
+		buffer.writeu8(buf, offset, TAG_NIL)
+		return offset + 1
+	end
+	local kind = typeof(value)
+	if value == nil then
+		buffer.writeu8(buf, offset, TAG_NIL)
+		return offset + 1
+	elseif kind == "boolean" then
+		buffer.writeu8(buf, offset, TAG_BOOL)
+		buffer.writeu8(buf, offset + 1, if value then 1 else 0)
+		return offset + 2
+	elseif kind == "number" then
+		buffer.writeu8(buf, offset, TAG_NUM)
+		buffer.writef64(buf, offset + 1, value)
+		return offset + 9
+	elseif kind == "string" then
+		buffer.writeu8(buf, offset, TAG_STR)
+		buffer.writeu32(buf, offset + 1, #value)
+		buffer.writestring(buf, offset + 5, value)
+		return offset + 5 + #value
+	elseif kind == "Vector3" then
+		buffer.writeu8(buf, offset, TAG_V3)
+		buffer.writef64(buf, offset + 1, value.X)
+		buffer.writef64(buf, offset + 9, value.Y)
+		buffer.writef64(buf, offset + 17, value.Z)
+		return offset + 25
+	elseif kind == "Vector2" then
+		buffer.writeu8(buf, offset, TAG_V2)
+		buffer.writef64(buf, offset + 1, value.X)
+		buffer.writef64(buf, offset + 9, value.Y)
+		return offset + 17
+	elseif kind == "CFrame" then
+		buffer.writeu8(buf, offset, TAG_CF)
+		local components = { value:GetComponents() }
+		for i = 1, 12 do
+			buffer.writef64(buf, offset + 1 + (i - 1) * 8, components[i])
+		end
+		return offset + 1 + 96
+	elseif kind == "Color3" then
+		buffer.writeu8(buf, offset, TAG_COL)
+		buffer.writef64(buf, offset + 1, value.R)
+		buffer.writef64(buf, offset + 9, value.G)
+		buffer.writef64(buf, offset + 17, value.B)
+		return offset + 25
+	elseif kind == "UDim" then
+		buffer.writeu8(buf, offset, TAG_UDIM)
+		buffer.writef32(buf, offset + 1, value.Scale)
+		buffer.writei32(buf, offset + 5, value.Offset)
+		return offset + 13
+	elseif kind == "UDim2" then
+		buffer.writeu8(buf, offset, TAG_UDIM2)
+		buffer.writef32(buf, offset + 1, value.X.Scale)
+		buffer.writei32(buf, offset + 5, value.X.Offset)
+		buffer.writef32(buf, offset + 9, value.Y.Scale)
+		buffer.writei32(buf, offset + 13, value.Y.Offset)
+		return offset + 17
+	elseif kind == "Instance" and value:IsA("Player") then
+		buffer.writeu8(buf, offset, TAG_PLAYER)
+		buffer.writef64(buf, offset + 1, value.UserId)
+		return offset + 9
+	elseif kind == "table" then
+		local count = 0
+		for _ in value do
+			count += 1
+		end
+		buffer.writeu8(buf, offset, TAG_TABLE)
+		buffer.writeu32(buf, offset + 1, count)
+		offset += 5
+		for key, child in value do
+			offset = writeValue(buf, offset, key, depth + 1)
+			offset = writeValue(buf, offset, child, depth + 1)
+		end
+		return offset
+	end
+	buffer.writeu8(buf, offset, TAG_NIL)
+	return offset + 1
+end
+
+local function encode(values): buffer
+	local size = 1
+	for _, value in values do
+		size += estimate(value, 0)
+	end
+	local buf = buffer.create(size)
+	buffer.writeu8(buf, 0, #values)
+	local offset = 1
+	for _, value in values do
+		offset = writeValue(buf, offset, value, 0)
+	end
+	return buf
+end
+
+readValue = function(buf: buffer, offset: number)
+	local tag = buffer.readu8(buf, offset)
+	offset += 1
+	if tag == TAG_NIL then
+		return nil, offset
+	elseif tag == TAG_BOOL then
+		return buffer.readu8(buf, offset) == 1, offset + 1
+	elseif tag == TAG_NUM then
+		return buffer.readf64(buf, offset), offset + 8
+	elseif tag == TAG_STR then
+		local len = buffer.readu32(buf, offset)
+		return buffer.readstring(buf, offset + 4, len), offset + 4 + len
+	elseif tag == TAG_V3 then
+		return Vector3.new(buffer.readf64(buf, offset), buffer.readf64(buf, offset + 8), buffer.readf64(buf, offset + 16)), offset + 24
+	elseif tag == TAG_V2 then
+		return Vector2.new(buffer.readf64(buf, offset), buffer.readf64(buf, offset + 8)), offset + 16
+	elseif tag == TAG_CF then
+		local c = table.create(12)
+		for i = 1, 12 do
+			c[i] = buffer.readf64(buf, offset + (i - 1) * 8)
+		end
+		return CFrame.new(table.unpack(c)), offset + 96
+	elseif tag == TAG_COL then
+		return Color3.new(buffer.readf64(buf, offset), buffer.readf64(buf, offset + 8), buffer.readf64(buf, offset + 16)), offset + 24
+	elseif tag == TAG_UDIM then
+		return UDim.new(buffer.readf32(buf, offset), buffer.readi32(buf, offset + 4)), offset + 12
+	elseif tag == TAG_UDIM2 then
+		return UDim2.new(
+			buffer.readf32(buf, offset),
+			buffer.readi32(buf, offset + 4),
+			buffer.readf32(buf, offset + 8),
+			buffer.readi32(buf, offset + 12)
+		),
+			offset + 16
+	elseif tag == TAG_PLAYER then
+		local userId = buffer.readf64(buf, offset)
+		return Players:GetPlayerByUserId(userId), offset + 8
+	elseif tag == TAG_TABLE then
+		local count = buffer.readu32(buf, offset)
+		offset += 4
+		local out = {}
+		for _ = 1, count do
+			local key
+			key, offset = readValue(buf, offset)
+			local child
+			child, offset = readValue(buf, offset)
+			out[key] = child
+		end
+		return out, offset
+	end
+	return nil, offset
+end
+
+local function decode(buf: buffer)
+	local count = buffer.readu8(buf, 0)
+	local offset = 1
+	local values = table.create(count)
+	for i = 1, count do
+		local value
+		value, offset = readValue(buf, offset)
+		values[i] = value
+	end
+	return values
+end
+
+return {
+	encode = encode,
+	decode = decode,
+}