roblox-opencode 1.0.0

package/vendor/rbxutil/ser/init.luau

@@ -0,0 +1,175 @@
+--!strict
+
+-- Ser
+-- Stephen Leitnick
+-- August 28, 2020
+
+--[[
+
+	Ser is a serialization/deserialization utility module that is used
+	by Knit to automatically serialize/deserialize values passing
+	through remote functions and remote events.
+
+
+	Ser.Classes = {
+		[ClassName] = {
+			Serialize = (value) -> serializedValue
+			Deserialize = (value) => deserializedValue
+		}
+	}
+
+	Ser.SerializeArgs(...)            -> table
+	Ser.SerializeArgsAndUnpack(...)   -> Tuple
+	Ser.DeserializeArgs(...)          -> table
+	Ser.DeserializeArgsAndUnpack(...) -> Tuple
+	Ser.Serialize(value: any)         -> any
+	Ser.Deserialize(value: any)       -> any
+	Ser.UnpackArgs(args: table)       -> Tuple
+
+--]]
+
+type Args = {
+	n: number,
+	[any]: any,
+}
+
+local Option = require(script.Parent.Option)
+
+--[=[
+	@class Ser
+
+	Library for serializing and deserializing data.
+
+	See the `Classes` property for information on extending the use
+	of the Ser library to include other classes.
+
+]=]
+local Ser = {}
+
+--[=[
+	@within Ser
+	@prop Classes table
+
+	A dictionary of classes along with a Serialize and Deserialize function.
+	For instance, the default class added is the Option class, which looks
+	like the following:
+
+	```lua
+	Ser.Classes.Option = {
+		Serialize = function(opt) return opt:Serialize() end;
+		Deserialize = Option.Deserialize;
+	}
+	```
+
+	Add to this table in order to extend what classes are automatically
+	serialized/deserialized.
+
+	The Ser library checks every object's `ClassName` field in both serialized
+	and deserialized data in order to map it to the correct function within
+	the Classes table.
+]=]
+Ser.Classes = {
+	Option = {
+		Serialize = function(opt)
+			return opt:Serialize()
+		end,
+		Deserialize = Option.Deserialize,
+	},
+}
+
+--[=[
+	@param ... any
+	@return args: table
+	Serializes the arguments and returns the serialized values in a table.
+]=]
+function Ser.SerializeArgs(...: any): Args
+	local args = table.pack(...)
+	for i, arg in ipairs(args) do
+		if type(arg) == "table" then
+			local ser = Ser.Classes[arg.ClassName]
+			if ser then
+				args[i] = ser.Serialize(arg)
+			end
+		end
+	end
+	return args
+end
+
+--[=[
+	@param ... any
+	@return args: ...any
+	Serializes the arguments and returns the serialized values.
+]=]
+function Ser.SerializeArgsAndUnpack(...: any): ...any
+	local args = Ser.SerializeArgs(...)
+	return table.unpack(args, 1, args.n)
+end
+
+--[=[
+	@param ... any
+	@return args: table
+	Deserializes the arguments and returns the deserialized values in a table.
+]=]
+function Ser.DeserializeArgs(...: any): Args
+	local args = table.pack(...)
+	for i, arg in ipairs(args) do
+		if type(arg) == "table" then
+			local ser = Ser.Classes[arg.ClassName]
+			if ser then
+				args[i] = ser.Deserialize(arg)
+			end
+		end
+	end
+	return args
+end
+
+--[=[
+	@param ... any
+	@return args: table
+	Deserializes the arguments and returns the deserialized values.
+]=]
+function Ser.DeserializeArgsAndUnpack(...: any): ...any
+	local args = Ser.DeserializeArgs(...)
+	return table.unpack(args, 1, args.n)
+end
+
+--[=[
+	@param value any
+	@return any
+	Serializes the given value.
+]=]
+function Ser.Serialize(value: any): any
+	if type(value) == "table" then
+		local ser = Ser.Classes[value.ClassName]
+		if ser then
+			value = ser.Serialize(value)
+		end
+	end
+	return value
+end
+
+--[=[
+	@param value any
+	@return any
+	Deserializes the given value.
+]=]
+function Ser.Deserialize(value: any): any
+	if type(value) == "table" then
+		local ser = Ser.Classes[value.ClassName]
+		if ser then
+			value = ser.Deserialize(value)
+		end
+	end
+	return value
+end
+
+--[=[
+	@param value any
+	@return any
+	Unpacks the arguments returned by either `SerializeArgs` or `DeserializeArgs`.
+]=]
+function Ser.UnpackArgs(value: Args): ...any
+	return table.unpack(value, 1, value.n)
+end
+
+return Ser

package/vendor/rbxutil/ser/init.test.luau

@@ -0,0 +1,50 @@
+local ServerScriptService = game:GetService("ServerScriptService")
+
+local Test = require(ServerScriptService.TestRunner.Test)
+
+return function(ctx: Test.TestContext)
+	local Option = require(script.Parent.Parent.Option)
+	local Ser = require(script.Parent)
+
+	ctx:Describe("SerializeArgs", function()
+		ctx:Test("should serialize an option", function()
+			local opt = Option.Some(32)
+			local serOpt = table.unpack(Ser.SerializeArgs(opt))
+			ctx:Expect(serOpt.ClassName):ToBe("Option")
+			ctx:Expect(serOpt.Value):ToBe(32)
+		end)
+	end)
+
+	ctx:Describe("SerializeArgsAndUnpack", function()
+		ctx:Test("should serialize an option", function()
+			local opt = Option.Some(32)
+			local serOpt = Ser.SerializeArgsAndUnpack(opt)
+			ctx:Expect(serOpt.ClassName):ToBe("Option")
+			ctx:Expect(serOpt.Value):ToBe(32)
+		end)
+	end)
+
+	ctx:Describe("DeserializeArgs", function()
+		ctx:Test("should deserialize args to option", function()
+			local serOpt = {
+				ClassName = "Option",
+				Value = 32,
+			}
+			local opt = table.unpack(Ser.DeserializeArgs(serOpt))
+			ctx:Expect(Option.Is(opt)):ToBe(true)
+			ctx:Expect(opt:Contains(32)):ToBe(true)
+		end)
+	end)
+
+	ctx:Describe("DeserializeArgsAndUnpack", function()
+		ctx:Test("should deserialize args to option", function()
+			local serOpt = {
+				ClassName = "Option",
+				Value = 32,
+			}
+			local opt = Ser.DeserializeArgsAndUnpack(serOpt)
+			ctx:Expect(Option.Is(opt)):ToBe(true)
+			ctx:Expect(opt:Contains(32)):ToBe(true)
+		end)
+	end)
+end

package/vendor/rbxutil/ser/wally.toml

@@ -0,0 +1,11 @@
+[package]
+name = "sleitnick/ser"
+description = "Ser class for serialization and deserialization"
+version = "1.0.5"
+license = "MIT"
+authors = ["Stephen Leitnick"]
+registry = "https://github.com/UpliftGames/wally-index"
+realm = "shared"
+
+[dependencies]
+Option = "sleitnick/option@^1.0"

package/vendor/rbxutil/shake/index.d.ts

@@ -0,0 +1,36 @@
+declare namespace Shake {
+	interface Constructor {
+		new (): Shake;
+
+		InverseSquare: (shake: Vector3, distance: number) => Vector3;
+		NextRenderName: () => string;
+	}
+}
+
+type UpdateReturn = [position: Vector3, rotation: Vector3, done: boolean];
+
+interface Shake {
+	Amplitude: number;
+	Frequency: number;
+	FadeInTime: number;
+	FadeOutTime: number;
+	SustainTime: number;
+	Sustain: boolean;
+	PositionInfluence: Vector3;
+	RotationInfluence: Vector3;
+	TimeFunction: () => number;
+
+	Start(): void;
+	Stop(): void;
+	IsShaking(): boolean;
+	StopSustain(): void;
+	Update(): LuaTuple<UpdateReturn>;
+	OnSignal(signal: RBXScriptSignal, callback: (...args: UpdateReturn) => void): RBXScriptConnection;
+	BindToRenderStep(name: string, priority: number, callback: (...args: UpdateReturn) => void): void;
+	Clone(): Shake;
+	Destroy(): void;
+}
+
+declare const Shake: Shake.Constructor;
+
+export = Shake;