@lattice-ui/focus 0.3.2 → 0.4.1

package/README.md

@@ -1,10 +1,9 @@
 # @lattice-ui/focus
 
-Focus and directional navigation primitives for Roblox UI.
+Focus management primitives for Roblox UI.
 
 ## Current status
 
-- `RovingFocusGroup` and `RovingFocusItem` provide arrow/Home/End navigation across registered selectable items.
 - `FocusScope` can trap `GuiService.SelectedObject` and restore captured focus on scope teardown.
 
 ## FocusScope behavior

package/out/FocusScope/FocusScope.luau

@@ -1,59 +1,33 @@
 -- Compiled with roblox-ts v3.0.0
 local TS = _G[script]
 local _core = TS.import(script, TS.getModule(script, "@lattice-ui", "core").out)
+local createFocusScopeId = _core.createFocusScopeId
+local FocusScopeProvider = _core.FocusScopeProvider
 local React = _core.React
+local registerFocusScope = _core.registerFocusScope
+local releaseExternalFocusBridge = _core.releaseExternalFocusBridge
+local retainExternalFocusBridge = _core.retainExternalFocusBridge
 local Slot = _core.Slot
-local _guiSelection = TS.import(script, script.Parent.Parent, "internals", "guiSelection")
-local getSelectedGuiObject = _guiSelection.getSelectedGuiObject
-local setSelectedGuiObject = _guiSelection.setSelectedGuiObject
-local _focusManager = TS.import(script, script.Parent, "focusManager")
-local captureFocus = _focusManager.captureFocus
-local GuiService = _focusManager.GuiService
-local restoreFocus = _focusManager.restoreFocus
-local _scopeStack = TS.import(script, script.Parent, "scopeStack")
-local isTopTrappedScope = _scopeStack.isTopTrappedScope
-local registerTrappedScope = _scopeStack.registerTrappedScope
-local unregisterTrappedScope = _scopeStack.unregisterTrappedScope
-local nextScopeId = 0
+local syncFocusScope = _core.syncFocusScope
+local unregisterFocusScope = _core.unregisterFocusScope
+local useFocusLayerOrder = _core.useFocusLayerOrder
+local useFocusScopeId = _core.useFocusScopeId
 local function toGuiObject(instance)
 	if not instance or not instance:IsA("GuiObject") then
 		return nil
 	end
 	return instance
 end
-local function isLiveGuiObject(guiObject)
-	return guiObject ~= nil and guiObject.Parent ~= nil
-end
-local function isFocusable(guiObject)
-	return isLiveGuiObject(guiObject) and guiObject.Selectable
-end
-local function isInsideScope(scopeRoot, guiObject)
-	if not isLiveGuiObject(scopeRoot) or not isLiveGuiObject(guiObject) then
-		return false
-	end
-	return guiObject == scopeRoot or guiObject:IsDescendantOf(scopeRoot)
-end
-local function findFirstFocusableInScope(scopeRoot)
-	if isFocusable(scopeRoot) then
-		return scopeRoot
-	end
-	for _, descendant in scopeRoot:GetDescendants() do
-		if descendant:IsA("GuiObject") and isFocusable(descendant) then
-			return descendant
-		end
-	end
-	return nil
-end
-local function getFocusableRestoreTarget(snapshot)
-	if not snapshot then
-		return nil
-	end
-	if not isFocusable(snapshot) then
-		return nil
-	end
-	return snapshot
+local function useLatest(value)
+	local ref = React.useRef(value)
+	React.useEffect(function()
+		ref.current = value
+	end, { value })
+	return ref
 end
 local function FocusScope(props)
+	local parentScopeId = useFocusScopeId()
+	local layerOrder = useFocusLayerOrder()
 	local _condition = props.active
 	if _condition == nil then
 		_condition = true
@@ -63,117 +37,56 @@ local function FocusScope(props)
 	local shouldRestoreFocus = props.restoreFocus ~= false
 	local scopeIdRef = React.useRef(0)
 	if scopeIdRef.current == 0 then
-		nextScopeId += 1
-		scopeIdRef.current = nextScopeId
+		scopeIdRef.current = createFocusScopeId()
 	end
 	local scopeRootRef = React.useRef()
-	local lastFocusedInsideRef = React.useRef()
-	local restoreSnapshotRef = React.useRef()
-	local isRedirectingRef = React.useRef(false)
-	local shouldRestoreFocusRef = React.useRef(shouldRestoreFocus)
-	React.useEffect(function()
-		shouldRestoreFocusRef.current = shouldRestoreFocus
-	end, { shouldRestoreFocus })
-	local updateLastFocusedInside = React.useCallback(function()
-		local scopeRoot = scopeRootRef.current
-		if not scopeRoot then
-			return nil
-		end
-		local selectedObject = getSelectedGuiObject()
-		if not selectedObject or not isInsideScope(scopeRoot, selectedObject) then
-			return nil
-		end
-		if isFocusable(selectedObject) then
-			lastFocusedInsideRef.current = selectedObject
-		end
-	end, {})
-	local resolveFallbackTarget = React.useCallback(function()
-		local scopeRoot = scopeRootRef.current
-		if not isLiveGuiObject(scopeRoot) then
-			return nil
-		end
-		local previousFocus = lastFocusedInsideRef.current
-		if previousFocus and isInsideScope(scopeRoot, previousFocus) and isFocusable(previousFocus) then
-			return previousFocus
-		end
-		return findFirstFocusableInScope(scopeRoot)
-	end, {})
-	local enforceFocusTrap = React.useCallback(function()
-		if not active or not trapped then
-			return nil
-		end
-		if not isTopTrappedScope(scopeIdRef.current) then
-			return nil
-		end
-		local scopeRoot = scopeRootRef.current
-		if not isLiveGuiObject(scopeRoot) then
-			return nil
-		end
-		local selectedObject = getSelectedGuiObject()
-		if selectedObject and isInsideScope(scopeRoot, selectedObject) then
-			if isFocusable(selectedObject) then
-				lastFocusedInsideRef.current = selectedObject
-			end
-			return nil
-		end
-		local fallbackTarget = resolveFallbackTarget()
-		if not fallbackTarget or fallbackTarget == selectedObject then
-			return nil
-		end
-		isRedirectingRef.current = true
-		setSelectedGuiObject(fallbackTarget)
-		isRedirectingRef.current = false
-	end, { active, resolveFallbackTarget, trapped })
+	local activeRef = useLatest(active)
+	local trappedRef = useLatest(trapped)
+	local restoreFocusRef = useLatest(shouldRestoreFocus)
+	local layerOrderRef = useLatest(layerOrder)
 	local setScopeRoot = React.useCallback(function(instance)
-		local scopeRoot = toGuiObject(instance)
-		scopeRootRef.current = scopeRoot
-		if not scopeRoot then
-			return nil
+		scopeRootRef.current = toGuiObject(instance)
+		if scopeIdRef.current ~= 0 then
+			syncFocusScope(scopeIdRef.current)
 		end
-		updateLastFocusedInside()
-		if active and trapped then
-			enforceFocusTrap()
+	end, {})
+	React.useEffect(function()
+		local scopeId = scopeIdRef.current
+		registerFocusScope(scopeId, {
+			parentScopeId = parentScopeId,
+			getRoot = function()
+				return scopeRootRef.current
+			end,
+			getActive = function()
+				return activeRef.current
+			end,
+			getTrapped = function()
+				return trappedRef.current
+			end,
+			getRestoreFocus = function()
+				return restoreFocusRef.current
+			end,
+			getLayerOrder = function()
+				return layerOrderRef.current
+			end,
+		})
+		return function()
+			unregisterFocusScope(scopeId)
 		end
-	end, { active, enforceFocusTrap, trapped, updateLastFocusedInside })
+	end, { activeRef, layerOrderRef, parentScopeId, restoreFocusRef, trappedRef })
+	React.useEffect(function()
+		syncFocusScope(scopeIdRef.current)
+	end, { active, layerOrder, shouldRestoreFocus, trapped })
 	React.useEffect(function()
 		if not active then
-			restoreSnapshotRef.current = nil
 			return nil
 		end
-		if shouldRestoreFocusRef.current then
-			restoreSnapshotRef.current = captureFocus()
-		else
-			restoreSnapshotRef.current = nil
-		end
-		local currentScopeId = scopeIdRef.current
-		if trapped then
-			registerTrappedScope(currentScopeId)
-		end
-		local selectedObjectConnection = GuiService:GetPropertyChangedSignal("SelectedObject"):Connect(function()
-			if isRedirectingRef.current then
-				return nil
-			end
-			updateLastFocusedInside()
-			if trapped then
-				enforceFocusTrap()
-			end
-		end)
-		if trapped then
-			enforceFocusTrap()
-		end
+		retainExternalFocusBridge()
 		return function()
-			selectedObjectConnection:Disconnect()
-			if trapped then
-				unregisterTrappedScope(currentScopeId)
-			end
-			local restoreTarget = getFocusableRestoreTarget(restoreSnapshotRef.current)
-			restoreSnapshotRef.current = nil
-			if restoreTarget and shouldRestoreFocusRef.current then
-				restoreFocus(restoreTarget)
-			end
+			releaseExternalFocusBridge()
 		end
-	end, { active, enforceFocusTrap, trapped, updateLastFocusedInside })
-	if props.asChild then
+	end, { active })
+	local content = if props.asChild then ((function()
 		local child = props.children
 		if not React.isValidElement(child) then
 			error("[FocusScope] `asChild` requires a child element.")
@@ -181,14 +94,16 @@ local function FocusScope(props)
 		return React.createElement(Slot, {
 			ref = setScopeRoot,
 		}, child)
-	end
-	return React.createElement("frame", {
+	end)()) else (React.createElement("frame", {
 		BackgroundTransparency = 1,
 		BorderSizePixel = 0,
 		Position = UDim2.fromScale(0, 0),
 		Size = UDim2.fromScale(1, 1),
 		ref = setScopeRoot,
-	}, props.children)
+	}, props.children))
+	return React.createElement(FocusScopeProvider, {
+		scopeId = scopeIdRef.current,
+	}, content)
 end
 return {
 	FocusScope = FocusScope,

package/out/index.d.ts

@@ -1,3 +1 @@
 export * from "./FocusScope/FocusScope";
-export * from "./RovingFocus/RovingFocusGroup";
-export * from "./RovingFocus/RovingFocusItem";

package/out/init.luau

@@ -4,10 +4,4 @@ local exports = {}
 for _k, _v in TS.import(script, script, "FocusScope", "FocusScope") or {} do
 	exports[_k] = _v
 end
-for _k, _v in TS.import(script, script, "RovingFocus", "RovingFocusGroup") or {} do
-	exports[_k] = _v
-end
-for _k, _v in TS.import(script, script, "RovingFocus", "RovingFocusItem") or {} do
-	exports[_k] = _v
-end
 return exports

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lattice-ui/focus",
-  "version": "0.3.2",
+  "version": "0.4.1",
   "private": false,
   "main": "out/init.luau",
   "types": "out/index.d.ts",
@@ -9,7 +9,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@lattice-ui/core": "0.3.2"
+    "@lattice-ui/core": "0.4.1"
   },
   "devDependencies": {
     "@rbxts/react": "17.3.7-ts.1",

package/out/RovingFocus/RovingFocusGroup.d.ts

@@ -1,3 +0,0 @@
-import { React } from "@lattice-ui/core";
-import type { RovingFocusGroupProps } from "./types";
-export declare function RovingFocusGroup(props: RovingFocusGroupProps): React.JSX.Element;

package/out/RovingFocus/RovingFocusGroup.luau

@@ -1,196 +0,0 @@
--- Compiled with roblox-ts v3.0.0
-local TS = _G[script]
-local React = TS.import(script, TS.getModule(script, "@lattice-ui", "core").out).React
-local _guiSelection = TS.import(script, script.Parent.Parent, "internals", "guiSelection")
-local getSelectedGuiObject = _guiSelection.getSelectedGuiObject
-local setSelectedGuiObject = _guiSelection.setSelectedGuiObject
-local UserInputService = _guiSelection.UserInputService
-local RovingFocusProvider = TS.import(script, script.Parent, "context").RovingFocusProvider
-local _roving = TS.import(script, script.Parent, "roving")
-local getFirstEnabledRovingIndex = _roving.getFirstEnabledRovingIndex
-local getLastEnabledRovingIndex = _roving.getLastEnabledRovingIndex
-local getNextRovingIndex = _roving.getNextRovingIndex
-local function findCurrentIndex(items, selectedObject)
-	if not selectedObject then
-		return -1
-	end
-	-- ▼ ReadonlyArray.findIndex ▼
-	local _callback = function(item)
-		local node = item.getNode()
-		if not node then
-			return false
-		end
-		return selectedObject == node or selectedObject:IsDescendantOf(node)
-	end
-	local _result = -1
-	for _i, _v in items do
-		if _callback(_v, _i - 1, items) == true then
-			_result = _i - 1
-			break
-		end
-	end
-	-- ▲ ReadonlyArray.findIndex ▲
-	return _result
-end
-local function isItemDisabled(items, index)
-	local item = items[index + 1]
-	if not item then
-		return true
-	end
-	return item.getDisabled()
-end
-local function focusItem(items, index)
-	local item = items[index + 1]
-	if not item then
-		return nil
-	end
-	if item.getDisabled() then
-		return nil
-	end
-	local node = item.getNode()
-	if not node or not node.Selectable then
-		return nil
-	end
-	setSelectedGuiObject(node)
-end
-local function resolveArrowDirection(keyCode, orientation)
-	if (orientation == "vertical" or orientation == "both") and keyCode == Enum.KeyCode.Up then
-		return "prev"
-	end
-	if (orientation == "vertical" or orientation == "both") and keyCode == Enum.KeyCode.Down then
-		return "next"
-	end
-	if (orientation == "horizontal" or orientation == "both") and keyCode == Enum.KeyCode.Left then
-		return "prev"
-	end
-	if (orientation == "horizontal" or orientation == "both") and keyCode == Enum.KeyCode.Right then
-		return "next"
-	end
-	return nil
-end
-local function RovingFocusGroup(props)
-	local _condition = props.loop
-	if _condition == nil then
-		_condition = true
-	end
-	local loop = _condition
-	local orientation = props.orientation or "both"
-	local _condition_1 = props.active
-	if _condition_1 == nil then
-		_condition_1 = true
-	end
-	local active = _condition_1
-	local autoFocus = props.autoFocus or "none"
-	local itemEntriesRef = React.useRef({})
-	local revision, setRevision = React.useState(0)
-	local registerItem = React.useCallback(function(item)
-		local _current = itemEntriesRef.current
-		local _item = item
-		table.insert(_current, _item)
-		setRevision(function(value)
-			return value + 1
-		end)
-		return function()
-			local _exp = itemEntriesRef.current
-			-- ▼ ReadonlyArray.findIndex ▼
-			local _callback = function(entry)
-				return entry.id == item.id
-			end
-			local _result = -1
-			for _i, _v in _exp do
-				if _callback(_v, _i - 1, _exp) == true then
-					_result = _i - 1
-					break
-				end
-			end
-			-- ▲ ReadonlyArray.findIndex ▲
-			local index = _result
-			if index >= 0 then
-				table.remove(itemEntriesRef.current, index + 1)
-				setRevision(function(value)
-					return value + 1
-				end)
-			end
-		end
-	end, {})
-	React.useEffect(function()
-		if not active or autoFocus ~= "first" then
-			return nil
-		end
-		local items = itemEntriesRef.current
-		local firstEnabledIndex = getFirstEnabledRovingIndex(#items, function(index)
-			return isItemDisabled(items, index)
-		end)
-		if firstEnabledIndex >= 0 then
-			focusItem(items, firstEnabledIndex)
-		end
-	end, { active, autoFocus, revision })
-	React.useEffect(function()
-		if not active then
-			return nil
-		end
-		local connection = UserInputService.InputBegan:Connect(function(inputObject, gameProcessedEvent)
-			if gameProcessedEvent then
-				return nil
-			end
-			local keyCode = inputObject.KeyCode
-			local isHomeKey = keyCode == Enum.KeyCode.Home
-			local isEndKey = keyCode == Enum.KeyCode.End
-			local direction = resolveArrowDirection(keyCode, orientation)
-			if not isHomeKey and not isEndKey and not direction then
-				return nil
-			end
-			local items = itemEntriesRef.current
-			local itemCount = #items
-			if itemCount <= 0 then
-				return nil
-			end
-			local selectedObject = getSelectedGuiObject()
-			local currentIndex = findCurrentIndex(items, selectedObject)
-			if currentIndex < 0 then
-				return nil
-			end
-			if isHomeKey then
-				local firstEnabledIndex = getFirstEnabledRovingIndex(itemCount, function(index)
-					return isItemDisabled(items, index)
-				end)
-				if firstEnabledIndex >= 0 then
-					focusItem(items, firstEnabledIndex)
-				end
-				return nil
-			end
-			if isEndKey then
-				local lastEnabledIndex = getLastEnabledRovingIndex(itemCount, function(index)
-					return isItemDisabled(items, index)
-				end)
-				if lastEnabledIndex >= 0 then
-					focusItem(items, lastEnabledIndex)
-				end
-				return nil
-			end
-			if not direction then
-				return nil
-			end
-			local nextIndex = getNextRovingIndex(currentIndex, itemCount, direction, loop, function(index)
-				return isItemDisabled(items, index)
-			end)
-			if nextIndex >= 0 then
-				focusItem(items, nextIndex)
-			end
-		end)
-		return function()
-			connection:Disconnect()
-		end
-	end, { active, loop, orientation })
-	local contextValue = React.useMemo(function()
-		return {
-			registerItem = registerItem,
-		}
-	end, { registerItem })
-	return React.createElement(RovingFocusProvider, {
-		value = contextValue,
-	}, props.children)
-end
-return {
-	RovingFocusGroup = RovingFocusGroup,
-}

package/out/RovingFocus/RovingFocusItem.d.ts

@@ -1,3 +0,0 @@
-import { React } from "@lattice-ui/core";
-import type { RovingFocusItemProps } from "./types";
-export declare function RovingFocusItem(props: RovingFocusItemProps): React.JSX.Element;

package/out/RovingFocus/RovingFocusItem.luau

@@ -1,66 +0,0 @@
--- Compiled with roblox-ts v3.0.0
-local TS = _G[script]
-local _core = TS.import(script, TS.getModule(script, "@lattice-ui", "core").out)
-local React = _core.React
-local Slot = _core.Slot
-local useRovingFocusContext = TS.import(script, script.Parent, "context").useRovingFocusContext
-local nextRovingItemId = 0
-local function toGuiObject(instance)
-	if not instance or not instance:IsA("GuiObject") then
-		return nil
-	end
-	return instance
-end
-local function RovingFocusItem(props)
-	local rovingFocusContext = useRovingFocusContext()
-	local itemRef = React.useRef()
-	local disabledRef = React.useRef(props.disabled == true)
-	React.useEffect(function()
-		disabledRef.current = props.disabled == true
-	end, { props.disabled })
-	local itemIdRef = React.useRef(0)
-	if itemIdRef.current == 0 then
-		nextRovingItemId += 1
-		itemIdRef.current = nextRovingItemId
-	end
-	React.useEffect(function()
-		return rovingFocusContext.registerItem({
-			id = itemIdRef.current,
-			getNode = function()
-				return itemRef.current
-			end,
-			getDisabled = function()
-				return disabledRef.current
-			end,
-		})
-	end, { rovingFocusContext })
-	local setItemRef = React.useCallback(function(instance)
-		itemRef.current = toGuiObject(instance)
-	end, {})
-	if props.asChild then
-		local child = props.children
-		if not child then
-			error("[RovingFocusItem] `asChild` requires a child element.")
-		end
-		return React.createElement(Slot, {
-			Active = props.disabled ~= true,
-			Selectable = props.disabled ~= true,
-			ref = setItemRef,
-		}, child)
-	end
-	return React.createElement("textbutton", {
-		Active = props.disabled ~= true,
-		AutoButtonColor = false,
-		BackgroundTransparency = 1,
-		BorderSizePixel = 0,
-		Selectable = props.disabled ~= true,
-		Size = UDim2.fromOffset(140, 30),
-		Text = "Item",
-		TextColor3 = Color3.fromRGB(240, 244, 250),
-		TextSize = 15,
-		ref = setItemRef,
-	}, props.children)
-end
-return {
-	RovingFocusItem = RovingFocusItem,
-}

package/out/RovingFocus/context.d.ts

@@ -1,3 +0,0 @@
-import type { RovingFocusContextValue } from "./types";
-declare const RovingFocusProvider: import("@rbxts/react").Provider<RovingFocusContextValue | undefined>, useRovingFocusContext: () => RovingFocusContextValue;
-export { RovingFocusProvider, useRovingFocusContext };

package/out/RovingFocus/context.luau

@@ -1,10 +0,0 @@
--- Compiled with roblox-ts v3.0.0
-local TS = _G[script]
-local createStrictContext = TS.import(script, TS.getModule(script, "@lattice-ui", "core").out).createStrictContext
-local _binding = createStrictContext("RovingFocusGroup")
-local RovingFocusProvider = _binding[1]
-local useRovingFocusContext = _binding[2]
-return {
-	RovingFocusProvider = RovingFocusProvider,
-	useRovingFocusContext = useRovingFocusContext,
-}

package/out/RovingFocus/roving.d.ts

@@ -1,4 +0,0 @@
-import type { RovingDirection } from "./types";
-export declare function getNextRovingIndex(currentIndex: number, itemCount: number, direction: RovingDirection, loop: boolean, isDisabled?: (index: number) => boolean): number;
-export declare function getFirstEnabledRovingIndex(itemCount: number, isDisabled?: (index: number) => boolean): number;
-export declare function getLastEnabledRovingIndex(itemCount: number, isDisabled?: (index: number) => boolean): number;

package/out/RovingFocus/roving.luau

@@ -1,85 +0,0 @@
--- Compiled with roblox-ts v3.0.0
-local function getDirectionDelta(direction)
-	return if direction == "next" then 1 else -1
-end
-local function getNextRovingIndex(currentIndex, itemCount, direction, loop, isDisabled)
-	if itemCount <= 0 then
-		return -1
-	end
-	-- Keep focus unchanged when the current index is outside this group.
-	if currentIndex < 0 or currentIndex >= itemCount then
-		return currentIndex
-	end
-	local delta = getDirectionDelta(direction)
-	local candidate = currentIndex
-	do
-		local attempts = 0
-		local _shouldIncrement = false
-		while true do
-			if _shouldIncrement then
-				attempts += 1
-			else
-				_shouldIncrement = true
-			end
-			if not (attempts < itemCount) then
-				break
-			end
-			candidate += delta
-			if candidate < 0 or candidate >= itemCount then
-				if not loop then
-					return currentIndex
-				end
-				candidate = if direction == "next" then 0 else itemCount - 1
-			end
-			if not isDisabled or not isDisabled(candidate) then
-				return candidate
-			end
-		end
-	end
-	return currentIndex
-end
-local function getFirstEnabledRovingIndex(itemCount, isDisabled)
-	do
-		local index = 0
-		local _shouldIncrement = false
-		while true do
-			if _shouldIncrement then
-				index += 1
-			else
-				_shouldIncrement = true
-			end
-			if not (index < itemCount) then
-				break
-			end
-			if not isDisabled or not isDisabled(index) then
-				return index
-			end
-		end
-	end
-	return -1
-end
-local function getLastEnabledRovingIndex(itemCount, isDisabled)
-	do
-		local index = itemCount - 1
-		local _shouldIncrement = false
-		while true do
-			if _shouldIncrement then
-				index -= 1
-			else
-				_shouldIncrement = true
-			end
-			if not (index >= 0) then
-				break
-			end
-			if not isDisabled or not isDisabled(index) then
-				return index
-			end
-		end
-	end
-	return -1
-end
-return {
-	getNextRovingIndex = getNextRovingIndex,
-	getFirstEnabledRovingIndex = getFirstEnabledRovingIndex,
-	getLastEnabledRovingIndex = getLastEnabledRovingIndex,
-}

package/out/RovingFocus/types.d.ts

@@ -1,25 +0,0 @@
-import type React from "@rbxts/react";
-export type RovingDirection = "next" | "prev";
-export type RovingOrientation = "horizontal" | "vertical" | "both";
-export type RovingAutoFocus = "none" | "first";
-export type RovingFocusGroupProps = {
-    loop?: boolean;
-    orientation?: RovingOrientation;
-    active?: boolean;
-    autoFocus?: RovingAutoFocus;
-    children?: React.ReactNode;
-};
-export type RovingFocusItemProps = {
-    asChild?: boolean;
-    disabled?: boolean;
-    children?: React.ReactElement;
-};
-export type RovingItemRegistration = {
-    id: number;
-    getNode: () => GuiObject | undefined;
-    getDisabled: () => boolean;
-};
-export type RovingFocusContextValue = {
-    registerItem: (item: RovingItemRegistration) => () => void;
-    children?: React.ReactNode;
-};

package/out/RovingFocus/types.luau

@@ -1,2 +0,0 @@
--- Compiled with roblox-ts v3.0.0
-return nil

package/out/internals/guiSelection.d.ts

@@ -1,3 +0,0 @@
-export declare const UserInputService: UserInputService;
-export declare function getSelectedGuiObject(): GuiObject | undefined;
-export declare function setSelectedGuiObject(guiObject: GuiObject | undefined): void;

package/out/internals/guiSelection.luau

@@ -1,15 +0,0 @@
--- Compiled with roblox-ts v3.0.0
-local TS = _G[script]
-local GuiService = TS.import(script, script.Parent.Parent, "FocusScope", "focusManager").GuiService
-local UserInputService = game:GetService("UserInputService")
-local function getSelectedGuiObject()
-	return GuiService.SelectedObject
-end
-local function setSelectedGuiObject(guiObject)
-	GuiService.SelectedObject = guiObject
-end
-return {
-	getSelectedGuiObject = getSelectedGuiObject,
-	setSelectedGuiObject = setSelectedGuiObject,
-	UserInputService = UserInputService,
-}