@taiga-ui/cdk 2.24.0 → 2.27.1

package/fesm2015/taiga-ui-cdk-date-time.js

@@ -1,8 +1,8 @@
+import { InjectionToken, inject } from '@angular/core';
+import { CHAR_NO_BREAK_SPACE, CHAR_EN_DASH } from '@taiga-ui/cdk/constants';
 import { tuiAssert } from '@taiga-ui/cdk/classes';
 import { padStart } from '@taiga-ui/cdk/utils/format';
 import { inRange, normalizeToIntNumber } from '@taiga-ui/cdk/utils/math';
-import { CHAR_NO_BREAK_SPACE, CHAR_EN_DASH } from '@taiga-ui/cdk/constants';
-import { InjectionToken, inject } from '@angular/core';
 
 const DAYS_IN_WEEK = 7;
 const DAYS_IN_NORMAL_YEAR = 365;
@@ -22,6 +22,44 @@ const MILLISECONDS_IN_MINUTE = MILLISECONDS_IN_SECOND * SECONDS_IN_MINUTE;
 const MILLISECONDS_IN_HOUR = MILLISECONDS_IN_MINUTE * MINUTES_IN_HOUR;
 const 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
+ */
+const TUI_DATE_FILLER = new InjectionToken('date filler for Taiga UI', {
+    factory: () => `dd.mm.yyyy`,
+});
+/**
+ * @deprecated dont use it
+ * TODO: get rid of this in v3.0
+ */
+const TUI_DATE_RANGE_FILLER = new InjectionToken('date range filler for Taiga UI', {
+    factory: () => {
+        const dateFiller = inject(TUI_DATE_FILLER);
+        return `${dateFiller}${RANGE_SEPARATOR_CHAR}${dateFiller}`;
+    },
+});
+/**
+ * @internal 'dd.mm.yyyy'.length
+ * Used in:
+ * - {@link TuiInputDateComponent}
+ * - {@link TuiInputDateRangeComponent}
+ * - {@link TuiInputDateTimeComponent}
+ */
+const DATE_FILLER_LENGTH = 10;
+/**
+ * @internal
+ * Used in {@link TuiInputDateRangeComponent}
+ */
+const DATE_RANGE_FILLER_LENGTH = 2 * DATE_FILLER_LENGTH + RANGE_SEPARATOR_CHAR.length;
+
+/**
+ * TODO This token supports only DMY now. Add other {@link TuiDateMode} support
+ */
+const TUI_DATE_FORMAT = new InjectionToken('Active date format for Taiga UI', {
+    factory: () => 'DMY',
+});
+
 /**
  * Immutable year object
  * @nosideeffects
@@ -31,6 +69,54 @@ class TuiYear {
         this.year = year;
         tuiAssert.assert(TuiYear.isValidYear(year));
     }
+    /**
+     * Checks year for validity
+     */
+    static isValidYear(year) {
+        return Number.isInteger(year) && inRange(year, MIN_YEAR, MAX_YEAR + 1);
+    }
+    /**
+     * Check if passed year is a leap year
+     */
+    static isLeapYear(year) {
+        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
+     */
+    static getAbsoluteLeapYears(year) {
+        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
+     */
+    static getYearStartDaysOffset(year, absoluteLeapYears) {
+        tuiAssert.assert(TuiYear.isValidYear(year));
+        tuiAssert.assert(Number.isInteger(absoluteLeapYears));
+        tuiAssert.assert(year >= absoluteLeapYears);
+        tuiAssert.assert(absoluteLeapYears >= 0);
+        return ((absoluteLeapYears * DAYS_IN_LEAP_YEAR +
+            (year - absoluteLeapYears) * DAYS_IN_NORMAL_YEAR +
+            5) %
+            DAYS_IN_WEEK);
+    }
+    static lengthBetween(from, to) {
+        return to.year - from.year;
+    }
+    /**
+     * Normalizes year by clamping it between min and max years
+     */
+    static normalizeYearPart(year) {
+        return normalizeToIntNumber(year, MIN_YEAR, MAX_YEAR);
+    }
     get formattedYear() {
         return padStart(this.year.toString(), 4, '0');
     }
@@ -100,68 +186,75 @@ class TuiYear {
     toJSON() {
         return this.formattedYear;
     }
+}
+
+/**
+ * Immutable object consisting of year and month
+ */
+class TuiMonth extends TuiYear {
     /**
-     * Checks year for validity
+     * @param year
+     * @param month (starting with 0)
      */
-    static isValidYear(year) {
-        return Number.isInteger(year) && inRange(year, MIN_YEAR, MAX_YEAR + 1);
+    constructor(year, month) {
+        super(year);
+        this.month = month;
+        tuiAssert.assert(TuiMonth.isValidMonth(year, month));
     }
     /**
-     * Check if passed year is a leap year
+     * Tests month and year for validity
      */
-    static isLeapYear(year) {
-        tuiAssert.assert(TuiYear.isValidYear(year));
-        return year % 400 === 0 || (year % 4 === 0 && year % 100 !== 0);
+    static isValidMonth(year, month) {
+        return TuiYear.isValidYear(year) && TuiMonth.isValidMonthPart(month);
     }
     /**
-     * Returns amount of leap years from year 0 to the passed one
+     * Returns number of days in a month
      */
-    static getAbsoluteLeapYears(year) {
-        tuiAssert.assert(TuiYear.isValidYear(year));
-        return Math.ceil(year / 400) + (Math.ceil(year / 4) - Math.ceil(year / 100));
+    static getMonthDaysCount(month, isLeapYear) {
+        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;
+        }
     }
     /**
-     * @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
+     * Returns current month and year based on local time zone
+     * @nosideeffects
      */
-    static getYearStartDaysOffset(year, absoluteLeapYears) {
-        tuiAssert.assert(TuiYear.isValidYear(year));
-        tuiAssert.assert(Number.isInteger(absoluteLeapYears));
-        tuiAssert.assert(year >= absoluteLeapYears);
-        tuiAssert.assert(absoluteLeapYears >= 0);
-        return ((absoluteLeapYears * DAYS_IN_LEAP_YEAR +
-            (year - absoluteLeapYears) * DAYS_IN_NORMAL_YEAR +
-            5) %
-            DAYS_IN_WEEK);
+    static currentLocal() {
+        const nativeDate = new Date();
+        return new TuiMonth(nativeDate.getFullYear(), nativeDate.getMonth());
+    }
+    /**
+     * Returns current month and year based on UTC
+     */
+    static currentUtc() {
+        const nativeDate = new Date();
+        return new TuiMonth(nativeDate.getUTCFullYear(), nativeDate.getUTCMonth());
     }
     static lengthBetween(from, to) {
-        return to.year - from.year;
+        const absoluteFrom = from.month + from.year * 12;
+        const absoluteTo = to.month + to.year * 12;
+        return absoluteTo - absoluteFrom;
     }
     /**
-     * Normalizes year by clamping it between min and max years
+     * Normalizes number by clamping it between min and max month
      */
-    static normalizeYearPart(year) {
-        return normalizeToIntNumber(year, MIN_YEAR, MAX_YEAR);
+    static normalizeMonthPart(month) {
+        return normalizeToIntNumber(month, MIN_MONTH, MAX_MONTH);
     }
-}
-
-/**
- * Immutable object consisting of year and month
- */
-class TuiMonth extends TuiYear {
     /**
-     * @param year
-     * @param month (starting with 0)
+     * Tests month for validity
      */
-    constructor(year, month) {
-        super(year);
-        this.month = month;
-        tuiAssert.assert(TuiMonth.isValidMonth(year, month));
+    static isValidMonthPart(month) {
+        return Number.isInteger(month) && inRange(month, MIN_MONTH, MAX_MONTH + 1);
     }
     get formattedMonthPart() {
         return padStart((this.month + 1).toString(), 2, '0');
@@ -266,61 +359,6 @@ class TuiMonth extends TuiYear {
     toUtcNativeDate() {
         return new Date(Date.UTC(this.year, this.month));
     }
-    /**
-     * Tests month and year for validity
-     */
-    static isValidMonth(year, month) {
-        return TuiYear.isValidYear(year) && TuiMonth.isValidMonthPart(month);
-    }
-    /**
-     * Returns number of days in a month
-     */
-    static getMonthDaysCount(month, isLeapYear) {
-        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
-     */
-    static currentLocal() {
-        const nativeDate = new Date();
-        return new TuiMonth(nativeDate.getFullYear(), nativeDate.getMonth());
-    }
-    /**
-     * Returns current month and year based on UTC
-     */
-    static currentUtc() {
-        const nativeDate = new Date();
-        return new TuiMonth(nativeDate.getUTCFullYear(), nativeDate.getUTCMonth());
-    }
-    static lengthBetween(from, to) {
-        const absoluteFrom = from.month + from.year * 12;
-        const absoluteTo = to.month + to.year * 12;
-        return absoluteTo - absoluteFrom;
-    }
-    /**
-     * Normalizes number by clamping it between min and max month
-     */
-    static normalizeMonthPart(month) {
-        return normalizeToIntNumber(month, MIN_MONTH, MAX_MONTH);
-    }
-    /**
-     * Tests month for validity
-     */
-    static isValidMonthPart(month) {
-        return Number.isInteger(month) && inRange(month, MIN_MONTH, MAX_MONTH + 1);
-    }
 }
 
 // TODO: Localized formatting
@@ -333,24 +371,143 @@ class TuiDay extends TuiMonth {
         this.day = day;
         tuiAssert.assert(TuiDay.isValidDay(year, month, day));
     }
-    get formattedDayPart() {
-        return padStart(this.day.toString(), 2, '0');
-    }
     /**
-     * Formatted whole date
+     * Creates {@link TuiDay} from native {@link Date} based on local time zone
      */
-    get formattedDay() {
-        return `${this.formattedDayPart}.${this.formattedMonth}`;
-    }
-    get isWeekend() {
-        const dayOfWeek = this.dayOfWeek(false);
-        return dayOfWeek === 6 /* Saturday */ || dayOfWeek === 0 /* Sunday */;
+    static fromLocalNativeDate(date) {
+        return new TuiDay(date.getFullYear(), date.getMonth(), date.getDate());
     }
     /**
-     * Returns day of week
-     *
-     * @param startFromMonday whether week starts from Monday and not from Sunday
-     * @return day of week (from 0 to 6)
+     * Creates {@link TuiDay} from native {@link Date} using UTC
+     */
+    static fromUtcNativeDate(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
+     */
+    static isValidDay(year, month, day) {
+        return (TuiMonth.isValidMonth(year, month) &&
+            Number.isInteger(day) &&
+            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)
+     */
+    static getDayFromMonthRowCol(month, row, col) {
+        tuiAssert.assert(Number.isInteger(row));
+        tuiAssert.assert(inRange(row, 0, 6));
+        tuiAssert.assert(Number.isInteger(col));
+        tuiAssert.assert(inRange(col, 0, DAYS_IN_WEEK));
+        let 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
+     */
+    static currentLocal() {
+        const nativeDate = new Date();
+        const year = nativeDate.getFullYear();
+        const month = nativeDate.getMonth();
+        const 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
+     */
+    static normalizeOf(year, month, day) {
+        const normalizedYear = TuiYear.normalizeYearPart(year);
+        const normalizedMonth = TuiMonth.normalizeMonthPart(month);
+        const normalizedDay = TuiDay.normalizeDayPart(day, normalizedMonth, normalizedYear);
+        return new TuiDay(normalizedYear, normalizedMonth, normalizedDay);
+    }
+    static lengthBetween(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
+     */
+    static normalizeParse(yearMonthDayString) {
+        const day = parseInt(yearMonthDayString.slice(0, 2), 10);
+        const month = parseInt(yearMonthDayString.slice(3, 5), 10) - 1;
+        const 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
+     */
+    static jsonParse(yearMonthDayString) {
+        const day = parseInt(yearMonthDayString.slice(8, 10), 10);
+        const month = parseInt(yearMonthDayString.slice(5, 7), 10) - 1;
+        const 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) ||
+            !inRange(day, MIN_DAY, TuiMonth.getMonthDaysCount(month, TuiYear.isLeapYear(year)) + 1)) {
+            throw new Error('Invalid day: ' + day);
+        }
+        return new TuiDay(year, month, day);
+    }
+    static normalizeDayPart(day, month, year) {
+        tuiAssert.assert(TuiMonth.isValidMonth(year, month));
+        const monthDaysCount = TuiMonth.getMonthDaysCount(month, TuiYear.isLeapYear(year));
+        return normalizeToIntNumber(day, 1, monthDaysCount);
+    }
+    get formattedDayPart() {
+        return padStart(this.day.toString(), 2, '0');
+    }
+    /**
+     * Formatted whole date
+     */
+    get formattedDay() {
+        return `${this.formattedDayPart}.${this.formattedMonth}`;
+    }
+    get isWeekend() {
+        const dayOfWeek = this.dayOfWeek(false);
+        return dayOfWeek === 6 /* Saturday */ || dayOfWeek === 0 /* Sunday */;
+    }
+    /**
+     * Returns day of week
+     *
+     * @param startFromMonday whether week starts from Monday and not from Sunday
+     * @return day of week (from 0 to 6)
      */
     dayOfWeek(startFromMonday = true) {
         const dayOfWeek = startFromMonday
@@ -470,161 +627,8 @@ class TuiDay extends TuiMonth {
     toUtcNativeDate() {
         return new Date(Date.UTC(this.year, this.month, this.day));
     }
-    /**
-     * Creates {@link TuiDay} from native {@link Date} based on local time zone
-     */
-    static fromLocalNativeDate(date) {
-        return new TuiDay(date.getFullYear(), date.getMonth(), date.getDate());
-    }
-    /**
-     * Creates {@link TuiDay} from native {@link Date} using UTC
-     */
-    static fromUtcNativeDate(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
-     */
-    static isValidDay(year, month, day) {
-        return (TuiMonth.isValidMonth(year, month) &&
-            Number.isInteger(day) &&
-            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)
-     */
-    static getDayFromMonthRowCol(month, row, col) {
-        tuiAssert.assert(Number.isInteger(row));
-        tuiAssert.assert(inRange(row, 0, 6));
-        tuiAssert.assert(Number.isInteger(col));
-        tuiAssert.assert(inRange(col, 0, DAYS_IN_WEEK));
-        let 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
-     */
-    static currentLocal() {
-        const nativeDate = new Date();
-        const year = nativeDate.getFullYear();
-        const month = nativeDate.getMonth();
-        const 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
-     */
-    static normalizeOf(year, month, day) {
-        const normalizedYear = TuiYear.normalizeYearPart(year);
-        const normalizedMonth = TuiMonth.normalizeMonthPart(month);
-        const normalizedDay = TuiDay.normalizeDayPart(day, normalizedMonth, normalizedYear);
-        return new TuiDay(normalizedYear, normalizedMonth, normalizedDay);
-    }
-    static lengthBetween(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
-     */
-    static normalizeParse(yearMonthDayString) {
-        const day = parseInt(yearMonthDayString.slice(0, 2), 10);
-        const month = parseInt(yearMonthDayString.slice(3, 5), 10) - 1;
-        const 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
-     */
-    static jsonParse(yearMonthDayString) {
-        const day = parseInt(yearMonthDayString.slice(8, 10), 10);
-        const month = parseInt(yearMonthDayString.slice(5, 7), 10) - 1;
-        const 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) ||
-            !inRange(day, MIN_DAY, TuiMonth.getMonthDaysCount(month, TuiYear.isLeapYear(year)) + 1)) {
-            throw new Error('Invalid day: ' + day);
-        }
-        return new TuiDay(year, month, day);
-    }
-    static normalizeDayPart(day, month, year) {
-        tuiAssert.assert(TuiMonth.isValidMonth(year, month));
-        const monthDaysCount = TuiMonth.getMonthDaysCount(month, TuiYear.isLeapYear(year));
-        return normalizeToIntNumber(day, 1, monthDaysCount);
-    }
 }
 
-const TUI_FIRST_DAY = new TuiDay(MIN_YEAR, MIN_MONTH, MIN_DAY);
-const 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
- */
-const TUI_DATE_FILLER = new InjectionToken('date filler for Taiga UI', {
-    factory: () => `dd.mm.yyyy`,
-});
-/**
- * @deprecated dont use it
- * TODO: get rid of this in v3.0
- */
-const TUI_DATE_RANGE_FILLER = new InjectionToken('date range filler for Taiga UI', {
-    factory: () => {
-        const dateFiller = inject(TUI_DATE_FILLER);
-        return `${dateFiller}${RANGE_SEPARATOR_CHAR}${dateFiller}`;
-    },
-});
-/**
- * @internal 'dd.mm.yyyy'.length
- * Used in:
- * - {@link TuiInputDateComponent}
- * - {@link TuiInputDateRangeComponent}
- * - {@link TuiInputDateTimeComponent}
- */
-const DATE_FILLER_LENGTH = 10;
-/**
- * @internal
- * Used in {@link TuiInputDateRangeComponent}
- */
-const DATE_RANGE_FILLER_LENGTH = 2 * DATE_FILLER_LENGTH + RANGE_SEPARATOR_CHAR.length;
-
 /**
  * An immutable range of two {@link TuiMonth} objects
  */
@@ -634,6 +638,11 @@ class TuiMonthRange {
         this.to = to;
         tuiAssert.assert(from.monthSameOrBefore(to));
     }
+    static sort(month1, month2) {
+        return month1.monthSameOrBefore(month2)
+            ? new TuiMonthRange(month1, month2)
+            : new TuiMonthRange(month2, month1);
+    }
     get isSingleMonth() {
         return this.from.monthSame(this.to);
     }
@@ -646,11 +655,6 @@ class TuiMonthRange {
     toString() {
         return `${this.from}${RANGE_SEPARATOR_CHAR}${this.to}`;
     }
-    static sort(month1, month2) {
-        return month1.monthSameOrBefore(month2)
-            ? new TuiMonthRange(month1, month2)
-            : new TuiMonthRange(month2, month1);
-    }
 }
 
 /**
@@ -663,6 +667,31 @@ class TuiDayRange extends TuiMonthRange {
         this.to = to;
         tuiAssert.assert(from.daySameOrBefore(to));
     }
+    /**
+     * Creates range from two days after sorting them
+     *
+     * @param day1
+     * @param day2
+     * @return new range with sorted days
+     */
+    static sort(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
+     */
+    static normalizeParse(rangeString) {
+        const 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)));
+    }
     get isSingleDay() {
         return this.from.daySame(this.to);
     }
@@ -691,33 +720,11 @@ class TuiDayRange extends TuiMonthRange {
     dayLimit(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
-     */
-    static sort(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
-     */
-    static normalizeParse(rangeString) {
-        const 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)));
-    }
 }
 
+const TUI_FIRST_DAY = new TuiDay(MIN_YEAR, MIN_MONTH, MIN_DAY);
+const TUI_LAST_DAY = new TuiDay(MAX_YEAR, MAX_MONTH, 31);
+
 /**
  * Immutable time object with hours, minutes, seconds and ms
  */
@@ -729,45 +736,6 @@ class TuiTime {
         this.ms = ms;
         tuiAssert.assert(TuiTime.isValidTime(hours, minutes, seconds, ms), 'Time must be real, but got:', hours, minutes, seconds, ms);
     }
-    /**
-     * Shifts time by hours and minutes
-     */
-    shift({ hours = 0, minutes = 0, seconds = 0, ms = 0 }) {
-        const newMs = (1000 + this.ms + (ms % 1000)) % 1000;
-        const secondsInMs = ms < 0 ? Math.ceil(ms / 1000) : Math.floor(ms / 1000);
-        const secondsToAdd = secondsInMs + seconds;
-        const newSeconds = (60 + this.seconds + (secondsToAdd % 60)) % 60;
-        const minutesInSeconds = secondsToAdd < 0
-            ? Math.ceil(secondsToAdd / 60)
-            : Math.floor(secondsToAdd / 60);
-        const minutesToAdd = minutesInSeconds + minutes;
-        const newMinutes = (60 + this.minutes + (minutesToAdd % 60)) % 60;
-        const hoursInMinutes = minutesToAdd < 0
-            ? Math.ceil(minutesToAdd / 60)
-            : Math.floor(minutesToAdd / 60);
-        const hoursToAdd = hoursInMinutes + hours;
-        const newHours = (24 + this.hours + (hoursToAdd % 24)) % 24;
-        return new TuiTime(newHours, newMinutes, newSeconds, newMs);
-    }
-    /**
-     * Converts TuiTime to string
-     */
-    toString(mode) {
-        const needAddMs = mode === 'HH:MM:SS.MSS' || (!mode && this.ms > 0);
-        const 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
-     */
-    toAbsoluteMilliseconds() {
-        return (this.hours * MILLISECONDS_IN_HOUR +
-            this.minutes * MILLISECONDS_IN_MINUTE +
-            this.seconds * 1000 +
-            this.ms);
-    }
     /**
      * Checks if time is valid
      */
@@ -824,18 +792,50 @@ class TuiTime {
     static fromLocalNativeDate(date) {
         return new TuiTime(date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
     }
+    /**
+     * Shifts time by hours and minutes
+     */
+    shift({ hours = 0, minutes = 0, seconds = 0, ms = 0 }) {
+        const newMs = (1000 + this.ms + (ms % 1000)) % 1000;
+        const secondsInMs = ms < 0 ? Math.ceil(ms / 1000) : Math.floor(ms / 1000);
+        const secondsToAdd = secondsInMs + seconds;
+        const newSeconds = (60 + this.seconds + (secondsToAdd % 60)) % 60;
+        const minutesInSeconds = secondsToAdd < 0
+            ? Math.ceil(secondsToAdd / 60)
+            : Math.floor(secondsToAdd / 60);
+        const minutesToAdd = minutesInSeconds + minutes;
+        const newMinutes = (60 + this.minutes + (minutesToAdd % 60)) % 60;
+        const hoursInMinutes = minutesToAdd < 0
+            ? Math.ceil(minutesToAdd / 60)
+            : Math.floor(minutesToAdd / 60);
+        const hoursToAdd = hoursInMinutes + hours;
+        const newHours = (24 + this.hours + (hoursToAdd % 24)) % 24;
+        return new TuiTime(newHours, newMinutes, newSeconds, newMs);
+    }
+    /**
+     * Converts TuiTime to string
+     */
+    toString(mode) {
+        const needAddMs = mode === 'HH:MM:SS.MSS' || (!mode && this.ms > 0);
+        const 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
+     */
+    toAbsoluteMilliseconds() {
+        return (this.hours * MILLISECONDS_IN_HOUR +
+            this.minutes * MILLISECONDS_IN_MINUTE +
+            this.seconds * 1000 +
+            this.ms);
+    }
     formatTime(time, digits = 2) {
         return padStart(time.toString(), digits, '0');
     }
 }
 
-/**
- * TODO This token supports only DMY now. Add other {@link TuiDateMode} support
- */
-const TUI_DATE_FORMAT = new InjectionToken('Active date format for Taiga UI', {
-    factory: () => 'DMY',
-});
-
 /**
  * Generated bundle index. Do not edit.
  */