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

package/node/hooks/usePickerContext.js

@@ -5,16 +5,17 @@ var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWild
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.usePickerContext = void 0;
+exports.usePickerContext = exports.PickerContext = void 0;
 var React = _interopRequireWildcard(require("react"));
-var _PickerProvider = require("../internals/components/PickerProvider");
+const PickerContext = exports.PickerContext = /*#__PURE__*/React.createContext(null);
+
 /**
  * Returns the context passed by the picker that wraps the current component.
  */
 const usePickerContext = () => {
-  const value = React.useContext(_PickerProvider.PickerContext);
+  const value = React.useContext(PickerContext);
   if (value == null) {
-    throw new Error(['MUI X: The `usePickerContext` can only be called in fields that are used as a slot of a picker component'].join('\n'));
+    throw new Error('MUI X: The `usePickerContext` hook can only be called inside the context of a picker component');
   }
   return value;
 };

package/node/hooks/useSplitFieldProps.js

@@ -10,13 +10,13 @@ exports.useSplitFieldProps = void 0;
 var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
 var React = _interopRequireWildcard(require("react"));
 var _extractValidationProps = require("../validation/extractValidationProps");
-const SHARED_FIELD_INTERNAL_PROP_NAMES = ['value', 'defaultValue', 'referenceDate', 'format', 'formatDensity', 'onChange', 'timezone', 'onError', 'shouldRespectLeadingZeros', 'selectedSections', 'onSelectedSectionsChange', 'unstableFieldRef', 'enableAccessibleFieldDOMStructure', 'disabled', 'readOnly', 'dateSeparator'];
+const SHARED_FIELD_INTERNAL_PROP_NAMES = ['value', 'defaultValue', 'referenceDate', 'format', 'formatDensity', 'onChange', 'timezone', 'onError', 'shouldRespectLeadingZeros', 'selectedSections', 'onSelectedSectionsChange', 'unstableFieldRef', 'unstableStartFieldRef', 'unstableEndFieldRef', 'enableAccessibleFieldDOMStructure', 'disabled', 'readOnly', 'dateSeparator', 'autoFocus'];
 /**
  * Split the props received by the field component into:
  * - `internalProps` which are used by the various hooks called by the field component.
  * - `forwardedProps` which are passed to the underlying component.
  * Note that some forwarded props might be used by the hooks as well.
- * For instance, hooks like `useDateField` need props like `autoFocus` to know how to behave.
+ * For instance, hooks like `useDateField` need props like `onKeyDown` to merge the default event handler and the one provided by the application.
  * @template TProps, TValueType
  * @param {TProps} props The props received by the field component.
  * @param {TValueType} valueType The type of the field value ('date', 'time', or 'date-time').
@@ -48,4 +48,9 @@ const useSplitFieldProps = (props, valueType) => {
     };
   }, [props, valueType]);
 };
+
+/**
+ * Extract the internal props from the props received by the field component.
+ * This makes sure that the internal props not defined in the props are not present in the result.
+ */
 exports.useSplitFieldProps = useSplitFieldProps;

package/node/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-date-pickers v8.0.0-alpha.0
+ * @mui/x-date-pickers v8.0.0-alpha.10
  *
  * @license MIT
  * This source code is licensed under the MIT license found in the
@@ -463,4 +463,16 @@ Object.keys(_validation).forEach(function (key) {
       return _validation[key];
     }
   });
+});
+var _managers = require("./managers");
+Object.keys(_managers).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _managers[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _managers[key];
+    }
+  });
 });

package/node/internals/components/PickerFieldUI.js

@@ -0,0 +1,329 @@
+"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.PickerFieldUI = PickerFieldUI;
+exports.PickerFieldUIContextProvider = PickerFieldUIContextProvider;
+exports.cleanFieldResponse = void 0;
+exports.useFieldTextFieldProps = useFieldTextFieldProps;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+var React = _interopRequireWildcard(require("react"));
+var _useEventCallback = _interopRequireDefault(require("@mui/utils/useEventCallback"));
+var _useForkRef = _interopRequireDefault(require("@mui/utils/useForkRef"));
+var _resolveComponentProps = _interopRequireDefault(require("@mui/utils/resolveComponentProps"));
+var _TextField = _interopRequireDefault(require("@mui/material/TextField"));
+var _IconButton = _interopRequireDefault(require("@mui/material/IconButton"));
+var _InputAdornment = _interopRequireDefault(require("@mui/material/InputAdornment"));
+var _useSlotProps5 = _interopRequireDefault(require("@mui/utils/useSlotProps"));
+var _useFieldOwnerState = require("../hooks/useFieldOwnerState");
+var _hooks = require("../../hooks");
+var _icons = require("../../icons");
+var _useNullablePickerContext = require("../hooks/useNullablePickerContext");
+var _PickersTextField = require("../../PickersTextField");
+var _jsxRuntime = require("react/jsx-runtime");
+const _excluded = ["enableAccessibleFieldDOMStructure"],
+  _excluded2 = ["InputProps", "readOnly", "onClear", "clearable", "clearButtonPosition", "openPickerButtonPosition", "openPickerAriaLabel"],
+  _excluded3 = ["onPaste", "onKeyDown", "inputMode", "readOnly", "InputProps", "inputProps", "inputRef", "onClear", "clearable", "clearButtonPosition", "openPickerButtonPosition", "openPickerAriaLabel"],
+  _excluded4 = ["ownerState"],
+  _excluded5 = ["ownerState"],
+  _excluded6 = ["ownerState"],
+  _excluded7 = ["ownerState"],
+  _excluded8 = ["InputProps", "inputProps"];
+const cleanFieldResponse = _ref => {
+  let {
+      enableAccessibleFieldDOMStructure
+    } = _ref,
+    fieldResponse = (0, _objectWithoutPropertiesLoose2.default)(_ref, _excluded);
+  if (enableAccessibleFieldDOMStructure) {
+    const {
+        InputProps,
+        readOnly,
+        onClear,
+        clearable,
+        clearButtonPosition,
+        openPickerButtonPosition,
+        openPickerAriaLabel
+      } = fieldResponse,
+      other = (0, _objectWithoutPropertiesLoose2.default)(fieldResponse, _excluded2);
+    return {
+      clearable,
+      onClear,
+      clearButtonPosition,
+      openPickerButtonPosition,
+      openPickerAriaLabel,
+      textFieldProps: (0, _extends2.default)({}, other, {
+        InputProps: (0, _extends2.default)({}, InputProps ?? {}, {
+          readOnly
+        })
+      })
+    };
+  }
+  const {
+      onPaste,
+      onKeyDown,
+      inputMode,
+      readOnly,
+      InputProps,
+      inputProps,
+      inputRef,
+      onClear,
+      clearable,
+      clearButtonPosition,
+      openPickerButtonPosition,
+      openPickerAriaLabel
+    } = fieldResponse,
+    other = (0, _objectWithoutPropertiesLoose2.default)(fieldResponse, _excluded3);
+  return {
+    clearable,
+    onClear,
+    clearButtonPosition,
+    openPickerButtonPosition,
+    openPickerAriaLabel,
+    textFieldProps: (0, _extends2.default)({}, other, {
+      InputProps: (0, _extends2.default)({}, InputProps ?? {}, {
+        readOnly
+      }),
+      inputProps: (0, _extends2.default)({}, inputProps ?? {}, {
+        inputMode,
+        onPaste,
+        onKeyDown,
+        ref: inputRef
+      })
+    })
+  };
+};
+exports.cleanFieldResponse = cleanFieldResponse;
+const PickerFieldUIContext = /*#__PURE__*/React.createContext({
+  slots: {},
+  slotProps: {},
+  inputRef: undefined
+});
+
+/**
+ * Adds the button to open the picker and the button to clear the value of the field.
+ * @ignore - internal component.
+ */
+function PickerFieldUI(props) {
+  const {
+    slots,
+    slotProps,
+    fieldResponse,
+    defaultOpenPickerIcon
+  } = props;
+  const translations = (0, _hooks.usePickerTranslations)();
+  const pickerContext = (0, _useNullablePickerContext.useNullablePickerContext)();
+  const pickerFieldUIContext = React.useContext(PickerFieldUIContext);
+  const {
+    textFieldProps,
+    onClear,
+    clearable,
+    openPickerAriaLabel,
+    clearButtonPosition: clearButtonPositionProp = 'end',
+    openPickerButtonPosition: openPickerButtonPositionProp = 'end'
+  } = cleanFieldResponse(fieldResponse);
+  const ownerState = (0, _useFieldOwnerState.useFieldOwnerState)(textFieldProps);
+  const handleClickOpeningButton = (0, _useEventCallback.default)(event => {
+    event.preventDefault();
+    pickerContext?.setOpen(prev => !prev);
+  });
+  const triggerStatus = pickerContext ? pickerContext.triggerStatus : 'hidden';
+  const clearButtonPosition = clearable ? clearButtonPositionProp : null;
+  const openPickerButtonPosition = triggerStatus !== 'hidden' ? openPickerButtonPositionProp : null;
+  const TextField = slots?.textField ?? pickerFieldUIContext.slots.textField ?? (fieldResponse.enableAccessibleFieldDOMStructure === false ? _TextField.default : _PickersTextField.PickersTextField);
+  const InputAdornment = slots?.inputAdornment ?? pickerFieldUIContext.slots.inputAdornment ?? _InputAdornment.default;
+  const _useSlotProps = (0, _useSlotProps5.default)({
+      elementType: InputAdornment,
+      externalSlotProps: mergeSlotProps(pickerFieldUIContext.slotProps.inputAdornment, slotProps?.inputAdornment),
+      additionalProps: {
+        position: 'start'
+      },
+      ownerState: (0, _extends2.default)({}, ownerState, {
+        position: 'start'
+      })
+    }),
+    startInputAdornmentProps = (0, _objectWithoutPropertiesLoose2.default)(_useSlotProps, _excluded4);
+  const _useSlotProps2 = (0, _useSlotProps5.default)({
+      elementType: InputAdornment,
+      externalSlotProps: slotProps?.inputAdornment,
+      additionalProps: {
+        position: 'end'
+      },
+      ownerState: (0, _extends2.default)({}, ownerState, {
+        position: 'end'
+      })
+    }),
+    endInputAdornmentProps = (0, _objectWithoutPropertiesLoose2.default)(_useSlotProps2, _excluded5);
+  const OpenPickerButton = pickerFieldUIContext.slots.openPickerButton ?? _IconButton.default;
+  // We don't want to forward the `ownerState` to the `<IconButton />` component, see mui/material-ui#34056
+  const _useSlotProps3 = (0, _useSlotProps5.default)({
+      elementType: OpenPickerButton,
+      externalSlotProps: pickerFieldUIContext.slotProps.openPickerButton,
+      additionalProps: {
+        disabled: triggerStatus === 'disabled',
+        onClick: handleClickOpeningButton,
+        'aria-label': openPickerAriaLabel,
+        edge: clearButtonPosition === 'start' && openPickerButtonPosition === 'start' ? undefined : openPickerButtonPosition
+      },
+      ownerState
+    }),
+    openPickerButtonProps = (0, _objectWithoutPropertiesLoose2.default)(_useSlotProps3, _excluded6);
+  const OpenPickerIcon = pickerFieldUIContext.slots.openPickerIcon ?? defaultOpenPickerIcon;
+  const openPickerIconProps = (0, _useSlotProps5.default)({
+    elementType: OpenPickerIcon,
+    externalSlotProps: pickerFieldUIContext.slotProps.openPickerIcon,
+    ownerState
+  });
+  const ClearButton = slots?.clearButton ?? pickerFieldUIContext.slots.clearButton ?? _IconButton.default;
+  // We don't want to forward the `ownerState` to the `<IconButton />` component, see mui/material-ui#34056
+  const _useSlotProps4 = (0, _useSlotProps5.default)({
+      elementType: ClearButton,
+      externalSlotProps: mergeSlotProps(pickerFieldUIContext.slotProps.clearButton, slotProps?.clearButton),
+      className: 'clearButton',
+      additionalProps: {
+        title: translations.fieldClearLabel,
+        tabIndex: -1,
+        onClick: onClear,
+        disabled: fieldResponse.disabled || fieldResponse.readOnly,
+        edge: clearButtonPosition === 'end' && openPickerButtonPosition === 'end' ? undefined : clearButtonPosition
+      },
+      ownerState
+    }),
+    clearButtonProps = (0, _objectWithoutPropertiesLoose2.default)(_useSlotProps4, _excluded7);
+  const ClearIcon = slots?.clearIcon ?? pickerFieldUIContext.slots.clearIcon ?? _icons.ClearIcon;
+  const clearIconProps = (0, _useSlotProps5.default)({
+    elementType: ClearIcon,
+    externalSlotProps: mergeSlotProps(pickerFieldUIContext.slotProps.clearIcon, slotProps?.clearIcon),
+    additionalProps: {
+      fontSize: 'small'
+    },
+    ownerState
+  });
+  textFieldProps.ref = (0, _useForkRef.default)(textFieldProps.ref, pickerContext?.rootRef);
+  if (!textFieldProps.InputProps) {
+    textFieldProps.InputProps = {};
+  }
+  if (pickerContext) {
+    textFieldProps.InputProps.ref = pickerContext.triggerRef;
+  }
+  if (!textFieldProps.InputProps?.startAdornment && (clearButtonPosition === 'start' || openPickerButtonPosition === 'start')) {
+    textFieldProps.InputProps.startAdornment = /*#__PURE__*/(0, _jsxRuntime.jsxs)(InputAdornment, (0, _extends2.default)({}, startInputAdornmentProps, {
+      children: [openPickerButtonPosition === 'start' && /*#__PURE__*/(0, _jsxRuntime.jsx)(OpenPickerButton, (0, _extends2.default)({}, openPickerButtonProps, {
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(OpenPickerIcon, (0, _extends2.default)({}, openPickerIconProps))
+      })), clearButtonPosition === 'start' && /*#__PURE__*/(0, _jsxRuntime.jsx)(ClearButton, (0, _extends2.default)({}, clearButtonProps, {
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(ClearIcon, (0, _extends2.default)({}, clearIconProps))
+      }))]
+    }));
+  }
+  if (!textFieldProps.InputProps?.endAdornment && (clearButtonPosition === 'end' || openPickerButtonPosition === 'end')) {
+    textFieldProps.InputProps.endAdornment = /*#__PURE__*/(0, _jsxRuntime.jsxs)(InputAdornment, (0, _extends2.default)({}, endInputAdornmentProps, {
+      children: [clearButtonPosition === 'end' && /*#__PURE__*/(0, _jsxRuntime.jsx)(ClearButton, (0, _extends2.default)({}, clearButtonProps, {
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(ClearIcon, (0, _extends2.default)({}, clearIconProps))
+      })), openPickerButtonPosition === 'end' && /*#__PURE__*/(0, _jsxRuntime.jsx)(OpenPickerButton, (0, _extends2.default)({}, openPickerButtonProps, {
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(OpenPickerIcon, (0, _extends2.default)({}, openPickerIconProps))
+      }))]
+    }));
+  }
+  if (clearButtonPosition != null) {
+    textFieldProps.sx = [{
+      '& .clearButton': {
+        opacity: 1
+      },
+      '@media (pointer: fine)': {
+        '& .clearButton': {
+          opacity: 0
+        },
+        '&:hover, &:focus-within': {
+          '.clearButton': {
+            opacity: 1
+          }
+        }
+      }
+    }, ...(Array.isArray(textFieldProps.sx) ? textFieldProps.sx : [textFieldProps.sx])];
+  }
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(TextField, (0, _extends2.default)({}, textFieldProps));
+}
+function mergeSlotProps(slotPropsA, slotPropsB) {
+  if (!slotPropsA) {
+    return slotPropsB;
+  }
+  if (!slotPropsB) {
+    return slotPropsA;
+  }
+  return ownerState => {
+    return (0, _extends2.default)({}, (0, _resolveComponentProps.default)(slotPropsB, ownerState), (0, _resolveComponentProps.default)(slotPropsA, ownerState));
+  };
+}
+
+/**
+ * The `textField` slot props cannot be handled inside `PickerFieldUI` because it would be a breaking change to not pass the enriched props to `useField`.
+ * Once the non-accessible DOM structure will be removed, we will be able to remove the `textField` slot and clean this logic.
+ */
+function useFieldTextFieldProps(parameters) {
+  const {
+    ref,
+    externalForwardedProps,
+    slotProps
+  } = parameters;
+  const pickerFieldUIContext = React.useContext(PickerFieldUIContext);
+  const pickerContext = (0, _useNullablePickerContext.useNullablePickerContext)();
+  const ownerState = (0, _useFieldOwnerState.useFieldOwnerState)(externalForwardedProps);
+  const {
+      InputProps,
+      inputProps
+    } = externalForwardedProps,
+    otherExternalForwardedProps = (0, _objectWithoutPropertiesLoose2.default)(externalForwardedProps, _excluded8);
+  const textFieldProps = (0, _useSlotProps5.default)({
+    elementType: _PickersTextField.PickersTextField,
+    externalSlotProps: mergeSlotProps(pickerFieldUIContext.slotProps.textField, slotProps?.textField),
+    externalForwardedProps: otherExternalForwardedProps,
+    additionalProps: {
+      ref,
+      sx: pickerContext?.rootSx,
+      label: pickerContext?.label,
+      name: pickerContext?.name,
+      className: pickerContext?.rootClassName,
+      inputRef: pickerFieldUIContext.inputRef
+    },
+    ownerState
+  });
+
+  // TODO: Remove when mui/material-ui#35088 will be merged
+  textFieldProps.inputProps = (0, _extends2.default)({}, inputProps, textFieldProps.inputProps);
+  textFieldProps.InputProps = (0, _extends2.default)({}, InputProps, textFieldProps.InputProps);
+  return textFieldProps;
+}
+function PickerFieldUIContextProvider(props) {
+  const {
+    slots = {},
+    slotProps = {},
+    inputRef,
+    children
+  } = props;
+  const contextValue = React.useMemo(() => ({
+    inputRef,
+    slots: {
+      openPickerButton: slots.openPickerButton,
+      openPickerIcon: slots.openPickerIcon,
+      textField: slots.textField,
+      inputAdornment: slots.inputAdornment,
+      clearIcon: slots.clearIcon,
+      clearButton: slots.clearButton
+    },
+    slotProps: {
+      openPickerButton: slotProps.openPickerButton,
+      openPickerIcon: slotProps.openPickerIcon,
+      textField: slotProps.textField,
+      inputAdornment: slotProps.inputAdornment,
+      clearIcon: slotProps.clearIcon,
+      clearButton: slotProps.clearButton
+    }
+  }), [inputRef, slots.openPickerButton, slots.openPickerIcon, slots.textField, slots.inputAdornment, slots.clearIcon, slots.clearButton, slotProps.openPickerButton, slotProps.openPickerIcon, slotProps.textField, slotProps.inputAdornment, slotProps.clearIcon, slotProps.clearButton]);
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(PickerFieldUIContext.Provider, {
+    value: contextValue,
+    children: children
+  });
+}

package/node/internals/components/{PickersPopper.js → PickerPopper/PickerPopper.js}

@@ -5,7 +5,7 @@ var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWild
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.PickersPopper = PickersPopper;
+exports.PickerPopper = PickerPopper;
 var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
 var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
 var React = _interopRequireWildcard(require("react"));
@@ -17,23 +17,21 @@ var _Popper = _interopRequireDefault(require("@mui/material/Popper"));
 var _Unstable_TrapFocus = _interopRequireDefault(require("@mui/material/Unstable_TrapFocus"));
 var _utils = require("@mui/utils");
 var _styles = require("@mui/material/styles");
-var _pickersPopperClasses = require("./pickersPopperClasses");
-var _utils2 = require("../utils/utils");
-var _useDefaultReduceAnimations = require("../hooks/useDefaultReduceAnimations");
+var _pickerPopperClasses = require("./pickerPopperClasses");
+var _utils2 = require("../../utils/utils");
+var _usePickerPrivateContext = require("../../hooks/usePickerPrivateContext");
+var _hooks = require("../../../hooks");
 var _jsxRuntime = require("react/jsx-runtime");
-const _excluded = ["PaperComponent", "popperPlacement", "ownerState", "children", "paperSlotProps", "paperClasses", "onPaperClick", "onPaperTouchStart"];
-const useUtilityClasses = ownerState => {
-  const {
-    classes
-  } = ownerState;
+const _excluded = ["PaperComponent", "ownerState", "children", "paperSlotProps", "paperClasses", "onPaperClick", "onPaperTouchStart"];
+const useUtilityClasses = classes => {
   const slots = {
     root: ['root'],
     paper: ['paper']
   };
-  return (0, _utils.unstable_composeClasses)(slots, _pickersPopperClasses.getPickersPopperUtilityClass, classes);
+  return (0, _utils.unstable_composeClasses)(slots, _pickerPopperClasses.getPickerPopperUtilityClass, classes);
 };
-const PickersPopperRoot = (0, _styles.styled)(_Popper.default, {
-  name: 'MuiPickersPopper',
+const PickerPopperRoot = (0, _styles.styled)(_Popper.default, {
+  name: 'MuiPickerPopper',
   slot: 'Root',
   overridesResolver: (_, styles) => styles.root
 })(({
@@ -41,8 +39,8 @@ const PickersPopperRoot = (0, _styles.styled)(_Popper.default, {
 }) => ({
   zIndex: theme.zIndex.modal
 }));
-const PickersPopperPaper = (0, _styles.styled)(_Paper.default, {
-  name: 'MuiPickersPopper',
+const PickerPopperPaper = (0, _styles.styled)(_Paper.default, {
+  name: 'MuiPickerPopper',
   slot: 'Paper',
   overridesResolver: (_, styles) => styles.paper
 })({
@@ -50,8 +48,8 @@ const PickersPopperPaper = (0, _styles.styled)(_Paper.default, {
   transformOrigin: 'top center',
   variants: [{
     props: ({
-      placement
-    }) => ['top', 'top-start', 'top-end'].includes(placement),
+      popperPlacement
+    }) => ['top', 'top-start', 'top-end'].includes(popperPlacement),
     style: {
       transformOrigin: 'bottom center'
     }
@@ -172,11 +170,10 @@ function useClickAwayListener(active, onClickAway) {
   }, [active, handleClickAway]);
   return [nodeRef, handleSynthetic, handleSynthetic];
 }
-const PickersPopperPaperWrapper = /*#__PURE__*/React.forwardRef((props, ref) => {
+const PickerPopperPaperWrapper = /*#__PURE__*/React.forwardRef((props, ref) => {
   const {
       PaperComponent,
-      popperPlacement,
-      ownerState: inOwnerState,
+      ownerState,
       children,
       paperSlotProps,
       paperClasses,
@@ -186,9 +183,6 @@ const PickersPopperPaperWrapper = /*#__PURE__*/React.forwardRef((props, ref) =>
       // https://mui.com/material-ui/transitions/#child-requirement
     } = props,
     other = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
-  const ownerState = (0, _extends2.default)({}, inOwnerState, {
-    placement: popperPlacement
-  });
   const paperProps = (0, _useSlotProps.default)({
     elementType: PaperComponent,
     externalSlotProps: paperSlotProps,
@@ -213,39 +207,44 @@ const PickersPopperPaperWrapper = /*#__PURE__*/React.forwardRef((props, ref) =>
     children: children
   }));
 });
-function PickersPopper(inProps) {
+function PickerPopper(inProps) {
   const props = (0, _styles.useThemeProps)({
     props: inProps,
-    name: 'MuiPickersPopper'
+    name: 'MuiPickerPopper'
   });
   const {
-    anchorEl,
     children,
     containerRef = null,
-    shouldRestoreFocus,
     onBlur,
-    onDismiss,
-    open,
     role,
-    placement,
+    placement = 'bottom-start',
     slots,
     slotProps,
-    reduceAnimations: inReduceAnimations
+    classes: classesProp
   } = props;
+  const {
+    open,
+    triggerRef,
+    reduceAnimations
+  } = (0, _hooks.usePickerContext)();
+  const {
+    dismissViews,
+    doesTheCurrentViewHasAnUI
+  } = (0, _usePickerPrivateContext.usePickerPrivateContext)();
   React.useEffect(() => {
     function handleKeyDown(nativeEvent) {
       if (open && nativeEvent.key === 'Escape') {
-        onDismiss();
+        dismissViews();
       }
     }
     document.addEventListener('keydown', handleKeyDown);
     return () => {
       document.removeEventListener('keydown', handleKeyDown);
     };
-  }, [onDismiss, open]);
+  }, [dismissViews, open]);
   const lastFocusedElementRef = React.useRef(null);
   React.useEffect(() => {
-    if (role === 'tooltip' || shouldRestoreFocus && !shouldRestoreFocus()) {
+    if (role === 'tooltip' || !doesTheCurrentViewHasAnUI()) {
       return;
     }
     if (open) {
@@ -259,26 +258,29 @@ function PickersPopper(inProps) {
         }
       });
     }
-  }, [open, role, shouldRestoreFocus]);
-  const [clickAwayRef, onPaperClick, onPaperTouchStart] = useClickAwayListener(open, onBlur ?? onDismiss);
+  }, [open, role, doesTheCurrentViewHasAnUI]);
+  const [clickAwayRef, onPaperClick, onPaperTouchStart] = useClickAwayListener(open, onBlur ?? dismissViews);
   const paperRef = React.useRef(null);
   const handleRef = (0, _utils.unstable_useForkRef)(paperRef, containerRef);
   const handlePaperRef = (0, _utils.unstable_useForkRef)(handleRef, clickAwayRef);
-  const ownerState = props;
-  const classes = useUtilityClasses(ownerState);
-  const defaultReduceAnimations = (0, _useDefaultReduceAnimations.useDefaultReduceAnimations)();
-  const reduceAnimations = inReduceAnimations ?? defaultReduceAnimations;
+  const classes = useUtilityClasses(classesProp);
+  const {
+    ownerState: pickerOwnerState
+  } = (0, _usePickerPrivateContext.usePickerPrivateContext)();
+  const ownerState = (0, _extends2.default)({}, pickerOwnerState, {
+    popperPlacement: placement
+  });
   const handleKeyDown = event => {
     if (event.key === 'Escape') {
       // stop the propagation to avoid closing parent modal
       event.stopPropagation();
-      onDismiss();
+      dismissViews();
     }
   };
   const Transition = slots?.desktopTransition ?? reduceAnimations ? _Fade.default : _Grow.default;
   const FocusTrap = slots?.desktopTrapFocus ?? _Unstable_TrapFocus.default;
-  const Paper = slots?.desktopPaper ?? PickersPopperPaper;
-  const Popper = slots?.popper ?? PickersPopperRoot;
+  const Paper = slots?.desktopPaper ?? PickerPopperPaper;
+  const Popper = slots?.popper ?? PickerPopperRoot;
   const popperProps = (0, _useSlotProps.default)({
     elementType: Popper,
     externalSlotProps: slotProps?.popper,
@@ -286,17 +288,16 @@ function PickersPopper(inProps) {
       transition: true,
       role,
       open,
-      anchorEl,
       placement,
+      anchorEl: triggerRef.current,
       onKeyDown: handleKeyDown
     },
     className: classes.root,
-    ownerState: props
+    ownerState
   });
   return /*#__PURE__*/(0, _jsxRuntime.jsx)(Popper, (0, _extends2.default)({}, popperProps, {
     children: ({
-      TransitionProps,
-      placement: popperPlacement
+      TransitionProps
     }) => /*#__PURE__*/(0, _jsxRuntime.jsx)(FocusTrap, (0, _extends2.default)({
       open: open,
       disableAutoFocus: true
@@ -309,10 +310,9 @@ function PickersPopper(inProps) {
       isEnabled: () => true
     }, slotProps?.desktopTrapFocus, {
       children: /*#__PURE__*/(0, _jsxRuntime.jsx)(Transition, (0, _extends2.default)({}, TransitionProps, slotProps?.desktopTransition, {
-        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(PickersPopperPaperWrapper, {
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(PickerPopperPaperWrapper, {
           PaperComponent: Paper,
           ownerState: ownerState,
-          popperPlacement: popperPlacement,
           ref: handlePaperRef,
           onPaperClick: onPaperClick,
           onPaperTouchStart: onPaperTouchStart,

package/node/internals/components/PickerPopper/index.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "PickerPopper", {
+  enumerable: true,
+  get: function () {
+    return _PickerPopper.PickerPopper;
+  }
+});
+Object.defineProperty(exports, "getPickerPopperUtilityClass", {
+  enumerable: true,
+  get: function () {
+    return _pickerPopperClasses.getPickerPopperUtilityClass;
+  }
+});
+Object.defineProperty(exports, "pickerPopperClasses", {
+  enumerable: true,
+  get: function () {
+    return _pickerPopperClasses.pickerPopperClasses;
+  }
+});
+var _PickerPopper = require("./PickerPopper");
+var _pickerPopperClasses = require("./pickerPopperClasses");

package/node/internals/components/PickerPopper/pickerPopperClasses.js

@@ -0,0 +1,14 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPickerPopperUtilityClass = getPickerPopperUtilityClass;
+exports.pickerPopperClasses = void 0;
+var _generateUtilityClass = _interopRequireDefault(require("@mui/utils/generateUtilityClass"));
+var _generateUtilityClasses = _interopRequireDefault(require("@mui/utils/generateUtilityClasses"));
+function getPickerPopperUtilityClass(slot) {
+  return (0, _generateUtilityClass.default)('MuiPickerPopper', slot);
+}
+const pickerPopperClasses = exports.pickerPopperClasses = (0, _generateUtilityClasses.default)('MuiPickerPopper', ['root', 'paper']);