@mui/x-date-pickers 8.0.0-alpha.4 → 8.0.0-alpha.6

package/YearCalendar/YearCalendar.js

@@ -7,9 +7,10 @@ import * as React from 'react';
 import PropTypes from 'prop-types';
 import clsx from 'clsx';
 import { useRtl } from '@mui/system/RtlProvider';
+import { shouldForwardProp } from '@mui/system/createStyled';
 import { styled, useThemeProps } from '@mui/material/styles';
 import { unstable_useForkRef as useForkRef, unstable_composeClasses as composeClasses, unstable_useControlled as useControlled, unstable_useEventCallback as useEventCallback } from '@mui/utils';
-import { PickersYear } from "./PickersYear.js";
+import { YearCalendarButton } from "./YearCalendarButton.js";
 import { useUtils, useNow, useDefaultDates } from "../internals/hooks/useUtils.js";
 import { getYearCalendarUtilityClass } from "./yearCalendarClasses.js";
 import { applyDefaultDate } from "../internals/utils/date-utils.js";
@@ -18,7 +19,7 @@ import { SECTION_TYPE_GRANULARITY } from "../internals/utils/getDefaultReference
 import { useControlledValueWithTimezone } from "../internals/hooks/useValueWithTimezone.js";
 import { DIALOG_WIDTH, MAX_CALENDAR_HEIGHT } from "../internals/constants/dimensions.js";
 import { usePickerPrivateContext } from "../internals/hooks/usePickerPrivateContext.js";
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 const useUtilityClasses = classes => {
   const slots = {
     root: ['root']
@@ -37,6 +38,7 @@ function useYearCalendarDefaultizedProps(props, name) {
     disableFuture: false
   }, themeProps, {
     yearsPerRow: themeProps.yearsPerRow ?? 3,
+    yearsOrder: themeProps.yearsOrder ?? 'asc',
     minDate: applyDefaultDate(utils, themeProps.minDate, defaultDates.minDate),
     maxDate: applyDefaultDate(utils, themeProps.maxDate, defaultDates.maxDate)
   });
@@ -44,19 +46,43 @@ function useYearCalendarDefaultizedProps(props, name) {
 const YearCalendarRoot = styled('div', {
   name: 'MuiYearCalendar',
   slot: 'Root',
-  overridesResolver: (props, styles) => styles.root
+  shouldForwardProp: prop => shouldForwardProp(prop) && prop !== 'yearsPerRow'
 })({
   display: 'flex',
-  flexDirection: 'row',
   flexWrap: 'wrap',
+  justifyContent: 'space-evenly',
+  rowGap: 12,
+  padding: '6px 0',
   overflowY: 'auto',
   height: '100%',
-  padding: '0 4px',
   width: DIALOG_WIDTH,
   maxHeight: MAX_CALENDAR_HEIGHT,
   // avoid padding increasing width over defined
   boxSizing: 'border-box',
-  position: 'relative'
+  position: 'relative',
+  variants: [{
+    props: {
+      yearsPerRow: 3
+    },
+    style: {
+      columnGap: 24
+    }
+  }, {
+    props: {
+      yearsPerRow: 4
+    },
+    style: {
+      columnGap: 0,
+      padding: '0 2px'
+    }
+  }]
+});
+const YearCalendarButtonFiller = styled('div', {
+  name: 'MuiYearCalendar',
+  slot: 'ButtonFiller'
+})({
+  height: 36,
+  width: 72
 });
 /**
  * Demos:
@@ -87,7 +113,7 @@ export const YearCalendar = /*#__PURE__*/React.forwardRef(function YearCalendar(
       onYearFocus,
       hasFocus,
       onFocusedViewChange,
-      yearsOrder = 'asc',
+      yearsOrder,
       yearsPerRow,
       timezone: timezoneProp,
       gridLabelId,
@@ -239,18 +265,23 @@ export const YearCalendar = /*#__PURE__*/React.forwardRef(function YearCalendar(
   if (yearsOrder === 'desc') {
     yearRange.reverse();
   }
-  return /*#__PURE__*/_jsx(YearCalendarRoot, _extends({
+  let fillerAmount = yearsPerRow - yearRange.length % yearsPerRow;
+  if (fillerAmount === yearsPerRow) {
+    fillerAmount = 0;
+  }
+  return /*#__PURE__*/_jsxs(YearCalendarRoot, _extends({
     ref: handleRef,
     className: clsx(classes.root, className),
     ownerState: ownerState,
     role: "radiogroup",
-    "aria-labelledby": gridLabelId
+    "aria-labelledby": gridLabelId,
+    yearsPerRow: yearsPerRow
   }, other, {
-    children: yearRange.map(year => {
+    children: [yearRange.map(year => {
       const yearNumber = utils.getYear(year);
       const isSelected = yearNumber === selectedYear;
       const isDisabled = disabled || isYearDisabled(year);
-      return /*#__PURE__*/_jsx(PickersYear, {
+      return /*#__PURE__*/_jsx(YearCalendarButton, {
         selected: isSelected,
         value: yearNumber,
         onClick: handleYearSelection,
@@ -261,12 +292,14 @@ export const YearCalendar = /*#__PURE__*/React.forwardRef(function YearCalendar(
         onFocus: handleYearFocus,
         onBlur: handleYearBlur,
         "aria-current": todayYear === yearNumber ? 'date' : undefined,
-        yearsPerRow: yearsPerRow,
         slots: slots,
         slotProps: slotProps,
+        classes: classesProp,
         children: utils.format(year, 'year')
       }, utils.format(year, 'year'));
-    })
+    }), Array.from({
+      length: fillerAmount
+    }, (_, index) => /*#__PURE__*/_jsx(YearCalendarButtonFiller, {}, index))]
   }));
 });
 process.env.NODE_ENV !== "production" ? YearCalendar.propTypes = {

package/YearCalendar/YearCalendar.types.d.ts

@@ -6,7 +6,7 @@ import { YearCalendarClasses } from './yearCalendarClasses';
 import { BaseDateValidationProps, YearValidationProps } from '../internals/models/validation';
 import { PickerOwnerState, PickerValidDate, TimezoneProps } from '../models';
 import { FormProps } from '../internals/models/formProps';
-export interface PickerYearOwnerState extends PickerOwnerState {
+export interface YearButtonOwnerState extends PickerOwnerState {
     isYearSelected: boolean;
     isYearDisabled: boolean;
 }
@@ -20,7 +20,7 @@ export interface YearCalendarSlots {
 export interface YearCalendarSlotProps {
     yearButton?: SlotComponentPropsFromProps<React.HTMLAttributes<HTMLButtonElement> & {
         sx: SxProps;
-    }, {}, PickerYearOwnerState>;
+    }, {}, YearButtonOwnerState>;
 }
 export interface ExportedYearCalendarProps {
     /**

package/YearCalendar/YearCalendarButton.d.ts

@@ -0,0 +1,23 @@
+import * as React from 'react';
+import { YearCalendarSlotProps, YearCalendarSlots } from './YearCalendar.types';
+import { YearCalendarClasses } from './yearCalendarClasses';
+export interface YearCalendarButtonProps {
+    value: number;
+    tabIndex: number;
+    selected: boolean;
+    disabled: boolean;
+    autoFocus: boolean;
+    classes: Partial<YearCalendarClasses> | undefined;
+    slots: YearCalendarSlots | undefined;
+    slotProps: YearCalendarSlotProps | undefined;
+    'aria-current': React.AriaAttributes['aria-current'];
+    children: React.ReactNode;
+    onClick: (event: React.MouseEvent, year: number) => void;
+    onKeyDown: (event: React.KeyboardEvent, year: number) => void;
+    onFocus: (event: React.FocusEvent, year: number) => void;
+    onBlur: (event: React.FocusEvent, year: number) => void;
+}
+/**
+ * @ignore - internal component.
+ */
+export declare const YearCalendarButton: React.NamedExoticComponent<YearCalendarButtonProps>;

package/YearCalendar/{PickersYear.js → YearCalendarButton.js}

@@ -1,47 +1,27 @@
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
 import _extends from "@babel/runtime/helpers/esm/extends";
-const _excluded = ["autoFocus", "className", "classes", "children", "disabled", "selected", "value", "tabIndex", "onClick", "onKeyDown", "onFocus", "onBlur", "aria-current", "yearsPerRow", "slots", "slotProps"];
+const _excluded = ["autoFocus", "classes", "disabled", "selected", "value", "onClick", "onKeyDown", "onFocus", "onBlur", "slots", "slotProps"];
 import * as React from 'react';
-import clsx from 'clsx';
-import { styled, alpha, useThemeProps } from '@mui/material/styles';
+import { styled, alpha } from '@mui/material/styles';
 import useSlotProps from '@mui/utils/useSlotProps';
 import composeClasses from '@mui/utils/composeClasses';
 import useEnhancedEffect from '@mui/utils/useEnhancedEffect';
-import { getPickersYearUtilityClass, pickersYearClasses } from "./pickersYearClasses.js";
 import { usePickerPrivateContext } from "../internals/hooks/usePickerPrivateContext.js";
+import { getYearCalendarUtilityClass, yearCalendarClasses } from "./yearCalendarClasses.js";
 import { jsx as _jsx } from "react/jsx-runtime";
 const useUtilityClasses = (classes, ownerState) => {
   const slots = {
-    root: ['root'],
-    yearButton: ['yearButton', ownerState.isYearDisabled && 'disabled', ownerState.isYearSelected && 'selected']
+    button: ['button', ownerState.isYearDisabled && 'disabled', ownerState.isYearSelected && 'selected']
   };
-  return composeClasses(slots, getPickersYearUtilityClass, classes);
+  return composeClasses(slots, getYearCalendarUtilityClass, classes);
 };
-const PickersYearRoot = styled('div', {
-  name: 'MuiPickersYear',
-  slot: 'Root',
-  overridesResolver: (_, styles) => [styles.root]
-})({
-  display: 'flex',
-  alignItems: 'center',
-  justifyContent: 'center',
-  flexBasis: '33.3%',
-  variants: [{
-    props: {
-      yearsPerRow: 4
-    },
-    style: {
-      flexBasis: '25%'
-    }
-  }]
-});
-const YearCalendarButton = styled('button', {
-  name: 'MuiPickersYear',
-  slot: 'YearButton',
-  overridesResolver: (_, styles) => [styles.yearButton, {
-    [`&.${pickersYearClasses.disabled}`]: styles.disabled
+const DefaultYearButton = styled('button', {
+  name: 'MuiYearCalendar',
+  slot: 'Button',
+  overridesResolver: (_, styles) => [styles.button, {
+    [`&.${yearCalendarClasses.disabled}`]: styles.disabled
   }, {
-    [`&.${pickersYearClasses.selected}`]: styles.selected
+    [`&.${yearCalendarClasses.selected}`]: styles.selected
   }]
 })(({
   theme
@@ -51,7 +31,6 @@ const YearCalendarButton = styled('button', {
   border: 0,
   outline: 0
 }, theme.typography.subtitle1, {
-  margin: '6px 0',
   height: 36,
   width: 72,
   borderRadius: 18,
@@ -66,10 +45,10 @@ const YearCalendarButton = styled('button', {
     cursor: 'auto',
     pointerEvents: 'none'
   },
-  [`&.${pickersYearClasses.disabled}`]: {
+  [`&.${yearCalendarClasses.disabled}`]: {
     color: (theme.vars || theme).palette.text.secondary
   },
-  [`&.${pickersYearClasses.selected}`]: {
+  [`&.${yearCalendarClasses.selected}`]: {
     color: (theme.vars || theme).palette.primary.contrastText,
     backgroundColor: (theme.vars || theme).palette.primary.main,
     '&:focus, &:hover': {
@@ -81,28 +60,17 @@ const YearCalendarButton = styled('button', {
 /**
  * @ignore - internal component.
  */
-export const PickersYear = /*#__PURE__*/React.memo(function PickersYear(inProps) {
-  const props = useThemeProps({
-    props: inProps,
-    name: 'MuiPickersYear'
-  });
+export const YearCalendarButton = /*#__PURE__*/React.memo(function YearCalendarButton(props) {
   const {
       autoFocus,
-      className,
       classes: classesProp,
-      children,
-      disabled = false,
-      selected = false,
+      disabled,
+      selected,
       value,
-      tabIndex,
       onClick,
       onKeyDown,
       onFocus,
       onBlur,
-      'aria-current': ariaCurrent
-      // We don't want to forward this prop to the root element
-      ,
-
       slots,
       slotProps
     } = props,
@@ -124,18 +92,16 @@ export const PickersYear = /*#__PURE__*/React.memo(function PickersYear(inProps)
       ref.current?.focus();
     }
   }, [autoFocus]);
-  const YearButton = slots?.yearButton ?? YearCalendarButton;
+  const YearButton = slots?.yearButton ?? DefaultYearButton;
   const yearButtonProps = useSlotProps({
     elementType: YearButton,
     externalSlotProps: slotProps?.yearButton,
+    externalForwardedProps: other,
     additionalProps: {
-      children,
       disabled,
-      tabIndex,
       ref,
       type: 'button',
       role: 'radio',
-      'aria-current': ariaCurrent,
       'aria-checked': selected,
       onClick: event => onClick(event, value),
       onKeyDown: event => onKeyDown(event, value),
@@ -143,12 +109,7 @@ export const PickersYear = /*#__PURE__*/React.memo(function PickersYear(inProps)
       onBlur: event => onBlur(event, value)
     },
     ownerState,
-    className: classes.yearButton
+    className: classes.button
   });
-  return /*#__PURE__*/_jsx(PickersYearRoot, _extends({
-    className: clsx(classes.root, className),
-    ownerState: ownerState
-  }, other, {
-    children: /*#__PURE__*/_jsx(YearButton, _extends({}, yearButtonProps))
-  }));
+  return /*#__PURE__*/_jsx(YearButton, _extends({}, yearButtonProps));
 });

package/YearCalendar/index.d.ts

@@ -2,6 +2,3 @@ export { YearCalendar } from './YearCalendar';
 export type { YearCalendarProps, YearCalendarSlots, YearCalendarSlotProps, } from './YearCalendar.types';
 export { yearCalendarClasses, getYearCalendarUtilityClass } from './yearCalendarClasses';
 export type { YearCalendarClasses, YearCalendarClassKey } from './yearCalendarClasses';
-export { pickersYearClasses } from './pickersYearClasses';
-export type { PickersYearClasses, PickersYearClassKey } from './pickersYearClasses';
-export type { ExportedPickersYearProps } from './PickersYear';

package/YearCalendar/index.js

@@ -1,3 +1,2 @@
 export { YearCalendar } from "./YearCalendar.js";
-export { yearCalendarClasses, getYearCalendarUtilityClass } from "./yearCalendarClasses.js";
-export { pickersYearClasses } from "./pickersYearClasses.js";
+export { yearCalendarClasses, getYearCalendarUtilityClass } from "./yearCalendarClasses.js";

package/YearCalendar/yearCalendarClasses.d.ts

@@ -1,7 +1,13 @@
 export interface YearCalendarClasses {
     /** Styles applied to the root element. */
     root: string;
+    /** Styles applied to the button element that represents a single year */
+    button: string;
+    /** Styles applied to a disabled button element. */
+    disabled: string;
+    /** Styles applied to a selected button element. */
+    selected: string;
 }
 export type YearCalendarClassKey = keyof YearCalendarClasses;
 export declare function getYearCalendarUtilityClass(slot: string): string;
-export declare const yearCalendarClasses: Record<"root", string>;
+export declare const yearCalendarClasses: Record<"button" | "disabled" | "selected" | "root", string>;

package/YearCalendar/yearCalendarClasses.js

@@ -2,4 +2,4 @@ import { unstable_generateUtilityClass as generateUtilityClass, unstable_generat
 export function getYearCalendarUtilityClass(slot) {
   return generateUtilityClass('MuiYearCalendar', slot);
 }
-export const yearCalendarClasses = generateUtilityClasses('MuiYearCalendar', ['root']);
+export const yearCalendarClasses = generateUtilityClasses('MuiYearCalendar', ['root', 'button', 'disabled', 'selected']);

package/hooks/index.d.ts

@@ -4,3 +4,4 @@ export { usePickerTranslations } from './usePickerTranslations';
 export { useSplitFieldProps } from './useSplitFieldProps';
 export { useParsedFormat } from './useParsedFormat';
 export { usePickerContext } from './usePickerContext';
+export { usePickerActionsContext } from './usePickerActionsContext';

package/hooks/index.js

@@ -2,4 +2,5 @@ export { useClearableField } from "./useClearableField.js";
 export { usePickerTranslations } from "./usePickerTranslations.js";
 export { useSplitFieldProps } from "./useSplitFieldProps.js";
 export { useParsedFormat } from "./useParsedFormat.js";
-export { usePickerContext } from "./usePickerContext.js";
+export { usePickerContext } from "./usePickerContext.js";
+export { usePickerActionsContext } from "./usePickerActionsContext.js";

package/hooks/usePickerActionsContext.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns a subset of the context passed by the picker wrapping the current component.
+ * It only contains the actions and never causes a re-render of the component using it.
+ */
+export declare const usePickerActionsContext: () => import("../internals/components/PickerProvider").PickerActionsContextValue;

package/hooks/usePickerActionsContext.js

@@ -0,0 +1,16 @@
+'use client';
+
+import * as React from 'react';
+import { PickerActionsContext } from "../internals/components/PickerProvider.js";
+
+/**
+ * Returns a subset of the context passed by the picker wrapping the current component.
+ * It only contains the actions and never causes a re-render of the component using it.
+ */
+export const usePickerActionsContext = () => {
+  const value = React.useContext(PickerActionsContext);
+  if (value == null) {
+    throw new Error(['MUI X: The `usePickerActionsContext` can only be called in fields that are used as a slot of a picker component'].join('\n'));
+  }
+  return value;
+};

package/hooks/usePickerContext.d.ts

@@ -1,4 +1,6 @@
+import { PickerContextValue } from '../internals/components/PickerProvider';
+import { DateOrTimeViewWithMeridiem } from '../internals/models';
 /**
  * Returns the context passed by the picker that wraps the current component.
  */
-export declare const usePickerContext: () => import("../internals/components/PickerProvider").PickerContextValue;
+export declare const usePickerContext: <TView extends DateOrTimeViewWithMeridiem = DateOrTimeViewWithMeridiem>() => PickerContextValue<TView>;

package/hooks/usePickerContext.js

@@ -2,7 +2,6 @@
 
 import * as React from 'react';
 import { PickerContext } from "../internals/components/PickerProvider.js";
-
 /**
  * Returns the context passed by the picker that wraps the current component.
  */

package/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-date-pickers v8.0.0-alpha.4
+ * @mui/x-date-pickers v8.0.0-alpha.6
  *
  * @license MIT
  * This source code is licensed under the MIT license found in the

package/internals/components/PickerProvider.d.ts

@@ -1,9 +1,11 @@
 import * as React from 'react';
 import { PickerOwnerState } from '../../models';
 import { PickersInputLocaleText } from '../../locales';
-import { PickerOrientation, PickerVariant } from '../models';
-import type { UsePickerValueContextValue } from '../hooks/usePicker/usePickerValue.types';
-export declare const PickerContext: React.Context<PickerContextValue | null>;
+import { DateOrTimeViewWithMeridiem, PickerOrientation, PickerVariant } from '../models';
+import type { UsePickerValueActionsContextValue, UsePickerValueContextValue, UsePickerValuePrivateContextValue } from '../hooks/usePicker/usePickerValue.types';
+import { UsePickerViewsContextValue } from '../hooks/usePicker/usePickerViews';
+export declare const PickerContext: React.Context<PickerContextValue<any> | null>;
+export declare const PickerActionsContext: React.Context<PickerActionsContextValue | null>;
 export declare const PickerPrivateContext: React.Context<PickerPrivateContextValue>;
 /**
  * Provides the context for the various parts of a picker component:
@@ -14,12 +16,13 @@ export declare const PickerPrivateContext: React.Context<PickerPrivateContextVal
  */
 export declare function PickerProvider(props: PickerProviderProps): React.JSX.Element;
 export interface PickerProviderProps {
-    contextValue: PickerContextValue;
+    contextValue: PickerContextValue<any>;
+    actionsContextValue: PickerActionsContextValue;
     privateContextValue: PickerPrivateContextValue;
     localeText: PickersInputLocaleText | undefined;
     children: React.ReactNode;
 }
-export interface PickerContextValue extends UsePickerValueContextValue {
+export interface PickerContextValue<TView extends DateOrTimeViewWithMeridiem = DateOrTimeViewWithMeridiem> extends UsePickerValueContextValue, UsePickerViewsContextValue<TView> {
     /**
      * `true` if the picker is disabled, `false` otherwise.
      */
@@ -46,7 +49,9 @@ export interface PickerContextValue extends UsePickerValueContextValue {
      */
     orientation: PickerOrientation;
 }
-export interface PickerPrivateContextValue {
+export interface PickerActionsContextValue extends UsePickerValueActionsContextValue {
+}
+export interface PickerPrivateContextValue extends UsePickerValuePrivateContextValue {
     /**
      * The ownerState of the picker.
      */

package/internals/components/PickerProvider.js

@@ -2,6 +2,7 @@ import * as React from 'react';
 import { LocalizationProvider } from "../../LocalizationProvider/index.js";
 import { jsx as _jsx } from "react/jsx-runtime";
 export const PickerContext = /*#__PURE__*/React.createContext(null);
+export const PickerActionsContext = /*#__PURE__*/React.createContext(null);
 export const PickerPrivateContext = /*#__PURE__*/React.createContext({
   ownerState: {
     isPickerDisabled: false,
@@ -10,7 +11,8 @@ export const PickerPrivateContext = /*#__PURE__*/React.createContext({
     isPickerOpen: false,
     pickerVariant: 'desktop',
     pickerOrientation: 'portrait'
-  }
+  },
+  dismissViews: () => {}
 });
 
 /**
@@ -23,17 +25,21 @@ export const PickerPrivateContext = /*#__PURE__*/React.createContext({
 export function PickerProvider(props) {
   const {
     contextValue,
+    actionsContextValue,
     privateContextValue,
     localeText,
     children
   } = props;
   return /*#__PURE__*/_jsx(PickerContext.Provider, {
     value: contextValue,
-    children: /*#__PURE__*/_jsx(PickerPrivateContext.Provider, {
-      value: privateContextValue,
-      children: /*#__PURE__*/_jsx(LocalizationProvider, {
-        localeText: localeText,
-        children: children
+    children: /*#__PURE__*/_jsx(PickerActionsContext.Provider, {
+      value: actionsContextValue,
+      children: /*#__PURE__*/_jsx(PickerPrivateContext.Provider, {
+        value: privateContextValue,
+        children: /*#__PURE__*/_jsx(LocalizationProvider, {
+          localeText: localeText,
+          children: children
+        })
       })
     })
   });

package/internals/components/PickersArrowSwitcher/PickersArrowSwitcher.js

@@ -38,7 +38,7 @@ const PickersArrowSwitcherButton = styled(IconButton, {
 })({
   variants: [{
     props: {
-      hidden: true
+      isButtonHidden: true
     },
     style: {
       visibility: 'hidden'
@@ -109,7 +109,7 @@ export const PickersArrowSwitcher = /*#__PURE__*/React.forwardRef(function Picke
       onClick: previousProps.goTo
     },
     ownerState: _extends({}, ownerState, {
-      hidden: previousProps.isHidden ?? false
+      isButtonHidden: previousProps.isHidden ?? false
     }),
     className: clsx(classes.button, classes.previousIconButton)
   });
@@ -126,7 +126,7 @@ export const PickersArrowSwitcher = /*#__PURE__*/React.forwardRef(function Picke
       onClick: nextProps.goTo
     },
     ownerState: _extends({}, ownerState, {
-      hidden: nextProps.isHidden ?? false
+      isButtonHidden: nextProps.isHidden ?? false
     }),
     className: clsx(classes.button, classes.nextIconButton)
   });

package/internals/components/PickersArrowSwitcher/PickersArrowSwitcher.types.d.ts

@@ -41,7 +41,7 @@ export interface PickersArrowSwitcherOwnerState extends PickerOwnerState {
     /**
      * If `true`, this button should be hidden.
      */
-    hidden: boolean;
+    isButtonHidden: boolean;
 }
 export interface PickersArrowSwitcherSlotPropsOverrides {
 }

package/internals/components/PickersModalDialog.d.ts

@@ -2,7 +2,6 @@ import * as React from 'react';
 import { DialogProps as MuiDialogProps } from '@mui/material/Dialog';
 import { PaperProps as MuiPaperProps } from '@mui/material/Paper';
 import { TransitionProps as MuiTransitionProps } from '@mui/material/transitions';
-import { UsePickerValueActions } from '../hooks/usePicker/usePickerValue.types';
 export interface PickersModalDialogSlots {
     /**
      * Custom component for the dialog inside which the views are rendered on mobile.
@@ -34,7 +33,7 @@ export interface PickersModalDialogSlotProps {
      */
     mobileTransition?: Partial<MuiTransitionProps>;
 }
-export interface PickersModalDialogProps extends UsePickerValueActions {
+export interface PickersModalDialogProps {
     /**
      * Overridable component slots.
      * @default {}
@@ -45,6 +44,5 @@ export interface PickersModalDialogProps extends UsePickerValueActions {
      * @default {}
      */
     slotProps?: PickersModalDialogSlotProps;
-    open: boolean;
 }
 export declare function PickersModalDialog(props: React.PropsWithChildren<PickersModalDialogProps>): React.JSX.Element;

package/internals/components/PickersModalDialog.js

@@ -5,6 +5,8 @@ import Fade from '@mui/material/Fade';
 import MuiDialog, { dialogClasses } from '@mui/material/Dialog';
 import { styled } from '@mui/material/styles';
 import { DIALOG_WIDTH } from "../constants/dimensions.js";
+import { usePickerContext } from "../../hooks/index.js";
+import { usePickerPrivateContext } from "../hooks/usePickerPrivateContext.js";
 import { jsx as _jsx } from "react/jsx-runtime";
 const PickersModalDialogRoot = styled(MuiDialog)({
   [`& .${dialogClasses.container}`]: {
@@ -23,16 +25,20 @@ const PickersModalDialogContent = styled(DialogContent)({
 export function PickersModalDialog(props) {
   const {
     children,
-    onDismiss,
-    open,
     slots,
     slotProps
   } = props;
+  const {
+    open
+  } = usePickerContext();
+  const {
+    dismissViews
+  } = usePickerPrivateContext();
   const Dialog = slots?.dialog ?? PickersModalDialogRoot;
   const Transition = slots?.mobileTransition ?? Fade;
   return /*#__PURE__*/_jsx(Dialog, _extends({
     open: open,
-    onClose: onDismiss
+    onClose: dismissViews
   }, slotProps?.dialog, {
     TransitionComponent: Transition,
     TransitionProps: slotProps?.mobileTransition,

package/internals/components/PickersPopper.d.ts

@@ -5,7 +5,6 @@ import { TrapFocusProps as MuiTrapFocusProps } from '@mui/material/Unstable_Trap
 import { TransitionProps as MuiTransitionProps } from '@mui/material/transitions';
 import { SlotComponentPropsFromProps } from '@mui/x-internals/types';
 import { PickersPopperClasses } from './pickersPopperClasses';
-import { UsePickerValueActions } from '../hooks/usePicker/usePickerValue.types';
 import { PickerOwnerState } from '../../models';
 interface PickerPopperOwnerState extends PickerOwnerState {
     popperPlacement: PopperPlacementType;
@@ -50,10 +49,9 @@ export interface PickersPopperSlotProps {
      */
     popper?: SlotComponentPropsFromProps<PopperProps, {}, PickerPopperOwnerState>;
 }
-export interface PickerPopperProps extends UsePickerValueActions {
+export interface PickerPopperProps {
     role: 'tooltip' | 'dialog';
     anchorEl: MuiPopperProps['anchorEl'];
-    open: MuiPopperProps['open'];
     /**
      * @default "bottom"
      */