roblox-opencode 1.0.0 → 1.0.1

package/vendor/fusion/Memory/whichLivesLonger.luau

@@ -1,75 +1,75 @@
---!strict
---!nolint LocalUnused
---!nolint LocalShadow
-local task = nil -- Disable usage of Roblox's task scheduler
-
---[[
-	Calculates how the lifetimes of the two values relate. Specifically, it
-	calculates which value will be destroyed earlier or later, if it is possible
-	to infer this from their scopes.
-]]
-local Package = script.Parent.Parent
-local Types = require(Package.Types)
-local External = require(Package.External)
-
-local function whichScopeLivesLonger(
-	scopeA: Types.Scope<unknown>,
-	scopeB: Types.Scope<unknown>
-): "definitely-a" | "definitely-b" | "unsure"
-	-- If we can prove one scope is inside of the other scope, then the outer
-	-- scope must live longer than the inner scope (assuming idiomatic scopes).
-	-- So, we will search the scopes recursively until we find one of them, at
-	-- which point we know they must have been found inside the other scope.
-	local openSet: {Types.Scope<unknown>} = {scopeA, scopeB}
-	local nextOpenSet: {Types.Scope<unknown>} = {}
-	local openSetSize, nextOpenSetSize = 2, 0
-	local closedSet = {}
-	while openSetSize > 0 do
-		for _, scope in openSet do
-			closedSet[scope] = true
-			for _, inScope in ipairs(scope) do
-				if inScope == scopeA then
-					return "definitely-b"
-				elseif inScope == scopeB then
-					return "definitely-a"
-				elseif typeof(inScope) == "table" then
-					local inScope = inScope :: {unknown}
-					if inScope[1] ~= nil and closedSet[scope] == nil then
-						nextOpenSetSize += 1
-						nextOpenSet[nextOpenSetSize] = inScope :: Types.Scope<unknown>
-					end
-				end 
-			end
-		end
-		table.clear(openSet)
-		openSet, nextOpenSet = nextOpenSet, openSet
-		openSetSize, nextOpenSetSize = nextOpenSetSize, 0
-	end
-	return "unsure"
-end
-
-local function whichLivesLonger(
-	scopeA: Types.Scope<unknown>,
-	a: unknown,
-	scopeB: Types.Scope<unknown>,
-	b: unknown
-): "definitely-a" | "definitely-b" | "unsure"
-	if External.isTimeCritical() then
-		return "unsure"
-	elseif scopeA == scopeB then
-		local scopeA: {unknown} = scopeA
-		for index = #scopeA, 1, -1 do
-			local value = scopeA[index]
-			if value == a then
-				return "definitely-b"
-			elseif value == b then
-				return "definitely-a"
-			end
-		end
-		return "unsure"
-	else
-		return whichScopeLivesLonger(scopeA, scopeB)
-	end
-end
-
+--!strict
+--!nolint LocalUnused
+--!nolint LocalShadow
+local task = nil -- Disable usage of Roblox's task scheduler
+
+--[[
+	Calculates how the lifetimes of the two values relate. Specifically, it
+	calculates which value will be destroyed earlier or later, if it is possible
+	to infer this from their scopes.
+]]
+local Package = script.Parent.Parent
+local Types = require(Package.Types)
+local External = require(Package.External)
+
+local function whichScopeLivesLonger(
+	scopeA: Types.Scope<unknown>,
+	scopeB: Types.Scope<unknown>
+): "definitely-a" | "definitely-b" | "unsure"
+	-- If we can prove one scope is inside of the other scope, then the outer
+	-- scope must live longer than the inner scope (assuming idiomatic scopes).
+	-- So, we will search the scopes recursively until we find one of them, at
+	-- which point we know they must have been found inside the other scope.
+	local openSet: {Types.Scope<unknown>} = {scopeA, scopeB}
+	local nextOpenSet: {Types.Scope<unknown>} = {}
+	local openSetSize, nextOpenSetSize = 2, 0
+	local closedSet = {}
+	while openSetSize > 0 do
+		for _, scope in openSet do
+			closedSet[scope] = true
+			for _, inScope in ipairs(scope) do
+				if inScope == scopeA then
+					return "definitely-b"
+				elseif inScope == scopeB then
+					return "definitely-a"
+				elseif typeof(inScope) == "table" then
+					local inScope = inScope :: {unknown}
+					if inScope[1] ~= nil and closedSet[scope] == nil then
+						nextOpenSetSize += 1
+						nextOpenSet[nextOpenSetSize] = inScope :: Types.Scope<unknown>
+					end
+				end 
+			end
+		end
+		table.clear(openSet)
+		openSet, nextOpenSet = nextOpenSet, openSet
+		openSetSize, nextOpenSetSize = nextOpenSetSize, 0
+	end
+	return "unsure"
+end
+
+local function whichLivesLonger(
+	scopeA: Types.Scope<unknown>,
+	a: unknown,
+	scopeB: Types.Scope<unknown>,
+	b: unknown
+): "definitely-a" | "definitely-b" | "unsure"
+	if External.isTimeCritical() then
+		return "unsure"
+	elseif scopeA == scopeB then
+		local scopeA: {unknown} = scopeA
+		for index = #scopeA, 1, -1 do
+			local value = scopeA[index]
+			if value == a then
+				return "definitely-b"
+			elseif value == b then
+				return "definitely-a"
+			end
+		end
+		return "unsure"
+	else
+		return whichScopeLivesLonger(scopeA, scopeB)
+	end
+end
+
 return whichLivesLonger

package/vendor/fusion/RobloxExternal.luau

@@ -1,98 +1,98 @@
---!strict
---!nolint LocalUnused
---!nolint LocalShadow
-
---[[
-	Roblox implementation for Fusion's abstract provider layer.
-]]
-
-local RunService = game:GetService("RunService")
-local HttpService = game:GetService("HttpService")
-
-local Package = script.Parent
-local External = require(Package.External)
-
-local RobloxExternal = {}
-
-RobloxExternal.policies = {
-	allowWebLinks = RunService:IsStudio()
-}
-
---[[
-   Sends an immediate task to the external provider. Throws if none is set.
-]]
-function RobloxExternal.doTaskImmediate(
-	resume: () -> ()
-)
-   task.spawn(resume)
-end
-
---[[
-	Sends a deferred task to the external provider. Throws if none is set.
-]]
-function RobloxExternal.doTaskDeferred(
-	resume: () -> ()
-)
-	task.defer(resume)
-end
-
---[[
-	Errors in a different thread to preserve the flow of execution.
-]]
-function RobloxExternal.logErrorNonFatal(
-	errorString: string
-)
-	task.spawn(error, errorString, 0)
-end
-
---[[
-	Shows a warning message in the output.
-]]
-RobloxExternal.logWarn = warn
-
---[[
-	Sends an update step to Fusion using the Roblox clock time.
-]]
-local function performUpdateStep()
-	External.performUpdateStep(os.clock())
-end
-
---[[
-	Binds Fusion's update step to RunService step events.
-]]
-local stopSchedulerFunc = nil :: (() -> ())?
-function RobloxExternal.startScheduler()
-	if stopSchedulerFunc ~= nil then
-		return
-	end
-	if RunService:IsClient() then
-		-- In cases where multiple Fusion modules are running simultaneously,
-		-- this prevents collisions.
-		local id = "FusionUpdateStep_" .. HttpService:GenerateGUID()
-		RunService:BindToRenderStep(
-			id,
-			Enum.RenderPriority.First.Value,
-			performUpdateStep
-		)
-		stopSchedulerFunc = function()
-			RunService:UnbindFromRenderStep(id)
-		end
-	else
-		local connection = RunService.Heartbeat:Connect(performUpdateStep)
-		stopSchedulerFunc = function()
-			connection:Disconnect()
-		end
-	end
-end
-
---[[
-	Unbinds Fusion's update step from RunService step events.
-]]
-function RobloxExternal.stopScheduler()
-	if stopSchedulerFunc ~= nil then
-		stopSchedulerFunc()
-		stopSchedulerFunc = nil
-	end
-end
-
+--!strict
+--!nolint LocalUnused
+--!nolint LocalShadow
+
+--[[
+	Roblox implementation for Fusion's abstract provider layer.
+]]
+
+local RunService = game:GetService("RunService")
+local HttpService = game:GetService("HttpService")
+
+local Package = script.Parent
+local External = require(Package.External)
+
+local RobloxExternal = {}
+
+RobloxExternal.policies = {
+	allowWebLinks = RunService:IsStudio()
+}
+
+--[[
+   Sends an immediate task to the external provider. Throws if none is set.
+]]
+function RobloxExternal.doTaskImmediate(
+	resume: () -> ()
+)
+   task.spawn(resume)
+end
+
+--[[
+	Sends a deferred task to the external provider. Throws if none is set.
+]]
+function RobloxExternal.doTaskDeferred(
+	resume: () -> ()
+)
+	task.defer(resume)
+end
+
+--[[
+	Errors in a different thread to preserve the flow of execution.
+]]
+function RobloxExternal.logErrorNonFatal(
+	errorString: string
+)
+	task.spawn(error, errorString, 0)
+end
+
+--[[
+	Shows a warning message in the output.
+]]
+RobloxExternal.logWarn = warn
+
+--[[
+	Sends an update step to Fusion using the Roblox clock time.
+]]
+local function performUpdateStep()
+	External.performUpdateStep(os.clock())
+end
+
+--[[
+	Binds Fusion's update step to RunService step events.
+]]
+local stopSchedulerFunc = nil :: (() -> ())?
+function RobloxExternal.startScheduler()
+	if stopSchedulerFunc ~= nil then
+		return
+	end
+	if RunService:IsClient() then
+		-- In cases where multiple Fusion modules are running simultaneously,
+		-- this prevents collisions.
+		local id = "FusionUpdateStep_" .. HttpService:GenerateGUID()
+		RunService:BindToRenderStep(
+			id,
+			Enum.RenderPriority.First.Value,
+			performUpdateStep
+		)
+		stopSchedulerFunc = function()
+			RunService:UnbindFromRenderStep(id)
+		end
+	else
+		local connection = RunService.Heartbeat:Connect(performUpdateStep)
+		stopSchedulerFunc = function()
+			connection:Disconnect()
+		end
+	end
+end
+
+--[[
+	Unbinds Fusion's update step from RunService step events.
+]]
+function RobloxExternal.stopScheduler()
+	if stopSchedulerFunc ~= nil then
+		stopSchedulerFunc()
+		stopSchedulerFunc = nil
+	end
+end
+
 return RobloxExternal

package/vendor/fusion/State/Computed.luau

@@ -1,139 +1,139 @@
---!strict
---!nolint LocalUnused
---!nolint LocalShadow
-local task = nil -- Disable usage of Roblox's task scheduler
-
---[[
-	A specialised state object for tracking single values computed from a
-	user-defined computation.
-
-	https://elttob.uk/Fusion/0.3/api-reference/state/types/computed/
-]]
-
-local Package = script.Parent.Parent
-local Types = require(Package.Types)
-local External = require(Package.External)
--- Logging
-local parseError = require(Package.Logging.parseError)
--- Utility
-local isSimilar = require(Package.Utility.isSimilar)
-local never = require(Package.Utility.never)
--- Graph
-local depend = require(Package.Graph.depend)
--- State
-local castToState = require(Package.State.castToState)
-local peek = require(Package.State.peek)
--- Memory
-local doCleanup = require(Package.Memory.doCleanup)
-local deriveScope = require(Package.Memory.deriveScope)
-local checkLifetime = require(Package.Memory.checkLifetime)
-local scopePool = require(Package.Memory.scopePool)
--- Utility
-local nicknames = require(Package.Utility.nicknames)
-
-type Self<T, S> = Types.Computed<T> & {
-	_innerScope: Types.Scope<S>?,
-	_processor: (Types.Use, Types.Scope<S>) -> T
-}
-
-local class = {}
-class.type = "State"
-class.kind = "Computed"
-class.timeliness = "lazy"
-
-local METATABLE = table.freeze {__index = class}
-
-local function Computed<T, S>(
-	scope: S & Types.Scope<unknown>,
-	processor: (Types.Use, S) -> T,
-	destructor: unknown?
-): Types.Computed<T>
-	local createdAt = os.clock()
-	if typeof(scope) == "function" then
-		External.logError("scopeMissing", nil, "Computeds", "myScope:Computed(function(use, scope) ... end)")
-	elseif destructor ~= nil then
-		External.logWarn("destructorRedundant", "Computed")
-	end
-	local self: Self<T, S> = setmetatable(
-		{
-			createdAt = createdAt,
-			dependencySet = {},
-			dependentSet = {},
-			lastChange = nil,
-			scope = scope,
-			validity = "invalid",
-			_EXTREMELY_DANGEROUS_usedAsValue = nil,
-			_innerScope = nil,
-			_processor = processor
-		}, 
-		METATABLE
-	) :: any
-	local destroy = function()
-		self.scope = nil
-		for dependency in pairs(self.dependencySet) do
-			dependency.dependentSet[self] = nil
-		end
-		if self._innerScope ~= nil then
-			doCleanup(self._innerScope)
-		end
-	end
-	self.oldestTask = destroy
-	nicknames[self.oldestTask] = "Computed"
-	table.insert(scope, destroy)
-	return self
-end
-
-function class.get<T, S>(
-	_self: Self<T, S>
-): never
-	External.logError("stateGetWasRemoved")
-	return never()
-end
-
-function class._evaluate<T, S>(
-	self: Self<T, S>
-): boolean
-	if self.scope == nil then
-		return false
-	end
-	local outerScope = self.scope :: S & Types.Scope<unknown>
-	local innerScope = deriveScope(outerScope)
-	local function use<T>(target: Types.UsedAs<T>): T
-		local targetState = castToState(target)
-		if targetState ~= nil then
-			checkLifetime.bOutlivesA(
-				outerScope, self.oldestTask, 
-				targetState.scope, targetState.oldestTask, 
-				checkLifetime.formatters.useFunction
-			)
-			depend(self, targetState)
-		end
-		return peek(target)
-	end
-	local ok, newValue = xpcall(self._processor, parseError, use, innerScope)
-	local innerScope = scopePool.giveIfEmpty(innerScope)
-	if ok then
-		local similar = isSimilar(self._EXTREMELY_DANGEROUS_usedAsValue, newValue)
-		if self._innerScope ~= nil then
-			doCleanup(self._innerScope)
-		end
-		self._innerScope = innerScope
-
-		self._EXTREMELY_DANGEROUS_usedAsValue = newValue
-		return not similar
-	else
-		local errorObj = (newValue :: any) :: Types.Error
-		if innerScope ~= nil then
-			doCleanup(innerScope)
-		end
-		innerScope = nil
-		
-		-- this needs to be non-fatal, because otherwise it'd disrupt the
-		-- update process
-		External.logErrorNonFatal("callbackError", errorObj)
-		return false
-	end
-end
-
-table.freeze(class)
+--!strict
+--!nolint LocalUnused
+--!nolint LocalShadow
+local task = nil -- Disable usage of Roblox's task scheduler
+
+--[[
+	A specialised state object for tracking single values computed from a
+	user-defined computation.
+
+	https://elttob.uk/Fusion/0.3/api-reference/state/types/computed/
+]]
+
+local Package = script.Parent.Parent
+local Types = require(Package.Types)
+local External = require(Package.External)
+-- Logging
+local parseError = require(Package.Logging.parseError)
+-- Utility
+local isSimilar = require(Package.Utility.isSimilar)
+local never = require(Package.Utility.never)
+-- Graph
+local depend = require(Package.Graph.depend)
+-- State
+local castToState = require(Package.State.castToState)
+local peek = require(Package.State.peek)
+-- Memory
+local doCleanup = require(Package.Memory.doCleanup)
+local deriveScope = require(Package.Memory.deriveScope)
+local checkLifetime = require(Package.Memory.checkLifetime)
+local scopePool = require(Package.Memory.scopePool)
+-- Utility
+local nicknames = require(Package.Utility.nicknames)
+
+type Self<T, S> = Types.Computed<T> & {
+	_innerScope: Types.Scope<S>?,
+	_processor: (Types.Use, Types.Scope<S>) -> T
+}
+
+local class = {}
+class.type = "State"
+class.kind = "Computed"
+class.timeliness = "lazy"
+
+local METATABLE = table.freeze {__index = class}
+
+local function Computed<T, S>(
+	scope: S & Types.Scope<unknown>,
+	processor: (Types.Use, S) -> T,
+	destructor: unknown?
+): Types.Computed<T>
+	local createdAt = os.clock()
+	if typeof(scope) == "function" then
+		External.logError("scopeMissing", nil, "Computeds", "myScope:Computed(function(use, scope) ... end)")
+	elseif destructor ~= nil then
+		External.logWarn("destructorRedundant", "Computed")
+	end
+	local self: Self<T, S> = setmetatable(
+		{
+			createdAt = createdAt,
+			dependencySet = {},
+			dependentSet = {},
+			lastChange = nil,
+			scope = scope,
+			validity = "invalid",
+			_EXTREMELY_DANGEROUS_usedAsValue = nil,
+			_innerScope = nil,
+			_processor = processor
+		}, 
+		METATABLE
+	) :: any
+	local destroy = function()
+		self.scope = nil
+		for dependency in pairs(self.dependencySet) do
+			dependency.dependentSet[self] = nil
+		end
+		if self._innerScope ~= nil then
+			doCleanup(self._innerScope)
+		end
+	end
+	self.oldestTask = destroy
+	nicknames[self.oldestTask] = "Computed"
+	table.insert(scope, destroy)
+	return self
+end
+
+function class.get<T, S>(
+	_self: Self<T, S>
+): never
+	External.logError("stateGetWasRemoved")
+	return never()
+end
+
+function class._evaluate<T, S>(
+	self: Self<T, S>
+): boolean
+	if self.scope == nil then
+		return false
+	end
+	local outerScope = self.scope :: S & Types.Scope<unknown>
+	local innerScope = deriveScope(outerScope)
+	local function use<T>(target: Types.UsedAs<T>): T
+		local targetState = castToState(target)
+		if targetState ~= nil then
+			checkLifetime.bOutlivesA(
+				outerScope, self.oldestTask, 
+				targetState.scope, targetState.oldestTask, 
+				checkLifetime.formatters.useFunction
+			)
+			depend(self, targetState)
+		end
+		return peek(target)
+	end
+	local ok, newValue = xpcall(self._processor, parseError, use, innerScope)
+	local innerScope = scopePool.giveIfEmpty(innerScope)
+	if ok then
+		local similar = isSimilar(self._EXTREMELY_DANGEROUS_usedAsValue, newValue)
+		if self._innerScope ~= nil then
+			doCleanup(self._innerScope)
+		end
+		self._innerScope = innerScope
+
+		self._EXTREMELY_DANGEROUS_usedAsValue = newValue
+		return not similar
+	else
+		local errorObj = (newValue :: any) :: Types.Error
+		if innerScope ~= nil then
+			doCleanup(innerScope)
+		end
+		innerScope = nil
+		
+		-- this needs to be non-fatal, because otherwise it'd disrupt the
+		-- update process
+		External.logErrorNonFatal("callbackError", errorObj)
+		return false
+	end
+end
+
+table.freeze(class)
 return Computed :: Types.ComputedConstructor