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

package/esm/models/fields.d.ts

@@ -1,24 +1,16 @@
 import * as React from 'react';
-import { UseFieldResponse, FormProps, PickerValue, PickerRangeValue } from '@mui/x-date-pickers/internals';
+import { PickerValue, PickerRangeValue } from '@mui/x-date-pickers/internals';
 import { FieldRef, PickerFieldSlotProps } from '@mui/x-date-pickers/models';
+import type { UseMultiInputRangeFieldTextFieldProps } from '../hooks/useMultiInputRangeField';
 export type { FieldRangeSection } from '@mui/x-date-pickers/internals';
 export type FieldType = 'single-input' | 'multi-input';
 /**
  * Props the `textField` slot of the multi input field can receive when used inside a picker.
  */
-export interface MultiInputFieldSlotTextFieldProps extends FormProps {
+export type MultiInputFieldSlotTextFieldProps<TEnableAccessibleFieldDOMStructure extends boolean = true> = UseMultiInputRangeFieldTextFieldProps<TEnableAccessibleFieldDOMStructure, {
   label?: React.ReactNode;
-  id?: string;
-  onKeyDown?: React.KeyboardEventHandler;
-  onClick?: React.MouseEventHandler;
-  onFocus?: React.FocusEventHandler;
   focused?: boolean;
-  InputProps?: {
-    ref?: React.Ref<any>;
-    endAdornment?: React.ReactNode;
-    startAdornment?: React.ReactNode;
-  };
-}
+}>;
 /**
  * Props the `root` slot of the multi input field can receive when used inside a picker.
  */
@@ -39,9 +31,4 @@ export interface RangeFieldSeparatorProps {
 /**
  * Props the `slotProps.field` of a range picker component can receive.
  */
-export type PickerRangeFieldSlotProps<TEnableAccessibleFieldDOMStructure extends boolean> = PickerFieldSlotProps<PickerRangeValue, TEnableAccessibleFieldDOMStructure> & RangeFieldSeparatorProps;
-/**
- * Props the text field receives when used with a multi input picker.
- * Only contains what the MUI components are passing to the text field, not what users can pass using the `props.slotProps.textField`.
- */
-export type BaseMultiInputPickersTextFieldProps<TEnableAccessibleFieldDOMStructure extends boolean> = Omit<UseFieldResponse<TEnableAccessibleFieldDOMStructure, MultiInputFieldSlotTextFieldProps>, 'slots' | 'slotProps' | 'clearable' | 'onClear' | 'openPickerButtonPosition' | 'clearButtonPosition' | 'openPickerAriaLabel'>;
+export type PickerRangeFieldSlotProps<TEnableAccessibleFieldDOMStructure extends boolean> = PickerFieldSlotProps<PickerRangeValue, TEnableAccessibleFieldDOMStructure> & RangeFieldSeparatorProps;

package/hooks/index.d.ts

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

package/hooks/useMultiInputRangeField/index.d.ts

@@ -1 +1,2 @@
-export { useMultiInputRangeField } from "./useMultiInputRangeField.js";
+export { useMultiInputRangeField } from "./useMultiInputRangeField.js";
+export type { UseMultiInputRangeFieldTextFieldProps } from './useMultiInputRangeField';

package/hooks/useMultiInputRangeField/useMultiInputRangeField.d.ts

@@ -1,5 +1,7 @@
 import { PickerManagerEnableAccessibleFieldDOMStructure, PickerManagerFieldInternalProps, UseFieldResponse } from '@mui/x-date-pickers/internals';
+import { UseTextFieldBaseForwardedProps } from "./useTextFieldProps.js";
 import { PickerAnyRangeManager } from "../../internals/models/managers.js";
+import { UseMultiInputRangeFieldRootPropsReturnValue } from "./useMultiInputRangeFieldRootProps.js";
 /**
  * Basic example:
  *
@@ -12,42 +14,59 @@ import { PickerAnyRangeManager } from "../../internals/models/managers.js";
  * function MultiInputField(props) {
  *   const manager = useDateRangeManager();
  *   const { internalProps, forwardedProps } = useSplitFieldProps(props, 'date');
- *   const { startDate, endDate } = useMultiInputRangeField({
+ *   const response = useMultiInputRangeField({
  *     manager,
  *     internalProps,
- *     startForwardedProps: forwardedProps,
- *     endForwardedProps: forwardedProps,
+ *     startTextFieldProps: {},
+ *     endTextFieldProps: {},
+ *     rootProps: forwardedProps,
  *   });
  *
  *   return (
- *     <Box {...forwardedProps}>
- *       <PickersTextField {...startDate} />
+ *     <Box {...response.root}>
+ *       <PickersTextField {...response.startTextField} />
  *       <span>{' – '}</span>
- *       <PickersTextField {...endDate} />
+ *       <PickersTextField {...response.endTextField} />
  *     </Box>
  *   );
  * }
  * ```
  *
- * @param {UseMultiInputRangeFieldParameters<TManager, TForwardedProps>} parameters The parameters of the hook.
+ * @param {UseMultiInputRangeFieldParameters<TManager, TTextFieldProps>} 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.
+ * @param {TTextFieldProps} parameters.startForwardedProps The forwarded props of the start field.
+ * @param {TTextFieldProps} parameters.endForwardedProps The forwarded props of the end field.
+ * @returns {UseMultiInputRangeFieldReturnValue<TManager, TTextFieldProps>} The props to pass to the start and the end components.
  */
-export declare function useMultiInputRangeField<TManager extends PickerAnyRangeManager, TForwardedProps extends {
+export declare function useMultiInputRangeField<TManager extends PickerAnyRangeManager, TTextFieldProps extends UseTextFieldBaseForwardedProps, TRootProps extends {
   [key: string]: any;
-}>(parameters: UseMultiInputRangeFieldParameters<TManager, TForwardedProps>): UseMultiInputRangeFieldReturnValue<TManager, TForwardedProps>;
-interface UseMultiInputRangeFieldParameters<TManager extends PickerAnyRangeManager, TForwardedProps extends {}> {
+}>(parameters: UseMultiInputRangeFieldParameters<TManager, TTextFieldProps, TRootProps>): UseMultiInputRangeFieldReturnValue<TManager, TTextFieldProps, TRootProps>;
+interface UseMultiInputRangeFieldParameters<TManager extends PickerAnyRangeManager, TTextFieldProps extends {
+  [key: string]: any;
+}, TRootProps extends {
+  [key: string]: any;
+}> {
   manager: TManager;
   internalProps: PickerManagerFieldInternalProps<TManager>;
-  startForwardedProps: TForwardedProps;
-  endForwardedProps: TForwardedProps;
+  rootProps: TRootProps;
+  startTextFieldProps: TTextFieldProps;
+  endTextFieldProps: TTextFieldProps;
 }
-interface UseMultiInputRangeFieldReturnValue<TManager extends PickerAnyRangeManager, TForwardedProps extends {}> {
-  startDate: Omit<UseFieldResponse<PickerManagerEnableAccessibleFieldDOMStructure<TManager>, TForwardedProps>, 'clearable' | 'onClear'>;
-  endDate: Omit<UseFieldResponse<PickerManagerEnableAccessibleFieldDOMStructure<TManager>, TForwardedProps>, 'clearable' | 'onClear'>;
+interface UseMultiInputRangeFieldReturnValue<TManager extends PickerAnyRangeManager, TTextFieldProps extends {
+  [key: string]: any;
+}, TRootProps extends {
+  [key: string]: any;
+}> {
+  root: UseMultiInputRangeFieldRootPropsReturnValue<TRootProps>;
+  startTextField: UseMultiInputRangeFieldTextFieldProps<PickerManagerEnableAccessibleFieldDOMStructure<TManager>, TTextFieldProps>;
+  endTextField: UseMultiInputRangeFieldTextFieldProps<PickerManagerEnableAccessibleFieldDOMStructure<TManager>, TTextFieldProps>;
   enableAccessibleFieldDOMStructure: PickerManagerEnableAccessibleFieldDOMStructure<TManager>;
 }
+export type UseMultiInputRangeFieldTextFieldProps<TEnableAccessibleFieldDOMStructure extends boolean, TForwardedProps extends UseTextFieldBaseForwardedProps> = Omit<UseFieldResponse<TEnableAccessibleFieldDOMStructure, TForwardedProps & {
+  onKeyDown: React.KeyboardEventHandler;
+  onClick: React.MouseEventHandler;
+  onFocus: React.FocusEventHandler;
+  id: string;
+}>, 'onClear' | 'clearable' | 'openPickerAriaLabel'>;
 export {};

package/hooks/useMultiInputRangeField/useMultiInputRangeField.js

@@ -1,17 +1,15 @@
 "use strict";
 'use client';
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useMultiInputRangeField = useMultiInputRangeField;
-var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
-var _useEventCallback = _interopRequireDefault(require("@mui/utils/useEventCallback"));
 var _internals = require("@mui/x-date-pickers/internals");
 var _validation = require("@mui/x-date-pickers/validation");
-var _useMultiInputRangeFieldTextFieldProps = require("./useMultiInputRangeFieldTextFieldProps");
+var _useTextFieldProps = require("./useTextFieldProps");
 var _useMultiInputRangeFieldSelectedSections = require("./useMultiInputRangeFieldSelectedSections");
+var _useMultiInputRangeFieldRootProps = require("./useMultiInputRangeFieldRootProps");
 /**
  * Basic example:
  *
@@ -24,36 +22,38 @@ var _useMultiInputRangeFieldSelectedSections = require("./useMultiInputRangeFiel
  * function MultiInputField(props) {
  *   const manager = useDateRangeManager();
  *   const { internalProps, forwardedProps } = useSplitFieldProps(props, 'date');
- *   const { startDate, endDate } = useMultiInputRangeField({
+ *   const response = useMultiInputRangeField({
  *     manager,
  *     internalProps,
- *     startForwardedProps: forwardedProps,
- *     endForwardedProps: forwardedProps,
+ *     startTextFieldProps: {},
+ *     endTextFieldProps: {},
+ *     rootProps: forwardedProps,
  *   });
  *
  *   return (
- *     <Box {...forwardedProps}>
- *       <PickersTextField {...startDate} />
+ *     <Box {...response.root}>
+ *       <PickersTextField {...response.startTextField} />
  *       <span>{' – '}</span>
- *       <PickersTextField {...endDate} />
+ *       <PickersTextField {...response.endTextField} />
  *     </Box>
  *   );
  * }
  * ```
  *
- * @param {UseMultiInputRangeFieldParameters<TManager, TForwardedProps>} parameters The parameters of the hook.
+ * @param {UseMultiInputRangeFieldParameters<TManager, TTextFieldProps>} 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.
+ * @param {TTextFieldProps} parameters.startForwardedProps The forwarded props of the start field.
+ * @param {TTextFieldProps} parameters.endForwardedProps The forwarded props of the end field.
+ * @returns {UseMultiInputRangeFieldReturnValue<TManager, TTextFieldProps>} The props to pass to the start and the end components.
  */
 function useMultiInputRangeField(parameters) {
   const {
     manager,
     internalProps,
-    startForwardedProps,
-    endForwardedProps
+    rootProps,
+    startTextFieldProps,
+    endTextFieldProps
   } = parameters;
   const internalPropsWithDefaults = (0, _internals.useFieldInternalPropsWithDefaults)({
     manager,
@@ -90,34 +90,20 @@ function useMultiInputRangeField(parameters) {
     onChange,
     valueManager: manager.internal_valueManager
   });
-  const {
-    validationError,
-    getValidationErrorForNewValue
-  } = (0, _validation.useValidation)({
+  const validation = (0, _validation.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 = (0, _extends2.default)({}, rawContext, {
-        validationError: getValidationErrorForNewValue(newRange)
-      });
-      handleValueChange(newRange, context);
-    };
-  };
-  const handleStartDateChange = (0, _useEventCallback.default)(buildChangeHandler(0));
-  const handleEndDateChange = (0, _useEventCallback.default)(buildChangeHandler(1));
   const selectedSectionsResponse = (0, _useMultiInputRangeFieldSelectedSections.useMultiInputRangeFieldSelectedSections)({
     selectedSections,
     onSelectedSectionsChange,
     unstableStartFieldRef,
     unstableEndFieldRef
   });
-  const sharedProps = {
+  const sharedInternalProps = {
     disabled,
     readOnly,
     timezone,
@@ -126,30 +112,33 @@ function useMultiInputRangeField(parameters) {
     shouldRespectLeadingZeros,
     enableAccessibleFieldDOMStructure
   };
-  const startDateProps = (0, _useMultiInputRangeFieldTextFieldProps.useMultiInputRangeFieldTextFieldProps)({
+  const rootResponse = (0, _useMultiInputRangeFieldRootProps.useMultiInputRangeFieldRootProps)(rootProps);
+  const startTextFieldResponse = (0, _useTextFieldProps.useTextFieldProps)({
     valueType: manager.valueType,
-    fieldProps: (0, _extends2.default)({
-      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.
-    })
+    position: 'start',
+    value,
+    onChange: handleValueChange,
+    autoFocus,
+    validation,
+    forwardedProps: startTextFieldProps,
+    selectedSectionProps: selectedSectionsResponse.start,
+    sharedInternalProps
   });
-  const endDateProps = (0, _useMultiInputRangeFieldTextFieldProps.useMultiInputRangeFieldTextFieldProps)({
+  const endTextFieldResponse = (0, _useTextFieldProps.useTextFieldProps)({
     valueType: manager.valueType,
-    fieldProps: (0, _extends2.default)({
-      error: !!validationError[1]
-    }, endForwardedProps, selectedSectionsResponse.end, sharedProps, {
-      value: valueProp === undefined ? undefined : valueProp[1],
-      defaultValue: defaultValue === undefined ? undefined : defaultValue[1],
-      onChange: handleEndDateChange
-    })
+    position: 'end',
+    value,
+    onChange: handleValueChange,
+    autoFocus,
+    validation,
+    forwardedProps: endTextFieldProps,
+    selectedSectionProps: selectedSectionsResponse.end,
+    sharedInternalProps
   });
   return {
-    startDate: startDateProps,
-    endDate: endDateProps,
+    root: rootResponse,
+    startTextField: startTextFieldResponse,
+    endTextField: endTextFieldResponse,
     enableAccessibleFieldDOMStructure
   };
 }

package/hooks/useMultiInputRangeField/useMultiInputRangeFieldRootProps.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @ignore - internal hook.
+ */
+export declare function useMultiInputRangeFieldRootProps<TForwardedProps extends {
+  [key: string]: any;
+}>(forwardedProps: TForwardedProps): UseMultiInputRangeFieldRootPropsReturnValue<TForwardedProps>;
+export type UseMultiInputRangeFieldRootPropsReturnValue<TForwardedProps extends {
+  [key: string]: any;
+}> = Omit<TForwardedProps, 'onBlur'> & {
+  onBlur: () => void;
+};

package/hooks/useMultiInputRangeField/useMultiInputRangeFieldRootProps.js

@@ -0,0 +1,31 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useMultiInputRangeFieldRootProps = useMultiInputRangeFieldRootProps;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _useEventCallback = _interopRequireDefault(require("@mui/utils/useEventCallback"));
+var _internals = require("@mui/x-date-pickers/internals");
+/**
+ * @ignore - internal hook.
+ */
+function useMultiInputRangeFieldRootProps(forwardedProps) {
+  const pickerContext = (0, _internals.useNullablePickerContext)();
+  const privatePickerContext = (0, _internals.usePickerPrivateContext)();
+  const handleBlur = (0, _useEventCallback.default)(() => {
+    if (!pickerContext || privatePickerContext.viewContainerRole !== 'tooltip') {
+      return;
+    }
+    (0, _internals.executeInTheNextEventLoopTick)(() => {
+      if (privatePickerContext.rootRefObject.current?.contains((0, _internals.getActiveElement)(document)) || pickerContext.popupRef.current?.contains((0, _internals.getActiveElement)(document))) {
+        return;
+      }
+      privatePickerContext.dismissViews();
+    });
+  });
+  return (0, _extends2.default)({}, forwardedProps, {
+    onBlur: handleBlur
+  });
+}

package/hooks/useMultiInputRangeField/useMultiInputRangeFieldSelectedSections.d.ts

@@ -3,7 +3,7 @@ import { PickerRangeValue, PickerValue, UseFieldInternalProps } from '@mui/x-dat
 import { FieldRef, FieldSelectedSections } from '@mui/x-date-pickers/models';
 import { MultiInputFieldRefs } from "../../models/index.js";
 interface UseMultiInputRangeFieldSelectedSectionsParameters extends Pick<UseFieldInternalProps<PickerRangeValue, any, any>, 'selectedSections' | 'onSelectedSectionsChange'>, MultiInputFieldRefs {}
-interface UseMultiInputFieldSelectedSectionsResponseItem {
+export interface UseMultiInputFieldSelectedSectionsResponseItem {
   unstableFieldRef?: React.Ref<FieldRef<PickerValue>>;
   selectedSections: FieldSelectedSections;
   onSelectedSectionsChange: (newSelectedSections: FieldSelectedSections) => void;
@@ -12,5 +12,8 @@ interface UseMultiInputFieldSelectedSectionsResponse {
   start: UseMultiInputFieldSelectedSectionsResponseItem;
   end: UseMultiInputFieldSelectedSectionsResponseItem;
 }
+/**
+ * @ignore - internal hook.
+ */
 export declare const useMultiInputRangeFieldSelectedSections: (parameters: UseMultiInputRangeFieldSelectedSectionsParameters) => UseMultiInputFieldSelectedSectionsResponse;
 export {};

package/hooks/useMultiInputRangeField/useMultiInputRangeFieldSelectedSections.js

@@ -1,5 +1,4 @@
 "use strict";
-'use client';
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
 var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
@@ -10,6 +9,9 @@ exports.useMultiInputRangeFieldSelectedSections = void 0;
 var React = _interopRequireWildcard(require("react"));
 var _useForkRef = _interopRequireDefault(require("@mui/utils/useForkRef"));
 var _useEventCallback = _interopRequireDefault(require("@mui/utils/useEventCallback"));
+/**
+ * @ignore - internal hook.
+ */
 const useMultiInputRangeFieldSelectedSections = parameters => {
   const unstableEndFieldRef = React.useRef(null);
   const handleUnstableEndFieldRef = (0, _useForkRef.default)(parameters.unstableEndFieldRef, unstableEndFieldRef);

package/hooks/useMultiInputRangeField/useTextFieldProps.d.ts

@@ -0,0 +1,30 @@
+import * as React from 'react';
+import { UseValidationReturnValue } from '@mui/x-date-pickers/validation';
+import { PickerValueType } from '@mui/x-date-pickers/models';
+import { FieldChangeHandler, PickerManagerEnableAccessibleFieldDOMStructure, PickerManagerError, PickerRangeValue, PickerValue, RangePosition, UseFieldInternalProps } from '@mui/x-date-pickers/internals';
+import { PickerAnyRangeManager } from "../../internals/models/managers.js";
+import { UseMultiInputFieldSelectedSectionsResponseItem } from "./useMultiInputRangeFieldSelectedSections.js";
+import type { UseMultiInputRangeFieldTextFieldProps } from './useMultiInputRangeField';
+/**
+ * @ignore - internal hook.
+ */
+export declare function useTextFieldProps<TManager extends PickerAnyRangeManager, TForwardedProps extends UseTextFieldBaseForwardedProps>(parameters: UseTextFieldPropsParameters<TManager, TForwardedProps>): UseMultiInputRangeFieldTextFieldProps<PickerManagerEnableAccessibleFieldDOMStructure<TManager>, TForwardedProps>;
+interface UseTextFieldPropsParameters<TManager extends PickerAnyRangeManager, TForwardedProps extends UseTextFieldBaseForwardedProps> {
+  valueType: PickerValueType;
+  value: PickerRangeValue;
+  onChange: FieldChangeHandler<PickerRangeValue, PickerManagerError<TManager>>;
+  autoFocus: boolean | undefined;
+  forwardedProps: TForwardedProps;
+  sharedInternalProps: UseTextFieldSharedInternalProps<TManager>;
+  selectedSectionProps: UseMultiInputFieldSelectedSectionsResponseItem;
+  position: RangePosition;
+  validation: UseValidationReturnValue<PickerRangeValue, PickerManagerError<TManager>>;
+}
+export interface UseTextFieldBaseForwardedProps {
+  onKeyDown?: React.KeyboardEventHandler;
+  onClick?: React.MouseEventHandler;
+  onFocus?: React.FocusEventHandler;
+  [key: string]: any;
+}
+interface UseTextFieldSharedInternalProps<TManager extends PickerAnyRangeManager> extends Pick<UseFieldInternalProps<PickerValue, PickerManagerEnableAccessibleFieldDOMStructure<TManager>, PickerManagerError<TManager>>, 'enableAccessibleFieldDOMStructure' | 'disabled' | 'readOnly' | 'timezone' | 'format' | 'formatDensity' | 'shouldRespectLeadingZeros'> {}
+export {};

package/hooks/useMultiInputRangeField/useTextFieldProps.js

@@ -0,0 +1,149 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTextFieldProps = useTextFieldProps;
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var React = _interopRequireWildcard(require("react"));
+var _useEventCallback = _interopRequireDefault(require("@mui/utils/useEventCallback"));
+var _managers = require("@mui/x-date-pickers/managers");
+var _hooks = require("@mui/x-date-pickers/hooks");
+var _internals = require("@mui/x-date-pickers/internals");
+var _useNullablePickerRangePositionContext = require("../../internals/hooks/useNullablePickerRangePositionContext");
+const _excluded = ["clearable", "onClear", "openPickerAriaLabel"];
+/**
+ * @ignore - internal hook.
+ */
+function useTextFieldProps(parameters) {
+  const pickerContext = (0, _internals.useNullablePickerContext)();
+  const fieldPrivateContext = (0, _internals.useNullableFieldPrivateContext)();
+  const pickerPrivateContext = (0, _internals.usePickerPrivateContext)();
+  const rangePositionContext = (0, _useNullablePickerRangePositionContext.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 = _managers.useDateManager;
+        break;
+      }
+    case 'time':
+      {
+        useManager = _managers.useTimeManager;
+        break;
+      }
+    case 'date-time':
+      {
+        useManager = _managers.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 = (0, _useEventCallback.default)(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 = (0, _useEventCallback.default)(event => {
+    openPickerIfPossible(event);
+  });
+  const handleFocus = (0, _useEventCallback.default)(event => {
+    forwardedProps.onFocus?.(event);
+    if (pickerContext?.open) {
+      setRangePosition?.(position);
+      if (previousRangePosition.current !== position && pickerContext.initialView) {
+        pickerContext.setView?.(pickerContext.initialView);
+      }
+    }
+  });
+  const handleChange = (0, _useEventCallback.default)((newSingleValue, rawContext) => {
+    const newRange = position === 'start' ? [newSingleValue, value[1]] : [value[0], newSingleValue];
+    const context = (0, _extends2.default)({}, rawContext, {
+      validationError: validation.getValidationErrorForNewValue(newRange)
+    });
+    onChange(newRange, context);
+  });
+  const allProps = (0, _extends2.default)({
+    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 = (0, _hooks.useSplitFieldProps)(allProps, valueType);
+  const internalPropsWithDefaults = (0, _internals.useFieldInternalPropsWithDefaults)({
+    manager,
+    internalProps: splittedProps.internalProps,
+    skipContextFieldRefAssignment: rangePosition !== position
+  });
+  const _ref = (0, _internals.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 = (0, _objectWithoutPropertiesLoose2.default)(_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/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/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/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'> {