@tenancy.nz/datepicker 1.3.4

package/dist/esm/node_modules/.pnpm/@mui_x-date-pickers@8.27.0_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@em_f7106fb7eba50d62f3c82acfcf63ee91/node_modules/@mui/x-date-pickers/esm/YearCalendar/YearCalendar.js

@@ -0,0 +1,414 @@
+import _objectWithoutPropertiesLoose from '../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js';
+import _extends from '../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/extends.js';
+import * as React from 'react';
+import PropTypes from '../../../../../../../../_virtual/index.js';
+import { clsx } from '../../../../../../clsx@2.1.1/node_modules/clsx/dist/clsx.js';
+import { useRtl } from '../../../../../../@mui_system@7.3.1_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@emotion_sty_acba54c86a0a45a77cd5d01171297ec0/node_modules/@mui/system/esm/RtlProvider/index.js';
+import { styled, useThemeProps } from '@mui/material/styles';
+import { YearCalendarButton } from './YearCalendarButton.js';
+import { useNow } from '../internals/hooks/useUtils.js';
+import { getYearCalendarUtilityClass } from './yearCalendarClasses.js';
+import { singleItemValueManager } from '../internals/utils/valueManagers.js';
+import { SECTION_TYPE_GRANULARITY } from '../internals/utils/getDefaultReferenceDate.js';
+import { useControlledValue } from '../internals/hooks/useControlledValue.js';
+import { MAX_CALENDAR_HEIGHT, DIALOG_WIDTH } from '../internals/constants/dimensions.js';
+import { usePickerPrivateContext } from '../internals/hooks/usePickerPrivateContext.js';
+import { useApplyDefaultValuesToDateValidationProps } from '../managers/useDateManager.js';
+import { usePickerAdapter } from '../hooks/usePickerAdapter.js';
+import { jsxs, jsx } from 'react/jsx-runtime';
+import useControlled from '../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useControlled/useControlled.js';
+import useEventCallback from '../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useEventCallback/useEventCallback.js';
+import useForkRef from '../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useForkRef/useForkRef.js';
+import composeClasses from '../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/composeClasses/composeClasses.js';
+import { shouldForwardProp } from '../../../../../../@mui_system@7.3.1_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@emotion_sty_acba54c86a0a45a77cd5d01171297ec0/node_modules/@mui/system/esm/createStyled/createStyled.js';
+
+const _excluded = ["autoFocus", "className", "classes", "value", "defaultValue", "referenceDate", "disabled", "disableFuture", "disablePast", "maxDate", "minDate", "onChange", "readOnly", "shouldDisableYear", "disableHighlightToday", "onYearFocus", "hasFocus", "onFocusedViewChange", "yearsOrder", "yearsPerRow", "timezone", "gridLabelId", "slots", "slotProps"];
+const useUtilityClasses = classes => {
+  const slots = {
+    root: ['root']
+  };
+  return composeClasses(slots, getYearCalendarUtilityClass, classes);
+};
+function useYearCalendarDefaultizedProps(props, name) {
+  const themeProps = useThemeProps({
+    props,
+    name
+  });
+  const validationProps = useApplyDefaultValuesToDateValidationProps(themeProps);
+  return _extends({}, themeProps, validationProps, {
+    yearsPerRow: themeProps.yearsPerRow ?? 3,
+    yearsOrder: themeProps.yearsOrder ?? 'asc'
+  });
+}
+const YearCalendarRoot = styled('div', {
+  name: 'MuiYearCalendar',
+  slot: 'Root',
+  shouldForwardProp: prop => shouldForwardProp(prop) && prop !== 'yearsPerRow'
+})({
+  display: 'flex',
+  flexWrap: 'wrap',
+  justifyContent: 'space-evenly',
+  rowGap: 12,
+  padding: '6px 0',
+  overflowY: 'auto',
+  height: '100%',
+  width: DIALOG_WIDTH,
+  maxHeight: MAX_CALENDAR_HEIGHT,
+  // avoid padding increasing width over defined
+  boxSizing: 'border-box',
+  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:
+ *
+ * - [DateCalendar](https://mui.com/x/react-date-pickers/date-calendar/)
+ *
+ * API:
+ *
+ * - [YearCalendar API](https://mui.com/x/api/date-pickers/year-calendar/)
+ */
+const YearCalendar = /*#__PURE__*/React.forwardRef(function YearCalendar(inProps, ref) {
+  const props = useYearCalendarDefaultizedProps(inProps, 'MuiYearCalendar');
+  const {
+      autoFocus,
+      className,
+      classes: classesProp,
+      value: valueProp,
+      defaultValue,
+      referenceDate: referenceDateProp,
+      disabled,
+      disableFuture,
+      disablePast,
+      maxDate,
+      minDate,
+      onChange,
+      readOnly,
+      shouldDisableYear,
+      onYearFocus,
+      hasFocus,
+      onFocusedViewChange,
+      yearsOrder,
+      yearsPerRow,
+      timezone: timezoneProp,
+      gridLabelId,
+      slots,
+      slotProps
+    } = props,
+    other = _objectWithoutPropertiesLoose(props, _excluded);
+  const {
+    value,
+    handleValueChange,
+    timezone
+  } = useControlledValue({
+    name: 'YearCalendar',
+    timezone: timezoneProp,
+    value: valueProp,
+    defaultValue,
+    referenceDate: referenceDateProp,
+    onChange,
+    valueManager: singleItemValueManager
+  });
+  const now = useNow(timezone);
+  const isRtl = useRtl();
+  const adapter = usePickerAdapter();
+  const {
+    ownerState
+  } = usePickerPrivateContext();
+  const referenceDate = React.useMemo(() => singleItemValueManager.getInitialReferenceValue({
+    value,
+    adapter,
+    props,
+    timezone,
+    referenceDate: referenceDateProp,
+    granularity: SECTION_TYPE_GRANULARITY.year
+  }), [] // eslint-disable-line react-hooks/exhaustive-deps
+  );
+  const classes = useUtilityClasses(classesProp);
+  const todayYear = React.useMemo(() => adapter.getYear(now), [adapter, now]);
+  const selectedYear = React.useMemo(() => {
+    if (value != null) {
+      return adapter.getYear(value);
+    }
+    return null;
+  }, [value, adapter]);
+  const [focusedYear, setFocusedYear] = React.useState(() => selectedYear || adapter.getYear(referenceDate));
+  const [internalHasFocus, setInternalHasFocus] = useControlled({
+    name: 'YearCalendar',
+    state: 'hasFocus',
+    controlled: hasFocus,
+    default: autoFocus ?? false
+  });
+  const changeHasFocus = useEventCallback(newHasFocus => {
+    setInternalHasFocus(newHasFocus);
+    if (onFocusedViewChange) {
+      onFocusedViewChange(newHasFocus);
+    }
+  });
+  const isYearDisabled = React.useCallback(dateToValidate => {
+    if (disablePast && adapter.isBeforeYear(dateToValidate, now)) {
+      return true;
+    }
+    if (disableFuture && adapter.isAfterYear(dateToValidate, now)) {
+      return true;
+    }
+    if (minDate && adapter.isBeforeYear(dateToValidate, minDate)) {
+      return true;
+    }
+    if (maxDate && adapter.isAfterYear(dateToValidate, maxDate)) {
+      return true;
+    }
+    if (!shouldDisableYear) {
+      return false;
+    }
+    const yearToValidate = adapter.startOfYear(dateToValidate);
+    return shouldDisableYear(yearToValidate);
+  }, [disableFuture, disablePast, maxDate, minDate, now, shouldDisableYear, adapter]);
+  const handleYearSelection = useEventCallback((event, year) => {
+    if (readOnly) {
+      return;
+    }
+    const newDate = adapter.setYear(value ?? referenceDate, year);
+    handleValueChange(newDate);
+  });
+  const focusYear = useEventCallback(year => {
+    if (!isYearDisabled(adapter.setYear(value ?? referenceDate, year))) {
+      setFocusedYear(year);
+      changeHasFocus(true);
+      onYearFocus?.(year);
+    }
+  });
+  React.useEffect(() => {
+    setFocusedYear(prevFocusedYear => selectedYear !== null && prevFocusedYear !== selectedYear ? selectedYear : prevFocusedYear);
+  }, [selectedYear]);
+  const verticalDirection = yearsOrder !== 'desc' ? yearsPerRow * 1 : yearsPerRow * -1;
+  const horizontalDirection = isRtl && yearsOrder === 'asc' || !isRtl && yearsOrder === 'desc' ? -1 : 1;
+  const handleKeyDown = useEventCallback((event, year) => {
+    switch (event.key) {
+      case 'ArrowUp':
+        focusYear(year - verticalDirection);
+        event.preventDefault();
+        break;
+      case 'ArrowDown':
+        focusYear(year + verticalDirection);
+        event.preventDefault();
+        break;
+      case 'ArrowLeft':
+        focusYear(year - horizontalDirection);
+        event.preventDefault();
+        break;
+      case 'ArrowRight':
+        focusYear(year + horizontalDirection);
+        event.preventDefault();
+        break;
+    }
+  });
+  const handleYearFocus = useEventCallback((event, year) => {
+    focusYear(year);
+  });
+  const handleYearBlur = useEventCallback((event, year) => {
+    if (focusedYear === year) {
+      changeHasFocus(false);
+    }
+  });
+  const scrollerRef = React.useRef(null);
+  const handleRef = useForkRef(ref, scrollerRef);
+  React.useEffect(() => {
+    if (autoFocus || scrollerRef.current === null) {
+      return;
+    }
+    const tabbableButton = scrollerRef.current.querySelector('[tabindex="0"]');
+    if (!tabbableButton) {
+      return;
+    }
+
+    // Taken from useScroll in x-data-grid, but vertically centered
+    const offsetHeight = tabbableButton.offsetHeight;
+    const offsetTop = tabbableButton.offsetTop;
+    const clientHeight = scrollerRef.current.clientHeight;
+    const scrollTop = scrollerRef.current.scrollTop;
+    const elementBottom = offsetTop + offsetHeight;
+    if (offsetHeight > clientHeight || offsetTop < scrollTop) {
+      // Button already visible
+      return;
+    }
+    scrollerRef.current.scrollTop = elementBottom - clientHeight / 2 - offsetHeight / 2;
+  }, [autoFocus]);
+  const yearRange = adapter.getYearRange([minDate, maxDate]);
+  if (yearsOrder === 'desc') {
+    yearRange.reverse();
+  }
+  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,
+    yearsPerRow: yearsPerRow
+  }, other, {
+    children: [yearRange.map(year => {
+      const yearNumber = adapter.getYear(year);
+      const isSelected = yearNumber === selectedYear;
+      const isDisabled = disabled || isYearDisabled(year);
+      return /*#__PURE__*/jsx(YearCalendarButton, {
+        selected: isSelected,
+        value: yearNumber,
+        onClick: handleYearSelection,
+        onKeyDown: handleKeyDown,
+        autoFocus: internalHasFocus && yearNumber === focusedYear,
+        disabled: isDisabled,
+        tabIndex: yearNumber === focusedYear && !isDisabled ? 0 : -1,
+        onFocus: handleYearFocus,
+        onBlur: handleYearBlur,
+        "aria-current": todayYear === yearNumber ? 'date' : undefined,
+        slots: slots,
+        slotProps: slotProps,
+        classes: classesProp,
+        children: adapter.format(year, 'year')
+      }, adapter.format(year, 'year'));
+    }), Array.from({
+      length: fillerAmount
+    }, (_, index) => /*#__PURE__*/jsx(YearCalendarButtonFiller, {}, index))]
+  }));
+});
+if (process.env.NODE_ENV !== "production") YearCalendar.displayName = "YearCalendar";
+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 "pnpm 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`, the component is disabled.
+   * When disabled, the value cannot be changed and no interaction is possible.
+   * @default false
+   */
+  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.
+   * @default 2099-12-31
+   */
+  maxDate: PropTypes.object,
+  /**
+   * Minimal selectable date.
+   * @default 1900-01-01
+   */
+  minDate: PropTypes.object,
+  /**
+   * Callback fired when the value changes.
+   * @param {PickerValidDate} value The new value.
+   */
+  onChange: PropTypes.func,
+  onFocusedViewChange: PropTypes.func,
+  onYearFocus: PropTypes.func,
+  /**
+   * If `true`, the component is read-only.
+   * When read-only, the value cannot be changed but the user can interact with the interface.
+   * @default false
+   */
+  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.
+   * @param {PickerValidDate} year The year to test.
+   * @returns {boolean} If `true`, the year will be disabled.
+   */
+  shouldDisableYear: PropTypes.func,
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: PropTypes.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: PropTypes.object,
+  /**
+   * 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 are displayed in ascending (chronological) order by default.
+   * If `desc`, years are displayed in descending order.
+   * @default 'asc'
+   */
+  yearsOrder: PropTypes.oneOf(['asc', 'desc']),
+  /**
+   * Years rendered per row.
+   * @default 3
+   */
+  yearsPerRow: PropTypes.oneOf([3, 4])
+} : void 0;
+
+export { YearCalendar };

package/dist/esm/node_modules/.pnpm/@mui_x-date-pickers@8.27.0_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@em_f7106fb7eba50d62f3c82acfcf63ee91/node_modules/@mui/x-date-pickers/esm/YearCalendar/YearCalendarButton.js

@@ -0,0 +1,119 @@
+import _objectWithoutPropertiesLoose from '../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js';
+import _extends from '../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/extends.js';
+import * as React from 'react';
+import { styled, alpha } from '@mui/material/styles';
+import { usePickerPrivateContext } from '../internals/hooks/usePickerPrivateContext.js';
+import { getYearCalendarUtilityClass, yearCalendarClasses } from './yearCalendarClasses.js';
+import { jsx } from 'react/jsx-runtime';
+import useEnhancedEffect from '../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useEnhancedEffect/useEnhancedEffect.js';
+import useSlotProps from '../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useSlotProps/useSlotProps.js';
+import composeClasses from '../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/composeClasses/composeClasses.js';
+
+const _excluded = ["autoFocus", "classes", "disabled", "selected", "value", "onClick", "onKeyDown", "onFocus", "onBlur", "slots", "slotProps"];
+const useUtilityClasses = (classes, ownerState) => {
+  const slots = {
+    button: ['button', ownerState.isYearDisabled && 'disabled', ownerState.isYearSelected && 'selected']
+  };
+  return composeClasses(slots, getYearCalendarUtilityClass, classes);
+};
+const DefaultYearButton = styled('button', {
+  name: 'MuiYearCalendar',
+  slot: 'Button',
+  overridesResolver: (_, styles) => [styles.button, {
+    [`&.${yearCalendarClasses.disabled}`]: styles.disabled
+  }, {
+    [`&.${yearCalendarClasses.selected}`]: styles.selected
+  }]
+})(({
+  theme
+}) => _extends({
+  color: 'unset',
+  backgroundColor: 'transparent',
+  border: 0,
+  outline: 0
+}, theme.typography.subtitle1, {
+  height: 36,
+  width: 72,
+  borderRadius: 18,
+  cursor: 'pointer',
+  '&:focus': {
+    backgroundColor: theme.vars ? `rgba(${theme.vars.palette.action.activeChannel} / ${theme.vars.palette.action.focusOpacity})` : alpha(theme.palette.action.active, theme.palette.action.focusOpacity)
+  },
+  '&:hover': {
+    backgroundColor: theme.vars ? `rgba(${theme.vars.palette.action.activeChannel} / ${theme.vars.palette.action.hoverOpacity})` : alpha(theme.palette.action.active, theme.palette.action.hoverOpacity)
+  },
+  '&:disabled': {
+    cursor: 'auto',
+    pointerEvents: 'none'
+  },
+  [`&.${yearCalendarClasses.disabled}`]: {
+    color: (theme.vars || theme).palette.text.secondary
+  },
+  [`&.${yearCalendarClasses.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.
+ */
+const YearCalendarButton = /*#__PURE__*/React.memo(function YearCalendarButton(props) {
+  const {
+      autoFocus,
+      classes: classesProp,
+      disabled,
+      selected,
+      value,
+      onClick,
+      onKeyDown,
+      onFocus,
+      onBlur,
+      slots,
+      slotProps
+    } = props,
+    other = _objectWithoutPropertiesLoose(props, _excluded);
+  const ref = React.useRef(null);
+  const {
+    ownerState: pickerOwnerState
+  } = usePickerPrivateContext();
+  const ownerState = _extends({}, pickerOwnerState, {
+    isYearDisabled: disabled,
+    isYearSelected: selected
+  });
+  const classes = useUtilityClasses(classesProp, ownerState);
+
+  // We can't forward the `autoFocus` to the button because it is a native button, not a MUI Button
+  useEnhancedEffect(() => {
+    if (autoFocus) {
+      // `ref.current` being `null` would be a bug in MUI.
+      ref.current?.focus();
+    }
+  }, [autoFocus]);
+  const YearButton = slots?.yearButton ?? DefaultYearButton;
+  const yearButtonProps = useSlotProps({
+    elementType: YearButton,
+    externalSlotProps: slotProps?.yearButton,
+    externalForwardedProps: other,
+    additionalProps: {
+      disabled,
+      ref,
+      type: 'button',
+      role: 'radio',
+      'aria-checked': selected,
+      onClick: event => onClick(event, value),
+      onKeyDown: event => onKeyDown(event, value),
+      onFocus: event => onFocus(event, value),
+      onBlur: event => onBlur(event, value)
+    },
+    ownerState,
+    className: classes.button
+  });
+  return /*#__PURE__*/jsx(YearButton, _extends({}, yearButtonProps));
+});
+if (process.env.NODE_ENV !== "production") YearCalendarButton.displayName = "YearCalendarButton";
+
+export { YearCalendarButton };

package/dist/esm/node_modules/.pnpm/@mui_x-date-pickers@8.27.0_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@em_f7106fb7eba50d62f3c82acfcf63ee91/node_modules/@mui/x-date-pickers/esm/YearCalendar/yearCalendarClasses.js

@@ -0,0 +1,9 @@
+import generateUtilityClass from '../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/generateUtilityClass/generateUtilityClass.js';
+import generateUtilityClasses from '../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/generateUtilityClasses/generateUtilityClasses.js';
+
+function getYearCalendarUtilityClass(slot) {
+  return generateUtilityClass('MuiYearCalendar', slot);
+}
+const yearCalendarClasses = generateUtilityClasses('MuiYearCalendar', ['root', 'button', 'disabled', 'selected']);
+
+export { getYearCalendarUtilityClass, yearCalendarClasses };

package/dist/esm/node_modules/.pnpm/@mui_x-date-pickers@8.27.0_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@em_f7106fb7eba50d62f3c82acfcf63ee91/node_modules/@mui/x-date-pickers/esm/dateViewRenderers/dateViewRenderers.js

@@ -0,0 +1,86 @@
+import { isDatePickerView } from '../internals/utils/date-utils.js';
+import { jsx } from 'react/jsx-runtime';
+import { DateCalendar } from '../DateCalendar/DateCalendar.js';
+
+const renderDateViewCalendar = ({
+  view,
+  onViewChange,
+  views,
+  focusedView,
+  onFocusedViewChange,
+  value,
+  defaultValue,
+  referenceDate,
+  onChange,
+  className,
+  classes,
+  disableFuture,
+  disablePast,
+  minDate,
+  maxDate,
+  shouldDisableDate,
+  shouldDisableMonth,
+  shouldDisableYear,
+  reduceAnimations,
+  onMonthChange,
+  monthsPerRow,
+  onYearChange,
+  yearsOrder,
+  yearsPerRow,
+  slots,
+  slotProps,
+  loading,
+  renderLoading,
+  disableHighlightToday,
+  readOnly,
+  disabled,
+  showDaysOutsideCurrentMonth,
+  dayOfWeekFormatter,
+  sx,
+  autoFocus,
+  fixedWeekNumber,
+  displayWeekNumber,
+  timezone
+}) => /*#__PURE__*/jsx(DateCalendar, {
+  view: view,
+  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,
+  yearsOrder: yearsOrder,
+  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
+});
+if (process.env.NODE_ENV !== "production") renderDateViewCalendar.displayName = "renderDateViewCalendar";
+
+export { renderDateViewCalendar };

package/dist/esm/node_modules/.pnpm/@mui_x-date-pickers@8.27.0_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@em_f7106fb7eba50d62f3c82acfcf63ee91/node_modules/@mui/x-date-pickers/esm/hooks/useIsValidValue.js

@@ -0,0 +1,13 @@
+import * as React from 'react';
+
+const IsValidValueContext = /*#__PURE__*/React.createContext(() => true);
+
+/**
+ * Returns a function to check if a value is valid according to the validation props passed to the parent Picker.
+ */
+if (process.env.NODE_ENV !== "production") IsValidValueContext.displayName = "IsValidValueContext";
+function useIsValidValue() {
+  return React.useContext(IsValidValueContext);
+}
+
+export { IsValidValueContext, useIsValidValue };

package/dist/esm/node_modules/.pnpm/@mui_x-date-pickers@8.27.0_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@em_f7106fb7eba50d62f3c82acfcf63ee91/node_modules/@mui/x-date-pickers/esm/hooks/usePickerActionsContext.js

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { PickerActionsContext } from '../internals/components/PickerProvider.js';
+
+/**
+ * Returns a subset of the context passed by the Picker wrapping the current component.
+ * It only contains the actions and never causes a re-render of the component using it.
+ */
+const usePickerActionsContext = () => {
+  const value = React.useContext(PickerActionsContext);
+  if (value == null) {
+    throw new Error(['MUI X: The `usePickerActionsContext` can only be called in fields that are used as a slot of a Picker component'].join('\n'));
+  }
+  return value;
+};
+
+export { usePickerActionsContext };

package/dist/esm/node_modules/.pnpm/@mui_x-date-pickers@8.27.0_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@em_f7106fb7eba50d62f3c82acfcf63ee91/node_modules/@mui/x-date-pickers/esm/hooks/usePickerAdapter.js

@@ -0,0 +1,21 @@
+import _extends from '../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/extends.js';
+import * as React from 'react';
+import { DEFAULT_LOCALE } from '../locales/enUS.js';
+import { PickerAdapterContext } from '../LocalizationProvider/LocalizationProvider.js';
+
+const useLocalizationContext = () => {
+  const localization = React.useContext(PickerAdapterContext);
+  if (localization === null) {
+    throw new Error(['MUI X: Can not find the date and time pickers localization context.', 'It looks like you forgot to wrap your component in LocalizationProvider.', 'This can also happen if you are bundling multiple versions of the `@mui/x-date-pickers` package'].join('\n'));
+  }
+  if (localization.adapter === null) {
+    throw new Error(['MUI X: Can not find the date and time pickers adapter from its localization context.', 'It looks like you forgot to pass a `dateAdapter` to your LocalizationProvider.'].join('\n'));
+  }
+  const localeText = React.useMemo(() => _extends({}, DEFAULT_LOCALE, localization.localeText), [localization.localeText]);
+  return React.useMemo(() => _extends({}, localization, {
+    localeText
+  }), [localization, localeText]);
+};
+const usePickerAdapter = () => useLocalizationContext().adapter;
+
+export { useLocalizationContext, usePickerAdapter };