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

package/StaticDatePicker/StaticDatePicker.js

@@ -41,11 +41,11 @@ const StaticDatePicker = /*#__PURE__*/React.forwardRef(function StaticDatePicker
   const {
     renderPicker
   } = useStaticPicker({
+    ref,
     props,
     valueManager: singleItemValueManager,
     valueType: 'date',
-    validator: validateDate,
-    ref
+    validator: validateDate
   });
   return renderPicker();
 });

package/StaticDatePicker/StaticDatePicker.types.d.ts

@@ -1,10 +1,9 @@
 import { MakeOptional } from '@mui/x-internals/types';
 import { BaseDatePickerProps, BaseDatePickerSlots, BaseDatePickerSlotProps } from '../DatePicker/shared';
 import { StaticOnlyPickerProps, UseStaticPickerSlots, UseStaticPickerSlotProps } from '../internals/hooks/useStaticPicker';
-import { DateView } from '../models';
-export interface StaticDatePickerSlots extends BaseDatePickerSlots, UseStaticPickerSlots<DateView> {
+export interface StaticDatePickerSlots extends BaseDatePickerSlots, UseStaticPickerSlots {
 }
-export interface StaticDatePickerSlotProps extends BaseDatePickerSlotProps, UseStaticPickerSlotProps<DateView> {
+export interface StaticDatePickerSlotProps extends BaseDatePickerSlotProps, UseStaticPickerSlotProps {
 }
 export interface StaticDatePickerProps extends BaseDatePickerProps, MakeOptional<StaticOnlyPickerProps, 'displayStaticWrapperAs'> {
     /**

package/StaticDateTimePicker/StaticDateTimePicker.js

@@ -51,11 +51,11 @@ const StaticDateTimePicker = /*#__PURE__*/React.forwardRef(function StaticDateTi
   const {
     renderPicker
   } = useStaticPicker({
+    ref,
     props,
     valueManager: singleItemValueManager,
     valueType: 'date-time',
-    validator: validateDateTime,
-    ref
+    validator: validateDateTime
   });
   return renderPicker();
 });

package/StaticDateTimePicker/StaticDateTimePicker.types.d.ts

@@ -2,9 +2,9 @@ import { MakeOptional } from '@mui/x-internals/types';
 import { BaseDateTimePickerProps, BaseDateTimePickerSlots, BaseDateTimePickerSlotProps } from '../DateTimePicker/shared';
 import { StaticOnlyPickerProps, UseStaticPickerSlots, UseStaticPickerSlotProps } from '../internals/hooks/useStaticPicker';
 import { DateOrTimeView } from '../models';
-export interface StaticDateTimePickerSlots extends BaseDateTimePickerSlots, UseStaticPickerSlots<DateOrTimeView> {
+export interface StaticDateTimePickerSlots extends BaseDateTimePickerSlots, UseStaticPickerSlots {
 }
-export interface StaticDateTimePickerSlotProps extends BaseDateTimePickerSlotProps, UseStaticPickerSlotProps<DateOrTimeView> {
+export interface StaticDateTimePickerSlotProps extends BaseDateTimePickerSlotProps, UseStaticPickerSlotProps {
 }
 export interface StaticDateTimePickerProps extends BaseDateTimePickerProps<DateOrTimeView>, MakeOptional<StaticOnlyPickerProps, 'displayStaticWrapperAs'> {
     /**

package/StaticTimePicker/StaticTimePicker.js

@@ -43,11 +43,11 @@ const StaticTimePicker = /*#__PURE__*/React.forwardRef(function StaticTimePicker
   const {
     renderPicker
   } = useStaticPicker({
+    ref,
     props,
     valueManager: singleItemValueManager,
     valueType: 'time',
-    validator: validateTime,
-    ref
+    validator: validateTime
   });
   return renderPicker();
 });

package/StaticTimePicker/StaticTimePicker.types.d.ts

@@ -2,9 +2,9 @@ import { MakeOptional } from '@mui/x-internals/types';
 import { BaseTimePickerProps, BaseTimePickerSlots, BaseTimePickerSlotProps } from '../TimePicker/shared';
 import { StaticOnlyPickerProps, UseStaticPickerSlots, UseStaticPickerSlotProps } from '../internals/hooks/useStaticPicker';
 import { TimeView } from '../models';
-export interface StaticTimePickerSlots extends BaseTimePickerSlots, UseStaticPickerSlots<TimeView> {
+export interface StaticTimePickerSlots extends BaseTimePickerSlots, UseStaticPickerSlots {
 }
-export interface StaticTimePickerSlotProps extends BaseTimePickerSlotProps, UseStaticPickerSlotProps<TimeView> {
+export interface StaticTimePickerSlotProps extends BaseTimePickerSlotProps, UseStaticPickerSlotProps {
 }
 export interface StaticTimePickerProps extends BaseTimePickerProps<TimeView>, MakeOptional<StaticOnlyPickerProps, 'displayStaticWrapperAs'> {
     /**

package/TimeClock/Clock.d.ts

@@ -26,6 +26,10 @@ export interface ClockProps extends ReturnType<typeof useMeridiemMode>, FormProp
      * The current full date value.
      */
     value: PickerValidDate | null;
+    /**
+     * Minimum and maximum value of the clock.
+     */
+    viewRange: [number, number];
     className?: string;
     classes?: Partial<ClockClasses>;
 }

package/TimeClock/Clock.js

@@ -11,20 +11,17 @@ import { useUtils } from "../internals/hooks/useUtils.js";
 import { CLOCK_HOUR_WIDTH, getHours, getMinutes } from "./shared.js";
 import { getClockUtilityClass } from "./clockClasses.js";
 import { formatMeridiem } from "../internals/utils/date-utils.js";
+import { usePickerPrivateContext } from "../internals/hooks/usePickerPrivateContext.js";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-const useUtilityClasses = ownerState => {
-  const {
-    classes,
-    meridiemMode
-  } = ownerState;
+const useUtilityClasses = (classes, ownerState) => {
   const slots = {
     root: ['root'],
     clock: ['clock'],
     wrapper: ['wrapper'],
     squareMask: ['squareMask'],
     pin: ['pin'],
-    amButton: ['amButton', meridiemMode === 'am' && 'selected'],
-    pmButton: ['pmButton', meridiemMode === 'pm' && 'selected'],
+    amButton: ['amButton', ownerState.clockMeridiemMode === 'am' && 'selected'],
+    pmButton: ['pmButton', ownerState.clockMeridiemMode === 'pm' && 'selected'],
     meridiemText: ['meridiemText']
   };
   return composeClasses(slots, getClockUtilityClass, classes);
@@ -78,7 +75,7 @@ const ClockSquareMask = styled('div', {
   userSelect: 'none',
   variants: [{
     props: {
-      disabled: false
+      isClockDisabled: false
     },
     style: {
       '@media (pointer: fine)': {
@@ -180,15 +177,23 @@ export function Clock(inProps) {
     selectedId,
     type,
     viewValue,
+    viewRange: [minViewValue, maxViewValue],
     disabled = false,
     readOnly,
-    className
+    className,
+    classes: classesProp
   } = props;
-  const ownerState = props;
   const utils = useUtils();
   const translations = usePickerTranslations();
+  const {
+    ownerState: pickerOwnerState
+  } = usePickerPrivateContext();
+  const ownerState = _extends({}, pickerOwnerState, {
+    isClockDisabled: disabled,
+    clockMeridiemMode: meridiemMode
+  });
   const isMoving = React.useRef(false);
-  const classes = useUtilityClasses(ownerState);
+  const classes = useUtilityClasses(classesProp, ownerState);
   const isSelectedTimeDisabled = isTimeDisabled(viewValue, type);
   const isPointerInner = !ampm && type === 'hours' && (viewValue < 1 || viewValue > 12);
   const handleValueChange = (newValue, isFinish) => {
@@ -222,6 +227,7 @@ export function Clock(inProps) {
       setTime(event, 'finish');
       isMoving.current = false;
     }
+    event.preventDefault();
   };
   const handleMouseMove = event => {
     // event.buttons & PRIMARY_MOUSE_BUTTON
@@ -235,12 +241,7 @@ export function Clock(inProps) {
     }
     setTime(event.nativeEvent, 'finish');
   };
-  const hasSelected = React.useMemo(() => {
-    if (type === 'hours') {
-      return true;
-    }
-    return viewValue % 5 === 0;
-  }, [type, viewValue]);
+  const isPointerBetweenTwoClockValues = type === 'hours' ? false : viewValue % 5 !== 0;
   const keyboardControlStep = type === 'minutes' ? minutesStep : 1;
   const listboxRef = React.useRef(null);
   // Since this is rendered when a Popper is opened we can't use passive effects.
@@ -251,6 +252,8 @@ export function Clock(inProps) {
       listboxRef.current.focus();
     }
   }, [autoFocus]);
+  const clampValue = newValue => Math.max(minViewValue, Math.min(maxViewValue, newValue));
+  const circleValue = newValue => (newValue + (maxViewValue + 1)) % (maxViewValue + 1);
   const handleKeyDown = event => {
     // TODO: Why this early exit?
     if (isMoving.current) {
@@ -259,27 +262,27 @@ export function Clock(inProps) {
     switch (event.key) {
       case 'Home':
         // reset both hours and minutes
-        handleValueChange(0, 'partial');
+        handleValueChange(minViewValue, 'partial');
         event.preventDefault();
         break;
       case 'End':
-        handleValueChange(type === 'minutes' ? 59 : 23, 'partial');
+        handleValueChange(maxViewValue, 'partial');
         event.preventDefault();
         break;
       case 'ArrowUp':
-        handleValueChange(viewValue + keyboardControlStep, 'partial');
+        handleValueChange(circleValue(viewValue + keyboardControlStep), 'partial');
         event.preventDefault();
         break;
       case 'ArrowDown':
-        handleValueChange(viewValue - keyboardControlStep, 'partial');
+        handleValueChange(circleValue(viewValue - keyboardControlStep), 'partial');
         event.preventDefault();
         break;
       case 'PageUp':
-        handleValueChange(viewValue + 5, 'partial');
+        handleValueChange(clampValue(viewValue + 5), 'partial');
         event.preventDefault();
         break;
       case 'PageDown':
-        handleValueChange(viewValue - 5, 'partial');
+        handleValueChange(clampValue(viewValue - 5), 'partial');
         event.preventDefault();
         break;
       case 'Enter':
@@ -301,9 +304,7 @@ export function Clock(inProps) {
         onTouchEnd: handleTouchEnd,
         onMouseUp: handleMouseUp,
         onMouseMove: handleMouseMove,
-        ownerState: {
-          disabled
-        },
+        ownerState: ownerState,
         className: classes.squareMask
       }), !isSelectedTimeDisabled && /*#__PURE__*/_jsxs(React.Fragment, {
         children: [/*#__PURE__*/_jsx(ClockPin, {
@@ -312,7 +313,7 @@ export function Clock(inProps) {
           type: type,
           viewValue: viewValue,
           isInner: isPointerInner,
-          hasSelected: hasSelected
+          isBetweenTwoClockValues: isPointerBetweenTwoClockValues
         })]
       }), /*#__PURE__*/_jsx(ClockWrapper, {
         "aria-activedescendant": selectedId,

package/TimeClock/ClockNumber.js

@@ -1,21 +1,17 @@
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
 import _extends from "@babel/runtime/helpers/esm/extends";
-const _excluded = ["className", "disabled", "index", "inner", "label", "selected"];
+const _excluded = ["className", "classes", "disabled", "index", "inner", "label", "selected"];
 import * as React from 'react';
 import clsx from 'clsx';
 import { styled, useThemeProps } from '@mui/material/styles';
 import composeClasses from '@mui/utils/composeClasses';
 import { CLOCK_WIDTH, CLOCK_HOUR_WIDTH } from "./shared.js";
 import { getClockNumberUtilityClass, clockNumberClasses } from "./clockNumberClasses.js";
+import { usePickerPrivateContext } from "../internals/hooks/usePickerPrivateContext.js";
 import { jsx as _jsx } from "react/jsx-runtime";
-const useUtilityClasses = ownerState => {
-  const {
-    classes,
-    selected,
-    disabled
-  } = ownerState;
+const useUtilityClasses = (classes, ownerState) => {
   const slots = {
-    root: ['root', selected && 'selected', disabled && 'disabled']
+    root: ['root', ownerState.isClockNumberSelected && 'selected', ownerState.isClockNumberDisabled && 'disabled']
   };
   return composeClasses(slots, getClockNumberUtilityClass, classes);
 };
@@ -52,7 +48,7 @@ const ClockNumberRoot = styled('span', {
   },
   variants: [{
     props: {
-      inner: true
+      isClockNumberInInnerRing: true
     },
     style: _extends({}, theme.typography.body2, {
       color: (theme.vars || theme).palette.text.secondary
@@ -70,6 +66,7 @@ export function ClockNumber(inProps) {
   });
   const {
       className,
+      classes: classesProp,
       disabled,
       index,
       inner,
@@ -77,8 +74,15 @@ export function ClockNumber(inProps) {
       selected
     } = props,
     other = _objectWithoutPropertiesLoose(props, _excluded);
-  const ownerState = props;
-  const classes = useUtilityClasses(ownerState);
+  const {
+    ownerState: pickerOwnerState
+  } = usePickerPrivateContext();
+  const ownerState = _extends({}, pickerOwnerState, {
+    isClockNumberInInnerRing: inner,
+    isClockNumberSelected: selected,
+    isClockNumberDisabled: disabled
+  });
+  const classes = useUtilityClasses(classesProp, ownerState);
   const angle = index % 12 / 12 * Math.PI * 2 - Math.PI / 2;
   const length = (CLOCK_WIDTH - CLOCK_HOUR_WIDTH - 2) / 2 * (inner ? 0.65 : 1);
   const x = Math.round(Math.cos(angle) * length);

package/TimeClock/ClockPointer.d.ts

@@ -2,7 +2,12 @@ import * as React from 'react';
 import { TimeView } from '../models';
 import { ClockPointerClasses } from './clockPointerClasses';
 export interface ClockPointerProps extends React.HTMLAttributes<HTMLDivElement> {
-    hasSelected: boolean;
+    /**
+     * `true` if the pointer is between two clock values.
+     * On the `hours` view, it is always false.
+     * On the `minutes` view, it is true if the pointer is on a value that is not a multiple of 5.
+     */
+    isBetweenTwoClockValues: boolean;
     isInner: boolean;
     type: TimeView;
     viewValue: number;

package/TimeClock/ClockPointer.js

@@ -1,17 +1,17 @@
+'use client';
+
 import _extends from "@babel/runtime/helpers/esm/extends";
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-const _excluded = ["className", "hasSelected", "isInner", "type", "viewValue"];
+const _excluded = ["className", "classes", "isBetweenTwoClockValues", "isInner", "type", "viewValue"];
 import * as React from 'react';
 import clsx from 'clsx';
 import { styled, useThemeProps } from '@mui/material/styles';
 import composeClasses from '@mui/utils/composeClasses';
 import { CLOCK_WIDTH, CLOCK_HOUR_WIDTH } from "./shared.js";
 import { getClockPointerUtilityClass } from "./clockPointerClasses.js";
+import { usePickerPrivateContext } from "../internals/hooks/usePickerPrivateContext.js";
 import { jsx as _jsx } from "react/jsx-runtime";
-const useUtilityClasses = ownerState => {
-  const {
-    classes
-  } = ownerState;
+const useUtilityClasses = classes => {
   const slots = {
     root: ['root'],
     thumb: ['thumb']
@@ -33,7 +33,7 @@ const ClockPointerRoot = styled('div', {
   transformOrigin: 'center bottom 0px',
   variants: [{
     props: {
-      shouldAnimate: true
+      isClockPointerAnimated: true
     },
     style: {
       transition: theme.transitions.create(['transform', 'height'])
@@ -58,7 +58,7 @@ const ClockPointerThumb = styled('div', {
   boxSizing: 'content-box',
   variants: [{
     props: {
-      hasSelected: true
+      isBetweenTwoClockValues: false
     },
     style: {
       backgroundColor: (theme.vars || theme).palette.primary.main
@@ -76,6 +76,8 @@ export function ClockPointer(inProps) {
   });
   const {
       className,
+      classes: classesProp,
+      isBetweenTwoClockValues,
       isInner,
       type,
       viewValue
@@ -85,10 +87,14 @@ export function ClockPointer(inProps) {
   React.useEffect(() => {
     previousType.current = type;
   }, [type]);
-  const ownerState = _extends({}, props, {
-    shouldAnimate: previousType.current !== type
+  const {
+    ownerState: pickerOwnerState
+  } = usePickerPrivateContext();
+  const ownerState = _extends({}, pickerOwnerState, {
+    isClockPointerAnimated: previousType.current !== type,
+    isClockPointerBetweenTwoValues: isBetweenTwoClockValues
   });
-  const classes = useUtilityClasses(ownerState);
+  const classes = useUtilityClasses(classesProp);
   const getAngleStyle = () => {
     const max = type === 'hours' ? 12 : 60;
     let angle = 360 / max * viewValue;

package/TimeClock/TimeClock.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", "autoFocus", "slots", "slotProps", "value", "defaultValue", "referenceDate", "disableIgnoringDatePartForTimeValidation", "maxTime", "minTime", "disableFuture", "disablePast", "minutesStep", "shouldDisableTime", "showViewSwitcher", "onChange", "view", "views", "openTo", "onViewChange", "focusedView", "onFocusedViewChange", "className", "disabled", "readOnly", "timezone"];
+const _excluded = ["ampm", "ampmInClock", "autoFocus", "slots", "slotProps", "value", "defaultValue", "referenceDate", "disableIgnoringDatePartForTimeValidation", "maxTime", "minTime", "disableFuture", "disablePast", "minutesStep", "shouldDisableTime", "showViewSwitcher", "onChange", "view", "views", "openTo", "onViewChange", "focusedView", "onFocusedViewChange", "className", "classes", "disabled", "readOnly", "timezone"];
 import * as React from 'react';
 import clsx from 'clsx';
 import PropTypes from 'prop-types';
@@ -21,11 +21,9 @@ import { getHourNumbers, getMinutesNumbers } from "./ClockNumbers.js";
 import { useControlledValueWithTimezone } from "../internals/hooks/useValueWithTimezone.js";
 import { singleItemValueManager } from "../internals/utils/valueManagers.js";
 import { useClockReferenceDate } from "../internals/hooks/useClockReferenceDate.js";
+import { usePickerPrivateContext } from "../internals/hooks/usePickerPrivateContext.js";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-const useUtilityClasses = ownerState => {
-  const {
-    classes
-  } = ownerState;
+const useUtilityClasses = classes => {
   const slots = {
     root: ['root'],
     arrowSwitcher: ['arrowSwitcher']
@@ -93,6 +91,7 @@ export const TimeClock = /*#__PURE__*/React.forwardRef(function TimeClock(inProp
       focusedView,
       onFocusedViewChange,
       className,
+      classes: classesProp,
       disabled,
       readOnly,
       timezone: timezoneProp
@@ -107,6 +106,7 @@ export const TimeClock = /*#__PURE__*/React.forwardRef(function TimeClock(inProp
     timezone: timezoneProp,
     value: valueProp,
     defaultValue,
+    referenceDate: referenceDateProp,
     onChange,
     valueManager: singleItemValueManager
   });
@@ -119,6 +119,10 @@ export const TimeClock = /*#__PURE__*/React.forwardRef(function TimeClock(inProp
   });
   const translations = usePickerTranslations();
   const now = useNow(timezone);
+  const selectedId = useId();
+  const {
+    ownerState
+  } = usePickerPrivateContext();
   const {
     view,
     setView,
@@ -182,6 +186,9 @@ export const TimeClock = /*#__PURE__*/React.forwardRef(function TimeClock(inProp
         {
           const valueWithMeridiem = convertValueToMeridiem(rawValue, meridiemMode, ampm);
           const dateWithNewHours = utils.setHours(valueOrReferenceDate, valueWithMeridiem);
+          if (utils.getHours(dateWithNewHours) !== valueWithMeridiem) {
+            return true;
+          }
           const start = utils.setSeconds(utils.setMinutes(dateWithNewHours, 0), 0);
           const end = utils.setSeconds(utils.setMinutes(dateWithNewHours, 59), 59);
           return !containsValidTime({
@@ -213,7 +220,6 @@ export const TimeClock = /*#__PURE__*/React.forwardRef(function TimeClock(inProp
         throw new Error('not supported');
     }
   }, [ampm, valueOrReferenceDate, disableIgnoringDatePartForTimeValidation, maxTime, meridiemMode, minTime, minutesStep, shouldDisableTime, utils, disableFuture, disablePast, now, views]);
-  const selectedId = useId();
   const viewProps = React.useMemo(() => {
     switch (view) {
       case 'hours':
@@ -222,9 +228,20 @@ export const TimeClock = /*#__PURE__*/React.forwardRef(function TimeClock(inProp
             const valueWithMeridiem = convertValueToMeridiem(hourValue, meridiemMode, ampm);
             setValueAndGoToNextView(utils.setHours(valueOrReferenceDate, valueWithMeridiem), isFinish, 'hours');
           };
+          const viewValue = utils.getHours(valueOrReferenceDate);
+          let viewRange;
+          if (ampm) {
+            if (viewValue > 12) {
+              viewRange = [12, 23];
+            } else {
+              viewRange = [0, 11];
+            }
+          } else {
+            viewRange = [0, 23];
+          }
           return {
             onChange: handleHoursChange,
-            viewValue: utils.getHours(valueOrReferenceDate),
+            viewValue,
             children: getHourNumbers({
               value,
               utils,
@@ -233,7 +250,8 @@ export const TimeClock = /*#__PURE__*/React.forwardRef(function TimeClock(inProp
               getClockNumberText: translations.hoursClockNumberText,
               isDisabled: hourValue => disabled || isTimeDisabled(hourValue, 'hours'),
               selectedId
-            })
+            }),
+            viewRange
           };
         }
       case 'minutes':
@@ -252,7 +270,8 @@ export const TimeClock = /*#__PURE__*/React.forwardRef(function TimeClock(inProp
               getClockNumberText: translations.minutesClockNumberText,
               isDisabled: minuteValue => disabled || isTimeDisabled(minuteValue, 'minutes'),
               selectedId
-            })
+            }),
+            viewRange: [0, 59]
           };
         }
       case 'seconds':
@@ -271,15 +290,15 @@ export const TimeClock = /*#__PURE__*/React.forwardRef(function TimeClock(inProp
               getClockNumberText: translations.secondsClockNumberText,
               isDisabled: secondValue => disabled || isTimeDisabled(secondValue, 'seconds'),
               selectedId
-            })
+            }),
+            viewRange: [0, 59]
           };
         }
       default:
         throw new Error('You must provide the type for ClockView');
     }
   }, [view, utils, value, ampm, translations.hoursClockNumberText, translations.minutesClockNumberText, translations.secondsClockNumberText, meridiemMode, setValueAndGoToNextView, valueOrReferenceDate, isTimeDisabled, selectedId, disabled]);
-  const ownerState = props;
-  const classes = useUtilityClasses(ownerState);
+  const classes = useUtilityClasses(classesProp);
   return /*#__PURE__*/_jsxs(TimeClockRoot, _extends({
     ref: ref,
     className: clsx(classes.root, className),

package/TimeField/TimeField.js

@@ -1,18 +1,14 @@
 'use client';
 
-import _extends from "@babel/runtime/helpers/esm/extends";
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
 const _excluded = ["slots", "slotProps", "InputProps", "inputProps"];
 import * as React from 'react';
 import PropTypes from 'prop-types';
-import MuiTextField from '@mui/material/TextField';
 import { useThemeProps } from '@mui/material/styles';
-import useSlotProps from '@mui/utils/useSlotProps';
 import { refType } from '@mui/utils';
 import { useTimeField } from "./useTimeField.js";
-import { useClearableField } from "../hooks/index.js";
-import { PickersTextField } from "../PickersTextField/index.js";
-import { convertFieldResponseIntoMuiTextFieldProps } from "../internals/utils/convertFieldResponseIntoMuiTextFieldProps.js";
+import { PickerFieldUI, useFieldTextFieldProps } from "../internals/components/PickerFieldUI.js";
+import { ClockIcon } from "../icons/index.js";
 import { jsx as _jsx } from "react/jsx-runtime";
 /**
  * Demos:
@@ -31,33 +27,21 @@ const TimeField = /*#__PURE__*/React.forwardRef(function TimeField(inProps, inRe
   });
   const {
       slots,
-      slotProps,
-      InputProps,
-      inputProps
+      slotProps
     } = themeProps,
     other = _objectWithoutPropertiesLoose(themeProps, _excluded);
-  const ownerState = themeProps;
-  const TextField = slots?.textField ?? (inProps.enableAccessibleFieldDOMStructure === false ? MuiTextField : PickersTextField);
-  const textFieldProps = useSlotProps({
-    elementType: TextField,
-    externalSlotProps: slotProps?.textField,
-    externalForwardedProps: other,
-    ownerState,
-    additionalProps: {
-      ref: inRef
-    }
+  const textFieldProps = useFieldTextFieldProps({
+    slotProps,
+    ref: inRef,
+    externalForwardedProps: other
   });
-
-  // TODO: Remove when mui/material-ui#35088 will be merged
-  textFieldProps.inputProps = _extends({}, inputProps, textFieldProps.inputProps);
-  textFieldProps.InputProps = _extends({}, InputProps, textFieldProps.InputProps);
   const fieldResponse = useTimeField(textFieldProps);
-  const convertedFieldResponse = convertFieldResponseIntoMuiTextFieldProps(fieldResponse);
-  const processedFieldProps = useClearableField(_extends({}, convertedFieldResponse, {
-    slots,
-    slotProps
-  }));
-  return /*#__PURE__*/_jsx(TextField, _extends({}, processedFieldProps));
+  return /*#__PURE__*/_jsx(PickerFieldUI, {
+    slots: slots,
+    slotProps: slotProps,
+    fieldResponse: fieldResponse,
+    defaultOpenPickerIcon: ClockIcon
+  });
 });
 process.env.NODE_ENV !== "production" ? TimeField.propTypes = {
   // ----------------------------- Warning --------------------------------
@@ -80,6 +64,12 @@ process.env.NODE_ENV !== "production" ? TimeField.propTypes = {
    * @default false
    */
   clearable: PropTypes.bool,
+  /**
+   * The position at which the clear button is placed.
+   * If the field is not clearable, the button is not rendered.
+   * @default 'end'
+   */
+  clearButtonPosition: PropTypes.oneOf(['end', 'start']),
   /**
    * The color of the component.
    * It supports both default and custom theme colors, which can be added as shown in the
@@ -233,6 +223,12 @@ process.env.NODE_ENV !== "production" ? TimeField.propTypes = {
    * @param {FieldSelectedSections} newValue The new selected sections.
    */
   onSelectedSectionsChange: PropTypes.func,
+  /**
+   * The position at which the opening button is placed.
+   * If there is no picker to open, the button is not rendered
+   * @default 'end'
+   */
+  openPickerButtonPosition: PropTypes.oneOf(['end', 'start']),
   /**
    * If `true`, the component is read-only.
    * When read-only, the value cannot be changed but the user can interact with the interface.
@@ -268,10 +264,10 @@ process.env.NODE_ENV !== "production" ? TimeField.propTypes = {
    */
   shouldDisableTime: PropTypes.func,
   /**
-   * If `true`, the format will respect the leading zeroes (e.g: on dayjs, the format `M/D/YYYY` will render `8/16/2018`)
-   * If `false`, the format will always add leading zeroes (e.g: on dayjs, the format `M/D/YYYY` will render `08/16/2018`)
+   * If `true`, the format will respect the leading zeroes (for example on dayjs, the format `M/D/YYYY` will render `8/16/2018`)
+   * If `false`, the format will always add leading zeroes (for example on dayjs, the format `M/D/YYYY` will render `08/16/2018`)
    *
-   * Warning n°1: Luxon is not able to respect the leading zeroes when using macro tokens (e.g: "DD"), so `shouldRespectLeadingZeros={true}` might lead to inconsistencies when using `AdapterLuxon`.
+   * Warning n°1: Luxon is not able to respect the leading zeroes when using macro tokens (for example "DD"), so `shouldRespectLeadingZeros={true}` might lead to inconsistencies when using `AdapterLuxon`.
    *
    * Warning n°2: When `shouldRespectLeadingZeros={true}`, the field will add an invisible character on the sections containing a single digit to make sure `onChange` is fired.
    * If you need to get the clean value from the input, you can remove this character using `input.value.replace(/\u200e/g, '')`.

package/TimeField/TimeField.types.d.ts

@@ -1,13 +1,11 @@
-import * as React from 'react';
-import { SlotComponentProps } from '@mui/utils';
 import { MakeOptional } from '@mui/x-internals/types';
-import TextField from '@mui/material/TextField';
 import { UseFieldInternalProps } from '../internals/hooks/useField';
-import { FieldSection, PickerValidDate, TimeValidationError, BuiltInFieldTextFieldProps } from '../models';
-import { ExportedUseClearableFieldProps, UseClearableFieldSlots, UseClearableFieldSlotProps } from '../hooks/useClearableField';
+import { TimeValidationError, BuiltInFieldTextFieldProps } from '../models';
 import { ExportedValidateTimeProps } from '../validation/validateTime';
 import { AmPmProps } from '../internals/models/props/time';
-export interface UseTimeFieldProps<TEnableAccessibleFieldDOMStructure extends boolean> extends MakeOptional<UseFieldInternalProps<PickerValidDate | null, FieldSection, TEnableAccessibleFieldDOMStructure, TimeValidationError>, 'format'>, ExportedValidateTimeProps, ExportedUseClearableFieldProps, AmPmProps {
+import { PickerValue } from '../internals/models';
+import { ExportedPickerFieldUIProps, PickerFieldUISlotProps, PickerFieldUISlots } from '../internals/components/PickerFieldUI';
+export interface UseTimeFieldProps<TEnableAccessibleFieldDOMStructure extends boolean> extends MakeOptional<UseFieldInternalProps<PickerValue, TEnableAccessibleFieldDOMStructure, TimeValidationError>, 'format'>, ExportedValidateTimeProps, ExportedPickerFieldUIProps, AmPmProps {
 }
 export type TimeFieldProps<TEnableAccessibleFieldDOMStructure extends boolean = true> = UseTimeFieldProps<TEnableAccessibleFieldDOMStructure> & Omit<BuiltInFieldTextFieldProps<TEnableAccessibleFieldDOMStructure>, keyof UseTimeFieldProps<TEnableAccessibleFieldDOMStructure>> & {
     /**
@@ -19,16 +17,9 @@ export type TimeFieldProps<TEnableAccessibleFieldDOMStructure extends boolean =
      * The props used for each component slot.
      * @default {}
      */
-    slotProps?: TimeFieldSlotProps<TEnableAccessibleFieldDOMStructure>;
+    slotProps?: TimeFieldSlotProps;
 };
-export type TimeFieldOwnerState<TEnableAccessibleFieldDOMStructure extends boolean> = TimeFieldProps<TEnableAccessibleFieldDOMStructure>;
-export interface TimeFieldSlots extends UseClearableFieldSlots {
-    /**
-     * Form control with an input to render the value.
-     * @default TextField from '@mui/material' or PickersTextField if `enableAccessibleFieldDOMStructure` is `true`.
-     */
-    textField?: React.ElementType;
+export interface TimeFieldSlots extends PickerFieldUISlots {
 }
-export interface TimeFieldSlotProps<TEnableAccessibleFieldDOMStructure extends boolean> extends UseClearableFieldSlotProps {
-    textField?: SlotComponentProps<typeof TextField, {}, TimeFieldOwnerState<TEnableAccessibleFieldDOMStructure>>;
+export interface TimeFieldSlotProps extends PickerFieldUISlotProps {
 }