cluaupp 1.0.0 → 1.4.0

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

@@ -1,22 +0,0 @@
---[[
-    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

@@ -1,19 +0,0 @@
-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

@@ -1,386 +0,0 @@
--- -----------------------------------------------------------------------------
---               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

@@ -1,188 +0,0 @@
--- 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