@i-novus/n2o-components 1.0.0

package/lib/inputs/DatePicker/Calendar.js

@@ -0,0 +1,556 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Calendar = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _isNull = _interopRequireDefault(require("lodash/isNull"));
+
+var _moment = _interopRequireDefault(require("moment/moment"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _Day = require("./Day");
+
+var _CalendarHeader = require("./CalendarHeader");
+
+var _utils = require("./utils");
+
+var _DateTimeControl = require("./DateTimeControl");
+
+var _types = require("./types");
+
+require("../../styles/components/Calendar.scss");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var Calendar = /*#__PURE__*/function (_React$Component) {
+  (0, _inherits2["default"])(Calendar, _React$Component);
+
+  var _super = _createSuper(Calendar);
+
+  function Calendar(props) {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, Calendar);
+    _this = _super.call(this, props);
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "hourRef", null);
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "minuteRef", null);
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "secondRef", null);
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "changeCalendarType", function (type) {
+      _this.setState({
+        calendarType: type
+      });
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "setHourRef", function (el) {
+      _this.hourRef = el;
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "setMinuteRef", function (el) {
+      _this.minuteRef = el;
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "setSecondRef", function (el) {
+      _this.secondRef = el;
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "prevMonth", function () {
+      var displayesMonth = _this.state.displayesMonth;
+
+      _this.setState({
+        displayesMonth: displayesMonth.subtract(1, 'months')
+      });
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "nextMonth", function () {
+      var displayesMonth = _this.state.displayesMonth;
+
+      _this.setState({
+        displayesMonth: displayesMonth.add(1, 'months')
+      });
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "prevYear", function () {
+      var displayesMonth = _this.state.displayesMonth;
+
+      _this.setState({
+        displayesMonth: displayesMonth.subtract(1, 'years')
+      });
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "nextYear", function () {
+      var displayesMonth = _this.state.displayesMonth;
+
+      _this.setState({
+        displayesMonth: displayesMonth.add(1, 'years')
+      });
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "nextDecade", function () {
+      var displayesMonth = _this.state.displayesMonth;
+
+      _this.setState({
+        displayesMonth: displayesMonth.add(10, 'years')
+      });
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "prevDecade", function () {
+      var displayesMonth = _this.state.displayesMonth;
+
+      _this.setState({
+        displayesMonth: displayesMonth.subtract(10, 'years')
+      });
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onItemClick", function (itemType, item, i) {
+      if (itemType === 'month-item') {
+        _this.setDate('month', i);
+      } else {
+        _this.setDate('year', item);
+      }
+
+      _this.changeCalendarType(_types.CalendarType.BY_DAYS);
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "setTimeUnit", function (value, unit) {
+      var tempTimeObj = _this.state.tempTimeObj;
+
+      _this.setState({
+        tempTimeObj: _objectSpread(_objectSpread({}, tempTimeObj), {}, (0, _defineProperty2["default"])({}, unit, value))
+      });
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "setTime", function () {
+      var _this$props = _this.props,
+          value = _this$props.value,
+          inputName = _this$props.inputName,
+          markTimeAsSet = _this$props.markTimeAsSet,
+          select = _this$props.select;
+      var tempTimeObj = _this.state.tempTimeObj;
+
+      var _ref = tempTimeObj || {},
+          hours = _ref.hours,
+          minutes = _ref.minutes,
+          seconds = _ref.seconds;
+
+      var copyValue = value || (0, _moment["default"])();
+
+      _this.changeCalendarType(_types.CalendarType.BY_DAYS);
+
+      markTimeAsSet(inputName);
+      select((0, _utils.addTime)(copyValue.clone().startOf('day'), hours, minutes, seconds), inputName, false);
+    });
+    _this.state = {
+      displayesMonth: props.value ? props.value.clone().startOf('month') : (0, _moment["default"])().startOf('month'),
+      calendarType: _types.CalendarType.BY_DAYS,
+      tempTimeObj: props.value ? (0, _utils.objFromTime)(props.value) : props.time
+    };
+    return _this;
+  }
+
+  (0, _createClass2["default"])(Calendar, [{
+    key: "componentWillReceiveProps",
+    value: // eslint-disable-next-line react/no-deprecated
+    function componentWillReceiveProps(props) {
+      if (props.value) {
+        this.setState({
+          displayesMonth: props.value ? props.value.clone().startOf('month') : (0, _moment["default"])().startOf('month'),
+          tempTimeObj: props.value ? (0, _utils.objFromTime)(props.value) : props.time
+        });
+      }
+    }
+  }, {
+    key: "renderHeader",
+    value: function renderHeader() {
+      var _this$state = this.state,
+          displayesMonth = _this$state.displayesMonth,
+          calendarType = _this$state.calendarType;
+      var _this$props2 = this.props,
+          _this$props2$locale = _this$props2.locale,
+          locale = _this$props2$locale === void 0 ? 'ru' : _this$props2$locale,
+          t = _this$props2.t;
+      var nextMonth = this.nextMonth,
+          nextYear = this.nextYear,
+          prevMonth = this.prevMonth,
+          prevYear = this.prevYear,
+          nextDecade = this.nextDecade,
+          prevDecade = this.prevDecade,
+          changeCalendarType = this.changeCalendarType;
+      return /*#__PURE__*/_react["default"].createElement(_CalendarHeader.CalendarHeader, {
+        nextMonth: nextMonth,
+        nextYear: nextYear,
+        prevMonth: prevMonth,
+        prevYear: prevYear,
+        nextDecade: nextDecade,
+        prevDecade: prevDecade,
+        displayesMonth: displayesMonth,
+        locale: locale,
+        calendarType: calendarType,
+        changeCalendarType: changeCalendarType,
+        t: t
+      });
+    }
+  }, {
+    key: "setDate",
+    value: function setDate(unit, value) {
+      var displayesMonth = this.state.displayesMonth;
+      this.setState({
+        displayesMonth: displayesMonth.set(unit, Number(value))
+      });
+    }
+  }, {
+    key: "renderNameOfDays",
+    value: function renderNameOfDays() {
+      var _this$props$locale = this.props.locale,
+          locale = _this$props$locale === void 0 ? 'ru' : _this$props$locale;
+      var nameOfDays = locale === 'ru' ? ['Пн', 'Вт', 'Ср', 'Чт', 'Пт', 'Сб', 'Вс'] : ['Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa', 'Su'];
+      return /*#__PURE__*/_react["default"].createElement("tr", null, nameOfDays.map(function (day, i) {
+        return (
+          /*#__PURE__*/
+          // eslint-disable-next-line react/no-array-index-key
+          _react["default"].createElement("td", {
+            key: i
+          }, day)
+        );
+      }));
+    }
+  }, {
+    key: "renderWeeks",
+    value: function renderWeeks() {
+      var _this2 = this;
+
+      var _this$state2 = this.state,
+          displayesMonth = _this$state2.displayesMonth,
+          tempTimeObj = _this$state2.tempTimeObj;
+
+      var _ref2 = tempTimeObj || {},
+          hours = _ref2.hours,
+          minutes = _ref2.minutes,
+          seconds = _ref2.seconds;
+
+      var firstDay = (0, _utils.addTime)(displayesMonth.clone().startOf('isoWeek'), hours, minutes, seconds);
+      return (0, _utils.weeks)(firstDay).map(function (week, i) {
+        return _this2.renderWeek(week, i);
+      });
+    }
+  }, {
+    key: "renderWeek",
+    value: function renderWeek(week, i) {
+      var _this3 = this;
+
+      return /*#__PURE__*/_react["default"].createElement("tr", {
+        key: i
+      }, week.map(function (day, i) {
+        return _this3.renderDay(day, i);
+      }));
+    } // eslint-disable-next-line complexity
+
+  }, {
+    key: "renderDay",
+    value: function renderDay(day, i) {
+      var _this$props3 = this.props,
+          min = _this$props3.min,
+          max = _this$props3.max,
+          value = _this$props3.value,
+          select = _this$props3.select,
+          inputName = _this$props3.inputName,
+          type = _this$props3.type,
+          index = _this$props3.index,
+          values = _this$props3.values,
+          dateFormat = _this$props3.dateFormat;
+      var disabled = false;
+
+      if (min && max) {
+        disabled = day.isBefore(min) || day.isAfter(max);
+      } else if (min) {
+        disabled = day.isBefore(min);
+      } else if (max) {
+        disabled = day.isAfter(max);
+      }
+
+      if (type === _DateTimeControl.ControlType.DATE_INTERVAL) {
+        var begin = values.begin;
+
+        var disableDaysBefore = function disableDaysBefore(range) {
+          return day.isBefore(range);
+        };
+
+        var disableDaysAfter = function disableDaysAfter(range) {
+          return day.isAfter(range);
+        };
+
+        var disabledDaysBeyondTheScopeMinMax = disableDaysBefore(min) || disableDaysAfter(max);
+        var disabledDaysBeyondTheScopeBeginMax = disableDaysBefore(begin) || disableDaysAfter(max); // eslint-disable-next-line no-unused-vars,no-return-assign, @typescript-eslint/no-unused-vars
+
+        var rangeMinMax = function rangeMinMax(disabledDays) {
+          return disabledDays = disabledDaysBeyondTheScopeMinMax;
+        }; // если не выбрана дата(begin) ||  min or max
+
+
+        var hasMinOrMaxAndNullBegin = (0, _isNull["default"])(begin) && (min || max) || (0, _isNull["default"])(begin) && min && max; // если hasMinOrMaxAndNullBegin, устанавливаем default range (min or max)
+
+        if (hasMinOrMaxAndNullBegin) {
+          rangeMinMax(disabled);
+        } else if (min && max) {
+          disabled = index === 0 ? disabledDaysBeyondTheScopeMinMax : disabledDaysBeyondTheScopeBeginMax;
+        } else if (min) {
+          disabled = index === 0 ? disableDaysBefore(min) : index === 1 && disableDaysBefore(begin);
+        } else if (max) {
+          disabled = index === 0 ? disableDaysAfter(max) : index === 1 && disableDaysAfter(begin);
+        } else {
+          // не указан range (min, max)
+          disabled = index === 1 && disableDaysBefore(begin);
+        }
+      }
+
+      var displayesMonth = this.state.displayesMonth;
+      var otherMonth = (0, _utils.isDateFromNextMonth)(day, displayesMonth) || (0, _utils.isDateFromPrevMonth)(day, displayesMonth);
+      var selected = day.isSame(value);
+      var current = day.format('DD.MM.YYYY') === (0, _moment["default"])().format('DD.MM.YYYY');
+      var props = {
+        day: day,
+        otherMonth: otherMonth,
+        selected: selected,
+        disabled: disabled,
+        select: select,
+        inputName: inputName,
+        current: current,
+        dateFormat: dateFormat
+      };
+      return /*#__PURE__*/_react["default"].createElement(_Day.Day, (0, _extends2["default"])({
+        key: i
+      }, props));
+    }
+  }, {
+    key: "renderTime",
+    value: function renderTime() {
+      var _this$props4 = this.props,
+          value = _this$props4.value,
+          hasDefaultTime = _this$props4.hasDefaultTime,
+          timeFormat = _this$props4.timeFormat,
+          t = _this$props4.t;
+
+      if (hasDefaultTime) {
+        if (value) {
+          return value.format(timeFormat);
+        }
+
+        return '00:00:00';
+      }
+
+      if (t) {
+        return t('chooseTime');
+      }
+
+      return null;
+    }
+  }, {
+    key: "renderByDays",
+    value: function renderByDays() {
+      var _this4 = this;
+
+      var timeFormat = this.props.timeFormat;
+      return /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, /*#__PURE__*/_react["default"].createElement("table", {
+        className: "n2o-calendar-table"
+      }, /*#__PURE__*/_react["default"].createElement("thead", null, this.renderNameOfDays()), /*#__PURE__*/_react["default"].createElement("tbody", null, this.renderWeeks())), timeFormat && /*#__PURE__*/_react["default"].createElement("a", {
+        className: "n2o-calendar-time-container",
+        href: "/test",
+        onClick: function onClick(e) {
+          e.preventDefault();
+
+          _this4.changeCalendarType(_types.CalendarType.TIME_PICKER);
+        }
+      }, this.renderTime()));
+    }
+  }, {
+    key: "renderByMonths",
+    value: function renderByMonths() {
+      var _this$props$locale2 = this.props.locale,
+          locale = _this$props$locale2 === void 0 ? 'ru' : _this$props$locale2;
+      return /*#__PURE__*/_react["default"].createElement("div", {
+        className: "n2o-calendar-body"
+      }, this.renderList(_moment["default"].localeData(locale).months(), 'month-item'));
+    }
+  }, {
+    key: "renderList",
+    value: function renderList(list, className) {
+      var _this5 = this;
+
+      var value = this.props.value;
+
+      var isActive = function isActive(className, item, i) {
+        if (!value) {
+          return false;
+        }
+
+        if (className !== 'month-item') {
+          return item === value.year();
+        }
+
+        return i === value.month();
+      };
+
+      var isOtherDecade = function isOtherDecade(i) {
+        return className === 'year-item' && (i === 0 || i === 11);
+      };
+
+      return list.map(function (item, i) {
+        return /*#__PURE__*/_react["default"].createElement("div", {
+          className: (0, _classnames["default"])('n2o-calendar-body-item', className, {
+            active: isActive(className, item, i),
+            'other-decade': isOtherDecade(i)
+          }),
+          onClick: function onClick() {
+            return _this5.onItemClick(className, item, i);
+          }
+        }, item);
+      });
+    }
+  }, {
+    key: "renderByYears",
+    value: function renderByYears() {
+      var displayesMonth = this.state.displayesMonth;
+      var decadeStart = parseInt(String(Number(displayesMonth.format('YYYY')) / 10), 10) * 10;
+      var years = Array.from(new Array(12), function (val, index) {
+        return decadeStart + index - 1;
+      });
+      return /*#__PURE__*/_react["default"].createElement("div", {
+        className: "n2o-calendar-body"
+      }, this.renderList(years, 'year-item'));
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate() {
+      var calendarType = this.state.calendarType;
+
+      if (calendarType === _types.CalendarType.TIME_PICKER) {
+        if (this.minuteRef) {
+          this.minuteRef.scrollIntoView();
+        }
+
+        if (this.secondRef) {
+          this.secondRef.scrollIntoView();
+        }
+
+        if (this.hourRef) {
+          this.hourRef.scrollIntoView();
+        }
+      }
+    }
+  }, {
+    key: "renderTimePicker",
+    value: function renderTimePicker() {
+      var _this6 = this;
+
+      var tempTimeObj = this.state.tempTimeObj;
+
+      var _ref3 = tempTimeObj || {},
+          minutes = _ref3.minutes,
+          seconds = _ref3.seconds,
+          hours = _ref3.hours;
+      /* eslint-disable react/jsx-one-expression-per-line */
+
+
+      return /*#__PURE__*/_react["default"].createElement("div", null, /*#__PURE__*/_react["default"].createElement("div", {
+        className: "n2o-calendar-timepicker"
+      }, /*#__PURE__*/_react["default"].createElement("div", {
+        className: "n2o-calendar-picker hour-picker"
+      }, Array.from(new Array(24), function (val, index) {
+        return /*#__PURE__*/_react["default"].createElement("div", {
+          className: (0, _classnames["default"])('n2o-calendar-time-unit', {
+            active: index === hours
+          }),
+          onClick: function onClick() {
+            return _this6.setTimeUnit(index, 'hours');
+          },
+          ref: index === hours ? _this6.setHourRef : null
+        }, index);
+      })), /*#__PURE__*/_react["default"].createElement("div", {
+        className: "n2o-calendar-picker minute-picker"
+      }, Array.from(new Array(60), function (val, index) {
+        return /*#__PURE__*/_react["default"].createElement("div", {
+          className: (0, _classnames["default"])('n2o-calendar-time-unit', {
+            active: index === minutes
+          }),
+          ref: index === minutes ? _this6.setMinuteRef : null,
+          onClick: function onClick() {
+            return _this6.setTimeUnit(index, 'minutes');
+          }
+        }, index);
+      })), /*#__PURE__*/_react["default"].createElement("div", {
+        className: "n2o-calendar-picker second-picker"
+      }, Array.from(new Array(60), function (val, index) {
+        return /*#__PURE__*/_react["default"].createElement("div", {
+          className: (0, _classnames["default"])('n2o-calendar-time-unit', {
+            active: index === seconds
+          }),
+          ref: index === seconds ? _this6.setSecondRef : null,
+          onClick: function onClick() {
+            return _this6.setTimeUnit(index, 'seconds');
+          }
+        }, index);
+      }))), /*#__PURE__*/_react["default"].createElement("div", {
+        className: "n2o-calendar-time-buttons"
+      }, /*#__PURE__*/_react["default"].createElement("button", {
+        type: "button",
+        className: "btn btn-secondary btn-sm",
+        onClick: function onClick() {
+          return _this6.changeCalendarType(_types.CalendarType.BY_DAYS);
+        }
+      }, ' ', "\u041D\u0430\u0437\u0430\u0434"), /*#__PURE__*/_react["default"].createElement("button", {
+        className: "btn btn-primary btn-sm",
+        onClick: this.setTime,
+        type: "button"
+      }, ' ', "\u0412\u044B\u0431\u0440\u0430\u0442\u044C")));
+    }
+  }, {
+    key: "renderBody",
+    value: function renderBody(type) {
+      switch (type) {
+        case _types.CalendarType.BY_MONTHS:
+          return this.renderByMonths();
+
+        case _types.CalendarType.BY_YEARS:
+          return this.renderByYears();
+
+        case _types.CalendarType.TIME_PICKER:
+          return this.renderTimePicker();
+
+        case _types.CalendarType.BY_DAYS:
+        default:
+          return this.renderByDays();
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var calendarType = this.state.calendarType;
+      var timeFormat = this.props.timeFormat;
+      return /*#__PURE__*/_react["default"].createElement("div", {
+        className: (0, _classnames["default"])('n2o-calendar', {
+          time: timeFormat
+        })
+      }, this.renderHeader(), this.renderBody(calendarType));
+    }
+  }]);
+  return Calendar;
+}(_react["default"].Component);
+
+exports.Calendar = Calendar;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/inputs/DatePicker/Calendar.tsx"],"names":["Calendar","props","type","setState","calendarType","el","hourRef","minuteRef","secondRef","displayesMonth","state","subtract","add","itemType","item","i","setDate","changeCalendarType","CalendarType","BY_DAYS","value","unit","tempTimeObj","inputName","markTimeAsSet","select","hours","minutes","seconds","copyValue","clone","startOf","time","locale","t","nextMonth","nextYear","prevMonth","prevYear","nextDecade","prevDecade","set","Number","nameOfDays","map","day","firstDay","week","renderWeek","renderDay","min","max","index","values","dateFormat","disabled","isBefore","isAfter","ControlType","DATE_INTERVAL","begin","disableDaysBefore","range","disableDaysAfter","disabledDaysBeyondTheScopeMinMax","disabledDaysBeyondTheScopeBeginMax","rangeMinMax","disabledDays","hasMinOrMaxAndNullBegin","otherMonth","selected","isSame","current","format","hasDefaultTime","timeFormat","renderNameOfDays","renderWeeks","e","preventDefault","TIME_PICKER","renderTime","renderList","moment","localeData","months","list","className","isActive","year","month","isOtherDecade","active","onItemClick","decadeStart","parseInt","String","years","Array","from","val","scrollIntoView","setTimeUnit","setHourRef","setMinuteRef","setSecondRef","setTime","BY_MONTHS","renderByMonths","BY_YEARS","renderByYears","renderTimePicker","renderByDays","renderHeader","renderBody","React","Component"],"mappings":"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","sourcesContent":["import React, { ReactNode } from 'react'\nimport isNull from 'lodash/isNull'\nimport moment, { Moment, MomentInput, unitOfTime } from 'moment/moment'\nimport cx from 'classnames'\n\nimport { Day } from './Day'\nimport { CalendarHeader } from './CalendarHeader'\nimport {\n    weeks,\n    isDateFromPrevMonth,\n    isDateFromNextMonth,\n    addTime, objFromTime,\n} from './utils'\nimport { ControlType } from './DateTimeControl'\nimport { CalendarType, Time } from './types'\n\nimport '../../styles/components/Calendar.scss'\n\ntype CalendarProps = {\n    auto?: boolean,\n    dateFormat: string,\n    hasDefaultTime?: boolean,\n    index: number,\n    inputName: string,\n    locale: 'en' | 'ru',\n    markTimeAsSet(str: string): void,\n    max?: Moment | Date | string,\n    min?: Moment | Date | string,\n    select(day: Moment, name: string, type?: boolean): void,\n    setPlacement?(): void,\n    setVisibility?(): void,\n    t(key: string): ReactNode,\n    time: Time,\n    timeFormat?: string,\n    type?: string,\n    value: Moment | null,\n    values: Record<string, MomentInput>\n}\n\ntype CalendarState = {\n    calendarType: CalendarType,\n    displayesMonth: Moment,\n    tempTimeObj: Time\n}\n\nexport class Calendar extends React.Component<CalendarProps, CalendarState> {\n    private hourRef: HTMLDivElement | null = null\n\n    private minuteRef: HTMLDivElement | null = null\n\n    private secondRef: HTMLDivElement | null = null\n\n    constructor(props: CalendarProps) {\n        super(props)\n        this.state = {\n            displayesMonth: props.value\n                ? props.value.clone().startOf('month')\n                : moment().startOf('month'),\n            calendarType: CalendarType.BY_DAYS,\n            tempTimeObj: props.value ? objFromTime(props.value) : props.time,\n        }\n    }\n\n    changeCalendarType = (type: CalendarType) => {\n        this.setState({ calendarType: type })\n    }\n\n    // eslint-disable-next-line react/no-deprecated\n    componentWillReceiveProps(props: CalendarProps) {\n        if (props.value) {\n            this.setState({\n                displayesMonth: props.value\n                    ? props.value.clone().startOf('month')\n                    : moment().startOf('month'),\n                tempTimeObj: props.value ? objFromTime(props.value) : props.time,\n            })\n        }\n    }\n\n    setHourRef = (el: HTMLDivElement) => {\n        this.hourRef = el\n    }\n\n    setMinuteRef = (el: HTMLDivElement) => {\n        this.minuteRef = el\n    }\n\n    setSecondRef = (el: HTMLDivElement) => {\n        this.secondRef = el\n    }\n\n    renderHeader() {\n        const { displayesMonth, calendarType } = this.state\n        const { locale = 'ru', t } = this.props\n        const {\n            nextMonth,\n            nextYear,\n            prevMonth,\n            prevYear,\n            nextDecade,\n            prevDecade,\n            changeCalendarType,\n        } = this\n\n        return (\n            <CalendarHeader\n                nextMonth={nextMonth}\n                nextYear={nextYear}\n                prevMonth={prevMonth}\n                prevYear={prevYear}\n                nextDecade={nextDecade}\n                prevDecade={prevDecade}\n                displayesMonth={displayesMonth}\n                locale={locale}\n                calendarType={calendarType}\n                changeCalendarType={changeCalendarType}\n                t={t}\n            />\n        )\n    }\n\n    prevMonth = () => {\n        const { displayesMonth } = this.state\n\n        this.setState({ displayesMonth: displayesMonth.subtract(1, 'months') })\n    }\n\n    nextMonth = () => {\n        const { displayesMonth } = this.state\n\n        this.setState({ displayesMonth: displayesMonth.add(1, 'months') })\n    }\n\n    prevYear = () => {\n        const { displayesMonth } = this.state\n\n        this.setState({ displayesMonth: displayesMonth.subtract(1, 'years') })\n    }\n\n    nextYear = () => {\n        const { displayesMonth } = this.state\n\n        this.setState({ displayesMonth: displayesMonth.add(1, 'years') })\n    }\n\n    nextDecade = () => {\n        const { displayesMonth } = this.state\n\n        this.setState({ displayesMonth: displayesMonth.add(10, 'years') })\n    }\n\n    prevDecade = () => {\n        const { displayesMonth } = this.state\n\n        this.setState({ displayesMonth: displayesMonth.subtract(10, 'years') })\n    }\n\n    setDate(unit: string, value: number | string) {\n        const { displayesMonth } = this.state\n\n        this.setState({ displayesMonth: displayesMonth.set(unit as unitOfTime.All, Number(value)) })\n    }\n\n    renderNameOfDays() {\n        const { locale = 'ru' } = this.props\n        const nameOfDays = locale === 'ru'\n            ? ['Пн', 'Вт', 'Ср', 'Чт', 'Пт', 'Сб', 'Вс']\n            : ['Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa', 'Su']\n\n        return (\n            <tr>\n                {nameOfDays.map((day, i) => (\n                    // eslint-disable-next-line react/no-array-index-key\n                    <td key={i}>{day}</td>\n                ))}\n            </tr>\n        )\n    }\n\n    renderWeeks() {\n        const { displayesMonth, tempTimeObj } = this.state\n        const { hours, minutes, seconds } = tempTimeObj || {}\n        const firstDay = addTime(\n            displayesMonth.clone().startOf('isoWeek'),\n            hours,\n            minutes,\n            seconds,\n        )\n\n        return weeks(firstDay).map((week, i) => this.renderWeek(week, i))\n    }\n\n    renderWeek(week: Moment[], i: number) {\n        return <tr key={i}>{week.map((day, i) => this.renderDay(day, i))}</tr>\n    }\n\n    // eslint-disable-next-line complexity\n    renderDay(day: Moment, i: number) {\n        const {\n            min,\n            max,\n            value,\n            select,\n            inputName,\n            type,\n            index,\n            values,\n            dateFormat,\n        } = this.props\n\n        let disabled = false\n\n        if (min && max) {\n            disabled = day.isBefore(min) || day.isAfter(max)\n        } else if (min) {\n            disabled = day.isBefore(min)\n        } else if (max) {\n            disabled = day.isAfter(max)\n        }\n\n        if (type === ControlType.DATE_INTERVAL) {\n            const { begin } = values\n\n            const disableDaysBefore = (range: MomentInput) => day.isBefore(range)\n            const disableDaysAfter = (range: MomentInput) => day.isAfter(range)\n\n            const disabledDaysBeyondTheScopeMinMax = disableDaysBefore(min) || disableDaysAfter(max)\n            const disabledDaysBeyondTheScopeBeginMax = disableDaysBefore(begin) || disableDaysAfter(max)\n\n            // eslint-disable-next-line no-unused-vars,no-return-assign, @typescript-eslint/no-unused-vars\n            const rangeMinMax = (disabledDays: boolean) => (disabledDays = disabledDaysBeyondTheScopeMinMax)\n\n            // если не выбрана дата(begin) ||  min or max\n            const hasMinOrMaxAndNullBegin = (isNull(begin) && (min || max)) || (isNull(begin) && (min && max))\n\n            // если hasMinOrMaxAndNullBegin, устанавливаем default range (min or max)\n            if (hasMinOrMaxAndNullBegin) {\n                rangeMinMax(disabled)\n            } else if (min && max) {\n                disabled = index === 0\n                    ? disabledDaysBeyondTheScopeMinMax\n                    : disabledDaysBeyondTheScopeBeginMax\n            } else if (min) {\n                disabled = index === 0\n                    ? disableDaysBefore(min)\n                    : index === 1 && disableDaysBefore(begin)\n            } else if (max) {\n                disabled = index === 0\n                    ? disableDaysAfter(max)\n                    : index === 1 && disableDaysAfter(begin)\n            } else {\n                // не указан range (min, max)\n                disabled = index === 1 && disableDaysBefore(begin)\n            }\n        }\n\n        const { displayesMonth } = this.state\n        const otherMonth = isDateFromNextMonth(day, displayesMonth) ||\n            isDateFromPrevMonth(day, displayesMonth)\n        const selected = day.isSame(value)\n        const current = day.format('DD.MM.YYYY') === moment().format('DD.MM.YYYY')\n        const props = {\n            day,\n            otherMonth,\n            selected,\n            disabled,\n            select,\n            inputName,\n            current,\n            dateFormat,\n        }\n\n        return <Day key={i} {...props} />\n    }\n\n    renderTime() {\n        const { value, hasDefaultTime, timeFormat, t } = this.props\n\n        if (hasDefaultTime) {\n            if (value) {\n                return value.format(timeFormat)\n            }\n\n            return '00:00:00'\n        }\n\n        if (t) {\n            return t('chooseTime')\n        }\n\n        return null\n    }\n\n    renderByDays() {\n        const { timeFormat } = this.props\n\n        return (\n            <>\n                <table className=\"n2o-calendar-table\">\n                    <thead>{this.renderNameOfDays()}</thead>\n                    <tbody>{this.renderWeeks()}</tbody>\n                </table>\n                {timeFormat && (\n                    <a\n                        className=\"n2o-calendar-time-container\"\n                        href=\"/test\"\n                        onClick={(e) => {\n                            e.preventDefault()\n                            this.changeCalendarType(CalendarType.TIME_PICKER)\n                        }}\n                    >\n                        {this.renderTime()}\n                    </a>\n                )}\n            </>\n        )\n    }\n\n    renderByMonths() {\n        const { locale = 'ru' } = this.props\n\n        return (\n            <div className=\"n2o-calendar-body\">\n                {this.renderList(moment.localeData(locale).months(), 'month-item')}\n            </div>\n        )\n    }\n\n    onItemClick = (itemType: string, item: string | number, i: number) => {\n        if (itemType === 'month-item') {\n            this.setDate('month', i)\n        } else {\n            this.setDate('year', item)\n        }\n        this.changeCalendarType(CalendarType.BY_DAYS)\n    }\n\n    renderList(list: Array<string | number>, className: string) {\n        const { value } = this.props\n\n        const isActive = (className: string, item: string | number, i: number) => {\n            if (!value) { return false }\n            if (className !== 'month-item') {\n                return item === value.year()\n            }\n\n            return i === value.month()\n        }\n        const isOtherDecade = (i: number) => className === 'year-item' && (i === 0 || i === 11)\n\n        return list.map((item, i) => (\n            <div\n                className={cx('n2o-calendar-body-item', className, {\n                    active: isActive(className, item, i),\n                    'other-decade': isOtherDecade(i),\n                })}\n                onClick={() => this.onItemClick(className, item, i)}\n            >\n                {item}\n            </div>\n        ))\n    }\n\n    renderByYears() {\n        const { displayesMonth } = this.state\n        const decadeStart = parseInt(String(Number(displayesMonth.format('YYYY')) / 10), 10) * 10\n        const years = Array.from(\n            new Array(12),\n            (val, index) => decadeStart + index - 1,\n        )\n\n        return (\n            <div className=\"n2o-calendar-body\">\n                {this.renderList(years, 'year-item')}\n            </div>\n        )\n    }\n\n    componentDidUpdate() {\n        const { calendarType } = this.state\n\n        if (calendarType === CalendarType.TIME_PICKER) {\n            if (this.minuteRef) {\n                this.minuteRef.scrollIntoView()\n            }\n            if (this.secondRef) {\n                this.secondRef.scrollIntoView()\n            }\n            if (this.hourRef) {\n                this.hourRef.scrollIntoView()\n            }\n        }\n    }\n\n    setTimeUnit = (value: number, unit: string) => {\n        const { tempTimeObj } = this.state\n\n        this.setState({\n            tempTimeObj: { ...tempTimeObj, [unit]: value },\n        })\n    }\n\n    setTime = () => {\n        const { value, inputName, markTimeAsSet, select } = this.props\n        const { tempTimeObj } = this.state\n        const { hours, minutes, seconds } = tempTimeObj || {}\n        const copyValue = value || moment()\n\n        this.changeCalendarType(CalendarType.BY_DAYS)\n        markTimeAsSet(inputName)\n\n        select(\n            addTime(copyValue.clone().startOf('day'), hours, minutes, seconds),\n            inputName,\n            false,\n        )\n    }\n\n    renderTimePicker() {\n        const { tempTimeObj } = this.state\n        const { minutes, seconds, hours } = tempTimeObj || {}\n\n        /* eslint-disable react/jsx-one-expression-per-line */\n        return (\n            <div>\n                <div className=\"n2o-calendar-timepicker\">\n                    <div className=\"n2o-calendar-picker hour-picker\">\n                        {Array.from(new Array(24), (val, index) => (\n                            <div\n                                className={cx('n2o-calendar-time-unit', {\n                                    active: index === hours,\n                                })}\n                                onClick={() => this.setTimeUnit(index, 'hours')}\n                                ref={index === hours ? this.setHourRef : null}\n                            >\n                                {index}\n                            </div>\n                        ))}\n                    </div>\n                    <div className=\"n2o-calendar-picker minute-picker\">\n                        {Array.from(new Array(60), (val, index) => (\n                            <div\n                                className={cx('n2o-calendar-time-unit', {\n                                    active: index === minutes,\n                                })}\n                                ref={index === minutes ? this.setMinuteRef : null}\n                                onClick={() => this.setTimeUnit(index, 'minutes')}\n                            >\n                                {index}\n                            </div>\n                        ))}\n                    </div>\n                    <div className=\"n2o-calendar-picker second-picker\">\n                        {Array.from(new Array(60), (val, index) => (\n                            <div\n                                className={cx('n2o-calendar-time-unit', {\n                                    active: index === seconds,\n                                })}\n                                ref={index === seconds ? this.setSecondRef : null}\n                                onClick={() => this.setTimeUnit(index, 'seconds')}\n                            >\n                                {index}\n                            </div>\n                        ))}\n                    </div>\n                </div>\n                <div className=\"n2o-calendar-time-buttons\">\n                    <button\n                        type=\"button\"\n                        className=\"btn btn-secondary btn-sm\"\n                        onClick={() => this.changeCalendarType(CalendarType.BY_DAYS)}\n                    >\n                        {' '}\n\n                        Назад\n                    </button>\n                    <button className=\"btn btn-primary btn-sm\" onClick={this.setTime} type=\"button\">\n                        {' '}\n\n                        Выбрать\n                    </button>\n                </div>\n            </div>\n        )\n    }\n\n    renderBody(type: string) {\n        switch (type) {\n            case CalendarType.BY_MONTHS:\n                return this.renderByMonths()\n            case CalendarType.BY_YEARS:\n                return this.renderByYears()\n            case CalendarType.TIME_PICKER:\n                return this.renderTimePicker()\n            case CalendarType.BY_DAYS:\n            default:\n                return this.renderByDays()\n        }\n    }\n\n    render() {\n        const { calendarType } = this.state\n        const { timeFormat } = this.props\n\n        return (\n            <div\n                className={cx('n2o-calendar', {\n                    time: timeFormat,\n                })}\n            >\n                {this.renderHeader()}\n                {this.renderBody(calendarType)}\n            </div>\n        )\n    }\n}\n"]}

package/lib/inputs/DatePicker/CalendarHeader.d.ts

@@ -0,0 +1,26 @@
+import React, { ReactNode } from 'react';
+import type { Moment } from 'moment';
+import 'moment/locale/ru';
+import { CalendarType } from './types';
+import '../../styles/components/CalendarHeader.scss';
+declare type CalendarHeaderProps = {
+    calendarType: CalendarType;
+    changeCalendarType(type?: CalendarType): void;
+    displayesMonth: Moment;
+    locale: string;
+    nextDecade(): void;
+    nextMonth(): void;
+    nextYear(): void;
+    prevDecade(): void;
+    prevMonth(): void;
+    prevYear(): void;
+    t(str: string): ReactNode;
+};
+export declare class CalendarHeader extends React.Component<CalendarHeaderProps> {
+    renderHeaderValue(displayesMonth: Moment, locale: string, type?: CalendarType): string | JSX.Element | null;
+    static nextType: (type: CalendarType) => CalendarType.BY_MONTHS | CalendarType.BY_YEARS | CalendarType.TIME_PICKER | undefined;
+    nextView: (type: CalendarType) => void;
+    prevView: (type: CalendarType) => void;
+    render(): JSX.Element;
+}
+export {};