intelicoreact 0.0.53 → 0.0.64

package/dist/Atomic/FormElements/InputDateRange/components/Datepicker.js

@@ -0,0 +1,486 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _momentTimezone = _interopRequireDefault(require("moment-timezone"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _dependencies = require("../dependencies");
+
+var _Dropdown = _interopRequireDefault(require("../../Dropdown/Dropdown"));
+
+var _Input = _interopRequireDefault(require("../../Input/Input"));
+
+var _Button = _interopRequireDefault(require("../../../UI/Button/Button"));
+
+var _RangeCalendar = _interopRequireDefault(require("../../RangeCalendar/RangeCalendar"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+// eslint-disable-next-line no-unused-vars
+// import Switcher from '../../Switcher/Switcher';
+var padTime = function padTime(time) {
+  return "".concat(time.toString().padStart(2, '0'), ":00");
+};
+
+var handleDateInputOnChange = function handleDateInputOnChange(value) {
+  var replace = function replace(val) {
+    return val.replace(/[^0-9\/]/g, '');
+  };
+
+  var input = replace(value);
+  var lastSymbol = input ? input.slice(-1) : '';
+  var previousValue = input ? input.slice(0, input.length - 1) : '';
+  if (value.length > 10 || lastSymbol === '/') return previousValue;
+  return previousValue.length === 2 || previousValue.length === 5 ? previousValue + '/' + lastSymbol : input;
+};
+
+var Datepicker = function Datepicker(props) {
+  var txt = props.txt,
+      className = props.className,
+      _props$buttonsTypes = props.buttonsTypes,
+      buttonsTypes = _props$buttonsTypes === void 0 ? {} : _props$buttonsTypes,
+      _props$values = props.values,
+      values = _props$values === void 0 ? {} : _props$values,
+      onChange = props.onChange,
+      onChangeCompare = props.onChangeCompare,
+      onCancel = props.onCancel,
+      getSelectedMode = props.getSelectedMode,
+      onChangeInterval = props.onChangeInterval,
+      isCompareHidden = props.isCompareHidden,
+      limitRange = props.limitRange,
+      handleItemClick = props.handleItemClick,
+      setActiveInterval = props.setActiveInterval;
+  var _values$start = values.start,
+      start = _values$start === void 0 ? null : _values$start,
+      _values$end = values.end,
+      end = _values$end === void 0 ? null : _values$end,
+      _values$compare = values.compare,
+      compare = _values$compare === void 0 ? false : _values$compare;
+  var startDateInputRef = (0, _react.useRef)(null);
+  var endDateInputRef = (0, _react.useRef)(null);
+
+  var _useState = (0, _react.useState)(start),
+      _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+      startDate = _useState2[0],
+      setStartDate = _useState2[1];
+
+  var _useState3 = (0, _react.useState)(end),
+      _useState4 = (0, _slicedToArray2.default)(_useState3, 2),
+      endDate = _useState4[0],
+      setEndDate = _useState4[1];
+
+  var dateInterval = getSelectedMode({
+    start: startDate,
+    end: endDate
+  });
+
+  var _useState5 = (0, _react.useState)(start),
+      _useState6 = (0, _slicedToArray2.default)(_useState5, 2),
+      startDateInput = _useState6[0],
+      setStartDateInput = _useState6[1];
+
+  var _useState7 = (0, _react.useState)(end),
+      _useState8 = (0, _slicedToArray2.default)(_useState7, 2),
+      endDateInput = _useState8[0],
+      setEndDateInput = _useState8[1];
+
+  var _useState9 = (0, _react.useState)(start ? (0, _momentTimezone.default)(start).hour() : 0),
+      _useState10 = (0, _slicedToArray2.default)(_useState9, 2),
+      startHour = _useState10[0],
+      setStartHour = _useState10[1];
+
+  var _useState11 = (0, _react.useState)(end ? (0, _momentTimezone.default)(end).hour() : 0),
+      _useState12 = (0, _slicedToArray2.default)(_useState11, 2),
+      endHour = _useState12[0],
+      setEndHour = _useState12[1]; // eslint-disable-next-line no-unused-vars
+
+
+  var _useState13 = (0, _react.useState)(compare),
+      _useState14 = (0, _slicedToArray2.default)(_useState13, 2),
+      isCompare = _useState14[0],
+      setIsCompare = _useState14[1];
+
+  var _useState15 = (0, _react.useState)(start ? (0, _momentTimezone.default)(start).toDate() : (0, _momentTimezone.default)().subtract(1, 'month').toDate()),
+      _useState16 = (0, _slicedToArray2.default)(_useState15, 2),
+      date1 = _useState16[0],
+      setDate1 = _useState16[1];
+
+  var _useState17 = (0, _react.useState)(end ? (0, _momentTimezone.default)(end).toDate() : (0, _momentTimezone.default)().toDate()),
+      _useState18 = (0, _slicedToArray2.default)(_useState17, 2),
+      date2 = _useState18[0],
+      setDate2 = _useState18[1];
+
+  var _useState19 = (0, _react.useState)(false),
+      _useState20 = (0, _slicedToArray2.default)(_useState19, 2),
+      isStartFocused = _useState20[0],
+      setIsStartFocused = _useState20[1];
+
+  var _useState21 = (0, _react.useState)(false),
+      _useState22 = (0, _slicedToArray2.default)(_useState21, 2),
+      isEndFocused = _useState22[0],
+      setIsEndFocused = _useState22[1];
+
+  var _useState23 = (0, _react.useState)(null),
+      _useState24 = (0, _slicedToArray2.default)(_useState23, 2),
+      hoverStatus = _useState24[0],
+      setHoverStatus = _useState24[1];
+
+  var isNearby = (0, _react.useMemo)(function () {
+    return (0, _momentTimezone.default)(date2).subtract(1, 'month').isSame((0, _momentTimezone.default)(date1), 'month');
+  }, [date1, date2]);
+  var isPreviousPeriodShowed = (0, _react.useMemo)(function () {
+    return isCompare && !isCompareHidden && startDate && endDate;
+  }, [startDate, endDate, isCompare]);
+
+  var setInterval = function setInterval() {
+    setActiveInterval((0, _dependencies.getActualDateRange)({
+      start: startDate,
+      end: endDate
+    }).intervalKey);
+  };
+
+  var prevEndHour = (0, _react.useRef)(endHour);
+
+  var getStartHourItems = function getStartHourItems() {
+    return (0, _toConsumableArray2.default)(Array(24).keys()).map(function (hour) {
+      return {
+        label: padTime(hour),
+        value: hour,
+        disabled: (0, _momentTimezone.default)(startDate).isSame(endDate, 'day') && endHour <= hour
+      };
+    });
+  };
+
+  var getEndHourItems = function getEndHourItems() {
+    return (0, _toConsumableArray2.default)(Array(24).keys()).map(function (hour) {
+      return {
+        label: padTime(hour + 1),
+        value: hour === 23 ? 0 : hour + 1,
+        disabled: ((0, _momentTimezone.default)(startDate).isSame(endDate, 'day') || (0, _momentTimezone.default)(startDate).isSame((0, _momentTimezone.default)(endDate).subtract(1, 'days'), 'day') && endHour === 0) && hour < startHour
+      };
+    });
+  };
+
+  var startPrevDate = (0, _react.useMemo)(function () {
+    if (isPreviousPeriodShowed) {
+      var intervalHoursCount = (0, _momentTimezone.default)(endDate).diff(startDate, 'hours');
+      return (0, _momentTimezone.default)(startDate).subtract(intervalHoursCount, 'hours').toDate();
+    } else return null;
+  }, [startDate, endDate, isCompare]);
+  var endPrevDate = (0, _react.useMemo)(function () {
+    if (isPreviousPeriodShowed) {
+      return startDate;
+    } else return null;
+  }, [startDate, endDate, isCompare]);
+  var title = (0, _react.useMemo)(function () {
+    if (isCompare && !isCompareHidden && startDate && endDate) {
+      return "".concat((0, _momentTimezone.default)(startPrevDate).format('ll'), " (").concat((0, _momentTimezone.default)(startPrevDate).format('HH:mm'), ") - ").concat((0, _momentTimezone.default)(endPrevDate).format('ll'), " (").concat((0, _momentTimezone.default)(endPrevDate).format('HH:mm'), ")");
+    } else return '';
+  }, [startDate, endDate, isCompare]);
+
+  var subtractDay = function subtractDay(date) {
+    return endHour === 0 ? (0, _momentTimezone.default)(date).subtract(1, 'days') : date;
+  };
+
+  var addDay = function addDay(date) {
+    return endHour === 0 ? (0, _momentTimezone.default)(date).add(1, 'days') : date;
+  };
+
+  (0, _react.useEffect)(function () {
+    if ((0, _momentTimezone.default)(startDate).isSameOrAfter(endDate)) {
+      setStartDate((0, _momentTimezone.default)(endDate).subtract(1, 'd').toDate());
+      setDate1((0, _momentTimezone.default)(endDate).subtract(1, 'd'));
+    }
+  }, [startDate]);
+  (0, _react.useEffect)(function () {
+    if ((0, _momentTimezone.default)(endDate).isSameOrBefore(startDate)) {
+      setEndDate((0, _momentTimezone.default)(startDate).add(1, 'd').toDate());
+      setDate2((0, _momentTimezone.default)(startDate).add(1, 'd'));
+    }
+  }, [endDate]);
+  (0, _react.useEffect)(function () {
+    setStartDateInput(startDate);
+    setEndDateInput(endDate);
+
+    if ((0, _momentTimezone.default)(startDate).isBefore((0, _momentTimezone.default)(endDate), 'month')) {
+      setDate1((0, _momentTimezone.default)(startDate));
+      setDate2((0, _momentTimezone.default)(endDate));
+    }
+
+    setInterval();
+  }, [startDate, endDate]);
+  (0, _react.useEffect)(function () {
+    if ((0, _momentTimezone.default)(date1).isSameOrAfter((0, _momentTimezone.default)(date2), 'month')) {
+      setDate1((0, _momentTimezone.default)(date2).subtract(1, 'month'));
+    }
+  }, [date1, date2]);
+  (0, _react.useEffect)(function () {
+    onChangeInterval(dateInterval);
+  }, [dateInterval]);
+
+  var handleClick = function handleClick(date) {
+    prevEndHour.current = 0;
+
+    if (!startDate || startDate && endDate && !((0, _momentTimezone.default)(startDate).add(1, 'd').isSame(endDate, 'day') && endHour === 0)) {
+      setStartDate((0, _momentTimezone.default)(date).startOf('day').toDate());
+      setEndDate((0, _momentTimezone.default)(date).add(1, 'd').startOf('day').toDate());
+      setStartHour(0);
+      setEndHour(0);
+    } else if ((0, _momentTimezone.default)(date).isBefore((0, _momentTimezone.default)(startDate), 'day')) {
+      setEndDate((0, _momentTimezone.default)(startDate).add(1, 'd').startOf('day').toDate());
+      setStartDate((0, _momentTimezone.default)(date).set('hour', parseInt(startHour, 10)).toDate());
+    } else if ((0, _momentTimezone.default)(date).isAfter((0, _momentTimezone.default)(startDate), 'day')) {
+      setEndDate((0, _momentTimezone.default)(date).add(1, 'd').startOf('day').toDate());
+    }
+
+    setHoverStatus(null);
+  };
+
+  var timerId;
+
+  var handleHover = function handleHover(date) {
+    if (!date) {
+      timerId = setTimeout(function () {
+        setHoverStatus(null);
+      }, 400);
+      return;
+    }
+
+    if (timerId) clearTimeout(timerId);
+
+    if ((0, _momentTimezone.default)(startDate).add(1, 'd').isSame(endDate, 'day') && endHour === 0) {
+      if ((0, _momentTimezone.default)(date).isAfter((0, _momentTimezone.default)(startDate), 'day')) setHoverStatus('end');else if ((0, _momentTimezone.default)(date).isBefore((0, _momentTimezone.default)(startDate), 'day')) setHoverStatus('start');else setHoverStatus(null);
+    } else {
+      setHoverStatus('start');
+    }
+  };
+
+  var handleChangeStartHour = function handleChangeStartHour(val) {
+    setStartHour(+val);
+    setStartDate((0, _momentTimezone.default)(startDate).set('hour', +val).toDate());
+  };
+
+  var handleChangeEndHour = function handleChangeEndHour(val) {
+    var newHour = +val;
+    setEndHour(newHour);
+    var newEndDate;
+
+    if (prevEndHour.current === 0 && newHour !== 0) {
+      newEndDate = (0, _momentTimezone.default)(endDate).subtract(1, 'days');
+    } else if (prevEndHour.current !== 0 && newHour === 0) {
+      newEndDate = (0, _momentTimezone.default)(endDate).add(1, 'days');
+    } else {
+      newEndDate = endDate;
+    }
+
+    prevEndHour.current = newHour;
+    setEndDate((0, _momentTimezone.default)(newEndDate).set('hour', newHour).toDate());
+  };
+
+  var renderButtons = function renderButtons() {
+    var _txt$buttons, _txt$buttons2;
+
+    return /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/_react.default.createElement(_Button.default, {
+      className: "date-picker__button",
+      onClick: function onClick() {
+        return onCancel();
+      },
+      variant: buttonsTypes === null || buttonsTypes === void 0 ? void 0 : buttonsTypes.cancel
+    }, (txt === null || txt === void 0 ? void 0 : (_txt$buttons = txt.buttons) === null || _txt$buttons === void 0 ? void 0 : _txt$buttons.cancel) || 'cancel'), /*#__PURE__*/_react.default.createElement(_Button.default, {
+      className: "date-picker__button",
+      variant: buttonsTypes === null || buttonsTypes === void 0 ? void 0 : buttonsTypes.apply,
+      disabled: !startDate || !endDate,
+      onClick: function onClick() {
+        return onChange({
+          start: startDate,
+          end: endDate,
+          startPrevDate: startPrevDate,
+          endPrevDate: endPrevDate,
+          compare: isCompare
+        });
+      }
+    }, (txt === null || txt === void 0 ? void 0 : (_txt$buttons2 = txt.buttons) === null || _txt$buttons2 === void 0 ? void 0 : _txt$buttons2.apply) || 'apply'));
+  };
+
+  var renderPreviousPeriod = function renderPreviousPeriod() {
+    return /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, txt.labels.previousPeriod, ": ", /*#__PURE__*/_react.default.createElement("span", {
+      className: "date-picker__previous-period-interval"
+    }, title));
+  };
+
+  var doBlur = function doBlur(type, e) {
+    var executor = type === 'start' ? setIsStartFocused : setIsEndFocused;
+    e.target.blur();
+    executor(false);
+  };
+
+  var handleStartDateFocus = function handleStartDateFocus(e) {
+    setIsStartFocused(true);
+    setStartDateInput((0, _momentTimezone.default)(startDate).format('L'));
+    setTimeout(function () {
+      return e.target.select();
+    }, 0);
+  };
+
+  var handleStartDateBlur = function handleStartDateBlur(e) {
+    var newDate;
+
+    if ((0, _momentTimezone.default)(startDateInput).isValid()) {
+      newDate = (0, _momentTimezone.default)(startDateInput).set('hour', parseInt(startHour, 10)).toDate();
+      setStartDate(newDate);
+    } else {
+      newDate = startDate;
+      setStartDateInput(newDate);
+    }
+
+    doBlur('start', e);
+    setDate1((0, _momentTimezone.default)(newDate).isSameOrAfter((0, _momentTimezone.default)(date2), 'month') ? (0, _momentTimezone.default)(date2).subtract(1, 'month') : (0, _momentTimezone.default)(newDate));
+  };
+
+  var handleEndDateFocus = function handleEndDateFocus(e) {
+    setIsEndFocused(true);
+    setEndDateInput((0, _momentTimezone.default)(subtractDay(endDateInput)).format('L'));
+    setTimeout(function () {
+      return e.target.select();
+    }, 0);
+  };
+
+  var handleEndDateBlur = function handleEndDateBlur(e) {
+    var newDate;
+
+    if ((0, _momentTimezone.default)(endDateInput).isValid()) {
+      newDate = (0, _momentTimezone.default)(endDateInput).set('hour', parseInt(endHour, 10)).toDate();
+      setEndDate(addDay(newDate));
+    } else {
+      newDate = endDate;
+      setEndDateInput(newDate);
+    }
+
+    doBlur('end', e);
+    setDate2(newDate);
+    setEndDateInput();
+  };
+
+  var handleKeyPressed = function handleKeyPressed(code, e, type) {
+    if (code === 13) (type === 'start' ? handleStartDateBlur : handleEndDateBlur)(e);
+    if (code === 27) doBlur(type, e);
+  };
+
+  return /*#__PURE__*/_react.default.createElement("div", {
+    className: (0, _classnames.default)('date-picker', className)
+  }, /*#__PURE__*/_react.default.createElement("div", {
+    className: "date-picker__header"
+  }, /*#__PURE__*/_react.default.createElement("div", {
+    className: "date-picker__inputs-block"
+  }, /*#__PURE__*/_react.default.createElement(_Input.default, {
+    dataTest: "datepicker_start-date-input",
+    className: (0, _classnames.default)('date-picker__date-input', {
+      'date-picker__date-input_active': hoverStatus === 'start'
+    }),
+    value: isStartFocused ? startDateInput : (0, _momentTimezone.default)(startDate).format('ll'),
+    disabled: !startDate,
+    onChange: function onChange(value) {
+      return setStartDateInput(handleDateInputOnChange(value));
+    },
+    onFocus: handleStartDateFocus,
+    onBlur: handleStartDateBlur,
+    onKeyUp: function onKeyUp(code, e) {
+      return handleKeyPressed(code, e, 'start');
+    },
+    ref: startDateInputRef // mask={moment(startDate).format('L').replace(/[0-9]/g, '9')}
+
+  }), /*#__PURE__*/_react.default.createElement(_Dropdown.default, {
+    dataTest: "datepicker_start-hour-select-input",
+    className: (0, _classnames.default)('date-picker__hour-select-input'),
+    onChange: function onChange(value) {
+      return handleChangeStartHour(value);
+    },
+    value: startHour,
+    options: getStartHourItems(),
+    disabled: !startDate,
+    short: true
+  }), /*#__PURE__*/_react.default.createElement("div", {
+    className: "date-picker__inputs-separator date-picker__header--gray"
+  }, "\u2014"), /*#__PURE__*/_react.default.createElement(_Input.default, {
+    dataTest: "datepicker_end-date-input",
+    className: (0, _classnames.default)('date-picker__date-input', {
+      'date-picker__date-input_active': hoverStatus === 'end'
+    }),
+    value: isEndFocused ? endDateInput : (0, _momentTimezone.default)(subtractDay(endDate)).format('ll'),
+    disabled: !endDate,
+    onChange: function onChange(value) {
+      return setEndDateInput(handleDateInputOnChange(value));
+    },
+    onFocus: handleEndDateFocus,
+    onBlur: handleEndDateBlur,
+    onKeyUp: function onKeyUp(code, e) {
+      return handleKeyPressed(code, e, 'end');
+    },
+    ref: endDateInputRef
+  }), /*#__PURE__*/_react.default.createElement(_Dropdown.default, {
+    dataTest: "datepicker_end-hour-select-input",
+    className: (0, _classnames.default)('date-picker__hour-select-input'),
+    onChange: function onChange(value) {
+      return handleChangeEndHour(value);
+    },
+    value: endHour,
+    options: getEndHourItems(),
+    disabled: !endDate,
+    short: true
+  })), isCompare && !isCompareHidden && startDate && endDate && /*#__PURE__*/_react.default.createElement("div", {
+    className: "date-picker__previous-period"
+  }, renderPreviousPeriod())), /*#__PURE__*/_react.default.createElement("div", {
+    className: "date-picker__calendars"
+  }, /*#__PURE__*/_react.default.createElement("div", {
+    className: "date-picker__calendars-wrapper"
+  }, /*#__PURE__*/_react.default.createElement(_RangeCalendar.default, {
+    className: "date-picker__calendar",
+    date: date1,
+    setDate: setDate1,
+    allowNext: !isNearby,
+    startDate: startDate,
+    endDate: endDate,
+    startPrevDate: startPrevDate,
+    endPrevDate: endPrevDate,
+    onClick: handleClick,
+    onHover: handleHover,
+    limitRange: limitRange
+  }), /*#__PURE__*/_react.default.createElement(_RangeCalendar.default, {
+    className: "date-picker__calendar",
+    date: date2,
+    setDate: setDate2,
+    allowPrev: !isNearby,
+    startDate: startDate,
+    endDate: endDate,
+    startPrevDate: startPrevDate,
+    endPrevDate: endPrevDate,
+    onClick: handleClick,
+    onHover: handleHover
+  }))), /*#__PURE__*/_react.default.createElement("div", {
+    className: (0, _classnames.default)('date-picker__footer', {
+      'date-picker__footer_once-element': isCompareHidden
+    })
+  }, /*#__PURE__*/_react.default.createElement("div", {
+    className: "date-picker__buttons-block"
+  }, renderButtons())));
+};
+
+var _default = Datepicker;
+exports.default = _default;

package/dist/Atomic/FormElements/InputDateRange/components/OpenedPart.js

@@ -0,0 +1,154 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _momentTimezone = _interopRequireDefault(require("moment-timezone"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _dependencies = require("../dependencies");
+
+var _SelectItem = _interopRequireDefault(require("./SelectItem"));
+
+var _Datepicker = _interopRequireDefault(require("./Datepicker"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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; }
+
+var OpenedPart = /*#__PURE__*/_react.default.forwardRef(function (props, ref) {
+  var txt = props.txt,
+      buttonsTypes = props.buttonsTypes,
+      actualValues = props.actualValues,
+      _props$onChange = props.onChange,
+      _onChange = _props$onChange === void 0 ? function () {} : _props$onChange,
+      isHoverable = props.isHoverable,
+      short = props.short,
+      _props$isCompact = props.isCompact,
+      isCompact = _props$isCompact === void 0 ? false : _props$isCompact,
+      _props$isIntervalsHid = props.isIntervalsHidden,
+      isIntervalsHidden = _props$isIntervalsHid === void 0 ? false : _props$isIntervalsHid,
+      _props$isCompareHidde = props.isCompareHidden,
+      isCompareHidden = _props$isCompareHidde === void 0 ? false : _props$isCompareHidde,
+      limitRange = props.limitRange,
+      isOptionsRight = props.isOptionsRight,
+      current = props.current,
+      setCurrent = props.setCurrent,
+      isCompare = props.isCompare,
+      setIsCompare = props.setIsCompare,
+      toggleOff = props.toggleOff;
+
+  var items = isCompact ? (0, _toConsumableArray2.default)(Object.keys(_dependencies.INTERVALS)) : [].concat((0, _toConsumableArray2.default)(Object.keys(_dependencies.INTERVALS)), [_dependencies.CUSTOM_INTERVAL_KEY]);
+
+  var _useState = (0, _react.useState)(actualValues.intervalKey),
+      _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+      activeInterval = _useState2[0],
+      setActiveInterval = _useState2[1];
+
+  var handleItemClick = function handleItemClick(item) {
+    if (item !== _dependencies.CUSTOM_INTERVAL_KEY) {
+      _onChange({
+        intervalKey: item,
+        compare: isCompare
+      });
+
+      setTimeout(function () {
+        return toggleOff();
+      }, 0);
+    }
+
+    setCurrent(item);
+  };
+
+  var getSelectedMode = function getSelectedMode(newValues) {
+    var start = newValues.start,
+        end = newValues.end;
+
+    if ((0, _momentTimezone.default)(start).get('hour') !== 0 || (0, _momentTimezone.default)(end).get('hour') !== 0) {
+      return _dependencies.CUSTOM_INTERVAL_KEY;
+    }
+
+    for (var _i = 0, _Object$entries = Object.entries(_dependencies.INTERVALS); _i < _Object$entries.length; _i++) {
+      var _Object$entries$_i = (0, _slicedToArray2.default)(_Object$entries[_i], 2),
+          key = _Object$entries$_i[0],
+          interval = _Object$entries$_i[1];
+
+      if ((0, _momentTimezone.default)(start).isSame(interval.start()) && (0, _momentTimezone.default)(end).isSame(interval.end())) {
+        return key;
+      }
+    }
+
+    return _dependencies.CUSTOM_INTERVAL_KEY;
+  };
+
+  return /*#__PURE__*/_react.default.createElement("div", {
+    className: (0, _classnames.default)('date-range-input__opened-part', 'opened-part') // style={styles}
+
+  }, /*#__PURE__*/_react.default.createElement("div", {
+    className: (0, _classnames.default)('opened-part__wrapper', {
+      'opened-part__wrapper_right-position-once-element': isOptionsRight && (isCompact || isIntervalsHidden)
+    })
+  }, !isIntervalsHidden && /*#__PURE__*/_react.default.createElement("div", {
+    className: (0, _classnames.default)('opened-part__intervals-list' // 'form-select-options',
+    // { 'form-select-options--short': short },
+    // { 'form-select-options--hoverable': isHoverable },
+    )
+  }, items.map(function (item, index) {
+    var _intervals$item;
+
+    return /*#__PURE__*/_react.default.createElement(_SelectItem.default, {
+      key: index,
+      item: item,
+      label: (txt === null || txt === void 0 ? void 0 : txt.labels) && (txt === null || txt === void 0 ? void 0 : txt.labels[item]) || ((_intervals$item = _dependencies.INTERVALS[item]) === null || _intervals$item === void 0 ? void 0 : _intervals$item.label) || item,
+      isActive: activeInterval === item,
+      onItemClick: function onItemClick() {
+        return handleItemClick(item.value || item);
+      },
+      disabled: item === _dependencies.CUSTOM_INTERVAL_KEY
+    });
+  })), !isCompact && /*#__PURE__*/_react.default.createElement(_Datepicker.default, {
+    className: (0, _classnames.default)('opened-part__date-picker'),
+    buttonsTypes: buttonsTypes,
+    values: actualValues,
+    onChange: function onChange(data) {
+      _onChange(_objectSpread({
+        intervalKey: current
+      }, data));
+
+      toggleOff();
+    },
+    getSelectedMode: getSelectedMode,
+    onChangeInterval: function onChangeInterval(val) {
+      return setCurrent(val);
+    },
+    onChangeCompare: function onChangeCompare(data) {
+      return setIsCompare(data);
+    },
+    onCancel: toggleOff,
+    isCompareHidden: isCompareHidden,
+    limitRange: limitRange,
+    setActiveInterval: setActiveInterval
+  })));
+});
+
+var _default = OpenedPart;
+exports.default = _default;

package/dist/Atomic/FormElements/InputDateRange/components/SelectItem.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var SelectItem = function SelectItem(_ref) {
+  var item = _ref.item,
+      label = _ref.label,
+      isActive = _ref.isActive,
+      onItemClick = _ref.onItemClick,
+      onMouseEnter = _ref.onMouseEnter,
+      disabled = _ref.disabled;
+  return /*#__PURE__*/_react.default.createElement("div", {
+    className: (0, _classnames.default)('opened-part__intervals-item', {
+      'opened-part__intervals-item_active': isActive,
+      'opened-part__intervals-item_disabled': disabled
+    }),
+    onClick: onItemClick,
+    onMouseEnter: onMouseEnter,
+    "data-item": item
+  }, isActive && /*#__PURE__*/_react.default.createElement("svg", {
+    className: (0, _classnames.default)('opened-part__intervals-item-icon-active'),
+    width: "16",
+    height: "16",
+    viewBox: "0 0 16 16",
+    fill: "none",
+    xmlns: "http://www.w3.org/2000/svg"
+  }, /*#__PURE__*/_react.default.createElement("path", {
+    d: "M13.3333 4L5.99999 11.3333L2.66666 8",
+    stroke: "black",
+    "stroke-width": "1.33333",
+    "stroke-linecap": "round",
+    "stroke-linejoin": "round"
+  })), label);
+};
+
+var _default = SelectItem;
+exports.default = _default;