small fix and add tests

Author: ajivanyandev

packages/devextreme/js/__internal/core/localization/date.global_formats.test.ts

@@ -26,7 +26,8 @@ const saveAndRestore = (): { save: () => void; restore: () => void } => {
           // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
           delete currentConfig[key];
         } else {
-          currentConfig[key] = savedValues[key];
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          (currentConfig as any)[key] = savedValues[key];
         }
       });
     },
@@ -187,7 +188,10 @@ describe('date localization - dateTimeFormatPresets', () => {
         },
       });
 
-      const customFormatter = (d: Date): string => `custom:${d.getFullYear()}`;
+      const customFormatter = (value: number | Date): string => {
+        const d = value instanceof Date ? value : new Date(value);
+        return `custom:${d.getFullYear()}`;
+      };
       const result = dateLocalization.format(new Date(2020, 0, 2), { formatter: customFormatter });
 
       expect(result).toBe('custom:2020');

packages/devextreme/js/__internal/core/m_config.test.ts

@@ -0,0 +1,127 @@
+import {
+  afterEach, beforeEach, describe, expect, it,
+} from '@jest/globals';
+import config from '@js/core/config';
+
+const FORMAT_KEYS = ['dateFormat', 'timeFormat', 'dateTimeFormat', 'numberFormat', 'dateTimeFormatPresets'] as const;
+
+describe('config() - clearing format properties with undefined', () => {
+  let savedValues: Record<string, unknown>;
+
+  beforeEach(() => {
+    const currentConfig = config();
+    savedValues = {};
+    FORMAT_KEYS.forEach((key) => {
+      savedValues[key] = currentConfig[key];
+    });
+  });
+
+  afterEach(() => {
+    const currentConfig = config();
+    FORMAT_KEYS.forEach((key) => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (currentConfig as any)[key] = savedValues[key];
+    });
+  });
+
+  it('should clear dateFormat when set to undefined', () => {
+    config({ dateFormat: 'dd/MM/yyyy' });
+    expect(config().dateFormat).toBe('dd/MM/yyyy');
+
+    config({ dateFormat: undefined });
+    expect(config().dateFormat).toBeUndefined();
+  });
+
+  it('should clear timeFormat when set to undefined', () => {
+    config({ timeFormat: 'HH:mm:ss' });
+    expect(config().timeFormat).toBe('HH:mm:ss');
+
+    config({ timeFormat: undefined });
+    expect(config().timeFormat).toBeUndefined();
+  });
+
+  it('should clear dateTimeFormat when set to undefined', () => {
+    config({ dateTimeFormat: 'dd/MM/yyyy HH:mm' });
+    expect(config().dateTimeFormat).toBe('dd/MM/yyyy HH:mm');
+
+    config({ dateTimeFormat: undefined });
+    expect(config().dateTimeFormat).toBeUndefined();
+  });
+
+  it('should clear numberFormat when set to undefined', () => {
+    config({ numberFormat: '#,##0.00' });
+    expect(config().numberFormat).toBe('#,##0.00');
+
+    config({ numberFormat: undefined });
+    expect(config().numberFormat).toBeUndefined();
+  });
+
+  it('should clear dateTimeFormatPresets when set to undefined', () => {
+    config({ dateTimeFormatPresets: { shortDate: 'dd/MM/yyyy' } });
+    expect(config().dateTimeFormatPresets).toEqual({ shortDate: 'dd/MM/yyyy' });
+
+    config({ dateTimeFormatPresets: undefined });
+    expect(config().dateTimeFormatPresets).toBeUndefined();
+  });
+
+  it('should clear all format keys at once', () => {
+    config({
+      dateFormat: 'dd/MM/yyyy',
+      timeFormat: 'HH:mm',
+      dateTimeFormat: 'dd/MM/yyyy HH:mm',
+      numberFormat: '#,##0.00',
+      dateTimeFormatPresets: { shortDate: 'dd/MM/yyyy' },
+    });
+
+    config({
+      dateFormat: undefined,
+      timeFormat: undefined,
+      dateTimeFormat: undefined,
+      numberFormat: undefined,
+      dateTimeFormatPresets: undefined,
+    });
+
+    expect(config().dateFormat).toBeUndefined();
+    expect(config().timeFormat).toBeUndefined();
+    expect(config().dateTimeFormat).toBeUndefined();
+    expect(config().numberFormat).toBeUndefined();
+    expect(config().dateTimeFormatPresets).toBeUndefined();
+  });
+
+  it('should not affect non-format properties when clearing format keys', () => {
+    const originalRtl = config().rtlEnabled;
+
+    config({
+      dateFormat: 'dd/MM/yyyy',
+      rtlEnabled: true,
+    });
+
+    config({
+      dateFormat: undefined,
+    });
+
+    expect(config().dateFormat).toBeUndefined();
+    expect(config().rtlEnabled).toBe(true);
+
+    // Restore
+    config({ rtlEnabled: originalRtl });
+  });
+
+  it('should allow re-setting a format after clearing', () => {
+    config({ dateFormat: 'dd/MM/yyyy' });
+    config({ dateFormat: undefined });
+    config({ dateFormat: 'yyyy-MM-dd' });
+
+    expect(config().dateFormat).toBe('yyyy-MM-dd');
+  });
+
+  it('should not clear a format key if it is not in the newConfig object', () => {
+    config({ dateFormat: 'dd/MM/yyyy', timeFormat: 'HH:mm' });
+
+    // Only clear dateFormat, timeFormat should remain
+    config({ dateFormat: undefined });
+
+    expect(config().dateFormat).toBeUndefined();
+    expect(config().timeFormat).toBe('HH:mm');
+  });
+});

packages/devextreme/js/__internal/core/m_config.ts

@@ -83,6 +83,12 @@ const configMethod = (...args) => {
   });
 
   extend(config, newConfig);
+  const formatKeys = ['dateFormat', 'timeFormat', 'dateTimeFormat', 'numberFormat', 'dateTimeFormatPresets'] as const;
+  for (const key of formatKeys) {
+    if (key in newConfig && newConfig[key] === undefined) {
+      config[key] = undefined;
+    }
+  }
 };
 
 // @ts-expect-error typescript cant see global

packages/devextreme/js/__internal/core/m_global_format_config.test.ts

@@ -27,7 +27,8 @@ describe('m_global_format_config', () => {
         // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
         delete currentConfig[key];
       } else {
-        currentConfig[key] = savedValues[key];
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (currentConfig as any)[key] = savedValues[key];
       }
     });
   });

packages/devextreme/js/__internal/filter_builder/__tests__/utils.global_format.test.ts

@@ -0,0 +1,111 @@
+import {
+  afterEach, beforeEach, describe, expect, it,
+} from '@jest/globals';
+import config from '@js/core/config';
+import type { Field } from '@js/ui/filter_builder';
+
+import { getCurrentValueText } from '../m_utils';
+
+const FORMAT_KEYS = ['dateFormat', 'timeFormat', 'dateTimeFormat', 'numberFormat', 'dateTimeFormatPresets'] as const;
+
+describe('FilterBuilder - global format integration', () => {
+  let savedValues: Record<string, unknown> = {};
+
+  beforeEach(() => {
+    const currentConfig = config();
+    savedValues = {};
+    FORMAT_KEYS.forEach((key) => {
+      savedValues[key] = currentConfig[key];
+    });
+  });
+
+  afterEach(() => {
+    const currentConfig = config();
+    FORMAT_KEYS.forEach((key) => {
+      if (savedValues[key] === undefined) {
+        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+        delete currentConfig[key];
+      } else {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (currentConfig as any)[key] = savedValues[key];
+      }
+    });
+  });
+
+  describe('date fields with global dateFormat', () => {
+    it('should use global dateFormat when field has no explicit format', () => {
+      config({ ...config(), dateFormat: 'dd/MM/yyyy' });
+
+      const field: Field = { dataType: 'date' };
+      const value = new Date(2025, 0, 15);
+
+      expect(getCurrentValueText(field, value, null)).toBe('15/01/2025');
+    });
+
+    it('should prefer explicit field.format over global dateFormat', () => {
+      config({ ...config(), dateFormat: 'dd/MM/yyyy' });
+
+      const field: Field = { dataType: 'date', format: 'yyyy-MM-dd' };
+      const value = new Date(2025, 0, 15);
+
+      expect(getCurrentValueText(field, value, null)).toBe('2025-01-15');
+    });
+
+    it('should fall back to shortDate when no global dateFormat and no field format', () => {
+      const field: Field = { dataType: 'date' };
+      const value = new Date(2025, 0, 15);
+
+      const result = getCurrentValueText(field, value, null);
+      expect(result).toBeTruthy();
+      expect(typeof result).toBe('string');
+    });
+  });
+
+  describe('datetime fields with global dateTimeFormat', () => {
+    it('should use global dateTimeFormat when field has no explicit format', () => {
+      config({ ...config(), dateTimeFormat: 'dd/MM/yyyy HH:mm' });
+
+      const field: Field = { dataType: 'datetime' };
+      const value = new Date(2025, 0, 15, 14, 30);
+
+      expect(getCurrentValueText(field, value, null)).toBe('15/01/2025 14:30');
+    });
+
+    it('should prefer explicit field.format over global dateTimeFormat', () => {
+      config({ ...config(), dateTimeFormat: 'dd/MM/yyyy HH:mm' });
+
+      const field: Field = { dataType: 'datetime', format: 'yyyy-MM-dd' };
+      const value = new Date(2025, 0, 15, 14, 30);
+
+      expect(getCurrentValueText(field, value, null)).toBe('2025-01-15');
+    });
+  });
+
+  describe('number fields', () => {
+    it('should use built-in shortDate format for date field when no global format set', () => {
+      const field: Field = { dataType: 'date' };
+      const value = new Date(2017, 8, 5, 12, 30, 0);
+
+      // This is the existing behavior — should keep working
+      expect(getCurrentValueText(field, value, null)).toBe('9/5/2017');
+    });
+  });
+
+  describe('dateTimeFormatPresets interaction', () => {
+    it('should apply preset override to shortDate default format', () => {
+      config({
+        ...config(),
+        dateTimeFormatPresets: {
+          shortDate: 'dd.MM.yyyy',
+        },
+      });
+
+      const field: Field = { dataType: 'date' };
+      const value = new Date(2025, 0, 15);
+
+      // With no global dateFormat set, falls back to DEFAULT_FORMAT['date'] = 'shortDate'
+      // The preset override should be applied via dateLocalization.format()
+      expect(getCurrentValueText(field, value, null)).toBe('15.01.2025');
+    });
+  });
+});

packages/devextreme/js/__internal/grids/pivot_grid/__tests__/m_widget_utils.global_format.test.ts

@@ -0,0 +1,110 @@
+import {
+  afterEach, beforeEach, describe, expect, it,
+} from '@jest/globals';
+import config from '@js/core/config';
+
+import { setDefaultFieldValueFormatting } from '../m_widget_utils';
+
+const FORMAT_KEYS = ['dateFormat', 'timeFormat', 'dateTimeFormat', 'numberFormat', 'dateTimeFormatPresets'] as const;
+
+describe('PivotGrid - setDefaultFieldValueFormatting global format', () => {
+  let savedValues: Record<string, unknown> = {};
+
+  beforeEach(() => {
+    const currentConfig = config();
+    savedValues = {};
+    FORMAT_KEYS.forEach((key) => {
+      savedValues[key] = currentConfig[key];
+    });
+  });
+
+  afterEach(() => {
+    const currentConfig = config();
+    FORMAT_KEYS.forEach((key) => {
+      if (savedValues[key] === undefined) {
+        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+        delete currentConfig[key];
+      } else {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (currentConfig as any)[key] = savedValues[key];
+      }
+    });
+  });
+
+  describe('date field formatting', () => {
+    it('should use global dateFormat when no format or groupInterval is set', () => {
+      config({ ...config(), dateFormat: 'dd/MM/yyyy' });
+
+      const field: Record<string, unknown> = { dataType: 'date' };
+      setDefaultFieldValueFormatting(field);
+
+      expect(field.format).toBe('dd/MM/yyyy');
+    });
+
+    it('should use DATE_INTERVAL_FORMATS when groupInterval is set (e.g. month)', () => {
+      config({ ...config(), dateFormat: 'dd/MM/yyyy' });
+
+      const field: Record<string, unknown> = { dataType: 'date', groupInterval: 'month' };
+      setDefaultFieldValueFormatting(field);
+
+      // groupInterval "month" maps to a function in DATE_INTERVAL_FORMATS
+      expect(typeof field.format).toBe('function');
+    });
+
+    it('should prefer DATE_INTERVAL_FORMATS over global dateFormat', () => {
+      config({ ...config(), dateFormat: 'dd/MM/yyyy' });
+
+      const field: Record<string, unknown> = { dataType: 'date', groupInterval: 'quarter' };
+      setDefaultFieldValueFormatting(field);
+
+      // quarter maps to a DATE_INTERVAL_FORMATS function
+      expect(typeof field.format).toBe('function');
+    });
+
+    it('should not set format when groupInterval has no matching DATE_INTERVAL_FORMAT and no global dateFormat', () => {
+      const field: Record<string, unknown> = { dataType: 'date', groupInterval: 'year' };
+      setDefaultFieldValueFormatting(field);
+
+      // 'year' has no entry in DATE_INTERVAL_FORMATS and no global dateFormat
+      expect(field.format).toBeUndefined();
+    });
+
+    it('should use global dateFormat when groupInterval has no matching DATE_INTERVAL_FORMAT', () => {
+      config({ ...config(), dateFormat: 'dd/MM/yyyy' });
+
+      const field: Record<string, unknown> = { dataType: 'date', groupInterval: 'year' };
+      setDefaultFieldValueFormatting(field);
+
+      expect(field.format).toBe('dd/MM/yyyy');
+    });
+
+    it('should not override explicit field.format', () => {
+      config({ ...config(), dateFormat: 'dd/MM/yyyy' });
+
+      const field: Record<string, unknown> = { dataType: 'date', format: 'yyyy-MM-dd' };
+      setDefaultFieldValueFormatting(field);
+
+      expect(field.format).toBe('yyyy-MM-dd');
+    });
+  });
+
+  describe('non-date fields', () => {
+    it('should not set format for number field without groupInterval', () => {
+      config({ ...config(), numberFormat: '#,##0.00' });
+
+      const field: Record<string, unknown> = { dataType: 'number' };
+      setDefaultFieldValueFormatting(field);
+
+      // Number fields don't get a default format from setDefaultFieldValueFormatting
+      // (number format is handled via formatHelper.format at display time)
+      expect(field.format).toBeUndefined();
+    });
+
+    it('should not set format for string field', () => {
+      const field: Record<string, unknown> = { dataType: 'string' };
+      setDefaultFieldValueFormatting(field);
+
+      expect(field.format).toBeUndefined();
+    });
+  });
+});