@data-vegle/serial 0.1.0

package/out/lib/RobloxCodecs.luau

@@ -0,0 +1,506 @@
+
+local a=1
+local b=2
+local c=4
+local d=1
+local e=2
+local f=4
+local g=8
+local h=16
+local i=32
+local j
+local function createEnumCodecByName(k)
+local l=Enum
+local m=l[k]
+if m==nil then
+error(string.format([[[Serialization] an enum schema referenced an unknown enum: %s]], tostring(k)))
+end
+return j(m)
+end
+function j(k)
+local l=k:GetEnumItems()
+local m={}
+for n,o in l do
+local p=o.Value
+m[p]=o
+end
+return{
+write=function(p,q,r)
+q:writeVarUint(r.Value)
+end,
+read=function(p,q)
+local r=q:readVarUint()
+local s=m[r]
+if s==nil then
+error(string.format([[[Serialization] an enum read a value that does not exist: %s]], tostring(r)))
+end
+return s
+end,
+}
+end
+local k={
+write=function(k,l,m)
+l:writeF32(m.X)
+l:writeF32(m.Y)
+l:writeF32(m.Z)
+end,
+read=function(k,l)
+local m=l:readF32()
+local n=l:readF32()
+local o=l:readF32()
+return Vector3.new(m,n,o)
+end,
+}
+local l={
+write=function(l,m,n)
+m:writeF32(n.X)
+m:writeF32(n.Y)
+end,
+read=function(l,m)
+local n=m:readF32()
+local o=m:readF32()
+return Vector2.new(n,o)
+end,
+}
+local m={
+write=function(m,n,o)
+n:writeI16(o.X)
+n:writeI16(o.Y)
+n:writeI16(o.Z)
+end,
+read=function(m,n)
+local o=n:readI16()
+local p=n:readI16()
+local q=n:readI16()
+return Vector3int16.new(o,p,q)
+end,
+}
+local n={
+write=function(n,o,p)
+o:writeI16(p.X)
+o:writeI16(p.Y)
+end,
+read=function(n,o)
+local p=o:readI16()
+local q=o:readI16()
+return Vector2int16.new(p,q)
+end,
+}
+local o={
+write=function(o,p,q)
+local r=q.Position
+local s,t,u=q:ToOrientation()
+p:writeF32(r.X)
+p:writeF32(r.Y)
+p:writeF32(r.Z)
+p:writeF32(s)
+p:writeF32(t)
+p:writeF32(u)
+end,
+read=function(o,p)
+local q=p:readF32()
+local r=p:readF32()
+local s=p:readF32()
+local t=p:readF32()
+local u=p:readF32()
+local v=p:readF32()
+local w=CFrame.fromOrientation(t,u,v)
+local x=Vector3.new(q,r,s)
+return w+x
+end,
+}
+local p={
+write=function(p,q,r)
+q:writeF32(r.R)
+q:writeF32(r.G)
+q:writeF32(r.B)
+end,
+read=function(p,q)
+local r=q:readF32()
+local s=q:readF32()
+local t=q:readF32()
+return Color3.new(r,s,t)
+end,
+}
+local q={
+write=function(q,r,s)
+r:writeVarUint(s.Number)
+end,
+read=function(q,r)
+local s=r:readVarUint()
+return BrickColor.new(s)
+end,
+}
+local r={
+write=function(r,s,t)
+s:writeF32(t.Scale)
+s:writeI32(t.Offset)
+end,
+read=function(r,s)
+local t=s:readF32()
+local u=s:readI32()
+return UDim.new(t,u)
+end,
+}
+local s={
+write=function(s,t,u)
+t:writeF32(u.X.Scale)
+t:writeI32(u.X.Offset)
+t:writeF32(u.Y.Scale)
+t:writeI32(u.Y.Offset)
+end,
+read=function(s,t)
+local u=t:readF32()
+local v=t:readI32()
+local w=t:readF32()
+local x=t:readI32()
+return UDim2.new(u,v,w,x)
+end,
+}
+local t={
+write=function(t,u,v)
+u:writeF32(v.Min.X)
+u:writeF32(v.Min.Y)
+u:writeF32(v.Max.X)
+u:writeF32(v.Max.Y)
+end,
+read=function(t,u)
+local v=u:readF32()
+local w=u:readF32()
+local x=u:readF32()
+local y=u:readF32()
+local z=Vector2.new(v,w)
+local A=Vector2.new(x,y)
+return Rect.new(z,A)
+end,
+}
+local u={
+write=function(u,v,w)
+local x=w.Origin
+local y=w.Direction
+v:writeF32(x.X)
+v:writeF32(x.Y)
+v:writeF32(x.Z)
+v:writeF32(y.X)
+v:writeF32(y.Y)
+v:writeF32(y.Z)
+end,
+read=function(u,v)
+local w=v:readF32()
+local x=v:readF32()
+local y=v:readF32()
+local z=v:readF32()
+local A=v:readF32()
+local B=v:readF32()
+local C=Vector3.new(w,x,y)
+local D=Vector3.new(z,A,B)
+return Ray.new(C,D)
+end,
+}
+local v={
+write=function(v,w,x)
+local y=x.Size
+local z=y/2
+local A=x.CFrame.Position
+local B=A-z
+local C=A+z
+w:writeF32(B.X)
+w:writeF32(B.Y)
+w:writeF32(B.Z)
+w:writeF32(C.X)
+w:writeF32(C.Y)
+w:writeF32(C.Z)
+end,
+read=function(v,w)
+local x=w:readF32()
+local y=w:readF32()
+local z=w:readF32()
+local A=w:readF32()
+local B=w:readF32()
+local C=w:readF32()
+local D=Vector3.new(x,y,z)
+local E=Vector3.new(A,B,C)
+return Region3.new(D,E)
+end,
+}
+local w={
+write=function(w,x,y)
+x:writeI16(y.Min.X)
+x:writeI16(y.Min.Y)
+x:writeI16(y.Min.Z)
+x:writeI16(y.Max.X)
+x:writeI16(y.Max.Y)
+x:writeI16(y.Max.Z)
+end,
+read=function(w,x)
+local y=x:readI16()
+local z=x:readI16()
+local A=x:readI16()
+local B=x:readI16()
+local C=x:readI16()
+local D=x:readI16()
+local E=Vector3int16.new(y,z,A)
+local F=Vector3int16.new(B,C,D)
+return Region3int16.new(E,F)
+end,
+}
+local x={
+write=function(x,y,z)
+y:writeF32(z.Min)
+y:writeF32(z.Max)
+end,
+read=function(x,y)
+local z=y:readF32()
+local A=y:readF32()
+return NumberRange.new(z,A)
+end,
+}
+local y={
+write=function(y,z,A)
+local B=A.Keypoints
+local C=#B
+z:writeVarUint(C)
+for D,E in B do
+z:writeF32(E.Time)
+z:writeF32(E.Value)
+z:writeF32(E.Envelope)
+end
+end,
+read=function(y,z)
+local A=z:readVarUint()
+local B={}
+do
+local C=0
+local D=false
+while true do
+if D then
+C=C+1
+else
+D=true
+end
+if not(C<A)then
+break
+end
+local E=z:readF32()
+local F=z:readF32()
+local G=z:readF32()
+local H=NumberSequenceKeypoint.new(E,F,G)
+table.insert(B,H)
+end
+end
+return NumberSequence.new(B)
+end,
+}
+local z={
+write=function(z,A,B)
+local C=B.Keypoints
+local D=#C
+A:writeVarUint(D)
+for E,F in C do
+local G=F.Value
+A:writeF32(F.Time)
+A:writeF32(G.R)
+A:writeF32(G.G)
+A:writeF32(G.B)
+end
+end,
+read=function(z,A)
+local B=A:readVarUint()
+local C={}
+do
+local D=0
+local E=false
+while true do
+if E then
+D=D+1
+else
+E=true
+end
+if not(D<B)then
+break
+end
+local F=A:readF32()
+local G=A:readF32()
+local H=A:readF32()
+local I=A:readF32()
+local J=Color3.new(G,H,I)
+local K=ColorSequenceKeypoint.new(F,J)
+table.insert(C,K)
+end
+end
+return ColorSequence.new(C)
+end,
+}
+local A={
+write=function(A,B,C)
+B:writeF32(C.Density)
+B:writeF32(C.Friction)
+B:writeF32(C.Elasticity)
+B:writeF32(C.FrictionWeight)
+B:writeF32(C.ElasticityWeight)
+end,
+read=function(A,B)
+local C=B:readF32()
+local D=B:readF32()
+local E=B:readF32()
+local F=B:readF32()
+local G=B:readF32()
+return PhysicalProperties.new(C,D,E,F,G)
+end,
+}
+local B={
+write=function(B,C,D)
+C:writeF64(D.UnixTimestampMillis)
+end,
+read=function(B,C)
+local D=C:readF64()
+return DateTime.fromUnixTimestampMillis(D)
+end,
+}
+local C=j(Enum.FontWeight)
+local D=j(Enum.FontStyle)
+local E=j(Enum.EasingStyle)
+local F=j(Enum.EasingDirection)
+local G={
+write=function(G,H,I)
+H:writeString(I.Family)
+C:write(H,I.Weight)
+D:write(H,I.Style)
+end,
+read=function(G,H)
+local I=H:readString()
+local J=C:read(H)
+local K=D:read(H)
+return Font.new(I,J,K)
+end,
+}
+local H={
+write=function(H,I,J)
+I:writeF32(J.Time)
+E:write(I,J.EasingStyle)
+F:write(I,J.EasingDirection)
+I:writeI32(J.RepeatCount)
+I:writeBool(J.Reverses)
+I:writeF32(J.DelayTime)
+end,
+read=function(H,I)
+local J=I:readF32()
+local K=E:read(I)
+local L=F:read(I)
+local M=I:readI32()
+local N=I:readBool()
+local O=I:readF32()
+return TweenInfo.new(J,K,L,M,N,O)
+end,
+}
+local I={
+write=function(I,J,K)
+local L=0
+if K.X then
+L=L+a
+end
+if K.Y then
+L=L+b
+end
+if K.Z then
+L=L+c
+end
+J:writeU8(L)
+end,
+read=function(I,J)
+local K=J:readU8()
+local L={}
+if bit32.band(K,a)~=0 then
+local M=Enum.Axis.X
+table.insert(L,M)
+end
+if bit32.band(K,b)~=0 then
+local M=Enum.Axis.Y
+table.insert(L,M)
+end
+if bit32.band(K,c)~=0 then
+local M=Enum.Axis.Z
+table.insert(L,M)
+end
+return Axes.new(unpack(L))
+end,
+}
+local J={
+write=function(J,K,L)
+local M=0
+if L.Top then
+M=M+d
+end
+if L.Bottom then
+M=M+e
+end
+if L.Left then
+M=M+f
+end
+if L.Right then
+M=M+g
+end
+if L.Back then
+M=M+h
+end
+if L.Front then
+M=M+i
+end
+K:writeU8(M)
+end,
+read=function(J,K)
+local L=K:readU8()
+local M={}
+if bit32.band(L,d)~=0 then
+local N=Enum.NormalId.Top
+table.insert(M,N)
+end
+if bit32.band(L,e)~=0 then
+local N=Enum.NormalId.Bottom
+table.insert(M,N)
+end
+if bit32.band(L,f)~=0 then
+local N=Enum.NormalId.Left
+table.insert(M,N)
+end
+if bit32.band(L,g)~=0 then
+local N=Enum.NormalId.Right
+table.insert(M,N)
+end
+if bit32.band(L,h)~=0 then
+local N=Enum.NormalId.Back
+table.insert(M,N)
+end
+if bit32.band(L,i)~=0 then
+local N=Enum.NormalId.Front
+table.insert(M,N)
+end
+return Faces.new(unpack(M))
+end,
+}
+return{
+createEnumCodecByName=createEnumCodecByName,
+createEnumCodec=j,
+vector3Codec=k,
+vector2Codec=l,
+vector3int16Codec=m,
+vector2int16Codec=n,
+cframeCodec=o,
+color3Codec=p,
+brickColorCodec=q,
+udimCodec=r,
+udim2Codec=s,
+rectCodec=t,
+rayCodec=u,
+region3Codec=v,
+region3int16Codec=w,
+numberRangeCodec=x,
+numberSequenceCodec=y,
+colorSequenceCodec=z,
+physicalPropertiesCodec=A,
+dateTimeCodec=B,
+fontCodec=G,
+tweenInfoCodec=H,
+axesCodec=I,
+facesCodec=J,
+}

package/out/lib/Serializer.d.ts

@@ -0,0 +1,14 @@
+import type { Modding } from "@flamework/core";
+import type { SerializerMetadata } from "./SerializerMetadata";
+export type SerializedData = [buffer, Array<defined>];
+/**
+ * @metadata macro
+ */
+export declare class Serializer<T> {
+    private readonly meta?;
+    private readonly schema;
+    private readonly codec;
+    constructor(meta?: Modding.Many<SerializerMetadata<T>> | undefined);
+    serialize(value: T): SerializedData;
+    deserialize(data: SerializedData): T;
+}

package/out/lib/Serializer.luau

@@ -0,0 +1,45 @@
+
+local a=_G[script]
+local b=a.import(script,script.Parent,"BufferReader").BufferReader
+local c=a.import(script,script.Parent,"BufferWriter").BufferWriter
+local d=a.import(script,script.Parent,"CodecCompiler").compileCodec
+
+
+
+
+
+local e
+do
+e=setmetatable({},{
+__tostring=function()
+return"Serializer"
+end,
+})
+e.__index=e
+function e.new(...)
+local f=setmetatable({},e)
+return f:constructor(...)or f
+end
+function e.constructor(f,g)
+f.meta=g
+if g==nil then
+error"[Serialization] createSerializer was called without a generated schema"
+end
+f.schema=g
+f.codec=d(f.schema)
+end
+function e.serialize(f,g)
+local h=c.new()
+f.codec:write(h,g)
+local i=h:getBuffer()
+local j=h:getBlobs()
+return{i,j}
+end
+function e.deserialize(f,g)
+local h=b.new(g[1],g[2])
+return f.codec:read(h)
+end
+end
+return{
+Serializer=e,
+}

package/out/lib/SerializerMetadata.d.ts

@@ -0,0 +1,63 @@
+type Mask<V, T> = T extends object ? V & Reconstruct<T> : V;
+type IsLiteral<T> = T extends undefined ? true : T extends string ? Mask<string, T> extends T ? false : true : T extends number ? Mask<number, T> extends T ? false : true : T extends boolean ? true : false;
+type HasNominal<T> = T extends T ? (T extends `_nominal_${string}` ? true : never) : never;
+type IsUnion<T, U = T> = true extends (T extends T ? (U extends T ? never : true) : never) ? true : false;
+type IsExactlyBoolean<T> = [T] extends [boolean] ? ([boolean] extends [T] ? true : false) : false;
+type IsLiteralUnion<T> = [boolean, NonNullable<T>] extends [NonNullable<T>, boolean] ? false : (T extends T ? (T extends undefined ? true : IsLiteral<T> extends true ? true : false) : never) extends true ? true : false;
+type NonUnionKeys<T> = {
+    [K in keyof T]: true extends IsUnion<T[K]> ? never : K;
+}[keyof T];
+type LiteralKeys<T> = {
+    [K in keyof T]: true extends IsLiteral<T[K]> ? K : never;
+}[keyof T];
+type DiscriminatorKeys<T> = NonUnionKeys<T> & LiteralKeys<T>;
+type SharedDiscriminators<T> = UnionToIntersection<T extends T ? [DiscriminatorKeys<T>] : never>[never];
+type UniqueDiscriminators<T, D extends keyof T, U extends T = T> = D extends D ? (T extends T ? (T[D] extends Exclude<U, T>[D] ? unknown : D) : never) extends D ? D : never : never;
+type FindDiscriminator<T> = UniqueDiscriminators<T, SharedDiscriminators<T>>;
+type IsDiscriminableUnion<T> = true extends IsUnion<T> ? (FindDiscriminator<T> extends never ? false : true) : false;
+type EnumName<T> = [T] extends [EnumItem] ? ExtractKeys<Enums, T["EnumType"]> : never;
+interface RobloxDataTypes {
+    readonly vector3: Vector3;
+    readonly vector2: Vector2;
+    readonly vector3int16: Vector3int16;
+    readonly vector2int16: Vector2int16;
+    readonly cframe: CFrame;
+    readonly color3: Color3;
+    readonly udim: UDim;
+    readonly udim2: UDim2;
+    readonly rect: Rect;
+    readonly ray: Ray;
+    readonly region3: Region3;
+    readonly region3int16: Region3int16;
+    readonly numberrange: NumberRange;
+    readonly numbersequence: NumberSequence;
+    readonly colorsequence: ColorSequence;
+    readonly physicalproperties: PhysicalProperties;
+    readonly datetime: DateTime;
+    readonly tweeninfo: TweenInfo;
+    readonly font: Font;
+    readonly axes: Axes;
+    readonly faces: Faces;
+}
+type LiteralMode<T> = true extends IsUnion<T> ? (undefined extends T ? 1 : 0) : -1;
+type TupleMetadata<T extends ReadonlyArray<unknown>> = [
+    "tuple",
+    {
+        [K in keyof T]: SerializerMetadata<T[K]>;
+    }
+];
+type ArrayMetadata<T extends ReadonlyArray<unknown>> = [T] extends [
+    {
+        length: number;
+    }
+] ? TupleMetadata<T> : ["list", SerializerMetadata<T[number]>];
+type VariantMetadata<T> = FindDiscriminator<T> extends infer D ? T extends T ? [T[D & keyof T], SerializerMetadata<Omit<T, D & keyof T>>] : never : never;
+type FieldMetadata<T> = {
+    [K in keyof T]-?: [K, SerializerMetadata<T[K]>];
+}[keyof T];
+export type SerializerMetadata<T> = IsExactlyBoolean<T> extends true ? ["bool"] : IsLiteralUnion<T> extends true ? ["literal", Array<NonNullable<T>>, LiteralMode<T>] : unknown extends T ? ["optional", ["blob"]] : undefined extends T ? ["optional", SerializerMetadata<NonNullable<T>>] : [T] extends [number] ? ["f64"] : [T] extends [string] ? ["string"] : [T] extends [buffer] ? ["buffer"] : [T] extends [BrickColor] ? ["brickcolor"] : [T] extends [RobloxDataTypes[keyof RobloxDataTypes]] ? [ExtractKeys<RobloxDataTypes, T>] : [T] extends [ReadonlySet<infer V>] ? ["set", SerializerMetadata<V>] : [T] extends [ReadonlyMap<infer K, infer V>] ? ["map", SerializerMetadata<K>, SerializerMetadata<V>] : [T] extends [ReadonlyArray<unknown>] ? ArrayMetadata<T> : [T] extends [EnumItem] ? ["enum", EnumName<T>] : IsDiscriminableUnion<T> extends true ? [
+    "union",
+    FindDiscriminator<T>,
+    Array<VariantMetadata<T>>
+] : true extends IsUnion<T> ? ["blob"] : true extends HasNominal<keyof T> ? ["blob"] : T extends object ? ["object", Array<FieldMetadata<T>>] : ["blob"];
+export {};

package/out/lib/SerializerMetadata.luau

@@ -0,0 +1,2 @@
+
+return nil

package/package.json

@@ -0,0 +1,45 @@
+{
+	"name": "@data-vegle/serial",
+	"version": "0.1.0",
+	"description": "Serialize roblox-ts types into buffers.",
+	"license": "MIT",
+	"main": "out/init.luau",
+	"types": "out/index.d.ts",
+	"files": [
+		"out",
+		"flamework.build",
+		"!**/*.tsbuildinfo"
+	],
+	"scripts": {
+		"build": "rbxtsc && npm run minify",
+		"minify": "node scripts/minify.js",
+		"watch": "rbxtsc --type=package -w",
+		"clean": "rimraf out include",
+		"format": "prettier --write \"src/**/*.ts\"",
+		"format:check": "prettier --check \"src/**/*.ts\"",
+		"prepublishOnly": "npm run clean && npm run build"
+	},
+	"keywords": [
+		"roblox",
+		"roblox-ts",
+		"flamework",
+		"buffer",
+		"serialization"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"peerDependencies": {
+		"@flamework/core": "^1.3.2"
+	},
+	"devDependencies": {
+		"@rbxts/compiler-types": "3.0.0-types.0",
+		"@rbxts/types": "^1.0.943",
+		"darklua-wasm": "^0.1.0",
+		"prettier": "^3.3.3",
+		"rbxts-transformer-flamework": "^1.3.2",
+		"rimraf": "^6.0.1",
+		"roblox-ts": "^3.0.0",
+		"typescript": "=5.5.3"
+	}
+}