@mui/x-date-pickers-pro 8.0.0-alpha.12 → 8.0.0-alpha.13

package/modern/hooks/useMultiInputRangeField/useTextFieldProps.js

@@ -0,0 +1,141 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _extends from "@babel/runtime/helpers/esm/extends";
+const _excluded = ["clearable", "onClear", "openPickerAriaLabel"];
+import * as React from 'react';
+import useEventCallback from '@mui/utils/useEventCallback';
+import { useDateManager, useDateTimeManager, useTimeManager } from '@mui/x-date-pickers/managers';
+import { useSplitFieldProps } from '@mui/x-date-pickers/hooks';
+import { useField, useFieldInternalPropsWithDefaults, useNullableFieldPrivateContext, useNullablePickerContext, usePickerPrivateContext } from '@mui/x-date-pickers/internals';
+import { useNullablePickerRangePositionContext } from "../../internals/hooks/useNullablePickerRangePositionContext.js";
+/**
+ * @ignore - internal hook.
+ */
+export function useTextFieldProps(parameters) {
+  const pickerContext = useNullablePickerContext();
+  const fieldPrivateContext = useNullableFieldPrivateContext();
+  const pickerPrivateContext = usePickerPrivateContext();
+  const rangePositionContext = useNullablePickerRangePositionContext();
+  const rangePosition = rangePositionContext?.rangePosition ?? 'start';
+  const setRangePosition = rangePositionContext?.setRangePosition;
+  const previousRangePosition = React.useRef(rangePosition);
+  const {
+    forwardedProps,
+    sharedInternalProps,
+    selectedSectionProps,
+    valueType,
+    position,
+    value,
+    onChange,
+    autoFocus,
+    validation
+  } = 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: sharedInternalProps.enableAccessibleFieldDOMStructure
+  });
+  const openPickerIfPossible = event => {
+    if (!pickerContext) {
+      return;
+    }
+    setRangePosition?.(position);
+    if (pickerContext.triggerStatus === 'enabled') {
+      event.preventDefault();
+      pickerContext.setOpen(true);
+    }
+  };
+  const handleKeyDown = useEventCallback(event => {
+    if (event.key === 'Enter' || event.key === ' ') {
+      openPickerIfPossible(event);
+    }
+  });
+
+  // Registering `onClick` listener on the root element as well to correctly handle cases where user is clicking on `label`
+  // which has `pointer-events: none` and due to DOM structure the `input` does not catch the click event
+  const handleClick = useEventCallback(event => {
+    openPickerIfPossible(event);
+  });
+  const handleFocus = useEventCallback(event => {
+    forwardedProps.onFocus?.(event);
+    if (pickerContext?.open) {
+      setRangePosition?.(position);
+      if (previousRangePosition.current !== position && pickerContext.initialView) {
+        pickerContext.setView?.(pickerContext.initialView);
+      }
+    }
+  });
+  const handleChange = useEventCallback((newSingleValue, rawContext) => {
+    const newRange = position === 'start' ? [newSingleValue, value[1]] : [value[0], newSingleValue];
+    const context = _extends({}, rawContext, {
+      validationError: validation.getValidationErrorForNewValue(newRange)
+    });
+    onChange(newRange, context);
+  });
+  const allProps = _extends({
+    value: position === 'start' ? value[0] : value[1],
+    error: position === 'start' ? !!validation.validationError[0] : !!validation.validationError[1],
+    id: `${pickerPrivateContext.labelId}-${position}`,
+    autoFocus: position === 'start' ? autoFocus : undefined
+  }, forwardedProps, sharedInternalProps, selectedSectionProps, {
+    onClick: handleClick,
+    onFocus: handleFocus,
+    onKeyDown: handleKeyDown,
+    onChange: handleChange
+  });
+  const splittedProps = useSplitFieldProps(allProps, valueType);
+  const internalPropsWithDefaults = useFieldInternalPropsWithDefaults({
+    manager,
+    internalProps: splittedProps.internalProps,
+    skipContextFieldRefAssignment: rangePosition !== position
+  });
+  const _ref = useField({
+      forwardedProps: splittedProps.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);
+  React.useEffect(() => {
+    if (!pickerContext?.open || pickerContext?.variant === 'mobile') {
+      return;
+    }
+    fieldPrivateContext?.fieldRef.current?.focusField();
+    if (!fieldPrivateContext?.fieldRef.current || pickerContext.view === pickerContext.initialView) {
+      // could happen when the user is switching between the inputs
+      previousRangePosition.current = rangePosition;
+      return;
+    }
+
+    // bring back focus to the field
+    // currentView is present on DateTimeRangePicker
+    fieldPrivateContext?.fieldRef.current.setSelectedSections(
+    // use the current view or `0` when the range position has just been swapped
+    previousRangePosition.current === rangePosition ? pickerContext.view : 0);
+    previousRangePosition.current = rangePosition;
+  }, [rangePosition, pickerContext?.open, pickerContext?.variant, pickerContext?.initialView, pickerContext?.view, fieldPrivateContext?.fieldRef]);
+  return fieldResponse;
+}

package/modern/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-date-pickers-pro v8.0.0-alpha.12
+ * @mui/x-date-pickers-pro v8.0.0-alpha.13
  *
  * @license MUI X Commercial
  * This source code is licensed under the commercial license found in the

package/modern/internals/hooks/models/index.d.ts

@@ -1 +1 @@
-export type { UseRangePickerSlots, UseRangePickerSlotProps, RangeOnlyPickerProps, UseRangePickerProps, UseRangePickerParams } from './useRangePicker';
+export type { RangeOnlyPickerProps, UseRangePickerProps, UseRangePickerParams } from './useRangePicker';

package/modern/internals/hooks/models/useRangePicker.d.ts

@@ -1,13 +1,6 @@
-import { UsePickerParams, BasePickerProps, ExportedBaseToolbarProps, UsePickerViewsProps, UsePickerValueNonStaticProps, UsePickerProviderNonStaticProps, DateOrTimeViewWithMeridiem, ExportedBaseTabsProps, PickerRangeValue } from '@mui/x-date-pickers/internals';
-import { ExportedPickersLayoutSlots, ExportedPickersLayoutSlotProps } from '@mui/x-date-pickers/PickersLayout';
+import { UsePickerParams, BasePickerProps, UsePickerViewsProps, UsePickerValueNonStaticProps, UsePickerProviderNonStaticProps, DateOrTimeViewWithMeridiem, PickerRangeValue } from '@mui/x-date-pickers/internals';
 import { BaseRangeNonStaticPickerProps } from "../../models/index.js";
 import { UseRangePositionProps } from "../useRangePosition.js";
-import { RangePickerFieldSlots, RangePickerFieldSlotProps } from "../useEnrichedRangePickerField.js";
-export interface UseRangePickerSlots extends ExportedPickersLayoutSlots<PickerRangeValue>, RangePickerFieldSlots {}
-export interface UseRangePickerSlotProps<TEnableAccessibleFieldDOMStructure extends boolean> extends ExportedPickersLayoutSlotProps<PickerRangeValue>, RangePickerFieldSlotProps<TEnableAccessibleFieldDOMStructure> {
-  tabs?: ExportedBaseTabsProps;
-  toolbar?: ExportedBaseToolbarProps;
-}
 export interface RangeOnlyPickerProps extends UsePickerValueNonStaticProps, UsePickerProviderNonStaticProps, BaseRangeNonStaticPickerProps, UseRangePositionProps {}
 export interface UseRangePickerProps<TView extends DateOrTimeViewWithMeridiem, TError, TExternalProps extends UsePickerViewsProps<any, TView, any>> extends RangeOnlyPickerProps, BasePickerProps<PickerRangeValue, TView, TError, TExternalProps> {}
 export interface UseRangePickerParams<TView extends DateOrTimeViewWithMeridiem, TExternalProps extends UseRangePickerProps<TView, any, TExternalProps>> extends Pick<UsePickerParams<PickerRangeValue, TView, TExternalProps>, 'valueManager' | 'valueType' | 'validator' | 'rendererInterceptor' | 'ref'> {

package/modern/internals/hooks/useDesktopRangePicker/useDesktopRangePicker.js

@@ -6,11 +6,11 @@ import * as React from 'react';
 import useSlotProps from '@mui/utils/useSlotProps';
 import { useLicenseVerifier } from '@mui/x-license';
 import { PickersLayout } from '@mui/x-date-pickers/PickersLayout';
-import { executeInTheNextEventLoopTick, getActiveElement, usePicker, PickerPopper, PickerProvider, PickerFieldUIContextProvider } from '@mui/x-date-pickers/internals';
-import { useEnrichedRangePickerField } from "../useEnrichedRangePickerField.js";
+import { usePicker, PickerPopper, PickerProvider, PickerFieldUIContextProvider } from '@mui/x-date-pickers/internals';
 import { getReleaseInfo } from "../../utils/releaseInfo.js";
 import { useRangePosition } from "../useRangePosition.js";
 import { PickerRangePositionContext } from "../../../hooks/usePickerRangePositionContext.js";
+import { getRangeFieldType } from "../../utils/date-fields-utils.js";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 const releaseInfo = getReleaseInfo();
 export const useDesktopRangePicker = _ref => {
@@ -23,27 +23,11 @@ export const useDesktopRangePicker = _ref => {
     slots,
     slotProps,
     inputRef,
-    readOnly,
-    autoFocus,
-    disableOpenPicker,
     localeText
   } = props;
-  const fieldContainerRef = React.useRef(null);
-  const popperRef = React.useRef(null);
-  const startFieldRef = React.useRef(null);
-  const endFieldRef = React.useRef(null);
-  const singleInputFieldRef = React.useRef(null);
-  const initialView = React.useRef(props.openTo ?? null);
-  const fieldType = slots.field.fieldType ?? 'multi-input';
-  const rangePositionResponse = useRangePosition(props, fieldType === 'single-input' ? singleInputFieldRef : undefined);
-  let fieldRef;
-  if (fieldType === 'single-input') {
-    fieldRef = singleInputFieldRef;
-  } else if (rangePositionResponse.rangePosition === 'start') {
-    fieldRef = startFieldRef;
-  } else {
-    fieldRef = endFieldRef;
-  }
+  const fieldType = getRangeFieldType(slots.field);
+  const viewContainerRole = fieldType === 'single-input' ? 'dialog' : 'tooltip';
+  const rangePositionResponse = useRangePosition(props);
   const {
     providerProps,
     renderCurrentView,
@@ -51,77 +35,26 @@ export const useDesktopRangePicker = _ref => {
   } = usePicker(_extends({}, pickerParams, {
     props,
     variant: 'desktop',
-    autoFocusView: false,
-    fieldRef,
+    autoFocusView: viewContainerRole === 'dialog',
+    viewContainerRole,
     localeText
   }));
-
-  // Temporary hack to hide the opening button on the range pickers until we have migrate them to the new opening logic.
-  providerProps.contextValue.triggerStatus = 'hidden';
-  React.useEffect(() => {
-    if (providerProps.contextValue.view) {
-      initialView.current = providerProps.contextValue.view;
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, []);
-  const handleBlur = () => {
-    executeInTheNextEventLoopTick(() => {
-      if (fieldContainerRef.current?.contains(getActiveElement(document)) || popperRef.current?.contains(getActiveElement(document))) {
-        return;
-      }
-
-      // This direct access to `providerProps` will go away once the range fields stop having their views in a tooltip.
-      providerProps.privateContextValue.dismissViews();
-    });
-  };
   const Field = slots.field;
   const _useSlotProps = useSlotProps({
       elementType: Field,
       externalSlotProps: slotProps?.field,
-      additionalProps: {
-        // Internal props
-        readOnly,
-        autoFocus: autoFocus && !props.open,
-        // Forwarded props
-        ref: fieldContainerRef
-      },
       ownerState
     }),
     fieldProps = _objectWithoutPropertiesLoose(_useSlotProps, _excluded2);
-  const enrichedFieldResponse = useEnrichedRangePickerField(_extends({
-    variant: 'desktop',
-    fieldType,
-    // These direct access to `providerProps` will go away once the range fields handle the picker opening
-    contextValue: providerProps.contextValue,
-    fieldPrivateContextValue: providerProps.fieldPrivateContextValue,
-    readOnly,
-    disableOpenPicker,
-    localeText,
-    onBlur: handleBlur,
-    pickerSlotProps: slotProps,
-    pickerSlots: slots,
-    fieldProps,
-    anchorRef: providerProps.contextValue.triggerRef,
-    startFieldRef,
-    endFieldRef,
-    singleInputFieldRef,
-    currentView: providerProps.contextValue.view !== props.openTo ? providerProps.contextValue.view : undefined,
-    initialView: initialView.current ?? undefined
-  }, rangePositionResponse));
   const Layout = slots?.layout ?? PickersLayout;
   const renderPicker = () => /*#__PURE__*/_jsx(PickerProvider, _extends({}, providerProps, {
-    // This override will go away once the range fields handle the picker opening
-    fieldPrivateContextValue: _extends({}, providerProps.fieldPrivateContextValue, enrichedFieldResponse.fieldPrivateContextValue),
     children: /*#__PURE__*/_jsx(PickerFieldUIContextProvider, {
       slots: slots,
       slotProps: slotProps,
       inputRef: inputRef,
       children: /*#__PURE__*/_jsxs(PickerRangePositionContext.Provider, {
         value: rangePositionResponse,
-        children: [/*#__PURE__*/_jsx(Field, _extends({}, enrichedFieldResponse.fieldProps)), /*#__PURE__*/_jsx(PickerPopper, {
-          role: "tooltip",
-          containerRef: popperRef,
-          onBlur: handleBlur,
+        children: [/*#__PURE__*/_jsx(Field, _extends({}, fieldProps)), /*#__PURE__*/_jsx(PickerPopper, {
           slots: slots,
           slotProps: slotProps,
           children: /*#__PURE__*/_jsx(Layout, _extends({}, slotProps?.layout, {

package/modern/internals/hooks/useDesktopRangePicker/useDesktopRangePicker.types.d.ts

@@ -1,7 +1,19 @@
-import { PickerPopperSlots, PickerPopperSlotProps, UsePickerViewsProps, DateOrTimeViewWithMeridiem } from '@mui/x-date-pickers/internals';
-import { RangeOnlyPickerProps, UseRangePickerParams, UseRangePickerProps, UseRangePickerSlotProps, UseRangePickerSlots } from "../models/useRangePicker.js";
-export interface UseDesktopRangePickerSlots extends UseRangePickerSlots, PickerPopperSlots {}
-export interface UseDesktopRangePickerSlotProps<TEnableAccessibleFieldDOMStructure extends boolean> extends UseRangePickerSlotProps<TEnableAccessibleFieldDOMStructure>, PickerPopperSlotProps {}
+import { SlotComponentPropsFromProps } from '@mui/x-internals/types';
+import { PickerFieldSlotProps, PickerOwnerState } from '@mui/x-date-pickers/models';
+import { PickerPopperSlots, PickerPopperSlotProps, UsePickerViewsProps, DateOrTimeViewWithMeridiem, PickerRangeValue, PickerFieldUISlotsFromContext, PickerFieldUISlotPropsFromContext } from '@mui/x-date-pickers/internals';
+import { ExportedPickersLayoutSlotProps, ExportedPickersLayoutSlots } from '@mui/x-date-pickers/PickersLayout';
+import { RangeOnlyPickerProps, UseRangePickerParams, UseRangePickerProps } from "../models/useRangePicker.js";
+export interface UseDesktopRangePickerSlots extends PickerPopperSlots, ExportedPickersLayoutSlots<PickerRangeValue>, PickerFieldUISlotsFromContext {
+  /**
+   * Component used to enter the date with the keyboard.
+   */
+  field: React.ElementType;
+}
+export interface UseDesktopRangePickerSlotProps<TEnableAccessibleFieldDOMStructure extends boolean> extends PickerPopperSlotProps, ExportedPickersLayoutSlotProps<PickerRangeValue>, PickerFieldUISlotPropsFromContext {
+  field?: SlotComponentPropsFromProps<PickerFieldSlotProps<PickerRangeValue, TEnableAccessibleFieldDOMStructure> & {
+    dateSeparator?: string;
+  }, {}, PickerOwnerState>;
+}
 export interface DesktopRangeOnlyPickerProps extends RangeOnlyPickerProps {
   /**
    * If `true`, the start `input` element is focused during the first mount.

package/modern/internals/hooks/useMobileRangePicker/useMobileRangePicker.js

@@ -4,15 +4,15 @@ const _excluded = ["props"],
   _excluded2 = ["ownerState"];
 import * as React from 'react';
 import useSlotProps from '@mui/utils/useSlotProps';
+import resolveComponentProps from '@mui/utils/resolveComponentProps';
 import { useLicenseVerifier } from '@mui/x-license';
 import { PickersLayout } from '@mui/x-date-pickers/PickersLayout';
 import { usePicker, PickersModalDialog, PickerProvider, PickerFieldUIContextProvider } from '@mui/x-date-pickers/internals';
 import { usePickerTranslations } from '@mui/x-date-pickers/hooks';
-import useId from '@mui/utils/useId';
-import { useEnrichedRangePickerField } from "../useEnrichedRangePickerField.js";
 import { getReleaseInfo } from "../../utils/releaseInfo.js";
 import { useRangePosition } from "../useRangePosition.js";
 import { PickerRangePositionContext } from "../../../hooks/usePickerRangePositionContext.js";
+import { getRangeFieldType } from "../../utils/date-fields-utils.js";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 const releaseInfo = getReleaseInfo();
 export const useMobileRangePicker = _ref => {
@@ -26,25 +26,11 @@ export const useMobileRangePicker = _ref => {
     slotProps: innerSlotProps,
     label,
     inputRef,
-    readOnly,
-    disableOpenPicker,
     localeText
   } = props;
-  const startFieldRef = React.useRef(null);
-  const endFieldRef = React.useRef(null);
-  const singleInputFieldRef = React.useRef(null);
-  const fieldType = slots.field.fieldType ?? 'multi-input';
-  const rangePositionResponse = useRangePosition(props, fieldType === 'single-input' ? singleInputFieldRef : undefined);
-  const labelId = useId();
+  const fieldType = getRangeFieldType(slots.field);
+  const rangePositionResponse = useRangePosition(props);
   const contextTranslations = usePickerTranslations();
-  let fieldRef;
-  if (fieldType === 'single-input') {
-    fieldRef = singleInputFieldRef;
-  } else if (rangePositionResponse.rangePosition === 'start') {
-    fieldRef = startFieldRef;
-  } else {
-    fieldRef = endFieldRef;
-  }
   const {
     providerProps,
     renderCurrentView,
@@ -53,41 +39,21 @@ export const useMobileRangePicker = _ref => {
     props,
     variant: 'mobile',
     autoFocusView: true,
-    fieldRef,
+    viewContainerRole: 'dialog',
     localeText
   }));
-
-  // Temporary hack to hide the opening button on the range pickers until we have migrate them to the new opening logic.
-  providerProps.contextValue.triggerStatus = 'hidden';
+  const labelId = providerProps.privateContextValue.labelId;
+  const isToolbarHidden = innerSlotProps?.toolbar?.hidden ?? false;
   const Field = slots.field;
   const _useSlotProps = useSlotProps({
       elementType: Field,
       externalSlotProps: innerSlotProps?.field,
-      additionalProps: {
-        // Internal props
-        readOnly: readOnly ?? true
-      },
+      additionalProps: _extends({}, fieldType === 'single-input' && isToolbarHidden && {
+        id: labelId
+      }),
       ownerState
     }),
     fieldProps = _objectWithoutPropertiesLoose(_useSlotProps, _excluded2);
-  const isToolbarHidden = innerSlotProps?.toolbar?.hidden ?? false;
-  const enrichedFieldResponse = useEnrichedRangePickerField(_extends({
-    variant: 'mobile',
-    fieldType,
-    // These direct access to `providerProps` will go away once the range fields handle the picker opening
-    contextValue: providerProps.contextValue,
-    fieldPrivateContextValue: providerProps.fieldPrivateContextValue,
-    readOnly,
-    labelId,
-    disableOpenPicker,
-    localeText,
-    pickerSlots: slots,
-    pickerSlotProps: innerSlotProps,
-    fieldProps,
-    startFieldRef,
-    endFieldRef,
-    singleInputFieldRef
-  }, rangePositionResponse));
   const Layout = slots?.layout ?? PickersLayout;
   const finalLocaleText = _extends({}, contextTranslations, localeText);
   let labelledById = pickerParams.valueType === 'date-time' ? `${labelId}-start-toolbar ${labelId}-end-toolbar` : labelId;
@@ -112,17 +78,21 @@ export const useMobileRangePicker = _ref => {
     mobilePaper: _extends({
       'aria-labelledby': labelledById
     }, innerSlotProps?.mobilePaper)
+  }, fieldType === 'multi-input' && {
+    textField: slotOwnerState => {
+      return _extends({}, resolveComponentProps(innerSlotProps?.textField, slotOwnerState), {
+        id: `${labelId}-${slotOwnerState.position}`
+      });
+    }
   });
   const renderPicker = () => /*#__PURE__*/_jsx(PickerProvider, _extends({}, providerProps, {
-    // This override will go away once the range fields handle the picker opening
-    fieldPrivateContextValue: _extends({}, providerProps.fieldPrivateContextValue, enrichedFieldResponse.fieldPrivateContextValue),
     children: /*#__PURE__*/_jsx(PickerFieldUIContextProvider, {
       slots: slots,
       slotProps: slotProps,
       inputRef: inputRef,
       children: /*#__PURE__*/_jsxs(PickerRangePositionContext.Provider, {
         value: rangePositionResponse,
-        children: [/*#__PURE__*/_jsx(Field, _extends({}, enrichedFieldResponse.fieldProps)), /*#__PURE__*/_jsx(PickersModalDialog, {
+        children: [/*#__PURE__*/_jsx(Field, _extends({}, fieldProps)), /*#__PURE__*/_jsx(PickersModalDialog, {
           slots: slots,
           slotProps: slotProps,
           children: /*#__PURE__*/_jsx(Layout, _extends({}, slotProps?.layout, {

package/modern/internals/hooks/useMobileRangePicker/useMobileRangePicker.types.d.ts

@@ -1,7 +1,20 @@
-import { PickersModalDialogSlots, PickersModalDialogSlotProps, UsePickerViewsProps, DateOrTimeViewWithMeridiem } from '@mui/x-date-pickers/internals';
-import { RangeOnlyPickerProps, UseRangePickerParams, UseRangePickerProps, UseRangePickerSlotProps, UseRangePickerSlots } from "../models/useRangePicker.js";
-export interface UseMobileRangePickerSlots extends UseRangePickerSlots, PickersModalDialogSlots {}
-export interface UseMobileRangePickerSlotProps<TEnableAccessibleFieldDOMStructure extends boolean> extends UseRangePickerSlotProps<TEnableAccessibleFieldDOMStructure>, PickersModalDialogSlotProps {}
+import { SlotComponentPropsFromProps } from '@mui/x-internals/types';
+import { PickerFieldSlotProps, PickerOwnerState } from '@mui/x-date-pickers/models';
+import { PickersModalDialogSlots, PickersModalDialogSlotProps, UsePickerViewsProps, DateOrTimeViewWithMeridiem, PickerRangeValue, PickerFieldUISlotsFromContext, PickerFieldUISlotPropsFromContext } from '@mui/x-date-pickers/internals';
+import { ExportedPickersLayoutSlotProps, ExportedPickersLayoutSlots, PickersLayoutSlotProps } from '@mui/x-date-pickers/PickersLayout';
+import { RangeOnlyPickerProps, UseRangePickerParams, UseRangePickerProps } from "../models/useRangePicker.js";
+export interface UseMobileRangePickerSlots extends PickersModalDialogSlots, ExportedPickersLayoutSlots<PickerRangeValue>, PickerFieldUISlotsFromContext {
+  /**
+   * Component used to enter the date with the keyboard.
+   */
+  field: React.ElementType;
+}
+export interface ExportedUseMobileRangePickerSlotProps<TEnableAccessibleFieldDOMStructure extends boolean> extends PickersModalDialogSlotProps, ExportedPickersLayoutSlotProps<PickerRangeValue>, PickerFieldUISlotPropsFromContext {
+  field?: SlotComponentPropsFromProps<PickerFieldSlotProps<PickerRangeValue, TEnableAccessibleFieldDOMStructure> & {
+    dateSeparator?: string;
+  }, {}, PickerOwnerState>;
+}
+export interface UseMobileRangePickerSlotProps<TEnableAccessibleFieldDOMStructure extends boolean> extends ExportedUseMobileRangePickerSlotProps<TEnableAccessibleFieldDOMStructure>, Pick<PickersLayoutSlotProps<PickerRangeValue>, 'toolbar'> {}
 export interface MobileRangeOnlyPickerProps extends RangeOnlyPickerProps {}
 export interface UseMobileRangePickerProps<TView extends DateOrTimeViewWithMeridiem, TEnableAccessibleFieldDOMStructure extends boolean, TError, TExternalProps extends UsePickerViewsProps<any, TView, any>> extends UseRangePickerProps<TView, TError, TExternalProps> {
   /**

package/modern/internals/hooks/useRangePosition.d.ts

@@ -1,6 +1,3 @@
-import * as React from 'react';
-import { FieldRef } from '@mui/x-date-pickers/models';
-import { PickerRangeValue } from '@mui/x-date-pickers/internals';
 import { RangePosition } from "../../models/index.js";
 export interface UseRangePositionProps {
   /**
@@ -24,4 +21,4 @@ export interface UseRangePositionResponse {
   rangePosition: RangePosition;
   setRangePosition: (newPosition: RangePosition) => void;
 }
-export declare const useRangePosition: (props: UseRangePositionProps, singleInputFieldRef?: React.RefObject<FieldRef<PickerRangeValue> | null>) => UseRangePositionResponse;
+export declare const useRangePosition: (props: UseRangePositionProps) => UseRangePositionResponse;

package/modern/internals/hooks/useRangePosition.js

@@ -1,32 +1,15 @@
 import useControlled from '@mui/utils/useControlled';
 import useEventCallback from '@mui/utils/useEventCallback';
-export const useRangePosition = (props, singleInputFieldRef) => {
+export const useRangePosition = props => {
   const [rangePosition, setRangePosition] = useControlled({
     name: 'useRangePosition',
     state: 'rangePosition',
     controlled: props.rangePosition,
     default: props.defaultRangePosition ?? 'start'
   });
-
-  // When using a single input field,
-  // we want to select the 1st section of the edited date when updating the range position.
-  const syncRangePositionWithSingleInputField = newRangePosition => {
-    if (singleInputFieldRef?.current == null) {
-      return;
-    }
-    const sections = singleInputFieldRef.current.getSections();
-    const targetActiveSectionIndex = newRangePosition === 'start' ? 0 : sections.length / 2;
-    const activeSectionIndex = singleInputFieldRef.current.getActiveSectionIndex();
-    // if the active section is already within the target range, we don't need to update it.
-    if (activeSectionIndex && activeSectionIndex >= targetActiveSectionIndex && activeSectionIndex < targetActiveSectionIndex + sections.length / 2) {
-      return;
-    }
-    singleInputFieldRef.current.setSelectedSections(targetActiveSectionIndex);
-  };
   const handleRangePositionChange = useEventCallback(newRangePosition => {
     setRangePosition(newRangePosition);
     props.onRangePositionChange?.(newRangePosition);
-    syncRangePositionWithSingleInputField(newRangePosition);
   });
   return {
     rangePosition,

package/modern/internals/hooks/useStaticRangePicker/useStaticRangePicker.js

@@ -39,10 +39,10 @@ export const useStaticRangePicker = _ref => {
     renderCurrentView
   } = usePicker(_extends({}, pickerParams, {
     props,
+    variant: displayStaticWrapperAs,
     autoFocusView: autoFocus ?? false,
-    fieldRef: undefined,
-    localeText,
-    variant: displayStaticWrapperAs
+    viewContainerRole: null,
+    localeText
   }));
   const Layout = slots?.layout ?? PickerStaticLayout;
   const renderPicker = () => /*#__PURE__*/_jsx(PickerRangePositionContext.Provider, {

package/modern/internals/utils/createMultiInputRangeField/createMultiInputRangeField.js

@@ -12,10 +12,11 @@ import { styled, useThemeProps } from '@mui/material/styles';
 import composeClasses from '@mui/utils/composeClasses';
 import useSlotProps from '@mui/utils/useSlotProps';
 import useForkRef from '@mui/utils/useForkRef';
-import { cleanFieldResponse, useFieldOwnerState, useNullablePickerContext } from '@mui/x-date-pickers/internals';
+import { cleanFieldResponse, useFieldOwnerState, PickerFieldUIContext, useNullablePickerContext } from '@mui/x-date-pickers/internals';
 import { useSplitFieldProps } from '@mui/x-date-pickers/hooks';
 import { PickersTextField } from '@mui/x-date-pickers/PickersTextField';
 import { useMultiInputRangeField } from "../../../hooks/useMultiInputRangeField/index.js";
+import { useTextFieldProps } from "./useTextFieldProps.js";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 export function createMultiInputRangeField({
   useManager,
@@ -52,14 +53,19 @@ export function createMultiInputRangeField({
       // eslint-disable-next-line material-ui/mui-name-matches-component-name
       name
     });
+    const pickerFieldUIContext = React.useContext(PickerFieldUIContext);
+    const pickerContext = useNullablePickerContext();
     const manager = useManager({
       enableAccessibleFieldDOMStructure: props.enableAccessibleFieldDOMStructure,
       dateSeparator: props.dateSeparator
     });
     const {
-      internalProps,
+      internalProps: rawInternalProps,
       forwardedProps
     } = useSplitFieldProps(themeProps, manager.valueType);
+    const internalProps = pickerContext?.variant === 'mobile' ? _extends({}, rawInternalProps, {
+      readOnly: true
+    }) : rawInternalProps;
     const {
         slots,
         slotProps,
@@ -69,7 +75,6 @@ export function createMultiInputRangeField({
       otherForwardedProps = _objectWithoutPropertiesLoose(forwardedProps, _excluded);
     const classes = useUtilityClasses(classesProp);
     const ownerState = useFieldOwnerState(internalProps);
-    const pickerContext = useNullablePickerContext();
     const handleRef = useForkRef(ref, pickerContext?.rootRef);
     const Root = slots?.root ?? MultiInputRangeFieldRoot;
     const rootProps = useSlotProps({
@@ -82,29 +87,22 @@ export function createMultiInputRangeField({
       ownerState,
       className: clsx(className, classes.root)
     });
-    const startTextFieldProps = useSlotProps({
-      elementType: PickersTextField,
-      externalSlotProps: slotProps?.textField,
-      ownerState: _extends({}, ownerState, {
-        position: 'start'
-      })
+    const startTextFieldProps = useTextFieldProps({
+      slotProps,
+      ownerState,
+      position: 'start'
     });
-    const endTextFieldProps = useSlotProps({
-      elementType: PickersTextField,
-      externalSlotProps: slotProps?.textField,
-      ownerState: _extends({}, ownerState, {
-        position: 'end'
-      })
+    const endTextFieldProps = useTextFieldProps({
+      slotProps,
+      ownerState,
+      position: 'end'
     });
-    const {
-      startDate,
-      endDate,
-      enableAccessibleFieldDOMStructure
-    } = useMultiInputRangeField({
+    const fieldResponse = useMultiInputRangeField({
       manager,
       internalProps,
-      startForwardedProps: startTextFieldProps,
-      endForwardedProps: endTextFieldProps
+      rootProps,
+      startTextFieldProps,
+      endTextFieldProps
     });
     const Separator = slots?.separator ?? MultiInputRangeFieldSeparator;
     const separatorProps = useSlotProps({
@@ -116,19 +114,15 @@ export function createMultiInputRangeField({
       ownerState,
       className: classes.separator
     });
-    const {
-      textFieldProps: startDateProps
-    } = cleanFieldResponse(startDate);
-    const {
-      textFieldProps: endDateProps
-    } = cleanFieldResponse(endDate);
-    const TextField = slots?.textField ?? (enableAccessibleFieldDOMStructure === false ? MuiTextField : PickersTextField);
-    return /*#__PURE__*/_jsxs(Root, _extends({}, rootProps, {
+    const cleanStartTextFieldResponse = cleanFieldResponse(fieldResponse.startTextField);
+    const cleanEndTextFieldResponse = cleanFieldResponse(fieldResponse.endTextField);
+    const TextField = slots?.textField ?? pickerFieldUIContext.slots.textField ?? (fieldResponse.enableAccessibleFieldDOMStructure === false ? MuiTextField : PickersTextField);
+    return /*#__PURE__*/_jsxs(Root, _extends({}, fieldResponse.root, {
       children: [/*#__PURE__*/_jsx(TextField, _extends({
         fullWidth: true
-      }, startDateProps)), /*#__PURE__*/_jsx(Separator, _extends({}, separatorProps)), /*#__PURE__*/_jsx(TextField, _extends({
+      }, cleanStartTextFieldResponse.textFieldProps)), /*#__PURE__*/_jsx(Separator, _extends({}, separatorProps)), /*#__PURE__*/_jsx(TextField, _extends({
         fullWidth: true
-      }, endDateProps))]
+      }, cleanEndTextFieldResponse.textFieldProps))]
     }));
   });
   MultiInputRangeField.fieldType = 'multi-input';

package/modern/internals/utils/createMultiInputRangeField/createMultiInputRangeField.types.d.ts

@@ -7,7 +7,7 @@ import { FieldOwnerState } from '@mui/x-date-pickers/models';
 import { PickerManagerEnableAccessibleFieldDOMStructure, PickerManagerFieldInternalProps } from '@mui/x-date-pickers/internals';
 import { FieldType, MultiInputFieldRefs, RangeFieldSeparatorProps, RangePosition } from "../../../models/index.js";
 import { PickerAnyRangeManager } from "../../models/managers.js";
-export type MultiInputRangeFieldProps<TManager extends PickerAnyRangeManager> = MultiInputFieldRefs & RangeFieldSeparatorProps & Omit<PickerManagerFieldInternalProps<TManager>, 'unstableFieldRef' | 'clearable' | 'onClear'> & Omit<StackProps, 'position' | keyof PickerManagerFieldInternalProps<TManager>> & {
+export type MultiInputRangeFieldProps<TManager extends PickerAnyRangeManager> = MultiInputFieldRefs & RangeFieldSeparatorProps & Omit<PickerManagerFieldInternalProps<TManager>, 'unstableFieldRef' | 'clearable' | 'onClear' | 'focused'> & Omit<StackProps, 'position' | keyof PickerManagerFieldInternalProps<TManager>> & {
   /**
    * If `true`, the field is focused during the first mount.
    * @default false