@lumx/react 4.17.1-alpha.2 → 4.17.1-alpha.3

package/_internal/utils/moving-focus/constants.d.ts

@@ -0,0 +1,19 @@
+//#region src/utils/moving-focus/constants.d.ts
+declare const LOOP_AROUND_TYPES: {
+  /**
+   * Will continue navigation to the next row or column and loop back to the start
+   * when the last tab stop is reached
+   */
+  readonly nextLoop: "next-loop";
+  /**
+   * Will continue navigation to the next row or column until
+   * the last tab stop is reached
+   */
+  readonly nextEnd: "next-end";
+  /**
+   * Will loop within the current row or column
+   */
+  readonly inside: "inside";
+};
+//#endregion
+export { LOOP_AROUND_TYPES };

package/_internal/utils/moving-focus/constants.js

@@ -0,0 +1,25 @@
+//#region src/utils/moving-focus/constants.ts
+var LOOP_AROUND_TYPES = {
+	/**
+	* Will continue navigation to the next row or column and loop back to the start
+	* when the last tab stop is reached
+	*/
+	nextLoop: "next-loop",
+	/**
+	* Will continue navigation to the next row or column until
+	* the last tab stop is reached
+	*/
+	nextEnd: "next-end",
+	/**
+	* Will loop within the current row or column
+	*/
+	inside: "inside"
+};
+var CELL_SEARCH_DIRECTION = {
+	/** Look ahead of the given position */
+	asc: "asc",
+	/** Look before the given position */
+	desc: "desc"
+};
+//#endregion
+export { CELL_SEARCH_DIRECTION, LOOP_AROUND_TYPES };

package/_internal/utils/moving-focus/ducks/keyboard-navigation.js

@@ -0,0 +1,453 @@
+import { createGridMap } from "../utils/createGridMap.js";
+import { tabStopIsEnabled } from "../utils/tabStopIsEnabled.js";
+import { LOOP_AROUND_TYPES } from "../constants.js";
+import { getCell } from "../utils/getCell.js";
+import { getCellCoordinates } from "../utils/getCellCoordinates.js";
+import { shouldLoopListVertically } from "../utils/shouldLoopListVertically.js";
+import { shouldLoopListHorizontally } from "../utils/shouldLoopListHorizontally.js";
+import findLast from "lodash/findLast.js";
+import isNil from "lodash/isNil.js";
+import find from "lodash/find.js";
+import findLastIndex from "lodash/findLastIndex.js";
+//#region src/utils/moving-focus/ducks/keyboard-navigation.ts
+var VERTICAL_NAV_KEYS = [
+	"ArrowUp",
+	"ArrowDown",
+	"Home",
+	"End"
+];
+var HORIZONTAL_NAV_KEYS = [
+	"ArrowLeft",
+	"ArrowRight",
+	"Home",
+	"End"
+];
+var NAV_KEYS = {
+	both: [...HORIZONTAL_NAV_KEYS, ...VERTICAL_NAV_KEYS],
+	vertical: VERTICAL_NAV_KEYS,
+	horizontal: HORIZONTAL_NAV_KEYS
+};
+var MOVES = {
+	NEXT(state, _, index) {
+		for (let i = index + 1; i < state.tabStops.length; ++i) {
+			const tabStop = state.tabStops[i];
+			if (!tabStop.disabled) return {
+				...state,
+				allowFocusing: true,
+				selectedId: tabStop.id
+			};
+		}
+		return state;
+	},
+	PREVIOUS(state, _, index) {
+		for (let i = index - 1; i >= 0; --i) {
+			const tabStop = state.tabStops[i];
+			if (!tabStop.disabled) return {
+				...state,
+				allowFocusing: true,
+				selectedId: tabStop.id
+			};
+		}
+		return state;
+	},
+	NEXT_ROW(state, currentTabStop) {
+		const currentRowKey = currentTabStop.rowKey;
+		if (isNil(currentRowKey)) return state;
+		const gridMap = state.gridMap || createGridMap(state.tabStops);
+		const cellCoordinates = getCellCoordinates(gridMap, currentTabStop);
+		if (!cellCoordinates) return state;
+		const { rowIndex, columnOffset } = cellCoordinates;
+		/** First try to get the next cell in the current column */
+		let tabStop = getCell(gridMap, {
+			row: {
+				from: rowIndex + 1,
+				direction: "asc"
+			},
+			col: columnOffset
+		});
+		if (!tabStop) switch (state.loopAround.col) {
+			/**
+			* If columns are configured to be looped inside,
+			* get the first enabled cell of the current column
+			*/
+			case LOOP_AROUND_TYPES.inside:
+				tabStop = getCell(gridMap, {
+					col: columnOffset,
+					row: {
+						from: 0,
+						direction: "asc"
+					}
+				});
+				break;
+			/**
+			* If columns are configured to be go to the next,
+			* search for the next enabled cell from the next column
+			*/
+			case LOOP_AROUND_TYPES.nextEnd:
+			case LOOP_AROUND_TYPES.nextLoop:
+			default:
+				tabStop = getCell(gridMap, {
+					row: {
+						from: 0,
+						direction: "asc"
+					},
+					col: {
+						from: columnOffset + 1,
+						direction: "asc"
+					}
+				});
+				break;
+		}
+		/**
+		* If still none is found and the columns are configured to loop
+		* search starting from the start
+		*/
+		if (!tabStop && state.loopAround.col === LOOP_AROUND_TYPES.nextLoop) tabStop = getCell(gridMap, {
+			row: {
+				from: 0,
+				direction: "asc"
+			},
+			col: {
+				from: 0,
+				direction: "asc"
+			}
+		});
+		if (tabStop) return {
+			...state,
+			allowFocusing: true,
+			selectedId: tabStop.id,
+			gridMap
+		};
+		return {
+			...state,
+			allowFocusing: true,
+			gridMap
+		};
+	},
+	PREVIOUS_ROW(state, currentTabStop) {
+		const currentRowKey = currentTabStop.rowKey;
+		if (isNil(currentRowKey)) return state;
+		const gridMap = state.gridMap || createGridMap(state.tabStops);
+		const cellCoordinates = getCellCoordinates(gridMap, currentTabStop);
+		if (!cellCoordinates) return state;
+		const { rowIndex, columnOffset } = cellCoordinates;
+		const previousRow = rowIndex - 1;
+		let tabStop;
+		/** Search for the previous enabled cell in the current column */
+		if (previousRow >= 0) tabStop = getCell(gridMap, {
+			row: {
+				from: previousRow,
+				direction: "desc"
+			},
+			col: columnOffset
+		});
+		if (!tabStop) switch (state.loopAround.col) {
+			/**
+			* If columns are configured to be looped inside,
+			* get the last enabled cell of the current column
+			*/
+			case LOOP_AROUND_TYPES.inside:
+				tabStop = getCell(gridMap, {
+					col: columnOffset,
+					row: {
+						from: -1,
+						direction: "desc"
+					}
+				});
+				break;
+			/**
+			* If columns are configured to be go to the previous,
+			* search for the last enabled cell from the previous column
+			*/
+			case LOOP_AROUND_TYPES.nextEnd:
+			case LOOP_AROUND_TYPES.nextLoop:
+			default: if (columnOffset - 1 >= 0) {
+				tabStop = getCell(gridMap, {
+					row: {
+						from: -1,
+						direction: "desc"
+					},
+					col: {
+						from: columnOffset - 1,
+						direction: "desc"
+					}
+				});
+				break;
+			}
+		}
+		/**
+		* If still none is found and the columns are configured to loop
+		* search starting from the end
+		*/
+		if (!tabStop && state.loopAround.col === LOOP_AROUND_TYPES.nextLoop) tabStop = getCell(gridMap, {
+			row: {
+				from: -1,
+				direction: "desc"
+			},
+			col: {
+				from: -1,
+				direction: "desc"
+			}
+		});
+		if (tabStop) return {
+			...state,
+			allowFocusing: true,
+			selectedId: tabStop.id,
+			gridMap
+		};
+		return {
+			...state,
+			allowFocusing: true,
+			gridMap
+		};
+	},
+	VERY_FIRST(state) {
+		const tabStop = state.tabStops.find(tabStopIsEnabled);
+		if (tabStop) return {
+			...state,
+			allowFocusing: true,
+			selectedId: tabStop.id
+		};
+		return state;
+	},
+	VERY_LAST(state) {
+		const tabStop = findLast(state.tabStops, tabStopIsEnabled);
+		if (tabStop) return {
+			...state,
+			allowFocusing: true,
+			selectedId: tabStop.id
+		};
+		return state;
+	},
+	NEXT_COLUMN(state, currentTabStop, index) {
+		const currentRowKey = currentTabStop.rowKey;
+		if (isNil(currentRowKey)) return state;
+		const gridMap = state.gridMap || createGridMap(state.tabStops);
+		const cellCoordinates = getCellCoordinates(gridMap, currentTabStop);
+		if (!cellCoordinates) return state;
+		const { rowIndex, columnOffset } = cellCoordinates;
+		let tabStop = getCell(gridMap, {
+			row: rowIndex,
+			col: {
+				from: columnOffset + 1,
+				direction: "asc"
+			}
+		});
+		if (!tabStop) switch (state.loopAround.row) {
+			/**
+			* If rows are configured to be looped inside,
+			* get the first enabled cell of the current rows
+			*/
+			case LOOP_AROUND_TYPES.inside:
+				tabStop = getCell(gridMap, {
+					row: rowIndex,
+					col: {
+						from: 0,
+						direction: "asc"
+					}
+				});
+				break;
+			/**
+			* If rows are configured to be go to the next,
+			* search for the next enabled cell from the next row
+			*/
+			case LOOP_AROUND_TYPES.nextEnd:
+			case LOOP_AROUND_TYPES.nextLoop:
+			default:
+				tabStop = find(state.tabStops, tabStopIsEnabled, index + 1);
+				break;
+		}
+		/**
+		* If still none is found and the row are configured to loop
+		* search starting from the start
+		*/
+		if (!tabStop && state.loopAround.row === LOOP_AROUND_TYPES.nextLoop) tabStop = find(state.tabStops, tabStopIsEnabled);
+		return {
+			...state,
+			allowFocusing: true,
+			selectedId: tabStop?.id || state.selectedId,
+			gridMap
+		};
+	},
+	PREVIOUS_COLUMN(state, currentTabStop, index) {
+		const currentRowKey = currentTabStop.rowKey;
+		if (isNil(currentRowKey)) return state;
+		const gridMap = state.gridMap || createGridMap(state.tabStops);
+		const cellCoordinates = getCellCoordinates(gridMap, currentTabStop);
+		if (!cellCoordinates) return state;
+		const { rowIndex, columnOffset } = cellCoordinates;
+		const previousColumn = columnOffset - 1;
+		let tabStop;
+		if (previousColumn >= 0) tabStop = getCell(gridMap, {
+			row: rowIndex,
+			col: {
+				from: previousColumn,
+				direction: "desc"
+			}
+		});
+		if (!tabStop) switch (state.loopAround.row) {
+			/**
+			* If rows are configured to be looped inside,
+			* get the last enabled cell of the current row
+			*/
+			case LOOP_AROUND_TYPES.inside:
+				tabStop = getCell(gridMap, {
+					row: rowIndex,
+					col: {
+						from: -1,
+						direction: "desc"
+					}
+				});
+				break;
+			/**
+			* If rows are configured to be go to the next,
+			* search for the previous enabled cell from the previous row
+			*/
+			case LOOP_AROUND_TYPES.nextEnd:
+			case LOOP_AROUND_TYPES.nextLoop:
+			default:
+				if (index - 1 >= 0) tabStop = findLast(state.tabStops, tabStopIsEnabled, index - 1);
+				break;
+		}
+		/**
+		* If still none is found and the rows are configured to loop
+		* search starting from the end
+		*/
+		if (!tabStop && state.loopAround.row === LOOP_AROUND_TYPES.nextLoop) tabStop = findLast(state.tabStops, tabStopIsEnabled);
+		return {
+			...state,
+			allowFocusing: true,
+			selectedId: tabStop?.id || state.selectedId,
+			gridMap
+		};
+	},
+	FIRST_IN_COLUMN(state, currentTabStop) {
+		const currentRowKey = currentTabStop.rowKey;
+		if (isNil(currentRowKey)) return state;
+		const gridMap = state.gridMap || createGridMap(state.tabStops);
+		const cellCoordinates = getCellCoordinates(gridMap, currentTabStop);
+		if (!cellCoordinates) return state;
+		const { columnOffset } = cellCoordinates;
+		const tabStop = getCell(gridMap, {
+			col: columnOffset,
+			row: {
+				from: 0,
+				direction: "asc"
+			}
+		});
+		return {
+			...state,
+			allowFocusing: true,
+			selectedId: tabStop?.id || state.selectedId,
+			gridMap
+		};
+	},
+	LAST_IN_COLUMN(state, currentTabStop) {
+		const currentRowKey = currentTabStop.rowKey;
+		if (isNil(currentRowKey)) return state;
+		const gridMap = state.gridMap || createGridMap(state.tabStops);
+		const cellCoordinates = getCellCoordinates(gridMap, currentTabStop);
+		if (!cellCoordinates) return state;
+		const { columnOffset } = cellCoordinates;
+		const tabStop = getCell(gridMap, {
+			col: columnOffset,
+			row: {
+				from: -1,
+				direction: "desc"
+			}
+		});
+		return {
+			...state,
+			allowFocusing: true,
+			selectedId: tabStop?.id || state.selectedId,
+			gridMap
+		};
+	},
+	FIRST_IN_ROW(state, currentTabStop) {
+		const currentRowKey = currentTabStop.rowKey;
+		if (isNil(currentRowKey)) return state;
+		const gridMap = state.gridMap || createGridMap(state.tabStops);
+		const cellCoordinates = getCellCoordinates(gridMap, currentTabStop);
+		if (!cellCoordinates) return state;
+		const { rowIndex } = cellCoordinates;
+		const tabStop = getCell(gridMap, {
+			row: rowIndex,
+			col: {
+				from: 0,
+				direction: "asc"
+			}
+		});
+		return {
+			...state,
+			allowFocusing: true,
+			selectedId: tabStop?.id || state.selectedId,
+			gridMap
+		};
+	},
+	LAST_IN_ROW(state, currentTabStop) {
+		const currentRowKey = currentTabStop.rowKey;
+		if (isNil(currentRowKey)) return state;
+		const gridMap = state.gridMap || createGridMap(state.tabStops);
+		const cellCoordinates = getCellCoordinates(gridMap, currentTabStop);
+		if (!cellCoordinates) return state;
+		const { rowIndex } = cellCoordinates;
+		const tabStop = getCell(gridMap, {
+			row: rowIndex,
+			col: {
+				from: -1,
+				direction: "desc"
+			}
+		});
+		return {
+			...state,
+			allowFocusing: true,
+			selectedId: tabStop?.id || state.selectedId,
+			gridMap
+		};
+	}
+};
+/** Handle `KEY_NAV` action to update */
+var KEY_NAV = (state, action) => {
+	const { id = state.selectedId || state.tabStops[0]?.id, key, ctrlKey } = action.payload;
+	const index = state.tabStops.findIndex((tabStop) => tabStop.id === id);
+	if (index === -1) return state;
+	const currentTabStop = state.tabStops[index];
+	if (currentTabStop.disabled) return state;
+	const isGrid = currentTabStop.rowKey !== null;
+	const isFirst = index === state.tabStops.findIndex(tabStopIsEnabled);
+	const isLast = index === findLastIndex(state.tabStops, tabStopIsEnabled);
+	let navigation = null;
+	switch (key) {
+		case "ArrowLeft":
+			if (isGrid) navigation = "PREVIOUS_COLUMN";
+			else if (state.direction === "horizontal" || state.direction === "both") navigation = shouldLoopListHorizontally(state.direction, state.loopAround) && isFirst ? "VERY_LAST" : "PREVIOUS";
+			break;
+		case "ArrowRight":
+			if (isGrid) navigation = "NEXT_COLUMN";
+			else if (state.direction === "horizontal" || state.direction === "both") navigation = shouldLoopListHorizontally(state.direction, state.loopAround) && isLast ? "VERY_FIRST" : "NEXT";
+			break;
+		case "ArrowUp":
+			if (isGrid) navigation = "PREVIOUS_ROW";
+			else if (state.direction === "vertical" || state.direction === "both") navigation = shouldLoopListVertically(state.direction, state.loopAround) && isFirst ? "VERY_LAST" : "PREVIOUS";
+			break;
+		case "ArrowDown":
+			if (isGrid) navigation = "NEXT_ROW";
+			else if (state.direction === "vertical" || state.direction === "both") navigation = shouldLoopListVertically(state.direction, state.loopAround) && isLast ? "VERY_FIRST" : "NEXT";
+			break;
+		case "Home":
+			if (isGrid && !ctrlKey) navigation = state.gridJumpToShortcutDirection === "vertical" ? "FIRST_IN_COLUMN" : "FIRST_IN_ROW";
+			else navigation = "VERY_FIRST";
+			break;
+		case "End":
+			if (isGrid && !ctrlKey) navigation = state.gridJumpToShortcutDirection === "vertical" ? "LAST_IN_COLUMN" : "LAST_IN_ROW";
+			else navigation = "VERY_LAST";
+			break;
+	}
+	if (!navigation) return state;
+	return {
+		...MOVES[navigation](state, currentTabStop, index),
+		isUsingKeyboard: true
+	};
+};
+//#endregion
+export { KEY_NAV, NAV_KEYS };

package/_internal/utils/moving-focus/ducks/slice.js

@@ -0,0 +1,50 @@
+import { tabStopIsEnabled } from "../utils/tabStopIsEnabled.js";
+import { buildLoopAroundObject } from "../utils/buildLoopAroundObject.js";
+import { KEY_NAV } from "./keyboard-navigation.js";
+import { REGISTER_TAB_STOP, RESET_SELECTED_TAB_STOP, SELECT_TAB_STOP, SET_ALLOW_FOCUSING, UNREGISTER_TAB_STOP, UPDATE_TAB_STOP } from "./tab-stop.js";
+import findLast from "lodash/findLast.js";
+//#region src/utils/moving-focus/ducks/slice.ts
+var INITIAL_STATE = {
+	selectedId: null,
+	allowFocusing: false,
+	tabStops: [],
+	direction: "horizontal",
+	loopAround: buildLoopAroundObject(false),
+	gridMap: null,
+	defaultSelectedId: null,
+	autofocus: void 0,
+	isUsingKeyboard: false
+};
+var OPTIONS_UPDATED = (state, action) => {
+	const { autofocus } = action.payload;
+	let { selectedId, allowFocusing } = state;
+	if (!state.autofocus && autofocus) {
+		if (autofocus === "first") selectedId = state.tabStops.find(tabStopIsEnabled)?.id || null;
+		else if (autofocus === "last") selectedId = findLast(state.tabStops, tabStopIsEnabled)?.id || null;
+		allowFocusing = true;
+	}
+	return {
+		...state,
+		...action.payload,
+		selectedId,
+		allowFocusing: action.payload.allowFocusing || allowFocusing,
+		loopAround: buildLoopAroundObject(action.payload.loopAround)
+	};
+};
+/** Reducers for each action type: */
+var REDUCERS = {
+	REGISTER_TAB_STOP,
+	UNREGISTER_TAB_STOP,
+	UPDATE_TAB_STOP,
+	SELECT_TAB_STOP,
+	OPTIONS_UPDATED,
+	KEY_NAV,
+	SET_ALLOW_FOCUSING,
+	RESET_SELECTED_TAB_STOP
+};
+/** Main reducer */
+var reducer = (state, action) => {
+	return REDUCERS[action.type]?.(state, action) || state;
+};
+//#endregion
+export { INITIAL_STATE, reducer };

package/_internal/utils/moving-focus/ducks/tab-stop.js

@@ -0,0 +1,109 @@
+import { tabStopIsEnabled } from "../utils/tabStopIsEnabled.js";
+import findLast from "lodash/findLast.js";
+import findLastIndex from "lodash/findLastIndex.js";
+//#region src/utils/moving-focus/ducks/tab-stop.ts
+/** Determine the updated value for selectedId: */
+var getUpdatedSelectedId = (tabStops, currentSelectedId, defaultSelectedId = null) => {
+	const tabStop = currentSelectedId && tabStops.find((ts) => ts.id === currentSelectedId && !ts.disabled);
+	if (!tabStop) return tabStops.find((ts) => ts.id === defaultSelectedId)?.id || tabStops.find(tabStopIsEnabled)?.id || null;
+	return tabStop?.id || defaultSelectedId;
+};
+/** Handle `REGISTER_TAB_STOP` action registering a new tab stop. */
+var REGISTER_TAB_STOP = (state, action) => {
+	const newTabStop = action.payload;
+	const newTabStopElement = newTabStop.domElementRef.current;
+	if (!newTabStopElement) return state;
+	const insertIndex = findLastIndex(state.tabStops, (tabStop) => {
+		if (tabStop.id === newTabStop.id) return false;
+		return tabStop.domElementRef.current?.compareDocumentPosition(newTabStopElement) === Node.DOCUMENT_POSITION_FOLLOWING;
+	}) + 1;
+	const newTabStops = [...state.tabStops];
+	newTabStops.splice(insertIndex, 0, newTabStop);
+	let { selectedId, allowFocusing } = state;
+	if (state.autofocus === "first" && insertIndex === 0 || state.autofocus === "last" && insertIndex === newTabStops.length - 1 || newTabStop.autofocus) {
+		allowFocusing = true;
+		selectedId = newTabStop.id;
+	}
+	const newSelectedId = newTabStop.id === state.defaultSelectedId && !newTabStop.disabled ? newTabStop.id : getUpdatedSelectedId(newTabStops, selectedId, state.defaultSelectedId);
+	return {
+		...state,
+		/**
+		* If the tab currently being registered is enabled and set as default selected,
+		* set as selected.
+		*
+		*/
+		selectedId: newSelectedId,
+		tabStops: newTabStops,
+		gridMap: null,
+		allowFocusing
+	};
+};
+/** Handle `UNREGISTER_TAB_STOP` action un-registering a new tab stop. */
+var UNREGISTER_TAB_STOP = (state, action) => {
+	const { id } = action.payload;
+	const newTabStops = state.tabStops.filter((tabStop) => tabStop.id !== id);
+	if (newTabStops.length === state.tabStops.length) return state;
+	/** Get the previous enabled tab stop */
+	const previousTabStopIndex = state.tabStops.findIndex((tabStop) => tabStop.id === state.selectedId && tabStopIsEnabled(tabStop));
+	const previousTabStop = previousTabStopIndex - 1 > -1 ? findLast(newTabStops, tabStopIsEnabled, previousTabStopIndex - 1) : void 0;
+	return {
+		...state,
+		/** Set the focus on either the previous tab stop if found or the one set as default */
+		selectedId: getUpdatedSelectedId(newTabStops, state.selectedId, previousTabStop?.id || state.defaultSelectedId),
+		tabStops: newTabStops,
+		gridMap: null
+	};
+};
+/** Handle `UPDATE_TAB_STOP` action updating properties of a tab stop. */
+var UPDATE_TAB_STOP = (state, action) => {
+	const { id, rowKey, disabled } = action.payload;
+	const index = state.tabStops.findIndex((tabStop) => tabStop.id === id);
+	if (index === -1) return state;
+	const tabStop = state.tabStops[index];
+	if (tabStop.disabled === disabled && tabStop.rowKey === rowKey) return state;
+	const newTabStop = {
+		...tabStop,
+		rowKey,
+		disabled
+	};
+	const newTabStops = [...state.tabStops];
+	newTabStops.splice(index, 1, newTabStop);
+	return {
+		...state,
+		selectedId: getUpdatedSelectedId(newTabStops, state.selectedId, state.defaultSelectedId),
+		tabStops: newTabStops,
+		gridMap: null
+	};
+};
+/** Handle `SELECT_TAB_STOP` action selecting a tab stop. */
+var SELECT_TAB_STOP = (state, action) => {
+	const { id, type } = action.payload;
+	const tabStop = state.tabStops.find((ts) => ts.id === id);
+	if (!tabStop || tabStop.disabled) return state;
+	return {
+		...state,
+		allowFocusing: true,
+		selectedId: tabStop.id,
+		isUsingKeyboard: type === "keyboard"
+	};
+};
+var SET_ALLOW_FOCUSING = (state, action) => {
+	return {
+		...state,
+		selectedId: getUpdatedSelectedId(state.tabStops, null, state.defaultSelectedId),
+		allowFocusing: action.payload.allow,
+		isUsingKeyboard: Boolean(action.payload.isKeyboardNavigation)
+	};
+};
+/** Handle `RESET_SELECTED_TAB_STOP` action reseting the selected tab stop. */
+var RESET_SELECTED_TAB_STOP = (state) => {
+	return {
+		...state,
+		allowFocusing: false,
+		selectedId: getUpdatedSelectedId(state.tabStops, null, state.defaultSelectedId),
+		defaultSelectedId: getUpdatedSelectedId(state.tabStops, null, state.defaultSelectedId),
+		isUsingKeyboard: false
+	};
+};
+//#endregion
+export { REGISTER_TAB_STOP, RESET_SELECTED_TAB_STOP, SELECT_TAB_STOP, SET_ALLOW_FOCUSING, UNREGISTER_TAB_STOP, UPDATE_TAB_STOP };

package/_internal/utils/moving-focus/hooks/useRovingTabIndex/index.d.ts

@@ -0,0 +1 @@
+import { useRovingTabIndex } from "./useRovingTabIndex.js";

package/_internal/utils/moving-focus/hooks/useRovingTabIndex/useRovingTabIndex.d.ts

@@ -0,0 +1,19 @@
+import { BaseHookOptions } from "../../types.js";
+import React from "react";
+
+//#region src/utils/moving-focus/hooks/useRovingTabIndex/useRovingTabIndex.d.ts
+/**
+ * A tuple of values to be applied by the containing component for the roving tabindex to work correctly.
+ */
+type Output = [/** The tabIndex value to apply to the tab stop element. */tabIndex: number, /** Whether focus() should be invoked on the tab stop element. */focused: boolean,
+/**
+ * The onKeyDown callback to apply to the tab stop element. If the key press is relevant to the hook then
+ * event.preventDefault() will be invoked on the event.
+ */
+handleKeyDown: (event: React.KeyboardEvent) => void, /** The onClick callback to apply to the tab stop element. */handleClick: () => void];
+/**
+ * Includes the given DOM element in the current roving tabindex.
+ */
+declare const useRovingTabIndex: (...args: BaseHookOptions) => Output;
+//#endregion
+export { useRovingTabIndex };