@mui/x-date-pickers 6.4.0 → 6.5.0

package/legacy/DateTimeField/useDateTimeField.js

@@ -1,11 +1,10 @@
-import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
 import _extends from "@babel/runtime/helpers/esm/extends";
-var _excluded = ["value", "defaultValue", "format", "formatDensity", "shouldRespectLeadingZeros", "onChange", "readOnly", "onError", "shouldDisableDate", "shouldDisableMonth", "shouldDisableYear", "minDate", "maxDate", "disableFuture", "disablePast", "minTime", "maxTime", "minDateTime", "maxDateTime", "minutesStep", "disableIgnoringDatePartForTimeValidation", "shouldDisableClock", "shouldDisableTime", "selectedSections", "onSelectedSectionsChange", "ampm", "unstableFieldRef"];
 import { singleItemFieldValueManager, singleItemValueManager } from '../internals/utils/valueManagers';
 import { useField } from '../internals/hooks/useField';
 import { validateDateTime } from '../internals/utils/validation/validateDateTime';
 import { applyDefaultDate } from '../internals/utils/date-utils';
 import { useUtils, useDefaultDates } from '../internals/hooks/useUtils';
+import { splitFieldInternalAndForwardedProps } from '../internals/utils/fields';
 var useDefaultizedDateTimeField = function useDefaultizedDateTimeField(props) {
   var _props$ampm, _props$disablePast, _props$disableFuture, _props$format, _props$minDateTime, _props$maxDateTime, _props$minDateTime2, _props$maxDateTime2;
   var utils = useUtils();
@@ -24,67 +23,16 @@ var useDefaultizedDateTimeField = function useDefaultizedDateTimeField(props) {
   });
 };
 export var useDateTimeField = function useDateTimeField(_ref) {
-  var props = _ref.props,
+  var inProps = _ref.props,
     inputRef = _ref.inputRef;
-  var _useDefaultizedDateTi = useDefaultizedDateTimeField(props),
-    value = _useDefaultizedDateTi.value,
-    defaultValue = _useDefaultizedDateTi.defaultValue,
-    format = _useDefaultizedDateTi.format,
-    formatDensity = _useDefaultizedDateTi.formatDensity,
-    shouldRespectLeadingZeros = _useDefaultizedDateTi.shouldRespectLeadingZeros,
-    onChange = _useDefaultizedDateTi.onChange,
-    readOnly = _useDefaultizedDateTi.readOnly,
-    onError = _useDefaultizedDateTi.onError,
-    shouldDisableDate = _useDefaultizedDateTi.shouldDisableDate,
-    shouldDisableMonth = _useDefaultizedDateTi.shouldDisableMonth,
-    shouldDisableYear = _useDefaultizedDateTi.shouldDisableYear,
-    minDate = _useDefaultizedDateTi.minDate,
-    maxDate = _useDefaultizedDateTi.maxDate,
-    disableFuture = _useDefaultizedDateTi.disableFuture,
-    disablePast = _useDefaultizedDateTi.disablePast,
-    minTime = _useDefaultizedDateTi.minTime,
-    maxTime = _useDefaultizedDateTi.maxTime,
-    minDateTime = _useDefaultizedDateTi.minDateTime,
-    maxDateTime = _useDefaultizedDateTi.maxDateTime,
-    minutesStep = _useDefaultizedDateTi.minutesStep,
-    disableIgnoringDatePartForTimeValidation = _useDefaultizedDateTi.disableIgnoringDatePartForTimeValidation,
-    shouldDisableClock = _useDefaultizedDateTi.shouldDisableClock,
-    shouldDisableTime = _useDefaultizedDateTi.shouldDisableTime,
-    selectedSections = _useDefaultizedDateTi.selectedSections,
-    onSelectedSectionsChange = _useDefaultizedDateTi.onSelectedSectionsChange,
-    ampm = _useDefaultizedDateTi.ampm,
-    unstableFieldRef = _useDefaultizedDateTi.unstableFieldRef,
-    other = _objectWithoutProperties(_useDefaultizedDateTi, _excluded);
+  var props = useDefaultizedDateTimeField(inProps);
+  var _splitFieldInternalAn = splitFieldInternalAndForwardedProps(props, 'date-time'),
+    forwardedProps = _splitFieldInternalAn.forwardedProps,
+    internalProps = _splitFieldInternalAn.internalProps;
   return useField({
     inputRef: inputRef,
-    forwardedProps: other,
-    internalProps: {
-      value: value,
-      defaultValue: defaultValue,
-      format: format,
-      formatDensity: formatDensity,
-      shouldRespectLeadingZeros: shouldRespectLeadingZeros,
-      onChange: onChange,
-      readOnly: readOnly,
-      onError: onError,
-      shouldDisableDate: shouldDisableDate,
-      shouldDisableMonth: shouldDisableMonth,
-      shouldDisableYear: shouldDisableYear,
-      minDate: minDate,
-      maxDate: maxDate,
-      disableFuture: disableFuture,
-      disablePast: disablePast,
-      minTime: minTime,
-      maxTime: maxTime,
-      minutesStep: minutesStep,
-      shouldDisableClock: shouldDisableClock,
-      shouldDisableTime: shouldDisableTime,
-      disableIgnoringDatePartForTimeValidation: disableIgnoringDatePartForTimeValidation,
-      selectedSections: selectedSections,
-      onSelectedSectionsChange: onSelectedSectionsChange,
-      ampm: ampm,
-      unstableFieldRef: unstableFieldRef
-    },
+    forwardedProps: forwardedProps,
+    internalProps: internalProps,
     valueManager: singleItemValueManager,
     fieldValueManager: singleItemFieldValueManager,
     validator: validateDateTime,

package/legacy/DesktopDateTimePicker/DesktopDateTimePicker.js

@@ -39,8 +39,7 @@ var DesktopDateTimePicker = /*#__PURE__*/React.forwardRef(function DesktopDateTi
       field: function field(ownerState) {
         var _defaultizedProps$slo;
         return _extends({}, resolveComponentProps((_defaultizedProps$slo = defaultizedProps.slotProps) == null ? void 0 : _defaultizedProps$slo.field, ownerState), extractValidationProps(defaultizedProps), {
-          ref: ref,
-          ampm: defaultizedProps.ampm
+          ref: ref
         });
       },
       toolbar: _extends({

package/legacy/DesktopTimePicker/DesktopTimePicker.js

@@ -53,8 +53,7 @@ var DesktopTimePicker = /*#__PURE__*/React.forwardRef(function DesktopTimePicker
       field: function field(ownerState) {
         var _defaultizedProps$slo;
         return _extends({}, resolveComponentProps((_defaultizedProps$slo = defaultizedProps.slotProps) == null ? void 0 : _defaultizedProps$slo.field, ownerState), extractValidationProps(defaultizedProps), {
-          ref: ref,
-          ampm: defaultizedProps.ampm
+          ref: ref
         });
       },
       toolbar: _extends({

package/legacy/MobileDateTimePicker/MobileDateTimePicker.js

@@ -37,8 +37,7 @@ var MobileDateTimePicker = /*#__PURE__*/React.forwardRef(function MobileDateTime
       field: function field(ownerState) {
         var _defaultizedProps$slo;
         return _extends({}, resolveComponentProps((_defaultizedProps$slo = defaultizedProps.slotProps) == null ? void 0 : _defaultizedProps$slo.field, ownerState), extractValidationProps(defaultizedProps), {
-          ref: ref,
-          ampm: defaultizedProps.ampm
+          ref: ref
         });
       },
       toolbar: _extends({

package/legacy/MobileTimePicker/MobileTimePicker.js

@@ -33,8 +33,7 @@ var MobileTimePicker = /*#__PURE__*/React.forwardRef(function MobileTimePicker(i
       field: function field(ownerState) {
         var _defaultizedProps$slo;
         return _extends({}, resolveComponentProps((_defaultizedProps$slo = defaultizedProps.slotProps) == null ? void 0 : _defaultizedProps$slo.field, ownerState), extractValidationProps(defaultizedProps), {
-          ref: ref,
-          ampm: defaultizedProps.ampm
+          ref: ref
         });
       },
       toolbar: _extends({

package/legacy/TimeField/useTimeField.js

@@ -1,10 +1,9 @@
-import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
 import _extends from "@babel/runtime/helpers/esm/extends";
-var _excluded = ["value", "defaultValue", "format", "formatDensity", "shouldRespectLeadingZeros", "onChange", "readOnly", "onError", "disableFuture", "disablePast", "minTime", "maxTime", "minutesStep", "shouldDisableClock", "shouldDisableTime", "disableIgnoringDatePartForTimeValidation", "selectedSections", "onSelectedSectionsChange", "ampm", "unstableFieldRef"];
 import { singleItemFieldValueManager, singleItemValueManager } from '../internals/utils/valueManagers';
 import { useField } from '../internals/hooks/useField';
 import { validateTime } from '../internals/utils/validation/validateTime';
 import { useUtils } from '../internals/hooks/useUtils';
+import { splitFieldInternalAndForwardedProps } from '../internals/utils/fields';
 var useDefaultizedTimeField = function useDefaultizedTimeField(props) {
   var _props$ampm, _props$disablePast, _props$disableFuture, _props$format;
   var utils = useUtils();
@@ -17,55 +16,16 @@ var useDefaultizedTimeField = function useDefaultizedTimeField(props) {
   });
 };
 export var useTimeField = function useTimeField(_ref) {
-  var props = _ref.props,
+  var inProps = _ref.props,
     inputRef = _ref.inputRef;
-  var _useDefaultizedTimeFi = useDefaultizedTimeField(props),
-    value = _useDefaultizedTimeFi.value,
-    defaultValue = _useDefaultizedTimeFi.defaultValue,
-    format = _useDefaultizedTimeFi.format,
-    formatDensity = _useDefaultizedTimeFi.formatDensity,
-    shouldRespectLeadingZeros = _useDefaultizedTimeFi.shouldRespectLeadingZeros,
-    onChange = _useDefaultizedTimeFi.onChange,
-    readOnly = _useDefaultizedTimeFi.readOnly,
-    onError = _useDefaultizedTimeFi.onError,
-    disableFuture = _useDefaultizedTimeFi.disableFuture,
-    disablePast = _useDefaultizedTimeFi.disablePast,
-    minTime = _useDefaultizedTimeFi.minTime,
-    maxTime = _useDefaultizedTimeFi.maxTime,
-    minutesStep = _useDefaultizedTimeFi.minutesStep,
-    shouldDisableClock = _useDefaultizedTimeFi.shouldDisableClock,
-    shouldDisableTime = _useDefaultizedTimeFi.shouldDisableTime,
-    disableIgnoringDatePartForTimeValidation = _useDefaultizedTimeFi.disableIgnoringDatePartForTimeValidation,
-    selectedSections = _useDefaultizedTimeFi.selectedSections,
-    onSelectedSectionsChange = _useDefaultizedTimeFi.onSelectedSectionsChange,
-    ampm = _useDefaultizedTimeFi.ampm,
-    unstableFieldRef = _useDefaultizedTimeFi.unstableFieldRef,
-    other = _objectWithoutProperties(_useDefaultizedTimeFi, _excluded);
+  var props = useDefaultizedTimeField(inProps);
+  var _splitFieldInternalAn = splitFieldInternalAndForwardedProps(props, 'time'),
+    forwardedProps = _splitFieldInternalAn.forwardedProps,
+    internalProps = _splitFieldInternalAn.internalProps;
   return useField({
     inputRef: inputRef,
-    forwardedProps: other,
-    internalProps: {
-      value: value,
-      defaultValue: defaultValue,
-      format: format,
-      formatDensity: formatDensity,
-      shouldRespectLeadingZeros: shouldRespectLeadingZeros,
-      onChange: onChange,
-      readOnly: readOnly,
-      onError: onError,
-      disableFuture: disableFuture,
-      disablePast: disablePast,
-      minTime: minTime,
-      maxTime: maxTime,
-      minutesStep: minutesStep,
-      shouldDisableClock: shouldDisableClock,
-      shouldDisableTime: shouldDisableTime,
-      disableIgnoringDatePartForTimeValidation: disableIgnoringDatePartForTimeValidation,
-      selectedSections: selectedSections,
-      onSelectedSectionsChange: onSelectedSectionsChange,
-      ampm: ampm,
-      unstableFieldRef: unstableFieldRef
-    },
+    forwardedProps: forwardedProps,
+    internalProps: internalProps,
     valueManager: singleItemValueManager,
     fieldValueManager: singleItemFieldValueManager,
     validator: validateTime,

package/legacy/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-date-pickers v6.4.0
+ * @mui/x-date-pickers v6.5.0
  *
  * @license MIT
  * This source code is licensed under the MIT license found in the

package/legacy/internals/hooks/useField/useField.js

@@ -67,10 +67,18 @@ export var useField = function useField(params) {
       return;
     }
     var browserStartIndex = (_selectionStart = inputRef.current.selectionStart) != null ? _selectionStart : 0;
-    var nextSectionIndex = browserStartIndex <= state.sections[0].startInInput ? 1 // Special case if browser index is in invisible characters at the beginning.
-    : state.sections.findIndex(function (section) {
-      return section.startInInput - section.startSeparator.length > browserStartIndex;
-    });
+    var nextSectionIndex;
+    if (browserStartIndex <= state.sections[0].startInInput) {
+      // Special case if browser index is in invisible characters at the beginning
+      nextSectionIndex = 1;
+    } else if (browserStartIndex >= state.sections[state.sections.length - 1].endInInput) {
+      // If the click is after the last character of the input, then we want to select the 1st section.
+      nextSectionIndex = 1;
+    } else {
+      nextSectionIndex = state.sections.findIndex(function (section) {
+        return section.startInInput - section.startSeparator.length > browserStartIndex;
+      });
+    }
     var sectionIndex = nextSectionIndex === -1 ? state.sections.length - 1 : nextSectionIndex - 1;
     _setSelectedSections(sectionIndex);
   };

package/legacy/internals/hooks/useViews.js

@@ -53,6 +53,8 @@ export function useViews(_ref) {
       return !views.includes(previousView);
     })) {
       setView(views.includes(openTo) ? openTo : views[0]);
+      previousViews.current = views;
+      previousOpenTo.current = openTo;
     }
   }, [openTo, setView, view, views]);
   var viewIndex = views.indexOf(view);

package/legacy/internals/index.js

@@ -16,13 +16,14 @@ export { useLocalizationContext, useDefaultDates, useUtils, useLocaleText, useNo
 export { useValidation } from './hooks/useValidation';
 export { usePreviousMonthDisabled, useNextMonthDisabled } from './hooks/date-helpers-hooks';
 export { applyDefaultDate, replaceInvalidDateByNull, areDatesEqual } from './utils/date-utils';
+export { splitFieldInternalAndForwardedProps } from './utils/fields';
 export { executeInTheNextEventLoopTick, getActiveElement, onSpaceOrEnter, DEFAULT_DESKTOP_MODE_MEDIA_QUERY } from './utils/utils';
 export { defaultReduceAnimations } from './utils/defaultReduceAnimations';
 export { extractValidationProps } from './utils/validation/extractValidationProps';
 export { validateDate } from './utils/validation/validateDate';
 export { validateDateTime } from './utils/validation/validateDateTime';
 export { validateTime } from './utils/validation/validateTime';
-export { buildDeprecatedPropsWarning } from './utils/warning';
+export { buildDeprecatedPropsWarning, buildWarning } from './utils/warning';
 export { uncapitalizeObjectKeys } from './utils/slots-migration';
 export { PickersCalendarHeader } from '../DateCalendar/PickersCalendarHeader';
 export { DayCalendar } from '../DateCalendar/DayCalendar';

package/legacy/internals/utils/fields.js

@@ -0,0 +1,28 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { DATE_TIME_VALIDATION_PROP_NAMES, DATE_VALIDATION_PROP_NAMES, TIME_VALIDATION_PROP_NAMES } from './validation/extractValidationProps';
+var SHARED_FIELD_INTERNAL_PROP_NAMES = ['value', 'defaultValue', 'format', 'formatDensity', 'onChange', 'readOnly', 'onError', 'shouldRespectLeadingZeros', 'selectedSections', 'onSelectedSectionsChange', 'unstableFieldRef'];
+export var splitFieldInternalAndForwardedProps = function splitFieldInternalAndForwardedProps(props, valueType) {
+  var forwardedProps = _extends({}, props);
+  var internalProps = {};
+  var extractProp = function extractProp(propName) {
+    if (forwardedProps.hasOwnProperty(propName)) {
+      // @ts-ignore
+      internalProps[propName] = forwardedProps[propName];
+      delete forwardedProps[propName];
+    }
+  };
+  SHARED_FIELD_INTERNAL_PROP_NAMES.forEach(extractProp);
+  if (valueType === 'date') {
+    DATE_VALIDATION_PROP_NAMES.forEach(extractProp);
+  } else if (valueType === 'time') {
+    TIME_VALIDATION_PROP_NAMES.forEach(extractProp);
+  } else if (valueType === 'date-time') {
+    DATE_VALIDATION_PROP_NAMES.forEach(extractProp);
+    TIME_VALIDATION_PROP_NAMES.forEach(extractProp);
+    DATE_TIME_VALIDATION_PROP_NAMES.forEach(extractProp);
+  }
+  return {
+    forwardedProps: forwardedProps,
+    internalProps: internalProps
+  };
+};

package/legacy/internals/utils/validation/extractValidationProps.js

@@ -1,4 +1,7 @@
-var VALIDATION_PROP_NAMES = ['disablePast', 'disableFuture', 'minDate', 'maxDate', 'minTime', 'maxTime', 'minDateTime', 'maxDateTime', 'shouldDisableDate', 'shouldDisableMonth', 'shouldDisableYear', 'shouldDisableClock', 'shouldDisableTime', 'minutesStep'];
+export var DATE_VALIDATION_PROP_NAMES = ['disablePast', 'disableFuture', 'minDate', 'maxDate', 'shouldDisableDate', 'shouldDisableMonth', 'shouldDisableYear'];
+export var TIME_VALIDATION_PROP_NAMES = ['disablePast', 'disableFuture', 'minTime', 'maxTime', 'shouldDisableClock', 'shouldDisableTime', 'minutesStep', 'ampm', 'disableIgnoringDatePartForTimeValidation'];
+export var DATE_TIME_VALIDATION_PROP_NAMES = ['minDateTime', 'maxDateTime'];
+var VALIDATION_PROP_NAMES = [].concat(DATE_VALIDATION_PROP_NAMES, TIME_VALIDATION_PROP_NAMES, DATE_TIME_VALIDATION_PROP_NAMES);
 /**
  * Extract the validation props for the props received by a component.
  * Limit the risk of forgetting some of them and reduce the bundle size.

package/legacy/tests/describeGregorianAdapter/testCalculations.js

@@ -21,7 +21,7 @@ export var testCalculations = function testCalculations(_ref) {
       expect(adapter.date(null)).to.equal(null);
     });
     it('should parse undefined', function () {
-      expect(adapter.date(undefined)).toEqualDateTime(new Date());
+      expect(Math.abs(adapter.toJsDate(adapter.date(undefined)).getTime() - Date.now())).to.be.lessThan(5);
     });
   });
   it('Method: toJsDate', function () {

package/legacy/tests/describeValue/describeValue.js

@@ -1,19 +1,46 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 import createDescribe from '@mui/monorepo/test/utils/createDescribe';
+import { buildFieldInteractions } from 'test/utils/pickers-utils';
 import { testControlledUnControlled } from './testControlledUnControlled';
 import { testPickerOpenCloseLifeCycle } from './testPickerOpenCloseLifeCycle';
 import { testPickerActionBar } from './testPickerActionBar';
 import { jsx as _jsx } from "react/jsx-runtime";
 var TEST_SUITES = [testControlledUnControlled, testPickerOpenCloseLifeCycle, testPickerActionBar];
 function innerDescribeValue(ElementToTest, getOptions) {
-  var _getOptions = getOptions(),
-    defaultProps = _getOptions.defaultProps;
+  var options = getOptions();
+  var defaultProps = options.defaultProps,
+    render = options.render,
+    clock = options.clock,
+    componentFamily = options.componentFamily;
   function WrappedElementToTest(props) {
     return /*#__PURE__*/_jsx(ElementToTest, _extends({}, defaultProps, props));
   }
+  var renderWithProps;
+  if (componentFamily === 'field' || componentFamily === 'picker') {
+    var interactions = buildFieldInteractions({
+      clock: clock,
+      render: render,
+      Component: ElementToTest
+    });
+    renderWithProps = function renderWithProps(props) {
+      return interactions.renderWithProps(_extends({}, defaultProps, props), componentFamily);
+    };
+  } else {
+    renderWithProps = function renderWithProps(props) {
+      var response = render( /*#__PURE__*/_jsx(WrappedElementToTest, _extends({}, props)));
+      return _extends({}, response, {
+        input: null,
+        selectSection: function selectSection() {
+          throw new Error('You can only select a section on components that render a field');
+        }
+      });
+    };
+  }
   TEST_SUITES.forEach(function (testSuite) {
-    testSuite(WrappedElementToTest, getOptions);
+    testSuite(WrappedElementToTest, _extends({}, options, {
+      renderWithProps: renderWithProps
+    }));
   });
 }
 /**

package/legacy/tests/describeValue/testControlledUnControlled.js

@@ -1,7 +1,7 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
-var _excluded = ["render", "values", "componentFamily", "emptyValue", "assertRenderedValue", "setNewValue", "clock"];
+var _excluded = ["render", "renderWithProps", "values", "componentFamily", "emptyValue", "assertRenderedValue", "setNewValue", "clock"];
 import * as React from 'react';
 import { expect } from 'chai';
 import { spy } from 'sinon';
@@ -10,16 +10,16 @@ import { inputBaseClasses } from '@mui/material/InputBase';
 import { getExpectedOnChangeCount } from 'test/utils/pickers-utils';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { jsxs as _jsxs } from "react/jsx-runtime";
-export var testControlledUnControlled = function testControlledUnControlled(ElementToTest, getOptions) {
-  var _getOptions = getOptions(),
-    render = _getOptions.render,
-    values = _getOptions.values,
-    componentFamily = _getOptions.componentFamily,
-    emptyValue = _getOptions.emptyValue,
-    assertRenderedValue = _getOptions.assertRenderedValue,
-    setNewValue = _getOptions.setNewValue,
-    clock = _getOptions.clock,
-    pickerParams = _objectWithoutProperties(_getOptions, _excluded);
+export var testControlledUnControlled = function testControlledUnControlled(ElementToTest, options) {
+  var render = options.render,
+    renderWithProps = options.renderWithProps,
+    values = options.values,
+    componentFamily = options.componentFamily,
+    emptyValue = options.emptyValue,
+    assertRenderedValue = options.assertRenderedValue,
+    setNewValue = options.setNewValue,
+    clock = options.clock,
+    pickerParams = _objectWithoutProperties(options, _excluded);
   var params = pickerParams;
   describe('Controlled / uncontrolled value', function () {
     it('should render `props.defaultValue` if no `props.value` is passed', function () {
@@ -47,11 +47,14 @@ export var testControlledUnControlled = function testControlledUnControlled(Elem
     });
     it('should call onChange when updating a value defined with `props.defaultValue` and update the rendered value', function () {
       var onChange = spy();
-      render( /*#__PURE__*/_jsx(ElementToTest, {
-        defaultValue: values[0],
-        onChange: onChange
-      }));
-      var newValue = setNewValue(values[0]);
+      var _renderWithProps = renderWithProps({
+          defaultValue: values[0],
+          onChange: onChange
+        }),
+        selectSection = _renderWithProps.selectSection;
+      var newValue = setNewValue(values[0], {
+        selectSection: selectSection
+      });
       assertRenderedValue(newValue);
       // TODO: Clean this exception or change the clock behavior
       expect(onChange.callCount).to.equal(getExpectedOnChangeCount(componentFamily));
@@ -65,11 +68,14 @@ export var testControlledUnControlled = function testControlledUnControlled(Elem
     });
     it('should call onChange when updating a value defined with `props.value`', function () {
       var onChange = spy();
-      render( /*#__PURE__*/_jsx(ElementToTest, {
-        value: values[0],
-        onChange: onChange
-      }));
-      var newValue = setNewValue(values[0]);
+      var _renderWithProps2 = renderWithProps({
+          defaultValue: values[0],
+          onChange: onChange
+        }),
+        selectSection = _renderWithProps2.selectSection;
+      var newValue = setNewValue(values[0], {
+        selectSection: selectSection
+      });
       expect(onChange.callCount).to.equal(getExpectedOnChangeCount(componentFamily));
       if (Array.isArray(newValue)) {
         newValue.forEach(function (value, index) {

package/legacy/tests/describeValue/testPickerActionBar.js

@@ -4,14 +4,14 @@ import { spy } from 'sinon';
 import { screen, userEvent } from '@mui/monorepo/test/utils';
 import { adapterToUse } from 'test/utils/pickers-utils';
 import { jsx as _jsx } from "react/jsx-runtime";
-export var testPickerActionBar = function testPickerActionBar(ElementToTest, getOptions) {
-  var _getOptions = getOptions(),
-    componentFamily = _getOptions.componentFamily,
-    render = _getOptions.render,
-    values = _getOptions.values,
-    emptyValue = _getOptions.emptyValue,
-    setNewValue = _getOptions.setNewValue,
-    type = _getOptions.type;
+export var testPickerActionBar = function testPickerActionBar(ElementToTest, options) {
+  var componentFamily = options.componentFamily,
+    render = options.render,
+    renderWithProps = options.renderWithProps,
+    values = options.values,
+    emptyValue = options.emptyValue,
+    setNewValue = options.setNewValue,
+    type = options.type;
   if (componentFamily !== 'picker') {
     return;
   }
@@ -83,23 +83,25 @@ export var testPickerActionBar = function testPickerActionBar(ElementToTest, get
         var onChange = spy();
         var onAccept = spy();
         var onClose = spy();
-        render( /*#__PURE__*/_jsx(ElementToTest, {
-          onChange: onChange,
-          onAccept: onAccept,
-          onClose: onClose,
-          open: true,
-          value: values[0],
-          slotProps: {
-            actionBar: {
-              actions: ['cancel']
-            }
-          },
-          closeOnSelect: false
-        }));
+        var _renderWithProps = renderWithProps({
+            onChange: onChange,
+            onAccept: onAccept,
+            onClose: onClose,
+            open: true,
+            value: values[0],
+            slotProps: {
+              actionBar: {
+                actions: ['cancel']
+              }
+            },
+            closeOnSelect: false
+          }),
+          selectSection = _renderWithProps.selectSection;
 
         // Change the value (already tested)
         setNewValue(values[0], {
-          isOpened: true
+          isOpened: true,
+          selectSection: selectSection
         });
 
         // Cancel the modifications
@@ -145,23 +147,25 @@ export var testPickerActionBar = function testPickerActionBar(ElementToTest, get
         var onChange = spy();
         var onAccept = spy();
         var onClose = spy();
-        render( /*#__PURE__*/_jsx(ElementToTest, {
-          onChange: onChange,
-          onAccept: onAccept,
-          onClose: onClose,
-          open: true,
-          defaultValue: values[0],
-          slotProps: {
-            actionBar: {
-              actions: ['accept']
-            }
-          },
-          closeOnSelect: false
-        }));
+        var _renderWithProps2 = renderWithProps({
+            onChange: onChange,
+            onAccept: onAccept,
+            onClose: onClose,
+            open: true,
+            defaultValue: values[0],
+            slotProps: {
+              actionBar: {
+                actions: ['accept']
+              }
+            },
+            closeOnSelect: false
+          }),
+          selectSection = _renderWithProps2.selectSection;
 
         // Change the value (already tested)
         setNewValue(values[0], {
-          isOpened: true
+          isOpened: true,
+          selectSection: selectSection
         });
 
         // Accept the modifications