@mui/x-date-pickers 8.0.0-beta.0 → 8.0.0-beta.1

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

@@ -0,0 +1,204 @@
+import useEventCallback from '@mui/utils/useEventCallback';
+import { useUtils } from "../useUtils.js";
+import { cleanDigitSectionValue, getLetterEditingOptions, removeLocalizedDigits } from "./useField.utils.js";
+
+/**
+ * Returns the `onKeyDown` handler to pass to the root element of the field.
+ */
+export function useFieldRootHandleKeyDown(parameters) {
+  const utils = useUtils();
+  const {
+    manager: {
+      internal_fieldValueManager: fieldValueManager
+    },
+    internalPropsWithDefaults: {
+      minutesStep,
+      disabled,
+      readOnly
+    },
+    stateResponse: {
+      // States and derived states
+      state,
+      value,
+      activeSectionIndex,
+      parsedSelectedSections,
+      sectionsValueBoundaries,
+      localizedDigits,
+      timezone,
+      sectionOrder,
+      // Methods to update the states
+      clearValue,
+      clearActiveSection,
+      setSelectedSections,
+      updateSectionValue
+    }
+  } = parameters;
+  return useEventCallback(event => {
+    if (disabled) {
+      return;
+    }
+    // eslint-disable-next-line default-case
+    switch (true) {
+      // Select all
+      case (event.ctrlKey || event.metaKey) && String.fromCharCode(event.keyCode) === 'A' && !event.shiftKey && !event.altKey:
+        {
+          // prevent default to make sure that the next line "select all" while updating
+          // the internal state at the same time.
+          event.preventDefault();
+          setSelectedSections('all');
+          break;
+        }
+
+      // Move selection to next section
+      case event.key === 'ArrowRight':
+        {
+          event.preventDefault();
+          if (parsedSelectedSections == null) {
+            setSelectedSections(sectionOrder.startIndex);
+          } else if (parsedSelectedSections === 'all') {
+            setSelectedSections(sectionOrder.endIndex);
+          } else {
+            const nextSectionIndex = sectionOrder.neighbors[parsedSelectedSections].rightIndex;
+            if (nextSectionIndex !== null) {
+              setSelectedSections(nextSectionIndex);
+            }
+          }
+          break;
+        }
+
+      // Move selection to previous section
+      case event.key === 'ArrowLeft':
+        {
+          event.preventDefault();
+          if (parsedSelectedSections == null) {
+            setSelectedSections(sectionOrder.endIndex);
+          } else if (parsedSelectedSections === 'all') {
+            setSelectedSections(sectionOrder.startIndex);
+          } else {
+            const nextSectionIndex = sectionOrder.neighbors[parsedSelectedSections].leftIndex;
+            if (nextSectionIndex !== null) {
+              setSelectedSections(nextSectionIndex);
+            }
+          }
+          break;
+        }
+
+      // Reset the value of the selected section
+      case event.key === 'Delete':
+        {
+          event.preventDefault();
+          if (readOnly) {
+            break;
+          }
+          if (parsedSelectedSections == null || parsedSelectedSections === 'all') {
+            clearValue();
+          } else {
+            clearActiveSection();
+          }
+          break;
+        }
+
+      // Increment / decrement the selected section value
+      case ['ArrowUp', 'ArrowDown', 'Home', 'End', 'PageUp', 'PageDown'].includes(event.key):
+        {
+          event.preventDefault();
+          if (readOnly || activeSectionIndex == null) {
+            break;
+          }
+
+          // if all sections are selected, mark the currently editing one as selected
+          if (parsedSelectedSections === 'all') {
+            setSelectedSections(activeSectionIndex);
+          }
+          const activeSection = state.sections[activeSectionIndex];
+          const newSectionValue = adjustSectionValue(utils, timezone, activeSection, event.key, sectionsValueBoundaries, localizedDigits, fieldValueManager.getDateFromSection(value, activeSection), {
+            minutesStep
+          });
+          updateSectionValue({
+            section: activeSection,
+            newSectionValue,
+            shouldGoToNextSection: false
+          });
+          break;
+        }
+    }
+  });
+}
+function getDeltaFromKeyCode(keyCode) {
+  switch (keyCode) {
+    case 'ArrowUp':
+      return 1;
+    case 'ArrowDown':
+      return -1;
+    case 'PageUp':
+      return 5;
+    case 'PageDown':
+      return -5;
+    default:
+      return 0;
+  }
+}
+function adjustSectionValue(utils, timezone, section, keyCode, sectionsValueBoundaries, localizedDigits, activeDate, stepsAttributes) {
+  const delta = getDeltaFromKeyCode(keyCode);
+  const isStart = keyCode === 'Home';
+  const isEnd = keyCode === 'End';
+  const shouldSetAbsolute = section.value === '' || isStart || isEnd;
+  const adjustDigitSection = () => {
+    const sectionBoundaries = sectionsValueBoundaries[section.type]({
+      currentDate: activeDate,
+      format: section.format,
+      contentType: section.contentType
+    });
+    const getCleanValue = value => cleanDigitSectionValue(utils, value, sectionBoundaries, localizedDigits, section);
+    const step = section.type === 'minutes' && stepsAttributes?.minutesStep ? stepsAttributes.minutesStep : 1;
+    let newSectionValueNumber;
+    if (shouldSetAbsolute) {
+      if (section.type === 'year' && !isEnd && !isStart) {
+        return utils.formatByString(utils.date(undefined, timezone), section.format);
+      }
+      if (delta > 0 || isStart) {
+        newSectionValueNumber = sectionBoundaries.minimum;
+      } else {
+        newSectionValueNumber = sectionBoundaries.maximum;
+      }
+    } else {
+      const currentSectionValue = parseInt(removeLocalizedDigits(section.value, localizedDigits), 10);
+      newSectionValueNumber = currentSectionValue + delta * step;
+    }
+    if (newSectionValueNumber % step !== 0) {
+      if (delta < 0 || isStart) {
+        newSectionValueNumber += step - (step + newSectionValueNumber) % step; // for JS -3 % 5 = -3 (should be 2)
+      }
+      if (delta > 0 || isEnd) {
+        newSectionValueNumber -= newSectionValueNumber % step;
+      }
+    }
+    if (newSectionValueNumber > sectionBoundaries.maximum) {
+      return getCleanValue(sectionBoundaries.minimum + (newSectionValueNumber - sectionBoundaries.maximum - 1) % (sectionBoundaries.maximum - sectionBoundaries.minimum + 1));
+    }
+    if (newSectionValueNumber < sectionBoundaries.minimum) {
+      return getCleanValue(sectionBoundaries.maximum - (sectionBoundaries.minimum - newSectionValueNumber - 1) % (sectionBoundaries.maximum - sectionBoundaries.minimum + 1));
+    }
+    return getCleanValue(newSectionValueNumber);
+  };
+  const adjustLetterSection = () => {
+    const options = getLetterEditingOptions(utils, timezone, section.type, section.format);
+    if (options.length === 0) {
+      return section.value;
+    }
+    if (shouldSetAbsolute) {
+      if (delta > 0 || isStart) {
+        return options[0];
+      }
+      return options[options.length - 1];
+    }
+    const currentOptionIndex = options.indexOf(section.value);
+    const newOptionIndex = (currentOptionIndex + delta) % options.length;
+    const clampedIndex = (newOptionIndex + options.length) % options.length;
+    return options[clampedIndex];
+  };
+  if (section.contentType === 'digit' || section.contentType === 'digit-with-letter') {
+    return adjustDigitSection();
+  }
+  return adjustLetterSection();
+}

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

@@ -1,7 +1,13 @@
-import { UseFieldInternalProps, UseFieldParams, UseFieldState, FieldParsedSelectedSections, FieldSectionsValueBoundaries, UseFieldForwardedProps } from "./useField.types.js";
-import { FieldSelectedSections, PickersTimezone, InferFieldSection } from "../../../models/index.js";
+import { UseFieldInternalProps, UseFieldState, FieldParsedSelectedSections, FieldSectionsValueBoundaries, SectionOrdering, UseFieldForwardedProps, CharacterEditingQuery } from "./useField.types.js";
+import { FieldSelectedSections, PickersTimezone, InferFieldSection, PickerManager } from "../../../models/index.js";
 import { PickerValidValue } from "../../models/index.js";
-export interface UpdateSectionValueParams<TValue extends PickerValidValue> {
+export declare const useFieldState: <TValue extends PickerValidValue, TEnableAccessibleFieldDOMStructure extends boolean, TError, TValidationProps extends {}, TForwardedProps extends UseFieldForwardedProps<TEnableAccessibleFieldDOMStructure>>(parameters: UseFieldStateParameters<TValue, TEnableAccessibleFieldDOMStructure, TError, TValidationProps, TForwardedProps>) => UseFieldStateReturnValue<TValue>;
+interface UseFieldStateParameters<TValue extends PickerValidValue, TEnableAccessibleFieldDOMStructure extends boolean, TError, TValidationProps extends {}, TForwardedProps extends UseFieldForwardedProps<TEnableAccessibleFieldDOMStructure>> {
+  manager: PickerManager<TValue, TEnableAccessibleFieldDOMStructure, TError, TValidationProps, any>;
+  internalPropsWithDefaults: UseFieldInternalProps<TValue, TEnableAccessibleFieldDOMStructure, TError> & TValidationProps;
+  forwardedProps: TForwardedProps;
+}
+export interface UpdateSectionValueParameters<TValue extends PickerValidValue> {
   /**
    * The section on which we want to apply the new value.
    */
@@ -15,20 +21,24 @@ export interface UpdateSectionValueParams<TValue extends PickerValidValue> {
    */
   shouldGoToNextSection: boolean;
 }
-export interface UseFieldStateResponse<TValue extends PickerValidValue> {
-  state: UseFieldState<TValue>;
-  value: TValue;
+export interface UseFieldStateReturnValue<TValue extends PickerValidValue> {
   activeSectionIndex: number | null;
+  areAllSectionsEmpty: boolean;
+  error: boolean;
+  localizedDigits: string[];
   parsedSelectedSections: FieldParsedSelectedSections;
-  setSelectedSections: (sections: FieldSelectedSections) => void;
+  sectionOrder: SectionOrdering;
+  sectionsValueBoundaries: FieldSectionsValueBoundaries;
+  state: UseFieldState<TValue>;
+  timezone: PickersTimezone;
+  value: TValue;
   clearValue: () => void;
   clearActiveSection: () => void;
-  updateSectionValue: (params: UpdateSectionValueParams<TValue>) => void;
-  updateValueFromValueStr: (valueStr: string) => void;
+  setCharacterQuery: (characterQuery: CharacterEditingQuery | null) => void;
+  setSelectedSections: (sections: FieldSelectedSections) => void;
   setTempAndroidValueStr: (tempAndroidValueStr: string | null) => void;
-  sectionsValueBoundaries: FieldSectionsValueBoundaries;
+  updateSectionValue: (parameters: UpdateSectionValueParameters<TValue>) => void;
+  updateValueFromValueStr: (valueStr: string) => void;
   getSectionsFromValue: (value: TValue, fallbackSections?: InferFieldSection<TValue>[] | null) => InferFieldSection<TValue>[];
-  localizedDigits: string[];
-  timezone: PickersTimezone;
 }
-export declare const useFieldState: <TValue extends PickerValidValue, TEnableAccessibleFieldDOMStructure extends boolean, TForwardedProps extends UseFieldForwardedProps<TEnableAccessibleFieldDOMStructure>, TInternalProps extends UseFieldInternalProps<TValue, TEnableAccessibleFieldDOMStructure, any>>(params: UseFieldParams<TValue, TEnableAccessibleFieldDOMStructure, TForwardedProps, TInternalProps>) => UseFieldStateResponse<TValue>;
+export {};

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

@@ -2,25 +2,30 @@ import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 import useControlled from '@mui/utils/useControlled';
 import useTimeout from '@mui/utils/useTimeout';
+import useEventCallback from '@mui/utils/useEventCallback';
 import { useRtl } from '@mui/system/RtlProvider';
 import { usePickerTranslations } from "../../../hooks/usePickerTranslations.js";
 import { useUtils, useLocalizationContext } from "../useUtils.js";
-import { mergeDateIntoReferenceDate, getSectionsBoundaries, validateSections, getDateFromDateSections, parseSelectedSections, getLocalizedDigits } from "./useField.utils.js";
+import { mergeDateIntoReferenceDate, getSectionsBoundaries, validateSections, getDateFromDateSections, parseSelectedSections, getLocalizedDigits, getSectionOrder } from "./useField.utils.js";
 import { buildSectionsFromFormat } from "./buildSectionsFromFormat.js";
+import { useValidation } from "../../../validation/index.js";
 import { useControlledValue } from "../useControlledValue.js";
 import { getSectionTypeGranularity } from "../../utils/getDefaultReferenceDate.js";
-export const useFieldState = params => {
+const QUERY_LIFE_DURATION_MS = 5000;
+export const useFieldState = parameters => {
   const utils = useUtils();
   const translations = usePickerTranslations();
   const adapter = useLocalizationContext();
   const isRtl = useRtl();
   const {
-    valueManager,
-    fieldValueManager,
-    valueType,
-    validator,
-    internalProps,
-    internalProps: {
+    manager: {
+      validator,
+      valueType,
+      internal_valueManager: valueManager,
+      internal_fieldValueManager: fieldValueManager
+    },
+    internalPropsWithDefaults,
+    internalPropsWithDefaults: {
       value: valueProp,
       defaultValue,
       referenceDate: referenceDateProp,
@@ -32,8 +37,11 @@ export const useFieldState = params => {
       shouldRespectLeadingZeros = false,
       timezone: timezoneProp,
       enableAccessibleFieldDOMStructure = true
+    },
+    forwardedProps: {
+      error: errorProp
     }
-  } = params;
+  } = parameters;
   const {
     value,
     handleValueChange,
@@ -51,6 +59,23 @@ export const useFieldState = params => {
   React.useEffect(() => {
     valueRef.current = value;
   }, [value]);
+  const {
+    hasValidationError
+  } = useValidation({
+    props: internalPropsWithDefaults,
+    validator,
+    timezone,
+    value,
+    onError: internalPropsWithDefaults.onError
+  });
+  const error = React.useMemo(() => {
+    // only override when `error` is undefined.
+    // in case of multi input fields, the `error` value is provided externally and will always be defined.
+    if (errorProp !== undefined) {
+      return errorProp;
+    }
+    return hasValidationError;
+  }, [hasValidationError, errorProp]);
   const localizedDigits = React.useMemo(() => getLocalizedDigits(utils), [utils]);
   const sectionsValueBoundaries = React.useMemo(() => getSectionsBoundaries(utils, localizedDigits, timezone), [utils, localizedDigits, timezone]);
   const getSectionsFromValue = React.useCallback(valueToAnalyze => fieldValueManager.getSectionsFromValue(valueToAnalyze, date => buildSectionsFromFormat({
@@ -75,14 +100,15 @@ export const useFieldState = params => {
         isRtl,
         locale: utils.locale
       },
-      tempValueStrAndroid: null
+      tempValueStrAndroid: null,
+      characterQuery: null
     };
     const granularity = getSectionTypeGranularity(sections);
     const referenceValue = valueManager.getInitialReferenceValue({
       referenceDate: referenceDateProp,
       value,
       utils,
-      props: internalProps,
+      props: internalPropsWithDefaults,
       granularity,
       timezone
     });
@@ -102,13 +128,15 @@ export const useFieldState = params => {
   };
   const parsedSelectedSections = React.useMemo(() => parseSelectedSections(selectedSections, state.sections), [selectedSections, state.sections]);
   const activeSectionIndex = parsedSelectedSections === 'all' ? 0 : parsedSelectedSections;
+  const sectionOrder = React.useMemo(() => getSectionOrder(state.sections, isRtl && !enableAccessibleFieldDOMStructure), [state.sections, isRtl, enableAccessibleFieldDOMStructure]);
+  const areAllSectionsEmpty = React.useMemo(() => state.sections.every(section => section.value === ''), [state.sections]);
   const publishValue = newValue => {
     const context = {
       validationError: validator({
         adapter,
         value: newValue,
         timezone,
-        props: internalProps
+        props: internalPropsWithDefaults
       })
     };
     handleValueChange(newValue, context);
@@ -122,7 +150,7 @@ export const useFieldState = params => {
     return newSections;
   };
   const sectionToUpdateOnNextInvalidDateRef = React.useRef(null);
-  const timeoutToUpdateSectionValueOnNextInvalidDate = useTimeout();
+  const updateSectionValueOnNextInvalidDateTimeout = useTimeout();
   const setSectionUpdateToApplyOnNextInvalidDate = newSectionValue => {
     if (activeSectionIndex == null) {
       return;
@@ -131,7 +159,7 @@ export const useFieldState = params => {
       sectionIndex: activeSectionIndex,
       value: newSectionValue
     };
-    timeoutToUpdateSectionValueOnNextInvalidDate.start(0, () => {
+    updateSectionValueOnNextInvalidDateTimeout.start(0, () => {
       sectionToUpdateOnNextInvalidDateRef.current = null;
     });
   };
@@ -141,9 +169,13 @@ export const useFieldState = params => {
         sections: prevState.sections.map(section => _extends({}, section, {
           value: ''
         })),
-        tempValueStrAndroid: null
+        tempValueStrAndroid: null,
+        characterQuery: null
       }));
     } else {
+      setState(prevState => _extends({}, prevState, {
+        characterQuery: null
+      }));
       publishValue(valueManager.emptyValue);
     }
   };
@@ -159,9 +191,13 @@ export const useFieldState = params => {
     if (fieldValueManager.getDateFromSection(value, activeSection) === null) {
       setState(prevState => _extends({}, prevState, {
         sections: setSectionValue(activeSectionIndex, ''),
-        tempValueStrAndroid: null
+        tempValueStrAndroid: null,
+        characterQuery: null
       }));
     } else {
+      setState(prevState => _extends({}, prevState, {
+        characterQuery: null
+      }));
       publishValue(fieldValueManager.updateDateInValue(value, activeSection, null));
     }
   };
@@ -187,14 +223,14 @@ export const useFieldState = params => {
     const newValue = fieldValueManager.parseValueStr(valueStr, state.referenceValue, parseDateStr);
     publishValue(newValue);
   };
-  const timeoutToCleanActiveDateSectionsIfValueNull = useTimeout();
+  const cleanActiveDateSectionsIfValueNullTimeout = useTimeout();
   const updateSectionValue = ({
     section,
     newSectionValue,
     shouldGoToNextSection
   }) => {
-    timeoutToUpdateSectionValueOnNextInvalidDate.clear();
-    timeoutToCleanActiveDateSectionsIfValueNull.clear();
+    updateSectionValueOnNextInvalidDateTimeout.clear();
+    cleanActiveDateSectionsIfValueNullTimeout.clear();
     const activeDate = fieldValueManager.getDateFromSection(value, section);
 
     /**
@@ -219,7 +255,7 @@ export const useFieldState = params => {
     if (utils.isValid(newActiveDate)) {
       const mergedDate = mergeDateIntoReferenceDate(utils, newActiveDate, newActiveDateSections, fieldValueManager.getDateFromSection(state.referenceValue, section), true);
       if (activeDate == null) {
-        timeoutToCleanActiveDateSectionsIfValueNull.start(0, () => {
+        cleanActiveDateSectionsIfValueNullTimeout.start(0, () => {
           if (valueRef.current === value) {
             setState(prevState => _extends({}, prevState, {
               sections: fieldValueManager.clearDateSections(state.sections, section),
@@ -258,9 +294,14 @@ export const useFieldState = params => {
       tempValueStrAndroid: null
     }));
   };
-  const setTempAndroidValueStr = tempValueStrAndroid => setState(prev => _extends({}, prev, {
+  const setTempAndroidValueStr = tempValueStrAndroid => setState(prevState => _extends({}, prevState, {
     tempValueStrAndroid
   }));
+  const setCharacterQuery = useEventCallback(newCharacterQuery => {
+    setState(prevState => _extends({}, prevState, {
+      characterQuery: newCharacterQuery
+    }));
+  });
 
   // If `prop.value` changes, we update the state to reflect the new value
   if (value !== state.lastExternalValue) {
@@ -292,28 +333,60 @@ export const useFieldState = params => {
         locale: utils.locale
       },
       sections,
-      tempValueStrAndroid: null
+      tempValueStrAndroid: null,
+      characterQuery: null
     }));
   }
+  if (state.characterQuery != null && !error && activeSectionIndex == null) {
+    setCharacterQuery(null);
+  }
+  if (state.characterQuery != null && state.sections[state.characterQuery.sectionIndex]?.type !== state.characterQuery.sectionType) {
+    setCharacterQuery(null);
+  }
   React.useEffect(() => {
     if (sectionToUpdateOnNextInvalidDateRef.current != null) {
       sectionToUpdateOnNextInvalidDateRef.current = null;
     }
   });
+  const cleanCharacterQueryTimeout = useTimeout();
+  React.useEffect(() => {
+    if (state.characterQuery != null) {
+      cleanCharacterQueryTimeout.start(QUERY_LIFE_DURATION_MS, () => setCharacterQuery(null));
+    }
+    return () => {};
+  }, [state.characterQuery, setCharacterQuery, cleanCharacterQueryTimeout]);
+
+  // If `tempValueStrAndroid` is still defined for some section when running `useEffect`,
+  // Then `onChange` has only been called once, which means the user pressed `Backspace` to reset the section.
+  // This causes a small flickering on Android,
+  // But we can't use `useEnhancedEffect` which is always called before the second `onChange` call and then would cause false positives.
+  React.useEffect(() => {
+    if (state.tempValueStrAndroid != null && activeSectionIndex != null) {
+      clearActiveSection();
+    }
+  }, [state.sections]); // eslint-disable-line react-hooks/exhaustive-deps
+
   return {
-    state,
-    value,
+    // States and derived states
     activeSectionIndex,
+    areAllSectionsEmpty,
+    error,
+    localizedDigits,
     parsedSelectedSections,
-    setSelectedSections,
+    sectionOrder,
+    sectionsValueBoundaries,
+    state,
+    timezone,
+    value,
+    // Methods to update the states
     clearValue,
     clearActiveSection,
+    setCharacterQuery,
+    setSelectedSections,
+    setTempAndroidValueStr,
     updateSectionValue,
     updateValueFromValueStr,
-    setTempAndroidValueStr,
-    getSectionsFromValue,
-    sectionsValueBoundaries,
-    localizedDigits,
-    timezone
+    // Utilities methods
+    getSectionsFromValue
   };
 };

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

@@ -1,6 +1,8 @@
-import { UseFieldTextField } from "./useField.types.js";
+import { UseFieldParameters, UseFieldProps, UseFieldReturnValue } from "./useField.types.js";
 import { InferFieldSection } from "../../../models/index.js";
 import { PickerValidValue } from "../../models/index.js";
+export declare const addPositionPropertiesToSections: <TValue extends PickerValidValue>(sections: InferFieldSection<TValue>[], localizedDigits: string[], isRtl: boolean) => FieldSectionWithPositions<TValue>[];
+export declare const useFieldV6TextField: <TValue extends PickerValidValue, TError, TValidationProps extends {}, TProps extends UseFieldProps<false>>(parameters: UseFieldParameters<TValue, false, TError, TValidationProps, TProps>) => UseFieldReturnValue<false, TProps>;
 type FieldSectionWithPositions<TValue extends PickerValidValue> = InferFieldSection<TValue> & {
   /**
    * Start index of the section in the format
@@ -21,6 +23,4 @@ type FieldSectionWithPositions<TValue extends PickerValidValue> = InferFieldSect
    */
   endInInput: number;
 };
-export declare const addPositionPropertiesToSections: <TValue extends PickerValidValue>(sections: InferFieldSection<TValue>[], localizedDigits: string[], isRtl: boolean) => FieldSectionWithPositions<TValue>[];
-export declare const useFieldV6TextField: UseFieldTextField<false>;
 export {};