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

package/modern/TimePicker/TimePickerToolbar.js

@@ -2,7 +2,7 @@
 
 import _extends from "@babel/runtime/helpers/esm/extends";
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-const _excluded = ["ampm", "ampmInClock", "value", "isLandscape", "onChange", "className", "classes"];
+const _excluded = ["ampm", "ampmInClock", "className", "classes"];
 import * as React from 'react';
 import clsx from 'clsx';
 import PropTypes from 'prop-types';
@@ -122,9 +122,6 @@ function TimePickerToolbar(inProps) {
   const {
       ampm,
       ampmInClock,
-      value,
-      isLandscape,
-      onChange,
       className,
       classes: classesProp
     } = props,
@@ -134,18 +131,27 @@ function TimePickerToolbar(inProps) {
   const ownerState = useToolbarOwnerState();
   const classes = useUtilityClasses(classesProp, ownerState);
   const {
+    value,
+    setValue,
     disabled,
     readOnly,
     view,
-    onViewChange,
+    setView,
     views
   } = usePickerContext();
   const showAmPmControl = Boolean(ampm && !ampmInClock && views.includes('hours'));
   const {
     meridiemMode,
     handleMeridiemChange
-  } = useMeridiemMode(value, ampm, onChange);
-  const formatHours = time => ampm ? utils.format(time, 'hours12h') : utils.format(time, 'hours24h');
+  } = useMeridiemMode(value, ampm, newValue => setValue(newValue, {
+    changeImportance: 'set'
+  }));
+  const formatSection = format => {
+    if (!utils.isValid(value)) {
+      return '--';
+    }
+    return utils.format(value, format);
+  };
   const separator = /*#__PURE__*/_jsx(TimePickerToolbarSeparator, {
     tabIndex: -1,
     value: ":",
@@ -156,7 +162,6 @@ function TimePickerToolbar(inProps) {
   return /*#__PURE__*/_jsxs(TimePickerToolbarRoot, _extends({
     landscapeDirection: "row",
     toolbarTitle: translations.timePickerToolbarTitle,
-    isLandscape: isLandscape,
     ownerState: ownerState,
     className: clsx(classes.root, className)
   }, other, {
@@ -166,20 +171,20 @@ function TimePickerToolbar(inProps) {
       children: [arrayIncludes(views, 'hours') && /*#__PURE__*/_jsx(PickersToolbarButton, {
         tabIndex: -1,
         variant: "h3",
-        onClick: () => onViewChange('hours'),
+        onClick: () => setView('hours'),
         selected: view === 'hours',
-        value: value ? formatHours(value) : '--'
+        value: formatSection(ampm ? 'hours12h' : 'hours24h')
       }), arrayIncludes(views, ['hours', 'minutes']) && separator, arrayIncludes(views, 'minutes') && /*#__PURE__*/_jsx(PickersToolbarButton, {
         tabIndex: -1,
         variant: "h3",
-        onClick: () => onViewChange('minutes'),
+        onClick: () => setView('minutes'),
         selected: view === 'minutes',
-        value: value ? utils.format(value, 'minutes') : '--'
+        value: formatSection('minutes')
       }), arrayIncludes(views, ['minutes', 'seconds']) && separator, arrayIncludes(views, 'seconds') && /*#__PURE__*/_jsx(PickersToolbarButton, {
         variant: "h3",
-        onClick: () => onViewChange('seconds'),
+        onClick: () => setView('seconds'),
         selected: view === 'seconds',
-        value: value ? utils.format(value, 'seconds') : '--'
+        value: formatSection('seconds')
       })]
     }), showAmPmControl && /*#__PURE__*/_jsxs(TimePickerToolbarAmPmSelection, {
       className: classes.ampmSelection,
@@ -221,8 +226,6 @@ process.env.NODE_ENV !== "production" ? TimePickerToolbar.propTypes = {
    * @default `true` for Desktop, `false` for Mobile.
    */
   hidden: PropTypes.bool,
-  isLandscape: PropTypes.bool.isRequired,
-  onChange: PropTypes.func.isRequired,
   /**
    * The system prop that allows defining system overrides as well as additional CSS styles.
    */
@@ -236,7 +239,6 @@ process.env.NODE_ENV !== "production" ? TimePickerToolbar.propTypes = {
    * Toolbar value placeholder—it is displayed when the value is empty.
    * @default "––"
    */
-  toolbarPlaceholder: PropTypes.node,
-  value: PropTypes.object
+  toolbarPlaceholder: PropTypes.node
 } : void 0;
 export { TimePickerToolbar };

package/modern/hooks/index.js

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

package/modern/hooks/useIsValidValue.js

@@ -0,0 +1,11 @@
+'use client';
+
+import * as React from 'react';
+export const IsValidValueContext = /*#__PURE__*/React.createContext(() => true);
+
+/**
+ * Returns a function to check if a value is valid according to the validation props passed to the parent picker.
+ */
+export function useIsValidValue() {
+  return React.useContext(IsValidValueContext);
+}

package/modern/hooks/useParsedFormat.js

@@ -6,32 +6,30 @@ import { useUtils } from "../internals/hooks/useUtils.js";
 import { buildSectionsFromFormat } from "../internals/hooks/useField/buildSectionsFromFormat.js";
 import { getLocalizedDigits } from "../internals/hooks/useField/useField.utils.js";
 import { usePickerTranslations } from "./usePickerTranslations.js";
+import { useNullablePickerContext } from "../internals/hooks/useNullablePickerContext.js";
 /**
  * Returns the parsed format to be rendered in the field when there is no value or in other parts of the Picker.
  * This format is localized (for example `AAAA` for the year with the French locale) and cannot be parsed by your date library.
  * @param {object} The parameters needed to build the placeholder.
- * @param {string} params.format Format of the date to use.
- * @param {'dense' | 'spacious'} params.formatDensity Density of the format (setting `formatDensity` to `"spacious"` will add a space before and after each `/`, `-` and `.` character).
- * @param {boolean} params.shouldRespectLeadingZeros If `true`, the format will respect the leading zeroes, if `false`, the format will always add leading zeroes.
+ * @param {string} params.format Format to parse.
  * @returns
  */
-export const useParsedFormat = parameters => {
-  const {
-    format,
-    formatDensity = 'dense',
-    shouldRespectLeadingZeros = false
-  } = parameters;
+export const useParsedFormat = (parameters = {}) => {
+  const pickerContext = useNullablePickerContext();
   const utils = useUtils();
   const isRtl = useRtl();
   const translations = usePickerTranslations();
   const localizedDigits = React.useMemo(() => getLocalizedDigits(utils), [utils]);
+  const {
+    format = pickerContext?.fieldFormat ?? utils.formats.fullDate
+  } = parameters;
   return React.useMemo(() => {
     const sections = buildSectionsFromFormat({
       utils,
       format,
-      formatDensity,
+      formatDensity: 'dense',
       isRtl,
-      shouldRespectLeadingZeros,
+      shouldRespectLeadingZeros: true,
       localeText: translations,
       localizedDigits,
       date: null,
@@ -39,5 +37,5 @@ export const useParsedFormat = parameters => {
       enableAccessibleFieldDOMStructure: false
     });
     return sections.map(section => `${section.startSeparator}${section.placeholder}${section.endSeparator}`).join('');
-  }, [utils, isRtl, translations, localizedDigits, format, formatDensity, shouldRespectLeadingZeros]);
+  }, [utils, isRtl, translations, localizedDigits, format]);
 };

package/modern/hooks/usePickerActionsContext.js

@@ -2,7 +2,6 @@
 
 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.

package/modern/hooks/usePickerContext.js

@@ -1,14 +1,15 @@
 'use client';
 
 import * as React from 'react';
-import { PickerContext } from "../internals/components/PickerProvider.js";
+export const PickerContext = /*#__PURE__*/React.createContext(null);
+
 /**
  * Returns the context passed by the picker that wraps the current component.
  */
 export const usePickerContext = () => {
   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/modern/hooks/useSplitFieldProps.js

@@ -3,13 +3,13 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 import { DATE_TIME_VALIDATION_PROP_NAMES, DATE_VALIDATION_PROP_NAMES, TIME_VALIDATION_PROP_NAMES } from "../validation/extractValidationProps.js";
-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').
@@ -40,4 +40,9 @@ export const useSplitFieldProps = (props, valueType) => {
       internalProps
     };
   }, [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.
+ */

package/modern/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-date-pickers v8.0.0-alpha.6
+ * @mui/x-date-pickers v8.0.0-alpha.8
  *
  * @license MIT
  * This source code is licensed under the MIT license found in the
@@ -57,4 +57,5 @@ export { DEFAULT_DESKTOP_MODE_MEDIA_QUERY } from "./internals/utils/utils.js";
 export * from "./models/index.js";
 export * from "./icons/index.js";
 export * from "./hooks/index.js";
-export * from "./validation/index.js";
+export * from "./validation/index.js";
+export * from "./managers/index.js";

package/modern/internals/components/PickerFieldUI.js

@@ -0,0 +1,306 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+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"];
+import * as React from 'react';
+import useEventCallback from '@mui/utils/useEventCallback';
+import resolveComponentProps from '@mui/utils/resolveComponentProps';
+import MuiTextField from '@mui/material/TextField';
+import MuiIconButton from '@mui/material/IconButton';
+import MuiInputAdornment from '@mui/material/InputAdornment';
+import useSlotProps from '@mui/utils/useSlotProps';
+import { useFieldOwnerState } from "../hooks/useFieldOwnerState.js";
+import { usePickerTranslations } from "../../hooks/index.js";
+import { ClearIcon as MuiClearIcon } from "../../icons/index.js";
+import { useNullablePickerContext } from "../hooks/useNullablePickerContext.js";
+import { PickersTextField } from "../../PickersTextField/index.js";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export const cleanFieldResponse = _ref => {
+  let {
+      enableAccessibleFieldDOMStructure
+    } = _ref,
+    fieldResponse = _objectWithoutPropertiesLoose(_ref, _excluded);
+  if (enableAccessibleFieldDOMStructure) {
+    const {
+        InputProps,
+        readOnly,
+        onClear,
+        clearable,
+        clearButtonPosition,
+        openPickerButtonPosition,
+        openPickerAriaLabel
+      } = fieldResponse,
+      other = _objectWithoutPropertiesLoose(fieldResponse, _excluded2);
+    return {
+      clearable,
+      onClear,
+      clearButtonPosition,
+      openPickerButtonPosition,
+      openPickerAriaLabel,
+      textFieldProps: _extends({}, other, {
+        InputProps: _extends({}, InputProps ?? {}, {
+          readOnly
+        })
+      })
+    };
+  }
+  const {
+      onPaste,
+      onKeyDown,
+      inputMode,
+      readOnly,
+      InputProps,
+      inputProps,
+      inputRef,
+      onClear,
+      clearable,
+      clearButtonPosition,
+      openPickerButtonPosition,
+      openPickerAriaLabel
+    } = fieldResponse,
+    other = _objectWithoutPropertiesLoose(fieldResponse, _excluded3);
+  return {
+    clearable,
+    onClear,
+    clearButtonPosition,
+    openPickerButtonPosition,
+    openPickerAriaLabel,
+    textFieldProps: _extends({}, other, {
+      InputProps: _extends({}, InputProps ?? {}, {
+        readOnly
+      }),
+      inputProps: _extends({}, inputProps ?? {}, {
+        inputMode,
+        onPaste,
+        onKeyDown,
+        ref: inputRef
+      })
+    })
+  };
+};
+const PickerFieldUIContext = /*#__PURE__*/React.createContext({
+  slots: {},
+  slotProps: {}
+});
+
+/**
+ * Adds the button to open the picker and the button to clear the value of the field.
+ * @ignore - internal component.
+ */
+export function PickerFieldUI(props) {
+  const {
+    slots,
+    slotProps,
+    fieldResponse,
+    defaultOpenPickerIcon
+  } = props;
+  const translations = usePickerTranslations();
+  const pickerContext = useNullablePickerContext();
+  const pickerFieldUIContext = React.useContext(PickerFieldUIContext);
+  const {
+    textFieldProps,
+    onClear,
+    clearable,
+    openPickerAriaLabel,
+    clearButtonPosition: clearButtonPositionProp = 'end',
+    openPickerButtonPosition: openPickerButtonPositionProp = 'end'
+  } = cleanFieldResponse(fieldResponse);
+  const ownerState = useFieldOwnerState(textFieldProps);
+  const handleClickOpeningButton = useEventCallback(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 ? MuiTextField : PickersTextField);
+  const InputAdornment = slots?.inputAdornment ?? pickerFieldUIContext.slots.inputAdornment ?? MuiInputAdornment;
+  const _useSlotProps = useSlotProps({
+      elementType: InputAdornment,
+      externalSlotProps: mergeSlotProps(pickerFieldUIContext.slotProps.inputAdornment, slotProps?.inputAdornment),
+      additionalProps: {
+        position: 'start'
+      },
+      ownerState: _extends({}, ownerState, {
+        position: 'start'
+      })
+    }),
+    startInputAdornmentProps = _objectWithoutPropertiesLoose(_useSlotProps, _excluded4);
+  const _useSlotProps2 = useSlotProps({
+      elementType: InputAdornment,
+      externalSlotProps: slotProps?.inputAdornment,
+      additionalProps: {
+        position: 'end'
+      },
+      ownerState: _extends({}, ownerState, {
+        position: 'end'
+      })
+    }),
+    endInputAdornmentProps = _objectWithoutPropertiesLoose(_useSlotProps2, _excluded5);
+  const OpenPickerButton = pickerFieldUIContext.slots.openPickerButton ?? MuiIconButton;
+  // We don't want to forward the `ownerState` to the `<IconButton />` component, see mui/material-ui#34056
+  const _useSlotProps3 = useSlotProps({
+      elementType: OpenPickerButton,
+      externalSlotProps: pickerFieldUIContext.slotProps.openPickerButton,
+      additionalProps: {
+        disabled: triggerStatus === 'disabled',
+        onClick: handleClickOpeningButton,
+        'aria-label': openPickerAriaLabel,
+        edge: clearButtonPosition === 'start' && openPickerButtonPosition === 'start' ? undefined : openPickerButtonPosition
+      },
+      ownerState
+    }),
+    openPickerButtonProps = _objectWithoutPropertiesLoose(_useSlotProps3, _excluded6);
+  const OpenPickerIcon = pickerFieldUIContext.slots.openPickerIcon ?? defaultOpenPickerIcon;
+  const openPickerIconProps = useSlotProps({
+    elementType: OpenPickerIcon,
+    externalSlotProps: pickerFieldUIContext.slotProps.openPickerIcon,
+    ownerState
+  });
+  const ClearButton = slots?.clearButton ?? pickerFieldUIContext.slots.clearButton ?? MuiIconButton;
+  // We don't want to forward the `ownerState` to the `<IconButton />` component, see mui/material-ui#34056
+  const _useSlotProps4 = useSlotProps({
+      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 = _objectWithoutPropertiesLoose(_useSlotProps4, _excluded7);
+  const ClearIcon = slots?.clearIcon ?? pickerFieldUIContext.slots.clearIcon ?? MuiClearIcon;
+  const clearIconProps = useSlotProps({
+    elementType: ClearIcon,
+    externalSlotProps: mergeSlotProps(pickerFieldUIContext.slotProps.clearIcon, slotProps?.clearIcon),
+    additionalProps: {
+      fontSize: 'small'
+    },
+    ownerState
+  });
+  if (!textFieldProps.InputProps) {
+    textFieldProps.InputProps = {};
+  }
+  if (pickerContext) {
+    textFieldProps.InputProps.ref = pickerContext.triggerRef;
+  }
+  if (!textFieldProps.InputProps?.startAdornment && (clearButtonPosition === 'start' || openPickerButtonPosition === 'start')) {
+    textFieldProps.InputProps.startAdornment = /*#__PURE__*/_jsxs(InputAdornment, _extends({}, startInputAdornmentProps, {
+      children: [openPickerButtonPosition === 'start' && /*#__PURE__*/_jsx(OpenPickerButton, _extends({}, openPickerButtonProps, {
+        children: /*#__PURE__*/_jsx(OpenPickerIcon, _extends({}, openPickerIconProps))
+      })), clearButtonPosition === 'start' && /*#__PURE__*/_jsx(ClearButton, _extends({}, clearButtonProps, {
+        children: /*#__PURE__*/_jsx(ClearIcon, _extends({}, clearIconProps))
+      }))]
+    }));
+  }
+  if (!textFieldProps.InputProps?.endAdornment && (clearButtonPosition === 'end' || openPickerButtonPosition === 'end')) {
+    textFieldProps.InputProps.endAdornment = /*#__PURE__*/_jsxs(InputAdornment, _extends({}, endInputAdornmentProps, {
+      children: [clearButtonPosition === 'end' && /*#__PURE__*/_jsx(ClearButton, _extends({}, clearButtonProps, {
+        children: /*#__PURE__*/_jsx(ClearIcon, _extends({}, clearIconProps))
+      })), openPickerButtonPosition === 'end' && /*#__PURE__*/_jsx(OpenPickerButton, _extends({}, openPickerButtonProps, {
+        children: /*#__PURE__*/_jsx(OpenPickerIcon, _extends({}, 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__*/_jsx(TextField, _extends({}, textFieldProps));
+}
+function mergeSlotProps(slotPropsA, slotPropsB) {
+  if (!slotPropsA) {
+    return slotPropsB;
+  }
+  if (!slotPropsB) {
+    return slotPropsA;
+  }
+  return ownerState => {
+    return _extends({}, resolveComponentProps(slotPropsB, ownerState), resolveComponentProps(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.
+ */
+export function useFieldTextFieldProps(parameters) {
+  const {
+    ref,
+    externalForwardedProps,
+    slotProps
+  } = parameters;
+  const pickerFieldUIContext = React.useContext(PickerFieldUIContext);
+  const ownerState = useFieldOwnerState(externalForwardedProps);
+  const {
+      InputProps,
+      inputProps
+    } = externalForwardedProps,
+    otherExternalForwardedProps = _objectWithoutPropertiesLoose(externalForwardedProps, _excluded8);
+  const textFieldProps = useSlotProps({
+    elementType: PickersTextField,
+    externalSlotProps: mergeSlotProps(pickerFieldUIContext.slotProps.textField, slotProps?.textField),
+    externalForwardedProps: otherExternalForwardedProps,
+    additionalProps: {
+      ref
+    },
+    ownerState
+  });
+
+  // TODO: Remove when mui/material-ui#35088 will be merged
+  textFieldProps.inputProps = _extends({}, inputProps, textFieldProps.inputProps);
+  textFieldProps.InputProps = _extends({}, InputProps, textFieldProps.InputProps);
+  return textFieldProps;
+}
+export function PickerFieldUIContextProvider(props) {
+  const {
+    slots = {},
+    slotProps = {},
+    children
+  } = props;
+  const contextValue = React.useMemo(() => ({
+    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
+    }
+  }), [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__*/_jsx(PickerFieldUIContext.Provider, {
+    value: contextValue,
+    children: children
+  });
+}

package/modern/internals/components/PickerProvider.js

@@ -1,7 +1,9 @@
 import * as React from 'react';
 import { LocalizationProvider } from "../../LocalizationProvider/index.js";
+import { IsValidValueContext } from "../../hooks/useIsValidValue.js";
+import { PickerFieldPrivateContext } from "../hooks/useField/useFieldInternalPropsWithDefaults.js";
+import { PickerContext } from "../../hooks/usePickerContext.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: {
@@ -27,6 +29,8 @@ export function PickerProvider(props) {
     contextValue,
     actionsContextValue,
     privateContextValue,
+    fieldPrivateContextValue,
+    isValidContextValue,
     localeText,
     children
   } = props;
@@ -36,9 +40,15 @@ export function PickerProvider(props) {
       value: actionsContextValue,
       children: /*#__PURE__*/_jsx(PickerPrivateContext.Provider, {
         value: privateContextValue,
-        children: /*#__PURE__*/_jsx(LocalizationProvider, {
-          localeText: localeText,
-          children: children
+        children: /*#__PURE__*/_jsx(PickerFieldPrivateContext.Provider, {
+          value: fieldPrivateContextValue,
+          children: /*#__PURE__*/_jsx(IsValidValueContext.Provider, {
+            value: isValidContextValue,
+            children: /*#__PURE__*/_jsx(LocalizationProvider, {
+              localeText: localeText,
+              children: children
+            })
+          })
         })
       })
     })

package/modern/internals/components/PickersToolbar.js

@@ -1,6 +1,6 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-const _excluded = ["children", "className", "classes", "toolbarTitle", "hidden", "titleId", "isLandscape", "classes", "landscapeDirection"];
+const _excluded = ["children", "className", "classes", "toolbarTitle", "hidden", "titleId", "classes", "landscapeDirection"];
 import * as React from 'react';
 import clsx from 'clsx';
 import Typography from '@mui/material/Typography';

package/modern/internals/hooks/date-helpers-hooks.js

@@ -27,11 +27,12 @@ export function usePreviousMonthDisabled(month, {
 }
 export function useMeridiemMode(date, ampm, onChange, selectionState) {
   const utils = useUtils();
-  const meridiemMode = getMeridiem(date, utils);
+  const cleanDate = React.useMemo(() => !utils.isValid(date) ? null : date, [utils, date]);
+  const meridiemMode = getMeridiem(cleanDate, utils);
   const handleMeridiemChange = React.useCallback(mode => {
-    const timeWithMeridiem = date == null ? null : convertToMeridiem(date, mode, Boolean(ampm), utils);
+    const timeWithMeridiem = cleanDate == null ? null : convertToMeridiem(cleanDate, mode, Boolean(ampm), utils);
     onChange(timeWithMeridiem, selectionState ?? 'partial');
-  }, [ampm, date, onChange, selectionState, utils]);
+  }, [ampm, cleanDate, onChange, selectionState, utils]);
   return {
     meridiemMode,
     handleMeridiemChange