roblox-opencode 1.0.0

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

@@ -0,0 +1,203 @@
+local ServerScriptService = game:GetService("ServerScriptService")
+
+local Test = require(ServerScriptService.TestRunner.Test)
+
+return function(ctx: Test.TestContext)
+	local Trove = require(script.Parent)
+
+	ctx:Describe("Trove", function()
+		local trove
+
+		ctx:BeforeEach(function()
+			trove = Trove.new()
+		end)
+
+		ctx:AfterEach(function()
+			if trove then
+				trove:Destroy()
+				trove = nil
+			end
+		end)
+
+		ctx:Test("should add and clean up roblox instance", function()
+			local part = Instance.new("Part")
+			part.Parent = workspace
+			trove:Add(part)
+			trove:Destroy()
+			ctx:Expect(part.Parent):ToBeNil()
+		end)
+
+		ctx:Test("should add and clean up roblox connection", function()
+			local connection = workspace.Changed:Connect(function() end)
+			trove:Add(connection)
+			trove:Destroy()
+			ctx:Expect(connection.Connected):ToBe(false)
+		end)
+
+		ctx:Test("should add and clean up a table with a destroy method", function()
+			local tbl = { Destroyed = false }
+			function tbl:Destroy()
+				self.Destroyed = true
+			end
+			trove:Add(tbl)
+			trove:Destroy()
+			ctx:Expect(tbl.Destroyed):ToBe(true)
+		end)
+
+		ctx:Test("should add and clean up a table with a disconnect method", function()
+			local tbl = { Connected = true }
+			function tbl:Disconnect()
+				self.Connected = false
+			end
+			trove:Add(tbl)
+			trove:Destroy()
+			ctx:Expect(tbl.Connected):ToBe(false)
+		end)
+
+		ctx:Test("should add and clean up a function", function()
+			local fired = false
+			trove:Add(function()
+				fired = true
+			end)
+			trove:Destroy()
+			ctx:Expect(fired):ToBe(true)
+		end)
+
+		ctx:Test("should allow a custom cleanup method", function()
+			local tbl = { Cleaned = false }
+			function tbl:Cleanup()
+				self.Cleaned = true
+			end
+			trove:Add(tbl, "Cleanup")
+			trove:Destroy()
+			ctx:Expect(tbl.Cleaned):ToBe(true)
+		end)
+
+		ctx:Test("should return the object passed to add", function()
+			local part = Instance.new("Part")
+			local part2 = trove:Add(part)
+			ctx:Expect(part):ToBe(part2)
+			trove:Destroy()
+		end)
+
+		ctx:Test("should fail to add object without proper cleanup method", function()
+			local tbl = {}
+			ctx:Expect(function()
+				trove:Add(tbl)
+			end):ToThrow()
+		end)
+
+		ctx:Test("should construct an object and add it", function()
+			local class = {}
+			class.__index = class
+			function class.new(msg)
+				local self = setmetatable({}, class)
+				self._msg = msg
+				self._destroyed = false
+				return self
+			end
+			function class:Destroy()
+				self._destroyed = true
+			end
+			local msg = "abc"
+			local obj = trove:Construct(class, msg)
+			ctx:Expect(typeof(obj)):ToBe("table")
+			ctx:Expect(getmetatable(obj)):ToBe(class)
+			ctx:Expect(obj._msg):ToBe(msg)
+			ctx:Expect(obj._destroyed):ToBe(false)
+			trove:Destroy()
+			ctx:Expect(obj._destroyed):ToBe(true)
+		end)
+
+		ctx:Test("should connect to a signal", function()
+			local connection = trove:Connect(workspace.Changed, function() end)
+			ctx:Expect(typeof(connection)):ToBe("RBXScriptConnection")
+			ctx:Expect(connection.Connected):ToBe(true)
+			trove:Destroy()
+			ctx:Expect(connection.Connected):ToBe(false)
+		end)
+
+		ctx:Test("should remove an object", function()
+			local connection = trove:Connect(workspace.Changed, function() end)
+			ctx:Expect(trove:Remove(connection)):ToBe(true)
+			ctx:Expect(connection.Connected):ToBe(false)
+		end)
+
+		ctx:Test("should not remove an object not in the trove", function()
+			local connection = workspace.Changed:Connect(function() end)
+			ctx:Expect(trove:Remove(connection)):ToBe(false)
+			ctx:Expect(connection.Connected):ToBe(true)
+			connection:Disconnect()
+		end)
+
+		ctx:Test("should attach to instance", function()
+			local part = Instance.new("Part")
+			part.Parent = workspace
+			local connection = trove:AttachToInstance(part)
+			ctx:Expect(connection.Connected):ToBe(true)
+			part:Destroy()
+			ctx:Expect(connection.Connected):ToBe(false)
+		end)
+
+		ctx:Test("should fail to attach to instance not in hierarchy", function()
+			local part = Instance.new("Part")
+			ctx:Expect(function()
+				trove:AttachToInstance(part)
+			end):ToThrow()
+		end)
+
+		ctx:Test("should extend itself", function()
+			local subTrove = trove:Extend()
+			local called = false
+			subTrove:Add(function()
+				called = true
+			end)
+			ctx:Expect(typeof(subTrove)):ToBe("table")
+			ctx:Expect(getmetatable(subTrove)):ToBe(getmetatable(trove))
+			trove:Clean()
+			ctx:Expect(called):ToBe(true)
+		end)
+
+		ctx:Test("should clone an instance", function()
+			local name = "TroveCloneTest"
+			local p1 = trove:Construct(Instance.new, "Part")
+			p1.Name = name
+			local p2 = trove:Clone(p1)
+			ctx:Expect(typeof(p2)):ToBe("Instance")
+			ctx:Expect(p2):Not():ToBe(p1)
+			ctx:Expect(p2.Name):ToBe(name)
+			ctx:Expect(p1.Name):ToBe(p2.Name)
+		end)
+
+		ctx:Test("should clean up a thread", function()
+			local co = coroutine.create(function() end)
+			trove:Add(co)
+			ctx:Expect(coroutine.status(co)):ToBe("suspended")
+			trove:Clean()
+			ctx:Expect(coroutine.status(co)):ToBe("dead")
+		end)
+
+		ctx:Test("should not allow objects added during cleanup", function()
+			local added = false
+			trove:Add(function()
+				trove:Add(function() end)
+				added = true
+			end)
+			trove:Clean()
+
+			ctx:Expect(added):ToBe(false)
+		end)
+
+		ctx:Test("should not allow objects to be removed during cleanup", function()
+			local f = function() end
+			local removed = false
+			trove:Add(f)
+			trove:Add(function()
+				trove:Remove(f)
+				removed = true
+			end)
+
+			ctx:Expect(removed):ToBe(false)
+		end)
+	end)
+end

package/vendor/rbxutil/trove/wally.toml

@@ -0,0 +1,8 @@
+[package]
+name = "sleitnick/trove"
+description = "Trove class for tracking and cleaning up objects"
+version = "1.8.0"
+license = "MIT"
+authors = ["Stephen Leitnick"]
+registry = "https://github.com/UpliftGames/wally-index"
+realm = "shared"

package/vendor/rbxutil/typed-remote/init.luau

@@ -0,0 +1,196 @@
+--!strict
+
+type Signal<T...> = {
+	Connect: (self: Signal<T...>, fn: (T...) -> ()) -> RBXScriptConnection,
+	ConnectParallel: (self: Signal<T...>, fn: (T...) -> ()) -> RBXScriptConnection,
+	Once: (self: Signal<T...>, fn: (T...) -> ()) -> RBXScriptConnection,
+	Wait: (self: Signal<T...>) -> T...,
+}
+
+type PlayerSignal<T...> = {
+	Connect: (self: PlayerSignal<T...>, fn: (player: Player, T...) -> ()) -> RBXScriptConnection,
+	ConnectParallel: (self: PlayerSignal<T...>, fn: (player: Player, T...) -> ()) -> RBXScriptConnection,
+	Once: (self: PlayerSignal<T...>, fn: (player: Player, T...) -> ()) -> RBXScriptConnection,
+	Wait: (self: PlayerSignal<T...>) -> (Player, T...),
+}
+
+--[=[
+	@within TypedRemote
+	@interface Event<T...>
+	.OnClientEvent Signal<T...>,
+	.OnServerEvent PlayerSignal<T...>,
+	.FireClient (self: Event<T...>, player: Player, T...) -> (),
+	.FireAllClients (self: Event<T...>, T...) -> (),
+	.FireServer (self: Event<T...>, T...) -> (),
+]=]
+export type Event<T...> = Instance & {
+	OnClientEvent: Signal<T...>,
+	OnServerEvent: PlayerSignal<T...>,
+	FireClient: (self: Event<T...>, player: Player, T...) -> (),
+	FireAllClients: (self: Event<T...>, T...) -> (),
+	FireServer: (self: Event<T...>, T...) -> (),
+}
+
+--[=[
+	@within TypedRemote
+	@interface UnreliableEvent<T...>
+	.OnClientEvent Signal<T...>,
+	.OnServerEvent PlayerSignal<T...>,
+	.FireClient (self: Event<T...>, player: Player, T...) -> (),
+	.FireAllClients (self: Event<T...>, T...) -> (),
+	.FireServer (self: Event<T...>, T...) -> (),
+]=]
+export type UnreliableEvent<T...> = Event<T...>
+
+--[=[
+	@within TypedRemote
+	@interface Function<T..., R...>
+	.InvokeServer (self: Function<T..., R...>, T...) -> R...,
+	.OnServerInvoke (player: Player, T...) -> R...,
+]=]
+export type Function<T..., R...> = Instance & {
+	InvokeServer: (self: Function<T..., R...>, T...) -> R...,
+	OnServerInvoke: (player: Player, T...) -> R...,
+}
+
+type CreatorFn<T> = (name: string) -> T
+
+local IS_SERVER = game:GetService("RunService"):IsServer()
+
+--[=[
+	@class TypedRemote
+
+	Simple networking package that helps create typed RemoteEvents and RemoteFunctions.
+
+	```lua
+	-- ReplicatedStorage.Network (ModuleScript)
+
+	local TypedRemote = require(ReplicatedStorage.Packages.TypedRemote)
+
+	-- Get the RF, RE and URE instance creators, which create RemoteFunctions/RemoteEvents/UnreliableRemoteEvents
+	-- within the given parent (the script by default):
+	local RF, RE, URE = TypedRemote.parent()
+
+	-- Redeclare the TypedRemote types for simplicity:
+	type RF<T..., R...> = TypedRemote.Function<T..., R...>
+	type RE<T...> = TypedRemote.Event<T...>
+	type URE<T...> = TypedRemote.UnreliableEvent<T...>
+
+	-- Define network table:
+	return {
+		-- RemoteFunction that takes two arguments (boolean, string) and returns a number:
+		MyFunc = RF("MyFunc") :: RF<(boolean, string), (number)>,
+
+		-- RemoteEvent that takes two arguments - a string and a number:
+		MyEvent = RE("MyEvent") :: RE<string, number>,
+
+		-- UnreliableRemoteEvent that takes two arguments - a string and a number:
+		MyUnreliableEvent = URE("MyUnreliableEvent") :: URE<string, number>,
+	}
+	```
+
+	```lua
+	-- Example usage of the above Network module:
+
+	local Network = require(ReplicatedStorage.Network)
+
+	-- If you type this out, intellisense will help with what the function signature should be:
+	Network.MyEvent.OnClientEvent:Connect(function(player, str, num)
+		-- Foo
+	end)
+	```
+
+	In most cases, the `TypedRemote.parent()` function will be used to create the memoized
+	RemoteFunction and RemoteEvent builder functions. From there, call the given functions
+	with the desired name per remote.
+
+	The `TypedRemote.func` and `TypedRemote.event` functions can also be used, but the
+	parent must be supplied to each call, hence the helpful `parent()` memoizer.
+]=]
+local TypedRemote = {}
+
+--[=[
+	@return ((name: string) -> RemoteFunction, (name: string) -> RemoteEvent)
+
+	Creates a memoized version of the `func` and `event` functions that include the `parent`
+	in each call.
+
+	```lua
+	-- Create RF and RE functions that use the current script as the instance parent:
+	local RF, RE = TypedRemote.parent(script)
+
+	local remoteFunc = RF("RemoteFunc")
+	```
+]=]
+function TypedRemote.parent(
+	parent: Instance?
+): (CreatorFn<RemoteFunction>, CreatorFn<RemoteEvent>, CreatorFn<UnreliableRemoteEvent>)
+	return function(name: string)
+		return TypedRemote.func(name, parent)
+	end, function(name: string)
+		return TypedRemote.event(name, parent)
+	end, function(name: string)
+		return TypedRemote.unreliableEvent(name, parent)
+	end
+end
+
+--[=[
+	Creates a RemoteFunction with `name` and parents it inside of `parent`.
+	
+	If the `parent` argument is not included or is `nil`, then it defaults to the parent of
+	this TypedRemote ModuleScript.
+]=]
+function TypedRemote.func(name: string, parent: Instance?): RemoteFunction
+	local rf: RemoteFunction
+	if IS_SERVER then
+		rf = Instance.new("RemoteFunction")
+		rf.Name = name
+		rf.Parent = if parent then parent else script
+	else
+		rf = (if parent then parent else script):WaitForChild(name)
+		assert(rf:IsA("RemoteFunction"), "expected remote function")
+	end
+	return rf
+end
+
+--[=[
+	Creates a RemoteEvent with `name` and parents it inside of `parent`.
+	
+	If the `parent` argument is not included or is `nil`, then it defaults to the parent of
+	this TypedRemote ModuleScript.
+]=]
+function TypedRemote.event(name: string, parent: Instance?): RemoteEvent
+	local re: RemoteEvent
+	if IS_SERVER then
+		re = Instance.new("RemoteEvent")
+		re.Name = name
+		re.Parent = if parent then parent else script
+	else
+		re = (if parent then parent else script):WaitForChild(name)
+		assert(re:IsA("RemoteEvent"), "expected remote event")
+	end
+	return re
+end
+
+--[=[
+	Creates an UnreliableRemoteEvent with `name` and parents it inside of `parent`.
+	
+	If the `parent` argument is not included or is `nil`, then it defaults to the parent of
+	this TypedRemote ModuleScript.
+]=]
+function TypedRemote.unreliableEvent(name: string, parent: Instance?): UnreliableRemoteEvent
+	local ure: UnreliableRemoteEvent
+	if IS_SERVER then
+		ure = Instance.new("UnreliableRemoteEvent")
+		ure.Name = name
+		ure.Parent = if parent then parent else script
+	else
+		ure = (if parent then parent else script):WaitForChild(name)
+		assert(ure:IsA("UnreliableRemoteEvent"), "expected unreliable remote event")
+	end
+	return ure
+end
+
+table.freeze(TypedRemote)
+
+return TypedRemote

package/vendor/rbxutil/typed-remote/wally.toml

@@ -0,0 +1,8 @@
+[package]
+name = "sleitnick/typed-remote"
+description = "Simple networking package for typed RemoteEvents and RemoteFunctions"
+version = "0.3.0"
+license = "MIT"
+authors = ["Stephen Leitnick"]
+registry = "https://github.com/UpliftGames/wally-index"
+realm = "shared"

package/vendor/rbxutil/wait-for/index.d.ts

@@ -0,0 +1,17 @@
+declare namespace WaitFor {
+	interface Constructor {
+		readonly Error: { Unparented: "Unparented"; ParentChanged: "ParentChanged" };
+
+		Child: (parent: Instance, childName: string, timeout?: number) => Promise<Instance>;
+		Children: (parent: Instance, childrenNames: string[], timeout?: number) => Promise<Instance[]>;
+		Descendant: (parent: Instance, descendantName: string, timeout?: number) => Promise<Instance>;
+		Descendants: (parent: Instance, descendantNames: string[], timeout?: number) => Promise<Instance[]>;
+		PrimaryPart: (model: Model, timeout?: number) => Promise<BasePart>;
+		ObjectValue: (objectValue: ObjectValue, timeout?: number) => Promise<Instance>;
+		Custom: <T>(predicate: () => T | undefined, timeout?: number) => Promise<T>;
+	}
+}
+
+declare const WaitFor: WaitFor.Constructor;
+
+export = WaitFor;

package/vendor/rbxutil/wait-for/init.luau

@@ -0,0 +1,257 @@
+-- WaitFor
+-- Stephen Leitnick
+-- January 17, 2022
+
+local RunService = game:GetService("RunService")
+
+local Promise = require(script.Parent.Promise)
+
+local DEFAULT_TIMEOUT = 60
+
+--[=[
+	@class WaitFor
+	Utility class for awaiting the existence of instances.
+
+	By default, all promises timeout after 60 seconds, unless the `timeout`
+	argument is specified.
+
+	:::note
+	Promises will be rejected if the parent (or any ancestor) is unparented
+	from the game.
+	:::
+
+	:::caution Set name before parent
+	When waiting for instances based on name (e.g. `WaitFor.Child`), the `WaitFor`
+	system is listening to events to capture these instances being added. This
+	means that the name must be set _before_ being parented into the object.
+	:::
+]=]
+local WaitFor = {}
+
+--[=[
+	@within WaitFor
+	@prop Error {Unparented: string, ParentChanged: string}
+]=]
+WaitFor.Error = {
+	Unparented = "Unparented",
+	ParentChanged = "ParentChanged",
+}
+
+local function PromiseWatchAncestry(instance: Instance, promise)
+	return Promise.race({
+		promise,
+		Promise.fromEvent(instance.AncestryChanged, function(_, newParent)
+			return newParent == nil
+		end):andThen(function()
+			return Promise.reject(WaitFor.Error.Unparented)
+		end),
+	})
+end
+
+--[=[
+	@return Promise<Instance>
+	Wait for a child to exist within a given parent based on the child name.
+
+	```lua
+	WaitFor.Child(parent, "SomeObject"):andThen(function(someObject)
+		print(someObject, "now exists")
+	end):catch(warn)
+	```
+]=]
+function WaitFor.Child(parent: Instance, childName: string, timeout: number?)
+	local child = parent:FindFirstChild(childName)
+	if child then
+		return Promise.resolve(child)
+	end
+	return PromiseWatchAncestry(
+		parent,
+		Promise.fromEvent(parent.ChildAdded, function(c)
+			return c.Name == childName
+		end):timeout(timeout or DEFAULT_TIMEOUT)
+	)
+end
+
+--[=[
+	@return Promise<{Instance}>
+	Wait for all children to exist within the given parent.
+
+	```lua
+	WaitFor.Children(parent, {"SomeObject01", "SomeObject02"}):andThen(function(children)
+		local someObject01, someObject02 = table.unpack(children)
+	end)
+	```
+
+	:::note
+	Once all children are found, a second check is made to ensure that all children
+	are still directly parented to the given `parent` (since one child's parent
+	might have changed before another child was found). A rejected promise with the
+	`WaitFor.Error.ParentChanged` error will be thrown if any parents of the children
+	no longer match the given `parent`.
+	:::
+]=]
+function WaitFor.Children(parent: Instance, childrenNames: { string }, timeout: number?)
+	local all = table.create(#childrenNames)
+	for i, childName in ipairs(childrenNames) do
+		all[i] = WaitFor.Child(parent, childName, timeout)
+	end
+	return Promise.all(all):andThen(function(children)
+		-- Check that all are still parented
+		for _, child in ipairs(children) do
+			if child.Parent ~= parent then
+				return Promise.reject(WaitFor.Error.ParentChanged)
+			end
+		end
+		return children
+	end)
+end
+
+--[=[
+	@return Promise<Instance>
+	Wait for a descendant to exist within a given parent. This is similar to
+	`WaitFor.Child`, except it looks for all descendants instead of immediate
+	children.
+
+	```lua
+	WaitFor.Descendant(parent, "SomeDescendant"):andThen(function(someDescendant)
+		print("SomeDescendant now exists")
+	end)
+	```
+]=]
+function WaitFor.Descendant(parent: Instance, descendantName: string, timeout: number?)
+	local descendant = parent:FindFirstChild(descendantName, true)
+	if descendant then
+		return Promise.resolve(descendant)
+	end
+	return PromiseWatchAncestry(
+		parent,
+		Promise.fromEvent(parent.DescendantAdded, function(d)
+			return d.Name == descendantName
+		end):timeout(timeout or DEFAULT_TIMEOUT)
+	)
+end
+
+--[=[
+	@return Promise<{Instance}>
+	Wait for all descendants to exist within a given parent.
+
+	```lua
+	WaitFor.Descendants(parent, {"SomeDescendant01", "SomeDescendant02"}):andThen(function(descendants)
+		local someDescendant01, someDescendant02 = table.unpack(descendants)
+	end)
+	```
+
+	:::note
+	Once all descendants are found, a second check is made to ensure that none of the
+	instances have moved outside of the parent (since one instance might change before
+	another instance is found). A rejected promise with the `WaitFor.Error.ParentChanged`
+	error will be thrown if any of the instances are no longer descendants of the given
+	`parent`.
+	:::
+]=]
+function WaitFor.Descendants(parent: Instance, descendantNames: { string }, timeout: number?)
+	local all = table.create(#descendantNames)
+	for i, descendantName in ipairs(descendantNames) do
+		all[i] = WaitFor.Descendant(parent, descendantName, timeout)
+	end
+	return Promise.all(all):andThen(function(descendants)
+		-- Check that all are still parented
+		for _, descendant in ipairs(descendants) do
+			if not descendant:IsDescendantOf(parent) then
+				return Promise.reject(WaitFor.Error.ParentChanged)
+			end
+		end
+		return descendants
+	end)
+end
+
+--[=[
+	@return Promise<Instance>
+	Wait for the PrimaryPart of a model to exist.
+
+	```lua
+	WaitFor.PrimaryPart(model):andThen(function(primaryPart)
+		print(primaryPart == model.PrimaryPart)
+	end)
+	```
+]=]
+function WaitFor.PrimaryPart(model: Model, timeout: number?)
+	local primary = model.PrimaryPart
+	if primary then
+		return Promise.resolve(primary)
+	end
+	return PromiseWatchAncestry(
+		model,
+		Promise.fromEvent(model:GetPropertyChangedSignal("PrimaryPart"), function()
+			primary = model.PrimaryPart
+			return primary ~= nil
+		end)
+			:andThen(function()
+				return primary
+			end)
+			:timeout(timeout or DEFAULT_TIMEOUT)
+	)
+end
+
+--[=[
+	@return Promise<Instance>
+	Wait for the Value of an ObjectValue to exist.
+
+	```lua
+	WaitFor.ObjectValue(someObjectValue):andThen(function(value)
+		print("someObjectValue's value is", value)
+	end)
+	```
+]=]
+function WaitFor.ObjectValue(objectValue: ObjectValue, timeout: number?)
+	local value = objectValue.Value
+	if value then
+		return Promise.resolve(value)
+	end
+	return PromiseWatchAncestry(
+		objectValue,
+		Promise.fromEvent(objectValue.Changed, function(v)
+			value = v
+			return value ~= nil
+		end)
+			:andThen(function()
+				return value
+			end)
+			:timeout(timeout or DEFAULT_TIMEOUT)
+	)
+end
+
+--[=[
+	@return Promise<T>
+	Wait for the given predicate function to return a non-nil value of
+	of type `T`. The predicate is fired every RunService Heartbeat step.
+
+	```lua
+	-- Example, waiting for some property to be set:
+	WaitFor.Custom(function() return vectorForce.Attachment0 end):andThen(function(a0)
+		print(a0)
+	end)
+	```
+]=]
+function WaitFor.Custom<T>(predicate: () -> T?, timeout: number?)
+	local value = predicate()
+	if value ~= nil then
+		return Promise.resolve(value)
+	end
+	return Promise.new(function(resolve, _reject, onCancel)
+		local heartbeat
+		local function OnDone()
+			heartbeat:Disconnect()
+		end
+		local function Update()
+			local v = predicate()
+			if v ~= nil then
+				OnDone()
+				resolve(v)
+			end
+		end
+		heartbeat = RunService.Heartbeat:Connect(Update)
+		onCancel(OnDone)
+	end):timeout(timeout or DEFAULT_TIMEOUT)
+end
+
+return WaitFor