roblox-opencode 1.0.0 → 1.0.1

package/vendor/fusion/Animation/Stopwatch.luau

@@ -1,128 +1,128 @@
---!strict
---!nolint LocalUnused
---!nolint LocalShadow
-local task = nil -- Disable usage of Roblox's task scheduler
-
---[[
-	State object for measuring time since an event using a reference timer.
-
-	TODO: this should not be exposed to users until it has a proper reactive API
-	surface
-]]
-
-local Package = script.Parent.Parent
-local Types = require(Package.Types)
--- Memory
-local checkLifetime = require(Package.Memory.checkLifetime)
--- Graph
-local depend = require(Package.Graph.depend)
-local change = require(Package.Graph.change)
--- State
-local peek = require(Package.State.peek)
--- Utility
-local nicknames = require(Package.Utility.nicknames)
-
-export type Stopwatch = Types.StateObject<number> & {
-	zero: (Stopwatch) -> (),
-	pause: (Stopwatch) -> (),
-	unpause: (Stopwatch) -> ()
-}
-
-type Self = Stopwatch & {
-	_measureTimeSince: number,
-	_playing: boolean,
-	_timer: Types.StateObject<number>
-}
-
-local class = {}
-class.type = "State"
-class.kind = "Stopwatch"
-class.timeliness = "lazy"
-
-local METATABLE = table.freeze {__index = class}
-
-local function Stopwatch(
-	scope: Types.Scope<unknown>,
-	timer: Types.StateObject<number>
-): Stopwatch
-	local createdAt = os.clock()
-	local self: Self = setmetatable(
-		{
-			awake = true,
-			createdAt = createdAt,
-			dependencySet = {},
-			dependentSet = {},
-			lastChange = nil,
-			scope = scope,
-			validity = "invalid",
-			_EXTREMELY_DANGEROUS_usedAsValue = 0,
-			_measureTimeSince = 0, -- this should be set on unpause
-			_playing = false,
-			_timer = timer
-		}, 
-		METATABLE
-	) :: any
-	local destroy = function()
-		self.scope = nil
-	end
-	self.oldestTask = destroy
-	nicknames[self.oldestTask] = "Stopwatch"
-	table.insert(scope, destroy)
-
-	checkLifetime.bOutlivesA(
-		scope, self.oldestTask,
-		timer.scope, timer.oldestTask,
-		checkLifetime.formatters.parameter, "timer"
-	)
-	depend(self, timer)
-	return self
-end
-
-function class.zero(
-	self: Self
-): ()
-	local newTimepoint = peek(self._timer)
-	if newTimepoint ~= self._measureTimeSince then
-		self._measureTimeSince = newTimepoint
-		self._EXTREMELY_DANGEROUS_usedAsValue = 0
-		change(self)
-	end
-end
-
-function class.pause(
-	self: Self
-): ()
-	if self._playing == true then
-		self._playing = false
-		change(self)
-	end
-end
-
-function class.unpause(
-	self: Self
-): ()
-	if self._playing == false then
-		self._playing = true
-		self._measureTimeSince = peek(self._timer) - self._EXTREMELY_DANGEROUS_usedAsValue
-		change(self)
-	end
-end
-
-function class._evaluate(
-	self: Self
-): boolean
-	if self._playing then
-		depend(self, self._timer)
-		local currentTime = peek(self._timer)
-		local oldValue = self._EXTREMELY_DANGEROUS_usedAsValue
-		local newValue = currentTime - self._measureTimeSince
-		self._EXTREMELY_DANGEROUS_usedAsValue = newValue
-		return oldValue ~= newValue
-	else
-		return false
-	end
-	
-end
-
-table.freeze(class)
+--!strict
+--!nolint LocalUnused
+--!nolint LocalShadow
+local task = nil -- Disable usage of Roblox's task scheduler
+
+--[[
+	State object for measuring time since an event using a reference timer.
+
+	TODO: this should not be exposed to users until it has a proper reactive API
+	surface
+]]
+
+local Package = script.Parent.Parent
+local Types = require(Package.Types)
+-- Memory
+local checkLifetime = require(Package.Memory.checkLifetime)
+-- Graph
+local depend = require(Package.Graph.depend)
+local change = require(Package.Graph.change)
+-- State
+local peek = require(Package.State.peek)
+-- Utility
+local nicknames = require(Package.Utility.nicknames)
+
+export type Stopwatch = Types.StateObject<number> & {
+	zero: (Stopwatch) -> (),
+	pause: (Stopwatch) -> (),
+	unpause: (Stopwatch) -> ()
+}
+
+type Self = Stopwatch & {
+	_measureTimeSince: number,
+	_playing: boolean,
+	_timer: Types.StateObject<number>
+}
+
+local class = {}
+class.type = "State"
+class.kind = "Stopwatch"
+class.timeliness = "lazy"
+
+local METATABLE = table.freeze {__index = class}
+
+local function Stopwatch(
+	scope: Types.Scope<unknown>,
+	timer: Types.StateObject<number>
+): Stopwatch
+	local createdAt = os.clock()
+	local self: Self = setmetatable(
+		{
+			awake = true,
+			createdAt = createdAt,
+			dependencySet = {},
+			dependentSet = {},
+			lastChange = nil,
+			scope = scope,
+			validity = "invalid",
+			_EXTREMELY_DANGEROUS_usedAsValue = 0,
+			_measureTimeSince = 0, -- this should be set on unpause
+			_playing = false,
+			_timer = timer
+		}, 
+		METATABLE
+	) :: any
+	local destroy = function()
+		self.scope = nil
+	end
+	self.oldestTask = destroy
+	nicknames[self.oldestTask] = "Stopwatch"
+	table.insert(scope, destroy)
+
+	checkLifetime.bOutlivesA(
+		scope, self.oldestTask,
+		timer.scope, timer.oldestTask,
+		checkLifetime.formatters.parameter, "timer"
+	)
+	depend(self, timer)
+	return self
+end
+
+function class.zero(
+	self: Self
+): ()
+	local newTimepoint = peek(self._timer)
+	if newTimepoint ~= self._measureTimeSince then
+		self._measureTimeSince = newTimepoint
+		self._EXTREMELY_DANGEROUS_usedAsValue = 0
+		change(self)
+	end
+end
+
+function class.pause(
+	self: Self
+): ()
+	if self._playing == true then
+		self._playing = false
+		change(self)
+	end
+end
+
+function class.unpause(
+	self: Self
+): ()
+	if self._playing == false then
+		self._playing = true
+		self._measureTimeSince = peek(self._timer) - self._EXTREMELY_DANGEROUS_usedAsValue
+		change(self)
+	end
+end
+
+function class._evaluate(
+	self: Self
+): boolean
+	if self._playing then
+		depend(self, self._timer)
+		local currentTime = peek(self._timer)
+		local oldValue = self._EXTREMELY_DANGEROUS_usedAsValue
+		local newValue = currentTime - self._measureTimeSince
+		self._EXTREMELY_DANGEROUS_usedAsValue = newValue
+		return oldValue ~= newValue
+	else
+		return false
+	end
+	
+end
+
+table.freeze(class)
 return Stopwatch

package/vendor/fusion/Animation/Tween.luau

@@ -1,187 +1,187 @@
---!strict
---!nolint LocalUnused
---!nolint LocalShadow
-local task = nil -- Disable usage of Roblox's task scheduler
-
---[[
-	A specialised state object for following a goal state smoothly over time,
-	using a TweenInfo to shape the motion.
-
-	https://elttob.uk/Fusion/0.3/api-reference/animation/types/tween/
-]]
-
-local Package = script.Parent.Parent
-local Types = require(Package.Types)
-local External = require(Package.External)
--- Memory
-local checkLifetime = require(Package.Memory.checkLifetime)
--- Graph
-local depend = require(Package.Graph.depend)
-local evaluate = require(Package.Graph.evaluate)
--- State
-local castToState = require(Package.State.castToState)
-local peek = require(Package.State.peek)
--- Animation
-local ExternalTime = require(Package.Animation.ExternalTime)
-local Stopwatch = require(Package.Animation.Stopwatch)
-local lerpType = require(Package.Animation.lerpType)
-local getTweenRatio = require(Package.Animation.getTweenRatio)
-local getTweenDuration = require(Package.Animation.getTweenDuration)
--- Utility
-local nicknames = require(Package.Utility.nicknames)
-
-export type Self<T> = Types.Tween<T> & {
-	_activeDuration: number,
-	_activeElapsed: number,
-	_activeFrom: T,
-	_activeTo: T,
-	_activeTweenInfo: TweenInfo,
-	_goal: Types.UsedAs<T>,
-	_stopwatch: Stopwatch.Stopwatch?,
-	_tweenInfo: Types.UsedAs<TweenInfo>,
-}
-
-local class = {}
-class.type = "State"
-class.kind = "Tween"
-class.timeliness = "eager"
-
-local METATABLE = table.freeze {__index = class}
-
-local function Tween<T>(
-	scope: Types.Scope<unknown>,
-	goal: Types.UsedAs<T>,
-	tweenInfo: Types.UsedAs<TweenInfo>?
-): Types.Tween<T>
-	local createdAt = os.clock()
-	if castToState(scope) then
-		External.logError("scopeMissing", nil, "Tweens", "myScope:Tween(goalState, tweenInfo)")
-	end
-
-	local goalState = castToState(goal)
-	local stopwatch = nil
-	if goalState ~= nil then
-		stopwatch = Stopwatch(scope, ExternalTime(scope))
-	end
-
-	local self: Self<T> = setmetatable(
-		{
-			createdAt = createdAt,
-			dependencySet = {},
-			dependentSet = {},
-			lastChange = nil,
-			scope = scope,
-			validity = "invalid",
-			_activeDuration = nil,
-			_activeElapsed = nil,
-			_activeFrom = nil,
-			_activeTo = nil,
-			_activeTweenInfo = nil,
-			_EXTREMELY_DANGEROUS_usedAsValue = peek(goal),
-			_goal = goal,
-			_stopwatch = stopwatch,
-			_tweenInfo = tweenInfo or TweenInfo.new()
-		},
-		METATABLE
-	) :: any
-	local destroy = function()
-		self.scope = nil
-		for dependency in pairs(self.dependencySet) do
-			dependency.dependentSet[self] = nil
-		end
-	end
-	self.oldestTask = destroy
-	nicknames[self.oldestTask] = "Tween"
-	table.insert(scope, destroy)
-
-	if goalState ~= nil then
-		checkLifetime.bOutlivesA(
-			scope, self.oldestTask,
-			goalState.scope, goalState.oldestTask,
-			checkLifetime.formatters.animationGoal
-		)
-	end
-
-	local tweenInfoState = castToState(tweenInfo)
-	if tweenInfoState ~= nil then
-		checkLifetime.bOutlivesA(
-			scope, self.oldestTask,
-			tweenInfoState.scope, tweenInfoState.oldestTask,
-			checkLifetime.formatters.parameter, "tween info"
-		)
-	end
-
-	-- Eagerly evaluated objects need to evaluate themselves so that they're
-	-- valid at all times.
-	evaluate(self, true)
-
-	return self
-end
-
-function class.get<T>(
-	self: Self<T>
-): never
-	return External.logError("stateGetWasRemoved")
-end
-
-function class._evaluate<T>(
-	self: Self<T>
-): boolean
-	local goal = castToState(self._goal)
-	-- Allow non-state goals to pass through transparently.
-	if goal == nil then
-		self._EXTREMELY_DANGEROUS_usedAsValue = self._goal :: T
-		return false
-	end
-	depend(self, goal)
-	local newTweenTo = peek(goal)
-	-- Protect against NaN goals.
-	if newTweenTo ~= newTweenTo then
-		External.logWarn("tweenNanGoal")
-		return false
-	end
-	local stopwatch = self._stopwatch :: Stopwatch.Stopwatch
-	local tweenInfo = peek(self._tweenInfo) :: TweenInfo
-	-- Restart animation when the goal changes, or if the tween info changes
-	-- partway through another animation.
-	if 
-		self._activeTo ~= newTweenTo or
-		(self._activeElapsed < self._activeDuration and self._activeTweenInfo ~= tweenInfo)
-	then
-		self._activeDuration = getTweenDuration(tweenInfo)
-		self._activeFrom = self._EXTREMELY_DANGEROUS_usedAsValue
-		self._activeTo = newTweenTo
-		self._activeTweenInfo = tweenInfo
-		stopwatch:zero()
-		stopwatch:unpause()
-	end
-	depend(self, stopwatch)
-	self._activeElapsed = peek(stopwatch)
-	if
-		self._activeFrom == self._activeTo or -- endpoints match
-		self._activeElapsed >= self._activeDuration or -- animation is done
-		typeof(self._activeTo) ~= typeof(self._activeFrom) -- type difference
-	then
-		self._activeFrom = self._activeTo
-		self._activeElapsed = self._activeDuration
-		stopwatch:pause()
-	end
-	-- Compute actual tweened value.
-	local ratio = getTweenRatio(tweenInfo, self._activeElapsed)
-	local oldValue = self._EXTREMELY_DANGEROUS_usedAsValue
-	local newValue = lerpType(self._activeFrom, self._activeTo, ratio) :: T
-	-- Protect against NaN after motion.
-	if newValue ~= newValue then
-		External.logWarn("tweenNanMotion")
-		newValue = self._activeTo
-	end
-	-- Push update and check for similarity.
-	-- Don't need to use the similarity test here because this code doesn't
-	-- deal with tables, and NaN is already guarded against, so the similarity
-	-- test doesn't actually add any new safety here.
-	self._EXTREMELY_DANGEROUS_usedAsValue = newValue
-	return oldValue ~= newValue
-end
-
-table.freeze(class)
-return Tween :: Types.TweenConstructor
+--!strict
+--!nolint LocalUnused
+--!nolint LocalShadow
+local task = nil -- Disable usage of Roblox's task scheduler
+
+--[[
+	A specialised state object for following a goal state smoothly over time,
+	using a TweenInfo to shape the motion.
+
+	https://elttob.uk/Fusion/0.3/api-reference/animation/types/tween/
+]]
+
+local Package = script.Parent.Parent
+local Types = require(Package.Types)
+local External = require(Package.External)
+-- Memory
+local checkLifetime = require(Package.Memory.checkLifetime)
+-- Graph
+local depend = require(Package.Graph.depend)
+local evaluate = require(Package.Graph.evaluate)
+-- State
+local castToState = require(Package.State.castToState)
+local peek = require(Package.State.peek)
+-- Animation
+local ExternalTime = require(Package.Animation.ExternalTime)
+local Stopwatch = require(Package.Animation.Stopwatch)
+local lerpType = require(Package.Animation.lerpType)
+local getTweenRatio = require(Package.Animation.getTweenRatio)
+local getTweenDuration = require(Package.Animation.getTweenDuration)
+-- Utility
+local nicknames = require(Package.Utility.nicknames)
+
+export type Self<T> = Types.Tween<T> & {
+	_activeDuration: number,
+	_activeElapsed: number,
+	_activeFrom: T,
+	_activeTo: T,
+	_activeTweenInfo: TweenInfo,
+	_goal: Types.UsedAs<T>,
+	_stopwatch: Stopwatch.Stopwatch?,
+	_tweenInfo: Types.UsedAs<TweenInfo>,
+}
+
+local class = {}
+class.type = "State"
+class.kind = "Tween"
+class.timeliness = "eager"
+
+local METATABLE = table.freeze {__index = class}
+
+local function Tween<T>(
+	scope: Types.Scope<unknown>,
+	goal: Types.UsedAs<T>,
+	tweenInfo: Types.UsedAs<TweenInfo>?
+): Types.Tween<T>
+	local createdAt = os.clock()
+	if castToState(scope) then
+		External.logError("scopeMissing", nil, "Tweens", "myScope:Tween(goalState, tweenInfo)")
+	end
+
+	local goalState = castToState(goal)
+	local stopwatch = nil
+	if goalState ~= nil then
+		stopwatch = Stopwatch(scope, ExternalTime(scope))
+	end
+
+	local self: Self<T> = setmetatable(
+		{
+			createdAt = createdAt,
+			dependencySet = {},
+			dependentSet = {},
+			lastChange = nil,
+			scope = scope,
+			validity = "invalid",
+			_activeDuration = nil,
+			_activeElapsed = nil,
+			_activeFrom = nil,
+			_activeTo = nil,
+			_activeTweenInfo = nil,
+			_EXTREMELY_DANGEROUS_usedAsValue = peek(goal),
+			_goal = goal,
+			_stopwatch = stopwatch,
+			_tweenInfo = tweenInfo or TweenInfo.new()
+		},
+		METATABLE
+	) :: any
+	local destroy = function()
+		self.scope = nil
+		for dependency in pairs(self.dependencySet) do
+			dependency.dependentSet[self] = nil
+		end
+	end
+	self.oldestTask = destroy
+	nicknames[self.oldestTask] = "Tween"
+	table.insert(scope, destroy)
+
+	if goalState ~= nil then
+		checkLifetime.bOutlivesA(
+			scope, self.oldestTask,
+			goalState.scope, goalState.oldestTask,
+			checkLifetime.formatters.animationGoal
+		)
+	end
+
+	local tweenInfoState = castToState(tweenInfo)
+	if tweenInfoState ~= nil then
+		checkLifetime.bOutlivesA(
+			scope, self.oldestTask,
+			tweenInfoState.scope, tweenInfoState.oldestTask,
+			checkLifetime.formatters.parameter, "tween info"
+		)
+	end
+
+	-- Eagerly evaluated objects need to evaluate themselves so that they're
+	-- valid at all times.
+	evaluate(self, true)
+
+	return self
+end
+
+function class.get<T>(
+	self: Self<T>
+): never
+	return External.logError("stateGetWasRemoved")
+end
+
+function class._evaluate<T>(
+	self: Self<T>
+): boolean
+	local goal = castToState(self._goal)
+	-- Allow non-state goals to pass through transparently.
+	if goal == nil then
+		self._EXTREMELY_DANGEROUS_usedAsValue = self._goal :: T
+		return false
+	end
+	depend(self, goal)
+	local newTweenTo = peek(goal)
+	-- Protect against NaN goals.
+	if newTweenTo ~= newTweenTo then
+		External.logWarn("tweenNanGoal")
+		return false
+	end
+	local stopwatch = self._stopwatch :: Stopwatch.Stopwatch
+	local tweenInfo = peek(self._tweenInfo) :: TweenInfo
+	-- Restart animation when the goal changes, or if the tween info changes
+	-- partway through another animation.
+	if 
+		self._activeTo ~= newTweenTo or
+		(self._activeElapsed < self._activeDuration and self._activeTweenInfo ~= tweenInfo)
+	then
+		self._activeDuration = getTweenDuration(tweenInfo)
+		self._activeFrom = self._EXTREMELY_DANGEROUS_usedAsValue
+		self._activeTo = newTweenTo
+		self._activeTweenInfo = tweenInfo
+		stopwatch:zero()
+		stopwatch:unpause()
+	end
+	depend(self, stopwatch)
+	self._activeElapsed = peek(stopwatch)
+	if
+		self._activeFrom == self._activeTo or -- endpoints match
+		self._activeElapsed >= self._activeDuration or -- animation is done
+		typeof(self._activeTo) ~= typeof(self._activeFrom) -- type difference
+	then
+		self._activeFrom = self._activeTo
+		self._activeElapsed = self._activeDuration
+		stopwatch:pause()
+	end
+	-- Compute actual tweened value.
+	local ratio = getTweenRatio(tweenInfo, self._activeElapsed)
+	local oldValue = self._EXTREMELY_DANGEROUS_usedAsValue
+	local newValue = lerpType(self._activeFrom, self._activeTo, ratio) :: T
+	-- Protect against NaN after motion.
+	if newValue ~= newValue then
+		External.logWarn("tweenNanMotion")
+		newValue = self._activeTo
+	end
+	-- Push update and check for similarity.
+	-- Don't need to use the similarity test here because this code doesn't
+	-- deal with tables, and NaN is already guarded against, so the similarity
+	-- test doesn't actually add any new safety here.
+	self._EXTREMELY_DANGEROUS_usedAsValue = newValue
+	return oldValue ~= newValue
+end
+
+table.freeze(class)
+return Tween :: Types.TweenConstructor

package/vendor/fusion/Animation/getTweenDuration.luau

@@ -1,27 +1,27 @@
---!strict
---!nolint LocalUnused
---!nolint LocalShadow
-local task = nil -- Disable usage of Roblox's task scheduler
-
---[[
-	Given a `tweenInfo`, returns how many seconds it will take before the tween
-	finishes moving. The result may be infinite if the tween repeats forever.
-]]
-
-local TweenService = game:GetService("TweenService")
-
-local function getTweenDuration(
-	tweenInfo: TweenInfo
-): number
-	if tweenInfo.RepeatCount <= -1 then
-		return math.huge
-	end
-	local tweenDuration = tweenInfo.DelayTime + tweenInfo.Time
-	if tweenInfo.Reverses then
-		tweenDuration += tweenInfo.Time
-	end
-	tweenDuration *= tweenInfo.RepeatCount + 1
-	return tweenDuration
-end
-
-return getTweenDuration
+--!strict
+--!nolint LocalUnused
+--!nolint LocalShadow
+local task = nil -- Disable usage of Roblox's task scheduler
+
+--[[
+	Given a `tweenInfo`, returns how many seconds it will take before the tween
+	finishes moving. The result may be infinite if the tween repeats forever.
+]]
+
+local TweenService = game:GetService("TweenService")
+
+local function getTweenDuration(
+	tweenInfo: TweenInfo
+): number
+	if tweenInfo.RepeatCount <= -1 then
+		return math.huge
+	end
+	local tweenDuration = tweenInfo.DelayTime + tweenInfo.Time
+	if tweenInfo.Reverses then
+		tweenDuration += tweenInfo.Time
+	end
+	tweenDuration *= tweenInfo.RepeatCount + 1
+	return tweenDuration
+end
+
+return getTweenDuration