@mui/x-date-pickers 7.0.0-beta.2 → 7.0.0-beta.5

package/internals/demo/DemoContainer.js

@@ -3,6 +3,7 @@ import * as React from 'react';
 import Stack, { stackClasses } from '@mui/material/Stack';
 import Typography from '@mui/material/Typography';
 import { textFieldClasses } from '@mui/material/TextField';
+import { pickersTextFieldClasses } from '@mui/x-date-pickers/PickersTextField';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { jsxs as _jsxs } from "react/jsx-runtime";
 const getChildTypeFromChildName = childName => {
@@ -123,13 +124,13 @@ export function DemoContainer(props) {
   } else if (childrenTypes.has('single-input-range-field')) {
     if (!childrenSupportedSections.has('date-time')) {
       extraSx = {
-        [`& > .${textFieldClasses.root}`]: {
+        [`& > .${textFieldClasses.root}, & > .${pickersTextFieldClasses.root}`]: {
           minWidth: 300
         }
       };
     } else {
       extraSx = {
-        [`& > .${textFieldClasses.root}`]: {
+        [`& > .${textFieldClasses.root}, & > .${pickersTextFieldClasses.root}`]: {
           minWidth: {
             xs: 300,
             // If demo also contains MultiInputDateTimeRangeField, increase width to avoid cutting off the value.
@@ -140,21 +141,21 @@ export function DemoContainer(props) {
     }
   } else if (childrenSupportedSections.has('date-time')) {
     extraSx = {
-      [`& > .${textFieldClasses.root}`]: {
+      [`& > .${textFieldClasses.root}, & > .${pickersTextFieldClasses.root}`]: {
         minWidth: 270
       }
     };
     if (childrenTypes.has('multi-input-range-field')) {
       // increase width for the multi input date time range fields
       demoItemSx = {
-        [`& > .${stackClasses.root} > .${textFieldClasses.root}`]: {
+        [`& > .${stackClasses.root} > .${textFieldClasses.root}, & > .${stackClasses.root} > .${pickersTextFieldClasses.root}`]: {
           minWidth: 210
         }
       };
     }
   } else {
     extraSx = {
-      [`& > .${textFieldClasses.root}`]: {
+      [`& > .${textFieldClasses.root}, & > .${pickersTextFieldClasses.root}`]: {
         minWidth: 200
       }
     };

package/internals/hooks/defaultizedFieldProps.d.ts

@@ -0,0 +1,19 @@
+import { BaseDateValidationProps, BaseTimeValidationProps, DateTimeValidationProps, TimeValidationProps } from '../models/validation';
+import { DefaultizedProps } from '../models/helpers';
+import { PickerValidDate } from '../../models';
+export interface UseDefaultizedDateFieldBaseProps<TDate extends PickerValidDate> extends BaseDateValidationProps<TDate> {
+    format?: string;
+}
+export declare const useDefaultizedDateField: <TDate extends PickerValidDate, TKnownProps extends UseDefaultizedDateFieldBaseProps<TDate>, TAllProps extends {}>(props: TKnownProps & TAllProps) => TAllProps & Omit<TKnownProps, keyof UseDefaultizedDateFieldBaseProps<any>> & Required<Pick<TKnownProps, keyof UseDefaultizedDateFieldBaseProps<any>>>;
+export interface UseDefaultizedTimeFieldBaseProps extends BaseTimeValidationProps {
+    format?: string;
+}
+export declare const useDefaultizedTimeField: <TDate extends PickerValidDate, TKnownProps extends UseDefaultizedTimeFieldBaseProps & {
+    ampm?: boolean | undefined;
+}, TAllProps extends {}>(props: TKnownProps & TAllProps) => TAllProps & Omit<TKnownProps, keyof UseDefaultizedTimeFieldBaseProps> & Required<Pick<TKnownProps, keyof UseDefaultizedTimeFieldBaseProps>>;
+export interface UseDefaultizedDateTimeFieldBaseProps<TDate extends PickerValidDate> extends BaseDateValidationProps<TDate>, BaseTimeValidationProps {
+    format?: string;
+}
+export declare const useDefaultizedDateTimeField: <TDate extends PickerValidDate, TKnownProps extends UseDefaultizedDateTimeFieldBaseProps<TDate> & DateTimeValidationProps<TDate> & TimeValidationProps<TDate> & {
+    ampm?: boolean | undefined;
+}, TAllProps extends {}>(props: TKnownProps & TAllProps) => TAllProps & Omit<TKnownProps, keyof UseDefaultizedDateTimeFieldBaseProps<any>> & Required<Pick<TKnownProps, keyof UseDefaultizedDateTimeFieldBaseProps<any>>>;

package/internals/hooks/defaultizedFieldProps.js

@@ -0,0 +1,43 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { applyDefaultDate } from '../utils/date-utils';
+import { useUtils, useDefaultDates } from './useUtils';
+export const useDefaultizedDateField = props => {
+  var _props$disablePast, _props$disableFuture, _props$format;
+  const utils = useUtils();
+  const defaultDates = useDefaultDates();
+  return _extends({}, props, {
+    disablePast: (_props$disablePast = props.disablePast) != null ? _props$disablePast : false,
+    disableFuture: (_props$disableFuture = props.disableFuture) != null ? _props$disableFuture : false,
+    format: (_props$format = props.format) != null ? _props$format : utils.formats.keyboardDate,
+    minDate: applyDefaultDate(utils, props.minDate, defaultDates.minDate),
+    maxDate: applyDefaultDate(utils, props.maxDate, defaultDates.maxDate)
+  });
+};
+export const useDefaultizedTimeField = props => {
+  var _props$ampm, _props$disablePast2, _props$disableFuture2, _props$format2;
+  const utils = useUtils();
+  const ampm = (_props$ampm = props.ampm) != null ? _props$ampm : utils.is12HourCycleInCurrentLocale();
+  const defaultFormat = ampm ? utils.formats.fullTime12h : utils.formats.fullTime24h;
+  return _extends({}, props, {
+    disablePast: (_props$disablePast2 = props.disablePast) != null ? _props$disablePast2 : false,
+    disableFuture: (_props$disableFuture2 = props.disableFuture) != null ? _props$disableFuture2 : false,
+    format: (_props$format2 = props.format) != null ? _props$format2 : defaultFormat
+  });
+};
+export const useDefaultizedDateTimeField = props => {
+  var _props$ampm2, _props$disablePast3, _props$disableFuture3, _props$format3, _props$minDateTime, _props$maxDateTime, _props$minDateTime2, _props$maxDateTime2;
+  const utils = useUtils();
+  const defaultDates = useDefaultDates();
+  const ampm = (_props$ampm2 = props.ampm) != null ? _props$ampm2 : utils.is12HourCycleInCurrentLocale();
+  const defaultFormat = ampm ? utils.formats.keyboardDateTime12h : utils.formats.keyboardDateTime24h;
+  return _extends({}, props, {
+    disablePast: (_props$disablePast3 = props.disablePast) != null ? _props$disablePast3 : false,
+    disableFuture: (_props$disableFuture3 = props.disableFuture) != null ? _props$disableFuture3 : false,
+    format: (_props$format3 = props.format) != null ? _props$format3 : defaultFormat,
+    disableIgnoringDatePartForTimeValidation: Boolean(props.minDateTime || props.maxDateTime),
+    minDate: applyDefaultDate(utils, (_props$minDateTime = props.minDateTime) != null ? _props$minDateTime : props.minDate, defaultDates.minDate),
+    maxDate: applyDefaultDate(utils, (_props$maxDateTime = props.maxDateTime) != null ? _props$maxDateTime : props.maxDate, defaultDates.maxDate),
+    minTime: (_props$minDateTime2 = props.minDateTime) != null ? _props$minDateTime2 : props.minTime,
+    maxTime: (_props$maxDateTime2 = props.maxDateTime) != null ? _props$maxDateTime2 : props.maxTime
+  });
+};

package/internals/hooks/useDesktopPicker/useDesktopPicker.d.ts

@@ -8,6 +8,6 @@ import { DateOrTimeViewWithMeridiem } from '../../models';
  * - DesktopDateTimePicker
  * - DesktopTimePicker
  */
-export declare const useDesktopPicker: <TDate extends PickerValidDate, TView extends DateOrTimeViewWithMeridiem, TExternalProps extends UseDesktopPickerProps<TDate, TView, any, TExternalProps>>({ props, getOpenDialogAriaText, ...pickerParams }: UseDesktopPickerParams<TDate, TView, TExternalProps>) => {
+export declare const useDesktopPicker: <TDate extends PickerValidDate, TView extends DateOrTimeViewWithMeridiem, TEnableAccessibleFieldDOMStructure extends boolean, TExternalProps extends UseDesktopPickerProps<TDate, TView, TEnableAccessibleFieldDOMStructure, any, TExternalProps>>({ props, getOpenDialogAriaText, ...pickerParams }: UseDesktopPickerParams<TDate, TView, TEnableAccessibleFieldDOMStructure, TExternalProps>) => {
     renderPicker: () => React.JSX.Element;
 };

package/internals/hooks/useDesktopPicker/useDesktopPicker.js

@@ -36,6 +36,9 @@ export const useDesktopPicker = _ref => {
     sx,
     format,
     formatDensity,
+    enableAccessibleFieldDOMStructure,
+    selectedSections,
+    onSelectedSectionsChange,
     timezone,
     name,
     label,
@@ -47,8 +50,8 @@ export const useDesktopPicker = _ref => {
     reduceAnimations
   } = props;
   const utils = useUtils();
-  const internalInputRef = React.useRef(null);
   const containerRef = React.useRef(null);
+  const fieldRef = React.useRef(null);
   const labelId = useId();
   const isToolbarHidden = (_innerSlotProps$toolb = innerSlotProps == null || (_innerSlotProps$toolb2 = innerSlotProps.toolbar) == null ? void 0 : _innerSlotProps$toolb2.hidden) != null ? _innerSlotProps$toolb : false;
   const {
@@ -61,7 +64,7 @@ export const useDesktopPicker = _ref => {
     fieldProps: pickerFieldProps
   } = usePicker(_extends({}, pickerParams, {
     props,
-    inputRef: internalInputRef,
+    fieldRef,
     autoFocusView: true,
     additionalViewProps: {},
     wrapperVariant: 'desktop'
@@ -103,12 +106,17 @@ export const useDesktopPicker = _ref => {
       sx,
       format,
       formatDensity,
+      enableAccessibleFieldDOMStructure,
+      selectedSections,
+      onSelectedSectionsChange,
       timezone,
       label,
       name,
       autoFocus: autoFocus && !props.open,
       focused: open ? true : undefined
-    }),
+    }, inputRef ? {
+      inputRef
+    } : {}),
     ownerState: props
   });
 
@@ -129,7 +137,6 @@ export const useDesktopPicker = _ref => {
     clearButton: slots.clearButton
   }, fieldProps.slots);
   const Layout = (_slots$layout = slots.layout) != null ? _slots$layout : PickersLayout;
-  const handleInputRef = useForkRef(internalInputRef, fieldProps.inputRef, inputRef);
   let labelledById = labelId;
   if (isToolbarHidden) {
     if (label) {
@@ -146,12 +153,13 @@ export const useDesktopPicker = _ref => {
       'aria-labelledby': labelledById
     }, innerSlotProps == null ? void 0 : innerSlotProps.popper)
   });
+  const handleFieldRef = useForkRef(fieldRef, fieldProps.unstableFieldRef);
   const renderPicker = () => /*#__PURE__*/_jsxs(LocalizationProvider, {
     localeText: localeText,
     children: [/*#__PURE__*/_jsx(Field, _extends({}, fieldProps, {
       slots: slotsForField,
       slotProps: slotProps,
-      inputRef: handleInputRef
+      unstableFieldRef: handleFieldRef
     })), /*#__PURE__*/_jsx(PickersPopper, _extends({
       role: "dialog",
       placement: "bottom-start",

package/internals/hooks/useDesktopPicker/useDesktopPicker.types.d.ts

@@ -1,7 +1,7 @@
 import * as React from 'react';
 import IconButton, { IconButtonProps } from '@mui/material/IconButton';
 import { InputAdornmentProps } from '@mui/material/InputAdornment';
-import TextField, { TextFieldProps } from '@mui/material/TextField';
+import TextField from '@mui/material/TextField';
 import { SlotComponentProps } from '@mui/base/utils';
 import { BaseNonStaticPickerProps, BasePickerProps, BaseNonRangeNonStaticPickerProps } from '../../models/props/basePickerProps';
 import { PickersPopperSlots, PickersPopperSlotProps } from '../../components/PickersPopper';
@@ -12,17 +12,17 @@ import { UsePickerValueNonStaticProps } from '../usePicker/usePickerValue.types'
 import { UsePickerViewsNonStaticProps, UsePickerViewsProps } from '../usePicker/usePickerViews';
 import { DateOrTimeViewWithMeridiem } from '../../models';
 import { UseClearableFieldSlots, UseClearableFieldSlotProps } from '../../../hooks/useClearableField';
+import { SlotComponentPropsFromProps } from '../../models/helpers';
 export interface UseDesktopPickerSlots<TDate extends PickerValidDate, TView extends DateOrTimeViewWithMeridiem> extends Pick<PickersPopperSlots, 'desktopPaper' | 'desktopTransition' | 'desktopTrapFocus' | 'popper'>, ExportedPickersLayoutSlots<TDate | null, TDate, TView>, UseClearableFieldSlots {
     /**
      * Component used to enter the date with the keyboard.
      */
-    field: React.ElementType<BaseSingleInputFieldProps<TDate | null, TDate, FieldSection, any>>;
+    field: React.ElementType;
     /**
      * Form control with an input to render the value inside the default field.
-     * Receives the same props as `@mui/material/TextField`.
-     * @default TextField from '@mui/material'
+     * @default TextField from '@mui/material' or PickersTextField if `enableAccessibleFieldDOMStructure` is `true`.
      */
-    textField?: React.ElementType<TextFieldProps>;
+    textField?: React.ElementType;
     /**
      * Component displayed on the start or end input adornment used to open the picker on desktop.
      * @default InputAdornment
@@ -38,22 +38,23 @@ export interface UseDesktopPickerSlots<TDate extends PickerValidDate, TView exte
      */
     openPickerIcon: React.ElementType;
 }
-export interface UseDesktopPickerSlotProps<TDate extends PickerValidDate, TView extends DateOrTimeViewWithMeridiem> extends ExportedUseDesktopPickerSlotProps<TDate, TView>, Pick<PickersLayoutSlotProps<TDate | null, TDate, TView>, 'toolbar'> {
+export interface UseDesktopPickerSlotProps<TDate extends PickerValidDate, TView extends DateOrTimeViewWithMeridiem, TEnableAccessibleFieldDOMStructure extends boolean> extends ExportedUseDesktopPickerSlotProps<TDate, TView, TEnableAccessibleFieldDOMStructure>, Pick<PickersLayoutSlotProps<TDate | null, TDate, TView>, 'toolbar'> {
 }
-export interface ExportedUseDesktopPickerSlotProps<TDate extends PickerValidDate, TView extends DateOrTimeViewWithMeridiem> extends PickersPopperSlotProps, ExportedPickersLayoutSlotProps<TDate | null, TDate, TView>, UseClearableFieldSlotProps {
-    field?: SlotComponentProps<React.ElementType<BaseSingleInputFieldProps<TDate | null, TDate, FieldSection, unknown>>, {}, UsePickerProps<TDate | null, TDate, any, FieldSection, any, any, any>>;
+export interface ExportedUseDesktopPickerSlotProps<TDate extends PickerValidDate, TView extends DateOrTimeViewWithMeridiem, TEnableAccessibleFieldDOMStructure extends boolean> extends PickersPopperSlotProps, ExportedPickersLayoutSlotProps<TDate | null, TDate, TView>, UseClearableFieldSlotProps {
+    field?: SlotComponentPropsFromProps<BaseSingleInputFieldProps<TDate | null, TDate, FieldSection, TEnableAccessibleFieldDOMStructure, unknown>, {}, UsePickerProps<TDate | null, TDate, any, any, any, any>>;
     textField?: SlotComponentProps<typeof TextField, {}, Record<string, any>>;
     inputAdornment?: Partial<InputAdornmentProps>;
-    openPickerButton?: SlotComponentProps<typeof IconButton, {}, UseDesktopPickerProps<TDate, any, any, any>>;
+    openPickerButton?: SlotComponentProps<typeof IconButton, {}, UseDesktopPickerProps<TDate, any, TEnableAccessibleFieldDOMStructure, any, any>>;
     openPickerIcon?: Record<string, any>;
 }
-export interface DesktopOnlyPickerProps<TDate extends PickerValidDate> extends BaseNonStaticPickerProps, BaseNonRangeNonStaticPickerProps, UsePickerValueNonStaticProps<TDate | null, FieldSection>, UsePickerViewsNonStaticProps {
+export interface DesktopOnlyPickerProps extends BaseNonStaticPickerProps, BaseNonRangeNonStaticPickerProps, UsePickerValueNonStaticProps, UsePickerViewsNonStaticProps {
     /**
      * If `true`, the `input` element is focused during the first mount.
+     * @default false
      */
     autoFocus?: boolean;
 }
-export interface UseDesktopPickerProps<TDate extends PickerValidDate, TView extends DateOrTimeViewWithMeridiem, TError, TExternalProps extends UsePickerViewsProps<any, any, TView, any, any>> extends BasePickerProps<TDate | null, TDate, TView, TError, TExternalProps, {}>, DesktopOnlyPickerProps<TDate> {
+export interface UseDesktopPickerProps<TDate extends PickerValidDate, TView extends DateOrTimeViewWithMeridiem, TEnableAccessibleFieldDOMStructure extends boolean, TError, TExternalProps extends UsePickerViewsProps<any, any, TView, any, any>> extends BasePickerProps<TDate | null, TDate, TView, TError, TExternalProps, {}>, DesktopOnlyPickerProps {
     /**
      * Overridable component slots.
      * @default {}
@@ -63,9 +64,9 @@ export interface UseDesktopPickerProps<TDate extends PickerValidDate, TView exte
      * The props used for each component slot.
      * @default {}
      */
-    slotProps?: UseDesktopPickerSlotProps<TDate, TView>;
+    slotProps?: UseDesktopPickerSlotProps<TDate, TView, TEnableAccessibleFieldDOMStructure>;
 }
-export interface UseDesktopPickerParams<TDate extends PickerValidDate, TView extends DateOrTimeViewWithMeridiem, TExternalProps extends UseDesktopPickerProps<TDate, TView, any, TExternalProps>> extends Pick<UsePickerParams<TDate | null, TDate, TView, FieldSection, TExternalProps, {}>, 'valueManager' | 'valueType' | 'validator'> {
+export interface UseDesktopPickerParams<TDate extends PickerValidDate, TView extends DateOrTimeViewWithMeridiem, TEnableAccessibleFieldDOMStructure extends boolean, TExternalProps extends UseDesktopPickerProps<TDate, TView, TEnableAccessibleFieldDOMStructure, any, TExternalProps>> extends Pick<UsePickerParams<TDate | null, TDate, TView, FieldSection, TExternalProps, {}>, 'valueManager' | 'valueType' | 'validator'> {
     props: TExternalProps;
     getOpenDialogAriaText: (date: TDate | null, utils: MuiPickersAdapter<TDate>) => string;
 }

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

@@ -0,0 +1,16 @@
+import { FieldSection, MuiPickersAdapter, PickersTimezone, PickerValidDate } from '../../../models';
+import { PickersLocaleText } from '../../../locales';
+interface BuildSectionsFromFormatParams<TDate extends PickerValidDate> {
+    utils: MuiPickersAdapter<TDate>;
+    format: string;
+    formatDensity: 'dense' | 'spacious';
+    isRTL: boolean;
+    timezone: PickersTimezone;
+    shouldRespectLeadingZeros: boolean;
+    localeText: PickersLocaleText<TDate>;
+    localizedDigits: string[];
+    date: TDate | null;
+    enableAccessibleFieldDOMStructure: boolean;
+}
+export declare const buildSectionsFromFormat: <TDate extends PickerValidDate>(params: BuildSectionsFromFormatParams<TDate>) => FieldSection[];
+export {};

package/internals/hooks/useField/buildSectionsFromFormat.js

@@ -0,0 +1,251 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { applyLocalizedDigits, cleanLeadingZeros, doesSectionFormatHaveLeadingZeros, getDateSectionConfigFromFormatToken, removeLocalizedDigits } from './useField.utils';
+const expandFormat = ({
+  utils,
+  format
+}) => {
+  // Expand the provided format
+  let formatExpansionOverflow = 10;
+  let prevFormat = format;
+  let nextFormat = utils.expandFormat(format);
+  while (nextFormat !== prevFormat) {
+    prevFormat = nextFormat;
+    nextFormat = utils.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 picker component.');
+    }
+  }
+  return nextFormat;
+};
+const getEscapedPartsFromFormat = ({
+  utils,
+  expandedFormat
+}) => {
+  const escapedParts = [];
+  const {
+    start: startChar,
+    end: endChar
+  } = utils.escapedCharacters;
+  const regExp = new RegExp(`(\\${startChar}[^\\${endChar}]*\\${endChar})+`, 'g');
+  let match = null;
+  // eslint-disable-next-line no-cond-assign
+  while (match = regExp.exec(expandedFormat)) {
+    escapedParts.push({
+      start: match.index,
+      end: regExp.lastIndex - 1
+    });
+  }
+  return escapedParts;
+};
+const getSectionPlaceholder = (utils, timezone, localeText, sectionConfig, sectionFormat) => {
+  switch (sectionConfig.type) {
+    case 'year':
+      {
+        return localeText.fieldYearPlaceholder({
+          digitAmount: utils.formatByString(utils.date(undefined, timezone), sectionFormat).length,
+          format: sectionFormat
+        });
+      }
+    case 'month':
+      {
+        return localeText.fieldMonthPlaceholder({
+          contentType: sectionConfig.contentType,
+          format: sectionFormat
+        });
+      }
+    case 'day':
+      {
+        return localeText.fieldDayPlaceholder({
+          format: sectionFormat
+        });
+      }
+    case 'weekDay':
+      {
+        return localeText.fieldWeekDayPlaceholder({
+          contentType: sectionConfig.contentType,
+          format: sectionFormat
+        });
+      }
+    case 'hours':
+      {
+        return localeText.fieldHoursPlaceholder({
+          format: sectionFormat
+        });
+      }
+    case 'minutes':
+      {
+        return localeText.fieldMinutesPlaceholder({
+          format: sectionFormat
+        });
+      }
+    case 'seconds':
+      {
+        return localeText.fieldSecondsPlaceholder({
+          format: sectionFormat
+        });
+      }
+    case 'meridiem':
+      {
+        return localeText.fieldMeridiemPlaceholder({
+          format: sectionFormat
+        });
+      }
+    default:
+      {
+        return sectionFormat;
+      }
+  }
+};
+const createSection = ({
+  utils,
+  timezone,
+  date,
+  shouldRespectLeadingZeros,
+  localeText,
+  localizedDigits,
+  now,
+  token,
+  startSeparator
+}) => {
+  if (token === '') {
+    throw new Error('MUI X: Should not call `commitToken` with an empty token');
+  }
+  const sectionConfig = getDateSectionConfigFromFormatToken(utils, token);
+  const hasLeadingZerosInFormat = doesSectionFormatHaveLeadingZeros(utils, timezone, sectionConfig.contentType, sectionConfig.type, token);
+  const hasLeadingZerosInInput = shouldRespectLeadingZeros ? hasLeadingZerosInFormat : sectionConfig.contentType === 'digit';
+  const isValidDate = date != null && utils.isValid(date);
+  let sectionValue = isValidDate ? utils.formatByString(date, token) : '';
+  let maxLength = null;
+  if (hasLeadingZerosInInput) {
+    if (hasLeadingZerosInFormat) {
+      maxLength = sectionValue === '' ? utils.formatByString(now, token).length : sectionValue.length;
+    } else {
+      if (sectionConfig.maxLength == null) {
+        throw new Error(`MUI X: The token ${token} should have a 'maxDigitNumber' property on it's adapter`);
+      }
+      maxLength = sectionConfig.maxLength;
+      if (isValidDate) {
+        sectionValue = applyLocalizedDigits(cleanLeadingZeros(removeLocalizedDigits(sectionValue, localizedDigits), maxLength), localizedDigits);
+      }
+    }
+  }
+  return _extends({}, sectionConfig, {
+    format: token,
+    maxLength,
+    value: sectionValue,
+    placeholder: getSectionPlaceholder(utils, timezone, localeText, sectionConfig, token),
+    hasLeadingZerosInFormat,
+    hasLeadingZerosInInput,
+    startSeparator,
+    endSeparator: '',
+    modified: false
+  });
+};
+const buildSections = params => {
+  const {
+    utils,
+    expandedFormat,
+    escapedParts
+  } = params;
+  const now = utils.date(undefined);
+  const sections = [];
+  let startSeparator = '';
+
+  // This RegExp test if the beginning of a string corresponds to a supported token
+  const isTokenStartRegExp = new RegExp(`^(${Object.keys(utils.formatTokenMap).sort((a, b) => b.length - a.length) // Sort to put longest word first
+  .join('|')})`, 'g') // used to get access to lastIndex state
+  ;
+  let currentTokenValue = '';
+  for (let i = 0; i < expandedFormat.length; i += 1) {
+    const escapedPartOfCurrentChar = escapedParts.find(escapeIndex => escapeIndex.start <= i && escapeIndex.end >= i);
+    const char = expandedFormat[i];
+    const isEscapedChar = escapedPartOfCurrentChar != null;
+    const potentialToken = `${currentTokenValue}${expandedFormat.slice(i)}`;
+    const regExpMatch = isTokenStartRegExp.test(potentialToken);
+    if (!isEscapedChar && char.match(/([A-Za-z]+)/) && regExpMatch) {
+      currentTokenValue = potentialToken.slice(0, isTokenStartRegExp.lastIndex);
+      i += isTokenStartRegExp.lastIndex - 1;
+    } else {
+      // If we are on the opening or closing character of an escaped part of the format,
+      // Then we ignore this character.
+      const isEscapeBoundary = isEscapedChar && (escapedPartOfCurrentChar == null ? void 0 : escapedPartOfCurrentChar.start) === i || (escapedPartOfCurrentChar == null ? void 0 : escapedPartOfCurrentChar.end) === i;
+      if (!isEscapeBoundary) {
+        if (currentTokenValue !== '') {
+          sections.push(createSection(_extends({}, params, {
+            now,
+            token: currentTokenValue,
+            startSeparator
+          })));
+          currentTokenValue = '';
+        }
+        if (sections.length === 0) {
+          startSeparator += char;
+        } else {
+          startSeparator = '';
+          sections[sections.length - 1].endSeparator += char;
+        }
+      }
+    }
+  }
+  if (currentTokenValue !== '') {
+    sections.push(createSection(_extends({}, params, {
+      now,
+      token: currentTokenValue,
+      startSeparator
+    })));
+  }
+  if (sections.length === 0 && startSeparator.length > 0) {
+    sections.push({
+      type: 'empty',
+      contentType: 'letter',
+      maxLength: null,
+      format: '',
+      value: '',
+      placeholder: '',
+      hasLeadingZerosInFormat: false,
+      hasLeadingZerosInInput: false,
+      startSeparator,
+      endSeparator: '',
+      modified: false
+    });
+  }
+  return sections;
+};
+const postProcessSections = ({
+  isRTL,
+  formatDensity,
+  sections
+}) => {
+  return sections.map(section => {
+    const cleanSeparator = separator => {
+      let cleanedSeparator = separator;
+      if (isRTL && cleanedSeparator !== null && cleanedSeparator.includes(' ')) {
+        cleanedSeparator = `\u2069${cleanedSeparator}\u2066`;
+      }
+      if (formatDensity === 'spacious' && ['/', '.', '-'].includes(cleanedSeparator)) {
+        cleanedSeparator = ` ${cleanedSeparator} `;
+      }
+      return cleanedSeparator;
+    };
+    section.startSeparator = cleanSeparator(section.startSeparator);
+    section.endSeparator = cleanSeparator(section.endSeparator);
+    return section;
+  });
+};
+export const buildSectionsFromFormat = params => {
+  let expandedFormat = expandFormat(params);
+  if (params.isRTL && params.enableAccessibleFieldDOMStructure) {
+    expandedFormat = expandedFormat.split(' ').reverse().join(' ');
+  }
+  const escapedParts = getEscapedPartsFromFormat(_extends({}, params, {
+    expandedFormat
+  }));
+  const sections = buildSections(_extends({}, params, {
+    expandedFormat,
+    escapedParts
+  }));
+  return postProcessSections(_extends({}, params, {
+    sections
+  }));
+};

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

@@ -1,3 +1,3 @@
 export { useField } from './useField';
-export type { FieldValueManager, UseFieldInternalProps, UseFieldForwardedProps, UseFieldParams, UseFieldResponse, FieldChangeHandler, FieldChangeHandlerContext, FieldRef, } from './useField.types';
-export { splitFormatIntoSections, addPositionPropertiesToSections, createDateStrForInputFromSections, } from './useField.utils';
+export type { FieldValueManager, UseFieldInternalProps, UseFieldParams, UseFieldResponse, FieldChangeHandler, FieldChangeHandlerContext, } from './useField.types';
+export { createDateStrForV7HiddenInputFromSections, createDateStrForV6InputFromSections, } from './useField.utils';

package/internals/hooks/useField/index.js

@@ -1,2 +1,2 @@
 export { useField } from './useField';
-export { splitFormatIntoSections, addPositionPropertiesToSections, createDateStrForInputFromSections } from './useField.utils';
+export { createDateStrForV7HiddenInputFromSections, createDateStrForV6InputFromSections } from './useField.utils';

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

@@ -1,5 +1,5 @@
-import { UseFieldParams, UseFieldResponse, UseFieldForwardedProps, UseFieldInternalProps } from './useField.types';
-import { FieldSection, PickerValidDate } from '../../../models';
-export declare const useField: <TValue, TDate extends PickerValidDate, TSection extends FieldSection, TForwardedProps extends UseFieldForwardedProps, TInternalProps extends UseFieldInternalProps<any, any, any, any> & {
+import { UseFieldParams, UseFieldResponse, UseFieldCommonForwardedProps, UseFieldInternalProps } from './useField.types';
+import { PickerValidDate, FieldSection } from '../../../models';
+export declare const useField: <TValue, TDate extends PickerValidDate, TSection extends FieldSection, TEnableAccessibleFieldDOMStructure extends boolean, TForwardedProps extends UseFieldCommonForwardedProps & (TEnableAccessibleFieldDOMStructure extends false ? import("./useField.types").UseFieldV6ForwardedProps : import("./useField.types").UseFieldV7ForwardedProps), TInternalProps extends UseFieldInternalProps<any, any, any, TEnableAccessibleFieldDOMStructure, any> & {
     minutesStep?: number | undefined;
-}>(params: UseFieldParams<TValue, TDate, TSection, TForwardedProps, TInternalProps>) => UseFieldResponse<TForwardedProps>;
+}>(params: UseFieldParams<TValue, TDate, TSection, TEnableAccessibleFieldDOMStructure, TForwardedProps, TInternalProps>) => UseFieldResponse<TEnableAccessibleFieldDOMStructure, TForwardedProps>;