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

package/DateCalendar/PickersSlideTransition.mjs

@@ -0,0 +1,143 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["children", "className", "reduceAnimations", "slideDirection", "transKey", "classes"];
+import * as React from 'react';
+import clsx from 'clsx';
+import { styled, useTheme, useThemeProps } from '@mui/material/styles';
+import composeClasses from '@mui/utils/composeClasses';
+import { CSSTransition, TransitionGroup } from 'react-transition-group';
+import { getPickersSlideTransitionUtilityClass, pickersSlideTransitionClasses } from "./pickersSlideTransitionClasses.mjs";
+import { usePickerPrivateContext } from "../internals/hooks/usePickerPrivateContext.mjs";
+import { jsx as _jsx } from "react/jsx-runtime";
+const useUtilityClasses = (classes, ownerState) => {
+  const {
+    slideDirection
+  } = ownerState;
+  const slots = {
+    root: ['root'],
+    exit: ['slideExit'],
+    enterActive: ['slideEnterActive'],
+    enter: [`slideEnter-${slideDirection}`],
+    exitActive: [`slideExitActiveLeft-${slideDirection}`]
+  };
+  return composeClasses(slots, getPickersSlideTransitionUtilityClass, classes);
+};
+const PickersSlideTransitionRoot = styled(TransitionGroup, {
+  name: 'MuiPickersSlideTransition',
+  slot: 'Root',
+  overridesResolver: (_, styles) => [styles.root, {
+    [`.${pickersSlideTransitionClasses['slideEnter-left']}`]: styles['slideEnter-left']
+  }, {
+    [`.${pickersSlideTransitionClasses['slideEnter-right']}`]: styles['slideEnter-right']
+  }, {
+    [`.${pickersSlideTransitionClasses.slideEnterActive}`]: styles.slideEnterActive
+  }, {
+    [`.${pickersSlideTransitionClasses.slideExit}`]: styles.slideExit
+  }, {
+    [`.${pickersSlideTransitionClasses['slideExitActiveLeft-left']}`]: styles['slideExitActiveLeft-left']
+  }, {
+    [`.${pickersSlideTransitionClasses['slideExitActiveLeft-right']}`]: styles['slideExitActiveLeft-right']
+  }]
+})(({
+  theme
+}) => {
+  const slideTransition = theme.transitions.create('transform', {
+    duration: theme.transitions.duration.complex,
+    easing: 'cubic-bezier(0.35, 0.8, 0.4, 1)'
+  });
+  return {
+    display: 'block',
+    position: 'relative',
+    overflowX: 'hidden',
+    '& > *': {
+      position: 'absolute',
+      top: 0,
+      right: 0,
+      left: 0
+    },
+    [`& .${pickersSlideTransitionClasses['slideEnter-left']}`]: {
+      willChange: 'transform',
+      transform: 'translate(100%)',
+      zIndex: 1
+    },
+    [`& .${pickersSlideTransitionClasses['slideEnter-right']}`]: {
+      willChange: 'transform',
+      transform: 'translate(-100%)',
+      zIndex: 1
+    },
+    [`& .${pickersSlideTransitionClasses.slideEnterActive}`]: {
+      transform: 'translate(0%)',
+      transition: slideTransition
+    },
+    [`& .${pickersSlideTransitionClasses.slideExit}`]: {
+      transform: 'translate(0%)'
+    },
+    [`& .${pickersSlideTransitionClasses['slideExitActiveLeft-left']}`]: {
+      willChange: 'transform',
+      transform: 'translate(-100%)',
+      transition: slideTransition,
+      zIndex: 0
+    },
+    [`& .${pickersSlideTransitionClasses['slideExitActiveLeft-right']}`]: {
+      willChange: 'transform',
+      transform: 'translate(100%)',
+      transition: slideTransition,
+      zIndex: 0
+    }
+  };
+});
+
+/**
+ * @ignore - do not document.
+ */
+export function PickersSlideTransition(inProps) {
+  const props = useThemeProps({
+    props: inProps,
+    name: 'MuiPickersSlideTransition'
+  });
+  const {
+      children,
+      className,
+      reduceAnimations,
+      slideDirection,
+      transKey,
+      classes: classesProp
+    } = props,
+    other = _objectWithoutPropertiesLoose(props, _excluded);
+  const {
+    ownerState: pickerOwnerState
+  } = usePickerPrivateContext();
+  const ownerState = _extends({}, pickerOwnerState, {
+    slideDirection
+  });
+  const classes = useUtilityClasses(classesProp, ownerState);
+  const theme = useTheme();
+  if (reduceAnimations) {
+    return /*#__PURE__*/_jsx("div", {
+      className: clsx(classes.root, className),
+      children: children
+    });
+  }
+  const transitionClasses = {
+    exit: classes.exit,
+    enterActive: classes.enterActive,
+    enter: classes.enter,
+    exitActive: classes.exitActive
+  };
+  return /*#__PURE__*/_jsx(PickersSlideTransitionRoot, {
+    className: clsx(classes.root, className),
+    childFactory: element => /*#__PURE__*/React.cloneElement(element, {
+      classNames: transitionClasses
+    }),
+    role: "presentation",
+    ownerState: ownerState,
+    children: /*#__PURE__*/_jsx(CSSTransition, _extends({
+      mountOnEnter: true,
+      unmountOnExit: true,
+      timeout: theme.transitions.duration.complex,
+      classNames: transitionClasses
+    }, other, {
+      children: children
+    }), transKey)
+  });
+}

package/DateCalendar/index.d.mts

@@ -0,0 +1,12 @@
+export { DateCalendar } from "./DateCalendar.mjs";
+export type { DateCalendarProps, DateCalendarSlots, DateCalendarSlotProps } from "./DateCalendar.types.mjs";
+export { getDateCalendarUtilityClass, dateCalendarClasses } from "./dateCalendarClasses.mjs";
+export type { DateCalendarClassKey, DateCalendarClasses } from "./dateCalendarClasses.mjs";
+export { dayCalendarClasses } from "./dayCalendarClasses.mjs";
+export type { DayCalendarClassKey, DayCalendarClasses } from "./dayCalendarClasses.mjs";
+export type { PickersFadeTransitionGroupProps, ExportedPickersFadeTransitionGroupProps } from "./PickersFadeTransitionGroup.mjs";
+export { pickersFadeTransitionGroupClasses } from "./pickersFadeTransitionGroupClasses.mjs";
+export type { PickersFadeTransitionGroupClassKey, PickersFadeTransitionGroupClasses } from "./pickersFadeTransitionGroupClasses.mjs";
+export { pickersSlideTransitionClasses } from "./pickersSlideTransitionClasses.mjs";
+export type { PickersSlideTransitionClassKey, PickersSlideTransitionClasses } from "./pickersSlideTransitionClasses.mjs";
+export type { ExportedSlideTransitionProps } from "./PickersSlideTransition.mjs";

package/DateCalendar/index.mjs

@@ -0,0 +1,5 @@
+export { DateCalendar } from "./DateCalendar.mjs";
+export { getDateCalendarUtilityClass, dateCalendarClasses } from "./dateCalendarClasses.mjs";
+export { dayCalendarClasses } from "./dayCalendarClasses.mjs";
+export { pickersFadeTransitionGroupClasses } from "./pickersFadeTransitionGroupClasses.mjs";
+export { pickersSlideTransitionClasses } from "./pickersSlideTransitionClasses.mjs";

package/DateCalendar/useCalendarState.d.mts

@@ -0,0 +1,27 @@
+import { SlideDirection } from "./PickersSlideTransition.mjs";
+import { PickersTimezone, PickerValidDate } from "../models/index.mjs";
+import { DateCalendarDefaultizedProps } from "./DateCalendar.types.mjs";
+interface CalendarState {
+  currentMonth: PickerValidDate;
+  focusedDay: PickerValidDate | null;
+  isMonthSwitchingAnimating: boolean;
+  slideDirection: SlideDirection;
+}
+interface UseCalendarStateParameters extends Pick<DateCalendarDefaultizedProps, 'referenceDate' | 'disableFuture' | 'disablePast' | 'minDate' | 'maxDate' | 'onMonthChange' | 'onYearChange' | 'reduceAnimations' | 'shouldDisableDate'> {
+  value: PickerValidDate | null;
+  timezone: PickersTimezone;
+  getCurrentMonthFromVisibleDate: (focusedDay: PickerValidDate, prevMonth: PickerValidDate) => PickerValidDate;
+}
+interface UseCalendarStateReturnValue {
+  referenceDate: PickerValidDate;
+  calendarState: CalendarState;
+  setVisibleDate: (parameters: SetVisibleDateParameters) => void;
+  isDateDisabled: (day: PickerValidDate | null) => boolean;
+  onMonthSwitchingAnimationEnd: () => void;
+}
+export declare const useCalendarState: (params: UseCalendarStateParameters) => UseCalendarStateReturnValue;
+interface SetVisibleDateParameters {
+  target: PickerValidDate;
+  reason: 'header-navigation' | 'cell-interaction' | 'controlled-value-change';
+}
+export {};

package/DateCalendar/useCalendarState.js

@@ -43,7 +43,7 @@ const createCalendarStateReducer = (reduceAnimations, adapter) => (state, action
         isMonthSwitchingAnimating: false
       });
     default:
-      throw new Error('missing support');
+      throw /* minify-error-disabled */new Error('missing support');
   }
 };
 const useCalendarState = params => {

package/DateCalendar/useCalendarState.mjs

@@ -0,0 +1,160 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import useEventCallback from '@mui/utils/useEventCallback';
+import { useIsDateDisabled } from "./useIsDateDisabled.mjs";
+import { singleItemValueManager } from "../internals/utils/valueManagers.mjs";
+import { SECTION_TYPE_GRANULARITY } from "../internals/utils/getDefaultReferenceDate.mjs";
+import { findClosestEnabledDate } from "../internals/utils/date-utils.mjs";
+import { usePickerAdapter } from "../hooks/usePickerAdapter.mjs";
+const createCalendarStateReducer = (reduceAnimations, adapter) => (state, action) => {
+  switch (action.type) {
+    case 'setVisibleDate':
+      return _extends({}, state, {
+        slideDirection: action.direction,
+        currentMonth: action.month,
+        isMonthSwitchingAnimating: !adapter.isSameMonth(action.month, state.currentMonth) && !reduceAnimations && !action.skipAnimation,
+        focusedDay: action.focusedDay
+      });
+    case 'changeMonthTimezone':
+      {
+        const newTimezone = action.newTimezone;
+        if (adapter.getTimezone(state.currentMonth) === newTimezone) {
+          return state;
+        }
+        let newCurrentMonth = adapter.setTimezone(state.currentMonth, newTimezone);
+        if (adapter.getMonth(newCurrentMonth) !== adapter.getMonth(state.currentMonth)) {
+          newCurrentMonth = adapter.setMonth(newCurrentMonth, adapter.getMonth(state.currentMonth));
+        }
+        return _extends({}, state, {
+          currentMonth: newCurrentMonth
+        });
+      }
+    case 'finishMonthSwitchingAnimation':
+      return _extends({}, state, {
+        isMonthSwitchingAnimating: false
+      });
+    default:
+      throw /* minify-error-disabled */new Error('missing support');
+  }
+};
+export const useCalendarState = params => {
+  const {
+    value,
+    referenceDate: referenceDateProp,
+    disableFuture,
+    disablePast,
+    maxDate,
+    minDate,
+    onMonthChange,
+    onYearChange,
+    reduceAnimations,
+    shouldDisableDate,
+    timezone,
+    getCurrentMonthFromVisibleDate
+  } = params;
+  const adapter = usePickerAdapter();
+  const reducerFn = React.useRef(createCalendarStateReducer(Boolean(reduceAnimations), adapter)).current;
+  const referenceDate = React.useMemo(() => {
+    return singleItemValueManager.getInitialReferenceValue({
+      value,
+      adapter,
+      timezone,
+      props: params,
+      referenceDate: referenceDateProp,
+      granularity: SECTION_TYPE_GRANULARITY.day
+    });
+  },
+  // We want the `referenceDate` to update on prop and `timezone` change (https://github.com/mui/mui-x/issues/10804)
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  [referenceDateProp, timezone]);
+  const [calendarState, dispatch] = React.useReducer(reducerFn, {
+    isMonthSwitchingAnimating: false,
+    focusedDay: referenceDate,
+    // Keep the time from the reference date when computing the current month anchor.
+    // Using startOfMonth would reset the time to 00:00 which breaks expectations
+    // that month selections preserve the referenceDate time when no value is provided.
+    // See tests: "should use `referenceDate` when no value defined".
+    currentMonth: adapter.setDate(referenceDate, 1),
+    slideDirection: 'left'
+  });
+  const isDateDisabled = useIsDateDisabled({
+    shouldDisableDate,
+    minDate,
+    maxDate,
+    disableFuture,
+    disablePast,
+    timezone
+  });
+
+  // Ensure that `calendarState.currentMonth` timezone is updated when `referenceDate` (or timezone changes)
+  // https://github.com/mui/mui-x/issues/10804
+  React.useEffect(() => {
+    dispatch({
+      type: 'changeMonthTimezone',
+      newTimezone: adapter.getTimezone(referenceDate)
+    });
+  }, [referenceDate, adapter]);
+  const setVisibleDate = useEventCallback(({
+    target,
+    reason
+  }) => {
+    if (reason === 'cell-interaction' && calendarState.focusedDay != null && adapter.isSameDay(target, calendarState.focusedDay)) {
+      return;
+    }
+    const skipAnimation = reason === 'cell-interaction';
+    let month;
+    let focusedDay;
+    if (reason === 'cell-interaction') {
+      month = getCurrentMonthFromVisibleDate(target, calendarState.currentMonth);
+      focusedDay = target;
+    } else {
+      month = adapter.isSameMonth(target, calendarState.currentMonth) ? calendarState.currentMonth : adapter.startOfMonth(target);
+      focusedDay = target;
+
+      // If the date is disabled, we try to find a non-disabled date inside the same month.
+      if (isDateDisabled(focusedDay)) {
+        const startOfMonth = adapter.startOfMonth(target);
+        const endOfMonth = adapter.endOfMonth(target);
+        focusedDay = findClosestEnabledDate({
+          adapter,
+          date: focusedDay,
+          minDate: adapter.isBefore(minDate, startOfMonth) ? startOfMonth : minDate,
+          maxDate: adapter.isAfter(maxDate, endOfMonth) ? endOfMonth : maxDate,
+          disablePast,
+          disableFuture,
+          isDateDisabled,
+          timezone
+        });
+      }
+    }
+    const hasChangedMonth = !adapter.isSameMonth(calendarState.currentMonth, month);
+    const hasChangedYear = !adapter.isSameYear(calendarState.currentMonth, month);
+    if (hasChangedMonth) {
+      onMonthChange?.(month);
+    }
+    if (hasChangedYear) {
+      onYearChange?.(adapter.startOfYear(month));
+    }
+    dispatch({
+      type: 'setVisibleDate',
+      month,
+      direction: adapter.isAfterDay(month, calendarState.currentMonth) ? 'left' : 'right',
+      focusedDay: calendarState.focusedDay != null && focusedDay != null && adapter.isSameDay(focusedDay, calendarState.focusedDay) ? calendarState.focusedDay : focusedDay,
+      skipAnimation
+    });
+  });
+  const onMonthSwitchingAnimationEnd = React.useCallback(() => {
+    dispatch({
+      type: 'finishMonthSwitchingAnimation'
+    });
+  }, []);
+  return {
+    referenceDate,
+    calendarState,
+    setVisibleDate,
+    isDateDisabled,
+    onMonthSwitchingAnimationEnd
+  };
+};

package/DateCalendar/useIsDateDisabled.d.mts

@@ -0,0 +1,13 @@
+import { DefaultizedProps } from '@mui/x-internals/types';
+import { ValidateDateProps } from "../validation/index.mjs";
+import { PickerValidDate, TimezoneProps } from "../models/index.mjs";
+export declare const useIsDateDisabled: ({
+  shouldDisableDate,
+  shouldDisableMonth,
+  shouldDisableYear,
+  minDate,
+  maxDate,
+  disableFuture,
+  disablePast,
+  timezone
+}: ValidateDateProps & DefaultizedProps<TimezoneProps, "timezone">) => (day: PickerValidDate | null) => boolean;

package/DateCalendar/useIsDateDisabled.mjs

@@ -0,0 +1,31 @@
+'use client';
+
+import * as React from 'react';
+import { validateDate } from "../validation/index.mjs";
+import { usePickerAdapter } from "../hooks/usePickerAdapter.mjs";
+export const useIsDateDisabled = ({
+  shouldDisableDate,
+  shouldDisableMonth,
+  shouldDisableYear,
+  minDate,
+  maxDate,
+  disableFuture,
+  disablePast,
+  timezone
+}) => {
+  const adapter = usePickerAdapter();
+  return React.useCallback(day => validateDate({
+    adapter,
+    value: day,
+    timezone,
+    props: {
+      shouldDisableDate,
+      shouldDisableMonth,
+      shouldDisableYear,
+      minDate,
+      maxDate,
+      disableFuture,
+      disablePast
+    }
+  }) !== null, [adapter, shouldDisableDate, shouldDisableMonth, shouldDisableYear, minDate, maxDate, disableFuture, disablePast, timezone]);
+};

package/DateField/DateField.d.mts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { DateFieldProps } from "./DateField.types.mjs";
+type DateFieldComponent = (<TEnableAccessibleFieldDOMStructure extends boolean = true>(props: DateFieldProps<TEnableAccessibleFieldDOMStructure> & React.RefAttributes<HTMLDivElement>) => React.JSX.Element) & {
+  propTypes?: any;
+};
+/**
+ * Demos:
+ *
+ * - [DateField](http://mui.com/x/react-date-pickers/date-field/)
+ * - [Fields](https://mui.com/x/react-date-pickers/fields/)
+ *
+ * API:
+ *
+ * - [DateField API](https://mui.com/x/api/date-pickers/date-field/)
+ */
+declare const DateField: DateFieldComponent;
+export { DateField };