@mui/x-date-pickers 8.0.0-alpha.0 → 8.0.0-alpha.10

package/node/internals/hooks/usePicker/usePickerValue.js

@@ -13,106 +13,6 @@ var _useOpenState = require("../useOpenState");
 var _useUtils = require("../useUtils");
 var _validation = require("../../../validation");
 var _useValueWithTimezone = require("../useValueWithTimezone");
-/**
- * Decide if the new value should be published
- * The published value will be passed to `onChange` if defined.
- */
-const shouldPublishValue = params => {
-  const {
-    action,
-    hasChanged,
-    dateState,
-    isControlled
-  } = params;
-  const isCurrentValueTheDefaultValue = !isControlled && !dateState.hasBeenModifiedSinceMount;
-
-  // The field is responsible for only calling `onChange` when needed.
-  if (action.name === 'setValueFromField') {
-    return true;
-  }
-  if (action.name === 'setValueFromAction') {
-    // If the component is not controlled, and the value has not been modified since the mount,
-    // Then we want to publish the default value whenever the user pressed the "Accept", "Today" or "Clear" button.
-    if (isCurrentValueTheDefaultValue && ['accept', 'today', 'clear'].includes(action.pickerAction)) {
-      return true;
-    }
-    return hasChanged(dateState.lastPublishedValue);
-  }
-  if (action.name === 'setValueFromView' && action.selectionState !== 'shallow') {
-    // On the first view,
-    // If the value is not controlled, then clicking on any value (including the one equal to `defaultValue`) should call `onChange`
-    if (isCurrentValueTheDefaultValue) {
-      return true;
-    }
-    return hasChanged(dateState.lastPublishedValue);
-  }
-  if (action.name === 'setValueFromShortcut') {
-    // On the first view,
-    // If the value is not controlled, then clicking on any value (including the one equal to `defaultValue`) should call `onChange`
-    if (isCurrentValueTheDefaultValue) {
-      return true;
-    }
-    return hasChanged(dateState.lastPublishedValue);
-  }
-  return false;
-};
-
-/**
- * Decide if the new value should be committed.
- * The committed value will be passed to `onAccept` if defined.
- * It will also be used as a reset target when calling the `cancel` picker action (when clicking on the "Cancel" button).
- */
-const shouldCommitValue = params => {
-  const {
-    action,
-    hasChanged,
-    dateState,
-    isControlled,
-    closeOnSelect
-  } = params;
-  const isCurrentValueTheDefaultValue = !isControlled && !dateState.hasBeenModifiedSinceMount;
-  if (action.name === 'setValueFromAction') {
-    // If the component is not controlled, and the value has not been modified since the mount,
-    // Then we want to commit the default value whenever the user pressed the "Accept", "Today" or "Clear" button.
-    if (isCurrentValueTheDefaultValue && ['accept', 'today', 'clear'].includes(action.pickerAction)) {
-      return true;
-    }
-    return hasChanged(dateState.lastCommittedValue);
-  }
-  if (action.name === 'setValueFromView' && action.selectionState === 'finish' && closeOnSelect) {
-    // On picker where the 1st view is also the last view,
-    // If the value is not controlled, then clicking on any value (including the one equal to `defaultValue`) should call `onAccept`
-    if (isCurrentValueTheDefaultValue) {
-      return true;
-    }
-    return hasChanged(dateState.lastCommittedValue);
-  }
-  if (action.name === 'setValueFromShortcut') {
-    return action.changeImportance === 'accept' && hasChanged(dateState.lastCommittedValue);
-  }
-  return false;
-};
-
-/**
- * Decide if the picker should be closed after the value is updated.
- */
-const shouldClosePicker = params => {
-  const {
-    action,
-    closeOnSelect
-  } = params;
-  if (action.name === 'setValueFromAction') {
-    return true;
-  }
-  if (action.name === 'setValueFromView') {
-    return action.selectionState === 'finish' && closeOnSelect;
-  }
-  if (action.name === 'setValueFromShortcut') {
-    return action.changeImportance === 'accept';
-  }
-  return false;
-};
-
 /**
  * Manage the value lifecycle of all the pickers.
  */
@@ -120,7 +20,6 @@ const usePickerValue = ({
   props,
   valueManager,
   valueType,
-  wrapperVariant,
   validator
 }) => {
   const {
@@ -128,8 +27,9 @@ const usePickerValue = ({
     onChange,
     value: inValueWithoutRenderTimezone,
     defaultValue: inDefaultValue,
-    closeOnSelect = wrapperVariant === 'desktop',
-    timezone: timezoneProp
+    closeOnSelect = false,
+    timezone: timezoneProp,
+    referenceDate
   } = props;
   const {
     current: defaultValue
@@ -137,6 +37,7 @@ const usePickerValue = ({
   const {
     current: isControlled
   } = React.useRef(inValueWithoutRenderTimezone !== undefined);
+  const [previousTimezoneProp, setPreviousTimezoneProp] = React.useState(timezoneProp);
 
   /* eslint-disable react-hooks/rules-of-hooks, react-hooks/exhaustive-deps */
   if (process.env.NODE_ENV !== 'production') {
@@ -156,8 +57,8 @@ const usePickerValue = ({
   const utils = (0, _useUtils.useUtils)();
   const adapter = (0, _useUtils.useLocalizationContext)();
   const {
-    isOpen,
-    setIsOpen
+    open,
+    setOpen
   } = (0, _useOpenState.useOpenState)(props);
   const {
     timezone,
@@ -167,6 +68,7 @@ const usePickerValue = ({
     timezone: timezoneProp,
     value: inValueWithoutRenderTimezone,
     defaultValue,
+    referenceDate,
     onChange,
     valueManager
   });
@@ -183,10 +85,19 @@ const usePickerValue = ({
       draft: initialValue,
       lastPublishedValue: initialValue,
       lastCommittedValue: initialValue,
-      lastControlledValue: inValueWithTimezoneToRender,
+      lastControlledValue: inValueWithoutRenderTimezone,
       hasBeenModifiedSinceMount: false
     };
   });
+  const timezoneFromDraftValue = valueManager.getTimezone(utils, dateState.draft);
+  if (previousTimezoneProp !== timezoneProp) {
+    setPreviousTimezoneProp(timezoneProp);
+    if (timezoneProp && timezoneFromDraftValue && timezoneProp !== timezoneFromDraftValue) {
+      setDateState(prev => (0, _extends2.default)({}, prev, {
+        draft: valueManager.setTimezone(utils, timezoneProp, prev.draft)
+      }));
+    }
+  }
   const {
     getValidationErrorForNewValue
   } = (0, _validation.useValidation)({
@@ -196,50 +107,57 @@ const usePickerValue = ({
     value: dateState.draft,
     onError: props.onError
   });
-  const updateDate = (0, _useEventCallback.default)(action => {
-    const updaterParams = {
-      action,
-      dateState,
-      hasChanged: comparison => !valueManager.areValuesEqual(utils, action.value, comparison),
-      isControlled,
-      closeOnSelect
-    };
-    const shouldPublish = shouldPublishValue(updaterParams);
-    const shouldCommit = shouldCommitValue(updaterParams);
-    const shouldClose = shouldClosePicker(updaterParams);
+  const setValue = (0, _useEventCallback.default)((newValue, options) => {
+    const {
+      changeImportance = 'accept',
+      skipPublicationIfPristine = false,
+      validationError,
+      shortcut,
+      shouldClose = changeImportance === 'accept'
+    } = options ?? {};
+    let shouldPublish;
+    let shouldCommit;
+    if (!skipPublicationIfPristine && !isControlled && !dateState.hasBeenModifiedSinceMount) {
+      // If the value is not controlled and the value has never been modified before,
+      // Then clicking on any value (including the one equal to `defaultValue`) should call `onChange` and `onAccept`
+      shouldPublish = true;
+      shouldCommit = changeImportance === 'accept';
+    } else {
+      shouldPublish = !valueManager.areValuesEqual(utils, newValue, dateState.lastPublishedValue);
+      shouldCommit = changeImportance === 'accept' && !valueManager.areValuesEqual(utils, newValue, dateState.lastCommittedValue);
+    }
     setDateState(prev => (0, _extends2.default)({}, prev, {
-      draft: action.value,
-      lastPublishedValue: shouldPublish ? action.value : prev.lastPublishedValue,
-      lastCommittedValue: shouldCommit ? action.value : prev.lastCommittedValue,
+      draft: newValue,
+      lastPublishedValue: shouldPublish ? newValue : prev.lastPublishedValue,
+      lastCommittedValue: shouldCommit ? newValue : prev.lastCommittedValue,
       hasBeenModifiedSinceMount: true
     }));
     let cachedContext = null;
     const getContext = () => {
       if (!cachedContext) {
-        const validationError = action.name === 'setValueFromField' ? action.context.validationError : getValidationErrorForNewValue(action.value);
         cachedContext = {
-          validationError
+          validationError: validationError == null ? getValidationErrorForNewValue(newValue) : validationError
         };
-        if (action.name === 'setValueFromShortcut') {
-          cachedContext.shortcut = action.shortcut;
+        if (shortcut) {
+          cachedContext.shortcut = shortcut;
         }
       }
       return cachedContext;
     };
     if (shouldPublish) {
-      handleValueChange(action.value, getContext());
+      handleValueChange(newValue, getContext());
     }
     if (shouldCommit && onAccept) {
-      onAccept(action.value, getContext());
+      onAccept(newValue, getContext());
     }
     if (shouldClose) {
-      setIsOpen(false);
+      setOpen(false);
     }
   });
-  if (inValueWithTimezoneToRender !== undefined && (dateState.lastControlledValue === undefined || !valueManager.areValuesEqual(utils, dateState.lastControlledValue, inValueWithTimezoneToRender))) {
+  if (dateState.lastControlledValue !== inValueWithoutRenderTimezone) {
     const isUpdateComingFromPicker = valueManager.areValuesEqual(utils, dateState.draft, inValueWithTimezoneToRender);
     setDateState(prev => (0, _extends2.default)({}, prev, {
-      lastControlledValue: inValueWithTimezoneToRender
+      lastControlledValue: inValueWithoutRenderTimezone
     }, isUpdateComingFromPicker ? {} : {
       lastCommittedValue: inValueWithTimezoneToRender,
       lastPublishedValue: inValueWithTimezoneToRender,
@@ -247,85 +165,6 @@ const usePickerValue = ({
       hasBeenModifiedSinceMount: true
     }));
   }
-  const handleClear = (0, _useEventCallback.default)(() => {
-    updateDate({
-      value: valueManager.emptyValue,
-      name: 'setValueFromAction',
-      pickerAction: 'clear'
-    });
-  });
-  const handleAccept = (0, _useEventCallback.default)(() => {
-    updateDate({
-      value: dateState.lastPublishedValue,
-      name: 'setValueFromAction',
-      pickerAction: 'accept'
-    });
-  });
-  const handleDismiss = (0, _useEventCallback.default)(() => {
-    updateDate({
-      value: dateState.lastPublishedValue,
-      name: 'setValueFromAction',
-      pickerAction: 'dismiss'
-    });
-  });
-  const handleCancel = (0, _useEventCallback.default)(() => {
-    updateDate({
-      value: dateState.lastCommittedValue,
-      name: 'setValueFromAction',
-      pickerAction: 'cancel'
-    });
-  });
-  const handleSetToday = (0, _useEventCallback.default)(() => {
-    updateDate({
-      value: valueManager.getTodayValue(utils, timezone, valueType),
-      name: 'setValueFromAction',
-      pickerAction: 'today'
-    });
-  });
-  const handleOpen = (0, _useEventCallback.default)(event => {
-    event.preventDefault();
-    setIsOpen(true);
-  });
-  const handleClose = (0, _useEventCallback.default)(event => {
-    event?.preventDefault();
-    setIsOpen(false);
-  });
-  const handleChange = (0, _useEventCallback.default)((newValue, selectionState = 'partial') => updateDate({
-    name: 'setValueFromView',
-    value: newValue,
-    selectionState
-  }));
-  const handleSelectShortcut = (0, _useEventCallback.default)((newValue, changeImportance, shortcut) => updateDate({
-    name: 'setValueFromShortcut',
-    value: newValue,
-    changeImportance,
-    shortcut
-  }));
-  const handleChangeFromField = (0, _useEventCallback.default)((newValue, context) => updateDate({
-    name: 'setValueFromField',
-    value: newValue,
-    context
-  }));
-  const actions = {
-    onClear: handleClear,
-    onAccept: handleAccept,
-    onDismiss: handleDismiss,
-    onCancel: handleCancel,
-    onSetToday: handleSetToday,
-    onOpen: handleOpen,
-    onClose: handleClose
-  };
-  const fieldResponse = {
-    value: dateState.draft,
-    onChange: handleChangeFromField
-  };
-  const viewValue = React.useMemo(() => valueManager.cleanValue(utils, dateState.draft), [utils, valueManager, dateState.draft]);
-  const viewResponse = {
-    value: viewValue,
-    onChange: handleChange,
-    onClose: handleClose,
-    open: isOpen
-  };
   const isValid = testedValue => {
     const error = validator({
       adapter,
@@ -335,18 +174,62 @@ const usePickerValue = ({
     });
     return !valueManager.hasError(error);
   };
-  const layoutResponse = (0, _extends2.default)({}, actions, {
-    value: viewValue,
-    onChange: handleChange,
-    onSelectShortcut: handleSelectShortcut,
-    isValid
+  const clearValue = (0, _useEventCallback.default)(() => setValue(valueManager.emptyValue));
+  const setValueToToday = (0, _useEventCallback.default)(() => setValue(valueManager.getTodayValue(utils, timezone, valueType)));
+  const acceptValueChanges = (0, _useEventCallback.default)(() => setValue(dateState.lastPublishedValue));
+  const cancelValueChanges = (0, _useEventCallback.default)(() => setValue(dateState.lastCommittedValue, {
+    skipPublicationIfPristine: true
+  }));
+  const dismissViews = (0, _useEventCallback.default)(() => {
+    setValue(dateState.lastPublishedValue, {
+      skipPublicationIfPristine: true
+    });
   });
+  const setValueFromView = (0, _useEventCallback.default)((newValue, selectionState = 'partial') => {
+    // TODO: Expose a new method (private?) like `setView` that only updates the draft value.
+    if (selectionState === 'shallow') {
+      setDateState(prev => (0, _extends2.default)({}, prev, {
+        draft: newValue,
+        hasBeenModifiedSinceMount: true
+      }));
+    }
+    setValue(newValue, {
+      changeImportance: selectionState === 'finish' && closeOnSelect ? 'accept' : 'set'
+    });
+  });
+  const valueWithoutError = React.useMemo(() => valueManager.cleanValue(utils, dateState.draft), [utils, valueManager, dateState.draft]);
+  const viewResponse = {
+    value: valueWithoutError,
+    onChange: setValueFromView,
+    open,
+    setOpen
+  };
+  const actionsContextValue = React.useMemo(() => ({
+    setValue,
+    setOpen,
+    clearValue,
+    setValueToToday,
+    acceptValueChanges,
+    cancelValueChanges
+  }), [setValue, setOpen, clearValue, setValueToToday, acceptValueChanges, cancelValueChanges]);
+  const contextValue = React.useMemo(() => (0, _extends2.default)({}, actionsContextValue, {
+    value: dateState.draft,
+    timezone,
+    open
+  }), [actionsContextValue, timezone, open, dateState.draft]);
+  const privateContextValue = React.useMemo(() => ({
+    dismissViews
+  }), [dismissViews]);
+  const providerParams = {
+    value: dateState.draft,
+    contextValue,
+    actionsContextValue,
+    privateContextValue,
+    isValidContextValue: isValid
+  };
   return {
-    open: isOpen,
-    fieldProps: fieldResponse,
     viewProps: viewResponse,
-    layoutProps: layoutResponse,
-    actions
+    provider: providerParams
   };
 };
 exports.usePickerValue = usePickerValue;

package/node/internals/hooks/usePicker/usePickerViews.js

@@ -13,19 +13,14 @@ var _useEnhancedEffect = _interopRequireDefault(require("@mui/utils/useEnhancedE
 var _useEventCallback = _interopRequireDefault(require("@mui/utils/useEventCallback"));
 var _useViews = require("../useViews");
 var _timeUtils = require("../../utils/time-utils");
+var _jsxRuntime = require("react/jsx-runtime");
 const _excluded = ["className", "sx"];
 /**
  * Props used to handle the views that are common to all pickers.
  */
-
-/**
- * Props used to handle the views of the pickers.
- */
-
 /**
  * Props used to handle the value of the pickers.
  */
-
 /**
  * Manage the views of all the pickers:
  * - Handles the view switch
@@ -35,15 +30,15 @@ const _excluded = ["className", "sx"];
 const usePickerViews = ({
   props,
   propsFromPickerValue,
-  additionalViewProps,
   autoFocusView,
-  rendererInterceptor,
+  rendererInterceptor: RendererInterceptor,
   fieldRef
 }) => {
   const {
     onChange,
+    value,
     open,
-    onClose
+    setOpen
   } = propsFromPickerValue;
   const {
     view: inView,
@@ -95,7 +90,7 @@ const usePickerViews = ({
     return acc;
   }, 0), [viewRenderers, views]);
   const currentViewMode = viewModeLookup[view];
-  const shouldRestoreFocus = (0, _useEventCallback.default)(() => currentViewMode === 'UI');
+  const doesTheCurrentViewHasAnUI = (0, _useEventCallback.default)(() => currentViewMode === 'UI');
   const [popperView, setPopperView] = React.useState(currentViewMode === 'UI' ? view : null);
   if (popperView !== view && viewModeLookup[view] === 'UI') {
     setPopperView(view);
@@ -103,7 +98,7 @@ const usePickerViews = ({
   (0, _useEnhancedEffect.default)(() => {
     // Handle case of `DateTimePicker` without time renderers
     if (currentViewMode === 'field' && open) {
-      onClose();
+      setOpen(false);
       setTimeout(() => {
         fieldRef?.current?.setSelectedSections(view);
         // focusing the input before the range selection is done
@@ -134,15 +129,26 @@ const usePickerViews = ({
     setFocusedView(newView, true);
   }, [open]); // eslint-disable-line react-hooks/exhaustive-deps
 
-  const layoutProps = {
+  const actionsContextValue = React.useMemo(() => ({
+    setView
+  }), [setView]);
+  const contextValue = React.useMemo(() => (0, _extends2.default)({}, actionsContextValue, {
     views,
-    view: popperView,
-    onViewChange: setView
+    view: popperView
+  }), [actionsContextValue, views, popperView]);
+  const privateContextValue = React.useMemo(() => ({
+    hasUIView,
+    doesTheCurrentViewHasAnUI
+  }), [hasUIView, doesTheCurrentViewHasAnUI]);
+  const providerParams = {
+    hasUIView,
+    views,
+    contextValue,
+    actionsContextValue,
+    privateContextValue
   };
   return {
-    hasUIView,
-    shouldRestoreFocus,
-    layoutProps,
+    provider: providerParams,
     renderCurrentView: () => {
       if (popperView == null) {
         return null;
@@ -151,9 +157,10 @@ const usePickerViews = ({
       if (renderer == null) {
         return null;
       }
-      const rendererProps = (0, _extends2.default)({}, propsToForwardToView, additionalViewProps, propsFromPickerValue, {
+      const rendererProps = (0, _extends2.default)({}, propsToForwardToView, {
         views,
         timezone,
+        value,
         onChange: setValueAndGoToNextView,
         view: popperView,
         onViewChange: setView,
@@ -162,8 +169,12 @@ const usePickerViews = ({
         showViewSwitcher: timeViewsCount > 1,
         timeViewsCount
       });
-      if (rendererInterceptor) {
-        return rendererInterceptor(viewRenderers, popperView, rendererProps);
+      if (RendererInterceptor) {
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(RendererInterceptor, {
+          viewRenderers: viewRenderers,
+          popperView: popperView,
+          rendererProps: rendererProps
+        });
       }
       return renderer(rendererProps);
     }

package/node/internals/hooks/{useDefaultReduceAnimations.js → useReduceAnimations.js}

@@ -4,7 +4,8 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.useDefaultReduceAnimations = exports.slowAnimationDevices = void 0;
+exports.slowAnimationDevices = void 0;
+exports.useReduceAnimations = useReduceAnimations;
 var _useMediaQuery = _interopRequireDefault(require("@mui/material/useMediaQuery"));
 const PREFERS_REDUCED_MOTION = '@media (prefers-reduced-motion: reduce)';
 
@@ -13,10 +14,12 @@ const mobileVersionMatches = typeof navigator !== 'undefined' && navigator.userA
 const androidVersion = mobileVersionMatches && mobileVersionMatches[1] ? parseInt(mobileVersionMatches[1], 10) : null;
 const iOSVersion = mobileVersionMatches && mobileVersionMatches[2] ? parseInt(mobileVersionMatches[2], 10) : null;
 const slowAnimationDevices = exports.slowAnimationDevices = androidVersion && androidVersion < 10 || iOSVersion && iOSVersion < 13 || false;
-const useDefaultReduceAnimations = () => {
+function useReduceAnimations(customReduceAnimations) {
   const prefersReduced = (0, _useMediaQuery.default)(PREFERS_REDUCED_MOTION, {
     defaultMatches: false
   });
+  if (customReduceAnimations != null) {
+    return customReduceAnimations;
+  }
   return prefersReduced || slowAnimationDevices;
-};
-exports.useDefaultReduceAnimations = useDefaultReduceAnimations;
+}

package/node/internals/hooks/useStaticPicker/useStaticPicker.js

@@ -15,8 +15,9 @@ var _usePicker = require("../usePicker");
 var _PickerProvider = require("../../components/PickerProvider");
 var _PickersLayout = require("../../../PickersLayout");
 var _dimensions = require("../../constants/dimensions");
+var _utils = require("../../utils/utils");
 var _jsxRuntime = require("react/jsx-runtime");
-const _excluded = ["props", "ref"];
+const _excluded = ["props"];
 const PickerStaticLayout = (0, _styles.styled)(_PickersLayout.PickersLayout)(({
   theme
 }) => ({
@@ -33,39 +34,33 @@ const PickerStaticLayout = (0, _styles.styled)(_PickersLayout.PickersLayout)(({
  */
 const useStaticPicker = _ref => {
   let {
-      props,
-      ref
+      props
     } = _ref,
     pickerParams = (0, _objectWithoutPropertiesLoose2.default)(_ref, _excluded);
   const {
     localeText,
     slots,
     slotProps,
-    className,
-    sx,
     displayStaticWrapperAs,
     autoFocus
   } = props;
   const {
-    layoutProps,
     providerProps,
     renderCurrentView
   } = (0, _usePicker.usePicker)((0, _extends2.default)({}, pickerParams, {
     props,
     autoFocusView: autoFocus ?? false,
-    fieldRef: undefined,
     localeText,
-    additionalViewProps: {},
-    wrapperVariant: displayStaticWrapperAs
+    variant: displayStaticWrapperAs
   }));
   const Layout = slots?.layout ?? PickerStaticLayout;
   const renderPicker = () => /*#__PURE__*/(0, _jsxRuntime.jsx)(_PickerProvider.PickerProvider, (0, _extends2.default)({}, providerProps, {
-    children: /*#__PURE__*/(0, _jsxRuntime.jsx)(Layout, (0, _extends2.default)({}, layoutProps, slotProps?.layout, {
+    children: /*#__PURE__*/(0, _jsxRuntime.jsx)(Layout, (0, _extends2.default)({}, slotProps?.layout, {
       slots: slots,
       slotProps: slotProps,
-      sx: [...(Array.isArray(sx) ? sx : [sx]), ...(Array.isArray(slotProps?.layout?.sx) ? slotProps.layout.sx : [slotProps?.layout?.sx])],
-      className: (0, _clsx.default)(className, slotProps?.layout?.className),
-      ref: ref,
+      sx: (0, _utils.mergeSx)(providerProps.contextValue.rootSx, slotProps?.layout?.sx),
+      className: (0, _clsx.default)(providerProps.contextValue.rootClassName, slotProps?.layout?.className),
+      ref: providerProps.contextValue.rootRef,
       children: renderCurrentView()
     }))
   }));

package/node/internals/hooks/useToolbarOwnerState.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useToolbarOwnerState = useToolbarOwnerState;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var React = _interopRequireWildcard(require("react"));
+var _RtlProvider = require("@mui/system/RtlProvider");
+var _usePickerPrivateContext = require("./usePickerPrivateContext");
+function useToolbarOwnerState() {
+  const {
+    ownerState: pickerOwnerState
+  } = (0, _usePickerPrivateContext.usePickerPrivateContext)();
+  const isRtl = (0, _RtlProvider.useRtl)();
+  return React.useMemo(() => (0, _extends2.default)({}, pickerOwnerState, {
+    toolbarDirection: isRtl ? 'rtl' : 'ltr'
+  }), [pickerOwnerState, isRtl]);
+}

package/node/internals/hooks/useUtils.js

@@ -30,7 +30,7 @@ const useDefaultDates = () => useLocalizationContext().defaultDates;
 exports.useDefaultDates = useDefaultDates;
 const useNow = timezone => {
   const utils = useUtils();
-  const now = React.useRef();
+  const now = React.useRef(undefined);
   if (now.current === undefined) {
     now.current = utils.date(undefined, timezone);
   }

package/node/internals/hooks/useValueWithTimezone.js

@@ -19,6 +19,7 @@ const useValueWithTimezone = ({
   timezone: timezoneProp,
   value: valueProp,
   defaultValue,
+  referenceDate,
   onChange,
   valueManager
 }) => {
@@ -32,7 +33,16 @@ const useValueWithTimezone = ({
     }
     return valueManager.setTimezone(utils, inputTimezone, newValue);
   });
-  const timezoneToRender = timezoneProp ?? inputTimezone ?? 'default';
+  let timezoneToRender;
+  if (timezoneProp) {
+    timezoneToRender = timezoneProp;
+  } else if (inputTimezone) {
+    timezoneToRender = inputTimezone;
+  } else if (referenceDate) {
+    timezoneToRender = utils.getTimezone(referenceDate);
+  } else {
+    timezoneToRender = 'default';
+  }
   const valueWithTimezoneToRender = React.useMemo(() => valueManager.setTimezone(utils, timezoneToRender, inputValue), [valueManager, utils, timezoneToRender, inputValue]);
   const handleValueChange = (0, _useEventCallback.default)((newValue, ...otherParams) => {
     const newValueWithInputTimezone = setInputTimezone(newValue);
@@ -54,6 +64,7 @@ const useControlledValueWithTimezone = ({
   timezone: timezoneProp,
   value: valueProp,
   defaultValue,
+  referenceDate,
   onChange: onChangeProp,
   valueManager
 }) => {
@@ -71,6 +82,7 @@ const useControlledValueWithTimezone = ({
     timezone: timezoneProp,
     value: valueWithInputTimezone,
     defaultValue: undefined,
+    referenceDate,
     onChange,
     valueManager
   });