@mui/x-date-pickers 8.5.3 → 8.7.0

package/esm/internals/models/manager.d.ts

@@ -1,6 +1,6 @@
 import type { MuiPickersAdapter, PickerManager, PickersTimezone, PickerValidDate, PickerValueType } from "../../models/index.js";
 import type { GetDefaultReferenceDateProps } from "../utils/getDefaultReferenceDate.js";
-import { InferNonNullablePickerValue, PickerValidValue } from "./value.js";
+import { InferNonNullablePickerValue, PickerRangeValue, PickerValidValue } from "./value.js";
 import type { UseFieldInternalProps } from "../hooks/useField/index.js";
 export type PickerAnyManager = PickerManager<any, any, any, any, any>;
 type PickerManagerProperties<TManager extends PickerAnyManager> = TManager extends PickerManager<infer TValue, infer TEnableAccessibleFieldDOMStructure, infer TError, infer TValidationProps, infer TFieldInternalProps> ? {
@@ -20,12 +20,12 @@ export interface PickerValueManager<TValue extends PickerValidValue, TError> {
   /**
    * Determines if two values are equal.
    * @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.
-   * @param {MuiPickersAdapter} utils The adapter.
+   * @param {MuiPickersAdapter} adapter The Picker date adapter instance.
    * @param {TValue} valueLeft The first value to compare.
    * @param {TValue} valueRight The second value to compare.
    * @returns {boolean} A boolean indicating if the two values are equal.
    */
-  areValuesEqual: (utils: MuiPickersAdapter, valueLeft: TValue, valueRight: TValue) => boolean;
+  areValuesEqual: (adapter: MuiPickersAdapter, valueLeft: TValue, valueRight: TValue) => boolean;
   /**
    * Value to set when clicking the "Clear" button.
    */
@@ -33,30 +33,30 @@ export interface PickerValueManager<TValue extends PickerValidValue, TError> {
   /**
    * Method returning the value to set when clicking the "Today" button.
    * @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.
-   * @param {MuiPickersAdapter} utils The adapter.
+   * @param {MuiPickersAdapter} adapter The Picker date adapter instance.
    * @param {PickersTimezone} timezone The current timezone.
    * @param {PickerValueType} valueType The type of the value being edited.
    * @returns {TValue} The value to set when clicking the "Today" button.
    */
-  getTodayValue: (utils: MuiPickersAdapter, timezone: PickersTimezone, valueType: PickerValueType) => TValue;
+  getTodayValue: (adapter: MuiPickersAdapter, timezone: PickersTimezone, valueType: PickerValueType) => TValue;
   /**
    * @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.
    * Method returning the reference value to use when mounting the component.
    * @param {object} params The params of the method.
-   * @param {PickerValidDate | undefined} params.referenceDate The referenceDate provided by the user.
+   * @param {PickerValidDate | PickerValidDate[] | undefined} params.referenceDate The referenceDate provided by the user.
    * @param {TValue} params.value The value provided by the user.
    * @param {GetDefaultReferenceDateProps} params.props The validation props needed to compute the reference value.
-   * @param {MuiPickersAdapter} params.utils The adapter.
+   * @param {MuiPickersAdapter} params.adapter The Picker date adapter instance.
    * @param {number} params.granularity The granularity of the selection possible on this component.
    * @param {PickersTimezone} params.timezone The current timezone.
    * @param {() => PickerValidDate} params.getTodayDate The reference date to use if no reference date is passed to the component.
    * @returns {TValue} The reference value to use for non-provided dates.
    */
   getInitialReferenceValue: (params: {
-    referenceDate: PickerValidDate | undefined;
+    referenceDate?: TValue extends PickerRangeValue ? TValue | PickerValidDate : PickerValidDate;
     value: TValue;
     props: GetDefaultReferenceDateProps;
-    utils: MuiPickersAdapter;
+    adapter: MuiPickersAdapter;
     granularity: number;
     timezone: PickersTimezone;
     getTodayDate?: () => PickerValidDate;
@@ -64,20 +64,20 @@ export interface PickerValueManager<TValue extends PickerValidValue, TError> {
   /**
    * Method parsing the input value to replace all invalid dates by `null`.
    * @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.
-   * @param {MuiPickersAdapter} utils The adapter.
+   * @param {MuiPickersAdapter} adapter The Picker date adapter instance.
    * @param {TValue} value The value to parse.
    * @returns {TValue} The value without invalid date.
    */
-  cleanValue: (utils: MuiPickersAdapter, value: TValue) => TValue;
+  cleanValue: (adapter: MuiPickersAdapter, value: TValue) => TValue;
   /**
    * Generates the new value, given the previous value and the new proposed value.
    * @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.
-   * @param {MuiPickersAdapter} utils The adapter.
+   * @param {MuiPickersAdapter} adapter The Picker date adapter instance.
    * @param {TValue} lastValidDateValue The last valid value.
    * @param {TValue} value The proposed value.
    * @returns {TValue} The new value.
    */
-  valueReducer?: (utils: MuiPickersAdapter, lastValidDateValue: TValue, value: TValue) => TValue;
+  valueReducer?: (adapter: MuiPickersAdapter, lastValidDateValue: TValue, value: TValue) => TValue;
   /**
    * Compare two errors to know if they are equal.
    * @template TError
@@ -101,19 +101,19 @@ export interface PickerValueManager<TValue extends PickerValidValue, TError> {
      * Return the timezone of the date inside a value.
      * When used on a range Picker, throw an error if both values don't have the same timezone.
      * @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.
-     @param {MuiPickersAdapter} utils The utils to manipulate the date.
+     @param {MuiPickersAdapter} adapter The Picker date adapter instance.
      @param {TValue} value The current value.
      @returns {string | null} The timezone of the current value.
      */
-  getTimezone: (utils: MuiPickersAdapter, value: TValue) => string | null;
+  getTimezone: (adapter: MuiPickersAdapter, value: TValue) => string | null;
   /**
      * Change the timezone of the dates inside a value.
      * @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.
-     @param {MuiPickersAdapter} utils The utils to manipulate the date.
+     @param {MuiPickersAdapter} adapter The Picker date adapter instance.
      @param {PickersTimezone} timezone The current timezone.
      @param {TValue} value The value to convert.
      @returns {TValue} The value with the new dates in the new timezone.
      */
-  setTimezone: (utils: MuiPickersAdapter, timezone: PickersTimezone, value: TValue) => TValue;
+  setTimezone: (adapter: MuiPickersAdapter, timezone: PickersTimezone, value: TValue) => TValue;
 }
 export {};

package/esm/internals/models/props/time.d.ts

@@ -10,7 +10,7 @@ import { PickerValue } from "../value.js";
 export interface AmPmProps {
   /**
    * 12h/24h view for hour selection clock.
-   * @default utils.is12HourCycleInCurrentLocale()
+   * @default adapter.is12HourCycleInCurrentLocale()
    */
   ampm?: boolean;
 }

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

@@ -2,7 +2,7 @@ import { DefaultizedProps } from '@mui/x-internals/types';
 import { DateOrTimeView, MuiPickersAdapter } from "../../models/index.js";
 import { DateOrTimeViewWithMeridiem } from "../models/index.js";
 import { DigitalTimePickerProps } from "../models/props/time.js";
-export declare const resolveDateTimeFormat: (utils: MuiPickersAdapter, {
+export declare const resolveDateTimeFormat: (adapter: MuiPickersAdapter, {
   views,
   format,
   ...other

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

@@ -3,7 +3,7 @@ import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWith
 const _excluded = ["views", "format"];
 import { resolveTimeFormat, isTimeView, isInternalTimeView } from "./time-utils.js";
 import { isDatePickerView, resolveDateFormat } from "./date-utils.js";
-export const resolveDateTimeFormat = (utils, _ref, ignoreDateResolving) => {
+export const resolveDateTimeFormat = (adapter, _ref, ignoreDateResolving) => {
   let {
       views,
       format
@@ -22,19 +22,19 @@ export const resolveDateTimeFormat = (utils, _ref, ignoreDateResolving) => {
     }
   });
   if (timeViews.length === 0) {
-    return resolveDateFormat(utils, _extends({
+    return resolveDateFormat(adapter, _extends({
       views: dateViews
     }, other), false);
   }
   if (dateViews.length === 0) {
-    return resolveTimeFormat(utils, _extends({
+    return resolveTimeFormat(adapter, _extends({
       views: timeViews
     }, other));
   }
-  const timeFormat = resolveTimeFormat(utils, _extends({
+  const timeFormat = resolveTimeFormat(adapter, _extends({
     views: timeViews
   }, other));
-  const dateFormat = ignoreDateResolving ? utils.formats.keyboardDate : resolveDateFormat(utils, _extends({
+  const dateFormat = ignoreDateResolving ? adapter.formats.keyboardDate : resolveDateFormat(adapter, _extends({
     views: dateViews
   }, other), false);
   return `${dateFormat} ${timeFormat}`;

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

@@ -1,6 +1,6 @@
 import { DateView, MuiPickersAdapter, PickersTimezone, PickerValidDate, PickerValueType } from "../../models/index.js";
 import { DateOrTimeViewWithMeridiem } from "../models/index.js";
-export declare const mergeDateAndTime: (utils: MuiPickersAdapter, dateParam: PickerValidDate, timeParam: PickerValidDate) => PickerValidDate;
+export declare const mergeDateAndTime: (adapter: MuiPickersAdapter, dateParam: PickerValidDate, timeParam: PickerValidDate) => PickerValidDate;
 interface FindClosestDateParams {
   date: PickerValidDate;
   disableFuture?: boolean;
@@ -8,7 +8,7 @@ interface FindClosestDateParams {
   maxDate: PickerValidDate;
   minDate: PickerValidDate;
   isDateDisabled: (date: PickerValidDate) => boolean;
-  utils: MuiPickersAdapter;
+  adapter: MuiPickersAdapter;
   timezone: PickersTimezone;
 }
 export declare const findClosestEnabledDate: ({
@@ -18,23 +18,23 @@ export declare const findClosestEnabledDate: ({
   maxDate,
   minDate,
   isDateDisabled,
-  utils,
+  adapter,
   timezone
 }: FindClosestDateParams) => PickerValidDate | null;
-export declare const replaceInvalidDateByNull: (utils: MuiPickersAdapter, value: PickerValidDate | null) => PickerValidDate | null;
-export declare const applyDefaultDate: (utils: MuiPickersAdapter, value: PickerValidDate | null | undefined, defaultValue: PickerValidDate) => PickerValidDate;
-export declare const areDatesEqual: (utils: MuiPickersAdapter, a: PickerValidDate | null, b: PickerValidDate | null) => boolean;
-export declare const getMonthsInYear: (utils: MuiPickersAdapter, year: PickerValidDate) => PickerValidDate[];
-export declare const getTodayDate: (utils: MuiPickersAdapter, timezone: PickersTimezone, valueType?: PickerValueType) => PickerValidDate;
-export declare const formatMeridiem: (utils: MuiPickersAdapter, meridiem: "am" | "pm") => string;
+export declare const replaceInvalidDateByNull: (adapter: MuiPickersAdapter, value: PickerValidDate | null) => PickerValidDate | null;
+export declare const applyDefaultDate: (adapter: MuiPickersAdapter, value: PickerValidDate | null | undefined, defaultValue: PickerValidDate) => PickerValidDate;
+export declare const areDatesEqual: (adapter: MuiPickersAdapter, a: PickerValidDate | null, b: PickerValidDate | null) => boolean;
+export declare const getMonthsInYear: (adapter: MuiPickersAdapter, year: PickerValidDate) => PickerValidDate[];
+export declare const getTodayDate: (adapter: MuiPickersAdapter, timezone: PickersTimezone, valueType?: PickerValueType) => PickerValidDate;
+export declare const formatMeridiem: (adapter: MuiPickersAdapter, meridiem: "am" | "pm") => string;
 export declare const DATE_VIEWS: readonly ["year", "month", "day"];
 export declare const isDatePickerView: (view: DateOrTimeViewWithMeridiem) => view is DateView;
-export declare const resolveDateFormat: (utils: MuiPickersAdapter, {
+export declare const resolveDateFormat: (adapter: MuiPickersAdapter, {
   format,
   views
 }: {
   format?: string;
   views: readonly DateView[];
 }, isInToolbar: boolean) => string;
-export declare const getWeekdays: (utils: MuiPickersAdapter, date: PickerValidDate) => PickerValidDate[];
+export declare const getWeekdays: (adapter: MuiPickersAdapter, date: PickerValidDate) => PickerValidDate[];
 export {};

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]);
 }