@mui/x-date-pickers 8.0.0-alpha.13 → 8.0.0-alpha.14

package/internals/hooks/usePicker/{usePickerValue.js → hooks/useValueAndOpenStates.js}

@@ -5,108 +5,126 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.usePickerValue = void 0;
+exports.useValueAndOpenStates = useValueAndOpenStates;
 var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
 var React = _interopRequireWildcard(require("react"));
+var _warning = require("@mui/x-internals/warning");
 var _useEventCallback = _interopRequireDefault(require("@mui/utils/useEventCallback"));
-var _useOpenState = require("../useOpenState");
-var _useUtils = require("../useUtils");
-var _validation = require("../../../validation");
-var _useValueWithTimezone = require("../useValueWithTimezone");
-/**
- * Manage the value lifecycle of all the pickers.
- */
-const usePickerValue = ({
-  props,
-  valueManager,
-  valueType,
-  validator
-}) => {
+var _useValueWithTimezone = require("../../useValueWithTimezone");
+var _useUtils = require("../../useUtils");
+var _validation = require("../../../../validation");
+function useValueAndOpenStates(parameters) {
   const {
-    onAccept,
+    props,
+    valueManager,
+    validator
+  } = parameters;
+  const {
+    value: valueProp,
+    defaultValue: defaultValueProp,
     onChange,
-    value: inValueWithoutRenderTimezone,
-    defaultValue: inDefaultValue,
-    closeOnSelect = false,
+    referenceDate,
     timezone: timezoneProp,
-    referenceDate
+    onAccept,
+    closeOnSelect,
+    open: openProp,
+    onOpen,
+    onClose
   } = props;
   const {
     current: defaultValue
-  } = React.useRef(inDefaultValue);
+  } = React.useRef(defaultValueProp);
+  const {
+    current: isValueControlled
+  } = React.useRef(valueProp !== undefined);
   const {
-    current: isControlled
-  } = React.useRef(inValueWithoutRenderTimezone !== undefined);
+    current: isOpenControlled
+  } = React.useRef(openProp !== undefined);
   const [previousTimezoneProp, setPreviousTimezoneProp] = React.useState(timezoneProp);
+  const utils = (0, _useUtils.useUtils)();
+  if (process.env.NODE_ENV !== 'production') {
+    if (props.renderInput != null) {
+      (0, _warning.warnOnce)(['MUI X: The `renderInput` prop has been removed in version 6.0 of the Date and Time Pickers.', 'You can replace it with the `textField` component slot in most cases.', 'For more information, please have a look at the migration guide (https://mui.com/x/migration/migration-pickers-v5/#input-renderer-required-in-v5).']);
+    }
+  }
 
   /* eslint-disable react-hooks/rules-of-hooks, react-hooks/exhaustive-deps */
   if (process.env.NODE_ENV !== 'production') {
     React.useEffect(() => {
-      if (isControlled !== (inValueWithoutRenderTimezone !== undefined)) {
-        console.error([`MUI X: A component is changing the ${isControlled ? '' : 'un'}controlled value of a picker to be ${isControlled ? 'un' : ''}controlled.`, 'Elements should not switch from uncontrolled to controlled (or vice versa).', `Decide between using a controlled or uncontrolled value` + 'for the lifetime of the component.', "The nature of the state is determined during the first render. It's considered controlled if the value is not `undefined`.", 'More info: https://fb.me/react-controlled-components'].join('\n'));
+      if (isValueControlled !== (valueProp !== undefined)) {
+        console.error([`MUI X: A component is changing the ${isValueControlled ? '' : 'un'}controlled value of a picker to be ${isValueControlled ? 'un' : ''}controlled.`, 'Elements should not switch from uncontrolled to controlled (or vice versa).', `Decide between using a controlled or uncontrolled value` + 'for the lifetime of the component.', "The nature of the state is determined during the first render. It's considered controlled if the value is not `undefined`.", 'More info: https://fb.me/react-controlled-components'].join('\n'));
       }
-    }, [inValueWithoutRenderTimezone]);
+    }, [valueProp]);
     React.useEffect(() => {
-      if (!isControlled && defaultValue !== inDefaultValue) {
+      if (!isValueControlled && defaultValue !== defaultValueProp) {
         console.error([`MUI X: A component is changing the defaultValue of an uncontrolled picker after being initialized. ` + `To suppress this warning opt to use a controlled value.`].join('\n'));
       }
     }, [JSON.stringify(defaultValue)]);
   }
   /* eslint-enable react-hooks/rules-of-hooks, react-hooks/exhaustive-deps */
 
-  const utils = (0, _useUtils.useUtils)();
-  const adapter = (0, _useUtils.useLocalizationContext)();
-  const {
-    open,
-    setOpen
-  } = (0, _useOpenState.useOpenState)(props);
   const {
     timezone,
-    value: inValueWithTimezoneToRender,
+    value: valuePropWithTimezoneToRender,
     handleValueChange
   } = (0, _useValueWithTimezone.useValueWithTimezone)({
     timezone: timezoneProp,
-    value: inValueWithoutRenderTimezone,
+    value: valueProp,
     defaultValue,
     referenceDate,
     onChange,
     valueManager
   });
-  const [dateState, setDateState] = React.useState(() => {
+  const [state, setState] = React.useState(() => {
     let initialValue;
-    if (inValueWithTimezoneToRender !== undefined) {
-      initialValue = inValueWithTimezoneToRender;
+    if (valuePropWithTimezoneToRender !== undefined) {
+      initialValue = valuePropWithTimezoneToRender;
     } else if (defaultValue !== undefined) {
       initialValue = defaultValue;
     } else {
       initialValue = valueManager.emptyValue;
     }
     return {
+      open: false,
       draft: initialValue,
       lastPublishedValue: initialValue,
       lastCommittedValue: initialValue,
-      lastControlledValue: inValueWithoutRenderTimezone,
+      lastControlledValue: valueProp,
       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)({
     props,
     validator,
     timezone,
-    value: dateState.draft,
+    value: state.draft,
     onError: props.onError
   });
+  const timezoneFromDraftValue = valueManager.getTimezone(utils, state.draft);
+  if (previousTimezoneProp !== timezoneProp) {
+    setPreviousTimezoneProp(timezoneProp);
+    if (timezoneProp && timezoneFromDraftValue && timezoneProp !== timezoneFromDraftValue) {
+      setState(prev => (0, _extends2.default)({}, prev, {
+        draft: valueManager.setTimezone(utils, timezoneProp, prev.draft)
+      }));
+    }
+  }
+  const setOpen = (0, _useEventCallback.default)(action => {
+    const newOpen = typeof action === 'function' ? action(state.open) : action;
+    if (!isOpenControlled) {
+      setState(prevState => (0, _extends2.default)({}, prevState, {
+        open: newOpen
+      }));
+    }
+    if (newOpen && onOpen) {
+      onOpen();
+    }
+    if (!newOpen && onClose) {
+      onClose();
+    }
+  });
   const setValue = (0, _useEventCallback.default)((newValue, options) => {
     const {
       changeImportance = 'accept',
@@ -117,16 +135,16 @@ const usePickerValue = ({
     } = options ?? {};
     let shouldPublish;
     let shouldCommit;
-    if (!skipPublicationIfPristine && !isControlled && !dateState.hasBeenModifiedSinceMount) {
+    if (!skipPublicationIfPristine && !isValueControlled && !state.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);
+      shouldPublish = !valueManager.areValuesEqual(utils, newValue, state.lastPublishedValue);
+      shouldCommit = changeImportance === 'accept' && !valueManager.areValuesEqual(utils, newValue, state.lastCommittedValue);
     }
-    setDateState(prev => (0, _extends2.default)({}, prev, {
+    setState(prev => (0, _extends2.default)({}, prev, {
       draft: newValue,
       lastPublishedValue: shouldPublish ? newValue : prev.lastPublishedValue,
       lastCommittedValue: shouldCommit ? newValue : prev.lastCommittedValue,
@@ -154,41 +172,21 @@ const usePickerValue = ({
       setOpen(false);
     }
   });
-  if (dateState.lastControlledValue !== inValueWithoutRenderTimezone) {
-    const isUpdateComingFromPicker = valueManager.areValuesEqual(utils, dateState.draft, inValueWithTimezoneToRender);
-    setDateState(prev => (0, _extends2.default)({}, prev, {
-      lastControlledValue: inValueWithoutRenderTimezone
+  if (state.lastControlledValue !== valueProp) {
+    const isUpdateComingFromPicker = valueManager.areValuesEqual(utils, state.draft, valuePropWithTimezoneToRender);
+    setState(prev => (0, _extends2.default)({}, prev, {
+      lastControlledValue: valueProp
     }, isUpdateComingFromPicker ? {} : {
-      lastCommittedValue: inValueWithTimezoneToRender,
-      lastPublishedValue: inValueWithTimezoneToRender,
-      draft: inValueWithTimezoneToRender,
+      lastCommittedValue: valuePropWithTimezoneToRender,
+      lastPublishedValue: valuePropWithTimezoneToRender,
+      draft: valuePropWithTimezoneToRender,
       hasBeenModifiedSinceMount: true
     }));
   }
-  const isValid = testedValue => {
-    const error = validator({
-      adapter,
-      value: testedValue,
-      timezone,
-      props
-    });
-    return !valueManager.hasError(error);
-  };
-  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, {
+      setState(prev => (0, _extends2.default)({}, prev, {
         draft: newValue,
         hasBeenModifiedSinceMount: true
       }));
@@ -197,39 +195,24 @@ const usePickerValue = ({
       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
-  };
+
+  // It is required to update inner state in useEffect in order to avoid situation when
+  // Our component is not mounted yet, but `open` state is set to `true` (for example initially opened)
+  React.useEffect(() => {
+    if (isOpenControlled) {
+      if (openProp === undefined) {
+        throw new Error('You must not mix controlling and uncontrolled mode for `open` prop');
+      }
+      setState(prevState => (0, _extends2.default)({}, prevState, {
+        open: openProp
+      }));
+    }
+  }, [isOpenControlled, openProp]);
   return {
-    viewProps: viewResponse,
-    provider: providerParams
+    timezone,
+    state,
+    setValue,
+    setValueFromView,
+    setOpen
   };
-};
-exports.usePickerValue = usePickerValue;
+}

package/internals/hooks/usePicker/index.d.ts

@@ -1,4 +1,2 @@
 export { usePicker } from "./usePicker.js";
-export type { UsePickerProps, UsePickerBaseProps, UsePickerParams } from './usePicker.types';
-export type { PickerValueManager, PickerSelectionState, UsePickerValueFieldResponse } from './usePickerValue.types';
-export type { PickerViewsRendererProps } from './usePickerViews';
+export type { UsePickerProps, UsePickerBaseProps, UsePickerParameters, PickerSelectionState, PickerViewsRendererProps, PickerViewRendererLookup, PickerRendererInterceptorProps, PickerViewRenderer, UsePickerNonStaticProps } from './usePicker.types';

package/internals/hooks/usePicker/usePicker.d.ts

@@ -1,4 +1,4 @@
-import { UsePickerParams, UsePickerProps, UsePickerReturnValue } from "./usePicker.types.js";
+import { UsePickerParameters, UsePickerProps, UsePickerReturnValue } from "./usePicker.types.js";
 import { DateOrTimeViewWithMeridiem, PickerValidValue } from "../../models/index.js";
 export declare const usePicker: <TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem, TExternalProps extends UsePickerProps<TValue, TView, any, any>>({
   ref,
@@ -8,7 +8,7 @@ export declare const usePicker: <TValue extends PickerValidValue, TView extends
   variant,
   validator,
   autoFocusView,
-  viewContainerRole,
-  rendererInterceptor,
-  localeText
-}: UsePickerParams<TValue, TView, TExternalProps>) => UsePickerReturnValue<TValue>;
+  rendererInterceptor: RendererInterceptor,
+  localeText,
+  viewContainerRole
+}: UsePickerParameters<TValue, TView, TExternalProps>) => UsePickerReturnValue<TValue>;

package/internals/hooks/usePicker/usePicker.js

@@ -1,13 +1,26 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.usePicker = void 0;
-var _warning = require("@mui/x-internals/warning");
-var _usePickerValue = require("./usePickerValue");
-var _usePickerViews = require("./usePickerViews");
-var _usePickerProvider = require("./usePickerProvider");
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+var React = _interopRequireWildcard(require("react"));
+var _useEnhancedEffect = _interopRequireDefault(require("@mui/utils/useEnhancedEffect"));
+var _useEventCallback = _interopRequireDefault(require("@mui/utils/useEventCallback"));
+var _useForkRef = _interopRequireDefault(require("@mui/utils/useForkRef"));
+var _useId = _interopRequireDefault(require("@mui/utils/useId"));
+var _useUtils = require("../useUtils");
+var _useReduceAnimations = require("../useReduceAnimations");
+var _timeUtils = require("../../utils/time-utils");
+var _useViews = require("../useViews");
+var _useOrientation = require("./hooks/useOrientation");
+var _useValueAndOpenStates = require("./hooks/useValueAndOpenStates");
+var _jsxRuntime = require("react/jsx-runtime");
+const _excluded = ["className", "sx"];
 const usePicker = ({
   ref,
   props,
@@ -16,44 +29,275 @@ const usePicker = ({
   variant,
   validator,
   autoFocusView,
-  viewContainerRole,
-  rendererInterceptor,
-  localeText
+  rendererInterceptor: RendererInterceptor,
+  localeText,
+  viewContainerRole
 }) => {
-  if (process.env.NODE_ENV !== 'production') {
-    if (props.renderInput != null) {
-      (0, _warning.warnOnce)(['MUI X: The `renderInput` prop has been removed in version 6.0 of the Date and Time Pickers.', 'You can replace it with the `textField` component slot in most cases.', 'For more information, please have a look at the migration guide (https://mui.com/x/migration/migration-pickers-v5/#input-renderer-required-in-v5).']);
-    }
-  }
-  const pickerValueResponse = (0, _usePickerValue.usePickerValue)({
+  const {
+    // View props
+    views,
+    view: viewProp,
+    openTo,
+    onViewChange,
+    viewRenderers,
+    reduceAnimations: reduceAnimationsProp,
+    orientation: orientationProp,
+    disableOpenPicker,
+    // Form props
+    disabled,
+    readOnly,
+    // Field props
+    formatDensity,
+    enableAccessibleFieldDOMStructure,
+    selectedSections,
+    onSelectedSectionsChange,
+    format,
+    label,
+    // Other props
+    autoFocus,
+    name
+  } = props;
+  const {
+      className,
+      sx
+    } = props,
+    propsToForwardToView = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
+
+  /**
+   * TODO: Improve how we generate the aria-label and aria-labelledby attributes.
+   */
+  const labelId = (0, _useId.default)();
+  const utils = (0, _useUtils.useUtils)();
+  const adapter = (0, _useUtils.useLocalizationContext)();
+  const reduceAnimations = (0, _useReduceAnimations.useReduceAnimations)(reduceAnimationsProp);
+  const orientation = (0, _useOrientation.useOrientation)(views, orientationProp);
+  const {
+    current: initialView
+  } = React.useRef(openTo ?? null);
+
+  /**
+   * Refs
+   */
+  const triggerRef = React.useRef(null);
+  const popupRef = React.useRef(null);
+  const fieldRef = React.useRef(null);
+  const rootRefObject = React.useRef(null);
+  const rootRef = (0, _useForkRef.default)(ref, rootRefObject);
+  const {
+    timezone,
+    state,
+    setOpen,
+    setValue,
+    setValueFromView
+  } = (0, _useValueAndOpenStates.useValueAndOpenStates)({
     props,
     valueManager,
-    valueType,
     validator
   });
-  const pickerViewsResponse = (0, _usePickerViews.usePickerViews)({
-    props,
-    autoFocusView,
-    viewContainerRole,
-    propsFromPickerValue: pickerValueResponse.viewProps,
-    rendererInterceptor
+  const {
+    view,
+    setView,
+    defaultView,
+    focusedView,
+    setFocusedView,
+    setValueAndGoToNextView
+  } = (0, _useViews.useViews)({
+    view: viewProp,
+    views,
+    openTo,
+    onChange: setValueFromView,
+    onViewChange,
+    autoFocus: autoFocusView
   });
-  const providerProps = (0, _usePickerProvider.usePickerProvider)({
-    ref,
-    props,
-    localeText,
-    valueManager,
-    variant,
-    paramsFromUsePickerValue: pickerValueResponse.provider,
-    paramsFromUsePickerViews: pickerViewsResponse.provider
+  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(state.lastPublishedValue));
+  const cancelValueChanges = (0, _useEventCallback.default)(() => setValue(state.lastCommittedValue, {
+    skipPublicationIfPristine: true
+  }));
+  const dismissViews = (0, _useEventCallback.default)(() => {
+    setValue(state.lastPublishedValue, {
+      skipPublicationIfPristine: true
+    });
   });
+  const valueWithoutError = React.useMemo(() => valueManager.cleanValue(utils, state.draft), [utils, valueManager, state.draft]);
+  const {
+    hasUIView,
+    viewModeLookup,
+    timeViewsCount
+  } = React.useMemo(() => views.reduce((acc, viewForReduce) => {
+    const viewMode = viewRenderers[viewForReduce] == null ? 'field' : 'UI';
+    acc.viewModeLookup[viewForReduce] = viewMode;
+    if (viewMode === 'UI') {
+      acc.hasUIView = true;
+      if ((0, _timeUtils.isTimeView)(viewForReduce)) {
+        acc.timeViewsCount += 1;
+      }
+    }
+    return acc;
+  }, {
+    hasUIView: false,
+    viewModeLookup: {},
+    timeViewsCount: 0
+  }), [viewRenderers, views]);
+  const currentViewMode = viewModeLookup[view];
+  const getCurrentViewMode = (0, _useEventCallback.default)(() => currentViewMode);
+  const [popperView, setPopperView] = React.useState(currentViewMode === 'UI' ? view : null);
+  if (popperView !== view && viewModeLookup[view] === 'UI') {
+    setPopperView(view);
+  }
+  (0, _useEnhancedEffect.default)(() => {
+    // Handle case of Date Time Picker without time renderers
+    if (currentViewMode === 'field' && state.open) {
+      setOpen(false);
+      setTimeout(() => {
+        fieldRef?.current?.setSelectedSections(view);
+        // focusing the input before the range selection is done
+        // calling it outside of timeout results in an inconsistent behavior between Safari And Chrome
+        fieldRef?.current?.focusField(view);
+      });
+    }
+  }, [view]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  (0, _useEnhancedEffect.default)(() => {
+    if (!state.open) {
+      return;
+    }
+    let newView = view;
+
+    // If the current view is a field view, go to the last popper view
+    if (currentViewMode === 'field' && popperView != null) {
+      newView = popperView;
+    }
+
+    // If the current view is not the default view and both are UI views
+    if (newView !== defaultView && viewModeLookup[newView] === 'UI' && viewModeLookup[defaultView] === 'UI') {
+      newView = defaultView;
+    }
+    if (newView !== view) {
+      setView(newView);
+    }
+    setFocusedView(newView, true);
+  }, [state.open]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  const ownerState = React.useMemo(() => ({
+    isPickerValueEmpty: valueManager.areValuesEqual(utils, state.draft, valueManager.emptyValue),
+    isPickerOpen: state.open,
+    isPickerDisabled: props.disabled ?? false,
+    isPickerReadOnly: props.readOnly ?? false,
+    pickerOrientation: orientation,
+    pickerVariant: variant
+  }), [utils, valueManager, state.draft, state.open, orientation, variant, props.disabled, props.readOnly]);
+  const triggerStatus = React.useMemo(() => {
+    if (disableOpenPicker || !hasUIView) {
+      return 'hidden';
+    }
+    if (disabled || readOnly) {
+      return 'disabled';
+    }
+    return 'enabled';
+  }, [disableOpenPicker, hasUIView, disabled, readOnly]);
+  const actionsContextValue = React.useMemo(() => ({
+    setValue,
+    setOpen,
+    clearValue,
+    setValueToToday,
+    acceptValueChanges,
+    cancelValueChanges,
+    setView
+  }), [setValue, setOpen, clearValue, setValueToToday, acceptValueChanges, cancelValueChanges, setView]);
+  const contextValue = React.useMemo(() => (0, _extends2.default)({}, actionsContextValue, {
+    value: state.draft,
+    timezone,
+    open: state.open,
+    views,
+    view: popperView,
+    initialView,
+    disabled: disabled ?? false,
+    readOnly: readOnly ?? false,
+    autoFocus: autoFocus ?? false,
+    variant,
+    orientation,
+    popupRef,
+    reduceAnimations,
+    triggerRef,
+    triggerStatus,
+    fieldFormat: format ?? '',
+    name,
+    label,
+    rootSx: sx,
+    rootRef,
+    rootClassName: className
+  }), [actionsContextValue, state.draft, rootRef, variant, orientation, reduceAnimations, disabled, readOnly, format, className, name, label, sx, triggerRef, triggerStatus, timezone, state.open, popperView, views, initialView, autoFocus]);
+  const privateContextValue = React.useMemo(() => ({
+    dismissViews,
+    hasUIView,
+    getCurrentViewMode,
+    ownerState,
+    rootRefObject,
+    labelId,
+    viewContainerRole
+  }), [dismissViews, hasUIView, getCurrentViewMode, ownerState, rootRefObject, labelId, viewContainerRole]);
+  const fieldPrivateContextValue = React.useMemo(() => ({
+    formatDensity,
+    enableAccessibleFieldDOMStructure,
+    selectedSections,
+    onSelectedSectionsChange,
+    fieldRef
+  }), [formatDensity, enableAccessibleFieldDOMStructure, selectedSections, onSelectedSectionsChange, fieldRef]);
+  const isValidContextValue = testedValue => {
+    const error = validator({
+      adapter,
+      value: testedValue,
+      timezone,
+      props
+    });
+    return !valueManager.hasError(error);
+  };
+  const renderCurrentView = () => {
+    if (popperView == null) {
+      return null;
+    }
+    const renderer = viewRenderers[popperView];
+    if (renderer == null) {
+      return null;
+    }
+    const rendererProps = (0, _extends2.default)({}, propsToForwardToView, {
+      views,
+      timezone,
+      value: valueWithoutError,
+      onChange: setValueAndGoToNextView,
+      view: popperView,
+      onViewChange: setView,
+      showViewSwitcher: timeViewsCount > 1,
+      timeViewsCount
+    }, viewContainerRole === 'tooltip' ? {
+      focusedView: null,
+      onFocusedViewChange: () => {}
+    } : {
+      focusedView,
+      onFocusedViewChange: setFocusedView
+    });
+    if (RendererInterceptor) {
+      return /*#__PURE__*/(0, _jsxRuntime.jsx)(RendererInterceptor, {
+        viewRenderers: viewRenderers,
+        popperView: popperView,
+        rendererProps: rendererProps
+      });
+    }
+    return renderer(rendererProps);
+  };
   return {
-    // Picker views
-    renderCurrentView: pickerViewsResponse.renderCurrentView,
-    // Picker provider
-    providerProps,
-    // Picker owner state
-    ownerState: providerProps.privateContextValue.ownerState
+    providerProps: {
+      localeText,
+      contextValue,
+      privateContextValue,
+      actionsContextValue,
+      fieldPrivateContextValue,
+      isValidContextValue
+    },
+    renderCurrentView,
+    ownerState
   };
 };
 exports.usePicker = usePicker;