roblox-opencode 1.0.0

package/vendor/rbxutil/streamable/Streamable.luau

@@ -0,0 +1,202 @@
+--!strict
+
+-- Streamable
+-- Stephen Leitnick
+-- March 03, 2021
+
+type StreamableWithInstance = {
+	Instance: Instance?,
+	[any]: any,
+}
+
+local Trove = require(script.Parent.Parent.Trove)
+local Signal = require(script.Parent.Parent.Signal)
+
+--[=[
+	@within Streamable
+	@prop Instance Instance
+	The current instance represented by the Streamable. If this
+	is being observed, it will always exist. If not currently
+	being observed, this will be `nil`.
+]=]
+
+--[=[
+	@class Streamable
+	@client
+	Because parts in StreamingEnabled games can stream in and out of existence at
+	any point in time, it is hard to write code to interact with them. This is
+	where Streamables come into play. Streamables will observe the existence of
+	a given instance, and will signal when the instance exists and does not
+	exist.
+
+	The API is very simple. Create a Streamable that points to a certain parent
+	and looks for a specific child instance (typically a BasePart). Then, call
+	the `Observe` method to observe when the instance streams in and out.
+
+	```lua
+	local Streamable = require(packages.Streamable).Streamable
+
+	-- Models might take a bit to load, but the model instance
+	-- is never removed, thus we can use WaitForChild.
+	local model = workspace:WaitForChild("MyModel")
+
+	-- Watch for a specific part in the model:
+	local partStreamable = Streamable.new(model, "SomePart")
+
+	partStreamable:Observe(function(part, trove)
+		print(part:GetFullName() .. " added")
+		-- Run code on the part here.
+		-- Use the trove to manage cleanup when the part goes away.
+		trove:Add(function()
+			-- General cleanup stuff
+			print(part.Name .. " removed")
+		end)
+	end)
+
+	-- Watch for the PrimaryPart of a model to exist:
+	local primaryStreamable = Streamable.primary(model)
+	primaryStreamable:Observe(function(primary, trove)
+		print("Model now has a PrimaryPart:", primary.Name)
+		trove:Add(function()
+			print("Model's PrimaryPart has been removed")
+		end)
+	end)
+
+	-- At any given point, accessing the Instance field will
+	-- reference the observed part, if it exists:
+	if partStreamable.Instance then
+		print("Streamable has its instance:", partStreamable.Instance)
+	end
+
+	-- When/if done, call Destroy on the streamable, which will
+	-- also clean up any observers:
+	partStreamable:Destroy()
+	primaryStreamable:Destroy()
+	```
+
+	For more information on the mechanics of how StreamingEnabled works
+	and what sort of behavior to expect, see the
+	[Content Streaming](https://developer.roblox.com/en-us/articles/content-streaming#technical-behavior)
+	page. It is important to understand that only BaseParts and their descendants are streamed in/out,
+	whereas other instances are loaded during the initial client load. It is also important to understand
+	that streaming only occurs on the client. The server has immediate access to everything right away.
+]=]
+local Streamable = {}
+Streamable.__index = Streamable
+
+--[=[
+	@return Streamable
+	@param parent Instance
+	@param childName string
+
+	Constructs a Streamable that watches for a direct child of name `childName`
+	within the `parent` Instance. Call `Observe` to observe the existence of
+	the child within the parent.
+]=]
+function Streamable.new(parent: Instance, childName: string)
+	local self: StreamableWithInstance = {}
+	setmetatable(self, Streamable)
+
+	self._trove = Trove.new()
+	self._shown = self._trove:Construct(Signal)
+	self._shownTrove = Trove.new()
+	self._trove:Add(self._shownTrove)
+
+	self.Instance = parent:FindFirstChild(childName)
+
+	local function OnInstanceSet()
+		local instance = self.Instance
+		if typeof(instance) == "Instance" then
+			self._shown:Fire(instance, self._shownTrove)
+			self._shownTrove:Connect(instance:GetPropertyChangedSignal("Parent"), function()
+				if not instance.Parent then
+					self._shownTrove:Clean()
+				end
+			end)
+			self._shownTrove:Add(function()
+				if self.Instance == instance then
+					self.Instance = nil
+				end
+			end)
+		end
+	end
+
+	local function OnChildAdded(child: Instance)
+		if child.Name == childName and not self.Instance then
+			self.Instance = child
+			OnInstanceSet()
+		end
+	end
+
+	self._trove:Connect(parent.ChildAdded, OnChildAdded)
+	if self.Instance then
+		OnInstanceSet()
+	end
+
+	return self
+end
+
+--[=[
+	@return Streamable
+	@param parent Model
+
+	Constructs a streamable that watches for the PrimaryPart of the
+	given `parent` Model.
+]=]
+function Streamable.primary(parent: Model)
+	local self: StreamableWithInstance = {}
+	setmetatable(self, Streamable)
+
+	self._trove = Trove.new()
+	self._shown = self._trove:Construct(Signal)
+	self._shownTrove = Trove.new()
+	self._trove:Add(self._shownTrove)
+
+	self.Instance = parent.PrimaryPart
+
+	local function OnPrimaryPartChanged()
+		local primaryPart = parent.PrimaryPart
+		self._shownTrove:Clean()
+		self.Instance = primaryPart
+		if primaryPart then
+			self._shown:Fire(primaryPart, self._shownTrove)
+		end
+	end
+
+	self._trove:Connect(parent:GetPropertyChangedSignal("PrimaryPart"), OnPrimaryPartChanged)
+	if self.Instance then
+		OnPrimaryPartChanged()
+	end
+
+	return self
+end
+
+--[=[
+	@param handler (instance: Instance, trove: Trove) -> nil
+	@return Connection
+
+	Observes the instance. The handler is called anytime the
+	instance comes into existence, and the trove given is
+	cleaned up when the instance goes away.
+
+	To stop observing, disconnect the returned connection.
+]=]
+function Streamable:Observe(handler)
+	if self.Instance then
+		task.spawn(handler, self.Instance, self._shownTrove)
+	end
+	return self._shown:Connect(handler)
+end
+
+--[=[
+	Destroys the Streamable. Any observers will be disconnected,
+	which also means that troves within observers will be cleaned
+	up. This should be called when a streamable is no longer needed.
+]=]
+function Streamable:Destroy()
+	self._trove:Destroy()
+end
+
+export type Streamable = typeof(Streamable.new(workspace, "X"))
+
+return Streamable

package/vendor/rbxutil/streamable/StreamableUtil.luau

@@ -0,0 +1,80 @@
+--!strict
+
+-- StreamableUtil
+-- Stephen Leitnick
+-- March 03, 2021
+
+local Trove = require(script.Parent.Parent.Trove)
+local _Streamable = require(script.Parent.Streamable)
+
+type Streamables = { _Streamable.Streamable }
+type CompoundHandler = (Streamables, any) -> nil
+
+--[=[
+	@class StreamableUtil
+	@client
+	A utility library for the Streamable class.
+
+	```lua
+	local StreamableUtil = require(packages.Streamable).StreamableUtil
+	```
+]=]
+local StreamableUtil = {}
+
+--[=[
+	@param streamables {Streamable}
+	@param handler ({[child: string]: Instance}, trove: Trove) -> nil
+	@return Trove
+
+	Creates a compound streamable around all the given streamables. The compound
+	streamable's observer handler will be fired once _all_ the given streamables
+	are in existence, and will be cleaned up when _any_ of the streamables
+	disappear.
+
+	```lua
+	local s1 = Streamable.new(workspace, "Part1")
+	local s2 = Streamable.new(workspace, "Part2")
+
+	local compoundTrove = StreamableUtil.Compound({S1 = s1, S2 = s2}, function(streamables, trove)
+		local part1 = streamables.S1.Instance
+		local part2 = streamables.S2.Instance
+		trove:Add(function()
+			print("Cleanup")
+		end)
+	end)
+	```
+]=]
+function StreamableUtil.Compound(streamables: Streamables, handler: CompoundHandler)
+	local compoundTrove = Trove.new()
+	local observeAllTrove = Trove.new()
+	local allAvailable = false
+	local function Check()
+		if allAvailable then
+			return
+		end
+		for _, streamable in pairs(streamables) do
+			if not streamable.Instance then
+				return
+			end
+		end
+		allAvailable = true
+		handler(streamables, observeAllTrove)
+	end
+	local function Cleanup()
+		if not allAvailable then
+			return
+		end
+		allAvailable = false
+		observeAllTrove:Clean()
+	end
+	for _, streamable in pairs(streamables) do
+		compoundTrove:Add(streamable:Observe(function(_child, trove)
+			Check()
+			trove:Add(Cleanup)
+		end))
+	end
+	compoundTrove:Add(Cleanup)
+	return compoundTrove
+end
+
+return StreamableUtil

package/vendor/rbxutil/streamable/init.luau

@@ -0,0 +1,8 @@
+-- Streamable
+-- Stephen Leitnick
+-- November 08, 2021
+
+return {
+	Streamable = require(script.Streamable),
+	StreamableUtil = require(script.StreamableUtil),
+}

package/vendor/rbxutil/streamable/wally.toml

@@ -0,0 +1,12 @@
+[package]
+name = "sleitnick/streamable"
+description = "Streamable class and StreamableUtil"
+version = "1.2.4"
+license = "MIT"
+authors = ["Stephen Leitnick"]
+registry = "https://github.com/UpliftGames/wally-index"
+realm = "shared"
+
+[dependencies]
+Trove = "sleitnick/trove@^0.4"
+Signal = "sleitnick/signal@^1"

package/vendor/rbxutil/symbol/init.luau

@@ -0,0 +1,56 @@
+-- Symbol
+-- Stephen Leitnick
+-- January 04, 2022
+
+--[=[
+	@class Symbol
+
+	Represents a unique object.
+
+	Symbols are often used as unique keys in tables. This is useful to avoid possible collisions
+	with a key in a table, since the symbol will always be unique and cannot be reconstructed.
+
+	
+	:::note All Unique
+	Every creation of a symbol is unique, even if the
+	given names are the same.
+	:::
+
+	```lua
+	local Symbol = require(packages.Symbol)
+	
+	-- Create a symbol:
+	local symbol = Symbol("MySymbol")
+
+	-- The name is optional:
+	local anotherSymbol = Symbol()
+
+	-- Comparison:
+	print(symbol == symbol) --> true
+
+	-- All symbol constructions are unique, regardless of the name:
+	print(Symbol("Hello") == Symbol("Hello")) --> false
+
+	-- Commonly used as unique keys in a table:
+	local DATA_KEY = Symbol("Data")
+	local t = {
+		-- Can only be accessed using the DATA_KEY symbol:
+		[DATA_KEY] = {}
+	}
+
+	print(t[DATA_KEY]) --> {}
+	```
+]=]
+
+local function Symbol(name: string?)
+	local symbol = newproxy(true)
+	if not name then
+		name = ""
+	end
+	getmetatable(symbol).__tostring = function()
+		return "Symbol(" .. name .. ")"
+	end
+	return symbol
+end
+
+return Symbol

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

@@ -0,0 +1,37 @@
+local ServerScriptService = game:GetService("ServerScriptService")
+
+local Test = require(ServerScriptService.TestRunner.Test)
+
+return function(ctx: Test.TestContext)
+	local Symbol = require(script.Parent)
+
+	ctx:Describe("Constructor", function()
+		ctx:Test("should create a new symbol", function()
+			local symbol = Symbol("Test")
+			ctx:Expect(symbol):ToBeA("userdata")
+			ctx:Expect(symbol == symbol):ToBe(true)
+			ctx:Expect(tostring(symbol)):ToBe("Symbol(Test)")
+		end)
+
+		ctx:Test("should create a new symbol with no name", function()
+			local symbol = Symbol()
+			ctx:Expect(symbol):ToBeA("userdata")
+			ctx:Expect(symbol == symbol):ToBe(true)
+			ctx:Expect(tostring(symbol)):ToBe("Symbol()")
+		end)
+
+		ctx:Test("should be unique regardless of the name", function()
+			ctx:Expect(Symbol("Test") == Symbol("Test")):ToBe(false)
+			ctx:Expect(Symbol() == Symbol()):ToBe(false)
+			ctx:Expect(Symbol("Test") == Symbol()):ToBe(false)
+			ctx:Expect(Symbol("Test1") == Symbol("Test2")):ToBe(false)
+		end)
+
+		ctx:Test("should be useable as a table key", function()
+			local symbol = Symbol()
+			local t = {}
+			t[symbol] = 100
+			ctx:Expect(t[symbol]):ToBe(100)
+		end)
+	end)
+end

package/vendor/rbxutil/symbol/wally.toml

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