@taiga-ui/cdk 2.55.0 → 3.0.0-rc.0

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

@@ -1,9 +1,8 @@
-import { InjectionToken, inject } from '@angular/core';
 import { CHAR_NO_BREAK_SPACE, CHAR_EN_DASH } from '@taiga-ui/cdk/constants';
+import { InjectionToken } from '@angular/core';
 import { tuiAssert } from '@taiga-ui/cdk/classes';
-import { InvalidYearException, InvalidMonthException, InvalidDayException } from '@taiga-ui/cdk/exceptions';
-import { padStart } from '@taiga-ui/cdk/utils/format';
-import { inRange, normalizeToIntNumber } from '@taiga-ui/cdk/utils/math';
+import { TuiInvalidYearException, TuiInvalidMonthException, TuiInvalidDayException } from '@taiga-ui/cdk/exceptions';
+import { tuiInRange, tuiNormalizeToIntNumber } from '@taiga-ui/cdk/utils/math';
 
 const DAYS_IN_WEEK = 7;
 const DAYS_IN_NORMAL_YEAR = 365;
@@ -23,21 +22,6 @@ 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}
- */
-const TUI_DATE_FILLER = new InjectionToken('date filler for Taiga UI', {
-    factory: () => `dd.mm.yyyy`,
-});
-/**
- * @deprecated dont use it
- */
-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:
@@ -52,12 +36,12 @@ const DATE_FILLER_LENGTH = 10;
  */
 const DATE_RANGE_FILLER_LENGTH = 2 * DATE_FILLER_LENGTH + RANGE_SEPARATOR_CHAR.length;
 
-const TUI_DATE_FORMAT = new InjectionToken('Active date format for Taiga UI', {
-    factory: () => 'DMY',
+const TUI_DATE_FORMAT = new InjectionToken(`Active date format for Taiga UI`, {
+    factory: () => `DMY`,
 });
 
-const TUI_DATE_SEPARATOR = new InjectionToken('Date separator for Taiga UI components', {
-    factory: () => '.',
+const TUI_DATE_SEPARATOR = new InjectionToken(`Date separator for Taiga UI components`, {
+    factory: () => `.`,
 });
 const changeDateSeparator = (dateString, newDateSeparator) => dateString.replace(/[^0-9A-Za-zА-Яа-я]/gi, newDateSeparator);
 
@@ -74,7 +58,7 @@ class TuiYear {
      * Checks year for validity
      */
     static isValidYear(year) {
-        return Number.isInteger(year) && inRange(year, MIN_YEAR, MAX_YEAR + 1);
+        return Number.isInteger(year) && tuiInRange(year, MIN_YEAR, MAX_YEAR + 1);
     }
     /**
      * Check if passed year is a leap year
@@ -90,25 +74,6 @@ class TuiYear {
         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;
     }
@@ -116,10 +81,10 @@ class TuiYear {
      * Normalizes year by clamping it between min and max years
      */
     static normalizeYearPart(year) {
-        return normalizeToIntNumber(year, MIN_YEAR, MAX_YEAR);
+        return tuiNormalizeToIntNumber(year, MIN_YEAR, MAX_YEAR);
     }
     get formattedYear() {
-        return padStart(String(this.year), 4, '0');
+        return String(this.year).padStart(4, `0`);
     }
     get isLeapYear() {
         return TuiYear.isLeapYear(this.year);
@@ -130,14 +95,6 @@ class TuiYear {
     get absoluteLeapYears() {
         return TuiYear.getAbsoluteLeapYears(this.year);
     }
-    /**
-     * @deprecated DONT USE IT (will be deleted soon)
-     *
-     * Returns day of week offset of the beginning of the current year
-     */
-    get yearStartDaysOffset() {
-        return TuiYear.getYearStartDaysOffset(this.year, this.absoluteLeapYears);
-    }
     /**
      * Passed year is after current
      */
@@ -260,31 +217,16 @@ class TuiMonth extends TuiYear {
      * Normalizes number by clamping it between min and max month
      */
     static normalizeMonthPart(month) {
-        return normalizeToIntNumber(month, MIN_MONTH, MAX_MONTH);
+        return tuiNormalizeToIntNumber(month, MIN_MONTH, MAX_MONTH);
     }
     /**
      * Tests month for validity
      */
     static isValidMonthPart(month) {
-        return Number.isInteger(month) && inRange(month, MIN_MONTH, MAX_MONTH + 1);
+        return Number.isInteger(month) && tuiInRange(month, MIN_MONTH, MAX_MONTH + 1);
     }
     get formattedMonthPart() {
-        return padStart(String(this.month + 1), 2, '0');
-    }
-    /**
-     * @deprecated
-     * Formatter month and year
-     */
-    get formattedMonth() {
-        return `${this.formattedMonthPart}.${this.formattedYear}`;
-    }
-    /**
-     * @deprecated DONT USE IT (will be deleted soon)
-     *
-     * Calculates number of weeks in a month (counting non-full weeks)
-     */
-    get weeksRowsCount() {
-        return Math.ceil((this.monthStartDaysOffset + this.daysCount) / DAYS_IN_WEEK);
+        return String(this.month + 1).padStart(2, `0`);
     }
     /**
      * Returns days in a month
@@ -292,18 +234,6 @@ class TuiMonth extends TuiYear {
     get daysCount() {
         return TuiMonth.getMonthDaysCount(this.month, this.isLeapYear);
     }
-    /**
-     * @deprecated DONT USE IT (will be deleted soon)
-     *
-     * Computes day of week offset of the beginning of the month
-     */
-    get monthStartDaysOffset() {
-        let result = this.yearStartDaysOffset;
-        for (let currentMonth = 0; currentMonth <= this.month - 1; currentMonth++) {
-            result += TuiMonth.getMonthDaysCount(currentMonth, this.isLeapYear);
-        }
-        return result % DAYS_IN_WEEK;
-    }
     /**
      * Passed month and year are after current
      */
@@ -355,7 +285,7 @@ class TuiMonth extends TuiYear {
         return new TuiMonth(Math.floor(totalMonths / MONTHS_IN_YEAR), totalMonths % MONTHS_IN_YEAR);
     }
     toString() {
-        return this.formattedMonth;
+        return `${this.formattedMonthPart}.${this.formattedYear}`;
     }
     valueOf() {
         return this.toLocalNativeDate().valueOf();
@@ -410,33 +340,7 @@ class TuiDay extends TuiMonth {
     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);
+            tuiInRange(day, MIN_DAY, TuiMonth.getMonthDaysCount(month, TuiYear.isLeapYear(year)) + 1));
     }
     /**
      * Current day based on local time zone
@@ -476,23 +380,23 @@ class TuiDay extends TuiMonth {
         return Math.round((to.toLocalNativeDate().getTime() - from.toLocalNativeDate().getTime()) /
             (1000 * 60 * 60 * 24));
     }
-    static parseRawDateString(date, dateMode = 'DMY') {
-        tuiAssert.assert(date.length === DATE_FILLER_LENGTH, '[parseRawDateString]: wrong date string length');
+    static parseRawDateString(date, dateMode = `DMY`) {
+        tuiAssert.assert(date.length === DATE_FILLER_LENGTH, `[parseRawDateString]: wrong date string length`);
         switch (dateMode) {
-            case 'YMD':
+            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':
+            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':
+            case `DMY`:
                 return {
                     day: parseInt(date.slice(0, 2), 10),
                     month: parseInt(date.slice(3, 5), 10) - 1,
@@ -508,7 +412,7 @@ class TuiDay extends TuiMonth {
      * @param dateMode date format of the date string (DMY | MDY | YMD)
      * @return normalized date
      */
-    static normalizeParse(rawDate, dateMode = 'DMY') {
+    static normalizeParse(rawDate, dateMode = `DMY`) {
         const { day, month, year } = this.parseRawDateString(rawDate, dateMode);
         return TuiDay.normalizeOf(year, month, day);
     }
@@ -519,33 +423,26 @@ class TuiDay extends TuiMonth {
      * @throws exceptions if any part of the date is invalid
      */
     static jsonParse(yearMonthDayString) {
-        const { day, month, year } = this.parseRawDateString(yearMonthDayString, 'YMD');
+        const { day, month, year } = this.parseRawDateString(yearMonthDayString, `YMD`);
         if (!TuiYear.isValidYear(year)) {
-            throw new InvalidYearException(year);
+            throw new TuiInvalidYearException(year);
         }
         if (!TuiMonth.isValidMonth(year, month)) {
-            throw new InvalidMonthException(month);
+            throw new TuiInvalidMonthException(month);
         }
         if (!Number.isInteger(day) ||
-            !inRange(day, MIN_DAY, TuiMonth.getMonthDaysCount(month, TuiYear.isLeapYear(year)) + 1)) {
-            throw new InvalidDayException(day);
+            !tuiInRange(day, MIN_DAY, TuiMonth.getMonthDaysCount(month, TuiYear.isLeapYear(year)) + 1)) {
+            throw new TuiInvalidDayException(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);
+        return tuiNormalizeToIntNumber(day, 1, monthDaysCount);
     }
     get formattedDayPart() {
-        return padStart(String(this.day), 2, '0');
-    }
-    /**
-     * @deprecated use {@link getFormattedDay} instead
-     * Formatted whole date
-     */
-    get formattedDay() {
-        return `${this.formattedDayPart}.${this.formattedMonth}`;
+        return String(this.day).padStart(2, `0`);
     }
     get isWeekend() {
         const dayOfWeek = this.dayOfWeek(false);
@@ -661,21 +558,21 @@ class TuiDay extends TuiMonth {
      * Returns formatted whole date
      */
     getFormattedDay(dateFormat, separator) {
-        tuiAssert.assert(separator.length === 1, 'Separator should consist of only 1 symbol');
+        tuiAssert.assert(separator.length === 1, `Separator should consist of only 1 symbol`);
         const dd = this.formattedDayPart;
         const mm = this.formattedMonthPart;
         const yyyy = this.formattedYear;
         switch (dateFormat) {
-            case 'YMD':
+            case `YMD`:
                 return `${yyyy}${separator}${mm}${separator}${dd}`;
-            case 'MDY':
+            case `MDY`:
                 return `${mm}${separator}${dd}${separator}${yyyy}`;
-            case 'DMY':
+            case `DMY`:
             default:
                 return `${dd}${separator}${mm}${separator}${yyyy}`;
         }
     }
-    toString(dateFormat = 'DMY', separator = '.') {
+    toString(dateFormat = `DMY`, separator = `.`) {
         return this.getFormattedDay(dateFormat, separator);
     }
     toJSON() {
@@ -712,12 +609,6 @@ class TuiMonthRange {
     get isSingleMonth() {
         return this.from.monthSame(this.to);
     }
-    /**
-     * @deprecated
-     */
-    get formattedMonthRange() {
-        return `${this.from.formattedMonth}${RANGE_SEPARATOR_CHAR}${this.to.formattedMonth}`;
-    }
     monthSame(another) {
         return this.from.monthSame(another.from) && this.to.monthSame(another.to);
     }
@@ -730,7 +621,7 @@ class TuiMonthRange {
  * Temporary type guard to satisfy ts-overloading of normalizeParse method
  * @deprecated
  */
-const isDateMode = (dateMode) => ['DMY', 'YMD', 'MDY'].includes(dateMode);
+const isDateMode = (dateMode) => [`DMY`, `YMD`, `MDY`].includes(dateMode);
 /**
  * An immutable range of two {@link TuiDay} objects
  */
@@ -760,26 +651,16 @@ class TuiDayRange extends TuiMonthRange {
      * @param dateMode {@link TuiDateMode}
      * @return normalized day range object
      */
-    static normalizeParse(rangeString, dateMode = 'DMY') {
-        const dateFormat = isDateMode(dateMode) ? dateMode : 'DMY';
-        const leftDay = TuiDay.normalizeParse(rangeString.slice(0, DATE_FILLER_LENGTH), dateFormat);
+    static normalizeParse(rangeString, dateMode = `DMY`) {
+        const leftDay = TuiDay.normalizeParse(rangeString.slice(0, DATE_FILLER_LENGTH), dateMode);
         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));
+        return TuiDayRange.sort(leftDay, TuiDay.normalizeParse(rangeString.slice(DATE_FILLER_LENGTH + RANGE_SEPARATOR_CHAR.length), dateMode));
     }
     get isSingleDay() {
         return this.from.daySame(this.to);
     }
-    /**
-     * Human readable format.
-     * @deprecated use {@link getFormattedDayRange} instead
-     */
-    get formattedDayRange() {
-        const from = this.from.getFormattedDay('DMY', '.');
-        const to = this.to.getFormattedDay('DMY', '.');
-        return `${from}${RANGE_SEPARATOR_CHAR}${to}`;
-    }
     /**
      * Tests ranges for identity
      *
@@ -807,7 +688,7 @@ class TuiDayRange extends TuiMonthRange {
         const to = this.to.getFormattedDay(dateFormat, dateSeparator);
         return `${from}${RANGE_SEPARATOR_CHAR}${to}`;
     }
-    toString(dateFormat = 'DMY', dateSeparator = '.') {
+    toString(dateFormat = `DMY`, dateSeparator = `.`) {
         const from = this.from.getFormattedDay(dateFormat, dateSeparator);
         const to = this.to.getFormattedDay(dateFormat, dateSeparator);
         return `${from}${RANGE_SEPARATOR_CHAR}${to}`;
@@ -826,20 +707,20 @@ class TuiTime {
         this.minutes = minutes;
         this.seconds = seconds;
         this.ms = ms;
-        tuiAssert.assert(TuiTime.isValidTime(hours, minutes, seconds, ms), 'Time must be real, but got:', hours, minutes, seconds, ms);
+        tuiAssert.assert(TuiTime.isValidTime(hours, minutes, seconds, ms), `Time must be real, but got:`, hours, minutes, seconds, ms);
     }
     /**
      * Checks if time is valid
      */
     static isValidTime(hours, minutes, seconds = 0, ms = 0) {
         return (Number.isInteger(hours) &&
-            inRange(hours, 0, HOURS_IN_DAY) &&
+            tuiInRange(hours, 0, HOURS_IN_DAY) &&
             Number.isInteger(minutes) &&
-            inRange(minutes, 0, MINUTES_IN_HOUR) &&
+            tuiInRange(minutes, 0, MINUTES_IN_HOUR) &&
             Number.isInteger(seconds) &&
-            inRange(seconds, 0, SECONDS_IN_MINUTE) &&
+            tuiInRange(seconds, 0, SECONDS_IN_MINUTE) &&
             Number.isInteger(ms) &&
-            inRange(ms, 0, 1000));
+            tuiInRange(ms, 0, 1000));
     }
     /**
      * Current UTC time.
@@ -860,7 +741,7 @@ class TuiTime {
      */
     static fromAbsoluteMilliseconds(milliseconds) {
         tuiAssert.assert(Number.isInteger(milliseconds));
-        tuiAssert.assert(inRange(milliseconds, 0, MILLISECONDS_IN_DAY), `Milliseconds must be below ${MILLISECONDS_IN_DAY} (milliseconds in a day).`);
+        tuiAssert.assert(tuiInRange(milliseconds, 0, MILLISECONDS_IN_DAY), `Milliseconds must be below ${MILLISECONDS_IN_DAY} (milliseconds in a day).`);
         const hours = Math.floor(milliseconds / MILLISECONDS_IN_HOUR);
         const minutes = Math.floor((milliseconds % MILLISECONDS_IN_HOUR) / MILLISECONDS_IN_MINUTE);
         const seconds = Math.floor(((milliseconds % MILLISECONDS_IN_HOUR) % MILLISECONDS_IN_MINUTE) / 1000) || 0;
@@ -908,11 +789,11 @@ class TuiTime {
      * 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);
+        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)}` : ''}`);
+            `${needAddSeconds ? `:${this.formatTime(this.seconds)}` : ``}` +
+            `${needAddMs ? `.${this.formatTime(this.ms, 3)}` : ``}`);
     }
     valueOf() {
         return this.toAbsoluteMilliseconds();
@@ -935,7 +816,7 @@ class TuiTime {
             this.ms);
     }
     formatTime(time, digits = 2) {
-        return padStart(String(time), digits, '0');
+        return String(time).padStart(digits, `0`);
     }
 }
 
@@ -943,5 +824,5 @@ class TuiTime {
  * Generated bundle index. Do not edit.
  */
 
-export { DATE_FILLER_LENGTH, DATE_RANGE_FILLER_LENGTH, DAYS_IN_LEAP_YEAR, DAYS_IN_NORMAL_YEAR, DAYS_IN_WEEK, HOURS_IN_DAY, MAX_MONTH, MAX_YEAR, MILLISECONDS_IN_DAY, MILLISECONDS_IN_HOUR, MILLISECONDS_IN_MINUTE, MILLISECONDS_IN_SECOND, MINUTES_IN_HOUR, MIN_DAY, MIN_MONTH, MIN_YEAR, MONTHS_IN_YEAR, RANGE_SEPARATOR_CHAR, SECONDS_IN_MINUTE, TUI_DATE_FILLER, TUI_DATE_FORMAT, TUI_DATE_RANGE_FILLER, TUI_DATE_SEPARATOR, TUI_FIRST_DAY, TUI_LAST_DAY, TuiDay, TuiDayRange, TuiMonth, TuiMonthRange, TuiTime, TuiYear, changeDateSeparator, isDateMode };
+export { DATE_FILLER_LENGTH, DATE_RANGE_FILLER_LENGTH, DAYS_IN_LEAP_YEAR, DAYS_IN_NORMAL_YEAR, DAYS_IN_WEEK, HOURS_IN_DAY, MAX_MONTH, MAX_YEAR, MILLISECONDS_IN_DAY, MILLISECONDS_IN_HOUR, MILLISECONDS_IN_MINUTE, MILLISECONDS_IN_SECOND, MINUTES_IN_HOUR, MIN_DAY, MIN_MONTH, MIN_YEAR, MONTHS_IN_YEAR, RANGE_SEPARATOR_CHAR, SECONDS_IN_MINUTE, TUI_DATE_FORMAT, TUI_DATE_SEPARATOR, TUI_FIRST_DAY, TUI_LAST_DAY, TuiDay, TuiDayRange, TuiMonth, TuiMonthRange, TuiTime, TuiYear, changeDateSeparator, isDateMode };
 //# sourceMappingURL=taiga-ui-cdk-date-time.js.map