@hh.ru/magritte-ui-input 9.0.12 → 9.1.1

package/{index.esm-LrCm-Ziw.js → index.esm-CO13rGcB.js}

@@ -722,6 +722,20 @@ function countDigits(str) {
     return str.replaceAll(/\W/g, '').length;
 }
 
+function appendDate(initialDate, { day, month, year } = {}) {
+    const date = new Date(initialDate);
+    if (day) {
+        date.setDate(date.getDate() + day);
+    }
+    if (month) {
+        date.setMonth(date.getMonth() + month);
+    }
+    if (year) {
+        date.setFullYear(date.getFullYear() + year);
+    }
+    return date;
+}
+
 const getDateSegmentValueLength = (dateString) => {
     var _a, _b, _c;
     return ({
@@ -830,6 +844,45 @@ const TIME_SEGMENT_VALUE_LENGTHS = {
     seconds: 2,
     milliseconds: 3,
 };
+
+/**
+ * {@link https://unicode-table.com/en/00A0/ Non-breaking space}.
+ */
+const CHAR_NO_BREAK_SPACE = '\u00A0';
+/**
+ * {@link https://unicode-table.com/en/2013/ EN dash}
+ * is used to indicate a range of numbers or a span of time.
+ * @example 2006–2022
+ */
+const CHAR_EN_DASH = '\u2013';
+/**
+ * {@link https://unicode-table.com/en/2014/ EM dash}
+ * is used to mark a break in a sentence.
+ * @example Taiga UI — powerful set of open source components for Angular
+ * ___
+ * Don't confuse with {@link CHAR_EN_DASH} or {@link CHAR_HYPHEN}!
+ */
+const CHAR_EM_DASH = '\u2014';
+/**
+ * {@link https://unicode-table.com/en/002D/ Hyphen (minus sign)}
+ * is used to combine words.
+ * @example well-behaved
+ * ___
+ * Don't confuse with {@link CHAR_EN_DASH} or {@link CHAR_EM_DASH}!
+ */
+const CHAR_HYPHEN = '\u002D';
+/**
+ * {@link https://unicode-table.com/en/2212/ Minus}
+ * is used as math operator symbol or before negative digits.
+ * ---
+ * Can be used as `−`. Don't confuse with {@link CHAR_HYPHEN}
+ */
+const CHAR_MINUS = '\u2212';
+/**
+ * {@link https://symbl.cc/en/30FC/ Katakana-Hiragana Prolonged Sound Mark}
+ * is used as prolonged sounds in Japanese.
+ */
+const CHAR_JP_HYPHEN = '\u30FC';
 /**
  * {@link https://symbl.cc/en/003A/ Colon}
  * is a punctuation mark that connects parts of a text logically.
@@ -891,6 +944,14 @@ function escapeRegExp(str) {
     return str && reHasRegExpChar.test(str) ? str.replaceAll(reRegExpChar, '\\$&') : str;
 }
 
+function identity(x) {
+    return x;
+}
+
+function isEmpty(entity) {
+    return !entity || (typeof entity === 'object' && Object.keys(entity).length === 0);
+}
+
 function padWithZeroesUntilValid(segmentValue, paddedMaxValue, prefixedZeroesCount = 0) {
     if (Number(segmentValue.padEnd(paddedMaxValue.length, '0')) <= Number(paddedMaxValue)) {
         return { validatedSegmentValue: segmentValue, prefixedZeroesCount };
@@ -1270,6 +1331,122 @@ function maskitoDateOptionsGenerator({ mode, separator = '.', max, min, }) {
         ] });
 }
 
+const POSSIBLE_DATE_RANGE_SEPARATOR = [
+    CHAR_HYPHEN,
+    CHAR_EN_DASH,
+    CHAR_EM_DASH,
+    CHAR_MINUS,
+    CHAR_JP_HYPHEN,
+];
+
+function createMinMaxRangeLengthPostprocessor({ dateModeTemplate, rangeSeparator, minLength, maxLength, max = DEFAULT_MAX_DATE, }) {
+    if (isEmpty(minLength) && isEmpty(maxLength)) {
+        return identity;
+    }
+    return ({ value, selection }) => {
+        const dateStrings = parseDateRangeString(value, dateModeTemplate, rangeSeparator);
+        if (dateStrings.length !== 2 ||
+            dateStrings.some(date => !isDateStringComplete(date, dateModeTemplate))) {
+            return { value, selection };
+        }
+        const [fromDate, toDate] = dateStrings.map(dateString => segmentsToDate(parseDateString(dateString, dateModeTemplate)));
+        const minDistantToDate = appendDate(fromDate, Object.assign(Object.assign({}, minLength), { 
+            // 06.02.2023 - 07.02.2023 => {minLength: {day: 3}} => 06.02.2023 - 08.02.2023
+            // "from"-day is included in the range
+            day: (minLength === null || minLength === void 0 ? void 0 : minLength.day) && minLength.day - 1 }));
+        const maxDistantToDate = !isEmpty(maxLength)
+            ? appendDate(fromDate, Object.assign(Object.assign({}, maxLength), { day: (maxLength === null || maxLength === void 0 ? void 0 : maxLength.day) && maxLength.day - 1 }))
+            : max;
+        const minLengthClampedToDate = clamp(toDate, minDistantToDate, max);
+        const minMaxLengthClampedToDate = minLengthClampedToDate > maxDistantToDate
+            ? maxDistantToDate
+            : minLengthClampedToDate;
+        return {
+            selection,
+            value: dateStrings[0] +
+                rangeSeparator +
+                toDateString(dateToSegments(minMaxLengthClampedToDate), {
+                    dateMode: dateModeTemplate,
+                }),
+        };
+    };
+}
+
+function createSwapDatesPostprocessor({ dateModeTemplate, rangeSeparator, }) {
+    return ({ value, selection }) => {
+        const dateStrings = parseDateRangeString(value, dateModeTemplate, rangeSeparator);
+        const isDateRangeComplete = dateStrings.length === 2 &&
+            dateStrings.every(date => isDateStringComplete(date, dateModeTemplate));
+        const [from, to] = selection;
+        const caretAtTheEnd = from >= value.length;
+        const allValueSelected = from === 0 && to >= value.length; // dropping text inside with a pointer
+        if (!(caretAtTheEnd || allValueSelected) || !isDateRangeComplete) {
+            return { value, selection };
+        }
+        const [fromDate, toDate] = dateStrings.map(dateString => segmentsToDate(parseDateString(dateString, dateModeTemplate)));
+        return {
+            selection,
+            value: fromDate > toDate ? dateStrings.reverse().join(rangeSeparator) : value,
+        };
+    };
+}
+
+function maskitoDateRangeOptionsGenerator({ mode, min, max, minLength, maxLength, dateSeparator = '.', rangeSeparator = `${CHAR_NO_BREAK_SPACE}${CHAR_EN_DASH}${CHAR_NO_BREAK_SPACE}`, }) {
+    const dateModeTemplate = mode.split('/').join(dateSeparator);
+    const dateMask = Array.from(dateModeTemplate).map(char => char === dateSeparator ? char : /\d/);
+    return Object.assign(Object.assign({}, MASKITO_DEFAULT_OPTIONS), { mask: [...dateMask, ...Array.from(rangeSeparator), ...dateMask], overwriteMode: 'replace', preprocessors: [
+            createFullWidthToHalfWidthPreprocessor(),
+            createFirstDateEndSeparatorPreprocessor({
+                dateModeTemplate,
+                dateSegmentSeparator: dateSeparator,
+                firstDateEndSeparator: rangeSeparator,
+                pseudoFirstDateEndSeparators: POSSIBLE_DATE_RANGE_SEPARATOR,
+            }),
+            createZeroPlaceholdersPreprocessor(),
+            normalizeDatePreprocessor({
+                dateModeTemplate,
+                rangeSeparator,
+                dateSegmentsSeparator: dateSeparator,
+            }),
+            createValidDatePreprocessor({
+                dateModeTemplate,
+                rangeSeparator,
+                dateSegmentsSeparator: dateSeparator,
+            }),
+        ], postprocessors: [
+            createDateSegmentsZeroPaddingPostprocessor({
+                dateModeTemplate,
+                dateSegmentSeparator: dateSeparator,
+                splitFn: value => ({
+                    dateStrings: parseDateRangeString(value, dateModeTemplate, rangeSeparator),
+                }),
+                uniteFn: (validatedDateStrings, initialValue) => validatedDateStrings.reduce((acc, dateString, dateIndex) => acc +
+                    dateString +
+                    (!dateIndex && initialValue.includes(rangeSeparator)
+                        ? rangeSeparator
+                        : ''), ''),
+            }),
+            createMinMaxDatePostprocessor({
+                min,
+                max,
+                dateModeTemplate,
+                rangeSeparator,
+                dateSegmentSeparator: dateSeparator,
+            }),
+            createMinMaxRangeLengthPostprocessor({
+                dateModeTemplate,
+                minLength,
+                maxLength,
+                max,
+                rangeSeparator,
+            }),
+            createSwapDatesPostprocessor({
+                dateModeTemplate,
+                rangeSeparator,
+            }),
+        ] });
+}
+
 function padTimeSegments(timeSegments) {
     return Object.fromEntries(Object.entries(timeSegments).map(([segmentName, segmentValue]) => [
         segmentName,
@@ -1646,5 +1823,5 @@ const useMaskito = ({
   return onRefChange;
 };
 
-export { MASKITO_DEFAULT_OPTIONS as M, maskitoDateTimeOptionsGenerator as a, maskitoTimeOptionsGenerator as b, maskitoDateOptionsGenerator as m, useMaskito as u };
-//# sourceMappingURL=index.esm-LrCm-Ziw.js.map
+export { MASKITO_DEFAULT_OPTIONS as M, maskitoDateRangeOptionsGenerator as a, maskitoDateTimeOptionsGenerator as b, maskitoTimeOptionsGenerator as c, maskitoDateOptionsGenerator as m, useMaskito as u };
+//# sourceMappingURL=index.esm-CO13rGcB.js.map