@mui/x-date-pickers 8.0.0-alpha.4 → 8.0.0-alpha.5

package/PickersTextField/PickersTextField.js

@@ -2,7 +2,7 @@
 
 import _extends from "@babel/runtime/helpers/esm/extends";
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-const _excluded = ["onFocus", "onBlur", "className", "color", "disabled", "error", "variant", "required", "InputProps", "inputProps", "inputRef", "sectionListRef", "elements", "areAllSectionsEmpty", "onClick", "onKeyDown", "onKeyUp", "onPaste", "onInput", "endAdornment", "startAdornment", "tabIndex", "contentEditable", "focused", "value", "onChange", "fullWidth", "id", "name", "helperText", "FormHelperTextProps", "label", "InputLabelProps"];
+const _excluded = ["onFocus", "onBlur", "className", "classes", "color", "disabled", "error", "variant", "required", "InputProps", "inputProps", "inputRef", "sectionListRef", "elements", "areAllSectionsEmpty", "onClick", "onKeyDown", "onKeyUp", "onPaste", "onInput", "endAdornment", "startAdornment", "tabIndex", "contentEditable", "focused", "value", "onChange", "fullWidth", "id", "name", "helperText", "FormHelperTextProps", "label", "InputLabelProps"];
 import * as React from 'react';
 import PropTypes from 'prop-types';
 import clsx from 'clsx';
@@ -18,6 +18,8 @@ import { getPickersTextFieldUtilityClass } from "./pickersTextFieldClasses.js";
 import { PickersOutlinedInput } from "./PickersOutlinedInput/index.js";
 import { PickersFilledInput } from "./PickersFilledInput/index.js";
 import { PickersInput } from "./PickersInput/index.js";
+import { useFieldOwnerState } from "../internals/hooks/useFieldOwnerState.js";
+import { PickerTextFieldOwnerStateContext } from "./usePickerTextFieldOwnerState.js";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 const VARIANT_COMPONENT = {
   standard: PickersInput,
@@ -29,15 +31,14 @@ const PickersTextFieldRoot = styled(FormControl, {
   slot: 'Root',
   overridesResolver: (props, styles) => styles.root
 })({});
-const useUtilityClasses = ownerState => {
+const useUtilityClasses = (classes, ownerState) => {
   const {
-    focused,
-    disabled,
-    classes,
-    required
+    isFieldFocused,
+    isFieldDisabled,
+    isFieldRequired
   } = ownerState;
   const slots = {
-    root: ['root', focused && !disabled && 'focused', disabled && 'disabled', required && 'required']
+    root: ['root', isFieldFocused && !isFieldDisabled && 'focused', isFieldDisabled && 'disabled', isFieldRequired && 'required']
   };
   return composeClasses(slots, getPickersTextFieldUtilityClass, classes);
 };
@@ -51,6 +52,7 @@ const PickersTextField = /*#__PURE__*/React.forwardRef(function PickersTextField
       onFocus,
       onBlur,
       className,
+      classes: classesProp,
       color = 'primary',
       disabled = false,
       error = false,
@@ -91,64 +93,75 @@ const PickersTextField = /*#__PURE__*/React.forwardRef(function PickersTextField
   const id = useId(idProp);
   const helperTextId = helperText && id ? `${id}-helper-text` : undefined;
   const inputLabelId = label && id ? `${id}-label` : undefined;
-  const ownerState = _extends({}, props, {
-    color,
-    disabled,
-    error,
-    focused,
-    required,
-    variant
+  const fieldOwnerState = useFieldOwnerState({
+    disabled: props.disabled,
+    required: props.required,
+    readOnly: InputProps?.readOnly
   });
-  const classes = useUtilityClasses(ownerState);
+  const ownerState = React.useMemo(() => _extends({}, fieldOwnerState, {
+    isFieldValueEmpty: areAllSectionsEmpty,
+    isFieldFocused: focused ?? false,
+    hasFieldError: error ?? false,
+    inputSize: props.size ?? 'medium',
+    inputColor: color ?? 'primary',
+    isInputInFullWidth: fullWidth ?? false,
+    hasStartAdornment: Boolean(startAdornment ?? InputProps?.startAdornment),
+    hasEndAdornment: Boolean(endAdornment ?? InputProps?.endAdornment),
+    inputHasLabel: !!label
+  }), [fieldOwnerState, areAllSectionsEmpty, focused, error, props.size, color, fullWidth, startAdornment, endAdornment, InputProps?.startAdornment, InputProps?.endAdornment, label]);
+  const classes = useUtilityClasses(classesProp, ownerState);
   const PickersInputComponent = VARIANT_COMPONENT[variant];
-  return /*#__PURE__*/_jsxs(PickersTextFieldRoot, _extends({
-    className: clsx(classes.root, className),
-    ref: handleRootRef,
-    focused: focused,
-    disabled: disabled,
-    variant: variant,
-    error: error,
-    color: color,
-    fullWidth: fullWidth,
-    required: required,
-    ownerState: ownerState
-  }, other, {
-    children: [/*#__PURE__*/_jsx(InputLabel, _extends({
-      htmlFor: id,
-      id: inputLabelId
-    }, InputLabelProps, {
-      children: label
-    })), /*#__PURE__*/_jsx(PickersInputComponent, _extends({
-      elements: elements,
-      areAllSectionsEmpty: areAllSectionsEmpty,
-      onClick: onClick,
-      onKeyDown: onKeyDown,
-      onKeyUp: onKeyUp,
-      onInput: onInput,
-      onPaste: onPaste,
-      onFocus: onFocus,
-      onBlur: onBlur,
-      endAdornment: endAdornment,
-      startAdornment: startAdornment,
-      tabIndex: tabIndex,
-      contentEditable: contentEditable,
-      value: value,
-      onChange: onChange,
-      id: id,
+  return /*#__PURE__*/_jsx(PickerTextFieldOwnerStateContext.Provider, {
+    value: ownerState,
+    children: /*#__PURE__*/_jsxs(PickersTextFieldRoot, _extends({
+      className: clsx(classes.root, className),
+      ref: handleRootRef,
+      focused: focused,
+      disabled: disabled,
+      variant: variant,
+      error: error,
+      color: color,
       fullWidth: fullWidth,
-      inputProps: inputProps,
-      inputRef: inputRef,
-      sectionListRef: sectionListRef,
-      label: label,
-      name: name,
-      role: "group",
-      "aria-labelledby": inputLabelId
-    }, InputProps)), helperText && /*#__PURE__*/_jsx(FormHelperText, _extends({
-      id: helperTextId
-    }, FormHelperTextProps, {
-      children: helperText
-    }))]
-  }));
+      required: required,
+      ownerState: ownerState
+    }, other, {
+      children: [/*#__PURE__*/_jsx(InputLabel, _extends({
+        htmlFor: id,
+        id: inputLabelId
+      }, InputLabelProps, {
+        children: label
+      })), /*#__PURE__*/_jsx(PickersInputComponent, _extends({
+        elements: elements,
+        areAllSectionsEmpty: areAllSectionsEmpty,
+        onClick: onClick,
+        onKeyDown: onKeyDown,
+        onKeyUp: onKeyUp,
+        onInput: onInput,
+        onPaste: onPaste,
+        onFocus: onFocus,
+        onBlur: onBlur,
+        endAdornment: endAdornment,
+        startAdornment: startAdornment,
+        tabIndex: tabIndex,
+        contentEditable: contentEditable,
+        value: value,
+        onChange: onChange,
+        id: id,
+        fullWidth: fullWidth,
+        inputProps: inputProps,
+        inputRef: inputRef,
+        sectionListRef: sectionListRef,
+        label: label,
+        name: name,
+        role: "group",
+        "aria-labelledby": inputLabelId
+      }, InputProps)), helperText && /*#__PURE__*/_jsx(FormHelperText, _extends({
+        id: helperTextId
+      }, FormHelperTextProps, {
+        children: helperText
+      }))]
+    }))
+  });
 });
 process.env.NODE_ENV !== "production" ? PickersTextField.propTypes = {
   // ----------------------------- Warning --------------------------------

package/PickersTextField/PickersTextField.types.d.ts

@@ -1,12 +1,13 @@
 import * as React from 'react';
-import { FormControlProps } from '@mui/material/FormControl';
+import { FormControlOwnProps, FormControlProps } from '@mui/material/FormControl';
 import { FormHelperTextProps } from '@mui/material/FormHelperText';
 import { InputLabelProps } from '@mui/material/InputLabel';
 import { TextFieldVariants } from '@mui/material/TextField';
 import { PickersInputPropsUsedByField } from './PickersInputBase/PickersInputBase.types';
-import { PickersInputProps } from './PickersInput';
-import { PickersOutlinedInputProps } from './PickersOutlinedInput';
-import { PickersFilledInputProps } from './PickersFilledInput';
+import type { PickersInputProps } from './PickersInput';
+import type { PickersOutlinedInputProps } from './PickersOutlinedInput';
+import type { PickersFilledInputProps } from './PickersFilledInput';
+import { FieldOwnerState } from '../models';
 interface PickersTextFieldPropsUsedByField {
     onFocus: React.FocusEventHandler<HTMLDivElement>;
     onBlur: React.FocusEventHandler<HTMLDivElement>;
@@ -64,4 +65,42 @@ export interface PickersFilledTextFieldProps extends PickersBaseTextFieldProps {
     InputProps?: Partial<PickersFilledInputProps>;
 }
 export type PickersTextFieldProps<Variant extends TextFieldVariants = TextFieldVariants> = Variant extends 'filled' ? PickersFilledTextFieldProps : Variant extends 'standard' ? PickersStandardTextFieldProps : PickersOutlinedTextFieldProps;
+export interface PickerTextFieldOwnerState extends FieldOwnerState {
+    /**
+     * `true` if the value of the field is currently empty.
+     */
+    isFieldValueEmpty: boolean;
+    /**
+     * `true` if the field is focused, `false` otherwise.
+     */
+    isFieldFocused: boolean;
+    /**
+     * `true` if the field has an error, `false` otherwise.
+     */
+    hasFieldError: boolean;
+    /**
+     * The size of the input.
+     */
+    inputSize: Exclude<FormControlOwnProps['size'], undefined>;
+    /**
+     * The color of the input.
+     */
+    inputColor: Exclude<FormControlOwnProps['color'], undefined>;
+    /**
+     * `true` if the input takes up the full width of its container.
+     */
+    isInputInFullWidth: boolean;
+    /**
+     * `true` if the input has a start adornment, `false` otherwise.
+     */
+    hasStartAdornment: boolean;
+    /**
+     * `true` if the input has an end adornment, `false` otherwise.
+     */
+    hasEndAdornment: boolean;
+    /**
+     * `true` if the input has a label, `false` otherwise.
+     */
+    inputHasLabel: boolean;
+}
 export {};

package/PickersTextField/usePickerTextFieldOwnerState.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import { PickerTextFieldOwnerState } from './PickersTextField.types';
+export declare const PickerTextFieldOwnerStateContext: React.Context<PickerTextFieldOwnerState | null>;
+export declare const usePickerTextFieldOwnerState: () => PickerTextFieldOwnerState;

package/PickersTextField/usePickerTextFieldOwnerState.js

@@ -0,0 +1,11 @@
+'use client';
+
+import * as React from 'react';
+export const PickerTextFieldOwnerStateContext = /*#__PURE__*/React.createContext(null);
+export const usePickerTextFieldOwnerState = () => {
+  const value = React.useContext(PickerTextFieldOwnerStateContext);
+  if (value == null) {
+    throw new Error(['MUI X: The `usePickerTextFieldOwnerState` can only be called in components that are used inside a PickerTextField component'].join('\n'));
+  }
+  return value;
+};

package/TimeClock/Clock.d.ts

@@ -26,6 +26,10 @@ export interface ClockProps extends ReturnType<typeof useMeridiemMode>, FormProp
      * The current full date value.
      */
     value: PickerValidDate | null;
+    /**
+     * Minimum and maximum value of the clock.
+     */
+    viewRange: [number, number];
     className?: string;
     classes?: Partial<ClockClasses>;
 }

package/TimeClock/Clock.js

@@ -177,6 +177,7 @@ export function Clock(inProps) {
     selectedId,
     type,
     viewValue,
+    viewRange: [minViewValue, maxViewValue],
     disabled = false,
     readOnly,
     className,
@@ -251,6 +252,8 @@ export function Clock(inProps) {
       listboxRef.current.focus();
     }
   }, [autoFocus]);
+  const clampValue = newValue => Math.max(minViewValue, Math.min(maxViewValue, newValue));
+  const circleValue = newValue => (newValue + (maxViewValue + 1)) % (maxViewValue + 1);
   const handleKeyDown = event => {
     // TODO: Why this early exit?
     if (isMoving.current) {
@@ -259,27 +262,27 @@ export function Clock(inProps) {
     switch (event.key) {
       case 'Home':
         // reset both hours and minutes
-        handleValueChange(0, 'partial');
+        handleValueChange(minViewValue, 'partial');
         event.preventDefault();
         break;
       case 'End':
-        handleValueChange(type === 'minutes' ? 59 : 23, 'partial');
+        handleValueChange(maxViewValue, 'partial');
         event.preventDefault();
         break;
       case 'ArrowUp':
-        handleValueChange(viewValue + keyboardControlStep, 'partial');
+        handleValueChange(circleValue(viewValue + keyboardControlStep), 'partial');
         event.preventDefault();
         break;
       case 'ArrowDown':
-        handleValueChange(viewValue - keyboardControlStep, 'partial');
+        handleValueChange(circleValue(viewValue - keyboardControlStep), 'partial');
         event.preventDefault();
         break;
       case 'PageUp':
-        handleValueChange(viewValue + 5, 'partial');
+        handleValueChange(clampValue(viewValue + 5), 'partial');
         event.preventDefault();
         break;
       case 'PageDown':
-        handleValueChange(viewValue - 5, 'partial');
+        handleValueChange(clampValue(viewValue - 5), 'partial');
         event.preventDefault();
         break;
       case 'Enter':

package/TimeClock/TimeClock.js

@@ -186,6 +186,9 @@ export const TimeClock = /*#__PURE__*/React.forwardRef(function TimeClock(inProp
         {
           const valueWithMeridiem = convertValueToMeridiem(rawValue, meridiemMode, ampm);
           const dateWithNewHours = utils.setHours(valueOrReferenceDate, valueWithMeridiem);
+          if (utils.getHours(dateWithNewHours) !== valueWithMeridiem) {
+            return true;
+          }
           const start = utils.setSeconds(utils.setMinutes(dateWithNewHours, 0), 0);
           const end = utils.setSeconds(utils.setMinutes(dateWithNewHours, 59), 59);
           return !containsValidTime({
@@ -225,9 +228,20 @@ export const TimeClock = /*#__PURE__*/React.forwardRef(function TimeClock(inProp
             const valueWithMeridiem = convertValueToMeridiem(hourValue, meridiemMode, ampm);
             setValueAndGoToNextView(utils.setHours(valueOrReferenceDate, valueWithMeridiem), isFinish, 'hours');
           };
+          const viewValue = utils.getHours(valueOrReferenceDate);
+          let viewRange;
+          if (ampm) {
+            if (viewValue > 12) {
+              viewRange = [12, 23];
+            } else {
+              viewRange = [0, 11];
+            }
+          } else {
+            viewRange = [0, 23];
+          }
           return {
             onChange: handleHoursChange,
-            viewValue: utils.getHours(valueOrReferenceDate),
+            viewValue,
             children: getHourNumbers({
               value,
               utils,
@@ -236,7 +250,8 @@ export const TimeClock = /*#__PURE__*/React.forwardRef(function TimeClock(inProp
               getClockNumberText: translations.hoursClockNumberText,
               isDisabled: hourValue => disabled || isTimeDisabled(hourValue, 'hours'),
               selectedId
-            })
+            }),
+            viewRange
           };
         }
       case 'minutes':
@@ -255,7 +270,8 @@ export const TimeClock = /*#__PURE__*/React.forwardRef(function TimeClock(inProp
               getClockNumberText: translations.minutesClockNumberText,
               isDisabled: minuteValue => disabled || isTimeDisabled(minuteValue, 'minutes'),
               selectedId
-            })
+            }),
+            viewRange: [0, 59]
           };
         }
       case 'seconds':
@@ -274,7 +290,8 @@ export const TimeClock = /*#__PURE__*/React.forwardRef(function TimeClock(inProp
               getClockNumberText: translations.secondsClockNumberText,
               isDisabled: secondValue => disabled || isTimeDisabled(secondValue, 'seconds'),
               selectedId
-            })
+            }),
+            viewRange: [0, 59]
           };
         }
       default:

package/YearCalendar/YearCalendar.js

@@ -7,9 +7,10 @@ import * as React from 'react';
 import PropTypes from 'prop-types';
 import clsx from 'clsx';
 import { useRtl } from '@mui/system/RtlProvider';
+import { shouldForwardProp } from '@mui/system/createStyled';
 import { styled, useThemeProps } from '@mui/material/styles';
 import { unstable_useForkRef as useForkRef, unstable_composeClasses as composeClasses, unstable_useControlled as useControlled, unstable_useEventCallback as useEventCallback } from '@mui/utils';
-import { PickersYear } from "./PickersYear.js";
+import { YearCalendarButton } from "./YearCalendarButton.js";
 import { useUtils, useNow, useDefaultDates } from "../internals/hooks/useUtils.js";
 import { getYearCalendarUtilityClass } from "./yearCalendarClasses.js";
 import { applyDefaultDate } from "../internals/utils/date-utils.js";
@@ -18,7 +19,7 @@ import { SECTION_TYPE_GRANULARITY } from "../internals/utils/getDefaultReference
 import { useControlledValueWithTimezone } from "../internals/hooks/useValueWithTimezone.js";
 import { DIALOG_WIDTH, MAX_CALENDAR_HEIGHT } from "../internals/constants/dimensions.js";
 import { usePickerPrivateContext } from "../internals/hooks/usePickerPrivateContext.js";
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 const useUtilityClasses = classes => {
   const slots = {
     root: ['root']
@@ -37,6 +38,7 @@ function useYearCalendarDefaultizedProps(props, name) {
     disableFuture: false
   }, themeProps, {
     yearsPerRow: themeProps.yearsPerRow ?? 3,
+    yearsOrder: themeProps.yearsOrder ?? 'asc',
     minDate: applyDefaultDate(utils, themeProps.minDate, defaultDates.minDate),
     maxDate: applyDefaultDate(utils, themeProps.maxDate, defaultDates.maxDate)
   });
@@ -44,19 +46,43 @@ function useYearCalendarDefaultizedProps(props, name) {
 const YearCalendarRoot = styled('div', {
   name: 'MuiYearCalendar',
   slot: 'Root',
-  overridesResolver: (props, styles) => styles.root
+  shouldForwardProp: prop => shouldForwardProp(prop) && prop !== 'yearsPerRow'
 })({
   display: 'flex',
-  flexDirection: 'row',
   flexWrap: 'wrap',
+  justifyContent: 'space-evenly',
+  rowGap: 12,
+  padding: '6px 0',
   overflowY: 'auto',
   height: '100%',
-  padding: '0 4px',
   width: DIALOG_WIDTH,
   maxHeight: MAX_CALENDAR_HEIGHT,
   // avoid padding increasing width over defined
   boxSizing: 'border-box',
-  position: 'relative'
+  position: 'relative',
+  variants: [{
+    props: {
+      yearsPerRow: 3
+    },
+    style: {
+      columnGap: 24
+    }
+  }, {
+    props: {
+      yearsPerRow: 4
+    },
+    style: {
+      columnGap: 0,
+      padding: '0 2px'
+    }
+  }]
+});
+const YearCalendarButtonFiller = styled('div', {
+  name: 'MuiYearCalendar',
+  slot: 'ButtonFiller'
+})({
+  height: 36,
+  width: 72
 });
 /**
  * Demos:
@@ -87,7 +113,7 @@ export const YearCalendar = /*#__PURE__*/React.forwardRef(function YearCalendar(
       onYearFocus,
       hasFocus,
       onFocusedViewChange,
-      yearsOrder = 'asc',
+      yearsOrder,
       yearsPerRow,
       timezone: timezoneProp,
       gridLabelId,
@@ -239,18 +265,23 @@ export const YearCalendar = /*#__PURE__*/React.forwardRef(function YearCalendar(
   if (yearsOrder === 'desc') {
     yearRange.reverse();
   }
-  return /*#__PURE__*/_jsx(YearCalendarRoot, _extends({
+  let fillerAmount = yearsPerRow - yearRange.length % yearsPerRow;
+  if (fillerAmount === yearsPerRow) {
+    fillerAmount = 0;
+  }
+  return /*#__PURE__*/_jsxs(YearCalendarRoot, _extends({
     ref: handleRef,
     className: clsx(classes.root, className),
     ownerState: ownerState,
     role: "radiogroup",
-    "aria-labelledby": gridLabelId
+    "aria-labelledby": gridLabelId,
+    yearsPerRow: yearsPerRow
   }, other, {
-    children: yearRange.map(year => {
+    children: [yearRange.map(year => {
       const yearNumber = utils.getYear(year);
       const isSelected = yearNumber === selectedYear;
       const isDisabled = disabled || isYearDisabled(year);
-      return /*#__PURE__*/_jsx(PickersYear, {
+      return /*#__PURE__*/_jsx(YearCalendarButton, {
         selected: isSelected,
         value: yearNumber,
         onClick: handleYearSelection,
@@ -261,12 +292,14 @@ export const YearCalendar = /*#__PURE__*/React.forwardRef(function YearCalendar(
         onFocus: handleYearFocus,
         onBlur: handleYearBlur,
         "aria-current": todayYear === yearNumber ? 'date' : undefined,
-        yearsPerRow: yearsPerRow,
         slots: slots,
         slotProps: slotProps,
+        classes: classesProp,
         children: utils.format(year, 'year')
       }, utils.format(year, 'year'));
-    })
+    }), Array.from({
+      length: fillerAmount
+    }, (_, index) => /*#__PURE__*/_jsx(YearCalendarButtonFiller, {}, index))]
   }));
 });
 process.env.NODE_ENV !== "production" ? YearCalendar.propTypes = {

package/YearCalendar/YearCalendar.types.d.ts

@@ -6,7 +6,7 @@ import { YearCalendarClasses } from './yearCalendarClasses';
 import { BaseDateValidationProps, YearValidationProps } from '../internals/models/validation';
 import { PickerOwnerState, PickerValidDate, TimezoneProps } from '../models';
 import { FormProps } from '../internals/models/formProps';
-export interface PickerYearOwnerState extends PickerOwnerState {
+export interface YearButtonOwnerState extends PickerOwnerState {
     isYearSelected: boolean;
     isYearDisabled: boolean;
 }
@@ -20,7 +20,7 @@ export interface YearCalendarSlots {
 export interface YearCalendarSlotProps {
     yearButton?: SlotComponentPropsFromProps<React.HTMLAttributes<HTMLButtonElement> & {
         sx: SxProps;
-    }, {}, PickerYearOwnerState>;
+    }, {}, YearButtonOwnerState>;
 }
 export interface ExportedYearCalendarProps {
     /**

package/YearCalendar/YearCalendarButton.d.ts

@@ -0,0 +1,23 @@
+import * as React from 'react';
+import { YearCalendarSlotProps, YearCalendarSlots } from './YearCalendar.types';
+import { YearCalendarClasses } from './yearCalendarClasses';
+export interface YearCalendarButtonProps {
+    value: number;
+    tabIndex: number;
+    selected: boolean;
+    disabled: boolean;
+    autoFocus: boolean;
+    classes: Partial<YearCalendarClasses> | undefined;
+    slots: YearCalendarSlots | undefined;
+    slotProps: YearCalendarSlotProps | undefined;
+    'aria-current': React.AriaAttributes['aria-current'];
+    children: React.ReactNode;
+    onClick: (event: React.MouseEvent, year: number) => void;
+    onKeyDown: (event: React.KeyboardEvent, year: number) => void;
+    onFocus: (event: React.FocusEvent, year: number) => void;
+    onBlur: (event: React.FocusEvent, year: number) => void;
+}
+/**
+ * @ignore - internal component.
+ */
+export declare const YearCalendarButton: React.NamedExoticComponent<YearCalendarButtonProps>;