Function useGridState

packages/react-stately/src/grid/useGridState.ts:40–136

(
  props: GridStateOptions<T, C>
)

 * focusable child if applicable.
 */
export function useGridState<T extends object, C extends IGridCollection<T>>(
  props: GridStateOptions<T, C>
): GridState<T, C> {
  let {collection, focusMode} = props;
  // eslint-disable-next-line react-hooks/rules-of-hooks
  let selectionState = props.UNSAFE_selectionState || useMultipleSelectionState(props);
  let disabledKeys = useMemo(
    () => (props.disabledKeys ? new Set(props.disabledKeys) : new Set<Key>()),
    [props.disabledKeys]
  );

  let setFocusedKey = selectionState.setFocusedKey;
  selectionState.setFocusedKey = (key, child) => {
    // If focusMode is cell and an item is focused, focus a child cell instead.
    if (focusMode === 'cell' && key != null) {
      let item = collection.getItem(key);
      if (item?.type === 'item') {
        let children = getChildNodes(item, collection);
        if (child === 'last') {
          key = getLastItem(children)?.key ?? null;
        } else {
          key = getFirstItem(children)?.key ?? null;
        }
      }
    }

    setFocusedKey(key, child);
  };

  let selectionManager = useMemo(
    () => new SelectionManager(collection, selectionState),
    [collection, selectionState]
  );

  // Reset focused key if that item is deleted from the collection.
  const cachedCollection = useRef<C | null>(null);
  useEffect(() => {
    if (
      selectionState.focusedKey != null &&
      cachedCollection.current &&
      !collection.getItem(selectionState.focusedKey)
    ) {
      const node = cachedCollection.current.getItem(selectionState.focusedKey);
      const parentNode =
        node?.parentKey != null &&
        (node.type === 'cell' || node.type === 'rowheader' || node.type === 'column')
          ? cachedCollection.current.getItem(node.parentKey)
          : node;
      if (!parentNode) {
        selectionState.setFocusedKey(null);
        return;
      }
      const cachedRows = cachedCollection.current.rows;
      const rows = collection.rows;
      const diff = cachedRows.length - rows.length;
      let index = Math.min(
        diff > 1 ? Math.max(parentNode.index - diff + 1, 0) : parentNode.index,
        rows.length - 1