@mui/x-date-pickers 6.10.2 → 6.11.1

package/node/tests/describeValue/testPickerActionBar.js

@@ -11,6 +11,7 @@ var _chai = require("chai");
 var _sinon = require("sinon");
 var _utils = require("@mui/monorepo/test/utils");
 var _pickersUtils = require("test/utils/pickers-utils");
+var _assertions = require("test/utils/pickers/assertions");
 var _jsxRuntime = require("react/jsx-runtime");
 const _excluded = ["componentFamily", "render", "renderWithProps", "values", "emptyValue", "setNewValue"];
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
@@ -50,21 +51,9 @@ const testPickerActionBar = (ElementToTest, options) => {
         // Clear the date
         _utils.userEvent.mousePress(_utils.screen.getByText(/clear/i));
         (0, _chai.expect)(onChange.callCount).to.equal(1);
-        if (pickerParams.type === 'date-range') {
-          onChange.lastCall.args[0].forEach((value, index) => {
-            (0, _chai.expect)(value).to.deep.equal(emptyValue[index]);
-          });
-        } else {
-          (0, _chai.expect)(onChange.lastCall.args[0]).to.deep.equal(emptyValue);
-        }
+        (0, _assertions.expectPickerChangeHandlerValue)(pickerParams.type, onChange, emptyValue);
         (0, _chai.expect)(onAccept.callCount).to.equal(1);
-        if (pickerParams.type === 'date-range') {
-          onAccept.lastCall.args[0].forEach((value, index) => {
-            (0, _chai.expect)(value).to.deep.equal(emptyValue[index]);
-          });
-        } else {
-          (0, _chai.expect)(onAccept.lastCall.args[0]).to.deep.equal(emptyValue);
-        }
+        (0, _assertions.expectPickerChangeHandlerValue)(pickerParams.type, onAccept, emptyValue);
         (0, _chai.expect)(onClose.callCount).to.equal(1);
       });
       it('should not call onChange or onAccept if the value is already empty value', () => {
@@ -256,23 +245,18 @@ const testPickerActionBar = (ElementToTest, options) => {
           }
         }));
         _utils.userEvent.mousePress(_utils.screen.getByText(/today/i));
-        const startOfToday = pickerParams.type === 'date' ? _pickersUtils.adapterToUse.startOfDay(_pickersUtils.adapterToUse.date()) : _pickersUtils.adapterToUse.date();
-        (0, _chai.expect)(onChange.callCount).to.equal(1);
-        if (pickerParams.type === 'date-range') {
-          onChange.lastCall.args[0].forEach(value => {
-            (0, _chai.expect)(value).toEqualDateTime(startOfToday);
-          });
+        let startOfToday;
+        if (pickerParams.type === 'date') {
+          startOfToday = _pickersUtils.adapterToUse.startOfDay(_pickersUtils.adapterToUse.date());
+        } else if (pickerParams.type === 'date-range') {
+          startOfToday = [_pickersUtils.adapterToUse.date(), _pickersUtils.adapterToUse.date()];
         } else {
-          (0, _chai.expect)(onChange.lastCall.args[0]).toEqualDateTime(startOfToday);
+          startOfToday = _pickersUtils.adapterToUse.date();
         }
+        (0, _chai.expect)(onChange.callCount).to.equal(1);
+        (0, _assertions.expectPickerChangeHandlerValue)(pickerParams.type, onChange, startOfToday);
         (0, _chai.expect)(onAccept.callCount).to.equal(1);
-        if (pickerParams.type === 'date-range') {
-          onAccept.lastCall.args[0].forEach(value => {
-            (0, _chai.expect)(value).toEqualDateTime(startOfToday);
-          });
-        } else {
-          (0, _chai.expect)(onAccept.lastCall.args[0]).toEqualDateTime(startOfToday);
-        }
+        (0, _assertions.expectPickerChangeHandlerValue)(pickerParams.type, onAccept, startOfToday);
         (0, _chai.expect)(onClose.callCount).to.equal(1);
       });
     });

package/node/tests/describeValue/testShortcuts.js

@@ -0,0 +1,122 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.testShortcuts = void 0;
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+var React = _interopRequireWildcard(require("react"));
+var _chai = require("chai");
+var _sinon = require("sinon");
+var _assertions = require("test/utils/pickers/assertions");
+var _utils = require("@mui/monorepo/test/utils");
+var _jsxRuntime = require("react/jsx-runtime");
+const _excluded = ["componentFamily", "render", "renderWithProps", "values", "emptyValue", "setNewValue"];
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+const testShortcuts = (ElementToTest, options) => {
+  const {
+      componentFamily,
+      render,
+      values
+    } = options,
+    pickerParams = (0, _objectWithoutPropertiesLoose2.default)(options, _excluded);
+  if (componentFamily !== 'picker') {
+    return;
+  }
+  describe('Picker shortcuts', () => {
+    it('should call onClose, onChange and onAccept when picking a shortcut without explicit changeImportance', () => {
+      const onChange = (0, _sinon.spy)();
+      const onAccept = (0, _sinon.spy)();
+      const onClose = (0, _sinon.spy)();
+      render( /*#__PURE__*/(0, _jsxRuntime.jsx)(ElementToTest, {
+        onChange: onChange,
+        onAccept: onAccept,
+        onClose: onClose,
+        defaultValue: values[0],
+        open: true,
+        closeOnSelect: true,
+        slotProps: {
+          shortcuts: {
+            items: [{
+              label: 'Test shortcut',
+              getValue: () => values[1]
+            }]
+          }
+        }
+      }));
+      const shortcut = _utils.screen.getByRole('button', {
+        name: 'Test shortcut'
+      });
+      _utils.userEvent.mousePress(shortcut);
+      (0, _chai.expect)(onChange.callCount).to.equal(1);
+      (0, _assertions.expectPickerChangeHandlerValue)(pickerParams.type, onChange, values[1]);
+      (0, _chai.expect)(onAccept.callCount).to.equal(1);
+      (0, _assertions.expectPickerChangeHandlerValue)(pickerParams.type, onAccept, values[1]);
+      (0, _chai.expect)(onClose.callCount).to.equal(1);
+    });
+    it('should call onClose and onChange when picking a shortcut with changeImportance="accept"', () => {
+      const onChange = (0, _sinon.spy)();
+      const onAccept = (0, _sinon.spy)();
+      const onClose = (0, _sinon.spy)();
+      render( /*#__PURE__*/(0, _jsxRuntime.jsx)(ElementToTest, {
+        onChange: onChange,
+        onAccept: onAccept,
+        onClose: onClose,
+        defaultValue: values[0],
+        open: true,
+        closeOnSelect: true,
+        slotProps: {
+          shortcuts: {
+            items: [{
+              label: 'Test shortcut',
+              getValue: () => values[1]
+            }],
+            changeImportance: 'accept'
+          }
+        }
+      }));
+      const shortcut = _utils.screen.getByRole('button', {
+        name: 'Test shortcut'
+      });
+      _utils.userEvent.mousePress(shortcut);
+      (0, _chai.expect)(onChange.callCount).to.equal(1);
+      (0, _assertions.expectPickerChangeHandlerValue)(pickerParams.type, onChange, values[1]);
+      (0, _chai.expect)(onAccept.callCount).to.equal(1);
+      (0, _assertions.expectPickerChangeHandlerValue)(pickerParams.type, onAccept, values[1]);
+      (0, _chai.expect)(onClose.callCount).to.equal(1);
+    });
+    it('should call onClose and onChange when picking a shortcut with changeImportance="set"', () => {
+      const onChange = (0, _sinon.spy)();
+      const onAccept = (0, _sinon.spy)();
+      const onClose = (0, _sinon.spy)();
+      render( /*#__PURE__*/(0, _jsxRuntime.jsx)(ElementToTest, {
+        onChange: onChange,
+        onAccept: onAccept,
+        onClose: onClose,
+        defaultValue: values[0],
+        open: true,
+        closeOnSelect: true,
+        slotProps: {
+          shortcuts: {
+            items: [{
+              label: 'Test shortcut',
+              getValue: () => values[1]
+            }],
+            changeImportance: 'set'
+          }
+        }
+      }));
+      const shortcut = _utils.screen.getByRole('button', {
+        name: 'Test shortcut'
+      });
+      _utils.userEvent.mousePress(shortcut);
+      (0, _chai.expect)(onChange.callCount).to.equal(1);
+      (0, _assertions.expectPickerChangeHandlerValue)(pickerParams.type, onChange, values[1]);
+      (0, _chai.expect)(onAccept.callCount).to.equal(0);
+      (0, _chai.expect)(onClose.callCount).to.equal(0);
+    });
+  });
+};
+exports.testShortcuts = testShortcuts;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/x-date-pickers",
-  "version": "6.10.2",
+  "version": "6.11.1",
   "description": "The community edition of the date picker components (MUI X).",
   "author": "MUI Team",
   "main": "./node/index.js",
@@ -34,9 +34,9 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.22.6",
-    "@mui/utils": "^5.13.7",
+    "@mui/utils": "^5.14.3",
     "@types/react-transition-group": "^4.4.6",
-    "clsx": "^1.2.1",
+    "clsx": "^2.0.0",
     "prop-types": "^15.8.1",
     "react-transition-group": "^4.4.5"
   },

package/tests/describeGregorianAdapter/testCalculations.js

@@ -1,6 +1,17 @@
 import { expect } from 'chai';
 import { getDateOffset } from 'test/utils/pickers-utils';
 import { TEST_DATE_ISO_STRING, TEST_DATE_LOCALE_STRING } from './describeGregorianAdapter.utils';
+
+/**
+ * To check if the date has the right offset even after changing it's date parts,
+ * we convert it to a different timezone that always has the same offset,
+ * then we check that both dates have the same hour value.
+ */
+// We change to
+const expectSameTimeInMonacoTZ = (adapter, value) => {
+  const valueInMonacoTz = adapter.setTimezone(value, 'Europe/Monaco');
+  expect(adapter.getHours(value)).to.equal(adapter.getHours(valueInMonacoTz));
+};
 export const testCalculations = ({
   adapter,
   adapterTZ,
@@ -9,6 +20,7 @@ export const testCalculations = ({
   getLocaleFromDate
 }) => {
   const testDateIso = adapter.date(TEST_DATE_ISO_STRING);
+  const testDateLastNonDSTDay = adapterTZ.isTimezoneCompatible ? adapterTZ.dateWithTimezone('2022-03-27', 'Europe/Paris') : adapterTZ.date('2022-03-27');
   const testDateLocale = adapter.date(TEST_DATE_LOCALE_STRING);
   describe('Method: date', () => {
     it('should parse strings', () => {
@@ -484,10 +496,19 @@ export const testCalculations = ({
     expect(adapter.endOfYear(testDateIso)).toEqualDateTime(expected);
     expect(adapter.endOfYear(testDateLocale)).toEqualDateTime(expected);
   });
-  it('Method: endOfMonth', () => {
-    const expected = '2018-10-31T23:59:59.999Z';
-    expect(adapter.endOfMonth(testDateIso)).toEqualDateTime(expected);
-    expect(adapter.endOfMonth(testDateLocale)).toEqualDateTime(expected);
+  describe('Method: endOfMonth', () => {
+    it('should handle basic usecases', () => {
+      const expected = '2018-10-31T23:59:59.999Z';
+      expect(adapter.endOfMonth(testDateIso)).toEqualDateTime(expected);
+      expect(adapter.endOfMonth(testDateLocale)).toEqualDateTime(expected);
+    });
+    it('should update the offset when entering DST', function test() {
+      if (!adapterTZ.isTimezoneCompatible) {
+        this.skip();
+      }
+      expectSameTimeInMonacoTZ(adapterTZ, testDateLastNonDSTDay);
+      expectSameTimeInMonacoTZ(adapterTZ, adapterTZ.endOfMonth(testDateLastNonDSTDay));
+    });
   });
   it('Method: endOfWeek', () => {
     const expected = adapter.lib === 'luxon' ? '2018-11-04T23:59:59.999Z' : '2018-11-03T23:59:59.999Z';
@@ -503,18 +524,45 @@ export const testCalculations = ({
     expect(adapter.addYears(testDateIso, 2)).toEqualDateTime('2020-10-30T11:44:00.000Z');
     expect(adapter.addYears(testDateIso, -2)).toEqualDateTime('2016-10-30T11:44:00.000Z');
   });
-  it('Method: addMonths', () => {
-    expect(adapter.addMonths(testDateIso, 2)).toEqualDateTime('2018-12-30T11:44:00.000Z');
-    expect(adapter.addMonths(testDateIso, -2)).toEqualDateTime('2018-08-30T11:44:00.000Z');
-    expect(adapter.addMonths(testDateIso, 3)).toEqualDateTime('2019-01-30T11:44:00.000Z');
+  describe('Method: addMonths', () => {
+    it('should handle basic usecases', () => {
+      expect(adapter.addMonths(testDateIso, 2)).toEqualDateTime('2018-12-30T11:44:00.000Z');
+      expect(adapter.addMonths(testDateIso, -2)).toEqualDateTime('2018-08-30T11:44:00.000Z');
+      expect(adapter.addMonths(testDateIso, 3)).toEqualDateTime('2019-01-30T11:44:00.000Z');
+    });
+    it('should update the offset when entering DST', function test() {
+      if (!adapterTZ.isTimezoneCompatible) {
+        this.skip();
+      }
+      expectSameTimeInMonacoTZ(adapterTZ, testDateLastNonDSTDay);
+      expectSameTimeInMonacoTZ(adapterTZ, adapterTZ.addMonths(testDateLastNonDSTDay, 1));
+    });
   });
-  it('Method: addWeeks', () => {
-    expect(adapter.addWeeks(testDateIso, 2)).toEqualDateTime('2018-11-13T11:44:00.000Z');
-    expect(adapter.addWeeks(testDateIso, -2)).toEqualDateTime('2018-10-16T11:44:00.000Z');
+  describe('Method: addWeeks', () => {
+    it('should handle basic usecases', () => {
+      expect(adapter.addWeeks(testDateIso, 2)).toEqualDateTime('2018-11-13T11:44:00.000Z');
+      expect(adapter.addWeeks(testDateIso, -2)).toEqualDateTime('2018-10-16T11:44:00.000Z');
+    });
+    it('should update the offset when entering DST', function test() {
+      if (!adapterTZ.isTimezoneCompatible) {
+        this.skip();
+      }
+      expectSameTimeInMonacoTZ(adapterTZ, testDateLastNonDSTDay);
+      expectSameTimeInMonacoTZ(adapterTZ, adapterTZ.addWeeks(testDateLastNonDSTDay, 1));
+    });
   });
-  it('Method: addDays', () => {
-    expect(adapter.addDays(testDateIso, 2)).toEqualDateTime('2018-11-01T11:44:00.000Z');
-    expect(adapter.addDays(testDateIso, -2)).toEqualDateTime('2018-10-28T11:44:00.000Z');
+  describe('Method: addWeeks', () => {
+    it('should handle basic usecases', () => {
+      expect(adapter.addDays(testDateIso, 2)).toEqualDateTime('2018-11-01T11:44:00.000Z');
+      expect(adapter.addDays(testDateIso, -2)).toEqualDateTime('2018-10-28T11:44:00.000Z');
+    });
+    it('should update the offset when entering DST', function test() {
+      if (!adapterTZ.isTimezoneCompatible) {
+        this.skip();
+      }
+      expectSameTimeInMonacoTZ(adapterTZ, testDateLastNonDSTDay);
+      expectSameTimeInMonacoTZ(adapterTZ, adapterTZ.addDays(testDateLastNonDSTDay, 1));
+    });
   });
   it('Method: addHours', () => {
     expect(adapter.addHours(testDateIso, 2)).toEqualDateTime('2018-10-30T13:44:00.000Z');
@@ -624,14 +672,13 @@ export const testCalculations = ({
       const referenceDate = adapterTZ.dateWithTimezone('2022-03-17', 'Europe/Paris');
       const weekArray = adapterTZ.getWeekArray(referenceDate);
       let expectedDate = adapter.startOfWeek(adapter.startOfMonth(referenceDate));
-      const lastNonDSTDay = adapterTZ.dateWithTimezone('2022-03-27', 'Europe/Paris');
       expect(weekArray).to.have.length(5);
       weekArray.forEach(week => {
         expect(week).to.have.length(7);
         week.forEach(day => {
           expect(adapterTZ.startOfDay(day)).toEqualDateTime(adapterTZ.startOfDay(expectedDate));
           expectedDate = adapterTZ.addDays(expectedDate, 1);
-          expect(getDateOffset(adapterTZ, day)).to.equal(adapterTZ.isAfter(day, lastNonDSTDay) ? 120 : 60);
+          expect(getDateOffset(adapterTZ, day)).to.equal(adapterTZ.isAfter(day, testDateLastNonDSTDay) ? 120 : 60);
         });
       });
     });

package/tests/describeValue/describeValue.js

@@ -7,8 +7,9 @@ import { buildFieldInteractions } from 'test/utils/pickers-utils';
 import { testControlledUnControlled } from './testControlledUnControlled';
 import { testPickerOpenCloseLifeCycle } from './testPickerOpenCloseLifeCycle';
 import { testPickerActionBar } from './testPickerActionBar';
+import { testShortcuts } from './testShortcuts';
 import { jsx as _jsx } from "react/jsx-runtime";
-const TEST_SUITES = [testControlledUnControlled, testPickerOpenCloseLifeCycle, testPickerActionBar];
+const TEST_SUITES = [testControlledUnControlled, testPickerOpenCloseLifeCycle, testPickerActionBar, testShortcuts];
 function innerDescribeValue(ElementToTest, getOptions) {
   const options = getOptions();
   const {

package/tests/describeValue/testPickerActionBar.js

@@ -5,6 +5,7 @@ import { expect } from 'chai';
 import { spy } from 'sinon';
 import { screen, userEvent } from '@mui/monorepo/test/utils';
 import { adapterToUse, getExpectedOnChangeCount } from 'test/utils/pickers-utils';
+import { expectPickerChangeHandlerValue } from 'test/utils/pickers/assertions';
 import { jsx as _jsx } from "react/jsx-runtime";
 export const testPickerActionBar = (ElementToTest, options) => {
   const {
@@ -41,21 +42,9 @@ export const testPickerActionBar = (ElementToTest, options) => {
         // Clear the date
         userEvent.mousePress(screen.getByText(/clear/i));
         expect(onChange.callCount).to.equal(1);
-        if (pickerParams.type === 'date-range') {
-          onChange.lastCall.args[0].forEach((value, index) => {
-            expect(value).to.deep.equal(emptyValue[index]);
-          });
-        } else {
-          expect(onChange.lastCall.args[0]).to.deep.equal(emptyValue);
-        }
+        expectPickerChangeHandlerValue(pickerParams.type, onChange, emptyValue);
         expect(onAccept.callCount).to.equal(1);
-        if (pickerParams.type === 'date-range') {
-          onAccept.lastCall.args[0].forEach((value, index) => {
-            expect(value).to.deep.equal(emptyValue[index]);
-          });
-        } else {
-          expect(onAccept.lastCall.args[0]).to.deep.equal(emptyValue);
-        }
+        expectPickerChangeHandlerValue(pickerParams.type, onAccept, emptyValue);
         expect(onClose.callCount).to.equal(1);
       });
       it('should not call onChange or onAccept if the value is already empty value', () => {
@@ -247,23 +236,18 @@ export const testPickerActionBar = (ElementToTest, options) => {
           }
         }));
         userEvent.mousePress(screen.getByText(/today/i));
-        const startOfToday = pickerParams.type === 'date' ? adapterToUse.startOfDay(adapterToUse.date()) : adapterToUse.date();
-        expect(onChange.callCount).to.equal(1);
-        if (pickerParams.type === 'date-range') {
-          onChange.lastCall.args[0].forEach(value => {
-            expect(value).toEqualDateTime(startOfToday);
-          });
+        let startOfToday;
+        if (pickerParams.type === 'date') {
+          startOfToday = adapterToUse.startOfDay(adapterToUse.date());
+        } else if (pickerParams.type === 'date-range') {
+          startOfToday = [adapterToUse.date(), adapterToUse.date()];
         } else {
-          expect(onChange.lastCall.args[0]).toEqualDateTime(startOfToday);
+          startOfToday = adapterToUse.date();
         }
+        expect(onChange.callCount).to.equal(1);
+        expectPickerChangeHandlerValue(pickerParams.type, onChange, startOfToday);
         expect(onAccept.callCount).to.equal(1);
-        if (pickerParams.type === 'date-range') {
-          onAccept.lastCall.args[0].forEach(value => {
-            expect(value).toEqualDateTime(startOfToday);
-          });
-        } else {
-          expect(onAccept.lastCall.args[0]).toEqualDateTime(startOfToday);
-        }
+        expectPickerChangeHandlerValue(pickerParams.type, onAccept, startOfToday);
         expect(onClose.callCount).to.equal(1);
       });
     });

package/tests/describeValue/testShortcuts.js

@@ -0,0 +1,112 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["componentFamily", "render", "renderWithProps", "values", "emptyValue", "setNewValue"];
+import * as React from 'react';
+import { expect } from 'chai';
+import { spy } from 'sinon';
+import { expectPickerChangeHandlerValue } from 'test/utils/pickers/assertions';
+import { userEvent, screen } from '@mui/monorepo/test/utils';
+import { jsx as _jsx } from "react/jsx-runtime";
+export const testShortcuts = (ElementToTest, options) => {
+  const {
+      componentFamily,
+      render,
+      values
+    } = options,
+    pickerParams = _objectWithoutPropertiesLoose(options, _excluded);
+  if (componentFamily !== 'picker') {
+    return;
+  }
+  describe('Picker shortcuts', () => {
+    it('should call onClose, onChange and onAccept when picking a shortcut without explicit changeImportance', () => {
+      const onChange = spy();
+      const onAccept = spy();
+      const onClose = spy();
+      render( /*#__PURE__*/_jsx(ElementToTest, {
+        onChange: onChange,
+        onAccept: onAccept,
+        onClose: onClose,
+        defaultValue: values[0],
+        open: true,
+        closeOnSelect: true,
+        slotProps: {
+          shortcuts: {
+            items: [{
+              label: 'Test shortcut',
+              getValue: () => values[1]
+            }]
+          }
+        }
+      }));
+      const shortcut = screen.getByRole('button', {
+        name: 'Test shortcut'
+      });
+      userEvent.mousePress(shortcut);
+      expect(onChange.callCount).to.equal(1);
+      expectPickerChangeHandlerValue(pickerParams.type, onChange, values[1]);
+      expect(onAccept.callCount).to.equal(1);
+      expectPickerChangeHandlerValue(pickerParams.type, onAccept, values[1]);
+      expect(onClose.callCount).to.equal(1);
+    });
+    it('should call onClose and onChange when picking a shortcut with changeImportance="accept"', () => {
+      const onChange = spy();
+      const onAccept = spy();
+      const onClose = spy();
+      render( /*#__PURE__*/_jsx(ElementToTest, {
+        onChange: onChange,
+        onAccept: onAccept,
+        onClose: onClose,
+        defaultValue: values[0],
+        open: true,
+        closeOnSelect: true,
+        slotProps: {
+          shortcuts: {
+            items: [{
+              label: 'Test shortcut',
+              getValue: () => values[1]
+            }],
+            changeImportance: 'accept'
+          }
+        }
+      }));
+      const shortcut = screen.getByRole('button', {
+        name: 'Test shortcut'
+      });
+      userEvent.mousePress(shortcut);
+      expect(onChange.callCount).to.equal(1);
+      expectPickerChangeHandlerValue(pickerParams.type, onChange, values[1]);
+      expect(onAccept.callCount).to.equal(1);
+      expectPickerChangeHandlerValue(pickerParams.type, onAccept, values[1]);
+      expect(onClose.callCount).to.equal(1);
+    });
+    it('should call onClose and onChange when picking a shortcut with changeImportance="set"', () => {
+      const onChange = spy();
+      const onAccept = spy();
+      const onClose = spy();
+      render( /*#__PURE__*/_jsx(ElementToTest, {
+        onChange: onChange,
+        onAccept: onAccept,
+        onClose: onClose,
+        defaultValue: values[0],
+        open: true,
+        closeOnSelect: true,
+        slotProps: {
+          shortcuts: {
+            items: [{
+              label: 'Test shortcut',
+              getValue: () => values[1]
+            }],
+            changeImportance: 'set'
+          }
+        }
+      }));
+      const shortcut = screen.getByRole('button', {
+        name: 'Test shortcut'
+      });
+      userEvent.mousePress(shortcut);
+      expect(onChange.callCount).to.equal(1);
+      expectPickerChangeHandlerValue(pickerParams.type, onChange, values[1]);
+      expect(onAccept.callCount).to.equal(0);
+      expect(onClose.callCount).to.equal(0);
+    });
+  });
+};

package/themeAugmentation/components.d.ts

@@ -19,12 +19,14 @@ export interface PickerComponents<Theme = unknown> {
   };
   MuiDateField?: {
     defaultProps?: ComponentsProps['MuiDateField'];
-    styleOverrides?: ComponentsOverrides<Theme>['MuiDateField'];
   };
   MuiDatePickerToolbar?: {
     defaultProps?: ComponentsProps['MuiDatePickerToolbar'];
     styleOverrides?: ComponentsOverrides<Theme>['MuiDatePickerToolbar'];
   };
+  MuiDateTimeField?: {
+    defaultProps?: ComponentsProps['MuiDateTimeField'];
+  };
   MuiDateTimePickerTabs?: {
     defaultProps?: ComponentsProps['MuiDateTimePickerTabs'];
     styleOverrides?: ComponentsOverrides<Theme>['MuiDateTimePickerTabs'];
@@ -47,7 +49,6 @@ export interface PickerComponents<Theme = unknown> {
   };
   MuiLocalizationProvider?: {
     defaultProps?: ComponentsProps['MuiLocalizationProvider'];
-    styleOverrides?: ComponentsOverrides<Theme>['MuiLocalizationProvider'];
   };
   MuiMonthCalendar?: {
     defaultProps?: ComponentsProps['MuiMonthCalendar'];
@@ -113,6 +114,9 @@ export interface PickerComponents<Theme = unknown> {
     defaultProps?: ComponentsProps['MuiTimeClock'];
     styleOverrides?: ComponentsOverrides<Theme>['MuiTimeClock'];
   };
+  MuiTimeField?: {
+    defaultProps?: ComponentsProps['MuiTimeField'];
+  };
   MuiTimePickerToolbar?: {
     defaultProps?: ComponentsProps['MuiTimePickerToolbar'];
     styleOverrides?: ComponentsOverrides<Theme>['MuiTimePickerToolbar'];
@@ -125,55 +129,43 @@ export interface PickerComponents<Theme = unknown> {
   // Date Pickers
   MuiDatePicker?: {
     defaultProps?: ComponentsProps['MuiDatePicker'];
-    styleOverrides?: ComponentsOverrides<Theme>['MuiDatePicker'];
   };
   MuiDesktopDatePicker?: {
     defaultProps?: ComponentsProps['MuiDesktopDatePicker'];
-    styleOverrides?: ComponentsOverrides<Theme>['MuiDesktopDatePicker'];
   };
   MuiMobileDatePicker?: {
     defaultProps?: ComponentsProps['MuiMobileDatePicker'];
-    styleOverrides?: ComponentsOverrides<Theme>['MuiMobileDatePicker'];
   };
   MuiStaticDatePicker?: {
     defaultProps?: ComponentsProps['MuiStaticDatePicker'];
-    styleOverrides?: ComponentsOverrides<Theme>['MuiStaticDatePicker'];
   };
 
   // Time Pickers
   MuiTimePicker?: {
     defaultProps?: ComponentsProps['MuiTimePicker'];
-    styleOverrides?: ComponentsOverrides<Theme>['MuiTimePicker'];
   };
   MuiDesktopTimePicker?: {
     defaultProps?: ComponentsProps['MuiDesktopTimePicker'];
-    styleOverrides?: ComponentsOverrides<Theme>['MuiDesktopTimePicker'];
   };
   MuiMobileTimePicker?: {
     defaultProps?: ComponentsProps['MuiMobileTimePicker'];
-    styleOverrides?: ComponentsOverrides<Theme>['MuiMobileTimePicker'];
   };
   MuiStaticTimePicker?: {
     defaultProps?: ComponentsProps['MuiStaticTimePicker'];
-    styleOverrides?: ComponentsOverrides<Theme>['MuiStaticTimePicker'];
   };
 
   // Date Time Pickers
   MuiDateTimePicker?: {
     defaultProps?: ComponentsProps['MuiDateTimePicker'];
-    styleOverrides?: ComponentsOverrides<Theme>['MuiDateTimePicker'];
   };
   MuiDesktopDateTimePicker?: {
     defaultProps?: ComponentsProps['MuiDesktopDateTimePicker'];
-    styleOverrides?: ComponentsOverrides<Theme>['MuiDesktopDateTimePicker'];
   };
   MuiMobileDateTimePicker?: {
     defaultProps?: ComponentsProps['MuiMobileDateTimePicker'];
-    styleOverrides?: ComponentsOverrides<Theme>['MuiMobileDateTimePicker'];
   };
   MuiStaticDateTimePicker?: {
     defaultProps?: ComponentsProps['MuiStaticDateTimePicker'];
-    styleOverrides?: ComponentsOverrides<Theme>['MuiStaticDateTimePicker'];
   };
 }
 

package/themeAugmentation/overrides.d.ts

@@ -38,14 +38,12 @@ export interface PickersComponentNameToClassKey {
   MuiClockNumber: ClockNumberClassKey;
   MuiClockPointer: ClockPointerClassKey;
   MuiDateCalendar: DateCalendarClassKey;
-  MuiDateField: never;
   MuiDatePickerToolbar: DatePickerToolbarClassKey;
   MuiDateTimePickerTabs: DateTimePickerTabsClassKey;
   MuiDateTimePickerToolbar: DateTimePickerToolbarClassKey;
   MuiDayCalendar: DayCalendarClassKey;
   MuiDayCalendarSkeleton: DayCalendarSkeletonClassKey;
   MuiDigitalClock: DigitalClockClassKey;
-  MuiLocalizationProvider: never;
   MuiMonthCalendar: MonthCalendarClassKey;
   MuiMultiSectionDigitalClock: MultiSectionDigitalClockClassKey;
   MuiMultiSectionDigitalClockSection: MultiSectionDigitalClockSectionClassKey;
@@ -64,24 +62,6 @@ export interface PickersComponentNameToClassKey {
   MuiTimeClock: TimeClockClassKey;
   MuiTimePickerToolbar: TimePickerToolbarClassKey;
   MuiYearCalendar: YearCalendarClassKey;
-
-  // Date Pickers
-  MuiDatePicker: never;
-  MuiDesktopDatePicker: never;
-  MuiMobileDatePicker: never;
-  MuiStaticDatePicker: never;
-
-  // Time Pickers
-  MuiTimePicker: never;
-  MuiDesktopTimePicker: never;
-  MuiMobileTimePicker: never;
-  MuiStaticTimePicker: never;
-  
-  // Date Time Pickers
-  MuiDateTimePicker: never;
-  MuiDesktopDateTimePicker: never;
-  MuiMobileDateTimePicker: never;
-  MuiStaticDateTimePicker: never;
 }
 
 declare module '@mui/material/styles' {