@mui/x-date-pickers 8.5.3 → 8.6.0

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

@@ -1,10 +1,10 @@
 import { areViewsEqual } from "./views.js";
-export const mergeDateAndTime = (utils, dateParam, timeParam) => {
+export const mergeDateAndTime = (adapter, dateParam, timeParam) => {
   let mergedDate = dateParam;
-  mergedDate = utils.setHours(mergedDate, utils.getHours(timeParam));
-  mergedDate = utils.setMinutes(mergedDate, utils.getMinutes(timeParam));
-  mergedDate = utils.setSeconds(mergedDate, utils.getSeconds(timeParam));
-  mergedDate = utils.setMilliseconds(mergedDate, utils.getMilliseconds(timeParam));
+  mergedDate = adapter.setHours(mergedDate, adapter.getHours(timeParam));
+  mergedDate = adapter.setMinutes(mergedDate, adapter.getMinutes(timeParam));
+  mergedDate = adapter.setSeconds(mergedDate, adapter.getSeconds(timeParam));
+  mergedDate = adapter.setMilliseconds(mergedDate, adapter.getMilliseconds(timeParam));
   return mergedDate;
 };
 export const findClosestEnabledDate = ({
@@ -14,87 +14,87 @@ export const findClosestEnabledDate = ({
   maxDate,
   minDate,
   isDateDisabled,
-  utils,
+  adapter,
   timezone
 }) => {
-  const today = mergeDateAndTime(utils, utils.date(undefined, timezone), date);
-  if (disablePast && utils.isBefore(minDate, today)) {
+  const today = mergeDateAndTime(adapter, adapter.date(undefined, timezone), date);
+  if (disablePast && adapter.isBefore(minDate, today)) {
     minDate = today;
   }
-  if (disableFuture && utils.isAfter(maxDate, today)) {
+  if (disableFuture && adapter.isAfter(maxDate, today)) {
     maxDate = today;
   }
   let forward = date;
   let backward = date;
-  if (utils.isBefore(date, minDate)) {
+  if (adapter.isBefore(date, minDate)) {
     forward = minDate;
     backward = null;
   }
-  if (utils.isAfter(date, maxDate)) {
+  if (adapter.isAfter(date, maxDate)) {
     if (backward) {
       backward = maxDate;
     }
     forward = null;
   }
   while (forward || backward) {
-    if (forward && utils.isAfter(forward, maxDate)) {
+    if (forward && adapter.isAfter(forward, maxDate)) {
       forward = null;
     }
-    if (backward && utils.isBefore(backward, minDate)) {
+    if (backward && adapter.isBefore(backward, minDate)) {
       backward = null;
     }
     if (forward) {
       if (!isDateDisabled(forward)) {
         return forward;
       }
-      forward = utils.addDays(forward, 1);
+      forward = adapter.addDays(forward, 1);
     }
     if (backward) {
       if (!isDateDisabled(backward)) {
         return backward;
       }
-      backward = utils.addDays(backward, -1);
+      backward = adapter.addDays(backward, -1);
     }
   }
   return null;
 };
-export const replaceInvalidDateByNull = (utils, value) => !utils.isValid(value) ? null : value;
-export const applyDefaultDate = (utils, value, defaultValue) => {
-  if (value == null || !utils.isValid(value)) {
+export const replaceInvalidDateByNull = (adapter, value) => !adapter.isValid(value) ? null : value;
+export const applyDefaultDate = (adapter, value, defaultValue) => {
+  if (value == null || !adapter.isValid(value)) {
     return defaultValue;
   }
   return value;
 };
-export const areDatesEqual = (utils, a, b) => {
-  if (!utils.isValid(a) && a != null && !utils.isValid(b) && b != null) {
+export const areDatesEqual = (adapter, a, b) => {
+  if (!adapter.isValid(a) && a != null && !adapter.isValid(b) && b != null) {
     return true;
   }
-  return utils.isEqual(a, b);
+  return adapter.isEqual(a, b);
 };
-export const getMonthsInYear = (utils, year) => {
-  const firstMonth = utils.startOfYear(year);
+export const getMonthsInYear = (adapter, year) => {
+  const firstMonth = adapter.startOfYear(year);
   const months = [firstMonth];
   while (months.length < 12) {
     const prevMonth = months[months.length - 1];
-    months.push(utils.addMonths(prevMonth, 1));
+    months.push(adapter.addMonths(prevMonth, 1));
   }
   return months;
 };
-export const getTodayDate = (utils, timezone, valueType) => valueType === 'date' ? utils.startOfDay(utils.date(undefined, timezone)) : utils.date(undefined, timezone);
-export const formatMeridiem = (utils, meridiem) => {
-  const date = utils.setHours(utils.date(), meridiem === 'am' ? 2 : 14);
-  return utils.format(date, 'meridiem');
+export const getTodayDate = (adapter, timezone, valueType) => valueType === 'date' ? adapter.startOfDay(adapter.date(undefined, timezone)) : adapter.date(undefined, timezone);
+export const formatMeridiem = (adapter, meridiem) => {
+  const date = adapter.setHours(adapter.date(), meridiem === 'am' ? 2 : 14);
+  return adapter.format(date, 'meridiem');
 };
 export const DATE_VIEWS = ['year', 'month', 'day'];
 export const isDatePickerView = view => DATE_VIEWS.includes(view);
-export const resolveDateFormat = (utils, {
+export const resolveDateFormat = (adapter, {
   format,
   views
 }, isInToolbar) => {
   if (format != null) {
     return format;
   }
-  const formats = utils.formats;
+  const formats = adapter.formats;
   if (areViewsEqual(views, ['year'])) {
     return formats.year;
   }
@@ -114,11 +114,11 @@ export const resolveDateFormat = (utils, {
     // Little localization hack (Google is doing the same for android native pickers):
     // For english localization it is convenient to include weekday into the date "Mon, Jun 1".
     // For other locales using strings like "June 1", without weekday.
-    return /en/.test(utils.getCurrentLocaleCode()) ? formats.normalDateWithWeekday : formats.normalDate;
+    return /en/.test(adapter.getCurrentLocaleCode()) ? formats.normalDateWithWeekday : formats.normalDate;
   }
   return formats.keyboardDate;
 };
-export const getWeekdays = (utils, date) => {
-  const start = utils.startOfWeek(date);
-  return [0, 1, 2, 3, 4, 5, 6].map(diff => utils.addDays(start, diff));
+export const getWeekdays = (adapter, date) => {
+  const start = adapter.startOfWeek(date);
+  return [0, 1, 2, 3, 4, 5, 6].map(diff => adapter.addDays(start, diff));
 };

package/esm/internals/utils/getDefaultReferenceDate.d.ts

@@ -18,13 +18,13 @@ export declare const SECTION_TYPE_GRANULARITY: {
 export declare const getSectionTypeGranularity: (sections: FieldSection[]) => number;
 export declare const getDefaultReferenceDate: ({
   props,
-  utils,
+  adapter,
   granularity,
   timezone,
   getTodayDate: inGetTodayDate
 }: {
   props: GetDefaultReferenceDateProps;
-  utils: MuiPickersAdapter;
+  adapter: MuiPickersAdapter;
   granularity: number;
   timezone: PickersTimezone;
   getTodayDate?: () => PickerValidDate;

package/esm/internals/utils/getDefaultReferenceDate.js

@@ -10,50 +10,50 @@ export const SECTION_TYPE_GRANULARITY = {
   milliseconds: 7
 };
 export const getSectionTypeGranularity = sections => Math.max(...sections.map(section => SECTION_TYPE_GRANULARITY[section.type] ?? 1));
-const roundDate = (utils, granularity, date) => {
+const roundDate = (adapter, granularity, date) => {
   if (granularity === SECTION_TYPE_GRANULARITY.year) {
-    return utils.startOfYear(date);
+    return adapter.startOfYear(date);
   }
   if (granularity === SECTION_TYPE_GRANULARITY.month) {
-    return utils.startOfMonth(date);
+    return adapter.startOfMonth(date);
   }
   if (granularity === SECTION_TYPE_GRANULARITY.day) {
-    return utils.startOfDay(date);
+    return adapter.startOfDay(date);
   }
 
   // We don't have startOfHour / startOfMinute / startOfSecond
   let roundedDate = date;
   if (granularity < SECTION_TYPE_GRANULARITY.minutes) {
-    roundedDate = utils.setMinutes(roundedDate, 0);
+    roundedDate = adapter.setMinutes(roundedDate, 0);
   }
   if (granularity < SECTION_TYPE_GRANULARITY.seconds) {
-    roundedDate = utils.setSeconds(roundedDate, 0);
+    roundedDate = adapter.setSeconds(roundedDate, 0);
   }
   if (granularity < SECTION_TYPE_GRANULARITY.milliseconds) {
-    roundedDate = utils.setMilliseconds(roundedDate, 0);
+    roundedDate = adapter.setMilliseconds(roundedDate, 0);
   }
   return roundedDate;
 };
 export const getDefaultReferenceDate = ({
   props,
-  utils,
+  adapter,
   granularity,
   timezone,
   getTodayDate: inGetTodayDate
 }) => {
-  let referenceDate = inGetTodayDate ? inGetTodayDate() : roundDate(utils, granularity, getTodayDate(utils, timezone));
-  if (props.minDate != null && utils.isAfterDay(props.minDate, referenceDate)) {
-    referenceDate = roundDate(utils, granularity, props.minDate);
+  let referenceDate = inGetTodayDate ? inGetTodayDate() : roundDate(adapter, granularity, getTodayDate(adapter, timezone));
+  if (props.minDate != null && adapter.isAfterDay(props.minDate, referenceDate)) {
+    referenceDate = roundDate(adapter, granularity, props.minDate);
   }
-  if (props.maxDate != null && utils.isBeforeDay(props.maxDate, referenceDate)) {
-    referenceDate = roundDate(utils, granularity, props.maxDate);
+  if (props.maxDate != null && adapter.isBeforeDay(props.maxDate, referenceDate)) {
+    referenceDate = roundDate(adapter, granularity, props.maxDate);
   }
-  const isAfter = createIsAfterIgnoreDatePart(props.disableIgnoringDatePartForTimeValidation ?? false, utils);
+  const isAfter = createIsAfterIgnoreDatePart(props.disableIgnoringDatePartForTimeValidation ?? false, adapter);
   if (props.minTime != null && isAfter(props.minTime, referenceDate)) {
-    referenceDate = roundDate(utils, granularity, props.disableIgnoringDatePartForTimeValidation ? props.minTime : mergeDateAndTime(utils, referenceDate, props.minTime));
+    referenceDate = roundDate(adapter, granularity, props.disableIgnoringDatePartForTimeValidation ? props.minTime : mergeDateAndTime(adapter, referenceDate, props.minTime));
   }
   if (props.maxTime != null && isAfter(referenceDate, props.maxTime)) {
-    referenceDate = roundDate(utils, granularity, props.disableIgnoringDatePartForTimeValidation ? props.maxTime : mergeDateAndTime(utils, referenceDate, props.maxTime));
+    referenceDate = roundDate(adapter, granularity, props.disableIgnoringDatePartForTimeValidation ? props.maxTime : mergeDateAndTime(adapter, referenceDate, props.maxTime));
   }
   return referenceDate;
 };

package/esm/internals/utils/time-utils.d.ts

@@ -5,12 +5,12 @@ export declare const TIME_VIEWS: readonly ["hours", "minutes", "seconds", "merid
 export declare const isTimeView: (view: DateOrTimeViewWithMeridiem) => boolean;
 export declare const isInternalTimeView: (view: DateOrTimeViewWithMeridiem) => view is TimeViewWithMeridiem;
 export type Meridiem = 'am' | 'pm';
-export declare const getMeridiem: (date: PickerValidDate | null, utils: MuiPickersAdapter) => Meridiem | null;
+export declare const getMeridiem: (date: PickerValidDate | null, adapter: MuiPickersAdapter) => Meridiem | null;
 export declare const convertValueToMeridiem: (value: number, meridiem: Meridiem | null, ampm: boolean) => number;
-export declare const convertToMeridiem: (time: PickerValidDate, meridiem: Meridiem, ampm: boolean, utils: MuiPickersAdapter) => PickerValidDate;
-export declare const getSecondsInDay: (date: PickerValidDate, utils: MuiPickersAdapter) => number;
-export declare const createIsAfterIgnoreDatePart: (disableIgnoringDatePartForTimeValidation: boolean, utils: MuiPickersAdapter) => (dateLeft: PickerValidDate, dateRight: PickerValidDate) => boolean;
-export declare const resolveTimeFormat: (utils: MuiPickersAdapter, {
+export declare const convertToMeridiem: (time: PickerValidDate, meridiem: Meridiem, ampm: boolean, adapter: MuiPickersAdapter) => PickerValidDate;
+export declare const getSecondsInDay: (date: PickerValidDate, adapter: MuiPickersAdapter) => number;
+export declare const createIsAfterIgnoreDatePart: (disableIgnoringDatePartForTimeValidation: boolean, adapter: MuiPickersAdapter) => (dateLeft: PickerValidDate, dateRight: PickerValidDate) => boolean;
+export declare const resolveTimeFormat: (adapter: MuiPickersAdapter, {
   format,
   views,
   ampm

package/esm/internals/utils/time-utils.js

@@ -3,11 +3,11 @@ export const EXPORTED_TIME_VIEWS = ['hours', 'minutes', 'seconds'];
 export const TIME_VIEWS = ['hours', 'minutes', 'seconds', 'meridiem'];
 export const isTimeView = view => EXPORTED_TIME_VIEWS.includes(view);
 export const isInternalTimeView = view => TIME_VIEWS.includes(view);
-export const getMeridiem = (date, utils) => {
+export const getMeridiem = (date, adapter) => {
   if (!date) {
     return null;
   }
-  return utils.getHours(date) >= 12 ? 'pm' : 'am';
+  return adapter.getHours(date) >= 12 ? 'pm' : 'am';
 };
 export const convertValueToMeridiem = (value, meridiem, ampm) => {
   if (ampm) {
@@ -18,20 +18,20 @@ export const convertValueToMeridiem = (value, meridiem, ampm) => {
   }
   return value;
 };
-export const convertToMeridiem = (time, meridiem, ampm, utils) => {
-  const newHoursAmount = convertValueToMeridiem(utils.getHours(time), meridiem, ampm);
-  return utils.setHours(time, newHoursAmount);
+export const convertToMeridiem = (time, meridiem, ampm, adapter) => {
+  const newHoursAmount = convertValueToMeridiem(adapter.getHours(time), meridiem, ampm);
+  return adapter.setHours(time, newHoursAmount);
 };
-export const getSecondsInDay = (date, utils) => {
-  return utils.getHours(date) * 3600 + utils.getMinutes(date) * 60 + utils.getSeconds(date);
+export const getSecondsInDay = (date, adapter) => {
+  return adapter.getHours(date) * 3600 + adapter.getMinutes(date) * 60 + adapter.getSeconds(date);
 };
-export const createIsAfterIgnoreDatePart = (disableIgnoringDatePartForTimeValidation, utils) => (dateLeft, dateRight) => {
+export const createIsAfterIgnoreDatePart = (disableIgnoringDatePartForTimeValidation, adapter) => (dateLeft, dateRight) => {
   if (disableIgnoringDatePartForTimeValidation) {
-    return utils.isAfter(dateLeft, dateRight);
+    return adapter.isAfter(dateLeft, dateRight);
   }
-  return getSecondsInDay(dateLeft, utils) > getSecondsInDay(dateRight, utils);
+  return getSecondsInDay(dateLeft, adapter) > getSecondsInDay(dateRight, adapter);
 };
-export const resolveTimeFormat = (utils, {
+export const resolveTimeFormat = (adapter, {
   format,
   views,
   ampm
@@ -39,7 +39,7 @@ export const resolveTimeFormat = (utils, {
   if (format != null) {
     return format;
   }
-  const formats = utils.formats;
+  const formats = adapter.formats;
   if (areViewsEqual(views, ['hours'])) {
     return ampm ? `${formats.hours12h} ${formats.meridiem}` : formats.hours24h;
   }

package/esm/internals/utils/valueManagers.js

@@ -13,7 +13,7 @@ export const singleItemValueManager = {
         referenceDate
       } = _ref,
       params = _objectWithoutPropertiesLoose(_ref, _excluded);
-    if (params.utils.isValid(value)) {
+    if (params.adapter.isValid(value)) {
       return value;
     }
     if (referenceDate != null) {
@@ -26,11 +26,11 @@ export const singleItemValueManager = {
   isSameError: (a, b) => a === b,
   hasError: error => error != null,
   defaultErrorState: null,
-  getTimezone: (utils, value) => utils.isValid(value) ? utils.getTimezone(value) : null,
-  setTimezone: (utils, timezone, value) => value == null ? null : utils.setTimezone(value, timezone)
+  getTimezone: (adapter, value) => adapter.isValid(value) ? adapter.getTimezone(value) : null,
+  setTimezone: (adapter, timezone, value) => value == null ? null : adapter.setTimezone(value, timezone)
 };
 export const singleItemFieldValueManager = {
-  updateReferenceValue: (utils, value, prevReferenceValue) => utils.isValid(value) ? value : prevReferenceValue,
+  updateReferenceValue: (adapter, value, prevReferenceValue) => adapter.isValid(value) ? value : prevReferenceValue,
   getSectionsFromValue: (date, getSectionsFromDate) => getSectionsFromDate(date),
   getV7HiddenInputValueFromSections: createDateStrForV7HiddenInputFromSections,
   getV6InputValueFromSections: createDateStrForV6InputFromSections,

package/esm/managers/useDateManager.js

@@ -5,8 +5,8 @@ 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 { useDefaultDates, useUtils } from "../internals/hooks/useUtils.js";
-import { usePickerTranslations } from "../hooks/usePickerTranslations.js";
+import { useDefaultDates } from "../internals/hooks/useUtils.js";
+import { usePickerAdapter, usePickerTranslations } from "../hooks/index.js";
 export function useDateManager(parameters = {}) {
   const {
     enableAccessibleFieldDOMStructure = true
@@ -22,27 +22,27 @@ export function useDateManager(parameters = {}) {
   }), [enableAccessibleFieldDOMStructure]);
 }
 function useOpenPickerButtonAriaLabel(value) {
-  const utils = useUtils();
+  const adapter = usePickerAdapter();
   const translations = usePickerTranslations();
   return React.useMemo(() => {
-    const formattedValue = utils.isValid(value) ? utils.format(value, 'fullDate') : null;
+    const formattedValue = adapter.isValid(value) ? adapter.format(value, 'fullDate') : null;
     return translations.openDatePickerDialogue(formattedValue);
-  }, [value, translations, utils]);
+  }, [value, translations, adapter]);
 }
 function useApplyDefaultValuesToDateFieldInternalProps(internalProps) {
-  const utils = useUtils();
+  const adapter = usePickerAdapter();
   const validationProps = useApplyDefaultValuesToDateValidationProps(internalProps);
   return React.useMemo(() => _extends({}, internalProps, validationProps, {
-    format: internalProps.format ?? utils.formats.keyboardDate
-  }), [internalProps, validationProps, utils]);
+    format: internalProps.format ?? adapter.formats.keyboardDate
+  }), [internalProps, validationProps, adapter]);
 }
 export function useApplyDefaultValuesToDateValidationProps(props) {
-  const utils = useUtils();
+  const adapter = usePickerAdapter();
   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]);
+    minDate: applyDefaultDate(adapter, props.minDate, defaultDates.minDate),
+    maxDate: applyDefaultDate(adapter, props.maxDate, defaultDates.maxDate)
+  }), [props.minDate, props.maxDate, props.disableFuture, props.disablePast, adapter, defaultDates]);
 }

package/esm/managers/useDateTimeManager.js

@@ -5,8 +5,8 @@ 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 { useDefaultDates, useUtils } from "../internals/hooks/useUtils.js";
-import { usePickerTranslations } from "../hooks/usePickerTranslations.js";
+import { useDefaultDates } from "../internals/hooks/useUtils.js";
+import { usePickerAdapter, usePickerTranslations } from "../hooks/index.js";
 export function useDateTimeManager(parameters = {}) {
   const {
     enableAccessibleFieldDOMStructure = true
@@ -22,32 +22,32 @@ export function useDateTimeManager(parameters = {}) {
   }), [enableAccessibleFieldDOMStructure]);
 }
 function useOpenPickerButtonAriaLabel(value) {
-  const utils = useUtils();
+  const adapter = usePickerAdapter();
   const translations = usePickerTranslations();
   return React.useMemo(() => {
-    const formattedValue = utils.isValid(value) ? utils.format(value, 'fullDate') : null;
+    const formattedValue = adapter.isValid(value) ? adapter.format(value, 'fullDate') : null;
     return translations.openDatePickerDialogue(formattedValue);
-  }, [value, translations, utils]);
+  }, [value, translations, adapter]);
 }
 function useApplyDefaultValuesToDateTimeFieldInternalProps(internalProps) {
-  const utils = useUtils();
+  const adapter = usePickerAdapter();
   const validationProps = useApplyDefaultValuesToDateTimeValidationProps(internalProps);
-  const ampm = React.useMemo(() => internalProps.ampm ?? utils.is12HourCycleInCurrentLocale(), [internalProps.ampm, utils]);
+  const ampm = React.useMemo(() => internalProps.ampm ?? adapter.is12HourCycleInCurrentLocale(), [internalProps.ampm, adapter]);
   return React.useMemo(() => _extends({}, internalProps, validationProps, {
-    format: internalProps.format ?? (ampm ? utils.formats.keyboardDateTime12h : utils.formats.keyboardDateTime24h)
-  }), [internalProps, validationProps, ampm, utils]);
+    format: internalProps.format ?? (ampm ? adapter.formats.keyboardDateTime12h : adapter.formats.keyboardDateTime24h)
+  }), [internalProps, validationProps, ampm, adapter]);
 }
 export function useApplyDefaultValuesToDateTimeValidationProps(props) {
-  const utils = useUtils();
+  const adapter = usePickerAdapter();
   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),
+    minDate: applyDefaultDate(adapter, props.minDateTime ?? props.minDate, defaultDates.minDate),
+    maxDate: applyDefaultDate(adapter, 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]);
+  }), [props.minDateTime, props.maxDateTime, props.minTime, props.maxTime, props.minDate, props.maxDate, props.disableFuture, props.disablePast, adapter, defaultDates]);
 }

package/esm/managers/useTimeManager.js

@@ -4,8 +4,7 @@ import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 import { singleItemFieldValueManager, singleItemValueManager } from "../internals/utils/valueManagers.js";
 import { validateTime } from "../validation/index.js";
-import { useUtils } from "../internals/hooks/useUtils.js";
-import { usePickerTranslations } from "../hooks/usePickerTranslations.js";
+import { usePickerAdapter, usePickerTranslations } from "../hooks/index.js";
 export function useTimeManager(parameters = {}) {
   const {
     enableAccessibleFieldDOMStructure = true,
@@ -23,22 +22,22 @@ export function useTimeManager(parameters = {}) {
 }
 function createUseOpenPickerButtonAriaLabel(ampm) {
   return function useOpenPickerButtonAriaLabel(value) {
-    const utils = useUtils();
+    const adapter = usePickerAdapter();
     const translations = usePickerTranslations();
     return React.useMemo(() => {
-      const formatKey = ampm ?? utils.is12HourCycleInCurrentLocale() ? 'fullTime12h' : 'fullTime24h';
-      const formattedValue = utils.isValid(value) ? utils.format(value, formatKey) : null;
+      const formatKey = ampm ?? adapter.is12HourCycleInCurrentLocale() ? 'fullTime12h' : 'fullTime24h';
+      const formattedValue = adapter.isValid(value) ? adapter.format(value, formatKey) : null;
       return translations.openTimePickerDialogue(formattedValue);
-    }, [value, translations, utils]);
+    }, [value, translations, adapter]);
   };
 }
 function useApplyDefaultValuesToTimeFieldInternalProps(internalProps) {
-  const utils = useUtils();
+  const adapter = usePickerAdapter();
   const validationProps = useApplyDefaultValuesToTimeValidationProps(internalProps);
-  const ampm = React.useMemo(() => internalProps.ampm ?? utils.is12HourCycleInCurrentLocale(), [internalProps.ampm, utils]);
+  const ampm = React.useMemo(() => internalProps.ampm ?? adapter.is12HourCycleInCurrentLocale(), [internalProps.ampm, adapter]);
   return React.useMemo(() => _extends({}, internalProps, validationProps, {
-    format: internalProps.format ?? (ampm ? utils.formats.fullTime12h : utils.formats.fullTime24h)
-  }), [internalProps, validationProps, ampm, utils]);
+    format: internalProps.format ?? (ampm ? adapter.formats.fullTime12h : adapter.formats.fullTime24h)
+  }), [internalProps, validationProps, ampm, adapter]);
 }
 export function useApplyDefaultValuesToTimeValidationProps(props) {
   return React.useMemo(() => ({

package/esm/validation/useValidation.d.ts

@@ -1,10 +1,9 @@
-import { MuiPickersAdapterContextValue } from "../LocalizationProvider/LocalizationProvider.js";
-import { OnErrorProps, PickersTimezone } from "../models/index.js";
+import { MuiPickersAdapter, OnErrorProps, PickersTimezone } from "../models/index.js";
 import type { PickerValueManager } from "../internals/models/index.js";
 import { PickerValidValue } from "../internals/models/index.js";
 export type Validator<TValue extends PickerValidValue, TError, TValidationProps> = {
   (params: {
-    adapter: MuiPickersAdapterContextValue;
+    adapter: MuiPickersAdapter;
     value: TValue;
     timezone: PickersTimezone;
     props: TValidationProps;

package/esm/validation/useValidation.js

@@ -2,7 +2,7 @@
 
 import * as React from 'react';
 import useEventCallback from '@mui/utils/useEventCallback';
-import { useLocalizationContext } from "../internals/hooks/useUtils.js";
+import { usePickerAdapter } from "../hooks/index.js";
 /**
  * Utility hook to check if a given value is valid based on the provided validation props.
  * @template TValue The value type. It will be the same type as `value` or `null`. It can be in `[start, end]` format in case of range value.
@@ -22,7 +22,7 @@ export function useValidation(options) {
     timezone,
     onError
   } = options;
-  const adapter = useLocalizationContext();
+  const adapter = usePickerAdapter();
   const previousValidationErrorRef = React.useRef(validator.valueManager.defaultErrorState);
   const validationError = validator({
     adapter,

package/esm/validation/validateDate.js

@@ -30,9 +30,9 @@ export const validateDate = ({
     minDate,
     maxDate
   } = props;
-  const now = adapter.utils.date(undefined, timezone);
+  const now = adapter.date(undefined, timezone);
   switch (true) {
-    case !adapter.utils.isValid(value):
+    case !adapter.isValid(value):
       return 'invalidDate';
     case Boolean(shouldDisableDate && shouldDisableDate(value)):
       return 'shouldDisableDate';
@@ -40,13 +40,13 @@ export const validateDate = ({
       return 'shouldDisableMonth';
     case Boolean(shouldDisableYear && shouldDisableYear(value)):
       return 'shouldDisableYear';
-    case Boolean(disableFuture && adapter.utils.isAfterDay(value, now)):
+    case Boolean(disableFuture && adapter.isAfterDay(value, now)):
       return 'disableFuture';
-    case Boolean(disablePast && adapter.utils.isBeforeDay(value, now)):
+    case Boolean(disablePast && adapter.isBeforeDay(value, now)):
       return 'disablePast';
-    case Boolean(minDate && adapter.utils.isBeforeDay(value, minDate)):
+    case Boolean(minDate && adapter.isBeforeDay(value, minDate)):
       return 'minDate';
-    case Boolean(maxDate && adapter.utils.isAfterDay(value, maxDate)):
+    case Boolean(maxDate && adapter.isAfterDay(value, maxDate)):
       return 'maxDate';
     default:
       return null;

package/esm/validation/validateTime.js

@@ -31,18 +31,18 @@ export const validateTime = ({
     disablePast,
     disableFuture
   } = props;
-  const now = adapter.utils.date(undefined, timezone);
-  const isAfter = createIsAfterIgnoreDatePart(disableIgnoringDatePartForTimeValidation, adapter.utils);
+  const now = adapter.date(undefined, timezone);
+  const isAfter = createIsAfterIgnoreDatePart(disableIgnoringDatePartForTimeValidation, adapter);
   switch (true) {
-    case !adapter.utils.isValid(value):
+    case !adapter.isValid(value):
       return 'invalidDate';
     case Boolean(minTime && isAfter(minTime, value)):
       return 'minTime';
     case Boolean(maxTime && isAfter(value, maxTime)):
       return 'maxTime';
-    case Boolean(disableFuture && adapter.utils.isAfter(value, now)):
+    case Boolean(disableFuture && adapter.isAfter(value, now)):
       return 'disableFuture';
-    case Boolean(disablePast && adapter.utils.isBefore(value, now)):
+    case Boolean(disablePast && adapter.isBefore(value, now)):
       return 'disablePast';
     case Boolean(shouldDisableTime && shouldDisableTime(value, 'hours')):
       return 'shouldDisableTime-hours';
@@ -50,7 +50,7 @@ export const validateTime = ({
       return 'shouldDisableTime-minutes';
     case Boolean(shouldDisableTime && shouldDisableTime(value, 'seconds')):
       return 'shouldDisableTime-seconds';
-    case Boolean(minutesStep && adapter.utils.getMinutes(value) % minutesStep !== 0):
+    case Boolean(minutesStep && adapter.getMinutes(value) % minutesStep !== 0):
       return 'minutesStep';
     default:
       return null;

package/hooks/index.d.ts

@@ -3,4 +3,5 @@ export { useSplitFieldProps } from "./useSplitFieldProps.js";
 export { useParsedFormat } from "./useParsedFormat.js";
 export { usePickerContext } from "./usePickerContext.js";
 export { usePickerActionsContext } from "./usePickerActionsContext.js";
-export { useIsValidValue } from "./useIsValidValue.js";
+export { useIsValidValue } from "./useIsValidValue.js";
+export { usePickerAdapter } from "./usePickerAdapter.js";

package/hooks/index.js

@@ -21,6 +21,12 @@ Object.defineProperty(exports, "usePickerActionsContext", {
     return _usePickerActionsContext.usePickerActionsContext;
   }
 });
+Object.defineProperty(exports, "usePickerAdapter", {
+  enumerable: true,
+  get: function () {
+    return _usePickerAdapter.usePickerAdapter;
+  }
+});
 Object.defineProperty(exports, "usePickerContext", {
   enumerable: true,
   get: function () {
@@ -44,4 +50,5 @@ var _useSplitFieldProps = require("./useSplitFieldProps");
 var _useParsedFormat = require("./useParsedFormat");
 var _usePickerContext = require("./usePickerContext");
 var _usePickerActionsContext = require("./usePickerActionsContext");
-var _useIsValidValue = require("./useIsValidValue");
+var _useIsValidValue = require("./useIsValidValue");
+var _usePickerAdapter = require("./usePickerAdapter");

package/hooks/useParsedFormat.js

@@ -8,7 +8,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.useParsedFormat = void 0;
 var React = _interopRequireWildcard(require("react"));
 var _RtlProvider = require("@mui/system/RtlProvider");
-var _useUtils = require("../internals/hooks/useUtils");
+var _usePickerAdapter = require("./usePickerAdapter");
 var _buildSectionsFromFormat = require("../internals/hooks/useField/buildSectionsFromFormat");
 var _useField = require("../internals/hooks/useField/useField.utils");
 var _usePickerTranslations = require("./usePickerTranslations");
@@ -22,16 +22,16 @@ var _useNullablePickerContext = require("../internals/hooks/useNullablePickerCon
  */
 const useParsedFormat = (parameters = {}) => {
   const pickerContext = (0, _useNullablePickerContext.useNullablePickerContext)();
-  const utils = (0, _useUtils.useUtils)();
+  const adapter = (0, _usePickerAdapter.usePickerAdapter)();
   const isRtl = (0, _RtlProvider.useRtl)();
   const translations = (0, _usePickerTranslations.usePickerTranslations)();
-  const localizedDigits = React.useMemo(() => (0, _useField.getLocalizedDigits)(utils), [utils]);
+  const localizedDigits = React.useMemo(() => (0, _useField.getLocalizedDigits)(adapter), [adapter]);
   const {
-    format = pickerContext?.fieldFormat ?? utils.formats.fullDate
+    format = pickerContext?.fieldFormat ?? adapter.formats.fullDate
   } = parameters;
   return React.useMemo(() => {
     const sections = (0, _buildSectionsFromFormat.buildSectionsFromFormat)({
-      utils,
+      adapter,
       format,
       formatDensity: 'dense',
       isRtl,
@@ -43,6 +43,6 @@ const useParsedFormat = (parameters = {}) => {
       enableAccessibleFieldDOMStructure: false
     });
     return sections.map(section => `${section.startSeparator}${section.placeholder}${section.endSeparator}`).join('');
-  }, [utils, isRtl, translations, localizedDigits, format]);
+  }, [adapter, isRtl, translations, localizedDigits, format]);
 };
 exports.useParsedFormat = useParsedFormat;