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

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

@@ -1,42 +1,36 @@
-import { TEMPLATES } from '../consts.js';
-import { createCaretPosPlugin } from './plugins.js';
-import { createPreventCaretJumpPostprocessor } from './postprocessors.js';
-import { createDisallowInputPreprocessor, createValidationPreprocessor } from './preprocessors.js';
-import { segmentsToString, getValueSegments, shiftSegmentsData, segmentsToPattern } from './utils.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 'date-fns/startOfDay';
-import '../../../shared/cssm';
-import 'date-fns/clamp';
-import 'date-fns/getDaysInMonth';
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var consts = require('../consts.js');
+var mask_plugins = require('./plugins.js');
+var mask_postprocessors = require('./postprocessors.js');
+var mask_preprocessors = require('./preprocessors.js');
+var mask_utils = require('./utils.js');
 
 function createMaskOptions(view, min, max, autoCorrection, onCorrection) {
-    const template = TEMPLATES[view];
-    const stringTemplate = segmentsToString(template.segments, template.separators);
+    var template = consts.TEMPLATES[view];
+    var stringTemplate = mask_utils.segmentsToString(template.segments, template.separators);
     return {
         mask: createMaskExpression(template),
-        preprocessors: [
-            createDisallowInputPreprocessor(),
-            ...(autoCorrection
-                ? [createValidationPreprocessor(template, stringTemplate, min, max, onCorrection)]
-                : []),
-        ],
-        postprocessors: [createPreventCaretJumpPostprocessor()],
-        plugins: [createCaretPosPlugin(template)],
+        preprocessors: tslib.__spreadArray([
+            mask_preprocessors.createDisallowInputPreprocessor()
+        ], (autoCorrection
+            ? [mask_preprocessors.createValidationPreprocessor(template, stringTemplate, min, max, onCorrection)]
+            : []), true),
+        postprocessors: [mask_postprocessors.createPreventCaretJumpPostprocessor()],
+        plugins: [mask_plugins.createCaretPosPlugin(template)],
     };
 }
-function createMaskExpression({ segments: templateSegments, separators, }) {
-    return ({ value }) => {
+function createMaskExpression(_a) {
+    var templateSegments = _a.segments, separators = _a.separators;
+    return function (_a) {
+        var value = _a.value;
         if (value.length < 2)
             return [/\d/];
-        const rawSegments = getValueSegments(value, separators);
-        const segments = shiftSegmentsData(rawSegments, templateSegments);
-        return segmentsToPattern(segments, separators);
+        var rawSegments = mask_utils.getValueSegments(value, separators);
+        var segments = mask_utils.shiftSegmentsData(rawSegments, templateSegments);
+        return mask_utils.segmentsToPattern(segments, separators);
     };
 }
 
-export { createMaskOptions };
+exports.createMaskOptions = createMaskOptions;

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

@@ -1,31 +1,31 @@
-import { getValueSegments, findCursorPlace } from './utils.js';
-import 'date-fns/clamp';
-import 'date-fns/getDaysInMonth';
-import '../consts.js';
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var mask_utils = require('./utils.js');
 
 function createCaretPosPlugin(template) {
-    return (element) => {
-        const handleKeyDown = (evt) => {
-            const event = evt;
-            const { selectionStart, selectionEnd, value } = element;
+    return function (element) {
+        var handleKeyDown = function (evt) {
+            var event = evt;
+            var selectionStart = element.selectionStart, selectionEnd = element.selectionEnd, value = element.value;
             if ([' ', '.'].includes(event.key) && selectionStart === selectionEnd) {
-                const nextPos = findNextSegmentPos(value, template, selectionStart || 0);
+                var nextPos = findNextSegmentPos(value, template, selectionStart || 0);
                 element.setSelectionRange(nextPos, nextPos);
             }
         };
         element.addEventListener('keydown', handleKeyDown);
-        return () => element.removeEventListener('keydown', handleKeyDown);
+        return function () { return element.removeEventListener('keydown', handleKeyDown); };
     };
 }
 function findNextSegmentPos(value, template, cursorPos) {
-    const segments = getValueSegments(value, template.separators);
-    const selection = [cursorPos, cursorPos];
-    const currCursorPlace = findCursorPlace(segments, template.segments, template.separators, selection);
+    var _a;
+    var segments = mask_utils.getValueSegments(value, template.separators);
+    var selection = [cursorPos, cursorPos];
+    var currCursorPlace = mask_utils.findCursorPlace(segments, template.segments, template.separators, selection);
     if (currCursorPlace) {
-        let nextCursorPos = 0;
-        for (let i = 0; i < segments.length; i++) {
-            const segment = segments[i];
-            const separatorLen = template.separators[i]?.length || 0;
+        var nextCursorPos = 0;
+        for (var i = 0; i < segments.length; i++) {
+            var segment = segments[i];
+            var separatorLen = ((_a = template.separators[i]) === null || _a === void 0 ? void 0 : _a.length) || 0;
             if (i === currCursorPlace.segmentIdx) {
                 nextCursorPos += segment.length + separatorLen;
                 return nextCursorPos;
@@ -36,4 +36,4 @@ function findNextSegmentPos(value, template, cursorPos) {
     return cursorPos;
 }
 
-export { createCaretPosPlugin };
+exports.createCaretPosPlugin = createCaretPosPlugin;

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

@@ -1,27 +1,24 @@
-import { isDigit } from './utils.js';
-import 'date-fns/clamp';
-import 'date-fns/getDaysInMonth';
-import '../consts.js';
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var mask_utils = require('./utils.js');
 
 function createPreventCaretJumpPostprocessor() {
-    return (state, prevState) => {
-        const [prevFrom, prevTo] = prevState.selection;
-        const { selection, value } = state;
-        const [from, to] = selection;
-        const prevPosIsEqual = prevFrom === prevTo;
-        const posIsEqual = from === to;
-        if (prevPosIsEqual && posIsEqual && from - prevFrom > 1 && !isDigit(value[from - 1])) {
-            let caretPos = from - 1;
-            while (caretPos > 0 && !isDigit(value[caretPos - 1])) {
+    return function (state, prevState) {
+        var _a = prevState.selection, prevFrom = _a[0], prevTo = _a[1];
+        var selection = state.selection, value = state.value;
+        var from = selection[0], to = selection[1];
+        var prevPosIsEqual = prevFrom === prevTo;
+        var posIsEqual = from === to;
+        if (prevPosIsEqual && posIsEqual && from - prevFrom > 1 && !mask_utils.isDigit(value[from - 1])) {
+            var caretPos = from - 1;
+            while (caretPos > 0 && !mask_utils.isDigit(value[caretPos - 1])) {
                 caretPos -= 1;
             }
-            return {
-                ...state,
-                selection: [caretPos, caretPos],
-            };
+            return tslib.__assign(tslib.__assign({}, state), { selection: [caretPos, caretPos] });
         }
         return state;
     };
 }
 
-export { createPreventCaretJumpPostprocessor };
+exports.createPreventCaretJumpPostprocessor = createPreventCaretJumpPostprocessor;

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

@@ -1,112 +1,112 @@
-import isValid from 'date-fns/isValid';
-import { DATE_RANGE_SEPARATOR } from '../consts.js';
-import { parseDateString } from '../utils/index.js';
-import { getValueSegments, shiftSegmentsData, replaceSegmentsData, segmentsToString, parseDateRangeString, validateSegments, removeSeparatorsFromTail, countSeparatorsFromHead } from './utils.js';
-import 'date-fns/differenceInDays';
-import 'date-fns/format';
-import 'date-fns/isSameDay';
-import 'date-fns/parse';
-import 'date-fns/startOfDay';
-import '../../../shared/cssm';
-import 'date-fns/clamp';
-import 'date-fns/getDaysInMonth';
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var isValid = require('date-fns/isValid');
+var consts = require('../consts.js');
+var utils_index = require('../utils/index.js');
+var mask_utils = require('./utils.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var isValid__default = /*#__PURE__*/_interopDefaultCompat(isValid);
 
 function createDisallowInputPreprocessor() {
-    return (state, actionType) => {
-        const { elementState, data } = state;
-        const { value, selection: [from, to], } = elementState;
+    return function (state, actionType) {
+        var elementState = state.elementState, data = state.data;
+        var value = elementState.value, _a = elementState.selection, from = _a[0], to = _a[1];
         // Запрещаем удалять сепаратор
         if (['deleteForward', 'deleteBackward'].includes(actionType)) {
-            const separators = value.slice(from, to).replace(/\d/g, '');
-            const newValue = value.slice(0, from) + separators + value.slice(to);
-            const caretPos = actionType === 'deleteForward' ? to : from;
-            return { elementState: { value: newValue, selection: [caretPos, caretPos] }, data };
+            var separators = value.slice(from, to).replace(/\d/g, '');
+            var newValue = value.slice(0, from) + separators + value.slice(to);
+            var caretPos = actionType === 'deleteForward' ? to : from;
+            return { elementState: { value: newValue, selection: [caretPos, caretPos] }, data: data };
         }
         // разрешаем вводить только цифры
         if (!data.replace(/\D/g, '')) {
-            return { elementState, data: '' };
+            return { elementState: elementState, data: '' };
         }
         return state;
     };
 }
 function createValidationPreprocessor(template, fullStringTemplate, min, max, onCorrection) {
-    const rangeSeparator = template.separators.find((s) => s === DATE_RANGE_SEPARATOR) || '';
-    const dateTemplate = rangeSeparator
+    var rangeSeparator = template.separators.find(function (s) { return s === consts.DATE_RANGE_SEPARATOR; }) || '';
+    var dateTemplate = rangeSeparator
         ? fullStringTemplate.split(rangeSeparator)[0]
         : fullStringTemplate;
-    return (state, actionType) => {
-        const { elementState, data } = state;
-        const { value, selection } = elementState;
-        const isValidation = actionType === 'validation';
-        const [from, to] = selection;
-        const rawValue = value.slice(0, from) + data + value.slice(to);
+    return function (state, actionType) {
+        var _a;
+        var elementState = state.elementState, data = state.data;
+        var value = elementState.value, selection = elementState.selection;
+        var isValidation = actionType === 'validation';
+        var from = selection[0], to = selection[1];
+        var rawValue = value.slice(0, from) + data + value.slice(to);
         if (!rawValue || (isValidation && from !== to))
             return state;
-        const rawSegments = getValueSegments(rawValue, template.separators);
-        const segments = 
+        var rawSegments = mask_utils.getValueSegments(rawValue, template.separators);
+        var segments = 
         // При вставке сдвигаем данные в сегментах
         data.length > 2
-            ? shiftSegmentsData(rawSegments, template.segments)
-            : replaceSegmentsData(rawSegments, template, selection, data);
-        const possibleValue = segmentsToString(segments, template.separators);
-        const dateStrings = parseDateRangeString(possibleValue, dateTemplate.length);
-        let validatedValue = '';
-        const hasRangeSeparator = Boolean(rangeSeparator) && possibleValue.includes(rangeSeparator);
-        let toSelection = to + data.length;
-        for (let i = 0; i < dateStrings.length; i++) {
-            const dateString = dateStrings[i];
-            const { minDate = min, maxDate = max } = getMinMax({
-                hasRangeSeparator,
-                dateStrings,
-                dateTemplate,
+            ? mask_utils.shiftSegmentsData(rawSegments, template.segments)
+            : mask_utils.replaceSegmentsData(rawSegments, template, selection, data);
+        var possibleValue = mask_utils.segmentsToString(segments, template.separators);
+        var dateStrings = mask_utils.parseDateRangeString(possibleValue, dateTemplate.length);
+        var validatedValue = '';
+        var hasRangeSeparator = Boolean(rangeSeparator) && possibleValue.includes(rangeSeparator);
+        var toSelection = to + data.length;
+        for (var i = 0; i < dateStrings.length; i++) {
+            var dateString = dateStrings[i];
+            var _b = getMinMax({
+                hasRangeSeparator: hasRangeSeparator,
+                dateStrings: dateStrings,
+                dateTemplate: dateTemplate,
                 dateIdx: i,
-            });
-            const validateResult = validateSegments({
+            }), _c = _b.minDate, minDate = _c === void 0 ? min : _c, _d = _b.maxDate, maxDate = _d === void 0 ? max : _d;
+            var validateResult = mask_utils.validateSegments({
                 templateSegments: template.segments,
                 segments: validatedValue ? segments.slice(3) : segments,
-                dateTemplate,
+                dateTemplate: dateTemplate,
                 selection: [from, toSelection],
                 min: minDate,
                 max: maxDate,
             });
-            let { validatedDateString } = validateResult;
+            var validatedDateString = validateResult.validatedDateString;
             if (dateStrings.length === 1 || (dateStrings.length > 1 && i > 0)) {
-                validatedDateString = removeSeparatorsFromTail(validatedDateString);
+                validatedDateString = mask_utils.removeSeparatorsFromTail(validatedDateString);
             }
             if (dateString && !validatedDateString)
-                return { elementState, data: '' };
-            [, toSelection] = validateResult.updatedSelection;
+                return { elementState: elementState, data: '' };
+            _a = validateResult.updatedSelection, toSelection = _a[1];
             validatedValue +=
                 hasRangeSeparator && validatedValue
                     ? rangeSeparator + validatedDateString
                     : validatedDateString;
         }
         if (!isValidation) {
-            const clearPossibleValue = possibleValue.replace(/0/g, '');
-            const clearValidatedValue = validatedValue.replace(/0/g, '');
+            var clearPossibleValue = possibleValue.replace(/0/g, '');
+            var clearValidatedValue = validatedValue.replace(/0/g, '');
             if (clearPossibleValue !== clearValidatedValue)
                 onCorrection();
         }
         if (isValidation || !data) {
-            return { elementState: { value: validatedValue, selection: [from, from] }, data };
+            return { elementState: { value: validatedValue, selection: [from, from] }, data: data };
         }
         return insertNewData({
-            elementState,
-            validatedValue,
-            actionType,
-            rawValue,
-            possibleValue,
-            toSelection,
+            elementState: elementState,
+            validatedValue: validatedValue,
+            actionType: actionType,
+            rawValue: rawValue,
+            possibleValue: possibleValue,
+            toSelection: toSelection,
         });
     };
 }
-function insertNewData({ elementState, validatedValue, rawValue, possibleValue, toSelection, }) {
-    const { selection: [from, to], } = elementState;
-    const addedDateSegmentSeparators = Math.max(0, possibleValue.length - rawValue.length);
-    const existSegmentSeparator = countSeparatorsFromHead(validatedValue, from);
-    const selectedChars = to - from;
-    const newData = validatedValue.slice(from + existSegmentSeparator, toSelection - selectedChars + addedDateSegmentSeparators + existSegmentSeparator);
-    const newValue = validatedValue.slice(0, from + existSegmentSeparator) +
+function insertNewData(_a) {
+    var elementState = _a.elementState, validatedValue = _a.validatedValue, rawValue = _a.rawValue, possibleValue = _a.possibleValue, toSelection = _a.toSelection;
+    var _b = elementState.selection, from = _b[0], to = _b[1];
+    var addedDateSegmentSeparators = Math.max(0, possibleValue.length - rawValue.length);
+    var existSegmentSeparator = mask_utils.countSeparatorsFromHead(validatedValue, from);
+    var selectedChars = to - from;
+    var newData = validatedValue.slice(from + existSegmentSeparator, toSelection - selectedChars + addedDateSegmentSeparators + existSegmentSeparator);
+    var newValue = validatedValue.slice(0, from + existSegmentSeparator) +
         validatedValue.slice(to + existSegmentSeparator + newData.length - selectedChars);
     return {
         elementState: {
@@ -116,18 +116,21 @@ function insertNewData({ elementState, validatedValue, rawValue, possibleValue,
         data: newData,
     };
 }
-function getMinMax({ hasRangeSeparator, dateIdx, dateStrings, dateTemplate, }) {
-    const isFirstDateOfRange = hasRangeSeparator && dateIdx === 0 && dateStrings.length === 2;
-    const isSecondDateOfRange = hasRangeSeparator && dateIdx === 1 && dateStrings.length === 2;
-    const isFirstDateFilled = dateStrings[0].length === dateTemplate.length;
-    const isSecondDateFilled = dateStrings[1]?.length === dateTemplate.length;
-    const firstDateOfRange = isFirstDateFilled ? parseDateString(dateStrings[0]) : undefined;
-    const secondDateOfRage = isSecondDateFilled ? parseDateString(dateStrings[1]) : undefined;
-    const firstDateValid = isFirstDateFilled && isValid(firstDateOfRange);
-    const secondDateValid = isSecondDateFilled && isValid(secondDateOfRage);
-    const minDate = isSecondDateOfRange && firstDateValid ? firstDateOfRange : undefined;
-    const maxDate = isFirstDateOfRange && secondDateValid ? secondDateOfRage : undefined;
-    return { minDate, maxDate };
+function getMinMax(_a) {
+    var _b;
+    var hasRangeSeparator = _a.hasRangeSeparator, dateIdx = _a.dateIdx, dateStrings = _a.dateStrings, dateTemplate = _a.dateTemplate;
+    var isFirstDateOfRange = hasRangeSeparator && dateIdx === 0 && dateStrings.length === 2;
+    var isSecondDateOfRange = hasRangeSeparator && dateIdx === 1 && dateStrings.length === 2;
+    var isFirstDateFilled = dateStrings[0].length === dateTemplate.length;
+    var isSecondDateFilled = ((_b = dateStrings[1]) === null || _b === void 0 ? void 0 : _b.length) === dateTemplate.length;
+    var firstDateOfRange = isFirstDateFilled ? utils_index.parseDateString(dateStrings[0]) : undefined;
+    var secondDateOfRage = isSecondDateFilled ? utils_index.parseDateString(dateStrings[1]) : undefined;
+    var firstDateValid = isFirstDateFilled && isValid__default.default(firstDateOfRange);
+    var secondDateValid = isSecondDateFilled && isValid__default.default(secondDateOfRage);
+    var minDate = isSecondDateOfRange && firstDateValid ? firstDateOfRange : undefined;
+    var maxDate = isFirstDateOfRange && secondDateValid ? secondDateOfRage : undefined;
+    return { minDate: minDate, maxDate: maxDate };
 }
 
-export { createDisallowInputPreprocessor, createValidationPreprocessor };
+exports.createDisallowInputPreprocessor = createDisallowInputPreprocessor;
+exports.createValidationPreprocessor = createValidationPreprocessor;