@mui/x-date-pickers 7.0.0-beta.2 → 7.0.0-beta.4

package/legacy/YearCalendar/PickersYear.js

@@ -1,137 +0,0 @@
-import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
-import _extends from "@babel/runtime/helpers/esm/extends";
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-var _excluded = ["autoFocus", "className", "children", "disabled", "selected", "value", "tabIndex", "onClick", "onKeyDown", "onFocus", "onBlur", "aria-current", "yearsPerRow"];
-import * as React from 'react';
-import clsx from 'clsx';
-import { unstable_composeClasses as composeClasses } from '@mui/utils';
-import { alpha, styled, useThemeProps } from '@mui/material/styles';
-import { getPickersYearUtilityClass, pickersYearClasses } from './pickersYearClasses';
-import { jsx as _jsx } from "react/jsx-runtime";
-var useUtilityClasses = function useUtilityClasses(ownerState) {
-  var disabled = ownerState.disabled,
-    selected = ownerState.selected,
-    classes = ownerState.classes;
-  var slots = {
-    root: ['root'],
-    yearButton: ['yearButton', disabled && 'disabled', selected && 'selected']
-  };
-  return composeClasses(slots, getPickersYearUtilityClass, classes);
-};
-var PickersYearRoot = styled('div', {
-  name: 'MuiPickersYear',
-  slot: 'Root',
-  overridesResolver: function overridesResolver(_, styles) {
-    return [styles.root];
-  }
-})(function (_ref) {
-  var ownerState = _ref.ownerState;
-  return {
-    flexBasis: ownerState.yearsPerRow === 3 ? '33.3%' : '25%',
-    display: 'flex',
-    alignItems: 'center',
-    justifyContent: 'center'
-  };
-});
-var PickersYearButton = styled('button', {
-  name: 'MuiPickersYear',
-  slot: 'YearButton',
-  overridesResolver: function overridesResolver(_, styles) {
-    return [styles.yearButton, _defineProperty({}, "&.".concat(pickersYearClasses.disabled), styles.disabled), _defineProperty({}, "&.".concat(pickersYearClasses.selected), styles.selected)];
-  }
-})(function (_ref4) {
-  var theme = _ref4.theme;
-  return _extends({
-    color: 'unset',
-    backgroundColor: 'transparent',
-    border: 0,
-    outline: 0
-  }, theme.typography.subtitle1, _defineProperty(_defineProperty({
-    margin: '6px 0',
-    height: 36,
-    width: 72,
-    borderRadius: 18,
-    cursor: 'pointer',
-    '&:focus': {
-      backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette.action.activeChannel, " / ").concat(theme.vars.palette.action.focusOpacity, ")") : alpha(theme.palette.action.active, theme.palette.action.focusOpacity)
-    },
-    '&:hover': {
-      backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette.action.activeChannel, " / ").concat(theme.vars.palette.action.hoverOpacity, ")") : alpha(theme.palette.action.active, theme.palette.action.hoverOpacity)
-    },
-    '&:disabled': {
-      cursor: 'auto',
-      pointerEvents: 'none'
-    }
-  }, "&.".concat(pickersYearClasses.disabled), {
-    color: (theme.vars || theme).palette.text.secondary
-  }), "&.".concat(pickersYearClasses.selected), {
-    color: (theme.vars || theme).palette.primary.contrastText,
-    backgroundColor: (theme.vars || theme).palette.primary.main,
-    '&:focus, &:hover': {
-      backgroundColor: (theme.vars || theme).palette.primary.dark
-    }
-  }));
-});
-
-/**
- * @ignore - internal component.
- */
-export var PickersYear = /*#__PURE__*/React.memo(function PickersYear(inProps) {
-  var props = useThemeProps({
-    props: inProps,
-    name: 'MuiPickersYear'
-  });
-  var autoFocus = props.autoFocus,
-    className = props.className,
-    children = props.children,
-    disabled = props.disabled,
-    selected = props.selected,
-    value = props.value,
-    tabIndex = props.tabIndex,
-    _onClick = props.onClick,
-    _onKeyDown = props.onKeyDown,
-    _onFocus = props.onFocus,
-    _onBlur = props.onBlur,
-    ariaCurrent = props['aria-current'],
-    yearsPerRow = props.yearsPerRow,
-    other = _objectWithoutProperties(props, _excluded);
-  var ref = React.useRef(null);
-  var classes = useUtilityClasses(props);
-
-  // We can't forward the `autoFocus` to the button because it is a native button, not a MUI Button
-  React.useEffect(function () {
-    if (autoFocus) {
-      // `ref.current` being `null` would be a bug in MUI.
-      ref.current.focus();
-    }
-  }, [autoFocus]);
-  return /*#__PURE__*/_jsx(PickersYearRoot, _extends({
-    className: clsx(classes.root, className),
-    ownerState: props
-  }, other, {
-    children: /*#__PURE__*/_jsx(PickersYearButton, {
-      ref: ref,
-      disabled: disabled,
-      type: "button",
-      role: "radio",
-      tabIndex: disabled ? -1 : tabIndex,
-      "aria-current": ariaCurrent,
-      "aria-checked": selected,
-      onClick: function onClick(event) {
-        return _onClick(event, value);
-      },
-      onKeyDown: function onKeyDown(event) {
-        return _onKeyDown(event, value);
-      },
-      onFocus: function onFocus(event) {
-        return _onFocus(event, value);
-      },
-      onBlur: function onBlur(event) {
-        return _onBlur(event, value);
-      },
-      className: classes.yearButton,
-      ownerState: props,
-      children: children
-    })
-  }));
-});

package/legacy/YearCalendar/YearCalendar.js

@@ -1,362 +0,0 @@
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
-import _extends from "@babel/runtime/helpers/esm/extends";
-var _excluded = ["autoFocus", "className", "value", "defaultValue", "referenceDate", "disabled", "disableFuture", "disablePast", "maxDate", "minDate", "onChange", "readOnly", "shouldDisableYear", "disableHighlightToday", "onYearFocus", "hasFocus", "onFocusedViewChange", "yearsPerRow", "timezone", "gridLabelId"];
-import * as React from 'react';
-import PropTypes from 'prop-types';
-import clsx from 'clsx';
-import { useTheme } from '@mui/system';
-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';
-import { useUtils, useNow, useDefaultDates } from '../internals/hooks/useUtils';
-import { getYearCalendarUtilityClass } from './yearCalendarClasses';
-import { applyDefaultDate } from '../internals/utils/date-utils';
-import { singleItemValueManager } from '../internals/utils/valueManagers';
-import { SECTION_TYPE_GRANULARITY } from '../internals/utils/getDefaultReferenceDate';
-import { useControlledValueWithTimezone } from '../internals/hooks/useValueWithTimezone';
-import { DIALOG_WIDTH, MAX_CALENDAR_HEIGHT } from '../internals/constants/dimensions';
-import { jsx as _jsx } from "react/jsx-runtime";
-var useUtilityClasses = function useUtilityClasses(ownerState) {
-  var classes = ownerState.classes;
-  var slots = {
-    root: ['root']
-  };
-  return composeClasses(slots, getYearCalendarUtilityClass, classes);
-};
-function useYearCalendarDefaultizedProps(props, name) {
-  var _themeProps$yearsPerR;
-  var utils = useUtils();
-  var defaultDates = useDefaultDates();
-  var themeProps = useThemeProps({
-    props: props,
-    name: name
-  });
-  return _extends({
-    disablePast: false,
-    disableFuture: false
-  }, themeProps, {
-    yearsPerRow: (_themeProps$yearsPerR = themeProps.yearsPerRow) != null ? _themeProps$yearsPerR : 3,
-    minDate: applyDefaultDate(utils, themeProps.minDate, defaultDates.minDate),
-    maxDate: applyDefaultDate(utils, themeProps.maxDate, defaultDates.maxDate)
-  });
-}
-var YearCalendarRoot = styled('div', {
-  name: 'MuiYearCalendar',
-  slot: 'Root',
-  overridesResolver: function overridesResolver(props, styles) {
-    return styles.root;
-  }
-})({
-  display: 'flex',
-  flexDirection: 'row',
-  flexWrap: 'wrap',
-  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'
-});
-/**
- * Demos:
- *
- * - [DateCalendar](https://mui.com/x/react-date-pickers/date-calendar/)
- *
- * API:
- *
- * - [YearCalendar API](https://mui.com/x/api/date-pickers/year-calendar/)
- */
-export var YearCalendar = /*#__PURE__*/React.forwardRef(function YearCalendar(inProps, ref) {
-  var props = useYearCalendarDefaultizedProps(inProps, 'MuiYearCalendar');
-  var autoFocus = props.autoFocus,
-    className = props.className,
-    valueProp = props.value,
-    defaultValue = props.defaultValue,
-    referenceDateProp = props.referenceDate,
-    disabled = props.disabled,
-    disableFuture = props.disableFuture,
-    disablePast = props.disablePast,
-    maxDate = props.maxDate,
-    minDate = props.minDate,
-    onChange = props.onChange,
-    readOnly = props.readOnly,
-    shouldDisableYear = props.shouldDisableYear,
-    disableHighlightToday = props.disableHighlightToday,
-    onYearFocus = props.onYearFocus,
-    hasFocus = props.hasFocus,
-    onFocusedViewChange = props.onFocusedViewChange,
-    yearsPerRow = props.yearsPerRow,
-    timezoneProp = props.timezone,
-    gridLabelId = props.gridLabelId,
-    other = _objectWithoutProperties(props, _excluded);
-  var _useControlledValueWi = useControlledValueWithTimezone({
-      name: 'YearCalendar',
-      timezone: timezoneProp,
-      value: valueProp,
-      defaultValue: defaultValue,
-      onChange: onChange,
-      valueManager: singleItemValueManager
-    }),
-    value = _useControlledValueWi.value,
-    handleValueChange = _useControlledValueWi.handleValueChange,
-    timezone = _useControlledValueWi.timezone;
-  var now = useNow(timezone);
-  var theme = useTheme();
-  var utils = useUtils();
-  var referenceDate = React.useMemo(function () {
-    return singleItemValueManager.getInitialReferenceValue({
-      value: value,
-      utils: utils,
-      props: props,
-      timezone: timezone,
-      referenceDate: referenceDateProp,
-      granularity: SECTION_TYPE_GRANULARITY.year
-    });
-  }, [] // eslint-disable-line react-hooks/exhaustive-deps
-  );
-  var ownerState = props;
-  var classes = useUtilityClasses(ownerState);
-  var todayYear = React.useMemo(function () {
-    return utils.getYear(now);
-  }, [utils, now]);
-  var selectedYear = React.useMemo(function () {
-    if (value != null) {
-      return utils.getYear(value);
-    }
-    return null;
-  }, [value, utils]);
-  var _React$useState = React.useState(function () {
-      return selectedYear || utils.getYear(referenceDate);
-    }),
-    _React$useState2 = _slicedToArray(_React$useState, 2),
-    focusedYear = _React$useState2[0],
-    setFocusedYear = _React$useState2[1];
-  var _useControlled = useControlled({
-      name: 'YearCalendar',
-      state: 'hasFocus',
-      controlled: hasFocus,
-      default: autoFocus != null ? autoFocus : false
-    }),
-    _useControlled2 = _slicedToArray(_useControlled, 2),
-    internalHasFocus = _useControlled2[0],
-    setInternalHasFocus = _useControlled2[1];
-  var changeHasFocus = useEventCallback(function (newHasFocus) {
-    setInternalHasFocus(newHasFocus);
-    if (onFocusedViewChange) {
-      onFocusedViewChange(newHasFocus);
-    }
-  });
-  var isYearDisabled = React.useCallback(function (dateToValidate) {
-    if (disablePast && utils.isBeforeYear(dateToValidate, now)) {
-      return true;
-    }
-    if (disableFuture && utils.isAfterYear(dateToValidate, now)) {
-      return true;
-    }
-    if (minDate && utils.isBeforeYear(dateToValidate, minDate)) {
-      return true;
-    }
-    if (maxDate && utils.isAfterYear(dateToValidate, maxDate)) {
-      return true;
-    }
-    if (!shouldDisableYear) {
-      return false;
-    }
-    var yearToValidate = utils.startOfYear(dateToValidate);
-    return shouldDisableYear(yearToValidate);
-  }, [disableFuture, disablePast, maxDate, minDate, now, shouldDisableYear, utils]);
-  var handleYearSelection = useEventCallback(function (event, year) {
-    if (readOnly) {
-      return;
-    }
-    var newDate = utils.setYear(value != null ? value : referenceDate, year);
-    handleValueChange(newDate);
-  });
-  var focusYear = useEventCallback(function (year) {
-    if (!isYearDisabled(utils.setYear(value != null ? value : referenceDate, year))) {
-      setFocusedYear(year);
-      changeHasFocus(true);
-      onYearFocus == null || onYearFocus(year);
-    }
-  });
-  React.useEffect(function () {
-    setFocusedYear(function (prevFocusedYear) {
-      return selectedYear !== null && prevFocusedYear !== selectedYear ? selectedYear : prevFocusedYear;
-    });
-  }, [selectedYear]);
-  var handleKeyDown = useEventCallback(function (event, year) {
-    switch (event.key) {
-      case 'ArrowUp':
-        focusYear(year - yearsPerRow);
-        event.preventDefault();
-        break;
-      case 'ArrowDown':
-        focusYear(year + yearsPerRow);
-        event.preventDefault();
-        break;
-      case 'ArrowLeft':
-        focusYear(year + (theme.direction === 'ltr' ? -1 : 1));
-        event.preventDefault();
-        break;
-      case 'ArrowRight':
-        focusYear(year + (theme.direction === 'ltr' ? 1 : -1));
-        event.preventDefault();
-        break;
-      default:
-        break;
-    }
-  });
-  var handleYearFocus = useEventCallback(function (event, year) {
-    focusYear(year);
-  });
-  var handleYearBlur = useEventCallback(function (event, year) {
-    if (focusedYear === year) {
-      changeHasFocus(false);
-    }
-  });
-  var scrollerRef = React.useRef(null);
-  var handleRef = useForkRef(ref, scrollerRef);
-  React.useEffect(function () {
-    if (autoFocus || scrollerRef.current === null) {
-      return;
-    }
-    var tabbableButton = scrollerRef.current.querySelector('[tabindex="0"]');
-    if (!tabbableButton) {
-      return;
-    }
-
-    // Taken from useScroll in x-data-grid, but vertically centered
-    var offsetHeight = tabbableButton.offsetHeight;
-    var offsetTop = tabbableButton.offsetTop;
-    var clientHeight = scrollerRef.current.clientHeight;
-    var scrollTop = scrollerRef.current.scrollTop;
-    var elementBottom = offsetTop + offsetHeight;
-    if (offsetHeight > clientHeight || offsetTop < scrollTop) {
-      // Button already visible
-      return;
-    }
-    scrollerRef.current.scrollTop = elementBottom - clientHeight / 2 - offsetHeight / 2;
-  }, [autoFocus]);
-  return /*#__PURE__*/_jsx(YearCalendarRoot, _extends({
-    ref: handleRef,
-    className: clsx(classes.root, className),
-    ownerState: ownerState,
-    role: "radiogroup",
-    "aria-labelledby": gridLabelId
-  }, other, {
-    children: utils.getYearRange([minDate, maxDate]).map(function (year) {
-      var yearNumber = utils.getYear(year);
-      var isSelected = yearNumber === selectedYear;
-      var isDisabled = disabled || isYearDisabled(year);
-      return /*#__PURE__*/_jsx(PickersYear, {
-        selected: isSelected,
-        value: yearNumber,
-        onClick: handleYearSelection,
-        onKeyDown: handleKeyDown,
-        autoFocus: internalHasFocus && yearNumber === focusedYear,
-        disabled: isDisabled,
-        tabIndex: yearNumber === focusedYear ? 0 : -1,
-        onFocus: handleYearFocus,
-        onBlur: handleYearBlur,
-        "aria-current": todayYear === yearNumber ? 'date' : undefined,
-        yearsPerRow: yearsPerRow,
-        children: utils.format(year, 'year')
-      }, utils.format(year, 'year'));
-    })
-  }));
-});
-process.env.NODE_ENV !== "production" ? YearCalendar.propTypes = {
-  // ----------------------------- Warning --------------------------------
-  // | These PropTypes are generated from the TypeScript type definitions |
-  // | To update them edit the TypeScript types and run "yarn proptypes"  |
-  // ----------------------------------------------------------------------
-  autoFocus: PropTypes.bool,
-  /**
-   * Override or extend the styles applied to the component.
-   */
-  classes: PropTypes.object,
-  className: PropTypes.string,
-  /**
-   * The default selected value.
-   * Used when the component is not controlled.
-   */
-  defaultValue: PropTypes.object,
-  /**
-   * If `true` picker is disabled
-   */
-  disabled: PropTypes.bool,
-  /**
-   * If `true`, disable values after the current date for date components, time for time components and both for date time components.
-   * @default false
-   */
-  disableFuture: PropTypes.bool,
-  /**
-   * If `true`, today's date is rendering without highlighting with circle.
-   * @default false
-   */
-  disableHighlightToday: PropTypes.bool,
-  /**
-   * If `true`, disable values before the current date for date components, time for time components and both for date time components.
-   * @default false
-   */
-  disablePast: PropTypes.bool,
-  gridLabelId: PropTypes.string,
-  hasFocus: PropTypes.bool,
-  /**
-   * Maximal selectable date.
-   */
-  maxDate: PropTypes.object,
-  /**
-   * Minimal selectable date.
-   */
-  minDate: PropTypes.object,
-  /**
-   * Callback fired when the value changes.
-   * @template TDate
-   * @param {TDate} value The new value.
-   */
-  onChange: PropTypes.func,
-  onFocusedViewChange: PropTypes.func,
-  onYearFocus: PropTypes.func,
-  /**
-   * If `true` picker is readonly
-   */
-  readOnly: PropTypes.bool,
-  /**
-   * The date used to generate the new value when both `value` and `defaultValue` are empty.
-   * @default The closest valid year using the validation props, except callbacks such as `shouldDisableYear`.
-   */
-  referenceDate: PropTypes.object,
-  /**
-   * Disable specific year.
-   * @template TDate
-   * @param {TDate} year The year to test.
-   * @returns {boolean} If `true`, the year will be disabled.
-   */
-  shouldDisableYear: PropTypes.func,
-  /**
-   * The system prop that allows defining system overrides as well as additional CSS styles.
-   */
-  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
-  /**
-   * Choose which timezone to use for the value.
-   * Example: "default", "system", "UTC", "America/New_York".
-   * If you pass values from other timezones to some props, they will be converted to this timezone before being used.
-   * @see See the {@link https://mui.com/x/react-date-pickers/timezone/ timezones documentation} for more details.
-   * @default The timezone of the `value` or `defaultValue` prop is defined, 'default' otherwise.
-   */
-  timezone: PropTypes.string,
-  /**
-   * The selected value.
-   * Used when the component is controlled.
-   */
-  value: PropTypes.object,
-  /**
-   * Years rendered per row.
-   * @default 3
-   */
-  yearsPerRow: PropTypes.oneOf([3, 4])
-} : void 0;

package/legacy/YearCalendar/YearCalendar.types.js

@@ -1 +0,0 @@
-export {};

package/legacy/YearCalendar/index.js

@@ -1,3 +0,0 @@
-export { YearCalendar } from './YearCalendar';
-export { yearCalendarClasses, getYearCalendarUtilityClass } from './yearCalendarClasses';
-export { pickersYearClasses } from './pickersYearClasses';

package/legacy/YearCalendar/pickersYearClasses.js

@@ -1,5 +0,0 @@
-import { unstable_generateUtilityClass as generateUtilityClass, unstable_generateUtilityClasses as generateUtilityClasses } from '@mui/utils';
-export function getPickersYearUtilityClass(slot) {
-  return generateUtilityClass('MuiPickersYear', slot);
-}
-export var pickersYearClasses = generateUtilityClasses('MuiPickersYear', ['root', 'yearButton', 'selected', 'disabled']);

package/legacy/YearCalendar/yearCalendarClasses.js

@@ -1,5 +0,0 @@
-import { unstable_generateUtilityClass as generateUtilityClass, unstable_generateUtilityClasses as generateUtilityClasses } from '@mui/utils';
-export function getYearCalendarUtilityClass(slot) {
-  return generateUtilityClass('MuiYearCalendar', slot);
-}
-export var yearCalendarClasses = generateUtilityClasses('MuiYearCalendar', ['root']);

package/legacy/dateTimeViewRenderers/dateTimeViewRenderers.js

@@ -1,162 +0,0 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import Divider from '@mui/material/Divider';
-import { resolveComponentProps } from '@mui/base/utils';
-import { DateCalendar } from '../DateCalendar';
-import { multiSectionDigitalClockSectionClasses } from '../MultiSectionDigitalClock';
-import { DateTimeViewWrapper } from '../internals/components/DateTimeViewWrapper';
-import { isInternalTimeView } from '../internals/utils/time-utils';
-import { isDatePickerView } from '../internals/utils/date-utils';
-import { renderDigitalClockTimeView, renderMultiSectionDigitalClockTimeView } from '../timeViewRenderers';
-import { digitalClockClasses } from '../DigitalClock';
-import { VIEW_HEIGHT } from '../internals/constants/dimensions';
-import { jsx as _jsx } from "react/jsx-runtime";
-import { jsxs as _jsxs } from "react/jsx-runtime";
-export var renderDesktopDateTimeView = function renderDesktopDateTimeView(_ref) {
-  var _resolveComponentProp;
-  var view = _ref.view,
-    onViewChange = _ref.onViewChange,
-    views = _ref.views,
-    focusedView = _ref.focusedView,
-    onFocusedViewChange = _ref.onFocusedViewChange,
-    value = _ref.value,
-    defaultValue = _ref.defaultValue,
-    referenceDate = _ref.referenceDate,
-    onChange = _ref.onChange,
-    className = _ref.className,
-    classes = _ref.classes,
-    disableFuture = _ref.disableFuture,
-    disablePast = _ref.disablePast,
-    minDate = _ref.minDate,
-    minTime = _ref.minTime,
-    maxDate = _ref.maxDate,
-    maxTime = _ref.maxTime,
-    shouldDisableDate = _ref.shouldDisableDate,
-    shouldDisableMonth = _ref.shouldDisableMonth,
-    shouldDisableYear = _ref.shouldDisableYear,
-    shouldDisableTime = _ref.shouldDisableTime,
-    reduceAnimations = _ref.reduceAnimations,
-    minutesStep = _ref.minutesStep,
-    ampm = _ref.ampm,
-    onMonthChange = _ref.onMonthChange,
-    monthsPerRow = _ref.monthsPerRow,
-    onYearChange = _ref.onYearChange,
-    yearsPerRow = _ref.yearsPerRow,
-    slots = _ref.slots,
-    slotProps = _ref.slotProps,
-    loading = _ref.loading,
-    renderLoading = _ref.renderLoading,
-    disableHighlightToday = _ref.disableHighlightToday,
-    readOnly = _ref.readOnly,
-    disabled = _ref.disabled,
-    showDaysOutsideCurrentMonth = _ref.showDaysOutsideCurrentMonth,
-    dayOfWeekFormatter = _ref.dayOfWeekFormatter,
-    sx = _ref.sx,
-    autoFocus = _ref.autoFocus,
-    fixedWeekNumber = _ref.fixedWeekNumber,
-    displayWeekNumber = _ref.displayWeekNumber,
-    timezone = _ref.timezone,
-    disableIgnoringDatePartForTimeValidation = _ref.disableIgnoringDatePartForTimeValidation,
-    timeSteps = _ref.timeSteps,
-    skipDisabled = _ref.skipDisabled,
-    timeViewsCount = _ref.timeViewsCount,
-    shouldRenderTimeInASingleColumn = _ref.shouldRenderTimeInASingleColumn;
-  var isActionBarVisible = !!((_resolveComponentProp = resolveComponentProps(slotProps == null ? void 0 : slotProps.actionBar, {})) != null && (_resolveComponentProp = _resolveComponentProp.actions) != null && _resolveComponentProp.length);
-  var commonTimeProps = {
-    view: isInternalTimeView(view) ? view : 'hours',
-    onViewChange: onViewChange,
-    focusedView: focusedView && isInternalTimeView(focusedView) ? focusedView : null,
-    onFocusedViewChange: onFocusedViewChange,
-    views: views.filter(isInternalTimeView),
-    value: value,
-    defaultValue: defaultValue,
-    referenceDate: referenceDate,
-    onChange: onChange,
-    className: className,
-    classes: classes,
-    disableFuture: disableFuture,
-    disablePast: disablePast,
-    minTime: minTime,
-    maxTime: maxTime,
-    shouldDisableTime: shouldDisableTime,
-    minutesStep: minutesStep,
-    ampm: ampm,
-    slots: slots,
-    slotProps: slotProps,
-    readOnly: readOnly,
-    disabled: disabled,
-    autoFocus: autoFocus,
-    disableIgnoringDatePartForTimeValidation: disableIgnoringDatePartForTimeValidation,
-    timeSteps: timeSteps,
-    skipDisabled: skipDisabled,
-    timezone: timezone
-  };
-  return /*#__PURE__*/_jsxs(React.Fragment, {
-    children: [/*#__PURE__*/_jsxs(DateTimeViewWrapper, {
-      children: [/*#__PURE__*/_jsx(DateCalendar, {
-        view: isDatePickerView(view) ? view : 'day',
-        onViewChange: onViewChange,
-        views: views.filter(isDatePickerView),
-        focusedView: focusedView && isDatePickerView(focusedView) ? focusedView : null,
-        onFocusedViewChange: onFocusedViewChange,
-        value: value,
-        defaultValue: defaultValue,
-        referenceDate: referenceDate,
-        onChange: onChange,
-        className: className,
-        classes: classes,
-        disableFuture: disableFuture,
-        disablePast: disablePast,
-        minDate: minDate,
-        maxDate: maxDate,
-        shouldDisableDate: shouldDisableDate,
-        shouldDisableMonth: shouldDisableMonth,
-        shouldDisableYear: shouldDisableYear,
-        reduceAnimations: reduceAnimations,
-        onMonthChange: onMonthChange,
-        monthsPerRow: monthsPerRow,
-        onYearChange: onYearChange,
-        yearsPerRow: yearsPerRow,
-        slots: slots,
-        slotProps: slotProps,
-        loading: loading,
-        renderLoading: renderLoading,
-        disableHighlightToday: disableHighlightToday,
-        readOnly: readOnly,
-        disabled: disabled,
-        showDaysOutsideCurrentMonth: showDaysOutsideCurrentMonth,
-        dayOfWeekFormatter: dayOfWeekFormatter,
-        sx: sx,
-        autoFocus: autoFocus,
-        fixedWeekNumber: fixedWeekNumber,
-        displayWeekNumber: displayWeekNumber,
-        timezone: timezone
-      }), timeViewsCount > 0 && /*#__PURE__*/_jsxs(React.Fragment, {
-        children: [/*#__PURE__*/_jsx(Divider, {
-          orientation: "vertical"
-        }), shouldRenderTimeInASingleColumn ? renderDigitalClockTimeView(_extends({}, commonTimeProps, {
-          view: 'hours',
-          views: ['hours'],
-          focusedView: focusedView && isInternalTimeView(focusedView) ? 'hours' : null,
-          sx: [_defineProperty({
-            width: 'auto'
-          }, "&.".concat(digitalClockClasses.root), {
-            maxHeight: VIEW_HEIGHT
-          })].concat(_toConsumableArray(Array.isArray(sx) ? sx : [sx]))
-        })) : renderMultiSectionDigitalClockTimeView(_extends({}, commonTimeProps, {
-          view: isInternalTimeView(view) ? view : 'hours',
-          views: views.filter(isInternalTimeView),
-          focusedView: focusedView && isInternalTimeView(focusedView) ? focusedView : null,
-          sx: [_defineProperty({
-            borderBottom: 0,
-            width: 'auto'
-          }, ".".concat(multiSectionDigitalClockSectionClasses.root), {
-            maxHeight: '100%'
-          })].concat(_toConsumableArray(Array.isArray(sx) ? sx : [sx]))
-        }))]
-      })]
-    }), isActionBarVisible && /*#__PURE__*/_jsx(Divider, {})]
-  });
-};

package/legacy/dateTimeViewRenderers/index.js

@@ -1 +0,0 @@
-export { renderDesktopDateTimeView } from './dateTimeViewRenderers';