@jetbrains/ring-ui 5.1.23 → 5.1.24

package/dist/date-picker/date-popup.js

@@ -0,0 +1,493 @@
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, k as _assertThisInitialized, g as _objectSpread2, d as _createClass, e as _objectWithoutProperties, f as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.reduce.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.array.map.js';
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import isAfter from 'date-fns/isAfter';
+import isBefore from 'date-fns/isBefore';
+import isSameDay from 'date-fns/isSameDay';
+import startOfDay from 'date-fns/startOfDay';
+import { set } from 'date-fns';
+import memoize from '../global/memoize.js';
+import DateInput from './date-input.js';
+import Months from './months.js';
+import Years from './years.js';
+import Weekdays from './weekdays.js';
+import { dateType, parseTime } from './consts.js';
+import { m as modules_0c7b7d96 } from '../_helpers/date-picker.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.map.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/es.weak-map.js';
+import 'core-js/modules/es.array.concat.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.replace.js';
+import 'core-js/modules/es.array.filter.js';
+import 'classnames';
+import '../input/input.js';
+import 'core-js/modules/es.object.values.js';
+import '@jetbrains/icons/close-12px';
+import '../global/prop-types.js';
+import '../button/button.js';
+import '@jetbrains/icons/chevron-10px';
+import '../icon/icon.js';
+import 'util-deprecate';
+import '../icon/icon__constants.js';
+import '../_helpers/icon.js';
+import '../icon/icon__svg.js';
+import 'core-js/modules/es.string.starts-with.js';
+import '../link/clickableLink.js';
+import '../global/controls-height.js';
+import '../_helpers/button__classes.js';
+import '../global/get-uid.js';
+import 'core-js/modules/es.regexp.to-string.js';
+import '../i18n/i18n-context.js';
+import '../i18n/i18n.js';
+import 'core-js/modules/es.set.js';
+import '../global/composeRefs.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import '../control-label/control-label.js';
+import '../_helpers/control-label.js';
+import '../_helpers/input.js';
+import 'date-fns/addMonths';
+import 'date-fns/getDay';
+import 'date-fns/getDaysInMonth';
+import 'date-fns/startOfMonth';
+import 'date-fns/subMonths';
+import 'date-fns/endOfMonth';
+import '../global/schedule-raf.js';
+import '../global/linear-function.js';
+import '../global/use-event-callback.js';
+import './month.js';
+import 'date-fns/addDays';
+import 'date-fns/format';
+import 'date-fns/setDay';
+import './day.js';
+import 'core-js/modules/es.array.includes.js';
+import 'core-js/modules/es.string.includes.js';
+import 'date-fns/getDate';
+import 'date-fns/isToday';
+import 'core-js/modules/es.array.slice.js';
+import 'core-js/modules/es.array.index-of.js';
+import 'date-fns/add';
+import './month-names.js';
+import 'date-fns/isThisMonth';
+import 'date-fns/set';
+import 'date-fns/startOfYear';
+import './month-slider.js';
+import 'date-fns/addYears';
+import 'date-fns/subYears';
+import 'date-fns/getYear';
+import 'date-fns/isSameYear';
+import 'date-fns/isThisYear';
+import 'date-fns/setYear';
+
+var _excluded = ["from", "to", "date", "time"];
+var scrollExpDelay = 10;
+var DatePopup = /*#__PURE__*/function (_Component) {
+  _inherits(DatePopup, _Component);
+  var _super = _createSuper(DatePopup);
+  function DatePopup(props) {
+    var _this;
+    _classCallCheck(this, DatePopup);
+    _this = _super.call(this, props);
+    _defineProperty(_assertThisInitialized(_this), "_scrollDate", void 0);
+    _defineProperty(_assertThisInitialized(_this), "_scrollTS", void 0);
+    _defineProperty(_assertThisInitialized(_this), "isInTimeMode", function () {
+      return !_this.props.range && _this.props.withTime || false;
+    });
+    _defineProperty(_assertThisInitialized(_this), "componentRef", /*#__PURE__*/React.createRef());
+    _defineProperty(_assertThisInitialized(_this), "handleWheel", function (e) {
+      if (e.cancelable) {
+        e.preventDefault();
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "isValidDate", function (parsedText) {
+      var minDate = _this.parse(_this.props.minDate, 'date');
+      var maxDate = _this.parse(_this.props.maxDate, 'date');
+      if (parsedText) {
+        return !(minDate && isBefore(parsedText, minDate) || maxDate && isAfter(parsedText, maxDate));
+      }
+      return false;
+    });
+    _defineProperty(_assertThisInitialized(_this), "scheduleScroll", function () {
+      var current = _this.state.scrollDate && _this.parse(_this.state.scrollDate, 'date') || _this.parse(_this.props[_this.state.active], 'date') || new Date();
+      var goal = _this._scrollDate;
+      if (!current || !goal || DatePopup.sameDay(goal, current)) {
+        _this._scrollDate = null;
+        _this._scrollTS = null;
+        return;
+      }
+      if (_this._scrollTS) {
+        var diff = goal - Number(current);
+        var dt = Date.now() - _this._scrollTS;
+        var next = goal - diff * Math.pow(Math.E, -dt / scrollExpDelay);
+        _this.setState({
+          scrollDate: next
+        });
+      }
+      _this._scrollTS = Date.now();
+      window.requestAnimationFrame(_this.scheduleScroll);
+    });
+    _defineProperty(_assertThisInitialized(_this), "scrollTo", function (scrollDate) {
+      _this._scrollDate = scrollDate;
+      if (!_this._scrollTS) {
+        _this.scheduleScroll();
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "hoverHandler", function (hoverDate) {
+      return _this.setState({
+        hoverDate
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleActivate", memoize(function (name) {
+      return function () {
+        return _this.setState({
+          active: name
+        });
+      };
+    }));
+    _defineProperty(_assertThisInitialized(_this), "handleInput", function (text, name) {
+      if (name !== 'time') {
+        var parsed = _this.parse(text, name);
+        if (_this.isValidDate(parsed)) {
+          _this.scrollTo(Number(parsed));
+        }
+      }
+      _this.setState({
+        text,
+        hoverDate: null
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleConfirm", memoize(function (name) {
+      return function () {
+        return _this.confirm(name);
+      };
+    }));
+    _defineProperty(_assertThisInitialized(_this), "selectHandler", function (date) {
+      if (_this.isInTimeMode()) {
+        _this.setState({
+          active: 'time'
+        }, function () {
+          return _this.select({
+            date
+          });
+        });
+      } else {
+        _this.select({
+          [_this.state.active]: date
+        });
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleScroll", function (scrollDate) {
+      return _this.setState({
+        scrollDate
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "onClear", function (e) {
+      var _this$props$onClear, _this$props, _this$componentRef$cu;
+      var changes;
+      if (_this.props.range) {
+        changes = {
+          from: null,
+          to: null
+        };
+      } else {
+        changes = {
+          date: null
+        };
+      }
+      _this.select(changes);
+      (_this$props$onClear = (_this$props = _this.props).onClear) === null || _this$props$onClear === void 0 || _this$props$onClear.call(_this$props, e);
+      (_this$componentRef$cu = _this.componentRef.current) === null || _this$componentRef$cu === void 0 || (_this$componentRef$cu = _this$componentRef$cu.querySelector('input')) === null || _this$componentRef$cu === void 0 || _this$componentRef$cu.focus();
+    });
+    var defaultState = {
+      text: null,
+      hoverDate: null,
+      scrollDate: null
+    };
+    var range = props.range,
+      withTime = props.withTime;
+    if (!range) {
+      var parsedDate = _this.parse(props.date, 'date');
+      var active = withTime && parsedDate && !props.time ? 'time' : 'date';
+      _this.state = _objectSpread2(_objectSpread2({}, defaultState), {}, {
+        active
+      });
+    } else if (props.from && !props.to) {
+      _this.state = _objectSpread2(_objectSpread2({}, defaultState), {}, {
+        active: 'to'
+      });
+    } else {
+      _this.state = _objectSpread2(_objectSpread2({}, defaultState), {}, {
+        active: 'from'
+      });
+    }
+    return _this;
+  }
+  _createClass(DatePopup, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      if (this.componentRef.current) {
+        this.componentRef.current.addEventListener('wheel', this.handleWheel);
+      }
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps, prevState) {
+      if (this.state.active !== prevState.active) {
+        if (this.state.text && prevState.active) {
+          this.confirm(prevState.active);
+        }
+        this.setState({
+          text: null
+        });
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      if (this.componentRef.current) {
+        this.componentRef.current.removeEventListener('wheel', this.handleWheel);
+      }
+    }
+  }, {
+    key: "parse",
+    value: function parse(text, type) {
+      if (type === 'time') {
+        return parseTime(String(text));
+      }
+      return this.props.parseDateInput(text);
+    }
+  }, {
+    key: "select",
+    value: function select(changes) {
+      var _this$props2 = this.props,
+        range = _this$props2.range,
+        withTime = _this$props2.withTime;
+      var prevActive = this.state.active;
+      if (!range && !withTime) {
+        this.setState({
+          text: null,
+          scrollDate: null
+        });
+        var adjustedDate = changes.date && set(new Date(), {
+          year: changes.date.getFullYear(),
+          month: changes.date.getMonth(),
+          date: changes.date.getDate()
+        });
+        this.props.onChange(adjustedDate);
+        this.props.onComplete();
+      } else if (!range && withTime) {
+        var date = this.parse(this.props.date, 'date');
+        var time = this.parse(this.props.time, 'time');
+        var changeToSubmit = {
+          date: changes.date || date,
+          time: changes.time || time
+        };
+        this.setState({
+          active: changes.date ? 'time' : 'date',
+          text: null,
+          scrollDate: null
+        });
+        this.props.onChange(changeToSubmit);
+        if (!changes.date && prevActive === 'time' && changeToSubmit.date && changeToSubmit.time) {
+          this.props.onComplete();
+        }
+      } else {
+        var _this$props$changes = _objectSpread2(_objectSpread2({}, this.props), changes),
+          from = _this$props$changes.from,
+          to = _this$props$changes.to;
+        from = this.parse(from, 'from');
+        to = this.parse(to, 'to');
+        // proceed to setting the end by default
+        var active = 'to';
+        var complete = false;
+        // end is before beginning
+        if (from && to && isAfter(startOfDay(from), startOfDay(to))) {
+          // ignore the old end when beginning is changed
+          if (changes.from) {
+            to = null;
+            // treat range as reverse when end is changed
+          } else if (changes.to) {
+            to = from;
+            from = changes.to;
+          }
+        } else if (changes.to) {
+          active = 'from';
+          complete = !!from;
+        }
+        this.setState({
+          active,
+          hoverDate: null,
+          text: null
+        });
+        this.props.onChange({
+          from,
+          to
+        });
+        if (complete) {
+          this.props.onComplete();
+        }
+      }
+    }
+  }, {
+    key: "confirm",
+    value: function confirm(name) {
+      var text = this.state.text;
+      var result;
+      if (name === 'time') {
+        result = this.parse(text, name);
+        var time = this.parse('time' in this.props ? this.props.time : '', 'time');
+        var emptyCase = this.state.active === 'time' ? '00:00' : null;
+        result = result || time || emptyCase;
+      } else {
+        result = this.parse(text, name);
+        if (!this.isValidDate(result)) {
+          result = this.parse(name in this.props ? this.props[name] : '', name);
+        }
+      }
+      this.select({
+        [name]: result
+      });
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+      var _this$props3 = this.props,
+        range = _this$props3.range,
+        withTime = _this$props3.withTime,
+        locale = _this$props3.locale;
+      var _this$props4 = this.props;
+        _this$props4.from;
+        _this$props4.to;
+        _this$props4.date;
+        var time = _this$props4.time,
+        restProps = _objectWithoutProperties(_this$props4, _excluded);
+      var parsedDate = this.parse(this.props.date, 'date');
+      var parsedTo = this.parse(this.props.to, 'to');
+      var names = range ? ['from', 'to'] : ['date'];
+      var dates = names.reduce(function (obj, key) {
+        var value = _this2.props[key];
+        return _objectSpread2(_objectSpread2({}, obj), {}, {
+          [key]: _this2.parse(value, key)
+        });
+      }, {});
+      var activeDate = this.state.active !== 'time' ? this.state.hoverDate || (this.state.text != null ? this.parse(this.state.text, 'date') : null) : this.state.hoverDate || null;
+      var currentRange = range && dates.from && dates.to && [dates.from, dates.to] || null;
+      var activeRange = null;
+      if (range && activeDate) {
+        switch (this.state.active) {
+          case 'from':
+            if (dates.to && isAfter(startOfDay(activeDate), startOfDay(dates.to))) {
+              activeRange = [activeDate, dates.to];
+            }
+            break;
+          case 'to':
+            if (!dates.from) {
+              break;
+            }
+            if (isBefore(startOfDay(activeDate), startOfDay(dates.from))) {
+              activeRange = [activeDate, dates.from];
+            } else {
+              activeRange = [dates.from, activeDate];
+            }
+            break;
+        }
+      }
+      var scrollDate = withTime && !range ? this.state.scrollDate || dates.date || new Date() : this.state.scrollDate || dates[this.state.active] || new Date();
+      var calendarProps = _objectSpread2(_objectSpread2(_objectSpread2({}, restProps), dates), {}, {
+        scrollDate,
+        activeDate,
+        currentRange,
+        activeRange,
+        onScroll: this.handleScroll,
+        onScrollChange: this.scrollTo
+      });
+      var clearable = Boolean(this.props.onClear);
+      return /*#__PURE__*/React.createElement("div", {
+        className: modules_0c7b7d96.datePopup,
+        "data-test": "ring-date-popup",
+        ref: this.componentRef
+      }, /*#__PURE__*/React.createElement("div", {
+        className: modules_0c7b7d96.filterWrapper
+      }, names.map(function (name) {
+        var onClear;
+        if (clearable && name !== 'from' && !_this2.isInTimeMode()) {
+          onClear = _this2.onClear.bind(_this2);
+        }
+        return /*#__PURE__*/React.createElement(DateInput, _extends({}, _this2.props, _this2.state, {
+          divider: name === 'from' && (dates[name] != null || parsedTo != null),
+          name: name,
+          key: name,
+          date: dates[name],
+          active: _this2.state.active === name,
+          onActivate: _this2.handleActivate(name),
+          onInput: _this2.handleInput,
+          onConfirm: _this2.handleConfirm(name),
+          onClear: onClear,
+          locale: locale
+        }));
+      }), this.isInTimeMode() ? /*#__PURE__*/React.createElement(DateInput, _extends({}, this.props, {
+        text: this.state.text,
+        divider: !!parsedDate,
+        hoverDate: null,
+        name: 'time',
+        key: 'time',
+        date: null,
+        time: time,
+        active: this.state.active === 'time',
+        onActivate: this.handleActivate('time'),
+        onInput: this.handleInput,
+        onConfirm: this.handleConfirm('time'),
+        onClear: clearable && this.onClear || undefined,
+        locale: locale
+      })) : ''), /*#__PURE__*/React.createElement(Weekdays, {
+        locale: locale
+      }), /*#__PURE__*/React.createElement("div", {
+        className: modules_0c7b7d96.calendar
+      }, /*#__PURE__*/React.createElement(Months, _extends({}, calendarProps, {
+        onHover: this.hoverHandler,
+        onSelect: this.selectHandler,
+        locale: locale
+      })), /*#__PURE__*/React.createElement(Years, calendarProps)), this.props.renderAfterCalendar && this.props.renderAfterCalendar(this.state));
+    }
+  }], [{
+    key: "sameDay",
+    value: function sameDay(next, prev) {
+      if (next && prev) {
+        return isSameDay(next, prev);
+      }
+      return next === prev;
+    }
+  }]);
+  return DatePopup;
+}(Component);
+_defineProperty(DatePopup, "propTypes", {
+  className: PropTypes.string,
+  date: dateType,
+  range: PropTypes.bool,
+  withTime: PropTypes.bool,
+  time: PropTypes.string,
+  from: dateType,
+  to: dateType,
+  renderAfterCalendar: PropTypes.func,
+  displayFormat: PropTypes.func,
+  parseDateInput: PropTypes.func,
+  onChange: PropTypes.func,
+  onComplete: PropTypes.func,
+  onClear: PropTypes.func,
+  minDate: dateType,
+  maxDate: dateType,
+  fromPlaceholder: PropTypes.string,
+  toPlaceholder: PropTypes.string,
+  timePlaceholder: PropTypes.string,
+  locale: PropTypes.object
+});
+_defineProperty(DatePopup, "defaultProps", {
+  onChange() {}
+});
+
+export { DatePopup as default };

package/dist/date-picker/day.d.ts

@@ -0,0 +1,31 @@
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import { MonthsProps } from './consts';
+export interface DayProps extends MonthsProps {
+    day: Date;
+    empty: boolean;
+}
+export default class Day extends Component<DayProps> {
+    static propTypes: {
+        day: PropTypes.Requireable<NonNullable<string | number | Date | null | undefined>>;
+        from: PropTypes.Requireable<NonNullable<string | number | Date | null | undefined>>;
+        currentRange: PropTypes.Requireable<(NonNullable<string | number | Date | null | undefined> | null | undefined)[]>;
+        activeRange: PropTypes.Requireable<(NonNullable<string | number | Date | null | undefined> | null | undefined)[]>;
+        empty: PropTypes.Requireable<boolean>;
+        onSelect: PropTypes.Requireable<(...args: any[]) => any>;
+        parseDateInput: PropTypes.Requireable<(...args: any[]) => any>;
+        onHover: PropTypes.Requireable<(...args: any[]) => any>;
+        locale: PropTypes.Requireable<object>;
+        minDate: PropTypes.Requireable<NonNullable<string | number | Date | null | undefined>>;
+        maxDate: PropTypes.Requireable<NonNullable<string | number | Date | null | undefined>>;
+    };
+    handleClick: () => void;
+    handleMouseOver: () => void;
+    handleMouseOut: () => void;
+    isDay: (date: Date) => boolean;
+    is: (name: 'date' | 'from' | 'to' | 'activeDate') => boolean;
+    inRange: (range: [Date, Date] | null) => boolean | null;
+    isDisabled: (date: Date) => boolean;
+    parse(text: string | null | undefined): Date | null;
+    render(): React.JSX.Element;
+}

package/dist/date-picker/day.js

@@ -0,0 +1,139 @@
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, k as _assertThisInitialized, d as _createClass } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.array.includes.js';
+import 'core-js/modules/es.string.includes.js';
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import addDays from 'date-fns/addDays';
+import format from 'date-fns/format';
+import getDay from 'date-fns/getDay';
+import getDate from 'date-fns/getDate';
+import isAfter from 'date-fns/isAfter';
+import isBefore from 'date-fns/isBefore';
+import isSameDay from 'date-fns/isSameDay';
+import isToday from 'date-fns/isToday';
+import startOfDay from 'date-fns/startOfDay';
+import { dateType, getDayNumInWeek, weekdays } from './consts.js';
+import { m as modules_0c7b7d96 } from '../_helpers/date-picker.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.array.slice.js';
+import 'core-js/modules/es.object.values.js';
+import 'core-js/modules/es.array.index-of.js';
+import 'date-fns/add';
+
+var hoverTO;
+var Day = /*#__PURE__*/function (_Component) {
+  _inherits(Day, _Component);
+  var _super = _createSuper(Day);
+  function Day() {
+    var _this;
+    _classCallCheck(this, Day);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "handleClick", function () {
+      return _this.props.onSelect(_this.props.day);
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleMouseOver", function () {
+      if (hoverTO) {
+        window.clearTimeout(hoverTO);
+        hoverTO = null;
+      }
+      _this.props.onHover(_this.props.day);
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleMouseOut", function () {
+      hoverTO = window.setTimeout(_this.props.onHover, 0);
+    });
+    _defineProperty(_assertThisInitialized(_this), "isDay", function (date) {
+      return isSameDay(_this.props.day, date);
+    });
+    _defineProperty(_assertThisInitialized(_this), "is", function (name) {
+      var value = _this.props[name];
+      return value != null && _this.isDay(value);
+    });
+    _defineProperty(_assertThisInitialized(_this), "inRange", function (range) {
+      return range && isAfter(startOfDay(_this.props.day), startOfDay(range[0])) && isBefore(startOfDay(_this.props.day), startOfDay(range[1]));
+    });
+    _defineProperty(_assertThisInitialized(_this), "isDisabled", function (date) {
+      var min = _this.parse(_this.props.minDate);
+      var max = _this.parse(_this.props.maxDate);
+      return min != null && isBefore(startOfDay(date), startOfDay(min)) || max != null && isAfter(startOfDay(date), startOfDay(max));
+    });
+    return _this;
+  }
+  _createClass(Day, [{
+    key: "parse",
+    value: function parse(text) {
+      return this.props.parseDateInput(text);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        day = _this$props.day,
+        from = _this$props.from,
+        currentRange = _this$props.currentRange,
+        activeRange = _this$props.activeRange,
+        empty = _this$props.empty,
+        locale = _this$props.locale;
+      var reverse = activeRange && activeRange[1] === from;
+      var dayInWeek = getDayNumInWeek(locale, getDay(day)) + 1;
+      function makeSpreadRange(range) {
+        return range && [range[0], addDays(range[1], 1)];
+      }
+      var spreadRange = makeSpreadRange(currentRange);
+      var disabled = this.isDisabled(day);
+      var activeSpreadRange = makeSpreadRange(activeRange);
+      return (
+        /*#__PURE__*/
+        // TODO make keyboard navigation actually work
+        React.createElement("button", {
+          type: "button",
+          className: classNames(modules_0c7b7d96.day, modules_0c7b7d96["Day".concat(dayInWeek)], {
+            [modules_0c7b7d96.current]: ['date', 'from', 'to'].some(this.is),
+            [modules_0c7b7d96.active]: !disabled && this.is('activeDate'),
+            [modules_0c7b7d96.weekend]: [weekdays.SA, weekdays.SU].includes(getDay(day)),
+            [modules_0c7b7d96.empty]: empty,
+            [modules_0c7b7d96.from]: currentRange && this.isDay(currentRange[0]) && !reverse || activeRange && this.isDay(activeRange[0]),
+            [modules_0c7b7d96.to]: currentRange && this.isDay(currentRange[1]) || activeRange && this.isDay(activeRange[1]),
+            [modules_0c7b7d96.between]: this.inRange(currentRange),
+            [modules_0c7b7d96.activeBetween]: !disabled && this.inRange(activeRange),
+            [modules_0c7b7d96.first]: getDate(day) === 1,
+            [modules_0c7b7d96.spread]: this.inRange(spreadRange),
+            [modules_0c7b7d96.activeSpread]: !disabled && this.inRange(activeSpreadRange),
+            [modules_0c7b7d96.disabled]: disabled
+          }),
+          onClick: this.handleClick,
+          onMouseOver: this.handleMouseOver,
+          onFocus: this.handleMouseOver,
+          onMouseOut: this.handleMouseOut,
+          onBlur: this.handleMouseOut,
+          disabled: disabled
+        }, empty || /*#__PURE__*/React.createElement("span", {
+          className: classNames({
+            [modules_0c7b7d96.today]: isToday(day)
+          })
+        }, format(day, 'd')))
+      );
+    }
+  }]);
+  return Day;
+}(Component);
+_defineProperty(Day, "propTypes", {
+  day: dateType,
+  from: dateType,
+  currentRange: PropTypes.arrayOf(dateType),
+  activeRange: PropTypes.arrayOf(dateType),
+  empty: PropTypes.bool,
+  onSelect: PropTypes.func,
+  parseDateInput: PropTypes.func,
+  onHover: PropTypes.func,
+  locale: PropTypes.object,
+  minDate: dateType,
+  maxDate: dateType
+});
+
+export { Day as default };

package/dist/date-picker/formats.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string[];
+export default _default;