@mui/x-date-pickers-pro 8.5.3 → 8.7.0

package/TimeRangePicker/TimeRangePicker.js

@@ -60,7 +60,7 @@ process.env.NODE_ENV !== "production" ? TimeRangePicker.propTypes = {
   // ----------------------------------------------------------------------
   /**
    * 12h/24h view for hour selection clock.
-   * @default utils.is12HourCycleInCurrentLocale()
+   * @default adapter.is12HourCycleInCurrentLocale()
    */
   ampm: _propTypes.default.bool,
   /**
@@ -250,7 +250,7 @@ process.env.NODE_ENV !== "production" ? TimeRangePicker.propTypes = {
    * The date used to generate the new value when both `value` and `defaultValue` are empty.
    * @default The closest valid date-time using the validation props, except callbacks like `shouldDisable<...>`.
    */
-  referenceDate: _propTypes.default.object,
+  referenceDate: _propTypes.default.oneOfType([_propTypes.default.arrayOf(_propTypes.default.object), _propTypes.default.object]),
   /**
    * The currently selected sections.
    * This prop accepts four formats:

package/TimeRangePicker/TimeRangePickerTimeWrapper.js

@@ -7,33 +7,35 @@ Object.defineProperty(exports, "__esModule", {
 exports.TimeRangePickerTimeWrapper = TimeRangePickerTimeWrapper;
 var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
 var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
-var _internals = require("@mui/x-date-pickers/internals");
+var _hooks = require("@mui/x-date-pickers/hooks");
 var _dateUtils = require("../internals/utils/date-utils");
 var _dateRangeManager = require("../internals/utils/date-range-manager");
-var _hooks = require("../hooks");
-const _excluded = ["viewRenderer", "value", "onChange", "defaultValue", "onViewChange", "views", "className"];
+var _hooks2 = require("../hooks");
+const _excluded = ["viewRenderer", "value", "onChange", "defaultValue", "onViewChange", "views", "className", "referenceDate"];
 /**
  * @ignore - internal component.
  */
 function TimeRangePickerTimeWrapper(props) {
-  const utils = (0, _internals.useUtils)();
+  const adapter = (0, _hooks.usePickerAdapter)();
   const {
       viewRenderer,
       value,
       onChange,
       defaultValue,
       onViewChange,
-      views
+      views,
+      referenceDate: referenceDateProp
     } = props,
     other = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
   const {
     rangePosition
-  } = (0, _hooks.usePickerRangePositionContext)();
+  } = (0, _hooks2.usePickerRangePositionContext)();
   if (!viewRenderer) {
     return null;
   }
   const currentValue = (rangePosition === 'start' ? value?.[0] : value?.[1]) ?? null;
   const currentDefaultValue = (rangePosition === 'start' ? defaultValue?.[0] : defaultValue?.[1]) ?? null;
+  const referenceDate = (0, _dateRangeManager.resolveReferenceDate)(referenceDateProp, rangePosition);
   const handleOnChange = (newDate, selectionState, selectedView) => {
     if (!onChange || !value) {
       return;
@@ -42,14 +44,15 @@ function TimeRangePickerTimeWrapper(props) {
       newRange
     } = (0, _dateRangeManager.calculateRangeChange)({
       newDate,
-      utils,
+      adapter,
       range: value,
       rangePosition
     });
-    const isFullRangeSelected = rangePosition === 'end' && (0, _dateUtils.isRangeValid)(utils, newRange);
+    const isFullRangeSelected = rangePosition === 'end' && (0, _dateUtils.isRangeValid)(adapter, newRange);
     onChange(newRange, isFullRangeSelected ? 'finish' : 'partial', selectedView);
   };
   return viewRenderer((0, _extends2.default)({}, other, {
+    referenceDate,
     views,
     onViewChange,
     value: currentValue,

package/TimeRangePicker/TimeRangePickerToolbar.js

@@ -99,13 +99,13 @@ function TimeRangePickerToolbarTimeElement(props) {
     separatorClasses,
     toolbarPlaceholder
   } = props;
-  const utils = (0, _internals.useUtils)();
+  const adapter = (0, _hooks.usePickerAdapter)();
   const {
     variant,
     views
   } = (0, _hooks.usePickerContext)();
-  const formatHours = time => ampm ? utils.format(time, 'hours12h') : utils.format(time, 'hours24h');
-  const meridiemMode = (0, _internals.getMeridiem)(value, utils);
+  const formatHours = time => ampm ? adapter.format(time, 'hours12h') : adapter.format(time, 'hours24h');
+  const meridiemMode = (0, _internals.getMeridiem)(value, adapter);
   const sectionWidth = variant === 'desktop' ? _internals.MULTI_SECTION_CLOCK_SECTION_WIDTH : '100%';
   return /*#__PURE__*/(0, _jsxRuntime.jsxs)(TimeRangePickerToolbarTimeContainer, {
     children: [views.includes('hours') && /*#__PURE__*/(0, _jsxRuntime.jsxs)(React.Fragment, {
@@ -114,7 +114,7 @@ function TimeRangePickerToolbarTimeElement(props) {
         width: sectionWidth,
         onClick: () => onViewChange('hours'),
         selected: view === 'hours',
-        value: utils.isValid(value) ? formatHours(value) : toolbarPlaceholder
+        value: adapter.isValid(value) ? formatHours(value) : toolbarPlaceholder
       }), /*#__PURE__*/(0, _jsxRuntime.jsx)(TimeRangePickerToolbarSeparator, {
         variant: "h5",
         value: ":",
@@ -124,7 +124,7 @@ function TimeRangePickerToolbarTimeElement(props) {
         width: sectionWidth,
         onClick: () => onViewChange('minutes'),
         selected: view === 'minutes' || !views.includes('minutes') && view === 'hours',
-        value: utils.isValid(value) ? utils.format(value, 'minutes') : toolbarPlaceholder,
+        value: adapter.isValid(value) ? adapter.format(value, 'minutes') : toolbarPlaceholder,
         disabled: !views.includes('minutes')
       })]
     }), views.includes('seconds') && /*#__PURE__*/(0, _jsxRuntime.jsxs)(React.Fragment, {
@@ -137,13 +137,13 @@ function TimeRangePickerToolbarTimeElement(props) {
         width: sectionWidth,
         onClick: () => onViewChange('seconds'),
         selected: view === 'seconds',
-        value: value ? utils.format(value, 'seconds') : toolbarPlaceholder
+        value: value ? adapter.format(value, 'seconds') : toolbarPlaceholder
       })]
     }), ampm && /*#__PURE__*/(0, _jsxRuntime.jsx)(_internals.PickersToolbarButton, {
       variant: "h5",
       onClick: () => onViewChange('meridiem'),
       selected: view === 'meridiem',
-      value: value && meridiemMode ? (0, _internals.formatMeridiem)(utils, meridiemMode) : toolbarPlaceholder,
+      value: value && meridiemMode ? (0, _internals.formatMeridiem)(adapter, meridiemMode) : toolbarPlaceholder,
       width: sectionWidth
     })]
   });

package/TimeRangePicker/shared.js

@@ -10,16 +10,17 @@ var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends")
 var React = _interopRequireWildcard(require("react"));
 var _styles = require("@mui/material/styles");
 var _internals = require("@mui/x-date-pickers/internals");
+var _hooks = require("@mui/x-date-pickers/hooks");
 var _TimeRangePickerToolbar = require("./TimeRangePickerToolbar");
 var _TimeRangePickerTabs = require("./TimeRangePickerTabs");
 function useTimeRangePickerDefaultizedProps(props, name) {
-  const utils = (0, _internals.useUtils)();
+  const adapter = (0, _hooks.usePickerAdapter)();
   const themeProps = (0, _styles.useThemeProps)({
     props,
     name
   });
   const validationProps = (0, _internals.useApplyDefaultValuesToTimeValidationProps)(themeProps);
-  const ampm = themeProps.ampm ?? utils.is12HourCycleInCurrentLocale();
+  const ampm = themeProps.ampm ?? adapter.is12HourCycleInCurrentLocale();
   const {
     openTo,
     views: defaultViews

package/esm/DateRangeCalendar/DateRangeCalendar.js

@@ -15,11 +15,12 @@ import { styled, useThemeProps } from '@mui/material/styles';
 import composeClasses from '@mui/utils/composeClasses';
 import useId from '@mui/utils/useId';
 import { Watermark } from '@mui/x-license';
-import { DayCalendar, useReduceAnimations, useCalendarState, useUtils, DEFAULT_DESKTOP_MODE_MEDIA_QUERY, useControlledValue, useViews, usePickerPrivateContext, areDatesEqual, useApplyDefaultValuesToDateValidationProps } from '@mui/x-date-pickers/internals';
+import { DayCalendar, useReduceAnimations, useCalendarState, DEFAULT_DESKTOP_MODE_MEDIA_QUERY, useControlledValue, useViews, usePickerPrivateContext, areDatesEqual, useApplyDefaultValuesToDateValidationProps } from '@mui/x-date-pickers/internals';
 import { warnOnce } from '@mui/x-internals/warning';
+import { usePickerAdapter } from '@mui/x-date-pickers/hooks';
 import { dateRangeCalendarClasses, getDateRangeCalendarUtilityClass } from "./dateRangeCalendarClasses.js";
 import { isEndOfRange, isRangeValid, isStartOfRange, isWithinRange } from "../internals/utils/date-utils.js";
-import { calculateRangeChange, calculateRangePreview } from "../internals/utils/date-range-manager.js";
+import { calculateRangeChange, calculateRangePreview, resolveReferenceDate } from "../internals/utils/date-range-manager.js";
 import { DateRangePickerDay, dateRangePickerDayClasses as dayClasses } from "../DateRangePickerDay/index.js";
 import { rangeValueManager } from "../internals/utils/valueManagers.js";
 import { useDragRange } from "./useDragRange.js";
@@ -29,7 +30,7 @@ import { PickersRangeCalendarHeader } from "../PickersRangeCalendarHeader/index.
 import { useNullablePickerRangePositionContext } from "../internals/hooks/useNullablePickerRangePositionContext.js";
 import { dateRangePickerDay2Classes } from "../DateRangePickerDay2/index.js";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-const releaseInfo = "MTc1MDI4NDAwMDAwMA==";
+const releaseInfo = "MTc1MTU4MDAwMDAwMA==";
 const DateRangeCalendarRoot = styled('div', {
   name: 'MuiDateRangeCalendar',
   slot: 'Root'
@@ -187,7 +188,7 @@ const DateRangeCalendar = /*#__PURE__*/React.forwardRef(function DateRangeCalend
     focusedView: focusedViewProp,
     onFocusedViewChange
   });
-  const utils = useUtils();
+  const adapter = usePickerAdapter();
   const id = useId();
   const {
     rangePosition,
@@ -208,7 +209,7 @@ const DateRangeCalendar = /*#__PURE__*/React.forwardRef(function DateRangeCalend
       newRange
     } = calculateRangeChange({
       newDate,
-      utils,
+      adapter,
       range: value,
       rangePosition,
       allowRangeFlip,
@@ -219,7 +220,7 @@ const DateRangeCalendar = /*#__PURE__*/React.forwardRef(function DateRangeCalend
     if (isNextSectionAvailable) {
       setRangePosition(nextSelection);
     }
-    const isFullRangeSelected = rangePosition === 'end' && isRangeValid(utils, newRange);
+    const isFullRangeSelected = rangePosition === 'end' && isRangeValid(adapter, newRange);
     setValueAndGoToNextView(newRange, isFullRangeSelected || !isNextSectionAvailable ? 'finish' : 'partial', view);
   });
   const handleDrop = useEventCallback(newDate => {
@@ -229,12 +230,12 @@ const DateRangeCalendar = /*#__PURE__*/React.forwardRef(function DateRangeCalend
 
   // Range going for the start of the start day to the end of the end day.
   // This makes sure that `isWithinRange` works with any time in the start and end day.
-  const valueDayRange = React.useMemo(() => [!utils.isValid(value[0]) ? value[0] : utils.startOfDay(value[0]), !utils.isValid(value[1]) ? value[1] : utils.endOfDay(value[1])], [value, utils]);
+  const valueDayRange = React.useMemo(() => [!adapter.isValid(value[0]) ? value[0] : adapter.startOfDay(value[0]), !adapter.isValid(value[1]) ? value[1] : adapter.endOfDay(value[1])], [value, adapter]);
   const _useDragRange = useDragRange({
       disableDragEditing: shouldDisableDragEditing,
       onDrop: handleDrop,
       onDatePositionChange: handleDatePositionChange,
-      utils,
+      adapter,
       dateRange: valueDayRange,
       timezone
     }),
@@ -256,14 +257,14 @@ const DateRangeCalendar = /*#__PURE__*/React.forwardRef(function DateRangeCalend
       return [null, null];
     }
     const newRange = calculateRangeChange({
-      utils,
+      adapter,
       range: valueDayRange,
       newDate: rangeDragDay,
       rangePosition,
       allowRangeFlip: true
     }).newRange;
-    return newRange[0] !== null && newRange[1] !== null ? [utils.startOfDay(newRange[0]), utils.endOfDay(newRange[1])] : newRange;
-  }, [rangePosition, rangeDragDay, utils, valueDayRange]);
+    return newRange[0] !== null && newRange[1] !== null ? [adapter.startOfDay(newRange[0]), adapter.endOfDay(newRange[1])] : newRange;
+  }, [rangePosition, rangeDragDay, adapter, valueDayRange]);
   const wrappedShouldDisableDate = React.useMemo(() => {
     if (!shouldDisableDate) {
       return undefined;
@@ -276,7 +277,7 @@ const DateRangeCalendar = /*#__PURE__*/React.forwardRef(function DateRangeCalend
     onMonthSwitchingAnimationEnd
   } = useCalendarState({
     value: value[0] || value[1],
-    referenceDate,
+    referenceDate: resolveReferenceDate(referenceDate, rangePosition),
     disableFuture,
     disablePast,
     maxDate,
@@ -286,24 +287,24 @@ const DateRangeCalendar = /*#__PURE__*/React.forwardRef(function DateRangeCalend
     shouldDisableDate: wrappedShouldDisableDate,
     timezone,
     getCurrentMonthFromVisibleDate: (visibleDate, prevMonth) => {
-      const firstVisibleMonth = utils.addMonths(prevMonth, 1 - currentMonthCalendarPosition);
-      const lastVisibleMonth = utils.endOfMonth(utils.addMonths(firstVisibleMonth, calendars - 1));
+      const firstVisibleMonth = adapter.addMonths(prevMonth, 1 - currentMonthCalendarPosition);
+      const lastVisibleMonth = adapter.endOfMonth(adapter.addMonths(firstVisibleMonth, calendars - 1));
 
       // The new focused day is inside the visible calendars,
       // Do not change the current month
-      if (utils.isWithinRange(visibleDate, [firstVisibleMonth, lastVisibleMonth])) {
+      if (adapter.isWithinRange(visibleDate, [firstVisibleMonth, lastVisibleMonth])) {
         return prevMonth;
       }
 
       // The new focused day is after the last visible month,
       // Move the current month so that the new focused day is inside the first visible month
-      if (utils.isAfter(visibleDate, lastVisibleMonth)) {
-        return utils.startOfMonth(utils.addMonths(visibleDate, currentMonthCalendarPosition - 1));
+      if (adapter.isAfter(visibleDate, lastVisibleMonth)) {
+        return adapter.startOfMonth(adapter.addMonths(visibleDate, currentMonthCalendarPosition - 1));
       }
 
       // The new focused day is before the first visible month,
       // Move the current month so that the new focused day is inside the last visible month
-      return utils.startOfMonth(utils.addMonths(visibleDate, currentMonthCalendarPosition - calendars));
+      return adapter.startOfMonth(adapter.addMonths(visibleDate, currentMonthCalendarPosition - calendars));
     }
   });
   const CalendarHeader = slots?.calendarHeader ?? PickersRangeCalendarHeader;
@@ -336,7 +337,7 @@ const DateRangeCalendar = /*#__PURE__*/React.forwardRef(function DateRangeCalend
   const prevValue = React.useRef(null);
   React.useEffect(() => {
     const date = rangePosition === 'start' ? value[0] : value[1];
-    if (!utils.isValid(date)) {
+    if (!adapter.isValid(date)) {
       return;
     }
     const prevDate = rangePosition === 'start' ? prevValue.current?.[0] : prevValue.current?.[1];
@@ -344,16 +345,16 @@ const DateRangeCalendar = /*#__PURE__*/React.forwardRef(function DateRangeCalend
 
     // The current date did not change, this call comes either from a `rangePosition` change or a change in the other date.
     // In both cases, we don't want to change the visible month(s).
-    if (disableAutoMonthSwitching && prevDate && utils.isEqual(prevDate, date)) {
+    if (disableAutoMonthSwitching && prevDate && adapter.isEqual(prevDate, date)) {
       return;
     }
     const displayingMonthRange = calendars - currentMonthCalendarPosition;
-    const currentMonthNumber = utils.getMonth(calendarState.currentMonth);
-    const requestedMonthNumber = utils.getMonth(date);
-    if (!utils.isSameYear(calendarState.currentMonth, date) || requestedMonthNumber < currentMonthNumber || requestedMonthNumber > currentMonthNumber + displayingMonthRange) {
+    const currentMonthNumber = adapter.getMonth(calendarState.currentMonth);
+    const requestedMonthNumber = adapter.getMonth(date);
+    if (!adapter.isSameYear(calendarState.currentMonth, date) || requestedMonthNumber < currentMonthNumber || requestedMonthNumber > currentMonthNumber + displayingMonthRange) {
       const newMonth = rangePosition === 'start' ? date :
       // If need to focus end, scroll to the state when "end" is displaying in the last calendar
-      utils.addMonths(date, -displayingMonthRange);
+      adapter.addMonths(date, -displayingMonthRange);
       setVisibleDate({
         target: newMonth,
         reason: 'controlled-value-change'
@@ -377,7 +378,7 @@ const DateRangeCalendar = /*#__PURE__*/React.forwardRef(function DateRangeCalend
     onMouseLeave: () => setRangePreviewDay(null)
   }), []);
   const previewingRange = calculateRangePreview({
-    utils,
+    adapter,
     range: valueDayRange,
     newDate: rangePreviewDay,
     rangePosition
@@ -386,12 +387,12 @@ const DateRangeCalendar = /*#__PURE__*/React.forwardRef(function DateRangeCalend
     let cleanNewRangePreviewDay;
     if (valueDayRange[0] == null && valueDayRange[1] == null) {
       cleanNewRangePreviewDay = null;
-    } else if (isWithinRange(utils, newRangePreviewDay, valueDayRange)) {
+    } else if (isWithinRange(adapter, newRangePreviewDay, valueDayRange)) {
       cleanNewRangePreviewDay = null;
     } else {
       cleanNewRangePreviewDay = newRangePreviewDay;
     }
-    if (!areDatesEqual(utils, cleanNewRangePreviewDay, rangePreviewDay)) {
+    if (!areDatesEqual(adapter, cleanNewRangePreviewDay, rangePreviewDay)) {
       setRangePreviewDay(cleanNewRangePreviewDay);
     }
   });
@@ -404,8 +405,8 @@ const DateRangeCalendar = /*#__PURE__*/React.forwardRef(function DateRangeCalend
         day,
         isDaySelected
       } = dayOwnerState;
-      const isSelectedStartDate = isStartOfRange(utils, day, valueDayRange);
-      const isSelectedEndDate = isEndOfRange(utils, day, valueDayRange);
+      const isSelectedStartDate = isStartOfRange(adapter, day, valueDayRange);
+      const isSelectedEndDate = isEndOfRange(adapter, day, valueDayRange);
       const shouldInitDragging = !shouldDisableDragEditing && valueDayRange[0] && valueDayRange[1];
       const isElementDraggable = shouldInitDragging && (isSelectedStartDate || isSelectedEndDate);
       let datePosition;
@@ -414,15 +415,15 @@ const DateRangeCalendar = /*#__PURE__*/React.forwardRef(function DateRangeCalend
       } else if (isSelectedEndDate) {
         datePosition = 'end';
       }
-      const isStartOfHighlighting = isDragging ? isStartOfRange(utils, day, draggingRange) : isSelectedStartDate;
-      const isEndOfHighlighting = isDragging ? isEndOfRange(utils, day, draggingRange) : isSelectedEndDate;
+      const isStartOfHighlighting = isDragging ? isStartOfRange(adapter, day, draggingRange) : isSelectedStartDate;
+      const isEndOfHighlighting = isDragging ? isEndOfRange(adapter, day, draggingRange) : isSelectedEndDate;
       return _extends({
-        isPreviewing: shouldHavePreview ? isWithinRange(utils, day, previewingRange) : false,
-        isStartOfPreviewing: shouldHavePreview ? isStartOfRange(utils, day, previewingRange) : false,
-        isEndOfPreviewing: shouldHavePreview ? isEndOfRange(utils, day, previewingRange) : false,
-        isHighlighting: isWithinRange(utils, day, isDragging ? draggingRange : valueDayRange),
+        isPreviewing: shouldHavePreview ? isWithinRange(adapter, day, previewingRange) : false,
+        isStartOfPreviewing: shouldHavePreview ? isStartOfRange(adapter, day, previewingRange) : false,
+        isEndOfPreviewing: shouldHavePreview ? isEndOfRange(adapter, day, previewingRange) : false,
+        isHighlighting: isWithinRange(adapter, day, isDragging ? draggingRange : valueDayRange),
         isStartOfHighlighting,
-        isEndOfHighlighting: isDragging ? isEndOfRange(utils, day, draggingRange) : isSelectedEndDate,
+        isEndOfHighlighting: isDragging ? isEndOfRange(adapter, day, draggingRange) : isSelectedEndDate,
         onMouseEnter: shouldHavePreview ? handleDayMouseEnter : undefined,
         // apply selected styling to the dragging start or end day
         isVisuallySelected: isDaySelected || isDragging && (isStartOfHighlighting || isEndOfHighlighting),
@@ -441,11 +442,11 @@ const DateRangeCalendar = /*#__PURE__*/React.forwardRef(function DateRangeCalend
         warnOnce(['MUI X: The `currentMonthCalendarPosition` prop must be an integer between `1` and the amount of calendars rendered.', 'For example if you have 2 calendars rendered, it should be equal to either 1 or 2.']);
       }
     }
-    const firstMonth = utils.addMonths(calendarState.currentMonth, 1 - currentMonthCalendarPosition);
+    const firstMonth = adapter.addMonths(calendarState.currentMonth, 1 - currentMonthCalendarPosition);
     return Array.from({
       length: calendars
-    }).map((_, index) => utils.addMonths(firstMonth, index));
-  }, [utils, calendarState.currentMonth, calendars, currentMonthCalendarPosition]);
+    }).map((_, index) => adapter.addMonths(firstMonth, index));
+  }, [adapter, calendarState.currentMonth, calendars, currentMonthCalendarPosition]);
   const hasFocus = focusedView !== null;
   const prevOpenViewRef = React.useRef(view);
   React.useEffect(() => {
@@ -679,7 +680,7 @@ process.env.NODE_ENV !== "production" ? DateRangeCalendar.propTypes = {
    * The date used to generate the new value when both `value` and `defaultValue` are empty.
    * @default The closest valid date using the validation props, except callbacks such as `shouldDisableDate`.
    */
-  referenceDate: PropTypes.object,
+  referenceDate: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.object.isRequired), PropTypes.object]),
   /**
    * Component rendered on the "day" view when `props.loading` is true.
    * @returns {React.ReactNode} The node to render when loading.

package/esm/DateRangeCalendar/DateRangeCalendar.types.d.ts

@@ -73,7 +73,7 @@ export interface DateRangeCalendarProps extends ExportedDateRangeCalendarProps,
    * The date used to generate the new value when both `value` and `defaultValue` are empty.
    * @default The closest valid date using the validation props, except callbacks such as `shouldDisableDate`.
    */
-  referenceDate?: PickerValidDate;
+  referenceDate?: PickerValidDate | [PickerValidDate, PickerValidDate];
   /**
    * The number of calendars to render.
    * @default 2

package/esm/DateRangeCalendar/useDragRange.d.ts

@@ -4,7 +4,7 @@ import { PickerRangeValue } from '@mui/x-date-pickers/internals';
 import { RangePosition } from "../models/index.js";
 interface UseDragRangeParams {
   disableDragEditing?: boolean;
-  utils: MuiPickersAdapter;
+  adapter: MuiPickersAdapter;
   setRangeDragDay: (value: PickerValidDate | null) => void;
   setIsDragging: (value: boolean) => void;
   isDragging: boolean;
@@ -31,7 +31,7 @@ interface UseDragRangeResponse extends UseDragRangeEvents {
 }
 export declare const useDragRange: ({
   disableDragEditing,
-  utils,
+  adapter,
   onDatePositionChange,
   onDrop,
   dateRange,

package/esm/DateRangeCalendar/useDragRange.js

@@ -4,13 +4,13 @@ import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 import useEventCallback from '@mui/utils/useEventCallback';
 import { isEndOfRange, isStartOfRange } from "../internals/utils/date-utils.js";
-const resolveDateFromTarget = (target, utils, timezone) => {
+const resolveDateFromTarget = (target, adapter, timezone) => {
   const timestampString = target.dataset.timestamp;
   if (!timestampString) {
     return null;
   }
   const timestamp = +timestampString;
-  return utils.date(new Date(timestamp).toISOString(), timezone);
+  return adapter.date(new Date(timestamp).toISOString(), timezone);
 };
 const isSameAsDraggingDate = event => {
   const timestampString = event.target.dataset.timestamp;
@@ -43,7 +43,7 @@ const resolveElementFromTouch = (event, ignoreTouchTarget) => {
   return null;
 };
 const useDragRangeEvents = ({
-  utils,
+  adapter,
   setRangeDragDay,
   setIsDragging,
   isDragging,
@@ -64,12 +64,12 @@ const useDragRangeEvents = ({
       return false;
     }
     const shouldInitDragging = !disableDragEditing && !!dateRange[0] && !!dateRange[1];
-    const isSelectedStartDate = isStartOfRange(utils, day, dateRange);
-    const isSelectedEndDate = isEndOfRange(utils, day, dateRange);
+    const isSelectedStartDate = isStartOfRange(adapter, day, dateRange);
+    const isSelectedEndDate = isEndOfRange(adapter, day, dateRange);
     return shouldInitDragging && (isSelectedStartDate || isSelectedEndDate);
   };
   const handleDragStart = useEventCallback(event => {
-    const newDate = resolveDateFromTarget(event.target, utils, timezone);
+    const newDate = resolveDateFromTarget(event.target, adapter, timezone);
     if (!isElementDraggable(newDate)) {
       return;
     }
@@ -93,7 +93,7 @@ const useDragRangeEvents = ({
     if (!target) {
       return;
     }
-    const newDate = resolveDateFromTarget(target, utils, timezone);
+    const newDate = resolveDateFromTarget(target, adapter, timezone);
     if (!isElementDraggable(newDate)) {
       return;
     }
@@ -106,14 +106,14 @@ const useDragRangeEvents = ({
     event.preventDefault();
     event.stopPropagation();
     event.dataTransfer.dropEffect = 'move';
-    setRangeDragDay(resolveDateFromTarget(event.target, utils, timezone));
+    setRangeDragDay(resolveDateFromTarget(event.target, adapter, timezone));
   });
   const handleTouchMove = useEventCallback(event => {
     const target = resolveElementFromTouch(event);
     if (!target) {
       return;
     }
-    const newDate = resolveDateFromTarget(target, utils, timezone);
+    const newDate = resolveDateFromTarget(target, adapter, timezone);
     if (newDate) {
       setRangeDragDay(newDate);
     }
@@ -160,7 +160,7 @@ const useDragRangeEvents = ({
 
     // make sure the focused element is the element where touch ended
     target.focus();
-    const newDate = resolveDateFromTarget(target, utils, timezone);
+    const newDate = resolveDateFromTarget(target, adapter, timezone);
     if (newDate) {
       onDrop(newDate);
     }
@@ -187,7 +187,7 @@ const useDragRangeEvents = ({
     if (isSameAsDraggingDate(event)) {
       return;
     }
-    const newDate = resolveDateFromTarget(event.target, utils, timezone);
+    const newDate = resolveDateFromTarget(event.target, adapter, timezone);
     if (newDate) {
       onDrop(newDate);
     }
@@ -206,7 +206,7 @@ const useDragRangeEvents = ({
 };
 export const useDragRange = ({
   disableDragEditing,
-  utils,
+  adapter,
   onDatePositionChange,
   onDrop,
   dateRange,
@@ -215,24 +215,24 @@ export const useDragRange = ({
   const [isDragging, setIsDragging] = React.useState(false);
   const [rangeDragDay, setRangeDragDay] = React.useState(null);
   const handleRangeDragDayChange = useEventCallback(newValue => {
-    if (!utils.isEqual(newValue, rangeDragDay)) {
+    if (!adapter.isEqual(newValue, rangeDragDay)) {
       setRangeDragDay(newValue);
     }
   });
   const draggingDatePosition = React.useMemo(() => {
     const [start, end] = dateRange;
     if (rangeDragDay) {
-      if (start && utils.isBefore(rangeDragDay, start)) {
+      if (start && adapter.isBefore(rangeDragDay, start)) {
         return 'start';
       }
-      if (end && utils.isAfter(rangeDragDay, end)) {
+      if (end && adapter.isAfter(rangeDragDay, end)) {
         return 'end';
       }
     }
     return null;
-  }, [dateRange, rangeDragDay, utils]);
+  }, [dateRange, rangeDragDay, adapter]);
   const dragRangeEvents = useDragRangeEvents({
-    utils,
+    adapter,
     onDatePositionChange,
     onDrop,
     setIsDragging,

package/esm/DateRangePicker/DateRangePicker.js

@@ -268,7 +268,7 @@ process.env.NODE_ENV !== "production" ? DateRangePicker.propTypes = {
    * The date used to generate the new value when both `value` and `defaultValue` are empty.
    * @default The closest valid date-time using the validation props, except callbacks like `shouldDisable<...>`.
    */
-  referenceDate: PropTypes.object,
+  referenceDate: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.object), PropTypes.object]),
   /**
    * Component rendered on the "day" view when `props.loading` is true.
    * @returns {React.ReactNode} The node to render when loading.

package/esm/DateRangePicker/DateRangePickerToolbar.js

@@ -9,8 +9,8 @@ import clsx from 'clsx';
 import Typography from '@mui/material/Typography';
 import { styled, useThemeProps } from '@mui/material/styles';
 import composeClasses from '@mui/utils/composeClasses';
-import { PickersToolbar, PickersToolbarButton, useUtils, useToolbarOwnerState } from '@mui/x-date-pickers/internals';
-import { usePickerContext, usePickerTranslations } from '@mui/x-date-pickers/hooks';
+import { PickersToolbar, PickersToolbarButton, useToolbarOwnerState } from '@mui/x-date-pickers/internals';
+import { usePickerAdapter, usePickerContext, usePickerTranslations } from '@mui/x-date-pickers/hooks';
 import { getDateRangePickerToolbarUtilityClass } from "./dateRangePickerToolbarClasses.js";
 import { usePickerRangePositionContext } from "../hooks/index.js";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
@@ -42,7 +42,7 @@ const DateRangePickerToolbarContainer = styled('div', {
  * - [DateRangePickerToolbar API](https://mui.com/x/api/date-pickers/date-range-picker-toolbar/)
  */
 const DateRangePickerToolbar = /*#__PURE__*/React.forwardRef(function DateRangePickerToolbar(inProps, ref) {
-  const utils = useUtils();
+  const adapter = usePickerAdapter();
   const props = useThemeProps({
     props: inProps,
     name: 'MuiDateRangePickerToolbar'
@@ -65,12 +65,12 @@ const DateRangePickerToolbar = /*#__PURE__*/React.forwardRef(function DateRangeP
   const classes = useUtilityClasses(classesProp);
 
   // This can't be a default value when spreading because it breaks the API generation.
-  const toolbarFormat = toolbarFormatProp ?? utils.formats.shortDate;
+  const toolbarFormat = toolbarFormatProp ?? adapter.formats.shortDate;
   const formatDate = (date, fallback) => {
-    if (!utils.isValid(date)) {
+    if (!adapter.isValid(date)) {
       return fallback;
     }
-    return utils.formatByString(date, toolbarFormat);
+    return adapter.formatByString(date, toolbarFormat);
   };
   return /*#__PURE__*/_jsx(DateRangePickerToolbarRoot, _extends({}, other, {
     toolbarTitle: translations.dateRangePickerToolbarTitle,

package/esm/DateRangePickerDay/DateRangePickerDay.js

@@ -9,8 +9,9 @@ import clsx from 'clsx';
 import { useLicenseVerifier } from '@mui/x-license';
 import { alpha, styled, useThemeProps } from '@mui/material/styles';
 import composeClasses from '@mui/utils/composeClasses';
-import { useUtils, usePickerDayOwnerState } from '@mui/x-date-pickers/internals';
+import { usePickerDayOwnerState } from '@mui/x-date-pickers/internals';
 import { PickersDay } from '@mui/x-date-pickers/PickersDay';
+import { usePickerAdapter } from '@mui/x-date-pickers/hooks';
 import { getDateRangePickerDayUtilityClass, dateRangePickerDayClasses } from "./dateRangePickerDayClasses.js";
 import { jsx as _jsx } from "react/jsx-runtime";
 const useUtilityClasses = (classes, ownerState) => {
@@ -227,8 +228,8 @@ const DateRangePickerDayRaw = /*#__PURE__*/React.forwardRef(function DateRangePi
       showDaysOutsideCurrentMonth
     } = props,
     other = _objectWithoutPropertiesLoose(props, _excluded);
-  useLicenseVerifier('x-date-pickers-pro', "MTc1MDI4NDAwMDAwMA==");
-  const utils = useUtils();
+  useLicenseVerifier('x-date-pickers-pro', "MTc1MTU4MDAwMDAwMA==");
+  const adapter = usePickerAdapter();
   const shouldRenderHighlight = isHighlighting && !outsideCurrentMonth;
   const shouldRenderPreview = isPreviewing && !outsideCurrentMonth;
   const pickersDayOwnerState = usePickerDayOwnerState({
@@ -252,8 +253,8 @@ const DateRangePickerDayRaw = /*#__PURE__*/React.forwardRef(function DateRangePi
     isDayPreviewEnd: isEndOfPreviewing,
     isDayInsidePreview: isPreviewing && !isStartOfPreviewing && !isEndOfPreviewing,
     // Properties specific to the MUI implementation (some might be removed in the next major)
-    isDayStartOfMonth: utils.isSameDay(day, utils.startOfMonth(day)),
-    isDayEndOfMonth: utils.isSameDay(day, utils.endOfMonth(day)),
+    isDayStartOfMonth: adapter.isSameDay(day, adapter.startOfMonth(day)),
+    isDayEndOfMonth: adapter.isSameDay(day, adapter.endOfMonth(day)),
     isDayFirstVisibleCell: isFirstVisibleCell,
     isDayLastVisibleCell: isLastVisibleCell,
     isDayFillerCell: outsideCurrentMonth && !showDaysOutsideCurrentMonth