@trioforge/anvil 0.0.0-stage → 0.1.1

package/out/runtime.luau

@@ -0,0 +1,797 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _charm = TS.import(script, TS.getModule(script, "@rbxts", "charm").src)
+local atom = _charm.atom
+local computed = _charm.computed
+local effect = _charm.effect
+local _services = TS.import(script, TS.getModule(script, "@rbxts", "services"))
+local GuiService = _services.GuiService
+local UserInputService = _services.UserInputService
+local _vide = TS.import(script, TS.getModule(script, "@rbxts", "vide").src)
+local cleanup = _vide.cleanup
+local context = _vide.context
+local videEffect = _vide.effect
+local read = _vide.read
+local source = _vide.source
+local useAtom = TS.import(script, TS.getModule(script, "@rbxts", "vide-charm").src).useAtom
+local adapter = TS.import(script, script.Parent, "adapter").adapter
+local _modal_state = TS.import(script, script.Parent, "modal-state")
+local enter = _modal_state.enter
+local hasModal = _modal_state.hasModal
+local leave = _modal_state.leave
+local top = _modal_state.top
+local _selection_policy = TS.import(script, script.Parent, "selection-policy")
+local decide = _selection_policy.decide
+local emptySelection = _selection_policy.emptySelection
+local ownerContext = context("Base")
+local closeFallbackContext = context(false)
+local state = atom({
+	entries = {},
+})
+local modalOpen = computed(function()
+	return hasModal(state())
+end)
+local topId = computed(function()
+	local _result = top(state())
+	if _result ~= nil then
+		_result = _result.id
+	end
+	return _result
+end)
+local selectedObject = atom()
+local textEditing = atom(false)
+local menuOpen = atom(false)
+local roots = {}
+local controls = {}
+local serial = 0
+local baseRestore
+local writing = false
+local generation = 0
+local waiting = {}
+local selectedWatch = {}
+local capturedA
+local runtimeOwners = {}
+-- The primitives draw the hover/selection geometry; blank only kit controls so TopbarPlus keeps its artwork.
+local blankSelectionImage = Instance.new("Frame")
+blankSelectionImage.Name = "SelectionImage"
+blankSelectionImage.BackgroundTransparency = 1
+local function active(owner)
+	return if owner == "Base" then not modalOpen() else topId() == owner
+end
+local function native(owner)
+	local _condition = active(owner)
+	if _condition then
+		local _condition_1 = owner == "Base"
+		if not _condition_1 then
+			local _owner = owner
+			local _result = roots[_owner]
+			if _result ~= nil then
+				_result = _result.mode
+			end
+			_condition_1 = _result == "Native"
+		end
+		_condition = _condition_1
+	end
+	return _condition
+end
+local function finite(value)
+	return value == value and math.abs(value) < math.huge
+end
+local function alive(object)
+	if not object:FindFirstAncestorOfClass("PlayerGui") then
+		return false
+	end
+	local ancestor = object
+	while ancestor do
+		if ancestor:IsA("GuiObject") and not ancestor.Visible then
+			return false
+		end
+		if ancestor:IsA("LayerCollector") and not ancestor.Enabled then
+			return false
+		end
+		ancestor = ancestor.Parent
+	end
+	return true
+end
+local function ready(object, isRoot)
+	if (not isRoot and not object.Selectable) or not alive(object) then
+		return false
+	end
+	local ancestor = object
+	while ancestor do
+		if ancestor:IsA("GuiObject") then
+			local size = ancestor.AbsoluteSize
+			local position = ancestor.AbsolutePosition
+			if not finite(size.X) or not finite(size.Y) or not finite(position.X) or not finite(position.Y) or size.X < 0 or size.Y < 0 then
+				return false
+			end
+			if (ancestor == object or ancestor.ClipsDescendants) and (size.X < 1 or size.Y < 1) then
+				return false
+			end
+		end
+		ancestor = ancestor.Parent
+	end
+	return true
+end
+local function disconnect(connections)
+	for _, connection in connections do
+		connection:Disconnect()
+	end
+end
+local function watch(object, changed)
+	local connections = { object.AncestryChanged:Connect(changed), object:GetPropertyChangedSignal("Selectable"):Connect(changed) }
+	local ancestor = object
+	while ancestor do
+		if ancestor:IsA("GuiObject") then
+			local _arg0 = ancestor:GetPropertyChangedSignal("AbsoluteSize"):Connect(changed)
+			table.insert(connections, _arg0)
+			local _arg0_1 = ancestor:GetPropertyChangedSignal("AbsolutePosition"):Connect(changed)
+			table.insert(connections, _arg0_1)
+			local _arg0_2 = ancestor:GetPropertyChangedSignal("Visible"):Connect(changed)
+			table.insert(connections, _arg0_2)
+			local _arg0_3 = ancestor:GetPropertyChangedSignal("ClipsDescendants"):Connect(changed)
+			table.insert(connections, _arg0_3)
+		elseif ancestor:IsA("LayerCollector") then
+			local _arg0 = ancestor:GetPropertyChangedSignal("Enabled"):Connect(changed)
+			table.insert(connections, _arg0)
+		end
+		ancestor = ancestor.Parent
+	end
+	return connections
+end
+local function cancelRequest()
+	generation += 1
+	disconnect(waiting)
+	waiting = {}
+end
+local function writeSelection(object)
+	writing = true
+	GuiService.SelectedObject = object
+	selectedObject(object)
+	writing = false
+end
+local function canSelect(owner)
+	return native(owner) and adapter().device() == "Gamepad" and not menuOpen() and not textEditing()
+end
+local function request(owner, target)
+	cancelRequest()
+	local token = generation
+	local _result
+	if target == "Root" then
+		local _result_1
+		if owner == "Base" then
+			_result_1 = nil
+		else
+			local _owner = owner
+			local _result_2 = roots[_owner]
+			if _result_2 ~= nil then
+				_result_2 = _result_2.root
+			end
+			_result_1 = _result_2
+		end
+		_result = _result_1
+	else
+		_result = target
+	end
+	local object = _result
+	if not object then
+		return nil
+	end
+	local queued = false
+	local queue
+	local retry = function()
+		if token ~= generation then
+			return nil
+		end
+		queued = false
+		disconnect(waiting)
+		waiting = {}
+		if not canSelect(owner) then
+			return nil
+		end
+		local _condition = target ~= "Root"
+		if _condition then
+			local _result_1 = controls[object]
+			if _result_1 ~= nil then
+				_result_1 = _result_1.owner
+			end
+			_condition = _result_1 ~= owner
+		end
+		if _condition then
+			return nil
+		end
+		if ready(object, target == "Root") then
+			if target == "Root" then
+				writing = true
+				GuiService:Select(object)
+				selectedObject(GuiService.SelectedObject)
+				writing = false
+			else
+				writeSelection(object)
+			end
+		else
+			waiting = watch(object, queue)
+		end
+	end
+	queue = function()
+		if not queued then
+			queued = true
+			task.defer(retry)
+		end
+	end
+	queue()
+end
+local function dispatch(id, event)
+	local _id = id
+	local record = roots[_id]
+	if not record then
+		return nil
+	end
+	local current = GuiService.SelectedObject
+	local _exp = record.selection
+	local _exp_1 = event
+	local _object = {}
+	local _left = "current"
+	local _condition = current
+	if _condition then
+		local _result = controls[current]
+		if _result ~= nil then
+			_result = _result.owner
+		end
+		_condition = _result == id
+	end
+	_object[_left] = if _condition then current else nil
+	_object.close = record.close
+	_object.alive = function(object)
+		local _object_1 = object
+		local _result = controls[_object_1]
+		if _result ~= nil then
+			_result = _result.owner
+		end
+		local _condition_1 = _result == id
+		if _condition_1 then
+			_condition_1 = alive(object)
+		end
+		return _condition_1
+	end
+	_object.canSelect = canSelect(id)
+	local decision = decide(_exp, _exp_1, _object)
+	record.selection = decision.selection
+	if decision.target ~= nil then
+		request(id, decision.target)
+	end
+end
+local function cancelA()
+	local session = capturedA
+	capturedA = nil
+	local _result = session
+	if _result ~= nil then
+		_result = _result.control.buttonAUp
+		if _result ~= nil then
+			_result(session.input)
+		end
+	end
+end
+local function selectionChanged()
+	local previous = selectedObject()
+	local current = GuiService.SelectedObject
+	selectedObject(current)
+	disconnect(selectedWatch)
+	selectedWatch = {}
+	if capturedA and capturedA.object ~= current then
+		cancelA()
+	end
+	if not writing then
+		cancelRequest()
+	end
+	local control = current and controls[current]
+	local _condition = current and control
+	if _condition then
+		local _owner = control.owner
+		_condition = type(_owner) == "number"
+	end
+	if _condition then
+		dispatch(control.owner, {
+			kind = "Selected",
+			object = current,
+		})
+	elseif not writing then
+		local previousControl = previous and controls[previous]
+		local _owner = previousControl
+		if _owner ~= nil then
+			_owner = _owner.owner
+		end
+		local owner = _owner
+		local id = topId()
+		if previous and type(owner) == "number" and active(owner) then
+			dispatch(owner, {
+				kind = "Lost",
+				removed = not alive(previous),
+			})
+		elseif id ~= nil and ((current and not control) or (previous and not previousControl)) then
+			dispatch(id, {
+				kind = "Lost",
+				removed = false,
+			})
+		end
+	end
+	if current and control then
+		selectedWatch = watch(current, function()
+			if GuiService.SelectedObject ~= current or not active(control.owner) or alive(current) then
+				return nil
+			end
+			writeSelection()
+			local _owner = control.owner
+			if type(_owner) == "number" then
+				dispatch(control.owner, {
+					kind = "Lost",
+					removed = true,
+				})
+			end
+		end)
+	end
+end
+local function openRoot(mode, onClose)
+	serial += 1
+	local id = serial
+	if not modalOpen() then
+		local selected = GuiService.SelectedObject
+		local _condition = selected
+		if _condition then
+			local _result = controls[selected]
+			if _result ~= nil then
+				_result = _result.owner
+			end
+			_condition = _result == "Base"
+		end
+		baseRestore = if _condition then selected else nil
+	end
+	local _arg1 = {
+		id = id,
+		serial = id,
+		mode = mode,
+		onClose = onClose,
+		selection = emptySelection(),
+	}
+	roots[id] = _arg1
+	state(enter(state(), {
+		id = id,
+		serial = id,
+		order = nil,
+	}))
+	return id
+end
+local function attachRoot(id, root)
+	local _id = id
+	local record = roots[_id]
+	if not record then
+		return function() end
+	end
+	local _result = record.stopAttachment
+	if _result ~= nil then
+		_result()
+	end
+	record.root = root
+	local orderConnection
+	local update
+	update = function()
+		local _id_1 = id
+		if roots[_id_1] ~= record then
+			return nil
+		end
+		local _result_1 = orderConnection
+		if _result_1 ~= nil then
+			_result_1:Disconnect()
+		end
+		local gui = root:FindFirstAncestorWhichIsA("ScreenGui")
+		if gui then
+			orderConnection = gui:GetPropertyChangedSignal("DisplayOrder"):Connect(update)
+		end
+		local _exp = state()
+		local _object = {
+			id = id,
+			serial = record.serial,
+		}
+		local _left = "order"
+		local _result_2 = gui
+		if _result_2 ~= nil then
+			_result_2 = _result_2.DisplayOrder
+		end
+		_object[_left] = _result_2
+		state(enter(_exp, _object))
+	end
+	local connection = root.AncestryChanged:Connect(update)
+	update()
+	local detach = function()
+		connection:Disconnect()
+		local _result_1 = orderConnection
+		if _result_1 ~= nil then
+			_result_1:Disconnect()
+		end
+	end
+	record.stopAttachment = detach
+	return detach
+end
+local function closeRoot(id)
+	local _id = id
+	local record = roots[_id]
+	if not record then
+		return nil
+	end
+	local _result = record.stopAttachment
+	if _result ~= nil then
+		_result()
+	end
+	local wasTop = topId() == id or topId() == nil
+	local selected = GuiService.SelectedObject
+	local _condition = selected
+	if _condition then
+		local _result_1 = controls[selected]
+		if _result_1 ~= nil then
+			_result_1 = _result_1.owner
+		end
+		_condition = _result_1
+	end
+	local selectedOwner = _condition
+	local restore = wasTop and not record.selection.paused and (selected == nil or selectedOwner == id)
+	if selectedOwner == id then
+		writeSelection()
+	end
+	local _id_1 = id
+	roots[_id_1] = nil
+	state(leave(state(), id))
+	if not modalOpen() then
+		local target = baseRestore
+		baseRestore = nil
+		local _condition_1 = restore and target
+		if _condition_1 then
+			local _result_1 = controls[target]
+			if _result_1 ~= nil then
+				_result_1 = _result_1.owner
+			end
+			_condition_1 = _result_1 == "Base"
+		end
+		if _condition_1 then
+			request("Base", target)
+		end
+	end
+end
+local function registerControl(object, control, fallback)
+	if fallback == nil then
+		fallback = false
+	end
+	local _object = object
+	local _control = control
+	controls[_object] = _control
+	object.SelectionImageObject = blankSelectionImage
+	local _owner = control.owner
+	local _result
+	if type(_owner) == "number" then
+		local _owner_1 = control.owner
+		_result = roots[_owner_1]
+	else
+		_result = nil
+	end
+	local record = _result
+	if fallback and record then
+		record.close = object
+	end
+	return function()
+		local selected = GuiService.SelectedObject == object
+		-- Vide builds a replacement before disposing the selected control; clear before Roblox chooses a neighbour.
+		if selected then
+			writeSelection()
+		end
+		local _result_1 = capturedA
+		if _result_1 ~= nil then
+			_result_1 = _result_1.object
+		end
+		if _result_1 == object then
+			cancelA()
+		end
+		local _object_1 = object
+		controls[_object_1] = nil
+		local _result_2 = record
+		if _result_2 ~= nil then
+			_result_2 = _result_2.close
+		end
+		if _result_2 == object then
+			record.close = nil
+		end
+		local _owner_1 = control.owner
+		if type(_owner_1) == "number" then
+			dispatch(control.owner, {
+				kind = "Unmarked",
+				object = object,
+			})
+			local owner = control.owner
+			if selected then
+				task.defer(function()
+					return dispatch(owner, {
+						kind = "Lost",
+						removed = true,
+					})
+				end)
+			end
+		end
+	end
+end
+local function markControl(owner, object, marked)
+	local _owner = owner
+	if not (type(_owner) == "number") then
+		return nil
+	end
+	local _owner_1 = owner
+	local record = roots[_owner_1]
+	local current = GuiService.SelectedObject
+	local _condition = current
+	if _condition then
+		local _result = record
+		if _result ~= nil then
+			_result = table.find(_result.selection.marked, current) ~= nil
+		end
+		_condition = _result
+	end
+	local replaces = if _condition then current else nil
+	dispatch(owner, if marked then {
+		kind = "Marked",
+		object = object,
+		replaces = replaces,
+	} else {
+		kind = "Unmarked",
+		object = object,
+	})
+end
+local function useSelection(options)
+	if options == nil then
+		options = {}
+	end
+	local owner = ownerContext()
+	local fallback = closeFallbackContext()
+	local object = source()
+	local selected = useAtom(selectedObject)
+	local selectable = useAtom(function()
+		return native(owner)
+	end)
+	local allowed = useAtom(function()
+		return active(owner)
+	end)
+	videEffect(function()
+		local instance = object()
+		if instance then
+			instance.Selectable = selectable()
+		end
+	end)
+	videEffect(function()
+		local instance = object()
+		if not instance then
+			return nil
+		end
+		local _condition = options.selectFirst
+		if _condition == nil then
+			_condition = false
+		end
+		markControl(owner, instance, read(_condition))
+		cleanup(function()
+			return markControl(owner, instance, false)
+		end)
+	end)
+	return {
+		allowed = allowed,
+		selected = function()
+			return object() ~= nil and selected() == object()
+		end,
+		action = function(instance)
+			local unregister = registerControl(instance, {
+				owner = owner,
+				buttonADown = options.buttonADown,
+				buttonAUp = options.buttonAUp,
+			}, fallback)
+			object(instance)
+			cleanup(unregister)
+		end,
+	}
+end
+local start, stop
+local function startMenuRuntime()
+	local host = adapter()
+	local token = {}
+	runtimeOwners[token] = true
+	-- ▼ ReadonlySet.size ▼
+	local _size = 0
+	for _ in runtimeOwners do
+		_size += 1
+	end
+	-- ▲ ReadonlySet.size ▲
+	if _size == 1 then
+		start(host)
+	end
+	return function()
+		-- ▼ Set.delete ▼
+		local _valueExisted = runtimeOwners[token] ~= nil
+		runtimeOwners[token] = nil
+		-- ▲ Set.delete ▲
+		local _condition = _valueExisted
+		if _condition then
+			_condition = next(runtimeOwners) == nil
+		end
+		if _condition then
+			local _result = stop
+			if _result ~= nil then
+				_result()
+			end
+		end
+	end
+end
+function start(host)
+	local armed = not host.close.held()
+	local previousTop
+	local connections = { GuiService:GetPropertyChangedSignal("SelectedObject"):Connect(selectionChanged), GuiService:GetPropertyChangedSignal("MenuIsOpen"):Connect(function()
+		return menuOpen(GuiService.MenuIsOpen)
+	end), UserInputService.TextBoxFocused:Connect(function()
+		return textEditing(true)
+	end), UserInputService.TextBoxFocusReleased:Connect(function()
+		return task.defer(function()
+			return textEditing(UserInputService:GetFocusedTextBox() ~= nil)
+		end)
+	end), UserInputService.InputBegan:Connect(function(input)
+		if input.KeyCode ~= Enum.KeyCode.ButtonA or capturedA or textEditing() or menuOpen() then
+			return nil
+		end
+		local object = GuiService.SelectedObject
+		local control = object and controls[object]
+		local _condition = not object
+		if not _condition then
+			local _result = control
+			if _result ~= nil then
+				_result = _result.buttonADown
+			end
+			_condition = not _result
+			if not _condition then
+				_condition = not native(control.owner)
+			end
+		end
+		if _condition then
+			return nil
+		end
+		capturedA = {
+			object = object,
+			input = input,
+			control = control,
+		}
+		control.buttonADown(input)
+	end), UserInputService.InputEnded:Connect(function(input)
+		local _condition = input.KeyCode == Enum.KeyCode.ButtonA
+		if _condition then
+			local _result = capturedA
+			if _result ~= nil then
+				_result = _result.input.UserInputType
+			end
+			_condition = _result == input.UserInputType
+		end
+		if _condition then
+			cancelA()
+		end
+	end), UserInputService.GamepadDisconnected:Connect(function(gamepad)
+		local _result = capturedA
+		if _result ~= nil then
+			_result = _result.input.UserInputType
+		end
+		if _result == gamepad then
+			cancelA()
+		end
+		armed = not host.close.held()
+	end) }
+	local stopClose = { host.close.onPressed(function()
+		local id = topId()
+		local record = if id ~= nil then roots[id] else nil
+		if not armed or not record or record.mode ~= "Native" or textEditing() or menuOpen() then
+			return nil
+		end
+		armed = false
+		local _result = record.onClose
+		if _result ~= nil then
+			_result()
+		end
+	end), host.close.onReleased(function()
+		armed = not host.close.held()
+	end) }
+	menuOpen(GuiService.MenuIsOpen)
+	textEditing(UserInputService:GetFocusedTextBox() ~= nil)
+	selectionChanged()
+	local stopEffects = { effect(function()
+		local id = topId()
+		cancelRequest()
+		cancelA()
+		armed = not host.close.held()
+		local old = previousTop
+		previousTop = id
+		if id ~= nil and id ~= old then
+			task.defer(function()
+				if topId() == id then
+					dispatch(id, {
+						kind = "Shown",
+					})
+				end
+			end)
+		end
+	end), effect(function()
+		local id = topId()
+		local editing = textEditing()
+		local menu = menuOpen()
+		armed = not host.close.held()
+		if editing or menu then
+			cancelRequest()
+			cancelA()
+		end
+		local _condition = id ~= nil
+		if _condition then
+			local _result = roots[id]
+			if _result ~= nil then
+				_result = _result.mode
+			end
+			_condition = _result == "Native"
+			if _condition then
+				_condition = not editing
+			end
+		end
+		if _condition then
+			if not menu and GuiService.SelectedObject == nil then
+				task.defer(function()
+					if topId() == id then
+						dispatch(id, {
+							kind = "Shown",
+						})
+					end
+				end)
+			end
+			return host.claimMenuInput()
+		end
+	end), effect(function()
+		if host.device() ~= "Gamepad" then
+			cancelRequest()
+			cancelA()
+			return nil
+		end
+		local id = topId()
+		if id ~= nil and GuiService.SelectedObject == nil then
+			task.defer(function()
+				if topId() == id then
+					dispatch(id, {
+						kind = "Shown",
+					})
+				end
+			end)
+		end
+	end) }
+	stop = function()
+		disconnect(connections)
+		for _, dispose in stopClose do
+			dispose()
+		end
+		for _, cleanupEffect in stopEffects do
+			cleanupEffect()
+		end
+		cancelA()
+		cancelRequest()
+		disconnect(selectedWatch)
+		selectedWatch = {}
+		stop = nil
+	end
+end
+return {
+	active = active,
+	openRoot = openRoot,
+	attachRoot = attachRoot,
+	closeRoot = closeRoot,
+	registerControl = registerControl,
+	markControl = markControl,
+	useSelection = useSelection,
+	startMenuRuntime = startMenuRuntime,
+	ownerContext = ownerContext,
+	closeFallbackContext = closeFallbackContext,
+	modalOpen = modalOpen,
+	selectedObject = selectedObject,
+	textEditing = textEditing,
+	menuOpen = menuOpen,
+}