@jetbrains/ring-ui 5.1.1 → 6.0.2-beta.0

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

@@ -1,4 +1,8 @@
-import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+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.number.constructor.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';
@@ -13,26 +17,38 @@ 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/es.string.iterator.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 '../_helpers/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 'focus-visible';
 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 '../_helpers/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 '../_helpers/input.js';
-import '../input/input-label.js';
-import 'date-fns/add';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import '../control-label/control-label.js';
 import 'date-fns/addMonths';
 import 'date-fns/getDay';
 import 'date-fns/getDaysInMonth';
@@ -41,13 +57,17 @@ 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 'date-fns/add';
 import './month-names.js';
 import 'date-fns/isThisMonth';
 import 'date-fns/set';
@@ -60,96 +80,110 @@ import 'date-fns/isSameYear';
 import 'date-fns/isThisYear';
 import 'date-fns/setYear';
 
-const scrollExpDelay = 10;
-class DatePopup extends Component {
-  static sameDay(next, prev) {
-    if (next && prev) {
-      return isSameDay(next, prev);
-    }
-    return next === prev;
-  }
-  constructor(props) {
-    super(props);
-    _defineProperty(this, "_scrollDate", void 0);
-    _defineProperty(this, "_scrollTS", void 0);
-    _defineProperty(this, "isInTimeMode", () => !this.props.range && this.props.withTime || false);
-    _defineProperty(this, "componentRef", /*#__PURE__*/React.createRef());
-    _defineProperty(this, "handleWheel", e => {
+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(this, "isValidDate", parsedText => {
-      const minDate = this.parse(this.props.minDate, 'date');
-      const maxDate = this.parse(this.props.maxDate, 'date');
+    _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(this, "scheduleScroll", () => {
-      const current = this.state.scrollDate && this.parse(this.state.scrollDate, 'date') || this.parse(this.props[this.state.active], 'date') || new Date();
-      const goal = this._scrollDate;
+    _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;
+        _this._scrollDate = null;
+        _this._scrollTS = null;
         return;
       }
-      if (this._scrollTS) {
-        const diff = goal - Number(current);
-        const dt = Date.now() - this._scrollTS;
-        const next = goal - diff * Math.E ** (-dt / scrollExpDelay);
-        this.setState({
+      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);
+      _this._scrollTS = Date.now();
+      window.requestAnimationFrame(_this.scheduleScroll);
     });
-    _defineProperty(this, "scrollTo", scrollDate => {
-      this._scrollDate = scrollDate;
-      if (!this._scrollTS) {
-        this.scheduleScroll();
+    _defineProperty(_assertThisInitialized(_this), "scrollTo", function (scrollDate) {
+      _this._scrollDate = scrollDate;
+      if (!_this._scrollTS) {
+        _this.scheduleScroll();
       }
     });
-    _defineProperty(this, "hoverHandler", hoverDate => this.setState({
-      hoverDate
+    _defineProperty(_assertThisInitialized(_this), "hoverHandler", function (hoverDate) {
+      return _this.setState({
+        hoverDate: hoverDate
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleActivate", memoize(function (name) {
+      return function () {
+        return _this.setState({
+          active: name
+        });
+      };
     }));
-    _defineProperty(this, "handleActivate", memoize(name => () => this.setState({
-      active: name
-    })));
-    _defineProperty(this, "handleInput", (text, name) => {
+    _defineProperty(_assertThisInitialized(_this), "handleInput", function (text, name) {
       if (name !== 'time') {
-        const parsed = this.parse(text, name);
-        if (this.isValidDate(parsed)) {
-          this.scrollTo(Number(parsed));
+        var parsed = _this.parse(text, name);
+        if (_this.isValidDate(parsed)) {
+          _this.scrollTo(Number(parsed));
         }
       }
-      this.setState({
-        text,
+      _this.setState({
+        text: text,
         hoverDate: null
       });
     });
-    _defineProperty(this, "handleConfirm", memoize(name => () => this.confirm(name)));
-    _defineProperty(this, "selectHandler", date => {
-      if (this.isInTimeMode()) {
-        this.setState({
+    _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'
-        }, () => this.select({
-          date
-        }));
-      } else {
-        this.select({
-          [this.state.active]: date
+        }, function () {
+          return _this.select({
+            date: date
+          });
         });
+      } else {
+        _this.select(_defineProperty({}, _this.state.active, date));
       }
     });
-    _defineProperty(this, "handleScroll", scrollDate => this.setState({
-      scrollDate
-    }));
-    _defineProperty(this, "onClear", e => {
-      let changes;
-      if (this.props.range) {
+    _defineProperty(_assertThisInitialized(_this), "handleScroll", function (scrollDate) {
+      return _this.setState({
+        scrollDate: 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
@@ -159,266 +193,272 @@ class DatePopup extends Component {
           date: null
         };
       }
-      this.select(changes);
-      this.props.onClear?.(e);
+      _this.select(changes);
+      (_this$props$onClear = (_this$props = _this.props).onClear) === null || _this$props$onClear === void 0 ? 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 ? void 0 : _this$componentRef$cu.focus();
     });
-    const defaultState = {
+    var defaultState = {
       text: null,
       hoverDate: null,
       scrollDate: null
     };
-    const {
-      range,
-      withTime
-    } = props;
+    var range = props.range,
+      withTime = props.withTime;
     if (!range) {
-      const parsedDate = this.parse(props.date, 'date');
-      const active = withTime && parsedDate && !props.time ? 'time' : 'date';
-      this.state = {
-        ...defaultState,
-        active
-      };
+      var parsedDate = _this.parse(props.date, 'date');
+      var active = withTime && parsedDate && !props.time ? 'time' : 'date';
+      _this.state = _objectSpread2(_objectSpread2({}, defaultState), {}, {
+        active: active
+      });
     } else if (props.from && !props.to) {
-      this.state = {
-        ...defaultState,
+      _this.state = _objectSpread2(_objectSpread2({}, defaultState), {}, {
         active: 'to'
-      };
+      });
     } else {
-      this.state = {
-        ...defaultState,
+      _this.state = _objectSpread2(_objectSpread2({}, defaultState), {}, {
         active: 'from'
-      };
-    }
-  }
-  componentDidMount() {
-    if (this.componentRef.current) {
-      this.componentRef.current.addEventListener('wheel', this.handleWheel, {
-        passive: true
       });
     }
+    return _this;
   }
-  componentDidUpdate(prevProps, prevState) {
-    if (this.state.active !== prevState.active) {
-      if (this.state.text && prevState.active) {
-        this.confirm(prevState.active);
+  _createClass(DatePopup, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      if (this.componentRef.current) {
+        this.componentRef.current.addEventListener('wheel', this.handleWheel);
       }
-      this.setState({
-        text: null
-      });
     }
-  }
-  componentWillUnmount() {
-    if (this.componentRef.current) {
-      this.componentRef.current.removeEventListener('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
+        });
+      }
     }
-  }
-  parse(text, type) {
-    if (type === 'time') {
-      return parseTime(String(text));
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      if (this.componentRef.current) {
+        this.componentRef.current.removeEventListener('wheel', this.handleWheel);
+      }
     }
-    return this.props.parseDateInput(text);
-  }
-  select(changes) {
-    const {
-      range,
-      withTime
-    } = this.props;
-    const prevActive = this.state.active;
-    if (!range && !withTime) {
-      this.setState({
-        text: null,
-        scrollDate: null
-      });
-      const 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) {
-      const date = this.parse(this.props.date, 'date');
-      const time = this.parse(this.props.time, 'time');
-      const 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();
+  }, {
+    key: "parse",
+    value: function parse(text, type) {
+      if (type === 'time') {
+        return parseTime(String(text));
       }
-    } else {
-      let {
-        from,
-        to
-      } = {
-        ...this.props,
-        ...changes
-      };
-      from = this.parse(from, 'from');
-      to = this.parse(to, 'to');
-      // proceed to setting the end by default
-      let active = 'to';
-      let 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
+      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) {
-          to = from;
-          from = changes.to;
+          active = 'from';
+          complete = !!from;
+        }
+        this.setState({
+          active: active,
+          hoverDate: null,
+          text: null
+        });
+        this.props.onChange({
+          from: from,
+          to: to
+        });
+        if (complete) {
+          this.props.onComplete();
         }
-      } 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();
       }
     }
-  }
-  confirm(name) {
-    const text = this.state.text;
-    let result;
-    if (name === 'time') {
-      result = this.parse(text, name);
-      const time = this.parse('time' in this.props ? this.props.time : '', 'time');
-      const 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);
+  }, {
+    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(_defineProperty({}, name, result));
     }
-    this.select({
-      [name]: result
-    });
-  }
-  render() {
-    const {
-      range,
-      hidden,
-      withTime,
-      locale
-    } = this.props;
-    const {
-      from,
-      to,
-      date,
-      time,
-      ...restProps
-    } = this.props;
-    const parsedDate = this.parse(this.props.date, 'date');
-    const parsedTo = this.parse(this.props.to, 'to');
-    const names = range ? ['from', 'to'] : ['date'];
-    const dates = names.reduce((obj, key) => {
-      const value = this.props[key];
-      return {
-        ...obj,
-        [key]: this.parse(value, key)
-      };
-    }, {});
-    const activeDate = this.state.active !== 'time' ? this.state.hoverDate || (this.state.text != null ? this.parse(this.state.text, 'date') : null) : this.state.hoverDate || null;
-    const currentRange = range && dates.from && dates.to && [dates.from, dates.to] || null;
-    let 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) {
+  }, {
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+      var _this$props3 = this.props,
+        range = _this$props3.range,
+        hidden = _this$props3.hidden,
+        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), {}, _defineProperty({}, 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;
-          }
-          if (isBefore(startOfDay(activeDate), startOfDay(dates.from))) {
-            activeRange = [activeDate, dates.from];
-          } else {
-            activeRange = [dates.from, activeDate];
-          }
-          break;
-      }
-    }
-    const scrollDate = withTime && !range ? this.state.scrollDate || dates.date || new Date() : this.state.scrollDate || dates[this.state.active] || new Date();
-    const calendarProps = {
-      ...restProps,
-      ...dates,
-      scrollDate,
-      activeDate,
-      currentRange,
-      activeRange,
-      onScroll: this.handleScroll,
-      onScrollChange: this.scrollTo
-    };
-    const 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(name => {
-      let onClear;
-      if (clearable && name !== 'from' && !this.isInTimeMode()) {
-        onClear = this.onClear.bind(this);
+          case 'to':
+            if (!dates.from) {
+              break;
+            }
+            if (isBefore(startOfDay(activeDate), startOfDay(dates.from))) {
+              activeRange = [activeDate, dates.from];
+            } else {
+              activeRange = [dates.from, activeDate];
+            }
+            break;
+        }
       }
-      return /*#__PURE__*/React.createElement(DateInput, _extends({}, this.props, this.state, {
-        divider: name === 'from' && (dates[name] != null || parsedTo != null),
-        name: name,
-        key: name,
-        date: dates[name],
-        active: this.state.active === name,
+      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: scrollDate,
+        activeDate: activeDate,
+        currentRange: currentRange,
+        activeRange: 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,
+          hidden: hidden,
+          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',
         hidden: hidden,
-        onActivate: this.handleActivate(name),
+        onActivate: this.handleActivate('time'),
         onInput: this.handleInput,
-        onConfirm: this.handleConfirm(name),
-        onClear: onClear,
+        onConfirm: this.handleConfirm('time'),
+        onClear: clearable && this.onClear || undefined,
         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',
-      hidden: hidden,
-      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));
-  }
-}
+      })) : ''), /*#__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,
@@ -442,7 +482,7 @@ _defineProperty(DatePopup, "propTypes", {
   locale: PropTypes.object
 });
 _defineProperty(DatePopup, "defaultProps", {
-  onChange() {}
+  onChange: function onChange() {}
 });
 
 export { DatePopup as default };