@taiga-ui/cdk 3.51.0-canary.d032cc6 → 3.52.0-canary.164e55d

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

@@ -32,11 +32,28 @@
     var MILLISECONDS_IN_HOUR = MILLISECONDS_IN_MINUTE * MINUTES_IN_HOUR;
     var MILLISECONDS_IN_DAY = MILLISECONDS_IN_HOUR * HOURS_IN_DAY;
 
+    /**
+     * @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;
 
+    /**
+     * Active date format for Taiga UI
+     */
     var TUI_DATE_FORMAT = utils.tuiCreateToken("DMY");
 
+    /**
+     * Date separator for Taiga UI components
+     */
     var TUI_DATE_SEPARATOR = utils.tuiCreateToken(".");
     var changeDateSeparator = function (dateString, newDateSeparator) { return dateString.replace(/[^0-9A-Za-zА-Яа-я]/gi, newDateSeparator); };
 
@@ -358,18 +375,31 @@
         return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
     }
 
+    /**
+     * Immutable year object
+     * @nosideeffects
+     */
     var TuiYear = /** @class */ (function () {
         function TuiYear(year) {
             this.year = year;
             ngDevMode && classes.tuiAssert.assert(TuiYear.isValidYear(year));
         }
+        /**
+         * Checks year for validity
+         */
         TuiYear.isValidYear = function (year) {
             return Number.isInteger(year) && math.tuiInRange(year, MIN_YEAR, MAX_YEAR + 1);
         };
+        /**
+         * Check if passed year is a leap year
+         */
         TuiYear.isLeapYear = function (year) {
             ngDevMode && 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) {
             ngDevMode && classes.tuiAssert.assert(TuiYear.isValidYear(year));
             return Math.ceil(year / 400) + (Math.ceil(year / 4) - Math.ceil(year / 100));
@@ -377,6 +407,9 @@
         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.tuiNormalizeToIntNumber(year, MIN_YEAR, MAX_YEAR);
         };
@@ -395,32 +428,53 @@
             configurable: true
         });
         Object.defineProperty(TuiYear.prototype, "absoluteLeapYears", {
+            /**
+             * Returns amount of leap years from year 0 to current
+             */
             get: function () {
                 return TuiYear.getAbsoluteLeapYears(this.year);
             },
             enumerable: false,
             configurable: true
         });
+        /**
+         * Passed year is after current
+         */
         TuiYear.prototype.yearBefore = function (_a) {
             var year = _a.year;
             return this.year < year;
         };
+        /**
+         * Passed year is the same or after current
+         */
         TuiYear.prototype.yearSameOrBefore = function (_a) {
             var year = _a.year;
             return this.year <= year;
         };
+        /**
+         * Passed year is the same as current
+         */
         TuiYear.prototype.yearSame = function (_a) {
             var year = _a.year;
             return this.year === year;
         };
+        /**
+         * Passed year is either the same of before the current
+         */
         TuiYear.prototype.yearSameOrAfter = function (_a) {
             var year = _a.year;
             return this.year >= year;
         };
+        /**
+         * Passed year is before current
+         */
         TuiYear.prototype.yearAfter = function (_a) {
             var year = _a.year;
             return this.year > year;
         };
+        /**
+         * Immutably offsets year
+         */
         TuiYear.prototype.append = function (_a) {
             var _b = _a.year, year = _b === void 0 ? 0 : _b;
             ngDevMode && classes.tuiAssert.assert(Number.isInteger(year));
@@ -434,6 +488,11 @@
         TuiYear.prototype.valueOf = function () {
             return this.year;
         };
+        /**
+         * Returns the primitive value of the given Date object.
+         * Depending on the argument, the method can return either a string or a number.
+         * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/@@toPrimitive
+         */
         TuiYear.prototype[Symbol.toPrimitive] = function (hint) {
             return Date.prototype[Symbol.toPrimitive].call(this, hint);
         };
@@ -443,17 +502,30 @@
         return TuiYear;
     }());
 
+    /**
+     * Immutable object consisting of year and month
+     */
     var TuiMonth = /** @class */ (function (_super) {
         __extends(TuiMonth, _super);
+        /**
+         * @param year
+         * @param month (starting with 0)
+         */
         function TuiMonth(year, month) {
             var _this = _super.call(this, year) || this;
             _this.month = month;
             ngDevMode && 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) {
             ngDevMode && classes.tuiAssert.assert(TuiMonth.isValidMonthPart(month));
             switch (month) {
@@ -468,10 +540,17 @@
                     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());
@@ -481,9 +560,15 @@
             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.tuiNormalizeToIntNumber(month, MIN_MONTH, MAX_MONTH);
         };
+        /**
+         * Tests month for validity
+         */
         TuiMonth.isValidMonthPart = function (month) {
             return Number.isInteger(month) && math.tuiInRange(month, MIN_MONTH, MAX_MONTH + 1);
         };
@@ -495,31 +580,55 @@
             configurable: true
         });
         Object.defineProperty(TuiMonth.prototype, "daysCount", {
+            /**
+             * Returns days in a month
+             */
             get: function () {
                 return TuiMonth.getMonthDaysCount(this.month, this.isLeapYear);
             },
             enumerable: false,
             configurable: true
         });
+        /**
+         * Passed month and year are after current
+         */
         TuiMonth.prototype.monthBefore = function (another) {
             return (this.yearBefore(another) ||
                 (this.yearSame(another) && this.month < another.month));
         };
+        /**
+         * Passed month and year are after or the same as current
+         */
         TuiMonth.prototype.monthSameOrBefore = function (another) {
             return (this.yearBefore(another) ||
                 (this.yearSame(another) && this.month <= another.month));
         };
+        /**
+         * Passed month and year are the same as current
+         */
         TuiMonth.prototype.monthSame = function (another) {
             return this.yearSame(another) && this.month === another.month;
         };
+        /**
+         * Passed month and year are either before or equal to current
+         */
         TuiMonth.prototype.monthSameOrAfter = function (another) {
             return (this.yearAfter(another) ||
                 (this.yearSame(another) && this.month >= another.month));
         };
+        /**
+         * Passed month and year are before current
+         */
         TuiMonth.prototype.monthAfter = function (another) {
             return (this.yearAfter(another) ||
                 (this.yearSame(another) && this.month > another.month));
         };
+        /**
+         * Immutably alters current month and year by passed offset
+         *
+         * @param offset
+         * @return new month and year object as a result of offsetting current
+         */
         TuiMonth.prototype.append = function (_a) {
             var _b = _a.year, year = _b === void 0 ? 0 : _b, _c = _a.month, month = _c === void 0 ? 0 : _c;
             var totalMonths = (this.year + year) * MONTHS_IN_YEAR + this.month + month;
@@ -534,15 +643,25 @@
         TuiMonth.prototype.toJSON = function () {
             return _super.prototype.toJSON.call(this) + "-" + this.formattedMonthPart;
         };
+        /**
+         * Returns native {@link Date} based on local time zone
+         */
         TuiMonth.prototype.toLocalNativeDate = function () {
             return new Date(this.year, this.month);
         };
+        /**
+         * Returns native {@link Date} based on UTC
+         */
         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) {
@@ -551,17 +670,34 @@
             ngDevMode && classes.tuiAssert.assert(TuiDay.isValidDay(year, month, day));
             return _this;
         }
+        /**
+         * 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.tuiInRange(day, MIN_DAY, TuiMonth.getMonthDaysCount(month, TuiYear.isLeapYear(year)) + 1));
         };
+        /**
+         * Current day based on local time zone
+         */
         TuiDay.currentLocal = function () {
             var nativeDate = new Date();
             var year = nativeDate.getFullYear();
@@ -569,6 +705,9 @@
             var day = nativeDate.getDate();
             return new TuiDay(year, month, day);
         };
+        /**
+         * Returns current day based on UTC
+         */
         TuiDay.currentUtc = function () {
             var nativeDate = new Date();
             var year = nativeDate.getUTCFullYear();
@@ -576,6 +715,14 @@
             var day = nativeDate.getUTCDate();
             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);
@@ -612,11 +759,25 @@
                     };
             }
         };
+        // TODO: Move month and year related code corresponding classes
+        /**
+         * 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
+         */
         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);
         };
+        /**
+         * 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 _a = this.parseRawDateString(yearMonthDayString, "YMD"), day = _a.day, month = _a.month, year = _a.year;
             if (!TuiYear.isValidYear(year)) {
@@ -651,6 +812,12 @@
             enumerable: false,
             configurable: true
         });
+        /**
+         * Returns day of week
+         *
+         * @param startFromMonday whether week starts from Monday and not from Sunday
+         * @return day of week (from 0 to 6)
+         */
         TuiDay.prototype.dayOfWeek = function (startFromMonday) {
             if (startFromMonday === void 0) { startFromMonday = true; }
             var dayOfWeek = startFromMonday
@@ -658,25 +825,47 @@
                 : this.toLocalNativeDate().getDay();
             return dayOfWeek < 0 ? 6 : dayOfWeek;
         };
+        /**
+         * Passed date is after current
+         */
         TuiDay.prototype.dayBefore = function (another) {
             return (this.monthBefore(another) ||
                 (this.monthSame(another) && this.day < another.day));
         };
+        /**
+         * Passed date is after or equals to current
+         */
         TuiDay.prototype.daySameOrBefore = function (another) {
             return (this.monthBefore(another) ||
                 (this.monthSame(another) && this.day <= another.day));
         };
+        /**
+         * Passed date is the same as current
+         */
         TuiDay.prototype.daySame = function (another) {
             return this.monthSame(another) && this.day === another.day;
         };
+        /**
+         * Passed date is either before or the same as current
+         */
         TuiDay.prototype.daySameOrAfter = function (another) {
             return (this.monthAfter(another) ||
                 (this.monthSame(another) && this.day >= another.day));
         };
+        /**
+         * Passed date is before current
+         */
         TuiDay.prototype.dayAfter = function (another) {
             return (this.monthAfter(another) ||
                 (this.monthSame(another) && this.day > another.day));
         };
+        /**
+         * Clamping date between two limits
+         *
+         * @param min
+         * @param max
+         * @return clamped date
+         */
         TuiDay.prototype.dayLimit = function (min, max) {
             if (min !== null && this.dayBefore(min)) {
                 return min;
@@ -686,6 +875,16 @@
             }
             return this;
         };
+        /**
+         * Immutably alters current day by passed offset
+         *
+         * If resulting month has more days than original one, date is rounded to the maximum day
+         * in the resulting month. Offset of days will be calculated based on the resulted year and month
+         * to not interfere with parent classes methods
+         *
+         * @param offset
+         * @return new date object as a result of offsetting current
+         */
         TuiDay.prototype.append = function (_a) {
             var _b = _a.year, year = _b === void 0 ? 0 : _b, _c = _a.month, month = _c === void 0 ? 0 : _c, _d = _a.day, day = _d === void 0 ? 0 : _d;
             var totalMonths = (this.year + year) * MONTHS_IN_YEAR + this.month + month;
@@ -714,6 +913,9 @@
             }
             return new TuiDay(years, months, days);
         };
+        /**
+         * Returns formatted whole date
+         */
         TuiDay.prototype.getFormattedDay = function (dateFormat, separator) {
             ngDevMode &&
                 classes.tuiAssert.assert(separator.length === 1, "Separator should consist of only 1 symbol");
@@ -738,15 +940,24 @@
         TuiDay.prototype.toJSON = function () {
             return _super.prototype.toJSON.call(this) + "-" + this.formattedDayPart;
         };
+        /**
+         * Returns native {@link Date} based on local time zone
+         */
         TuiDay.prototype.toLocalNativeDate = function () {
             return new Date(this.year, this.month, this.day);
         };
+        /**
+         * Returns native {@link Date} based on UTC
+         */
         TuiDay.prototype.toUtcNativeDate = function () {
             return new Date(Date.UTC(this.year, this.month, this.day));
         };
         return TuiDay;
     }(TuiMonth));
 
+    /**
+     * An immutable range of two {@link TuiMonth} objects
+     */
     var TuiMonthRange = /** @class */ (function () {
         function TuiMonthRange(from, to) {
             this.from = from;
@@ -774,6 +985,9 @@
         return TuiMonthRange;
     }());
 
+    /**
+     * An immutable range of two {@link TuiDay} objects
+     */
     var TuiDayRange = /** @class */ (function (_super) {
         __extends(TuiDayRange, _super);
         function TuiDayRange(from, to) {
@@ -783,11 +997,25 @@
             ngDevMode && 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 leftDay = TuiDay.normalizeParse(rangeString.slice(0, DATE_FILLER_LENGTH), dateMode);
@@ -803,12 +1031,28 @@
             enumerable: false,
             configurable: true
         });
+        /**
+         * Tests ranges for identity
+         *
+         * @param another second range to test against current
+         * @return `true` if days are identical
+         */
         TuiDayRange.prototype.daySame = function (another) {
             return this.from.daySame(another.from) && this.to.daySame(another.to);
         };
+        /**
+         * Locks range between two days included, or limits from one side if the other is null
+         *
+         * @param min
+         * @param max
+         * @return range — clamped range
+         */
         TuiDayRange.prototype.dayLimit = function (min, max) {
             return new TuiDayRange(this.from.dayLimit(min, max), this.to.dayLimit(min, max));
         };
+        /**
+         * Human readable format.
+         */
         TuiDayRange.prototype.getFormattedDayRange = function (dateFormat, dateSeparator) {
             var from = this.from.getFormattedDay(dateFormat, dateSeparator);
             var to = this.to.getFormattedDay(dateFormat, dateSeparator);
@@ -827,6 +1071,9 @@
     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
+     */
     var TuiTime = /** @class */ (function () {
         function TuiTime(hours, minutes, seconds, ms) {
             if (seconds === void 0) { seconds = 0; }
@@ -838,6 +1085,9 @@
             ngDevMode &&
                 classes.tuiAssert.assert(TuiTime.isValidTime(hours, minutes, seconds, ms), "Time must be real, but got:", hours, minutes, seconds, ms);
         }
+        /**
+         * Checks if time is valid
+         */
         TuiTime.isValidTime = function (hours, minutes, seconds, ms) {
             if (seconds === void 0) { seconds = 0; }
             if (ms === void 0) { ms = 0; }
@@ -850,14 +1100,23 @@
                 Number.isInteger(ms) &&
                 math.tuiInRange(ms, 0, 1000));
         };
+        /**
+         * Current UTC time.
+         */
         TuiTime.current = function () {
             return TuiTime.fromAbsoluteMilliseconds(Date.now() % MILLISECONDS_IN_DAY);
         };
+        /**
+         * Current time in local timezone
+         */
         TuiTime.currentLocal = function () {
             var date = new Date();
             return TuiTime.fromAbsoluteMilliseconds((Date.now() - date.getTimezoneOffset() * MILLISECONDS_IN_MINUTE) %
                 MILLISECONDS_IN_DAY);
         };
+        /**
+         * Calculates TuiTime from milliseconds
+         */
         TuiTime.fromAbsoluteMilliseconds = function (milliseconds) {
             ngDevMode && classes.tuiAssert.assert(Number.isInteger(milliseconds));
             ngDevMode &&
@@ -868,6 +1127,9 @@
             var ms = Math.floor(((milliseconds % MILLISECONDS_IN_HOUR) % MILLISECONDS_IN_MINUTE) % 1000) || 0;
             return new TuiTime(hours, minutes, seconds, ms);
         };
+        /**
+         * Parses string into TuiTime object
+         */
         TuiTime.fromString = function (time) {
             var hours = Number(time.slice(0, 2));
             var minutes = Number(time.slice(3, 5));
@@ -875,9 +1137,16 @@
             var ms = Number(time.slice(9, 12)) || 0;
             return new TuiTime(hours, minutes, seconds, ms);
         };
+        /**
+         * Converts Date object into TuiTime
+         * @param date
+         */
         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;
@@ -896,6 +1165,9 @@
             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);
@@ -906,9 +1178,17 @@
         TuiTime.prototype.valueOf = function () {
             return this.toAbsoluteMilliseconds();
         };
+        /**
+         * Returns the primitive value of the given Date object.
+         * Depending on the argument, the method can return either a string or a number.
+         * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/@@toPrimitive
+         */
         TuiTime.prototype[Symbol.toPrimitive] = function (hint) {
             return Date.prototype[Symbol.toPrimitive].call(this, hint);
         };
+        /**
+         * Converts TuiTime to milliseconds
+         */
         TuiTime.prototype.toAbsoluteMilliseconds = function () {
             return (this.hours * MILLISECONDS_IN_HOUR +
                 this.minutes * MILLISECONDS_IN_MINUTE +
@@ -922,6 +1202,10 @@
         return TuiTime;
     }());
 
+    /**
+     * Generated bundle index. Do not edit.
+     */
+
     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;