roblox-opencode 1.0.0

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

@@ -0,0 +1,43 @@
+/**
+ * Adds helpful functions that wrap
+ * [`Instance:QueryDescendants()`](https://create.roblox.com/docs/reference/engine/classes/Instance#QueryDescendants).
+ */
+interface Query {
+	/**
+	 * Equivalent to [`parent.QueryDescendants(selector)`](https://create.roblox.com/docs/reference/engine/classes/Instance#QueryDescendants).
+	 */
+	all: (parent: Instance, selector: string) => Instance[];
+
+	/**
+	 * Returns the query result, filtered by the `filter` function. Ideally, most of
+	 * the filtering should be done with the selector itself. However, if the selector
+	 * is not enough, this function can be used to further filter the results.
+	 */
+	filter: (parent: Instance, selector: string, filter: (instance: Instance) => boolean) => Instance[];
+
+	/**
+	 * Returns the query result mapped by the `map` function.
+	 */
+	map: <T>(parent: Instance, selector: string, map: (instance: Instance) => T) => Instance[];
+
+	/**
+	 * Returns the first item from the query. Might be `nil` if the query returns
+	 * nothing.
+	 *
+	 * This is equivalent to `parent.QueryDescendants(selector)[1]`.
+	 */
+	first: (parent: Instance, selector: string) => Instance | undefined;
+
+	/**
+	 * Asserts that the query returns exactly one instance. The instance is returned.
+	 * This is useful when attempting to find an exact match of an instance that
+	 * must exist.
+ 	 *
+	 * If the result returns zero or more than one result, an error is thrown.
+	 */
+	one: (parent: Instance, selector: string) => Instance;
+}
+
+declare const Query: Query;
+
+export = Query;

package/vendor/rbxutil/query/init.luau

@@ -0,0 +1,117 @@
+--!strict
+
+--[=[
+	@class Query
+
+	Adds helpful functions that wrap
+	[`Instance:QueryDescendants()`](https://create.roblox.com/docs/reference/engine/classes/Instance#QueryDescendants).
+]=]
+
+local Query = {}
+
+--[=[
+	@within Query
+
+	Equivalent to [`parent:QueryDescendants(selector)`](https://create.roblox.com/docs/reference/engine/classes/Instance#QueryDescendants).
+]=]
+function Query.all(parent: Instance, selector: string): { Instance }
+	return parent:QueryDescendants(selector)
+end
+
+--[=[
+	@within Query
+
+	Returns the query result, filtered by the `filter` function. Ideally, most of
+	the filtering should be done with the selector itself. However, if the selector
+	is not enough, this function can be used to further filter the results.
+
+	```lua
+	local buttons = Query.filter(workspace, ".Button", function(instance)
+		return instance.Transparency > 0.25
+	end)
+	```
+]=]
+function Query.filter(parent: Instance, selector: string, filter: (Instance) -> boolean): { Instance }
+	local instances = parent:QueryDescendants(selector)
+	for i = #instances, 1, -1 do
+		if not filter(instances[i]) then
+			table.remove(instances, i)
+		end
+	end
+	return instances
+end
+
+--[=[
+	@within Query
+
+	Returns the query result mapped by the `map` function.
+
+	```lua
+	local Button = {}
+
+	function Button.new(btn: BasePart)
+		...
+	end
+
+	----
+
+	local buttons = Query.map(workspace, ".Button", function(instance)
+		return Button.new(instance)
+	end)
+	```
+]=]
+function Query.map<T>(parent: Instance, selector: string, map: (Instance) -> T): { T }
+	local instances = parent:QueryDescendants(selector)
+	local mapped = table.create(#instances)
+	for i, instance in instances do
+		mapped[i] = map(instance)
+	end
+	return mapped
+end
+
+--[=[
+	@within Query
+
+	Returns the first item from the query. Might be `nil` if the query returns
+	nothing.
+
+	This is equivalent to `parent:QueryDescendants(selector)[1]`.
+
+	```lua
+	-- Find an instance tagged with 'Tycoon' that has
+	-- the OwnerId attribute matching the player's UserId:
+	local tycoon = Query.first(workspace, `.Tycoon[$OwnerId = {player.UserId}]`)
+
+	if tycoon then
+		...
+	end
+	```
+]=]
+function Query.first(parent: Instance, selector: string): Instance?
+	return parent:QueryDescendants(selector)[1]
+end
+
+--[=[
+	@within Query
+
+	Asserts that the query returns exactly one instance. The instance is returned.
+	This is useful when attempting to find an exact match of an instance that
+	must exist.
+
+	If the result returns zero or more than one result, an error is thrown.
+
+	```lua
+	-- Find a SpawnLocation that has the MainSpawn attribute set to true:
+	local spawnPoint = Query.one(workspace, "SpawnLocation[$MainSpawn = true]")
+	```
+]=]
+function Query.one(parent: Instance, selector: string): Instance
+	local instances = parent:QueryDescendants(selector)
+	if #instances ~= 1 then
+		error(`expected 1 instance from query; got {#instances} instances (selector: {selector})`, 2)
+	end
+
+	return instances[1]
+end
+
+return Query

package/vendor/rbxutil/query/package.json

@@ -0,0 +1,18 @@
+{
+	"name": "@rbxutil/query",
+	"version": "0.2.0",
+	"main": "init.luau",
+	"repository": {
+		"url": "git+https://github.com/Sleitnick/RbxUtil.git"
+	},
+	"license": "MIT",
+	"types": "index.d.ts",
+	"files": [
+		"./*",
+		"!*.toml",
+		"!*.json"
+	],
+	"publishConfig": {
+		"access": "public"
+	}
+}

package/vendor/rbxutil/query/wally.toml

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

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

@@ -0,0 +1,28 @@
+declare namespace Sequent {
+	interface Constructor {
+		new <T>(cancellable?: boolean): Sequent<T>;
+	}
+
+	interface SequentEvent<T> {
+		readonly Value: T;
+		readonly Cancellable: boolean;
+		Cancel(): void;
+	}
+
+	interface SequentConnection {
+		readonly Connected: boolean;
+		Disconnect(): void;
+	}
+}
+
+interface Sequent<T> {
+	Fire(value: T): void;
+	Connect(callback: (event: Sequent.SequentEvent<T>) => void): Sequent.SequentConnection;
+	Once(callback: (event: Sequent.SequentEvent<T>) => void): Sequent.SequentConnection;
+	Cancel(): void;
+	Destroy(): void;
+}
+
+declare const Sequent: Sequent.Constructor;
+
+export = Sequent;

package/vendor/rbxutil/sequent/init.luau

@@ -0,0 +1,340 @@
+export type Sequent<T> = {
+	Fire: (self: Sequent<T>, T) -> (),
+	Connect: (self: Sequent<T>, callback: (SequentEvent<T>) -> ()) -> SequentConnection,
+	Once: (self: Sequent<T>, callback: (SequentEvent<T>) -> ()) -> SequentConnection,
+	Cancel: (self: Sequent<T>) -> (),
+	Destroy: (self: Sequent<T>) -> (),
+}
+
+--[=[
+	@interface SequentConnection
+	@within Sequent
+	.Connected boolean
+	.Disconnect (self: SequentConnection) -> ()
+
+	```lua
+	print(sequent.Connected)
+	sequent:Disconnect()
+	```
+]=]
+export type SequentConnection = {
+	Connected: boolean,
+	Disconnect: (self: SequentConnection) -> (),
+}
+
+--[=[
+	@interface SequentEvent<T>
+	@within Sequent
+	.Value T
+	.Cancellable boolean
+	.Cancel (self: SequentEvent<T>) -> ()
+
+	Events are passed to connected callbacks when sequents are fired. Events
+	can be cancelled as well, which prevents the event from propagating to
+	other connected callbacks during the same firing. This can be used to
+	sink events if desired.
+
+	```lua
+	sequent:Connect(function(event)
+		print(event.Value)
+		event:Cancel()
+	end, 0)
+	```
+]=]
+export type SequentEvent<T> = {
+	Value: T,
+	Cancellable: boolean,
+	Cancel: (self: SequentEvent<T>) -> (),
+}
+
+type InternalSequentConnection = SequentConnection & {
+	_priority: number,
+	_sequent: Sequent<unknown>,
+}
+
+-----------------------------------------------------------------------------
+-- Connection
+local SequentConnection = {}
+SequentConnection.__index = SequentConnection
+
+function SequentConnection:Disconnect()
+	self._sequent:_disconnect(self)
+end
+
+-----------------------------------------------------------------------------
+-- Sequent
+
+--[=[
+	@interface Priority
+	@within Sequent
+	.Highest math.huge
+	.High 1000
+	.Normal 0
+	.Low -1000
+	.Lowest -math.huge
+
+	```lua
+	sequent:Connect(fn, Sequent.Priority.Highest)
+	```
+]=]
+local Priority = {
+	Highest = math.huge,
+	High = 1000,
+	Normal = 0,
+	Low = -1000,
+	Lowest = -math.huge,
+}
+
+--[=[
+	@class Sequent
+
+	Sequent is a signal-like structure that executes connections in a serial nature. Each
+	connection must fully complete before the next is run. Connections can be prioritized
+	and cancelled.
+
+	```lua
+	local sequent = Sequent.new()
+
+	sequent:Connect(
+		function(event)
+			print("Got value", event.Value)
+			event:Cancel()
+		end,
+		Sequent.Priority.Highest,
+	)
+
+	sequent:Connect(
+		function(event)
+			print("This won't print!")
+		end,
+		Sequent.Priority.Lowest,
+	)
+
+	sequent:Fire("Test")
+	```
+]=]
+local Sequent = {}
+Sequent.__index = Sequent
+
+--[=[
+	Constructs a new Sequent. If `cancellable` is `true`, then
+	connected handlers can cancel event propagation.
+]=]
+function Sequent.new<T>(cancellable: boolean?): Sequent<T>
+	local self = setmetatable({
+		_connections = {},
+		_firing = false,
+		_queuedDisconnect = false,
+
+		_firingThread = nil,
+		_taskThread = nil,
+
+		_cancellable = not not cancellable,
+	}, Sequent)
+
+	return self
+end
+
+--[=[
+	@yields
+	Fires the Sequent with the given value.
+
+	This method will yield until all connections complete. Errors will
+	bubble up if they occur within a connection.
+]=]
+function Sequent:Fire<T>(value: T)
+	assert(not self._firing, "cannot fire while already firing")
+	self._firing = true
+
+	local cancelled = false
+	local event: SequentEvent<T> = table.freeze({
+		Value = value,
+		Cancellable = self._cancellable,
+		Cancel = function(_evt)
+			if not self._cancellable then
+				warn("attempted to cancel non-cancellable event")
+				return
+			end
+			cancelled = true
+		end,
+	})
+
+	local thread = coroutine.running()
+	self._firingThread = thread
+	for _, connection in self._connections do
+		if not connection.Connected then
+			continue
+		end
+
+		-- Run the task:
+		local success, err = nil, nil
+		local taskThread = task.spawn(function()
+			self._taskThread = coroutine.running()
+
+			local s, e = pcall(function()
+				connection._callback(event)
+			end)
+
+			self._taskThread = nil
+
+			-- Resume the parent thread if it yielded:
+			if coroutine.status(thread) == "suspended" then
+				task.spawn(thread, s, e)
+			else
+				success, err = s, e
+			end
+		end)
+
+		-- If the task thread yielded, yield this thread too:
+		if success == nil then
+			success, err = coroutine.yield()
+		end
+
+		self._firingThread = nil
+
+		-- Throw error if the task failed:
+		if not success then
+			error(debug.traceback(taskThread, tostring(err)))
+		end
+
+		if cancelled then
+			break
+		end
+	end
+
+	-- If connections were disconnected while firing connections, disconnect them now:
+	if self._queuedDisconnect then
+		self._queuedDisconnect = false
+		for i = #self._connections, 1, -1 do
+			local connection = self._connections[i]
+			if not connection.Connected then
+				self:_removeConnection(connection)
+			end
+		end
+	end
+
+	self._firing = false
+end
+
+--[=[
+	Returns `true` if the Sequent is currently firing.
+]=]
+function Sequent:IsFiring(): boolean
+	return self._firing
+end
+
+--[=[
+	Connects a callback to the Sequent, which gets called anytime `Fire`
+	is called.
+
+	The given `priority` indicates the firing priority of the callback. Higher
+	priority values will be run first. There are a few defaults available via
+	`Sequent.Priority`.
+]=]
+function Sequent:Connect(callback: (...unknown) -> (), priority: number): SequentConnection
+	assert(not self._firing, "cannot connect while firing")
+
+	local connection = setmetatable({
+		Connected = true,
+		_callback = callback,
+		_priority = priority,
+		_sequent = self,
+	}, SequentConnection)
+
+	-- Find the correct index to remain sorted by priority:
+	local idx = #self._connections + 1
+	for i, c: InternalSequentConnection in self._connections do
+		if c._priority < priority then
+			idx = i
+			break
+		end
+	end
+
+	table.insert(self._connections, idx, connection)
+
+	return connection
+end
+
+--[=[
+	`Once()` is the same as `Connect()`, except the connection is automatically
+	disconnected after being fired once.
+]=]
+function Sequent:Once(callback: (...unknown) -> (), priority: number): SequentConnection
+	local connection: SequentConnection
+
+	connection = self:Connect(function(...)
+		if not connection.Connected then
+			return
+		end
+		connection:Disconnect()
+		callback(...)
+	end, priority)
+
+	return connection
+end
+
+--[=[
+	Cancels a currently-firing Sequent.
+]=]
+function Sequent:Cancel()
+	if not self._firing then
+		return
+	end
+
+	if self._taskThread == coroutine.running() then
+		error("cannot cancel sequent from connected task", 2)
+	end
+
+	if self._taskThread then
+		-- pcall needed as the task thread may have yielded from a call to
+		-- a roblox service, which will throw an error when calling task.cancel:
+		pcall(function()
+			task.cancel(self._taskThread)
+		end)
+		self._taskThread = nil
+	end
+
+	if self._firingThread then
+		local thread = self._firingThread
+		self._firingThread = nil
+		task.spawn(thread, true)
+	end
+end
+
+--[=[
+	Cleans up the Sequent. All connections are disconnected. The Sequent is cancelled
+	if it is currently firing.
+]=]
+function Sequent:Destroy()
+	self:Cancel()
+
+	for _, connection in self._connections do
+		connection.Connected = false
+	end
+end
+
+function Sequent:_disconnect(connection)
+	if not connection.Connected then
+		return
+	end
+	connection.Connected = false
+
+	if self._firing then
+		self._queuedDisconnect = true
+		return
+	end
+
+	self:_removeConnection(connection)
+end
+
+function Sequent:_removeConnection(connection)
+	local idx = table.find(self._connections, connection)
+	if idx then
+		table.remove(self._connections, idx)
+	end
+end
+
+return table.freeze({
+	new = Sequent.new,
+	Priority = Priority,
+})

package/vendor/rbxutil/sequent/package.json

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

package/vendor/rbxutil/sequent/wally.toml

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