Scheduler: Add timezones cache (T1296816) (DevExpress#30276)

Co-authored-by: Vladimir Bushmanov <vladimir.bushmanov@devexpress.com>

Author: Ambrozy

packages/devextreme/js/__internal/scheduler/global_cache.test.ts

@@ -0,0 +1,75 @@
+import {
+  describe, expect, it, jest,
+} from '@jest/globals';
+
+import { Cache } from './global_cache';
+
+describe('global cache', () => {
+  it('should be empty at initialization', () => {
+    const cache = new Cache();
+    expect(cache.size).toBe(0);
+  });
+
+  it('should get non-existed value', () => {
+    const cache = new Cache();
+
+    expect(cache.get('test0')).toBe(undefined);
+  });
+
+  it('should get existed value', () => {
+    const cache = new Cache();
+    cache.memo('test0', () => 'callbackValue');
+
+    expect(cache.get('test0')).toBe('callbackValue');
+  });
+
+  it('should memo value', () => {
+    const cache = new Cache();
+    const valueCallback = jest.fn().mockReturnValue(1).mockReturnValueOnce(2);
+    const memoValue = cache.memo('test', valueCallback);
+
+    expect(cache.get('test')).toBe(memoValue);
+    expect(cache.size).toBe(1);
+  });
+
+  it('should memo twice for deleted value', () => {
+    const cache = new Cache();
+    const valueCallback1 = jest.fn().mockReturnValue(1).mockReturnValueOnce(2);
+    const valueCallback2 = jest.fn().mockReturnValue(1).mockReturnValueOnce(2);
+    const memoValue1 = cache.memo('test1', valueCallback1);
+    const memoValue2 = cache.memo('test2', valueCallback2);
+    cache.delete('test1');
+
+    expect(cache.size).toBe(1);
+    expect(cache.memo('test1', valueCallback1)).not.toBe(memoValue1);
+    expect(cache.memo('test2', valueCallback2)).toBe(memoValue2);
+    expect(cache.size).toBe(2);
+  });
+
+  it('should delete existed value', () => {
+    const cache = new Cache();
+    cache.memo('test1', () => 'callbackValue1');
+    cache.delete('test1');
+
+    expect(cache.get('test1')).toBe(undefined);
+    expect(cache.size).toBe(0);
+  });
+
+  it('should delete non-existed value', () => {
+    const cache = new Cache();
+    cache.memo('test1', () => 'callbackValue1');
+    cache.memo('test2', () => 'callbackValue2');
+    cache.delete('non-existed');
+
+    expect(cache.size).toBe(2);
+  });
+
+  it('should clear all values', () => {
+    const cache = new Cache();
+    cache.memo('test0', () => 'callbackValue');
+    cache.memo('test1', () => 'callbackValue');
+    cache.clear();
+
+    expect(cache.size).toBe(0);
+  });
+});

packages/devextreme/js/__internal/scheduler/global_cache.ts

@@ -0,0 +1,35 @@
+import { isDefined } from '@js/core/utils/type';
+
+export class Cache {
+  private readonly cache = new Map();
+
+  get size(): number { return this.cache.size; }
+
+  clear(): void {
+    this.cache.clear();
+  }
+
+  get<R>(name: string): R | undefined {
+    return this.cache.get(name) as R | undefined;
+  }
+
+  memo<R>(name: string, valueCallback: () => R): R {
+    if (!this.cache.has(name)) {
+      const value = valueCallback();
+
+      if (isDefined(value)) {
+        this.cache.set(name, value);
+      }
+    }
+
+    return this.cache.get(name) as R;
+  }
+
+  delete(name: string): void {
+    this.cache.delete(name);
+  }
+}
+
+export const globalCache = {
+  timezones: new Cache(),
+};

packages/devextreme/js/__internal/scheduler/m_recurrence.ts

@@ -121,7 +121,7 @@ class RecurrenceProcessor {
 
   _getLocalMachineOffset(rruleDate) {
     const machineTimezoneOffset = timeZoneUtils.getClientTimezoneOffset(rruleDate);
-    const machineTimezoneName = dateUtils.getMachineTimezoneName();
+    const machineTimezoneName = timeZoneUtils.getMachineTimezoneName();
     const result = [machineTimezoneOffset];
 
     // NOTE: Workaround for the RRule bug with timezones greater than GMT+12 (e.g. Apia Standard Time GMT+13)

packages/devextreme/js/__internal/scheduler/m_utils_time_zone.test.ts

@@ -0,0 +1,31 @@
+import {
+  beforeAll, describe, expect, it,
+} from '@jest/globals';
+
+import { globalCache } from './global_cache';
+import timeZoneUtils from './m_utils_time_zone';
+import timeZoneList from './timezones/timezone_list';
+
+describe('timezone utils', () => {
+  beforeAll(() => {
+    globalCache.timezones.clear();
+  });
+
+  describe('calculateTimezoneByValue', () => {
+    it('should work faster after first run', () => {
+      let now = Date.now();
+      timeZoneList.value.forEach((timezone) => {
+        timeZoneUtils.calculateTimezoneByValue(timezone);
+      });
+      const delta1 = Date.now() - now; // 41
+      now = Date.now();
+      timeZoneList.value.forEach((timezone) => {
+        timeZoneUtils.calculateTimezoneByValue(timezone);
+      });
+      const delta2 = Date.now() - now; // 6
+
+      expect(globalCache.timezones.size).toBe(timeZoneList.value.length);
+      expect(delta2).toBeLessThan(delta1 / 5);
+    });
+  });
+});

packages/devextreme/js/__internal/scheduler/m_utils_time_zone.ts

@@ -5,6 +5,7 @@ import { dateUtilsTs } from '@ts/core/utils/date';
 import { macroTaskArray } from '@ts/scheduler/utils/index';
 
 import dateUtils from '../../core/utils/date';
+import { globalCache } from './global_cache';
 import DateAdapter from './m_date_adapter';
 import timeZoneDataUtils from './timezones/m_utils_timezones_data';
 import timeZoneList from './timezones/timezone_list';
@@ -21,6 +22,7 @@ export interface TimezoneData extends TimezoneLabel {
   offset?: number;
 }
 
+const timeZoneListSet = new Set(timeZoneList.value);
 const toMs = dateUtils.dateToMilliseconds;
 const MINUTES_IN_HOUR = 60;
 const MS_IN_MINUTE = 60000;
@@ -103,7 +105,7 @@ const calculateTimezoneByValue = (timeZone: string | undefined, date = new Date(
     return undefined;
   }
 
-  const isValidTimezone = timeZoneList.value.includes(timeZone);
+  const isValidTimezone = timeZoneListSet.has(timeZone);
   if (!isValidTimezone) {
     errors.log('W0009', timeZone);
     return undefined;
@@ -125,10 +127,10 @@ const calculateTimezoneByValue = (timeZone: string | undefined, date = new Date(
 const getStringOffset = (timeZone: string, date = new Date()): string | undefined => {
   let result = '';
   try {
-    const dateTimeFormat = new Intl.DateTimeFormat('en-US', {
+    const dateTimeFormat = globalCache.timezones.memo(`intl${timeZone}`, () => new Intl.DateTimeFormat('en-US', {
       timeZone,
       timeZoneName: 'longOffset',
-    } as any);
+    }));
 
     result = dateTimeFormat
       .formatToParts(date)
@@ -227,12 +229,12 @@ const getClientTimezoneOffset = (date = new Date()) => date.getTimezoneOffset()
 
 const getDiffBetweenClientTimezoneOffsets = (firstDate = new Date(), secondDate = new Date()) => getClientTimezoneOffset(firstDate) - getClientTimezoneOffset(secondDate);
 
+const getMachineTimezoneName = () => globalCache.timezones.memo('localTimezone', () => dateUtils.getMachineTimezoneName());
+
 const isEqualLocalTimeZone = (timeZoneName, date = new Date()) => {
-  if (Intl) {
-    const localTimeZoneName = Intl.DateTimeFormat().resolvedOptions().timeZone;
-    if (localTimeZoneName === timeZoneName) {
-      return true;
-    }
+  const localTimeZoneName = getMachineTimezoneName();
+  if (localTimeZoneName && localTimeZoneName === timeZoneName) {
+    return true;
   }
 
   return isEqualLocalTimeZoneByDeclaration(timeZoneName, date);
@@ -380,6 +382,7 @@ const utils = {
   isTimezoneChangeInDate,
   getDateWithoutTimezoneChange,
   hasDSTInLocalTimeZone,
+  getMachineTimezoneName,
   isEqualLocalTimeZone,
   isEqualLocalTimeZoneByDeclaration,