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

package/SingleInputTimeRangeField/SingleInputTimeRangeField.js

@@ -1,16 +1,12 @@
 'use client';
 
-import _extends from "@babel/runtime/helpers/esm/extends";
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-const _excluded = ["slots", "slotProps", "InputProps", "inputProps"];
+const _excluded = ["slots", "slotProps"];
 import * as React from 'react';
 import PropTypes from 'prop-types';
-import MuiTextField from '@mui/material/TextField';
-import { useClearableField } from '@mui/x-date-pickers/hooks';
-import { convertFieldResponseIntoMuiTextFieldProps } from '@mui/x-date-pickers/internals';
-import { PickersTextField } from '@mui/x-date-pickers/PickersTextField';
+import { ClockIcon } from '@mui/x-date-pickers/icons';
+import { PickerFieldUI, useFieldTextFieldProps } from '@mui/x-date-pickers/internals';
 import { useThemeProps } from '@mui/material/styles';
-import useSlotProps from '@mui/utils/useSlotProps';
 import { refType } from '@mui/utils';
 import { useSingleInputTimeRangeField } from "./useSingleInputTimeRangeField.js";
 import { jsx as _jsx } from "react/jsx-runtime";
@@ -31,33 +27,21 @@ const SingleInputTimeRangeField = /*#__PURE__*/React.forwardRef(function SingleI
   });
   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 = useSingleInputTimeRangeField(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
+  });
 });
 SingleInputTimeRangeField.fieldType = 'single-input';
 process.env.NODE_ENV !== "production" ? SingleInputTimeRangeField.propTypes = {
@@ -81,6 +65,12 @@ process.env.NODE_ENV !== "production" ? SingleInputTimeRangeField.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
@@ -274,10 +264,10 @@ process.env.NODE_ENV !== "production" ? SingleInputTimeRangeField.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/SingleInputTimeRangeField/SingleInputTimeRangeField.types.d.ts

@@ -1,12 +1,7 @@
-import * as React from 'react';
-import { SlotComponentProps } from '@mui/utils';
-import TextField from '@mui/material/TextField';
-import { PickerRangeValue, UseFieldInternalProps } from '@mui/x-date-pickers/internals';
+import { ExportedPickerFieldUIProps, PickerFieldUISlots, PickerFieldUISlotProps } from '@mui/x-date-pickers/internals';
 import { BuiltInFieldTextFieldProps } from '@mui/x-date-pickers/models';
-import { ExportedUseClearableFieldProps, UseClearableFieldSlots, UseClearableFieldSlotProps } from '@mui/x-date-pickers/hooks';
-import { UseTimeRangeFieldProps } from '../internals/models';
-import { RangeFieldSection, TimeRangeValidationError } from '../models';
-export interface UseSingleInputTimeRangeFieldProps<TEnableAccessibleFieldDOMStructure extends boolean> extends UseTimeRangeFieldProps<TEnableAccessibleFieldDOMStructure>, ExportedUseClearableFieldProps, Pick<UseFieldInternalProps<PickerRangeValue, RangeFieldSection, TEnableAccessibleFieldDOMStructure, TimeRangeValidationError>, 'unstableFieldRef'> {
+import { TimeRangeManagerFieldInternalProps } from '../managers/useTimeRangeManager';
+export interface UseSingleInputTimeRangeFieldProps<TEnableAccessibleFieldDOMStructure extends boolean> extends TimeRangeManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure>, Omit<ExportedPickerFieldUIProps, 'openPickerButtonPosition'> {
 }
 export type SingleInputTimeRangeFieldProps<TEnableAccessibleFieldDOMStructure extends boolean = true> = Omit<BuiltInFieldTextFieldProps<TEnableAccessibleFieldDOMStructure>, keyof UseSingleInputTimeRangeFieldProps<TEnableAccessibleFieldDOMStructure>> & UseSingleInputTimeRangeFieldProps<TEnableAccessibleFieldDOMStructure> & {
     /**
@@ -18,15 +13,9 @@ export type SingleInputTimeRangeFieldProps<TEnableAccessibleFieldDOMStructure ex
      * The props used for each component slot.
      * @default {}
      */
-    slotProps?: SingleInputTimeRangeFieldSlotProps<TEnableAccessibleFieldDOMStructure>;
+    slotProps?: SingleInputTimeRangeFieldSlotProps;
 };
-export interface SingleInputTimeRangeFieldSlots 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 SingleInputTimeRangeFieldSlots extends PickerFieldUISlots {
 }
-export interface SingleInputTimeRangeFieldSlotProps<TEnableAccessibleFieldDOMStructure extends boolean> extends UseClearableFieldSlotProps {
-    textField?: SlotComponentProps<typeof TextField, {}, SingleInputTimeRangeFieldProps<TEnableAccessibleFieldDOMStructure>>;
+export interface SingleInputTimeRangeFieldSlotProps extends PickerFieldUISlotProps {
 }

package/SingleInputTimeRangeField/useSingleInputTimeRangeField.d.ts

@@ -1,2 +1,2 @@
 import { UseSingleInputTimeRangeFieldProps } from './SingleInputTimeRangeField.types';
-export declare const useSingleInputTimeRangeField: <TEnableAccessibleFieldDOMStructure extends boolean, TAllProps extends UseSingleInputTimeRangeFieldProps<TEnableAccessibleFieldDOMStructure>>(inProps: TAllProps) => import("@mui/x-date-pickers/internals").UseFieldResponse<TEnableAccessibleFieldDOMStructure, Omit<TAllProps & Omit<UseSingleInputTimeRangeFieldProps<TEnableAccessibleFieldDOMStructure>, keyof import("@mui/x-date-pickers/internals/hooks/defaultizedFieldProps").UseDefaultizedTimeFieldBaseProps> & Required<Pick<UseSingleInputTimeRangeFieldProps<TEnableAccessibleFieldDOMStructure>, keyof import("@mui/x-date-pickers/internals/hooks/defaultizedFieldProps").UseDefaultizedTimeFieldBaseProps>>, "disabled" | "format" | "onChange" | "onError" | "defaultValue" | "value" | "readOnly" | "formatDensity" | "enableAccessibleFieldDOMStructure" | "selectedSections" | "onSelectedSectionsChange" | "timezone" | "unstableFieldRef" | "referenceDate" | "shouldRespectLeadingZeros" | "ampm" | keyof import("@mui/x-date-pickers/internals").BaseTimeValidationProps | keyof import("@mui/x-date-pickers/internals").TimeValidationProps | "dateSeparator">>;
+export declare const useSingleInputTimeRangeField: <TEnableAccessibleFieldDOMStructure extends boolean, TAllProps extends UseSingleInputTimeRangeFieldProps<TEnableAccessibleFieldDOMStructure>>(props: TAllProps) => import("@mui/x-date-pickers/internals").UseFieldResponse<TEnableAccessibleFieldDOMStructure, Omit<TAllProps, "disabled" | "readOnly" | "value" | "defaultValue" | "autoFocus" | "onChange" | "onError" | "format" | "unstableFieldRef" | "referenceDate" | "formatDensity" | "shouldRespectLeadingZeros" | "selectedSections" | "onSelectedSectionsChange" | "enableAccessibleFieldDOMStructure" | "timezone" | "ampm" | keyof import("@mui/x-date-pickers/internals").BaseTimeValidationProps | keyof import("@mui/x-date-pickers/internals").TimeValidationProps | "unstableStartFieldRef" | "unstableEndFieldRef" | "dateSeparator">>;

package/SingleInputTimeRangeField/useSingleInputTimeRangeField.js

@@ -1,25 +1,25 @@
 'use client';
 
-import * as React from 'react';
-import { useField, useDefaultizedTimeField } from '@mui/x-date-pickers/internals';
+import { useField, useFieldInternalPropsWithDefaults } from '@mui/x-date-pickers/internals';
 import { useSplitFieldProps } from '@mui/x-date-pickers/hooks';
-import { rangeValueManager, getRangeFieldValueManager } from "../internals/utils/valueManagers.js";
-import { validateTimeRange } from "../validation/index.js";
-export const useSingleInputTimeRangeField = inProps => {
-  const props = useDefaultizedTimeField(inProps);
+import { useTimeRangeManager } from "../managers/index.js";
+export const useSingleInputTimeRangeField = props => {
+  const manager = useTimeRangeManager(props);
   const {
     forwardedProps,
     internalProps
   } = useSplitFieldProps(props, 'time');
-  const fieldValueManager = React.useMemo(() => getRangeFieldValueManager({
-    dateSeparator: internalProps.dateSeparator
-  }), [internalProps.dateSeparator]);
+  const internalPropsWithDefaults = useFieldInternalPropsWithDefaults({
+    manager,
+    internalProps
+  });
   return useField({
     forwardedProps,
-    internalProps,
-    valueManager: rangeValueManager,
-    fieldValueManager,
-    validator: validateTimeRange,
-    valueType: 'time'
+    internalProps: internalPropsWithDefaults,
+    valueManager: manager.internal_valueManager,
+    fieldValueManager: manager.internal_fieldValueManager,
+    validator: manager.validator,
+    valueType: manager.valueType,
+    getOpenPickerButtonAriaLabel: manager.internal_getOpenPickerButtonAriaLabel
   });
 };

package/StaticDateRangePicker/StaticDateRangePicker.js

@@ -41,11 +41,11 @@ const StaticDateRangePicker = /*#__PURE__*/React.forwardRef(function StaticDateR
   const {
     renderPicker
   } = useStaticRangePicker({
+    ref,
     props,
     valueManager: rangeValueManager,
     valueType: 'date',
-    validator: validateDateRange,
-    ref
+    validator: validateDateRange
   });
   return renderPicker();
 });

package/StaticDateRangePicker/StaticDateRangePicker.types.d.ts

@@ -1,9 +1,9 @@
 import { MakeOptional } from '@mui/x-internals/types';
 import { StaticRangeOnlyPickerProps, UseStaticRangePickerSlots, UseStaticRangePickerSlotProps } from '../internals/hooks/useStaticRangePicker';
 import { BaseDateRangePickerProps, BaseDateRangePickerSlots, BaseDateRangePickerSlotProps } from '../DateRangePicker/shared';
-export interface StaticDateRangePickerSlots extends BaseDateRangePickerSlots, UseStaticRangePickerSlots<'day'> {
+export interface StaticDateRangePickerSlots extends BaseDateRangePickerSlots, UseStaticRangePickerSlots {
 }
-export interface StaticDateRangePickerSlotProps extends BaseDateRangePickerSlotProps, Omit<UseStaticRangePickerSlotProps<'day'>, 'toolbar'> {
+export interface StaticDateRangePickerSlotProps extends BaseDateRangePickerSlotProps, Omit<UseStaticRangePickerSlotProps, 'toolbar'> {
 }
 export interface StaticDateRangePickerProps extends BaseDateRangePickerProps, MakeOptional<StaticRangeOnlyPickerProps, 'displayStaticWrapperAs'> {
     /**

package/dateRangeViewRenderers/dateRangeViewRenderers.d.ts

@@ -1,11 +1,11 @@
 import * as React from 'react';
 import { DateOrTimeViewWithMeridiem } from '@mui/x-date-pickers/internals';
 import { DateRangeCalendarProps } from '../DateRangeCalendar';
-export interface DateRangeViewRendererProps<TView extends DateOrTimeViewWithMeridiem> extends Omit<DateRangeCalendarProps, 'views'> {
+export interface DateRangeViewRendererProps<TView extends DateOrTimeViewWithMeridiem> extends Omit<DateRangeCalendarProps, 'views' | 'onRangePositionChange' | 'rangePosition' | 'defaultRangePosition'> {
     views: readonly TView[];
 }
 /**
  * We don't pass all the props down to `DateRangeCalendar`,
  * because otherwise some unwanted props would be passed to the HTML element.
  */
-export declare const renderDateRangeViewCalendar: ({ value, defaultValue, referenceDate, onChange, className, classes, disableFuture, disablePast, minDate, maxDate, shouldDisableDate, reduceAnimations, onMonthChange, rangePosition, defaultRangePosition, onRangePositionChange, calendars, currentMonthCalendarPosition, slots, slotProps, loading, renderLoading, disableHighlightToday, readOnly, disabled, showDaysOutsideCurrentMonth, dayOfWeekFormatter, disableAutoMonthSwitching, sx, autoFocus, fixedWeekNumber, disableDragEditing, displayWeekNumber, timezone, availableRangePositions, views, view, onViewChange, }: DateRangeViewRendererProps<"day">) => React.JSX.Element;
+export declare const renderDateRangeViewCalendar: ({ value, defaultValue, referenceDate, onChange, className, classes, disableFuture, disablePast, minDate, maxDate, shouldDisableDate, reduceAnimations, onMonthChange, calendars, currentMonthCalendarPosition, slots, slotProps, loading, renderLoading, disableHighlightToday, readOnly, disabled, showDaysOutsideCurrentMonth, dayOfWeekFormatter, disableAutoMonthSwitching, sx, autoFocus, fixedWeekNumber, disableDragEditing, displayWeekNumber, timezone, availableRangePositions, views, view, onViewChange, }: DateRangeViewRendererProps<"day">) => React.JSX.Element;

package/dateRangeViewRenderers/dateRangeViewRenderers.js

@@ -19,9 +19,6 @@ export const renderDateRangeViewCalendar = ({
   shouldDisableDate,
   reduceAnimations,
   onMonthChange,
-  rangePosition,
-  defaultRangePosition,
-  onRangePositionChange,
   calendars,
   currentMonthCalendarPosition,
   slots,
@@ -58,9 +55,6 @@ export const renderDateRangeViewCalendar = ({
   shouldDisableDate: shouldDisableDate,
   reduceAnimations: reduceAnimations,
   onMonthChange: onMonthChange,
-  rangePosition: rangePosition,
-  defaultRangePosition: defaultRangePosition,
-  onRangePositionChange: onRangePositionChange,
   calendars: calendars,
   currentMonthCalendarPosition: currentMonthCalendarPosition,
   slots: slots,

package/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export { usePickerRangePositionContext } from './usePickerRangePositionContext';
+export { useMultiInputRangeField as unstable_useMultiInputRangeField } from './useMultiInputRangeField';

package/hooks/index.js

@@ -0,0 +1,2 @@
+export { usePickerRangePositionContext } from "./usePickerRangePositionContext.js";
+export { useMultiInputRangeField as unstable_useMultiInputRangeField } from "./useMultiInputRangeField/index.js";

package/hooks/package.json

@@ -0,0 +1,6 @@
+{
+  "sideEffects": false,
+  "module": "./index.js",
+  "main": "../node/hooks/index.js",
+  "types": "./index.d.ts"
+}

package/hooks/useMultiInputRangeField/index.d.ts

@@ -0,0 +1 @@
+export { useMultiInputRangeField } from './useMultiInputRangeField';

package/hooks/useMultiInputRangeField/index.js

@@ -0,0 +1 @@
+export { useMultiInputRangeField } from "./useMultiInputRangeField.js";

package/hooks/useMultiInputRangeField/useMultiInputRangeField.d.ts

@@ -0,0 +1,53 @@
+import { PickerManagerEnableAccessibleFieldDOMStructure, PickerManagerFieldInternalProps, UseFieldResponse } from '@mui/x-date-pickers/internals';
+import { PickerAnyRangeManager } from '../../internals/models/managers';
+/**
+ * Basic example:
+ *
+ * ```tsx
+ * import Box from '@mui/material/Box';
+ * import { useSplitFieldProps } from '@mui/x-date-pickers/hooks';
+ * import { PickersTextField } from '@mui/x-date-pickers/PickersTextField';
+ * import { useDateRangeManager } from '@mui/x-date-pickers-pro/managers';
+ *
+ * function MultiInputField(props) {
+ *   const manager = useDateRangeManager();
+ *   const { internalProps, forwardedProps } = useSplitFieldProps(props, 'date');
+ *   const { startDate, endDate } = useMultiInputRangeField({
+ *     manager,
+ *     internalProps,
+ *     startForwardedProps: forwardedProps,
+ *     endForwardedProps: forwardedProps,
+ *   });
+ *
+ *   return (
+ *     <Box {...forwardedProps}>
+ *       <PickersTextField {...startDate} />
+ *       <span>{' – '}</span>
+ *       <PickersTextField {...endDate} />
+ *     </Box>
+ *   );
+ * }
+ * ```
+ *
+ * @param {UseMultiInputRangeFieldParameters<TManager, TForwardedProps>} parameters The parameters of the hook.
+ * @param {TManager} parameters.manager The manager of the field.
+ * @param {PickerManagerFieldInternalProps<TManager>} parameters.internalProps The internal props of the field.
+ * @param {TForwardedProps} parameters.startForwardedProps The forwarded props of the start field.
+ * @param {TForwardedProps} parameters.endForwardedProps The forwarded props of the end field.
+ * @returns {UseMultiInputRangeFieldReturnValue<TManager, TForwardedProps>} The props to pass to the start and the end components.
+ */
+export declare function useMultiInputRangeField<TManager extends PickerAnyRangeManager, TForwardedProps extends {
+    [key: string]: any;
+}>(parameters: UseMultiInputRangeFieldParameters<TManager, TForwardedProps>): UseMultiInputRangeFieldReturnValue<TManager, TForwardedProps>;
+interface UseMultiInputRangeFieldParameters<TManager extends PickerAnyRangeManager, TForwardedProps extends {}> {
+    manager: TManager;
+    internalProps: PickerManagerFieldInternalProps<TManager>;
+    startForwardedProps: TForwardedProps;
+    endForwardedProps: TForwardedProps;
+}
+interface UseMultiInputRangeFieldReturnValue<TManager extends PickerAnyRangeManager, TForwardedProps extends {}> {
+    startDate: Omit<UseFieldResponse<PickerManagerEnableAccessibleFieldDOMStructure<TManager>, TForwardedProps>, 'clearable' | 'onClear'>;
+    endDate: Omit<UseFieldResponse<PickerManagerEnableAccessibleFieldDOMStructure<TManager>, TForwardedProps>, 'clearable' | 'onClear'>;
+    enableAccessibleFieldDOMStructure: PickerManagerEnableAccessibleFieldDOMStructure<TManager>;
+}
+export {};

package/hooks/useMultiInputRangeField/useMultiInputRangeField.js

@@ -0,0 +1,149 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import useEventCallback from '@mui/utils/useEventCallback';
+import { useControlledValueWithTimezone, useFieldInternalPropsWithDefaults } from '@mui/x-date-pickers/internals';
+import { useValidation } from '@mui/x-date-pickers/validation';
+import { useMultiInputRangeFieldTextFieldProps } from "./useMultiInputRangeFieldTextFieldProps.js";
+import { useMultiInputRangeFieldSelectedSections } from "./useMultiInputRangeFieldSelectedSections.js";
+/**
+ * Basic example:
+ *
+ * ```tsx
+ * import Box from '@mui/material/Box';
+ * import { useSplitFieldProps } from '@mui/x-date-pickers/hooks';
+ * import { PickersTextField } from '@mui/x-date-pickers/PickersTextField';
+ * import { useDateRangeManager } from '@mui/x-date-pickers-pro/managers';
+ *
+ * function MultiInputField(props) {
+ *   const manager = useDateRangeManager();
+ *   const { internalProps, forwardedProps } = useSplitFieldProps(props, 'date');
+ *   const { startDate, endDate } = useMultiInputRangeField({
+ *     manager,
+ *     internalProps,
+ *     startForwardedProps: forwardedProps,
+ *     endForwardedProps: forwardedProps,
+ *   });
+ *
+ *   return (
+ *     <Box {...forwardedProps}>
+ *       <PickersTextField {...startDate} />
+ *       <span>{' – '}</span>
+ *       <PickersTextField {...endDate} />
+ *     </Box>
+ *   );
+ * }
+ * ```
+ *
+ * @param {UseMultiInputRangeFieldParameters<TManager, TForwardedProps>} parameters The parameters of the hook.
+ * @param {TManager} parameters.manager The manager of the field.
+ * @param {PickerManagerFieldInternalProps<TManager>} parameters.internalProps The internal props of the field.
+ * @param {TForwardedProps} parameters.startForwardedProps The forwarded props of the start field.
+ * @param {TForwardedProps} parameters.endForwardedProps The forwarded props of the end field.
+ * @returns {UseMultiInputRangeFieldReturnValue<TManager, TForwardedProps>} The props to pass to the start and the end components.
+ */
+export function useMultiInputRangeField(parameters) {
+  const {
+    manager,
+    internalProps,
+    startForwardedProps,
+    endForwardedProps
+  } = parameters;
+  const internalPropsWithDefaults = useFieldInternalPropsWithDefaults({
+    manager,
+    internalProps
+  });
+  const {
+    value: valueProp,
+    defaultValue,
+    format,
+    formatDensity,
+    shouldRespectLeadingZeros,
+    onChange,
+    disabled,
+    readOnly,
+    selectedSections,
+    onSelectedSectionsChange,
+    timezone: timezoneProp,
+    enableAccessibleFieldDOMStructure,
+    autoFocus,
+    referenceDate,
+    unstableStartFieldRef,
+    unstableEndFieldRef
+  } = internalPropsWithDefaults;
+  const {
+    value,
+    handleValueChange,
+    timezone
+  } = useControlledValueWithTimezone({
+    name: 'useMultiInputRangeField',
+    timezone: timezoneProp,
+    value: valueProp,
+    defaultValue,
+    referenceDate,
+    onChange,
+    valueManager: manager.internal_valueManager
+  });
+  const {
+    validationError,
+    getValidationErrorForNewValue
+  } = useValidation({
+    props: internalPropsWithDefaults,
+    value,
+    timezone,
+    validator: manager.validator,
+    onError: internalPropsWithDefaults.onError
+  });
+  const buildChangeHandler = index => {
+    return (newSingleValue, rawContext) => {
+      const newRange = index === 0 ? [newSingleValue, value[1]] : [value[0], newSingleValue];
+      const context = _extends({}, rawContext, {
+        validationError: getValidationErrorForNewValue(newRange)
+      });
+      handleValueChange(newRange, context);
+    };
+  };
+  const handleStartDateChange = useEventCallback(buildChangeHandler(0));
+  const handleEndDateChange = useEventCallback(buildChangeHandler(1));
+  const selectedSectionsResponse = useMultiInputRangeFieldSelectedSections({
+    selectedSections,
+    onSelectedSectionsChange,
+    unstableStartFieldRef,
+    unstableEndFieldRef
+  });
+  const sharedProps = {
+    disabled,
+    readOnly,
+    timezone,
+    format,
+    formatDensity,
+    shouldRespectLeadingZeros,
+    enableAccessibleFieldDOMStructure
+  };
+  const startDateProps = useMultiInputRangeFieldTextFieldProps({
+    valueType: manager.valueType,
+    fieldProps: _extends({
+      error: !!validationError[0]
+    }, startForwardedProps, selectedSectionsResponse.start, sharedProps, {
+      value: valueProp === undefined ? undefined : valueProp[0],
+      defaultValue: defaultValue === undefined ? undefined : defaultValue[0],
+      onChange: handleStartDateChange,
+      autoFocus // Do not add on end field.
+    })
+  });
+  const endDateProps = useMultiInputRangeFieldTextFieldProps({
+    valueType: manager.valueType,
+    fieldProps: _extends({
+      error: !!validationError[1]
+    }, endForwardedProps, selectedSectionsResponse.end, sharedProps, {
+      value: valueProp === undefined ? undefined : valueProp[1],
+      defaultValue: defaultValue === undefined ? undefined : defaultValue[1],
+      onChange: handleEndDateChange
+    })
+  });
+  return {
+    startDate: startDateProps,
+    endDate: endDateProps,
+    enableAccessibleFieldDOMStructure
+  };
+}

package/hooks/useMultiInputRangeField/useMultiInputRangeFieldSelectedSections.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { PickerRangeValue, PickerValue, UseFieldInternalProps } from '@mui/x-date-pickers/internals';
+import { FieldRef, FieldSelectedSections } from '@mui/x-date-pickers/models';
+import { MultiInputFieldRefs } from '../../models';
+interface UseMultiInputRangeFieldSelectedSectionsParameters extends Pick<UseFieldInternalProps<PickerRangeValue, any, any>, 'selectedSections' | 'onSelectedSectionsChange'>, MultiInputFieldRefs {
+}
+interface UseMultiInputFieldSelectedSectionsResponseItem {
+    unstableFieldRef?: React.Ref<FieldRef<PickerValue>>;
+    selectedSections: FieldSelectedSections;
+    onSelectedSectionsChange: (newSelectedSections: FieldSelectedSections) => void;
+}
+interface UseMultiInputFieldSelectedSectionsResponse {
+    start: UseMultiInputFieldSelectedSectionsResponseItem;
+    end: UseMultiInputFieldSelectedSectionsResponseItem;
+}
+export declare const useMultiInputRangeFieldSelectedSections: (parameters: UseMultiInputRangeFieldSelectedSectionsParameters) => UseMultiInputFieldSelectedSectionsResponse;
+export {};

package/{modern/internals/hooks/useMultiInputFieldSelectedSections.js → hooks/useMultiInputRangeField/useMultiInputRangeFieldSelectedSections.js}

@@ -1,10 +1,12 @@
+'use client';
+
 import * as React from 'react';
 import useForkRef from '@mui/utils/useForkRef';
 import useEventCallback from '@mui/utils/useEventCallback';
-export const useMultiInputFieldSelectedSections = params => {
+export const useMultiInputRangeFieldSelectedSections = parameters => {
   const unstableEndFieldRef = React.useRef(null);
-  const handleUnstableEndFieldRef = useForkRef(params.unstableEndFieldRef, unstableEndFieldRef);
-  const [startSelectedSection, setStartSelectedSection] = React.useState(params.selectedSections ?? null);
+  const handleUnstableEndFieldRef = useForkRef(parameters.unstableEndFieldRef, unstableEndFieldRef);
+  const [startSelectedSection, setStartSelectedSection] = React.useState(parameters.selectedSections ?? null);
   const [endSelectedSection, setEndSelectedSection] = React.useState(null);
   const getActiveField = () => {
     if (unstableEndFieldRef.current && unstableEndFieldRef.current.isFieldFocused()) {
@@ -15,25 +17,25 @@ export const useMultiInputFieldSelectedSections = params => {
   const handleStartSelectedSectionChange = useEventCallback(newSelectedSections => {
     setStartSelectedSection(newSelectedSections);
     if (getActiveField() === 'start') {
-      params.onSelectedSectionsChange?.(newSelectedSections);
+      parameters.onSelectedSectionsChange?.(newSelectedSections);
     }
   });
   const handleEndSelectedSectionChange = useEventCallback(newSelectedSections => {
     setEndSelectedSection(newSelectedSections);
     if (getActiveField() === 'end') {
-      params.onSelectedSectionsChange?.(newSelectedSections);
+      parameters.onSelectedSectionsChange?.(newSelectedSections);
     }
   });
   const activeField = getActiveField();
   return {
     start: {
-      unstableFieldRef: params.unstableStartFieldRef,
-      selectedSections: activeField === 'start' && params.selectedSections !== undefined ? params.selectedSections : startSelectedSection,
+      unstableFieldRef: parameters.unstableStartFieldRef,
+      selectedSections: activeField === 'start' && parameters.selectedSections !== undefined ? parameters.selectedSections : startSelectedSection,
       onSelectedSectionsChange: handleStartSelectedSectionChange
     },
     end: {
       unstableFieldRef: handleUnstableEndFieldRef,
-      selectedSections: activeField === 'end' && params.selectedSections !== undefined ? params.selectedSections : endSelectedSection,
+      selectedSections: activeField === 'end' && parameters.selectedSections !== undefined ? parameters.selectedSections : endSelectedSection,
       onSelectedSectionsChange: handleEndSelectedSectionChange
     }
   };

package/hooks/useMultiInputRangeField/useMultiInputRangeFieldTextFieldProps.d.ts

@@ -0,0 +1,17 @@
+import { UseDateManagerReturnValue, UseDateTimeManagerReturnValue, UseTimeManagerReturnValue } from '@mui/x-date-pickers/managers';
+import { PickerValueType } from '@mui/x-date-pickers/models';
+import { PickerManagerEnableAccessibleFieldDOMStructure, PickerManagerFieldInternalProps, UseFieldResponse } from '@mui/x-date-pickers/internals';
+import { PickerAnyRangeManager } from '../../internals/models/managers';
+import { UseDateRangeManagerReturnValue, UseDateTimeRangeManagerReturnValue, UseTimeRangeManagerReturnValue } from '../../managers';
+/**
+ * @ignore - internal hook.
+ */
+export declare function useMultiInputRangeFieldTextFieldProps<TManager extends PickerAnyRangeManager, TForwardedProps extends {
+    [key: string]: any;
+}>(parameters: UseMultiInputRangeFieldTextFieldProps<TManager>): Omit<UseFieldResponse<PickerManagerEnableAccessibleFieldDOMStructure<TManager>, TForwardedProps>, "clearable" | "onClear">;
+interface UseMultiInputRangeFieldTextFieldProps<TManager extends PickerAnyRangeManager> {
+    valueType: PickerValueType;
+    fieldProps: PickerManagerFieldInternalProps<GetDerivedManager<TManager>>;
+}
+type GetDerivedManager<TManager extends PickerAnyRangeManager> = TManager extends UseDateRangeManagerReturnValue<infer TEnableAccessibleFieldDOMStructure> ? UseDateManagerReturnValue<TEnableAccessibleFieldDOMStructure> : TManager extends UseTimeRangeManagerReturnValue<infer TEnableAccessibleFieldDOMStructure> ? UseTimeManagerReturnValue<TEnableAccessibleFieldDOMStructure> : TManager extends UseDateTimeRangeManagerReturnValue<infer TEnableAccessibleFieldDOMStructure> ? UseDateTimeManagerReturnValue<TEnableAccessibleFieldDOMStructure> : never;
+export {};

package/hooks/useMultiInputRangeField/useMultiInputRangeFieldTextFieldProps.js

@@ -0,0 +1,59 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["clearable", "onClear"];
+import { useDateManager, useDateTimeManager, useTimeManager } from '@mui/x-date-pickers/managers';
+import { useSplitFieldProps } from '@mui/x-date-pickers/hooks';
+import { useField, useFieldInternalPropsWithDefaults } from '@mui/x-date-pickers/internals';
+/**
+ * @ignore - internal hook.
+ */
+export function useMultiInputRangeFieldTextFieldProps(parameters) {
+  const {
+    fieldProps,
+    valueType
+  } = parameters;
+  let useManager;
+  switch (valueType) {
+    case 'date':
+      {
+        useManager = useDateManager;
+        break;
+      }
+    case 'time':
+      {
+        useManager = useTimeManager;
+        break;
+      }
+    case 'date-time':
+      {
+        useManager = useDateTimeManager;
+        break;
+      }
+    default:
+      {
+        throw new Error(`Unknown valueType: ${valueType}`);
+      }
+  }
+  const manager = useManager({
+    enableAccessibleFieldDOMStructure: fieldProps.enableAccessibleFieldDOMStructure
+  });
+  const {
+    forwardedProps,
+    internalProps
+  } = useSplitFieldProps(fieldProps, 'date');
+  const internalPropsWithDefaults = useFieldInternalPropsWithDefaults({
+    manager,
+    internalProps
+  });
+  const _ref = useField({
+      forwardedProps,
+      internalProps: internalPropsWithDefaults,
+      valueManager: manager.internal_valueManager,
+      fieldValueManager: manager.internal_fieldValueManager,
+      validator: manager.validator,
+      valueType: manager.valueType,
+      // TODO v8: Add a real aria label before moving the opening logic to the field on range pickers.
+      getOpenPickerButtonAriaLabel: () => ''
+    }),
+    fieldResponse = _objectWithoutPropertiesLoose(_ref, _excluded);
+  return fieldResponse;
+}

package/hooks/usePickerRangePositionContext.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import { UseRangePositionResponse } from '../internals/hooks/useRangePosition';
+export declare const PickerRangePositionContext: React.Context<UseRangePositionResponse | null>;
+/**
+ * Returns information about the range position of the picker that wraps the current component.
+ */
+export declare function usePickerRangePositionContext(): UseRangePositionResponse;

package/hooks/usePickerRangePositionContext.js

@@ -0,0 +1,15 @@
+'use client';
+
+import * as React from 'react';
+export const PickerRangePositionContext = /*#__PURE__*/React.createContext(null);
+
+/**
+ * Returns information about the range position of the picker that wraps the current component.
+ */
+export function usePickerRangePositionContext() {
+  const value = React.useContext(PickerRangePositionContext);
+  if (value == null) {
+    throw new Error(['MUI X: The `usePickerRangePositionContext` can only be called in components that are used inside a picker component'].join('\n'));
+  }
+  return value;
+}