inital commit

node_modules/react-date-range/dist/components/Calendar/index.js

@@ -0,0 +1,621 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _DayCell = require("../DayCell");
+var _Month = _interopRequireDefault(require("../Month"));
+var _DateInput = _interopRequireDefault(require("../DateInput"));
+var _utils = require("../../utils");
+var _classnames = _interopRequireDefault(require("classnames"));
+var _reactList = _interopRequireDefault(require("react-list"));
+var _shallowEqual = require("shallow-equal");
+var _dateFns = require("date-fns");
+var _enUS = require("date-fns/locale/en-US");
+var _styles = _interopRequireDefault(require("../../styles"));
+var _accessibility = require("../../accessibility");
+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 (!r && 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 || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+class Calendar extends _react.PureComponent {
+  constructor(_props, context) {
+    var _this;
+    super(_props, context);
+    _this = this;
+    _defineProperty(this, "focusToDate", function (date) {
+      let props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _this.props;
+      let preventUnnecessary = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+      if (!props.scroll.enabled) {
+        if (preventUnnecessary && props.preventSnapRefocus) {
+          const focusedDateDiff = (0, _dateFns.differenceInCalendarMonths)(date, _this.state.focusedDate);
+          const isAllowedForward = props.calendarFocus === 'forwards' && focusedDateDiff >= 0;
+          const isAllowedBackward = props.calendarFocus === 'backwards' && focusedDateDiff <= 0;
+          if ((isAllowedForward || isAllowedBackward) && Math.abs(focusedDateDiff) < props.months) {
+            return;
+          }
+        }
+        _this.setState({
+          focusedDate: date
+        });
+        return;
+      }
+      const targetMonthIndex = (0, _dateFns.differenceInCalendarMonths)(date, props.minDate, _this.dateOptions);
+      const visibleMonths = _this.list.getVisibleRange();
+      if (preventUnnecessary && visibleMonths.includes(targetMonthIndex)) return;
+      _this.isFirstRender = true;
+      _this.list.scrollTo(targetMonthIndex);
+      _this.setState({
+        focusedDate: date
+      });
+    });
+    _defineProperty(this, "updateShownDate", function () {
+      let props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _this.props;
+      const newProps = props.scroll.enabled ? {
+        ...props,
+        months: _this.list.getVisibleRange().length
+      } : props;
+      const newFocus = (0, _utils.calcFocusDate)(_this.state.focusedDate, newProps);
+      _this.focusToDate(newFocus, newProps);
+    });
+    _defineProperty(this, "updatePreview", val => {
+      if (!val) {
+        this.setState({
+          preview: null
+        });
+        return;
+      }
+      const preview = {
+        startDate: val,
+        endDate: val,
+        color: this.props.color
+      };
+      this.setState({
+        preview
+      });
+    });
+    _defineProperty(this, "changeShownDate", function (value) {
+      let mode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'set';
+      const {
+        focusedDate
+      } = _this.state;
+      const {
+        onShownDateChange,
+        minDate,
+        maxDate
+      } = _this.props;
+      const modeMapper = {
+        monthOffset: () => (0, _dateFns.addMonths)(focusedDate, value),
+        setMonth: () => (0, _dateFns.setMonth)(focusedDate, value),
+        setYear: () => (0, _dateFns.setYear)(focusedDate, value),
+        set: () => value
+      };
+      const newDate = (0, _dateFns.min)([(0, _dateFns.max)([modeMapper[mode](), minDate]), maxDate]);
+      _this.focusToDate(newDate, _this.props, false);
+      onShownDateChange && onShownDateChange(newDate);
+    });
+    _defineProperty(this, "handleRangeFocusChange", (rangesIndex, rangeItemIndex) => {
+      this.props.onRangeFocusChange && this.props.onRangeFocusChange([rangesIndex, rangeItemIndex]);
+    });
+    _defineProperty(this, "handleScroll", () => {
+      const {
+        onShownDateChange,
+        minDate
+      } = this.props;
+      const {
+        focusedDate
+      } = this.state;
+      const {
+        isFirstRender
+      } = this;
+      const visibleMonths = this.list.getVisibleRange();
+      // prevent scroll jump with wrong visible value
+      if (visibleMonths[0] === undefined) return;
+      const visibleMonth = (0, _dateFns.addMonths)(minDate, visibleMonths[0] || 0);
+      const isFocusedToDifferent = !(0, _dateFns.isSameMonth)(visibleMonth, focusedDate);
+      if (isFocusedToDifferent && !isFirstRender) {
+        this.setState({
+          focusedDate: visibleMonth
+        });
+        onShownDateChange && onShownDateChange(visibleMonth);
+      }
+      this.isFirstRender = false;
+    });
+    _defineProperty(this, "renderMonthAndYear", (focusedDate, changeShownDate, props) => {
+      const {
+        showMonthArrow,
+        minDate,
+        maxDate,
+        showMonthAndYearPickers,
+        ariaLabels
+      } = props;
+      const upperYearLimit = (maxDate || Calendar.defaultProps.maxDate).getFullYear();
+      const lowerYearLimit = (minDate || Calendar.defaultProps.minDate).getFullYear();
+      const styles = this.styles;
+      return /*#__PURE__*/_react.default.createElement("div", {
+        onMouseUp: e => e.stopPropagation(),
+        className: styles.monthAndYearWrapper
+      }, showMonthArrow ? /*#__PURE__*/_react.default.createElement("button", {
+        type: "button",
+        className: (0, _classnames.default)(styles.nextPrevButton, styles.prevButton),
+        onClick: () => changeShownDate(-1, 'monthOffset'),
+        "aria-label": ariaLabels.prevButton
+      }, /*#__PURE__*/_react.default.createElement("i", null)) : null, showMonthAndYearPickers ? /*#__PURE__*/_react.default.createElement("span", {
+        className: styles.monthAndYearPickers
+      }, /*#__PURE__*/_react.default.createElement("span", {
+        className: styles.monthPicker
+      }, /*#__PURE__*/_react.default.createElement("select", {
+        value: focusedDate.getMonth(),
+        onChange: e => changeShownDate(e.target.value, 'setMonth'),
+        "aria-label": ariaLabels.monthPicker
+      }, this.state.monthNames.map((monthName, i) => /*#__PURE__*/_react.default.createElement("option", {
+        key: i,
+        value: i
+      }, monthName)))), /*#__PURE__*/_react.default.createElement("span", {
+        className: styles.monthAndYearDivider
+      }), /*#__PURE__*/_react.default.createElement("span", {
+        className: styles.yearPicker
+      }, /*#__PURE__*/_react.default.createElement("select", {
+        value: focusedDate.getFullYear(),
+        onChange: e => changeShownDate(e.target.value, 'setYear'),
+        "aria-label": ariaLabels.yearPicker
+      }, new Array(upperYearLimit - lowerYearLimit + 1).fill(upperYearLimit).map((val, i) => {
+        const year = val - i;
+        return /*#__PURE__*/_react.default.createElement("option", {
+          key: year,
+          value: year
+        }, year);
+      })))) : /*#__PURE__*/_react.default.createElement("span", {
+        className: styles.monthAndYearPickers
+      }, this.state.monthNames[focusedDate.getMonth()], " ", focusedDate.getFullYear()), showMonthArrow ? /*#__PURE__*/_react.default.createElement("button", {
+        type: "button",
+        className: (0, _classnames.default)(styles.nextPrevButton, styles.nextButton),
+        onClick: () => changeShownDate(+1, 'monthOffset'),
+        "aria-label": ariaLabels.nextButton
+      }, /*#__PURE__*/_react.default.createElement("i", null)) : null);
+    });
+    _defineProperty(this, "renderDateDisplay", () => {
+      const {
+        focusedRange,
+        color,
+        ranges,
+        rangeColors,
+        dateDisplayFormat,
+        editableDateInputs,
+        startDatePlaceholder,
+        endDatePlaceholder,
+        ariaLabels
+      } = this.props;
+      const defaultColor = rangeColors[focusedRange[0]] || color;
+      const styles = this.styles;
+      return /*#__PURE__*/_react.default.createElement("div", {
+        className: styles.dateDisplayWrapper
+      }, ranges.map((range, i) => {
+        if (range.showDateDisplay === false || range.disabled && !range.showDateDisplay) return null;
+        return /*#__PURE__*/_react.default.createElement("div", {
+          className: styles.dateDisplay,
+          key: i,
+          style: {
+            color: range.color || defaultColor
+          }
+        }, /*#__PURE__*/_react.default.createElement(_DateInput.default, {
+          className: (0, _classnames.default)(styles.dateDisplayItem, {
+            [styles.dateDisplayItemActive]: focusedRange[0] === i && focusedRange[1] === 0
+          }),
+          readOnly: !editableDateInputs,
+          disabled: range.disabled,
+          value: range.startDate,
+          placeholder: startDatePlaceholder,
+          dateOptions: this.dateOptions,
+          dateDisplayFormat: dateDisplayFormat,
+          ariaLabel: ariaLabels.dateInput && ariaLabels.dateInput[range.key] && ariaLabels.dateInput[range.key].startDate,
+          onChange: this.onDragSelectionEnd,
+          onFocus: () => this.handleRangeFocusChange(i, 0)
+        }), /*#__PURE__*/_react.default.createElement(_DateInput.default, {
+          className: (0, _classnames.default)(styles.dateDisplayItem, {
+            [styles.dateDisplayItemActive]: focusedRange[0] === i && focusedRange[1] === 1
+          }),
+          readOnly: !editableDateInputs,
+          disabled: range.disabled,
+          value: range.endDate,
+          placeholder: endDatePlaceholder,
+          dateOptions: this.dateOptions,
+          dateDisplayFormat: dateDisplayFormat,
+          ariaLabel: ariaLabels.dateInput && ariaLabels.dateInput[range.key] && ariaLabels.dateInput[range.key].endDate,
+          onChange: this.onDragSelectionEnd,
+          onFocus: () => this.handleRangeFocusChange(i, 1)
+        }));
+      }));
+    });
+    _defineProperty(this, "onDragSelectionStart", date => {
+      const {
+        onChange,
+        dragSelectionEnabled
+      } = this.props;
+      if (dragSelectionEnabled) {
+        this.setState({
+          drag: {
+            status: true,
+            range: {
+              startDate: date,
+              endDate: date
+            },
+            disablePreview: true
+          }
+        });
+      } else {
+        onChange && onChange(date);
+      }
+    });
+    _defineProperty(this, "onDragSelectionEnd", date => {
+      const {
+        updateRange,
+        displayMode,
+        onChange,
+        dragSelectionEnabled
+      } = this.props;
+      if (!dragSelectionEnabled) return;
+      if (displayMode === 'date' || !this.state.drag.status) {
+        onChange && onChange(date);
+        return;
+      }
+      const newRange = {
+        startDate: this.state.drag.range.startDate,
+        endDate: date
+      };
+      if (displayMode !== 'dateRange' || (0, _dateFns.isSameDay)(newRange.startDate, date)) {
+        this.setState({
+          drag: {
+            status: false,
+            range: {}
+          }
+        }, () => onChange && onChange(date));
+      } else {
+        this.setState({
+          drag: {
+            status: false,
+            range: {}
+          }
+        }, () => {
+          updateRange && updateRange(newRange);
+        });
+      }
+    });
+    _defineProperty(this, "onDragSelectionMove", date => {
+      const {
+        drag
+      } = this.state;
+      if (!drag.status || !this.props.dragSelectionEnabled) return;
+      this.setState({
+        drag: {
+          status: drag.status,
+          range: {
+            startDate: drag.range.startDate,
+            endDate: date
+          },
+          disablePreview: true
+        }
+      });
+    });
+    _defineProperty(this, "estimateMonthSize", (index, cache) => {
+      const {
+        direction,
+        minDate
+      } = this.props;
+      const {
+        scrollArea
+      } = this.state;
+      if (cache) {
+        this.listSizeCache = cache;
+        if (cache[index]) return cache[index];
+      }
+      if (direction === 'horizontal') return scrollArea.monthWidth;
+      const monthStep = (0, _dateFns.addMonths)(minDate, index);
+      const {
+        start,
+        end
+      } = (0, _utils.getMonthDisplayRange)(monthStep, this.dateOptions);
+      const isLongMonth = (0, _dateFns.differenceInDays)(end, start, this.dateOptions) + 1 > 7 * 5;
+      return isLongMonth ? scrollArea.longMonthHeight : scrollArea.monthHeight;
+    });
+    this.dateOptions = {
+      locale: _props.locale
+    };
+    if (_props.weekStartsOn !== undefined) this.dateOptions.weekStartsOn = _props.weekStartsOn;
+    this.styles = (0, _utils.generateStyles)([_styles.default, _props.classNames]);
+    this.listSizeCache = {};
+    this.isFirstRender = true;
+    this.state = {
+      monthNames: this.getMonthNames(),
+      focusedDate: (0, _utils.calcFocusDate)(null, _props),
+      drag: {
+        status: false,
+        range: {
+          startDate: null,
+          endDate: null
+        },
+        disablePreview: false
+      },
+      scrollArea: this.calcScrollArea(_props)
+    };
+  }
+  getMonthNames() {
+    return [...Array(12).keys()].map(i => this.props.locale.localize.month(i));
+  }
+  calcScrollArea(props) {
+    const {
+      direction,
+      months,
+      scroll
+    } = props;
+    if (!scroll.enabled) return {
+      enabled: false
+    };
+    const longMonthHeight = scroll.longMonthHeight || scroll.monthHeight;
+    if (direction === 'vertical') {
+      return {
+        enabled: true,
+        monthHeight: scroll.monthHeight || 220,
+        longMonthHeight: longMonthHeight || 260,
+        calendarWidth: 'auto',
+        calendarHeight: (scroll.calendarHeight || longMonthHeight || 240) * months
+      };
+    }
+    return {
+      enabled: true,
+      monthWidth: scroll.monthWidth || 332,
+      calendarWidth: (scroll.calendarWidth || scroll.monthWidth || 332) * months,
+      monthHeight: longMonthHeight || 300,
+      calendarHeight: longMonthHeight || 300
+    };
+  }
+  componentDidMount() {
+    if (this.props.scroll.enabled) {
+      // prevent react-list's initial render focus problem
+      setTimeout(() => this.focusToDate(this.state.focusedDate));
+    }
+  }
+  componentDidUpdate(prevProps) {
+    const propMapper = {
+      dateRange: 'ranges',
+      date: 'date'
+    };
+    const targetProp = propMapper[this.props.displayMode];
+    if (this.props[targetProp] !== prevProps[targetProp]) {
+      this.updateShownDate(this.props);
+    }
+    if (prevProps.locale !== this.props.locale || prevProps.weekStartsOn !== this.props.weekStartsOn) {
+      this.dateOptions = {
+        locale: this.props.locale
+      };
+      if (this.props.weekStartsOn !== undefined) this.dateOptions.weekStartsOn = this.props.weekStartsOn;
+      this.setState({
+        monthNames: this.getMonthNames()
+      });
+    }
+    if (!(0, _shallowEqual.shallowEqualObjects)(prevProps.scroll, this.props.scroll)) {
+      this.setState({
+        scrollArea: this.calcScrollArea(this.props)
+      });
+    }
+  }
+  renderWeekdays() {
+    const now = new Date();
+    return /*#__PURE__*/_react.default.createElement("div", {
+      className: this.styles.weekDays
+    }, (0, _dateFns.eachDayOfInterval)({
+      start: (0, _dateFns.startOfWeek)(now, this.dateOptions),
+      end: (0, _dateFns.endOfWeek)(now, this.dateOptions)
+    }).map((day, i) => /*#__PURE__*/_react.default.createElement("span", {
+      className: this.styles.weekDay,
+      key: i
+    }, (0, _dateFns.format)(day, this.props.weekdayDisplayFormat, this.dateOptions))));
+  }
+  render() {
+    const {
+      showDateDisplay,
+      onPreviewChange,
+      scroll,
+      direction,
+      disabledDates,
+      disabledDay,
+      maxDate,
+      minDate,
+      rangeColors,
+      color,
+      navigatorRenderer,
+      className,
+      preview
+    } = this.props;
+    const {
+      scrollArea,
+      focusedDate
+    } = this.state;
+    const isVertical = direction === 'vertical';
+    const monthAndYearRenderer = navigatorRenderer || this.renderMonthAndYear;
+    const ranges = this.props.ranges.map((range, i) => ({
+      ...range,
+      color: range.color || rangeColors[i] || color
+    }));
+    return /*#__PURE__*/_react.default.createElement("div", {
+      className: (0, _classnames.default)(this.styles.calendarWrapper, className),
+      onMouseUp: () => this.setState({
+        drag: {
+          status: false,
+          range: {}
+        }
+      }),
+      onMouseLeave: () => {
+        this.setState({
+          drag: {
+            status: false,
+            range: {}
+          }
+        });
+      }
+    }, showDateDisplay && this.renderDateDisplay(), monthAndYearRenderer(focusedDate, this.changeShownDate, this.props), scroll.enabled ? /*#__PURE__*/_react.default.createElement("div", null, isVertical && this.renderWeekdays(this.dateOptions), /*#__PURE__*/_react.default.createElement("div", {
+      className: (0, _classnames.default)(this.styles.infiniteMonths, isVertical ? this.styles.monthsVertical : this.styles.monthsHorizontal),
+      onMouseLeave: () => onPreviewChange && onPreviewChange(),
+      style: {
+        width: scrollArea.calendarWidth + 11,
+        height: scrollArea.calendarHeight + 11
+      },
+      onScroll: this.handleScroll
+    }, /*#__PURE__*/_react.default.createElement(_reactList.default, {
+      length: (0, _dateFns.differenceInCalendarMonths)((0, _dateFns.endOfMonth)(maxDate), (0, _dateFns.addDays)((0, _dateFns.startOfMonth)(minDate), -1), this.dateOptions),
+      treshold: 500,
+      type: "variable",
+      ref: target => this.list = target,
+      itemSizeEstimator: this.estimateMonthSize,
+      axis: isVertical ? 'y' : 'x',
+      itemRenderer: (index, key) => {
+        const monthStep = (0, _dateFns.addMonths)(minDate, index);
+        return /*#__PURE__*/_react.default.createElement(_Month.default, _extends({}, this.props, {
+          onPreviewChange: onPreviewChange || this.updatePreview,
+          preview: preview || this.state.preview,
+          ranges: ranges,
+          key: key,
+          drag: this.state.drag,
+          dateOptions: this.dateOptions,
+          disabledDates: disabledDates,
+          disabledDay: disabledDay,
+          month: monthStep,
+          onDragSelectionStart: this.onDragSelectionStart,
+          onDragSelectionEnd: this.onDragSelectionEnd,
+          onDragSelectionMove: this.onDragSelectionMove,
+          onMouseLeave: () => onPreviewChange && onPreviewChange(),
+          styles: this.styles,
+          style: isVertical ? {
+            height: this.estimateMonthSize(index)
+          } : {
+            height: scrollArea.monthHeight,
+            width: this.estimateMonthSize(index)
+          },
+          showMonthName: true,
+          showWeekDays: !isVertical
+        }));
+      }
+    }))) : /*#__PURE__*/_react.default.createElement("div", {
+      className: (0, _classnames.default)(this.styles.months, isVertical ? this.styles.monthsVertical : this.styles.monthsHorizontal)
+    }, new Array(this.props.months).fill(null).map((_, i) => {
+      let monthStep = (0, _dateFns.addMonths)(this.state.focusedDate, i);
+      if (this.props.calendarFocus === 'backwards') {
+        monthStep = (0, _dateFns.subMonths)(this.state.focusedDate, this.props.months - 1 - i);
+      }
+      return /*#__PURE__*/_react.default.createElement(_Month.default, _extends({}, this.props, {
+        onPreviewChange: onPreviewChange || this.updatePreview,
+        preview: preview || this.state.preview,
+        ranges: ranges,
+        key: i,
+        drag: this.state.drag,
+        dateOptions: this.dateOptions,
+        disabledDates: disabledDates,
+        disabledDay: disabledDay,
+        month: monthStep,
+        onDragSelectionStart: this.onDragSelectionStart,
+        onDragSelectionEnd: this.onDragSelectionEnd,
+        onDragSelectionMove: this.onDragSelectionMove,
+        onMouseLeave: () => onPreviewChange && onPreviewChange(),
+        styles: this.styles,
+        showWeekDays: !isVertical || i === 0,
+        showMonthName: !isVertical || i > 0
+      }));
+    })));
+  }
+}
+Calendar.defaultProps = {
+  showMonthArrow: true,
+  showMonthAndYearPickers: true,
+  disabledDates: [],
+  disabledDay: () => {},
+  classNames: {},
+  locale: _enUS.enUS,
+  ranges: [],
+  focusedRange: [0, 0],
+  dateDisplayFormat: 'MMM d, yyyy',
+  monthDisplayFormat: 'MMM yyyy',
+  weekdayDisplayFormat: 'E',
+  dayDisplayFormat: 'd',
+  showDateDisplay: true,
+  showPreview: true,
+  displayMode: 'date',
+  months: 1,
+  color: '#3d91ff',
+  scroll: {
+    enabled: false
+  },
+  direction: 'vertical',
+  maxDate: (0, _dateFns.addYears)(new Date(), 20),
+  minDate: (0, _dateFns.addYears)(new Date(), -100),
+  rangeColors: ['#3d91ff', '#3ecf8e', '#fed14c'],
+  startDatePlaceholder: 'Early',
+  endDatePlaceholder: 'Continuous',
+  editableDateInputs: false,
+  dragSelectionEnabled: true,
+  fixedHeight: false,
+  calendarFocus: 'forwards',
+  preventSnapRefocus: false,
+  ariaLabels: {}
+};
+Calendar.propTypes = {
+  showMonthArrow: _propTypes.default.bool,
+  showMonthAndYearPickers: _propTypes.default.bool,
+  disabledDates: _propTypes.default.array,
+  disabledDay: _propTypes.default.func,
+  minDate: _propTypes.default.object,
+  maxDate: _propTypes.default.object,
+  date: _propTypes.default.object,
+  onChange: _propTypes.default.func,
+  onPreviewChange: _propTypes.default.func,
+  onRangeFocusChange: _propTypes.default.func,
+  classNames: _propTypes.default.object,
+  locale: _propTypes.default.object,
+  shownDate: _propTypes.default.object,
+  onShownDateChange: _propTypes.default.func,
+  ranges: _propTypes.default.arrayOf(_DayCell.rangeShape),
+  preview: _propTypes.default.shape({
+    startDate: _propTypes.default.object,
+    endDate: _propTypes.default.object,
+    color: _propTypes.default.string
+  }),
+  dateDisplayFormat: _propTypes.default.string,
+  monthDisplayFormat: _propTypes.default.string,
+  weekdayDisplayFormat: _propTypes.default.string,
+  weekStartsOn: _propTypes.default.number,
+  dayDisplayFormat: _propTypes.default.string,
+  focusedRange: _propTypes.default.arrayOf(_propTypes.default.number),
+  initialFocusedRange: _propTypes.default.arrayOf(_propTypes.default.number),
+  months: _propTypes.default.number,
+  className: _propTypes.default.string,
+  showDateDisplay: _propTypes.default.bool,
+  showPreview: _propTypes.default.bool,
+  displayMode: _propTypes.default.oneOf(['dateRange', 'date']),
+  color: _propTypes.default.string,
+  updateRange: _propTypes.default.func,
+  scroll: _propTypes.default.shape({
+    enabled: _propTypes.default.bool,
+    monthHeight: _propTypes.default.number,
+    longMonthHeight: _propTypes.default.number,
+    monthWidth: _propTypes.default.number,
+    calendarWidth: _propTypes.default.number,
+    calendarHeight: _propTypes.default.number
+  }),
+  direction: _propTypes.default.oneOf(['vertical', 'horizontal']),
+  startDatePlaceholder: _propTypes.default.string,
+  endDatePlaceholder: _propTypes.default.string,
+  navigatorRenderer: _propTypes.default.func,
+  rangeColors: _propTypes.default.arrayOf(_propTypes.default.string),
+  editableDateInputs: _propTypes.default.bool,
+  dragSelectionEnabled: _propTypes.default.bool,
+  fixedHeight: _propTypes.default.bool,
+  calendarFocus: _propTypes.default.string,
+  preventSnapRefocus: _propTypes.default.bool,
+  ariaLabels: _accessibility.ariaLabelsShape
+};
+var _default = exports.default = Calendar;

node_modules/react-date-range/dist/components/Calendar/index.test.js

@@ -0,0 +1,9 @@
+"use strict";
+
+var _Calendar = _interopRequireDefault(require("../Calendar"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+describe('Calendar', () => {
+  test('Should resolve', () => {
+    expect(_Calendar.default).toEqual(expect.anything());
+  });
+});

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

@@ -0,0 +1,139 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _dateFns = require("date-fns");
+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 (!r && 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 || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+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.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.defaultProps = {
+  readOnly: true,
+  disabled: false,
+  dateDisplayFormat: 'MMM D, YYYY'
+};
+var _default = exports.default = DateInput;

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

@@ -0,0 +1,194 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _Calendar = _interopRequireDefault(require("../Calendar"));
+var _DayCell = require("../DayCell");
+var _utils = require("../../utils");
+var _dateFns = require("date-fns");
+var _classnames = _interopRequireDefault(require("classnames"));
+var _styles = _interopRequireDefault(require("../../styles"));
+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 (!r && 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 || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+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.defaultProps = {
+  classNames: {},
+  ranges: [],
+  moveRangeOnFirstSelection: false,
+  retainEndDateOnFirstSelection: false,
+  rangeColors: ['#3d91ff', '#3ecf8e', '#fed14c'],
+  disabledDates: []
+};
+DateRange.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
+};
+var _default = exports.default = DateRange;

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

@@ -0,0 +1,86 @@
+"use strict";
+
+var _react = _interopRequireDefault(require("react"));
+var _dateFns = require("date-fns");
+var _DateRange = _interopRequireDefault(require("../DateRange"));
+var _reactTestRenderer = _interopRequireDefault(require("react-test-renderer"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: 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); }
+let testRenderer = null;
+let instance = null;
+const endDate = new Date();
+const startDate = (0, _dateFns.subDays)(endDate, 7);
+const commonProps = {
+  ranges: [{
+    startDate,
+    endDate,
+    key: 'selection'
+  }],
+  onChange: () => {},
+  moveRangeOnFirstSelection: false
+};
+const compareRanges = (newRange, assertionRange) => {
+  ['startDate', 'endDate'].forEach(key => {
+    if (!newRange[key] || !assertionRange[key]) {
+      return expect(newRange[key]).toEqual(assertionRange[key]);
+    }
+    return expect((0, _dateFns.isSameDay)(newRange[key], assertionRange[key])).toEqual(true);
+  });
+};
+beforeEach(() => {
+  testRenderer = _reactTestRenderer.default.create( /*#__PURE__*/_react.default.createElement(_DateRange.default, commonProps));
+  instance = testRenderer.getInstance();
+});
+describe('DateRange', () => {
+  test('Should resolve', () => {
+    expect(_DateRange.default).toEqual(expect.anything());
+  });
+  test('calculate new selection by resetting end date', () => {
+    const methodResult = instance.calcNewSelection((0, _dateFns.subDays)(endDate, 10), true);
+    compareRanges(methodResult.range, {
+      startDate: (0, _dateFns.subDays)(endDate, 10),
+      endDate: (0, _dateFns.subDays)(endDate, 10)
+    });
+  });
+  test('calculate new selection by resetting end date if start date is not before', () => {
+    const methodResult = instance.calcNewSelection((0, _dateFns.addDays)(endDate, 2), true);
+    compareRanges(methodResult.range, {
+      startDate: (0, _dateFns.addDays)(endDate, 2),
+      endDate: (0, _dateFns.addDays)(endDate, 2)
+    });
+  });
+  test('calculate new selection based on moveRangeOnFirstSelection prop', () => {
+    testRenderer.update( /*#__PURE__*/_react.default.createElement(_DateRange.default, _extends({}, commonProps, {
+      moveRangeOnFirstSelection: true
+    })));
+    const methodResult = instance.calcNewSelection((0, _dateFns.subDays)(endDate, 10), true);
+    compareRanges(methodResult.range, {
+      startDate: (0, _dateFns.subDays)(endDate, 10),
+      endDate: (0, _dateFns.subDays)(endDate, 3)
+    });
+  });
+  test('calculate new selection by retaining end date, based on retainEndDateOnFirstSelection prop', () => {
+    testRenderer.update( /*#__PURE__*/_react.default.createElement(_DateRange.default, _extends({}, commonProps, {
+      retainEndDateOnFirstSelection: true
+    })));
+    const methodResult = instance.calcNewSelection((0, _dateFns.subDays)(endDate, 10), true);
+    compareRanges(methodResult.range, {
+      startDate: (0, _dateFns.subDays)(endDate, 10),
+      endDate
+    });
+  });
+  test('calculate new selection by retaining the unset end date, based on retainEndDateOnFirstSelection prop', () => {
+    testRenderer.update( /*#__PURE__*/_react.default.createElement(_DateRange.default, _extends({}, commonProps, {
+      ranges: [{
+        ...commonProps.ranges[0],
+        endDate: null
+      }],
+      retainEndDateOnFirstSelection: true
+    })));
+    const methodResult = instance.calcNewSelection((0, _dateFns.subDays)(endDate, 10), true);
+    compareRanges(methodResult.range, {
+      startDate: (0, _dateFns.subDays)(endDate, 10),
+      endDate: null
+    });
+  });
+});

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

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _DateRange = _interopRequireDefault(require("../DateRange"));
+var _DefinedRange = _interopRequireDefault(require("../DefinedRange"));
+var _utils = require("../../utils");
+var _classnames = _interopRequireDefault(require("classnames"));
+var _styles = _interopRequireDefault(require("../../styles"));
+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 (!r && 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); }
+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.defaultProps = {};
+DateRangePicker.propTypes = {
+  ..._DateRange.default.propTypes,
+  ..._DefinedRange.default.propTypes,
+  className: _propTypes.default.string
+};
+var _default = exports.default = DateRangePicker;

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

@@ -0,0 +1,238 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.rangeShape = exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _dateFns = require("date-fns");
+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 (!r && 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 || "default"); 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 */
+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.defaultProps = {};
+const rangeShape = exports.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.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
+};
+var _default = exports.default = DayCell;

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

@@ -0,0 +1,149 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _styles = _interopRequireDefault(require("../../styles"));
+var _defaultRanges = require("../../defaultRanges");
+var _DayCell = require("../DayCell");
+var _InputRangeField = _interopRequireDefault(require("../InputRangeField"));
+var _classnames = _interopRequireDefault(require("classnames"));
+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 (!r && 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 || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+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.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.defaultProps = {
+  inputRanges: _defaultRanges.defaultInputRanges,
+  staticRanges: _defaultRanges.defaultStaticRanges,
+  ranges: [],
+  rangeColors: ['#3d91ff', '#3ecf8e', '#fed14c'],
+  focusedRange: [0, 0]
+};
+var _default = exports.default = DefinedRange;

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

@@ -0,0 +1,98 @@
+"use strict";
+
+var _react = _interopRequireDefault(require("react"));
+var _enzyme = require("enzyme");
+var _DefinedRange = _interopRequireDefault(require("../DefinedRange"));
+var _dateFns = require("date-fns");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+describe('DefinedRange tests', () => {
+  test('Should call "renderStaticRangeLabel" callback correct amount of times according to the "hasCustomRendering" option', () => {
+    const renderStaticRangeLabel = jest.fn();
+    (0, _enzyme.mount)( /*#__PURE__*/_react.default.createElement(_DefinedRange.default, {
+      staticRanges: [{
+        label: 'Dynamic Label',
+        range: {},
+        isSelected(range) {
+          const definedRange = this.range();
+          return (0, _dateFns.isSameDay)(range.startDate, definedRange.startDate) && (0, _dateFns.isSameDay)(range.endDate, definedRange.endDate);
+        },
+        hasCustomRendering: true
+      }, {
+        label: 'Static Label',
+        range: {},
+        isSelected(range) {
+          const definedRange = this.range();
+          return (0, _dateFns.isSameDay)(range.startDate, definedRange.startDate) && (0, _dateFns.isSameDay)(range.endDate, definedRange.endDate);
+        }
+      }, {
+        label: 'Hede',
+        range: {},
+        isSelected(range) {
+          const definedRange = this.range();
+          return (0, _dateFns.isSameDay)(range.startDate, definedRange.startDate) && (0, _dateFns.isSameDay)(range.endDate, definedRange.endDate);
+        },
+        hasCustomRendering: true
+      }],
+      renderStaticRangeLabel: renderStaticRangeLabel
+    }));
+    expect(renderStaticRangeLabel).toHaveBeenCalledTimes(2);
+  });
+  test('Should render dynamic static label contents correctly', () => {
+    const renderItalicLabelContent = () => /*#__PURE__*/_react.default.createElement("i", {
+      className: 'italic-label-content'
+    }, 'Italic Content');
+    const renderBoldLabelContent = () => /*#__PURE__*/_react.default.createElement("b", {
+      className: 'bold-label-content'
+    }, 'Bold Content');
+    const renderSomethingElse = () => /*#__PURE__*/_react.default.createElement("img", {
+      className: 'random-image'
+    });
+    const renderStaticRangeLabel = function (staticRange) {
+      let result;
+      if (staticRange.id === 'italic') {
+        result = renderItalicLabelContent();
+      } else if (staticRange.id === 'bold') {
+        result = renderBoldLabelContent();
+      } else {
+        result = renderSomethingElse();
+      }
+      return result;
+    };
+    const wrapper = (0, _enzyme.shallow)( /*#__PURE__*/_react.default.createElement(_DefinedRange.default, {
+      staticRanges: [{
+        id: 'italic',
+        range: {},
+        isSelected(range) {
+          const definedRange = this.range();
+          return (0, _dateFns.isSameDay)(range.startDate, definedRange.startDate) && (0, _dateFns.isSameDay)(range.endDate, definedRange.endDate);
+        },
+        hasCustomRendering: true
+      }, {
+        label: 'Static Label',
+        range: {},
+        isSelected(range) {
+          const definedRange = this.range();
+          return (0, _dateFns.isSameDay)(range.startDate, definedRange.startDate) && (0, _dateFns.isSameDay)(range.endDate, definedRange.endDate);
+        }
+      }, {
+        id: 'whatever',
+        range: {},
+        isSelected(range) {
+          const definedRange = this.range();
+          return (0, _dateFns.isSameDay)(range.startDate, definedRange.startDate) && (0, _dateFns.isSameDay)(range.endDate, definedRange.endDate);
+        },
+        hasCustomRendering: true
+      }, {
+        id: 'bold',
+        range: {},
+        isSelected(range) {
+          const definedRange = this.range();
+          return (0, _dateFns.isSameDay)(range.startDate, definedRange.startDate) && (0, _dateFns.isSameDay)(range.endDate, definedRange.endDate);
+        },
+        hasCustomRendering: true
+      }],
+      renderStaticRangeLabel: renderStaticRangeLabel
+    }));
+    expect(wrapper).toMatchSnapshot();
+  });
+});

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

@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+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 (!r && 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 || "default"); 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;
+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.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.defaultProps = {
+  value: '',
+  placeholder: '-'
+};
+var _default = exports.default = InputRangeField;

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

@@ -0,0 +1,111 @@
+"use strict";
+
+var _react = _interopRequireDefault(require("react"));
+var _enzyme = require("enzyme");
+var _InputRangeField = _interopRequireDefault(require("../InputRangeField"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const styles = {
+  inputRange: 'range',
+  inputRangeInput: 'input',
+  inputRangeLabel: 'label'
+};
+const toChangeEvent = value => ({
+  target: {
+    value
+  }
+});
+describe('InputRangeField tests', () => {
+  test('Should parse input value to number', () => {
+    const onChange = jest.fn();
+    const wrapper = (0, _enzyme.mount)( /*#__PURE__*/_react.default.createElement(_InputRangeField.default, {
+      label: "Input label",
+      styles: styles,
+      onChange: onChange,
+      onFocus: jest.fn(),
+      onBlur: jest.fn()
+    }));
+    wrapper.find('input').simulate('change', toChangeEvent('3'));
+    expect(onChange).lastCalledWith(3);
+    wrapper.find('input').simulate('change', toChangeEvent(12));
+    expect(onChange).lastCalledWith(12);
+    wrapper.find('input').simulate('change', toChangeEvent(''));
+    expect(onChange).lastCalledWith(0);
+    wrapper.find('input').simulate('change', toChangeEvent('invalid number'));
+    expect(onChange).lastCalledWith(0);
+    wrapper.find('input').simulate('change', toChangeEvent(-12));
+    expect(onChange).lastCalledWith(0);
+    wrapper.find('input').simulate('change', toChangeEvent(99999999));
+    expect(onChange).lastCalledWith(99999);
+    expect(onChange).toHaveBeenCalledTimes(6);
+    expect(wrapper).toMatchSnapshot();
+  });
+  test('Should rerender when props change', () => {
+    const wrapper = (0, _enzyme.mount)( /*#__PURE__*/_react.default.createElement(_InputRangeField.default, {
+      value: 12,
+      placeholder: "Placeholder",
+      label: "Input label",
+      styles: styles,
+      onChange: jest.fn(),
+      onFocus: jest.fn(),
+      onBlur: jest.fn()
+    }));
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('value')).toEqual(12);
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('placeholder')).toEqual('Placeholder');
+    expect(wrapper.find(`.${styles.inputRangeLabel}`).text()).toEqual('Input label');
+    wrapper.setProps({
+      value: '32'
+    });
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('value')).toEqual('32');
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('placeholder')).toEqual('Placeholder');
+    expect(wrapper.find(`.${styles.inputRangeLabel}`).text()).toEqual('Input label');
+    wrapper.setProps({
+      placeholder: '-'
+    });
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('value')).toEqual('32');
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('placeholder')).toEqual('-');
+    expect(wrapper.find(`.${styles.inputRangeLabel}`).text()).toEqual('Input label');
+    wrapper.setProps({
+      label: 'Label'
+    });
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('value')).toEqual('32');
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('placeholder')).toEqual('-');
+    expect(wrapper.find(`.${styles.inputRangeLabel}`).text()).toEqual('Label');
+  });
+  test('Should render the label as a Component', () => {
+    const Label = () => /*#__PURE__*/_react.default.createElement("span", {
+      className: "input-range-field-label"
+    }, "Input label");
+    const wrapper = (0, _enzyme.mount)( /*#__PURE__*/_react.default.createElement(_InputRangeField.default, {
+      value: 12,
+      placeholder: "Placeholder",
+      label: /*#__PURE__*/_react.default.createElement(Label, null),
+      styles: styles,
+      onChange: jest.fn(),
+      onFocus: jest.fn(),
+      onBlur: jest.fn()
+    }));
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('value')).toEqual(12);
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('placeholder')).toEqual('Placeholder');
+    expect(wrapper.find(`.${styles.inputRangeLabel}`).text()).toEqual('Input label');
+    expect(wrapper.find(`.${styles.inputRangeLabel}`).text()).toEqual('Input label');
+    expect(wrapper.find(`.input-range-field-label`).text()).toEqual('Input label');
+    wrapper.setProps({
+      value: '32'
+    });
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('value')).toEqual('32');
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('placeholder')).toEqual('Placeholder');
+    expect(wrapper.find(`.${styles.inputRangeLabel}`).text()).toEqual('Input label');
+    wrapper.setProps({
+      placeholder: '-'
+    });
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('value')).toEqual('32');
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('placeholder')).toEqual('-');
+    expect(wrapper.find(`.${styles.inputRangeLabel}`).text()).toEqual('Input label');
+    wrapper.setProps({
+      label: 'Label'
+    });
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('value')).toEqual('32');
+    expect(wrapper.find(`.${styles.inputRangeInput}`).prop('placeholder')).toEqual('-');
+    expect(wrapper.find(`.${styles.inputRangeLabel}`).text()).toEqual('Label');
+  });
+});

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

@@ -0,0 +1,131 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _DayCell = _interopRequireWildcard(require("../DayCell"));
+var _dateFns = require("date-fns");
+var _utils = require("../../utils");
+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 (!r && 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))));
+}
+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.defaultProps = {};
+Month.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
+};
+var _default = exports.default = Month;