Update to latest rbx_dom_lua

plugin/rbx_dom_lua/src/EncodedValue.lua

@@ -23,332 +23,433 @@ end
 local ALL_AXES = {"X", "Y", "Z"}
 local ALL_FACES = {"Right", "Top", "Back", "Left", "Bottom", "Front"}
 
-local encoders
+local types
-encoders = {
+types = {
-	Bool = identity,
+	Axes = {
-	Content = identity,
+		fromPod = function(pod)
-	Float32 = serializeFloat,
+			local axes = {}
-	Float64 = serializeFloat,
-	Int32 = identity,
-	Int64 = identity,
-	String = identity,
 
-	BinaryString = base64.encode,
+			for index, axisName in ipairs(pod) do
-	SharedString = base64.encode,
+				axes[index] = Enum.Axis[axisName]
-
-	Axes = function(value)
-		local output = {}
-
-		for _, axis in ipairs(ALL_AXES) do
-			if value[axis] then
-				table.insert(output, axis)
 			end
-		end
 
-		return output
+			return Axes.new(unpack(axes))
-	end,
+		end,
 
-	Faces = function(value)
+		toPod = function(roblox)
-		local output = {}
+			local json = {}
 
-		for _, face in ipairs(ALL_FACES) do
+			for _, axis in ipairs(ALL_AXES) do
-			if value[face] then
+				if roblox[axis] then
-				table.insert(output, face)
+					table.insert(json, axis)
+				end
 			end
-		end
 
-		return output
+			return json
-	end,
+		end,
+	},
 
-	Enum = function(value)
+	BinaryString = {
-		if typeof(value) == "number" then
+		fromPod = base64.decode,
-			return value
+		toPod = base64.encode,
-		else
+	},
-			return value.Value
-		end
-	end,
 
-	BrickColor = function(value)
+	Bool = {
-		return value.Number
+		fromPod = identity,
-	end,
+		toPod = identity,
+	},
 
-	CFrame = function(value)
+	BrickColor = {
-		local x, y, z,
+		fromPod = function(pod)
-			r00, r01, r02,
+			return BrickColor.new(pod)
-			r10, r11, r12,
+		end,
-			r20, r21, r22 = value:GetComponents()
 
-		return {
+		toPod = function(roblox)
-			Position = {x, y, z},
+			return roblox.Number
-			Orientation = {
+		end,
-				{r00, r10, r20},
+	},
-				{r01, r11, r21},
-				{r02, r12, r22},
-			},
-		}
-	end,
-	Color3 = function(value)
-		return {value.r, value.g, value.b}
-	end,
-	NumberRange = function(value)
-		return {value.Min, value.Max}
-	end,
-	NumberSequence = function(value)
-		local keypoints = {}
 
-		for index, keypoint in ipairs(value.Keypoints) do
+	CFrame = {
-			keypoints[index] = {
+		fromPod = function(pod)
-				Time = keypoint.Time,
+			local pos = pod.Position
-				Value = keypoint.Value,
+			local orient = pod.Orientation
-				Envelope = keypoint.Envelope,
-			}
-		end
 
-		return {
+			return CFrame.new(
-			Keypoints = keypoints,
+				pos[1], pos[2], pos[3],
-		}
+				orient[1][1], orient[1][2], orient[1][3],
-	end,
+				orient[2][1], orient[2][2], orient[2][3],
-	ColorSequence = function(value)
+				orient[3][1], orient[3][2], orient[3][3]
-		local keypoints = {}
+			)
+		end,
 
-		for index, keypoint in ipairs(value.Keypoints) do
+		toPod = function(roblox)
-			keypoints[index] = {
+			local x, y, z,
-				Time = keypoint.Time,
+				r00, r01, r02,
-				Color = encoders.Color3(keypoint.Value),
+				r10, r11, r12,
-			}
+				r20, r21, r22 = roblox:GetComponents()
-		end
 
-		return {
-			Keypoints = keypoints,
-		}
-	end,
-	Rect = function(value)
-		return {
-			encoders.Vector2(value.Min),
-			encoders.Vector2(value.Max),
-		}
-	end,
-	UDim = function(value)
-		return {value.Scale, value.Offset}
-	end,
-	UDim2 = function(value)
-		return {
-			encoders.UDim(value.X),
-			encoders.UDim(value.Y),
-		}
-	end,
-	Vector2 = function(value)
-		return {
-			serializeFloat(value.X),
-			serializeFloat(value.Y),
-		}
-	end,
-	Vector2int16 = function(value)
-		return {value.X, value.Y}
-	end,
-	Vector3 = function(value)
-		return {
-			serializeFloat(value.X),
-			serializeFloat(value.Y),
-			serializeFloat(value.Z),
-		}
-	end,
-	Vector3int16 = function(value)
-		return {value.X, value.Y, value.Z}
-	end,
-
-	PhysicalProperties = function(value)
-		if value == nil then
-			return nil
-		else
 			return {
-				Density = value.Density,
+				Position = {x, y, z},
-				Friction = value.Friction,
+				Orientation = {
-				Elasticity = value.Elasticity,
+					{r00, r01, r02},
-				FrictionWeight = value.FrictionWeight,
+					{r10, r11, r12},
-				ElasticityWeight = value.ElasticityWeight,
+					{r20, r21, r22},
+				},
 			}
-		end
+		end,
-	end,
+	},
 
-	Ray = function(value)
+	Color3 = {
-		return {
+		fromPod = unpackDecoder(Color3.new),
-			Origin = encoders.Vector3(value.Origin),
-			Direction = encoders.Vector3(value.Direction),
-		}
-	end,
 
-	Ref = function(value)
+		toPod = function(roblox)
-		return nil
+			return {roblox.r, roblox.g, roblox.b}
-	end,
+		end,
+	},
 
-	Region3int16 = function(value)
+	Color3uint8 = {
-		return {
+		fromPod = unpackDecoder(Color3.fromRGB),
-			encoders.Vector3int16(value.Min),
-			encoders.Vector3int16(value.Max),
-		}
-	end,
 
-	Color3uint8 = function(value)
+		toPod = function(roblox)
-		return {
+			return {
-			math.round(value.R * 255),
+				math.round(roblox.R * 255),
-			math.round(value.G * 255),
+				math.round(roblox.G * 255),
-			math.round(value.B * 255),
+				math.round(roblox.B * 255),
-		}
+			}
-	end,
+		end,
-}
+	},
 
-local decoders
+	ColorSequence = {
-decoders = {
+		fromPod = function(pod)
-	Bool = identity,
+			local keypoints = {}
-	Content = identity,
-	Enum = identity,
-	Float32 = identity,
-	Float64 = identity,
-	Int32 = identity,
-	Int64 = identity,
-	String = identity,
 
-	BinaryString = base64.decode,
+			for index, keypoint in ipairs(pod.Keypoints) do
-	SharedString = base64.decode,
+				keypoints[index] = ColorSequenceKeypoint.new(
+					keypoint.Time,
+					types.Color3.fromPod(keypoint.Color)
+				)
+			end
 
-	BrickColor = BrickColor.new,
+			return ColorSequence.new(keypoints)
+		end,
 
-	Color3 = unpackDecoder(Color3.new),
+		toPod = function(roblox)
-	Color3uint8 = unpackDecoder(Color3.fromRGB),
+			local keypoints = {}
-	NumberRange = unpackDecoder(NumberRange.new),
-	UDim = unpackDecoder(UDim.new),
-	Vector2 = unpackDecoder(Vector2.new),
-	Vector2int16 = unpackDecoder(Vector2int16.new),
-	Vector3 = unpackDecoder(Vector3.new),
-	Vector3int16 = unpackDecoder(Vector3int16.new),
 
-	UDim2 = function(value)
+			for index, keypoint in ipairs(roblox.Keypoints) do
-		return UDim2.new(
+				keypoints[index] = {
-			value[1][1],
+					Time = keypoint.Time,
-			value[1][2],
+					Color = types.Color3.toPod(keypoint.Value),
-			value[2][1],
+				}
-			value[2][2]
+			end
-		)
-	end,
 
-	Axes = function(value)
+			return {
-		local axes = {}
+				Keypoints = keypoints,
-		for index, axisName in ipairs(value) do
+			}
-			axes[index] = Enum.Axis[axisName]
+		end,
-		end
+	},
 
-		return Axes.new(unpack(axes))
+	Content = {
-	end,
+		fromPod = identity,
+		toPod = identity,
+	},
 
-	Faces = function(value)
+	Enum = {
-		local normalIds = {}
+		fromPod = identity,
-		for index, faceName in ipairs(value) do
-			normalIds[index] = Enum.NormalId[faceName]
-		end
 
-		return Faces.new(unpack(normalIds))
+		toPod = function(roblox)
-	end,
+			-- FIXME: More robust handling of enums
+			if typeof(roblox) == "number" then
+				return roblox
+			else
+				return roblox.Value
+			end
+		end,
+	},
 
-	CFrame = function(value)
+	Faces = {
-		return CFrame.fromMatrix(
+		fromPod = function(pod)
-			decoders.Vector3(value.Position),
+			local faces = {}
-			decoders.Vector3(value.Orientation[1]),
-			decoders.Vector3(value.Orientation[2]),
-			decoders.Vector3(value.Orientation[3])
-		)
-	end,
 
-	Rect = function(value)
+			for index, faceName in ipairs(pod) do
-		return Rect.new(
+				faces[index] = Enum.NormalId[faceName]
-			decoders.Vector2(value[1]),
+			end
-			decoders.Vector2(value[2])
-		)
-	end,
 
-	Ray = function(value)
+			return Faces.new(unpack(faces))
-		return Ray.new(
+		end,
-			decoders.Vector3(value.Origin),
-			decoders.Vector3(value.Direction)
-		)
-	end,
 
-	NumberSequence = function(value)
+		toPod = function(roblox)
-		local keypoints = {}
+			local pod = {}
 
-		for index, keypoint in ipairs(value.Keypoints) do
+			for _, face in ipairs(ALL_FACES) do
-			keypoints[index] = NumberSequenceKeypoint.new(
+				if roblox[face] then
-				keypoint.Time,
+					table.insert(pod, face)
-				keypoint.Value,
+				end
-				keypoint.Envelope
+			end
+
+			return pod
+		end,
+	},
+
+	Float32 = {
+		fromPod = identity,
+		toPod = serializeFloat,
+	},
+
+	Float64 = {
+		fromPod = identity,
+		toPod = serializeFloat,
+	},
+
+	Int32 = {
+		fromPod = identity,
+		toPod = identity,
+	},
+
+	Int64 = {
+		fromPod = identity,
+		toPod = identity,
+	},
+
+	NumberRange = {
+		fromPod = unpackDecoder(NumberRange.new),
+
+		toPod = function(roblox)
+			return {roblox.Min, roblox.Max}
+		end,
+	},
+
+	NumberSequence = {
+		fromPod = function(pod)
+			local keypoints = {}
+
+			for index, keypoint in ipairs(pod.Keypoints) do
+				keypoints[index] = NumberSequenceKeypoint.new(
+					keypoint.Time,
+					keypoint.Value,
+					keypoint.Envelope
+				)
+			end
+
+			return NumberSequence.new(keypoints)
+		end,
+
+		toPod = function(roblox)
+			local keypoints = {}
+
+			for index, keypoint in ipairs(roblox.Keypoints) do
+				keypoints[index] = {
+					Time = keypoint.Time,
+					Value = keypoint.Value,
+					Envelope = keypoint.Envelope,
+				}
+			end
+
+			return {
+				Keypoints = keypoints,
+			}
+		end,
+	},
+
+	PhysicalProperties = {
+		fromPod = function(pod)
+			if pod == "Default" then
+				return nil
+			else
+				return PhysicalProperties.new(
+					pod.Density,
+					pod.Friction,
+					pod.Elasticity,
+					pod.FrictionWeight,
+					pod.ElasticityWeight
+				)
+			end
+		end,
+
+		toPod = function(roblox)
+			if roblox == nil then
+				return "Default"
+			else
+				return {
+					Density = roblox.Density,
+					Friction = roblox.Friction,
+					Elasticity = roblox.Elasticity,
+					FrictionWeight = roblox.FrictionWeight,
+					ElasticityWeight = roblox.ElasticityWeight,
+				}
+			end
+		end,
+	},
+
+	Ray = {
+		fromPod = function(pod)
+			return Ray.new(
+				types.Vector3.fromPod(pod.Origin),
+				types.Vector3.fromPod(pod.Direction)
 			)
-		end
+		end,
 
-		return NumberSequence.new(keypoints)
+		toPod = function(roblox)
-	end,
+			return {
+				Origin = types.Vector3.toPod(roblox.Origin),
+				Direction = types.Vector3.toPod(roblox.Direction),
+			}
+		end,
+	},
 
-	ColorSequence = function(value)
+	Rect = {
-		local keypoints = {}
+		fromPod = function(pod)
-
+			return Rect.new(
-		for index, keypoint in ipairs(value.Keypoints) do
+				types.Vector2.fromPod(pod[1]),
-			keypoints[index] = ColorSequenceKeypoint.new(
+				types.Vector2.fromPod(pod[2])
-				keypoint.Time,
-				Color3.new(unpack(keypoint.Color))
 			)
-		end
+		end,
 
-		return ColorSequence.new(keypoints)
+		toPod = function(roblox)
-	end,
+			return {
+				types.Vector2.toPod(roblox.Min),
+				types.Vector2.toPod(roblox.Max),
+			}
+		end,
+	},
 
-	PhysicalProperties = function(properties)
+	Ref = {
-		if properties == nil then
+		fromPod = function(_pod)
-			return nil
+			error("Ref cannot be decoded on its own")
-		else
+		end,
-			return PhysicalProperties.new(
+
-				properties.Density,
+		toPod = function(_roblox)
-				properties.Friction,
+			error("Ref can not be encoded on its own")
-				properties.Elasticity,
+		end,
-				properties.FrictionWeight,
+	},
-				properties.ElasticityWeight
+
+	Region3 = {
+		fromPod = function(pod)
+			error("Region3 is not implemented")
+		end,
+
+		toPod = function(roblox)
+			error("Region3 is not implemented")
+		end,
+	},
+
+	Region3int16 = {
+		fromPod = function(pod)
+			return Region3int16.new(
+				types.Vector3int16.fromPod(pod[1]),
+				types.Vector3int16.fromPod(pod[2])
 			)
-		end
+		end,
-	end,
 
-	Ref = function()
+		toPod = function(roblox)
-		return nil
+			return {
-	end,
+				types.Vector3int16.toPod(roblox.Min),
+				types.Vector3int16.toPod(roblox.Max),
+			}
+		end,
+	},
 
-	Region3int16 = function(value)
+	SharedString = {
-		return Region3int16.new(
+		fromPod = function(pod)
-			decoders.Vector3int16(value[1]),
+			error("SharedString is not supported")
-			decoders.Vector3int16(value[2])
+		end,
-		)
+
-	end,
+		toPod = function(roblox)
+			error("SharedString is not supported")
+		end,
+	},
+
+	String = {
+		fromPod = identity,
+		toPod = identity,
+	},
+
+	UDim = {
+		fromPod = unpackDecoder(UDim.new),
+
+		toPod = function(roblox)
+			return {roblox.Scale, roblox.Offset}
+		end,
+	},
+
+	UDim2 = {
+		fromPod = function(pod)
+			return UDim2.new(
+				types.UDim.fromPod(pod[1]),
+				types.UDim.fromPod(pod[2])
+			)
+		end,
+
+		toPod = function(roblox)
+			return {
+				types.UDim.toPod(roblox.X),
+				types.UDim.toPod(roblox.Y),
+			}
+		end,
+	},
+
+	Vector2 = {
+		fromPod = unpackDecoder(Vector2.new),
+
+		toPod = function(roblox)
+			return {
+				serializeFloat(roblox.X),
+				serializeFloat(roblox.Y),
+			}
+		end,
+	},
+
+	Vector2int16 = {
+		fromPod = unpackDecoder(Vector2int16.new),
+
+		toPod = function(roblox)
+			return {roblox.X, roblox.Y}
+		end,
+	},
+
+	Vector3 = {
+		fromPod = unpackDecoder(Vector3.new),
+
+		toPod = function(roblox)
+			return {
+				serializeFloat(roblox.X),
+				serializeFloat(roblox.Y),
+				serializeFloat(roblox.Z),
+			}
+		end,
+	},
+
+	Vector3int16 = {
+		fromPod = unpackDecoder(Vector3int16.new),
+
+		toPod = function(roblox)
+			return {roblox.X, roblox.Y, roblox.Z}
+		end,
+	},
 }
 
 local EncodedValue = {}
 
 function EncodedValue.decode(encodedValue)
-	local decoder = decoders[encodedValue.Type]
+	local typeImpl = types[encodedValue.Type]
-	if decoder ~= nil then
+	if typeImpl == nil then
-		return true, decoder(encodedValue.Value)
+		return false, "Couldn't decode value " .. tostring(encodedValue.Type)
 	end
 
-	return false, "Couldn't decode value " .. tostring(encodedValue.Type)
+	return true, typeImpl.fromPod(encodedValue.Value)
 end
 
 function EncodedValue.encode(rbxValue, propertyType)
 	assert(propertyType ~= nil, "Property type descriptor is required")
 
-	local encoder = encoders[propertyType]
+	local typeImpl = types[propertyType]
-
+	if typeImpl == nil then
-	if encoder == nil then
 		return false, ("Missing encoder for property type %q"):format(propertyType)
 	end
 
 	return true, {
 		Type = propertyType,
-		Value = encoder(rbxValue),
+		Value = typeImpl.toPod(rbxValue),
 	}
 end
 

plugin/rbx_dom_lua/src/EncodedValue.spec.lua

@@ -1,7 +1,6 @@
 return function()
 	local HttpService = game:GetService("HttpService")
 	
-	local RbxDom = require(script.Parent)
 	local EncodedValue = require(script.Parent.EncodedValue)
 	local allValues = require(script.Parent.allValues)
 
@@ -39,11 +38,21 @@ return function()
 		end
 	end
 
+	local extraAssertions = {
+		CFrame = function(value)
+			expect(value).to.equal(CFrame.new(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12))
+		end,
+	}
+
 	for testName, testEntry in pairs(allValues) do
 		it("round trip " .. testName, function()
 			local ok, decoded = EncodedValue.decode(testEntry.value)
 			assert(ok, decoded)
 
+			if extraAssertions[testName] ~= nil then
+				extraAssertions[testName](decoded)
+			end
+
 			local ok, encoded = EncodedValue.encode(decoded, testEntry.ty)
 			assert(ok, encoded)
 

plugin/rbx_dom_lua/src/allValues.json

@@ -1,160 +1,4 @@
 {
-  "Color3uint8": {
-    "value": {
-      "Type": "Color3uint8",
-      "Value": [
-        0,
-        128,
-        255
-      ]
-    },
-    "ty": "Color3uint8"
-  },
-  "Bool": {
-    "value": {
-      "Type": "Bool",
-      "Value": true
-    },
-    "ty": "Bool"
-  },
-  "BinaryString": {
-    "value": {
-      "Type": "BinaryString",
-      "Value": "SGVsbG8h"
-    },
-    "ty": "BinaryString"
-  },
-  "BrickColor": {
-    "value": {
-      "Type": "BrickColor",
-      "Value": 1004
-    },
-    "ty": "BrickColor"
-  },
-  "Vector3": {
-    "value": {
-      "Type": "Vector3",
-      "Value": [
-        -300.0,
-        0.0,
-        1500.0
-      ]
-    },
-    "ty": "Vector3"
-  },
-  "String": {
-    "value": {
-      "Type": "String",
-      "Value": "Hello, world!"
-    },
-    "ty": "String"
-  },
-  "NumberRange": {
-    "value": {
-      "Type": "NumberRange",
-      "Value": [
-        -36.0,
-        94.0
-      ]
-    },
-    "ty": "NumberRange"
-  },
-  "Int64": {
-    "value": {
-      "Type": "Int64",
-      "Value": 23491023
-    },
-    "ty": "Int64"
-  },
-  "Vector3int16": {
-    "value": {
-      "Type": "Vector3int16",
-      "Value": [
-        60,
-        37,
-        -450
-      ]
-    },
-    "ty": "Vector3int16"
-  },
-  "Float32": {
-    "value": {
-      "Type": "Float32",
-      "Value": 15.0
-    },
-    "ty": "Float32"
-  },
-  "NumberSequence": {
-    "value": {
-      "Type": "NumberSequence",
-      "Value": {
-        "Keypoints": [
-          {
-            "Time": 0.0,
-            "Value": 5.0,
-            "Envelope": 2.0
-          },
-          {
-            "Time": 1.0,
-            "Value": 22.0,
-            "Envelope": 0.0
-          }
-        ]
-      }
-    },
-    "ty": "NumberSequence"
-  },
-  "ColorSequence": {
-    "value": {
-      "Type": "ColorSequence",
-      "Value": {
-        "Keypoints": [
-          {
-            "Time": 0.0,
-            "Color": [
-              1.0,
-              1.0,
-              0.5
-            ]
-          },
-          {
-            "Time": 1.0,
-            "Color": [
-              0.0,
-              0.0,
-              0.0
-            ]
-          }
-        ]
-      }
-    },
-    "ty": "ColorSequence"
-  },
-  "Ray": {
-    "value": {
-      "Type": "Ray",
-      "Value": {
-        "Origin": [
-          1.0,
-          2.0,
-          3.0
-        ],
-        "Direction": [
-          4.0,
-          5.0,
-          6.0
-        ]
-      }
-    },
-    "ty": "Ray"
-  },
-  "Int32": {
-    "value": {
-      "Type": "Int32",
-      "Value": 6014
-    },
-    "ty": "Int32"
-  },
   "Axes": {
     "value": {
       "Type": "Axes",
@@ -166,98 +10,26 @@
     },
     "ty": "Axes"
   },
-  "Enum": {
+  "BinaryString": {
     "value": {
-      "Type": "Enum",
+      "Type": "BinaryString",
-      "Value": 1234
+      "Value": "SGVsbG8h"
     },
-    "ty": "Enum"
+    "ty": "BinaryString"
   },
-  "Faces": {
+  "Bool": {
     "value": {
-      "Type": "Faces",
+      "Type": "Bool",
-      "Value": [
+      "Value": true
-        "Right",
-        "Top",
-        "Back",
-        "Left",
-        "Bottom",
-        "Front"
-      ]
     },
-    "ty": "Faces"
+    "ty": "Bool"
   },
-  "UDim": {
+  "BrickColor": {
     "value": {
-      "Type": "UDim",
+      "Type": "BrickColor",
-      "Value": [
+      "Value": 1004
-        1.0,
-        32
-      ]
     },
-    "ty": "UDim"
+    "ty": "BrickColor"
-  },
-  "Vector2": {
-    "value": {
-      "Type": "Vector2",
-      "Value": [
-        -50.0,
-        50.0
-      ]
-    },
-    "ty": "Vector2"
-  },
-  "Color3": {
-    "value": {
-      "Type": "Color3",
-      "Value": [
-        1.0,
-        2.0,
-        3.0
-      ]
-    },
-    "ty": "Color3"
-  },
-  "Float64": {
-    "value": {
-      "Type": "Float64",
-      "Value": 15123.0
-    },
-    "ty": "Float64"
-  },
-  "UDim2": {
-    "value": {
-      "Type": "UDim2",
-      "Value": [
-        [
-          -1.0,
-          100
-        ],
-        [
-          1.0,
-          -100
-        ]
-      ]
-    },
-    "ty": "UDim2"
-  },
-  "Region3int16": {
-    "value": {
-      "Type": "Region3int16",
-      "Value": [
-        [
-          -10,
-          -5,
-          0
-        ],
-        [
-          5,
-          10,
-          15
-        ]
-      ]
-    },
-    "ty": "Region3int16"
   },
   "CFrame": {
     "value": {
@@ -289,6 +61,54 @@
     },
     "ty": "CFrame"
   },
+  "Color3": {
+    "value": {
+      "Type": "Color3",
+      "Value": [
+        1.0,
+        2.0,
+        3.0
+      ]
+    },
+    "ty": "Color3"
+  },
+  "Color3uint8": {
+    "value": {
+      "Type": "Color3uint8",
+      "Value": [
+        0,
+        128,
+        255
+      ]
+    },
+    "ty": "Color3uint8"
+  },
+  "ColorSequence": {
+    "value": {
+      "Type": "ColorSequence",
+      "Value": {
+        "Keypoints": [
+          {
+            "Time": 0.0,
+            "Color": [
+              1.0,
+              1.0,
+              0.5
+            ]
+          },
+          {
+            "Time": 1.0,
+            "Color": [
+              0.0,
+              0.0,
+              0.0
+            ]
+          }
+        ]
+      }
+    },
+    "ty": "ColorSequence"
+  },
   "Content": {
     "value": {
       "Type": "Content",
@@ -296,7 +116,86 @@
     },
     "ty": "Content"
   },
-  "PhysicalProperties": {
+  "Enum": {
+    "value": {
+      "Type": "Enum",
+      "Value": 1234
+    },
+    "ty": "Enum"
+  },
+  "Faces": {
+    "value": {
+      "Type": "Faces",
+      "Value": [
+        "Right",
+        "Top",
+        "Back",
+        "Left",
+        "Bottom",
+        "Front"
+      ]
+    },
+    "ty": "Faces"
+  },
+  "Float32": {
+    "value": {
+      "Type": "Float32",
+      "Value": 15.0
+    },
+    "ty": "Float32"
+  },
+  "Float64": {
+    "value": {
+      "Type": "Float64",
+      "Value": 15123.0
+    },
+    "ty": "Float64"
+  },
+  "Int32": {
+    "value": {
+      "Type": "Int32",
+      "Value": 6014
+    },
+    "ty": "Int32"
+  },
+  "Int64": {
+    "value": {
+      "Type": "Int64",
+      "Value": 23491023
+    },
+    "ty": "Int64"
+  },
+  "NumberRange": {
+    "value": {
+      "Type": "NumberRange",
+      "Value": [
+        -36.0,
+        94.0
+      ]
+    },
+    "ty": "NumberRange"
+  },
+  "NumberSequence": {
+    "value": {
+      "Type": "NumberSequence",
+      "Value": {
+        "Keypoints": [
+          {
+            "Time": 0.0,
+            "Value": 5.0,
+            "Envelope": 2.0
+          },
+          {
+            "Time": 1.0,
+            "Value": 22.0,
+            "Envelope": 0.0
+          }
+        ]
+      }
+    },
+    "ty": "NumberSequence"
+  },
+  "PhysicalProperties-Custom": {
     "value": {
       "Type": "PhysicalProperties",
       "Value": {
@@ -309,6 +208,31 @@
     },
     "ty": "PhysicalProperties"
   },
+  "PhysicalProperties-Default": {
+    "value": {
+      "Type": "PhysicalProperties",
+      "Value": "Default"
+    },
+    "ty": "PhysicalProperties"
+  },
+  "Ray": {
+    "value": {
+      "Type": "Ray",
+      "Value": {
+        "Origin": [
+          1.0,
+          2.0,
+          3.0
+        ],
+        "Direction": [
+          4.0,
+          5.0,
+          6.0
+        ]
+      }
+    },
+    "ty": "Ray"
+  },
   "Rect": {
     "value": {
       "Type": "Rect",
@@ -325,6 +249,67 @@
     },
     "ty": "Rect"
   },
+  "Region3int16": {
+    "value": {
+      "Type": "Region3int16",
+      "Value": [
+        [
+          -10,
+          -5,
+          0
+        ],
+        [
+          5,
+          10,
+          15
+        ]
+      ]
+    },
+    "ty": "Region3int16"
+  },
+  "String": {
+    "value": {
+      "Type": "String",
+      "Value": "Hello, world!"
+    },
+    "ty": "String"
+  },
+  "UDim": {
+    "value": {
+      "Type": "UDim",
+      "Value": [
+        1.0,
+        32
+      ]
+    },
+    "ty": "UDim"
+  },
+  "UDim2": {
+    "value": {
+      "Type": "UDim2",
+      "Value": [
+        [
+          -1.0,
+          100
+        ],
+        [
+          1.0,
+          -100
+        ]
+      ]
+    },
+    "ty": "UDim2"
+  },
+  "Vector2": {
+    "value": {
+      "Type": "Vector2",
+      "Value": [
+        -50.0,
+        50.0
+      ]
+    },
+    "ty": "Vector2"
+  },
   "Vector2int16": {
     "value": {
       "Type": "Vector2int16",
@@ -334,5 +319,27 @@
       ]
     },
     "ty": "Vector2int16"
+  },
+  "Vector3": {
+    "value": {
+      "Type": "Vector3",
+      "Value": [
+        -300.0,
+        0.0,
+        1500.0
+      ]
+    },
+    "ty": "Vector3"
+  },
+  "Vector3int16": {
+    "value": {
+      "Type": "Vector3int16",
+      "Value": [
+        60,
+        37,
+        -450
+      ]
+    },
+    "ty": "Vector3int16"
   }
-}
+}

plugin/rbx_dom_lua/src/database.json

@@ -17708,6 +17708,10 @@
           "Type": "Bool",
           "Value": true
         },
+        "AssetId": {
+          "Type": "Content",
+          "Value": ""
+        },
         "AttributesSerialize": {
           "Type": "BinaryString",
           "Value": ""
@@ -19100,6 +19104,19 @@
       "Tags": [],
       "Superclass": "TriangleMeshPart",
       "Properties": {
+        "AssetId": {
+          "Name": "AssetId",
+          "Scriptability": "None",
+          "DataType": {
+            "Value": "Content"
+          },
+          "Tags": [],
+          "Kind": {
+            "Canonical": {
+              "Serialization": "Serializes"
+            }
+          }
+        },
         "RenderFidelity": {
           "Name": "RenderFidelity",
           "Scriptability": "ReadWrite",
@@ -19161,6 +19178,10 @@
           "Type": "Bool",
           "Value": false
         },
+        "AssetId": {
+          "Type": "Content",
+          "Value": ""
+        },
         "AttributesSerialize": {
           "Type": "BinaryString",
           "Value": ""
@@ -37376,6 +37397,10 @@
           "Type": "Bool",
           "Value": false
         },
+        "AssetId": {
+          "Type": "Content",
+          "Value": ""
+        },
         "AttributesSerialize": {
           "Type": "BinaryString",
           "Value": ""