From b5db2ca74cee97372fb24e7888013934109edeca Mon Sep 17 00:00:00 2001 From: Arkan Ahmedov Date: Thu, 23 Jul 2026 16:46:06 +0300 Subject: [PATCH 1/3] fix(grid): ensure final settle position in momentum scroll with trailing option --- .../igniteui-angular/grids/grid/src/grid-base.directive.ts | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/projects/igniteui-angular/grids/grid/src/grid-base.directive.ts b/projects/igniteui-angular/grids/grid/src/grid-base.directive.ts index ee11fce0646..d6abade655f 100644 --- a/projects/igniteui-angular/grids/grid/src/grid-base.directive.ts +++ b/projects/igniteui-angular/grids/grid/src/grid-base.directive.ts @@ -3697,7 +3697,12 @@ export abstract class IgxGridBaseDirective implements GridType, this.throttleTime$.pipe( take(1), switchMap(time => timer(time, this.throttleScheduler)) - ) + ), + // `trailing: true` ensures the final settle position of a fast momentum + // scroll is processed; otherwise the last scroll events are dropped and the + // rows stay frozen at an intermediate startIndex while the scrollbar is at top. + // `leading: true` keeps the immediate response on scroll start. + { leading: true, trailing: true } ), destructor ) From 0435932076beecf281b8da6fdc7b1d81c23ee9ff Mon Sep 17 00:00:00 2001 From: Arkan Ahmedov Date: Fri, 24 Jul 2026 12:59:15 +0300 Subject: [PATCH 2/3] test(grid): add regression coverage for momentum-scroll trailing settle Drives the vertical scrollNotify stream with an intermediate (leading-edge) position followed by a scrollTop=0 settle in the same throttle window, so the settle can only be delivered on the trailing edge. Asserts the grid resets to startIndex 0 / renders row 0, guarding against the dropped-trailing throttle config that left the top rows frozen out of view. --- .../grids/grid/src/grid.component.spec.ts | 52 +++++++++++++++++++ 1 file changed, 52 insertions(+) diff --git a/projects/igniteui-angular/grids/grid/src/grid.component.spec.ts b/projects/igniteui-angular/grids/grid/src/grid.component.spec.ts index 07b9e63e6c7..03d34e08fbb 100644 --- a/projects/igniteui-angular/grids/grid/src/grid.component.spec.ts +++ b/projects/igniteui-angular/grids/grid/src/grid.component.spec.ts @@ -3310,6 +3310,49 @@ describe('IgxGrid Component Tests #grid', () => { expect(() => fix.detectChanges()).not.toThrow(); }); }); + + describe('IgxGrid - scroll throttle trailing edge', () => { + beforeEach(waitForAsync(() => { + TestBed.configureTestingModule({ + imports: [NoopAnimationsModule, IgxGridScrollThrottleComponent], + providers: [{ provide: SCROLL_THROTTLE_TIME_MULTIPLIER, useValue: 0 }] + }).compileComponents(); + })); + + it('should settle at the top row when a fast momentum scroll ends at scrollTop 0 (throttle trailing edge)', async () => { + const fix = TestBed.createComponent(IgxGridScrollThrottleComponent); + fix.detectChanges(); + await wait(50); + fix.detectChanges(); + const grid = fix.componentInstance.grid; + const virtDir = grid.verticalScrollContainer; + const scrollEl = virtDir.getScroll(); + const maxScroll = scrollEl.scrollHeight - scrollEl.clientHeight; + + // Move away from the top so the first rows are virtualized out of view. + grid.scrollNotify.next({ target: { scrollTop: maxScroll } }); + await wait(50); + fix.detectChanges(); + expect(virtDir.state.startIndex).toBeGreaterThan(0); + + // Simulate a fast momentum/inertia scroll back to the top: an intermediate + // position lands on the throttle's leading edge and the scrollTop = 0 settle + // arrives within the same throttle window - timer(0, animationFrameScheduler) + // still defers the window close to the next frame - so it can only be delivered + // on the trailing edge. Feeding scrollNotify directly (instead of setting + // scrollTop) avoids the browser's async native scroll events, which all read the + // final scrollTop of 0, from masking a dropped-trailing regression. + grid.scrollNotify.next({ target: { scrollTop: Math.round(maxScroll / 2) } }); + grid.scrollNotify.next({ target: { scrollTop: 0 } }); + await wait(50); + fix.detectChanges(); + + // Without the trailing edge the settle event is dropped and the grid stays + // frozen at an intermediate startIndex while the scrollbar sits at the top. + expect(virtDir.state.startIndex).toBe(0); + expect(grid.gridAPI.get_row_by_index(0)).toBeDefined(); + }); + }); }); @Component({ @@ -4051,3 +4094,12 @@ export class IgxGridPerformanceComponent implements AfterViewInit, OnInit { export class IgxGridNoDataComponent { @ViewChild(IgxGridComponent, { static: true }) public grid: IgxGridComponent; } + +@Component({ + template: ``, + imports: [IgxGridComponent] +}) +class IgxGridScrollThrottleComponent { + @ViewChild(IgxGridComponent, { static: true }) public grid: IgxGridComponent; + public data = Array.from({ length: 200 }, (_row, index) => ({ ID: index, Name: `Record ${index}`, Value: index * 10 })); +} From fc0ba5de1acf0e781e091949237c170b442db1ca Mon Sep 17 00:00:00 2001 From: Arkan Ahmedov Date: Mon, 3 Aug 2026 12:50:31 +0300 Subject: [PATCH 3/3] test(grid): sync throttle-trailing test with review updates Match the base-branch test: place under the virtualization tests, use a fixture that overflows horizontally (30 columns) with an overflow assertion, and add the bottom-boundary case (#17464). --- .../grids/grid/src/grid.component.spec.ts | 119 +++++++++++------- 1 file changed, 75 insertions(+), 44 deletions(-) diff --git a/projects/igniteui-angular/grids/grid/src/grid.component.spec.ts b/projects/igniteui-angular/grids/grid/src/grid.component.spec.ts index 03d34e08fbb..41d2fd7f13f 100644 --- a/projects/igniteui-angular/grids/grid/src/grid.component.spec.ts +++ b/projects/igniteui-angular/grids/grid/src/grid.component.spec.ts @@ -882,6 +882,73 @@ describe('IgxGrid Component Tests #grid', () => { expect(grid.verticalScrollContainer.getScroll().scrollTop).toBe(initialScroll); expect(grid.headerContainer.getScroll().scrollLeft).toBeGreaterThanOrEqual(2 * (initialHorScroll + 50)); })); + + describe('scroll throttle trailing edge', () => { + beforeEach(waitForAsync(() => { + TestBed.configureTestingModule({ + imports: [NoopAnimationsModule, IgxGridScrollThrottleComponent], + providers: [{ provide: SCROLL_THROTTLE_TIME_MULTIPLIER, useValue: 0 }] + }).compileComponents(); + })); + + // Drive scrollNotify directly (not programmatic scrollTop, whose async native events would mask a dropped-trailing regression) to exercise the throttle window deterministically. + it('should settle at the top row after a fast momentum scroll back to scrollTop 0', async () => { + const fix = TestBed.createComponent(IgxGridScrollThrottleComponent); + fix.detectChanges(); + await wait(50); + fix.detectChanges(); + const grid = fix.componentInstance.grid; + const virtDir = grid.verticalScrollContainer; + const scrollEl = virtDir.getScroll(); + const hScroll = grid.headerContainer.getScroll(); + const maxScroll = scrollEl.scrollHeight - scrollEl.clientHeight; + + // Guard the reproduction condition: the fixture must overflow horizontally. + expect(hScroll.scrollWidth).toBeGreaterThan(hScroll.clientWidth); + + // Move away from the top so the first rows are virtualized out of view. + grid.scrollNotify.next({ target: { scrollTop: maxScroll } }); + await wait(50); + fix.detectChanges(); + expect(virtDir.state.startIndex).toBeGreaterThan(0); + + // Momentum scroll back to top: intermediate on the leading edge, scrollTop = 0 settle only on the trailing edge. + grid.scrollNotify.next({ target: { scrollTop: Math.round(maxScroll / 2) } }); + grid.scrollNotify.next({ target: { scrollTop: 0 } }); + await wait(50); + fix.detectChanges(); + + // Without the trailing edge the settle is dropped and startIndex stays frozen mid-list. + expect(virtDir.state.startIndex).toBe(0); + expect(grid.gridAPI.get_row_by_index(0)).toBeDefined(); + }); + + it('should settle at the last row after a fast momentum scroll to the bottom', async () => { + const fix = TestBed.createComponent(IgxGridScrollThrottleComponent); + fix.detectChanges(); + await wait(50); + fix.detectChanges(); + const grid = fix.componentInstance.grid; + const virtDir = grid.verticalScrollContainer; + const scrollEl = virtDir.getScroll(); + const hScroll = grid.headerContainer.getScroll(); + const maxScroll = scrollEl.scrollHeight - scrollEl.clientHeight; + const lastIndex = fix.componentInstance.data.length - 1; + + expect(hScroll.scrollWidth).toBeGreaterThan(hScroll.clientWidth); + expect(virtDir.state.startIndex).toBe(0); + + // Momentum scroll top to bottom: intermediate on the leading edge, max-scroll settle only on the trailing edge. + grid.scrollNotify.next({ target: { scrollTop: Math.round(maxScroll / 2) } }); + grid.scrollNotify.next({ target: { scrollTop: maxScroll } }); + await wait(50); + fix.detectChanges(); + + // Without the trailing edge the settle is dropped and the last row is never brought into view. + expect((virtDir.state.startIndex ?? 0) + (virtDir.state.chunkSize ?? 0)).toBeGreaterThanOrEqual(lastIndex + 1); + expect(grid.gridAPI.get_row_by_index(lastIndex)).toBeDefined(); + }); + }); }); describe('IgxGrid - default rendering for rows and columns', () => { @@ -3310,49 +3377,6 @@ describe('IgxGrid Component Tests #grid', () => { expect(() => fix.detectChanges()).not.toThrow(); }); }); - - describe('IgxGrid - scroll throttle trailing edge', () => { - beforeEach(waitForAsync(() => { - TestBed.configureTestingModule({ - imports: [NoopAnimationsModule, IgxGridScrollThrottleComponent], - providers: [{ provide: SCROLL_THROTTLE_TIME_MULTIPLIER, useValue: 0 }] - }).compileComponents(); - })); - - it('should settle at the top row when a fast momentum scroll ends at scrollTop 0 (throttle trailing edge)', async () => { - const fix = TestBed.createComponent(IgxGridScrollThrottleComponent); - fix.detectChanges(); - await wait(50); - fix.detectChanges(); - const grid = fix.componentInstance.grid; - const virtDir = grid.verticalScrollContainer; - const scrollEl = virtDir.getScroll(); - const maxScroll = scrollEl.scrollHeight - scrollEl.clientHeight; - - // Move away from the top so the first rows are virtualized out of view. - grid.scrollNotify.next({ target: { scrollTop: maxScroll } }); - await wait(50); - fix.detectChanges(); - expect(virtDir.state.startIndex).toBeGreaterThan(0); - - // Simulate a fast momentum/inertia scroll back to the top: an intermediate - // position lands on the throttle's leading edge and the scrollTop = 0 settle - // arrives within the same throttle window - timer(0, animationFrameScheduler) - // still defers the window close to the next frame - so it can only be delivered - // on the trailing edge. Feeding scrollNotify directly (instead of setting - // scrollTop) avoids the browser's async native scroll events, which all read the - // final scrollTop of 0, from masking a dropped-trailing regression. - grid.scrollNotify.next({ target: { scrollTop: Math.round(maxScroll / 2) } }); - grid.scrollNotify.next({ target: { scrollTop: 0 } }); - await wait(50); - fix.detectChanges(); - - // Without the trailing edge the settle event is dropped and the grid stays - // frozen at an intermediate startIndex while the scrollbar sits at the top. - expect(virtDir.state.startIndex).toBe(0); - expect(grid.gridAPI.get_row_by_index(0)).toBeDefined(); - }); - }); }); @Component({ @@ -4101,5 +4125,12 @@ export class IgxGridNoDataComponent { }) class IgxGridScrollThrottleComponent { @ViewChild(IgxGridComponent, { static: true }) public grid: IgxGridComponent; - public data = Array.from({ length: 200 }, (_row, index) => ({ ID: index, Name: `Record ${index}`, Value: index * 10 })); + // 30 columns in a 600px-wide grid guarantee horizontal overflow, plus 200 rows for vertical virtualization. + public data = Array.from({ length: 200 }, (_row, rowIndex) => { + const record: Record = { ID: rowIndex }; + for (let col = 0; col < 30; col++) { + record[`Col${col}`] = `r${rowIndex}c${col}`; + } + return record; + }); }