@taiga-ui/cdk 2.26.0 → 2.29.0

package/bundles/taiga-ui-cdk-date-time.umd.js

@@ -279,6 +279,10 @@
         factory: function () { return 'DMY'; },
     });
 
+    var TUI_DATE_SEPARATOR = new core.InjectionToken('Date separator for Taiga UI components', {
+        factory: function () { return '.'; },
+    });
+
     /**
      * Immutable year object
      * @nosideeffects
@@ -288,6 +292,54 @@
             this.year = year;
             classes.tuiAssert.assert(TuiYear.isValidYear(year));
         }
+        /**
+         * Checks year for validity
+         */
+        TuiYear.isValidYear = function (year) {
+            return Number.isInteger(year) && math.inRange(year, MIN_YEAR, MAX_YEAR + 1);
+        };
+        /**
+         * Check if passed year is a leap year
+         */
+        TuiYear.isLeapYear = function (year) {
+            classes.tuiAssert.assert(TuiYear.isValidYear(year));
+            return year % 400 === 0 || (year % 4 === 0 && year % 100 !== 0);
+        };
+        /**
+         * Returns amount of leap years from year 0 to the passed one
+         */
+        TuiYear.getAbsoluteLeapYears = function (year) {
+            classes.tuiAssert.assert(TuiYear.isValidYear(year));
+            return Math.ceil(year / 400) + (Math.ceil(year / 4) - Math.ceil(year / 100));
+        };
+        /**
+         * @deprecated DONT USE IT (will be deleted soon)
+         *
+         * Returns day of week offset of the beginning of the passed year
+         *
+         * @param year
+         * @param absoluteLeapYears amount of leap years prior to the passed one
+         * @return offset in days
+         */
+        TuiYear.getYearStartDaysOffset = function (year, absoluteLeapYears) {
+            classes.tuiAssert.assert(TuiYear.isValidYear(year));
+            classes.tuiAssert.assert(Number.isInteger(absoluteLeapYears));
+            classes.tuiAssert.assert(year >= absoluteLeapYears);
+            classes.tuiAssert.assert(absoluteLeapYears >= 0);
+            return ((absoluteLeapYears * DAYS_IN_LEAP_YEAR +
+                (year - absoluteLeapYears) * DAYS_IN_NORMAL_YEAR +
+                5) %
+                DAYS_IN_WEEK);
+        };
+        TuiYear.lengthBetween = function (from, to) {
+            return to.year - from.year;
+        };
+        /**
+         * Normalizes year by clamping it between min and max years
+         */
+        TuiYear.normalizeYearPart = function (year) {
+            return math.normalizeToIntNumber(year, MIN_YEAR, MAX_YEAR);
+        };
         Object.defineProperty(TuiYear.prototype, "formattedYear", {
             get: function () {
                 return format.padStart(this.year.toString(), 4, '0');
@@ -380,54 +432,6 @@
         TuiYear.prototype.toJSON = function () {
             return this.formattedYear;
         };
-        /**
-         * Checks year for validity
-         */
-        TuiYear.isValidYear = function (year) {
-            return Number.isInteger(year) && math.inRange(year, MIN_YEAR, MAX_YEAR + 1);
-        };
-        /**
-         * Check if passed year is a leap year
-         */
-        TuiYear.isLeapYear = function (year) {
-            classes.tuiAssert.assert(TuiYear.isValidYear(year));
-            return year % 400 === 0 || (year % 4 === 0 && year % 100 !== 0);
-        };
-        /**
-         * Returns amount of leap years from year 0 to the passed one
-         */
-        TuiYear.getAbsoluteLeapYears = function (year) {
-            classes.tuiAssert.assert(TuiYear.isValidYear(year));
-            return Math.ceil(year / 400) + (Math.ceil(year / 4) - Math.ceil(year / 100));
-        };
-        /**
-         * @deprecated DONT USE IT (will be deleted soon)
-         *
-         * Returns day of week offset of the beginning of the passed year
-         *
-         * @param year
-         * @param absoluteLeapYears amount of leap years prior to the passed one
-         * @return offset in days
-         */
-        TuiYear.getYearStartDaysOffset = function (year, absoluteLeapYears) {
-            classes.tuiAssert.assert(TuiYear.isValidYear(year));
-            classes.tuiAssert.assert(Number.isInteger(absoluteLeapYears));
-            classes.tuiAssert.assert(year >= absoluteLeapYears);
-            classes.tuiAssert.assert(absoluteLeapYears >= 0);
-            return ((absoluteLeapYears * DAYS_IN_LEAP_YEAR +
-                (year - absoluteLeapYears) * DAYS_IN_NORMAL_YEAR +
-                5) %
-                DAYS_IN_WEEK);
-        };
-        TuiYear.lengthBetween = function (from, to) {
-            return to.year - from.year;
-        };
-        /**
-         * Normalizes year by clamping it between min and max years
-         */
-        TuiYear.normalizeYearPart = function (year) {
-            return math.normalizeToIntNumber(year, MIN_YEAR, MAX_YEAR);
-        };
         return TuiYear;
     }());
 
@@ -446,6 +450,61 @@
             classes.tuiAssert.assert(TuiMonth.isValidMonth(year, month));
             return _this;
         }
+        /**
+         * Tests month and year for validity
+         */
+        TuiMonth.isValidMonth = function (year, month) {
+            return TuiYear.isValidYear(year) && TuiMonth.isValidMonthPart(month);
+        };
+        /**
+         * Returns number of days in a month
+         */
+        TuiMonth.getMonthDaysCount = function (month, isLeapYear) {
+            classes.tuiAssert.assert(TuiMonth.isValidMonthPart(month));
+            switch (month) {
+                case 1 /* February */:
+                    return isLeapYear ? 29 : 28;
+                case 3 /* April */:
+                case 5 /* June */:
+                case 8 /* September */:
+                case 10 /* November */:
+                    return 30;
+                default:
+                    return 31;
+            }
+        };
+        /**
+         * Returns current month and year based on local time zone
+         * @nosideeffects
+         */
+        TuiMonth.currentLocal = function () {
+            var nativeDate = new Date();
+            return new TuiMonth(nativeDate.getFullYear(), nativeDate.getMonth());
+        };
+        /**
+         * Returns current month and year based on UTC
+         */
+        TuiMonth.currentUtc = function () {
+            var nativeDate = new Date();
+            return new TuiMonth(nativeDate.getUTCFullYear(), nativeDate.getUTCMonth());
+        };
+        TuiMonth.lengthBetween = function (from, to) {
+            var absoluteFrom = from.month + from.year * 12;
+            var absoluteTo = to.month + to.year * 12;
+            return absoluteTo - absoluteFrom;
+        };
+        /**
+         * Normalizes number by clamping it between min and max month
+         */
+        TuiMonth.normalizeMonthPart = function (month) {
+            return math.normalizeToIntNumber(month, MIN_MONTH, MAX_MONTH);
+        };
+        /**
+         * Tests month for validity
+         */
+        TuiMonth.isValidMonthPart = function (month) {
+            return Number.isInteger(month) && math.inRange(month, MIN_MONTH, MAX_MONTH + 1);
+        };
         Object.defineProperty(TuiMonth.prototype, "formattedMonthPart", {
             get: function () {
                 return format.padStart((this.month + 1).toString(), 2, '0');
@@ -571,76 +630,163 @@
         TuiMonth.prototype.toUtcNativeDate = function () {
             return new Date(Date.UTC(this.year, this.month));
         };
+        return TuiMonth;
+    }(TuiYear));
+
+    // TODO: Localized formatting
+    /**
+     * Immutable date object, consisting of day, month and year
+     */
+    var TuiDay = /** @class */ (function (_super) {
+        __extends(TuiDay, _super);
+        function TuiDay(year, month, day) {
+            var _this = _super.call(this, year, month) || this;
+            _this.day = day;
+            classes.tuiAssert.assert(TuiDay.isValidDay(year, month, day));
+            return _this;
+        }
         /**
-         * Tests month and year for validity
+         * Creates {@link TuiDay} from native {@link Date} based on local time zone
          */
-        TuiMonth.isValidMonth = function (year, month) {
-            return TuiYear.isValidYear(year) && TuiMonth.isValidMonthPart(month);
+        TuiDay.fromLocalNativeDate = function (date) {
+            return new TuiDay(date.getFullYear(), date.getMonth(), date.getDate());
         };
         /**
-         * Returns number of days in a month
+         * Creates {@link TuiDay} from native {@link Date} using UTC
          */
-        TuiMonth.getMonthDaysCount = function (month, isLeapYear) {
-            classes.tuiAssert.assert(TuiMonth.isValidMonthPart(month));
-            switch (month) {
-                case 1 /* February */:
-                    return isLeapYear ? 29 : 28;
-                case 3 /* April */:
-                case 5 /* June */:
-                case 8 /* September */:
-                case 10 /* November */:
-                    return 30;
-                default:
-                    return 31;
+        TuiDay.fromUtcNativeDate = function (date) {
+            return new TuiDay(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
+        };
+        /**
+         * Check validity of year, month and day
+         *
+         * @param year
+         * @param month
+         * @param day
+         * @return boolean validity
+         */
+        TuiDay.isValidDay = function (year, month, day) {
+            return (TuiMonth.isValidMonth(year, month) &&
+                Number.isInteger(day) &&
+                math.inRange(day, MIN_DAY, TuiMonth.getMonthDaysCount(month, TuiYear.isLeapYear(year)) + 1));
+        };
+        /**
+         * @deprecated DONT USE IT (will be deleted soon)
+         *
+         * Calculated day on a calendar grid
+         *
+         * @param month
+         * @param row row in a calendar
+         * @param col column in a calendar
+         * @return resulting day on these coordinates (could exceed passed month)
+         */
+        TuiDay.getDayFromMonthRowCol = function (month, row, col) {
+            classes.tuiAssert.assert(Number.isInteger(row));
+            classes.tuiAssert.assert(math.inRange(row, 0, 6));
+            classes.tuiAssert.assert(Number.isInteger(col));
+            classes.tuiAssert.assert(math.inRange(col, 0, DAYS_IN_WEEK));
+            var day = row * DAYS_IN_WEEK + col - month.monthStartDaysOffset + 1;
+            if (day > month.daysCount) {
+                day = day - month.daysCount;
+                month = month.append({ month: 1 });
             }
+            if (day <= 0) {
+                month = month.append({ month: -1 });
+                day = month.daysCount + day;
+            }
+            return new TuiDay(month.year, month.month, day);
         };
         /**
-         * Returns current month and year based on local time zone
-         * @nosideeffects
+         * Current day based on local time zone
          */
-        TuiMonth.currentLocal = function () {
+        TuiDay.currentLocal = function () {
             var nativeDate = new Date();
-            return new TuiMonth(nativeDate.getFullYear(), nativeDate.getMonth());
+            var year = nativeDate.getFullYear();
+            var month = nativeDate.getMonth();
+            var day = nativeDate.getDate();
+            return new TuiDay(year, month, day);
         };
         /**
-         * Returns current month and year based on UTC
+         * Calculates {@link TuiDay} normalizing year, month and day. {@link NaN} is turned into minimal value.
+         *
+         * @param year any year value, including invalid
+         * @param month any month value, including invalid (months start with 0)
+         * @param day any day value, including invalid
+         * @return normalized date
          */
-        TuiMonth.currentUtc = function () {
-            var nativeDate = new Date();
-            return new TuiMonth(nativeDate.getUTCFullYear(), nativeDate.getUTCMonth());
+        TuiDay.normalizeOf = function (year, month, day) {
+            var normalizedYear = TuiYear.normalizeYearPart(year);
+            var normalizedMonth = TuiMonth.normalizeMonthPart(month);
+            var normalizedDay = TuiDay.normalizeDayPart(day, normalizedMonth, normalizedYear);
+            return new TuiDay(normalizedYear, normalizedMonth, normalizedDay);
         };
-        TuiMonth.lengthBetween = function (from, to) {
-            var absoluteFrom = from.month + from.year * 12;
-            var absoluteTo = to.month + to.year * 12;
-            return absoluteTo - absoluteFrom;
+        TuiDay.lengthBetween = function (from, to) {
+            return Math.round((to.toLocalNativeDate().getTime() - from.toLocalNativeDate().getTime()) /
+                (1000 * 60 * 60 * 24));
+        };
+        TuiDay.parseRawDateString = function (date, dateMode) {
+            if (dateMode === void 0) { dateMode = 'DMY'; }
+            classes.tuiAssert.assert(date.length === DATE_FILLER_LENGTH, '[parseRawDateString]: wrong date string length');
+            switch (dateMode) {
+                case 'YMD':
+                    return {
+                        day: parseInt(date.slice(8, 10), 10),
+                        month: parseInt(date.slice(5, 7), 10) - 1,
+                        year: parseInt(date.slice(0, 4), 10),
+                    };
+                case 'MDY':
+                    return {
+                        day: parseInt(date.slice(3, 5), 10),
+                        month: parseInt(date.slice(0, 2), 10) - 1,
+                        year: parseInt(date.slice(6, 10), 10),
+                    };
+                default:
+                case 'DMY':
+                    return {
+                        day: parseInt(date.slice(0, 2), 10),
+                        month: parseInt(date.slice(3, 5), 10) - 1,
+                        year: parseInt(date.slice(6, 10), 10),
+                    };
+            }
         };
+        // TODO: Move month and year related code corresponding classes
         /**
-         * Normalizes number by clamping it between min and max month
+         * Parsing a string with date with normalization
+         *
+         * @param rawDate date string
+         * @param dateMode date format of the date string (DMY | MDY | YMD)
+         * @return normalized date
          */
-        TuiMonth.normalizeMonthPart = function (month) {
-            return math.normalizeToIntNumber(month, MIN_MONTH, MAX_MONTH);
+        TuiDay.normalizeParse = function (rawDate, dateMode) {
+            if (dateMode === void 0) { dateMode = 'DMY'; }
+            var _a = this.parseRawDateString(rawDate, dateMode), day = _a.day, month = _a.month, year = _a.year;
+            return TuiDay.normalizeOf(year, month, day);
         };
         /**
-         * Tests month for validity
+         * Parsing a date stringified in a toJSON format
+         * @param yearMonthDayString date string in format of YYYY-MM-DD
+         * @return date
+         * @throws exceptions if any part of the date is invalid
          */
-        TuiMonth.isValidMonthPart = function (month) {
-            return Number.isInteger(month) && math.inRange(month, MIN_MONTH, MAX_MONTH + 1);
-        };
-        return TuiMonth;
-    }(TuiYear));
-
-    // TODO: Localized formatting
-    /**
-     * Immutable date object, consisting of day, month and year
-     */
-    var TuiDay = /** @class */ (function (_super) {
-        __extends(TuiDay, _super);
-        function TuiDay(year, month, day) {
-            var _this = _super.call(this, year, month) || this;
-            _this.day = day;
-            classes.tuiAssert.assert(TuiDay.isValidDay(year, month, day));
-            return _this;
-        }
+        TuiDay.jsonParse = function (yearMonthDayString) {
+            var _a = this.parseRawDateString(yearMonthDayString, 'YMD'), day = _a.day, month = _a.month, year = _a.year;
+            if (!TuiYear.isValidYear(year)) {
+                throw new Error('Invalid year: ' + year);
+            }
+            if (!TuiMonth.isValidMonth(year, month)) {
+                throw new Error('Invalid month: ' + month);
+            }
+            if (!Number.isInteger(day) ||
+                !math.inRange(day, MIN_DAY, TuiMonth.getMonthDaysCount(month, TuiYear.isLeapYear(year)) + 1)) {
+                throw new Error('Invalid day: ' + day);
+            }
+            return new TuiDay(year, month, day);
+        };
+        TuiDay.normalizeDayPart = function (day, month, year) {
+            classes.tuiAssert.assert(TuiMonth.isValidMonth(year, month));
+            var monthDaysCount = TuiMonth.getMonthDaysCount(month, TuiYear.isLeapYear(year));
+            return math.normalizeToIntNumber(day, 1, monthDaysCount);
+        };
         Object.defineProperty(TuiDay.prototype, "formattedDayPart", {
             get: function () {
                 return format.padStart(this.day.toString(), 2, '0');
@@ -650,6 +796,8 @@
         });
         Object.defineProperty(TuiDay.prototype, "formattedDay", {
             /**
+             * @deprecated use {@link getFormattedDay} instead
+             * TODO remove in 3.0
              * Formatted whole date
              */
             get: function () {
@@ -775,8 +923,28 @@
             }
             return new TuiDay(years, months, days);
         };
-        TuiDay.prototype.toString = function () {
-            return this.formattedDay;
+        /**
+         * Returns formatted whole date
+         */
+        TuiDay.prototype.getFormattedDay = function (dateFormat, separator) {
+            classes.tuiAssert.assert(separator.length === 1, 'Separator should consist of only 1 symbol');
+            var dd = this.formattedDayPart;
+            var mm = this.formattedMonthPart;
+            var yyyy = this.formattedYear;
+            switch (dateFormat) {
+                case 'YMD':
+                    return "" + yyyy + separator + mm + separator + dd;
+                case 'MDY':
+                    return "" + mm + separator + dd + separator + yyyy;
+                case 'DMY':
+                default:
+                    return "" + dd + separator + mm + separator + yyyy;
+            }
+        };
+        TuiDay.prototype.toString = function (dateFormat, separator) {
+            if (dateFormat === void 0) { dateFormat = 'DMY'; }
+            if (separator === void 0) { separator = '.'; }
+            return this.getFormattedDay(dateFormat, separator);
         };
         TuiDay.prototype.toJSON = function () {
             return _super.prototype.toJSON.call(this) + "-" + this.formattedDayPart;
@@ -793,125 +961,6 @@
         TuiDay.prototype.toUtcNativeDate = function () {
             return new Date(Date.UTC(this.year, this.month, this.day));
         };
-        /**
-         * Creates {@link TuiDay} from native {@link Date} based on local time zone
-         */
-        TuiDay.fromLocalNativeDate = function (date) {
-            return new TuiDay(date.getFullYear(), date.getMonth(), date.getDate());
-        };
-        /**
-         * Creates {@link TuiDay} from native {@link Date} using UTC
-         */
-        TuiDay.fromUtcNativeDate = function (date) {
-            return new TuiDay(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
-        };
-        /**
-         * Check validity of year, month and day
-         *
-         * @param year
-         * @param month
-         * @param day
-         * @return boolean validity
-         */
-        TuiDay.isValidDay = function (year, month, day) {
-            return (TuiMonth.isValidMonth(year, month) &&
-                Number.isInteger(day) &&
-                math.inRange(day, MIN_DAY, TuiMonth.getMonthDaysCount(month, TuiYear.isLeapYear(year)) + 1));
-        };
-        /**
-         * @deprecated DONT USE IT (will be deleted soon)
-         *
-         * Calculated day on a calendar grid
-         *
-         * @param month
-         * @param row row in a calendar
-         * @param col column in a calendar
-         * @return resulting day on these coordinates (could exceed passed month)
-         */
-        TuiDay.getDayFromMonthRowCol = function (month, row, col) {
-            classes.tuiAssert.assert(Number.isInteger(row));
-            classes.tuiAssert.assert(math.inRange(row, 0, 6));
-            classes.tuiAssert.assert(Number.isInteger(col));
-            classes.tuiAssert.assert(math.inRange(col, 0, DAYS_IN_WEEK));
-            var day = row * DAYS_IN_WEEK + col - month.monthStartDaysOffset + 1;
-            if (day > month.daysCount) {
-                day = day - month.daysCount;
-                month = month.append({ month: 1 });
-            }
-            if (day <= 0) {
-                month = month.append({ month: -1 });
-                day = month.daysCount + day;
-            }
-            return new TuiDay(month.year, month.month, day);
-        };
-        /**
-         * Current day based on local time zone
-         */
-        TuiDay.currentLocal = function () {
-            var nativeDate = new Date();
-            var year = nativeDate.getFullYear();
-            var month = nativeDate.getMonth();
-            var day = nativeDate.getDate();
-            return new TuiDay(year, month, day);
-        };
-        /**
-         * Calculates {@link TuiDay} normalizing year, month and day. {@link NaN} is turned into minimal value.
-         *
-         * @param year any year value, including invalid
-         * @param month any month value, including invalid (months start with 0)
-         * @param day any day value, including invalid
-         * @return normalized date
-         */
-        TuiDay.normalizeOf = function (year, month, day) {
-            var normalizedYear = TuiYear.normalizeYearPart(year);
-            var normalizedMonth = TuiMonth.normalizeMonthPart(month);
-            var normalizedDay = TuiDay.normalizeDayPart(day, normalizedMonth, normalizedYear);
-            return new TuiDay(normalizedYear, normalizedMonth, normalizedDay);
-        };
-        TuiDay.lengthBetween = function (from, to) {
-            return Math.round((to.toLocalNativeDate().getTime() - from.toLocalNativeDate().getTime()) /
-                (1000 * 60 * 60 * 24));
-        };
-        // TODO: Move month and year related code corresponding classes
-        /**
-         * Parsing a string with date with normalization
-         *
-         * @param yearMonthDayString date string in format of DD.MM.Yyyy
-         * @return normalized date
-         */
-        TuiDay.normalizeParse = function (yearMonthDayString) {
-            var day = parseInt(yearMonthDayString.slice(0, 2), 10);
-            var month = parseInt(yearMonthDayString.slice(3, 5), 10) - 1;
-            var year = parseInt(yearMonthDayString.slice(6, 10), 10);
-            return TuiDay.normalizeOf(year, month, day);
-        };
-        /**
-         * Parsing a date stringified in a toJSON format
-         * @param yearMonthDayString date string in format of YYYY-MM-DD
-         * @return date
-         * @throws exceptions if any part of the date is invalid
-         */
-        TuiDay.jsonParse = function (yearMonthDayString) {
-            var day = parseInt(yearMonthDayString.slice(8, 10), 10);
-            var month = parseInt(yearMonthDayString.slice(5, 7), 10) - 1;
-            var year = parseInt(yearMonthDayString.slice(0, 4), 10);
-            if (!TuiYear.isValidYear(year)) {
-                throw new Error('Invalid year: ' + year);
-            }
-            if (!TuiMonth.isValidMonth(year, month)) {
-                throw new Error('Invalid month: ' + month);
-            }
-            if (!Number.isInteger(day) ||
-                !math.inRange(day, MIN_DAY, TuiMonth.getMonthDaysCount(month, TuiYear.isLeapYear(year)) + 1)) {
-                throw new Error('Invalid day: ' + day);
-            }
-            return new TuiDay(year, month, day);
-        };
-        TuiDay.normalizeDayPart = function (day, month, year) {
-            classes.tuiAssert.assert(TuiMonth.isValidMonth(year, month));
-            var monthDaysCount = TuiMonth.getMonthDaysCount(month, TuiYear.isLeapYear(year));
-            return math.normalizeToIntNumber(day, 1, monthDaysCount);
-        };
         return TuiDay;
     }(TuiMonth));
 
@@ -924,6 +973,11 @@
             this.to = to;
             classes.tuiAssert.assert(from.monthSameOrBefore(to));
         }
+        TuiMonthRange.sort = function (month1, month2) {
+            return month1.monthSameOrBefore(month2)
+                ? new TuiMonthRange(month1, month2)
+                : new TuiMonthRange(month2, month1);
+        };
         Object.defineProperty(TuiMonthRange.prototype, "isSingleMonth", {
             get: function () {
                 return this.from.monthSame(this.to);
@@ -944,14 +998,16 @@
         TuiMonthRange.prototype.toString = function () {
             return "" + this.from + RANGE_SEPARATOR_CHAR + this.to;
         };
-        TuiMonthRange.sort = function (month1, month2) {
-            return month1.monthSameOrBefore(month2)
-                ? new TuiMonthRange(month1, month2)
-                : new TuiMonthRange(month2, month1);
-        };
         return TuiMonthRange;
     }());
 
+    /**
+     * Temporary type guard to satisfy ts-overloading of normalizeParse method
+     * @deprecated TODO rm in v3.0
+     */
+    var isDateMode = function (dateMode) {
+        return ['DMY', 'YMD', 'MDY'].includes(dateMode);
+    };
     /**
      * An immutable range of two {@link TuiDay} objects
      */
@@ -964,6 +1020,34 @@
             classes.tuiAssert.assert(from.daySameOrBefore(to));
             return _this;
         }
+        /**
+         * Creates range from two days after sorting them
+         *
+         * @param day1
+         * @param day2
+         * @return new range with sorted days
+         */
+        TuiDayRange.sort = function (day1, day2) {
+            return day1.daySameOrBefore(day2)
+                ? new TuiDayRange(day1, day2)
+                : new TuiDayRange(day2, day1);
+        };
+        /**
+         * Parse and correct a day range in string format
+         *
+         * @param rangeString a string of dates in a format dd.mm.yyyy - dd.mm.yyyy
+         * @param dateMode {@link TuiDateMode}
+         * @return normalized day range object
+         */
+        TuiDayRange.normalizeParse = function (rangeString, dateMode) {
+            if (dateMode === void 0) { dateMode = 'DMY'; }
+            var dateFormat = isDateMode(dateMode) ? dateMode : 'DMY';
+            var leftDay = TuiDay.normalizeParse(rangeString.slice(0, DATE_FILLER_LENGTH), dateFormat);
+            if (rangeString.length < DATE_RANGE_FILLER_LENGTH) {
+                return new TuiDayRange(leftDay, leftDay);
+            }
+            return TuiDayRange.sort(leftDay, TuiDay.normalizeParse(rangeString.slice(DATE_FILLER_LENGTH + RANGE_SEPARATOR_CHAR.length), dateFormat));
+        };
         Object.defineProperty(TuiDayRange.prototype, "isSingleDay", {
             get: function () {
                 return this.from.daySame(this.to);
@@ -974,9 +1058,12 @@
         Object.defineProperty(TuiDayRange.prototype, "formattedDayRange", {
             /**
              * Human readable format.
+             * @deprecated use {@link getFormattedDayRange} instead
              */
             get: function () {
-                return "" + this.from.formattedDay + RANGE_SEPARATOR_CHAR + this.to.formattedDay;
+                var from = this.from.getFormattedDay('DMY', '.');
+                var to = this.to.getFormattedDay('DMY', '.');
+                return "" + from + RANGE_SEPARATOR_CHAR + to;
             },
             enumerable: true,
             configurable: true
@@ -1001,29 +1088,19 @@
             return new TuiDayRange(this.from.dayLimit(min, max), this.to.dayLimit(min, max));
         };
         /**
-         * Creates range from two days after sorting them
-         *
-         * @param day1
-         * @param day2
-         * @return new range with sorted days
-         */
-        TuiDayRange.sort = function (day1, day2) {
-            return day1.daySameOrBefore(day2)
-                ? new TuiDayRange(day1, day2)
-                : new TuiDayRange(day2, day1);
-        };
-        /**
-         * Parse and correct a day range in string format
-         *
-         * @param rangeString a string of dates in a format dd.mm.yyyy - dd.mm.yyyy
-         * @return normalized day range object
+         * Human readable format.
          */
-        TuiDayRange.normalizeParse = function (rangeString) {
-            var leftDay = TuiDay.normalizeParse(rangeString.slice(0, DATE_FILLER_LENGTH));
-            if (rangeString.length < DATE_RANGE_FILLER_LENGTH) {
-                return new TuiDayRange(leftDay, leftDay);
-            }
-            return TuiDayRange.sort(leftDay, TuiDay.normalizeParse(rangeString.slice(DATE_FILLER_LENGTH + RANGE_SEPARATOR_CHAR.length)));
+        TuiDayRange.prototype.getFormattedDayRange = function (dateFormat, dateSeparator) {
+            var from = this.from.getFormattedDay(dateFormat, dateSeparator);
+            var to = this.to.getFormattedDay(dateFormat, dateSeparator);
+            return "" + from + RANGE_SEPARATOR_CHAR + to;
+        };
+        TuiDayRange.prototype.toString = function (dateFormat, dateSeparator) {
+            if (dateFormat === void 0) { dateFormat = 'DMY'; }
+            if (dateSeparator === void 0) { dateSeparator = '.'; }
+            var from = this.from.getFormattedDay(dateFormat, dateSeparator);
+            var to = this.to.getFormattedDay(dateFormat, dateSeparator);
+            return "" + from + RANGE_SEPARATOR_CHAR + to;
         };
         return TuiDayRange;
     }(TuiMonthRange));
@@ -1044,46 +1121,6 @@
             this.ms = ms;
             classes.tuiAssert.assert(TuiTime.isValidTime(hours, minutes, seconds, ms), 'Time must be real, but got:', hours, minutes, seconds, ms);
         }
-        /**
-         * Shifts time by hours and minutes
-         */
-        TuiTime.prototype.shift = function (_a) {
-            var _b = _a.hours, hours = _b === void 0 ? 0 : _b, _c = _a.minutes, minutes = _c === void 0 ? 0 : _c, _d = _a.seconds, seconds = _d === void 0 ? 0 : _d, _e = _a.ms, ms = _e === void 0 ? 0 : _e;
-            var newMs = (1000 + this.ms + (ms % 1000)) % 1000;
-            var secondsInMs = ms < 0 ? Math.ceil(ms / 1000) : Math.floor(ms / 1000);
-            var secondsToAdd = secondsInMs + seconds;
-            var newSeconds = (60 + this.seconds + (secondsToAdd % 60)) % 60;
-            var minutesInSeconds = secondsToAdd < 0
-                ? Math.ceil(secondsToAdd / 60)
-                : Math.floor(secondsToAdd / 60);
-            var minutesToAdd = minutesInSeconds + minutes;
-            var newMinutes = (60 + this.minutes + (minutesToAdd % 60)) % 60;
-            var hoursInMinutes = minutesToAdd < 0
-                ? Math.ceil(minutesToAdd / 60)
-                : Math.floor(minutesToAdd / 60);
-            var hoursToAdd = hoursInMinutes + hours;
-            var newHours = (24 + this.hours + (hoursToAdd % 24)) % 24;
-            return new TuiTime(newHours, newMinutes, newSeconds, newMs);
-        };
-        /**
-         * Converts TuiTime to string
-         */
-        TuiTime.prototype.toString = function (mode) {
-            var needAddMs = mode === 'HH:MM:SS.MSS' || (!mode && this.ms > 0);
-            var needAddSeconds = needAddMs || mode === 'HH:MM:SS' || (!mode && this.seconds > 0);
-            return (this.formatTime(this.hours) + ":" + this.formatTime(this.minutes) +
-                ("" + (needAddSeconds ? ':' + this.formatTime(this.seconds) : '')) +
-                ("" + (needAddMs ? '.' + this.formatTime(this.ms, 3) : '')));
-        };
-        /**
-         * Converts TuiTime to milliseconds
-         */
-        TuiTime.prototype.toAbsoluteMilliseconds = function () {
-            return (this.hours * MILLISECONDS_IN_HOUR +
-                this.minutes * MILLISECONDS_IN_MINUTE +
-                this.seconds * 1000 +
-                this.ms);
-        };
         /**
          * Checks if time is valid
          */
@@ -1142,6 +1179,46 @@
         TuiTime.fromLocalNativeDate = function (date) {
             return new TuiTime(date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
         };
+        /**
+         * Shifts time by hours and minutes
+         */
+        TuiTime.prototype.shift = function (_a) {
+            var _b = _a.hours, hours = _b === void 0 ? 0 : _b, _c = _a.minutes, minutes = _c === void 0 ? 0 : _c, _d = _a.seconds, seconds = _d === void 0 ? 0 : _d, _e = _a.ms, ms = _e === void 0 ? 0 : _e;
+            var newMs = (1000 + this.ms + (ms % 1000)) % 1000;
+            var secondsInMs = ms < 0 ? Math.ceil(ms / 1000) : Math.floor(ms / 1000);
+            var secondsToAdd = secondsInMs + seconds;
+            var newSeconds = (60 + this.seconds + (secondsToAdd % 60)) % 60;
+            var minutesInSeconds = secondsToAdd < 0
+                ? Math.ceil(secondsToAdd / 60)
+                : Math.floor(secondsToAdd / 60);
+            var minutesToAdd = minutesInSeconds + minutes;
+            var newMinutes = (60 + this.minutes + (minutesToAdd % 60)) % 60;
+            var hoursInMinutes = minutesToAdd < 0
+                ? Math.ceil(minutesToAdd / 60)
+                : Math.floor(minutesToAdd / 60);
+            var hoursToAdd = hoursInMinutes + hours;
+            var newHours = (24 + this.hours + (hoursToAdd % 24)) % 24;
+            return new TuiTime(newHours, newMinutes, newSeconds, newMs);
+        };
+        /**
+         * Converts TuiTime to string
+         */
+        TuiTime.prototype.toString = function (mode) {
+            var needAddMs = mode === 'HH:MM:SS.MSS' || (!mode && this.ms > 0);
+            var needAddSeconds = needAddMs || mode === 'HH:MM:SS' || (!mode && this.seconds > 0);
+            return (this.formatTime(this.hours) + ":" + this.formatTime(this.minutes) +
+                ("" + (needAddSeconds ? ':' + this.formatTime(this.seconds) : '')) +
+                ("" + (needAddMs ? '.' + this.formatTime(this.ms, 3) : '')));
+        };
+        /**
+         * Converts TuiTime to milliseconds
+         */
+        TuiTime.prototype.toAbsoluteMilliseconds = function () {
+            return (this.hours * MILLISECONDS_IN_HOUR +
+                this.minutes * MILLISECONDS_IN_MINUTE +
+                this.seconds * 1000 +
+                this.ms);
+        };
         TuiTime.prototype.formatTime = function (time, digits) {
             if (digits === void 0) { digits = 2; }
             return format.padStart(time.toString(), digits, '0');
@@ -1171,6 +1248,7 @@
     exports.TUI_DATE_FILLER = TUI_DATE_FILLER;
     exports.TUI_DATE_FORMAT = TUI_DATE_FORMAT;
     exports.TUI_DATE_RANGE_FILLER = TUI_DATE_RANGE_FILLER;
+    exports.TUI_DATE_SEPARATOR = TUI_DATE_SEPARATOR;
     exports.TUI_FIRST_DAY = TUI_FIRST_DAY;
     exports.TUI_LAST_DAY = TUI_LAST_DAY;
     exports.TuiDay = TuiDay;
@@ -1179,6 +1257,7 @@
     exports.TuiMonthRange = TuiMonthRange;
     exports.TuiTime = TuiTime;
     exports.TuiYear = TuiYear;
+    exports.isDateMode = isDateMode;
 
     Object.defineProperty(exports, '__esModule', { value: true });