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

package/internals/utils/date-fields-utils.js

@@ -1,5 +1,13 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-export const splitDateRangeSections = sections => {
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getRangeFieldType = getRangeFieldType;
+exports.splitDateRangeSections = exports.removeLastSeparator = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+const splitDateRangeSections = sections => {
   const startDateSections = [];
   const endDateSections = [];
   sections.forEach(section => {
@@ -14,11 +22,17 @@ export const splitDateRangeSections = sections => {
     endDate: endDateSections
   };
 };
-export const removeLastSeparator = dateSections => dateSections.map((section, sectionIndex) => {
+exports.splitDateRangeSections = splitDateRangeSections;
+const removeLastSeparator = dateSections => dateSections.map((section, sectionIndex) => {
   if (sectionIndex === dateSections.length - 1) {
-    return _extends({}, section, {
+    return (0, _extends2.default)({}, section, {
       separator: null
     });
   }
   return section;
-});
+});
+exports.removeLastSeparator = removeLastSeparator;
+function getRangeFieldType(field) {
+  const fieldType = field.fieldType ?? 'multi-input';
+  return fieldType;
+}

package/internals/utils/date-range-manager.d.ts

@@ -1,24 +1,32 @@
 import { MuiPickersAdapter, PickerValidDate } from '@mui/x-date-pickers/models';
 import { PickerRangeValue } from '@mui/x-date-pickers/internals';
-import { RangePosition } from '../../models';
+import { RangePosition } from "../../models/index.js";
 interface CalculateRangeChangeOptions {
-    utils: MuiPickersAdapter;
-    range: PickerRangeValue;
-    newDate: PickerValidDate | null;
-    rangePosition: RangePosition;
-    /**
-     * Should allow flipping range `start` and `end` dates if the `newDate` would result in a new range creation.
-     *
-     * It is used to allow dragging range `start` date past `end` date essentially becoming the new `end` date and vice versa.
-     */
-    allowRangeFlip?: boolean;
-    shouldMergeDateAndTime?: boolean;
-    referenceDate?: PickerValidDate;
+  utils: MuiPickersAdapter;
+  range: PickerRangeValue;
+  newDate: PickerValidDate | null;
+  rangePosition: RangePosition;
+  /**
+   * Should allow flipping range `start` and `end` dates if the `newDate` would result in a new range creation.
+   *
+   * It is used to allow dragging range `start` date past `end` date essentially becoming the new `end` date and vice versa.
+   */
+  allowRangeFlip?: boolean;
+  shouldMergeDateAndTime?: boolean;
+  referenceDate?: PickerValidDate;
 }
 interface CalculateRangeChangeResponse {
-    nextSelection: RangePosition;
-    newRange: PickerRangeValue;
+  nextSelection: RangePosition;
+  newRange: PickerRangeValue;
 }
-export declare function calculateRangeChange({ utils, range, newDate: selectedDate, rangePosition, allowRangeFlip, shouldMergeDateAndTime, referenceDate, }: CalculateRangeChangeOptions): CalculateRangeChangeResponse;
+export declare function calculateRangeChange({
+  utils,
+  range,
+  newDate: selectedDate,
+  rangePosition,
+  allowRangeFlip,
+  shouldMergeDateAndTime,
+  referenceDate
+}: CalculateRangeChangeOptions): CalculateRangeChangeResponse;
 export declare function calculateRangePreview(options: CalculateRangeChangeOptions): PickerRangeValue;
-export {};
+export {};

package/internals/utils/date-range-manager.js

@@ -1,5 +1,12 @@
-import { mergeDateAndTime } from '@mui/x-date-pickers/internals';
-export function calculateRangeChange({
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calculateRangeChange = calculateRangeChange;
+exports.calculateRangePreview = calculateRangePreview;
+var _internals = require("@mui/x-date-pickers/internals");
+function calculateRangeChange({
   utils,
   range,
   newDate: selectedDate,
@@ -13,13 +20,13 @@ export function calculateRangeChange({
   if (shouldMergeDateAndTime && selectedDate) {
     // If there is a date already selected, then we want to keep its time
     if (start && rangePosition === 'start') {
-      selectedDate = mergeDateAndTime(utils, selectedDate, start);
+      selectedDate = (0, _internals.mergeDateAndTime)(utils, selectedDate, start);
     }
     if (end && rangePosition === 'end') {
-      selectedDate = mergeDateAndTime(utils, selectedDate, end);
+      selectedDate = (0, _internals.mergeDateAndTime)(utils, selectedDate, end);
     }
   }
-  const newSelectedDate = referenceDate && selectedDate && shouldMergeDateAndTime ? mergeDateAndTime(utils, selectedDate, referenceDate) : selectedDate;
+  const newSelectedDate = referenceDate && selectedDate && shouldMergeDateAndTime ? (0, _internals.mergeDateAndTime)(utils, selectedDate, referenceDate) : selectedDate;
   if (rangePosition === 'start') {
     const truthyResult = allowRangeFlip ? {
       nextSelection: 'start',
@@ -45,7 +52,7 @@ export function calculateRangeChange({
     newRange: [start, newSelectedDate]
   };
 }
-export function calculateRangePreview(options) {
+function calculateRangePreview(options) {
   if (options.newDate == null) {
     return [null, null];
   }

package/internals/utils/date-utils.d.ts

@@ -3,4 +3,4 @@ import { PickerRangeValue } from '@mui/x-date-pickers/internals';
 export declare const isRangeValid: (utils: MuiPickersAdapter, range: PickerRangeValue | null) => range is [PickerValidDate, PickerValidDate];
 export declare const isWithinRange: (utils: MuiPickersAdapter, day: PickerValidDate, range: PickerRangeValue | null) => boolean;
 export declare const isStartOfRange: (utils: MuiPickersAdapter, day: PickerValidDate, range: PickerRangeValue | null) => boolean;
-export declare const isEndOfRange: (utils: MuiPickersAdapter, day: PickerValidDate, range: PickerRangeValue | null) => boolean;
+export declare const isEndOfRange: (utils: MuiPickersAdapter, day: PickerValidDate, range: PickerRangeValue | null) => boolean;

package/internals/utils/date-utils.js

@@ -1,12 +1,22 @@
-export const isRangeValid = (utils, range) => {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isWithinRange = exports.isStartOfRange = exports.isRangeValid = exports.isEndOfRange = void 0;
+const isRangeValid = (utils, range) => {
   return Boolean(range && range[0] && range[1] && !utils.isBefore(range[1], range[0]));
 };
-export const isWithinRange = (utils, day, range) => {
+exports.isRangeValid = isRangeValid;
+const isWithinRange = (utils, day, range) => {
   return isRangeValid(utils, range) && utils.isWithinRange(day, range);
 };
-export const isStartOfRange = (utils, day, range) => {
+exports.isWithinRange = isWithinRange;
+const isStartOfRange = (utils, day, range) => {
   return isRangeValid(utils, range) && utils.isSameDay(day, range[0]);
 };
-export const isEndOfRange = (utils, day, range) => {
+exports.isStartOfRange = isStartOfRange;
+const isEndOfRange = (utils, day, range) => {
   return isRangeValid(utils, range) && utils.isSameDay(day, range[1]);
-};
+};
+exports.isEndOfRange = isEndOfRange;

package/internals/utils/releaseInfo.d.ts

@@ -1 +1 @@
-export declare const getReleaseInfo: () => any;
+export declare const getReleaseInfo: () => any;

package/internals/utils/releaseInfo.js

@@ -1,13 +1,20 @@
-import { ponyfillGlobal } from '@mui/utils';
-export const getReleaseInfo = () => {
-  const releaseInfo = "MTczODg4MjgwMDAwMA==";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getReleaseInfo = void 0;
+var _utils = require("@mui/utils");
+const getReleaseInfo = () => {
+  const releaseInfo = "MTc0MDY5NzIwMDAwMA==";
   if (process.env.NODE_ENV !== 'production') {
     // A simple hack to set the value in the test environment (has no build step).
     // eslint-disable-next-line no-useless-concat
     if (releaseInfo === '__RELEASE' + '_INFO__') {
       // eslint-disable-next-line no-underscore-dangle
-      return ponyfillGlobal.__MUI_RELEASE_INFO__;
+      return _utils.ponyfillGlobal.__MUI_RELEASE_INFO__;
     }
   }
   return releaseInfo;
-};
+};
+exports.getReleaseInfo = getReleaseInfo;

package/internals/utils/valueManagers.d.ts

@@ -2,7 +2,9 @@ import { PickerValueManager, FieldValueManager, PickerRangeValue } from '@mui/x-
 import type { DateRangeValidationError, DateTimeRangeValidationError, TimeRangeValidationError } from '../../models';
 type RangePickerValueManager<TError extends DateRangeValidationError | TimeRangeValidationError | DateTimeRangeValidationError = any> = PickerValueManager<PickerRangeValue, TError>;
 export declare const rangeValueManager: RangePickerValueManager;
-export declare const getRangeFieldValueManager: ({ dateSeparator, }: {
-    dateSeparator: string | undefined;
+export declare const getRangeFieldValueManager: ({
+  dateSeparator
+}: {
+  dateSeparator: string | undefined;
 }) => FieldValueManager<PickerRangeValue>;
-export {};
+export {};

package/internals/utils/valueManagers.js

@@ -1,27 +1,34 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.rangeValueManager = exports.getRangeFieldValueManager = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+var _internals = require("@mui/x-date-pickers/internals");
+var _dateFieldsUtils = require("./date-fields-utils");
 const _excluded = ["value", "referenceDate"];
-import { replaceInvalidDateByNull, createDateStrForV7HiddenInputFromSections, createDateStrForV6InputFromSections, areDatesEqual, getTodayDate, getDefaultReferenceDate } from '@mui/x-date-pickers/internals';
-import { splitDateRangeSections, removeLastSeparator } from "./date-fields-utils.js";
-export const rangeValueManager = {
+const rangeValueManager = exports.rangeValueManager = {
   emptyValue: [null, null],
-  getTodayValue: (utils, timezone, valueType) => [getTodayDate(utils, timezone, valueType), getTodayDate(utils, timezone, valueType)],
+  getTodayValue: (utils, timezone, valueType) => [(0, _internals.getTodayDate)(utils, timezone, valueType), (0, _internals.getTodayDate)(utils, timezone, valueType)],
   getInitialReferenceValue: _ref => {
     let {
         value,
         referenceDate: referenceDateProp
       } = _ref,
-      params = _objectWithoutPropertiesLoose(_ref, _excluded);
+      params = (0, _objectWithoutPropertiesLoose2.default)(_ref, _excluded);
     const shouldKeepStartDate = params.utils.isValid(value[0]);
     const shouldKeepEndDate = params.utils.isValid(value[1]);
     if (shouldKeepStartDate && shouldKeepEndDate) {
       return value;
     }
-    const referenceDate = referenceDateProp ?? getDefaultReferenceDate(params);
+    const referenceDate = referenceDateProp ?? (0, _internals.getDefaultReferenceDate)(params);
     return [shouldKeepStartDate ? value[0] : referenceDate, shouldKeepEndDate ? value[1] : referenceDate];
   },
-  cleanValue: (utils, value) => value.map(date => replaceInvalidDateByNull(utils, date)),
-  areValuesEqual: (utils, a, b) => areDatesEqual(utils, a[0], b[0]) && areDatesEqual(utils, a[1], b[1]),
+  cleanValue: (utils, value) => value.map(date => (0, _internals.replaceInvalidDateByNull)(utils, date)),
+  areValuesEqual: (utils, a, b) => (0, _internals.areDatesEqual)(utils, a[0], b[0]) && (0, _internals.areDatesEqual)(utils, a[1], b[1]),
   isSameError: (a, b) => b !== null && a[1] === b[1] && a[0] === b[0],
   hasError: error => error[0] != null || error[1] != null,
   defaultErrorState: [null, null],
@@ -35,7 +42,7 @@ export const rangeValueManager = {
   },
   setTimezone: (utils, timezone, value) => [value[0] == null ? null : utils.setTimezone(value[0], timezone), value[1] == null ? null : utils.setTimezone(value[1], timezone)]
 };
-export const getRangeFieldValueManager = ({
+const getRangeFieldValueManager = ({
   dateSeparator = '–'
 }) => ({
   updateReferenceValue: (utils, value, prevReferenceValue) => {
@@ -56,7 +63,7 @@ export const getRangeFieldValueManager = ({
     const separatedFallbackSections = fallbackSections == null ? {
       startDate: null,
       endDate: null
-    } : splitDateRangeSections(fallbackSections);
+    } : (0, _dateFieldsUtils.splitDateRangeSections)(fallbackSections);
     const getSections = (newDate, fallbackDateSections, position) => {
       const shouldReUsePrevDateSections = !utils.isValid(newDate) && !!fallbackDateSections;
       if (shouldReUsePrevDateSections) {
@@ -65,13 +72,13 @@ export const getRangeFieldValueManager = ({
       const sections = getSectionsFromDate(newDate);
       return sections.map((section, sectionIndex) => {
         if (sectionIndex === sections.length - 1 && position === 'start') {
-          return _extends({}, section, {
+          return (0, _extends2.default)({}, section, {
             dateName: position,
             // TODO: Check if RTL still works
             endSeparator: `${section.endSeparator} ${dateSeparator} `
           });
         }
-        return _extends({}, section, {
+        return (0, _extends2.default)({}, section, {
           dateName: position
         });
       });
@@ -79,12 +86,12 @@ export const getRangeFieldValueManager = ({
     return [...getSections(start, separatedFallbackSections.startDate, 'start'), ...getSections(end, separatedFallbackSections.endDate, 'end')];
   },
   getV7HiddenInputValueFromSections: sections => {
-    const dateRangeSections = splitDateRangeSections(sections);
-    return createDateStrForV7HiddenInputFromSections([...dateRangeSections.startDate, ...dateRangeSections.endDate]);
+    const dateRangeSections = (0, _dateFieldsUtils.splitDateRangeSections)(sections);
+    return (0, _internals.createDateStrForV7HiddenInputFromSections)([...dateRangeSections.startDate, ...dateRangeSections.endDate]);
   },
   getV6InputValueFromSections: (sections, localizedDigits, isRtl) => {
-    const dateRangeSections = splitDateRangeSections(sections);
-    return createDateStrForV6InputFromSections([...dateRangeSections.startDate, ...dateRangeSections.endDate], localizedDigits, isRtl);
+    const dateRangeSections = (0, _dateFieldsUtils.splitDateRangeSections)(sections);
+    return (0, _internals.createDateStrForV6InputFromSections)([...dateRangeSections.startDate, ...dateRangeSections.endDate], localizedDigits, isRtl);
   },
   parseValueStr: (valueStr, referenceValue, parseDate) => {
     // TODO: Improve because it would not work if some section have the same separator as the dateSeparator.
@@ -103,9 +110,9 @@ export const getRangeFieldValueManager = ({
       date: state.value[index],
       referenceDate: state.referenceValue[index],
       getSections: sections => {
-        const dateRangeSections = splitDateRangeSections(sections);
+        const dateRangeSections = (0, _dateFieldsUtils.splitDateRangeSections)(sections);
         if (index === 0) {
-          return removeLastSeparator(dateRangeSections.startDate);
+          return (0, _dateFieldsUtils.removeLastSeparator)(dateRangeSections.startDate);
         }
         return dateRangeSections.endDate;
       },
@@ -115,4 +122,5 @@ export const getRangeFieldValueManager = ({
       })
     };
   }
-});
+});
+exports.getRangeFieldValueManager = getRangeFieldValueManager;

package/locales/index.d.ts

@@ -1 +1 @@
-export * from '@mui/x-date-pickers/locales';
+export * from '@mui/x-date-pickers/locales';

package/locales/index.js

@@ -1 +1,16 @@
-export * from '@mui/x-date-pickers/locales';
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _locales = require("@mui/x-date-pickers/locales");
+Object.keys(_locales).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _locales[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _locales[key];
+    }
+  });
+});

package/managers/index.d.ts

@@ -1,6 +1,6 @@
-export { useDateRangeManager } from './useDateRangeManager';
-export type { UseDateRangeManagerReturnValue, UseDateRangeManagerParameters, DateRangeManagerFieldInternalProps, } from './useDateRangeManager';
-export { useTimeRangeManager } from './useTimeRangeManager';
-export type { UseTimeRangeManagerReturnValue, UseTimeRangeManagerParameters, TimeRangeManagerFieldInternalProps, } from './useTimeRangeManager';
-export { useDateTimeRangeManager } from './useDateTimeRangeManager';
-export type { UseDateTimeRangeManagerReturnValue, UseDateTimeRangeManagerParameters, DateTimeRangeManagerFieldInternalProps, } from './useDateTimeRangeManager';
+export { useDateRangeManager } from "./useDateRangeManager.js";
+export type { UseDateRangeManagerReturnValue, UseDateRangeManagerParameters, DateRangeManagerFieldInternalProps } from './useDateRangeManager';
+export { useTimeRangeManager } from "./useTimeRangeManager.js";
+export type { UseTimeRangeManagerReturnValue, UseTimeRangeManagerParameters, TimeRangeManagerFieldInternalProps } from './useTimeRangeManager';
+export { useDateTimeRangeManager } from "./useDateTimeRangeManager.js";
+export type { UseDateTimeRangeManagerReturnValue, UseDateTimeRangeManagerParameters, DateTimeRangeManagerFieldInternalProps } from './useDateTimeRangeManager';

package/managers/index.js

@@ -1,3 +1,26 @@
-export { useDateRangeManager } from "./useDateRangeManager.js";
-export { useTimeRangeManager } from "./useTimeRangeManager.js";
-export { useDateTimeRangeManager } from "./useDateTimeRangeManager.js";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "useDateRangeManager", {
+  enumerable: true,
+  get: function () {
+    return _useDateRangeManager.useDateRangeManager;
+  }
+});
+Object.defineProperty(exports, "useDateTimeRangeManager", {
+  enumerable: true,
+  get: function () {
+    return _useDateTimeRangeManager.useDateTimeRangeManager;
+  }
+});
+Object.defineProperty(exports, "useTimeRangeManager", {
+  enumerable: true,
+  get: function () {
+    return _useTimeRangeManager.useTimeRangeManager;
+  }
+});
+var _useDateRangeManager = require("./useDateRangeManager");
+var _useTimeRangeManager = require("./useTimeRangeManager");
+var _useDateTimeRangeManager = require("./useDateTimeRangeManager");

package/managers/useDateRangeManager.d.ts

@@ -1,15 +1,13 @@
 import type { MakeOptional } from '@mui/x-internals/types';
 import { PickerManager } from '@mui/x-date-pickers/models';
 import { PickerRangeValue, UseFieldInternalProps } from '@mui/x-date-pickers/internals';
-import { DateRangeValidationError, RangeFieldSeparatorProps } from '../models';
-import { ExportedValidateDateRangeProps, ValidateDateRangeProps } from '../validation/validateDateRange';
+import { DateRangeValidationError, RangeFieldSeparatorProps } from "../models/index.js";
+import { ExportedValidateDateRangeProps, ValidateDateRangeProps } from "../validation/validateDateRange.js";
 export declare function useDateRangeManager<TEnableAccessibleFieldDOMStructure extends boolean = true>(parameters?: UseDateRangeManagerParameters<TEnableAccessibleFieldDOMStructure>): UseDateRangeManagerReturnValue<TEnableAccessibleFieldDOMStructure>;
 export interface UseDateRangeManagerParameters<TEnableAccessibleFieldDOMStructure extends boolean> extends RangeFieldSeparatorProps {
-    enableAccessibleFieldDOMStructure?: TEnableAccessibleFieldDOMStructure;
+  enableAccessibleFieldDOMStructure?: TEnableAccessibleFieldDOMStructure;
 }
 export type UseDateRangeManagerReturnValue<TEnableAccessibleFieldDOMStructure extends boolean> = PickerManager<PickerRangeValue, TEnableAccessibleFieldDOMStructure, DateRangeValidationError, DateRangeManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure>, DateRangeManagerFieldInternalPropsWithDefaults<TEnableAccessibleFieldDOMStructure>>;
-export interface DateRangeManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure extends boolean> extends MakeOptional<UseFieldInternalProps<PickerRangeValue, TEnableAccessibleFieldDOMStructure, DateRangeValidationError>, 'format'>, RangeFieldSeparatorProps, ExportedValidateDateRangeProps {
-}
-interface DateRangeManagerFieldInternalPropsWithDefaults<TEnableAccessibleFieldDOMStructure extends boolean> extends UseFieldInternalProps<PickerRangeValue, TEnableAccessibleFieldDOMStructure, DateRangeValidationError>, ValidateDateRangeProps, RangeFieldSeparatorProps {
-}
-export {};
+export interface DateRangeManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure extends boolean> extends MakeOptional<UseFieldInternalProps<PickerRangeValue, TEnableAccessibleFieldDOMStructure, DateRangeValidationError>, 'format'>, RangeFieldSeparatorProps, ExportedValidateDateRangeProps {}
+interface DateRangeManagerFieldInternalPropsWithDefaults<TEnableAccessibleFieldDOMStructure extends boolean> extends UseFieldInternalProps<PickerRangeValue, TEnableAccessibleFieldDOMStructure, DateRangeValidationError>, ValidateDateRangeProps, RangeFieldSeparatorProps {}
+export {};

package/managers/useDateRangeManager.js

@@ -1,20 +1,27 @@
+"use strict";
 'use client';
 
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import { getDateFieldInternalPropsDefaults } from '@mui/x-date-pickers/internals';
-import { getRangeFieldValueManager, rangeValueManager } from "../internals/utils/valueManagers.js";
-import { validateDateRange } from "../validation/index.js";
-export function useDateRangeManager(parameters = {}) {
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useDateRangeManager = useDateRangeManager;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var React = _interopRequireWildcard(require("react"));
+var _internals = require("@mui/x-date-pickers/internals");
+var _valueManagers = require("../internals/utils/valueManagers");
+var _validation = require("../validation");
+function useDateRangeManager(parameters = {}) {
   const {
     enableAccessibleFieldDOMStructure = true,
     dateSeparator
   } = parameters;
   return React.useMemo(() => ({
     valueType: 'date',
-    validator: validateDateRange,
-    internal_valueManager: rangeValueManager,
-    internal_fieldValueManager: getRangeFieldValueManager({
+    validator: _validation.validateDateRange,
+    internal_valueManager: _valueManagers.rangeValueManager,
+    internal_fieldValueManager: (0, _valueManagers.getRangeFieldValueManager)({
       dateSeparator
     }),
     internal_enableAccessibleFieldDOMStructure: enableAccessibleFieldDOMStructure,
@@ -22,12 +29,19 @@ export function useDateRangeManager(parameters = {}) {
       internalProps,
       utils,
       defaultDates
-    }) => _extends({}, internalProps, getDateFieldInternalPropsDefaults({
+    }) => (0, _extends2.default)({}, internalProps, (0, _internals.getDateFieldInternalPropsDefaults)({
       defaultDates,
       utils,
       internalProps
     })),
     // TODO v8: Add a real aria label before moving the opening logic to the field on range pickers.
-    internal_getOpenPickerButtonAriaLabel: () => ''
+    internal_getOpenPickerButtonAriaLabel: ({
+      value,
+      utils,
+      localeText
+    }) => {
+      const formattedValue = utils.isValid(value[0]) ? utils.format(value[0], 'fullDate') : null;
+      return localeText.openDatePickerDialogue(formattedValue);
+    }
   }), [enableAccessibleFieldDOMStructure, dateSeparator]);
 }

package/managers/useDateTimeRangeManager.d.ts

@@ -1,15 +1,13 @@
 import type { MakeOptional } from '@mui/x-internals/types';
 import { PickerManager } from '@mui/x-date-pickers/models';
 import { AmPmProps, PickerRangeValue, UseFieldInternalProps } from '@mui/x-date-pickers/internals';
-import { DateTimeRangeValidationError, RangeFieldSeparatorProps } from '../models';
-import { ExportedValidateDateTimeRangeProps, ValidateDateTimeRangeProps } from '../validation/validateDateTimeRange';
+import { DateTimeRangeValidationError, RangeFieldSeparatorProps } from "../models/index.js";
+import { ExportedValidateDateTimeRangeProps, ValidateDateTimeRangeProps } from "../validation/validateDateTimeRange.js";
 export declare function useDateTimeRangeManager<TEnableAccessibleFieldDOMStructure extends boolean = true>(parameters?: UseDateTimeRangeManagerParameters<TEnableAccessibleFieldDOMStructure>): UseDateTimeRangeManagerReturnValue<TEnableAccessibleFieldDOMStructure>;
 export interface UseDateTimeRangeManagerParameters<TEnableAccessibleFieldDOMStructure extends boolean> extends RangeFieldSeparatorProps {
-    enableAccessibleFieldDOMStructure?: TEnableAccessibleFieldDOMStructure;
+  enableAccessibleFieldDOMStructure?: TEnableAccessibleFieldDOMStructure;
 }
 export type UseDateTimeRangeManagerReturnValue<TEnableAccessibleFieldDOMStructure extends boolean> = PickerManager<PickerRangeValue, TEnableAccessibleFieldDOMStructure, DateTimeRangeValidationError, DateTimeRangeManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure>, DateTimeRangeManagerFieldInternalPropsWithDefaults<TEnableAccessibleFieldDOMStructure>>;
-export interface DateTimeRangeManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure extends boolean> extends MakeOptional<UseFieldInternalProps<PickerRangeValue, TEnableAccessibleFieldDOMStructure, DateTimeRangeValidationError>, 'format'>, ExportedValidateDateTimeRangeProps, AmPmProps, RangeFieldSeparatorProps {
-}
-interface DateTimeRangeManagerFieldInternalPropsWithDefaults<TEnableAccessibleFieldDOMStructure extends boolean> extends UseFieldInternalProps<PickerRangeValue, TEnableAccessibleFieldDOMStructure, DateTimeRangeValidationError>, ValidateDateTimeRangeProps, RangeFieldSeparatorProps {
-}
-export {};
+export interface DateTimeRangeManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure extends boolean> extends MakeOptional<UseFieldInternalProps<PickerRangeValue, TEnableAccessibleFieldDOMStructure, DateTimeRangeValidationError>, 'format'>, ExportedValidateDateTimeRangeProps, AmPmProps, RangeFieldSeparatorProps {}
+interface DateTimeRangeManagerFieldInternalPropsWithDefaults<TEnableAccessibleFieldDOMStructure extends boolean> extends UseFieldInternalProps<PickerRangeValue, TEnableAccessibleFieldDOMStructure, DateTimeRangeValidationError>, ValidateDateTimeRangeProps, RangeFieldSeparatorProps {}
+export {};

package/managers/useDateTimeRangeManager.js

@@ -1,20 +1,27 @@
+"use strict";
 'use client';
 
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import { getDateTimeFieldInternalPropsDefaults } from '@mui/x-date-pickers/internals';
-import { getRangeFieldValueManager, rangeValueManager } from "../internals/utils/valueManagers.js";
-import { validateDateTimeRange } from "../validation/index.js";
-export function useDateTimeRangeManager(parameters = {}) {
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useDateTimeRangeManager = useDateTimeRangeManager;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var React = _interopRequireWildcard(require("react"));
+var _internals = require("@mui/x-date-pickers/internals");
+var _valueManagers = require("../internals/utils/valueManagers");
+var _validation = require("../validation");
+function useDateTimeRangeManager(parameters = {}) {
   const {
     enableAccessibleFieldDOMStructure = true,
     dateSeparator
   } = parameters;
   return React.useMemo(() => ({
     valueType: 'date-time',
-    validator: validateDateTimeRange,
-    internal_valueManager: rangeValueManager,
-    internal_fieldValueManager: getRangeFieldValueManager({
+    validator: _validation.validateDateTimeRange,
+    internal_valueManager: _valueManagers.rangeValueManager,
+    internal_fieldValueManager: (0, _valueManagers.getRangeFieldValueManager)({
       dateSeparator
     }),
     internal_enableAccessibleFieldDOMStructure: enableAccessibleFieldDOMStructure,
@@ -22,12 +29,19 @@ export function useDateTimeRangeManager(parameters = {}) {
       internalProps,
       utils,
       defaultDates
-    }) => _extends({}, internalProps, getDateTimeFieldInternalPropsDefaults({
+    }) => (0, _extends2.default)({}, internalProps, (0, _internals.getDateTimeFieldInternalPropsDefaults)({
       internalProps,
       utils,
       defaultDates
     })),
     // TODO v8: Add a real aria label before moving the opening logic to the field on range pickers.
-    internal_getOpenPickerButtonAriaLabel: () => ''
+    internal_getOpenPickerButtonAriaLabel: ({
+      value,
+      utils,
+      localeText
+    }) => {
+      const formattedValue = utils.isValid(value[0]) ? utils.format(value[0], 'fullDate') : null;
+      return localeText.openDatePickerDialogue(formattedValue);
+    }
   }), [enableAccessibleFieldDOMStructure, dateSeparator]);
 }

package/managers/useTimeRangeManager.d.ts

@@ -1,15 +1,13 @@
 import type { MakeOptional } from '@mui/x-internals/types';
 import { PickerManager } from '@mui/x-date-pickers/models';
 import { AmPmProps, PickerRangeValue, UseFieldInternalProps } from '@mui/x-date-pickers/internals';
-import { TimeRangeValidationError, RangeFieldSeparatorProps } from '../models';
-import { ExportedValidateTimeRangeProps, ValidateTimeRangeProps } from '../validation/validateTimeRange';
+import { TimeRangeValidationError, RangeFieldSeparatorProps } from "../models/index.js";
+import { ExportedValidateTimeRangeProps, ValidateTimeRangeProps } from "../validation/validateTimeRange.js";
 export declare function useTimeRangeManager<TEnableAccessibleFieldDOMStructure extends boolean = true>(parameters?: UseTimeRangeManagerParameters<TEnableAccessibleFieldDOMStructure>): UseTimeRangeManagerReturnValue<TEnableAccessibleFieldDOMStructure>;
 export interface UseTimeRangeManagerParameters<TEnableAccessibleFieldDOMStructure extends boolean> extends RangeFieldSeparatorProps {
-    enableAccessibleFieldDOMStructure?: TEnableAccessibleFieldDOMStructure;
+  enableAccessibleFieldDOMStructure?: TEnableAccessibleFieldDOMStructure;
 }
 export type UseTimeRangeManagerReturnValue<TEnableAccessibleFieldDOMStructure extends boolean> = PickerManager<PickerRangeValue, TEnableAccessibleFieldDOMStructure, TimeRangeValidationError, TimeRangeManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure>, TimeRangeManagerFieldInternalPropsWithDefaults<TEnableAccessibleFieldDOMStructure>>;
-export interface TimeRangeManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure extends boolean> extends MakeOptional<UseFieldInternalProps<PickerRangeValue, TEnableAccessibleFieldDOMStructure, TimeRangeValidationError>, 'format'>, ExportedValidateTimeRangeProps, AmPmProps, RangeFieldSeparatorProps {
-}
-interface TimeRangeManagerFieldInternalPropsWithDefaults<TEnableAccessibleFieldDOMStructure extends boolean> extends UseFieldInternalProps<PickerRangeValue, TEnableAccessibleFieldDOMStructure, TimeRangeValidationError>, ValidateTimeRangeProps {
-}
-export {};
+export interface TimeRangeManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure extends boolean> extends MakeOptional<UseFieldInternalProps<PickerRangeValue, TEnableAccessibleFieldDOMStructure, TimeRangeValidationError>, 'format'>, ExportedValidateTimeRangeProps, AmPmProps, RangeFieldSeparatorProps {}
+interface TimeRangeManagerFieldInternalPropsWithDefaults<TEnableAccessibleFieldDOMStructure extends boolean> extends UseFieldInternalProps<PickerRangeValue, TEnableAccessibleFieldDOMStructure, TimeRangeValidationError>, ValidateTimeRangeProps {}
+export {};