antd3-esm 1.0.1

package/dist/CommonMixin.js

@@ -0,0 +1,816 @@
+import { _ as _inherits, a as _classCallCheck, b as _possibleConstructorReturn, e as _extends } from './icon.js';
+import React__default, { Component } from 'react';
+import { m as moment, c as classNames, P as PropTypes, t as enUs } from './config-provider.js';
+import { p as polyfill } from './menu.js';
+
+var DateConstants = {
+  DATE_ROW_COUNT: 6,
+  DATE_COL_COUNT: 7
+};
+
+var DateTHead = function (_React$Component) {
+  _inherits(DateTHead, _React$Component);
+
+  function DateTHead() {
+    _classCallCheck(this, DateTHead);
+
+    return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
+  }
+
+  DateTHead.prototype.render = function render() {
+    var props = this.props;
+    var value = props.value;
+    var localeData = value.localeData();
+    var prefixCls = props.prefixCls;
+    var veryShortWeekdays = [];
+    var weekDays = [];
+    var firstDayOfWeek = localeData.firstDayOfWeek();
+    var showWeekNumberEl = void 0;
+    var now = moment();
+    for (var dateColIndex = 0; dateColIndex < DateConstants.DATE_COL_COUNT; dateColIndex++) {
+      var index = (firstDayOfWeek + dateColIndex) % DateConstants.DATE_COL_COUNT;
+      now.day(index);
+      veryShortWeekdays[dateColIndex] = localeData.weekdaysMin(now);
+      weekDays[dateColIndex] = localeData.weekdaysShort(now);
+    }
+
+    if (props.showWeekNumber) {
+      showWeekNumberEl = React__default.createElement(
+        'th',
+        {
+          role: 'columnheader',
+          className: prefixCls + '-column-header ' + prefixCls + '-week-number-header'
+        },
+        React__default.createElement(
+          'span',
+          { className: prefixCls + '-column-header-inner' },
+          'x'
+        )
+      );
+    }
+    var weekDaysEls = weekDays.map(function (day, xindex) {
+      return React__default.createElement(
+        'th',
+        {
+          key: xindex,
+          role: 'columnheader',
+          title: day,
+          className: prefixCls + '-column-header'
+        },
+        React__default.createElement(
+          'span',
+          { className: prefixCls + '-column-header-inner' },
+          veryShortWeekdays[xindex]
+        )
+      );
+    });
+    return React__default.createElement(
+      'thead',
+      null,
+      React__default.createElement(
+        'tr',
+        { role: 'row' },
+        showWeekNumberEl,
+        weekDaysEls
+      )
+    );
+  };
+
+  return DateTHead;
+}(React__default.Component);
+
+var defaultDisabledTime = {
+  disabledHours: function disabledHours() {
+    return [];
+  },
+  disabledMinutes: function disabledMinutes() {
+    return [];
+  },
+  disabledSeconds: function disabledSeconds() {
+    return [];
+  }
+};
+
+function getTodayTime(value) {
+  var today = moment();
+  today.locale(value.locale()).utcOffset(value.utcOffset());
+  return today;
+}
+
+function getTitleString(value) {
+  return value.format('LL');
+}
+
+function getTodayTimeStr(value) {
+  var today = getTodayTime(value);
+  return getTitleString(today);
+}
+
+function getMonthName(month) {
+  var locale = month.locale();
+  var localeData = month.localeData();
+  return localeData[locale === 'zh-cn' ? 'months' : 'monthsShort'](month);
+}
+
+function syncTime(from, to) {
+  if (!moment.isMoment(from) || !moment.isMoment(to)) return;
+  to.hour(from.hour());
+  to.minute(from.minute());
+  to.second(from.second());
+  to.millisecond(from.millisecond());
+}
+
+function getTimeConfig(value, disabledTime) {
+  var disabledTimeConfig = disabledTime ? disabledTime(value) : {};
+  disabledTimeConfig = _extends({}, defaultDisabledTime, disabledTimeConfig);
+  return disabledTimeConfig;
+}
+
+function isTimeValidByConfig(value, disabledTimeConfig) {
+  var invalidTime = false;
+  if (value) {
+    var hour = value.hour();
+    var minutes = value.minute();
+    var seconds = value.second();
+    var disabledHours = disabledTimeConfig.disabledHours();
+    if (disabledHours.indexOf(hour) === -1) {
+      var disabledMinutes = disabledTimeConfig.disabledMinutes(hour);
+      if (disabledMinutes.indexOf(minutes) === -1) {
+        var disabledSeconds = disabledTimeConfig.disabledSeconds(hour, minutes);
+        invalidTime = disabledSeconds.indexOf(seconds) !== -1;
+      } else {
+        invalidTime = true;
+      }
+    } else {
+      invalidTime = true;
+    }
+  }
+  return !invalidTime;
+}
+
+function isTimeValid(value, disabledTime) {
+  var disabledTimeConfig = getTimeConfig(value, disabledTime);
+  return isTimeValidByConfig(value, disabledTimeConfig);
+}
+
+function isAllowedDate(value, disabledDate, disabledTime) {
+  if (disabledDate) {
+    if (disabledDate(value)) {
+      return false;
+    }
+  }
+  if (disabledTime) {
+    if (!isTimeValid(value, disabledTime)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function formatDate(value, format) {
+  if (!value) {
+    return '';
+  }
+
+  if (Array.isArray(format)) {
+    format = format[0];
+  }
+
+  return value.format(format);
+}
+
+function isSameDay(one, two) {
+  return one && two && one.isSame(two, 'day');
+}
+
+function beforeCurrentMonthYear(current, today) {
+  if (current.year() < today.year()) {
+    return 1;
+  }
+  return current.year() === today.year() && current.month() < today.month();
+}
+
+function afterCurrentMonthYear(current, today) {
+  if (current.year() > today.year()) {
+    return 1;
+  }
+  return current.year() === today.year() && current.month() > today.month();
+}
+
+function getIdFromDate(date) {
+  return 'rc-calendar-' + date.year() + '-' + date.month() + '-' + date.date();
+}
+
+var DateTBody = function (_React$Component) {
+  _inherits(DateTBody, _React$Component);
+
+  function DateTBody() {
+    _classCallCheck(this, DateTBody);
+
+    return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
+  }
+
+  DateTBody.prototype.render = function render() {
+    var props = this.props;
+    var contentRender = props.contentRender,
+        prefixCls = props.prefixCls,
+        selectedValue = props.selectedValue,
+        value = props.value,
+        showWeekNumber = props.showWeekNumber,
+        dateRender = props.dateRender,
+        disabledDate = props.disabledDate,
+        hoverValue = props.hoverValue;
+
+    var iIndex = void 0;
+    var jIndex = void 0;
+    var current = void 0;
+    var dateTable = [];
+    var today = getTodayTime(value);
+    var cellClass = prefixCls + '-cell';
+    var weekNumberCellClass = prefixCls + '-week-number-cell';
+    var dateClass = prefixCls + '-date';
+    var todayClass = prefixCls + '-today';
+    var selectedClass = prefixCls + '-selected-day';
+    var selectedDateClass = prefixCls + '-selected-date'; // do not move with mouse operation
+    var selectedStartDateClass = prefixCls + '-selected-start-date';
+    var selectedEndDateClass = prefixCls + '-selected-end-date';
+    var inRangeClass = prefixCls + '-in-range-cell';
+    var lastMonthDayClass = prefixCls + '-last-month-cell';
+    var nextMonthDayClass = prefixCls + '-next-month-btn-day';
+    var disabledClass = prefixCls + '-disabled-cell';
+    var firstDisableClass = prefixCls + '-disabled-cell-first-of-row';
+    var lastDisableClass = prefixCls + '-disabled-cell-last-of-row';
+    var lastDayOfMonthClass = prefixCls + '-last-day-of-month';
+    var month1 = value.clone();
+    month1.date(1);
+    var day = month1.day();
+    var lastMonthDiffDay = (day + 7 - value.localeData().firstDayOfWeek()) % 7;
+    // calculate last month
+    var lastMonth1 = month1.clone();
+    lastMonth1.add(0 - lastMonthDiffDay, 'days');
+    var passed = 0;
+
+    for (iIndex = 0; iIndex < DateConstants.DATE_ROW_COUNT; iIndex++) {
+      for (jIndex = 0; jIndex < DateConstants.DATE_COL_COUNT; jIndex++) {
+        current = lastMonth1;
+        if (passed) {
+          current = current.clone();
+          current.add(passed, 'days');
+        }
+        dateTable.push(current);
+        passed++;
+      }
+    }
+    var tableHtml = [];
+    passed = 0;
+
+    for (iIndex = 0; iIndex < DateConstants.DATE_ROW_COUNT; iIndex++) {
+      var _cx;
+
+      var isCurrentWeek = void 0;
+      var weekNumberCell = void 0;
+      var isActiveWeek = false;
+      var dateCells = [];
+      if (showWeekNumber) {
+        weekNumberCell = React__default.createElement(
+          'td',
+          {
+            key: dateTable[passed].week(),
+            role: 'gridcell',
+            className: weekNumberCellClass
+          },
+          dateTable[passed].week()
+        );
+      }
+      for (jIndex = 0; jIndex < DateConstants.DATE_COL_COUNT; jIndex++) {
+        var next = null;
+        var last = null;
+        current = dateTable[passed];
+        if (jIndex < DateConstants.DATE_COL_COUNT - 1) {
+          next = dateTable[passed + 1];
+        }
+        if (jIndex > 0) {
+          last = dateTable[passed - 1];
+        }
+        var cls = cellClass;
+        var disabled = false;
+        var selected = false;
+
+        if (isSameDay(current, today)) {
+          cls += ' ' + todayClass;
+          isCurrentWeek = true;
+        }
+
+        var isBeforeCurrentMonthYear = beforeCurrentMonthYear(current, value);
+        var isAfterCurrentMonthYear = afterCurrentMonthYear(current, value);
+
+        if (selectedValue && Array.isArray(selectedValue)) {
+          var rangeValue = hoverValue.length ? hoverValue : selectedValue;
+          if (!isBeforeCurrentMonthYear && !isAfterCurrentMonthYear) {
+            var startValue = rangeValue[0];
+            var endValue = rangeValue[1];
+            if (startValue) {
+              if (isSameDay(current, startValue)) {
+                selected = true;
+                isActiveWeek = true;
+                cls += ' ' + selectedStartDateClass;
+              }
+            }
+            if (startValue || endValue) {
+              if (isSameDay(current, endValue)) {
+                selected = true;
+                isActiveWeek = true;
+                cls += ' ' + selectedEndDateClass;
+              } else if ((startValue === null || startValue === undefined) && current.isBefore(endValue, 'day')) {
+                cls += ' ' + inRangeClass;
+              } else if ((endValue === null || endValue === undefined) && current.isAfter(startValue, 'day')) {
+                cls += ' ' + inRangeClass;
+              } else if (current.isAfter(startValue, 'day') && current.isBefore(endValue, 'day')) {
+                cls += ' ' + inRangeClass;
+              }
+            }
+          }
+        } else if (isSameDay(current, value)) {
+          // keyboard change value, highlight works
+          selected = true;
+          isActiveWeek = true;
+        }
+
+        if (isSameDay(current, selectedValue)) {
+          cls += ' ' + selectedDateClass;
+        }
+
+        if (isBeforeCurrentMonthYear) {
+          cls += ' ' + lastMonthDayClass;
+        }
+
+        if (isAfterCurrentMonthYear) {
+          cls += ' ' + nextMonthDayClass;
+        }
+
+        if (current.clone().endOf('month').date() === current.date()) {
+          cls += ' ' + lastDayOfMonthClass;
+        }
+
+        if (disabledDate) {
+          if (disabledDate(current, value)) {
+            disabled = true;
+
+            if (!last || !disabledDate(last, value)) {
+              cls += ' ' + firstDisableClass;
+            }
+
+            if (!next || !disabledDate(next, value)) {
+              cls += ' ' + lastDisableClass;
+            }
+          }
+        }
+
+        if (selected) {
+          cls += ' ' + selectedClass;
+        }
+
+        if (disabled) {
+          cls += ' ' + disabledClass;
+        }
+
+        var dateHtml = void 0;
+        if (dateRender) {
+          dateHtml = dateRender(current, value);
+        } else {
+          var content = contentRender ? contentRender(current, value) : current.date();
+          dateHtml = React__default.createElement(
+            'div',
+            {
+              key: getIdFromDate(current),
+              className: dateClass,
+              'aria-selected': selected,
+              'aria-disabled': disabled
+            },
+            content
+          );
+        }
+
+        dateCells.push(React__default.createElement(
+          'td',
+          {
+            key: passed,
+            onClick: disabled ? undefined : props.onSelect.bind(null, current),
+            onMouseEnter: disabled ? undefined : props.onDayHover && props.onDayHover.bind(null, current) || undefined,
+            role: 'gridcell',
+            title: getTitleString(current),
+            className: cls
+          },
+          dateHtml
+        ));
+
+        passed++;
+      }
+
+      tableHtml.push(React__default.createElement(
+        'tr',
+        {
+          key: iIndex,
+          role: 'row',
+          className: classNames((_cx = {}, _cx[prefixCls + '-current-week'] = isCurrentWeek, _cx[prefixCls + '-active-week'] = isActiveWeek, _cx))
+        },
+        weekNumberCell,
+        dateCells
+      ));
+    }
+    return React__default.createElement(
+      'tbody',
+      { className: prefixCls + '-tbody' },
+      tableHtml
+    );
+  };
+
+  return DateTBody;
+}(React__default.Component);
+
+DateTBody.propTypes = {
+  contentRender: PropTypes.func,
+  dateRender: PropTypes.func,
+  disabledDate: PropTypes.func,
+  prefixCls: PropTypes.string,
+  selectedValue: PropTypes.oneOfType([PropTypes.object, PropTypes.arrayOf(PropTypes.object)]),
+  value: PropTypes.object,
+  hoverValue: PropTypes.any,
+  showWeekNumber: PropTypes.bool
+};
+DateTBody.defaultProps = {
+  hoverValue: []
+};
+
+var DateTable = function (_React$Component) {
+  _inherits(DateTable, _React$Component);
+
+  function DateTable() {
+    _classCallCheck(this, DateTable);
+
+    return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
+  }
+
+  DateTable.prototype.render = function render() {
+    var props = this.props;
+    var prefixCls = props.prefixCls;
+    return React__default.createElement(
+      'table',
+      { className: prefixCls + '-table', cellSpacing: '0', role: 'grid' },
+      React__default.createElement(DateTHead, props),
+      React__default.createElement(DateTBody, props)
+    );
+  };
+
+  return DateTable;
+}(React__default.Component);
+
+var ROW = 4;
+var COL = 3;
+
+function noop$2() {}
+
+var MonthTable = function (_Component) {
+  _inherits(MonthTable, _Component);
+
+  function MonthTable() {
+    var _temp, _this, _ret;
+
+    _classCallCheck(this, MonthTable);
+
+    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    return _ret = (_temp = (_this = _possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args))), _this), _this.state = {}, _temp), _possibleConstructorReturn(_this, _ret);
+  }
+
+  MonthTable.getDerivedStateFromProps = function getDerivedStateFromProps(props) {
+    if ('value' in props) {
+      return { value: props.value };
+    }
+    return null;
+  };
+
+  MonthTable.prototype.setAndSelectValue = function setAndSelectValue(value) {
+    this.setState({
+      value: value
+    });
+    this.props.onSelect(value);
+  };
+
+  MonthTable.prototype.chooseMonth = function chooseMonth(month) {
+    var next = this.state.value.clone();
+    next.month(month);
+    this.setAndSelectValue(next);
+  };
+
+  MonthTable.prototype.months = function months() {
+    var value = this.state.value;
+    var current = value.clone();
+    var months = [];
+    var index = 0;
+    for (var rowIndex = 0; rowIndex < ROW; rowIndex++) {
+      months[rowIndex] = [];
+      for (var colIndex = 0; colIndex < COL; colIndex++) {
+        current.month(index);
+        var content = getMonthName(current);
+        months[rowIndex][colIndex] = {
+          value: index,
+          content: content,
+          title: content
+        };
+        index++;
+      }
+    }
+    return months;
+  };
+
+  MonthTable.prototype.render = function render() {
+    var _this2 = this;
+
+    var props = this.props;
+    var value = this.state.value;
+    var today = getTodayTime(value);
+    var months = this.months();
+    var currentMonth = value.month();
+    var prefixCls = props.prefixCls,
+        locale = props.locale,
+        contentRender = props.contentRender,
+        cellRender = props.cellRender;
+
+    var monthsEls = months.map(function (month, index) {
+      var tds = month.map(function (monthData) {
+        var _classNameMap;
+
+        var disabled = false;
+        if (props.disabledDate) {
+          var testValue = value.clone();
+          testValue.month(monthData.value);
+          disabled = props.disabledDate(testValue);
+        }
+        var classNameMap = (_classNameMap = {}, _classNameMap[prefixCls + '-cell'] = 1, _classNameMap[prefixCls + '-cell-disabled'] = disabled, _classNameMap[prefixCls + '-selected-cell'] = monthData.value === currentMonth, _classNameMap[prefixCls + '-current-cell'] = today.year() === value.year() && monthData.value === today.month(), _classNameMap);
+        var cellEl = void 0;
+        if (cellRender) {
+          var currentValue = value.clone();
+          currentValue.month(monthData.value);
+          cellEl = cellRender(currentValue, locale);
+        } else {
+          var content = void 0;
+          if (contentRender) {
+            var _currentValue = value.clone();
+            _currentValue.month(monthData.value);
+            content = contentRender(_currentValue, locale);
+          } else {
+            content = monthData.content;
+          }
+          cellEl = React__default.createElement(
+            'a',
+            { className: prefixCls + '-month' },
+            content
+          );
+        }
+        return React__default.createElement(
+          'td',
+          {
+            role: 'gridcell',
+            key: monthData.value,
+            onClick: disabled ? null : function () {
+              return _this2.chooseMonth(monthData.value);
+            },
+            title: monthData.title,
+            className: classNames(classNameMap)
+          },
+          cellEl
+        );
+      });
+      return React__default.createElement(
+        'tr',
+        { key: index, role: 'row' },
+        tds
+      );
+    });
+
+    return React__default.createElement(
+      'table',
+      { className: prefixCls + '-table', cellSpacing: '0', role: 'grid' },
+      React__default.createElement(
+        'tbody',
+        { className: prefixCls + '-tbody' },
+        monthsEls
+      )
+    );
+  };
+
+  return MonthTable;
+}(Component);
+
+MonthTable.defaultProps = {
+  onSelect: noop$2
+};
+
+MonthTable.propTypes = {
+  onSelect: PropTypes.func,
+  cellRender: PropTypes.func,
+  prefixCls: PropTypes.string,
+  value: PropTypes.object
+};
+
+polyfill(MonthTable);
+
+function noop$1() {}
+
+function getNowByCurrentStateValue(value) {
+  var ret = void 0;
+  if (value) {
+    ret = getTodayTime(value);
+  } else {
+    ret = moment();
+  }
+  return ret;
+}
+
+var calendarMixinPropTypes = {
+  value: PropTypes.object,
+  defaultValue: PropTypes.object,
+  onKeyDown: PropTypes.func
+};
+
+var calendarMixinDefaultProps = {
+  onKeyDown: noop$1
+};
+
+var calendarMixinWrapper = function calendarMixinWrapper(ComposeComponent) {
+  var _class, _temp2;
+
+  return _temp2 = _class = function (_ComposeComponent) {
+    _inherits(_class, _ComposeComponent);
+
+    function _class() {
+      var _temp, _this, _ret;
+
+      _classCallCheck(this, _class);
+
+      for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      return _ret = (_temp = (_this = _possibleConstructorReturn(this, _ComposeComponent.call.apply(_ComposeComponent, [this].concat(args))), _this), _this.onSelect = function (value, cause) {
+        if (value) {
+          _this.setValue(value);
+        }
+        _this.setSelectedValue(value, cause);
+      }, _this.renderRoot = function (newProps) {
+        var _className;
+
+        var props = _this.props;
+        var prefixCls = props.prefixCls;
+
+        var className = (_className = {}, _className[prefixCls] = 1, _className[prefixCls + '-hidden'] = !props.visible, _className[props.className] = !!props.className, _className[newProps.className] = !!newProps.className, _className);
+
+        return React__default.createElement(
+          'div',
+          {
+            ref: _this.saveRoot,
+            className: '' + classNames(className),
+            style: _this.props.style,
+            tabIndex: '0',
+            onKeyDown: _this.onKeyDown,
+            onBlur: _this.onBlur
+          },
+          newProps.children
+        );
+      }, _this.setSelectedValue = function (selectedValue, cause) {
+        // if (this.isAllowedDate(selectedValue)) {
+        if (!('selectedValue' in _this.props)) {
+          _this.setState({
+            selectedValue: selectedValue
+          });
+        }
+        if (_this.props.onSelect) {
+          _this.props.onSelect(selectedValue, cause);
+        }
+        // }
+      }, _this.setValue = function (value) {
+        var originalValue = _this.state.value;
+        if (!('value' in _this.props)) {
+          _this.setState({
+            value: value
+          });
+        }
+        if (originalValue && value && !originalValue.isSame(value) || !originalValue && value || originalValue && !value) {
+          _this.props.onChange(value);
+        }
+      }, _this.isAllowedDate = function (value) {
+        var disabledDate = _this.props.disabledDate;
+        var disabledTime = _this.props.disabledTime;
+        return isAllowedDate(value, disabledDate, disabledTime);
+      }, _temp), _possibleConstructorReturn(_this, _ret);
+    }
+
+    _class.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, prevState) {
+      // Use origin function if provided
+      if (ComposeComponent.getDerivedStateFromProps) {
+        return ComposeComponent.getDerivedStateFromProps(nextProps, prevState);
+      }
+
+      var value = nextProps.value,
+          selectedValue = nextProps.selectedValue;
+
+      var newState = {};
+
+      if ('value' in nextProps) {
+        newState.value = value || nextProps.defaultValue || getNowByCurrentStateValue(prevState.value);
+      }
+      if ('selectedValue' in nextProps) {
+        newState.selectedValue = selectedValue;
+      }
+
+      return newState;
+    };
+
+    return _class;
+  }(ComposeComponent), _class.displayName = 'CalendarMixinWrapper', _class.defaultProps = ComposeComponent.defaultProps, _temp2;
+};
+
+function noop() {}
+
+var propType = {
+  className: PropTypes.string,
+  locale: PropTypes.object,
+  style: PropTypes.object,
+  visible: PropTypes.bool,
+  onSelect: PropTypes.func,
+  prefixCls: PropTypes.string,
+  onChange: PropTypes.func,
+  onOk: PropTypes.func
+};
+
+var defaultProp = {
+  locale: enUs,
+  style: {},
+  visible: true,
+  prefixCls: 'rc-calendar',
+  className: '',
+  onSelect: noop,
+  onChange: noop,
+  onClear: noop,
+  renderFooter: function renderFooter() {
+    return null;
+  },
+  renderSidebar: function renderSidebar() {
+    return null;
+  }
+};
+
+var commonMixinWrapper = function commonMixinWrapper(ComposeComponent) {
+  var _class, _temp2;
+
+  return _temp2 = _class = function (_ComposeComponent) {
+    _inherits(_class, _ComposeComponent);
+
+    function _class() {
+      var _temp, _this, _ret;
+
+      _classCallCheck(this, _class);
+
+      for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      return _ret = (_temp = (_this = _possibleConstructorReturn(this, _ComposeComponent.call.apply(_ComposeComponent, [this].concat(args))), _this), _this.getFormat = function () {
+        var format = _this.props.format;
+        var _this$props = _this.props,
+            locale = _this$props.locale,
+            timePicker = _this$props.timePicker;
+
+        if (!format) {
+          if (timePicker) {
+            format = locale.dateTimeFormat;
+          } else {
+            format = locale.dateFormat;
+          }
+        }
+        return format;
+      }, _this.focus = function () {
+        if (_this.focusElement) {
+          _this.focusElement.focus();
+        } else if (_this.rootInstance) {
+          _this.rootInstance.focus();
+        }
+      }, _this.saveFocusElement = function (focusElement) {
+        _this.focusElement = focusElement;
+      }, _this.saveRoot = function (root) {
+        _this.rootInstance = root;
+      }, _temp), _possibleConstructorReturn(_this, _ret);
+    }
+
+    _class.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {
+      return this.props.visible || nextProps.visible;
+    };
+
+    return _class;
+  }(ComposeComponent), _class.displayName = 'CommonMixinWrapper', _class.defaultProps = ComposeComponent.defaultProps, _class.getDerivedStateFromProps = ComposeComponent.getDerivedStateFromProps, _temp2;
+};
+
+export { DateTable as D, MonthTable as M, commonMixinWrapper as a, getNowByCurrentStateValue as b, calendarMixinWrapper as c, calendarMixinPropTypes as d, calendarMixinDefaultProps as e, defaultProp as f, getMonthName as g, getTodayTime as h, isAllowedDate as i, getTodayTimeStr as j, formatDate as k, getTimeConfig as l, propType as p, syncTime as s };