tp-react-elements 1.0.0

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

@@ -0,0 +1,166 @@
+import { __exports as DefinedRange } from '../../../../../_virtual/index.esm4.js';
+import React__default from 'react';
+import { __require as requirePropTypes } from '../../../../prop-types/index.esm.js';
+import { __require as requireStyles } from '../../styles.esm.js';
+import { __require as requireDefaultRanges } from '../../defaultRanges.esm.js';
+import { __require as requireDayCell } from '../DayCell/index.esm.js';
+import { __require as requireInputRangeField } from '../InputRangeField/index.esm.js';
+import { __require as requireClassnames } from '../../../../classnames/index.esm.js';
+
+var hasRequiredDefinedRange;
+
+function requireDefinedRange () {
+	if (hasRequiredDefinedRange) return DefinedRange;
+	hasRequiredDefinedRange = 1;
+
+	Object.defineProperty(DefinedRange, "__esModule", {
+	  value: true
+	});
+	DefinedRange.default = void 0;
+	var _react = _interopRequireWildcard(React__default);
+	var _propTypes = _interopRequireDefault(/*@__PURE__*/ requirePropTypes());
+	var _styles = _interopRequireDefault(requireStyles());
+	var _defaultRanges = requireDefaultRanges();
+	var _DayCell = requireDayCell();
+	var _InputRangeField = _interopRequireDefault(requireInputRangeField());
+	var _classnames = _interopRequireDefault(requireClassnames());
+	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 DefinedRange$1 = class DefinedRange extends _react.Component {
+	  constructor(props) {
+	    super(props);
+	    _defineProperty(this, "handleRangeChange", range => {
+	      const {
+	        onChange,
+	        ranges,
+	        focusedRange
+	      } = this.props;
+	      const selectedRange = ranges[focusedRange[0]];
+	      if (!onChange || !selectedRange) return;
+	      onChange({
+	        [selectedRange.key || `range${focusedRange[0] + 1}`]: {
+	          ...selectedRange,
+	          ...range
+	        }
+	      });
+	    });
+	    this.state = {
+	      rangeOffset: 0,
+	      focusedInput: -1
+	    };
+	  }
+	  getRangeOptionValue(option) {
+	    const {
+	      ranges = [],
+	      focusedRange = []
+	    } = this.props;
+	    if (typeof option.getCurrentValue !== 'function') {
+	      return '';
+	    }
+	    const selectedRange = ranges[focusedRange[0]] || {};
+	    return option.getCurrentValue(selectedRange) || '';
+	  }
+	  getSelectedRange(ranges, staticRange) {
+	    const focusedRangeIndex = ranges.findIndex(range => {
+	      if (!range.startDate || !range.endDate || range.disabled) return false;
+	      return staticRange.isSelected(range);
+	    });
+	    const selectedRange = ranges[focusedRangeIndex];
+	    return {
+	      selectedRange,
+	      focusedRangeIndex
+	    };
+	  }
+	  render() {
+	    const {
+	      headerContent,
+	      footerContent,
+	      onPreviewChange,
+	      inputRanges,
+	      staticRanges,
+	      ranges,
+	      renderStaticRangeLabel,
+	      rangeColors,
+	      className
+	    } = this.props;
+	    return /*#__PURE__*/_react.default.createElement("div", {
+	      className: (0, _classnames.default)(_styles.default.definedRangesWrapper, className)
+	    }, headerContent, /*#__PURE__*/_react.default.createElement("div", {
+	      className: _styles.default.staticRanges
+	    }, staticRanges.map((staticRange, i) => {
+	      const {
+	        selectedRange,
+	        focusedRangeIndex
+	      } = this.getSelectedRange(ranges, staticRange);
+	      let labelContent;
+	      if (staticRange.hasCustomRendering) {
+	        labelContent = renderStaticRangeLabel(staticRange);
+	      } else {
+	        labelContent = staticRange.label;
+	      }
+	      return /*#__PURE__*/_react.default.createElement("button", {
+	        type: "button",
+	        className: (0, _classnames.default)(_styles.default.staticRange, {
+	          [_styles.default.staticRangeSelected]: Boolean(selectedRange)
+	        }),
+	        style: {
+	          color: selectedRange ? selectedRange.color || rangeColors[focusedRangeIndex] : null
+	        },
+	        key: i,
+	        onClick: () => this.handleRangeChange(staticRange.range(this.props)),
+	        onFocus: () => onPreviewChange && onPreviewChange(staticRange.range(this.props)),
+	        onMouseOver: () => onPreviewChange && onPreviewChange(staticRange.range(this.props)),
+	        onMouseLeave: () => {
+	          onPreviewChange && onPreviewChange();
+	        }
+	      }, /*#__PURE__*/_react.default.createElement("span", {
+	        tabIndex: -1,
+	        className: _styles.default.staticRangeLabel
+	      }, labelContent));
+	    })), /*#__PURE__*/_react.default.createElement("div", {
+	      className: _styles.default.inputRanges
+	    }, inputRanges.map((rangeOption, i) => /*#__PURE__*/_react.default.createElement(_InputRangeField.default, {
+	      key: i,
+	      styles: _styles.default,
+	      label: rangeOption.label,
+	      onFocus: () => this.setState({
+	        focusedInput: i,
+	        rangeOffset: 0
+	      }),
+	      onBlur: () => this.setState({
+	        rangeOffset: 0
+	      }),
+	      onChange: value => this.handleRangeChange(rangeOption.range(value, this.props)),
+	      value: this.getRangeOptionValue(rangeOption)
+	    }))), footerContent);
+	  }
+	};
+	DefinedRange$1.propTypes = {
+	  inputRanges: _propTypes.default.array,
+	  staticRanges: _propTypes.default.array,
+	  ranges: _propTypes.default.arrayOf(_DayCell.rangeShape),
+	  focusedRange: _propTypes.default.arrayOf(_propTypes.default.number),
+	  onPreviewChange: _propTypes.default.func,
+	  onChange: _propTypes.default.func,
+	  footerContent: _propTypes.default.any,
+	  headerContent: _propTypes.default.any,
+	  rangeColors: _propTypes.default.arrayOf(_propTypes.default.string),
+	  className: _propTypes.default.string,
+	  renderStaticRangeLabel: _propTypes.default.func
+	};
+	DefinedRange$1.defaultProps = {
+	  inputRanges: _defaultRanges.defaultInputRanges,
+	  staticRanges: _defaultRanges.defaultStaticRanges,
+	  ranges: [],
+	  rangeColors: ['#3d91ff', '#3ecf8e', '#fed14c'],
+	  focusedRange: [0, 0]
+	};
+	DefinedRange.default = DefinedRange$1;
+	return DefinedRange;
+}
+
+export { requireDefinedRange as __require };

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

@@ -0,0 +1,91 @@
+import { __exports as InputRangeField } from '../../../../../_virtual/index.esm12.js';
+import React__default from 'react';
+import { __require as requirePropTypes } from '../../../../prop-types/index.esm.js';
+
+var hasRequiredInputRangeField;
+
+function requireInputRangeField () {
+	if (hasRequiredInputRangeField) return InputRangeField;
+	hasRequiredInputRangeField = 1;
+
+	Object.defineProperty(InputRangeField, "__esModule", {
+	  value: true
+	});
+	InputRangeField.default = void 0;
+	var _react = _interopRequireWildcard(React__default);
+	var _propTypes = _interopRequireDefault(/*@__PURE__*/ requirePropTypes());
+	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); }
+	const MIN = 0;
+	const MAX = 99999;
+	let InputRangeField$1 = class InputRangeField extends _react.Component {
+	  constructor(props, context) {
+	    super(props, context);
+	    _defineProperty(this, "onChange", e => {
+	      const {
+	        onChange
+	      } = this.props;
+	      let value = parseInt(e.target.value, 10);
+	      value = isNaN(value) ? 0 : Math.max(Math.min(MAX, value), MIN);
+	      onChange(value);
+	    });
+	  }
+	  shouldComponentUpdate(nextProps) {
+	    const {
+	      value,
+	      label,
+	      placeholder
+	    } = this.props;
+	    return value !== nextProps.value || label !== nextProps.label || placeholder !== nextProps.placeholder;
+	  }
+	  render() {
+	    const {
+	      label,
+	      placeholder,
+	      value,
+	      styles,
+	      onBlur,
+	      onFocus
+	    } = this.props;
+	    return /*#__PURE__*/_react.default.createElement("div", {
+	      className: styles.inputRange
+	    }, /*#__PURE__*/_react.default.createElement("input", {
+	      className: styles.inputRangeInput,
+	      placeholder: placeholder,
+	      value: value,
+	      min: MIN,
+	      max: MAX,
+	      onChange: this.onChange,
+	      onFocus: onFocus,
+	      onBlur: onBlur
+	    }), /*#__PURE__*/_react.default.createElement("span", {
+	      className: styles.inputRangeLabel
+	    }, label));
+	  }
+	};
+	InputRangeField$1.propTypes = {
+	  value: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number]),
+	  label: _propTypes.default.oneOfType([_propTypes.default.element, _propTypes.default.node]).isRequired,
+	  placeholder: _propTypes.default.string,
+	  styles: _propTypes.default.shape({
+	    inputRange: _propTypes.default.string,
+	    inputRangeInput: _propTypes.default.string,
+	    inputRangeLabel: _propTypes.default.string
+	  }).isRequired,
+	  onBlur: _propTypes.default.func.isRequired,
+	  onFocus: _propTypes.default.func.isRequired,
+	  onChange: _propTypes.default.func.isRequired
+	};
+	InputRangeField$1.defaultProps = {
+	  value: '',
+	  placeholder: '-'
+	};
+	InputRangeField.default = InputRangeField$1;
+	return InputRangeField;
+}
+
+export { requireInputRangeField as __require };

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

@@ -0,0 +1,146 @@
+import { __exports as Month } from '../../../../../_virtual/index.esm13.js';
+import React__default from 'react';
+import { __require as requirePropTypes } from '../../../../prop-types/index.esm.js';
+import { __require as requireDayCell } from '../DayCell/index.esm.js';
+import { __require as requireDateFns } from '../../../../date-fns/index.esm.js';
+import { __require as requireUtils } from '../../utils.esm.js';
+
+var hasRequiredMonth;
+
+function requireMonth () {
+	if (hasRequiredMonth) return Month;
+	hasRequiredMonth = 1;
+
+	Object.defineProperty(Month, "__esModule", {
+	  value: true
+	});
+	Month.default = void 0;
+	var _react = _interopRequireWildcard(React__default);
+	var _propTypes = _interopRequireDefault(/*@__PURE__*/ requirePropTypes());
+	var _DayCell = _interopRequireWildcard(requireDayCell());
+	var _dateFns = /*@__PURE__*/ requireDateFns();
+	var _utils = requireUtils();
+	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); } /* eslint-disable no-fallthrough */
+	function renderWeekdays(styles, dateOptions, weekdayDisplayFormat) {
+	  const now = new Date();
+	  return /*#__PURE__*/_react.default.createElement("div", {
+	    className: styles.weekDays
+	  }, (0, _dateFns.eachDayOfInterval)({
+	    start: (0, _dateFns.startOfWeek)(now, dateOptions),
+	    end: (0, _dateFns.endOfWeek)(now, dateOptions)
+	  }).map((day, i) => /*#__PURE__*/_react.default.createElement("span", {
+	    className: styles.weekDay,
+	    key: i
+	  }, (0, _dateFns.format)(day, weekdayDisplayFormat, dateOptions))));
+	}
+	let Month$1 = class Month extends _react.PureComponent {
+	  render() {
+	    const now = new Date();
+	    const {
+	      displayMode,
+	      focusedRange,
+	      drag,
+	      styles,
+	      disabledDates,
+	      disabledDay
+	    } = this.props;
+	    const minDate = this.props.minDate && (0, _dateFns.startOfDay)(this.props.minDate);
+	    const maxDate = this.props.maxDate && (0, _dateFns.endOfDay)(this.props.maxDate);
+	    const monthDisplay = (0, _utils.getMonthDisplayRange)(this.props.month, this.props.dateOptions, this.props.fixedHeight);
+	    let ranges = this.props.ranges;
+	    if (displayMode === 'dateRange' && drag.status) {
+	      let {
+	        startDate,
+	        endDate
+	      } = drag.range;
+	      ranges = ranges.map((range, i) => {
+	        if (i !== focusedRange[0]) return range;
+	        return {
+	          ...range,
+	          startDate,
+	          endDate
+	        };
+	      });
+	    }
+	    const showPreview = this.props.showPreview && !drag.disablePreview;
+	    return /*#__PURE__*/_react.default.createElement("div", {
+	      className: styles.month,
+	      style: this.props.style
+	    }, this.props.showMonthName ? /*#__PURE__*/_react.default.createElement("div", {
+	      className: styles.monthName
+	    }, (0, _dateFns.format)(this.props.month, this.props.monthDisplayFormat, this.props.dateOptions)) : null, this.props.showWeekDays && renderWeekdays(styles, this.props.dateOptions, this.props.weekdayDisplayFormat), /*#__PURE__*/_react.default.createElement("div", {
+	      className: styles.days,
+	      onMouseLeave: this.props.onMouseLeave
+	    }, (0, _dateFns.eachDayOfInterval)({
+	      start: monthDisplay.start,
+	      end: monthDisplay.end
+	    }).map((day, index) => {
+	      const isStartOfMonth = (0, _dateFns.isSameDay)(day, monthDisplay.startDateOfMonth);
+	      const isEndOfMonth = (0, _dateFns.isSameDay)(day, monthDisplay.endDateOfMonth);
+	      const isOutsideMinMax = minDate && (0, _dateFns.isBefore)(day, minDate) || maxDate && (0, _dateFns.isAfter)(day, maxDate);
+	      const isDisabledSpecifically = disabledDates.some(disabledDate => (0, _dateFns.isSameDay)(disabledDate, day));
+	      const isDisabledDay = disabledDay(day);
+	      return /*#__PURE__*/_react.default.createElement(_DayCell.default, _extends({}, this.props, {
+	        ranges: ranges,
+	        day: day,
+	        preview: showPreview ? this.props.preview : null,
+	        isWeekend: (0, _dateFns.isWeekend)(day, this.props.dateOptions),
+	        isToday: (0, _dateFns.isSameDay)(day, now),
+	        isStartOfWeek: (0, _dateFns.isSameDay)(day, (0, _dateFns.startOfWeek)(day, this.props.dateOptions)),
+	        isEndOfWeek: (0, _dateFns.isSameDay)(day, (0, _dateFns.endOfWeek)(day, this.props.dateOptions)),
+	        isStartOfMonth: isStartOfMonth,
+	        isEndOfMonth: isEndOfMonth,
+	        key: index,
+	        disabled: isOutsideMinMax || isDisabledSpecifically || isDisabledDay,
+	        isPassive: !(0, _dateFns.isWithinInterval)(day, {
+	          start: monthDisplay.startDateOfMonth,
+	          end: monthDisplay.endDateOfMonth
+	        }),
+	        styles: styles,
+	        onMouseDown: this.props.onDragSelectionStart,
+	        onMouseUp: this.props.onDragSelectionEnd,
+	        onMouseEnter: this.props.onDragSelectionMove,
+	        dragRange: drag.range,
+	        drag: drag.status
+	      }));
+	    })));
+	  }
+	};
+	Month$1.defaultProps = {};
+	Month$1.propTypes = {
+	  style: _propTypes.default.object,
+	  styles: _propTypes.default.object,
+	  month: _propTypes.default.object,
+	  drag: _propTypes.default.object,
+	  dateOptions: _propTypes.default.object,
+	  disabledDates: _propTypes.default.array,
+	  disabledDay: _propTypes.default.func,
+	  preview: _propTypes.default.shape({
+	    startDate: _propTypes.default.object,
+	    endDate: _propTypes.default.object
+	  }),
+	  showPreview: _propTypes.default.bool,
+	  displayMode: _propTypes.default.oneOf(['dateRange', 'date']),
+	  minDate: _propTypes.default.object,
+	  maxDate: _propTypes.default.object,
+	  ranges: _propTypes.default.arrayOf(_DayCell.rangeShape),
+	  focusedRange: _propTypes.default.arrayOf(_propTypes.default.number),
+	  onDragSelectionStart: _propTypes.default.func,
+	  onDragSelectionEnd: _propTypes.default.func,
+	  onDragSelectionMove: _propTypes.default.func,
+	  onMouseLeave: _propTypes.default.func,
+	  monthDisplayFormat: _propTypes.default.string,
+	  weekdayDisplayFormat: _propTypes.default.string,
+	  dayDisplayFormat: _propTypes.default.string,
+	  showWeekDays: _propTypes.default.bool,
+	  showMonthName: _propTypes.default.bool,
+	  fixedHeight: _propTypes.default.bool
+	};
+	Month.default = Month$1;
+	return Month;
+}
+
+export { requireMonth as __require };

package/dist/node_modules/react-date-range/dist/defaultRanges.esm.js

@@ -0,0 +1,111 @@
+import { __exports as defaultRanges } from '../../../_virtual/defaultRanges.esm.js';
+import { __require as requireDateFns } from '../../date-fns/index.esm.js';
+
+var hasRequiredDefaultRanges;
+
+function requireDefaultRanges () {
+	if (hasRequiredDefaultRanges) return defaultRanges;
+	hasRequiredDefaultRanges = 1;
+
+	Object.defineProperty(defaultRanges, "__esModule", {
+	  value: true
+	});
+	defaultRanges.createStaticRanges = createStaticRanges;
+	defaultRanges.defaultStaticRanges = defaultRanges.defaultInputRanges = void 0;
+	var _dateFns = /*@__PURE__*/ requireDateFns();
+	const defineds = {
+	  startOfWeek: (0, _dateFns.startOfWeek)(new Date()),
+	  endOfWeek: (0, _dateFns.endOfWeek)(new Date()),
+	  startOfLastWeek: (0, _dateFns.startOfWeek)((0, _dateFns.addDays)(new Date(), -7)),
+	  endOfLastWeek: (0, _dateFns.endOfWeek)((0, _dateFns.addDays)(new Date(), -7)),
+	  startOfToday: (0, _dateFns.startOfDay)(new Date()),
+	  endOfToday: (0, _dateFns.endOfDay)(new Date()),
+	  startOfYesterday: (0, _dateFns.startOfDay)((0, _dateFns.addDays)(new Date(), -1)),
+	  endOfYesterday: (0, _dateFns.endOfDay)((0, _dateFns.addDays)(new Date(), -1)),
+	  startOfMonth: (0, _dateFns.startOfMonth)(new Date()),
+	  endOfMonth: (0, _dateFns.endOfMonth)(new Date()),
+	  startOfLastMonth: (0, _dateFns.startOfMonth)((0, _dateFns.addMonths)(new Date(), -1)),
+	  endOfLastMonth: (0, _dateFns.endOfMonth)((0, _dateFns.addMonths)(new Date(), -1))
+	};
+	const staticRangeHandler = {
+	  range: {},
+	  isSelected(range) {
+	    const definedRange = this.range();
+	    return (0, _dateFns.isSameDay)(range.startDate, definedRange.startDate) && (0, _dateFns.isSameDay)(range.endDate, definedRange.endDate);
+	  }
+	};
+	function createStaticRanges(ranges) {
+	  return ranges.map(range => ({
+	    ...staticRangeHandler,
+	    ...range
+	  }));
+	}
+	defaultRanges.defaultStaticRanges = createStaticRanges([{
+	  label: 'Today',
+	  range: () => ({
+	    startDate: defineds.startOfToday,
+	    endDate: defineds.endOfToday
+	  })
+	}, {
+	  label: 'Yesterday',
+	  range: () => ({
+	    startDate: defineds.startOfYesterday,
+	    endDate: defineds.endOfYesterday
+	  })
+	}, {
+	  label: 'This Week',
+	  range: () => ({
+	    startDate: defineds.startOfWeek,
+	    endDate: defineds.endOfWeek
+	  })
+	}, {
+	  label: 'Last Week',
+	  range: () => ({
+	    startDate: defineds.startOfLastWeek,
+	    endDate: defineds.endOfLastWeek
+	  })
+	}, {
+	  label: 'This Month',
+	  range: () => ({
+	    startDate: defineds.startOfMonth,
+	    endDate: defineds.endOfMonth
+	  })
+	}, {
+	  label: 'Last Month',
+	  range: () => ({
+	    startDate: defineds.startOfLastMonth,
+	    endDate: defineds.endOfLastMonth
+	  })
+	}]);
+	defaultRanges.defaultInputRanges = [{
+	  label: 'days up to today',
+	  range(value) {
+	    return {
+	      startDate: (0, _dateFns.addDays)(defineds.startOfToday, (Math.max(Number(value), 1) - 1) * -1),
+	      endDate: defineds.endOfToday
+	    };
+	  },
+	  getCurrentValue(range) {
+	    if (!(0, _dateFns.isSameDay)(range.endDate, defineds.endOfToday)) return '-';
+	    if (!range.startDate) return '∞';
+	    return (0, _dateFns.differenceInCalendarDays)(defineds.endOfToday, range.startDate) + 1;
+	  }
+	}, {
+	  label: 'days starting today',
+	  range(value) {
+	    const today = new Date();
+	    return {
+	      startDate: today,
+	      endDate: (0, _dateFns.addDays)(today, Math.max(Number(value), 1) - 1)
+	    };
+	  },
+	  getCurrentValue(range) {
+	    if (!(0, _dateFns.isSameDay)(range.startDate, defineds.startOfToday)) return '-';
+	    if (!range.endDate) return '∞';
+	    return (0, _dateFns.differenceInCalendarDays)(range.endDate, defineds.startOfToday) + 1;
+	  }
+	}];
+	return defaultRanges;
+}
+
+export { requireDefaultRanges as __require };

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

@@ -0,0 +1,70 @@
+import { __exports as dist } from '../../../_virtual/index.esm2.js';
+import { __require as requireDateRange } from './components/DateRange/index.esm.js';
+import { __require as requireCalendar } from './components/Calendar/index.esm.js';
+import { __require as requireDateRangePicker } from './components/DateRangePicker/index.esm.js';
+import { __require as requireDefinedRange } from './components/DefinedRange/index.esm.js';
+import { __require as requireDefaultRanges } from './defaultRanges.esm.js';
+
+var hasRequiredDist;
+
+function requireDist () {
+	if (hasRequiredDist) return dist;
+	hasRequiredDist = 1;
+	(function (exports) {
+
+		Object.defineProperty(exports, "__esModule", {
+		  value: true
+		});
+		Object.defineProperty(exports, "Calendar", {
+		  enumerable: true,
+		  get: function () {
+		    return _Calendar.default;
+		  }
+		});
+		Object.defineProperty(exports, "DateRange", {
+		  enumerable: true,
+		  get: function () {
+		    return _DateRange.default;
+		  }
+		});
+		Object.defineProperty(exports, "DateRangePicker", {
+		  enumerable: true,
+		  get: function () {
+		    return _DateRangePicker.default;
+		  }
+		});
+		Object.defineProperty(exports, "DefinedRange", {
+		  enumerable: true,
+		  get: function () {
+		    return _DefinedRange.default;
+		  }
+		});
+		Object.defineProperty(exports, "createStaticRanges", {
+		  enumerable: true,
+		  get: function () {
+		    return _defaultRanges.createStaticRanges;
+		  }
+		});
+		Object.defineProperty(exports, "defaultInputRanges", {
+		  enumerable: true,
+		  get: function () {
+		    return _defaultRanges.defaultInputRanges;
+		  }
+		});
+		Object.defineProperty(exports, "defaultStaticRanges", {
+		  enumerable: true,
+		  get: function () {
+		    return _defaultRanges.defaultStaticRanges;
+		  }
+		});
+		var _DateRange = _interopRequireDefault(requireDateRange());
+		var _Calendar = _interopRequireDefault(requireCalendar());
+		var _DateRangePicker = _interopRequireDefault(requireDateRangePicker());
+		var _DefinedRange = _interopRequireDefault(requireDefinedRange());
+		var _defaultRanges = requireDefaultRanges();
+		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 
+	} (dist));
+	return dist;
+}
+
+export { requireDist as __require };

package/dist/node_modules/react-date-range/dist/styles.esm.js

@@ -0,0 +1,69 @@
+import { __exports as styles } from '../../../_virtual/styles.esm.js';
+
+var hasRequiredStyles;
+
+function requireStyles () {
+	if (hasRequiredStyles) return styles;
+	hasRequiredStyles = 1;
+
+	Object.defineProperty(styles, "__esModule", {
+	  value: true
+	});
+	styles.default = void 0;
+	styles.default = {
+	  dateRangeWrapper: 'rdrDateRangeWrapper',
+	  calendarWrapper: 'rdrCalendarWrapper',
+	  dateDisplay: 'rdrDateDisplay',
+	  dateDisplayItem: 'rdrDateDisplayItem',
+	  dateDisplayItemActive: 'rdrDateDisplayItemActive',
+	  monthAndYearWrapper: 'rdrMonthAndYearWrapper',
+	  monthAndYearPickers: 'rdrMonthAndYearPickers',
+	  nextPrevButton: 'rdrNextPrevButton',
+	  month: 'rdrMonth',
+	  weekDays: 'rdrWeekDays',
+	  weekDay: 'rdrWeekDay',
+	  days: 'rdrDays',
+	  day: 'rdrDay',
+	  dayNumber: 'rdrDayNumber',
+	  dayPassive: 'rdrDayPassive',
+	  dayToday: 'rdrDayToday',
+	  dayStartOfWeek: 'rdrDayStartOfWeek',
+	  dayEndOfWeek: 'rdrDayEndOfWeek',
+	  daySelected: 'rdrDaySelected',
+	  dayDisabled: 'rdrDayDisabled',
+	  dayStartOfMonth: 'rdrDayStartOfMonth',
+	  dayEndOfMonth: 'rdrDayEndOfMonth',
+	  dayWeekend: 'rdrDayWeekend',
+	  dayStartPreview: 'rdrDayStartPreview',
+	  dayInPreview: 'rdrDayInPreview',
+	  dayEndPreview: 'rdrDayEndPreview',
+	  dayHovered: 'rdrDayHovered',
+	  dayActive: 'rdrDayActive',
+	  inRange: 'rdrInRange',
+	  endEdge: 'rdrEndEdge',
+	  startEdge: 'rdrStartEdge',
+	  prevButton: 'rdrPprevButton',
+	  nextButton: 'rdrNextButton',
+	  selected: 'rdrSelected',
+	  months: 'rdrMonths',
+	  monthPicker: 'rdrMonthPicker',
+	  yearPicker: 'rdrYearPicker',
+	  dateDisplayWrapper: 'rdrDateDisplayWrapper',
+	  definedRangesWrapper: 'rdrDefinedRangesWrapper',
+	  staticRanges: 'rdrStaticRanges',
+	  staticRange: 'rdrStaticRange',
+	  inputRanges: 'rdrInputRanges',
+	  inputRange: 'rdrInputRange',
+	  inputRangeInput: 'rdrInputRangeInput',
+	  dateRangePickerWrapper: 'rdrDateRangePickerWrapper',
+	  staticRangeLabel: 'rdrStaticRangeLabel',
+	  staticRangeSelected: 'rdrStaticRangeSelected',
+	  monthName: 'rdrMonthName',
+	  infiniteMonths: 'rdrInfiniteMonths',
+	  monthsVertical: 'rdrMonthsVertical',
+	  monthsHorizontal: 'rdrMonthsHorizontal'
+	};
+	return styles;
+}
+
+export { requireStyles as __require };