cluaupp 0.1.0

package/runtime/DataService/Enum.luau

@@ -0,0 +1,6 @@
+return table.freeze({
+	OrderList = table.freeze({
+		Asc = "asc",
+		Desc = "desc",
+	}),
+})

package/runtime/DataService/Enums.luau

@@ -0,0 +1,10 @@
+return table.freeze({
+	Init = "i",
+	Set = "s",
+	ArrayInsert = "ai",
+	ArrayRemove = "ar",
+	SetTransient = "ts",
+	ArrayInsertTransient = "tai",
+	ArrayRemoveTransient = "tar",
+	ClearTransient = "tc",
+})

package/runtime/DataService/Packages/quicknet/DataTypes.luau

@@ -0,0 +1,70 @@
+local Enums = require(script.Parent.Enums)
+local Parser = require(script.Parent.Parser)
+
+local dataTypes = {
+	NumberU4 = Enums.NumberU4,
+	NumberU8 = Enums.NumberU8,	
+	NumberU16 = Enums.NumberU16,
+	NumberU32 = Enums.NumberU32,
+	NumberI8 = Enums.NumberI8,
+	NumberI16 = Enums.NumberI16,
+	NumberI32 = Enums.NumberI32,
+	NumberF16 = Enums.NumberF16,
+	NumberF32 = Enums.NumberF32,
+	NumberF64 = Enums.NumberF64,
+	
+	--cframes
+	CFrameFX8 = Enums.CFrameFX8 :: CFrame,
+	CFrameI16FX16 = Enums.CFrameI16FX16 :: CFrame,
+	CFrameFX16 = Enums.CFrameFX16 :: CFrame,
+	CFrameF16 = Enums.CFrameF16 :: CFrame,
+	CFrameF32Aligned = Enums.CFrameF32Aligned :: CFrame,
+	CFrameF32FX16 = Enums.CFrameF32FX16 :: CFrame,
+	CFrameF32 = Enums.CFrameF32 :: CFrame,
+	
+	--vector3
+	Vector3FX8 = Enums.Vector3FX8 :: Vector3,
+	Vector3I16 = Enums.Vector3I16 :: Vector3,
+	Vector3FX16 = Enums.Vector3FX16 :: Vector3,
+	Vector3F16 = Enums.Vector3F16 :: Vector3,
+	Vector3F32 = Enums.Vector3F32 :: Vector3,
+	
+	--vector2
+	Vector2FX8 = Enums.Vector2FX8 :: Vector2,
+	Vector2I16 = Enums.Vector2I16 :: Vector2,
+	Vector2FX16 = Enums.Vector2FX16 :: Vector2,
+	Vector2F16 = Enums.Vector2F16 :: Vector2,
+	Vector2F32 = Enums.Vector2F32 :: Vector2,
+	
+	--misc
+	String = Enums.String :: string,
+	StringLong = Enums.StringLong :: string,
+	Color3 = Enums.Color3 :: Color3,
+	BrickColor = Enums.BrickColor :: BrickColor,
+	Boolean = Enums.Boolean :: boolean,
+	Nil = Enums.Nil :: any,
+	Buffer = Enums.Buffer :: buffer,
+	EnumItem = Enums.EnumItem :: EnumItem,
+	Instance = Enums.Instance :: Instance,
+	Player = Enums.Player :: Player,
+	DateTime32 = Enums.DateTime32 :: DateTime,
+	DateTime64 = Enums.DateTime64 :: DateTime,
+	TweenInfo = Enums.TweenInfo :: TweenInfo,
+	ColorSequence = Enums.ColorSequence :: ColorSequence,
+	NumberSequence = Enums.NumberSequence :: NumberSequence,
+	NumberRange = Enums.NumberRange :: NumberRange,
+	UDim = Enums.UDim :: UDim,
+	UDim2 = Enums.UDim2 :: UDim2,
+	Region3 = Enums.Region3 :: Region3,
+	PhysicalProperties = Enums.PhysicalProperties :: PhysicalProperties,
+	Rect = Enums.Rect :: Rect,
+	
+	--custom
+	Any = Enums.Any :: any,
+	optional = Parser.optional,
+	union = Parser.union,
+	unionMany = Parser.unionMany,
+	literal = Parser.literal,
+}
+
+return dataTypes

package/runtime/DataService/Packages/quicknet/Enums.luau

@@ -0,0 +1,85 @@
+local enums = {
+	Start = 1,
+	NumberU4 = 2,
+	["NumberU8"] = 3,
+	["NumberU16"] = 4,
+	["NumberU32"] = 5,
+	["NumberI8"] = 6,
+	["NumberI16"] = 7,
+	["NumberI32"] = 8,
+	["NumberF16"] = 9,
+	["NumberF32"] = 10,
+	["NumberF64"] = 11,
+	
+	["CFrameFX8"] = 12,
+	CFrameI16FX16 = 13,
+	["CFrameFX16"] = 14,
+	["CFrameF16"] = 15,
+	CFrameF32Aligned = 16,
+	["CFrameF32FX16"] = 17,
+	["CFrameF32"] = 18,
+	
+	["Vector3FX8"] = 19,
+	Vector3I16 = 20,
+	["Vector3FX16"] = 21,
+	["Vector3F16"] = 22,
+	["Vector3F32"] = 23,
+	
+	["Vector2FX8"] = 24,
+	Vector2I16 = 25,
+	["Vector2FX16"] = 26,
+	["Vector2F16"] = 27,
+	["Vector2F32"] = 28,
+
+	["String"] = 29,
+	StringLong = 30,
+	["Color3"] = 31,
+	BrickColor = 32,
+	["Boolean"] = 33,
+	["Nil"] = 34,
+	Buffer = 35,
+	EnumItem = 36,
+	Instance = 37,
+	Player = 38,
+	DateTime32 = 39,
+	DateTime64 = 40,
+	TweenInfo = 41,
+	ColorSequence = 42,
+	NumberSequence = 43,
+	NumberRange = 44,
+	UDim = 45,
+	UDim2 = 46,
+	Region3 = 47,
+	PhysicalProperties = 48,
+	Rect = 49,
+
+	["Any"] = 50,
+	Optional = 51,
+	Union = 52,
+	Literal = 53,
+	["ArrayStatic"] = 54,
+	["Array"] = 55,
+	["ArrayDynamic"] = 56,
+	["DictStatic"] = 57,
+	["Dict"] = 58,
+	["DictDynamic"] = 59,
+	
+	FastNumberU4Array = 60,
+	FastNumberU8Array = 61,
+	FastNumberI32Array = 62,
+	FastNumberF32Array = 63,
+	FastBoolArray = 64,
+	FastStringArray = 65,
+	FastNumberU8DictStatic = 66,
+	FastNumberI32DictStatic = 67,
+	FastNumberF32DictStatic = 68,
+	FastBoolDictStatic = 69,
+	FastStringDictStatic = 70,
+	FastNumberU8Dict = 71,
+	FastNumberI32Dict = 72,
+	FastNumberF32Dict = 73,
+	FastBoolDict = 74,
+	FastStringDict = 75,
+}
+
+return enums

package/runtime/DataService/Packages/quicknet/EnumsToNativeTypes.luau

@@ -0,0 +1,57 @@
+local module = {
+	[1] = "whatever",
+	[2] = "number",
+	[3] = "number",
+	[4] = "number",
+	[5] = "number",
+	[6] = "number",
+	[7] = "number",
+	[8] = "number",
+	[9] = "number",
+	[10] = "number",
+	[11] = "number",
+
+	[12] = "CFrame",
+	[13] = "CFrame",
+	[14] = "CFrame",
+	[15] = "CFrame",
+	[16] = "CFrame",
+	[17] = "CFrame",
+	[18] = "CFrame",
+
+	[19] = "Vector3",
+	[20] = "Vector3",
+	[21] = "Vector3",
+	[22] = "Vector3",
+	[23] = "Vector3",
+
+	[24] = "Vector2",
+	[25] = "Vector2",
+	[26] = "Vector2",
+	[27] = "Vector2",
+	[28] = "Vector2",
+
+	[29] = "string",
+	[30] = "string",
+	[31] = "Color3",
+	[32] = "BrickColor",
+	[33] = "boolean",
+	[34] = "nil",
+	[35] = "buffer",
+	[36] = "EnumItem",
+	[37] = "Instance",
+	[38] = "Player",
+	[39] = "DateTime",
+	[40] = "DateTime",
+	[41] = "TweenInfo",
+	[42] = "ColorSequence",
+	[43] = "NumberSequence",
+	[44] = "NumberRange",
+	[45] = "UDim",
+	[46] = "UDim2",
+	[47] = "Region3",
+	[48] = "PhysicalProperties",
+	[49] = "Rect",
+}
+
+return module

package/runtime/DataService/Packages/quicknet/Parser.luau

@@ -0,0 +1,355 @@
+local Enums = require(script.Parent.Enums)
+local EnumsToNative = require(script.Parent.EnumsToNativeTypes)
+local Types = require(script.Parent.Types)
+
+local SOURCE = "[QuickNet]"
+
+local function keyValueSwap(tbl: {[any]: any}): {[any]: any}
+	local new = {}
+	for k, v in tbl do
+		new[v] = k
+	end
+	return new
+end
+
+local reverseEnums = keyValueSwap(Enums)
+
+local fastPaths = {
+	Array = {
+		[Enums.NumberU4] = Enums.FastNumberU4Array,
+		[Enums.NumberU8] = Enums.FastNumberU8Array,
+		[Enums.NumberI32] = Enums.FastNumberI32Array,
+		[Enums.NumberF32] = Enums.FastNumberF32Array,
+		[Enums.Boolean] = Enums.FastBoolArray,
+		[Enums.String] = Enums.FastStringArray,
+	},
+
+	DictStatic = {
+		[Enums.NumberU4] = Enums.FastNumberU8DictStatic,
+		[Enums.NumberU8] = Enums.FastNumberU8DictStatic,
+		[Enums.NumberI32] = Enums.FastNumberI32DictStatic,
+		[Enums.NumberF32] = Enums.FastNumberF32DictStatic,
+		[Enums.Boolean] = Enums.FastBoolDictStatic,
+		[Enums.String] = Enums.FastStringDictStatic,
+	},
+
+	Dict = {
+		[Enums.NumberU4] = Enums.FastNumberU8Dict,
+		[Enums.NumberU8] = Enums.FastNumberU8Dict,
+		[Enums.NumberI32] = Enums.FastNumberI32Dict,
+		[Enums.NumberF32] = Enums.FastNumberF32Dict,
+		[Enums.Boolean] = Enums.FastBoolDict,
+		[Enums.String] = Enums.FastStringDict,
+	}
+}
+
+local function checkSameTypes(data: {any}): (boolean, number)
+	local sameValTypes = true
+	local prevVal = data[1]
+
+	for _, val in data do
+		if val ~= prevVal then
+			sameValTypes = false
+			break
+		end
+		prevVal = val
+	end
+	return sameValTypes, prevVal
+end
+
+--Indexes
+--1: Type
+--2: Data
+--3: FastPath
+local function arrayStatic(data: {any}): {any}
+	local sameTypes, dataType = checkSameTypes(data)
+
+	local schema = {
+		Enums.ArrayStatic, 
+		data,
+		sameTypes and fastPaths.Array[dataType] or nil
+	}
+	return schema
+end
+
+local function array<T>(data: {T}): {T}
+	local dataType = data[1]
+	local schema = {
+		Enums.Array, 
+		dataType,
+		fastPaths.Array[dataType],
+	}
+	return schema
+end
+
+local function arrayDynamic(): {any}
+	local schema = {
+		Enums.ArrayDynamic,
+	}
+	return schema
+end
+
+local dictId = 1
+
+local function getDictId(): number
+	local id = dictId
+	dictId += 1
+	return id
+end
+
+--1: Type
+--2: Data
+--3: KeysMap
+--4: FastPath
+local function dictStatic(data: {[string | number]: any}): {[string | number]: any}
+	local keys = {}
+	for key, val in data do
+		table.insert(keys, key)
+	end
+	table.sort(keys, function(a, b)
+		local aType = type(a)
+		local bType = type(b)
+
+		if aType ~= bType then
+			return aType < bType
+		end
+		return a < b
+	end)
+
+	local vals = {}
+	local template = {}
+	for idx, key in keys do		
+		vals[idx] = data[key]
+		template[key] = 123
+	end	
+	local sameTypes, dataType = checkSameTypes(vals)
+
+	local schema = {
+		Enums.DictStatic,
+		vals,
+		keys,
+		template,
+		sameTypes and fastPaths.DictStatic[dataType] or nil,
+	}
+	return schema
+end
+
+--1: Type
+--2: KeyData
+--3: ValueData
+--4: KeyFastPath
+--5: ValueFastPath
+local function dict<K, V>(data: {[K]: V}): {[K]: V}
+	local keyData, valData = next(data)
+	local keyFastPath = fastPaths.Dict[keyData]
+	local valFastPath = fastPaths.Dict[valData]
+
+	local schema = {
+		[1] = Enums.Dict,
+		[2] = keyData,
+		[3] = valData,
+		[4] = keyFastPath,
+		[5] = valFastPath,
+		[6] = getDictId(),
+	}
+	return schema
+end
+
+local function dictDynamic(): {[any]: any}
+	local schema = {
+		Enums.DictDynamic,
+	}
+	return schema
+end
+
+local function optional<T>(dataType: T): T?
+	return {
+		Enums.Optional,
+		dataType,
+	}
+end
+
+local function parseUnion(data: any, union: {any})
+	local isTable = type(data) == "table"
+
+	if isTable then
+		local enum = data[1]
+		if enum == Enums.Optional then
+			error(SOURCE.." optional type cannot be unioned", 2)
+			return
+				
+		elseif enum == Enums.Any then
+			error(SOURCE.." Any type cannot be unioned", 2)
+			return
+				
+		elseif enum == Enums.Literal then
+			error(SOURCE.." literal types cannot be unioned", 2)
+			return
+		end
+		union["table"] = data
+	else
+		local native = EnumsToNative[data]
+		if not native then
+			error(SOURCE.." invalid union type", 2)
+			return
+		end
+		if union[native] ~= nil then
+			error(SOURCE.. " cannot union multiple types of the same native type", 2)
+			return
+		end
+		union[native] = data
+	end
+end
+
+local function union<T1, T2>(data1: T1, data2: T2): T1 | T2
+	local union = {}
+	parseUnion(data1, union)
+	parseUnion(data2, union)
+	union[1] = Enums.Union
+	return union
+end
+
+local function unionMany<T...>(...: T...): any
+	local union = {}
+	for _, data in {...} do
+		parseUnion(data, union)
+	end
+	union[1] = Enums.Union
+	return union
+end
+
+local function literal<T...>(...: T...): Types.Literal
+	local map = {...}
+	for _, val in map do
+		local dt = typeof(val)
+		if dt ~= "string" and dt ~= "number" and dt ~= "boolean" and dt ~= "Vector3" then
+			error(SOURCE.." unsupported literal type: "..dt, 2)
+			return
+		end
+	end
+	local reverseMap = keyValueSwap(map)
+	local literal = {
+		Enums.Literal,
+		map,
+		reverseMap,
+	}
+	return literal
+end
+
+local function processSchema(schema: {[any]: any})
+	if type(schema) ~= "table" then
+		if not reverseEnums[schema] then
+			error(SOURCE.." invalid data type", 2)
+		end
+		return schema
+	end
+	
+	local dt = schema[1]	
+	local isLiteral = dt == Enums.Literal
+	if isLiteral then return schema end
+	
+	local isOptional = dt == Enums.Optional
+	if isOptional then
+		schema[2] = processSchema(schema[2])
+		return schema
+	end
+	
+	local isUnion = dt == Enums.Union
+	if isUnion then
+		local reverseMap = {}
+		for k, val in schema do
+			if type(k) ~= "string" then
+				continue
+			end			
+			local processed = processSchema(val)
+			schema[k] = processed
+			
+			local enum
+			if type(processed) == "table" then
+				enum = processed[1]
+			else
+				enum = processed
+			end			
+			reverseMap[enum] = processed
+		end
+		
+		for enum, processed in reverseMap do
+			schema[enum] = processed
+		end
+		return schema
+	end
+
+	local newSchema
+	local isArrayStatic = true
+	local count = 0
+	for i, arg in schema do
+		count += 1
+		if i ~= count then
+			isArrayStatic = false
+		end
+	end
+
+	local k, v = next(schema)
+	local isArray = count == 1 and k == 1
+	local isDict = not isArray and count == 1
+	local isDictStatic = not isArrayStatic and count > 1
+
+	if isArray then
+		newSchema = array(schema)
+		local data = newSchema[2]
+		if data == Enums.Any then
+			newSchema = arrayDynamic()
+		else
+			newSchema[2] = processSchema(data)
+		end
+
+	elseif isArrayStatic then
+		newSchema = arrayStatic(schema)
+		local data = newSchema[2]
+		local newData = {}
+		for i, val in data do
+			newData[i] = processSchema(val)
+		end
+		newSchema[2] = newData
+
+	elseif isDict then
+		newSchema = dict(schema)
+		local key = newSchema[2]
+		local val = newSchema[3]
+		if key == Enums.Any and val == Enums.Any then
+			newSchema = dictDynamic()
+		else
+			newSchema[2] = processSchema(key)
+			newSchema[3] = processSchema(val)
+		end
+
+	elseif isDictStatic then
+		newSchema = dictStatic(schema)
+		local vals = newSchema[2]
+		for i, val in vals do
+			vals[i] = processSchema(val)
+		end
+
+	else
+		error(SOURCE.. " invalid schema", 2)
+	end
+	return newSchema
+end
+
+local function getSchema(...)
+	local args = {...}
+	for i, arg in args do
+		args[i] = processSchema(arg)
+	end
+	return args
+end
+
+local Parser = {
+	getSchema = getSchema,
+	optional = optional,
+	union = union,
+	unionMany = unionMany,
+	literal = literal,
+}
+
+return Parser