roblox-opencode 1.0.0

package/vendor/rbxutil/timer/init.luau

@@ -0,0 +1,249 @@
+--!strict
+
+local RunService = game:GetService("RunService")
+
+local Signal = require(script.Parent.Signal)
+
+--[=[
+	@within Timer
+	@type CallbackFn () -> ()
+	Callback function.
+]=]
+type CallbackFn = () -> nil
+
+--[=[
+	@within Timer
+	@type TimeFn () -> number
+	Time function.
+]=]
+type TimeFn = () -> number
+
+--[=[
+	@class Timer
+
+	The Timer class allows for code to run periodically at specified intervals.
+
+	```lua
+	local timer = Timer.new(2)
+	timer.Tick:Connect(function()
+		print("Tock")
+	end)
+	timer:Start()
+	```
+]=]
+local Timer = {}
+Timer.__index = Timer
+
+export type Timer = typeof(setmetatable(
+	{} :: {
+		Interval: number,
+		UpdateSignal: RBXScriptSignal,
+		TimeFunction: () -> number,
+		AllowDrift: boolean,
+		Tick: Signal.Signal<>,
+
+		_runHandle: RBXScriptConnection?,
+	},
+	Timer
+))
+
+--[=[
+	@within Timer
+	@prop Interval number
+	Interval at which the `Tick` event fires.
+]=]
+--[=[
+	@within Timer
+	@prop UpdateSignal RBXScriptSignal | Signal
+	The signal which updates the timer internally.
+]=]
+--[=[
+	@within Timer
+	@prop TimeFunction TimeFn
+	The function which gets the current time.
+]=]
+--[=[
+	@within Timer
+	@prop AllowDrift boolean
+	Flag which indicates if the timer is allowed to drift. This
+	is set to `true` by default. This flag must be set before
+	calling `Start` or `StartNow`. This flag should only be set
+	to `false` if it is necessary for drift to be eliminated.
+]=]
+--[=[
+	@within Timer
+	@prop Tick RBXScriptSignal | Signal
+	The event which is fired every time the timer hits its interval.
+]=]
+
+--[=[
+	@return Timer
+	
+	Creates a new timer.
+]=]
+function Timer.new(interval: number): Timer
+	assert(type(interval) == "number", "argument #1 to Timer.new must be a number; got " .. type(interval))
+	assert(interval >= 0, "argument #1 to Timer.new must be greater or equal to 0; got " .. tostring(interval))
+
+	local self = setmetatable({}, Timer)
+
+	self._runHandle = nil
+	self.Interval = interval
+	self.UpdateSignal = RunService.Heartbeat
+	self.TimeFunction = time
+	self.AllowDrift = true
+	self.Tick = Signal.new()
+
+	return self
+end
+
+--[=[
+	@return RBXScriptConnection
+
+	Creates a simplified timer which just fires off a callback function at the given interval.
+
+	```lua
+	-- Basic:
+	Timer.simple(1, function()
+		print("Tick")
+	end)
+
+	-- Using other arguments:
+	Timer.simple(1, function()
+		print("Tick")
+	end, true, RunService.Heartbeat, os.clock)
+	```
+]=]
+function Timer.simple(
+	interval: number,
+	callback: CallbackFn,
+	startNow: boolean?,
+	updateSignal: RBXScriptSignal?,
+	timeFn: TimeFn?
+)
+	local update = updateSignal or RunService.Heartbeat
+	local t = timeFn or time
+	local nextTick = t() + interval
+
+	if startNow then
+		task.defer(callback)
+	end
+
+	return update:Connect(function()
+		local now = t()
+		if now >= nextTick then
+			nextTick = now + interval
+			task.defer(callback)
+		end
+	end)
+end
+
+--[=[
+	Returns `true` if the given object is a Timer.
+]=]
+function Timer.is(obj: any): boolean
+	return type(obj) == "table" and getmetatable(obj) == Timer
+end
+
+function Timer._startTimer(self: Timer)
+	local t = self.TimeFunction
+	local nextTick = t() + self.Interval
+
+	self._runHandle = self.UpdateSignal:Connect(function()
+		local now = t()
+		if now >= nextTick then
+			nextTick = now + self.Interval
+			self.Tick:Fire()
+		end
+	end)
+end
+
+function Timer._startTimerNoDrift(self: Timer)
+	assert(self.Interval > 0, "interval must be greater than 0 when AllowDrift is set to false")
+
+	local t = self.TimeFunction
+	local n = 1
+	local start = t()
+	local nextTick = start + self.Interval
+	self._runHandle = self.UpdateSignal:Connect(function()
+		local now = t()
+		while now >= nextTick do
+			n += 1
+			nextTick = start + (self.Interval * n)
+			self.Tick:Fire()
+		end
+	end)
+end
+
+--[=[
+	Starts the timer. Will do nothing if the timer is already running.
+
+	```lua
+	timer:Start()
+	```
+]=]
+function Timer.Start(self: Timer)
+	if self._runHandle then
+		return
+	end
+	if self.AllowDrift then
+		self:_startTimer()
+	else
+		self:_startTimerNoDrift()
+	end
+end
+
+--[=[
+	Starts the timer and fires off the Tick event immediately. Will do
+	nothing if the timer is already running.
+
+	```lua
+	timer:StartNow()
+	```
+]=]
+function Timer.StartNow(self: Timer)
+	if self._runHandle then
+		return
+	end
+	self.Tick:Fire()
+	self:Start()
+end
+
+--[=[
+	Stops the timer. Will do nothing if the timer is already stopped.
+
+	```lua
+	timer:Stop()
+	```
+]=]
+function Timer.Stop(self: Timer)
+	if not self._runHandle then
+		return
+	end
+
+	self._runHandle:Disconnect()
+	self._runHandle = nil
+end
+
+--[=[
+	Returns `true` if the timer is currently running.
+
+	```lua
+	if timer:IsRunning() then
+		-- Do something
+	end
+	```
+]=]
+function Timer.IsRunning(self: Timer): boolean
+	return self._runHandle ~= nil
+end
+
+--[=[
+	Destroys the timer. This will also stop the timer.
+]=]
+function Timer.Destroy(self: Timer)
+	self.Tick:Destroy()
+	self:Stop()
+end
+
+return Timer

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

@@ -0,0 +1,73 @@
+local ServerScriptService = game:GetService("ServerScriptService")
+
+local Test = require(ServerScriptService.TestRunner.Test)
+
+return function(ctx: Test.TestContext)
+	local Timer = require(script.Parent)
+
+	ctx:Describe("Timer", function()
+		local timer
+
+		ctx:BeforeEach(function()
+			timer = Timer.new(0.1)
+			timer.TimeFunction = os.clock
+		end)
+
+		ctx:AfterEach(function()
+			if timer then
+				timer:Destroy()
+				timer = nil
+			end
+		end)
+
+		ctx:Test("should create a new timer", function()
+			ctx:Expect(Timer.is(timer)):ToBe(true)
+		end)
+
+		ctx:Test("should tick appropriately", function()
+			local start = os.clock()
+			timer:Start()
+			timer.Tick:Wait()
+			local duration = (os.clock() - start)
+			ctx:Expect(duration):ToBeNear(duration, 0.02)
+		end)
+
+		ctx:Test("should start immediately", function()
+			local start = os.clock()
+			local stop = nil
+			timer.Tick:Connect(function()
+				if not stop then
+					stop = os.clock()
+				end
+			end)
+			timer:StartNow()
+			timer.Tick:Wait()
+			ctx:Expect(stop):ToBeA("number")
+			local duration = (stop - start)
+			ctx:Expect(duration):ToBeNear(0, 0.02)
+		end)
+
+		ctx:Test("should stop", function()
+			local ticks = 0
+			timer.Tick:Connect(function()
+				ticks += 1
+			end)
+			timer:StartNow()
+			timer:Stop()
+			task.wait(1)
+			ctx:Expect(ticks):ToBe(1)
+		end)
+
+		ctx:Test("should detect if running", function()
+			ctx:Expect(timer:IsRunning()):ToBe(false)
+			timer:Start()
+			ctx:Expect(timer:IsRunning()):ToBe(true)
+			timer:Stop()
+			ctx:Expect(timer:IsRunning()):ToBe(false)
+			timer:StartNow()
+			ctx:Expect(timer:IsRunning()):ToBe(true)
+			timer:Stop()
+			ctx:Expect(timer:IsRunning()):ToBe(false)
+		end)
+	end)
+end

package/vendor/rbxutil/timer/wally.toml

@@ -0,0 +1,11 @@
+[package]
+name = "sleitnick/timer"
+description = "Timer class"
+version = "2.0.0"
+license = "MIT"
+authors = ["Stephen Leitnick"]
+registry = "https://github.com/UpliftGames/wally-index"
+realm = "shared"
+
+[dependencies]
+Signal = "sleitnick/signal@^2"

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

@@ -0,0 +1,15 @@
+declare namespace Tree {
+	interface Constructor {
+		Find(parent: Instance, path: string): Instance;
+		Find<T extends keyof Instances>(parent: Instance, path: string, assertIsA: T): Instances[T];
+
+		Await(parent: Instance, path: string, timeout?: number): Instance;
+		Await<T extends keyof Instances>(parent: Instance, path: string, timeout: number, assertIsA: T): Instances[T];
+
+		Exists(parent: Instance, path: string, assertIsA?: keyof Instances): boolean;
+	}
+}
+
+declare const Tree: Tree.Constructor;
+
+export = Tree;

package/vendor/rbxutil/tree/init.luau

@@ -0,0 +1,137 @@
+local DELIM = "/"
+
+local function FullNameToPath(instance: Instance): string
+	return instance:GetFullName():gsub("%.", DELIM)
+end
+
+--[=[
+	@class Tree
+]=]
+local Tree = {}
+
+--[=[
+	Similar to FindFirstChild, with a few key differences:
+	- An error is thrown if the instance is not found
+	- A path to the instance can be provided, delimited by forward slashes (e.g. `Path/To/Child`)
+	- Optionally, the instance's type can be asserted using `IsA`
+
+	```lua
+	-- Find "Child" directly under parent:
+	local instance = Tree.Find(parent, "Child")
+
+	-- Find "Child" descendant:
+	local instance = Tree.Find(parent, "Path/To/Child")
+
+	-- Find "Child" descendant and assert that it's a BasePart:
+	local instance = Tree.Find(parent, "Path/To/Child", "BasePart") :: BasePart
+	```
+]=]
+function Tree.Find(parent: Instance, path: string, assertIsA: string?): Instance
+	local instance = parent
+	local paths = path:split(DELIM)
+
+	for _, p in paths do
+		-- Error for empty path parts:
+		if p == "" then
+			error(`Invalid path: {path}`, 2)
+		end
+
+		instance = instance:FindFirstChild(p)
+
+		-- Error if instance is not found:
+		if instance == nil then
+			error(`Failed to find {path} in {FullNameToPath(parent)}`, 2)
+		end
+	end
+
+	-- Assert class type if argument is supplied:
+	if assertIsA and not instance:IsA(assertIsA) then
+		error(`Got class {instance.ClassName}; expected to be of type {assertIsA}`, 2)
+	end
+
+	return instance
+end
+
+--[=[
+	Returns `true` if the instance is found. Similar to `Tree.Find`, except this returns `true|false`. No error is thrown unless the path is invalid.
+
+	```lua
+	-- Check if "Child" exists directly in `parent`:
+	if Tree.Exists(parent, "Child") then ... end
+	
+	-- Check if "Child" descendant exists at `parent.Path.To.Child`:
+	if Tree.Exists(parent, "Path/To/Child") then ... end
+	
+	-- Check if "Child" descendant exists at `parent.Path.To.Child` and is a BasePart:
+	if Tree.Exists(parent, "Path/To/Child", "BasePart") then ... end
+	```
+]=]
+function Tree.Exists(parent: Instance, path: string, assertIsA: string?): boolean
+	local instance = parent
+	local paths = path:split(DELIM)
+
+	for _, p in paths do
+		-- Error for empty path parts:
+		if p == "" then
+			error(`Invalid path: {path}`, 2)
+		end
+
+		instance = instance:FindFirstChild(p)
+
+		if instance == nil then
+			return false
+		end
+	end
+
+	if assertIsA and not instance:IsA(assertIsA) then
+		return false
+	end
+
+	return true
+end
+
+--[=[
+	@yields
+	Waits for the path to exist within the parent instance. Similar to `Tree.Find`, except `WaitForChild`
+	is used internally. An optional `timeout` can be supplied, which is passed along to each call to
+	`WaitForChild`.
+
+	An error is thrown if the path fails to resolve. This will only happen if the path is invalid _or_ if
+	the supplied timeout is reached.
+
+	:::caution Indefinite Yield Possible
+	If the `timeout` parameter is not supplied, then the internal call to `WaitForChild` will yield
+	indefinitely until the child is found. It is good practice to supply a timeout parameter.
+	:::
+
+	```lua
+	local child = Tree.Await(parent, "Path/To/Child", 30)
+	```
+]=]
+function Tree.Await(parent: Instance, path: string, timeout: number?, assertIsA: string?): Instance
+	local instance = parent
+	local paths = path:split(DELIM)
+
+	for _, p in paths do
+		-- Error for empty path parts:
+		if p == "" then
+			error(`Invalid path: {path}`, 2)
+		end
+
+		instance = instance:WaitForChild(p, timeout)
+
+		-- Error if instance is not found:
+		if instance == nil then
+			error(`Failed to await {path} in {FullNameToPath(parent)} (timeout reached)`, 2)
+		end
+	end
+
+	-- Assert class type if argument is supplied:
+	if assertIsA and not instance:IsA(assertIsA) then
+		error(`Got class {instance.ClassName}; expected to be of type {assertIsA}`, 2)
+	end
+
+	return instance
+end
+
+return Tree

package/vendor/rbxutil/tree/wally.toml

@@ -0,0 +1,8 @@
+[package]
+name = "sleitnick/tree"
+description = "Utility functions for accessing instances in the game hierarchy"
+version = "1.1.0"
+license = "MIT"
+authors = ["Stephen Leitnick"]
+registry = "https://github.com/UpliftGames/wally-index"
+realm = "shared"

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

@@ -0,0 +1,46 @@
+interface ConnectionLike {
+	Disconnect(this: ConnectionLike): void;
+}
+
+type Trackable =
+	| Instance
+	| RBXScriptConnection
+	| ConnectionLike
+	| Promise<unknown>
+	| thread
+	| ((...args: unknown[]) => unknown)
+	| { destroy: () => void }
+	| { disconnect: () => void }
+	| { Destroy: () => void }
+	| { Disconnect: () => void };
+
+declare namespace Trove {
+	interface Constructor {
+		new (): Trove;
+	}
+}
+
+interface Trove {
+	Extend(): Trove;
+	Clone<T extends Instance>(): T;
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	Construct<T extends { new (...args: any[]): InstanceType<T> }>(
+		cls: T,
+		...args: ConstructorParameters<T>
+	): InstanceType<T>;
+	Connect<T extends Callback = Callback>(signal: RBXScriptSignal<T>, fn: T): RBXScriptConnection;
+	Once<T extends Callback = Callback>(signal: RBXScriptSignal<T>, fn: T): RBXScriptConnection;
+	BindToRenderStep(name: string, priority: number, fn: (dt: number) => void): void;
+	AddPromise<T>(promise: Promise<T>): Promise<T>;
+	Add<T extends Trackable>(object: T, cleanupMethod?: string): T;
+	Remove<T extends Trackable>(object: T): boolean;
+	Pop<T extends Trackable>(object: T): boolean;
+	AttachToInstance(instance: Instance): RBXScriptConnection;
+	Clean(): void;
+	WrapClean(): () => void;
+	Destroy(): void;
+}
+
+declare const Trove: Trove.Constructor;
+
+export = Trove;