@mui/x-date-pickers 8.0.0-beta.0 → 8.0.0-beta.2

package/esm/locales/deDE.js

@@ -31,8 +31,7 @@ const deDEPickers = {
   dateTimePickerToolbarTitle: 'Datum & Uhrzeit auswählen',
   timePickerToolbarTitle: 'Uhrzeit auswählen',
   dateRangePickerToolbarTitle: 'Datumsbereich auswählen',
-  // timeRangePickerToolbarTitle: 'Select time range',
-
+  timeRangePickerToolbarTitle: 'Zeitspanne auswählen',
   // Clock labels
   clockLabelText: (view, formattedTime) => `${timeViews[view] ?? view} auswählen. ${!formattedTime ? 'Keine Uhrzeit ausgewählt' : `Gewählte Uhrzeit ist ${formattedTime}`}`,
   hoursClockNumberText: hours => `${hours} ${timeViews.hours}`,
@@ -48,7 +47,7 @@ const deDEPickers = {
   // Open Picker labels
   openDatePickerDialogue: formattedDate => formattedDate ? `Datum auswählen, gewähltes Datum ist ${formattedDate}` : 'Datum auswählen',
   openTimePickerDialogue: formattedTime => formattedTime ? `Uhrzeit auswählen, gewählte Uhrzeit ist ${formattedTime}` : 'Uhrzeit auswählen',
-  // openRangePickerDialogue: formattedRange => formattedRange ? `Choose range, selected range is ${formattedRange}` : 'Choose range',
+  openRangePickerDialogue: formattedRange => formattedRange ? `Zeitspanne auswählen, die aktuell ausgewählte Zeitspanne ist ${formattedRange}` : 'Zeitspanne auswählen',
   fieldClearLabel: 'Wert leeren',
   // Table labels
   timeTableLabel: 'Uhrzeit auswählen',

package/esm/managers/useDateManager.d.ts

@@ -1,23 +1,14 @@
 import type { MakeOptional } from '@mui/x-internals/types';
 import { PickerManager, DateValidationError } from "../models/index.js";
 import { UseFieldInternalProps } from "../internals/hooks/useField/index.js";
-import { MuiPickersAdapterContextValue } from "../LocalizationProvider/LocalizationProvider.js";
-import { ExportedValidateDateProps, ValidateDatePropsToDefault, ValidateDateProps } from "../validation/validateDate.js";
-import { PickerManagerFieldInternalPropsWithDefaults, PickerValue } from "../internals/models/index.js";
+import { ExportedValidateDateProps, ValidateDateProps } from "../validation/validateDate.js";
+import { PickerValue } from "../internals/models/index.js";
 export declare function useDateManager<TEnableAccessibleFieldDOMStructure extends boolean = true>(parameters?: UseDateManagerParameters<TEnableAccessibleFieldDOMStructure>): UseDateManagerReturnValue<TEnableAccessibleFieldDOMStructure>;
-/**
- * Private utility function to get the default internal props for the fields with date editing.
- * Is used by the `useDateManager` and `useDateRangeManager` hooks.
- */
-export declare function getDateFieldInternalPropsDefaults(parameters: GetDateFieldInternalPropsDefaultsParameters): GetDateFieldInternalPropsDefaultsReturnValue;
+type SharedDateAndDateRangeValidationProps = 'disablePast' | 'disableFuture' | 'minDate' | 'maxDate';
+export declare function useApplyDefaultValuesToDateValidationProps(props: Pick<ExportedValidateDateProps, SharedDateAndDateRangeValidationProps>): Pick<ValidateDateProps, SharedDateAndDateRangeValidationProps>;
 export interface UseDateManagerParameters<TEnableAccessibleFieldDOMStructure extends boolean> {
   enableAccessibleFieldDOMStructure?: TEnableAccessibleFieldDOMStructure;
 }
 export type UseDateManagerReturnValue<TEnableAccessibleFieldDOMStructure extends boolean> = PickerManager<PickerValue, TEnableAccessibleFieldDOMStructure, DateValidationError, ValidateDateProps, DateManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure>>;
 export interface DateManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure extends boolean> extends MakeOptional<UseFieldInternalProps<PickerValue, TEnableAccessibleFieldDOMStructure, DateValidationError>, 'format'>, ExportedValidateDateProps {}
-type DateManagerFieldPropsToDefault = 'format' | ValidateDatePropsToDefault;
-interface GetDateFieldInternalPropsDefaultsParameters extends Pick<MuiPickersAdapterContextValue, 'defaultDates' | 'utils'> {
-  internalProps: Pick<DateManagerFieldInternalProps<true>, DateManagerFieldPropsToDefault>;
-}
-interface GetDateFieldInternalPropsDefaultsReturnValue extends Pick<PickerManagerFieldInternalPropsWithDefaults<UseDateManagerReturnValue<true>>, DateManagerFieldPropsToDefault> {}
 export {};

package/esm/managers/useDateManager.js

@@ -5,7 +5,7 @@ import * as React from 'react';
 import { applyDefaultDate } from "../internals/utils/date-utils.js";
 import { singleItemFieldValueManager, singleItemValueManager } from "../internals/utils/valueManagers.js";
 import { validateDate } from "../validation/index.js";
-import { useUtils } from "../internals/hooks/useUtils.js";
+import { useDefaultDates, useUtils } from "../internals/hooks/useUtils.js";
 import { usePickerTranslations } from "../hooks/usePickerTranslations.js";
 export function useDateManager(parameters = {}) {
   const {
@@ -17,42 +17,32 @@ export function useDateManager(parameters = {}) {
     internal_valueManager: singleItemValueManager,
     internal_fieldValueManager: singleItemFieldValueManager,
     internal_enableAccessibleFieldDOMStructure: enableAccessibleFieldDOMStructure,
-    internal_applyDefaultsToFieldInternalProps: ({
-      internalProps,
-      utils,
-      defaultDates
-    }) => _extends({}, internalProps, getDateFieldInternalPropsDefaults({
-      defaultDates,
-      utils,
-      internalProps
-    })),
+    internal_useApplyDefaultValuesToFieldInternalProps: useApplyDefaultValuesToDateFieldInternalProps,
     internal_useOpenPickerButtonAriaLabel: useOpenPickerButtonAriaLabel
   }), [enableAccessibleFieldDOMStructure]);
 }
-function useOpenPickerButtonAriaLabel() {
+function useOpenPickerButtonAriaLabel(value) {
   const utils = useUtils();
   const translations = usePickerTranslations();
-  return React.useCallback(value => {
+  return React.useMemo(() => {
     const formattedValue = utils.isValid(value) ? utils.format(value, 'fullDate') : null;
     return translations.openDatePickerDialogue(formattedValue);
-  }, [translations, utils]);
+  }, [value, translations, utils]);
 }
-
-/**
- * Private utility function to get the default internal props for the fields with date editing.
- * Is used by the `useDateManager` and `useDateRangeManager` hooks.
- */
-export function getDateFieldInternalPropsDefaults(parameters) {
-  const {
-    defaultDates,
-    utils,
-    internalProps
-  } = parameters;
-  return {
-    format: internalProps.format ?? utils.formats.keyboardDate,
-    disablePast: internalProps.disablePast ?? false,
-    disableFuture: internalProps.disableFuture ?? false,
-    minDate: applyDefaultDate(utils, internalProps.minDate, defaultDates.minDate),
-    maxDate: applyDefaultDate(utils, internalProps.maxDate, defaultDates.maxDate)
-  };
+function useApplyDefaultValuesToDateFieldInternalProps(internalProps) {
+  const utils = useUtils();
+  const validationProps = useApplyDefaultValuesToDateValidationProps(internalProps);
+  return React.useMemo(() => _extends({}, internalProps, validationProps, {
+    format: internalProps.format ?? utils.formats.keyboardDate
+  }), [internalProps, validationProps, utils]);
+}
+export function useApplyDefaultValuesToDateValidationProps(props) {
+  const utils = useUtils();
+  const defaultDates = useDefaultDates();
+  return React.useMemo(() => ({
+    disablePast: props.disablePast ?? false,
+    disableFuture: props.disableFuture ?? false,
+    minDate: applyDefaultDate(utils, props.minDate, defaultDates.minDate),
+    maxDate: applyDefaultDate(utils, props.maxDate, defaultDates.maxDate)
+  }), [props.minDate, props.maxDate, props.disableFuture, props.disablePast, utils, defaultDates]);
 }

package/esm/managers/useDateTimeManager.d.ts

@@ -1,24 +1,15 @@
 import type { MakeOptional } from '@mui/x-internals/types';
 import { PickerManager, DateTimeValidationError } from "../models/index.js";
 import { UseFieldInternalProps } from "../internals/hooks/useField/index.js";
-import { MuiPickersAdapterContextValue } from "../LocalizationProvider/LocalizationProvider.js";
 import { AmPmProps } from "../internals/models/props/time.js";
-import { ExportedValidateDateTimeProps, ValidateDateTimeProps, ValidateDateTimePropsToDefault } from "../validation/validateDateTime.js";
-import { PickerManagerFieldInternalPropsWithDefaults, PickerValue } from "../internals/models/index.js";
+import { ExportedValidateDateTimeProps, ValidateDateTimeProps } from "../validation/validateDateTime.js";
+import { PickerValue } from "../internals/models/index.js";
 export declare function useDateTimeManager<TEnableAccessibleFieldDOMStructure extends boolean = true>(parameters?: UseDateTimeManagerParameters<TEnableAccessibleFieldDOMStructure>): UseDateTimeManagerReturnValue<TEnableAccessibleFieldDOMStructure>;
-/**
- * Private utility function to get the default internal props for the field with date time editing.
- * Is used by the `useDateTimeManager` and `useDateTimeRangeManager` hooks.
- */
-export declare function getDateTimeFieldInternalPropsDefaults(parameters: GetDateTimeFieldInternalPropsDefaultsParameters): GetDateTimeFieldInternalPropsDefaultsReturnValue;
+type SharedDateTimeAndDateTimeRangeValidationProps = 'disablePast' | 'disableFuture' | 'minTime' | 'maxTime' | 'minDate' | 'maxDate';
+export declare function useApplyDefaultValuesToDateTimeValidationProps(props: Pick<ExportedValidateDateTimeProps, SharedDateTimeAndDateTimeRangeValidationProps | 'minDateTime' | 'maxDateTime'>): Pick<ValidateDateTimeProps, SharedDateTimeAndDateTimeRangeValidationProps>;
 export interface UseDateTimeManagerParameters<TEnableAccessibleFieldDOMStructure extends boolean> {
   enableAccessibleFieldDOMStructure?: TEnableAccessibleFieldDOMStructure;
 }
 export type UseDateTimeManagerReturnValue<TEnableAccessibleFieldDOMStructure extends boolean> = PickerManager<PickerValue, TEnableAccessibleFieldDOMStructure, DateTimeValidationError, ValidateDateTimeProps, DateTimeManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure>>;
 export interface DateTimeManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure extends boolean> extends MakeOptional<UseFieldInternalProps<PickerValue, TEnableAccessibleFieldDOMStructure, DateTimeValidationError>, 'format'>, ExportedValidateDateTimeProps, AmPmProps {}
-type DateTimeManagerFieldPropsToDefault = 'format' | 'minTime' | 'maxTime' | ValidateDateTimePropsToDefault;
-interface GetDateTimeFieldInternalPropsDefaultsParameters extends Pick<MuiPickersAdapterContextValue, 'defaultDates' | 'utils'> {
-  internalProps: Pick<DateTimeManagerFieldInternalProps<true>, DateTimeManagerFieldPropsToDefault | 'minDateTime' | 'maxDateTime' | 'ampm'>;
-}
-interface GetDateTimeFieldInternalPropsDefaultsReturnValue extends Pick<PickerManagerFieldInternalPropsWithDefaults<UseDateTimeManagerReturnValue<true>>, DateTimeManagerFieldPropsToDefault | 'disableIgnoringDatePartForTimeValidation'> {}
 export {};

package/esm/managers/useDateTimeManager.js

@@ -5,7 +5,7 @@ import * as React from 'react';
 import { applyDefaultDate } from "../internals/utils/date-utils.js";
 import { singleItemFieldValueManager, singleItemValueManager } from "../internals/utils/valueManagers.js";
 import { validateDateTime } from "../validation/index.js";
-import { useUtils } from "../internals/hooks/useUtils.js";
+import { useDefaultDates, useUtils } from "../internals/hooks/useUtils.js";
 import { usePickerTranslations } from "../hooks/usePickerTranslations.js";
 export function useDateTimeManager(parameters = {}) {
   const {
@@ -17,47 +17,37 @@ export function useDateTimeManager(parameters = {}) {
     internal_valueManager: singleItemValueManager,
     internal_fieldValueManager: singleItemFieldValueManager,
     internal_enableAccessibleFieldDOMStructure: enableAccessibleFieldDOMStructure,
-    internal_applyDefaultsToFieldInternalProps: ({
-      internalProps,
-      utils,
-      defaultDates
-    }) => _extends({}, internalProps, getDateTimeFieldInternalPropsDefaults({
-      internalProps,
-      utils,
-      defaultDates
-    })),
+    internal_useApplyDefaultValuesToFieldInternalProps: useApplyDefaultValuesToDateTimeFieldInternalProps,
     internal_useOpenPickerButtonAriaLabel: useOpenPickerButtonAriaLabel
   }), [enableAccessibleFieldDOMStructure]);
 }
-function useOpenPickerButtonAriaLabel() {
+function useOpenPickerButtonAriaLabel(value) {
   const utils = useUtils();
   const translations = usePickerTranslations();
-  return React.useCallback(value => {
+  return React.useMemo(() => {
     const formattedValue = utils.isValid(value) ? utils.format(value, 'fullDate') : null;
     return translations.openDatePickerDialogue(formattedValue);
-  }, [translations, utils]);
+  }, [value, translations, utils]);
 }
-
-/**
- * Private utility function to get the default internal props for the field with date time editing.
- * Is used by the `useDateTimeManager` and `useDateTimeRangeManager` hooks.
- */
-export function getDateTimeFieldInternalPropsDefaults(parameters) {
-  const {
-    defaultDates,
-    utils,
-    internalProps
-  } = parameters;
-  const ampm = internalProps.ampm ?? utils.is12HourCycleInCurrentLocale();
-  const defaultFormat = ampm ? utils.formats.keyboardDateTime12h : utils.formats.keyboardDateTime24h;
-  return {
-    disablePast: internalProps.disablePast ?? false,
-    disableFuture: internalProps.disableFuture ?? false,
-    format: internalProps.format ?? defaultFormat,
-    disableIgnoringDatePartForTimeValidation: Boolean(internalProps.minDateTime || internalProps.maxDateTime),
-    minDate: applyDefaultDate(utils, internalProps.minDateTime ?? internalProps.minDate, defaultDates.minDate),
-    maxDate: applyDefaultDate(utils, internalProps.maxDateTime ?? internalProps.maxDate, defaultDates.maxDate),
-    minTime: internalProps.minDateTime ?? internalProps.minTime,
-    maxTime: internalProps.maxDateTime ?? internalProps.maxTime
-  };
+function useApplyDefaultValuesToDateTimeFieldInternalProps(internalProps) {
+  const utils = useUtils();
+  const validationProps = useApplyDefaultValuesToDateTimeValidationProps(internalProps);
+  const ampm = React.useMemo(() => internalProps.ampm ?? utils.is12HourCycleInCurrentLocale(), [internalProps.ampm, utils]);
+  return React.useMemo(() => _extends({}, internalProps, validationProps, {
+    format: internalProps.format ?? (ampm ? utils.formats.keyboardDateTime12h : utils.formats.keyboardDateTime24h)
+  }), [internalProps, validationProps, ampm, utils]);
+}
+export function useApplyDefaultValuesToDateTimeValidationProps(props) {
+  const utils = useUtils();
+  const defaultDates = useDefaultDates();
+  return React.useMemo(() => ({
+    disablePast: props.disablePast ?? false,
+    disableFuture: props.disableFuture ?? false,
+    // TODO: Explore if we can remove it from the public API
+    disableIgnoringDatePartForTimeValidation: !!props.minDateTime || !!props.maxDateTime || !!props.disableFuture || !!props.disablePast,
+    minDate: applyDefaultDate(utils, props.minDateTime ?? props.minDate, defaultDates.minDate),
+    maxDate: applyDefaultDate(utils, props.maxDateTime ?? props.maxDate, defaultDates.maxDate),
+    minTime: props.minDateTime ?? props.minTime,
+    maxTime: props.maxDateTime ?? props.maxTime
+  }), [props.minDateTime, props.maxDateTime, props.minTime, props.maxTime, props.minDate, props.maxDate, props.disableFuture, props.disablePast, utils, defaultDates]);
 }

package/esm/managers/useTimeManager.d.ts

@@ -1,24 +1,15 @@
 import type { MakeOptional } from '@mui/x-internals/types';
 import { PickerManager, TimeValidationError } from "../models/index.js";
 import { UseFieldInternalProps } from "../internals/hooks/useField/index.js";
-import { MuiPickersAdapterContextValue } from "../LocalizationProvider/LocalizationProvider.js";
 import { AmPmProps } from "../internals/models/props/time.js";
-import { ExportedValidateTimeProps, ValidateTimeProps, ValidateTimePropsToDefault } from "../validation/validateTime.js";
-import { PickerManagerFieldInternalPropsWithDefaults, PickerValue } from "../internals/models/index.js";
+import { ExportedValidateTimeProps, ValidateTimeProps } from "../validation/validateTime.js";
+import { PickerValue } from "../internals/models/index.js";
 export declare function useTimeManager<TEnableAccessibleFieldDOMStructure extends boolean = true>(parameters?: UseTimeManagerParameters<TEnableAccessibleFieldDOMStructure>): UseTimeManagerReturnValue<TEnableAccessibleFieldDOMStructure>;
-/**
- * Private utility function to get the default internal props for the fields with time editing.
- * Is used by the `useTimeManager` and `useTimeRangeManager` hooks.
- */
-export declare function getTimeFieldInternalPropsDefaults(parameters: GetTimeFieldInternalPropsDefaultsParameters): GetTimeFieldInternalPropsDefaultsReturnValue;
+type SharedTimeAndTimeRangeValidationProps = 'disablePast' | 'disableFuture';
+export declare function useApplyDefaultValuesToTimeValidationProps(props: Pick<ExportedValidateTimeProps, SharedTimeAndTimeRangeValidationProps>): Pick<ValidateTimeProps, SharedTimeAndTimeRangeValidationProps>;
 export interface UseTimeManagerParameters<TEnableAccessibleFieldDOMStructure extends boolean> extends AmPmProps {
   enableAccessibleFieldDOMStructure?: TEnableAccessibleFieldDOMStructure;
 }
 export type UseTimeManagerReturnValue<TEnableAccessibleFieldDOMStructure extends boolean> = PickerManager<PickerValue, TEnableAccessibleFieldDOMStructure, TimeValidationError, ValidateTimeProps, TimeManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure>>;
 export interface TimeManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure extends boolean> extends MakeOptional<UseFieldInternalProps<PickerValue, TEnableAccessibleFieldDOMStructure, TimeValidationError>, 'format'>, ExportedValidateTimeProps, AmPmProps {}
-type TimeManagerFieldPropsToDefault = 'format' | ValidateTimePropsToDefault;
-interface GetTimeFieldInternalPropsDefaultsParameters extends Pick<MuiPickersAdapterContextValue, 'utils'> {
-  internalProps: Pick<TimeManagerFieldInternalProps<true>, TimeManagerFieldPropsToDefault | 'ampm'>;
-}
-interface GetTimeFieldInternalPropsDefaultsReturnValue extends Pick<PickerManagerFieldInternalPropsWithDefaults<UseTimeManagerReturnValue<true>>, TimeManagerFieldPropsToDefault> {}
 export {};

package/esm/managers/useTimeManager.js

@@ -17,42 +17,32 @@ export function useTimeManager(parameters = {}) {
     internal_valueManager: singleItemValueManager,
     internal_fieldValueManager: singleItemFieldValueManager,
     internal_enableAccessibleFieldDOMStructure: enableAccessibleFieldDOMStructure,
-    internal_applyDefaultsToFieldInternalProps: ({
-      internalProps,
-      utils
-    }) => _extends({}, internalProps, getTimeFieldInternalPropsDefaults({
-      utils,
-      internalProps
-    })),
+    internal_useApplyDefaultValuesToFieldInternalProps: useApplyDefaultValuesToTimeFieldInternalProps,
     internal_useOpenPickerButtonAriaLabel: createUseOpenPickerButtonAriaLabel(ampm)
   }), [ampm, enableAccessibleFieldDOMStructure]);
 }
 function createUseOpenPickerButtonAriaLabel(ampm) {
-  return function useOpenPickerButtonAriaLabel() {
+  return function useOpenPickerButtonAriaLabel(value) {
     const utils = useUtils();
     const translations = usePickerTranslations();
-    return React.useCallback(value => {
+    return React.useMemo(() => {
       const formatKey = ampm ?? utils.is12HourCycleInCurrentLocale() ? 'fullTime12h' : 'fullTime24h';
       const formattedValue = utils.isValid(value) ? utils.format(value, formatKey) : null;
       return translations.openTimePickerDialogue(formattedValue);
-    }, [translations, utils]);
+    }, [value, translations, utils]);
   };
 }
-
-/**
- * Private utility function to get the default internal props for the fields with time editing.
- * Is used by the `useTimeManager` and `useTimeRangeManager` hooks.
- */
-export function getTimeFieldInternalPropsDefaults(parameters) {
-  const {
-    utils,
-    internalProps
-  } = parameters;
-  const ampm = internalProps.ampm ?? utils.is12HourCycleInCurrentLocale();
-  const defaultFormat = ampm ? utils.formats.fullTime12h : utils.formats.fullTime24h;
-  return {
-    disablePast: internalProps.disablePast ?? false,
-    disableFuture: internalProps.disableFuture ?? false,
-    format: internalProps.format ?? defaultFormat
-  };
+function useApplyDefaultValuesToTimeFieldInternalProps(internalProps) {
+  const utils = useUtils();
+  const validationProps = useApplyDefaultValuesToTimeValidationProps(internalProps);
+  const ampm = React.useMemo(() => internalProps.ampm ?? utils.is12HourCycleInCurrentLocale(), [internalProps.ampm, utils]);
+  return React.useMemo(() => _extends({}, internalProps, validationProps, {
+    format: internalProps.format ?? (ampm ? utils.formats.fullTime12h : utils.formats.fullTime24h)
+  }), [internalProps, validationProps, ampm, utils]);
+}
+export function useApplyDefaultValuesToTimeValidationProps(props) {
+  return React.useMemo(() => ({
+    disablePast: props.disablePast ?? false,
+    disableFuture: props.disableFuture ?? false
+  }), [props.disablePast, props.disableFuture]);
 }

package/esm/models/fields.d.ts

@@ -1,7 +1,7 @@
 import * as React from 'react';
 import { TextFieldProps } from '@mui/material/TextField';
 import type { ExportedPickersSectionListProps } from '../PickersSectionList';
-import type { UseFieldInternalProps, UseFieldResponse } from '../internals/hooks/useField';
+import type { UseFieldInternalProps, UseFieldReturnValue } from '../internals/hooks/useField';
 import type { PickersTextFieldProps } from '../PickersTextField';
 import { BaseSingleInputFieldProps, FieldRangeSection, PickerRangeValue, PickerValidValue } from "../internals/models/index.js";
 import { PickerOwnerState } from "./pickers.js";
@@ -131,7 +131,7 @@ export type PickerFieldSlotProps<TValue extends PickerValidValue, TEnableAccessi
  * Props the text field receives when used inside a single input Picker.
  * Only contains what the MUI components are passing to the text field, not what users can pass using the `props.slotProps.field` and `props.slotProps.textField`.
  */
-export type BaseSingleInputPickersTextFieldProps<TEnableAccessibleFieldDOMStructure extends boolean> = Omit<UseFieldResponse<TEnableAccessibleFieldDOMStructure, BaseSingleInputFieldProps>, 'slots' | 'slotProps' | 'clearable' | 'onClear' | 'openPickerButtonPosition' | 'clearButtonPosition' | 'openPickerAriaLabel'>;
+export type BaseSingleInputPickersTextFieldProps<TEnableAccessibleFieldDOMStructure extends boolean> = Omit<UseFieldReturnValue<TEnableAccessibleFieldDOMStructure, BaseSingleInputFieldProps>, 'slots' | 'slotProps' | 'clearable' | 'onClear' | 'openPickerButtonPosition' | 'clearButtonPosition' | 'openPickerAriaLabel'>;
 /**
  * Props the built-in text field component can receive.
  */

package/esm/models/manager.d.ts

@@ -1,5 +1,4 @@
 import type { FieldValueManager, UseFieldInternalProps } from '../internals/hooks/useField';
-import type { UseLocalizationContextReturnValue } from '../internals/hooks/useUtils';
 import type { PickerValidValue, PickerValueManager } from '../internals/models';
 import type { Validator } from '../validation';
 import type { PickerValueType } from './common';
@@ -66,17 +65,14 @@ export interface PickerManager<TValue extends PickerValidValue, TEnableAccessibl
    * - a default format to display the value in the field
    * - some default validation props that are needed to validate the value (e.g: minDate, maxDate)
    * This property is not part of the public API and should not be used directly.
-   * @param {ApplyDefaultsToFieldInternalPropsParameters<TFieldInternalProps>} parameters The parameters to apply the defaults.
+   * @param {TFieldInternalProps<TFieldInternalProps>} internalProps The field internal props to apply the defaults to.
    * @returns {TFieldInternalPropsWithDefaults} The field internal props with the defaults applied.
    */
-  internal_applyDefaultsToFieldInternalProps: (parameters: ApplyDefaultsToFieldInternalPropsParameters<TFieldInternalProps>) => UseFieldInternalProps<TValue, TEnableAccessibleFieldDOMStructure, TError> & TValidationProps;
+  internal_useApplyDefaultValuesToFieldInternalProps: (internalProps: TFieldInternalProps) => UseFieldInternalProps<TValue, TEnableAccessibleFieldDOMStructure, TError> & TValidationProps;
   /**
    * Returns a hook that creates the aria-label to apply on the button that opens the Picker.
-   * @returns {(value: TValue) => string} The method to create the aria-label to apply on the button that opens the Picker.
+   * @param {TValue} value The value of the Picker.
+   * @returns {string} The aria-label to apply on the button that opens the Picker.
    */
-  internal_useOpenPickerButtonAriaLabel: () => (value: TValue) => string;
-}
-interface ApplyDefaultsToFieldInternalPropsParameters<TFieldInternalProps extends {}> extends UseLocalizationContextReturnValue {
-  internalProps: TFieldInternalProps;
-}
-export {};
+  internal_useOpenPickerButtonAriaLabel: (value: TValue) => string;
+}

package/esm/validation/validateDate.js

@@ -1,4 +1,3 @@
-import { applyDefaultDate } from "../internals/utils/date-utils.js";
 import { singleItemValueManager } from "../internals/utils/valueManagers.js";
 
 /**
@@ -27,11 +26,11 @@ export const validateDate = ({
     shouldDisableMonth,
     shouldDisableYear,
     disablePast,
-    disableFuture
+    disableFuture,
+    minDate,
+    maxDate
   } = props;
   const now = adapter.utils.date(undefined, timezone);
-  const minDate = applyDefaultDate(adapter.utils, props.minDate, adapter.defaultDates.minDate);
-  const maxDate = applyDefaultDate(adapter.utils, props.maxDate, adapter.defaultDates.maxDate);
   switch (true) {
     case !adapter.utils.isValid(value):
       return 'invalidDate';

package/hooks/useSplitFieldProps.d.ts

@@ -1,7 +1,7 @@
 import { DATE_TIME_VALIDATION_PROP_NAMES, DATE_VALIDATION_PROP_NAMES, TIME_VALIDATION_PROP_NAMES } from "../validation/extractValidationProps.js";
 import { PickerValueType } from "../models/common.js";
 declare const SHARED_FIELD_INTERNAL_PROP_NAMES: readonly ["value", "defaultValue", "referenceDate", "format", "formatDensity", "onChange", "timezone", "onError", "shouldRespectLeadingZeros", "selectedSections", "onSelectedSectionsChange", "unstableFieldRef", "unstableStartFieldRef", "unstableEndFieldRef", "enableAccessibleFieldDOMStructure", "disabled", "readOnly", "dateSeparator", "autoFocus", "focused"];
-type InternalPropNames<TValueType extends PickerValueType> = (typeof SHARED_FIELD_INTERNAL_PROP_NAMES)[number] | (TValueType extends 'date' | 'date-time' ? (typeof DATE_VALIDATION_PROP_NAMES)[number] : never) | (TValueType extends 'time' | 'date-time' ? (typeof TIME_VALIDATION_PROP_NAMES)[number] : never) | (TValueType extends 'date-time' ? (typeof DATE_TIME_VALIDATION_PROP_NAMES)[number] : never);
+export type InternalPropNames<TValueType extends PickerValueType> = (typeof SHARED_FIELD_INTERNAL_PROP_NAMES)[number] | (TValueType extends 'date' | 'date-time' ? (typeof DATE_VALIDATION_PROP_NAMES)[number] : never) | (TValueType extends 'time' | 'date-time' ? (typeof TIME_VALIDATION_PROP_NAMES)[number] : never) | (TValueType extends 'date-time' ? (typeof DATE_TIME_VALIDATION_PROP_NAMES)[number] : never);
 /**
  * Split the props received by the field component into:
  * - `internalProps` which are used by the various hooks called by the field component.

package/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-date-pickers v8.0.0-beta.0
+ * @mui/x-date-pickers v8.0.0-beta.2
  *
  * @license MIT
  * This source code is licensed under the MIT license found in the

package/internals/components/PickerFieldUI.d.ts

@@ -6,9 +6,9 @@ import { SvgIconProps } from '@mui/material/SvgIcon';
 import { MakeOptional, SlotComponentPropsFromProps } from '@mui/x-internals/types';
 import { FieldOwnerState } from "../../models/index.js";
 import { UseFieldOwnerStateParameters } from "../hooks/useFieldOwnerState.js";
-import type { UseFieldResponse } from '../hooks/useField';
+import type { UseFieldReturnValue, UseFieldProps } from '../hooks/useField';
 import { PickersTextFieldProps } from "../../PickersTextField/index.js";
-export declare const cleanFieldResponse: <TFieldResponse extends MakeOptional<UseFieldResponse<any, ExportedPickerFieldUIProps & {
+export declare const cleanFieldResponse: <TFieldResponse extends MakeOptional<UseFieldReturnValue<any, ExportedPickerFieldUIProps & {
   [key: string]: any;
 }>, "onClear" | "clearable">>({
   enableAccessibleFieldDOMStructure,
@@ -22,7 +22,7 @@ export declare const PickerFieldUIContext: React.Context<PickerFieldUIContextVal
  * Adds the button to open the Picker and the button to clear the value of the field.
  * @ignore - internal component.
  */
-export declare function PickerFieldUI(props: PickerFieldUIProps): React.JSX.Element;
+export declare function PickerFieldUI<TEnableAccessibleFieldDOMStructure extends boolean, TProps extends UseFieldProps<TEnableAccessibleFieldDOMStructure>>(props: PickerFieldUIProps<TEnableAccessibleFieldDOMStructure, TProps>): React.JSX.Element;
 export interface ExportedPickerFieldUIProps {
   /**
    * If `true`, a clear button will be shown in the field allowing value clearing.
@@ -46,7 +46,7 @@ export interface ExportedPickerFieldUIProps {
    */
   openPickerButtonPosition?: 'start' | 'end';
 }
-export interface PickerFieldUIProps {
+export interface PickerFieldUIProps<TEnableAccessibleFieldDOMStructure extends boolean, TProps extends UseFieldProps<TEnableAccessibleFieldDOMStructure>> {
   /**
    * Overridable component slots.
    * @default {}
@@ -60,7 +60,7 @@ export interface PickerFieldUIProps {
   /**
    * Object returned by the `useField` hook or one of its wrapper (for example `useDateField`).
    */
-  fieldResponse: UseFieldResponse<any, any>;
+  fieldResponse: UseFieldReturnValue<TEnableAccessibleFieldDOMStructure, TProps>;
   /**
    * The component to use to render the Picker opening icon if none is provided in the Picker's slots.
    */

package/internals/hooks/useField/buildSectionsFromFormat.d.ts

@@ -1,6 +1,6 @@
 import { FieldSection, MuiPickersAdapter, PickerValidDate } from "../../../models/index.js";
 import { PickersLocaleText } from "../../../locales/index.js";
-interface BuildSectionsFromFormatParams {
+interface BuildSectionsFromFormatParameters {
   utils: MuiPickersAdapter;
   format: string;
   formatDensity: 'dense' | 'spacious';
@@ -11,5 +11,5 @@ interface BuildSectionsFromFormatParams {
   date: PickerValidDate | null;
   enableAccessibleFieldDOMStructure: boolean;
 }
-export declare const buildSectionsFromFormat: (params: BuildSectionsFromFormatParams) => FieldSection[];
+export declare const buildSectionsFromFormat: (parameters: BuildSectionsFromFormatParameters) => FieldSection[];
 export {};

package/internals/hooks/useField/buildSectionsFromFormat.js

@@ -148,12 +148,12 @@ const createSection = ({
     modified: false
   });
 };
-const buildSections = params => {
+const buildSections = parameters => {
   const {
     utils,
     expandedFormat,
     escapedParts
-  } = params;
+  } = parameters;
   const now = utils.date(undefined);
   const sections = [];
   let startSeparator = '';
@@ -178,7 +178,7 @@ const buildSections = params => {
       while (word.length > 0) {
         const firstWord = regExpFirstTokenInWord.exec(word)[1];
         word = word.slice(firstWord.length);
-        sections.push(createSection((0, _extends2.default)({}, params, {
+        sections.push(createSection((0, _extends2.default)({}, parameters, {
           now,
           token: firstWord,
           startSeparator
@@ -243,19 +243,19 @@ const postProcessSections = ({
     return section;
   });
 };
-const buildSectionsFromFormat = params => {
-  let expandedFormat = expandFormat(params);
-  if (params.isRtl && params.enableAccessibleFieldDOMStructure) {
+const buildSectionsFromFormat = parameters => {
+  let expandedFormat = expandFormat(parameters);
+  if (parameters.isRtl && parameters.enableAccessibleFieldDOMStructure) {
     expandedFormat = expandedFormat.split(' ').reverse().join(' ');
   }
-  const escapedParts = getEscapedPartsFromFormat((0, _extends2.default)({}, params, {
+  const escapedParts = getEscapedPartsFromFormat((0, _extends2.default)({}, parameters, {
     expandedFormat
   }));
-  const sections = buildSections((0, _extends2.default)({}, params, {
+  const sections = buildSections((0, _extends2.default)({}, parameters, {
     expandedFormat,
     escapedParts
   }));
-  return postProcessSections((0, _extends2.default)({}, params, {
+  return postProcessSections((0, _extends2.default)({}, parameters, {
     sections
   }));
 };

package/internals/hooks/useField/index.d.ts

@@ -1,4 +1,4 @@
 export { useField } from "./useField.js";
-export type { FieldValueManager, UseFieldInternalProps, UseFieldParams, UseFieldResponse, FieldChangeHandler, FieldChangeHandlerContext } from './useField.types';
+export type { UseFieldInternalProps, UseFieldParameters, UseFieldReturnValue, UseFieldProps, FieldValueManager, FieldChangeHandler, FieldChangeHandlerContext } from './useField.types';
 export { createDateStrForV7HiddenInputFromSections, createDateStrForV6InputFromSections } from "./useField.utils.js";
 export { useFieldInternalPropsWithDefaults } from "./useFieldInternalPropsWithDefaults.js";

package/internals/hooks/useField/syncSelectionToDOM.d.ts

@@ -0,0 +1,9 @@
+import { PickerValidValue } from "../../models/index.js";
+import { UseFieldDOMGetters } from "./useField.types.js";
+import { UseFieldStateReturnValue } from "./useFieldState.js";
+export declare function syncSelectionToDOM<TValue extends PickerValidValue>(parameters: SyncSelectionToDOMParameters<TValue>): void;
+export interface SyncSelectionToDOMParameters<TValue extends PickerValidValue> {
+  domGetters: UseFieldDOMGetters;
+  stateResponse: UseFieldStateReturnValue<TValue>;
+  focused: boolean;
+}

package/internals/hooks/useField/syncSelectionToDOM.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.syncSelectionToDOM = syncSelectionToDOM;
+var _utils = require("../../utils/utils");
+function syncSelectionToDOM(parameters) {
+  const {
+    focused,
+    domGetters,
+    stateResponse: {
+      // States and derived states
+      parsedSelectedSections,
+      state
+    }
+  } = parameters;
+  if (!domGetters.isReady()) {
+    return;
+  }
+  const selection = document.getSelection();
+  if (!selection) {
+    return;
+  }
+  if (parsedSelectedSections == null) {
+    // If the selection contains an element inside the field, we reset it.
+    if (selection.rangeCount > 0 && domGetters.getRoot().contains(selection.getRangeAt(0).startContainer)) {
+      selection.removeAllRanges();
+    }
+    if (focused) {
+      domGetters.getRoot().blur();
+    }
+    return;
+  }
+
+  // On multi input range pickers we want to update selection range only for the active input
+  if (!domGetters.getRoot().contains((0, _utils.getActiveElement)(document))) {
+    return;
+  }
+  const range = new window.Range();
+  let target;
+  if (parsedSelectedSections === 'all') {
+    target = domGetters.getRoot();
+  } else {
+    const section = state.sections[parsedSelectedSections];
+    if (section.type === 'empty') {
+      target = domGetters.getSectionContainer(parsedSelectedSections);
+    } else {
+      target = domGetters.getSectionContent(parsedSelectedSections);
+    }
+  }
+  range.selectNodeContents(target);
+  target.focus();
+  selection.removeAllRanges();
+  selection.addRange(range);
+}

package/internals/hooks/useField/useField.d.ts

@@ -1,5 +1,3 @@
-import { UseFieldParams, UseFieldResponse, UseFieldCommonForwardedProps, UseFieldInternalProps, UseFieldForwardedProps } from "./useField.types.js";
+import { UseFieldParameters, UseFieldReturnValue, UseFieldProps } from "./useField.types.js";
 import { PickerValidValue } from "../../models/index.js";
-export declare const useField: <TValue extends PickerValidValue, TEnableAccessibleFieldDOMStructure extends boolean, TForwardedProps extends UseFieldCommonForwardedProps & UseFieldForwardedProps<TEnableAccessibleFieldDOMStructure>, TInternalProps extends UseFieldInternalProps<TValue, TEnableAccessibleFieldDOMStructure, any> & {
-  minutesStep?: number;
-}>(params: UseFieldParams<TValue, TEnableAccessibleFieldDOMStructure, TForwardedProps, TInternalProps>) => UseFieldResponse<TEnableAccessibleFieldDOMStructure, TForwardedProps>;
+export declare const useField: <TValue extends PickerValidValue, TEnableAccessibleFieldDOMStructure extends boolean, TError, TValidationProps extends {}, TProps extends UseFieldProps<TEnableAccessibleFieldDOMStructure>>(parameters: UseFieldParameters<TValue, TEnableAccessibleFieldDOMStructure, TError, TValidationProps, TProps>) => UseFieldReturnValue<TEnableAccessibleFieldDOMStructure, TProps>;