From 958d9f32279aadd2d9322802059b075cc888951f Mon Sep 17 00:00:00 2001 From: Aliar666 Date: Mon, 16 Nov 2026 04:37:02 +0400 Subject: [PATCH 1/6] DataGrid: Fix PageUp/PageDown focusing a row from the previous scroll position when rows render asynchronously --- .../data_controller/data_controller.ts | 7 + .../page_navigation.integration.test.ts | 298 ++++++++++++++++++ .../keyboard_navigation.ts | 40 ++- .../grids/grid_core/views/rows_view.ts | 13 + .../virtual_scrolling_data_controller.ts | 4 + .../virtual_scrolling_core.ts | 15 +- 6 files changed, 369 insertions(+), 8 deletions(-) create mode 100644 packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/__tests__/page_navigation.integration.test.ts diff --git a/packages/devextreme/js/__internal/grids/grid_core/data_controller/data_controller.ts b/packages/devextreme/js/__internal/grids/grid_core/data_controller/data_controller.ts index f49d560f7f30..c8cca6802d32 100644 --- a/packages/devextreme/js/__internal/grids/grid_core/data_controller/data_controller.ts +++ b/packages/devextreme/js/__internal/grids/grid_core/data_controller/data_controller.ts @@ -1454,6 +1454,13 @@ export class DataController extends modules.Controller { return 0; } + /** + * @extended: virtual_scrolling + */ + public isViewportPositionPending(): boolean { + return false; + } + private changePaging(optionName: PagingOptionName, value?: number): PagingResult { const dataSourceAdapter = this.dataSourceController.getAdapter(); diff --git a/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/__tests__/page_navigation.integration.test.ts b/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/__tests__/page_navigation.integration.test.ts new file mode 100644 index 000000000000..36a9f87546b4 --- /dev/null +++ b/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/__tests__/page_navigation.integration.test.ts @@ -0,0 +1,298 @@ +import { + afterEach, beforeEach, describe, expect, it, jest, +} from '@jest/globals'; +import { Deferred } from '@js/core/utils/deferred'; +import type { LoadOptions } from '@js/data'; +import CustomStore from '@js/data/custom_store'; +import type { Properties as DataGridProperties } from '@js/ui/data_grid'; +import { createPendingTemplate } from '@ts/grids/grid_core/__tests__/__mock__/helpers/pending_template'; +import type { DataGridInstance } from '@ts/grids/grid_core/__tests__/__mock__/helpers/utils'; +import { + afterTest, + beforeTest, + createDataGrid, +} from '@ts/grids/grid_core/__tests__/__mock__/helpers/utils'; + +import { triggerKeyDown, triggerPointerDown } from './helpers/utils'; + +const ROW_COUNT = 100; +const ROW_HEIGHT = 50; +const VIEWPORT_HEIGHT = 250; +const ROWS_PER_PAGE = VIEWPORT_HEIGHT / ROW_HEIGHT; +const CONTENT_HEIGHT = ROW_COUNT * ROW_HEIGHT; +const LOAD_DELAY = 200; + +const ROWS = Array.from({ length: ROW_COUNT }, (_, id) => ({ id, name: `Row ${id}` })); + +type PageKey = 'pageDown' | 'pageUp'; + +interface ScrollOffset { + top: number; + left: number; +} + +interface ScrollableMock { + container: () => HTMLElement; + $content: () => { get: (index: number) => HTMLElement }; + _createActionByOption: (optionName: string) => (args: { scrollOffset: ScrollOffset }) => void; +} + +interface GridWithPendingTemplates { + instance: DataGridInstance; + renderPendingTemplates: () => void; +} + +let scrollTop = 0; + +const getRowIndex = (element: Element): number => Number(element.getAttribute('aria-rowindex')) - 1; + +const getFocusedRowIndex = (): number | undefined => { + const row = document.activeElement?.closest('tr.dx-data-row'); + + return row ? getRowIndex(row) : undefined; +}; + +const createRect = (top: number, height: number): DOMRect => ({ + top, bottom: top + height, height, left: 0, right: 0, width: 0, x: 0, y: top, toJSON: () => ({}), +}); + +const mockLayout = (): void => { + jest.spyOn(Element.prototype, 'getClientRects').mockReturnValue([{}] as unknown as DOMRectList); + + jest.spyOn(Element.prototype, 'getBoundingClientRect').mockImplementation(function getRect(this: Element) { + if (this.matches('tr.dx-data-row')) { + return createRect(getRowIndex(this) * ROW_HEIGHT - scrollTop, ROW_HEIGHT); + } + + if (this.matches('.dx-datagrid-rowsview .dx-datagrid-content')) { + return createRect(-scrollTop, CONTENT_HEIGHT); + } + + return createRect(0, 0); + }); +}; + +const mockScrolling = (instance: DataGridInstance): void => { + const scrollable = instance.getScrollable(); + const scrollableMock = scrollable as unknown as ScrollableMock; + const rowsViewElement = instance.getView('rowsView').element()?.get(0) as HTMLElement; + + rowsViewElement.style.height = `${VIEWPORT_HEIGHT}px`; + scrollableMock.container().style.height = `${VIEWPORT_HEIGHT}px`; + scrollableMock.$content().get(0).style.height = `${CONTENT_HEIGHT}px`; + + jest.spyOn(scrollable, 'scrollTop').mockImplementation(() => scrollTop); + jest.spyOn(scrollable, 'scrollBy').mockImplementation((distance) => { + const top = typeof distance === 'number' ? distance : distance.top ?? 0; + + scrollTop = Math.min(Math.max(scrollTop + top, 0), CONTENT_HEIGHT - VIEWPORT_HEIGHT); + scrollableMock._createActionByOption('onScroll')({ scrollOffset: { top: scrollTop, left: 0 } }); + }); +}; + +const createGrid = async (options: DataGridProperties = {}): Promise => { + const { instance } = await createDataGrid({ + dataSource: ROWS, + height: 300, + columns: ['id', 'name'], + scrolling: { mode: 'virtual' }, + ...options, + }); + + mockScrolling(instance); + jest.runAllTimers(); + + return instance; +}; + +const createGridWithAsyncRendering = (): Promise => createGrid({ + scrolling: { mode: 'virtual', renderAsync: true }, +}); + +const createRemoteStore = (): CustomStore => new CustomStore({ + key: 'id', + load: ({ skip = 0, take = ROW_COUNT }: LoadOptions) => { + const result = Deferred(); + + // eslint-disable-next-line no-restricted-globals -- delays the load on fake timers + setTimeout(() => { + result.resolve({ data: ROWS.slice(skip, skip + take), totalCount: ROW_COUNT }); + }, LOAD_DELAY); + + return result.promise(); + }, +}); + +const createGridWithAsyncTemplates = async (): Promise => { + const { template, renderPendingTemplates } = createPendingTemplate(); + const instance = await createGrid({ + columns: ['id', { dataField: 'name', cellTemplate: 'asyncTemplate' }], + templatesRenderAsynchronously: true, + integrationOptions: { + templates: { asyncTemplate: template }, + }, + } as DataGridProperties); + renderPendingTemplates(); + + return { instance, renderPendingTemplates }; +}; + +const clickRow = (instance: DataGridInstance, visibleRowIndex: number): void => { + triggerPointerDown(instance.getCellElement(visibleRowIndex, 0) as unknown as HTMLElement); +}; + +const focusFirstCell = (instance: DataGridInstance): void => { + clickRow(instance, 0); + jest.runAllTimers(); +}; + +const pressKey = (instance: DataGridInstance, keyName: PageKey): void => { + triggerKeyDown(instance, keyName, document.activeElement); + jest.runAllTimers(); +}; + +const pressKeyWithoutRendering = (instance: DataGridInstance, keyName: PageKey): void => { + triggerKeyDown(instance, keyName, document.activeElement); + jest.advanceTimersByTime(0); +}; + +describe('PageUp and PageDown with virtual scrolling (T898324)', () => { + beforeEach(() => { + beforeTest(); + scrollTop = 0; + mockLayout(); + }); + + afterEach(() => { + afterTest(); + jest.restoreAllMocks(); + }); + + it.each([true, false])('should focus the top visible row when scrolling.renderAsync is %s', async (renderAsync) => { + const instance = await createGrid({ scrolling: { mode: 'virtual', renderAsync } }); + focusFirstCell(instance); + + const focusedRowIndexes = (['pageDown', 'pageDown', 'pageUp', 'pageUp'] as const).map((keyName) => { + pressKey(instance, keyName); + + return getFocusedRowIndex(); + }); + + expect(focusedRowIndexes).toEqual([ROWS_PER_PAGE, 2 * ROWS_PER_PAGE, ROWS_PER_PAGE, 0]); + expect(instance.option('focusedRowIndex')).toBe(0); + expect(scrollTop).toBe(0); + }); + + it('should move the focused row when scrolling.legacyMode is true and rows are rendered virtually', async () => { + const instance = await createGrid({ + scrolling: { + mode: 'virtual', rowRenderingMode: 'virtual', legacyMode: true, renderAsync: true, + }, + } as DataGridProperties); + focusFirstCell(instance); + + const focusedRowIndexes = (['pageDown', 'pageDown', 'pageUp', 'pageUp'] as const).map((keyName) => { + pressKey(instance, keyName); + + return instance.option('focusedRowIndex'); + }); + + expect(focusedRowIndexes).toEqual([ROWS_PER_PAGE, 2 * ROWS_PER_PAGE, ROWS_PER_PAGE, 0]); + }); + + it('should focus the top visible row when PageDown is pressed again before the rows are rendered', async () => { + const instance = await createGridWithAsyncRendering(); + const pressCount = 4; + focusFirstCell(instance); + + Array.from({ length: pressCount }).forEach(() => { + pressKeyWithoutRendering(instance, 'pageDown'); + }); + jest.runAllTimers(); + + expect(getFocusedRowIndex()).toBe(pressCount * ROWS_PER_PAGE); + }); + + it('should focus the top visible row once its rows are loaded from a remote store', async () => { + const instance = await createGrid({ + keyExpr: undefined, + dataSource: createRemoteStore(), + remoteOperations: { paging: true }, + }); + focusFirstCell(instance); + pressKey(instance, 'pageDown'); + + pressKeyWithoutRendering(instance, 'pageDown'); + const isLoadingOnFocusRestore = instance.getController('data').isLoading(); + jest.runAllTimers(); + + expect(isLoadingOnFocusRestore).toBe(true); + expect(getFocusedRowIndex()).toBe(2 * ROWS_PER_PAGE); + }); + + it('should focus the top visible row once its rows have rendered async templates', async () => { + const { instance, renderPendingTemplates } = await createGridWithAsyncTemplates(); + focusFirstCell(instance); + pressKey(instance, 'pageDown'); + renderPendingTemplates(); + + pressKey(instance, 'pageDown'); + const isWaitingForTemplates = instance.getView('rowsView').isWaitingForRowsLayout(); + renderPendingTemplates(); + + expect(isWaitingForTemplates).toBe(true); + expect(getFocusedRowIndex()).toBe(2 * ROWS_PER_PAGE); + }); + + it('should ignore downArrow pressed before the rows of the new position are rendered', async () => { + const instance = await createGridWithAsyncRendering(); + focusFirstCell(instance); + pressKey(instance, 'pageDown'); + + pressKeyWithoutRendering(instance, 'pageUp'); + triggerKeyDown(instance, 'downArrow', document.activeElement); + const focusedRowIndexBeforeRendering = getFocusedRowIndex(); + jest.runAllTimers(); + + expect(focusedRowIndexBeforeRendering).toBeUndefined(); + expect(getFocusedRowIndex()).toBe(0); + }); + + it('should not ignore downArrow pressed while the rows of a scroll without PageUp and PageDown are rendering', async () => { + const instance = await createGridWithAsyncRendering(); + focusFirstCell(instance); + + instance.getScrollable().scrollBy({ top: ROW_HEIGHT }); + const isRowsRenderPending = instance.getView('rowsView').isViewportRowsRenderPending(); + triggerKeyDown(instance, 'downArrow', document.activeElement); + + expect(isRowsRenderPending).toBe(true); + expect(getFocusedRowIndex()).toBe(1); + }); + + it('should keep the row focused by downArrow after the next render once the page navigation is completed', async () => { + const instance = await createGridWithAsyncRendering(); + focusFirstCell(instance); + pressKey(instance, 'pageDown'); + triggerKeyDown(instance, 'downArrow', document.activeElement); + jest.runAllTimers(); + + instance.repaint(); + jest.runAllTimers(); + + expect(getFocusedRowIndex()).toBe(ROWS_PER_PAGE + 1); + }); + + it('should keep the row focused by a click before the rows of the new position are rendered', async () => { + const instance = await createGridWithAsyncRendering(); + const clickedVisibleRowIndex = 2; + focusFirstCell(instance); + pressKey(instance, 'pageDown'); + + pressKeyWithoutRendering(instance, 'pageUp'); + clickRow(instance, clickedVisibleRowIndex); + jest.runAllTimers(); + + expect(instance.option('focusedRowIndex')).toBe(ROWS_PER_PAGE + clickedVisibleRowIndex); + }); +}); diff --git a/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/keyboard_navigation.ts b/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/keyboard_navigation.ts index fc6089d0051f..2f0a4a5991cf 100644 --- a/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/keyboard_navigation.ts +++ b/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/keyboard_navigation.ts @@ -176,6 +176,8 @@ export class KeyboardNavigationController extends KeyboardNavigationControllerCo private focusRestoreScrollTop = 0; + private isPageNavigationPending = false; + // #region Initialization public init(): void { this._dataController = this.getController('data'); @@ -333,6 +335,8 @@ export class KeyboardNavigationController extends KeyboardNavigationControllerCo return; } + this.completePageNavigation(); + const isFullUpdate = !e || e.changeType === 'refresh'; const isFocusedViewCorrect = this._focusedView?.name === this._rowsView.name; const isAppend = e && (e.changeType === 'append' || e.changeType === 'prepend'); @@ -745,7 +749,10 @@ export class KeyboardNavigationController extends KeyboardNavigationControllerCo } private isWaitingForRowsRendering(eventArgs: KeyboardKeyDownEvent): boolean { - return this._rowsView.isWaitingForRowsLayout() + const isWaitingForRows = this._rowsView.isWaitingForRowsLayout() + || (this.isPageNavigationPending && this._rowsView.isViewportRowsRenderPending()); + + return isWaitingForRows && !this._editingController?.isEditing() && !this.isInsideMasterDetail($(eventArgs.originalEvent.target)); } @@ -1716,6 +1723,7 @@ export class KeyboardNavigationController extends KeyboardNavigationControllerCo this.setRowFocusType(); } + this.isPageNavigationPending = false; this._updateFocusedCellPosition($targetCell); if (this._allowRowUpdating() && isCellOrBatchEditMode && column?.allowEditing) { @@ -2062,14 +2070,18 @@ export class KeyboardNavigationController extends KeyboardNavigationControllerCo const { columnIndex } = this._focusedCellPosition; const rowIndexOffset = this._dataController.getRowIndexOffset(); - let newRowIndex = isUpArrow - ? rowIndex - : this._rowsView.getTopVisibleItemIndex() + rowIndexOffset; + let newRowIndex = isUpArrow ? rowIndex : this.getTopVisibleRowIndex(); if (!isUpArrow) { this._editorFactory.loseFocus(); this.applyTabIndexToElement($rowsViewElement); eventsEngine.trigger($rowsViewElement, 'focus'); + + this.isPageNavigationPending = this._rowsView.isViewportRowsRenderPending(); + + if (this.isPageNavigationPending) { + return; + } } else { // @ts-expect-error getRow() is typed as possibly undefined const $rowElement: dxElementWrapper = this._rowsView.getRow(newRowIndex - rowIndexOffset); @@ -2089,6 +2101,22 @@ export class KeyboardNavigationController extends KeyboardNavigationControllerCo } } + private getTopVisibleRowIndex(): number { + return this._rowsView.getTopVisibleItemIndex() + this._dataController.getRowIndexOffset(); + } + + private completePageNavigation(): void { + if (!this.isPageNavigationPending || this._rowsView.isViewportRowsRenderPending()) { + return; + } + + this.isPageNavigationPending = false; + this.setFocusedCellPosition( + this.getTopVisibleRowIndex(), + this._focusedCellPosition.columnIndex, + ); + } + // #endregion Focusing // #region Cell_Position private silentUpdateFocusedCellPosition( @@ -2813,7 +2841,7 @@ export class KeyboardNavigationController extends KeyboardNavigationControllerCo const { rowIndex = -1, columnIndex = -1 } = cellPosition; const rowIndexOffset = this._dataController.getRowIndexOffset(); const column = this._columnsController.getVisibleColumns(null, true)[columnIndex]; - const columnIndexOffset = column && column.fixed + const columnIndexOffset = column?.fixed ? this._getFixedColumnIndexOffset(column) : this._columnsController.getColumnIndexOffset(); @@ -3265,7 +3293,7 @@ const editing = ( const visibleColumnIndex = this._keyboardNavigationController.getVisibleColumnIndex(); const column = this._columnsController.getVisibleColumns()[visibleColumnIndex]; - if ((column && column.type) || this.getEditMode() === EDIT_MODE.form) { + if ((column?.type) || this.getEditMode() === EDIT_MODE.form) { this._keyboardNavigationController.resetFocusedCell(); } super.editRow(rowIndex); diff --git a/packages/devextreme/js/__internal/grids/grid_core/views/rows_view.ts b/packages/devextreme/js/__internal/grids/grid_core/views/rows_view.ts index d7f67a14bf52..51d73169a0a4 100644 --- a/packages/devextreme/js/__internal/grids/grid_core/views/rows_view.ts +++ b/packages/devextreme/js/__internal/grids/grid_core/views/rows_view.ts @@ -515,6 +515,19 @@ export class RowsView extends ColumnsView { return this._findContentElement(); } + public isViewportRowsRenderPending(): boolean { + const scrolling = this.option('scrolling'); + const isVirtualRender = isVirtualPaging(scrolling) || isVirtualRowRendering(scrolling); + + if (!isVirtualRender) { + return false; + } + + return this._dataController.isLoading() + || this._dataController.isViewportPositionPending() + || this.isWaitingForRowsLayout(); + } + public isWaitingForRowsLayout(): boolean { return this.isWaitingForAsyncTemplates() && !this.isRenderedLayoutCurrent(); } diff --git a/packages/devextreme/js/__internal/grids/grid_core/virtual_scrolling/extenders/virtual_scrolling_data_controller.ts b/packages/devextreme/js/__internal/grids/grid_core/virtual_scrolling/extenders/virtual_scrolling_data_controller.ts index 8fb3c0e4e3fe..4ee31adba8dc 100644 --- a/packages/devextreme/js/__internal/grids/grid_core/virtual_scrolling/extenders/virtual_scrolling_data_controller.ts +++ b/packages/devextreme/js/__internal/grids/grid_core/virtual_scrolling/extenders/virtual_scrolling_data_controller.ts @@ -659,6 +659,10 @@ export const virtualScrollingDataControllerExtender = ( } } + public isViewportPositionPending(): boolean { + return !!this._rowsScrollController?.isViewportPositionPending(); + } + public setContentItemSizes(sizes: number[]): void { const dataSourceAdapter = this.dataSourceController.getAdapter(); const result = this._rowsScrollController?.setContentItemSizes(sizes); diff --git a/packages/devextreme/js/__internal/grids/grid_core/virtual_scrolling/virtual_scrolling_core.ts b/packages/devextreme/js/__internal/grids/grid_core/virtual_scrolling/virtual_scrolling_core.ts index 3ed19021d7b7..97bce64fd0f2 100644 --- a/packages/devextreme/js/__internal/grids/grid_core/virtual_scrolling/virtual_scrolling_core.ts +++ b/packages/devextreme/js/__internal/grids/grid_core/virtual_scrolling/virtual_scrolling_core.ts @@ -189,6 +189,11 @@ class VirtualScrollController { this._dataLoader = new VirtualDataLoader(this, this._dataOptions); } + private clearScrollTimeout(): void { + clearTimeout(this._scrollTimeoutID); + this._scrollTimeoutID = undefined; + } + public getItemSizes(): ItemSizes { return this._itemSizes; } @@ -250,10 +255,12 @@ class VirtualScrollController { const result = Deferred(); const scrollingTimeout = this.getScrollingTimeout(); - clearTimeout(this._scrollTimeoutID); + this.clearScrollTimeout(); + if (scrollingTimeout > 0) { // eslint-disable-next-line no-restricted-globals -- delays rendering by scrolling.timeout this._scrollTimeoutID = setTimeout(() => { + this._scrollTimeoutID = undefined; this._setViewportPositionCore(position); result.resolve(); }, scrollingTimeout); @@ -265,6 +272,10 @@ class VirtualScrollController { return result.promise(); } + public isViewportPositionPending(): boolean { + return isDefined(this._scrollTimeoutID); + } + public getViewportPosition(): number { return this._position; } @@ -439,7 +450,7 @@ class VirtualScrollController { } public dispose(): void { - clearTimeout(this._scrollTimeoutID); + this.clearScrollTimeout(); this._windowScroll?.dispose(); this._windowScroll = null; } From 5e6d19c762618074bbae59f0c9b45312584509aa Mon Sep 17 00:00:00 2001 From: Aliar666 Date: Mon, 16 Nov 2026 12:52:43 +0400 Subject: [PATCH 2/6] DataGrid: Simplify PageUp/PageDown focus restore and test its waiting conditions --- .../page_navigation.integration.test.ts | 44 +++++++++++++++++++ .../keyboard_navigation.ts | 40 ++++++----------- 2 files changed, 57 insertions(+), 27 deletions(-) diff --git a/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/__tests__/page_navigation.integration.test.ts b/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/__tests__/page_navigation.integration.test.ts index 36a9f87546b4..377338d2c2d4 100644 --- a/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/__tests__/page_navigation.integration.test.ts +++ b/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/__tests__/page_navigation.integration.test.ts @@ -213,6 +213,28 @@ describe('PageUp and PageDown with virtual scrolling (T898324)', () => { expect(getFocusedRowIndex()).toBe(pressCount * ROWS_PER_PAGE); }); + it('should focus the top visible row when the grid is repainted before the rows are rendered', async () => { + const instance = await createGridWithAsyncRendering(); + const pressCount = 4; + let renderCount = 0; + focusFirstCell(instance); + instance.getView('rowsView').renderCompleted.add(() => { + renderCount += 1; + }); + + Array.from({ length: pressCount }).forEach(() => { + pressKeyWithoutRendering(instance, 'pageDown'); + }); + instance.repaint(); + const isRowsRenderPendingAfterRepaint = instance.getView('rowsView').isViewportRowsRenderPending(); + const renderCountBeforeTimeout = renderCount; + jest.runAllTimers(); + + expect(renderCountBeforeTimeout).toBeGreaterThan(0); + expect(isRowsRenderPendingAfterRepaint).toBe(true); + expect(getFocusedRowIndex()).toBe(pressCount * ROWS_PER_PAGE); + }); + it('should focus the top visible row once its rows are loaded from a remote store', async () => { const instance = await createGrid({ keyExpr: undefined, @@ -270,6 +292,28 @@ describe('PageUp and PageDown with virtual scrolling (T898324)', () => { expect(getFocusedRowIndex()).toBe(1); }); + it('should not ignore downArrow pressed after PageDown while the data is reloading when scrolling is standard', async () => { + const instance = await createGrid({ + keyExpr: undefined, + dataSource: createRemoteStore(), + remoteOperations: { paging: true }, + paging: { enabled: false }, + scrolling: { mode: 'standard' }, + }); + focusFirstCell(instance); + + instance.refresh().catch(() => {}); + pressKeyWithoutRendering(instance, 'pageDown'); + const isLoadingOnFocusRestore = instance.getController('data').isLoading(); + triggerKeyDown(instance, 'downArrow', document.activeElement); + const focusedRowIndexBeforeLoading = getFocusedRowIndex(); + jest.runAllTimers(); + + expect(isLoadingOnFocusRestore).toBe(true); + expect(focusedRowIndexBeforeLoading).toBe(ROWS_PER_PAGE + 1); + expect(getFocusedRowIndex()).toBe(ROWS_PER_PAGE + 1); + }); + it('should keep the row focused by downArrow after the next render once the page navigation is completed', async () => { const instance = await createGridWithAsyncRendering(); focusFirstCell(instance); diff --git a/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/keyboard_navigation.ts b/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/keyboard_navigation.ts index 2f0a4a5991cf..cef2c4e8d8c6 100644 --- a/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/keyboard_navigation.ts +++ b/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/keyboard_navigation.ts @@ -2058,47 +2058,33 @@ export class KeyboardNavigationController extends KeyboardNavigationControllerCo } private restoreFocusableElement(rowIndex?: number, $event?: Event): void { - // eslint-disable-next-line @typescript-eslint/init-declarations -- set in the up-arrow branch - let args: FocusedRowChangingArgs | undefined; - const isUpArrow = isDefined(rowIndex); const $rowsViewElement = this._rowsView.element(); if (!$rowsViewElement) { return; } - const { columnIndex } = this._focusedCellPosition; - const rowIndexOffset = this._dataController.getRowIndexOffset(); - - let newRowIndex = isUpArrow ? rowIndex : this.getTopVisibleRowIndex(); - - if (!isUpArrow) { + if (!isDefined(rowIndex)) { this._editorFactory.loseFocus(); this.applyTabIndexToElement($rowsViewElement); eventsEngine.trigger($rowsViewElement, 'focus'); - this.isPageNavigationPending = this._rowsView.isViewportRowsRenderPending(); - - if (this.isPageNavigationPending) { - return; - } - } else { - // @ts-expect-error getRow() is typed as possibly undefined - const $rowElement: dxElementWrapper = this._rowsView.getRow(newRowIndex - rowIndexOffset); - args = this._fireFocusedRowChanging($event, $rowElement); - - if (!args.cancel && args.rowIndexChanged) { - newRowIndex = args.newRowIndex; - } + this.isPageNavigationPending = true; + this.completePageNavigation(); + return; } - if (!isUpArrow || !args?.cancel) { - this.setFocusedCellPosition(newRowIndex, columnIndex); - } + const { columnIndex } = this._focusedCellPosition; + const rowIndexOffset = this._dataController.getRowIndexOffset(); + // @ts-expect-error getRow() is typed as possibly undefined + const $rowElement: dxElementWrapper = this._rowsView.getRow(rowIndex - rowIndexOffset); + const args = this._fireFocusedRowChanging($event, $rowElement); - if (isUpArrow) { - this.updateFocus(false); + if (!args.cancel) { + this.setFocusedCellPosition(args.rowIndexChanged ? args.newRowIndex : rowIndex, columnIndex); } + + this.updateFocus(false); } private getTopVisibleRowIndex(): number { From 46b26497f53ae66be6634b14df7bfb7407ffdf16 Mon Sep 17 00:00:00 2001 From: Aliar666 Date: Mon, 16 Nov 2026 13:51:44 +0400 Subject: [PATCH 3/6] DataGrid: Add the viewport position methods to QUnit mocks --- packages/devextreme/testing/helpers/gridBaseMocks.js | 4 ++++ .../tests/DevExpress.ui.widgets.dataGrid/rowsView.tests.js | 1 + 2 files changed, 5 insertions(+) diff --git a/packages/devextreme/testing/helpers/gridBaseMocks.js b/packages/devextreme/testing/helpers/gridBaseMocks.js index 086ce9e6a659..f3ab8164dd9d 100644 --- a/packages/devextreme/testing/helpers/gridBaseMocks.js +++ b/packages/devextreme/testing/helpers/gridBaseMocks.js @@ -219,6 +219,10 @@ module.exports = function($, gridCore, columnResizingReordering, domUtils, commo setViewportPosition: function() {}, + isViewportPositionPending: function() { + return false; + }, + getVirtualContentSize: function() { return 0; }, getContentOffset: function(type) { return options.virtualItemsCount ? options.virtualItemsCount[type || 'begin'] * 20 : 0; }, diff --git a/packages/devextreme/testing/tests/DevExpress.ui.widgets.dataGrid/rowsView.tests.js b/packages/devextreme/testing/tests/DevExpress.ui.widgets.dataGrid/rowsView.tests.js index 38e7373d4628..641e30418929 100644 --- a/packages/devextreme/testing/tests/DevExpress.ui.widgets.dataGrid/rowsView.tests.js +++ b/packages/devextreme/testing/tests/DevExpress.ui.widgets.dataGrid/rowsView.tests.js @@ -5704,6 +5704,7 @@ QUnit.module('Virtual scrolling', { rowsView._dataController.viewportItemSize = x.viewportItemSize; rowsView._dataController.setContentItemSizes = x.setContentItemSizes; rowsView._dataController.setViewportPosition = x.setViewportPosition; + rowsView._dataController.clearScrollTimeout = x.clearScrollTimeout; rowsView._dataController.getItemIndexByPosition = x.getItemIndexByPosition; rowsView._dataController._setViewportPositionCore = x._setViewportPositionCore; rowsView._dataController.option = rowsView.option.bind(rowsView); From 270250ed9282bb217e8770e4fee915dfdc0e91cd Mon Sep 17 00:00:00 2001 From: Aliar666 Date: Tue, 17 Nov 2026 00:43:40 +0400 Subject: [PATCH 4/6] Fix comments --- .../page_navigation.integration.test.ts | 28 +++++++++++++++++++ .../grids/grid_core/views/rows_view.ts | 2 +- 2 files changed, 29 insertions(+), 1 deletion(-) diff --git a/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/__tests__/page_navigation.integration.test.ts b/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/__tests__/page_navigation.integration.test.ts index 377338d2c2d4..764981277872 100644 --- a/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/__tests__/page_navigation.integration.test.ts +++ b/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/__tests__/page_navigation.integration.test.ts @@ -252,6 +252,34 @@ describe('PageUp and PageDown with virtual scrolling (T898324)', () => { expect(getFocusedRowIndex()).toBe(2 * ROWS_PER_PAGE); }); + it('should focus the top visible row when PageDown is pressed during custom loading', async () => { + const instance = await createGrid(); + focusFirstCell(instance); + + instance.beginCustomLoading(''); + pressKey(instance, 'pageDown'); + + expect(getFocusedRowIndex()).toBe(ROWS_PER_PAGE); + }); + + it('should focus the top visible row once its rows are loaded from a remote store during custom loading', async () => { + const instance = await createGrid({ + keyExpr: undefined, + dataSource: createRemoteStore(), + remoteOperations: { paging: true }, + }); + focusFirstCell(instance); + pressKey(instance, 'pageDown'); + instance.beginCustomLoading(''); + + pressKeyWithoutRendering(instance, 'pageDown'); + const isDataLoadingOnFocusRestore = instance.getController('dataSource').isLoading(); + jest.runAllTimers(); + + expect(isDataLoadingOnFocusRestore).toBe(true); + expect(getFocusedRowIndex()).toBe(2 * ROWS_PER_PAGE); + }); + it('should focus the top visible row once its rows have rendered async templates', async () => { const { instance, renderPendingTemplates } = await createGridWithAsyncTemplates(); focusFirstCell(instance); diff --git a/packages/devextreme/js/__internal/grids/grid_core/views/rows_view.ts b/packages/devextreme/js/__internal/grids/grid_core/views/rows_view.ts index 51d73169a0a4..1a794521e372 100644 --- a/packages/devextreme/js/__internal/grids/grid_core/views/rows_view.ts +++ b/packages/devextreme/js/__internal/grids/grid_core/views/rows_view.ts @@ -523,7 +523,7 @@ export class RowsView extends ColumnsView { return false; } - return this._dataController.isLoading() + return this.dataSourceController.isLoading() || this._dataController.isViewportPositionPending() || this.isWaitingForRowsLayout(); } From 514dd48ce5b25044c9147e3926b3bfeebfc105d4 Mon Sep 17 00:00:00 2001 From: Aliar666 Date: Tue, 17 Nov 2026 03:25:03 +0400 Subject: [PATCH 5/6] Fix comments --- .../page_navigation.integration.test.ts | 27 +++++++++++++++++++ .../keyboard_navigation.ts | 3 ++- 2 files changed, 29 insertions(+), 1 deletion(-) diff --git a/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/__tests__/page_navigation.integration.test.ts b/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/__tests__/page_navigation.integration.test.ts index 764981277872..d0e9d41f894f 100644 --- a/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/__tests__/page_navigation.integration.test.ts +++ b/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/__tests__/page_navigation.integration.test.ts @@ -235,6 +235,20 @@ describe('PageUp and PageDown with virtual scrolling (T898324)', () => { expect(getFocusedRowIndex()).toBe(pressCount * ROWS_PER_PAGE); }); + it('should not focus the previous row when the grid is repainted before the rows are rendered', async () => { + const instance = await createGridWithAsyncRendering(); + focusFirstCell(instance); + + pressKeyWithoutRendering(instance, 'pageDown'); + instance.repaint(); + jest.advanceTimersByTime(0); + const focusedRowIndexAfterRepaint = getFocusedRowIndex(); + jest.runAllTimers(); + + expect(focusedRowIndexAfterRepaint).toBeUndefined(); + expect(getFocusedRowIndex()).toBe(ROWS_PER_PAGE); + }); + it('should focus the top visible row once its rows are loaded from a remote store', async () => { const instance = await createGrid({ keyExpr: undefined, @@ -367,4 +381,17 @@ describe('PageUp and PageDown with virtual scrolling (T898324)', () => { expect(instance.option('focusedRowIndex')).toBe(ROWS_PER_PAGE + clickedVisibleRowIndex); }); + + it('should keep the cell focused by the focus method before the rows of the new position are rendered', async () => { + const instance = await createGridWithAsyncRendering(); + const focusedVisibleRowIndex = 2; + focusFirstCell(instance); + pressKey(instance, 'pageDown'); + + pressKeyWithoutRendering(instance, 'pageUp'); + instance.focus(instance.getCellElement(focusedVisibleRowIndex, 0) as HTMLElement); + jest.runAllTimers(); + + expect(instance.option('focusedRowIndex')).toBe(ROWS_PER_PAGE + focusedVisibleRowIndex); + }); }); diff --git a/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/keyboard_navigation.ts b/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/keyboard_navigation.ts index cef2c4e8d8c6..fef2360d9f91 100644 --- a/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/keyboard_navigation.ts +++ b/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/keyboard_navigation.ts @@ -351,7 +351,7 @@ export class KeyboardNavigationController extends KeyboardNavigationControllerCo this.initKeyDownHandler(); this._setRowsViewAttributes(); - if (isFocusedViewCorrect && isFocusedElementCorrect) { + if (isFocusedViewCorrect && isFocusedElementCorrect && !this.isPageNavigationPending) { const needUpdateFocus = this._isNeedFocus ? !isAppend : this._isHiddenFocus && isFullUpdate && !e?.virtualColumnsScrolling; @@ -1823,6 +1823,7 @@ export class KeyboardNavigationController extends KeyboardNavigationControllerCo } if (!args.cancel) { + this.isPageNavigationPending = false; this.applyFocus($elementToFocus, !args.isHighlighted); if (this.getElementType($elementToFocus) !== 'row' || isEditRow($elementToFocus)) { From 287f030bbdf1a51090a19660df6afaf01d520ddc Mon Sep 17 00:00:00 2001 From: Aliar666 Date: Wed, 18 Nov 2026 17:15:37 +0400 Subject: [PATCH 6/6] Fix comments --- .../data_controller/data_controller.ts | 7 -- .../page_navigation.integration.test.ts | 107 ++++++++++++++++++ .../keyboard_navigation.ts | 9 +- .../grids/grid_core/views/rows_view.ts | 14 +-- .../grid_core/virtual_scrolling/types.ts | 1 + .../virtual_scrolling/virtual_scrolling.ts | 16 +++ 6 files changed, 135 insertions(+), 19 deletions(-) diff --git a/packages/devextreme/js/__internal/grids/grid_core/data_controller/data_controller.ts b/packages/devextreme/js/__internal/grids/grid_core/data_controller/data_controller.ts index c8cca6802d32..f49d560f7f30 100644 --- a/packages/devextreme/js/__internal/grids/grid_core/data_controller/data_controller.ts +++ b/packages/devextreme/js/__internal/grids/grid_core/data_controller/data_controller.ts @@ -1454,13 +1454,6 @@ export class DataController extends modules.Controller { return 0; } - /** - * @extended: virtual_scrolling - */ - public isViewportPositionPending(): boolean { - return false; - } - private changePaging(optionName: PagingOptionName, value?: number): PagingResult { const dataSourceAdapter = this.dataSourceController.getAdapter(); diff --git a/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/__tests__/page_navigation.integration.test.ts b/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/__tests__/page_navigation.integration.test.ts index d0e9d41f894f..dfd244b95625 100644 --- a/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/__tests__/page_navigation.integration.test.ts +++ b/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/__tests__/page_navigation.integration.test.ts @@ -394,4 +394,111 @@ describe('PageUp and PageDown with virtual scrolling (T898324)', () => { expect(instance.option('focusedRowIndex')).toBe(ROWS_PER_PAGE + focusedVisibleRowIndex); }); + + it.each([ + { optionName: 'focusedRowKey', value: null, expectedFocusedRowIndex: -1 }, + { optionName: 'focusedRowKey', value: 3 * ROWS_PER_PAGE, expectedFocusedRowIndex: 3 * ROWS_PER_PAGE }, + { optionName: 'focusedRowIndex', value: 7, expectedFocusedRowIndex: 7 }, + ])('should keep $optionName set to $value before the rows of the new position are rendered', async ({ optionName, value, expectedFocusedRowIndex }) => { + const instance = await createGrid({ + focusedRowEnabled: true, + scrolling: { mode: 'virtual', renderAsync: true }, + }); + focusFirstCell(instance); + + pressKeyWithoutRendering(instance, 'pageDown'); + instance.option(optionName, value); + jest.runAllTimers(); + + expect(instance.option('focusedRowIndex')).toBe(expectedFocusedRowIndex); + }); + + it('should keep the focused row reset by onFocusedRowChanging on a click before the rows of the new position are rendered', async () => { + let isFocusedRowResetOnChanging = false; + const instance = await createGrid({ + focusedRowEnabled: true, + scrolling: { mode: 'virtual', renderAsync: true }, + onFocusedRowChanging: (e) => { + if (isFocusedRowResetOnChanging) { + e.newRowIndex = -1; + } + }, + }); + focusFirstCell(instance); + + pressKeyWithoutRendering(instance, 'pageDown'); + isFocusedRowResetOnChanging = true; + clickRow(instance, 2); + jest.runAllTimers(); + + expect(instance.option('focusedRowIndex')).toBe(-1); + }); + + it('should focus the top visible row once its rows are loaded from a remote store while all rows are being selected', async () => { + const instance = await createGrid({ + keyExpr: undefined, + dataSource: createRemoteStore(), + remoteOperations: { paging: true }, + selection: { mode: 'multiple', selectAllMode: 'allPages' }, + }); + focusFirstCell(instance); + pressKey(instance, 'pageDown'); + + instance.selectAll().catch(() => {}); + pressKey(instance, 'pageDown'); + + expect(getFocusedRowIndex()).toBe(2 * ROWS_PER_PAGE); + }); + + it('should focus the top visible row when a click is canceled while its rows are loaded from a remote store', async () => { + const instance = await createGrid({ + keyExpr: undefined, + dataSource: createRemoteStore(), + remoteOperations: { paging: true }, + }); + focusFirstCell(instance); + pressKey(instance, 'pageDown'); + + pressKeyWithoutRendering(instance, 'pageDown'); + clickRow(instance, 2); + jest.runAllTimers(); + + expect(getFocusedRowIndex()).toBe(2 * ROWS_PER_PAGE); + }); + + it('should focus the top visible row when onFocusedCellChanging cancels a click before the rows of the new position are rendered', async () => { + let isClickCanceled = false; + const instance = await createGrid({ + scrolling: { mode: 'virtual', renderAsync: true }, + onFocusedCellChanging: (e) => { + e.cancel = isClickCanceled; + }, + }); + focusFirstCell(instance); + + pressKeyWithoutRendering(instance, 'pageDown'); + isClickCanceled = true; + clickRow(instance, 2); + jest.runAllTimers(); + + expect(getFocusedRowIndex()).toBe(ROWS_PER_PAGE); + }); + + it.each(['refresh', 'push'])('should focus the top visible row when the focused row is restored after %s before the rows of the new position are rendered', async (operation) => { + const instance = await createGrid({ + focusedRowEnabled: true, + scrolling: { mode: 'virtual', renderAsync: true }, + }); + focusFirstCell(instance); + + pressKeyWithoutRendering(instance, 'pageDown'); + if (operation === 'refresh') { + instance.refresh().catch(() => {}); + } else { + instance.getDataSource().store().push([{ type: 'update', key: 2, data: { name: 'Updated' } }]); + } + jest.runAllTimers(); + + expect(instance.option('focusedRowIndex')).toBe(ROWS_PER_PAGE); + }); }); diff --git a/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/keyboard_navigation.ts b/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/keyboard_navigation.ts index fef2360d9f91..6c678c198c03 100644 --- a/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/keyboard_navigation.ts +++ b/packages/devextreme/js/__internal/grids/grid_core/keyboard_navigation/keyboard_navigation.ts @@ -1723,7 +1723,6 @@ export class KeyboardNavigationController extends KeyboardNavigationControllerCo this.setRowFocusType(); } - this.isPageNavigationPending = false; this._updateFocusedCellPosition($targetCell); if (this._allowRowUpdating() && isCellOrBatchEditMode && column?.allowEditing) { @@ -1823,7 +1822,6 @@ export class KeyboardNavigationController extends KeyboardNavigationControllerCo } if (!args.cancel) { - this.isPageNavigationPending = false; this.applyFocus($elementToFocus, !args.isHighlighted); if (this.getElementType($elementToFocus) !== 'row' || isEditRow($elementToFocus)) { @@ -2088,6 +2086,13 @@ export class KeyboardNavigationController extends KeyboardNavigationControllerCo this.updateFocus(false); } + public setFocusedRowIndex(rowIndex: number | undefined): void { + if (rowIndex !== this._focusedCellPosition?.rowIndex) { + this.isPageNavigationPending = false; + } + super.setFocusedRowIndex(rowIndex); + } + private getTopVisibleRowIndex(): number { return this._rowsView.getTopVisibleItemIndex() + this._dataController.getRowIndexOffset(); } diff --git a/packages/devextreme/js/__internal/grids/grid_core/views/rows_view.ts b/packages/devextreme/js/__internal/grids/grid_core/views/rows_view.ts index 1a794521e372..ab57297104e2 100644 --- a/packages/devextreme/js/__internal/grids/grid_core/views/rows_view.ts +++ b/packages/devextreme/js/__internal/grids/grid_core/views/rows_view.ts @@ -515,17 +515,11 @@ export class RowsView extends ColumnsView { return this._findContentElement(); } + /** + * @extended: virtual_scrolling + */ public isViewportRowsRenderPending(): boolean { - const scrolling = this.option('scrolling'); - const isVirtualRender = isVirtualPaging(scrolling) || isVirtualRowRendering(scrolling); - - if (!isVirtualRender) { - return false; - } - - return this.dataSourceController.isLoading() - || this._dataController.isViewportPositionPending() - || this.isWaitingForRowsLayout(); + return false; } public isWaitingForRowsLayout(): boolean { diff --git a/packages/devextreme/js/__internal/grids/grid_core/virtual_scrolling/types.ts b/packages/devextreme/js/__internal/grids/grid_core/virtual_scrolling/types.ts index 4becedfdbe3e..989b5158801c 100644 --- a/packages/devextreme/js/__internal/grids/grid_core/virtual_scrolling/types.ts +++ b/packages/devextreme/js/__internal/grids/grid_core/virtual_scrolling/types.ts @@ -97,6 +97,7 @@ export interface VirtualScrollingDataControllerExtension { viewportHeight: (height: number, scrollTop?: number) => void; viewportItemSize: (size?: number) => number | undefined; setViewportPosition: (position: number) => void; + isViewportPositionPending: () => boolean; setContentItemSizes: (sizes: number[]) => void; getItemSize: () => number | undefined; getItemSizes: () => ItemSizes | undefined; diff --git a/packages/devextreme/js/__internal/grids/grid_core/virtual_scrolling/virtual_scrolling.ts b/packages/devextreme/js/__internal/grids/grid_core/virtual_scrolling/virtual_scrolling.ts index 95f31e246af4..43746867d057 100644 --- a/packages/devextreme/js/__internal/grids/grid_core/virtual_scrolling/virtual_scrolling.ts +++ b/packages/devextreme/js/__internal/grids/grid_core/virtual_scrolling/virtual_scrolling.ts @@ -590,6 +590,22 @@ export const rowsView = ( this._scrollToCurrentPageOnResize(); } + public isViewportRowsRenderPending(): boolean { + const scrolling = this.option('scrolling'); + const isVirtualRender = isVirtualPaging(scrolling) || isVirtualRowRendering(scrolling); + + if (!isVirtualRender) { + return false; + } + + const isViewportDataLoading = this.dataSourceController.isLoading() + && !this.dataSourceController.getAdapter()?.customLoader.isLoading(); + + return isViewportDataLoading + || this._dataController.isViewportPositionPending() + || this.isWaitingForRowsLayout(); + } + private _scrollToCurrentPageOnResize(): void { if (this._dataController.pageIndex() > 0) { const resizeHandler = (): void => {