cluaupp 0.1.0

package/runtime/StateMachine/_impl/Functions/mergeTables.lua

@@ -0,0 +1,22 @@
+--[[
+    Merges two tables together
+]]
+local function mergeTables(baseTable, targetTable)
+    for index: string, value in targetTable do
+        if typeof(baseTable[index]) == typeof(value) then
+            if baseTable[index] ~= (getmetatable(baseTable) or {})[index] then
+                continue
+            end
+        end
+
+        if type(value) == "table" then
+            baseTable[index] = table.clone(value)
+        else
+            baseTable[index] = value
+        end
+    end
+
+    return baseTable
+end
+
+return mergeTables

package/runtime/StateMachine/_impl/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) [2023] [prooheckcp]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/runtime/StateMachine/_impl/Vendor/Signal.lua

@@ -0,0 +1,386 @@
+-- -----------------------------------------------------------------------------
+--               Batched Yield-Safe Signal Implementation                     --
+-- This is a Signal class which has effectively identical behavior to a       --
+-- normal RBXScriptSignal, with the only difference being a couple extra      --
+-- stack frames at the bottom of the stack trace when an error is thrown.     --
+-- This implementation caches runner coroutines, so the ability to yield in   --
+-- the signal handlers comes at minimal extra cost over a naive signal        --
+-- implementation that either always or never spawns a thread.                --
+--                                                                            --
+-- API:                                                                       --
+--   local Signal = require(THIS MODULE)                                      --
+--   local sig = Signal.new()                                                 --
+--   local connection = sig:Connect(function(arg1, arg2, ...) ... end)        --
+--   sig:Fire(arg1, arg2, ...)                                                --
+--   connection:Disconnect()                                                  --
+--   sig:DisconnectAll()                                                      --
+--   local arg1, arg2, ... = sig:Wait()                                       --
+--                                                                            --
+-- License:                                                                   --
+--   Licensed under the MIT license.                                          --
+--                                                                            --
+-- Authors:                                                                   --
+--   stravant - July 31st, 2021 - Created the file.                           --
+--   sleitnick - August 3rd, 2021 - Modified for Knit.                        --
+-- -----------------------------------------------------------------------------
+
+-- Signal types
+export type Connection = {
+	Disconnect: (self: Connection) -> (),
+	Destroy: (self: Connection) -> (),
+	Connected: boolean,
+}
+
+export type Signal<T...> = {
+	Fire: (self: Signal<T...>, T...) -> (),
+	FireDeferred: (self: Signal<T...>, T...) -> (),
+	Connect: (self: Signal<T...>, fn: (T...) -> ()) -> Connection,
+	Once: (self: Signal<T...>, fn: (T...) -> ()) -> Connection,
+	DisconnectAll: (self: Signal<T...>) -> (),
+	GetConnections: (self: Signal<T...>) -> { Connection },
+	Destroy: (self: Signal<T...>) -> (),
+	Wait: (self: Signal<T...>) -> T...,
+}
+
+-- The currently idle thread to run the next handler on
+local freeRunnerThread = nil
+
+-- Function which acquires the currently idle handler runner thread, runs the
+-- function fn on it, and then releases the thread, returning it to being the
+-- currently idle one.
+-- If there was a currently idle runner thread already, that's okay, that old
+-- one will just get thrown and eventually GCed.
+local function acquireRunnerThreadAndCallEventHandler(fn, ...)
+	local acquiredRunnerThread = freeRunnerThread
+	freeRunnerThread = nil
+	fn(...)
+	-- The handler finished running, this runner thread is free again.
+	freeRunnerThread = acquiredRunnerThread
+end
+
+-- Coroutine runner that we create coroutines of. The coroutine can be
+-- repeatedly resumed with functions to run followed by the argument to run
+-- them with.
+local function runEventHandlerInFreeThread(...)
+	acquireRunnerThreadAndCallEventHandler(...)
+	while true do
+		acquireRunnerThreadAndCallEventHandler(coroutine.yield())
+	end
+end
+
+--[[
+	@within Signal
+	@interface SignalConnection
+	.Connected boolean
+	.Disconnect (SignalConnection) -> ()
+	Represents a connection to a signal.
+	```lua
+	local connection = signal:Connect(function() end)
+	print(connection.Connected) --> true
+	connection:Disconnect()
+	print(connection.Connected) --> false
+	```
+]]
+
+-- Connection class
+local Connection = {}
+Connection.__index = Connection
+
+function Connection.new(signal, fn)
+	return setmetatable({
+		Connected = true,
+		_signal = signal,
+		_fn = fn,
+		_next = false,
+	}, Connection)
+end
+
+function Connection:Disconnect()
+	if not self.Connected then
+		return
+	end
+	self.Connected = false
+
+	-- Unhook the node, but DON'T clear it. That way any fire calls that are
+	-- currently sitting on this node will be able to iterate forwards off of
+	-- it, but any subsequent fire calls will not hit it, and it will be GCed
+	-- when no more fire calls are sitting on it.
+	if self._signal._handlerListHead == self then
+		self._signal._handlerListHead = self._next
+	else
+		local prev = self._signal._handlerListHead
+		while prev and prev._next ~= self do
+			prev = prev._next
+		end
+		if prev then
+			prev._next = self._next
+		end
+	end
+end
+
+Connection.Destroy = Connection.Disconnect
+
+-- Make Connection strict
+setmetatable(Connection, {
+	__index = function(_tb, key)
+		error(("Attempt to get Connection::%s (not a valid member)"):format(tostring(key)), 2)
+	end,
+	__newindex = function(_tb, key, _value)
+		error(("Attempt to set Connection::%s (not a valid member)"):format(tostring(key)), 2)
+	end,
+})
+
+--[[
+	@within Signal
+	@type ConnectionFn (...any) -> ()
+	A function connected to a signal.
+]]
+
+--[[
+	@class Signal
+	Signals allow events to be dispatched and handled.
+	For example:
+	```lua
+	local signal = Signal.new()
+	signal:Connect(function(msg)
+		print("Got message:", msg)
+	end)
+	signal:Fire("Hello world!")
+	```
+]]
+local Signal = {}
+Signal.__index = Signal
+
+--[[
+	Constructs a new Signal
+	@return Signal
+]]
+function Signal.new<T...>(): Signal<T...>
+	local self = setmetatable({
+		_handlerListHead = false,
+		_proxyHandler = nil,
+	}, Signal)
+	return self
+end
+
+--[[
+	Constructs a new Signal that wraps around an RBXScriptSignal.
+	@param rbxScriptSignal RBXScriptSignal -- Existing RBXScriptSignal to wrap
+	@return Signal
+	For example:
+	```lua
+	local signal = Signal.Wrap(workspace.ChildAdded)
+	signal:Connect(function(part) print(part.Name .. " added") end)
+	Instance.new("Part").Parent = workspace
+	```
+]]
+function Signal.Wrap<T...>(rbxScriptSignal: RBXScriptSignal): Signal<T...>
+	assert(
+		typeof(rbxScriptSignal) == "RBXScriptSignal",
+		"Argument #1 to Signal.Wrap must be a RBXScriptSignal; got " .. typeof(rbxScriptSignal)
+	)
+	local signal = Signal.new()
+	signal._proxyHandler = rbxScriptSignal:Connect(function(...)
+		signal:Fire(...)
+	end)
+	return signal
+end
+
+--[[
+	Checks if the given object is a Signal.
+	@param obj any -- Object to check
+	@return boolean -- `true` if the object is a Signal.
+]]
+function Signal.Is(obj: any): boolean
+	return type(obj) == "table" and getmetatable(obj) == Signal
+end
+
+--[[
+	@param fn ConnectionFn
+	@return SignalConnection
+	Connects a function to the signal, which will be called anytime the signal is fired.
+	```lua
+	signal:Connect(function(msg, num)
+		print(msg, num)
+	end)
+	signal:Fire("Hello", 25)
+	```
+]]
+function Signal:Connect(fn)
+	local connection = Connection.new(self, fn)
+	if self._handlerListHead then
+		connection._next = self._handlerListHead
+		self._handlerListHead = connection
+	else
+		self._handlerListHead = connection
+	end
+	return connection
+end
+
+--[[
+	@deprecated v1.3.0 -- Use `Signal:Once` instead.
+	@param fn ConnectionFn
+	@return SignalConnection
+]]
+function Signal:ConnectOnce(fn)
+	return self:Once(fn)
+end
+
+--[[
+	@param fn ConnectionFn
+	@return SignalConnection
+	Connects a function to the signal, which will be called the next time the signal fires. Once
+	the connection is triggered, it will disconnect itself.
+	```lua
+	signal:Once(function(msg, num)
+		print(msg, num)
+	end)
+	signal:Fire("Hello", 25)
+	signal:Fire("This message will not go through", 10)
+	```
+]]
+function Signal:Once(fn)
+	local connection
+	local done = false
+	connection = self:Connect(function(...)
+		if done then
+			return
+		end
+		done = true
+		connection:Disconnect()
+		fn(...)
+	end)
+	return connection
+end
+
+function Signal:GetConnections()
+	local items = {}
+	local item = self._handlerListHead
+	while item do
+		table.insert(items, item)
+		item = item._next
+	end
+	return items
+end
+
+-- Disconnect all handlers. Since we use a linked list it suffices to clear the
+-- reference to the head handler.
+--[[
+	Disconnects all connections from the signal.
+	```lua
+	signal:DisconnectAll()
+	```
+]]
+function Signal:DisconnectAll()
+	local item = self._handlerListHead
+	while item do
+		item.Connected = false
+		item = item._next
+	end
+	self._handlerListHead = false
+end
+
+-- Signal:Fire(...) implemented by running the handler functions on the
+-- coRunnerThread, and any time the resulting thread yielded without returning
+-- to us, that means that it yielded to the Roblox scheduler and has been taken
+-- over by Roblox scheduling, meaning we have to make a new coroutine runner.
+--[[
+	@param ... any
+	Fire the signal, which will call all of the connected functions with the given arguments.
+	```lua
+	signal:Fire("Hello")
+	-- Any number of arguments can be fired:
+	signal:Fire("Hello", 32, {Test = "Test"}, true)
+	```
+]]
+function Signal:Fire(...)
+	local item = self._handlerListHead
+	while item do
+		if item.Connected then
+			if not freeRunnerThread then
+				freeRunnerThread = coroutine.create(runEventHandlerInFreeThread)
+			end
+			task.spawn(freeRunnerThread, item._fn, ...)
+		end
+		item = item._next
+	end
+end
+
+--[[
+	@param ... any
+	Same as `Fire`, but uses `task.defer` internally & doesn't take advantage of thread reuse.
+	```lua
+	signal:FireDeferred("Hello")
+	```
+]]
+function Signal:FireDeferred(...)
+	local item = self._handlerListHead
+	while item do
+		task.defer(item._fn, ...)
+		item = item._next
+	end
+end
+
+--[[
+	@return ... any
+	@yields
+	Yields the current thread until the signal is fired, and returns the arguments fired from the signal.
+	Yielding the current thread is not always desirable. If the desire is to only capture the next event
+	fired, using `Once` might be a better solution.
+	```lua
+	task.spawn(function()
+		local msg, num = signal:Wait()
+		print(msg, num) --> "Hello", 32
+	end)
+	signal:Fire("Hello", 32)
+	```
+]]
+function Signal:Wait()
+	local waitingCoroutine = coroutine.running()
+	local connection
+	local done = false
+	connection = self:Connect(function(...)
+		if done then
+			return
+		end
+		done = true
+		connection:Disconnect()
+		task.spawn(waitingCoroutine, ...)
+	end)
+	return coroutine.yield()
+end
+
+--[[
+	Cleans up the signal.
+	Technically, this is only necessary if the signal is created using
+	`Signal.Wrap`. Connections should be properly GC'd once the signal
+	is no longer referenced anywhere. However, it is still good practice
+	to include ways to strictly clean up resources. Calling `Destroy`
+	on a signal will also disconnect all connections immediately.
+	```lua
+	signal:Destroy()
+	```
+]]
+function Signal:Destroy()
+	self:DisconnectAll()
+	local proxyHandler = rawget(self, "_proxyHandler")
+	if proxyHandler then
+		proxyHandler:Disconnect()
+	end
+end
+
+-- Make signal strict
+setmetatable(Signal, {
+	__index = function(_tb, key)
+		error(("Attempt to get Signal::%s (not a valid member)"):format(tostring(key)), 2)
+	end,
+	__newindex = function(_tb, key, _value)
+		error(("Attempt to set Signal::%s (not a valid member)"):format(tostring(key)), 2)
+	end,
+})
+
+return {
+	new = Signal.new,
+	Wrap = Signal.Wrap,
+	Is = Signal.Is,
+}

package/runtime/StateMachine/_impl/Vendor/Trove.lua

@@ -0,0 +1,188 @@
+-- Trove
+-- Stephen Leitnick
+-- October 16, 2021
+
+local FN_MARKER = newproxy()
+local THREAD_MARKER = newproxy()
+
+local RunService = game:GetService("RunService")
+
+local function GetObjectCleanupFunction(object, cleanupMethod)
+	local t = typeof(object)
+	if t == "function" then
+		return FN_MARKER
+	elseif t == "thread" then
+		return THREAD_MARKER
+	end
+	if cleanupMethod then
+		return cleanupMethod
+	end
+	if t == "Instance" then
+		return "Destroy"
+	elseif t == "RBXScriptConnection" then
+		return "Disconnect"
+	elseif t == "table" then
+		if typeof(object.Destroy) == "function" then
+			return "Destroy"
+		elseif typeof(object.Disconnect) == "function" then
+			return "Disconnect"
+		end
+	end
+	error("Failed to get cleanup function for object " .. t .. ": " .. tostring(object), 3)
+end
+
+local function AssertPromiseLike(object)
+	if
+		typeof(object) ~= "table"
+		or typeof(object.getStatus) ~= "function"
+		or typeof(object.finally) ~= "function"
+		or typeof(object.cancel) ~= "function"
+	then
+		error("Did not receive a Promise as an argument", 3)
+	end
+end
+
+local Trove = {}
+Trove.__index = Trove
+
+function Trove.new()
+	local self = setmetatable({}, Trove)
+	self._objects = {}
+	self._cleaning = false
+	return self
+end
+
+function Trove:Extend()
+	if self._cleaning then
+		error("Cannot call trove:Extend() while cleaning", 2)
+	end
+	return self:Construct(Trove)
+end
+
+function Trove:Clone(instance: Instance): Instance
+	if self._cleaning then
+		error("Cannot call trove:Clone() while cleaning", 2)
+	end
+	return self:Add(instance:Clone())
+end
+
+function Trove:Construct(class, ...)
+	if self._cleaning then
+		error("Cannot call trove:Construct() while cleaning", 2)
+	end
+	local object = nil
+	local t = type(class)
+	if t == "table" then
+		object = class.new(...)
+	elseif t == "function" then
+		object = class(...)
+	end
+	return self:Add(object)
+end
+
+function Trove:Connect(signal, fn)
+	if self._cleaning then
+		error("Cannot call trove:Connect() while cleaning", 2)
+	end
+	return self:Add(signal:Connect(fn))
+end
+
+function Trove:BindToRenderStep(name: string, priority: number, fn: (dt: number) -> ())
+	if self._cleaning then
+		error("Cannot call trove:BindToRenderStep() while cleaning", 2)
+	end
+	RunService:BindToRenderStep(name, priority, fn)
+	self:Add(function()
+		RunService:UnbindFromRenderStep(name)
+	end)
+end
+
+function Trove:AddPromise(promise)
+	if self._cleaning then
+		error("Cannot call trove:AddPromise() while cleaning", 2)
+	end
+	AssertPromiseLike(promise)
+	if promise:getStatus() == "Started" then
+		promise:finally(function()
+			if self._cleaning then
+				return
+			end
+			self:_findAndRemoveFromObjects(promise, false)
+		end)
+		self:Add(promise, "cancel")
+	end
+	return promise
+end
+
+function Trove:Add(object: any, cleanupMethod: string?): any
+	if self._cleaning then
+		error("Cannot call trove:Add() while cleaning", 2)
+	end
+	local cleanup = GetObjectCleanupFunction(object, cleanupMethod)
+	table.insert(self._objects, { object, cleanup })
+	return object
+end
+
+function Trove:Remove(object: any): boolean
+	if self._cleaning then
+		error("Cannot call trove:Remove() while cleaning", 2)
+	end
+	return self:_findAndRemoveFromObjects(object, true)
+end
+
+function Trove:Clean()
+	if self._cleaning then
+		return
+	end
+	self._cleaning = true
+	for _, obj in self._objects do
+		self:_cleanupObject(obj[1], obj[2])
+	end
+	table.clear(self._objects)
+	self._cleaning = false
+end
+
+function Trove:_findAndRemoveFromObjects(object: any, cleanup: boolean): boolean
+	local objects = self._objects
+	for i, obj in ipairs(objects) do
+		if obj[1] == object then
+			local n = #objects
+			objects[i] = objects[n]
+			objects[n] = nil
+			if cleanup then
+				self:_cleanupObject(obj[1], obj[2])
+			end
+			return true
+		end
+	end
+	return false
+end
+
+function Trove:_cleanupObject(object, cleanupMethod)
+	if cleanupMethod == FN_MARKER then
+		object()
+	elseif cleanupMethod == THREAD_MARKER then
+		pcall(task.cancel, object)
+	else
+		object[cleanupMethod](object)
+	end
+end
+
+function Trove:AttachToInstance(instance: Instance)
+	if self._cleaning then
+		error("Cannot call trove:AttachToInstance() while cleaning", 2)
+	elseif not instance:IsDescendantOf(game) then
+		error("Instance is not a descendant of the game hierarchy", 2)
+	end
+	return self:Connect(instance.Destroying, function()
+		self:Destroy()
+	end)
+end
+
+function Trove:Destroy()
+	self:Clean()
+end
+
+export type Trove = typeof(Trove.new(...))
+
+return Trove