@lattice-ui/focus 0.1.1 → 0.3.1

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2026 astra-void
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,15 +1,23 @@
 # @lattice-ui/focus
 
-This package is intentionally a skeleton in the current phase.
+Focus and directional navigation primitives for Roblox UI.
 
 ## Current status
 
-- `FocusScope` and `RovingFocusGroup` are no-op placeholders.
-- Public API is kept stable while layer/popper hardening lands first.
+- `RovingFocusGroup` and `RovingFocusItem` provide arrow/Home/End navigation across registered selectable items.
+- `FocusScope` can trap `GuiService.SelectedObject` and restore captured focus on scope teardown.
 
-## Next implementation targets
+## FocusScope behavior
 
-- `FocusScope`: trap + restore behavior for dialog-like surfaces.
-- `RovingFocusGroup`: keyboard/gamepad directional navigation.
-- `GuiService.SelectedObject` + `NextSelection*` graph management.
-- Focus restore flow to trigger elements when scope closes.
+- `active` defaults to `true`.
+- `asChild` keeps caller tree structure; without it, `FocusScope` renders a transparent full-size frame wrapper.
+- When `trapped` is true, outside selections are redirected to:
+  1. last focused selectable object inside the scope, then
+  2. first selectable descendant inside the scope.
+- Nested trapped scopes use stack order; only the top-most active trapped scope redirects focus.
+- When `restoreFocus` is true, captured focus is restored on unmount/deactivation if the target is still valid.
+
+## Known limits
+
+- Trap and restore currently use `GuiService.SelectedObject` only.
+- This phase does not manage `NextSelection*` graph rewrites.

package/out/FocusScope/FocusScope.d.ts

@@ -1,3 +1,3 @@
-import type React from "@rbxts/react";
+import { React } from "@lattice-ui/core";
 import type { FocusScopeProps } from "./types";
-export declare function FocusScope(props: FocusScopeProps): React.ReactNode;
+export declare function FocusScope(props: FocusScopeProps): React.JSX.Element;

package/out/FocusScope/FocusScope.luau

@@ -1,6 +1,194 @@
 -- 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 _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 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
+end
 local function FocusScope(props)
-	return props.children
+	local _condition = props.active
+	if _condition == nil then
+		_condition = true
+	end
+	local active = _condition
+	local trapped = props.trapped == true
+	local shouldRestoreFocus = props.restoreFocus ~= false
+	local scopeIdRef = React.useRef(0)
+	if scopeIdRef.current == 0 then
+		nextScopeId += 1
+		scopeIdRef.current = nextScopeId
+	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 setScopeRoot = React.useCallback(function(instance)
+		local scopeRoot = toGuiObject(instance)
+		scopeRootRef.current = scopeRoot
+		if not scopeRoot then
+			return nil
+		end
+		updateLastFocusedInside()
+		if active and trapped then
+			enforceFocusTrap()
+		end
+	end, { active, enforceFocusTrap, trapped, updateLastFocusedInside })
+	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
+		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
+		end
+	end, { active, enforceFocusTrap, trapped, updateLastFocusedInside })
+	if props.asChild then
+		local child = props.children
+		if not React.isValidElement(child) then
+			error("[FocusScope] `asChild` requires a child element.")
+		end
+		return React.createElement(Slot, {
+			ref = setScopeRoot,
+		}, child)
+	end
+	return React.createElement("frame", {
+		BackgroundTransparency = 1,
+		BorderSizePixel = 0,
+		Position = UDim2.fromScale(0, 0),
+		Size = UDim2.fromScale(1, 1),
+		ref = setScopeRoot,
+	}, props.children)
 end
 return {
 	FocusScope = FocusScope,

package/out/FocusScope/scopeStack.d.ts

@@ -0,0 +1,3 @@
+export declare function registerTrappedScope(scopeId: number): void;
+export declare function unregisterTrappedScope(scopeId: number): void;
+export declare function isTopTrappedScope(scopeId: number): boolean;

package/out/FocusScope/scopeStack.luau

@@ -0,0 +1,43 @@
+-- Compiled with roblox-ts v3.0.0
+local trappedScopeStack = {}
+local function findScopeIndex(scopeId)
+	-- ▼ ReadonlyArray.findIndex ▼
+	local _callback = function(entry)
+		return entry == scopeId
+	end
+	local _result = -1
+	for _i, _v in trappedScopeStack do
+		if _callback(_v, _i - 1, trappedScopeStack) == true then
+			_result = _i - 1
+			break
+		end
+	end
+	-- ▲ ReadonlyArray.findIndex ▲
+	return _result
+end
+local function registerTrappedScope(scopeId)
+	if findScopeIndex(scopeId) >= 0 then
+		return nil
+	end
+	local _scopeId = scopeId
+	table.insert(trappedScopeStack, _scopeId)
+end
+local function unregisterTrappedScope(scopeId)
+	local scopeIndex = findScopeIndex(scopeId)
+	if scopeIndex < 0 then
+		return nil
+	end
+	table.remove(trappedScopeStack, scopeIndex + 1)
+end
+local function isTopTrappedScope(scopeId)
+	if #trappedScopeStack <= 0 then
+		return false
+	end
+	local topScopeId = trappedScopeStack[#trappedScopeStack]
+	return topScopeId == scopeId
+end
+return {
+	registerTrappedScope = registerTrappedScope,
+	unregisterTrappedScope = unregisterTrappedScope,
+	isTopTrappedScope = isTopTrappedScope,
+}

package/out/FocusScope/types.d.ts

@@ -1,5 +1,7 @@
 import type React from "@rbxts/react";
 export type FocusScopeProps = {
+    active?: boolean;
+    asChild?: boolean;
     trapped?: boolean;
     restoreFocus?: boolean;
     children?: React.ReactNode;

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "@lattice-ui/focus",
-  "version": "0.1.1",
+  "version": "0.3.1",
   "private": false,
   "main": "out/init.luau",
   "types": "out/index.d.ts",
+  "files": [
+    "out",
+    "README.md"
+  ],
   "dependencies": {
-    "@lattice-ui/core": "0.1.1"
+    "@lattice-ui/core": "0.3.1"
   },
   "devDependencies": {
     "@rbxts/react": "17.3.7-ts.1",
@@ -17,7 +21,7 @@
   },
   "scripts": {
     "build": "rbxtsc -p tsconfig.json",
-    "watch": "rbxtsc -p tsconfig.json -w",
-    "typecheck": "tsc -p tsconfig.typecheck.json"
+    "typecheck": "tsc -p tsconfig.typecheck.json",
+    "watch": "rbxtsc -p tsconfig.json -w"
   }
 }

package/src/FocusScope/FocusScope.tsx

@@ -1,6 +0,0 @@
-import type React from "@rbxts/react";
-import type { FocusScopeProps } from "./types";
-
-export function FocusScope(props: FocusScopeProps): React.ReactNode {
-  return props.children;
-}

package/src/FocusScope/focusManager.ts

@@ -1,11 +0,0 @@
-export const GuiService = game.GetService("GuiService");
-
-export type FocusSnapshot = GuiObject | undefined;
-
-export function captureFocus(): FocusSnapshot {
-  return GuiService.SelectedObject;
-}
-
-export function restoreFocus(snapshot: FocusSnapshot) {
-  GuiService.SelectedObject = snapshot;
-}

package/src/FocusScope/types.ts

@@ -1,7 +0,0 @@
-import type React from "@rbxts/react";
-
-export type FocusScopeProps = {
-  trapped?: boolean;
-  restoreFocus?: boolean;
-  children?: React.ReactNode;
-};

package/src/RovingFocus/RovingFocusGroup.tsx

@@ -1,174 +0,0 @@
-import { React } from "@lattice-ui/core";
-import { getSelectedGuiObject, setSelectedGuiObject, UserInputService } from "../internals/guiSelection";
-import { RovingFocusProvider } from "./context";
-import { getFirstEnabledRovingIndex, getLastEnabledRovingIndex, getNextRovingIndex } from "./roving";
-import type { RovingDirection, RovingFocusGroupProps, RovingItemRegistration, RovingOrientation } from "./types";
-
-function findCurrentIndex(items: Array<RovingItemRegistration>, selectedObject: GuiObject | undefined) {
-  if (!selectedObject) {
-    return -1;
-  }
-
-  return items.findIndex((item) => {
-    const node = item.getNode();
-    if (!node) {
-      return false;
-    }
-
-    return selectedObject === node || selectedObject.IsDescendantOf(node);
-  });
-}
-
-function isItemDisabled(items: Array<RovingItemRegistration>, index: number) {
-  const item = items[index];
-  if (!item) {
-    return true;
-  }
-
-  return item.getDisabled();
-}
-
-function focusItem(items: Array<RovingItemRegistration>, index: number) {
-  const item = items[index];
-  if (!item) {
-    return;
-  }
-
-  if (item.getDisabled()) {
-    return;
-  }
-
-  const node = item.getNode();
-  if (!node || !node.Selectable) {
-    return;
-  }
-
-  setSelectedGuiObject(node);
-}
-
-function resolveArrowDirection(keyCode: Enum.KeyCode, orientation: RovingOrientation): RovingDirection | undefined {
-  if ((orientation === "vertical" || orientation === "both") && keyCode === Enum.KeyCode.Up) {
-    return "prev";
-  }
-
-  if ((orientation === "vertical" || orientation === "both") && keyCode === Enum.KeyCode.Down) {
-    return "next";
-  }
-
-  if ((orientation === "horizontal" || orientation === "both") && keyCode === Enum.KeyCode.Left) {
-    return "prev";
-  }
-
-  if ((orientation === "horizontal" || orientation === "both") && keyCode === Enum.KeyCode.Right) {
-    return "next";
-  }
-
-  return undefined;
-}
-
-export function RovingFocusGroup(props: RovingFocusGroupProps) {
-  const loop = props.loop ?? true;
-  const orientation = props.orientation ?? "both";
-  const active = props.active ?? true;
-  const autoFocus = props.autoFocus ?? "none";
-
-  const itemEntriesRef = React.useRef<Array<RovingItemRegistration>>([]);
-  const [revision, setRevision] = React.useState(0);
-
-  const registerItem = React.useCallback((item: RovingItemRegistration) => {
-    itemEntriesRef.current.push(item);
-    setRevision((value) => value + 1);
-
-    return () => {
-      const index = itemEntriesRef.current.findIndex((entry) => entry.id === item.id);
-      if (index >= 0) {
-        itemEntriesRef.current.remove(index);
-        setRevision((value) => value + 1);
-      }
-    };
-  }, []);
-
-  React.useEffect(() => {
-    if (!active || autoFocus !== "first") {
-      return;
-    }
-
-    const items = itemEntriesRef.current;
-    const firstEnabledIndex = getFirstEnabledRovingIndex(items.size(), (index) => isItemDisabled(items, index));
-    if (firstEnabledIndex >= 0) {
-      focusItem(items, firstEnabledIndex);
-    }
-  }, [active, autoFocus, revision]);
-
-  React.useEffect(() => {
-    if (!active) {
-      return;
-    }
-
-    const connection = UserInputService.InputBegan.Connect((inputObject, gameProcessedEvent) => {
-      if (gameProcessedEvent) {
-        return;
-      }
-
-      const keyCode = inputObject.KeyCode;
-      const isHomeKey = keyCode === Enum.KeyCode.Home;
-      const isEndKey = keyCode === Enum.KeyCode.End;
-      const direction = resolveArrowDirection(keyCode, orientation);
-      if (!isHomeKey && !isEndKey && !direction) {
-        return;
-      }
-
-      const items = itemEntriesRef.current;
-      const itemCount = items.size();
-      if (itemCount <= 0) {
-        return;
-      }
-
-      const selectedObject = getSelectedGuiObject();
-      const currentIndex = findCurrentIndex(items, selectedObject);
-      if (currentIndex < 0) {
-        return;
-      }
-
-      if (isHomeKey) {
-        const firstEnabledIndex = getFirstEnabledRovingIndex(itemCount, (index) => isItemDisabled(items, index));
-        if (firstEnabledIndex >= 0) {
-          focusItem(items, firstEnabledIndex);
-        }
-        return;
-      }
-
-      if (isEndKey) {
-        const lastEnabledIndex = getLastEnabledRovingIndex(itemCount, (index) => isItemDisabled(items, index));
-        if (lastEnabledIndex >= 0) {
-          focusItem(items, lastEnabledIndex);
-        }
-        return;
-      }
-
-      if (!direction) {
-        return;
-      }
-
-      const nextIndex = getNextRovingIndex(currentIndex, itemCount, direction, loop, (index) =>
-        isItemDisabled(items, index),
-      );
-      if (nextIndex >= 0) {
-        focusItem(items, nextIndex);
-      }
-    });
-
-    return () => {
-      connection.Disconnect();
-    };
-  }, [active, loop, orientation]);
-
-  const contextValue = React.useMemo(
-    () => ({
-      registerItem,
-    }),
-    [registerItem],
-  );
-
-  return <RovingFocusProvider value={contextValue}>{props.children}</RovingFocusProvider>;
-}

package/src/RovingFocus/RovingFocusItem.tsx

@@ -1,71 +0,0 @@
-import { React, Slot } from "@lattice-ui/core";
-import { useRovingFocusContext } from "./context";
-import type { RovingFocusItemProps } from "./types";
-
-let nextRovingItemId = 0;
-
-function toGuiObject(instance: Instance | undefined) {
-  if (!instance || !instance.IsA("GuiObject")) {
-    return undefined;
-  }
-
-  return instance;
-}
-
-export function RovingFocusItem(props: RovingFocusItemProps) {
-  const rovingFocusContext = useRovingFocusContext();
-  const itemRef = React.useRef<GuiObject>();
-  const disabledRef = React.useRef(props.disabled === true);
-
-  React.useEffect(() => {
-    disabledRef.current = props.disabled === true;
-  }, [props.disabled]);
-
-  const itemIdRef = React.useRef(0);
-  if (itemIdRef.current === 0) {
-    nextRovingItemId += 1;
-    itemIdRef.current = nextRovingItemId;
-  }
-
-  React.useEffect(() => {
-    return rovingFocusContext.registerItem({
-      id: itemIdRef.current,
-      getNode: () => itemRef.current,
-      getDisabled: () => disabledRef.current,
-    });
-  }, [rovingFocusContext]);
-
-  const setItemRef = React.useCallback((instance: Instance | undefined) => {
-    itemRef.current = toGuiObject(instance);
-  }, []);
-
-  if (props.asChild) {
-    const child = props.children;
-    if (!child) {
-      error("[RovingFocusItem] `asChild` requires a child element.");
-    }
-
-    return (
-      <Slot Active={props.disabled !== true} Selectable={props.disabled !== true} ref={setItemRef}>
-        {child}
-      </Slot>
-    );
-  }
-
-  return (
-    <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}
-    </textbutton>
-  );
-}

package/src/RovingFocus/context.ts

@@ -1,6 +0,0 @@
-import { createStrictContext } from "@lattice-ui/core";
-import type { RovingFocusContextValue } from "./types";
-
-const [RovingFocusProvider, useRovingFocusContext] = createStrictContext<RovingFocusContextValue>("RovingFocusGroup");
-
-export { RovingFocusProvider, useRovingFocusContext };

package/src/RovingFocus/roving.ts

@@ -1,62 +0,0 @@
-import type { RovingDirection } from "./types";
-
-function getDirectionDelta(direction: RovingDirection) {
-  return direction === "next" ? 1 : -1;
-}
-
-export function getNextRovingIndex(
-  currentIndex: number,
-  itemCount: number,
-  direction: RovingDirection,
-  loop: boolean,
-  isDisabled?: (index: number) => boolean,
-) {
-  if (itemCount <= 0) {
-    return -1;
-  }
-
-  // Keep focus unchanged when the current index is outside this group.
-  if (currentIndex < 0 || currentIndex >= itemCount) {
-    return currentIndex;
-  }
-
-  const delta = getDirectionDelta(direction);
-  let candidate = currentIndex;
-
-  for (let attempts = 0; attempts < itemCount; attempts++) {
-    candidate += delta;
-
-    if (candidate < 0 || candidate >= itemCount) {
-      if (!loop) {
-        return currentIndex;
-      }
-      candidate = direction === "next" ? 0 : itemCount - 1;
-    }
-
-    if (!isDisabled || !isDisabled(candidate)) {
-      return candidate;
-    }
-  }
-
-  return currentIndex;
-}
-
-export function getFirstEnabledRovingIndex(itemCount: number, isDisabled?: (index: number) => boolean) {
-  for (let index = 0; index < itemCount; index++) {
-    if (!isDisabled || !isDisabled(index)) {
-      return index;
-    }
-  }
-
-  return -1;
-}
-
-export function getLastEnabledRovingIndex(itemCount: number, isDisabled?: (index: number) => boolean) {
-  for (let index = itemCount - 1; index >= 0; index--) {
-    if (!isDisabled || !isDisabled(index)) {
-      return index;
-    }
-  }
-
-  return -1;
-}

package/src/RovingFocus/types.ts

@@ -1,30 +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/src/index.ts

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

package/src/internals/guiSelection.ts

@@ -1,11 +0,0 @@
-import { GuiService } from "../FocusScope/focusManager";
-
-export const UserInputService = game.GetService("UserInputService");
-
-export function getSelectedGuiObject() {
-  return GuiService.SelectedObject;
-}
-
-export function setSelectedGuiObject(guiObject: GuiObject | undefined) {
-  GuiService.SelectedObject = guiObject;
-}

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "rootDir": "src",
-    "outDir": "out",
-    "declaration": true,
-    "typeRoots": [
-      "./node_modules/@rbxts",
-      "../../node_modules/@rbxts",
-      "./node_modules/@lattice-ui",
-      "../../node_modules/@lattice-ui"
-    ],
-    "types": ["types", "compiler-types"]
-  },
-  "include": ["src"]
-}

package/tsconfig.typecheck.json

@@ -1,25 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "noEmit": true,
-    "baseUrl": "..",
-    "rootDir": "..",
-    "paths": {
-      "@lattice-ui/checkbox": ["checkbox/src/index.ts"],
-      "@lattice-ui/core": ["core/src/index.ts"],
-      "@lattice-ui/dialog": ["dialog/src/index.ts"],
-      "@lattice-ui/focus": ["focus/src/index.ts"],
-      "@lattice-ui/layer": ["layer/src/index.ts"],
-      "@lattice-ui/menu": ["menu/src/index.ts"],
-      "@lattice-ui/popover": ["popover/src/index.ts"],
-      "@lattice-ui/popper": ["popper/src/index.ts"],
-      "@lattice-ui/radio-group": ["radio-group/src/index.ts"],
-      "@lattice-ui/style": ["style/src/index.ts"],
-      "@lattice-ui/switch": ["switch/src/index.ts"],
-      "@lattice-ui/system": ["system/src/index.ts"],
-      "@lattice-ui/tabs": ["tabs/src/index.ts"],
-      "@lattice-ui/toggle-group": ["toggle-group/src/index.ts"],
-      "@lattice-ui/tooltip": ["tooltip/src/index.ts"]
-    }
-  }
-}