@tenancy.nz/datepicker 1.3.4

package/dist/cjs/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.cjs

@@ -0,0 +1,435 @@
+'use strict';
+
+var objectWithoutPropertiesLoose = require('../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.cjs');
+var _extends = require('../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/extends.cjs');
+var React = require('react');
+var index$1 = require('../../../../../../../../_virtual/index.cjs');
+var clsx = require('../../../../../../clsx@2.1.1/node_modules/clsx/dist/clsx.cjs');
+var index = require('../../../../../../@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.cjs');
+var styles = require('@mui/material/styles');
+var YearCalendarButton = require('./YearCalendarButton.cjs');
+var useUtils = require('../internals/hooks/useUtils.cjs');
+var yearCalendarClasses = require('./yearCalendarClasses.cjs');
+var valueManagers = require('../internals/utils/valueManagers.cjs');
+var getDefaultReferenceDate = require('../internals/utils/getDefaultReferenceDate.cjs');
+var useControlledValue = require('../internals/hooks/useControlledValue.cjs');
+var dimensions = require('../internals/constants/dimensions.cjs');
+var usePickerPrivateContext = require('../internals/hooks/usePickerPrivateContext.cjs');
+var useDateManager = require('../managers/useDateManager.cjs');
+var usePickerAdapter = require('../hooks/usePickerAdapter.cjs');
+var jsxRuntime = require('react/jsx-runtime');
+var useControlled = require('../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useControlled/useControlled.cjs');
+var useEventCallback = require('../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useEventCallback/useEventCallback.cjs');
+var useForkRef = require('../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useForkRef/useForkRef.cjs');
+var composeClasses = require('../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/composeClasses/composeClasses.cjs');
+var createStyled = require('../../../../../../@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.cjs');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+
+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.default(slots, yearCalendarClasses.getYearCalendarUtilityClass, classes);
+};
+function useYearCalendarDefaultizedProps(props, name) {
+  const themeProps = styles.useThemeProps({
+    props,
+    name
+  });
+  const validationProps = useDateManager.useApplyDefaultValuesToDateValidationProps(themeProps);
+  return _extends.default({}, themeProps, validationProps, {
+    yearsPerRow: themeProps.yearsPerRow ?? 3,
+    yearsOrder: themeProps.yearsOrder ?? 'asc'
+  });
+}
+const YearCalendarRoot = styles.styled('div', {
+  name: 'MuiYearCalendar',
+  slot: 'Root',
+  shouldForwardProp: prop => createStyled.shouldForwardProp(prop) && prop !== 'yearsPerRow'
+})({
+  display: 'flex',
+  flexWrap: 'wrap',
+  justifyContent: 'space-evenly',
+  rowGap: 12,
+  padding: '6px 0',
+  overflowY: 'auto',
+  height: '100%',
+  width: dimensions.DIALOG_WIDTH,
+  maxHeight: dimensions.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 = styles.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__namespace.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.default(props, _excluded);
+  const {
+    value,
+    handleValueChange,
+    timezone
+  } = useControlledValue.useControlledValue({
+    name: 'YearCalendar',
+    timezone: timezoneProp,
+    value: valueProp,
+    defaultValue,
+    referenceDate: referenceDateProp,
+    onChange,
+    valueManager: valueManagers.singleItemValueManager
+  });
+  const now = useUtils.useNow(timezone);
+  const isRtl = index.useRtl();
+  const adapter = usePickerAdapter.usePickerAdapter();
+  const {
+    ownerState
+  } = usePickerPrivateContext.usePickerPrivateContext();
+  const referenceDate = React__namespace.useMemo(() => valueManagers.singleItemValueManager.getInitialReferenceValue({
+    value,
+    adapter,
+    props,
+    timezone,
+    referenceDate: referenceDateProp,
+    granularity: getDefaultReferenceDate.SECTION_TYPE_GRANULARITY.year
+  }), [] // eslint-disable-line react-hooks/exhaustive-deps
+  );
+  const classes = useUtilityClasses(classesProp);
+  const todayYear = React__namespace.useMemo(() => adapter.getYear(now), [adapter, now]);
+  const selectedYear = React__namespace.useMemo(() => {
+    if (value != null) {
+      return adapter.getYear(value);
+    }
+    return null;
+  }, [value, adapter]);
+  const [focusedYear, setFocusedYear] = React__namespace.useState(() => selectedYear || adapter.getYear(referenceDate));
+  const [internalHasFocus, setInternalHasFocus] = useControlled.default({
+    name: 'YearCalendar',
+    state: 'hasFocus',
+    controlled: hasFocus,
+    default: autoFocus ?? false
+  });
+  const changeHasFocus = useEventCallback.default(newHasFocus => {
+    setInternalHasFocus(newHasFocus);
+    if (onFocusedViewChange) {
+      onFocusedViewChange(newHasFocus);
+    }
+  });
+  const isYearDisabled = React__namespace.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.default((event, year) => {
+    if (readOnly) {
+      return;
+    }
+    const newDate = adapter.setYear(value ?? referenceDate, year);
+    handleValueChange(newDate);
+  });
+  const focusYear = useEventCallback.default(year => {
+    if (!isYearDisabled(adapter.setYear(value ?? referenceDate, year))) {
+      setFocusedYear(year);
+      changeHasFocus(true);
+      onYearFocus?.(year);
+    }
+  });
+  React__namespace.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.default((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.default((event, year) => {
+    focusYear(year);
+  });
+  const handleYearBlur = useEventCallback.default((event, year) => {
+    if (focusedYear === year) {
+      changeHasFocus(false);
+    }
+  });
+  const scrollerRef = React__namespace.useRef(null);
+  const handleRef = useForkRef.default(ref, scrollerRef);
+  React__namespace.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__*/jsxRuntime.jsxs(YearCalendarRoot, _extends.default({
+    ref: handleRef,
+    className: clsx.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__*/jsxRuntime.jsx(YearCalendarButton.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__*/jsxRuntime.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: index$1.default.bool,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: index$1.default.object,
+  className: index$1.default.string,
+  /**
+   * The default selected value.
+   * Used when the component is not controlled.
+   */
+  defaultValue: index$1.default.object,
+  /**
+   * If `true`, the component is disabled.
+   * When disabled, the value cannot be changed and no interaction is possible.
+   * @default false
+   */
+  disabled: index$1.default.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: index$1.default.bool,
+  /**
+   * If `true`, today's date is rendering without highlighting with circle.
+   * @default false
+   */
+  disableHighlightToday: index$1.default.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: index$1.default.bool,
+  gridLabelId: index$1.default.string,
+  hasFocus: index$1.default.bool,
+  /**
+   * Maximal selectable date.
+   * @default 2099-12-31
+   */
+  maxDate: index$1.default.object,
+  /**
+   * Minimal selectable date.
+   * @default 1900-01-01
+   */
+  minDate: index$1.default.object,
+  /**
+   * Callback fired when the value changes.
+   * @param {PickerValidDate} value The new value.
+   */
+  onChange: index$1.default.func,
+  onFocusedViewChange: index$1.default.func,
+  onYearFocus: index$1.default.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: index$1.default.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: index$1.default.object,
+  /**
+   * Disable specific year.
+   * @param {PickerValidDate} year The year to test.
+   * @returns {boolean} If `true`, the year will be disabled.
+   */
+  shouldDisableYear: index$1.default.func,
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: index$1.default.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: index$1.default.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: index$1.default.oneOfType([index$1.default.arrayOf(index$1.default.oneOfType([index$1.default.func, index$1.default.object, index$1.default.bool])), index$1.default.func, index$1.default.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: index$1.default.string,
+  /**
+   * The selected value.
+   * Used when the component is controlled.
+   */
+  value: index$1.default.object,
+  /**
+   * Years are displayed in ascending (chronological) order by default.
+   * If `desc`, years are displayed in descending order.
+   * @default 'asc'
+   */
+  yearsOrder: index$1.default.oneOf(['asc', 'desc']),
+  /**
+   * Years rendered per row.
+   * @default 3
+   */
+  yearsPerRow: index$1.default.oneOf([3, 4])
+} : void 0;
+
+exports.YearCalendar = YearCalendar;

package/dist/cjs/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.cjs

@@ -0,0 +1,140 @@
+'use strict';
+
+var objectWithoutPropertiesLoose = require('../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.cjs');
+var _extends = require('../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/extends.cjs');
+var React = require('react');
+var styles = require('@mui/material/styles');
+var usePickerPrivateContext = require('../internals/hooks/usePickerPrivateContext.cjs');
+var yearCalendarClasses = require('./yearCalendarClasses.cjs');
+var jsxRuntime = require('react/jsx-runtime');
+var useEnhancedEffect = require('../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useEnhancedEffect/useEnhancedEffect.cjs');
+var useSlotProps = require('../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useSlotProps/useSlotProps.cjs');
+var composeClasses = require('../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/composeClasses/composeClasses.cjs');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+
+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.default(slots, yearCalendarClasses.getYearCalendarUtilityClass, classes);
+};
+const DefaultYearButton = styles.styled('button', {
+  name: 'MuiYearCalendar',
+  slot: 'Button',
+  overridesResolver: (_, styles) => [styles.button, {
+    [`&.${yearCalendarClasses.yearCalendarClasses.disabled}`]: styles.disabled
+  }, {
+    [`&.${yearCalendarClasses.yearCalendarClasses.selected}`]: styles.selected
+  }]
+})(({
+  theme
+}) => _extends.default({
+  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})` : styles.alpha(theme.palette.action.active, theme.palette.action.focusOpacity)
+  },
+  '&:hover': {
+    backgroundColor: theme.vars ? `rgba(${theme.vars.palette.action.activeChannel} / ${theme.vars.palette.action.hoverOpacity})` : styles.alpha(theme.palette.action.active, theme.palette.action.hoverOpacity)
+  },
+  '&:disabled': {
+    cursor: 'auto',
+    pointerEvents: 'none'
+  },
+  [`&.${yearCalendarClasses.yearCalendarClasses.disabled}`]: {
+    color: (theme.vars || theme).palette.text.secondary
+  },
+  [`&.${yearCalendarClasses.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__namespace.memo(function YearCalendarButton(props) {
+  const {
+      autoFocus,
+      classes: classesProp,
+      disabled,
+      selected,
+      value,
+      onClick,
+      onKeyDown,
+      onFocus,
+      onBlur,
+      slots,
+      slotProps
+    } = props,
+    other = objectWithoutPropertiesLoose.default(props, _excluded);
+  const ref = React__namespace.useRef(null);
+  const {
+    ownerState: pickerOwnerState
+  } = usePickerPrivateContext.usePickerPrivateContext();
+  const ownerState = _extends.default({}, 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.default(() => {
+    if (autoFocus) {
+      // `ref.current` being `null` would be a bug in MUI.
+      ref.current?.focus();
+    }
+  }, [autoFocus]);
+  const YearButton = slots?.yearButton ?? DefaultYearButton;
+  const yearButtonProps = useSlotProps.default({
+    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__*/jsxRuntime.jsx(YearButton, _extends.default({}, yearButtonProps));
+});
+if (process.env.NODE_ENV !== "production") YearCalendarButton.displayName = "YearCalendarButton";
+
+exports.YearCalendarButton = YearCalendarButton;

package/dist/cjs/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.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var generateUtilityClass = require('../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/generateUtilityClass/generateUtilityClass.cjs');
+var generateUtilityClasses = require('../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/generateUtilityClasses/generateUtilityClasses.cjs');
+
+function getYearCalendarUtilityClass(slot) {
+  return generateUtilityClass.default('MuiYearCalendar', slot);
+}
+const yearCalendarClasses = generateUtilityClasses.default('MuiYearCalendar', ['root', 'button', 'disabled', 'selected']);
+
+exports.getYearCalendarUtilityClass = getYearCalendarUtilityClass;
+exports.yearCalendarClasses = yearCalendarClasses;

package/dist/cjs/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.cjs

@@ -0,0 +1,88 @@
+'use strict';
+
+var dateUtils = require('../internals/utils/date-utils.cjs');
+var jsxRuntime = require('react/jsx-runtime');
+var DateCalendar = require('../DateCalendar/DateCalendar.cjs');
+
+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__*/jsxRuntime.jsx(DateCalendar.DateCalendar, {
+  view: view,
+  onViewChange: onViewChange,
+  views: views.filter(dateUtils.isDatePickerView),
+  focusedView: focusedView && dateUtils.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";
+
+exports.renderDateViewCalendar = renderDateViewCalendar;