@taiga-ui/cdk 2.24.0 → 2.27.1

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

@@ -1,8 +1,8 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@taiga-ui/cdk/classes'), require('@taiga-ui/cdk/utils/format'), require('@taiga-ui/cdk/utils/math'), require('@taiga-ui/cdk/constants'), require('@angular/core')) :
-    typeof define === 'function' && define.amd ? define('@taiga-ui/cdk/date-time', ['exports', '@taiga-ui/cdk/classes', '@taiga-ui/cdk/utils/format', '@taiga-ui/cdk/utils/math', '@taiga-ui/cdk/constants', '@angular/core'], factory) :
-    (global = global || self, factory((global['taiga-ui'] = global['taiga-ui'] || {}, global['taiga-ui'].cdk = global['taiga-ui'].cdk || {}, global['taiga-ui'].cdk['date-time'] = {}), global['taiga-ui'].cdk.classes, global['taiga-ui'].cdk.utils.format, global['taiga-ui'].cdk.utils.math, global['taiga-ui'].cdk.constants, global.ng.core));
-}(this, (function (exports, classes, format, math, constants, core) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@taiga-ui/cdk/constants'), require('@taiga-ui/cdk/classes'), require('@taiga-ui/cdk/utils/format'), require('@taiga-ui/cdk/utils/math')) :
+    typeof define === 'function' && define.amd ? define('@taiga-ui/cdk/date-time', ['exports', '@angular/core', '@taiga-ui/cdk/constants', '@taiga-ui/cdk/classes', '@taiga-ui/cdk/utils/format', '@taiga-ui/cdk/utils/math'], factory) :
+    (global = global || self, factory((global['taiga-ui'] = global['taiga-ui'] || {}, global['taiga-ui'].cdk = global['taiga-ui'].cdk || {}, global['taiga-ui'].cdk['date-time'] = {}), global.ng.core, global['taiga-ui'].cdk.constants, global['taiga-ui'].cdk.classes, global['taiga-ui'].cdk.utils.format, global['taiga-ui'].cdk.utils.math));
+}(this, (function (exports, core, constants, classes, format, math) { 'use strict';
 
     /*! *****************************************************************************
     Copyright (c) Microsoft Corporation.
@@ -241,6 +241,44 @@
     var MILLISECONDS_IN_HOUR = MILLISECONDS_IN_MINUTE * MINUTES_IN_HOUR;
     var MILLISECONDS_IN_DAY = MILLISECONDS_IN_HOUR * HOURS_IN_DAY;
 
+    /**
+     * @deprecated dont use it. See {@link TUI_DATE_FORMAT}
+     * TODO: get rid of this in v3.0
+     */
+    var TUI_DATE_FILLER = new core.InjectionToken('date filler for Taiga UI', {
+        factory: function () { return "dd.mm.yyyy"; },
+    });
+    /**
+     * @deprecated dont use it
+     * TODO: get rid of this in v3.0
+     */
+    var TUI_DATE_RANGE_FILLER = new core.InjectionToken('date range filler for Taiga UI', {
+        factory: function () {
+            var dateFiller = core.inject(TUI_DATE_FILLER);
+            return "" + dateFiller + RANGE_SEPARATOR_CHAR + dateFiller;
+        },
+    });
+    /**
+     * @internal 'dd.mm.yyyy'.length
+     * Used in:
+     * - {@link TuiInputDateComponent}
+     * - {@link TuiInputDateRangeComponent}
+     * - {@link TuiInputDateTimeComponent}
+     */
+    var DATE_FILLER_LENGTH = 10;
+    /**
+     * @internal
+     * Used in {@link TuiInputDateRangeComponent}
+     */
+    var DATE_RANGE_FILLER_LENGTH = 2 * DATE_FILLER_LENGTH + RANGE_SEPARATOR_CHAR.length;
+
+    /**
+     * TODO This token supports only DMY now. Add other {@link TuiDateMode} support
+     */
+    var TUI_DATE_FORMAT = new core.InjectionToken('Active date format for Taiga UI', {
+        factory: function () { return 'DMY'; },
+    });
+
     /**
      * Immutable year object
      * @nosideeffects
@@ -250,6 +288,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');
@@ -342,54 +428,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;
     }());
 
@@ -408,6 +446,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');
@@ -533,61 +626,6 @@
         TuiMonth.prototype.toUtcNativeDate = function () {
             return new Date(Date.UTC(this.year, this.month));
         };
-        /**
-         * 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);
-        };
         return TuiMonth;
     }(TuiYear));
 
@@ -603,18 +641,137 @@
             classes.tuiAssert.assert(TuiDay.isValidDay(year, month, day));
             return _this;
         }
-        Object.defineProperty(TuiDay.prototype, "formattedDayPart", {
-            get: function () {
-                return format.padStart(this.day.toString(), 2, '0');
-            },
-            enumerable: true,
-            configurable: true
-        });
-        Object.defineProperty(TuiDay.prototype, "formattedDay", {
-            /**
-             * Formatted whole date
-             */
-            get: function () {
+        /**
+         * 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);
+        };
+        Object.defineProperty(TuiDay.prototype, "formattedDayPart", {
+            get: function () {
+                return format.padStart(this.day.toString(), 2, '0');
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(TuiDay.prototype, "formattedDay", {
+            /**
+             * Formatted whole date
+             */
+            get: function () {
                 return this.formattedDayPart + "." + this.formattedMonth;
             },
             enumerable: true,
@@ -755,162 +912,9 @@
         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));
 
-    var TUI_FIRST_DAY = new TuiDay(MIN_YEAR, MIN_MONTH, MIN_DAY);
-    var TUI_LAST_DAY = new TuiDay(MAX_YEAR, MAX_MONTH, 31);
-
-    /**
-     * @deprecated dont use it. See {@link TUI_DATE_FORMAT}
-     * TODO: get rid of this in v3.0
-     */
-    var TUI_DATE_FILLER = new core.InjectionToken('date filler for Taiga UI', {
-        factory: function () { return "dd.mm.yyyy"; },
-    });
-    /**
-     * @deprecated dont use it
-     * TODO: get rid of this in v3.0
-     */
-    var TUI_DATE_RANGE_FILLER = new core.InjectionToken('date range filler for Taiga UI', {
-        factory: function () {
-            var dateFiller = core.inject(TUI_DATE_FILLER);
-            return "" + dateFiller + RANGE_SEPARATOR_CHAR + dateFiller;
-        },
-    });
-    /**
-     * @internal 'dd.mm.yyyy'.length
-     * Used in:
-     * - {@link TuiInputDateComponent}
-     * - {@link TuiInputDateRangeComponent}
-     * - {@link TuiInputDateTimeComponent}
-     */
-    var DATE_FILLER_LENGTH = 10;
-    /**
-     * @internal
-     * Used in {@link TuiInputDateRangeComponent}
-     */
-    var DATE_RANGE_FILLER_LENGTH = 2 * DATE_FILLER_LENGTH + RANGE_SEPARATOR_CHAR.length;
-
     /**
      * An immutable range of two {@link TuiMonth} objects
      */
@@ -920,6 +924,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);
@@ -940,11 +949,6 @@
         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;
     }());
 
@@ -960,6 +964,31 @@
             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
+         * @return normalized day range object
+         */
+        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)));
+        };
         Object.defineProperty(TuiDayRange.prototype, "isSingleDay", {
             get: function () {
                 return this.from.daySame(this.to);
@@ -996,34 +1025,12 @@
         TuiDayRange.prototype.dayLimit = function (min, max) {
             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
-         */
-        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)));
-        };
         return TuiDayRange;
     }(TuiMonthRange));
 
+    var TUI_FIRST_DAY = new TuiDay(MIN_YEAR, MIN_MONTH, MIN_DAY);
+    var TUI_LAST_DAY = new TuiDay(MAX_YEAR, MAX_MONTH, 31);
+
     /**
      * Immutable time object with hours, minutes, seconds and ms
      */
@@ -1037,46 +1044,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
          */
@@ -1135,6 +1102,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');
@@ -1142,13 +1149,6 @@
         return TuiTime;
     }());
 
-    /**
-     * TODO This token supports only DMY now. Add other {@link TuiDateMode} support
-     */
-    var TUI_DATE_FORMAT = new core.InjectionToken('Active date format for Taiga UI', {
-        factory: function () { return 'DMY'; },
-    });
-
     exports.DATE_FILLER_LENGTH = DATE_FILLER_LENGTH;
     exports.DATE_RANGE_FILLER_LENGTH = DATE_RANGE_FILLER_LENGTH;
     exports.DAYS_IN_LEAP_YEAR = DAYS_IN_LEAP_YEAR;