@mui/x-date-pickers 8.5.2 → 8.6.0

package/esm/internals/hooks/useControlledValue.js

@@ -1,7 +1,8 @@
 import * as React from 'react';
 import useEventCallback from '@mui/utils/useEventCallback';
 import useControlled from '@mui/utils/useControlled';
-import { useUtils } from "./useUtils.js";
+import { usePickerAdapter } from "../../hooks/usePickerAdapter.js";
+
 /**
  * Hooks controlling the value while making sure that:
  * - The value returned by `onChange` always have the timezone of `props.value` or `props.defaultValue` if defined
@@ -16,19 +17,19 @@ export const useControlledValue = ({
   onChange: onChangeProp,
   valueManager
 }) => {
-  const utils = useUtils();
+  const adapter = usePickerAdapter();
   const [valueWithInputTimezone, setValue] = useControlled({
     name,
     state: 'value',
     controlled: valueProp,
     default: defaultValue ?? valueManager.emptyValue
   });
-  const inputTimezone = React.useMemo(() => valueManager.getTimezone(utils, valueWithInputTimezone), [utils, valueManager, valueWithInputTimezone]);
+  const inputTimezone = React.useMemo(() => valueManager.getTimezone(adapter, valueWithInputTimezone), [adapter, valueManager, valueWithInputTimezone]);
   const setInputTimezone = useEventCallback(newValue => {
     if (inputTimezone == null) {
       return newValue;
     }
-    return valueManager.setTimezone(utils, inputTimezone, newValue);
+    return valueManager.setTimezone(adapter, inputTimezone, newValue);
   });
   const timezoneToRender = React.useMemo(() => {
     if (timezoneProp) {
@@ -38,11 +39,11 @@ export const useControlledValue = ({
       return inputTimezone;
     }
     if (referenceDate) {
-      return utils.getTimezone(referenceDate);
+      return adapter.getTimezone(referenceDate);
     }
     return 'default';
-  }, [timezoneProp, inputTimezone, referenceDate, utils]);
-  const valueWithTimezoneToRender = React.useMemo(() => valueManager.setTimezone(utils, timezoneToRender, valueWithInputTimezone), [valueManager, utils, timezoneToRender, valueWithInputTimezone]);
+  }, [timezoneProp, inputTimezone, referenceDate, adapter]);
+  const valueWithTimezoneToRender = React.useMemo(() => valueManager.setTimezone(adapter, timezoneToRender, valueWithInputTimezone), [valueManager, adapter, timezoneToRender, valueWithInputTimezone]);
   const handleValueChange = useEventCallback((newValue, ...otherParams) => {
     const newValueWithInputTimezone = setInputTimezone(newValue);
     setValue(newValueWithInputTimezone);

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

@@ -1,7 +1,7 @@
 import { FieldSection, MuiPickersAdapter, PickerValidDate } from "../../../models/index.js";
 import { PickersLocaleText } from "../../../locales/index.js";
 interface BuildSectionsFromFormatParameters {
-  utils: MuiPickersAdapter;
+  adapter: MuiPickersAdapter;
   format: string;
   formatDensity: 'dense' | 'spacious';
   isRtl: boolean;

package/esm/internals/hooks/useField/buildSectionsFromFormat.js

@@ -1,16 +1,16 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import { applyLocalizedDigits, cleanLeadingZeros, doesSectionFormatHaveLeadingZeros, getDateSectionConfigFromFormatToken, removeLocalizedDigits } from "./useField.utils.js";
 const expandFormat = ({
-  utils,
+  adapter,
   format
 }) => {
   // Expand the provided format
   let formatExpansionOverflow = 10;
   let prevFormat = format;
-  let nextFormat = utils.expandFormat(format);
+  let nextFormat = adapter.expandFormat(format);
   while (nextFormat !== prevFormat) {
     prevFormat = nextFormat;
-    nextFormat = utils.expandFormat(prevFormat);
+    nextFormat = adapter.expandFormat(prevFormat);
     formatExpansionOverflow -= 1;
     if (formatExpansionOverflow < 0) {
       throw new Error('MUI X: The format expansion seems to be in an infinite loop. Please open an issue with the format passed to the component.');
@@ -19,14 +19,14 @@ const expandFormat = ({
   return nextFormat;
 };
 const getEscapedPartsFromFormat = ({
-  utils,
+  adapter,
   expandedFormat
 }) => {
   const escapedParts = [];
   const {
     start: startChar,
     end: endChar
-  } = utils.escapedCharacters;
+  } = adapter.escapedCharacters;
   const regExp = new RegExp(`(\\${startChar}[^\\${endChar}]*\\${endChar})+`, 'g');
   let match = null;
   // eslint-disable-next-line no-cond-assign
@@ -38,12 +38,12 @@ const getEscapedPartsFromFormat = ({
   }
   return escapedParts;
 };
-const getSectionPlaceholder = (utils, localeText, sectionConfig, sectionFormat) => {
+const getSectionPlaceholder = (adapter, localeText, sectionConfig, sectionFormat) => {
   switch (sectionConfig.type) {
     case 'year':
       {
         return localeText.fieldYearPlaceholder({
-          digitAmount: utils.formatByString(utils.date(undefined, 'default'), sectionFormat).length,
+          digitAmount: adapter.formatByString(adapter.date(undefined, 'default'), sectionFormat).length,
           format: sectionFormat
         });
       }
@@ -98,7 +98,7 @@ const getSectionPlaceholder = (utils, localeText, sectionConfig, sectionFormat)
   }
 };
 const createSection = ({
-  utils,
+  adapter,
   date,
   shouldRespectLeadingZeros,
   localeText,
@@ -110,15 +110,15 @@ const createSection = ({
   if (token === '') {
     throw new Error('MUI X: Should not call `commitToken` with an empty token');
   }
-  const sectionConfig = getDateSectionConfigFromFormatToken(utils, token);
-  const hasLeadingZerosInFormat = doesSectionFormatHaveLeadingZeros(utils, sectionConfig.contentType, sectionConfig.type, token);
+  const sectionConfig = getDateSectionConfigFromFormatToken(adapter, token);
+  const hasLeadingZerosInFormat = doesSectionFormatHaveLeadingZeros(adapter, sectionConfig.contentType, sectionConfig.type, token);
   const hasLeadingZerosInInput = shouldRespectLeadingZeros ? hasLeadingZerosInFormat : sectionConfig.contentType === 'digit';
-  const isValidDate = utils.isValid(date);
-  let sectionValue = isValidDate ? utils.formatByString(date, token) : '';
+  const isValidDate = adapter.isValid(date);
+  let sectionValue = isValidDate ? adapter.formatByString(date, token) : '';
   let maxLength = null;
   if (hasLeadingZerosInInput) {
     if (hasLeadingZerosInFormat) {
-      maxLength = sectionValue === '' ? utils.formatByString(now, token).length : sectionValue.length;
+      maxLength = sectionValue === '' ? adapter.formatByString(now, token).length : sectionValue.length;
     } else {
       if (sectionConfig.maxLength == null) {
         throw new Error(`MUI X: The token ${token} should have a 'maxLength' property on it's adapter`);
@@ -133,7 +133,7 @@ const createSection = ({
     format: token,
     maxLength,
     value: sectionValue,
-    placeholder: getSectionPlaceholder(utils, localeText, sectionConfig, token),
+    placeholder: getSectionPlaceholder(adapter, localeText, sectionConfig, token),
     hasLeadingZerosInFormat,
     hasLeadingZerosInInput,
     startSeparator,
@@ -143,16 +143,16 @@ const createSection = ({
 };
 const buildSections = parameters => {
   const {
-    utils,
+    adapter,
     expandedFormat,
     escapedParts
   } = parameters;
-  const now = utils.date(undefined);
+  const now = adapter.date(undefined);
   const sections = [];
   let startSeparator = '';
 
   // This RegExp tests if the beginning of a string corresponds to a supported token
-  const validTokens = Object.keys(utils.formatTokenMap).sort((a, b) => b.length - a.length); // Sort to put longest word first
+  const validTokens = Object.keys(adapter.formatTokenMap).sort((a, b) => b.length - a.length); // Sort to put longest word first
 
   const regExpFirstWordInFormat = /^([a-zA-Z]+)/;
   const regExpWordOnlyComposedOfTokens = new RegExp(`^(${validTokens.join('|')})*$`);

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

@@ -201,12 +201,12 @@ export interface FieldValueManager<TValue extends PickerValidValue> {
    * Update the reference value with the new value.
    * This method must make sure that no date inside the returned `referenceValue` is invalid.
    * @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 adapter to manipulate the date.
    * @param {TValue} value The new value from which we want to take all valid dates in the `referenceValue` state.
    * @param {TValue} prevReferenceValue The previous reference value. It is used as a fallback for invalid dates in the new value.
    * @returns {TValue} The new reference value with no invalid date.
    */
-  updateReferenceValue: (utils: MuiPickersAdapter, value: TValue, prevReferenceValue: InferNonNullablePickerValue<TValue>) => InferNonNullablePickerValue<TValue>;
+  updateReferenceValue: (adapter: MuiPickersAdapter, value: TValue, prevReferenceValue: InferNonNullablePickerValue<TValue>) => InferNonNullablePickerValue<TValue>;
   /**
    * Extract from the given value the date that contains the given section.
    * @param {TValue} value The value to extract the date from.

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

@@ -1,13 +1,13 @@
 import { FieldSectionsValueBoundaries, SectionOrdering, FieldSectionValueBoundaries, FieldParsedSelectedSections } from "./useField.types.js";
 import { FieldSectionType, FieldSection, MuiPickersAdapter, FieldSectionContentType, PickersTimezone, PickerValidDate, FieldSelectedSections, PickerValueType, InferFieldSection } from "../../../models/index.js";
 import { PickerValidValue } from "../../models/index.js";
-export declare const getDateSectionConfigFromFormatToken: (utils: MuiPickersAdapter, formatToken: string) => Pick<FieldSection, "type" | "contentType"> & {
+export declare const getDateSectionConfigFromFormatToken: (adapter: MuiPickersAdapter, formatToken: string) => Pick<FieldSection, "type" | "contentType"> & {
   maxLength: number | undefined;
 };
-export declare const getDaysInWeekStr: (utils: MuiPickersAdapter, format: string) => string[];
-export declare const getLetterEditingOptions: (utils: MuiPickersAdapter, timezone: PickersTimezone, sectionType: FieldSectionType, format: string) => string[];
+export declare const getDaysInWeekStr: (adapter: MuiPickersAdapter, format: string) => string[];
+export declare const getLetterEditingOptions: (adapter: MuiPickersAdapter, timezone: PickersTimezone, sectionType: FieldSectionType, format: string) => string[];
 export declare const FORMAT_SECONDS_NO_LEADING_ZEROS = "s";
-export declare const getLocalizedDigits: (utils: MuiPickersAdapter) => string[];
+export declare const getLocalizedDigits: (adapter: MuiPickersAdapter) => string[];
 export declare const removeLocalizedDigits: (valueStr: string, localizedDigits: string[]) => string;
 export declare const applyLocalizedDigits: (valueStr: string, localizedDigits: string[]) => string;
 export declare const isStringNumber: (valueStr: string, localizedDigits: string[]) => boolean;
@@ -17,20 +17,20 @@ export declare const isStringNumber: (valueStr: string, localizedDigits: string[
  * Warning: Should only be called with non-localized digits. Call `removeLocalizedDigits` with your value if needed.
  */
 export declare const cleanLeadingZeros: (valueStr: string, size: number) => string;
-export declare const cleanDigitSectionValue: (utils: MuiPickersAdapter, value: number, sectionBoundaries: FieldSectionValueBoundaries<any>, localizedDigits: string[], section: Pick<FieldSection, "format" | "type" | "contentType" | "hasLeadingZerosInFormat" | "hasLeadingZerosInInput" | "maxLength">) => string;
+export declare const cleanDigitSectionValue: (adapter: MuiPickersAdapter, value: number, sectionBoundaries: FieldSectionValueBoundaries<any>, localizedDigits: string[], section: Pick<FieldSection, "format" | "type" | "contentType" | "hasLeadingZerosInFormat" | "hasLeadingZerosInInput" | "maxLength">) => string;
 export declare const getSectionVisibleValue: (section: FieldSection, target: "input-rtl" | "input-ltr" | "non-input", localizedDigits: string[]) => string;
-export declare const changeSectionValueFormat: (utils: MuiPickersAdapter, valueStr: string, currentFormat: string, newFormat: string) => string;
-export declare const doesSectionFormatHaveLeadingZeros: (utils: MuiPickersAdapter, contentType: FieldSectionContentType, sectionType: FieldSectionType, format: string) => boolean;
+export declare const changeSectionValueFormat: (adapter: MuiPickersAdapter, valueStr: string, currentFormat: string, newFormat: string) => string;
+export declare const doesSectionFormatHaveLeadingZeros: (adapter: MuiPickersAdapter, contentType: FieldSectionContentType, sectionType: FieldSectionType, format: string) => boolean;
 /**
  * Some date libraries like `dayjs` don't support parsing from date with escaped characters.
  * To make sure that the parsing works, we are building a format and a date without any separator.
  */
-export declare const getDateFromDateSections: (utils: MuiPickersAdapter, sections: FieldSection[], localizedDigits: string[]) => PickerValidDate;
+export declare const getDateFromDateSections: (adapter: MuiPickersAdapter, sections: FieldSection[], localizedDigits: string[]) => PickerValidDate;
 export declare const createDateStrForV7HiddenInputFromSections: (sections: FieldSection[]) => string;
 export declare const createDateStrForV6InputFromSections: (sections: FieldSection[], localizedDigits: string[], isRtl: boolean) => string;
-export declare const getSectionsBoundaries: (utils: MuiPickersAdapter, localizedDigits: string[], timezone: PickersTimezone) => FieldSectionsValueBoundaries;
+export declare const getSectionsBoundaries: (adapter: MuiPickersAdapter, localizedDigits: string[], timezone: PickersTimezone) => FieldSectionsValueBoundaries;
 export declare const validateSections: <TValue extends PickerValidValue>(sections: InferFieldSection<TValue>[], valueType: PickerValueType) => void;
-export declare const mergeDateIntoReferenceDate: (utils: MuiPickersAdapter, dateToTransferFrom: PickerValidDate, sections: FieldSection[], referenceDate: PickerValidDate, shouldLimitToEditedSections: boolean) => PickerValidDate;
+export declare const mergeDateIntoReferenceDate: (adapter: MuiPickersAdapter, dateToTransferFrom: PickerValidDate, sections: FieldSection[], referenceDate: PickerValidDate, shouldLimitToEditedSections: boolean) => PickerValidDate;
 export declare const isAndroid: () => boolean;
 export declare const getSectionOrder: (sections: FieldSection[], shouldApplyRTL: boolean) => SectionOrdering;
 export declare const parseSelectedSections: (selectedSections: FieldSelectedSections, sections: FieldSection[]) => FieldParsedSelectedSections;

package/esm/internals/hooks/useField/useField.utils.js

@@ -1,6 +1,6 @@
 import { getMonthsInYear } from "../../utils/date-utils.js";
-export const getDateSectionConfigFromFormatToken = (utils, formatToken) => {
-  const config = utils.formatTokenMap[formatToken];
+export const getDateSectionConfigFromFormatToken = (adapter, formatToken) => {
+  const config = adapter.formatTokenMap[formatToken];
   if (config == null) {
     throw new Error([`MUI X: The token "${formatToken}" is not supported by the Date and Time Pickers.`, 'Please try using another token or open an issue on https://github.com/mui/mui-x/issues/new/choose if you think it should be supported.'].join('\n'));
   }
@@ -17,32 +17,32 @@ export const getDateSectionConfigFromFormatToken = (utils, formatToken) => {
     maxLength: config.maxLength
   };
 };
-export const getDaysInWeekStr = (utils, format) => {
+export const getDaysInWeekStr = (adapter, format) => {
   const elements = [];
-  const now = utils.date(undefined, 'default');
-  const startDate = utils.startOfWeek(now);
-  const endDate = utils.endOfWeek(now);
+  const now = adapter.date(undefined, 'default');
+  const startDate = adapter.startOfWeek(now);
+  const endDate = adapter.endOfWeek(now);
   let current = startDate;
-  while (utils.isBefore(current, endDate)) {
+  while (adapter.isBefore(current, endDate)) {
     elements.push(current);
-    current = utils.addDays(current, 1);
+    current = adapter.addDays(current, 1);
   }
-  return elements.map(weekDay => utils.formatByString(weekDay, format));
+  return elements.map(weekDay => adapter.formatByString(weekDay, format));
 };
-export const getLetterEditingOptions = (utils, timezone, sectionType, format) => {
+export const getLetterEditingOptions = (adapter, timezone, sectionType, format) => {
   switch (sectionType) {
     case 'month':
       {
-        return getMonthsInYear(utils, utils.date(undefined, timezone)).map(month => utils.formatByString(month, format));
+        return getMonthsInYear(adapter, adapter.date(undefined, timezone)).map(month => adapter.formatByString(month, format));
       }
     case 'weekDay':
       {
-        return getDaysInWeekStr(utils, format);
+        return getDaysInWeekStr(adapter, format);
       }
     case 'meridiem':
       {
-        const now = utils.date(undefined, timezone);
-        return [utils.startOfDay(now), utils.endOfDay(now)].map(date => utils.formatByString(date, format));
+        const now = adapter.date(undefined, timezone);
+        return [adapter.startOfDay(now), adapter.endOfDay(now)].map(date => adapter.formatByString(date, format));
       }
     default:
       {
@@ -55,15 +55,15 @@ export const getLetterEditingOptions = (utils, timezone, sectionType, format) =>
 // If some adapter does not respect this convention, then we will need to hardcode the format on each adapter.
 export const FORMAT_SECONDS_NO_LEADING_ZEROS = 's';
 const NON_LOCALIZED_DIGITS = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
-export const getLocalizedDigits = utils => {
-  const today = utils.date(undefined);
-  const formattedZero = utils.formatByString(utils.setSeconds(today, 0), FORMAT_SECONDS_NO_LEADING_ZEROS);
+export const getLocalizedDigits = adapter => {
+  const today = adapter.date(undefined);
+  const formattedZero = adapter.formatByString(adapter.setSeconds(today, 0), FORMAT_SECONDS_NO_LEADING_ZEROS);
   if (formattedZero === '0') {
     return NON_LOCALIZED_DIGITS;
   }
   return Array.from({
     length: 10
-  }).map((_, index) => utils.formatByString(utils.setSeconds(today, index), FORMAT_SECONDS_NO_LEADING_ZEROS));
+  }).map((_, index) => adapter.formatByString(adapter.setSeconds(today, index), FORMAT_SECONDS_NO_LEADING_ZEROS));
 };
 export const removeLocalizedDigits = (valueStr, localizedDigits) => {
   if (localizedDigits[0] === '0') {
@@ -102,7 +102,7 @@ export const cleanLeadingZeros = (valueStr, size) => {
   // Remove the leading zeros and then add back as many as needed.
   return Number(valueStr).toString().padStart(size, '0');
 };
-export const cleanDigitSectionValue = (utils, value, sectionBoundaries, localizedDigits, section) => {
+export const cleanDigitSectionValue = (adapter, value, sectionBoundaries, localizedDigits, section) => {
   if (process.env.NODE_ENV !== 'production') {
     if (section.type !== 'day' && section.contentType === 'digit-with-letter') {
       throw new Error([`MUI X: The token "${section.format}" is a digit format with letter in it.'
@@ -110,8 +110,8 @@ export const cleanDigitSectionValue = (utils, value, sectionBoundaries, localize
     }
   }
   if (section.type === 'day' && section.contentType === 'digit-with-letter') {
-    const date = utils.setDate(sectionBoundaries.longestMonth, value);
-    return utils.formatByString(date, section.format);
+    const date = adapter.setDate(sectionBoundaries.longestMonth, value);
+    return adapter.formatByString(date, section.format);
   }
 
   // queryValue without leading `0` (`01` => `1`)
@@ -142,53 +142,53 @@ export const getSectionVisibleValue = (section, target, localizedDigits) => {
   }
   return value;
 };
-export const changeSectionValueFormat = (utils, valueStr, currentFormat, newFormat) => {
+export const changeSectionValueFormat = (adapter, valueStr, currentFormat, newFormat) => {
   if (process.env.NODE_ENV !== 'production') {
-    if (getDateSectionConfigFromFormatToken(utils, currentFormat).type === 'weekDay') {
+    if (getDateSectionConfigFromFormatToken(adapter, currentFormat).type === 'weekDay') {
       throw new Error("changeSectionValueFormat doesn't support week day formats");
     }
   }
-  return utils.formatByString(utils.parse(valueStr, currentFormat), newFormat);
+  return adapter.formatByString(adapter.parse(valueStr, currentFormat), newFormat);
 };
-const isFourDigitYearFormat = (utils, format) => utils.formatByString(utils.date(undefined, 'system'), format).length === 4;
-export const doesSectionFormatHaveLeadingZeros = (utils, contentType, sectionType, format) => {
+const isFourDigitYearFormat = (adapter, format) => adapter.formatByString(adapter.date(undefined, 'system'), format).length === 4;
+export const doesSectionFormatHaveLeadingZeros = (adapter, contentType, sectionType, format) => {
   if (contentType !== 'digit') {
     return false;
   }
-  const now = utils.date(undefined, 'default');
+  const now = adapter.date(undefined, 'default');
   switch (sectionType) {
-    // We can't use `changeSectionValueFormat`, because  `utils.parse('1', 'YYYY')` returns `1971` instead of `1`.
+    // We can't use `changeSectionValueFormat`, because  `adapter.parse('1', 'YYYY')` returns `1971` instead of `1`.
     case 'year':
       {
         // Remove once https://github.com/iamkun/dayjs/pull/2847 is merged and bump dayjs version
-        if (utils.lib === 'dayjs' && format === 'YY') {
+        if (adapter.lib === 'dayjs' && format === 'YY') {
           return true;
         }
-        return utils.formatByString(utils.setYear(now, 1), format).startsWith('0');
+        return adapter.formatByString(adapter.setYear(now, 1), format).startsWith('0');
       }
     case 'month':
       {
-        return utils.formatByString(utils.startOfYear(now), format).length > 1;
+        return adapter.formatByString(adapter.startOfYear(now), format).length > 1;
       }
     case 'day':
       {
-        return utils.formatByString(utils.startOfMonth(now), format).length > 1;
+        return adapter.formatByString(adapter.startOfMonth(now), format).length > 1;
       }
     case 'weekDay':
       {
-        return utils.formatByString(utils.startOfWeek(now), format).length > 1;
+        return adapter.formatByString(adapter.startOfWeek(now), format).length > 1;
       }
     case 'hours':
       {
-        return utils.formatByString(utils.setHours(now, 1), format).length > 1;
+        return adapter.formatByString(adapter.setHours(now, 1), format).length > 1;
       }
     case 'minutes':
       {
-        return utils.formatByString(utils.setMinutes(now, 1), format).length > 1;
+        return adapter.formatByString(adapter.setMinutes(now, 1), format).length > 1;
       }
     case 'seconds':
       {
-        return utils.formatByString(utils.setSeconds(now, 1), format).length > 1;
+        return adapter.formatByString(adapter.setSeconds(now, 1), format).length > 1;
       }
     default:
       {
@@ -201,7 +201,7 @@ export const doesSectionFormatHaveLeadingZeros = (utils, contentType, sectionTyp
  * Some date libraries like `dayjs` don't support parsing from date with escaped characters.
  * To make sure that the parsing works, we are building a format and a date without any separator.
  */
-export const getDateFromDateSections = (utils, sections, localizedDigits) => {
+export const getDateFromDateSections = (adapter, sections, localizedDigits) => {
   // If we have both a day and a weekDay section,
   // Then we skip the weekDay in the parsing because libraries like dayjs can't parse complicated formats containing a weekDay.
   // dayjs(dayjs().format('dddd MMMM D YYYY'), 'dddd MMMM D YYYY')) // returns `Invalid Date` even if the format is valid.
@@ -218,7 +218,7 @@ export const getDateFromDateSections = (utils, sections, localizedDigits) => {
   }
   const formatWithoutSeparator = sectionFormats.join(' ');
   const dateWithoutSeparatorStr = sectionValues.join(' ');
-  return utils.parse(dateWithoutSeparatorStr, formatWithoutSeparator);
+  return adapter.parse(dateWithoutSeparatorStr, formatWithoutSeparator);
 };
 export const createDateStrForV7HiddenInputFromSections = sections => sections.map(section => {
   return `${section.startSeparator}${section.value || section.placeholder}${section.endSeparator}`;
@@ -240,15 +240,15 @@ export const createDateStrForV6InputFromSections = (sections, localizedDigits, i
   // wrap into an isolated group such that separators can split the string in smaller ones by adding \u2069\u2068
   return `\u2066${dateStr}\u2069`;
 };
-export const getSectionsBoundaries = (utils, localizedDigits, timezone) => {
-  const today = utils.date(undefined, timezone);
-  const endOfYear = utils.endOfYear(today);
-  const endOfDay = utils.endOfDay(today);
+export const getSectionsBoundaries = (adapter, localizedDigits, timezone) => {
+  const today = adapter.date(undefined, timezone);
+  const endOfYear = adapter.endOfYear(today);
+  const endOfDay = adapter.endOfDay(today);
   const {
     maxDaysInMonth,
     longestMonth
-  } = getMonthsInYear(utils, today).reduce((acc, month) => {
-    const daysInMonth = utils.getDaysInMonth(month);
+  } = getMonthsInYear(adapter, today).reduce((acc, month) => {
+    const daysInMonth = adapter.getDaysInMonth(month);
     if (daysInMonth > acc.maxDaysInMonth) {
       return {
         maxDaysInMonth: daysInMonth,
@@ -265,18 +265,18 @@ export const getSectionsBoundaries = (utils, localizedDigits, timezone) => {
       format
     }) => ({
       minimum: 0,
-      maximum: isFourDigitYearFormat(utils, format) ? 9999 : 99
+      maximum: isFourDigitYearFormat(adapter, format) ? 9999 : 99
     }),
     month: () => ({
       minimum: 1,
       // Assumption: All years have the same amount of months
-      maximum: utils.getMonth(endOfYear) + 1
+      maximum: adapter.getMonth(endOfYear) + 1
     }),
     day: ({
       currentDate
     }) => ({
       minimum: 1,
-      maximum: utils.isValid(currentDate) ? utils.getDaysInMonth(currentDate) : maxDaysInMonth,
+      maximum: adapter.isValid(currentDate) ? adapter.getDaysInMonth(currentDate) : maxDaysInMonth,
       longestMonth: longestMonth
     }),
     weekDay: ({
@@ -284,7 +284,7 @@ export const getSectionsBoundaries = (utils, localizedDigits, timezone) => {
       contentType
     }) => {
       if (contentType === 'digit') {
-        const daysInWeek = getDaysInWeekStr(utils, format).map(Number);
+        const daysInWeek = getDaysInWeekStr(adapter, format).map(Number);
         return {
           minimum: Math.min(...daysInWeek),
           maximum: Math.max(...daysInWeek)
@@ -298,12 +298,12 @@ export const getSectionsBoundaries = (utils, localizedDigits, timezone) => {
     hours: ({
       format
     }) => {
-      const lastHourInDay = utils.getHours(endOfDay);
-      const hasMeridiem = removeLocalizedDigits(utils.formatByString(utils.endOfDay(today), format), localizedDigits) !== lastHourInDay.toString();
+      const lastHourInDay = adapter.getHours(endOfDay);
+      const hasMeridiem = removeLocalizedDigits(adapter.formatByString(adapter.endOfDay(today), format), localizedDigits) !== lastHourInDay.toString();
       if (hasMeridiem) {
         return {
           minimum: 1,
-          maximum: Number(removeLocalizedDigits(utils.formatByString(utils.startOfDay(today), format), localizedDigits))
+          maximum: Number(removeLocalizedDigits(adapter.formatByString(adapter.startOfDay(today), format), localizedDigits))
         };
       }
       return {
@@ -314,12 +314,12 @@ export const getSectionsBoundaries = (utils, localizedDigits, timezone) => {
     minutes: () => ({
       minimum: 0,
       // Assumption: All years have the same amount of minutes
-      maximum: utils.getMinutes(endOfDay)
+      maximum: adapter.getMinutes(endOfDay)
     }),
     seconds: () => ({
       minimum: 0,
       // Assumption: All years have the same amount of seconds
-      maximum: utils.getSeconds(endOfDay)
+      maximum: adapter.getSeconds(endOfDay)
     }),
     meridiem: () => ({
       minimum: 0,
@@ -350,55 +350,55 @@ export const validateSections = (sections, valueType) => {
     }
   }
 };
-const transferDateSectionValue = (utils, section, dateToTransferFrom, dateToTransferTo) => {
+const transferDateSectionValue = (adapter, section, dateToTransferFrom, dateToTransferTo) => {
   switch (section.type) {
     case 'year':
       {
-        return utils.setYear(dateToTransferTo, utils.getYear(dateToTransferFrom));
+        return adapter.setYear(dateToTransferTo, adapter.getYear(dateToTransferFrom));
       }
     case 'month':
       {
-        return utils.setMonth(dateToTransferTo, utils.getMonth(dateToTransferFrom));
+        return adapter.setMonth(dateToTransferTo, adapter.getMonth(dateToTransferFrom));
       }
     case 'weekDay':
       {
-        let dayInWeekStrOfActiveDate = utils.formatByString(dateToTransferFrom, section.format);
+        let dayInWeekStrOfActiveDate = adapter.formatByString(dateToTransferFrom, section.format);
         if (section.hasLeadingZerosInInput) {
           dayInWeekStrOfActiveDate = cleanLeadingZeros(dayInWeekStrOfActiveDate, section.maxLength);
         }
-        const formattedDaysInWeek = getDaysInWeekStr(utils, section.format);
+        const formattedDaysInWeek = getDaysInWeekStr(adapter, section.format);
         const dayInWeekOfActiveDate = formattedDaysInWeek.indexOf(dayInWeekStrOfActiveDate);
         const dayInWeekOfNewSectionValue = formattedDaysInWeek.indexOf(section.value);
         const diff = dayInWeekOfNewSectionValue - dayInWeekOfActiveDate;
-        return utils.addDays(dateToTransferFrom, diff);
+        return adapter.addDays(dateToTransferFrom, diff);
       }
     case 'day':
       {
-        return utils.setDate(dateToTransferTo, utils.getDate(dateToTransferFrom));
+        return adapter.setDate(dateToTransferTo, adapter.getDate(dateToTransferFrom));
       }
     case 'meridiem':
       {
-        const isAM = utils.getHours(dateToTransferFrom) < 12;
-        const mergedDateHours = utils.getHours(dateToTransferTo);
+        const isAM = adapter.getHours(dateToTransferFrom) < 12;
+        const mergedDateHours = adapter.getHours(dateToTransferTo);
         if (isAM && mergedDateHours >= 12) {
-          return utils.addHours(dateToTransferTo, -12);
+          return adapter.addHours(dateToTransferTo, -12);
         }
         if (!isAM && mergedDateHours < 12) {
-          return utils.addHours(dateToTransferTo, 12);
+          return adapter.addHours(dateToTransferTo, 12);
         }
         return dateToTransferTo;
       }
     case 'hours':
       {
-        return utils.setHours(dateToTransferTo, utils.getHours(dateToTransferFrom));
+        return adapter.setHours(dateToTransferTo, adapter.getHours(dateToTransferFrom));
       }
     case 'minutes':
       {
-        return utils.setMinutes(dateToTransferTo, utils.getMinutes(dateToTransferFrom));
+        return adapter.setMinutes(dateToTransferTo, adapter.getMinutes(dateToTransferFrom));
       }
     case 'seconds':
       {
-        return utils.setSeconds(dateToTransferTo, utils.getSeconds(dateToTransferFrom));
+        return adapter.setSeconds(dateToTransferTo, adapter.getSeconds(dateToTransferFrom));
       }
     default:
       {
@@ -417,11 +417,11 @@ const reliableSectionModificationOrder = {
   meridiem: 8,
   empty: 9
 };
-export const mergeDateIntoReferenceDate = (utils, dateToTransferFrom, sections, referenceDate, shouldLimitToEditedSections) =>
+export const mergeDateIntoReferenceDate = (adapter, dateToTransferFrom, sections, referenceDate, shouldLimitToEditedSections) =>
 // cloning sections before sort to avoid mutating it
 [...sections].sort((a, b) => reliableSectionModificationOrder[a.type] - reliableSectionModificationOrder[b.type]).reduce((mergedDate, section) => {
   if (!shouldLimitToEditedSections || section.modified) {
-    return transferDateSectionValue(utils, section, dateToTransferFrom, mergedDate);
+    return transferDateSectionValue(adapter, section, dateToTransferFrom, mergedDate);
   }
   return mergedDate;
 }, referenceDate);