@skbkontur/react-ui 0.0.0-ce2a893b1a → 0.0.0-d1bb8f344a

package/cjs/components/Button/getInnerLinkTheme.js

@@ -0,0 +1,22 @@
+"use strict";exports.__esModule = true;exports.getInnerLinkTheme = void 0;var _ThemeFactory = require("../../lib/theming/ThemeFactory");
+
+
+var getInnerLinkTheme = function getInnerLinkTheme(theme) {
+  return _ThemeFactory.ThemeFactory.create(
+  {
+    linkLineBorderBottomStyle: theme.btnLinkLineBorderBottomStyle,
+    linkLineHoverBorderBottomStyle: theme.btnLinkHoverLineBorderBottomStyle,
+    linkLineBorderBottomOpacity: theme.btnLinkLineBorderBottomOpacity,
+    linkLineBorderBottomColor: theme.btnLinkLineBorderBottomColor,
+    linkLineBorderBottomWidth: theme.btnLinkLineBorderBottomWidth,
+    linkDisabledColor: theme.btnLinkDisabledColor,
+    linkColor: theme.btnLinkColor,
+    linkHoverColor: theme.btnLinkHoverColor,
+    linkActiveColor: theme.btnLinkActiveColor,
+    linkHoverTextDecoration: theme.btnLinkHoverTextDecoration,
+    linkIconMarginRight: theme.btnLinkIconMarginRight,
+    linkBorderRadius: theme.btnLinkBorderRadius },
+
+  theme);
+
+};exports.getInnerLinkTheme = getInnerLinkTheme;

package/cjs/components/Button/getInnerLinkTheme.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["getInnerLinkTheme.ts"],"names":["getInnerLinkTheme","theme","ThemeFactory","create","linkLineBorderBottomStyle","btnLinkLineBorderBottomStyle","linkLineHoverBorderBottomStyle","btnLinkHoverLineBorderBottomStyle","linkLineBorderBottomOpacity","btnLinkLineBorderBottomOpacity","linkLineBorderBottomColor","btnLinkLineBorderBottomColor","linkLineBorderBottomWidth","btnLinkLineBorderBottomWidth","linkDisabledColor","btnLinkDisabledColor","linkColor","btnLinkColor","linkHoverColor","btnLinkHoverColor","linkActiveColor","btnLinkActiveColor","linkHoverTextDecoration","btnLinkHoverTextDecoration","linkIconMarginRight","btnLinkIconMarginRight","linkBorderRadius","btnLinkBorderRadius"],"mappings":"0EAAA;;;AAGO,IAAMA,iBAAiB,GAAG,SAApBA,iBAAoB,CAACC,KAAD,EAAyB;AACxD,SAAOC,2BAAaC,MAAb;AACL;AACEC,IAAAA,yBAAyB,EAAEH,KAAK,CAACI,4BADnC;AAEEC,IAAAA,8BAA8B,EAAEL,KAAK,CAACM,iCAFxC;AAGEC,IAAAA,2BAA2B,EAAEP,KAAK,CAACQ,8BAHrC;AAIEC,IAAAA,yBAAyB,EAAET,KAAK,CAACU,4BAJnC;AAKEC,IAAAA,yBAAyB,EAAEX,KAAK,CAACY,4BALnC;AAMEC,IAAAA,iBAAiB,EAAEb,KAAK,CAACc,oBAN3B;AAOEC,IAAAA,SAAS,EAAEf,KAAK,CAACgB,YAPnB;AAQEC,IAAAA,cAAc,EAAEjB,KAAK,CAACkB,iBARxB;AASEC,IAAAA,eAAe,EAAEnB,KAAK,CAACoB,kBATzB;AAUEC,IAAAA,uBAAuB,EAAErB,KAAK,CAACsB,0BAVjC;AAWEC,IAAAA,mBAAmB,EAAEvB,KAAK,CAACwB,sBAX7B;AAYEC,IAAAA,gBAAgB,EAAEzB,KAAK,CAAC0B,mBAZ1B,EADK;;AAeL1B,EAAAA,KAfK,CAAP;;AAiBD,CAlBM,C","sourcesContent":["import { ThemeFactory } from '../../lib/theming/ThemeFactory';\nimport { Theme } from '../../lib/theming/Theme';\n\nexport const getInnerLinkTheme = (theme: Theme): Theme => {\n  return ThemeFactory.create(\n    {\n      linkLineBorderBottomStyle: theme.btnLinkLineBorderBottomStyle,\n      linkLineHoverBorderBottomStyle: theme.btnLinkHoverLineBorderBottomStyle,\n      linkLineBorderBottomOpacity: theme.btnLinkLineBorderBottomOpacity,\n      linkLineBorderBottomColor: theme.btnLinkLineBorderBottomColor,\n      linkLineBorderBottomWidth: theme.btnLinkLineBorderBottomWidth,\n      linkDisabledColor: theme.btnLinkDisabledColor,\n      linkColor: theme.btnLinkColor,\n      linkHoverColor: theme.btnLinkHoverColor,\n      linkActiveColor: theme.btnLinkActiveColor,\n      linkHoverTextDecoration: theme.btnLinkHoverTextDecoration,\n      linkIconMarginRight: theme.btnLinkIconMarginRight,\n      linkBorderRadius: theme.btnLinkBorderRadius,\n    },\n    theme,\n  );\n};\n"]}

package/cjs/components/Calendar/Calendar.d.ts

@@ -0,0 +1,129 @@
+import React from 'react';
+import { CommonProps } from '../../internal/CommonWrapper';
+import { Nullable, Range } from '../../typings/utility-types';
+import { MonthViewModel } from './MonthViewModel';
+import { CalendarDayProps } from './CalendarDay';
+export interface CalendarProps extends CommonProps {
+    /**
+     * Вызывается при изменении `value`
+     *
+     * В аргументе хранится дата в формате `dd.mm.yyyy`
+     */
+    onValueChange?: (date: string) => void;
+    /**
+     * Задаёт текущую дату
+     *
+     * Дата задаётся в формате `dd.mm.yyyy`
+     */
+    value: Nullable<string>;
+    /**
+     * Задаёт максимальную возможную дату
+     *
+     * Дата задаётся в формате `dd.mm.yyyy`
+     */
+    maxDate?: string;
+    /**
+     * Задаёт минимальную возможную дату
+     *
+     * Дата задаётся в формате `dd.mm.yyyy`
+     */
+    minDate?: string;
+    /**
+     * Функция для определения праздничных дней
+     * @default (_day, isWeekend) => isWeekend
+     * @param {string} day - строка в формате `dd.mm.yyyy`
+     * @param {boolean} isWeekend - флаг выходного (суббота или воскресенье)
+     *
+     * @returns {boolean} `true` для выходного или `false` для рабочего дня
+     */
+    isHoliday?: (day: string, isWeekend: boolean) => boolean;
+    /**
+     * Позволяет задать начальный месяц
+     */
+    initialMonth?: Range<1, 13>;
+    /**
+     * Позволяет задать начальный год
+     */
+    initialYear?: number;
+    /**
+     * Метод отрисовки дат в календаре
+     * @default (props: CalendarDayProps) => <CalendarDay {...props} />
+     * @param {CalendarDayProps} props
+     *
+     * @returns {ReactElement} Элемент, который отрисовывает контент числа месяца.
+     */
+    renderDay?: (props: CalendarDayProps) => React.ReactElement;
+    /**
+     * Вызывается при каждом изменении месяца
+     * @param {CalendarMonthChangeInfo} changeInfo - информация о изменении отображаемого месяца, где
+     * `month: number` - номер текущего отображаемого месяца от 1 до 12,
+     * `year: number` - отображаемый год,
+     */
+    onMonthChange?: (changeInfo: CalendarMonthChangeInfo) => void;
+}
+export interface CalendarState {
+    scrollPosition: number;
+    months: MonthViewModel[];
+    scrollDirection: number;
+    scrollTarget: number;
+}
+export interface CalendarMonthChangeInfo {
+    month: number;
+    year: number;
+}
+export declare const CalendarDataTids: {
+    readonly root: "Calendar__root";
+    readonly month: "MonthView__month";
+    readonly dayCell: "DayCellView__root";
+    readonly headerMonth: "MonthView__headerMonth";
+    readonly monthSelectMobile: "MonthView__monthSelectMobile";
+    readonly headerYear: "MonthView__headerYear";
+    readonly yearSelectMobile: "MonthView__yearSelectMobile";
+};
+declare type DefaultProps = Required<Pick<CalendarProps, 'minDate' | 'maxDate' | 'isHoliday'>>;
+/**
+ * Компонент календаря из [DatePicker](https://tech.skbkontur.ru/react-ui/#/Components/DatePicker)'а
+ */
+export declare class Calendar extends React.Component<CalendarProps, CalendarState> {
+    static __KONTUR_REACT_UI__: string;
+    static displayName: string;
+    static Day: React.MemoExoticComponent<import("../../lib/forwardRefAndName").ReactUIComponentWithRef<HTMLButtonElement, CalendarDayProps> & Record<string, unknown>>;
+    private static formatDate;
+    static defaultProps: DefaultProps;
+    private getProps;
+    private theme;
+    private wheelEndTimeout;
+    private root;
+    private animation;
+    private touchStartY;
+    private setRootNode;
+    constructor(props: CalendarProps);
+    componentDidUpdate(prevProps: Readonly<CalendarProps>, prevState: Readonly<CalendarState>): void;
+    componentWillUnmount(): void;
+    render(): JSX.Element;
+    /**
+     * Прокручивает календарь до переданной даты
+     * @public
+     */
+    scrollToMonth: (month: number, year: number) => Promise<void>;
+    private handleMonthChange;
+    private getViewModel;
+    private renderMain;
+    private refRoot;
+    private renderMonth;
+    private handleDateClick;
+    private getDateInNativeFormat;
+    private getMonthPositions;
+    private getVisibleMonths;
+    private handleMonthYearChange;
+    private executeAnimations;
+    private handleTouchStart;
+    private handleTouchMove;
+    private throttledHandleTouchMove;
+    private handleWheel;
+    private handleWheelEnd;
+    private scrollToNearestWeek;
+    private scrollTo;
+    private scrollAmount;
+}
+export {};

package/cjs/components/Calendar/Calendar.js

@@ -0,0 +1,523 @@
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;exports.__esModule = true;exports.CalendarDataTids = exports.Calendar = void 0;var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));var _inheritsLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/inheritsLoose"));var _react = _interopRequireDefault(require("react"));
+var _normalizeWheel2 = _interopRequireDefault(require("normalize-wheel"));
+var _lodash = _interopRequireDefault(require("lodash.throttle"));
+var _shallowequal = _interopRequireDefault(require("shallowequal"));
+var _globalObject = require("@skbkontur/global-object");
+
+var _isInstanceOf = require("../../lib/isInstanceOf");
+var _InternalDate = require("../../lib/date/InternalDate");
+var _rootNode = require("../../lib/rootNode");
+var _Emotion = require("../../lib/theming/Emotion");
+var _CommonWrapper = require("../../internal/CommonWrapper");
+var _constants = require("../../lib/date/constants");
+
+
+var _ThemeContext = require("../../lib/theming/ThemeContext");
+var _animation = require("../../lib/animation");
+var _client = require("../../lib/client");
+var _createPropsGetter = require("../../lib/createPropsGetter");
+var _InternalDateTransformer = require("../../lib/date/InternalDateTransformer");
+
+var _config = require("./config");
+var _MonthViewModel = require("./MonthViewModel");
+var CalendarScrollEvents = _interopRequireWildcard(require("./CalendarScrollEvents"));
+var _Month = require("./Month");
+var _Calendar = require("./Calendar.styles");
+var _CalendarDateShape = require("./CalendarDateShape");
+var CalendarUtils = _interopRequireWildcard(require("./CalendarUtils"));
+var _CalendarContext = require("./CalendarContext");
+var _CalendarDay = require("./CalendarDay");var _class, _class2, _temp;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var CalendarDataTids = {
+  root: 'Calendar__root',
+  month: 'MonthView__month',
+  dayCell: 'DayCellView__root',
+  headerMonth: 'MonthView__headerMonth',
+  monthSelectMobile: 'MonthView__monthSelectMobile',
+  headerYear: 'MonthView__headerYear',
+  yearSelectMobile: 'MonthView__yearSelectMobile' };exports.CalendarDataTids = CalendarDataTids;
+
+
+
+
+/**
+ * Компонент календаря из [DatePicker](https://tech.skbkontur.ru/react-ui/#/Components/DatePicker)'а
+ */var
+
+Calendar = (0, _rootNode.rootNode)(_class = (_temp = _class2 = /*#__PURE__*/function (_React$Component) {(0, _inheritsLoose2.default)(Calendar, _React$Component);Calendar.
+
+
+
+
+
+  formatDate = function formatDate(date, month, year) {
+    return new _InternalDate.InternalDate().setComponents({ date: date, month: month, year: year }).toString({ withPad: true });
+  };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+  function Calendar(_props) {var _this$props$initialYe;var _this;
+    _this = _React$Component.call(this, _props) || this;_this.getProps = (0, _createPropsGetter.createPropsGetter)(Calendar.defaultProps);_this.animation = (0, _animation.animation)();_this.touchStartY = null;_this.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    scrollToMonth = /*#__PURE__*/function () {var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(month, year) {var minDate, maxDate, currentMonth, diffInMonths, maxMonthsToAdd, onEnd, isYearChanges, monthsToPrependCount, monthsToPrepend, monthsToAppendCount, monthsToAppend;return _regenerator.default.wrap(function _callee$(_context) {while (1) {switch (_context.prev = _context.next) {case 0:if (!
+                _this.animation.inProgress()) {_context.next = 4;break;}
+                _this.animation.finish();
+                // FIXME: Dirty hack to await batched updates
+                _context.next = 4;return new Promise(function (r) {return _globalObject.globalObject.setTimeout(r, 0);});case 4:
+
+
+                minDate = _this.getDateInNativeFormat(_this.getProps().minDate);
+                maxDate = _this.getDateInNativeFormat(_this.getProps().maxDate);if (!(
+
+                minDate && (0, _CalendarDateShape.isGreater)(minDate, (0, _CalendarDateShape.create)(32, month, year)))) {_context.next = 9;break;}
+                _this.scrollToMonth(minDate.month, minDate.year);return _context.abrupt("return");case 9:if (!(
+
+
+
+                maxDate && (0, _CalendarDateShape.isLess)(maxDate, (0, _CalendarDateShape.create)(0, month, year)))) {_context.next = 12;break;}
+                _this.scrollToMonth(maxDate.month, maxDate.year);return _context.abrupt("return");case 12:
+
+
+
+                currentMonth = _this.state.months[1];
+                diffInMonths = currentMonth.month + currentMonth.year * 12 - month - year * 12;if (!(
+
+                diffInMonths === 0)) {_context.next = 17;break;}
+                _this.scrollTo(0);return _context.abrupt("return");case 17:
+
+
+
+                maxMonthsToAdd = (0, _config.themeConfig)(_this.theme).MAX_MONTHS_TO_APPEND_ON_SCROLL;
+
+                onEnd = function onEnd() {
+                  _this.setState({
+                    months: CalendarUtils.getMonths(month, year),
+                    scrollPosition: 0 });
+
+                };
+
+                isYearChanges = function isYearChanges(state) {
+                  return (
+                    state.months[1].year !== year &&
+                    // if diff in months is 2 or less,
+                    // either year is not changing either months already
+                    // have right isFirstInYear/isLastInYear flags
+                    Math.abs(diffInMonths) > 2);
+
+                };
+
+                // If scrolling upwards, prepend maximum maxMonthsToAdd months
+                // and scroll to the first month
+                if (diffInMonths > 0) {
+                  monthsToPrependCount = Math.min(Math.abs(diffInMonths) - 1, maxMonthsToAdd);
+                  monthsToPrepend = Array.from({ length: monthsToPrependCount }, function (_, index) {
+                    return _MonthViewModel.MonthViewModel.create(month + index, year);
+                  });
+                  _this.setState(
+                  function (state) {
+                    var yearChanges = isYearChanges(state);
+                    if (yearChanges) {
+                      // Mutating here can lead to some unexpected bugs
+                      // but we couldn't find any yet
+                      state.months[0].isFirstInYear = true;
+                      if (monthsToPrepend.length) {
+                        // Mutating item here is safe as it was just created
+                        monthsToPrepend[monthsToPrepend.length - 1].isLastInYear = true;
+                      }
+                    }
+                    return {
+                      months: monthsToPrepend.concat(state.months),
+                      scrollPosition: -CalendarUtils.getMonthsHeight(monthsToPrepend, _this.theme) };
+
+                  },
+                  function () {
+                    var targetPosition = _this.state.months[0].getHeight(_this.theme);
+                    _this.scrollTo(targetPosition, onEnd);
+                  });
+
+                }
+
+                // If scrolling downwards, append maximum maxMonthsToAdd months
+                // and scroll to the last but one month
+                if (diffInMonths < 0) {
+                  monthsToAppendCount = Math.min(Math.abs(diffInMonths), maxMonthsToAdd);
+                  monthsToAppend = Array.from({ length: monthsToAppendCount }, function (_, index) {
+                    return _MonthViewModel.MonthViewModel.create(month + index - monthsToAppendCount + 2, year);
+                  });
+                  _this.setState(
+                  function (state) {
+                    if (isYearChanges(state)) {
+                      // Mutating here can lead to some unexpected bugs
+                      // but we couldn't find any yet
+                      state.months[state.months.length - 1].isLastInYear = true;
+                      // Mutating item here is safe as it was just created
+                      if (monthsToAppend[0]) {
+                        monthsToAppend[0].isFirstInYear = true;
+                      }
+                    }
+                    return { months: state.months.concat(monthsToAppend) };
+                  },
+                  function () {
+                    var targetPosition = -1 * CalendarUtils.getMonthsHeight(_this.state.months.slice(1, -2), _this.theme);
+                    _this.scrollTo(targetPosition, onEnd);
+                  });
+
+                }case 22:case "end":return _context.stop();}}}, _callee);}));return function (_x, _x2) {return _ref.apply(this, arguments);};}();_this.
+
+
+    handleMonthChange = function (visibleMonths) {
+      var currentMonth = visibleMonths[0];
+      var changeInfo = {
+        month: CalendarUtils.getMonthInHumanFormat(currentMonth.month),
+        year: currentMonth.year };
+
+
+      _this.props.onMonthChange == null ? void 0 : _this.props.onMonthChange(changeInfo);
+    };_this.
+
+    getViewModel = function (item) {return item[1];};_this.
+
+    renderMain = function () {
+      var monthsForRender = _this.getVisibleMonths(_this.state);
+      var wrapperStyle = { height: (0, _config.themeConfig)(_this.theme).WRAPPER_HEIGHT };
+
+      var props = _this.getProps();
+
+      var context = {
+        value: _this.getDateInNativeFormat(props.value),
+        minDate: _this.getDateInNativeFormat(props.minDate),
+        maxDate: _this.getDateInNativeFormat(props.maxDate),
+        isHoliday: props.isHoliday,
+        renderDay: props.renderDay,
+        today: CalendarUtils.getTodayDate(),
+        onDateClick: _this.handleDateClick };
+
+
+      return /*#__PURE__*/(
+        _react.default.createElement(_CommonWrapper.CommonWrapper, (0, _extends2.default)({ rootNodeRef: _this.setRootNode }, props), /*#__PURE__*/
+        _react.default.createElement("div", { ref: _this.refRoot, "data-tid": CalendarDataTids.root, className: (0, _Emotion.cx)(_Calendar.styles.root(_this.theme)) }, /*#__PURE__*/
+        _react.default.createElement("div", { style: wrapperStyle, className: _Calendar.styles.wrapper() }, /*#__PURE__*/
+        _react.default.createElement(_CalendarContext.CalendarContext.Provider, { value: context },
+        monthsForRender.map(_this.renderMonth, (0, _assertThisInitialized2.default)(_this)))), /*#__PURE__*/
+
+
+        _react.default.createElement("div", { className: _Calendar.styles.separator(_this.theme) }))));
+
+
+
+    };_this.
+
+    refRoot = function (element) {
+      if (!_this.root && element) {
+        if (_client.isMobile) {
+          element.addEventListener('touchstart', _this.handleTouchStart);
+          element.addEventListener('touchmove', _this.throttledHandleTouchMove);
+        } else {
+          element.addEventListener('wheel', _this.handleWheel, { passive: false });
+        }
+      }
+      if (_this.root && !element) {
+        if (_client.isMobile) {
+          _this.root.removeEventListener('touchstart', _this.handleTouchStart);
+          _this.root.removeEventListener('touchmove', _this.throttledHandleTouchMove);
+        } else {
+          _this.root.removeEventListener('wheel', _this.handleWheel);
+        }
+      }
+      _this.root = element;
+    };_this.
+
+
+
+
+
+
+
+
+
+
+
+
+    handleDateClick = function (dateShape) {
+      var value = _InternalDateTransformer.InternalDateTransformer.dateToHumanString(dateShape);
+
+      _this.props.onValueChange == null ? void 0 : _this.props.onValueChange(value);
+    };_this.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    handleMonthYearChange = function (month, year) {
+      _this.scrollToMonth(month, year);
+    };_this.
+
+    executeAnimations = function (pixelY) {
+      _this.setState(function (_ref2) {var months = _ref2.months,scrollPosition = _ref2.scrollPosition;
+        var targetPosition = CalendarUtils.calculateScrollPosition(
+        months,
+        scrollPosition,
+        pixelY,
+        _this.theme).
+        scrollPosition;
+        return { scrollTarget: targetPosition };
+      }, _this.handleWheelEnd);
+
+      _this.animation.animate(pixelY, function (deltaY) {
+        // FIXME: Typescript not resolving setState cb type
+        _this.setState(CalendarUtils.applyDelta(deltaY, _this.theme));
+      });
+
+      CalendarScrollEvents.emit();
+    };_this.
+
+    handleTouchStart = function (event) {
+      if (!(0, _isInstanceOf.isInstanceOf)(event, _globalObject.globalObject.TouchEvent)) {
+        return;
+      }
+
+      var clientY = event.targetTouches[0].clientY;
+      _this.touchStartY = clientY;
+    };_this.
+
+    handleTouchMove = function (event) {
+      if (!(0, _isInstanceOf.isInstanceOf)(event, _globalObject.globalObject.TouchEvent)) {
+        return;
+      }
+
+      var clientY = event.changedTouches[0].clientY;
+
+      var deltaY = (_this.touchStartY || 0) - clientY;
+      _this.touchStartY = clientY;
+
+      _this.executeAnimations(deltaY);
+    };_this.
+
+    throttledHandleTouchMove = (0, _lodash.default)(_this.handleTouchMove, 10);_this.
+
+    handleWheel = function (event) {
+      if (!(0, _isInstanceOf.isInstanceOf)(event, _globalObject.globalObject.WheelEvent)) {
+        return;
+      }
+      event.preventDefault();
+      var _normalizeWheel = (0, _normalizeWheel2.default)(event),pixelY = _normalizeWheel.pixelY;
+
+      _this.executeAnimations(pixelY);
+    };_this.
+
+    handleWheelEnd = function () {
+      if (_this.wheelEndTimeout) {
+        _globalObject.globalObject.clearTimeout(_this.wheelEndTimeout);
+      }
+      _this.wheelEndTimeout = _globalObject.globalObject.setTimeout(_this.scrollToNearestWeek, 300);
+    };_this.
+    scrollToNearestWeek = function () {
+      var _this$state = _this.state,scrollTarget = _this$state.scrollTarget,scrollDirection = _this$state.scrollDirection;
+
+      var thresholdHeight = (0, _config.themeConfig)(_this.theme).MONTH_TITLE_OFFSET_HEIGHT + (0, _config.themeConfig)(_this.theme).DAY_HEIGHT;
+
+      if (scrollTarget < thresholdHeight) {
+        var targetPosition = 0;
+        if (scrollDirection < 0) {
+          targetPosition = thresholdHeight;
+        }
+
+        _this.setState({ scrollTarget: targetPosition }, function () {
+          var amount = scrollTarget - targetPosition;
+          _this.animation.animate(amount, function (deltaY) {
+            // FIXME: Typescript not resolving setState cb type
+            _this.setState(CalendarUtils.applyDelta(deltaY, _this.theme));
+          });
+        });
+      }
+    };_this.
+
+    scrollTo = function (pos, onEnd) {
+      var scrollAmmount = pos - _this.state.scrollPosition;
+      return _this.scrollAmount(scrollAmmount, onEnd);
+    };_this.
+
+    scrollAmount = function (scrollAmmount, onEnd) {
+      return _this.animation.animate(
+      scrollAmmount,
+      function (deltaY) {
+        _this.setState(function (_ref3) {var scrollPosition = _ref3.scrollPosition;return {
+            scrollPosition: scrollPosition + deltaY };});
+
+      },
+      onEnd);
+
+    };var _this$getProps = _this.getProps(),_minDate = _this$getProps.minDate,_maxDate = _this$getProps.maxDate,_value = _this$getProps.value;var minDateShape = _this.getDateInNativeFormat(_minDate);var maxDateShape = _this.getDateInNativeFormat(_maxDate);var _dateShape = _this.getDateInNativeFormat(_value);var today = CalendarUtils.getTodayDate();var initialDate = CalendarUtils.getInitialDate({ today: today, date: _dateShape, minDate: minDateShape, maxDate: maxDateShape });var initialMonth = _this.props.initialMonth ? CalendarUtils.getMonthInNativeFormat(_this.props.initialMonth) : initialDate.month;var initialYear = (_this$props$initialYe = _this.props.initialYear) != null ? _this$props$initialYe : initialDate.year;_this.state = { scrollPosition: 0, months: CalendarUtils.getMonths(initialMonth, initialYear), scrollDirection: 1, scrollTarget: 0 };return _this;}var _proto = Calendar.prototype;_proto.componentDidUpdate = function componentDidUpdate(prevProps, prevState) {var _this$props = this.props,value = _this$props.value,onMonthChange = _this$props.onMonthChange;if (value && !(0, _shallowequal.default)(value, prevProps.value)) {var _date = new _InternalDate.InternalDate().parseValue(value).getComponentsLikeNumber();this.scrollToMonth(_date.month - 1, _date.year);}if (onMonthChange) {var visibleMonthsModels = this.getVisibleMonths(this.state).map(this.getViewModel);var prevFirstVisibleMonthModels = this.getVisibleMonths(prevState).map(this.getViewModel);var currentMonth = visibleMonthsModels[0].month;var prevCurrentMonth = prevFirstVisibleMonthModels[0].month;if (currentMonth !== prevCurrentMonth) {this.handleMonthChange(visibleMonthsModels);}}};_proto.componentWillUnmount = function componentWillUnmount() {if (this.animation.inProgress()) {this.animation.cancel();}};_proto.render = function render() {var _this2 = this;return /*#__PURE__*/_react.default.createElement(_ThemeContext.ThemeContext.Consumer, null, function (theme) {_this2.theme = theme;return _this2.renderMain();});} /**
+   * Прокручивает календарь до переданной даты
+   * @public
+   */;_proto.renderMonth = function renderMonth(_ref4) {var top = _ref4[0],month = _ref4[1];return /*#__PURE__*/_react.default.createElement(_Month.Month, { key: month.month + '-' + month.year, top: top, month: month, onMonthYearChange: this.handleMonthYearChange });};_proto.getDateInNativeFormat = function getDateInNativeFormat(date) {return new _InternalDate.InternalDate().parseValue(date).toNativeFormat();};_proto.getMonthPositions = function getMonthPositions(months, scrollPosition) {var positions = [scrollPosition - months[0].getHeight(this.theme)];for (var i = 1; i < months.length; i++) {var position = positions[i - 1] + months[i - 1].getHeight(this.theme);positions.push(position);}return positions;};_proto.getVisibleMonths = function getVisibleMonths(state) {var _this3 = this;var months = state.months,scrollPosition = state.scrollPosition;var positions = this.getMonthPositions(months, scrollPosition);return months.map(function (x, i) {return [positions[i], x];}).filter(function (_ref5) {var top = _ref5[0],month = _ref5[1];return CalendarUtils.isMonthVisible(top, month, _this3.theme);});};return Calendar;}(_react.default.Component), _class2.__KONTUR_REACT_UI__ = 'Calendar', _class2.displayName = 'Calendar', _class2.Day = _CalendarDay.CalendarDay, _class2.defaultProps = { minDate: _class2.formatDate(_constants.MIN_DATE, _constants.MIN_MONTH, _constants.MIN_YEAR), maxDate: _class2.formatDate(_constants.MAX_DATE, _constants.MAX_MONTH, _constants.MAX_YEAR), isHoliday: function isHoliday(_day, isWeekend) {return isWeekend;} }, _temp)) || _class;exports.Calendar = Calendar;