tp-react-elements-dev 1.12.35 → 1.14.0

package/dist/node_modules/react-date-range/dist/components/DateInput/index.esm.js

@@ -0,0 +1,153 @@
+import { __exports as DateInput } from '../../../../../_virtual/index.esm12.js';
+import React__default from 'react';
+import { __require as requirePropTypes } from '../../../../prop-types/index.esm.js';
+import { __require as requireClassnames } from '../../../../classnames/index.esm.js';
+import require$$3 from 'date-fns';
+
+var hasRequiredDateInput;
+
+function requireDateInput () {
+	if (hasRequiredDateInput) return DateInput;
+	hasRequiredDateInput = 1;
+
+	Object.defineProperty(DateInput, "__esModule", {
+	  value: true
+	});
+	DateInput.default = void 0;
+	var _react = _interopRequireWildcard(React__default);
+	var _propTypes = _interopRequireDefault(/*@__PURE__*/ requirePropTypes());
+	var _classnames = _interopRequireDefault(requireClassnames());
+	var _dateFns = require$$3;
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+	function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+	function _interopRequireWildcard(e, r) { if (e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+	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(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
+	function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+	let DateInput$1 = class DateInput extends _react.PureComponent {
+	  constructor(props, context) {
+	    super(props, context);
+	    _defineProperty(this, "onKeyDown", e => {
+	      const {
+	        value
+	      } = this.state;
+	      if (e.key === 'Enter') {
+	        this.update(value);
+	      }
+	    });
+	    _defineProperty(this, "onChange", e => {
+	      this.setState({
+	        value: e.target.value,
+	        changed: true,
+	        invalid: false
+	      });
+	    });
+	    _defineProperty(this, "onBlur", () => {
+	      const {
+	        value
+	      } = this.state;
+	      this.update(value);
+	    });
+	    this.state = {
+	      invalid: false,
+	      changed: false,
+	      value: this.formatDate(props)
+	    };
+	  }
+	  componentDidUpdate(prevProps) {
+	    const {
+	      value
+	    } = prevProps;
+	    if (!(0, _dateFns.isEqual)(value, this.props.value)) {
+	      this.setState({
+	        value: this.formatDate(this.props)
+	      });
+	    }
+	  }
+	  formatDate(_ref) {
+	    let {
+	      value,
+	      dateDisplayFormat,
+	      dateOptions
+	    } = _ref;
+	    if (value && (0, _dateFns.isValid)(value)) {
+	      return (0, _dateFns.format)(value, dateDisplayFormat, dateOptions);
+	    }
+	    return '';
+	  }
+	  update(value) {
+	    const {
+	      invalid,
+	      changed
+	    } = this.state;
+	    if (invalid || !changed || !value) {
+	      return;
+	    }
+	    const {
+	      onChange,
+	      dateDisplayFormat,
+	      dateOptions
+	    } = this.props;
+	    const parsed = (0, _dateFns.parse)(value, dateDisplayFormat, new Date(), dateOptions);
+	    if ((0, _dateFns.isValid)(parsed)) {
+	      this.setState({
+	        changed: false
+	      }, () => onChange(parsed));
+	    } else {
+	      this.setState({
+	        invalid: true
+	      });
+	    }
+	  }
+	  render() {
+	    const {
+	      className,
+	      readOnly,
+	      placeholder,
+	      ariaLabel,
+	      disabled,
+	      onFocus
+	    } = this.props;
+	    const {
+	      value,
+	      invalid
+	    } = this.state;
+	    return /*#__PURE__*/_react.default.createElement("span", {
+	      className: (0, _classnames.default)('rdrDateInput', className)
+	    }, /*#__PURE__*/_react.default.createElement("input", {
+	      readOnly: readOnly,
+	      disabled: disabled,
+	      value: value,
+	      placeholder: placeholder,
+	      "aria-label": ariaLabel,
+	      onKeyDown: this.onKeyDown,
+	      onChange: this.onChange,
+	      onBlur: this.onBlur,
+	      onFocus: onFocus
+	    }), invalid && /*#__PURE__*/_react.default.createElement("span", {
+	      className: "rdrWarning"
+	    }, "\u26A0"));
+	  }
+	};
+	DateInput$1.propTypes = {
+	  value: _propTypes.default.object,
+	  placeholder: _propTypes.default.string,
+	  disabled: _propTypes.default.bool,
+	  readOnly: _propTypes.default.bool,
+	  dateOptions: _propTypes.default.object,
+	  dateDisplayFormat: _propTypes.default.string,
+	  ariaLabel: _propTypes.default.string,
+	  className: _propTypes.default.string,
+	  onFocus: _propTypes.default.func.isRequired,
+	  onChange: _propTypes.default.func.isRequired
+	};
+	DateInput$1.defaultProps = {
+	  readOnly: true,
+	  disabled: false,
+	  dateDisplayFormat: 'MMM D, YYYY'
+	};
+	DateInput.default = DateInput$1;
+	return DateInput;
+}
+
+export { requireDateInput as __require };

package/dist/node_modules/react-date-range/dist/components/DateRange/index.esm.js

@@ -0,0 +1,212 @@
+import { __exports as DateRange } from '../../../../../_virtual/index.esm6.js';
+import React__default from 'react';
+import { __require as requirePropTypes } from '../../../../prop-types/index.esm.js';
+import { __require as requireCalendar } from '../Calendar/index.esm.js';
+import { __require as requireDayCell } from '../DayCell/index.esm.js';
+import { __require as requireUtils } from '../../utils.esm.js';
+import require$$3 from 'date-fns';
+import { __require as requireClassnames } from '../../../../classnames/index.esm.js';
+import { __require as requireStyles } from '../../styles.esm.js';
+
+var hasRequiredDateRange;
+
+function requireDateRange () {
+	if (hasRequiredDateRange) return DateRange;
+	hasRequiredDateRange = 1;
+
+	Object.defineProperty(DateRange, "__esModule", {
+	  value: true
+	});
+	DateRange.default = void 0;
+	var _react = _interopRequireWildcard(React__default);
+	var _propTypes = _interopRequireDefault(/*@__PURE__*/ requirePropTypes());
+	var _Calendar = _interopRequireDefault(requireCalendar());
+	var _DayCell = requireDayCell();
+	var _utils = requireUtils();
+	var _dateFns = require$$3;
+	var _classnames = _interopRequireDefault(requireClassnames());
+	var _styles = _interopRequireDefault(requireStyles());
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+	function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+	function _interopRequireWildcard(e, r) { if (e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+	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 _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(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
+	function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+	let DateRange$1 = class DateRange extends _react.Component {
+	  constructor(props, context) {
+	    var _this;
+	    super(props, context);
+	    _this = this;
+	    _defineProperty(this, "calcNewSelection", function (value) {
+	      let isSingleValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+	      const focusedRange = _this.props.focusedRange || _this.state.focusedRange;
+	      const {
+	        ranges,
+	        onChange,
+	        maxDate,
+	        moveRangeOnFirstSelection,
+	        retainEndDateOnFirstSelection,
+	        disabledDates
+	      } = _this.props;
+	      const focusedRangeIndex = focusedRange[0];
+	      const selectedRange = ranges[focusedRangeIndex];
+	      if (!selectedRange || !onChange) return {};
+	      let {
+	        startDate,
+	        endDate
+	      } = selectedRange;
+	      const now = new Date();
+	      let nextFocusRange;
+	      if (!isSingleValue) {
+	        startDate = value.startDate;
+	        endDate = value.endDate;
+	      } else if (focusedRange[1] === 0) {
+	        // startDate selection
+	        const dayOffset = (0, _dateFns.differenceInCalendarDays)(endDate || now, startDate);
+	        const calculateEndDate = () => {
+	          if (moveRangeOnFirstSelection) {
+	            return (0, _dateFns.addDays)(value, dayOffset);
+	          }
+	          if (retainEndDateOnFirstSelection) {
+	            if (!endDate || (0, _dateFns.isBefore)(value, endDate)) {
+	              return endDate;
+	            }
+	            return value;
+	          }
+	          return value || now;
+	        };
+	        startDate = value;
+	        endDate = calculateEndDate();
+	        if (maxDate) endDate = (0, _dateFns.min)([endDate, maxDate]);
+	        nextFocusRange = [focusedRange[0], 1];
+	      } else {
+	        endDate = value;
+	      }
+
+	      // reverse dates if startDate before endDate
+	      let isStartDateSelected = focusedRange[1] === 0;
+	      if ((0, _dateFns.isBefore)(endDate, startDate)) {
+	        isStartDateSelected = !isStartDateSelected;
+	        [startDate, endDate] = [endDate, startDate];
+	      }
+	      const inValidDatesWithinRange = disabledDates.filter(disabledDate => (0, _dateFns.isWithinInterval)(disabledDate, {
+	        start: startDate,
+	        end: endDate
+	      }));
+	      if (inValidDatesWithinRange.length > 0) {
+	        if (isStartDateSelected) {
+	          startDate = (0, _dateFns.addDays)((0, _dateFns.max)(inValidDatesWithinRange), 1);
+	        } else {
+	          endDate = (0, _dateFns.addDays)((0, _dateFns.min)(inValidDatesWithinRange), -1);
+	        }
+	      }
+	      if (!nextFocusRange) {
+	        const nextFocusRangeIndex = (0, _utils.findNextRangeIndex)(_this.props.ranges, focusedRange[0]);
+	        nextFocusRange = [nextFocusRangeIndex, 0];
+	      }
+	      return {
+	        wasValid: !(inValidDatesWithinRange.length > 0),
+	        range: {
+	          startDate,
+	          endDate
+	        },
+	        nextFocusRange: nextFocusRange
+	      };
+	    });
+	    _defineProperty(this, "setSelection", (value, isSingleValue) => {
+	      const {
+	        onChange,
+	        ranges,
+	        onRangeFocusChange
+	      } = this.props;
+	      const focusedRange = this.props.focusedRange || this.state.focusedRange;
+	      const focusedRangeIndex = focusedRange[0];
+	      const selectedRange = ranges[focusedRangeIndex];
+	      if (!selectedRange) return;
+	      const newSelection = this.calcNewSelection(value, isSingleValue);
+	      onChange({
+	        [selectedRange.key || `range${focusedRangeIndex + 1}`]: {
+	          ...selectedRange,
+	          ...newSelection.range
+	        }
+	      });
+	      this.setState({
+	        focusedRange: newSelection.nextFocusRange,
+	        preview: null
+	      });
+	      onRangeFocusChange && onRangeFocusChange(newSelection.nextFocusRange);
+	    });
+	    _defineProperty(this, "handleRangeFocusChange", focusedRange => {
+	      this.setState({
+	        focusedRange
+	      });
+	      this.props.onRangeFocusChange && this.props.onRangeFocusChange(focusedRange);
+	    });
+	    _defineProperty(this, "updatePreview", val => {
+	      if (!val) {
+	        this.setState({
+	          preview: null
+	        });
+	        return;
+	      }
+	      const {
+	        rangeColors,
+	        ranges
+	      } = this.props;
+	      const focusedRange = this.props.focusedRange || this.state.focusedRange;
+	      const color = ranges[focusedRange[0]]?.color || rangeColors[focusedRange[0]] || color;
+	      this.setState({
+	        preview: {
+	          ...val.range,
+	          color
+	        }
+	      });
+	    });
+	    this.state = {
+	      focusedRange: props.initialFocusedRange || [(0, _utils.findNextRangeIndex)(props.ranges), 0],
+	      preview: null
+	    };
+	    this.styles = (0, _utils.generateStyles)([_styles.default, props.classNames]);
+	  }
+	  render() {
+	    return /*#__PURE__*/_react.default.createElement(_Calendar.default, _extends({
+	      focusedRange: this.state.focusedRange,
+	      onRangeFocusChange: this.handleRangeFocusChange,
+	      preview: this.state.preview,
+	      onPreviewChange: value => {
+	        this.updatePreview(value ? this.calcNewSelection(value) : null);
+	      }
+	    }, this.props, {
+	      displayMode: "dateRange",
+	      className: (0, _classnames.default)(this.styles.dateRangeWrapper, this.props.className),
+	      onChange: this.setSelection,
+	      updateRange: val => this.setSelection(val, false),
+	      ref: target => {
+	        this.calendar = target;
+	      }
+	    }));
+	  }
+	};
+	DateRange$1.defaultProps = {
+	  classNames: {},
+	  ranges: [],
+	  moveRangeOnFirstSelection: false,
+	  retainEndDateOnFirstSelection: false,
+	  rangeColors: ['#3d91ff', '#3ecf8e', '#fed14c'],
+	  disabledDates: []
+	};
+	DateRange$1.propTypes = {
+	  ..._Calendar.default.propTypes,
+	  onChange: _propTypes.default.func,
+	  onRangeFocusChange: _propTypes.default.func,
+	  className: _propTypes.default.string,
+	  ranges: _propTypes.default.arrayOf(_DayCell.rangeShape),
+	  moveRangeOnFirstSelection: _propTypes.default.bool,
+	  retainEndDateOnFirstSelection: _propTypes.default.bool
+	};
+	DateRange.default = DateRange$1;
+	return DateRange;
+}
+
+export { requireDateRange as __require };

package/dist/node_modules/react-date-range/dist/components/DateRangePicker/index.esm.js

@@ -0,0 +1,72 @@
+import { __exports as DateRangePicker } from '../../../../../_virtual/index.esm4.js';
+import React__default from 'react';
+import { __require as requirePropTypes } from '../../../../prop-types/index.esm.js';
+import { __require as requireDateRange } from '../DateRange/index.esm.js';
+import { __require as requireDefinedRange } from '../DefinedRange/index.esm.js';
+import { __require as requireUtils } from '../../utils.esm.js';
+import { __require as requireClassnames } from '../../../../classnames/index.esm.js';
+import { __require as requireStyles } from '../../styles.esm.js';
+
+var hasRequiredDateRangePicker;
+
+function requireDateRangePicker () {
+	if (hasRequiredDateRangePicker) return DateRangePicker;
+	hasRequiredDateRangePicker = 1;
+
+	Object.defineProperty(DateRangePicker, "__esModule", {
+	  value: true
+	});
+	DateRangePicker.default = void 0;
+	var _react = _interopRequireWildcard(React__default);
+	var _propTypes = _interopRequireDefault(/*@__PURE__*/ requirePropTypes());
+	var _DateRange = _interopRequireDefault(requireDateRange());
+	var _DefinedRange = _interopRequireDefault(requireDefinedRange());
+	var _utils = requireUtils();
+	var _classnames = _interopRequireDefault(requireClassnames());
+	var _styles = _interopRequireDefault(requireStyles());
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+	function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+	function _interopRequireWildcard(e, r) { if (e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+	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); }
+	let DateRangePicker$1 = class DateRangePicker extends _react.Component {
+	  constructor(props) {
+	    super(props);
+	    this.state = {
+	      focusedRange: [(0, _utils.findNextRangeIndex)(props.ranges), 0]
+	    };
+	    this.styles = (0, _utils.generateStyles)([_styles.default, props.classNames]);
+	  }
+	  render() {
+	    const {
+	      focusedRange
+	    } = this.state;
+	    return /*#__PURE__*/_react.default.createElement("div", {
+	      className: (0, _classnames.default)(this.styles.dateRangePickerWrapper, this.props.className)
+	    }, /*#__PURE__*/_react.default.createElement(_DefinedRange.default, _extends({
+	      focusedRange: focusedRange,
+	      onPreviewChange: value => this.dateRange.updatePreview(value ? this.dateRange.calcNewSelection(value, typeof value === 'string') : null)
+	    }, this.props, {
+	      range: this.props.ranges[focusedRange[0]],
+	      className: undefined
+	    })), /*#__PURE__*/_react.default.createElement(_DateRange.default, _extends({
+	      onRangeFocusChange: focusedRange => this.setState({
+	        focusedRange
+	      }),
+	      focusedRange: focusedRange
+	    }, this.props, {
+	      ref: t => this.dateRange = t,
+	      className: undefined
+	    })));
+	  }
+	};
+	DateRangePicker$1.defaultProps = {};
+	DateRangePicker$1.propTypes = {
+	  ..._DateRange.default.propTypes,
+	  ..._DefinedRange.default.propTypes,
+	  className: _propTypes.default.string
+	};
+	DateRangePicker.default = DateRangePicker$1;
+	return DateRangePicker;
+}
+
+export { requireDateRangePicker as __require };

package/dist/node_modules/react-date-range/dist/components/DayCell/index.esm.js

@@ -0,0 +1,252 @@
+import { __exports as DayCell } from '../../../../../_virtual/index.esm10.js';
+import React__default from 'react';
+import { __require as requirePropTypes } from '../../../../prop-types/index.esm.js';
+import { __require as requireClassnames } from '../../../../classnames/index.esm.js';
+import require$$3 from 'date-fns';
+
+var hasRequiredDayCell;
+
+function requireDayCell () {
+	if (hasRequiredDayCell) return DayCell;
+	hasRequiredDayCell = 1;
+
+	Object.defineProperty(DayCell, "__esModule", {
+	  value: true
+	});
+	DayCell.rangeShape = DayCell.default = void 0;
+	var _react = _interopRequireWildcard(React__default);
+	var _propTypes = _interopRequireDefault(/*@__PURE__*/ requirePropTypes());
+	var _classnames = _interopRequireDefault(requireClassnames());
+	var _dateFns = require$$3;
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+	function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+	function _interopRequireWildcard(e, r) { if (e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+	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 _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(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
+	function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } /* eslint-disable no-fallthrough */
+	let DayCell$1 = class DayCell extends _react.Component {
+	  constructor(props, context) {
+	    super(props, context);
+	    _defineProperty(this, "handleKeyEvent", event => {
+	      const {
+	        day,
+	        onMouseDown,
+	        onMouseUp
+	      } = this.props;
+	      if ([13 /* space */, 32 /* enter */].includes(event.keyCode)) {
+	        if (event.type === 'keydown') onMouseDown(day);else onMouseUp(day);
+	      }
+	    });
+	    _defineProperty(this, "handleMouseEvent", event => {
+	      const {
+	        day,
+	        disabled,
+	        onPreviewChange,
+	        onMouseEnter,
+	        onMouseDown,
+	        onMouseUp
+	      } = this.props;
+	      const stateChanges = {};
+	      if (disabled) {
+	        onPreviewChange();
+	        return;
+	      }
+	      switch (event.type) {
+	        case 'mouseenter':
+	          onMouseEnter(day);
+	          onPreviewChange(day);
+	          stateChanges.hover = true;
+	          break;
+	        case 'blur':
+	        case 'mouseleave':
+	          stateChanges.hover = false;
+	          break;
+	        case 'mousedown':
+	          stateChanges.active = true;
+	          onMouseDown(day);
+	          break;
+	        case 'mouseup':
+	          event.stopPropagation();
+	          stateChanges.active = false;
+	          onMouseUp(day);
+	          break;
+	        case 'focus':
+	          onPreviewChange(day);
+	          break;
+	      }
+	      if (Object.keys(stateChanges).length) {
+	        this.setState(stateChanges);
+	      }
+	    });
+	    _defineProperty(this, "getClassNames", () => {
+	      const {
+	        isPassive,
+	        isToday,
+	        isWeekend,
+	        isStartOfWeek,
+	        isEndOfWeek,
+	        isStartOfMonth,
+	        isEndOfMonth,
+	        disabled,
+	        styles
+	      } = this.props;
+	      return (0, _classnames.default)(styles.day, {
+	        [styles.dayPassive]: isPassive,
+	        [styles.dayDisabled]: disabled,
+	        [styles.dayToday]: isToday,
+	        [styles.dayWeekend]: isWeekend,
+	        [styles.dayStartOfWeek]: isStartOfWeek,
+	        [styles.dayEndOfWeek]: isEndOfWeek,
+	        [styles.dayStartOfMonth]: isStartOfMonth,
+	        [styles.dayEndOfMonth]: isEndOfMonth,
+	        [styles.dayHovered]: this.state.hover,
+	        [styles.dayActive]: this.state.active
+	      });
+	    });
+	    _defineProperty(this, "renderPreviewPlaceholder", () => {
+	      const {
+	        preview,
+	        day,
+	        styles
+	      } = this.props;
+	      if (!preview) return null;
+	      const startDate = preview.startDate ? (0, _dateFns.endOfDay)(preview.startDate) : null;
+	      const endDate = preview.endDate ? (0, _dateFns.startOfDay)(preview.endDate) : null;
+	      const isInRange = (!startDate || (0, _dateFns.isAfter)(day, startDate)) && (!endDate || (0, _dateFns.isBefore)(day, endDate));
+	      const isStartEdge = !isInRange && (0, _dateFns.isSameDay)(day, startDate);
+	      const isEndEdge = !isInRange && (0, _dateFns.isSameDay)(day, endDate);
+	      return /*#__PURE__*/_react.default.createElement("span", {
+	        className: (0, _classnames.default)({
+	          [styles.dayStartPreview]: isStartEdge,
+	          [styles.dayInPreview]: isInRange,
+	          [styles.dayEndPreview]: isEndEdge
+	        }),
+	        style: {
+	          color: preview.color
+	        }
+	      });
+	    });
+	    _defineProperty(this, "renderSelectionPlaceholders", () => {
+	      const {
+	        styles,
+	        ranges,
+	        day
+	      } = this.props;
+	      if (this.props.displayMode === 'date') {
+	        let isSelected = (0, _dateFns.isSameDay)(this.props.day, this.props.date);
+	        return isSelected ? /*#__PURE__*/_react.default.createElement("span", {
+	          className: styles.selected,
+	          style: {
+	            color: this.props.color
+	          }
+	        }) : null;
+	      }
+	      const inRanges = ranges.reduce((result, range) => {
+	        let startDate = range.startDate;
+	        let endDate = range.endDate;
+	        if (startDate && endDate && (0, _dateFns.isBefore)(endDate, startDate)) {
+	          [startDate, endDate] = [endDate, startDate];
+	        }
+	        startDate = startDate ? (0, _dateFns.endOfDay)(startDate) : null;
+	        endDate = endDate ? (0, _dateFns.startOfDay)(endDate) : null;
+	        const isInRange = (!startDate || (0, _dateFns.isAfter)(day, startDate)) && (!endDate || (0, _dateFns.isBefore)(day, endDate));
+	        const isStartEdge = !isInRange && (0, _dateFns.isSameDay)(day, startDate);
+	        const isEndEdge = !isInRange && (0, _dateFns.isSameDay)(day, endDate);
+	        if (isInRange || isStartEdge || isEndEdge) {
+	          return [...result, {
+	            isStartEdge,
+	            isEndEdge: isEndEdge,
+	            isInRange,
+	            ...range
+	          }];
+	        }
+	        return result;
+	      }, []);
+	      return inRanges.map((range, i) => /*#__PURE__*/_react.default.createElement("span", {
+	        key: i,
+	        className: (0, _classnames.default)({
+	          [styles.startEdge]: range.isStartEdge,
+	          [styles.endEdge]: range.isEndEdge,
+	          [styles.inRange]: range.isInRange
+	        }),
+	        style: {
+	          color: range.color || this.props.color
+	        }
+	      }));
+	    });
+	    this.state = {
+	      hover: false,
+	      active: false
+	    };
+	  }
+	  render() {
+	    const {
+	      dayContentRenderer
+	    } = this.props;
+	    return /*#__PURE__*/_react.default.createElement("button", _extends({
+	      type: "button",
+	      onMouseEnter: this.handleMouseEvent,
+	      onMouseLeave: this.handleMouseEvent,
+	      onFocus: this.handleMouseEvent,
+	      onMouseDown: this.handleMouseEvent,
+	      onMouseUp: this.handleMouseEvent,
+	      onBlur: this.handleMouseEvent,
+	      onPauseCapture: this.handleMouseEvent,
+	      onKeyDown: this.handleKeyEvent,
+	      onKeyUp: this.handleKeyEvent,
+	      className: this.getClassNames(this.props.styles)
+	    }, this.props.disabled || this.props.isPassive ? {
+	      tabIndex: -1
+	    } : {}, {
+	      style: {
+	        color: this.props.color
+	      }
+	    }), this.renderSelectionPlaceholders(), this.renderPreviewPlaceholder(), /*#__PURE__*/_react.default.createElement("span", {
+	      className: this.props.styles.dayNumber
+	    }, dayContentRenderer?.(this.props.day) || /*#__PURE__*/_react.default.createElement("span", null, (0, _dateFns.format)(this.props.day, this.props.dayDisplayFormat))));
+	  }
+	};
+	DayCell$1.defaultProps = {};
+	const rangeShape = DayCell.rangeShape = _propTypes.default.shape({
+	  startDate: _propTypes.default.object,
+	  endDate: _propTypes.default.object,
+	  color: _propTypes.default.string,
+	  key: _propTypes.default.string,
+	  autoFocus: _propTypes.default.bool,
+	  disabled: _propTypes.default.bool,
+	  showDateDisplay: _propTypes.default.bool
+	});
+	DayCell$1.propTypes = {
+	  day: _propTypes.default.object.isRequired,
+	  dayDisplayFormat: _propTypes.default.string,
+	  date: _propTypes.default.object,
+	  ranges: _propTypes.default.arrayOf(rangeShape),
+	  preview: _propTypes.default.shape({
+	    startDate: _propTypes.default.object,
+	    endDate: _propTypes.default.object,
+	    color: _propTypes.default.string
+	  }),
+	  onPreviewChange: _propTypes.default.func,
+	  previewColor: _propTypes.default.string,
+	  disabled: _propTypes.default.bool,
+	  isPassive: _propTypes.default.bool,
+	  isToday: _propTypes.default.bool,
+	  isWeekend: _propTypes.default.bool,
+	  isStartOfWeek: _propTypes.default.bool,
+	  isEndOfWeek: _propTypes.default.bool,
+	  isStartOfMonth: _propTypes.default.bool,
+	  isEndOfMonth: _propTypes.default.bool,
+	  color: _propTypes.default.string,
+	  displayMode: _propTypes.default.oneOf(['dateRange', 'date']),
+	  styles: _propTypes.default.object,
+	  onMouseDown: _propTypes.default.func,
+	  onMouseUp: _propTypes.default.func,
+	  onMouseEnter: _propTypes.default.func,
+	  dayContentRenderer: _propTypes.default.func
+	};
+	DayCell.default = DayCell$1;
+	return DayCell;
+}
+
+export { requireDayCell as __require };