@pisell/date-picker 1.0.0

package/es/DateRangePicker/shared.js

@@ -0,0 +1,45 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+var _excluded = ["components", "componentsProps"];
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import * as React from 'react';
+import { useThemeProps } from '@mui/material/styles';
+import { useDefaultDates, useUtils, applyDefaultDate, uncapitalizeObjectKeys } from '@mui/x-date-pickers/internals';
+import { DateRangePickerToolbar } from "./DateRangePickerToolbar";
+export function useDateRangePickerDefaultizedProps(props, name) {
+  var _themeProps$disableFu, _themeProps$disablePa, _themeProps$slots, _themeProps$slotProps;
+  var utils = useUtils();
+  var defaultDates = useDefaultDates();
+  var _useThemeProps = useThemeProps({
+      props: props,
+      name: name
+    }),
+    components = _useThemeProps.components,
+    componentsProps = _useThemeProps.componentsProps,
+    themeProps = _objectWithoutProperties(_useThemeProps, _excluded);
+  var localeText = React.useMemo(function () {
+    var _themeProps$localeTex;
+    if (((_themeProps$localeTex = themeProps.localeText) === null || _themeProps$localeTex === void 0 ? void 0 : _themeProps$localeTex.toolbarTitle) == null) {
+      return themeProps.localeText;
+    }
+    return _objectSpread(_objectSpread({}, themeProps.localeText), {}, {
+      dateRangePickerToolbarTitle: themeProps.localeText.toolbarTitle
+    });
+  }, [themeProps.localeText]);
+  return _objectSpread(_objectSpread({}, themeProps), {}, {
+    localeText: localeText,
+    disableFuture: (_themeProps$disableFu = themeProps.disableFuture) !== null && _themeProps$disableFu !== void 0 ? _themeProps$disableFu : false,
+    disablePast: (_themeProps$disablePa = themeProps.disablePast) !== null && _themeProps$disablePa !== void 0 ? _themeProps$disablePa : false,
+    minDate: applyDefaultDate(utils, themeProps.minDate, defaultDates.minDate),
+    maxDate: applyDefaultDate(utils, themeProps.maxDate, defaultDates.maxDate),
+    slots: _objectSpread({
+      toolbar: DateRangePickerToolbar
+    }, (_themeProps$slots = themeProps.slots) !== null && _themeProps$slots !== void 0 ? _themeProps$slots : uncapitalizeObjectKeys(components)),
+    slotProps: (_themeProps$slotProps = themeProps.slotProps) !== null && _themeProps$slotProps !== void 0 ? _themeProps$slotProps : componentsProps
+  });
+}

package/es/DateRangePickerDay/DateRangePickerDay.d.ts

@@ -0,0 +1,51 @@
+import * as React from 'react';
+import { PickersDayProps } from '@mui/x-date-pickers/PickersDay';
+import { DateRangePickerDayClasses } from './dateRangePickerDayClasses';
+export interface DateRangePickerDayProps<TDate> extends Omit<PickersDayProps<TDate>, 'classes' | 'onBlur' | 'onFocus' | 'onKeyDown'> {
+    /**
+     * Set to `true` if the `day` is in a highlighted date range.
+     */
+    isHighlighting: boolean;
+    /**
+     * Set to `true` if the `day` is the end of a highlighted date range.
+     */
+    isEndOfHighlighting: boolean;
+    /**
+     * Set to `true` if the `day` is the start of a highlighted date range.
+     */
+    isStartOfHighlighting: boolean;
+    /**
+     * Set to `true` if the `day` is in a preview date range.
+     */
+    isPreviewing: boolean;
+    /**
+     * Set to `true` if the `day` is the end of a previewing date range.
+     */
+    isEndOfPreviewing: boolean;
+    /**
+     * Set to `true` if the `day` is the start of a previewing date range.
+     */
+    isStartOfPreviewing: boolean;
+    /**
+     * Override or extend the styles applied to the component.
+     */
+    classes?: Partial<DateRangePickerDayClasses>;
+    /**
+     * Indicates if the day should be visually selected.
+     */
+    isVisuallySelected?: boolean;
+}
+declare type DateRangePickerDayComponent = <TDate>(props: DateRangePickerDayProps<TDate> & React.RefAttributes<HTMLButtonElement>) => JSX.Element;
+/**
+ *
+ * Demos:
+ *
+ * - [Date Range Picker](https://mui.com/x/react-date-pickers/date-range-picker/)
+ *
+ * API:
+ *
+ * - [DateRangePickerDay API](https://mui.com/x/api/date-pickers/date-range-picker-day/)
+ */
+export declare const DateRangePickerDay: DateRangePickerDayComponent;
+export {};
+//# sourceMappingURL=DateRangePickerDay.d.ts.map

package/es/DateRangePickerDay/DateRangePickerDay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DateRangePickerDay.d.ts","sourceRoot":"","sources":["DateRangePickerDay.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAO/B,OAAO,EAAc,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAC7E,OAAO,EACL,yBAAyB,EAG1B,MAAM,6BAA6B,CAAC;AAKrC,MAAM,WAAW,uBAAuB,CAAC,KAAK,CAC5C,SAAQ,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,EAAE,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,WAAW,CAAC;IACpF;;OAEG;IACH,cAAc,EAAE,OAAO,CAAC;IACxB;;OAEG;IACH,mBAAmB,EAAE,OAAO,CAAC;IAC7B;;OAEG;IACH,qBAAqB,EAAE,OAAO,CAAC;IAC/B;;OAEG;IACH,YAAY,EAAE,OAAO,CAAC;IACtB;;OAEG;IACH,iBAAiB,EAAE,OAAO,CAAC;IAC3B;;OAEG;IACH,mBAAmB,EAAE,OAAO,CAAC;IAC7B;;OAEG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC,yBAAyB,CAAC,CAAC;IAC7C;;OAEG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAsND,aAAK,2BAA2B,GAAG,CAAC,KAAK,EACvC,KAAK,EAAE,uBAAuB,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,aAAa,CAAC,iBAAiB,CAAC,KAC3E,GAAG,CAAC,OAAO,CAAC;AA+PjB;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,6BAAmE,CAAC"}

package/es/DateRangePickerDay/DateRangePickerDay.js

@@ -0,0 +1,371 @@
+var _excluded = ["className", "day", "outsideCurrentMonth", "isEndOfHighlighting", "isEndOfPreviewing", "isHighlighting", "isPreviewing", "isStartOfHighlighting", "isStartOfPreviewing", "selected", "isVisuallySelected", "sx", "draggable", "isFirstVisibleCell", "isLastVisibleCell"];
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import clsx from 'clsx';
+import { alpha, styled, useThemeProps } from '@mui/material/styles';
+import { unstable_composeClasses as composeClasses } from '@mui/utils';
+import { useUtils } from '@mui/x-date-pickers/internals';
+import { PickersDay } from '@mui/x-date-pickers/PickersDay';
+import { getDateRangePickerDayUtilityClass, dateRangePickerDayClasses } from "./dateRangePickerDayClasses";
+import { getReleaseInfo } from "../internals/utils/releaseInfo";
+var releaseInfo = getReleaseInfo();
+var useUtilityClasses = function useUtilityClasses(ownerState) {
+  var isHighlighting = ownerState.isHighlighting,
+    outsideCurrentMonth = ownerState.outsideCurrentMonth,
+    isStartOfHighlighting = ownerState.isStartOfHighlighting,
+    isStartOfMonth = ownerState.isStartOfMonth,
+    isEndOfHighlighting = ownerState.isEndOfHighlighting,
+    isEndOfMonth = ownerState.isEndOfMonth,
+    isPreviewing = ownerState.isPreviewing,
+    isStartOfPreviewing = ownerState.isStartOfPreviewing,
+    isEndOfPreviewing = ownerState.isEndOfPreviewing,
+    isFirstVisibleCell = ownerState.isFirstVisibleCell,
+    isLastVisibleCell = ownerState.isLastVisibleCell,
+    isHiddenDayFiller = ownerState.isHiddenDayFiller,
+    selected = ownerState.selected,
+    classes = ownerState.classes;
+  var slots = {
+    root: ['root', isHighlighting && 'rangeIntervalDayHighlight', isStartOfHighlighting && 'rangeIntervalDayHighlightStart', isEndOfHighlighting && 'rangeIntervalDayHighlightEnd', outsideCurrentMonth && 'outsideCurrentMonth', isStartOfMonth && 'startOfMonth', isEndOfMonth && 'endOfMonth', isFirstVisibleCell && 'firstVisibleCell', isLastVisibleCell && 'lastVisibleCell', isHiddenDayFiller && 'hiddenDayFiller'],
+    rangeIntervalPreview: ['rangeIntervalPreview', isPreviewing && 'rangeIntervalDayPreview', (isStartOfPreviewing || isStartOfMonth) && 'rangeIntervalDayPreviewStart', (isEndOfPreviewing || isEndOfMonth) && 'rangeIntervalDayPreviewEnd'],
+    day: ['day', !selected && 'notSelectedDate', !isHighlighting && 'dayOutsideRangeInterval', !selected && isHighlighting && 'dayInsideRangeInterval']
+  };
+  return composeClasses(slots, getDateRangePickerDayUtilityClass, classes);
+};
+var endBorderStyle = {
+  borderTopRightRadius: '50%',
+  borderBottomRightRadius: '50%'
+};
+var startBorderStyle = {
+  borderTopLeftRadius: '50%',
+  borderBottomLeftRadius: '50%'
+};
+var DateRangePickerDayRoot = styled('div', {
+  name: 'MuiDateRangePickerDay',
+  slot: 'Root',
+  overridesResolver: function overridesResolver(_, styles) {
+    return [_defineProperty({}, "&.".concat(dateRangePickerDayClasses.rangeIntervalDayHighlight), styles.rangeIntervalDayHighlight), _defineProperty({}, "&.".concat(dateRangePickerDayClasses.rangeIntervalDayHighlightStart), styles.rangeIntervalDayHighlightStart), _defineProperty({}, "&.".concat(dateRangePickerDayClasses.rangeIntervalDayHighlightEnd), styles.rangeIntervalDayHighlightEnd), _defineProperty({}, "&.".concat(dateRangePickerDayClasses.firstVisibleCell), styles.firstVisibleCell), _defineProperty({}, "&.".concat(dateRangePickerDayClasses.lastVisibleCell), styles.lastVisibleCell), _defineProperty({}, "&.".concat(dateRangePickerDayClasses.startOfMonth), styles.startOfMonth), _defineProperty({}, "&.".concat(dateRangePickerDayClasses.endOfMonth), styles.endOfMonth), _defineProperty({}, "&.".concat(dateRangePickerDayClasses.outsideCurrentMonth), styles.outsideCurrentMonth), _defineProperty({}, "&.".concat(dateRangePickerDayClasses.hiddenDayFiller), styles.hiddenDayFiller), styles.root];
+  }
+})(function (_ref10) {
+  var _objectSpread2;
+  var theme = _ref10.theme,
+    ownerState = _ref10.ownerState;
+  return ownerState.isHiddenDayFiller ? {} : _objectSpread(_objectSpread(_objectSpread((_objectSpread2 = {}, _defineProperty(_objectSpread2, "&:first-of-type .".concat(dateRangePickerDayClasses.rangeIntervalDayPreview), _objectSpread(_objectSpread({}, startBorderStyle), {}, {
+    borderLeftColor: (theme.vars || theme).palette.divider
+  })), _defineProperty(_objectSpread2, "&:last-of-type .".concat(dateRangePickerDayClasses.rangeIntervalDayPreview), _objectSpread(_objectSpread({}, endBorderStyle), {}, {
+    borderRightColor: (theme.vars || theme).palette.divider
+  })), _objectSpread2), ownerState.isHighlighting && {
+    borderRadius: 0,
+    color: (theme.vars || theme).palette.primary.contrastText,
+    backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette.primary.mainChannel, " / ").concat(theme.vars.palette.action.focusOpacity, ")") : alpha(theme.palette.primary.main, theme.palette.action.focusOpacity),
+    '&:first-of-type': startBorderStyle,
+    '&:last-of-type': endBorderStyle
+  }), (ownerState.isStartOfHighlighting || ownerState.isFirstVisibleCell) && _objectSpread(_objectSpread({}, startBorderStyle), {}, {
+    paddingLeft: 0
+  })), (ownerState.isEndOfHighlighting || ownerState.isLastVisibleCell) && _objectSpread(_objectSpread({}, endBorderStyle), {}, {
+    paddingRight: 0
+  }));
+});
+DateRangePickerDayRoot.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "yarn proptypes"  |
+  // ----------------------------------------------------------------------
+  ownerState: PropTypes.object.isRequired
+};
+var DateRangePickerDayRangeIntervalPreview = styled('div', {
+  name: 'MuiDateRangePickerDay',
+  slot: 'RangeIntervalPreview',
+  overridesResolver: function overridesResolver(_, styles) {
+    return [_defineProperty({}, "&.".concat(dateRangePickerDayClasses.rangeIntervalDayPreview), styles.rangeIntervalDayPreview), _defineProperty({}, "&.".concat(dateRangePickerDayClasses.rangeIntervalDayPreviewStart), styles.rangeIntervalDayPreviewStart), _defineProperty({}, "&.".concat(dateRangePickerDayClasses.rangeIntervalDayPreviewEnd), styles.rangeIntervalDayPreviewEnd), styles.rangeIntervalPreview];
+  }
+})(function (_ref14) {
+  var theme = _ref14.theme,
+    ownerState = _ref14.ownerState;
+  return _objectSpread({
+    // replace default day component margin with transparent border to avoid jumping on preview
+    border: '2px solid transparent'
+  }, ownerState.isPreviewing && !ownerState.isHiddenDayFiller && _objectSpread(_objectSpread({
+    borderRadius: 0,
+    border: "2px dashed ".concat((theme.vars || theme).palette.divider),
+    borderLeftColor: 'transparent',
+    borderRightColor: 'transparent'
+  }, (ownerState.isStartOfPreviewing || ownerState.isFirstVisibleCell) && _objectSpread({
+    borderLeftColor: (theme.vars || theme).palette.divider
+  }, startBorderStyle)), (ownerState.isEndOfPreviewing || ownerState.isLastVisibleCell) && _objectSpread({
+    borderRightColor: (theme.vars || theme).palette.divider
+  }, endBorderStyle)));
+});
+DateRangePickerDayRangeIntervalPreview.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "yarn proptypes"  |
+  // ----------------------------------------------------------------------
+  ownerState: PropTypes.object.isRequired
+};
+var DateRangePickerDayDay = styled(PickersDay, {
+  name: 'MuiDateRangePickerDay',
+  slot: 'Day',
+  overridesResolver: function overridesResolver(_, styles) {
+    return [_defineProperty({}, "&.".concat(dateRangePickerDayClasses.dayInsideRangeInterval), styles.dayInsideRangeInterval), _defineProperty({}, "&.".concat(dateRangePickerDayClasses.dayOutsideRangeInterval), styles.dayOutsideRangeInterval), _defineProperty({}, "&.".concat(dateRangePickerDayClasses.notSelectedDate), styles.notSelectedDate), styles.day];
+  }
+})(function (_ref18) {
+  var ownerState = _ref18.ownerState;
+  return _objectSpread(_objectSpread({
+    // Required to overlap preview border
+    transform: 'scale(1.1)',
+    '& > *': {
+      transform: 'scale(0.9)'
+    }
+  }, ownerState.draggable && {
+    cursor: 'grab'
+  }), ownerState.draggable && {
+    touchAction: 'none'
+  });
+});
+var DateRangePickerDayRaw = /*#__PURE__*/React.forwardRef(function DateRangePickerDay(inProps, ref) {
+  var props = useThemeProps({
+    props: inProps,
+    name: 'MuiDateRangePickerDay'
+  });
+  var className = props.className,
+    day = props.day,
+    outsideCurrentMonth = props.outsideCurrentMonth,
+    isEndOfHighlighting = props.isEndOfHighlighting,
+    isEndOfPreviewing = props.isEndOfPreviewing,
+    isHighlighting = props.isHighlighting,
+    isPreviewing = props.isPreviewing,
+    isStartOfHighlighting = props.isStartOfHighlighting,
+    isStartOfPreviewing = props.isStartOfPreviewing,
+    _props$selected = props.selected,
+    selected = _props$selected === void 0 ? false : _props$selected,
+    isVisuallySelected = props.isVisuallySelected,
+    sx = props.sx,
+    draggable = props.draggable,
+    isFirstVisibleCell = props.isFirstVisibleCell,
+    isLastVisibleCell = props.isLastVisibleCell,
+    other = _objectWithoutProperties(props, _excluded);
+  var utils = useUtils();
+  var isEndOfMonth = utils.isSameDay(day, utils.endOfMonth(day));
+  var isStartOfMonth = utils.isSameDay(day, utils.startOfMonth(day));
+  var shouldRenderHighlight = isHighlighting && !outsideCurrentMonth;
+  var shouldRenderPreview = isPreviewing && !outsideCurrentMonth;
+  var ownerState = _objectSpread(_objectSpread({}, props), {}, {
+    selected: selected,
+    isStartOfMonth: isStartOfMonth,
+    isEndOfMonth: isEndOfMonth,
+    draggable: draggable,
+    isFirstVisibleCell: isFirstVisibleCell,
+    isLastVisibleCell: isLastVisibleCell,
+    isHiddenDayFiller: outsideCurrentMonth && !other.showDaysOutsideCurrentMonth
+  });
+  var classes = useUtilityClasses(ownerState);
+  return /*#__PURE__*/React.createElement(DateRangePickerDayRoot, {
+    "data-mui-test": shouldRenderHighlight ? 'DateRangeHighlight' : undefined,
+    className: clsx(classes.root, className),
+    ownerState: ownerState,
+    sx: sx
+  }, /*#__PURE__*/React.createElement(DateRangePickerDayRangeIntervalPreview, {
+    "data-mui-test": shouldRenderPreview ? 'DateRangePreview' : undefined,
+    className: classes.rangeIntervalPreview,
+    ownerState: ownerState
+  }, /*#__PURE__*/React.createElement(DateRangePickerDayDay, _extends({}, other, {
+    ref: ref,
+    disableMargin: true,
+    day: day,
+    selected: isVisuallySelected,
+    outsideCurrentMonth: outsideCurrentMonth,
+    "data-mui-test": "DateRangePickerDay",
+    className: classes.day,
+    ownerState: ownerState,
+    draggable: draggable,
+    isFirstVisibleCell: isFirstVisibleCell,
+    isLastVisibleCell: isLastVisibleCell
+  }))));
+});
+DateRangePickerDayRaw.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "yarn proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * A ref for imperative actions.
+   * It currently only supports `focusVisible()` action.
+   */
+  action: PropTypes.oneOfType([PropTypes.func, PropTypes.shape({
+    current: PropTypes.shape({
+      focusVisible: PropTypes.func.isRequired
+    })
+  })]),
+  /**
+   * If `true`, the ripples are centered.
+   * They won't start at the cursor interaction position.
+   * @default false
+   */
+  centerRipple: PropTypes.bool,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: PropTypes.object,
+  className: PropTypes.string,
+  /**
+   * The date to show.
+   */
+  day: PropTypes.any.isRequired,
+  /**
+   * If `true`, renders as disabled.
+   * @default false
+   */
+  disabled: PropTypes.bool,
+  /**
+   * If `true`, today's date is rendering without highlighting with circle.
+   * @default false
+   */
+  disableHighlightToday: PropTypes.bool,
+  /**
+   * If `true`, days are rendering without margin. Useful for displaying linked range of days.
+   * @default false
+   */
+  disableMargin: PropTypes.bool,
+  /**
+   * If `true`, the ripple effect is disabled.
+   *
+   * ⚠️ Without a ripple there is no styling for :focus-visible by default. Be sure
+   * to highlight the element by applying separate styles with the `.Mui-focusVisible` class.
+   * @default false
+   */
+  disableRipple: PropTypes.bool,
+  /**
+   * If `true`, the touch ripple effect is disabled.
+   * @default false
+   */
+  disableTouchRipple: PropTypes.bool,
+  /**
+   * If `true`, the base button will have a keyboard focus ripple.
+   * @default false
+   */
+  focusRipple: PropTypes.bool,
+  /**
+   * This prop can help identify which element has keyboard focus.
+   * The class name will be applied when the element gains the focus through keyboard interaction.
+   * It's a polyfill for the [CSS :focus-visible selector](https://drafts.csswg.org/selectors-4/#the-focus-visible-pseudo).
+   * The rationale for using this feature [is explained here](https://github.com/WICG/focus-visible/blob/HEAD/explainer.md).
+   * A [polyfill can be used](https://github.com/WICG/focus-visible) to apply a `focus-visible` class to other components
+   * if needed.
+   */
+  focusVisibleClassName: PropTypes.string,
+  isAnimating: PropTypes.bool,
+  /**
+   * Set to `true` if the `day` is the end of a highlighted date range.
+   */
+  isEndOfHighlighting: PropTypes.bool.isRequired,
+  /**
+   * Set to `true` if the `day` is the end of a previewing date range.
+   */
+  isEndOfPreviewing: PropTypes.bool.isRequired,
+  /**
+   * If `true`, day is the first visible cell of the month.
+   * Either the first day of the month or the first day of the week depending on `showDaysOutsideCurrentMonth`.
+   */
+  isFirstVisibleCell: PropTypes.bool.isRequired,
+  /**
+   * Set to `true` if the `day` is in a highlighted date range.
+   */
+  isHighlighting: PropTypes.bool.isRequired,
+  /**
+   * If `true`, day is the last visible cell of the month.
+   * Either the last day of the month or the last day of the week depending on `showDaysOutsideCurrentMonth`.
+   */
+  isLastVisibleCell: PropTypes.bool.isRequired,
+  /**
+   * Set to `true` if the `day` is in a preview date range.
+   */
+  isPreviewing: PropTypes.bool.isRequired,
+  /**
+   * Set to `true` if the `day` is the start of a highlighted date range.
+   */
+  isStartOfHighlighting: PropTypes.bool.isRequired,
+  /**
+   * Set to `true` if the `day` is the start of a previewing date range.
+   */
+  isStartOfPreviewing: PropTypes.bool.isRequired,
+  /**
+   * Indicates if the day should be visually selected.
+   */
+  isVisuallySelected: PropTypes.bool,
+  onDaySelect: PropTypes.func.isRequired,
+  /**
+   * Callback fired when the component is focused with a keyboard.
+   * We trigger a `onFocus` callback too.
+   */
+  onFocusVisible: PropTypes.func,
+  onMouseEnter: PropTypes.func,
+  /**
+   * If `true`, day is outside of month and will be hidden.
+   */
+  outsideCurrentMonth: PropTypes.bool.isRequired,
+  /**
+   * If `true`, renders as selected.
+   * @default false
+   */
+  selected: PropTypes.bool,
+  /**
+   * If `true`, days outside the current month are rendered:
+   *
+   * - if `fixedWeekNumber` is defined, renders days to have the weeks requested.
+   *
+   * - if `fixedWeekNumber` is not defined, renders day to fill the first and last week of the current month.
+   *
+   * - ignored if `calendars` equals more than `1` on range pickers.
+   * @default false
+   */
+  showDaysOutsideCurrentMonth: PropTypes.bool,
+  style: 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]),
+  /**
+   * @default 0
+   */
+  tabIndex: PropTypes.number,
+  /**
+   * If `true`, renders as today date.
+   * @default false
+   */
+  today: PropTypes.bool,
+  /**
+   * Props applied to the `TouchRipple` element.
+   */
+  TouchRippleProps: PropTypes.object,
+  /**
+   * A ref that points to the `TouchRipple` element.
+   */
+  touchRippleRef: PropTypes.oneOfType([PropTypes.func, PropTypes.shape({
+    current: PropTypes.shape({
+      pulsate: PropTypes.func.isRequired,
+      start: PropTypes.func.isRequired,
+      stop: PropTypes.func.isRequired
+    })
+  })])
+};
+
+/**
+ *
+ * Demos:
+ *
+ * - [Date Range Picker](https://mui.com/x/react-date-pickers/date-range-picker/)
+ *
+ * API:
+ *
+ * - [DateRangePickerDay API](https://mui.com/x/api/date-pickers/date-range-picker-day/)
+ */
+export var DateRangePickerDay = /*#__PURE__*/React.memo(DateRangePickerDayRaw);

package/es/DateRangePickerDay/dateRangePickerDayClasses.d.ts

@@ -0,0 +1,42 @@
+export interface DateRangePickerDayClasses {
+    /** Styles applied to the root element. */
+    root: string;
+    /** Styles applied to the root element if `isHighlighting=true`. */
+    rangeIntervalDayHighlight: string;
+    /** Styles applied to the root element if `isStartOfHighlighting=true`. */
+    rangeIntervalDayHighlightStart: string;
+    /** Styles applied to the root element if `isEndOfHighlighting=true`. */
+    rangeIntervalDayHighlightEnd: string;
+    /** Styles applied to the preview element. */
+    rangeIntervalPreview: string;
+    /** Styles applied to the root element if `isPreviewing=true`. */
+    rangeIntervalDayPreview: string;
+    /** Styles applied to the root element if `isStartOfPreviewing=true`. */
+    rangeIntervalDayPreviewStart: string;
+    /** Styles applied to the root element if `isEndOfPreviewing=true`. */
+    rangeIntervalDayPreviewEnd: string;
+    /** Styles applied to the root element if `outsideCurrentMonth=true` */
+    outsideCurrentMonth: string;
+    /** Styles applied to the root element if `day` is the start of the month. */
+    startOfMonth: string;
+    /** Styles applied to the root element if `day` is the end of the month. */
+    endOfMonth: string;
+    /** Styles applied to the root element if `day` is the first visible cell of the month. */
+    firstVisibleCell: string;
+    /** Styles applied to the root element if `day` is the last visible cell of the month. */
+    lastVisibleCell: string;
+    /** Styles applied to the root element if it is an empty cell used to fill the week. */
+    hiddenDayFiller: string;
+    /** Styles applied to the day element. */
+    day: string;
+    /** Styles applied to the day element if `isHighlighting=false`. */
+    dayOutsideRangeInterval: string;
+    /** Styles applied to the day element if `selected=false` and `isHighlighting=true`. */
+    dayInsideRangeInterval: string;
+    /** Styles applied to the day element if `selected=false`. */
+    notSelectedDate: string;
+}
+export declare type DateRangePickerDayClassKey = keyof DateRangePickerDayClasses;
+export declare function getDateRangePickerDayUtilityClass(slot: string): string;
+export declare const dateRangePickerDayClasses: DateRangePickerDayClasses;
+//# sourceMappingURL=dateRangePickerDayClasses.d.ts.map

package/es/DateRangePickerDay/dateRangePickerDayClasses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dateRangePickerDayClasses.d.ts","sourceRoot":"","sources":["dateRangePickerDayClasses.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,yBAAyB;IACxC,0CAA0C;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,mEAAmE;IACnE,yBAAyB,EAAE,MAAM,CAAC;IAClC,0EAA0E;IAC1E,8BAA8B,EAAE,MAAM,CAAC;IACvC,wEAAwE;IACxE,4BAA4B,EAAE,MAAM,CAAC;IACrC,6CAA6C;IAC7C,oBAAoB,EAAE,MAAM,CAAC;IAC7B,iEAAiE;IACjE,uBAAuB,EAAE,MAAM,CAAC;IAChC,wEAAwE;IACxE,4BAA4B,EAAE,MAAM,CAAC;IACrC,sEAAsE;IACtE,0BAA0B,EAAE,MAAM,CAAC;IACnC,uEAAuE;IACvE,mBAAmB,EAAE,MAAM,CAAC;IAC5B,6EAA6E;IAC7E,YAAY,EAAE,MAAM,CAAC;IACrB,2EAA2E;IAC3E,UAAU,EAAE,MAAM,CAAC;IACnB,0FAA0F;IAC1F,gBAAgB,EAAE,MAAM,CAAC;IACzB,yFAAyF;IACzF,eAAe,EAAE,MAAM,CAAC;IACxB,uFAAuF;IACvF,eAAe,EAAE,MAAM,CAAC;IACxB,yCAAyC;IACzC,GAAG,EAAE,MAAM,CAAC;IACZ,mEAAmE;IACnE,uBAAuB,EAAE,MAAM,CAAC;IAChC,uFAAuF;IACvF,sBAAsB,EAAE,MAAM,CAAC;IAC/B,6DAA6D;IAC7D,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,oBAAY,0BAA0B,GAAG,MAAM,yBAAyB,CAAC;AAEzE,wBAAgB,iCAAiC,CAAC,IAAI,EAAE,MAAM,UAE7D;AAED,eAAO,MAAM,yBAAyB,EAAE,yBAsBvC,CAAC"}

package/es/DateRangePickerDay/dateRangePickerDayClasses.js

@@ -0,0 +1,5 @@
+import { unstable_generateUtilityClass as generateUtilityClass, unstable_generateUtilityClasses as generateUtilityClasses } from '@mui/utils';
+export function getDateRangePickerDayUtilityClass(slot) {
+  return generateUtilityClass('MuiDateRangePickerDay', slot);
+}
+export var dateRangePickerDayClasses = generateUtilityClasses('MuiDateRangePickerDay', ['root', 'rangeIntervalDayHighlight', 'rangeIntervalDayHighlightStart', 'rangeIntervalDayHighlightEnd', 'rangeIntervalPreview', 'rangeIntervalDayPreview', 'rangeIntervalDayPreviewStart', 'rangeIntervalDayPreviewEnd', 'outsideCurrentMonth', 'startOfMonth', 'endOfMonth', 'firstVisibleCell', 'lastVisibleCell', 'hiddenDayFiller', 'day', 'dayOutsideRangeInterval', 'dayInsideRangeInterval', 'notSelectedDate']);

package/es/DateRangePickerDay/index.d.ts

@@ -0,0 +1,5 @@
+export { DateRangePickerDay } from './DateRangePickerDay';
+export type { DateRangePickerDayProps } from './DateRangePickerDay';
+export { getDateRangePickerDayUtilityClass, dateRangePickerDayClasses, } from './dateRangePickerDayClasses';
+export type { DateRangePickerDayClasses, DateRangePickerDayClassKey, } from './dateRangePickerDayClasses';
+//# sourceMappingURL=index.d.ts.map

package/es/DateRangePickerDay/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,YAAY,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAEpE,OAAO,EACL,iCAAiC,EACjC,yBAAyB,GAC1B,MAAM,6BAA6B,CAAC;AACrC,YAAY,EACV,yBAAyB,EACzB,0BAA0B,GAC3B,MAAM,6BAA6B,CAAC"}

package/es/DateRangePickerDay/index.js

@@ -0,0 +1,2 @@
+export { DateRangePickerDay } from "./DateRangePickerDay";
+export { getDateRangePickerDayUtilityClass, dateRangePickerDayClasses } from "./dateRangePickerDayClasses";

package/es/DesktopDateRangePicker/DesktopDateRangePicker.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { DesktopDateRangePickerProps } from './DesktopDateRangePicker.types';
+declare type DesktopDateRangePickerComponent = (<TDate>(props: DesktopDateRangePickerProps<TDate> & React.RefAttributes<HTMLDivElement>) => JSX.Element) & {
+    propTypes?: any;
+};
+declare const DesktopDateRangePicker: DesktopDateRangePickerComponent;
+export { DesktopDateRangePicker };
+//# sourceMappingURL=DesktopDateRangePicker.d.ts.map

package/es/DesktopDateRangePicker/DesktopDateRangePicker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DesktopDateRangePicker.d.ts","sourceRoot":"","sources":["DesktopDateRangePicker.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAK/B,OAAO,EAAE,2BAA2B,EAAE,MAAM,gCAAgC,CAAC;AAQ7E,aAAK,+BAA+B,GAAG,CAAC,CAAC,KAAK,EAC5C,KAAK,EAAE,2BAA2B,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,aAAa,CAAC,cAAc,CAAC,KAC5E,GAAG,CAAC,OAAO,CAAC,GAAG;IAAE,SAAS,CAAC,EAAE,GAAG,CAAA;CAAE,CAAC;AAExC,QAAA,MAAM,sBAAsB,iCA+CS,CAAC;AA4TtC,OAAO,EAAE,sBAAsB,EAAE,CAAC"}