cluaupp 0.1.0

package/runtime/Fusion/_impl/Utility/Contextual.luau

@@ -0,0 +1,91 @@
+--!strict
+--!nolint LocalUnused
+--!nolint LocalShadow
+local task = nil -- Disable usage of Roblox's task scheduler
+
+--[[
+    Time-based contextual values, to allow for transparently passing values down
+	the call stack.
+]]
+
+local Package = script.Parent.Parent
+local Types = require(Package.Types)
+local External = require(Package.External)
+-- Logging
+local parseError = require(Package.Logging.parseError)
+
+export type Self<T> = Types.Contextual<T> & {
+	_valuesNow: {[thread]: {value: T}},
+	_defaultValue: T
+}
+
+local class = {}
+class.type = "Contextual"
+
+local METATABLE = table.freeze {__index = class}
+local WEAK_KEYS_METATABLE = table.freeze {__mode = "k"}
+
+local function Contextual<T>(
+	defaultValue: T
+): Types.Contextual<T>
+	local self: Self<T> = setmetatable(
+		{
+			-- if we held strong references to threads here, then if a thread was
+			-- killed before this contextual had a chance to finish executing its
+			-- callback, it would be held strongly in this table forever
+			_valuesNow = setmetatable({}, WEAK_KEYS_METATABLE),
+			_defaultValue = defaultValue
+		}, 
+		METATABLE
+	) :: any
+
+	return self
+end
+
+--[[
+	Returns the current value of this contextual.
+]]
+function class.now<T>(
+	self: Self<T>
+): T
+	local thread = coroutine.running()
+	local value = self._valuesNow[thread]
+	if typeof(value) ~= "table" then
+		return self._defaultValue
+	else
+		return value.value
+	end
+end
+
+--[[
+	Temporarily assigns a value to this contextual.
+]]
+function class.is<T>(
+	self: Self<T>,
+	newValue: T
+)
+	local methods = {}
+	
+	function methods.during<T, A...>(
+		_: any, -- during is called with colon syntax but we don't care
+		callback: (A...) -> T,
+		...: A...
+	): T
+		local thread = coroutine.running()
+		local prevValue = self._valuesNow[thread]
+		-- Storing the value in this format allows us to distinguish storing
+		-- `nil` from not calling `:during()` at all.
+		self._valuesNow[thread] = { value = newValue }
+		local ok, value = xpcall(callback, parseError, ...)
+		self._valuesNow[thread] = prevValue
+		if not ok then
+			External.logError("callbackError", value :: any)
+		end
+		return value
+	end
+
+	return methods
+end
+
+table.freeze(class)
+return Contextual

package/runtime/Fusion/_impl/Utility/Safe.luau

@@ -0,0 +1,23 @@
+--!strict
+--!nolint LocalUnused
+--!nolint LocalShadow
+local task = nil -- Disable usage of Roblox's task scheduler
+
+--[[
+    A variant of xpcall() designed for inline usage, letting you define fallback
+	values based on caught errors.
+]]
+
+local Package = script.Parent.Parent
+
+local function Safe<Success, Fail>(
+	callbacks: {
+		try: () -> Success,
+		fallback: (err: unknown) -> Fail
+	}
+): Success | Fail
+	local _, value = xpcall(callbacks.try, callbacks.fallback)
+	return value
+end
+
+return Safe

package/runtime/Fusion/_impl/Utility/isSimilar.luau

@@ -0,0 +1,29 @@
+--!strict
+--!nolint LocalUnused
+--!nolint LocalShadow
+local task = nil -- Disable usage of Roblox's task scheduler
+
+--[[
+	Implements the 'similarity test' used to determine whether two values have
+	a meaningful difference.
+
+	https://elttob.uk/Fusion/0.3/tutorials/best-practices/optimisation/#similarity
+]]
+
+local function isSimilar(
+	a: unknown, 
+	b: unknown
+): boolean
+	local typeA = typeof(a)
+	local isTable = typeA == "table"
+	local isUserdata = typeA == "userdata"
+	return
+		if not (isTable or isUserdata) then
+			a == b or a ~= a and b ~= b
+		elseif typeA == typeof(b) and (isUserdata or table.isfrozen(a :: any) or getmetatable(a :: any) ~= nil) then
+			a == b
+		else
+			false
+end
+
+return isSimilar

package/runtime/Fusion/_impl/Utility/merge.luau

@@ -0,0 +1,35 @@
+--!strict
+--!nolint LocalUnused
+--!nolint LocalShadow
+local task = nil -- Disable usage of Roblox's task scheduler
+
+--[[
+	Attempts to merge a variadic number of tables together.
+]]
+
+local Package = script.Parent.Parent
+local External = require(Package.External)
+
+local function merge(
+	overwrite: boolean,
+	into: {[unknown]: unknown},
+	...: {[unknown]: unknown}
+): {[unknown]: unknown}
+	local fromTables = {...}
+	if #fromTables < 1 then
+		return into
+	else
+		for _, fromTable in fromTables do
+			for key, value in fromTable do
+				if overwrite or into[key] == nil then
+					into[key] = value
+				elseif not overwrite then
+					External.logError("mergeConflict", nil, tostring(key))
+				end
+			end
+		end
+		return into
+	end
+end
+
+return merge

package/runtime/Fusion/_impl/Utility/nameOf.luau

@@ -0,0 +1,35 @@
+--!strict
+--!nolint LocalUnused
+--!nolint LocalShadow
+local task = nil -- Disable usage of Roblox's task scheduler
+
+--[[
+	Returns the most specific custom name for the given object.
+]]
+
+local Package = script.Parent.Parent
+-- Utility
+local nicknames = require(Package.Utility.nicknames)
+
+local function nameOf(
+	x: unknown,
+	defaultName: string
+): string
+	local nickname = nicknames[x]
+	if typeof(nickname) == "string" then
+		return nickname
+	end
+	if typeof(x) == "table" then
+		local x = x :: {[any]: any}
+		if typeof(x.name) == "string" then
+			return x.name
+		elseif typeof(x.kind) == "string" then
+			return x.kind
+		elseif typeof(x.type) == "string" then
+			return x.type
+		end
+	end
+	return defaultName
+end
+
+return nameOf

package/runtime/Fusion/_impl/Utility/never.luau

@@ -0,0 +1,14 @@
+--!strict
+--!nolint LocalUnused
+--!nolint LocalShadow
+local task = nil -- Disable usage of Roblox's task scheduler
+
+--[[
+	Never returns.
+]]
+
+local function never(): never
+	error("This codepath should not be reachable")
+end
+
+return never

package/runtime/Fusion/_impl/Utility/nicknames.luau

@@ -0,0 +1,11 @@
+--!strict
+--!nolint LocalUnused
+--!nolint LocalShadow
+local task = nil -- Disable usage of Roblox's task scheduler
+
+--[[
+	Stores nicknames for values that don't support metatables, so that `nameOf`
+	can return values for them.
+]]
+
+return setmetatable({}, {__mode = "k"})

package/runtime/Fusion/_impl/Utility/xtypeof.luau

@@ -0,0 +1,27 @@
+--!strict
+--!nolint LocalUnused
+--!nolint LocalShadow
+local task = nil -- Disable usage of Roblox's task scheduler
+
+--[[
+	Extended typeof, designed for identifying custom objects.
+	If given a table with a `type` string, returns that.
+	Otherwise, returns `typeof()` the argument.
+]]
+
+local function xtypeof(
+	x: unknown
+): string
+	local typeString = typeof(x)
+
+	if typeString == "table" then
+		local x = x :: {type: unknown?}
+		if typeof(x.type) == "string" then
+			return x.type
+		end
+	end
+
+	return typeString
+end
+
+return xtypeof

package/runtime/Fusion/_impl/init.luau

@@ -0,0 +1,83 @@
+--!strict
+--!nolint LocalUnused
+--!nolint LocalShadow
+local task = nil -- Disable usage of Roblox's task scheduler
+--[[
+	The entry point for the Fusion library.
+]]
+
+local Types = require(script.Types)
+local External = require(script.External)
+
+type Fusion = Types.Fusion
+
+export type Animatable = Types.Animatable
+export type UsedAs<T> = Types.UsedAs<T>
+export type Child = Types.Child
+export type Computed<T> = Types.Computed<T>
+export type Contextual<T> = Types.Contextual<T>
+export type GraphObject = Types.GraphObject
+export type For<KO, VO> = Types.For<KO, VO>
+export type Observer = Types.Observer
+export type PropertyTable = Types.PropertyTable
+export type Scope<Constructors = Fusion> = Types.Scope<Constructors>
+export type ScopedObject = Types.ScopedObject
+export type SpecialKey = Types.SpecialKey
+export type Spring<T> = Types.Spring<T>
+export type StateObject<T> = Types.StateObject<T>
+export type Task = Types.Task
+export type Tween<T> = Types.Tween<T>
+export type Use = Types.Use
+export type Value<T, S = T> = Types.Value<T, S>
+export type Version = Types.Version
+
+-- Down the line, this will be conditional based on whether Fusion is being
+-- compiled for Roblox.
+do
+	local RobloxExternal = require(script.RobloxExternal)
+	External.setExternalProvider(RobloxExternal)
+end
+
+local Fusion: Fusion = table.freeze({
+	-- General
+	version = { major = 0, minor = 4, isRelease = false },
+	Contextual = require(script.Utility.Contextual),
+	Safe = require(script.Utility.Safe),
+
+	-- Memory
+	deriveScope = require(script.Memory.deriveScope),
+	doCleanup = require(script.Memory.doCleanup),
+	innerScope = require(script.Memory.innerScope),
+	insert = require(script.Memory.insert),
+	scoped = require(script.Memory.scoped),
+
+	-- Graph
+	Observer = require(script.Graph.Observer),
+
+	-- State
+	Computed = require(script.State.Computed),
+	ForKeys = require(script.State.ForKeys) :: Types.ForKeysConstructor,
+	ForPairs = require(script.State.ForPairs) :: Types.ForPairsConstructor,
+	ForValues = require(script.State.ForValues) :: Types.ForValuesConstructor,
+	peek = require(script.State.peek),
+	Value = require(script.State.Value),
+
+	-- Roblox API
+	Attribute = require(script.Instances.Attribute),
+	AttributeChange = require(script.Instances.AttributeChange),
+	AttributeOut = require(script.Instances.AttributeOut),
+	Child = require(script.Instances.Child),
+	Children = require(script.Instances.Children),
+	Hydrate = require(script.Instances.Hydrate),
+	New = require(script.Instances.New),
+	OnChange = require(script.Instances.OnChange),
+	OnEvent = require(script.Instances.OnEvent),
+	Out = require(script.Instances.Out),
+	Tag = require(script.Instances.Tag),
+
+	-- Animation
+	Tween = require(script.Animation.Tween),
+	Spring = require(script.Animation.Spring),
+})
+
+return Fusion

package/runtime/Fusion/init.luau

@@ -0,0 +1,27 @@
+--!strict
+-- Cluaupp Fusion — typed border over dphfox/Fusion (_impl).
+
+local Impl = require(script._impl)
+
+export type Animatable = Impl.Animatable
+export type UsedAs<T> = Impl.UsedAs<T>
+export type Child = Impl.Child
+export type Computed<T> = Impl.Computed<T>
+export type Contextual<T> = Impl.Contextual<T>
+export type GraphObject = Impl.GraphObject
+export type For<KO, VO> = Impl.For<KO, VO>
+export type Observer = Impl.Observer
+export type PropertyTable = Impl.PropertyTable
+export type Scope<T> = Impl.Scope<T>
+export type ScopedObject = Impl.ScopedObject
+export type SpecialKey = Impl.SpecialKey
+export type Spring<T> = Impl.Spring<T>
+export type StateObject<T> = Impl.StateObject<T>
+export type Task = Impl.Task
+export type Tween<T> = Impl.Tween<T>
+export type Use = Impl.Use
+export type Value<T, S = T> = Impl.Value<T, S>
+export type Version = Impl.Version
+export type Fusion = typeof(Impl)
+
+return Impl