@mui/x-date-pickers 7.0.0-alpha.3 → 7.0.0-alpha.4

package/internals/components/PickersTextField/PickersInput.js

@@ -1,18 +1,20 @@
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
 import _extends from "@babel/runtime/helpers/esm/extends";
-const _excluded = ["elements", "defaultValue", "label", "onFocus", "onWrapperClick", "onBlur", "valueStr", "onValueStrChange", "id", "InputProps", "inputProps", "autoFocus", "ownerState", "endAdornment", "startAdornment"];
+const _excluded = ["elements", "areAllSectionsEmpty", "defaultValue", "label", "value", "onChange", "id", "autoFocus", "endAdornment", "startAdornment", "contentEditable", "tabIndex", "fullWidth", "inputProps", "inputRef", "sectionsContainerRef"];
 import * as React from 'react';
 import clsx from 'clsx';
 import Box from '@mui/material/Box';
 import { useFormControl } from '@mui/material/FormControl';
 import { styled } from '@mui/material/styles';
 import useForkRef from '@mui/utils/useForkRef';
-import { unstable_composeClasses as composeClasses, unstable_capitalize as capitalize, visuallyHidden } from '@mui/utils';
+import composeClasses from '@mui/utils/composeClasses';
+import capitalize from '@mui/utils/capitalize';
+import visuallyHidden from '@mui/utils/visuallyHidden';
 import { pickersInputClasses, getPickersInputUtilityClass } from './pickersTextFieldClasses';
 import Outline from './Outline';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { jsxs as _jsxs } from "react/jsx-runtime";
-const SectionsWrapper = styled(Box, {
+const PickersInputRoot = styled(Box, {
   name: 'MuiPickersInput',
   slot: 'Root',
   overridesResolver: (props, styles) => styles.root
@@ -29,6 +31,7 @@ const SectionsWrapper = styled(Box, {
     alignItems: 'center',
     width: ownerState.fullWidth ? '100%' : '25ch',
     position: 'relative',
+    outline: 'none',
     borderRadius: (theme.vars || theme).shape.borderRadius,
     [`&:hover .${pickersInputClasses.notchedOutline}`]: {
       borderColor: (theme.vars || theme).palette.text.primary
@@ -59,22 +62,30 @@ const SectionsWrapper = styled(Box, {
     padding: '8.5px 14px'
   });
 });
-const SectionsContainer = styled('div', {
+const PickersInputSectionsContainer = styled('div', {
   name: 'MuiPickersInput',
-  slot: 'Input',
-  overridesResolver: (props, styles) => styles.input
+  slot: 'SectionsContainer',
+  overridesResolver: (props, styles) => styles.sectionsContainer
 })(({
   theme,
   ownerState
-}) => ({
+}) => _extends({
   fontFamily: theme.typography.fontFamily,
   fontSize: 'inherit',
   lineHeight: '1.4375em',
   // 23px
   flexGrow: 1,
-  visibility: ownerState.adornedStart || ownerState.focused ? 'visible' : 'hidden'
-}));
-const SectionContainer = styled('span', {
+  outline: 'none'
+}, !(ownerState.adornedStart || ownerState.focused || ownerState.filled) && _extends({
+  color: 'currentColor'
+}, ownerState.label == null && (theme.vars ? {
+  opacity: theme.vars.opacity.inputPlaceholder
+} : {
+  opacity: theme.palette.mode === 'light' ? 0.42 : 0.5
+}), ownerState.label != null && {
+  opacity: 0
+})));
+const PickersInputSection = styled('span', {
   name: 'MuiPickersInput',
   slot: 'Section',
   overridesResolver: (props, styles) => styles.section
@@ -87,9 +98,9 @@ const SectionContainer = styled('span', {
   // 23px
   flexGrow: 1
 }));
-const SectionInput = styled('span', {
+const PickersInputContent = styled('span', {
   name: 'MuiPickersInput',
-  slot: 'Content',
+  slot: 'SectionContent',
   overridesResolver: (props, styles) => styles.content
 })(({
   theme
@@ -100,16 +111,16 @@ const SectionInput = styled('span', {
   letterSpacing: 'inherit',
   width: 'fit-content'
 }));
-const SectionSeparator = styled('span', {
+const PickersInputSeparator = styled('span', {
   name: 'MuiPickersInput',
   slot: 'Separator',
   overridesResolver: (props, styles) => styles.separator
 })(() => ({
   whiteSpace: 'pre'
 }));
-const FakeHiddenInput = styled('input', {
+const PickersInputInput = styled('input', {
   name: 'MuiPickersInput',
-  slot: 'HiddenInput',
+  slot: 'Input',
   overridesResolver: (props, styles) => styles.hiddenInput
 })(_extends({}, visuallyHidden));
 const NotchedOutlineRoot = styled(Outline, {
@@ -124,36 +135,6 @@ const NotchedOutlineRoot = styled(Outline, {
     borderColor: theme.vars ? `rgba(${theme.vars.palette.common.onBackgroundChannel} / 0.23)` : borderColor
   };
 });
-function InputContent({
-  elements,
-  contentEditable,
-  ownerState
-}) {
-  if (contentEditable) {
-    return elements.map(({
-      content,
-      before,
-      after
-    }) => `${before.children}${content.children}${after.children}`).join('');
-  }
-  return /*#__PURE__*/_jsx(React.Fragment, {
-    children: elements.map(({
-      container,
-      content,
-      before,
-      after
-    }, elementIndex) => /*#__PURE__*/_jsxs(SectionContainer, _extends({}, container, {
-      children: [/*#__PURE__*/_jsx(SectionSeparator, _extends({}, before, {
-        className: clsx(pickersInputClasses.before, before == null ? void 0 : before.className)
-      })), /*#__PURE__*/_jsx(SectionInput, _extends({}, content, {
-        className: clsx(pickersInputClasses.content, content == null ? void 0 : content.className),
-        ownerState
-      })), /*#__PURE__*/_jsx(SectionSeparator, _extends({}, after, {
-        className: clsx(pickersInputClasses.after, after == null ? void 0 : after.className)
-      }))]
-    }), elementIndex))
-  });
-}
 const useUtilityClasses = ownerState => {
   const {
     focused,
@@ -161,104 +142,128 @@ const useUtilityClasses = ownerState => {
     error,
     classes,
     fullWidth,
+    readOnly,
     color,
     size,
     endAdornment,
     startAdornment
   } = ownerState;
   const slots = {
-    root: ['root', focused && !disabled && 'focused', disabled && 'disabled', error && 'error', fullWidth && 'fullWidth', `color${capitalize(color)}`, size === 'small' && 'inputSizeSmall', Boolean(startAdornment) && 'adornedStart', Boolean(endAdornment) && 'adornedEnd'],
+    root: ['root', focused && !disabled && 'focused', disabled && 'disabled', readOnly && 'readOnly', error && 'error', fullWidth && 'fullWidth', `color${capitalize(color)}`, size === 'small' && 'inputSizeSmall', Boolean(startAdornment) && 'adornedStart', Boolean(endAdornment) && 'adornedEnd'],
     notchedOutline: ['notchedOutline'],
-    before: ['before'],
-    after: ['after'],
-    content: ['content'],
-    input: ['input']
+    input: ['input'],
+    sectionsContainer: ['sectionsContainer'],
+    sectionContent: ['sectionContent'],
+    sectionBefore: ['sectionBefore'],
+    sectionAfter: ['sectionAfter']
   };
   return composeClasses(slots, getPickersInputUtilityClass, classes);
 };
-
-// TODO: move to utils
-// Separates the state props from the form control
-function formControlState({
-  props,
-  states,
-  muiFormControl
-}) {
-  return states.reduce((acc, state) => {
-    acc[state] = props[state];
-    if (muiFormControl) {
-      if (typeof props[state] === 'undefined') {
-        acc[state] = muiFormControl[state];
-      }
-    }
-    return acc;
-  }, {});
-}
-const PickersInput = /*#__PURE__*/React.forwardRef(function PickersInput(props, ref) {
+export const PickersInput = /*#__PURE__*/React.forwardRef(function PickersInput(props, ref) {
   const {
       elements,
+      areAllSectionsEmpty,
       label,
-      onWrapperClick,
-      valueStr,
-      onValueStrChange,
+      value,
+      onChange,
       id,
-      ownerState: ownerStateProp,
       endAdornment,
-      startAdornment
+      startAdornment,
+      contentEditable,
+      tabIndex,
+      inputProps,
+      inputRef,
+      sectionsContainerRef
     } = props,
     other = _objectWithoutPropertiesLoose(props, _excluded);
-  const inputRef = React.useRef(null);
-  const handleInputRef = useForkRef(ref, inputRef);
+  const rootRef = React.useRef(null);
+  const handleRootRef = useForkRef(ref, rootRef);
+  const handleInputRef = useForkRef(inputProps == null ? void 0 : inputProps.ref, inputRef);
   const muiFormControl = useFormControl();
-  const fcs = formControlState({
-    props,
-    muiFormControl,
-    states: ['color', 'disabled', 'error', 'focused', 'size', 'required', 'fullWidth', 'adornedStart']
-  });
+  if (!muiFormControl) {
+    throw new Error('MUI: PickersInput should always be used inside a PickersTextField component');
+  }
+  const handleInputFocus = event => {
+    var _muiFormControl$onFoc;
+    // Fix a bug with IE11 where the focus/blur events are triggered
+    // while the component is disabled.
+    if (muiFormControl.disabled) {
+      event.stopPropagation();
+      return;
+    }
+    (_muiFormControl$onFoc = muiFormControl.onFocus) == null || _muiFormControl$onFoc.call(muiFormControl, event);
+  };
   React.useEffect(() => {
     if (muiFormControl) {
       muiFormControl.setAdornedStart(Boolean(startAdornment));
     }
   }, [muiFormControl, startAdornment]);
-  const ownerState = _extends({}, props, ownerStateProp, {
-    color: fcs.color || 'primary',
-    disabled: fcs.disabled,
-    error: fcs.error,
-    focused: fcs.focused,
-    fullWidth: fcs.fullWidth,
-    size: fcs.size
-  });
+  React.useEffect(() => {
+    if (!muiFormControl) {
+      return;
+    }
+    if (areAllSectionsEmpty) {
+      muiFormControl.onEmpty();
+    } else {
+      muiFormControl.onFilled();
+    }
+  }, [muiFormControl, areAllSectionsEmpty]);
+  const ownerState = _extends({}, props, muiFormControl);
   const classes = useUtilityClasses(ownerState);
-  return /*#__PURE__*/_jsxs(SectionsWrapper, _extends({
-    ref: handleInputRef
-  }, other, {
+  return /*#__PURE__*/_jsxs(PickersInputRoot, _extends({}, other, {
     className: classes.root,
-    onClick: onWrapperClick,
     ownerState: ownerState,
-    "aria-invalid": fcs.error,
-    children: [startAdornment, /*#__PURE__*/_jsxs(SectionsContainer, {
+    "aria-invalid": muiFormControl.error,
+    ref: handleRootRef,
+    children: [startAdornment, /*#__PURE__*/_jsx(PickersInputSectionsContainer, {
       ownerState: ownerState,
-      className: classes.input,
-      children: [/*#__PURE__*/_jsx(InputContent, {
-        elements: elements,
-        contentEditable: other.contentEditable,
-        ownerState: ownerState
-      }), /*#__PURE__*/_jsx(FakeHiddenInput, {
-        value: valueStr,
-        onChange: onValueStrChange,
-        id: id,
-        "aria-hidden": "true",
-        tabIndex: -1
-      })]
+      className: classes.sectionsContainer,
+      contentEditable: contentEditable,
+      suppressContentEditableWarning: true,
+      onFocus: handleInputFocus,
+      onBlur: muiFormControl.onBlur,
+      tabIndex: tabIndex,
+      ref: sectionsContainerRef,
+      children: contentEditable ? elements.map(({
+        content,
+        before,
+        after
+      }) => `${before.children}${content.children}${after.children}`).join('') : /*#__PURE__*/_jsx(React.Fragment, {
+        children: elements.map(({
+          container,
+          content,
+          before,
+          after
+        }, elementIndex) => /*#__PURE__*/_jsxs(PickersInputSection, _extends({}, container, {
+          children: [/*#__PURE__*/_jsx(PickersInputSeparator, _extends({}, before, {
+            className: clsx(pickersInputClasses.sectionBefore, before == null ? void 0 : before.className)
+          })), /*#__PURE__*/_jsx(PickersInputContent, _extends({}, content, {
+            suppressContentEditableWarning: true,
+            className: clsx(pickersInputClasses.sectionContent, content == null ? void 0 : content.className),
+            ownerState
+          })), /*#__PURE__*/_jsx(PickersInputSeparator, _extends({}, after, {
+            className: clsx(pickersInputClasses.sectionAfter, after == null ? void 0 : after.className)
+          }))]
+        }), elementIndex))
+      })
     }), endAdornment, /*#__PURE__*/_jsx(NotchedOutlineRoot, {
-      shrink: fcs.adornedStart || fcs.focused,
-      notched: fcs.adornedStart || fcs.focused,
+      shrink: muiFormControl.adornedStart || muiFormControl.focused || muiFormControl.filled,
+      notched: muiFormControl.adornedStart || muiFormControl.focused || muiFormControl.filled,
       className: classes.notchedOutline,
-      label: label != null && label !== '' && fcs.required ? /*#__PURE__*/_jsxs(React.Fragment, {
+      label: label != null && label !== '' && muiFormControl.required ? /*#__PURE__*/_jsxs(React.Fragment, {
         children: [label, "\u2009", '*']
       }) : label,
       ownerState: ownerState
-    })]
+    }), /*#__PURE__*/_jsx(PickersInputInput, _extends({
+      className: classes.input,
+      value: value,
+      onChange: onChange,
+      id: id,
+      "aria-hidden": "true",
+      tabIndex: -1
+    }, inputProps, {
+      ref: handleInputRef
+    }))]
   }));
 });
-export default PickersInput;
+PickersInput.muiName = 'Input';

package/internals/components/PickersTextField/PickersInput.types.d.ts

@@ -1,30 +1,45 @@
-/// <reference types="react" />
-import { OutlinedInputProps } from '@mui/material/OutlinedInput';
-import { FieldsTextFieldProps } from '../../models';
+import * as React from 'react';
+import { BoxProps } from '@mui/material/Box';
 export interface PickersInputElement {
     container: React.HTMLAttributes<HTMLSpanElement>;
     content: React.HTMLAttributes<HTMLSpanElement>;
     before: React.HTMLAttributes<HTMLSpanElement>;
     after: React.HTMLAttributes<HTMLSpanElement>;
 }
-export interface PickersInputProps extends FieldsTextFieldProps {
+export interface PickersInputPropsUsedByField {
+    /**
+     * The elements to render.
+     * Each element contains the prop to edit a section of the value.
+     */
     elements: PickersInputElement[];
-    areAllSectionsEmpty?: boolean;
-    valueStr: string;
-    onValueStrChange: React.ChangeEventHandler<HTMLInputElement>;
-    id?: string;
-    InputProps?: Partial<OutlinedInputProps>;
-    inputProps: any;
-    autoFocus?: boolean;
-    ownerState?: any;
-    onWrapperClick: () => void;
-    defaultValue: string;
-    label?: string;
+    /**
+     * Is `true` if the current values equals the empty value.
+     * For a single item value, it means that `value === null`
+     * For a range value, it means that `value === [null, null]`
+     */
+    areAllSectionsEmpty: boolean;
+    onClick: React.MouseEventHandler<HTMLDivElement>;
+    onKeyDown: React.KeyboardEventHandler<HTMLDivElement>;
+    onInput: React.FormEventHandler<HTMLDivElement>;
+    onPaste: React.ClipboardEventHandler<HTMLDivElement>;
     endAdornment?: React.ReactNode;
     startAdornment?: React.ReactNode;
-    onBlur?: React.FocusEventHandler;
-    onChange?: React.FormEventHandler;
-    onFocus?: React.FocusEventHandler;
-    onKeyDown?: React.KeyboardEventHandler;
-    onKeyUp?: React.KeyboardEventHandler;
+    tabIndex: number | undefined;
+    contentEditable: boolean;
+    value: string;
+    onChange: React.ChangeEventHandler<HTMLInputElement>;
+    label?: React.ReactNode;
+    id?: string;
+    fullWidth?: boolean;
+    readOnly?: boolean;
+    inputProps?: React.HTMLAttributes<HTMLInputElement> & {
+        ref?: React.Ref<HTMLInputElement>;
+    };
+    inputRef?: React.Ref<HTMLInputElement>;
+    sectionsContainerRef?: React.Ref<HTMLDivElement>;
+}
+export interface PickersInputOtherProps extends Omit<BoxProps, keyof PickersInputPropsUsedByField> {
+    ref?: React.Ref<HTMLDivElement>;
+}
+export interface PickersInputProps extends PickersInputPropsUsedByField, PickersInputOtherProps {
 }

package/internals/components/PickersTextField/PickersTextField.js

@@ -1,6 +1,6 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-const _excluded = ["elements", "className", "color", "disabled", "error", "label", "variant", "fullWidth", "valueStr", "helperText", "valueType", "id", "FormHelperTextProps", "InputLabelProps", "inputProps", "InputProps", "required", "focused", "ownerState"];
+const _excluded = ["onFocus", "onBlur", "className", "color", "disabled", "error", "required", "variant", "InputProps", "inputProps", "inputRef", "sectionsContainerRef", "elements", "areAllSectionsEmpty", "onClick", "onKeyDown", "onKeyUp", "onPaste", "onInput", "endAdornment", "startAdornment", "tabIndex", "contentEditable", "focused", "value", "onChange", "fullWidth", "id", "helperText", "FormHelperTextProps", "label", "InputLabelProps"];
 import * as React from 'react';
 import clsx from 'clsx';
 import { styled } from '@mui/material/styles';
@@ -10,7 +10,7 @@ import InputLabel from '@mui/material/InputLabel';
 import FormHelperText from '@mui/material/FormHelperText';
 import FormControl from '@mui/material/FormControl';
 import { getPickersTextFieldUtilityClass } from './pickersTextFieldClasses';
-import PickersInput from './PickersInput';
+import { PickersInput } from './PickersInput';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { jsxs as _jsxs } from "react/jsx-runtime";
 const PickersTextFieldRoot = styled(FormControl, {
@@ -32,32 +32,46 @@ const useUtilityClasses = ownerState => {
 };
 export const PickersTextField = /*#__PURE__*/React.forwardRef(function PickersTextField(props, ref) {
   const {
-      elements,
+      // Props used by FormControl
+      onFocus,
+      onBlur,
       className,
       color = 'primary',
       disabled = false,
       error = false,
-      label,
+      required = false,
       variant = 'outlined',
-      fullWidth = false,
-      valueStr,
+      // Props used by PickersInput
+      InputProps,
+      inputProps,
+      inputRef,
+      sectionsContainerRef,
+      elements,
+      areAllSectionsEmpty,
+      onClick,
+      onKeyDown,
+      onPaste,
+      onInput,
+      endAdornment,
+      startAdornment,
+      tabIndex,
+      contentEditable,
+      focused,
+      value,
+      onChange,
+      fullWidth,
+      id: idProp,
+      // Props used by FormHelperText
       helperText,
-      valueType,
-      id: idOverride,
       FormHelperTextProps,
-      InputLabelProps,
-      inputProps,
-      InputProps,
-      required = false,
-      focused: focusedProp
+      // Props used by InputLabel
+      label,
+      InputLabelProps
     } = props,
     other = _objectWithoutPropertiesLoose(props, _excluded);
-  const [focused, setFocused] = React.useState(focusedProp);
   const rootRef = React.useRef(null);
   const handleRootRef = useForkRef(ref, rootRef);
-  const inputRef = React.useRef(null);
-  const handleInputRef = useForkRef(inputRef, InputProps == null ? void 0 : InputProps.ref);
-  const id = useId(idOverride);
+  const id = useId(idProp);
   const helperTextId = helperText && id ? `${id}-helper-text` : undefined;
   const inputLabelId = label && id ? `${id}-label` : undefined;
   const ownerState = _extends({}, props, {
@@ -65,56 +79,51 @@ export const PickersTextField = /*#__PURE__*/React.forwardRef(function PickersTe
     disabled,
     error,
     focused,
+    required,
     variant
   });
   const classes = useUtilityClasses(ownerState);
-
-  // TODO: delete after behavior implementation
-  const onWrapperClick = () => {
-    if (!focused) {
-      var _inputRef$current;
-      setFocused(true);
-      const container = rootRef.current;
-
-      // Find the first input element within the container
-      const firstInput = container == null ? void 0 : container.querySelector('.content');
-
-      // Check if the input element exists before focusing it
-      if (firstInput) {
-        firstInput.focus();
-      }
-      (_inputRef$current = inputRef.current) == null || _inputRef$current.focus();
-    }
-  };
-  return /*#__PURE__*/_jsxs(PickersTextFieldRoot, {
+  return /*#__PURE__*/_jsxs(PickersTextFieldRoot, _extends({
     className: clsx(classes.root, className),
     ref: handleRootRef,
     focused: focused,
+    onFocus: onFocus,
+    onBlur: onBlur,
     disabled: disabled,
     variant: variant,
     error: error,
     color: color,
-    fullWidth: fullWidth,
     required: required,
-    ownerState: ownerState,
+    ownerState: ownerState
+  }, other, {
     children: [/*#__PURE__*/_jsx(InputLabel, _extends({
       htmlFor: id,
       id: inputLabelId
     }, InputLabelProps, {
       children: label
     })), /*#__PURE__*/_jsx(PickersInput, _extends({
-      elements,
-      valueStr,
-      valueType,
-      onWrapperClick,
-      inputProps,
-      label
-    }, other, InputProps, {
-      ref: handleInputRef
-    })), helperText && /*#__PURE__*/_jsx(FormHelperText, _extends({
+      elements: elements,
+      areAllSectionsEmpty: areAllSectionsEmpty,
+      onClick: onClick,
+      onKeyDown: onKeyDown,
+      onInput: onInput,
+      onPaste: onPaste,
+      endAdornment: endAdornment,
+      startAdornment: startAdornment,
+      tabIndex: tabIndex,
+      contentEditable: contentEditable,
+      value: value,
+      onChange: onChange,
+      id: id,
+      fullWidth: fullWidth,
+      inputProps: inputProps,
+      inputRef: inputRef,
+      sectionsContainerRef: sectionsContainerRef,
+      label: label
+    }, InputProps)), helperText && /*#__PURE__*/_jsx(FormHelperText, _extends({
       id: helperTextId
     }, FormHelperTextProps, {
       children: helperText
     }))]
-  });
+  }));
 });

package/internals/components/PickersTextField/PickersTextField.types.d.ts

@@ -1,18 +1,21 @@
-/// <reference types="react" />
-import { TextFieldClasses } from '@mui/material/TextField';
-import { PickersInputProps } from './PickersInput.types';
-export interface PickersTextFieldProps extends PickersInputProps {
-    classes?: Partial<TextFieldClasses>;
-    className?: string;
-    color?: 'primary' | 'secondary' | 'error' | 'info' | 'success' | 'warning';
-    disabled?: boolean;
-    error?: boolean;
-    fullWidth?: boolean;
+import * as React from 'react';
+import { FormControlProps } from '@mui/material/FormControl';
+import { FormHelperTextProps } from '@mui/material/FormHelperText';
+import { InputLabelProps } from '@mui/material/InputLabel';
+import { PickersInputOtherProps, PickersInputPropsUsedByField } from './PickersInput.types';
+interface PickersTextFieldPropsUsedByField {
+    onFocus: React.FocusEventHandler<HTMLDivElement>;
+    onBlur: React.FocusEventHandler<HTMLDivElement>;
+    disabled: boolean;
+    error: boolean;
+}
+export interface PickersTextFieldProps extends PickersInputPropsUsedByField, PickersTextFieldPropsUsedByField, Omit<FormControlProps, keyof PickersInputPropsUsedByField | keyof PickersTextFieldPropsUsedByField> {
+    InputProps?: PickersInputOtherProps;
+    FormHelperTextProps?: Partial<FormHelperTextProps>;
+    InputLabelProps?: Partial<InputLabelProps>;
+    /**
+     * The helper text content.
+     */
     helperText?: React.ReactNode;
-    size?: 'small' | 'medium';
-    variant?: 'filled' | 'outlined' | 'standard';
-    valueStr: string;
-    InputProps: any;
-    valueType: 'value' | 'placeholder';
-    required?: boolean;
 }
+export {};

package/internals/components/PickersTextField/pickersTextFieldClasses.d.ts

@@ -20,18 +20,22 @@ export interface PickersInputClasses {
     focused: string;
     /** State class applied to the root element if `disabled=true`. */
     disabled: string;
+    /** State class applied to the root element if `readOnly=true`. */
+    readOnly: string;
     /** State class applied to the root element if `error=true`. */
     error: string;
     /** Styles applied to the NotchedOutline element. */
     notchedOutline: string;
-    /** Styles applied to the fake input element. */
+    /** Styles applied to the real hidden input element. */
     input: string;
-    /** Styles applied to the section of the picker. */
-    content: string;
-    /** Styles applied to the startSeparator */
-    before: string;
-    /** Styles applied to the endSeparator */
-    after: string;
+    /** Styles applied to the container of the sections. */
+    sectionsContainer: string;
+    /** Styles applied to the content of a section. */
+    sectionContent: string;
+    /** Styles applied to the separator before a section */
+    sectionBefore: string;
+    /** Styles applied to the separator after a section */
+    sectionAfter: string;
     /** Styles applied to the root if there is a startAdornment present */
     adornedStart: string;
     /** Styles applied to the root if there is an endAdornment present */

package/internals/components/PickersTextField/pickersTextFieldClasses.js

@@ -6,4 +6,4 @@ export const pickersTextFieldClasses = generateUtilityClasses('MuiPickersTextFie
 export function getPickersInputUtilityClass(slot) {
   return generateUtilityClass('MuiPickersInput', slot);
 }
-export const pickersInputClasses = generateUtilityClasses('MuiPickersInput', ['root', 'focused', 'disabled', 'error', 'notchedOutline', 'content', 'before', 'after', 'adornedStart', 'adornedEnd', 'input']);
+export const pickersInputClasses = generateUtilityClasses('MuiPickersInput', ['root', 'focused', 'disabled', 'error', 'notchedOutline', 'adornedStart', 'adornedEnd', 'input', 'sectionsContainer', 'sectionContent', 'sectionBefore', 'sectionAfter']);

package/internals/constants/dimensions.d.ts

@@ -2,6 +2,6 @@ export declare const DAY_SIZE = 36;
 export declare const DAY_MARGIN = 2;
 export declare const DIALOG_WIDTH = 320;
 export declare const MAX_CALENDAR_HEIGHT = 280;
-export declare const VIEW_HEIGHT = 334;
+export declare const VIEW_HEIGHT = 336;
 export declare const DIGITAL_CLOCK_VIEW_HEIGHT = 232;
 export declare const MULTI_SECTION_CLOCK_SECTION_WIDTH = 48;

package/internals/constants/dimensions.js

@@ -2,6 +2,6 @@ export const DAY_SIZE = 36;
 export const DAY_MARGIN = 2;
 export const DIALOG_WIDTH = 320;
 export const MAX_CALENDAR_HEIGHT = 280;
-export const VIEW_HEIGHT = 334;
+export const VIEW_HEIGHT = 336;
 export const DIGITAL_CLOCK_VIEW_HEIGHT = 232;
 export const MULTI_SECTION_CLOCK_SECTION_WIDTH = 48;