@alfalab/core-components 45.6.0-beta.2 → 45.6.1

package/universal-date-input/cssm/mask/utils.js

@@ -1,8 +1,15 @@
-import clamp from 'date-fns/clamp';
-import getDaysInMonth from 'date-fns/getDaysInMonth';
-import { DATE_RANGE_SEPARATOR, DATE_TIME_SEPARATOR, DATE_MAX_VALUES } from '../consts.js';
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var clamp = require('date-fns/clamp');
+var getDaysInMonth = require('date-fns/getDaysInMonth');
+var consts = require('../consts.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var clamp__default = /*#__PURE__*/_interopDefaultCompat(clamp);
+var getDaysInMonth__default = /*#__PURE__*/_interopDefaultCompat(getDaysInMonth);
 
-/* eslint-disable no-param-reassign */
 function fillMask(len) {
     return Array(len).fill(/\d/);
 }
@@ -14,19 +21,19 @@ function isDigit(v) {
  *  01.01.2020, 00:00 -> ['01', '01', '2020', '00', '00']
  */
 function getValueSegments(rawValue, separators) {
-    let separatorCursor = 0;
-    let prevSepIdx = 0;
-    const segments = [];
-    const value = prepareValueForSegmentation(rawValue);
+    var separatorCursor = 0;
+    var prevSepIdx = 0;
+    var segments = [];
+    var value = prepareValueForSegmentation(rawValue);
     while (separatorCursor <= separators.length) {
-        const sepIdx = value.indexOf(separators[separatorCursor], prevSepIdx);
+        var sepIdx = value.indexOf(separators[separatorCursor], prevSepIdx);
         if (sepIdx > -1) {
             segments.push(value.slice(prevSepIdx, sepIdx));
             prevSepIdx = sepIdx + separators[separatorCursor].length;
             separatorCursor += 1;
         }
         else {
-            const restValue = value.slice(prevSepIdx);
+            var restValue = value.slice(prevSepIdx);
             if (restValue) {
                 segments.push(restValue);
             }
@@ -41,19 +48,19 @@ function getValueSegments(rawValue, separators) {
  */
 function prepareValueForSegmentation(value) {
     if (value.indexOf(' ') !== -1) {
-        if (value.indexOf(DATE_RANGE_SEPARATOR) === -1 &&
-            value.indexOf(DATE_RANGE_SEPARATOR.trim()) !== -1) {
+        if (value.indexOf(consts.DATE_RANGE_SEPARATOR) === -1 &&
+            value.indexOf(consts.DATE_RANGE_SEPARATOR.trim()) !== -1) {
             return value
                 .replace(/\s/g, '')
-                .split(DATE_RANGE_SEPARATOR.trim())
-                .join(DATE_RANGE_SEPARATOR);
+                .split(consts.DATE_RANGE_SEPARATOR.trim())
+                .join(consts.DATE_RANGE_SEPARATOR);
         }
-        if (value.indexOf(DATE_TIME_SEPARATOR) === -1 &&
-            value.indexOf(DATE_TIME_SEPARATOR.trim()) !== -1) {
+        if (value.indexOf(consts.DATE_TIME_SEPARATOR) === -1 &&
+            value.indexOf(consts.DATE_TIME_SEPARATOR.trim()) !== -1) {
             return value
                 .replace(/\s/g, '')
-                .split(DATE_TIME_SEPARATOR.trim())
-                .join(DATE_TIME_SEPARATOR);
+                .split(consts.DATE_TIME_SEPARATOR.trim())
+                .join(consts.DATE_TIME_SEPARATOR);
         }
     }
     return value;
@@ -63,16 +70,17 @@ function prepareValueForSegmentation(value) {
  *  Например, ['00', '000', '1'] -> ['00', '00', '01']
  */
 function shiftSegmentsData(rawSegments, templateSegments) {
-    const segments = [...rawSegments];
-    templateSegments.forEach((item, idx, arr) => {
-        const isLast = idx === arr.length - 1;
-        const currSegment = segments[idx];
+    var segments = tslib.__spreadArray([], rawSegments, true);
+    templateSegments.forEach(function (item, idx, arr) {
+        var _a;
+        var isLast = idx === arr.length - 1;
+        var currSegment = segments[idx];
         if (currSegment && item.length < currSegment.length) {
-            const segmentValue = currSegment.slice(0, item.length);
-            const restValue = currSegment.slice(item.length);
+            var segmentValue = currSegment.slice(0, item.length);
+            var restValue = currSegment.slice(item.length);
             segments[idx] = segmentValue;
             if (!isLast) {
-                segments[idx + 1] = restValue + (segments[idx + 1] ?? '');
+                segments[idx + 1] = restValue + ((_a = segments[idx + 1]) !== null && _a !== void 0 ? _a : '');
             }
         }
     });
@@ -83,18 +91,19 @@ function shiftSegmentsData(rawSegments, templateSegments) {
  *  Например, data:1, selection: [0.0], segments: ['00', '000', '1'] -> ['10', '00', '1']
  */
 function replaceSegmentsData(rawSegments, template, selection, data) {
-    const segments = [...rawSegments];
-    const cursorPos = findCursorPlace(rawSegments, template.segments, template.separators, selection);
-    template.segments.forEach((templateSegment, idx, arr) => {
-        const isLast = idx === arr.length - 1;
-        const segment = segments[idx];
+    var segments = tslib.__spreadArray([], rawSegments, true);
+    var cursorPos = findCursorPlace(rawSegments, template.segments, template.separators, selection);
+    template.segments.forEach(function (templateSegment, idx, arr) {
+        var _a;
+        var isLast = idx === arr.length - 1;
+        var segment = segments[idx];
         if (segment && templateSegment.length < segment.length) {
-            const segmentIdx = cursorPos?.beforeNext
+            var segmentIdx = (cursorPos === null || cursorPos === void 0 ? void 0 : cursorPos.beforeNext)
                 ? cursorPos.segmentIdx + 1
-                : cursorPos?.segmentIdx;
-            const offset = cursorPos?.beforeNext ? 0 : cursorPos?.offset;
+                : cursorPos === null || cursorPos === void 0 ? void 0 : cursorPos.segmentIdx;
+            var offset = (cursorPos === null || cursorPos === void 0 ? void 0 : cursorPos.beforeNext) ? 0 : cursorPos === null || cursorPos === void 0 ? void 0 : cursorPos.offset;
             if (segmentIdx === idx && offset !== undefined) {
-                const overflowLen = segment.length - templateSegment.length;
+                var overflowLen = segment.length - templateSegment.length;
                 segments[idx] = (segment.slice(0, offset) +
                     data +
                     segment.slice(offset + overflowLen + data.length)).slice(0, templateSegment.length);
@@ -102,8 +111,8 @@ function replaceSegmentsData(rawSegments, template, selection, data) {
             else {
                 segments[idx] = segment.slice(0, templateSegment.length);
                 if (!isLast && data) {
-                    const restValue = segment.slice(templateSegment.length);
-                    segments[idx + 1] = restValue + (segments[idx + 1] ?? '');
+                    var restValue = segment.slice(templateSegment.length);
+                    segments[idx + 1] = restValue + ((_a = segments[idx + 1]) !== null && _a !== void 0 ? _a : '');
                 }
             }
         }
@@ -114,18 +123,19 @@ function replaceSegmentsData(rawSegments, template, selection, data) {
  * Возвращает информацию о каретке(сегмент, сдвиг внутри сегмента)
  */
 function findCursorPlace(segments, templateSegments, separators, selection) {
-    let cursorPlace;
-    let segmentIdx = 0;
-    let posStart = 0;
+    var _a;
+    var cursorPlace;
+    var segmentIdx = 0;
+    var posStart = 0;
     while (segments[segmentIdx] !== undefined) {
-        const segment = segments[segmentIdx];
-        const separatorLen = separators[segmentIdx]?.length || 1;
-        const bound = [posStart, segment.length + posStart + separatorLen];
+        var segment = segments[segmentIdx];
+        var separatorLen = ((_a = separators[segmentIdx]) === null || _a === void 0 ? void 0 : _a.length) || 1;
+        var bound = [posStart, segment.length + posStart + separatorLen];
         if (selection[0] >= bound[0] && selection[1] < bound[1]) {
-            const offset = selection[0] - bound[0];
+            var offset = selection[0] - bound[0];
             cursorPlace = {
-                segmentIdx,
-                offset,
+                segmentIdx: segmentIdx,
+                offset: offset,
                 beforeNext: offset >= templateSegments[segmentIdx].length,
             };
             break;
@@ -142,13 +152,13 @@ function findCursorPlace(segments, templateSegments, separators, selection) {
  * segments: ['00', '12'], separators: ['.', '.'] -> [/\d/, /\d/, '.', /\d/, /\d/]
  */
 function segmentsToPattern(segments, separators) {
-    return segments.reduce((mask, segment, idx) => {
-        const hasNextSegment = segments[idx + 1] !== undefined;
-        const segmentsLen = segment.length;
+    return segments.reduce(function (mask, segment, idx) {
+        var hasNextSegment = segments[idx + 1] !== undefined;
+        var segmentsLen = segment.length;
         if (idx > 0 && (segment.length || hasNextSegment)) {
-            mask.push(...separators[idx - 1].split(''));
+            mask.push.apply(mask, separators[idx - 1].split(''));
         }
-        mask.push(...fillMask(segmentsLen));
+        mask.push.apply(mask, fillMask(segmentsLen));
         return mask;
     }, []);
 }
@@ -157,10 +167,10 @@ function segmentsToPattern(segments, separators) {
  * segments:['00', '00'], separators: ['.', '.'] -> 00.00
  */
 function segmentsToString(segments, separators) {
-    const str = segments
-        .map((p, idx) => {
-        const isLast = idx === segments.length - 1;
-        return `${p}${separators[idx] && !isLast ? separators[idx] : ''}`;
+    var str = segments
+        .map(function (p, idx) {
+        var isLast = idx === segments.length - 1;
+        return "".concat(p).concat(separators[idx] && !isLast ? separators[idx] : '');
     })
         .join('');
     return removeSeparatorsFromTail(str);
@@ -170,7 +180,7 @@ function segmentsToString(segments, separators) {
  *  01.12. -> 01.12
  */
 function removeSeparatorsFromTail(str) {
-    let strLen = str.length;
+    var strLen = str.length;
     while (strLen > 0 && /\W/.test(str[strLen - 1])) {
         strLen -= 1;
     }
@@ -180,8 +190,9 @@ function removeSeparatorsFromTail(str) {
  *  Возвращает кол-во разделителей в начале строки.
  *  countSeparatorsFromHead('..2024') -> 2
  */
-function countSeparatorsFromHead(str, startFrom = 0) {
-    let cursor = startFrom;
+function countSeparatorsFromHead(str, startFrom) {
+    if (startFrom === void 0) { startFrom = 0; }
+    var cursor = startFrom;
     while (str[cursor] && /\W/.test(str[cursor])) {
         cursor += 1;
     }
@@ -191,21 +202,23 @@ function countSeparatorsFromHead(str, startFrom = 0) {
  *  Валидация сегментов.
  *  9.9 -> 09.09
  */
-function validateSegments({ dateTemplate, templateSegments, segments, selection: [from, to], min, max, }) {
-    const parsedDate = segmentsToObj(segments, templateSegments);
-    const dateSegments = Object.entries(parsedDate);
-    const validatedDateSegments = {};
-    let paddedZeroes = 0;
-    dateSegments.forEach(([segmentName, segmentValue = '']) => {
-        const maxSegmentValue = DATE_MAX_VALUES[segmentName];
-        const { validatedSegmentValue, prefixedZeroesCount } = padWithZeroesUntilValid(segmentValue, `${maxSegmentValue}`);
+function validateSegments(_a) {
+    var dateTemplate = _a.dateTemplate, templateSegments = _a.templateSegments, segments = _a.segments, _b = _a.selection, from = _b[0], to = _b[1], min = _a.min, max = _a.max;
+    var parsedDate = segmentsToObj(segments, templateSegments);
+    var dateSegments = Object.entries(parsedDate);
+    var validatedDateSegments = {};
+    var paddedZeroes = 0;
+    dateSegments.forEach(function (_a) {
+        var segmentName = _a[0], _b = _a[1], segmentValue = _b === void 0 ? '' : _b;
+        var maxSegmentValue = consts.DATE_MAX_VALUES[segmentName];
+        var _c = padWithZeroesUntilValid(segmentValue, "".concat(maxSegmentValue)), validatedSegmentValue = _c.validatedSegmentValue, prefixedZeroesCount = _c.prefixedZeroesCount;
         paddedZeroes += prefixedZeroesCount;
         validatedDateSegments[segmentName] = validatedSegmentValue;
     });
     minMaxValidation(validatedDateSegments, min, max);
-    const validatedDateString = toDateString(validatedDateSegments, dateTemplate);
+    var validatedDateString = toDateString(validatedDateSegments, dateTemplate);
     return {
-        validatedDateString,
+        validatedDateString: validatedDateString,
         updatedSelection: [from + paddedZeroes, to + paddedZeroes],
     };
 }
@@ -214,9 +227,10 @@ function validateSegments({ dateTemplate, templateSegments, segments, selection:
  *  35.02 -> 29.02, 01.01.0001 -> 01.01.1900
  */
 function minMaxValidation(segments, min, max) {
-    const dayFilled = segments.day?.length === 2;
-    const monthFilled = segments.month?.length === 2;
-    const yearFilled = segments.year?.length === 4;
+    var _a, _b, _c;
+    var dayFilled = ((_a = segments.day) === null || _a === void 0 ? void 0 : _a.length) === 2;
+    var monthFilled = ((_b = segments.month) === null || _b === void 0 ? void 0 : _b.length) === 2;
+    var yearFilled = ((_c = segments.year) === null || _c === void 0 ? void 0 : _c.length) === 4;
     if (dayFilled && segments.day === '00')
         segments.day = '01';
     if (monthFilled && segments.month === '00')
@@ -226,14 +240,14 @@ function minMaxValidation(segments, min, max) {
     }
     if (dayFilled && monthFilled) {
         // Если не введен год, берем 2000-й високосный год, иначе 29.02 невозможно будет указать
-        const filledYear = yearFilled ? segments.year : '2000';
-        const maxDays = getDaysInMonth(new Date(`${filledYear}-${segments.month}-01`));
+        var filledYear = yearFilled ? segments.year : '2000';
+        var maxDays = getDaysInMonth__default.default(new Date("".concat(filledYear, "-").concat(segments.month, "-01")));
         if (Number(segments.day) > maxDays) {
             segments.day = maxDays.toString();
         }
     }
     if (dayFilled && monthFilled && yearFilled) {
-        const date = clamp(new Date(`${segments.year}-${segments.month}-${segments.day}`), {
+        var date = clamp__default.default(new Date("".concat(segments.year, "-").concat(segments.month, "-").concat(segments.day)), {
             start: min,
             end: max,
         });
@@ -242,34 +256,36 @@ function minMaxValidation(segments, min, max) {
         segments.year = date.getFullYear().toString();
     }
 }
-function padWithZeroesUntilValid(segmentValue, paddedMaxValue, prefixedZeroesCount = 0) {
+function padWithZeroesUntilValid(segmentValue, paddedMaxValue, prefixedZeroesCount) {
+    if (prefixedZeroesCount === void 0) { prefixedZeroesCount = 0; }
     if (Number(segmentValue.padEnd(paddedMaxValue.length, '0')) <= Number(paddedMaxValue)) {
-        return { validatedSegmentValue: segmentValue, prefixedZeroesCount };
+        return { validatedSegmentValue: segmentValue, prefixedZeroesCount: prefixedZeroesCount };
     }
     if (segmentValue.endsWith('0')) {
         // 01.90 => 01.09|
-        return padWithZeroesUntilValid(`0${segmentValue.slice(0, paddedMaxValue.length - 1)}`, paddedMaxValue, prefixedZeroesCount + 1);
+        return padWithZeroesUntilValid("0".concat(segmentValue.slice(0, paddedMaxValue.length - 1)), paddedMaxValue, prefixedZeroesCount + 1);
     }
     if (segmentValue.length < paddedMaxValue.length) {
         // 01| => Type 9 => 01.90|
-        return padWithZeroesUntilValid(`${segmentValue.slice(0, paddedMaxValue.length - 1)}0`, paddedMaxValue, prefixedZeroesCount);
+        return padWithZeroesUntilValid("".concat(segmentValue.slice(0, paddedMaxValue.length - 1), "0"), paddedMaxValue, prefixedZeroesCount);
     }
     // 01.1|=> Type 9 => 01.12|
-    return { validatedSegmentValue: paddedMaxValue, prefixedZeroesCount };
+    return { validatedSegmentValue: paddedMaxValue, prefixedZeroesCount: prefixedZeroesCount };
 }
 /**
  *  Превращает объект с сегментами в строку
  */
-function toDateString({ day, month, year, hours, minutes }, dateTemplate) {
+function toDateString(_a, dateTemplate) {
+    var day = _a.day, month = _a.month, year = _a.year, hours = _a.hours, minutes = _a.minutes;
     return dateTemplate
-        .replace(/d+/g, day ?? '')
-        .replace(/MM+/g, month ?? '')
-        .replace(/y+/g, year ?? '')
-        .replace(/H+/g, hours ?? '')
-        .replace(/m+/g, minutes ?? '');
+        .replace(/d+/g, day !== null && day !== void 0 ? day : '')
+        .replace(/MM+/g, month !== null && month !== void 0 ? month : '')
+        .replace(/y+/g, year !== null && year !== void 0 ? year : '')
+        .replace(/H+/g, hours !== null && hours !== void 0 ? hours : '')
+        .replace(/m+/g, minutes !== null && minutes !== void 0 ? minutes : '');
 }
 function parseDateRangeString(dateRange, maxLen) {
-    return dateRange.split(DATE_RANGE_SEPARATOR).map((date) => date.slice(0, maxLen));
+    return dateRange.split(consts.DATE_RANGE_SEPARATOR).map(function (date) { return date.slice(0, maxLen); });
 }
 function segmentsToObj(segments, templateSegments) {
     return {
@@ -281,4 +297,18 @@ function segmentsToObj(segments, templateSegments) {
     };
 }
 
-export { countSeparatorsFromHead, findCursorPlace, getValueSegments, isDigit, minMaxValidation, padWithZeroesUntilValid, parseDateRangeString, removeSeparatorsFromTail, replaceSegmentsData, segmentsToObj, segmentsToPattern, segmentsToString, shiftSegmentsData, toDateString, validateSegments };
+exports.countSeparatorsFromHead = countSeparatorsFromHead;
+exports.findCursorPlace = findCursorPlace;
+exports.getValueSegments = getValueSegments;
+exports.isDigit = isDigit;
+exports.minMaxValidation = minMaxValidation;
+exports.padWithZeroesUntilValid = padWithZeroesUntilValid;
+exports.parseDateRangeString = parseDateRangeString;
+exports.removeSeparatorsFromTail = removeSeparatorsFromTail;
+exports.replaceSegmentsData = replaceSegmentsData;
+exports.segmentsToObj = segmentsToObj;
+exports.segmentsToPattern = segmentsToPattern;
+exports.segmentsToString = segmentsToString;
+exports.shiftSegmentsData = shiftSegmentsData;
+exports.toDateString = toDateString;
+exports.validateSegments = validateSegments;

package/universal-date-input/cssm/mobile/Component.mobile.js

@@ -1,35 +1,13 @@
-import React, { forwardRef } from 'react';
-import { BaseUniversalDateInput } from '../components/base-universal-date-input/Component.js';
-import 'react-merge-refs';
-import '@maskito/react';
-import 'classnames';
-import 'date-fns/endOfDay';
-import 'date-fns/startOfDay';
-import '../consts.js';
-import '../mask/index.js';
-import '../mask/plugins.js';
-import '../mask/utils.js';
-import 'date-fns/clamp';
-import 'date-fns/getDaysInMonth';
-import '../mask/postprocessors.js';
-import '../mask/preprocessors.js';
-import 'date-fns/isValid';
-import '../utils/index.js';
-import 'date-fns/differenceInDays';
-import 'date-fns/format';
-import 'date-fns/isSameDay';
-import 'date-fns/parse';
-import '../../../shared/cssm';
-import '../components/date-input/Component.js';
-import '../../../input/cssm';
-import '../../../popover/cssm';
-import '@alfalab/icons-glyph/CalendarMIcon';
-import '../index.module-cb4e6b79.js';
-import '../components/date-range-input/Component.js';
-import 'date-fns/isAfter';
-import 'date-fns/startOfMonth';
-import '../components/time-input/Component.js';
+Object.defineProperty(exports, '__esModule', { value: true });
 
-const UniversalDateInputMobile = forwardRef((props, ref) => (React.createElement(BaseUniversalDateInput, { ...props, ref: ref, breakpoint: 10000, platform: 'mobile', defaultMatchMediaValue: false })));
+var tslib = require('tslib');
+var React = require('react');
+var components_baseUniversalDateInput_Component = require('../components/base-universal-date-input/Component.js');
 
-export { UniversalDateInputMobile };
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultCompat(React);
+
+var UniversalDateInputMobile = React.forwardRef(function (props, ref) { return (React__default.default.createElement(components_baseUniversalDateInput_Component.BaseUniversalDateInput, tslib.__assign({}, props, { ref: ref, breakpoint: 10000, platform: 'mobile', defaultMatchMediaValue: false }))); });
+
+exports.UniversalDateInputMobile = UniversalDateInputMobile;

package/universal-date-input/cssm/mobile/index.js

@@ -1,32 +1,7 @@
-export { UniversalDateInputMobile } from './Component.mobile.js';
-import 'react';
-import '../components/base-universal-date-input/Component.js';
-import 'react-merge-refs';
-import '@maskito/react';
-import 'classnames';
-import 'date-fns/endOfDay';
-import 'date-fns/startOfDay';
-import '../consts.js';
-import '../mask/index.js';
-import '../mask/plugins.js';
-import '../mask/utils.js';
-import 'date-fns/clamp';
-import 'date-fns/getDaysInMonth';
-import '../mask/postprocessors.js';
-import '../mask/preprocessors.js';
-import 'date-fns/isValid';
-import '../utils/index.js';
-import 'date-fns/differenceInDays';
-import 'date-fns/format';
-import 'date-fns/isSameDay';
-import 'date-fns/parse';
-import '../../../shared/cssm';
-import '../components/date-input/Component.js';
-import '../../../input/cssm';
-import '../../../popover/cssm';
-import '@alfalab/icons-glyph/CalendarMIcon';
-import '../index.module-cb4e6b79.js';
-import '../components/date-range-input/Component.js';
-import 'date-fns/isAfter';
-import 'date-fns/startOfMonth';
-import '../components/time-input/Component.js';
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var mobile_Component_mobile = require('./Component.mobile.js');
+
+
+
+exports.UniversalDateInputMobile = mobile_Component_mobile.UniversalDateInputMobile;

package/universal-date-input/cssm/shared/index.js

@@ -1,8 +1,15 @@
-export { formatDate, formatDateRange, getUniversalDateInputTestIds, parseDateString } from '../utils/index.js';
-export { DATE_FORMAT, DATE_RANGE_SEPARATOR, DATE_TIME_FORMAT, DATE_TIME_SEPARATOR } from '../consts.js';
-import 'date-fns/differenceInDays';
-import 'date-fns/format';
-import 'date-fns/isSameDay';
-import 'date-fns/parse';
-import 'date-fns/startOfDay';
-import '../../../shared/cssm';
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils_index = require('../utils/index.js');
+var consts = require('../consts.js');
+
+
+
+exports.formatDate = utils_index.formatDate;
+exports.formatDateRange = utils_index.formatDateRange;
+exports.getUniversalDateInputTestIds = utils_index.getUniversalDateInputTestIds;
+exports.parseDateString = utils_index.parseDateString;
+exports.DATE_FORMAT = consts.DATE_FORMAT;
+exports.DATE_RANGE_SEPARATOR = consts.DATE_RANGE_SEPARATOR;
+exports.DATE_TIME_FORMAT = consts.DATE_TIME_FORMAT;
+exports.DATE_TIME_SEPARATOR = consts.DATE_TIME_SEPARATOR;

package/universal-date-input/cssm/utils/index.js

@@ -1,45 +1,65 @@
-import differenceInDays from 'date-fns/differenceInDays';
-import dateFnsFormat from 'date-fns/format';
-import isSameDay from 'date-fns/isSameDay';
-import parse from 'date-fns/parse';
-import startOfDay from 'date-fns/startOfDay';
-import { getDataTestId } from '../../../shared/cssm';
-import { DATE_FORMAT, DATE_RANGE_SEPARATOR } from '../consts.js';
+Object.defineProperty(exports, '__esModule', { value: true });
 
-function parseDateString(value, format = DATE_FORMAT) {
-    return parse(value, format, new Date());
+var differenceInDays = require('date-fns/differenceInDays');
+var dateFnsFormat = require('date-fns/format');
+var isSameDay = require('date-fns/isSameDay');
+var parse = require('date-fns/parse');
+var startOfDay = require('date-fns/startOfDay');
+var coreComponentsShared = require('../../../shared/cssm');
+var consts = require('../consts.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var differenceInDays__default = /*#__PURE__*/_interopDefaultCompat(differenceInDays);
+var dateFnsFormat__default = /*#__PURE__*/_interopDefaultCompat(dateFnsFormat);
+var isSameDay__default = /*#__PURE__*/_interopDefaultCompat(isSameDay);
+var parse__default = /*#__PURE__*/_interopDefaultCompat(parse);
+var startOfDay__default = /*#__PURE__*/_interopDefaultCompat(startOfDay);
+
+function parseDateString(value, format) {
+    if (format === void 0) { format = consts.DATE_FORMAT; }
+    return parse__default.default(value, format, new Date());
 }
-const formatDate = (date, dateFormat = DATE_FORMAT) => dateFnsFormat(date, dateFormat);
+var formatDate = function (date, dateFormat) {
+    if (dateFormat === void 0) { dateFormat = consts.DATE_FORMAT; }
+    return dateFnsFormat__default.default(date, dateFormat);
+};
 function formatDateRange(range) {
-    return formatDate(range.dateFrom) + DATE_RANGE_SEPARATOR + formatDate(range.dateTo);
+    return formatDate(range.dateFrom) + consts.DATE_RANGE_SEPARATOR + formatDate(range.dateTo);
 }
-function isCompleteDate(value = '') {
-    return value.length === DATE_FORMAT.length;
+function isCompleteDate(value) {
+    if (value === void 0) { value = ''; }
+    return value.length === consts.DATE_FORMAT.length;
 }
-function isCompleteTime(value = '', withTime = false) {
+function isCompleteTime(value, withTime) {
+    if (value === void 0) { value = ''; }
+    if (withTime === void 0) { withTime = false; }
     if (!withTime)
         return true;
     return value.length === 5;
 }
-function isCompleteDateRange(value = '') {
-    return value.length === DATE_RANGE_SEPARATOR.length + DATE_FORMAT.length * 2;
+function isCompleteDateRange(value) {
+    if (value === void 0) { value = ''; }
+    return value.length === consts.DATE_RANGE_SEPARATOR.length + consts.DATE_FORMAT.length * 2;
 }
-function isValidDate({ value = '', minDate, maxDate, offDays, }) {
-    const parsed = isCompleteDate(value) ? parseDateString(value).getTime() : undefined;
-    const minDateStartOfDay = startOfDay(new Date(minDate)).getTime();
+function isValidDate(_a) {
+    var _b = _a.value, value = _b === void 0 ? '' : _b, minDate = _a.minDate, maxDate = _a.maxDate, offDays = _a.offDays;
+    var parsed = isCompleteDate(value) ? parseDateString(value).getTime() : undefined;
+    var minDateStartOfDay = startOfDay__default.default(new Date(minDate)).getDate();
     if (parsed) {
         return (parsed >= minDateStartOfDay &&
             parsed <= maxDate &&
-            !offDays?.some((offDay) => isSameDay(offDay, parsed)));
+            !(offDays === null || offDays === void 0 ? void 0 : offDays.some(function (offDay) { return isSameDay__default.default(offDay, parsed); })));
     }
     return false;
 }
 function preventDefault(e) {
     e.preventDefault();
 }
-function getValidRange({ from, to, offDays, minDate, maxDate, }) {
-    const isValidFrom = isValidDate({ value: from, maxDate, minDate, offDays });
-    const isValidTo = isValidDate({ value: to, maxDate, minDate, offDays });
+function getValidRange(_a) {
+    var from = _a.from, to = _a.to, offDays = _a.offDays, minDate = _a.minDate, maxDate = _a.maxDate;
+    var isValidFrom = isValidDate({ value: from, maxDate: maxDate, minDate: minDate, offDays: offDays });
+    var isValidTo = isValidDate({ value: to, maxDate: maxDate, minDate: minDate, offDays: offDays });
     return {
         validFrom: isValidFrom ? parseDateString(from) : undefined,
         validTo: isValidTo ? parseDateString(to) : undefined,
@@ -48,9 +68,10 @@ function getValidRange({ from, to, offDays, minDate, maxDate, }) {
 /**
  * Частично копипаста updatePeriod хука в календаре
  */
-function updateRange({ date, validFrom, validTo, rangeBehavior, }) {
-    let selectedFrom = validFrom ? validFrom.getTime() : null;
-    let selectedTo = validTo ? validTo.getTime() : null;
+function updateRange(_a) {
+    var date = _a.date, validFrom = _a.validFrom, validTo = _a.validTo, rangeBehavior = _a.rangeBehavior;
+    var selectedFrom = validFrom ? validFrom.getTime() : null;
+    var selectedTo = validTo ? validTo.getTime() : null;
     if (rangeBehavior === 'clarification') {
         if (date === undefined || (date === selectedFrom && date === selectedTo)) {
             selectedFrom = null;
@@ -89,8 +110,8 @@ function updateRange({ date, validFrom, validTo, rangeBehavior, }) {
                 selectedFrom = date;
             }
         }
-        else if (Math.abs(differenceInDays(date, selectedTo)) >
-            Math.abs(differenceInDays(date, selectedFrom))) {
+        else if (Math.abs(differenceInDays__default.default(date, selectedTo)) >
+            Math.abs(differenceInDays__default.default(date, selectedFrom))) {
             selectedFrom = date;
         }
         else {
@@ -118,10 +139,10 @@ function updateRange({ date, validFrom, validTo, rangeBehavior, }) {
             selectedFrom = date;
         }
     }
-    const dateFrom = selectedFrom ? formatDate(selectedFrom) : null;
-    const dateTo = selectedTo ? formatDate(selectedTo) : null;
+    var dateFrom = selectedFrom ? formatDate(selectedFrom) : null;
+    var dateTo = selectedTo ? formatDate(selectedTo) : null;
     if (dateFrom && dateTo) {
-        return `${dateFrom}${DATE_RANGE_SEPARATOR}${dateTo}`;
+        return "".concat(dateFrom).concat(consts.DATE_RANGE_SEPARATOR).concat(dateTo);
     }
     if (dateFrom)
         return dateFrom;
@@ -130,16 +151,26 @@ function updateRange({ date, validFrom, validTo, rangeBehavior, }) {
 function getUniversalDateInputTestIds(dataTestId) {
     return {
         input: dataTestId,
-        componentWrapper: getDataTestId(dataTestId, 'wrapper'),
-        popover: getDataTestId(dataTestId, 'popover'),
-        calendar: getDataTestId(dataTestId, 'calendar'),
-        inputWrapper: getDataTestId(dataTestId, 'form-control'),
-        inputWrapperInner: getDataTestId(dataTestId, 'form-control-inner'),
-        leftAddons: getDataTestId(dataTestId, 'form-control-left-addons'),
-        rightAddons: getDataTestId(dataTestId, 'form-control-right-addons'),
-        error: getDataTestId(dataTestId, 'form-control-error-message'),
-        hint: getDataTestId(dataTestId, 'form-control-hint'),
+        componentWrapper: coreComponentsShared.getDataTestId(dataTestId, 'wrapper'),
+        popover: coreComponentsShared.getDataTestId(dataTestId, 'popover'),
+        calendar: coreComponentsShared.getDataTestId(dataTestId, 'calendar'),
+        inputWrapper: coreComponentsShared.getDataTestId(dataTestId, 'form-control'),
+        inputWrapperInner: coreComponentsShared.getDataTestId(dataTestId, 'form-control-inner'),
+        leftAddons: coreComponentsShared.getDataTestId(dataTestId, 'form-control-left-addons'),
+        rightAddons: coreComponentsShared.getDataTestId(dataTestId, 'form-control-right-addons'),
+        error: coreComponentsShared.getDataTestId(dataTestId, 'form-control-error-message'),
+        hint: coreComponentsShared.getDataTestId(dataTestId, 'form-control-hint'),
     };
 }
 
-export { formatDate, formatDateRange, getUniversalDateInputTestIds, getValidRange, isCompleteDate, isCompleteDateRange, isCompleteTime, isValidDate, parseDateString, preventDefault, updateRange };
+exports.formatDate = formatDate;
+exports.formatDateRange = formatDateRange;
+exports.getUniversalDateInputTestIds = getUniversalDateInputTestIds;
+exports.getValidRange = getValidRange;
+exports.isCompleteDate = isCompleteDate;
+exports.isCompleteDateRange = isCompleteDateRange;
+exports.isCompleteTime = isCompleteTime;
+exports.isValidDate = isValidDate;
+exports.parseDateString = parseDateString;
+exports.preventDefault = preventDefault;
+exports.updateRange = updateRange;

package/universal-date-input/esm/Component.responsive.js

@@ -26,7 +26,7 @@ import './components/date-input/Component.js';
 import '../../input/esm';
 import '../../popover/esm';
 import '@alfalab/icons-glyph/CalendarMIcon';
-import './index.module-2f3980d9.js';
+import './index.module-7dbb3214.js';
 import './components/date-range-input/Component.js';
 import 'date-fns/isAfter';
 import 'date-fns/startOfMonth';