es-grid-template 1.9.96 → 1.9.98

package/es/table-component/body/TableBodyCellEdit.js

@@ -1,4 +1,4 @@
-import { notifyArrowRowFocus } from "../../grid-component/hooks/rowFocus";
+import { focusArrowRow, notifyArrowRowFocus } from "../../grid-component/hooks/rowFocus";
 import Space from "rc-master-ui/es/space";
 import Command from "../components/command/Command";
 import { addRowsDown, addRowsDownWithCtrl, addRowsUp, addRowsUpWithCtrl, findFirst, flattenArray, flattenData, getColIdsBetween, getCommonPinningStyles, getDragRightData, getEditType, getFormat,
@@ -819,77 +819,26 @@ const TableBodyCellEdit = props => {
       }
       return;
     }
-    if (e.key === 'ArrowDown') {
-      // e.preventDefault()
-      // e.stopPropagation()
-
-      const nextRow = table.getRowModel().rows[rowNumber + 1];
-      if (nextRow) {
-        const nextRowId = nextRow.id;
-        setFocusedCell?.({
-          rowId: nextRowId,
-          colId
-        });
-        notifyArrowRowFocus(table.getRow(nextRowId).original, 'arrowDown', selectionSettings?.useArrow, rowFocus);
-        setStartCell?.({
-          rowId: nextRowId,
-          colId
-        });
-        setEndCell?.({
-          rowId: nextRowId,
-          colId
-        });
-        setRangeState?.(getSelectedCellMatrix(table, {
-          rowId: nextRowId,
-          colId
-        }, {
-          rowId: nextRowId,
-          colId
-        }));
-
-        // columnVirtualizer.scrollToIndex(nextCol.getIndex(), { align: 'center' })
-        // rowVirtualizer.scrollToIndex(nextRow.index, { align: 'center' })
-
-        const row = document.querySelector(`.ui-rc-grid-row[data-row-key="${nextRowId}"]`);
-        const cellFocus = row?.querySelector('.ui-rc-grid-cell:not(.ui-rc-grid-cell-selection)');
-        if (cellFocus) {
-          cellFocus.focus();
-        }
-      }
-      return;
-    }
-    if (e.key === 'ArrowUp') {
-      // e.preventDefault()
-      // e.stopPropagation()
-
-      const nextRow = table.getRowModel().rows[rowNumber - 1];
+    if (e.key === 'ArrowDown' || e.key === 'ArrowUp') {
+      const rows = table.getRowModel().rows;
+      const currentIndex = rows.findIndex(row => row.id === rowId);
+      if (currentIndex < 0) return;
+      const step = e.key === 'ArrowDown' ? 1 : -1;
+      const nextIndex = currentIndex + step;
+      const nextRow = rows[nextIndex];
       if (nextRow) {
-        const nextRowId = nextRow.id;
-        setFocusedCell?.({
-          rowId: nextRowId,
-          colId
-        });
-        notifyArrowRowFocus(table.getRow(nextRowId).original, 'arrowUp', selectionSettings?.useArrow, rowFocus);
-        setStartCell?.({
-          rowId: nextRowId,
-          colId
-        });
-        setEndCell?.({
-          rowId: nextRowId,
-          colId
-        });
-        setRangeState?.(getSelectedCellMatrix(table, {
-          rowId: nextRowId,
-          colId
-        }, {
-          rowId: nextRowId,
+        const nextCell = {
+          rowId: nextRow.id,
           colId
+        };
+        setFocusedCell?.(nextCell);
+        setStartCell?.(nextCell);
+        setEndCell?.(nextCell);
+        setRangeState?.(getSelectedCellMatrix(table, nextCell, nextCell));
+        focusArrowRow(e, nextRow.id, colId, () => rowVirtualizer.scrollToIndex(nextIndex, {
+          align: 'center'
         }));
-        const row = document.querySelector(`.ui-rc-grid-row[data-row-key="${nextRowId}"]`);
-        const cellFocus = row?.querySelector('.ui-rc-grid-cell:not(.ui-rc-grid-cell-selection)');
-        if (cellFocus) {
-          cellFocus.focus();
-        }
+        notifyArrowRowFocus(e, nextRow.original, e.key === 'ArrowDown' ? 'arrowDown' : 'arrowUp', selectionSettings?.useArrow, rowFocus);
       }
       return;
     }

package/es/table-component/table/TableWrapper.js

@@ -246,6 +246,7 @@ const TableWrapper = props => {
   }, /*#__PURE__*/React.createElement("div", {
     // id={id}
     ref: tableContainerRef,
+    "data-grid-scroll": true,
     style: {
       overflow: 'auto',
       //our scrollable table container

package/es/table-virtuoso/body/TableBodyCell.d.ts

@@ -4,6 +4,7 @@ import type { CommandClick } from "../../grid-component/type";
 import type { VirtualItem } from "@tanstack/react-virtual";
 interface TableBodyCellProps<T> {
     table: Table<T>;
+    scrollToRow?: (index: number) => void;
     tableId: string;
     cell: Cell<T, unknown>;
     commandClick?: (args: CommandClick<T>) => void;

package/es/table-virtuoso/body/TableBodyCell.js

@@ -1,4 +1,4 @@
-import { notifyArrowRowFocus } from "../../grid-component/hooks/rowFocus";
+import { focusArrowRow, notifyArrowRowFocus } from "../../grid-component/hooks/rowFocus";
 import Space from "rc-master-ui/es/space";
 import { getCommonPinningStyles, getFormat } from "../hook/utils";
 import Checkbox from "rc-master-ui/es/checkbox/Checkbox";
@@ -374,35 +374,18 @@ const TableBodyCell = props => {
       }
     },
     onKeyDown: e => {
-      const flatRows = table.getRowModel().flatRows;
-      if (e.key === 'ArrowDown' && rowNumber < flatRows.length - 1) {
-        const nextIndex = cell.row.index + 1;
-        // const nextIndex = rowNumber + 1
-
-        const nextId = flatRows[nextIndex].id;
-        setFocusedCell?.({
-          colId: cell.column.id,
-          rowId: nextId
-        });
-        notifyArrowRowFocus(table.getRow(nextId).original, 'arrowDown', selectionSettings?.useArrow, rowFocus);
-        const row = document.querySelector(`.ui-rc-grid-row[data-row-key="${nextId}"]`);
-        const cellFocus = row?.querySelector('.ui-rc-grid-cell:not(.ui-rc-grid-cell-selection)');
-        if (cellFocus) {
-          cellFocus.focus();
-        }
-      }
-      if (e.key === 'ArrowUp' && rowNumber > 0) {
-        const prevIndex = cell.row.index - 1;
-        const nextId = flatRows[prevIndex].id;
-        setFocusedCell?.({
-          colId: cell.column.id,
-          rowId: nextId
-        });
-        notifyArrowRowFocus(table.getRow(nextId).original, 'arrowUp', selectionSettings?.useArrow, rowFocus);
-        const row = document.querySelector(`.ui-rc-grid-row[data-row-key="${nextId}"]`);
-        const cellFocus = row?.querySelector('.ui-rc-grid-cell:not(.ui-rc-grid-cell-selection)');
-        if (cellFocus) {
-          cellFocus.focus();
+      if (e.key === 'ArrowDown' || e.key === 'ArrowUp') {
+        const rows = table.getRowModel().rows;
+        const currentIndex = rows.findIndex(row => row.id === cell.row.id);
+        const nextIndex = currentIndex + (e.key === 'ArrowDown' ? 1 : -1);
+        const nextRow = currentIndex >= 0 ? rows[nextIndex] : undefined;
+        if (nextRow) {
+          setFocusedCell?.({
+            colId: cell.column.id,
+            rowId: nextRow.id
+          });
+          focusArrowRow(e, nextRow.id, cell.column.id, () => props.scrollToRow?.(nextIndex));
+          notifyArrowRowFocus(e, nextRow.original, e.key === 'ArrowDown' ? 'arrowDown' : 'arrowUp', selectionSettings?.useArrow, rowFocus);
         }
       }
       if (e.ctrlKey && e.code === 'Space' && cell.row.getCanSelect()) {

package/es/table-virtuoso/body/TableBodyCellRowGroup.d.ts

@@ -4,6 +4,7 @@ import type { CommandClick } from "../../grid-component/type";
 import type { VirtualItem } from "@tanstack/react-virtual";
 interface TableBodyCellProps<T> {
     table: Table<T>;
+    scrollToRow?: (index: number) => void;
     tableId: string;
     cell: Cell<T, unknown>;
     commandClick?: (args: CommandClick<T>) => void;

package/es/table-virtuoso/body/TableBodyCellRowGroup.js

@@ -1,4 +1,4 @@
-import { notifyArrowRowFocus } from "../../grid-component/hooks/rowFocus";
+import { focusArrowRow, notifyArrowRowFocus } from "../../grid-component/hooks/rowFocus";
 import { getCommonPinningStyles } from "../hook/utils";
 import classNames from "classnames";
 import React from "react";
@@ -89,35 +89,18 @@ const TableBodyCellRowGroup = props => {
       }
     },
     onKeyDown: e => {
-      const flatRows = table.getRowModel().flatRows;
-      if (e.key === 'ArrowDown' && rowNumber < flatRows.length - 1) {
-        const nextIndex = cell.row.index + 1;
-        // const nextIndex = rowNumber + 1
-
-        const nextId = flatRows[nextIndex].id;
-        setFocusedCell?.({
-          colId: cell.column.id,
-          rowId: nextId
-        });
-        notifyArrowRowFocus(table.getRow(nextId).original, 'arrowDown', selectionSettings?.useArrow, rowFocus);
-        const row = document.querySelector(`.ui-rc-grid-row[data-row-key="${nextId}"]`);
-        const cellFocus = row?.querySelector('.ui-rc-grid-cell:not(.ui-rc-grid-cell-selection)');
-        if (cellFocus) {
-          cellFocus.focus();
-        }
-      }
-      if (e.key === 'ArrowUp' && rowNumber > 0) {
-        const prevIndex = cell.row.index - 1;
-        const nextId = flatRows[prevIndex].id;
-        setFocusedCell?.({
-          colId: cell.column.id,
-          rowId: nextId
-        });
-        notifyArrowRowFocus(table.getRow(nextId).original, 'arrowUp', selectionSettings?.useArrow, rowFocus);
-        const row = document.querySelector(`.ui-rc-grid-row[data-row-key="${nextId}"]`);
-        const cellFocus = row?.querySelector('.ui-rc-grid-cell:not(.ui-rc-grid-cell-selection)');
-        if (cellFocus) {
-          cellFocus.focus();
+      if (e.key === 'ArrowDown' || e.key === 'ArrowUp') {
+        const rows = table.getRowModel().rows;
+        const currentIndex = rows.findIndex(row => row.id === cell.row.id);
+        const nextIndex = currentIndex + (e.key === 'ArrowDown' ? 1 : -1);
+        const nextRow = currentIndex >= 0 ? rows[nextIndex] : undefined;
+        if (nextRow) {
+          setFocusedCell?.({
+            colId: cell.column.id,
+            rowId: nextRow.id
+          });
+          focusArrowRow(e, nextRow.id, cell.column.id, () => props.scrollToRow?.(nextIndex));
+          notifyArrowRowFocus(e, nextRow.original, e.key === 'ArrowDown' ? 'arrowDown' : 'arrowUp', selectionSettings?.useArrow, rowFocus);
         }
       }
       if (e.ctrlKey && e.code === 'Space' && cell.row.getCanSelect()) {

package/es/table-virtuoso/body/TableBodyRow.d.ts

@@ -4,10 +4,11 @@ import type { CommandClick } from "../../grid-component/type";
 interface TableBodyRowProps<T> {
     tableId: string;
     table: Table<T>;
+    scrollToRow?: (index: number) => void;
     row: Row<T>;
     commandClick?: (args: CommandClick<T>) => void;
     editAble?: boolean;
     [key: string]: any;
 }
-declare const TableBodyRow: <RecordType extends object>({ tableId, table, row, virtualRow, commandClick, contextMenuItems, onContextMenu, rowheight, editAble, isEditing, isRowEditable, ...rest }: TableBodyRowProps<RecordType>) => JSX.Element;
+declare const TableBodyRow: <RecordType extends object>({ tableId, table, row, scrollToRow, virtualRow, commandClick, contextMenuItems, onContextMenu, rowheight, editAble, isEditing, isRowEditable, ...rest }: TableBodyRowProps<RecordType>) => JSX.Element;
 export default TableBodyRow;

package/es/table-virtuoso/body/TableBodyRow.js

@@ -14,6 +14,7 @@ const TableBodyRow = ({
   tableId,
   table,
   row,
+  scrollToRow,
   virtualRow,
   commandClick,
   contextMenuItems,
@@ -133,7 +134,9 @@ const TableBodyRow = ({
         rowData: row.original,
         value: cellValue
       }) : /*#__PURE__*/React.createElement(React.Fragment, null, headertext, headertext ? ': ' : '', " ", cellContent);
-      return /*#__PURE__*/React.createElement(TableBodyCell, _extends({}, otherCellAttributes, {
+      return /*#__PURE__*/React.createElement(TableBodyCell, _extends({
+        scrollToRow: scrollToRow
+      }, otherCellAttributes, {
         table: table,
         tableId: tableId,
         key: cell.id,
@@ -166,7 +169,9 @@ const TableBodyRow = ({
       const childrenData = row.subRows.map(it => it.original);
       const sumValue = sumByField(childrenData, cell.column.id);
       const sumValueFormat = numericFormatter(sumValue.toString(), numericFormatProps);
-      return /*#__PURE__*/React.createElement(TableBodyCellRowGroup, _extends({}, otherCellAttributes, {
+      return /*#__PURE__*/React.createElement(TableBodyCellRowGroup, _extends({
+        scrollToRow: scrollToRow
+      }, otherCellAttributes, {
         table: table,
         tableId: tableId,
         key: cell.id,
@@ -179,7 +184,9 @@ const TableBodyRow = ({
         sumValue: sumValueFormat
       }));
     }
-    return /*#__PURE__*/React.createElement(TableBodyCell, _extends({}, otherCellAttributes, {
+    return /*#__PURE__*/React.createElement(TableBodyCell, _extends({
+      scrollToRow: scrollToRow
+    }, otherCellAttributes, {
       table: table,
       tableId: tableId,
       key: cell.id,

package/es/table-virtuoso/table/TableWrapper.js

@@ -34,6 +34,11 @@ const TableWrapper = props => {
 
   // ref cho scroll container
   const scrollRef = useRef(null);
+  const virtuosoRef = useRef(null);
+  const scrollToRow = index => virtuosoRef.current?.scrollToIndex({
+    index,
+    align: 'center'
+  });
   const {
     rows
   } = table.getRowModel();
@@ -126,6 +131,7 @@ const TableWrapper = props => {
       position: "relative"
     }
   }, /*#__PURE__*/React.createElement(TableVirtuoso, _extends({
+    ref: virtuosoRef,
     data: table.getRowModel().rows,
     totalCount: rows.length
   }, onVisibleRowsChange ? {
@@ -190,6 +196,7 @@ const TableWrapper = props => {
         return /*#__PURE__*/React.createElement(TableBodyRow, _extends({
           tableId: id,
           row: row,
+          scrollToRow: scrollToRow,
           table: table,
           commandClick: commandClick,
           rowheight: editAble ? 37 : rowheight,

package/lib/grid-component/hooks/rowFocus.d.ts

@@ -1,4 +1,4 @@
-import type { MouseEvent } from 'react';
+import type { KeyboardEvent as ReactKeyboardEvent, MouseEvent } from 'react';
 import type { RowFocusEventArgs } from '../type';
 type RowFocus<T> = (args: RowFocusEventArgs<T>) => void;
 /** Capture clicks even when a cell handles the event itself. */
@@ -6,6 +6,7 @@ export declare function getRowFocusHandlers<T>(rowData: T, rowFocus?: RowFocus<T
     onClickCapture: (event: MouseEvent<HTMLElement>) => void;
     onContextMenuCapture: (event: MouseEvent<HTMLElement>) => void;
 };
-/** Notify arrow focus without changing the existing navigation or selection. */
-export declare function notifyArrowRowFocus<T>(rowData: T, method: 'arrowUp' | 'arrowDown', useArrow?: boolean, rowFocus?: RowFocus<T>): void;
+/** Report the last focused row after the arrow key is released. */
+export declare function notifyArrowRowFocus<T>(event: ReactKeyboardEvent, rowData: T, method: 'arrowUp' | 'arrowDown', useArrow?: boolean, rowFocus?: RowFocus<T>): void;
+export declare function focusArrowRow(event: ReactKeyboardEvent, rowId: string, columnId: string, scrollToRow: () => void): void;
 export {};

package/lib/grid-component/hooks/rowFocus.js

@@ -3,8 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.focusArrowRow = focusArrowRow;
 exports.getRowFocusHandlers = getRowFocusHandlers;
 exports.notifyArrowRowFocus = notifyArrowRowFocus;
+const gridViewportSelector = '[data-grid-scroll], [data-virtuoso-scroller]';
+const pendingArrowFocus = new WeakMap();
+
 /** Capture clicks even when a cell handles the event itself. */
 function getRowFocusHandlers(rowData, rowFocus) {
   return {
@@ -23,10 +27,69 @@ function getRowFocusHandlers(rowData, rowFocus) {
   };
 }
 
-/** Notify arrow focus without changing the existing navigation or selection. */
-function notifyArrowRowFocus(rowData, method, useArrow, rowFocus) {
-  if (useArrow === true) rowFocus?.({
+/** Report the last focused row after the arrow key is released. */
+function notifyArrowRowFocus(event, rowData, method, useArrow, rowFocus) {
+  if (useArrow !== true || !rowFocus) return;
+  const viewport = event.currentTarget.closest(gridViewportSelector);
+  const view = viewport?.ownerDocument.defaultView;
+  if (!viewport || !view) return;
+  const notify = () => rowFocus({
     rowData,
     method
   });
+  const pending = pendingArrowFocus.get(viewport);
+  if (pending) {
+    pending.key = event.key;
+    pending.notify = notify;
+    return;
+  }
+  const focus = {
+    key: event.key,
+    notify
+  };
+  pendingArrowFocus.set(viewport, focus);
+  const cancel = () => {
+    pendingArrowFocus.delete(viewport);
+    view.removeEventListener('keyup', release, true);
+    view.removeEventListener('blur', cancel);
+    view.removeEventListener('pointerdown', cancel, true);
+  };
+  const release = keyEvent => {
+    if (keyEvent.key !== focus.key) return;
+    cancel();
+    view.setTimeout(() => {
+      if (viewport.isConnected) focus.notify();
+    }, 0);
+  };
+
+  // A virtualized row can unmount before keyup reaches its original cell.
+  view.addEventListener('keyup', release, true);
+  view.addEventListener('blur', cancel);
+  view.addEventListener('pointerdown', cancel, true);
+}
+function focusArrowRow(event, rowId, columnId, scrollToRow) {
+  event.preventDefault();
+  const source = event.currentTarget;
+  const body = source.closest('.ui-rc-grid-row')?.parentElement;
+  const row = body && Array.from(body.children).find(child => child.getAttribute('data-row-key') === rowId);
+  const viewport = source.closest(gridViewportSelector);
+  const canScroll = viewport && viewport.scrollHeight > viewport.clientHeight;
+  if (!row) {
+    if (canScroll) scrollToRow();
+    return;
+  }
+  const cell = Array.from(row.querySelectorAll(':scope > [data-col-key]')).find(element => element.getAttribute('data-col-key') === columnId) ?? row.querySelector(':scope > .ui-rc-grid-cell:not(.ui-rc-grid-cell-selection)');
+  cell?.focus({
+    preventScroll: true
+  });
+  if (canScroll) {
+    const header = body?.parentElement?.querySelector(':scope > .ui-rc-grid-thead');
+    const footer = body?.parentElement?.querySelector(':scope > .ui-rc-grid-tfoot');
+    const headerHeight = header?.getBoundingClientRect().height ?? 0;
+    const footerHeight = footer?.getBoundingClientRect().height ?? 0;
+    const viewportTop = viewport.getBoundingClientRect().top + viewport.clientTop;
+    const viewportCenter = viewportTop + (viewport.clientHeight + headerHeight - footerHeight) / 2;
+    const rowRect = row.getBoundingClientRect();
+    viewport.scrollTop += rowRect.top + rowRect.height / 2 - viewportCenter;
+  }
 }

package/lib/grid-component/type.d.ts

@@ -791,7 +791,7 @@ export type IWrapSettings = {
     wrapMode?: IWrapMode;
 };
 export type SelectionSettings<T = AnyObject> = {
-    /** Invoke rowFocus on ArrowUp/ArrowDown. Defaults to false. */
+    /** Invoke rowFocus for the final row after releasing ArrowUp or ArrowDown. Defaults to false. */
     useArrow?: boolean;
     mode?: 'checkbox' | 'radio';
     type?: 'single' | 'multiple';

package/lib/group-component/body/TableBodyCell.d.ts

@@ -1,8 +1,10 @@
 /// <reference types="react" />
+import type { Virtualizer } from "@tanstack/react-virtual";
 import type { Cell, Table } from "@tanstack/react-table";
 import type { CommandClick } from "../../grid-component/type";
 interface TableBodyCellProps<T> {
     table: Table<T>;
+    rowVirtualizer?: Virtualizer<HTMLDivElement, HTMLDivElement>;
     tableId: string;
     cell: Cell<T, unknown>;
     commandClick?: (args: CommandClick<T>) => void;

package/lib/group-component/body/TableBodyCell.js

@@ -454,35 +454,20 @@ const TableBodyCell = props => {
       }
     },
     onKeyDown: e => {
-      const flatRows = table.getRowModel().flatRows;
-      if (e.key === 'ArrowDown' && rowNumber < flatRows.length - 1) {
-        const nextIndex = cell.row.index + 1;
-        // const nextIndex = rowNumber + 1
-
-        const nextId = flatRows[nextIndex].id;
-        setFocusedCell?.({
-          colId: cell.column.id,
-          rowId: nextId
-        });
-        (0, _rowFocus.notifyArrowRowFocus)(table.getRow(nextId).original, 'arrowDown', selectionSettings?.useArrow, rowFocus);
-        const rowQr = document.querySelector(`.ui-rc-grid-row[data-row-key="${nextId}"]`);
-        const cellFocus = rowQr?.querySelector('.ui-rc-grid-cell:not(.ui-rc-grid-cell-selection)');
-        if (cellFocus) {
-          cellFocus.focus();
-        }
-      }
-      if (e.key === 'ArrowUp' && rowNumber > 0) {
-        const prevIndex = cell.row.index - 1;
-        const nextId = flatRows[prevIndex].id;
-        setFocusedCell?.({
-          colId: cell.column.id,
-          rowId: nextId
-        });
-        (0, _rowFocus.notifyArrowRowFocus)(table.getRow(nextId).original, 'arrowUp', selectionSettings?.useArrow, rowFocus);
-        const rowQr = document.querySelector(`.ui-rc-grid-row[data-row-key="${nextId}"]`);
-        const cellFocus = rowQr?.querySelector('.ui-rc-grid-cell:not(.ui-rc-grid-cell-selection)');
-        if (cellFocus) {
-          cellFocus.focus();
+      if (e.key === 'ArrowDown' || e.key === 'ArrowUp') {
+        const rows = table.getRowModel().rows;
+        const currentIndex = rows.findIndex(row => row.id === cell.row.id);
+        const nextIndex = currentIndex + (e.key === 'ArrowDown' ? 1 : -1);
+        const nextRow = currentIndex >= 0 ? rows[nextIndex] : undefined;
+        if (nextRow) {
+          setFocusedCell?.({
+            colId: cell.column.id,
+            rowId: nextRow.id
+          });
+          (0, _rowFocus.focusArrowRow)(e, nextRow.id, cell.column.id, () => props.rowVirtualizer?.scrollToIndex(nextIndex, {
+            align: 'center'
+          }));
+          (0, _rowFocus.notifyArrowRowFocus)(e, nextRow.original, e.key === 'ArrowDown' ? 'arrowDown' : 'arrowUp', selectionSettings?.useArrow, rowFocus);
         }
       }
       if (e.ctrlKey && e.code === 'Space' && cell.row.getCanSelect()) {

package/lib/group-component/body/TableBodyCellEdit.js

@@ -794,93 +794,30 @@ const TableBodyCellEdit = props => {
       }
       return;
     }
-    if (e.key === 'ArrowDown') {
-      // e.preventDefault()
-      // e.stopPropagation()
-
-      let nextRowIndex = rowNumber + 1;
-      let nextRow = table.getRowModel().rows[nextRowIndex];
-
-      // Nếu nextRow có children và chưa được expand, thì tìm tiếp dòng tiếp theo
-      while (nextRow && nextRow.subRows && nextRow.subRows.length > 0) {
-        nextRowIndex++;
-        nextRow = table.getRowModel().rows[nextRowIndex];
+    if (e.key === 'ArrowDown' || e.key === 'ArrowUp') {
+      const rows = table.getRowModel().rows;
+      const currentIndex = rows.findIndex(row => row.id === rowId);
+      if (currentIndex < 0) return;
+      const step = e.key === 'ArrowDown' ? 1 : -1;
+      let nextIndex = currentIndex + step;
+      let nextRow = rows[nextIndex];
+      while (nextRow?.subRows.length) {
+        nextIndex += step;
+        nextRow = rows[nextIndex];
       }
       if (nextRow) {
-        const nextRowId = nextRow.id;
-        setFocusedCell?.({
-          rowId: nextRowId,
-          colId
-        });
-        (0, _rowFocus.notifyArrowRowFocus)(table.getRow(nextRowId).original, 'arrowDown', selectionSettings?.useArrow, rowFocus);
-        setStartCell?.({
-          rowId: nextRowId,
-          colId
-        });
-        setEndCell?.({
-          rowId: nextRowId,
-          colId
-        });
-        setRangeState?.((0, _utils.getSelectedCellMatrix)(table, {
-          rowId: nextRowId,
-          colId
-        }, {
-          rowId: nextRowId,
-          colId
-        }));
-
-        // columnVirtualizer.scrollToIndex(nextCol.getIndex(), { align: 'center' })
-        // rowVirtualizer.scrollToIndex(nextRow.index, { align: 'center' })
-
-        const row = document.querySelector(`.ui-rc-grid-row[data-row-key="${nextRowId}"]`);
-        const cellFocus = row?.querySelector('.ui-rc-grid-cell:not(.ui-rc-grid-cell-selection)');
-        if (cellFocus) {
-          cellFocus.focus();
-        }
-      }
-      return;
-    }
-    if (e.key === 'ArrowUp') {
-      // e.preventDefault()
-      // e.stopPropagation()
-
-      // const nextRow = table.getRowModel().rows[rowNumber - 1]
-
-      let prevRowIndex = rowNumber - 1;
-      let prevRow = table.getRowModel().rows[prevRowIndex];
-
-      // Nếu nextRow có children và chưa được expand, thì tìm tiếp dòng tiếp theo
-      while (prevRow && prevRow.subRows && prevRow.subRows.length > 0) {
-        prevRowIndex--;
-        prevRow = table.getRowModel().rows[prevRowIndex];
-      }
-      if (prevRow) {
-        const nextRowId = prevRow.id;
-        setFocusedCell?.({
-          rowId: nextRowId,
-          colId
-        });
-        (0, _rowFocus.notifyArrowRowFocus)(table.getRow(nextRowId).original, 'arrowUp', selectionSettings?.useArrow, rowFocus);
-        setStartCell?.({
-          rowId: nextRowId,
-          colId
-        });
-        setEndCell?.({
-          rowId: nextRowId,
-          colId
-        });
-        setRangeState?.((0, _utils.getSelectedCellMatrix)(table, {
-          rowId: nextRowId,
-          colId
-        }, {
-          rowId: nextRowId,
+        const nextCell = {
+          rowId: nextRow.id,
           colId
+        };
+        setFocusedCell?.(nextCell);
+        setStartCell?.(nextCell);
+        setEndCell?.(nextCell);
+        setRangeState?.((0, _utils.getSelectedCellMatrix)(table, nextCell, nextCell));
+        (0, _rowFocus.focusArrowRow)(e, nextRow.id, colId, () => rowVirtualizer.scrollToIndex(nextIndex, {
+          align: 'center'
         }));
-        const row = document.querySelector(`.ui-rc-grid-row[data-row-key="${nextRowId}"]`);
-        const cellFocus = row?.querySelector('.ui-rc-grid-cell:not(.ui-rc-grid-cell-selection)');
-        if (cellFocus) {
-          cellFocus.focus();
-        }
+        (0, _rowFocus.notifyArrowRowFocus)(e, nextRow.original, e.key === 'ArrowDown' ? 'arrowDown' : 'arrowUp', selectionSettings?.useArrow, rowFocus);
       }
       return;
     }

package/lib/group-component/body/TableBodyCellEmpty.d.ts

@@ -1,8 +1,10 @@
 /// <reference types="react" />
+import type { Virtualizer } from "@tanstack/react-virtual";
 import type { Cell, Table } from "@tanstack/react-table";
 import type { CommandClick } from "../../grid-component/type";
 interface TableBodyCellProps<T> {
     table: Table<T>;
+    rowVirtualizer?: Virtualizer<HTMLDivElement, HTMLDivElement>;
     tableId: string;
     cell: Cell<T, unknown>;
     commandClick?: (args: CommandClick<T>) => void;