roblox-opencode 1.0.0

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

@@ -0,0 +1,364 @@
+local ServerScriptService = game:GetService("ServerScriptService")
+
+local Test = require(ServerScriptService.TestRunner.Test)
+
+return function(ctx: Test.TestContext)
+	local Concur = require(script.Parent)
+
+	local function Awaiter(timeout: number)
+		local awaiter = {}
+		local thread
+		local delayThread
+		function awaiter.Resume(...)
+			if coroutine.running() ~= delayThread then
+				task.cancel(delayThread)
+			end
+			task.spawn(thread, ...)
+		end
+		function awaiter.Yield()
+			thread = coroutine.running()
+			delayThread = task.delay(timeout, function()
+				awaiter.Resume()
+			end)
+			return coroutine.yield()
+		end
+		return awaiter
+	end
+
+	local bindableEvent
+	ctx:BeforeEach(function()
+		bindableEvent = Instance.new("BindableEvent")
+	end)
+	ctx:AfterEach(function()
+		bindableEvent:Destroy()
+		bindableEvent = nil
+	end)
+
+	ctx:Describe("Single", function()
+		ctx:Test("should spawn a new concur instance", function()
+			local value = nil
+			ctx:Expect(function()
+				Concur.spawn(function()
+					value = 10
+				end)
+			end)
+				:Not()
+				:ToThrow()
+			ctx:Expect(value):ToBe(10)
+		end)
+
+		ctx:Test("should defer a new concur instance", function()
+			local awaiter = Awaiter(1)
+			ctx:Expect(function()
+				Concur.defer(function()
+					awaiter.Resume(10)
+				end)
+			end)
+				:Not()
+				:ToThrow()
+			local value = awaiter.Yield()
+			ctx:Expect(value):ToBe(10)
+		end)
+
+		ctx:Test("should delay a new concur instance", function()
+			local awaiter = Awaiter(1)
+			ctx:Expect(function()
+				Concur.delay(0.1, function()
+					awaiter.Resume(10)
+				end)
+			end)
+				:Not()
+				:ToThrow()
+			local value = awaiter.Yield()
+			ctx:Expect(value):ToBe(10)
+		end)
+
+		ctx:Test("should create an immediate value concur instance", function()
+			local c
+			ctx:Expect(function()
+				c = Concur.value(10)
+			end)
+				:Not()
+				:ToThrow()
+			ctx:Expect(c):ToBeOk()
+			ctx:Expect(c:IsCompleted()):ToBe(true)
+			local err, val = c:Await()
+			ctx:Expect(err):ToBeNil()
+			ctx:Expect(val):ToBe(10)
+		end)
+
+		ctx:Test("should create a concur instance to watch an event with no predicate", function()
+			local c
+			ctx:Expect(function()
+				c = Concur.event(bindableEvent.Event)
+			end)
+				:Not()
+				:ToThrow()
+			ctx:Expect(c:IsCompleted()):ToBe(false)
+			bindableEvent:Fire(10)
+			local err, val = c:Await(1)
+			ctx:Expect(err):ToBeNil()
+			ctx:Expect(val):ToBe(10)
+		end)
+
+		ctx:Test("should create a concur instance to watch an event with a predicate", function()
+			local c
+			ctx:Expect(function()
+				c = Concur.event(bindableEvent.Event, function(v)
+					return v < 10
+				end)
+			end)
+				:Not()
+				:ToThrow()
+			ctx:Expect(c:IsCompleted()):ToBe(false)
+			bindableEvent:Fire(10)
+			bindableEvent:Fire(5)
+			local err, val = c:Await(1)
+			ctx:Expect(err):ToBeNil()
+			ctx:Expect(val):ToBe(5)
+		end)
+	end)
+
+	ctx:Describe("Multi", function()
+		ctx:Test("should complete all concur instances", function()
+			local c1 = Concur.spawn(function()
+				return 10
+			end)
+			local c2 = Concur.defer(function()
+				return 20
+			end)
+			local c3 = Concur.delay(0, function()
+				return 30
+			end)
+			local c4 = Concur.spawn(function()
+				error("fail")
+			end)
+			local c5 = Concur.event(bindableEvent.Event)
+			local c = Concur.all({ c1, c2, c3, c4, c5 })
+			ctx:Expect(c:IsCompleted()):ToBe(false)
+			bindableEvent:Fire(40)
+			local err, res = c:Await(1)
+			ctx:Expect(err):ToBeNil()
+			ctx:Expect(res[1][1]):ToBeNil()
+			ctx:Expect(res[1][2]):ToBe(10)
+			ctx:Expect(res[2][1]):ToBeNil()
+			ctx:Expect(res[2][2]):ToBe(20)
+			ctx:Expect(res[3][1]):ToBeNil()
+			ctx:Expect(res[3][2]):ToBe(30)
+			ctx:Expect(res[4][1]):ToBeOk()
+			ctx:Expect(res[4][2]):ToBeNil()
+			ctx:Expect(res[5][1]):ToBeNil()
+			ctx:Expect(res[5][2]):ToBe(40)
+		end)
+
+		ctx:Test("should complete the first concur instance", function()
+			local c1 = Concur.defer(function()
+				return 10
+			end)
+			local c2 = Concur.spawn(function()
+				return 20
+			end)
+			local c = Concur.first({ c1, c2 })
+			local err, res = c:Await(1)
+			ctx:Expect(err):ToBeNil()
+			ctx:Expect(res):ToBe(20)
+		end)
+	end)
+
+	ctx:Describe("Stop", function()
+		ctx:Test("should stop a single concur", function()
+			local c1 = Concur.defer(function()
+				return 10
+			end)
+			ctx:Expect(c1:IsCompleted()):ToBe(false)
+			c1:Stop()
+			ctx:Expect(c1:IsCompleted()):ToBe(true)
+			local err, val = c1:Await()
+			ctx:Expect(err):ToBe(Concur.Errors.Stopped)
+			ctx:Expect(val):ToBeNil()
+		end)
+
+		ctx:Test("should stop multiple concurs", function()
+			local c1 = Concur.defer(function() end)
+			local c2 = Concur.delay(1, function() end)
+			local c3 = Concur.event(bindableEvent.Event)
+			local c = Concur.all({ c1, c2, c3 })
+			c:Stop()
+			local err, val = c:Await()
+			ctx:Expect(err):ToBe(Concur.Errors.Stopped)
+			ctx:Expect(val):ToBeNil()
+		end)
+
+		ctx:Test("should not stop an already completed concur", function()
+			local c1 = Concur.spawn(function()
+				return 10
+			end)
+			ctx:Expect(c1:IsCompleted()):ToBe(true)
+			c1:Stop()
+			local err, val = c1:Await()
+			ctx:Expect(err):ToBeNil()
+			ctx:Expect(val):ToBe(10)
+		end)
+	end)
+
+	ctx:Describe("IsCompleted", function()
+		ctx:Test("should correctly check if a concur instance is completed", function()
+			local c1 = Concur.defer(function() end)
+			ctx:Expect(c1:IsCompleted()):ToBe(false)
+			local err = c1:Await()
+			ctx:Expect(err):ToBeNil()
+			ctx:Expect(c1:IsCompleted()):ToBe(true)
+		end)
+
+		ctx:Test("should be marked as completed if error", function()
+			local c1 = Concur.spawn(function()
+				error("err")
+			end)
+			ctx:Expect(c1:IsCompleted()):ToBe(true)
+		end)
+
+		ctx:Test("should be marked as completed if stopped", function()
+			local c1 = Concur.defer(function() end)
+			c1:Stop()
+			ctx:Expect(c1:IsCompleted()):ToBe(true)
+		end)
+	end)
+
+	ctx:Describe("Await", function()
+		ctx:Test("should await concur to be completed", function()
+			local c1 = Concur.defer(function()
+				return 10
+			end)
+			local err, val = c1:Await(1)
+			ctx:Expect(err):ToBeNil()
+			ctx:Expect(val):ToBe(10)
+		end)
+
+		ctx:Test("should await concur to be completed even if error", function()
+			local c1 = Concur.defer(function()
+				return error("err")
+			end)
+			local err, val = c1:Await(1)
+			ctx:Expect(err):ToBeOk()
+			ctx:Expect(val):ToBeNil()
+		end)
+
+		ctx:Test("should await concur to be completed even if stopped", function()
+			local c1 = Concur.delay(0.1, function()
+				return 10
+			end)
+			task.defer(function()
+				c1:Stop()
+			end)
+			local err, val = c1:Await(1)
+			ctx:Expect(err):ToBe(Concur.Errors.Stopped)
+			ctx:Expect(val):ToBeNil()
+		end)
+
+		ctx:Test("should return completed values immediately if already completed", function()
+			local c1 = Concur.spawn(function()
+				return 10
+			end)
+			ctx:Expect(c1:IsCompleted()):ToBe(true)
+			local err, val = c1:Await()
+			ctx:Expect(err):ToBeNil()
+			ctx:Expect(val):ToBe(10)
+		end)
+
+		ctx:Test("should timeout", function()
+			local c1 = Concur.delay(0.2, function()
+				return 10
+			end)
+			local err, val = c1:Await(0.1)
+			ctx:Expect(err):ToBe(Concur.Errors.Timeout)
+			ctx:Expect(val):ToBeNil()
+			err, val = c1:Await()
+			ctx:Expect(err):ToBeNil()
+			ctx:Expect(val):ToBe(10)
+		end)
+	end)
+
+	ctx:Describe("OnCompleted", function()
+		ctx:Test("should fire function once completed", function()
+			local awaiter = Awaiter(0.1)
+			local c1 = Concur.defer(function()
+				return 10
+			end)
+			ctx:Expect(c1:IsCompleted()):ToBe(false)
+			c1:OnCompleted(function(err, val)
+				awaiter.Resume(err, val)
+			end)
+			local err, val = awaiter.Yield()
+			ctx:Expect(err):ToBeNil()
+			ctx:Expect(val):ToBe(10)
+		end)
+
+		ctx:Test("should fire function even if already completed", function()
+			local c1 = Concur.spawn(function()
+				return 10
+			end)
+			ctx:Expect(c1:IsCompleted()):ToBe(true)
+			local err, val
+			c1:OnCompleted(function(e, v)
+				err, val = e, v
+			end)
+			ctx:Expect(err):ToBeNil()
+			ctx:Expect(val):ToBe(10)
+		end)
+
+		ctx:Test("should fire function even if error", function()
+			local awaiter = Awaiter(0.1)
+			local c1 = Concur.defer(function()
+				error("err")
+			end)
+			c1:OnCompleted(function(err, val)
+				awaiter.Resume(err, val)
+			end)
+			local err, val = awaiter.Yield()
+			ctx:Expect(err):ToBeOk()
+			ctx:Expect(val):ToBeNil()
+		end)
+
+		ctx:Test("should fire function even if stopped", function()
+			local awaiter = Awaiter(0.2)
+			local c1 = Concur.delay(0.1, function()
+				error("err")
+			end)
+			c1:OnCompleted(function(err, val)
+				awaiter.Resume(err, val)
+			end)
+			task.defer(function()
+				c1:Stop()
+			end)
+			local err, val = awaiter.Yield()
+			ctx:Expect(err):ToBe(Concur.Errors.Stopped)
+			ctx:Expect(val):ToBeNil()
+		end)
+
+		ctx:Test("should fire function even if timeout", function()
+			local awaiter = Awaiter(0.5)
+			local c1 = Concur.delay(0.2, function()
+				error("err")
+			end)
+			c1:OnCompleted(function(err, val)
+				awaiter.Resume(err, val)
+			end, 0.1)
+			local err, val = awaiter.Yield()
+			ctx:Expect(err):ToBe(Concur.Errors.Timeout)
+			ctx:Expect(val):ToBeNil()
+		end)
+
+		ctx:Test("should unbind function", function()
+			local c1 = Concur.defer(function() end)
+			local val = nil
+			local unbind = c1:OnCompleted(function()
+				val = 10
+			end)
+			unbind()
+			local err = c1:Await()
+			ctx:Expect(err):ToBeNil()
+			task.wait()
+			ctx:Expect(val):ToBeNil()
+		end)
+	end)
+end

package/vendor/rbxutil/concur/wally.toml

@@ -0,0 +1,8 @@
+[package]
+name = "sleitnick/concur"
+description = "Concurrent task handler"
+version = "0.1.2"
+license = "MIT"
+authors = ["Stephen Leitnick"]
+registry = "https://github.com/UpliftGames/wally-index"
+realm = "shared"

package/vendor/rbxutil/enum-list/init.luau

@@ -0,0 +1,101 @@
+-- EnumList
+-- Stephen Leitnick
+-- January 08, 2021
+
+type EnumNames = { string }
+
+--[=[
+	@interface EnumItem
+	.Name string
+	.Value number
+	.EnumType EnumList
+	@within EnumList
+]=]
+export type EnumItem = {
+	Name: string,
+	Value: number,
+	EnumType: any,
+}
+
+local LIST_KEY = newproxy()
+local NAME_KEY = newproxy()
+
+local function CreateEnumItem(name: string, value: number, enum: any): EnumItem
+	local enumItem = {
+		Name = name,
+		Value = value,
+		EnumType = enum,
+	}
+	table.freeze(enumItem)
+	return enumItem
+end
+
+--[=[
+	@class EnumList
+	Defines a new Enum.
+]=]
+local EnumList = {}
+EnumList.__index = EnumList
+
+--[=[
+	@param name string
+	@param enums {string}
+	@return EnumList
+	Constructs a new EnumList.
+
+	```lua
+	local directions = EnumList.new("Directions", {
+		"Up",
+		"Down",
+		"Left",
+		"Right",
+	})
+
+	local direction = directions.Up
+	```
+]=]
+function EnumList.new(name: string, enums: EnumNames)
+	assert(type(name) == "string", "Name string required")
+	assert(type(enums) == "table", "Enums table required")
+	local self = {}
+	self[LIST_KEY] = {}
+	self[NAME_KEY] = name
+	for i, enumName in ipairs(enums) do
+		assert(type(enumName) == "string", "Enum name must be a string")
+		local enumItem = CreateEnumItem(enumName, i, self)
+		self[enumName] = enumItem
+		table.insert(self[LIST_KEY], enumItem)
+	end
+	return table.freeze(setmetatable(self, EnumList))
+end
+
+--[=[
+	@param obj any
+	@return boolean
+	Returns `true` if `obj` belongs to the EnumList.
+]=]
+function EnumList:BelongsTo(obj: any): boolean
+	return type(obj) == "table" and obj.EnumType == self
+end
+
+--[=[
+	Returns an array of all enum items.
+	@return {EnumItem}
+	@since v2.0.0
+]=]
+function EnumList:GetEnumItems()
+	return self[LIST_KEY]
+end
+
+--[=[
+	Get the name of the enum.
+	@return string
+	@since v2.0.0
+]=]
+function EnumList:GetName()
+	return self[NAME_KEY]
+end
+
+export type EnumList = typeof(EnumList.new(...))
+
+return EnumList

package/vendor/rbxutil/enum-list/init.test.luau

@@ -0,0 +1,91 @@
+local ServerScriptService = game:GetService("ServerScriptService")
+
+local Test = require(ServerScriptService.TestRunner.Test)
+
+return function(ctx: Test.TestContext)
+	local EnumList = require(script.Parent)
+
+	ctx:Describe("Constructor", function()
+		ctx:Test("should create a new enumlist", function()
+			ctx:Expect(function()
+				EnumList.new("Test", { "ABC", "XYZ" })
+			end)
+				:Not()
+				:ToThrow()
+		end)
+
+		ctx:Test("should fail to create a new enumlist with no name", function()
+			ctx:Expect(function()
+				EnumList.new(nil, { "ABC", "XYZ" })
+			end):ToThrow()
+		end)
+
+		ctx:Test("should fail to create a new enumlist with no enums", function()
+			ctx:Expect(function()
+				EnumList.new("Test")
+			end):ToThrow()
+		end)
+
+		ctx:Test("should fail to create a new enumlist with non string enums", function()
+			ctx:Expect(function()
+				EnumList.new("Test", { true, false, 32, "ABC" })
+			end):ToThrow()
+		end)
+	end)
+
+	ctx:Describe("Access", function()
+		ctx:Test("should be able to access enum items", function()
+			local test = EnumList.new("Test", { "ABC", "XYZ" })
+			ctx:Expect(function()
+				local _item = test.ABC
+			end)
+				:Not()
+				:ToThrow()
+			ctx:Expect(test:BelongsTo(test.ABC)):ToBe(true)
+		end)
+
+		ctx:Test("should throw if trying to modify the enumlist", function()
+			local test = EnumList.new("Test", { "ABC", "XYZ" })
+			ctx:Expect(function()
+				test.Hello = 32
+			end):ToThrow()
+			ctx:Expect(function()
+				test.ABC = 32
+			end):ToThrow()
+		end)
+
+		ctx:Test("should throw if trying to modify an enumitem", function()
+			local test = EnumList.new("Test", { "ABC", "XYZ" })
+			ctx:Expect(function()
+				local abc = test.ABC
+				abc.XYZ = 32
+			end):ToThrow()
+			ctx:Expect(function()
+				local abc = test.ABC
+				abc.Name = "NewName"
+			end):ToThrow()
+		end)
+
+		ctx:Test("should get the name", function()
+			local test = EnumList.new("Test", { "ABC", "XYZ" })
+			local name = test:GetName()
+			ctx:Expect(name):ToBe("Test")
+		end)
+	end)
+
+	ctx:Describe("Get Items", function()
+		ctx:Test("should be able to get all enum items", function()
+			local test = EnumList.new("Test", { "ABC", "XYZ" })
+			local items = test:GetEnumItems()
+			ctx:Expect(items):ToBeA("table")
+			ctx:Expect(#items):ToBe(2)
+			for i, enumItem in ipairs(items) do
+				ctx:Expect(enumItem):ToBeA("table")
+				ctx:Expect(enumItem.Name):ToBeA("string")
+				ctx:Expect(enumItem.Value):ToBeA("number")
+				ctx:Expect(enumItem.Value):ToBe(i)
+				ctx:Expect(enumItem.EnumType):ToBe(test)
+			end
+		end)
+	end)
+end

package/vendor/rbxutil/enum-list/wally.toml

@@ -0,0 +1,8 @@
+[package]
+name = "sleitnick/enum-list"
+description = "Enum List class"
+version = "2.1.0"
+license = "MIT"
+authors = ["Stephen Leitnick"]
+registry = "https://github.com/UpliftGames/wally-index"
+realm = "shared"

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

@@ -0,0 +1,20 @@
+/**
+ * Find an instance in the data model hierarchy, otherwise throw an error.
+ *
+ * ```ts
+ * const part = find<BasePart>(Workspace, "Some", "Model", "Part");
+ * ```
+ *
+ * Note that the generic type is not a runtime-enforced type-check. A custom
+ * assertion is needed if you desire to enforce the type:
+ * ```ts
+ * const folder = find<Folder>(ReplicatedStorage, "Somewhere", "MyFolder");
+ * assert(folder.IsA("Folder"));
+ * ```
+ *
+ * @param parent The parent where the search begins.
+ * @param path The name of each instance, where the last one is the returned instance.
+ */
+declare function find<T extends Instance = Instance>(parent: Instance, ...path: string[]): T;
+
+export = find;

package/vendor/rbxutil/find/init.luau

@@ -0,0 +1,44 @@
+--!strict
+
+--[=[
+	@class Find
+
+	A utility function for finding objects in the data model hierarchy.
+
+	Similar to `FindFirstChild`, except it explicitly errors if any object
+	is not found, as well as a more helpful message as to what wasn't found.
+
+	```lua
+	local find = require(ReplicatedStorage.Packages.find)
+
+	-- Find instance "workspace.Some.Folder.Here.Item":
+	local item = find(workspace, "Some", "Folder", "Here", "Item")
+	```
+
+	In the above example, if "Folder" didn't exist, the function would throw an error with the message: `failed to find instance "Folder" within "Workspace.Some"`.
+
+	The return type is simply `Instance`. Any type-checking should be done on the return value:
+	```lua
+	local part = find(workspace, "SomePart") :: BasePart -- Blindly assume and type this as a BasePart
+	assert(part:IsA("BasePart")) -- Extra optional precaution to ensure type
+	```
+]=]
+
+local function find(parent: Instance, ...: string): Instance
+	local instance = parent
+
+	for i = 1, select("#", ...) do
+		local name = (select(i, ...))
+
+		local inst = instance:FindFirstChild(name)
+		if inst == nil then
+			error(`failed to find instance "{name}" within {instance:GetFullName()}`, 2)
+		end
+
+		instance = inst
+	end
+
+	return instance
+end
+
+return find

package/vendor/rbxutil/find/package.json

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

package/vendor/rbxutil/find/wally.toml

@@ -0,0 +1,8 @@
+[package]
+name = "sleitnick/find"
+description = "Utility function for finding an in the data model hierarchy"
+version = "1.0.0"
+license = "MIT"
+authors = ["Stephen Leitnick"]
+registry = "https://github.com/UpliftGames/wally-index"
+realm = "shared"