fix: fix normalization and add tests

Author: sjbur

packages/devextreme/js/__internal/scheduler/__tests__/workspace.test.ts

@@ -80,7 +80,7 @@ describe('Workspace', () => {
     });
   });
 
-  describe('scrollTo (T1310544)', () => {
+  describe('scrollTo', () => {
     beforeEach(() => {
       fx.off = true;
       setupSchedulerTestEnvironment({ height: 600 });
@@ -125,5 +125,109 @@ describe('Workspace', () => {
 
       scrollBySpy.mockRestore();
     });
+
+    describe('hour normalization', () => {
+      it('should normalize hours to visible range without viewOffset', async () => {
+        const { scheduler } = await createScheduler({
+          views: ['timelineDay'],
+          currentView: 'timelineDay',
+          currentDate: new Date(2021, 1, 2),
+          startDayHour: 6,
+          endDayHour: 18,
+          offset: 0,
+        });
+
+        const workspace = scheduler.getWorkSpace();
+        const scrollable = workspace.getScrollable();
+        const scrollBySpy = jest.spyOn(scrollable, 'scrollBy');
+
+        // Below startDayHour (6), should normalize to 6
+        const dateBelowRange = new Date(2021, 1, 2, 4, 0);
+        scheduler.scrollTo(dateBelowRange, undefined, false);
+        expect(scrollBySpy).toHaveBeenCalled();
+
+        scrollBySpy.mockClear();
+        // Above endDayHour (18), should normalize to 17
+        const dateAboveRange = new Date(2021, 1, 2, 20, 0);
+        scheduler.scrollTo(dateAboveRange, undefined, false);
+        expect(scrollBySpy).toHaveBeenCalled();
+
+        scrollBySpy.mockClear();
+        // Within range [6, 18), should scroll normally
+        const dateInRange = new Date(2021, 1, 2, 12, 0);
+        scheduler.scrollTo(dateInRange, undefined, false);
+        expect(scrollBySpy).toHaveBeenCalled();
+
+        scrollBySpy.mockRestore();
+      });
+
+      it('should normalize hours to visible range with viewOffset (no midnight crossing)', async () => {
+        const { scheduler } = await createScheduler({
+          views: ['timelineDay'],
+          currentView: 'timelineDay',
+          currentDate: new Date(2021, 1, 2),
+          startDayHour: 6,
+          endDayHour: 18,
+          offset: 360,
+        });
+
+        const workspace = scheduler.getWorkSpace();
+        const scrollable = workspace.getScrollable();
+        const scrollBySpy = jest.spyOn(scrollable, 'scrollBy');
+
+        // Below adjustedStartDayHour (12), should normalize to 12
+        const dateBelowAdjustedRange = new Date(2021, 1, 2, 10, 0);
+        scheduler.scrollTo(dateBelowAdjustedRange, undefined, false);
+        expect(scrollBySpy).toHaveBeenCalled();
+
+        scrollBySpy.mockClear();
+        // Within adjusted range [12, 24), should scroll normally
+        const dateInAdjustedRange = new Date(2021, 1, 2, 15, 0);
+        scheduler.scrollTo(dateInAdjustedRange, undefined, false);
+        expect(scrollBySpy).toHaveBeenCalled();
+
+        scrollBySpy.mockRestore();
+      });
+
+      it('should normalize hours to visible range with viewOffset (midnight crossing)', async () => {
+        const { scheduler } = await createScheduler({
+          views: ['timelineDay'],
+          currentView: 'timelineDay',
+          currentDate: new Date(2021, 1, 2),
+          startDayHour: 6,
+          endDayHour: 18,
+          offset: 720,
+        });
+
+        const workspace = scheduler.getWorkSpace();
+        const scrollable = workspace.getScrollable();
+        const scrollBySpy = jest.spyOn(scrollable, 'scrollBy');
+
+        // In gap [6, 18), should normalize to 18:00 Feb 2
+        const dateInGap = new Date(2021, 1, 2, 10, 0);
+        scheduler.scrollTo(dateInGap, undefined, false);
+        expect(scrollBySpy).toHaveBeenCalled();
+
+        scrollBySpy.mockClear();
+        // In range [18, 24) on Feb 2, should scroll normally
+        const dateInFirstRange = new Date(2021, 1, 2, 22, 0);
+        scheduler.scrollTo(dateInFirstRange, undefined, false);
+        expect(scrollBySpy).toHaveBeenCalled();
+
+        scrollBySpy.mockClear();
+        // In range [0, 6) but on wrong day (Feb 2), should normalize to 18:00 Feb 2
+        const dateInSecondRangeWrongDay = new Date(2021, 1, 2, 3, 0);
+        scheduler.scrollTo(dateInSecondRangeWrongDay, undefined, false);
+        expect(scrollBySpy).toHaveBeenCalled();
+
+        scrollBySpy.mockClear();
+        // In range [0, 6) on correct day (Feb 3), should scroll normally
+        const dateInSecondRangeCorrectDay = new Date(2021, 1, 3, 3, 0);
+        scheduler.scrollTo(dateInSecondRangeCorrectDay, undefined, false);
+        expect(scrollBySpy).toHaveBeenCalled();
+
+        scrollBySpy.mockRestore();
+      });
+    });
   });
 });

packages/devextreme/js/__internal/scheduler/workspaces/m_work_space.ts

@@ -1407,30 +1407,68 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
     return (this.$element() as any).find(`.${GROUP_HEADER_CLASS}`);
   }
 
-  _getScrollCoordinates(hours, minutes, date, groupIndex?: any, allDay?: any) {
-    const currentDate = date || new Date(this.option('currentDate'));
+  _getAdjustedHourBoundaries() {
     const startDayHour = this.option('startDayHour');
     const endDayHour = this.option('endDayHour');
-    const viewOffset = this.option('viewOffset');
+    const viewOffset = this.option('viewOffset') as number;
+    const viewOffsetHours = viewOffset / HOUR_MS;
+    const adjustedStartDayHour = (startDayHour + viewOffsetHours) % 24;
+    const adjustedEndDayHour = (endDayHour + viewOffsetHours) % 24;
+    const crossesMidnight = adjustedStartDayHour >= adjustedEndDayHour;
 
-    if (viewOffset === 0) {
-      if (hours < startDayHour) {
-        hours = startDayHour;
-      }
+    return { adjustedStartDayHour, adjustedEndDayHour, crossesMidnight };
+  }
 
-      if (hours >= endDayHour) {
-        hours = endDayHour - 1;
+  _normalizeHoursForScroll(hours: number, date: Date): { normalizedHours: number; normalizedDate: Date } {
+    const min = this.getStartViewDate();
+    const { adjustedStartDayHour, adjustedEndDayHour, crossesMidnight } = this._getAdjustedHourBoundaries();
+    const dateDayStart = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+    const minDayStart = new Date(min.getFullYear(), min.getMonth(), min.getDate());
+    const nextDay = new Date(minDayStart);
+    nextDay.setDate(nextDay.getDate() + 1);
+
+    let normalizedDate: Date;
+    let normalizedHours = hours;
+
+    if (crossesMidnight) {
+      // Boundaries cross midnight: [adjustedStartDayHour, 24) on minDay ∪ [0, adjustedEndDayHour) on next day
+      const isOnMinDay = dateDayStart.getTime() === minDayStart.getTime();
+      const isOnNextDay = dateDayStart.getTime() === nextDay.getTime();
+
+      if (hours >= adjustedStartDayHour && isOnMinDay) {
+        // Valid: hours [adjustedStartDayHour, 24) on minDay
+        normalizedDate = new Date(minDayStart);
+      } else if (hours < adjustedEndDayHour && isOnNextDay) {
+        // Valid: hours [0, adjustedEndDayHour) on next day
+        normalizedDate = new Date(nextDay);
+      } else {
+        // Normalize to adjustedStartDayHour on minDay
+        normalizedDate = new Date(minDayStart);
+        normalizedHours = adjustedStartDayHour;
+      }
+    } else {
+      // Normal case: boundaries don't cross midnight
+      normalizedDate = new Date(minDayStart);
+      if (hours < adjustedStartDayHour) {
+        normalizedHours = adjustedStartDayHour;
+      } else if (hours >= adjustedEndDayHour) {
+        normalizedHours = adjustedEndDayHour - 1;
       }
     }
 
-    currentDate.setHours(hours, minutes, 0, 0);
+    return { normalizedHours, normalizedDate };
+  }
+
+  _getScrollCoordinates(hours: number, minutes: number, date: Date, groupIndex?: number, allDay?: boolean) {
+    const { normalizedHours, normalizedDate } = this._normalizeHoursForScroll(hours, date);
+    normalizedDate.setHours(normalizedHours, minutes, 0, 0);
 
-    const cell = this.viewDataProvider.findGlobalCellPosition(currentDate, groupIndex, allDay);
+    const cell = this.viewDataProvider.findGlobalCellPosition(normalizedDate, groupIndex, allDay);
 
     return this.virtualScrollingDispatcher.calculateCoordinatesByDataAndPosition(
       cell?.cellData,
       cell?.position,
-      currentDate,
+      normalizedDate,
       isDateAndTimeView(this.type as any),
       this.viewDirection === 'vertical',
     );
@@ -1868,14 +1906,28 @@ class SchedulerWorkSpace extends Widget<WorkspaceOptionsInternal> {
   }
 
   _isValidScrollDate(date, throwWarning = true) {
-    const viewOffset = this.option('viewOffset') as number;
     const min = this.getStartViewDate();
     const max = this.getEndViewDate();
+    const { crossesMidnight } = this._getAdjustedHourBoundaries();
+
+    const dateDayStart = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+    const minDayStart = new Date(min.getFullYear(), min.getMonth(), min.getDate());
+    const maxDayStart = new Date(max.getFullYear(), max.getMonth(), max.getDate());
+
+    let isDayValid = false;
+    if (crossesMidnight) {
+      // Boundaries cross midnight: allow minDay or nextDay
+      const nextDay = new Date(minDayStart);
+      nextDay.setDate(nextDay.getDate() + 1);
+      isDayValid = dateDayStart.getTime() === minDayStart.getTime()
+        || dateDayStart.getTime() === nextDay.getTime()
+        || (dateDayStart >= minDayStart && dateDayStart <= maxDayStart);
+    } else {
+      // Normal case: date should be within [minDay, maxDay]
+      isDayValid = dateDayStart >= minDayStart && dateDayStart <= maxDayStart;
+    }
 
-    const extendedMin = new Date(min.getTime() - viewOffset);
-    const extendedMax = new Date(max.getTime() + viewOffset);
-
-    if (date < extendedMin || date > extendedMax) {
+    if (!isDayValid) {
       throwWarning && errors.log('W1008', date);
       return false;
     }