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

package/calendar/cssm/utils.js

@@ -1,34 +1,61 @@
-import addDays from 'date-fns/addDays';
-import addMonths from 'date-fns/addMonths';
-import eachDayOfInterval from 'date-fns/eachDayOfInterval';
-import eachMonthOfInterval from 'date-fns/eachMonthOfInterval';
-import eachYearOfInterval from 'date-fns/eachYearOfInterval';
-import endOfDay from 'date-fns/endOfDay';
-import endOfWeek from 'date-fns/endOfWeek';
-import endOfYear from 'date-fns/endOfYear';
-import format from 'date-fns/format';
-import isAfter from 'date-fns/isAfter';
-import isBefore from 'date-fns/isBefore';
-import isSameDay from 'date-fns/isSameDay';
-import lastDayOfMonth from 'date-fns/lastDayOfMonth';
-import max from 'date-fns/max';
-import min from 'date-fns/min';
-import parse from 'date-fns/parse';
-import startOfDay from 'date-fns/startOfDay';
-import startOfMonth from 'date-fns/startOfMonth';
-import startOfWeek from 'date-fns/startOfWeek';
-import startOfYear from 'date-fns/startOfYear';
-import subDays from 'date-fns/subDays';
-import subMonths from 'date-fns/subMonths';
-import { getDataTestId } from '../../shared/cssm';
+Object.defineProperty(exports, '__esModule', { value: true });
 
-const DAYS_IN_WEEK = 7;
-const MONTHS_IN_YEAR = 12;
-const SUNDAY_INDEX = 6;
-const DATE_FORMAT = 'dd.MM.yyyy';
-const NATIVE_DATE_FORMAT = 'yyyy-MM-dd';
-const WEEKDAYS = ['Пн', 'Вт', 'Ср', 'Чт', 'Пт', 'Сб', 'Вс'];
-const MONTHS = [
+var addDays = require('date-fns/addDays');
+var addMonths = require('date-fns/addMonths');
+var eachDayOfInterval = require('date-fns/eachDayOfInterval');
+var eachMonthOfInterval = require('date-fns/eachMonthOfInterval');
+var eachYearOfInterval = require('date-fns/eachYearOfInterval');
+var endOfDay = require('date-fns/endOfDay');
+var endOfWeek = require('date-fns/endOfWeek');
+var endOfYear = require('date-fns/endOfYear');
+var format = require('date-fns/format');
+var isAfter = require('date-fns/isAfter');
+var isBefore = require('date-fns/isBefore');
+var isSameDay = require('date-fns/isSameDay');
+var lastDayOfMonth = require('date-fns/lastDayOfMonth');
+var max = require('date-fns/max');
+var min = require('date-fns/min');
+var parse = require('date-fns/parse');
+var startOfDay = require('date-fns/startOfDay');
+var startOfMonth = require('date-fns/startOfMonth');
+var startOfWeek = require('date-fns/startOfWeek');
+var startOfYear = require('date-fns/startOfYear');
+var subDays = require('date-fns/subDays');
+var subMonths = require('date-fns/subMonths');
+var coreComponentsShared = require('../../shared/cssm');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var addDays__default = /*#__PURE__*/_interopDefaultCompat(addDays);
+var addMonths__default = /*#__PURE__*/_interopDefaultCompat(addMonths);
+var eachDayOfInterval__default = /*#__PURE__*/_interopDefaultCompat(eachDayOfInterval);
+var eachMonthOfInterval__default = /*#__PURE__*/_interopDefaultCompat(eachMonthOfInterval);
+var eachYearOfInterval__default = /*#__PURE__*/_interopDefaultCompat(eachYearOfInterval);
+var endOfDay__default = /*#__PURE__*/_interopDefaultCompat(endOfDay);
+var endOfWeek__default = /*#__PURE__*/_interopDefaultCompat(endOfWeek);
+var endOfYear__default = /*#__PURE__*/_interopDefaultCompat(endOfYear);
+var format__default = /*#__PURE__*/_interopDefaultCompat(format);
+var isAfter__default = /*#__PURE__*/_interopDefaultCompat(isAfter);
+var isBefore__default = /*#__PURE__*/_interopDefaultCompat(isBefore);
+var isSameDay__default = /*#__PURE__*/_interopDefaultCompat(isSameDay);
+var lastDayOfMonth__default = /*#__PURE__*/_interopDefaultCompat(lastDayOfMonth);
+var max__default = /*#__PURE__*/_interopDefaultCompat(max);
+var min__default = /*#__PURE__*/_interopDefaultCompat(min);
+var parse__default = /*#__PURE__*/_interopDefaultCompat(parse);
+var startOfDay__default = /*#__PURE__*/_interopDefaultCompat(startOfDay);
+var startOfMonth__default = /*#__PURE__*/_interopDefaultCompat(startOfMonth);
+var startOfWeek__default = /*#__PURE__*/_interopDefaultCompat(startOfWeek);
+var startOfYear__default = /*#__PURE__*/_interopDefaultCompat(startOfYear);
+var subDays__default = /*#__PURE__*/_interopDefaultCompat(subDays);
+var subMonths__default = /*#__PURE__*/_interopDefaultCompat(subMonths);
+
+var DAYS_IN_WEEK = 7;
+var MONTHS_IN_YEAR = 12;
+var SUNDAY_INDEX = 6;
+var DATE_FORMAT = 'dd.MM.yyyy';
+var NATIVE_DATE_FORMAT = 'yyyy-MM-dd';
+var WEEKDAYS = ['Пн', 'Вт', 'Ср', 'Чт', 'Пт', 'Сб', 'Вс'];
+var MONTHS = [
     'Январь',
     'Февраль',
     'Март',
@@ -46,22 +73,22 @@ const MONTHS = [
  * Возвращает «правильный» индекс дня недели, 0 - пн, 1 - вт и так далее.
  */
 function russianWeekDay(date) {
-    const sunday = 0;
-    const foreignWeekDayIndex = date.getDay();
+    var sunday = 0;
+    var foreignWeekDayIndex = date.getDay();
     return foreignWeekDayIndex === sunday ? DAYS_IN_WEEK - 1 : foreignWeekDayIndex - 1;
 }
 /**
  * Возвращает таблицу-календарь с заполненными датами для переданного месяца
  */
 function generateWeeks(month, options) {
-    const newWeek = () => Array(DAYS_IN_WEEK).fill(null);
-    const start = startOfMonth(month);
-    const end = lastDayOfMonth(start);
-    let week = newWeek();
-    return eachDayOfInterval({ start, end }).reduce((weeks, day) => {
-        const weekDay = russianWeekDay(day);
+    var newWeek = function () { return Array(DAYS_IN_WEEK).fill(null); };
+    var start = startOfMonth__default.default(month);
+    var end = lastDayOfMonth__default.default(start);
+    var week = newWeek();
+    return eachDayOfInterval__default.default({ start: start, end: end }).reduce(function (weeks, day) {
+        var weekDay = russianWeekDay(day);
         week[weekDay] = buildDay(day, options);
-        if (weekDay === SUNDAY_INDEX || isSameDay(day, end)) {
+        if (weekDay === SUNDAY_INDEX || isSameDay__default.default(day, end)) {
             weeks.push(week);
             week = newWeek();
         }
@@ -72,30 +99,32 @@ function generateWeeks(month, options) {
  * Возвращает массив с месяцами для переданного года
  */
 function generateMonths(year, options) {
-    return eachMonthOfInterval({ start: startOfYear(year), end: endOfYear(year) }).map((month) => buildMonth(month, options));
+    return eachMonthOfInterval__default.default({ start: startOfYear__default.default(year), end: endOfYear__default.default(year) }).map(function (month) {
+        return buildMonth(month, options);
+    });
 }
 /**
  * Возвращает массив лет от minYear до maxYear
  */
 function generateYears(minYear, maxYear) {
-    return eachYearOfInterval({
-        start: min([startOfYear(maxYear), startOfYear(minYear)]),
-        end: max([startOfYear(maxYear), startOfYear(minYear)]),
+    return eachYearOfInterval__default.default({
+        start: min__default.default([startOfYear__default.default(maxYear), startOfYear__default.default(minYear)]),
+        end: max__default.default([startOfYear__default.default(maxYear), startOfYear__default.default(minYear)]),
     }).reverse();
 }
 /**
  * Добавляет метаданные для переданного дня
  */
 function buildDay(day, options) {
-    const { minDate, maxDate, selected, eventsMap = {}, offDaysMap = {}, holidaysMap = {}, dayAddonsMap = {}, } = options;
-    const off = offDaysMap[day.getTime()];
-    const disabled = (minDate && isBefore(day, minDate)) || (maxDate && isAfter(day, maxDate));
+    var minDate = options.minDate, maxDate = options.maxDate, selected = options.selected, _a = options.eventsMap, eventsMap = _a === void 0 ? {} : _a, _b = options.offDaysMap, offDaysMap = _b === void 0 ? {} : _b, _c = options.holidaysMap, holidaysMap = _c === void 0 ? {} : _c, _d = options.dayAddonsMap, dayAddonsMap = _d === void 0 ? {} : _d;
+    var off = offDaysMap[day.getTime()];
+    var disabled = (minDate && isBefore__default.default(day, minDate)) || (maxDate && isAfter__default.default(day, maxDate));
     return {
         date: day,
         disabled: disabled || off,
         event: eventsMap[day.getTime()],
         holiday: holidaysMap[day.getTime()],
-        selected: selected && isSameDay(day, selected),
+        selected: selected && isSameDay__default.default(day, selected),
         dayAddon: dayAddonsMap[day.getTime()],
     };
 }
@@ -103,21 +132,21 @@ function buildDay(day, options) {
  * Добавляет метаданные для переданного месяца
  */
 function buildMonth(month, options) {
-    const { minMonth, maxMonth } = options;
+    var minMonth = options.minMonth, maxMonth = options.maxMonth;
     return {
         date: month,
-        disabled: (minMonth && isBefore(month, minMonth)) || (maxMonth && isAfter(month, maxMonth)),
+        disabled: (minMonth && isBefore__default.default(month, minMonth)) || (maxMonth && isAfter__default.default(month, maxMonth)),
     };
 }
 /**
  * Ограничивает дату на отрезке [minDate, maxDate]
  */
 function limitDate(date, minDate, maxDate) {
-    let limitedDate = date;
+    var limitedDate = date;
     if (minDate)
-        limitedDate = max([startOfDay(minDate), limitedDate]);
+        limitedDate = max__default.default([startOfDay__default.default(minDate), limitedDate]);
     if (maxDate)
-        limitedDate = min([endOfDay(maxDate), limitedDate]);
+        limitedDate = min__default.default([endOfDay__default.default(maxDate), limitedDate]);
     return new Date(limitedDate);
 }
 /**
@@ -136,14 +165,14 @@ function monthName(month) {
  * Превращает массив в объект, у которого ключи составляются из элементов массива
  */
 function dateArrayToHashTable(arr) {
-    return arr.reduce((acc, v) => {
-        acc[startOfDay(v).getTime()] = true;
+    return arr.reduce(function (acc, v) {
+        acc[startOfDay__default.default(v).getTime()] = true;
         return acc;
     }, {});
 }
 function addonArrayToHashTable(arr) {
-    return arr.reduce((acc, v) => {
-        acc[startOfDay(v.date).getTime()] = v.addon;
+    return arr.reduce(function (acc, v) {
+        acc[startOfDay__default.default(v.date).getTime()] = v.addon;
         return acc;
     }, {});
 }
@@ -153,37 +182,38 @@ function addonArrayToHashTable(arr) {
 function getSelectionRange(from, to, highlighted) {
     if (!from && !to)
         return null;
-    const end = to || highlighted;
-    const start = from || highlighted;
+    var end = to || highlighted;
+    var start = from || highlighted;
     if (start && end && start !== end) {
         return {
-            start: startOfDay(min([start, end])),
-            end: startOfDay(max([start, end])),
+            start: startOfDay__default.default(min__default.default([start, end])),
+            end: startOfDay__default.default(max__default.default([start, end])),
         };
     }
     return null;
 }
 // Меняет дату одним из способов с учетом границ и выходных дней
-function modifyDateByShift(shift, date, minDate, maxDate, offDaysMap = {}) {
-    const modifiers = {
-        prev: () => subDays(date, 1),
-        prevWeek: () => subDays(date, 7),
-        prevMonth: () => subMonths(date, 1),
-        next: () => addDays(date, 1),
-        nextWeek: () => addDays(date, 7),
-        nextMonth: () => addMonths(date, 1),
-        startOfWeek: () => startOfWeek(date, { weekStartsOn: 1 }),
-        endOfWeek: () => startOfDay(endOfWeek(date, { weekStartsOn: 1 })),
+function modifyDateByShift(shift, date, minDate, maxDate, offDaysMap) {
+    if (offDaysMap === void 0) { offDaysMap = {}; }
+    var modifiers = {
+        prev: function () { return subDays__default.default(date, 1); },
+        prevWeek: function () { return subDays__default.default(date, 7); },
+        prevMonth: function () { return subMonths__default.default(date, 1); },
+        next: function () { return addDays__default.default(date, 1); },
+        nextWeek: function () { return addDays__default.default(date, 7); },
+        nextMonth: function () { return addMonths__default.default(date, 1); },
+        startOfWeek: function () { return startOfWeek__default.default(date, { weekStartsOn: 1 }); },
+        endOfWeek: function () { return startOfDay__default.default(endOfWeek__default.default(date, { weekStartsOn: 1 })); },
     };
-    let newDate = modifiers[shift]();
+    var newDate = modifiers[shift]();
     while (offDaysMap[newDate.getTime()]) {
         // Перескакиваем через выходные дни, кроме случаев с концами недели
-        let amount = newDate < date ? -1 : 1;
+        var amount = newDate < date ? -1 : 1;
         if (shift === 'endOfWeek')
             amount = -1;
         if (shift === 'startOfWeek')
             amount = 1;
-        newDate = addDays(newDate, amount);
+        newDate = addDays__default.default(newDate, amount);
     }
     return limitDate(newDate, minDate, maxDate);
 }
@@ -193,25 +223,54 @@ function modifyDateByShift(shift, date, minDate, maxDate, offDaysMap = {}) {
  */
 function simulateTab(node) {
     if (window.KeyboardEvent) {
-        const event = new window.KeyboardEvent('keydown', {
+        var event_1 = new window.KeyboardEvent('keydown', {
             bubbles: true,
             key: 'Tab',
         });
-        node.dispatchEvent(event);
+        node.dispatchEvent(event_1);
     }
 }
-const formatDate = (date, dateFormat = DATE_FORMAT) => format(date, dateFormat);
-const parseDateString = (value, dateFormat = DATE_FORMAT) => parse(value, dateFormat, new Date());
+var formatDate = function (date, dateFormat) {
+    if (dateFormat === void 0) { dateFormat = DATE_FORMAT; }
+    return format__default.default(date, dateFormat);
+};
+var parseDateString = function (value, dateFormat) {
+    if (dateFormat === void 0) { dateFormat = DATE_FORMAT; }
+    return parse__default.default(value, dateFormat, new Date());
+};
 function getCalendarMobileTestIds(dataTestId) {
     return {
         calendar: dataTestId,
-        content: getDataTestId(dataTestId, 'content'),
-        footer: getDataTestId(dataTestId, 'footer'),
-        header: getDataTestId(dataTestId, 'header'),
-        closer: getDataTestId(dataTestId, 'header-closer'),
-        btnApply: getDataTestId(dataTestId, 'btn-apply'),
-        btnReset: getDataTestId(dataTestId, 'btn-reset'),
+        content: coreComponentsShared.getDataTestId(dataTestId, 'content'),
+        footer: coreComponentsShared.getDataTestId(dataTestId, 'footer'),
+        header: coreComponentsShared.getDataTestId(dataTestId, 'header'),
+        closer: coreComponentsShared.getDataTestId(dataTestId, 'header-closer'),
+        btnApply: coreComponentsShared.getDataTestId(dataTestId, 'btn-apply'),
+        btnReset: coreComponentsShared.getDataTestId(dataTestId, 'btn-reset'),
     };
 }
 
-export { DATE_FORMAT, DAYS_IN_WEEK, MONTHS, MONTHS_IN_YEAR, NATIVE_DATE_FORMAT, SUNDAY_INDEX, WEEKDAYS, addonArrayToHashTable, buildDay, buildMonth, dateArrayToHashTable, dateInLimits, formatDate, generateMonths, generateWeeks, generateYears, getCalendarMobileTestIds, getSelectionRange, limitDate, modifyDateByShift, monthName, parseDateString, russianWeekDay, simulateTab };
+exports.DATE_FORMAT = DATE_FORMAT;
+exports.DAYS_IN_WEEK = DAYS_IN_WEEK;
+exports.MONTHS = MONTHS;
+exports.MONTHS_IN_YEAR = MONTHS_IN_YEAR;
+exports.NATIVE_DATE_FORMAT = NATIVE_DATE_FORMAT;
+exports.SUNDAY_INDEX = SUNDAY_INDEX;
+exports.WEEKDAYS = WEEKDAYS;
+exports.addonArrayToHashTable = addonArrayToHashTable;
+exports.buildDay = buildDay;
+exports.buildMonth = buildMonth;
+exports.dateArrayToHashTable = dateArrayToHashTable;
+exports.dateInLimits = dateInLimits;
+exports.formatDate = formatDate;
+exports.generateMonths = generateMonths;
+exports.generateWeeks = generateWeeks;
+exports.generateYears = generateYears;
+exports.getCalendarMobileTestIds = getCalendarMobileTestIds;
+exports.getSelectionRange = getSelectionRange;
+exports.limitDate = limitDate;
+exports.modifyDateByShift = modifyDateByShift;
+exports.monthName = monthName;
+exports.parseDateString = parseDateString;
+exports.russianWeekDay = russianWeekDay;
+exports.simulateTab = simulateTab;

package/calendar-input/cssm/Component.responsive.js

@@ -1,32 +1,26 @@
-import React, { forwardRef } from 'react';
-import { useMedia } from '@alfalab/hooks';
-import { CalendarInputDesktop } from './desktop/Component.desktop.js';
-import { CalendarInputMobile } from './mobile/Component.mobile.js';
-import '../../calendar/cssm/desktop';
-import './components/calendar-input/Component.js';
-import 'react-merge-refs';
-import 'classnames';
-import '../../calendar/cssm/shared';
-import '../../date-input/cssm';
-import '../../popover/cssm';
-import '@alfalab/icons-glyph/CalendarMIcon';
-import './utils.js';
-import 'date-fns/format';
-import 'date-fns/isSameDay';
-import 'date-fns/parse';
-import './components/calendar-input/index.module.css';
-import '../../calendar/cssm/mobile';
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var React = require('react');
+var hooks = require('@alfalab/hooks');
+var desktop_Component_desktop = require('./desktop/Component.desktop.js');
+var mobile_Component_mobile = require('./mobile/Component.mobile.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultCompat(React);
 
 /**
  * @deprecated
  * use UniversalDateInput instead
  */
-const CalendarInputResponsive = forwardRef(({ breakpoint = 1024, ...restProps }, ref) => {
-    const [view] = useMedia([
-        ['mobile', `(max-width: ${breakpoint - 1}px)`],
-        ['desktop', `(min-width: ${breakpoint}px)`],
-    ], 'desktop');
-    return view === 'desktop' ? (React.createElement(CalendarInputDesktop, { ...restProps, ref: ref })) : (React.createElement(CalendarInputMobile, { ...restProps, ref: ref }));
+var CalendarInputResponsive = React.forwardRef(function (_a, ref) {
+    var _b = _a.breakpoint, breakpoint = _b === void 0 ? 1024 : _b, restProps = tslib.__rest(_a, ["breakpoint"]);
+    var view = hooks.useMedia([
+        ['mobile', "(max-width: ".concat(breakpoint - 1, "px)")],
+        ['desktop', "(min-width: ".concat(breakpoint, "px)")],
+    ], 'desktop')[0];
+    return view === 'desktop' ? (React__default.default.createElement(desktop_Component_desktop.CalendarInputDesktop, tslib.__assign({}, restProps, { ref: ref }))) : (React__default.default.createElement(mobile_Component_mobile.CalendarInputMobile, tslib.__assign({}, restProps, { ref: ref })));
 });
 
-export { CalendarInputResponsive };
+exports.CalendarInputResponsive = CalendarInputResponsive;

package/calendar-input/cssm/components/calendar-input/Component.js

@@ -1,53 +1,63 @@
-import React, { forwardRef, useState, useRef, useEffect } from 'react';
-import mergeRefs from 'react-merge-refs';
-import cn from 'classnames';
-import { dateInLimits } from '../../../../calendar/cssm/shared';
-import { parseDateString, DateInput, isCompleteDateInput, formatDate } from '../../../../date-input/cssm';
-import { Popover } from '../../../../popover/cssm';
-import { CalendarMIcon } from '@alfalab/icons-glyph/CalendarMIcon';
-import { SUPPORTS_INPUT_TYPE_DATE } from '../../utils.js';
-import styles from './index.module.css';
-import 'date-fns/format';
-import 'date-fns/isSameDay';
-import 'date-fns/parse';
+Object.defineProperty(exports, '__esModule', { value: true });
 
-const CalendarInput = forwardRef(({ block = false, className, inputClassName, popoverClassName, defaultOpen = false, defaultMonth, defaultValue = '', calendarPosition = 'popover', value, dataTestId, calendarProps = {}, minDate = calendarProps.minDate, maxDate = calendarProps.maxDate, offDays = calendarProps.offDays || [], events = calendarProps.events || [], preventFlip, mobileMode = 'popover', wrapperRef = null, disabled, onChange = () => null, onInputChange, onCalendarChange, onCalendarOpen, onCalendarClose, onKeyDown, readOnly, disableUserInput = false, Calendar, popoverPosition = 'bottom-start', zIndexPopover, useAnchorWidth, rightAddons, error, view = 'desktop', ...restProps }, ref) => {
-    const calendarResponsive = calendarProps?.responsive ?? true;
-    const shouldRenderNative = SUPPORTS_INPUT_TYPE_DATE && mobileMode === 'native';
-    const shouldRenderOnlyInput = mobileMode === 'input';
-    const shouldRenderStatic = calendarPosition === 'static' && !shouldRenderOnlyInput;
-    const shouldRenderPopover = calendarPosition === 'popover' && !shouldRenderNative && !shouldRenderOnlyInput;
-    const [open, setOpen] = useState(false);
-    const [inputValue, setInputValue] = useState(value || defaultValue);
-    const calendarValue = inputValue ? parseDateString(inputValue).getTime() : undefined;
-    const checkInputValueIsValid = (newInputValue) => {
+var tslib = require('tslib');
+var React = require('react');
+var mergeRefs = require('react-merge-refs');
+var cn = require('classnames');
+var shared = require('../../../../calendar/cssm/shared');
+var coreComponentsDateInput = require('../../../../date-input/cssm');
+var coreComponentsPopover = require('../../../../popover/cssm');
+var CalendarMIcon = require('@alfalab/icons-glyph/CalendarMIcon');
+var utils = require('../../utils.js');
+var styles = require('./index.module.css');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultCompat(React);
+var mergeRefs__default = /*#__PURE__*/_interopDefaultCompat(mergeRefs);
+var cn__default = /*#__PURE__*/_interopDefaultCompat(cn);
+var styles__default = /*#__PURE__*/_interopDefaultCompat(styles);
+
+var CalendarInput = React.forwardRef(function (_a, ref) {
+    var _b, _c;
+    var _d;
+    var _e = _a.block, block = _e === void 0 ? false : _e, className = _a.className, inputClassName = _a.inputClassName, popoverClassName = _a.popoverClassName, _f = _a.defaultOpen, defaultOpen = _f === void 0 ? false : _f, defaultMonth = _a.defaultMonth, _g = _a.defaultValue, defaultValue = _g === void 0 ? '' : _g, _h = _a.calendarPosition, calendarPosition = _h === void 0 ? 'popover' : _h, value = _a.value, dataTestId = _a.dataTestId, _j = _a.calendarProps, calendarProps = _j === void 0 ? {} : _j, _k = _a.minDate, minDate = _k === void 0 ? calendarProps.minDate : _k, _l = _a.maxDate, maxDate = _l === void 0 ? calendarProps.maxDate : _l, _m = _a.offDays, offDays = _m === void 0 ? calendarProps.offDays || [] : _m, _o = _a.events, events = _o === void 0 ? calendarProps.events || [] : _o, preventFlip = _a.preventFlip, _p = _a.mobileMode, mobileMode = _p === void 0 ? 'popover' : _p, _q = _a.wrapperRef, wrapperRef = _q === void 0 ? null : _q, disabled = _a.disabled, _r = _a.onChange, onChange = _r === void 0 ? function () { return null; } : _r, onInputChange = _a.onInputChange, onCalendarChange = _a.onCalendarChange, onCalendarOpen = _a.onCalendarOpen, onCalendarClose = _a.onCalendarClose, onKeyDown = _a.onKeyDown, readOnly = _a.readOnly, _s = _a.disableUserInput, disableUserInput = _s === void 0 ? false : _s, Calendar = _a.Calendar, _t = _a.popoverPosition, popoverPosition = _t === void 0 ? 'bottom-start' : _t, zIndexPopover = _a.zIndexPopover, useAnchorWidth = _a.useAnchorWidth, rightAddons = _a.rightAddons, error = _a.error, _u = _a.view, view = _u === void 0 ? 'desktop' : _u, restProps = tslib.__rest(_a, ["block", "className", "inputClassName", "popoverClassName", "defaultOpen", "defaultMonth", "defaultValue", "calendarPosition", "value", "dataTestId", "calendarProps", "minDate", "maxDate", "offDays", "events", "preventFlip", "mobileMode", "wrapperRef", "disabled", "onChange", "onInputChange", "onCalendarChange", "onCalendarOpen", "onCalendarClose", "onKeyDown", "readOnly", "disableUserInput", "Calendar", "popoverPosition", "zIndexPopover", "useAnchorWidth", "rightAddons", "error", "view"]);
+    var calendarResponsive = (_d = calendarProps === null || calendarProps === void 0 ? void 0 : calendarProps.responsive) !== null && _d !== void 0 ? _d : true;
+    var shouldRenderNative = utils.SUPPORTS_INPUT_TYPE_DATE && mobileMode === 'native';
+    var shouldRenderOnlyInput = mobileMode === 'input';
+    var shouldRenderStatic = calendarPosition === 'static' && !shouldRenderOnlyInput;
+    var shouldRenderPopover = calendarPosition === 'popover' && !shouldRenderNative && !shouldRenderOnlyInput;
+    var _v = React.useState(false), open = _v[0], setOpen = _v[1];
+    var _w = React.useState(value || defaultValue), inputValue = _w[0], setInputValue = _w[1];
+    var calendarValue = inputValue ? coreComponentsDateInput.parseDateString(inputValue).getTime() : undefined;
+    var checkInputValueIsValid = function (newInputValue) {
         if (!newInputValue)
             return false;
-        const dateValue = parseDateString(newInputValue).getTime();
+        var dateValue = coreComponentsDateInput.parseDateString(newInputValue).getTime();
         return !!(dateValue &&
-            isCompleteDateInput(newInputValue) &&
-            dateInLimits(dateValue, minDate, maxDate) &&
+            coreComponentsDateInput.isCompleteDateInput(newInputValue) &&
+            shared.dateInLimits(dateValue, minDate, maxDate) &&
             !offDays.includes(dateValue));
     };
-    const inputDisabled = disabled || readOnly;
-    const inputRef = useRef(null);
-    const inputWrapperRef = useRef(null);
-    const calendarRef = useRef(null);
-    const openCalendar = () => {
-        setOpen((prev) => {
+    var inputDisabled = disabled || readOnly;
+    var inputRef = React.useRef(null);
+    var inputWrapperRef = React.useRef(null);
+    var calendarRef = React.useRef(null);
+    var openCalendar = function () {
+        setOpen(function (prev) {
             if (!prev)
-                onCalendarOpen?.();
+                onCalendarOpen === null || onCalendarOpen === void 0 ? void 0 : onCalendarOpen();
             return true;
         });
     };
-    const closeCalendar = () => {
-        setOpen((prev) => {
+    var closeCalendar = function () {
+        setOpen(function (prev) {
             if (prev)
-                onCalendarClose?.();
+                onCalendarClose === null || onCalendarClose === void 0 ? void 0 : onCalendarClose();
             return false;
         });
     };
-    const handleKeyDown = (event) => {
+    var handleKeyDown = function (event) {
         if (event.target.tagName === 'INPUT' && event.key === 'Enter') {
             if (open) {
                 closeCalendar();
@@ -60,8 +70,9 @@ const CalendarInput = forwardRef(({ block = false, className, inputClassName, po
             closeCalendar();
         }
     };
-    const handleClick = (event) => {
-        if (!inputWrapperRef.current?.contains(event.target))
+    var handleClick = function (event) {
+        var _a;
+        if (!((_a = inputWrapperRef.current) === null || _a === void 0 ? void 0 : _a.contains(event.target)))
             return;
         if (!open)
             openCalendar();
@@ -69,9 +80,10 @@ const CalendarInput = forwardRef(({ block = false, className, inputClassName, po
             inputRef.current.focus();
         }
     };
-    const handleFocus = (event) => {
+    var handleFocus = function (event) {
+        var _a;
         if (view === 'desktop') {
-            if (!inputWrapperRef.current?.contains(event.target))
+            if (!((_a = inputWrapperRef.current) === null || _a === void 0 ? void 0 : _a.contains(event.target)))
                 return;
             openCalendar();
             if (!open && event.target.tagName !== 'INPUT' && calendarRef.current) {
@@ -79,16 +91,17 @@ const CalendarInput = forwardRef(({ block = false, className, inputClassName, po
             }
         }
     };
-    const handleBlur = (event) => {
+    var handleBlur = function (event) {
+        var _a;
         if (view === 'desktop') {
-            const target = (event.relatedTarget || document.activeElement);
+            var target = (event.relatedTarget || document.activeElement);
             if (inputRef.current !== target &&
-                calendarRef.current?.contains(target) === false) {
+                ((_a = calendarRef.current) === null || _a === void 0 ? void 0 : _a.contains(target)) === false) {
                 closeCalendar();
             }
         }
     };
-    const handleInputKeyDown = (event) => {
+    var handleInputKeyDown = function (event) {
         if (['ArrowDown', 'ArrowUp'].includes(event.key) && calendarRef.current) {
             event.preventDefault();
             calendarRef.current.focus();
@@ -96,7 +109,9 @@ const CalendarInput = forwardRef(({ block = false, className, inputClassName, po
         if (onKeyDown)
             onKeyDown(event);
     };
-    const changeHandler = (event, newValue, newDate, initiator = 'input', shouldChange = true) => {
+    var changeHandler = function (event, newValue, newDate, initiator, shouldChange) {
+        if (initiator === void 0) { initiator = 'input'; }
+        if (shouldChange === void 0) { shouldChange = true; }
         if (initiator === 'input' && event && onInputChange) {
             onInputChange(event, { value: newValue, date: newDate });
         }
@@ -108,45 +123,45 @@ const CalendarInput = forwardRef(({ block = false, className, inputClassName, po
             onChange(event, { date: newDate, value: newValue });
         }
     };
-    const handleInputChange = (event, payload) => {
+    var handleInputChange = function (event, payload) {
         changeHandler(event, payload.value, payload.date, 'input', !payload.value || checkInputValueIsValid(payload.value));
     };
-    const handleCalendarChange = (date) => {
+    var handleCalendarChange = function (date) {
         if (date) {
-            changeHandler(null, formatDate(date), new Date(date), 'calendar');
+            changeHandler(null, coreComponentsDateInput.formatDate(date), new Date(date), 'calendar');
         }
         if (view === 'desktop') {
             closeCalendar();
         }
     };
-    const handleCalendarWrapperMouseDown = (event) => {
+    var handleCalendarWrapperMouseDown = function (event) {
         // Не дает инпуту терять фокус при выборе даты
         event.preventDefault();
     };
-    useEffect(() => {
+    React.useEffect(function () {
         setOpen(defaultOpen);
     }, [defaultOpen]);
-    useEffect(() => {
+    React.useEffect(function () {
         if (typeof value !== 'undefined') {
             setInputValue(value);
         }
     }, [value]);
-    const renderCalendar = () => (
+    var renderCalendar = function () { return (
     // eslint-disable-next-line jsx-a11y/no-static-element-interactions
-    React.createElement("div", { onMouseDown: handleCalendarWrapperMouseDown }, Calendar ? (React.createElement(Calendar, { ...calendarProps, responsive: calendarResponsive, open: open, onClose: closeCalendar, ref: calendarRef, defaultMonth: defaultMonth, value: checkInputValueIsValid(inputValue) ? calendarValue : undefined, onChange: handleCalendarChange, minDate: minDate, maxDate: maxDate, offDays: offDays, events: events })) : null));
+    React__default.default.createElement("div", { onMouseDown: handleCalendarWrapperMouseDown }, Calendar ? (React__default.default.createElement(Calendar, tslib.__assign({}, calendarProps, { responsive: calendarResponsive, open: open, onClose: closeCalendar, ref: calendarRef, defaultMonth: defaultMonth, value: checkInputValueIsValid(inputValue) ? calendarValue : undefined, onChange: handleCalendarChange, minDate: minDate, maxDate: maxDate, offDays: offDays, events: events }))) : null)); };
     return (
     // eslint-disable-next-line jsx-a11y/no-static-element-interactions
-    React.createElement("div", { className: cn(styles.component, className, {
-            [styles.block]: block,
-        }), tabIndex: -1, onKeyDown: inputDisabled ? undefined : handleKeyDown, onClick: inputDisabled ? undefined : handleClick, onFocus: inputDisabled ? undefined : handleFocus, onBlur: handleBlur, "data-test-id": dataTestId },
-        React.createElement(DateInput, { autoComplete: 'off', ...restProps, ref: mergeRefs([inputRef, ref]), wrapperRef: mergeRefs([wrapperRef, inputWrapperRef]), value: inputValue, defaultValue: defaultValue, disabled: disabled, inputClassName: inputClassName, readOnly: readOnly, mobileMode: mobileMode === 'native' ? 'native' : 'input', error: error, disableUserInput: disableUserInput, rightAddons: React.createElement(React.Fragment, null,
+    React__default.default.createElement("div", { className: cn__default.default(styles__default.default.component, className, (_b = {},
+            _b[styles__default.default.block] = block,
+            _b)), tabIndex: -1, onKeyDown: inputDisabled ? undefined : handleKeyDown, onClick: inputDisabled ? undefined : handleClick, onFocus: inputDisabled ? undefined : handleFocus, onBlur: handleBlur, "data-test-id": dataTestId },
+        React__default.default.createElement(coreComponentsDateInput.DateInput, tslib.__assign({ autoComplete: 'off' }, restProps, { ref: mergeRefs__default.default([inputRef, ref]), wrapperRef: mergeRefs__default.default([wrapperRef, inputWrapperRef]), value: inputValue, defaultValue: defaultValue, disabled: disabled, inputClassName: inputClassName, readOnly: readOnly, mobileMode: mobileMode === 'native' ? 'native' : 'input', error: error, disableUserInput: disableUserInput, rightAddons: React__default.default.createElement(React__default.default.Fragment, null,
                 rightAddons,
-                shouldRenderPopover && (React.createElement(CalendarMIcon, { className: styles.calendarIcon }))), rightAddonsProps: { onMouseDown: (e) => e.preventDefault() }, onKeyDown: handleInputKeyDown, onChange: handleInputChange, block: true }),
+                shouldRenderPopover && (React__default.default.createElement(CalendarMIcon.CalendarMIcon, { className: styles__default.default.calendarIcon }))), rightAddonsProps: { onMouseDown: function (e) { return e.preventDefault(); } }, onKeyDown: handleInputKeyDown, onChange: handleInputChange, block: true })),
         shouldRenderStatic && renderCalendar(),
         shouldRenderPopover &&
-            (view === 'desktop' ? (React.createElement(Popover, { open: open, useAnchorWidth: useAnchorWidth, anchorElement: inputWrapperRef.current, popperClassName: cn(styles.calendarContainer, {
-                    [styles.calendarResponsive]: calendarResponsive,
-                }), className: popoverClassName, position: popoverPosition, offset: [0, 4], withTransition: false, preventFlip: preventFlip, zIndex: zIndexPopover }, renderCalendar())) : (renderCalendar()))));
+            (view === 'desktop' ? (React__default.default.createElement(coreComponentsPopover.Popover, { open: open, useAnchorWidth: useAnchorWidth, anchorElement: inputWrapperRef.current, popperClassName: cn__default.default(styles__default.default.calendarContainer, (_c = {},
+                    _c[styles__default.default.calendarResponsive] = calendarResponsive,
+                    _c)), className: popoverClassName, position: popoverPosition, offset: [0, 4], withTransition: false, preventFlip: preventFlip, zIndex: zIndexPopover }, renderCalendar())) : (renderCalendar()))));
 });
 
-export { CalendarInput };
+exports.CalendarInput = CalendarInput;

package/calendar-input/cssm/components/calendar-input/index.js

@@ -1,13 +1,7 @@
-export { CalendarInput } from './Component.js';
-import 'react';
-import 'react-merge-refs';
-import 'classnames';
-import '../../../../calendar/cssm/shared';
-import '../../../../date-input/cssm';
-import '../../../../popover/cssm';
-import '@alfalab/icons-glyph/CalendarMIcon';
-import '../../utils.js';
-import 'date-fns/format';
-import 'date-fns/isSameDay';
-import 'date-fns/parse';
-import './index.module.css';
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var components_calendarInput_Component = require('./Component.js');
+
+
+
+exports.CalendarInput = components_calendarInput_Component.CalendarInput;