roblox-opencode 1.0.0

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

@@ -0,0 +1,342 @@
+local ServerScriptService = game:GetService("ServerScriptService")
+
+local Test = require(ServerScriptService.TestRunner.Test)
+
+return function(ctx: Test.TestContext)
+	local Option = require(script.Parent)
+
+	ctx:Describe("Some", function()
+		ctx:Test("should create some option", function()
+			local opt = Option.Some(true)
+			ctx:Expect(opt:IsSome()):ToBe(true)
+		end)
+
+		ctx:Test("should fail to create some option with nil", function()
+			ctx:Expect(function()
+				Option.Some(nil)
+			end):ToThrow()
+		end)
+
+		ctx:Test("should not be none", function()
+			local opt = Option.Some(10)
+			ctx:Expect(opt:IsNone()):ToBe(false)
+		end)
+	end)
+
+	ctx:Describe("None", function()
+		ctx:Test("should be able to reference none", function()
+			ctx:Expect(function()
+				local _none = Option.None
+			end)
+				:Not()
+				:ToThrow()
+		end)
+
+		ctx:Test("should be able to check if none", function()
+			local none = Option.None
+			ctx:Expect(none:IsNone()):ToBe(true)
+		end)
+
+		ctx:Test("should be able to check if not some", function()
+			local none = Option.None
+			ctx:Expect(none:IsSome()):ToBe(false)
+		end)
+	end)
+
+	ctx:Describe("Equality", function()
+		ctx:Test("should equal the same some from same options", function()
+			local opt = Option.Some(32)
+			ctx:Expect(opt):ToBe(opt)
+		end)
+
+		ctx:Test("should equal the same some from different options", function()
+			local opt1 = Option.Some(32)
+			local opt2 = Option.Some(32)
+			ctx:Expect(opt1):ToBe(opt2)
+		end)
+	end)
+
+	ctx:Describe("Assert", function()
+		ctx:Test("should assert that a some option is an option", function()
+			ctx:Expect(Option.Is(Option.Some(10))):ToBe(true)
+		end)
+
+		ctx:Test("should assert that a none option is an option", function()
+			ctx:Expect(Option.Is(Option.None)):ToBe(true)
+		end)
+
+		ctx:Test("should assert that a non-option is not an option", function()
+			ctx:Expect(Option.Is(10)):ToBe(false)
+			ctx:Expect(Option.Is(true)):ToBe(false)
+			ctx:Expect(Option.Is(false)):ToBe(false)
+			ctx:Expect(Option.Is("Test")):ToBe(false)
+			ctx:Expect(Option.Is({})):ToBe(false)
+			ctx:Expect(Option.Is(function() end)):ToBe(false)
+			ctx:Expect(Option.Is(coroutine.create(function() end))):ToBe(false)
+			ctx:Expect(Option.Is(Option)):ToBe(false)
+		end)
+	end)
+
+	ctx:Describe("Unwrap", function()
+		ctx:Test("should unwrap a some option", function()
+			local opt = Option.Some(10)
+			ctx:Expect(function()
+				opt:Unwrap()
+			end)
+				:Not()
+				:ToThrow()
+			ctx:Expect(opt:Unwrap()):ToBe(10)
+		end)
+
+		ctx:Test("should fail to unwrap a none option", function()
+			local opt = Option.None
+			ctx:Expect(function()
+				opt:Unwrap()
+			end):ToThrow()
+		end)
+	end)
+
+	ctx:Describe("Expect", function()
+		ctx:Test("should expect a some option", function()
+			local opt = Option.Some(10)
+			ctx:Expect(function()
+				opt:Expect("Expecting some value")
+			end)
+				:Not()
+				:ToThrow()
+			ctx:Expect(opt:Unwrap()):ToBe(10)
+		end)
+
+		ctx:Test("should fail when expecting on a none option", function()
+			local opt = Option.None
+			ctx:Expect(function()
+				opt:Expect("Expecting some value")
+			end):ToThrow()
+		end)
+	end)
+
+	ctx:Describe("ExpectNone", function()
+		ctx:Test("should fail to expect a none option", function()
+			local opt = Option.Some(10)
+			ctx:Expect(function()
+				opt:ExpectNone("Expecting some value")
+			end):ToThrow()
+		end)
+
+		ctx:Test("should expect a none option", function()
+			local opt = Option.None
+			ctx:Expect(function()
+				opt:ExpectNone("Expecting some value")
+			end)
+				:Not()
+				:ToThrow()
+		end)
+	end)
+
+	ctx:Describe("UnwrapOr", function()
+		ctx:Test("should unwrap a some option", function()
+			local opt = Option.Some(10)
+			ctx:Expect(opt:UnwrapOr(20)):ToBe(10)
+		end)
+
+		ctx:Test("should unwrap a none option", function()
+			local opt = Option.None
+			ctx:Expect(opt:UnwrapOr(20)):ToBe(20)
+		end)
+	end)
+
+	ctx:Describe("UnwrapOrElse", function()
+		ctx:Test("should unwrap a some option", function()
+			local opt = Option.Some(10)
+			local result = opt:UnwrapOrElse(function()
+				return 30
+			end)
+			ctx:Expect(result):ToBe(10)
+		end)
+
+		ctx:Test("should unwrap a none option", function()
+			local opt = Option.None
+			local result = opt:UnwrapOrElse(function()
+				return 30
+			end)
+			ctx:Expect(result):ToBe(30)
+		end)
+	end)
+
+	ctx:Describe("And", function()
+		ctx:Test("should return the second option with and when both are some", function()
+			local opt1 = Option.Some(1)
+			local opt2 = Option.Some(2)
+			ctx:Expect(opt1:And(opt2)):ToBe(opt2)
+		end)
+
+		ctx:Test("should return none when first option is some and second option is none", function()
+			local opt1 = Option.Some(1)
+			local opt2 = Option.None
+			ctx:Expect(opt1:And(opt2):IsNone()):ToBe(true)
+		end)
+
+		ctx:Test("should return none when first option is none and second option is some", function()
+			local opt1 = Option.None
+			local opt2 = Option.Some(2)
+			ctx:Expect(opt1:And(opt2):IsNone()):ToBe(true)
+		end)
+
+		ctx:Test("should return none when both options are none", function()
+			local opt1 = Option.None
+			local opt2 = Option.None
+			ctx:Expect(opt1:And(opt2):IsNone()):ToBe(true)
+		end)
+	end)
+
+	ctx:Describe("AndThen", function()
+		ctx:Test("should pass the some value to the predicate", function()
+			local opt = Option.Some(32)
+			opt:AndThen(function(value)
+				ctx:Expect(value):ToBe(32)
+				return Option.None
+			end)
+		end)
+
+		ctx:Test("should throw if an option is not returned from predicate", function()
+			local opt = Option.Some(32)
+			ctx:Expect(function()
+				opt:AndThen(function() end)
+			end):ToThrow()
+		end)
+
+		ctx:Test("should return none if the option is none", function()
+			local opt = Option.None
+			ctx:Expect(opt:AndThen(function()
+				return Option.Some(10)
+			end):IsNone()):ToBe(true)
+		end)
+
+		ctx:Test("should return option of predicate if option is some", function()
+			local opt = Option.Some(32)
+			local result = opt:AndThen(function()
+				return Option.Some(10)
+			end)
+			ctx:Expect(result:IsSome()):ToBe(true)
+			ctx:Expect(result:Unwrap()):ToBe(10)
+		end)
+	end)
+
+	ctx:Describe("Or", function()
+		ctx:Test("should return the first option if it is some", function()
+			local opt1 = Option.Some(10)
+			local opt2 = Option.Some(20)
+			ctx:Expect(opt1:Or(opt2)):ToBe(opt1)
+		end)
+
+		ctx:Test("should return the second option if the first one is none", function()
+			local opt1 = Option.None
+			local opt2 = Option.Some(20)
+			ctx:Expect(opt1:Or(opt2)):ToBe(opt2)
+		end)
+	end)
+
+	ctx:Describe("OrElse", function()
+		ctx:Test("should return the first option if it is some", function()
+			local opt1 = Option.Some(10)
+			local opt2 = Option.Some(20)
+			ctx:Expect(opt1:OrElse(function()
+				return opt2
+			end)):ToBe(opt1)
+		end)
+
+		ctx:Test("should return the second option if the first one is none", function()
+			local opt1 = Option.None
+			local opt2 = Option.Some(20)
+			ctx:Expect(opt1:OrElse(function()
+				return opt2
+			end)):ToBe(opt2)
+		end)
+
+		ctx:Test("should throw if the predicate does not return an option", function()
+			local opt1 = Option.None
+			ctx:Expect(function()
+				opt1:OrElse(function() end)
+			end):ToThrow()
+		end)
+	end)
+
+	ctx:Describe("XOr", function()
+		ctx:Test("should return first option if first option is some and second option is none", function()
+			local opt1 = Option.Some(1)
+			local opt2 = Option.None
+			ctx:Expect(opt1:XOr(opt2)):ToBe(opt1)
+		end)
+
+		ctx:Test("should return second option if first option is none and second option is some", function()
+			local opt1 = Option.None
+			local opt2 = Option.Some(2)
+			ctx:Expect(opt1:XOr(opt2)):ToBe(opt2)
+		end)
+
+		ctx:Test("should return none if first and second option are some", function()
+			local opt1 = Option.Some(1)
+			local opt2 = Option.Some(2)
+			ctx:Expect(opt1:XOr(opt2)):ToBe(Option.None)
+		end)
+
+		ctx:Test("should return none if first and second option are none", function()
+			local opt1 = Option.None
+			local opt2 = Option.None
+			ctx:Expect(opt1:XOr(opt2)):ToBe(Option.None)
+		end)
+	end)
+
+	ctx:Describe("Filter", function()
+		ctx:Test("should return none if option is none", function()
+			local opt = Option.None
+			ctx:Expect(opt:Filter(function() end)):ToBe(Option.None)
+		end)
+
+		ctx:Test("should return none if option is some but fails predicate", function()
+			local opt = Option.Some(10)
+			ctx:Expect(opt:Filter(function(_v)
+				return false
+			end)):ToBe(Option.None)
+		end)
+
+		ctx:Test("should return self if option is some and passes predicate", function()
+			local opt = Option.Some(10)
+			ctx:Expect(opt:Filter(function(_v)
+				return true
+			end)):ToBe(opt)
+		end)
+	end)
+
+	ctx:Describe("Contains", function()
+		ctx:Test("should return true if some option contains the given value", function()
+			local opt = Option.Some(32)
+			ctx:Expect(opt:Contains(32)):ToBe(true)
+		end)
+
+		ctx:Test("should return false if some option does not contain the given value", function()
+			local opt = Option.Some(32)
+			ctx:Expect(opt:Contains(64)):ToBe(false)
+		end)
+
+		ctx:Test("should return false if option is none", function()
+			local opt = Option.None
+			ctx:Expect(opt:Contains(64)):ToBe(false)
+		end)
+	end)
+
+	ctx:Describe("ToString", function()
+		ctx:Test("should return string of none option", function()
+			local opt = Option.None
+			ctx:Expect(tostring(opt)):ToBe("Option<None>")
+		end)
+
+		ctx:Test("should return string of some option with type", function()
+			local values = { 10, true, false, "test", {}, function() end, coroutine.create(function() end), workspace }
+			for _, value in ipairs(values) do
+				local expectedString = ("Option<%s>"):format(typeof(value))
+				ctx:Expect(tostring(Option.Some(value))):ToBe(expectedString)
+			end
+		end)
+	end)
+end

package/vendor/rbxutil/option/wally.toml

@@ -0,0 +1,8 @@
+[package]
+name = "sleitnick/option"
+description = "Represent optional values in Lua"
+version = "1.0.5"
+license = "MIT"
+authors = ["Stephen Leitnick"]
+registry = "https://github.com/UpliftGames/wally-index"
+realm = "shared"

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

@@ -0,0 +1,53 @@
+declare namespace PID {
+	interface Constructor {
+		/**
+		 * Constructs a new PID.
+		 *
+		 * @param min Minimum output.
+		 * @param max Maximum output.
+		 * @param kp Proportional gain coefficient.
+		 * @param ki Integral gain coefficient.
+		 * @param kd Derivative gain coefficient.
+		 */
+		new (min: number, max: number, kp: number, ki: number, kd: number): PID;
+	}
+}
+
+interface PID {
+	/**
+	 * Calculates the new output based on the setpoint and input.
+	 *
+	 * @param setpoint The goal for the PID.
+	 * @param processVariable The measured value of the system to compare against the setpoint.
+	 * @param deltaTime Delta time.
+	 * @returns The updated output.
+	 */
+	Calculate(setpoint: number, processVariable: number, deltaTime: number): number;
+
+	/**
+	 * Resets the PID.
+	 */
+	Reset(): void;
+
+	/**
+	 * Creates a debug instance that can be used to tune the PID.
+	 * This only works in Studio. This does nothing outside of Studio.
+	 *
+	 * @param name The name of the debug folder instance.
+	 * @param parent The parent for the debug folder (defaults to Workspace).
+	 */
+	Debug(name: string, parent?: Instance): void;
+
+	/**
+	 * Destroys any debug instance created. `Destroy()` only needs
+	 * to be called if `Debug()` was called.
+	 */
+	Destroy(): void;
+}
+
+/**
+ * The PID class simulates a [PID controller](https://en.wikipedia.org/wiki/PID_controller).
+ */
+declare const PID: PID.Constructor;
+
+export = PID;

package/vendor/rbxutil/pid/init.luau

@@ -0,0 +1,195 @@
+--!native
+
+export type PID = {
+	Reset: (self: PID) -> (),
+	Calculate: (self: PID, setpoint: number, input: number, deltaTime: number) -> number,
+	Debug: (self: PID, name: string, parent: Instance?) -> (),
+	Destroy: (self: PID) -> (),
+}
+
+--[=[
+	@class PID
+	The PID class simulates a [PID controller](https://en.wikipedia.org/wiki/PID_controller). PID is an acronym
+	for _proportional, integral, derivative_. PIDs are input feedback loops that try to reach a specific
+	goal by measuring the difference between the input and the desired value, and then returning a new
+	desired input.
+
+	A common example is a car's cruise control, which would give a PID the current speed
+	and the desired speed, and the PID controller would return the desired throttle input to reach the
+	desired speed.
+]=]
+local PID = {}
+PID.__index = PID
+
+--[=[
+	@param min number -- Minimum value the PID can output
+	@param max number -- Maximum value the PID can output
+	@param kp number -- Proportional gain coefficient (P)
+	@param ki number -- Integral gain coefficient (I)
+	@param kd number -- Derivative gain coefficient (D)
+	@return PID
+
+	Constructs a new PID.
+
+	```lua
+	local pid = PID.new(0, 1, 0.1, 0, 0)
+	```
+]=]
+function PID.new(min: number, max: number, kp: number, ki: number, kd: number): PID
+	local self = setmetatable({}, PID)
+	self._min = min
+	self._max = max
+	self._kp = kp
+	self._ki = ki
+	self._kd = kd
+	self._lastError = 0 -- Store the last error for derivative calculation
+	self._integralSum = 0 -- Store the sum of errors for integral calculation
+	return self
+end
+
+--[=[
+	Resets the PID to a zero start state.
+]=]
+function PID:Reset()
+	self._lastError = 0
+	self._integralSum = 0
+end
+
+--[=[
+	@param setpoint number	-- The desired point to reach
+	@param processVariable number	-- The measured value of the system to compare against the setpoint
+	@param deltaTime number	-- Delta time. This is the time between each PID calculation
+	@return output: number
+
+	Calculates the new output based on the setpoint and input. For example,
+	if the PID was being used for a car's throttle control where the throttle
+	can be in the range of [0, 1], then the PID calculation might look like
+	the following:
+	```lua
+	local cruisePID = PID.new(0, 1, ...)
+	local desiredSpeed = 50
+
+	RunService.Heartbeat:Connect(function(dt)
+		local throttle = cruisePID:Calculate(desiredSpeed, car.CurrentSpeed, dt)
+		car:SetThrottle(throttle)
+	end)
+	```
+]=]
+function PID:Calculate(setpoint: number, processVariable: number, deltaTime: number): number
+	-- Calculate the error e(t) = SP - PV(t)
+	local err = setpoint - processVariable
+
+	-- Proportional term
+	local pOut = self._kp * err
+
+	-- Integral term
+	self._integralSum = self._integralSum + err * deltaTime
+	local iOut = self._ki * self._integralSum
+
+	-- Derivative term
+	local derivative = (err - self._lastError) / deltaTime
+	local dOut = self._kd * derivative
+
+	-- Combine terms
+	local output = pOut + iOut + dOut
+
+	-- Clamp output to min/max
+	output = math.clamp(output, self._min, self._max)
+
+	-- Save the current error for the next derivative calculation
+	self._lastError = err
+
+	return output
+end
+
+--[=[
+	@param name string -- Folder name
+	@param parent Instance? -- Folder parent
+
+	Creates a folder that contains attributes that can be used to
+	tune the PID during runtime within the explorer.
+
+	:::info Studio Only
+	This will only create the folder in Studio. In a real game server,
+	this function will do nothing.
+	:::
+]=]
+function PID:Debug(name: string, parent: Instance?)
+	if not game:GetService("RunService"):IsStudio() then
+		return
+	end
+
+	if self._debug then
+		return
+	end
+
+	local folder = Instance.new("Folder")
+	folder.Name = name
+	folder:AddTag("PIDDebug")
+
+	local function Bind(attrName, propName)
+		folder:SetAttribute(attrName, self[propName])
+		folder:GetAttributeChangedSignal(attrName):Connect(function()
+			self[propName] = folder:GetAttribute(attrName)
+			self:Reset()
+		end)
+	end
+
+	folder:SetAttribute("MinMax", NumberRange.new(self._min, self._max))
+	folder:GetAttributeChangedSignal("MinMax"):Connect(function()
+		local minMax = folder:GetAttribute("MinMax") :: NumberRange
+		self._min = minMax.Min
+		self._max = minMax.Max
+		self:Reset()
+	end)
+
+	Bind("kP", "_kp")
+	Bind("kI", "_ki")
+	Bind("kD", "_kd")
+
+	folder:SetAttribute("Output", self._min)
+
+	local lastOutput = 0
+	self.Calculate = function(s, sp, pv, ...)
+		lastOutput = PID.Calculate(s, sp, pv, ...)
+		folder:SetAttribute("Output", lastOutput)
+		return lastOutput
+	end
+
+	local delayThread: thread? = nil
+	folder:SetAttribute("ShowDebugger", false)
+	folder:GetAttributeChangedSignal("ShowDebugger"):Connect(function()
+		if delayThread then
+			task.cancel(delayThread)
+		end
+
+		local showDebugger = folder:GetAttribute("ShowDebugger")
+
+		if showDebugger then
+			delayThread = task.delay(0.1, function()
+				delayThread = nil
+				if folder:GetAttribute("ShowDebugger") then
+					folder:SetAttribute("ShowDebugger", false)
+					warn("Install the PID Debug plugin: https://create.roblox.com/store/asset/16279661108/PID-Debug")
+				end
+			end)
+		end
+	end)
+
+	folder.Parent = parent or workspace
+	self._debug = folder
+end
+
+--[=[
+	Destroys the PID. This is only necessary if calling `PID:Debug`.
+]=]
+function PID:Destroy()
+	if self._debug then
+		self._debug:Destroy()
+		self._debug = nil
+	end
+end
+
+return {
+	new = PID.new,
+}

package/vendor/rbxutil/pid/package.json

@@ -0,0 +1,16 @@
+{
+	"name": "@rbxutil/pid",
+	"version": "2.1.0",
+	"main": "init.luau",
+	"repository": "github:Sleitnick/RbxUtil",
+	"license": "MIT",
+	"types": "index.d.ts",
+	"files": [
+		"./",
+		"!*.toml",
+		"!*.json"
+	],
+	"publishConfig": {
+		"access": "public"
+	}
+}

package/vendor/rbxutil/pid/wally.toml

@@ -0,0 +1,9 @@
+[package]
+name = "sleitnick/pid"
+description = "PID Controller class"
+version = "2.1.0"
+license = "MIT"
+authors = ["Stephen Leitnick"]
+registry = "https://github.com/UpliftGames/wally-index"
+realm = "shared"
+exclude = ["node_modules", "package.json", "**/*.ts"]