@alfalab/core-components 45.9.0-beta.0 → 45.9.0-beta.2

package/calendar/cssm/useCalendar.js

@@ -1,62 +1,61 @@
-import { useState, useRef, useMemo, useCallback } from 'react';
-import mergeRefs from 'react-merge-refs';
-import addMonths from 'date-fns/addMonths';
-import addYears from 'date-fns/addYears';
-import isSameDay from 'date-fns/isSameDay';
-import isSameMonth from 'date-fns/isSameMonth';
-import isSameYear from 'date-fns/isSameYear';
-import setYear from 'date-fns/setYear';
-import startOfMonth from 'date-fns/startOfMonth';
-import subYears from 'date-fns/subYears';
-import { dateArrayToHashTable, addonArrayToHashTable, generateWeeks, generateMonths, generateYears, limitDate, simulateTab, modifyDateByShift, MONTHS_IN_YEAR } from './utils.js';
-import 'date-fns/addDays';
-import 'date-fns/eachDayOfInterval';
-import 'date-fns/eachMonthOfInterval';
-import 'date-fns/eachYearOfInterval';
-import 'date-fns/endOfDay';
-import 'date-fns/endOfWeek';
-import 'date-fns/endOfYear';
-import 'date-fns/format';
-import 'date-fns/isAfter';
-import 'date-fns/isBefore';
-import 'date-fns/lastDayOfMonth';
-import 'date-fns/max';
-import 'date-fns/min';
-import 'date-fns/parse';
-import 'date-fns/startOfDay';
-import 'date-fns/startOfWeek';
-import 'date-fns/startOfYear';
-import 'date-fns/subDays';
-import 'date-fns/subMonths';
-import '../../shared/cssm';
+Object.defineProperty(exports, '__esModule', { value: true });
 
-function useCalendar({ defaultMonth, month, minDate, view = 'days', maxDate, selected, events, offDays, holidays, dayAddons, onMonthChange, onChange, }) {
-    const [monthState, setMonthState] = useState(defaultMonth);
-    const [highlighted, setHighlighted] = useState();
-    const uncontrolled = month === undefined;
-    const activeMonth = uncontrolled ? monthState : month;
-    const dateRefs = useRef([]);
-    const rootRef = useRef(null);
-    const minMonth = useMemo(() => minDate && startOfMonth(minDate), [minDate]);
-    const maxMonth = useMemo(() => maxDate && startOfMonth(maxDate), [maxDate]);
-    const canSetPrevMonth = minMonth ? activeMonth > minMonth : true;
-    const canSetNextMonth = maxMonth ? activeMonth < maxMonth : true;
-    const eventsMap = useMemo(() => dateArrayToHashTable(events || []), [events]);
-    const offDaysMap = useMemo(() => dateArrayToHashTable(offDays || []), [offDays]);
-    const holidaysMap = useMemo(() => dateArrayToHashTable(holidays || []), [holidays]);
-    const dayAddonsMap = useMemo(() => addonArrayToHashTable(dayAddons || []), [dayAddons]);
-    const weeks = useMemo(() => generateWeeks(activeMonth, {
-        minDate,
-        maxDate,
-        selected,
-        eventsMap,
-        offDaysMap,
-        holidaysMap,
-        dayAddonsMap,
-    }), [maxDate, minDate, selected, dayAddonsMap, activeMonth, eventsMap, offDaysMap, holidaysMap]);
-    const months = useMemo(() => generateMonths(activeMonth, { minMonth, maxMonth }), [minMonth, maxMonth, activeMonth]);
-    const years = useMemo(() => generateYears(minDate || subYears(new Date(), 100), maxDate || addYears(new Date(), 1)), [minDate, maxDate]);
-    const setMonth = useCallback((newMonth) => {
+var React = require('react');
+var mergeRefs = require('react-merge-refs');
+var addMonths = require('date-fns/addMonths');
+var addYears = require('date-fns/addYears');
+var isSameDay = require('date-fns/isSameDay');
+var isSameMonth = require('date-fns/isSameMonth');
+var isSameYear = require('date-fns/isSameYear');
+var setYear = require('date-fns/setYear');
+var startOfMonth = require('date-fns/startOfMonth');
+var subYears = require('date-fns/subYears');
+var utils = require('./utils.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var mergeRefs__default = /*#__PURE__*/_interopDefaultCompat(mergeRefs);
+var addMonths__default = /*#__PURE__*/_interopDefaultCompat(addMonths);
+var addYears__default = /*#__PURE__*/_interopDefaultCompat(addYears);
+var isSameDay__default = /*#__PURE__*/_interopDefaultCompat(isSameDay);
+var isSameMonth__default = /*#__PURE__*/_interopDefaultCompat(isSameMonth);
+var isSameYear__default = /*#__PURE__*/_interopDefaultCompat(isSameYear);
+var setYear__default = /*#__PURE__*/_interopDefaultCompat(setYear);
+var startOfMonth__default = /*#__PURE__*/_interopDefaultCompat(startOfMonth);
+var subYears__default = /*#__PURE__*/_interopDefaultCompat(subYears);
+
+function useCalendar(_a) {
+    var defaultMonth = _a.defaultMonth, month = _a.month, minDate = _a.minDate, _b = _a.view, view = _b === void 0 ? 'days' : _b, maxDate = _a.maxDate, selected = _a.selected, events = _a.events, offDays = _a.offDays, holidays = _a.holidays, dayAddons = _a.dayAddons, onMonthChange = _a.onMonthChange, onChange = _a.onChange;
+    var _c = React.useState(defaultMonth), monthState = _c[0], setMonthState = _c[1];
+    var _d = React.useState(), highlighted = _d[0], setHighlighted = _d[1];
+    var uncontrolled = month === undefined;
+    var activeMonth = uncontrolled ? monthState : month;
+    var dateRefs = React.useRef([]);
+    var rootRef = React.useRef(null);
+    var minMonth = React.useMemo(function () { return minDate && startOfMonth__default.default(minDate); }, [minDate]);
+    var maxMonth = React.useMemo(function () { return maxDate && startOfMonth__default.default(maxDate); }, [maxDate]);
+    var canSetPrevMonth = minMonth ? activeMonth > minMonth : true;
+    var canSetNextMonth = maxMonth ? activeMonth < maxMonth : true;
+    var eventsMap = React.useMemo(function () { return utils.dateArrayToHashTable(events || []); }, [events]);
+    var offDaysMap = React.useMemo(function () { return utils.dateArrayToHashTable(offDays || []); }, [offDays]);
+    var holidaysMap = React.useMemo(function () { return utils.dateArrayToHashTable(holidays || []); }, [holidays]);
+    var dayAddonsMap = React.useMemo(function () { return utils.addonArrayToHashTable(dayAddons || []); }, [dayAddons]);
+    var weeks = React.useMemo(function () {
+        return utils.generateWeeks(activeMonth, {
+            minDate: minDate,
+            maxDate: maxDate,
+            selected: selected,
+            eventsMap: eventsMap,
+            offDaysMap: offDaysMap,
+            holidaysMap: holidaysMap,
+            dayAddonsMap: dayAddonsMap,
+        });
+    }, [maxDate, minDate, selected, dayAddonsMap, activeMonth, eventsMap, offDaysMap, holidaysMap]);
+    var months = React.useMemo(function () { return utils.generateMonths(activeMonth, { minMonth: minMonth, maxMonth: maxMonth }); }, [minMonth, maxMonth, activeMonth]);
+    var years = React.useMemo(function () {
+        return utils.generateYears(minDate || subYears__default.default(new Date(), 100), maxDate || addYears__default.default(new Date(), 1));
+    }, [minDate, maxDate]);
+    var setMonth = React.useCallback(function (newMonth) {
         if (uncontrolled) {
             setMonthState(newMonth);
         }
@@ -64,42 +63,42 @@ function useCalendar({ defaultMonth, month, minDate, view = 'days', maxDate, sel
             onMonthChange(newMonth.getTime());
         }
     }, [onMonthChange, uncontrolled]);
-    const setMonthByStep = useCallback((step) => {
-        setMonth(limitDate(addMonths(activeMonth, step), minMonth, maxMonth));
+    var setMonthByStep = React.useCallback(function (step) {
+        setMonth(utils.limitDate(addMonths__default.default(activeMonth, step), minMonth, maxMonth));
     }, [setMonth, activeMonth, minMonth, maxMonth]);
-    const setMonthByDate = useCallback((newMonth) => {
-        setMonth(limitDate(newMonth, minMonth, maxMonth));
+    var setMonthByDate = React.useCallback(function (newMonth) {
+        setMonth(utils.limitDate(newMonth, minMonth, maxMonth));
     }, [maxMonth, minMonth, setMonth]);
-    const setNextMonth = useCallback(() => {
+    var setNextMonth = React.useCallback(function () {
         setMonthByStep(1);
     }, [setMonthByStep]);
-    const setPrevMonth = useCallback(() => {
+    var setPrevMonth = React.useCallback(function () {
         setMonthByStep(-1);
     }, [setMonthByStep]);
-    const getFocusedDate = useCallback(() => dateRefs.current.find((node) => document.activeElement === node), []);
-    const getFocusableDate = useCallback(() => dateRefs.current.find((node) => node && node.tabIndex === 0), []);
-    const focusDate = useCallback((node) => {
+    var getFocusedDate = React.useCallback(function () { return dateRefs.current.find(function (node) { return document.activeElement === node; }); }, []);
+    var getFocusableDate = React.useCallback(function () { return dateRefs.current.find(function (node) { return node && node.tabIndex === 0; }); }, []);
+    var focusDate = React.useCallback(function (node) {
         if (node) {
-            simulateTab(node);
+            utils.simulateTab(node);
             node.focus();
         }
     }, []);
-    const focusFirstAvailableDate = useCallback(() => focusDate(getFocusableDate()), [focusDate, getFocusableDate]);
-    const focusDay = useCallback((shift) => {
-        const focusedNode = getFocusedDate();
+    var focusFirstAvailableDate = React.useCallback(function () { return focusDate(getFocusableDate()); }, [focusDate, getFocusableDate]);
+    var focusDay = React.useCallback(function (shift) {
+        var focusedNode = getFocusedDate();
         if (focusedNode && focusedNode.dataset.date) {
-            const focusedDate = new Date(+focusedNode.dataset.date);
-            const newDate = modifyDateByShift(shift, focusedDate, minDate, maxDate, offDaysMap);
-            let monthChanged = false;
-            if (newDate < focusedDate && newDate.getMonth() !== focusedDate.getMonth()) {
+            var focusedDate = new Date(+focusedNode.dataset.date);
+            var newDate_1 = utils.modifyDateByShift(shift, focusedDate, minDate, maxDate, offDaysMap);
+            var monthChanged = false;
+            if (newDate_1 < focusedDate && newDate_1.getMonth() !== focusedDate.getMonth()) {
                 setPrevMonth();
                 monthChanged = true;
             }
-            if (newDate > focusedDate && newDate.getMonth() !== focusedDate.getMonth()) {
+            if (newDate_1 > focusedDate && newDate_1.getMonth() !== focusedDate.getMonth()) {
                 setNextMonth();
                 monthChanged = true;
             }
-            const effect = () => focusDate(dateRefs.current[newDate.getDate() - 1]);
+            var effect = function () { return focusDate(dateRefs.current[newDate_1.getDate() - 1]); };
             if (monthChanged) {
                 setTimeout(effect, 0);
             }
@@ -120,12 +119,12 @@ function useCalendar({ defaultMonth, month, minDate, view = 'days', maxDate, sel
         setNextMonth,
         setPrevMonth,
     ]);
-    const focusMonth = useCallback((offset) => {
-        const focusedNode = getFocusedDate();
+    var focusMonth = React.useCallback(function (offset) {
+        var focusedNode = getFocusedDate();
         if (focusedNode && focusedNode.dataset.date) {
-            const focusedMonth = new Date(+focusedNode.dataset.date).getMonth();
-            const newFocusedMonth = focusedMonth + offset;
-            if (newFocusedMonth >= 0 && newFocusedMonth < MONTHS_IN_YEAR) {
+            var focusedMonth = new Date(+focusedNode.dataset.date).getMonth();
+            var newFocusedMonth = focusedMonth + offset;
+            if (newFocusedMonth >= 0 && newFocusedMonth < utils.MONTHS_IN_YEAR) {
                 focusDate(dateRefs.current[newFocusedMonth]);
             }
         }
@@ -133,12 +132,12 @@ function useCalendar({ defaultMonth, month, minDate, view = 'days', maxDate, sel
             focusFirstAvailableDate();
         }
     }, [focusDate, focusFirstAvailableDate, getFocusedDate]);
-    const focusYear = useCallback((offset) => {
-        const focusedNode = getFocusedDate();
+    var focusYear = React.useCallback(function (offset) {
+        var focusedNode = getFocusedDate();
         if (focusedNode && focusedNode.dataset.date) {
-            const focusedYear = new Date(+focusedNode.dataset.date).getFullYear();
-            const newFocusedYear = focusedYear + offset;
-            const currentYear = new Date().getFullYear();
+            var focusedYear = new Date(+focusedNode.dataset.date).getFullYear();
+            var newFocusedYear = focusedYear + offset;
+            var currentYear = new Date().getFullYear();
             if (newFocusedYear <= currentYear && newFocusedYear > currentYear - years.length) {
                 focusDate(dateRefs.current[newFocusedYear]);
             }
@@ -147,8 +146,8 @@ function useCalendar({ defaultMonth, month, minDate, view = 'days', maxDate, sel
             focusFirstAvailableDate();
         }
     }, [focusDate, focusFirstAvailableDate, getFocusedDate, years.length]);
-    const handleMonthClick = useCallback((event) => {
-        const { date } = event.currentTarget.dataset;
+    var handleMonthClick = React.useCallback(function (event) {
+        var date = event.currentTarget.dataset.date;
         if (date) {
             setMonthByDate(new Date(+date));
         }
@@ -160,72 +159,72 @@ function useCalendar({ defaultMonth, month, minDate, view = 'days', maxDate, sel
             rootRef.current.focus();
         }
     }, [setMonthByDate]);
-    const handleYearClick = useCallback((event) => {
-        const { date } = event.currentTarget.dataset;
+    var handleYearClick = React.useCallback(function (event) {
+        var date = event.currentTarget.dataset.date;
         if (date) {
-            setMonthByDate(setYear(activeMonth, new Date(+date).getFullYear()));
+            setMonthByDate(setYear__default.default(activeMonth, new Date(+date).getFullYear()));
         }
         if (rootRef.current && rootRef.current.contains(document.activeElement)) {
             rootRef.current.focus();
         }
     }, [activeMonth, setMonthByDate]);
-    const handleDateRef = useCallback((node, index) => {
+    var handleDateRef = React.useCallback(function (node, index) {
         dateRefs.current[index] = node;
     }, []);
-    const handleDayMouseEnter = useCallback((event) => {
-        const { date } = event.currentTarget.dataset;
+    var handleDayMouseEnter = React.useCallback(function (event) {
+        var date = event.currentTarget.dataset.date;
         setHighlighted(date ? +date : undefined);
     }, []);
-    const handleDayMouseLeave = useCallback(() => {
+    var handleDayMouseLeave = React.useCallback(function () {
         setHighlighted(undefined);
     }, []);
-    const handleDayClick = (event) => {
-        const { date } = event.currentTarget.dataset;
+    var handleDayClick = function (event) {
+        var date = event.currentTarget.dataset.date;
         if (date && onChange) {
             onChange(+date);
         }
         handleDayMouseLeave();
     };
-    const daysControls = useMemo(() => ({
-        ArrowLeft: () => focusDay('prev'),
-        ArrowRight: () => focusDay('next'),
-        ArrowUp: () => focusDay('prevWeek'),
-        ArrowDown: () => focusDay('nextWeek'),
-        End: () => focusDay('endOfWeek'),
-        Home: () => focusDay('startOfWeek'),
-        PageUp: () => focusDay('prevMonth'),
-        PageDown: () => focusDay('nextMonth'),
-    }), [focusDay]);
-    const monthControls = useMemo(() => ({
-        ArrowLeft: () => focusMonth(-1),
-        ArrowRight: () => focusMonth(1),
-        ArrowUp: () => focusMonth(-3),
-        ArrowDown: () => focusMonth(3),
-    }), [focusMonth]);
-    const yearsControls = useMemo(() => ({
-        ArrowLeft: () => focusYear(1),
-        ArrowRight: () => focusYear(-1),
-        ArrowUp: () => focusYear(3),
-        ArrowDown: () => focusYear(-3),
-    }), [focusYear]);
-    const controlsByView = {
+    var daysControls = React.useMemo(function () { return ({
+        ArrowLeft: function () { return focusDay('prev'); },
+        ArrowRight: function () { return focusDay('next'); },
+        ArrowUp: function () { return focusDay('prevWeek'); },
+        ArrowDown: function () { return focusDay('nextWeek'); },
+        End: function () { return focusDay('endOfWeek'); },
+        Home: function () { return focusDay('startOfWeek'); },
+        PageUp: function () { return focusDay('prevMonth'); },
+        PageDown: function () { return focusDay('nextMonth'); },
+    }); }, [focusDay]);
+    var monthControls = React.useMemo(function () { return ({
+        ArrowLeft: function () { return focusMonth(-1); },
+        ArrowRight: function () { return focusMonth(1); },
+        ArrowUp: function () { return focusMonth(-3); },
+        ArrowDown: function () { return focusMonth(3); },
+    }); }, [focusMonth]);
+    var yearsControls = React.useMemo(function () { return ({
+        ArrowLeft: function () { return focusYear(1); },
+        ArrowRight: function () { return focusYear(-1); },
+        ArrowUp: function () { return focusYear(3); },
+        ArrowDown: function () { return focusYear(-3); },
+    }); }, [focusYear]);
+    var controlsByView = {
         days: daysControls,
         months: monthControls,
         years: yearsControls,
     };
-    const handleKeyDown = (event) => {
-        const controls = controlsByView[view];
+    var handleKeyDown = function (event) {
+        var controls = controlsByView[view];
         if (event.key in controls) {
             controls[event.key]();
             event.preventDefault();
         }
     };
-    let focusableDayIsSet = false;
-    const getDayProps = (day) => {
-        const daySelected = selected && isSameDay(selected, day.date);
-        let canFocus = daySelected;
+    var focusableDayIsSet = false;
+    var getDayProps = function (day) {
+        var daySelected = selected && isSameDay__default.default(selected, day.date);
+        var canFocus = daySelected;
         // Если день не выбран — фокус должен начинаться с первого доступного дня месяца
-        if ((!selected || !isSameMonth(selected, activeMonth)) &&
+        if ((!selected || !isSameMonth__default.default(selected, activeMonth)) &&
             !focusableDayIsSet &&
             !day.disabled) {
             // eslint-disable-next-line react-hooks/exhaustive-deps
@@ -235,7 +234,7 @@ function useCalendar({ defaultMonth, month, minDate, view = 'days', maxDate, sel
         return {
             'data-date': day.date.getTime(),
             'aria-selected': daySelected,
-            ref: (node) => {
+            ref: function (node) {
                 handleDateRef(node, day.date.getDate() - 1);
             },
             tabIndex: canFocus ? 0 : -1,
@@ -244,12 +243,12 @@ function useCalendar({ defaultMonth, month, minDate, view = 'days', maxDate, sel
             onClick: handleDayClick,
         };
     };
-    const getMonthProps = (currMonth) => {
-        const monthselected = isSameMonth(activeMonth, currMonth.date);
+    var getMonthProps = function (currMonth) {
+        var monthselected = isSameMonth__default.default(activeMonth, currMonth.date);
         return {
             'data-date': currMonth.date.getTime(),
             'aria-selected': monthselected,
-            ref: (node) => {
+            ref: function (node) {
                 handleDateRef(node, currMonth.date.getMonth());
             },
             tabIndex: monthselected ? 0 : -1,
@@ -257,39 +256,42 @@ function useCalendar({ defaultMonth, month, minDate, view = 'days', maxDate, sel
             onClick: handleMonthClick,
         };
     };
-    const getYearProps = (year) => {
-        const yearSelected = isSameYear(activeMonth, year);
+    var getYearProps = function (year) {
+        var yearSelected = isSameYear__default.default(activeMonth, year);
         return {
             'data-date': year.getTime(),
             'aria-selected': yearSelected,
-            ref: (node) => {
+            ref: function (node) {
                 handleDateRef(node, year.getFullYear());
             },
             tabIndex: yearSelected ? 0 : -1,
             onClick: handleYearClick,
         };
     };
-    const getRootProps = ({ ref = null }) => ({
-        onKeyDown: handleKeyDown,
-        ref: mergeRefs([ref, rootRef]),
-        tabIndex: -1,
-    });
+    var getRootProps = function (_a) {
+        var _b = _a.ref, ref = _b === void 0 ? null : _b;
+        return ({
+            onKeyDown: handleKeyDown,
+            ref: mergeRefs__default.default([ref, rootRef]),
+            tabIndex: -1,
+        });
+    };
     return {
-        activeMonth,
-        weeks,
-        months,
-        years,
-        canSetPrevMonth,
-        canSetNextMonth,
-        highlighted,
-        setPrevMonth,
-        setNextMonth,
-        setMonthByDate,
-        getDayProps,
-        getMonthProps,
-        getYearProps,
-        getRootProps,
+        activeMonth: activeMonth,
+        weeks: weeks,
+        months: months,
+        years: years,
+        canSetPrevMonth: canSetPrevMonth,
+        canSetNextMonth: canSetNextMonth,
+        highlighted: highlighted,
+        setPrevMonth: setPrevMonth,
+        setNextMonth: setNextMonth,
+        setMonthByDate: setMonthByDate,
+        getDayProps: getDayProps,
+        getMonthProps: getMonthProps,
+        getYearProps: getYearProps,
+        getRootProps: getRootProps,
     };
 }
 
-export { useCalendar };
+exports.useCalendar = useCalendar;

package/calendar/cssm/usePeriod.js

@@ -1,21 +1,28 @@
-import { useState, useCallback } from 'react';
-import differenceInDays from 'date-fns/differenceInDays';
-import { useDidUpdateEffect } from '@alfalab/hooks';
+Object.defineProperty(exports, '__esModule', { value: true });
 
-function usePeriod({ onPeriodChange, initialSelectedFrom, initialSelectedTo, } = {}) {
-    const [selectedFrom, setSelectedFrom] = useState(initialSelectedFrom);
-    const [selectedTo, setSelectedTo] = useState(initialSelectedTo);
-    const resetPeriod = useCallback(() => {
+var React = require('react');
+var differenceInDays = require('date-fns/differenceInDays');
+var hooks = require('@alfalab/hooks');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var differenceInDays__default = /*#__PURE__*/_interopDefaultCompat(differenceInDays);
+
+function usePeriod(_a) {
+    var _b = _a === void 0 ? {} : _a, onPeriodChange = _b.onPeriodChange, initialSelectedFrom = _b.initialSelectedFrom, initialSelectedTo = _b.initialSelectedTo;
+    var _c = React.useState(initialSelectedFrom), selectedFrom = _c[0], setSelectedFrom = _c[1];
+    var _d = React.useState(initialSelectedTo), selectedTo = _d[0], setSelectedTo = _d[1];
+    var resetPeriod = React.useCallback(function () {
         setSelectedFrom(undefined);
         setSelectedTo(undefined);
     }, []);
-    const setStart = useCallback((date) => {
+    var setStart = React.useCallback(function (date) {
         setSelectedFrom(date);
     }, []);
-    const setEnd = useCallback((date) => {
+    var setEnd = React.useCallback(function (date) {
         setSelectedTo(date);
     }, []);
-    const updatePeriod = useCallback((date) => {
+    var updatePeriod = React.useCallback(function (date) {
         // сбрасываем выделение
         if (date === undefined || (date === selectedTo && date === selectedFrom)) {
             resetPeriod();
@@ -64,43 +71,44 @@ function usePeriod({ onPeriodChange, initialSelectedFrom, initialSelectedTo, } =
             return;
         }
         // сдвигаем тот конец выделения, который ближе к выбранной дате
-        if (Math.abs(differenceInDays(date, selectedTo)) >
-            Math.abs(differenceInDays(date, selectedFrom))) {
+        if (Math.abs(differenceInDays__default.default(date, selectedTo)) >
+            Math.abs(differenceInDays__default.default(date, selectedFrom))) {
             setSelectedFrom(date);
         }
         else {
             setSelectedTo(date);
         }
     }, [resetPeriod, selectedFrom, selectedTo]);
-    useDidUpdateEffect(() => {
+    hooks.useDidUpdateEffect(function () {
         if (onPeriodChange) {
             onPeriodChange(selectedFrom, selectedTo);
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [selectedFrom, selectedTo]);
     return {
-        selectedFrom,
-        selectedTo,
-        setStart,
-        setEnd,
-        resetPeriod,
-        updatePeriod,
+        selectedFrom: selectedFrom,
+        selectedTo: selectedTo,
+        setStart: setStart,
+        setEnd: setEnd,
+        resetPeriod: resetPeriod,
+        updatePeriod: updatePeriod,
     };
 }
-function usePeriodWithReset({ onPeriodChange, initialSelectedFrom, initialSelectedTo, } = {}) {
-    const [selectedFrom, setSelectedFrom] = useState(initialSelectedFrom);
-    const [selectedTo, setSelectedTo] = useState(initialSelectedTo);
-    const resetPeriod = useCallback(() => {
+function usePeriodWithReset(_a) {
+    var _b = _a === void 0 ? {} : _a, onPeriodChange = _b.onPeriodChange, initialSelectedFrom = _b.initialSelectedFrom, initialSelectedTo = _b.initialSelectedTo;
+    var _c = React.useState(initialSelectedFrom), selectedFrom = _c[0], setSelectedFrom = _c[1];
+    var _d = React.useState(initialSelectedTo), selectedTo = _d[0], setSelectedTo = _d[1];
+    var resetPeriod = React.useCallback(function () {
         setSelectedFrom(undefined);
         setSelectedTo(undefined);
     }, []);
-    const setStart = useCallback((date) => {
+    var setStart = React.useCallback(function (date) {
         setSelectedFrom(date);
     }, []);
-    const setEnd = useCallback((date) => {
+    var setEnd = React.useCallback(function (date) {
         setSelectedTo(date);
     }, []);
-    const updatePeriod = useCallback((date) => {
+    var updatePeriod = React.useCallback(function (date) {
         // сбрасываем выделение
         if (date === undefined) {
             resetPeriod();
@@ -126,20 +134,21 @@ function usePeriodWithReset({ onPeriodChange, initialSelectedFrom, initialSelect
         setSelectedTo(undefined);
         setSelectedFrom(date);
     }, [resetPeriod, selectedFrom, selectedTo]);
-    useDidUpdateEffect(() => {
+    hooks.useDidUpdateEffect(function () {
         if (onPeriodChange) {
             onPeriodChange(selectedFrom, selectedTo);
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [selectedFrom, selectedTo]);
     return {
-        selectedFrom,
-        selectedTo,
-        setStart,
-        setEnd,
-        resetPeriod,
-        updatePeriod,
+        selectedFrom: selectedFrom,
+        selectedTo: selectedTo,
+        setStart: setStart,
+        setEnd: setEnd,
+        resetPeriod: resetPeriod,
+        updatePeriod: updatePeriod,
     };
 }
 
-export { usePeriod, usePeriodWithReset };
+exports.usePeriod = usePeriod;
+exports.usePeriodWithReset = usePeriodWithReset;