@mui/x-date-pickers 9.0.0-alpha.1 → 9.0.0-alpha.2

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

@@ -1,256 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import useEventCallback from '@mui/utils/useEventCallback';
-import { changeSectionValueFormat, cleanDigitSectionValue, doesSectionFormatHaveLeadingZeros, getDateSectionConfigFromFormatToken, getDaysInWeekStr, getLetterEditingOptions, applyLocalizedDigits, removeLocalizedDigits, isStringNumber } from "./useField.utils.js";
-import { usePickerAdapter } from "../../../hooks/usePickerAdapter.js";
-const isQueryResponseWithoutValue = response => response.saveQuery != null;
-
-/**
- * Update the active section value when the user pressed a key that is not a navigation key (arrow key for example).
- * This hook has two main editing behaviors
- *
- * 1. The numeric editing when the user presses a digit
- * 2. The letter editing when the user presses another key
- */
-export const useFieldCharacterEditing = ({
-  stateResponse: {
-    // States and derived states
-    localizedDigits,
-    sectionsValueBoundaries,
-    state,
-    timezone,
-    // Methods to update the states
-    setCharacterQuery,
-    setTempAndroidValueStr,
-    updateSectionValue
-  }
-}) => {
-  const adapter = usePickerAdapter();
-  const applyQuery = ({
-    keyPressed,
-    sectionIndex
-  }, getFirstSectionValueMatchingWithQuery, isValidQueryValue) => {
-    const cleanKeyPressed = keyPressed.toLowerCase();
-    const activeSection = state.sections[sectionIndex];
-
-    // The current query targets the section being editing
-    // We can try to concatenate the value
-    if (state.characterQuery != null && (!isValidQueryValue || isValidQueryValue(state.characterQuery.value)) && state.characterQuery.sectionIndex === sectionIndex) {
-      const concatenatedQueryValue = `${state.characterQuery.value}${cleanKeyPressed}`;
-      const queryResponse = getFirstSectionValueMatchingWithQuery(concatenatedQueryValue, activeSection);
-      if (!isQueryResponseWithoutValue(queryResponse)) {
-        setCharacterQuery({
-          sectionIndex,
-          value: concatenatedQueryValue,
-          sectionType: activeSection.type
-        });
-        return queryResponse;
-      }
-    }
-    const queryResponse = getFirstSectionValueMatchingWithQuery(cleanKeyPressed, activeSection);
-    if (isQueryResponseWithoutValue(queryResponse) && !queryResponse.saveQuery) {
-      setCharacterQuery(null);
-      return null;
-    }
-    setCharacterQuery({
-      sectionIndex,
-      value: cleanKeyPressed,
-      sectionType: activeSection.type
-    });
-    if (isQueryResponseWithoutValue(queryResponse)) {
-      return null;
-    }
-    return queryResponse;
-  };
-  const applyLetterEditing = params => {
-    const findMatchingOptions = (format, options, queryValue) => {
-      const matchingValues = options.filter(option => option.toLowerCase().startsWith(queryValue));
-      if (matchingValues.length === 0) {
-        return {
-          saveQuery: false
-        };
-      }
-      return {
-        sectionValue: matchingValues[0],
-        shouldGoToNextSection: matchingValues.length === 1
-      };
-    };
-    const testQueryOnFormatAndFallbackFormat = (queryValue, activeSection, fallbackFormat, formatFallbackValue) => {
-      const getOptions = format => getLetterEditingOptions(adapter, timezone, activeSection.type, format);
-      if (activeSection.contentType === 'letter') {
-        return findMatchingOptions(activeSection.format, getOptions(activeSection.format), queryValue);
-      }
-
-      // When editing a digit-format month / weekDay and the user presses a letter,
-      // We can support the letter editing by using the letter-format month / weekDay and re-formatting the result.
-      // We just have to make sure that the default month / weekDay format is a letter format,
-      if (fallbackFormat && formatFallbackValue != null && getDateSectionConfigFromFormatToken(adapter, fallbackFormat).contentType === 'letter') {
-        const fallbackOptions = getOptions(fallbackFormat);
-        const response = findMatchingOptions(fallbackFormat, fallbackOptions, queryValue);
-        if (isQueryResponseWithoutValue(response)) {
-          return {
-            saveQuery: false
-          };
-        }
-        return _extends({}, response, {
-          sectionValue: formatFallbackValue(response.sectionValue, fallbackOptions)
-        });
-      }
-      return {
-        saveQuery: false
-      };
-    };
-    const getFirstSectionValueMatchingWithQuery = (queryValue, activeSection) => {
-      switch (activeSection.type) {
-        case 'month':
-          {
-            const formatFallbackValue = fallbackValue => changeSectionValueFormat(adapter, fallbackValue, adapter.formats.month, activeSection.format);
-            return testQueryOnFormatAndFallbackFormat(queryValue, activeSection, adapter.formats.month, formatFallbackValue);
-          }
-        case 'weekDay':
-          {
-            const formatFallbackValue = (fallbackValue, fallbackOptions) => fallbackOptions.indexOf(fallbackValue).toString();
-            return testQueryOnFormatAndFallbackFormat(queryValue, activeSection, adapter.formats.weekday, formatFallbackValue);
-          }
-        case 'meridiem':
-          {
-            return testQueryOnFormatAndFallbackFormat(queryValue, activeSection);
-          }
-        default:
-          {
-            return {
-              saveQuery: false
-            };
-          }
-      }
-    };
-    return applyQuery(params, getFirstSectionValueMatchingWithQuery);
-  };
-  const applyNumericEditing = params => {
-    const getNewSectionValue = ({
-      queryValue,
-      skipIfBelowMinimum,
-      section
-    }) => {
-      const cleanQueryValue = removeLocalizedDigits(queryValue, localizedDigits);
-      const queryValueNumber = Number(cleanQueryValue);
-      const sectionBoundaries = sectionsValueBoundaries[section.type]({
-        currentDate: null,
-        format: section.format,
-        contentType: section.contentType
-      });
-      if (queryValueNumber > sectionBoundaries.maximum) {
-        return {
-          saveQuery: false
-        };
-      }
-
-      // If the user types `0` on a month section,
-      // It is below the minimum, but we want to store the `0` in the query,
-      // So that when he pressed `1`, it will store `01` and move to the next section.
-      if (skipIfBelowMinimum && queryValueNumber < sectionBoundaries.minimum) {
-        return {
-          saveQuery: true
-        };
-      }
-      const shouldGoToNextSection = queryValueNumber * 10 > sectionBoundaries.maximum || cleanQueryValue.length === sectionBoundaries.maximum.toString().length;
-      const newSectionValue = cleanDigitSectionValue(adapter, queryValueNumber, sectionBoundaries, localizedDigits, section);
-      return {
-        sectionValue: newSectionValue,
-        shouldGoToNextSection
-      };
-    };
-    const getFirstSectionValueMatchingWithQuery = (queryValue, activeSection) => {
-      if (activeSection.contentType === 'digit' || activeSection.contentType === 'digit-with-letter') {
-        return getNewSectionValue({
-          queryValue,
-          skipIfBelowMinimum: false,
-          section: activeSection
-        });
-      }
-
-      // When editing a letter-format month and the user presses a digit,
-      // We can support the numeric editing by using the digit-format month and re-formatting the result.
-      if (activeSection.type === 'month') {
-        const hasLeadingZerosInFormat = doesSectionFormatHaveLeadingZeros(adapter, 'digit', 'month', 'MM');
-        const response = getNewSectionValue({
-          queryValue,
-          skipIfBelowMinimum: true,
-          section: {
-            type: activeSection.type,
-            format: 'MM',
-            hasLeadingZerosInFormat,
-            hasLeadingZerosInInput: true,
-            contentType: 'digit',
-            maxLength: 2
-          }
-        });
-        if (isQueryResponseWithoutValue(response)) {
-          return response;
-        }
-        const formattedValue = changeSectionValueFormat(adapter, response.sectionValue, 'MM', activeSection.format);
-        return _extends({}, response, {
-          sectionValue: formattedValue
-        });
-      }
-
-      // When editing a letter-format weekDay and the user presses a digit,
-      // We can support the numeric editing by returning the nth day in the week day array.
-      if (activeSection.type === 'weekDay') {
-        const response = getNewSectionValue({
-          queryValue,
-          skipIfBelowMinimum: true,
-          section: activeSection
-        });
-        if (isQueryResponseWithoutValue(response)) {
-          return response;
-        }
-        const formattedValue = getDaysInWeekStr(adapter, activeSection.format)[Number(response.sectionValue) - 1];
-        return _extends({}, response, {
-          sectionValue: formattedValue
-        });
-      }
-      return {
-        saveQuery: false
-      };
-    };
-    return applyQuery(params, getFirstSectionValueMatchingWithQuery, queryValue => isStringNumber(queryValue, localizedDigits));
-  };
-  return useEventCallback(params => {
-    const section = state.sections[params.sectionIndex];
-    const isNumericEditing = isStringNumber(params.keyPressed, localizedDigits);
-    const response = isNumericEditing ? applyNumericEditing(_extends({}, params, {
-      keyPressed: applyLocalizedDigits(params.keyPressed, localizedDigits)
-    })) : applyLetterEditing(params);
-    if (response == null) {
-      setTempAndroidValueStr(null);
-      return;
-    }
-    updateSectionValue({
-      section,
-      newSectionValue: response.sectionValue,
-      shouldGoToNextSection: response.shouldGoToNextSection
-    });
-  });
-};
-
-/**
- * The letter editing and the numeric editing each define a `CharacterEditingApplier`.
- * This function decides what the new section value should be and if the focus should switch to the next section.
- *
- * If it returns `null`, then the section value is not updated and the focus does not move.
- */
-
-/**
- * Function called by `applyQuery` which decides:
- * - what is the new section value ?
- * - should the query used to get this value be stored for the next key press ?
- *
- * If it returns `{ sectionValue: string; shouldGoToNextSection: boolean }`,
- * Then we store the query and update the section with the new value.
- *
- * If it returns `{ saveQuery: true` },
- * Then we store the query and don't update the section.
- *
- * If it returns `{ saveQuery: false },
- * Then we do nothing.
- */

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

@@ -1,20 +0,0 @@
-import * as React from 'react';
-import { PickerManager } from "../../../models/index.js";
-import { UseFieldStateReturnValue } from "./useFieldState.js";
-/**
- * Generate the props to pass to the hidden input element of the field.
- * It is not used by the non-accessible DOM structure (with an <input /> element for editing).
- * It should be used in the MUI accessible DOM structure and the Base UI implementation.
- * @param {UseFieldHiddenInputPropsParameters} parameters The parameters of the hook.
- * @returns {UseFieldHiddenInputPropsReturnValue} The props to forward to the hidden input element of the field.
- */
-export declare function useFieldHiddenInputProps(parameters: UseFieldHiddenInputPropsParameters): UseFieldHiddenInputPropsReturnValue;
-interface UseFieldHiddenInputPropsParameters {
-  manager: PickerManager<any, any, any, any, any>;
-  stateResponse: UseFieldStateReturnValue<any>;
-}
-interface UseFieldHiddenInputPropsReturnValue {
-  value: string;
-  onChange: React.ChangeEventHandler<HTMLInputElement>;
-}
-export {};

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

@@ -1,17 +0,0 @@
-import { PickerAnyManager, PickerManagerFieldInternalProps, PickerManagerFieldInternalPropsWithDefaults } from "../../models/index.js";
-/**
- * Applies the default values to the field internal props.
- * This is a temporary hook that will be removed during a follow up when `useField` will receive the internal props without the defaults.
- * It is only here to allow the migration to be done in smaller steps.
- */
-export declare function useFieldInternalPropsWithDefaults<TManager extends PickerAnyManager>(parameters: UseFieldInternalPropsWithDefaultsParameters<TManager>): PickerManagerFieldInternalPropsWithDefaults<TManager>;
-interface UseFieldInternalPropsWithDefaultsParameters<TManager extends PickerAnyManager> {
-  manager: TManager;
-  internalProps: PickerManagerFieldInternalProps<TManager>;
-  /**
-   * Hack to make sure that on multi input range field, the `useNullableFieldPrivateContext().fieldRef` is only bound to the field matching the range position.
-   * @default false
-   */
-  skipContextFieldRefAssignment?: boolean;
-}
-export {};

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

@@ -1,53 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import useForkRef from '@mui/utils/useForkRef';
-import { useNullablePickerContext } from "../useNullablePickerContext.js";
-import { useNullableFieldPrivateContext } from "../useNullableFieldPrivateContext.js";
-
-/**
- * Applies the default values to the field internal props.
- * This is a temporary hook that will be removed during a follow up when `useField` will receive the internal props without the defaults.
- * It is only here to allow the migration to be done in smaller steps.
- */
-export function useFieldInternalPropsWithDefaults(parameters) {
-  const {
-    manager: {
-      internal_useApplyDefaultValuesToFieldInternalProps: useApplyDefaultValuesToFieldInternalProps
-    },
-    internalProps,
-    skipContextFieldRefAssignment
-  } = parameters;
-  const pickerContext = useNullablePickerContext();
-  const fieldPrivateContext = useNullableFieldPrivateContext();
-  const handleFieldRef = useForkRef(internalProps.unstableFieldRef, skipContextFieldRefAssignment ? null : fieldPrivateContext?.fieldRef);
-  const setValue = pickerContext?.setValue;
-  const handleChangeFromPicker = React.useCallback((newValue, ctx) => {
-    return setValue?.(newValue, {
-      validationError: ctx.validationError,
-      shouldClose: false
-    });
-  }, [setValue]);
-  const internalPropsWithDefaultsFromContext = React.useMemo(() => {
-    // If one of the context is null,
-    // Then the field is used as a standalone component and the other context will be null as well.
-    if (fieldPrivateContext != null && pickerContext != null) {
-      return _extends({
-        value: pickerContext.value,
-        onChange: handleChangeFromPicker,
-        timezone: pickerContext.timezone,
-        disabled: pickerContext.disabled,
-        readOnly: pickerContext.readOnly,
-        autoFocus: pickerContext.autoFocus && !pickerContext.open,
-        focused: pickerContext.open ? true : undefined,
-        format: pickerContext.fieldFormat,
-        formatDensity: fieldPrivateContext.formatDensity,
-        enableAccessibleFieldDOMStructure: fieldPrivateContext.enableAccessibleFieldDOMStructure,
-        selectedSections: fieldPrivateContext.selectedSections,
-        onSelectedSectionsChange: fieldPrivateContext.onSelectedSectionsChange,
-        unstableFieldRef: handleFieldRef
-      }, internalProps);
-    }
-    return internalProps;
-  }, [pickerContext, fieldPrivateContext, internalProps, handleChangeFromPicker, handleFieldRef]);
-  return useApplyDefaultValuesToFieldInternalProps(internalPropsWithDefaultsFromContext);
-}

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

@@ -1,16 +0,0 @@
-import { PickerManager } from "../../../models/index.js";
-import { PickerValidValue } from "../../models/index.js";
-import { UseFieldStateReturnValue } from "./useFieldState.js";
-import { UseFieldInternalProps } from "./useField.types.js";
-/**
- * Returns the `onKeyDown` handler to pass to the root element of the field.
- */
-export declare function useFieldRootHandleKeyDown<TValue extends PickerValidValue>(parameters: UseFieldRootHandleKeyDownParameters<TValue>): (event: React.KeyboardEvent<HTMLSpanElement>) => void;
-interface UseFieldRootHandleKeyDownParameters<TValue extends PickerValidValue> {
-  manager: PickerManager<TValue, any, any, any, any>;
-  stateResponse: UseFieldStateReturnValue<TValue>;
-  internalPropsWithDefaults: UseFieldInternalProps<TValue, any, any> & {
-    minutesStep?: number;
-  };
-}
-export {};

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

@@ -1,205 +0,0 @@
-import useEventCallback from '@mui/utils/useEventCallback';
-import { cleanDigitSectionValue, getLetterEditingOptions, removeLocalizedDigits } from "./useField.utils.js";
-import { usePickerAdapter } from "../../../hooks/usePickerAdapter.js";
-
-/**
- * Returns the `onKeyDown` handler to pass to the root element of the field.
- */
-export function useFieldRootHandleKeyDown(parameters) {
-  const adapter = usePickerAdapter();
-  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(adapter, 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(adapter, 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(adapter, 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 adapter.formatByString(adapter.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(adapter, 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/useFieldRootProps.d.ts

@@ -1,32 +0,0 @@
-import { PickerManager } from "../../../models/index.js";
-import { UseFieldDOMGetters, UseFieldInternalProps } from "./useField.types.js";
-import { UseFieldStateReturnValue } from "./useFieldState.js";
-import { UseFieldCharacterEditingReturnValue } from "./useFieldCharacterEditing.js";
-/**
- * Generate the props to pass to the root element of the field.
- * It is not used by the non-accessible DOM structure (with an <input /> element for editing).
- * It should be used in the MUI accessible DOM structure and the Base UI implementation.
- * @param {UseFieldRootPropsParameters} parameters The parameters of the hook.
- * @returns {UseFieldRootPropsReturnValue} The props to forward to the root element of the field.
- */
-export declare function useFieldRootProps(parameters: UseFieldRootPropsParameters): UseFieldRootPropsReturnValue;
-interface UseFieldRootPropsParameters {
-  manager: PickerManager<any, any, any, any, any>;
-  stateResponse: UseFieldStateReturnValue<any>;
-  applyCharacterEditing: UseFieldCharacterEditingReturnValue;
-  internalPropsWithDefaults: UseFieldInternalProps<any, any, any>;
-  domGetters: UseFieldDOMGetters;
-  focused: boolean;
-  setFocused: (focused: boolean) => void;
-}
-interface UseFieldRootPropsReturnValue {
-  onKeyDown: React.KeyboardEventHandler<HTMLDivElement>;
-  onBlur: React.FocusEventHandler<HTMLDivElement>;
-  onFocus: React.FocusEventHandler<HTMLDivElement>;
-  onClick: React.MouseEventHandler<HTMLDivElement>;
-  onPaste: React.ClipboardEventHandler<HTMLDivElement>;
-  onInput: React.FormEventHandler<HTMLDivElement>;
-  contentEditable: boolean;
-  tabIndex: number;
-}
-export {};