@taiga-ui/cdk 3.491.1-canary.d27927b → 4.0.0-rc.2

package/esm2022/date-time/time.mjs

@@ -0,0 +1,128 @@
+/// <reference types="@taiga-ui/tsconfig/ng-dev-mode" />
+import { tuiInRange } from '@taiga-ui/cdk/utils/math';
+import { HOURS_IN_DAY, MILLISECONDS_IN_DAY, MILLISECONDS_IN_HOUR, MILLISECONDS_IN_MINUTE, MINUTES_IN_HOUR, SECONDS_IN_MINUTE, } from './date-time';
+/**
+ * Immutable time object with hours, minutes, seconds and ms
+ */
+export class TuiTime {
+    constructor(hours, minutes, seconds = 0, ms = 0) {
+        this.hours = hours;
+        this.minutes = minutes;
+        this.seconds = seconds;
+        this.ms = ms;
+        ngDevMode &&
+            console.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) &&
+            tuiInRange(hours, 0, HOURS_IN_DAY) &&
+            Number.isInteger(minutes) &&
+            tuiInRange(minutes, 0, MINUTES_IN_HOUR) &&
+            Number.isInteger(seconds) &&
+            tuiInRange(seconds, 0, SECONDS_IN_MINUTE) &&
+            Number.isInteger(ms) &&
+            tuiInRange(ms, 0, 1000));
+    }
+    /**
+     * Current UTC time.
+     */
+    static current() {
+        return TuiTime.fromAbsoluteMilliseconds(Date.now() % MILLISECONDS_IN_DAY);
+    }
+    /**
+     * Current time in local timezone
+     */
+    static currentLocal() {
+        const date = new Date();
+        return TuiTime.fromAbsoluteMilliseconds((Date.now() - date.getTimezoneOffset() * MILLISECONDS_IN_MINUTE) %
+            MILLISECONDS_IN_DAY);
+    }
+    /**
+     * Calculates TuiTime from milliseconds
+     */
+    static fromAbsoluteMilliseconds(milliseconds) {
+        ngDevMode && console.assert(Number.isInteger(milliseconds));
+        ngDevMode &&
+            console.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;
+        const ms = Math.floor(((milliseconds % MILLISECONDS_IN_HOUR) % MILLISECONDS_IN_MINUTE) % 1000) || 0;
+        return new TuiTime(hours, minutes, seconds, ms);
+    }
+    /**
+     * Parses string into TuiTime object
+     */
+    static fromString(time) {
+        const hours = Number(time.slice(0, 2));
+        const minutes = Number(time.slice(3, 5));
+        const seconds = Number(time.slice(6, 8)) || 0;
+        const ms = Number(time.slice(9, 12)) || 0;
+        return new TuiTime(hours, minutes, seconds, ms);
+    }
+    /**
+     * Converts Date object into TuiTime
+     * @param date
+     */
+    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);
+        const hhMm = `${this.formatTime(this.hours)}:${this.formatTime(this.minutes)}`;
+        const ss = needAddSeconds ? `:${this.formatTime(this.seconds)}` : '';
+        const mss = needAddMs ? `.${this.formatTime(this.ms, 3)}` : '';
+        return `${hhMm}${ss}${mss}`;
+    }
+    valueOf() {
+        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
+     */
+    [Symbol.toPrimitive](hint) {
+        return Date.prototype[Symbol.toPrimitive].call(this, hint);
+    }
+    /**
+     * 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 String(time).padStart(digits, '0');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"time.js","sourceRoot":"","sources":["../../../../projects/cdk/date-time/time.ts"],"names":[],"mappings":"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","sourcesContent":["/// <reference types=\"@taiga-ui/tsconfig/ng-dev-mode\" />\n\nimport {tuiInRange} from '@taiga-ui/cdk/utils/math';\n\nimport {\n    HOURS_IN_DAY,\n    MILLISECONDS_IN_DAY,\n    MILLISECONDS_IN_HOUR,\n    MILLISECONDS_IN_MINUTE,\n    MINUTES_IN_HOUR,\n    SECONDS_IN_MINUTE,\n} from './date-time';\nimport type {TuiTimeLike, TuiTimeMode} from './types';\n\n/**\n * Immutable time object with hours, minutes, seconds and ms\n */\nexport class TuiTime implements TuiTimeLike {\n    constructor(\n        public readonly hours: number,\n        public readonly minutes: number,\n        public readonly seconds = 0,\n        public readonly ms = 0,\n    ) {\n        ngDevMode &&\n            console.assert(\n                TuiTime.isValidTime(hours, minutes, seconds, ms),\n                'Time must be real, but got:',\n                hours,\n                minutes,\n                seconds,\n                ms,\n            );\n    }\n\n    /**\n     * Checks if time is valid\n     */\n    public static isValidTime(\n        hours: number,\n        minutes: number,\n        seconds = 0,\n        ms = 0,\n    ): boolean {\n        return (\n            Number.isInteger(hours) &&\n            tuiInRange(hours, 0, HOURS_IN_DAY) &&\n            Number.isInteger(minutes) &&\n            tuiInRange(minutes, 0, MINUTES_IN_HOUR) &&\n            Number.isInteger(seconds) &&\n            tuiInRange(seconds, 0, SECONDS_IN_MINUTE) &&\n            Number.isInteger(ms) &&\n            tuiInRange(ms, 0, 1000)\n        );\n    }\n\n    /**\n     * Current UTC time.\n     */\n    public static current(): TuiTime {\n        return TuiTime.fromAbsoluteMilliseconds(Date.now() % MILLISECONDS_IN_DAY);\n    }\n\n    /**\n     * Current time in local timezone\n     */\n    public static currentLocal(): TuiTime {\n        const date = new Date();\n\n        return TuiTime.fromAbsoluteMilliseconds(\n            (Date.now() - date.getTimezoneOffset() * MILLISECONDS_IN_MINUTE) %\n                MILLISECONDS_IN_DAY,\n        );\n    }\n\n    /**\n     * Calculates TuiTime from milliseconds\n     */\n    public static fromAbsoluteMilliseconds(milliseconds: number): TuiTime {\n        ngDevMode && console.assert(Number.isInteger(milliseconds));\n        ngDevMode &&\n            console.assert(\n                tuiInRange(milliseconds, 0, MILLISECONDS_IN_DAY),\n                `Milliseconds must be below ${MILLISECONDS_IN_DAY} (milliseconds in a day).`,\n            );\n\n        const hours = Math.floor(milliseconds / MILLISECONDS_IN_HOUR);\n        const minutes = Math.floor(\n            (milliseconds % MILLISECONDS_IN_HOUR) / MILLISECONDS_IN_MINUTE,\n        );\n        const seconds =\n            Math.floor(\n                ((milliseconds % MILLISECONDS_IN_HOUR) % MILLISECONDS_IN_MINUTE) / 1000,\n            ) || 0;\n        const ms =\n            Math.floor(\n                ((milliseconds % MILLISECONDS_IN_HOUR) % MILLISECONDS_IN_MINUTE) % 1000,\n            ) || 0;\n\n        return new TuiTime(hours, minutes, seconds, ms);\n    }\n\n    /**\n     * Parses string into TuiTime object\n     */\n    public static fromString(time: string): TuiTime {\n        const hours = Number(time.slice(0, 2));\n        const minutes = Number(time.slice(3, 5));\n        const seconds = Number(time.slice(6, 8)) || 0;\n        const ms = Number(time.slice(9, 12)) || 0;\n\n        return new TuiTime(hours, minutes, seconds, ms);\n    }\n\n    /**\n     * Converts Date object into TuiTime\n     * @param date\n     */\n    public static fromLocalNativeDate(date: Date): TuiTime {\n        return new TuiTime(\n            date.getHours(),\n            date.getMinutes(),\n            date.getSeconds(),\n            date.getMilliseconds(),\n        );\n    }\n\n    /**\n     * Shifts time by hours and minutes\n     */\n    public shift({hours = 0, minutes = 0, seconds = 0, ms = 0}: TuiTimeLike): TuiTime {\n        const newMs = (1000 + this.ms + (ms % 1000)) % 1000;\n\n        const secondsInMs = ms < 0 ? Math.ceil(ms / 1000) : Math.floor(ms / 1000);\n        const secondsToAdd = secondsInMs + seconds;\n        const newSeconds = (60 + this.seconds + (secondsToAdd % 60)) % 60;\n\n        const minutesInSeconds =\n            secondsToAdd < 0\n                ? Math.ceil(secondsToAdd / 60)\n                : Math.floor(secondsToAdd / 60);\n        const minutesToAdd = minutesInSeconds + minutes;\n        const newMinutes = (60 + this.minutes + (minutesToAdd % 60)) % 60;\n\n        const hoursInMinutes =\n            minutesToAdd < 0\n                ? Math.ceil(minutesToAdd / 60)\n                : Math.floor(minutesToAdd / 60);\n        const hoursToAdd = hoursInMinutes + hours;\n        const newHours = (24 + this.hours + (hoursToAdd % 24)) % 24;\n\n        return new TuiTime(newHours, newMinutes, newSeconds, newMs);\n    }\n\n    /**\n     * Converts TuiTime to string\n     */\n    public toString(mode?: TuiTimeMode): string {\n        const needAddMs = mode === 'HH:MM:SS.MSS' || (!mode && this.ms > 0);\n        const needAddSeconds =\n            needAddMs || mode === 'HH:MM:SS' || (!mode && this.seconds > 0);\n        const hhMm = `${this.formatTime(this.hours)}:${this.formatTime(this.minutes)}`;\n        const ss = needAddSeconds ? `:${this.formatTime(this.seconds)}` : '';\n        const mss = needAddMs ? `.${this.formatTime(this.ms, 3)}` : '';\n\n        return `${hhMm}${ss}${mss}`;\n    }\n\n    public valueOf(): number {\n        return this.toAbsoluteMilliseconds();\n    }\n\n    /**\n     * Returns the primitive value of the given Date object.\n     * Depending on the argument, the method can return either a string or a number.\n     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/@@toPrimitive\n     */\n    public [Symbol.toPrimitive](hint: string): number | string {\n        return Date.prototype[Symbol.toPrimitive].call(this, hint);\n    }\n\n    /**\n     * Converts TuiTime to milliseconds\n     */\n    public toAbsoluteMilliseconds(): number {\n        return (\n            this.hours * MILLISECONDS_IN_HOUR +\n            this.minutes * MILLISECONDS_IN_MINUTE +\n            this.seconds * 1000 +\n            this.ms\n        );\n    }\n\n    private formatTime(time: number, digits = 2): string {\n        return String(time).padStart(digits, '0');\n    }\n}\n"]}

package/esm2022/date-time/types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9jZGsvZGF0ZS10aW1lL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqICogRE1ZIC0gZGQubW0ueXl5eVxuICogKiBNRFkgLSBtbS5kZC55eXl5XG4gKiAqIFlNRCAtIHl5eXkubW0uZGRcbiAqL1xuZXhwb3J0IHR5cGUgVHVpRGF0ZU1vZGUgPSAnRE1ZJyB8ICdNRFknIHwgJ1lNRCc7XG5leHBvcnQgdHlwZSBUdWlUaW1lTW9kZSA9ICdISDpNTTpTUy5NU1MnIHwgJ0hIOk1NOlNTJyB8ICdISDpNTSc7XG5cbi8qKlxuICogT3B0aW9uYWxseSBoYXMgeWVhciBhbmQvb3IgbW9udGggYW5kL29yIGRheVxuICovXG5leHBvcnQgaW50ZXJmYWNlIFR1aURheUxpa2UgZXh0ZW5kcyBUdWlNb250aExpa2Uge1xuICAgIHJlYWRvbmx5IGRheT86IG51bWJlcjtcbn1cblxuLyoqXG4gKiBPcHRpb25hbGx5IGhhcyB5ZWFyIGFuZC9vciBtb250aFxuICovXG5leHBvcnQgaW50ZXJmYWNlIFR1aU1vbnRoTGlrZSBleHRlbmRzIFR1aVllYXJMaWtlIHtcbiAgICByZWFkb25seSBtb250aD86IG51bWJlcjtcbn1cblxuLyoqXG4gKiBPcHRpb25hbGx5IGhhcyB5ZWFyXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgVHVpWWVhckxpa2Uge1xuICAgIHJlYWRvbmx5IHllYXI/OiBudW1iZXI7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgVHVpVGltZUxpa2Uge1xuICAgIHJlYWRvbmx5IGhvdXJzPzogbnVtYmVyO1xuICAgIHJlYWRvbmx5IG1pbnV0ZXM/OiBudW1iZXI7XG4gICAgcmVhZG9ubHkgbXM/OiBudW1iZXI7XG4gICAgcmVhZG9ubHkgc2Vjb25kcz86IG51bWJlcjtcbn1cbiJdfQ==

package/esm2022/date-time/year.mjs

@@ -0,0 +1,111 @@
+/// <reference types="@taiga-ui/tsconfig/ng-dev-mode" />
+import { tuiInRange, tuiNormalizeToIntNumber } from '@taiga-ui/cdk/utils/math';
+import { MAX_YEAR, MIN_YEAR } from './date-time';
+/**
+ * Immutable year object
+ * @nosideeffects
+ */
+export class TuiYear {
+    constructor(year) {
+        this.year = year;
+        ngDevMode && console.assert(TuiYear.isValidYear(year));
+    }
+    /**
+     * Checks year for validity
+     */
+    static isValidYear(year) {
+        return Number.isInteger(year) && tuiInRange(year, MIN_YEAR, MAX_YEAR + 1);
+    }
+    /**
+     * Check if passed year is a leap year
+     */
+    static isLeapYear(year) {
+        ngDevMode && console.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) {
+        ngDevMode && console.assert(TuiYear.isValidYear(year));
+        return Math.ceil(year / 400) + (Math.ceil(year / 4) - Math.ceil(year / 100));
+    }
+    static lengthBetween(from, to) {
+        return to.year - from.year;
+    }
+    /**
+     * Normalizes year by clamping it between min and max years
+     */
+    static normalizeYearPart(year) {
+        return tuiNormalizeToIntNumber(year, MIN_YEAR, MAX_YEAR);
+    }
+    get formattedYear() {
+        return String(this.year).padStart(4, '0');
+    }
+    get isLeapYear() {
+        return TuiYear.isLeapYear(this.year);
+    }
+    /**
+     * Returns amount of leap years from year 0 to current
+     */
+    get absoluteLeapYears() {
+        return TuiYear.getAbsoluteLeapYears(this.year);
+    }
+    /**
+     * Passed year is after current
+     */
+    yearBefore({ year }) {
+        return this.year < year;
+    }
+    /**
+     * Passed year is the same or after current
+     */
+    yearSameOrBefore({ year }) {
+        return this.year <= year;
+    }
+    /**
+     * Passed year is the same as current
+     */
+    yearSame({ year }) {
+        return this.year === year;
+    }
+    /**
+     * Passed year is either the same of before the current
+     */
+    yearSameOrAfter({ year }) {
+        return this.year >= year;
+    }
+    /**
+     * Passed year is before current
+     */
+    yearAfter({ year }) {
+        return this.year > year;
+    }
+    /**
+     * Immutably offsets year
+     */
+    append({ year = 0 }) {
+        ngDevMode && console.assert(Number.isInteger(year));
+        const resultYear = this.year + year;
+        ngDevMode && console.assert(TuiYear.isValidYear(resultYear));
+        return new TuiYear(resultYear);
+    }
+    toString() {
+        return this.formattedYear;
+    }
+    valueOf() {
+        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
+     */
+    [Symbol.toPrimitive](hint) {
+        return Date.prototype[Symbol.toPrimitive].call(this, hint);
+    }
+    toJSON() {
+        return this.formattedYear;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"year.js","sourceRoot":"","sources":["../../../../projects/cdk/date-time/year.ts"],"names":[],"mappings":"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","sourcesContent":["/// <reference types=\"@taiga-ui/tsconfig/ng-dev-mode\" />\nimport {tuiInRange, tuiNormalizeToIntNumber} from '@taiga-ui/cdk/utils/math';\n\nimport {MAX_YEAR, MIN_YEAR} from './date-time';\nimport type {TuiYearLike} from './types';\n\n/**\n * Immutable year object\n * @nosideeffects\n */\nexport class TuiYear implements TuiYearLike {\n    constructor(public readonly year: number) {\n        ngDevMode && console.assert(TuiYear.isValidYear(year));\n    }\n\n    /**\n     * Checks year for validity\n     */\n    public static isValidYear(year: number): boolean {\n        return Number.isInteger(year) && tuiInRange(year, MIN_YEAR, MAX_YEAR + 1);\n    }\n\n    /**\n     * Check if passed year is a leap year\n     */\n    public static isLeapYear(year: number): boolean {\n        ngDevMode && console.assert(TuiYear.isValidYear(year));\n\n        return year % 400 === 0 || (year % 4 === 0 && year % 100 !== 0);\n    }\n\n    /**\n     * Returns amount of leap years from year 0 to the passed one\n     */\n    public static getAbsoluteLeapYears(year: number): number {\n        ngDevMode && console.assert(TuiYear.isValidYear(year));\n\n        return Math.ceil(year / 400) + (Math.ceil(year / 4) - Math.ceil(year / 100));\n    }\n\n    public static lengthBetween(from: TuiYear, to: TuiYear): number {\n        return to.year - from.year;\n    }\n\n    /**\n     * Normalizes year by clamping it between min and max years\n     */\n    public static normalizeYearPart(year: number): number {\n        return tuiNormalizeToIntNumber(year, MIN_YEAR, MAX_YEAR);\n    }\n\n    public get formattedYear(): string {\n        return String(this.year).padStart(4, '0');\n    }\n\n    public get isLeapYear(): boolean {\n        return TuiYear.isLeapYear(this.year);\n    }\n\n    /**\n     * Returns amount of leap years from year 0 to current\n     */\n    public get absoluteLeapYears(): number {\n        return TuiYear.getAbsoluteLeapYears(this.year);\n    }\n\n    /**\n     * Passed year is after current\n     */\n    public yearBefore({year}: TuiYear): boolean {\n        return this.year < year;\n    }\n\n    /**\n     * Passed year is the same or after current\n     */\n    public yearSameOrBefore({year}: TuiYear): boolean {\n        return this.year <= year;\n    }\n\n    /**\n     * Passed year is the same as current\n     */\n    public yearSame({year}: TuiYear): boolean {\n        return this.year === year;\n    }\n\n    /**\n     * Passed year is either the same of before the current\n     */\n    public yearSameOrAfter({year}: TuiYear): boolean {\n        return this.year >= year;\n    }\n\n    /**\n     * Passed year is before current\n     */\n    public yearAfter({year}: TuiYear): boolean {\n        return this.year > year;\n    }\n\n    /**\n     * Immutably offsets year\n     */\n    public append({year = 0}: TuiYearLike): TuiYear {\n        ngDevMode && console.assert(Number.isInteger(year));\n\n        const resultYear = this.year + year;\n\n        ngDevMode && console.assert(TuiYear.isValidYear(resultYear));\n\n        return new TuiYear(resultYear);\n    }\n\n    public toString(): string {\n        return this.formattedYear;\n    }\n\n    public valueOf(): number {\n        return this.year;\n    }\n\n    /**\n     * Returns the primitive value of the given Date object.\n     * Depending on the argument, the method can return either a string or a number.\n     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/@@toPrimitive\n     */\n    public [Symbol.toPrimitive](hint: string): number | string {\n        return Date.prototype[Symbol.toPrimitive].call(this, hint);\n    }\n\n    public toJSON(): string {\n        return this.formattedYear;\n    }\n}\n"]}

package/esm2022/directives/active-zone/active-zone.directive.mjs

@@ -0,0 +1,73 @@
+import { __decorate } from "tslib";
+import { Directive, inject, Input, NgZone, Output } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import { tuiZoneOptimized } from '@taiga-ui/cdk/observables';
+import { TUI_ACTIVE_ELEMENT } from '@taiga-ui/cdk/tokens';
+import { tuiArrayRemove, tuiInjectElement, tuiPure } from '@taiga-ui/cdk/utils';
+import { distinctUntilChanged, map, skip, startWith, tap } from 'rxjs';
+import * as i0 from "@angular/core";
+class TuiActiveZone {
+    constructor() {
+        this.control = inject(NgControl, { optional: true, self: true });
+        this.active$ = inject(TUI_ACTIVE_ELEMENT);
+        this.zone = inject(NgZone);
+        this.el = tuiInjectElement();
+        this.tuiActiveZoneParent = null;
+        this.subActiveZones = [];
+        this.directParentActiveZone = inject(TuiActiveZone, {
+            skipSelf: true,
+            optional: true,
+        });
+        this.tuiActiveZoneChange = this.active$.pipe(map(element => !!element && this.contains(element)), startWith(false), distinctUntilChanged(), skip(1), tap(active => {
+            if (!active && typeof this.control?.valueAccessor.onTouched === 'function') {
+                this.control.valueAccessor.onTouched();
+            }
+        }), tuiZoneOptimized(this.zone));
+        this.directParentActiveZone?.addSubActiveZone(this);
+    }
+    set tuiActiveZoneParentSetter(zone) {
+        this.setZone(zone);
+    }
+    ngOnDestroy() {
+        this.directParentActiveZone?.removeSubActiveZone(this);
+        this.tuiActiveZoneParent?.removeSubActiveZone(this);
+    }
+    contains(node) {
+        return (this.el.contains(node) ||
+            this.subActiveZones.some((item, index, array) => array.indexOf(item) === index && item.contains(node)));
+    }
+    setZone(zone) {
+        this.tuiActiveZoneParent?.removeSubActiveZone(this);
+        zone?.addSubActiveZone(this);
+        this.tuiActiveZoneParent = zone;
+    }
+    addSubActiveZone(activeZone) {
+        this.subActiveZones = [...this.subActiveZones, activeZone];
+    }
+    removeSubActiveZone(activeZone) {
+        this.subActiveZones = tuiArrayRemove(this.subActiveZones, this.subActiveZones.indexOf(activeZone));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiActiveZone, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: TuiActiveZone, isStandalone: true, selector: "[tuiActiveZone]:not(ng-container), [tuiActiveZoneChange]:not(ng-container), [tuiActiveZoneParent]:not(ng-container)", inputs: { tuiActiveZoneParentSetter: ["tuiActiveZoneParent", "tuiActiveZoneParentSetter"] }, outputs: { tuiActiveZoneChange: "tuiActiveZoneChange" }, host: { listeners: { "document:mousedown.silent": "(0)" } }, exportAs: ["tuiActiveZone"], ngImport: i0 }); }
+}
+__decorate([
+    tuiPure
+], TuiActiveZone.prototype, "setZone", null);
+export { TuiActiveZone };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiActiveZone, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[tuiActiveZone]:not(ng-container), [tuiActiveZoneChange]:not(ng-container), [tuiActiveZoneParent]:not(ng-container)',
+                    exportAs: 'tuiActiveZone',
+                    host: {
+                        '(document:mousedown.silent)': '(0)',
+                    },
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { tuiActiveZoneChange: [{
+                type: Output
+            }], tuiActiveZoneParentSetter: [{
+                type: Input,
+                args: ['tuiActiveZoneParent']
+            }], setZone: [] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/directives/active-zone/index.mjs

@@ -0,0 +1,2 @@
+export * from './active-zone.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jZGsvZGlyZWN0aXZlcy9hY3RpdmUtem9uZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHlCQUF5QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hY3RpdmUtem9uZS5kaXJlY3RpdmUnO1xuIl19

package/esm2022/directives/auto-focus/autofocus.directive.mjs

@@ -0,0 +1,46 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { DestroyRef, Directive, inject, Input } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { timer } from 'rxjs';
+import { TUI_AUTOFOCUS_HANDLER, TUI_AUTOFOCUS_OPTIONS, TUI_AUTOFOCUS_PROVIDERS, } from './autofocus.options';
+import * as i0 from "@angular/core";
+class TuiAutoFocus {
+    constructor() {
+        this.handler = inject(TUI_AUTOFOCUS_HANDLER);
+        this.options = inject(TUI_AUTOFOCUS_OPTIONS);
+        this.destroyRef = inject(DestroyRef);
+    }
+    ngAfterViewInit() {
+        if (this.autoFocus) {
+            this.focus();
+        }
+    }
+    focus() {
+        if (Number.isNaN(this.options.delay)) {
+            void Promise.resolve().then(() => this.handler.setFocus());
+        }
+        else {
+            timer(this.options.delay)
+                .pipe(takeUntilDestroyed(this.destroyRef))
+                .subscribe(() => this.handler.setFocus());
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiAutoFocus, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "16.2.12", type: TuiAutoFocus, isStandalone: true, selector: "[tuiAutoFocus]", inputs: { autoFocus: ["tuiAutoFocus", "autoFocus", coerceBooleanProperty] }, providers: TUI_AUTOFOCUS_PROVIDERS, ngImport: i0 }); }
+}
+export { TuiAutoFocus };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiAutoFocus, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[tuiAutoFocus]',
+                    providers: TUI_AUTOFOCUS_PROVIDERS,
+                }]
+        }], propDecorators: { autoFocus: [{
+                type: Input,
+                args: [{
+                        alias: 'tuiAutoFocus',
+                        transform: coerceBooleanProperty,
+                    }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/directives/auto-focus/autofocus.options.mjs

@@ -0,0 +1,24 @@
+import { ElementRef, InjectionToken, NgZone, Renderer2 } from '@angular/core';
+import { ANIMATION_FRAME, WINDOW } from '@ng-web-apis/common';
+import { TUI_IS_IOS } from '@taiga-ui/cdk/tokens';
+import { tuiCreateToken, tuiProvideOptions } from '@taiga-ui/cdk/utils/miscellaneous';
+import { TuiDefaultAutofocusHandler } from './handlers/default.handler';
+import { TuiIosAutofocusHandler } from './handlers/ios.handler';
+export const TUI_AUTOFOCUS_DEFAULT_OPTIONS = {
+    delay: NaN, // NaN = no delay/sync
+};
+export const TUI_AUTOFOCUS_OPTIONS = tuiCreateToken(TUI_AUTOFOCUS_DEFAULT_OPTIONS);
+export function tuiAutoFocusOptionsProvider(options) {
+    return tuiProvideOptions(TUI_AUTOFOCUS_OPTIONS, options, TUI_AUTOFOCUS_DEFAULT_OPTIONS);
+}
+export const TUI_AUTOFOCUS_HANDLER = new InjectionToken('[TUI_AUTOFOCUS_HANDLER]');
+export const TUI_AUTOFOCUS_PROVIDERS = [
+    {
+        provide: TUI_AUTOFOCUS_HANDLER,
+        useFactory: (el, animationFrame$, renderer, zone, win, isIos) => isIos
+            ? new TuiIosAutofocusHandler(el, renderer, zone, win)
+            : new TuiDefaultAutofocusHandler(el, animationFrame$),
+        deps: [ElementRef, ANIMATION_FRAME, Renderer2, NgZone, WINDOW, TUI_IS_IOS],
+    },
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/directives/auto-focus/handlers/abstract.handler.mjs

@@ -0,0 +1,16 @@
+export class AbstractTuiAutofocusHandler {
+    constructor(el) {
+        this.el = el;
+    }
+    get element() {
+        // TODO: Remove when legacy controls are dropped
+        const el = this.el.nativeElement.tagName.includes('-')
+            ? this.el.nativeElement.querySelector('input,textarea')
+            : this.el.nativeElement;
+        return el || this.el.nativeElement;
+    }
+    get isTextFieldElement() {
+        return this.element.matches('input, textarea, [contenteditable]');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3QuaGFuZGxlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Nkay9kaXJlY3RpdmVzL2F1dG8tZm9jdXMvaGFuZGxlcnMvYWJzdHJhY3QuaGFuZGxlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQSxNQUFNLE9BQWdCLDJCQUEyQjtJQUM3QyxZQUErQixFQUEyQjtRQUEzQixPQUFFLEdBQUYsRUFBRSxDQUF5QjtJQUFHLENBQUM7SUFJOUQsSUFBYyxPQUFPO1FBQ2pCLGdEQUFnRDtRQUNoRCxNQUFNLEVBQUUsR0FBRyxJQUFJLENBQUMsRUFBRSxDQUFDLGFBQWEsQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQztZQUNsRCxDQUFDLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxhQUFhLENBQUMsYUFBYSxDQUFjLGdCQUFnQixDQUFDO1lBQ3BFLENBQUMsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLGFBQWEsQ0FBQztRQUU1QixPQUFPLEVBQUUsSUFBSSxJQUFJLENBQUMsRUFBRSxDQUFDLGFBQWEsQ0FBQztJQUN2QyxDQUFDO0lBRUQsSUFBYyxrQkFBa0I7UUFDNUIsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxvQ0FBb0MsQ0FBQyxDQUFDO0lBQ3RFLENBQUM7Q0FDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHtFbGVtZW50UmVmfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHR5cGUge1R1aUF1dG9mb2N1c0hhbmRsZXJ9IGZyb20gJy4uL2F1dG9mb2N1cy5vcHRpb25zJztcblxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEFic3RyYWN0VHVpQXV0b2ZvY3VzSGFuZGxlciBpbXBsZW1lbnRzIFR1aUF1dG9mb2N1c0hhbmRsZXIge1xuICAgIGNvbnN0cnVjdG9yKHByb3RlY3RlZCByZWFkb25seSBlbDogRWxlbWVudFJlZjxIVE1MRWxlbWVudD4pIHt9XG5cbiAgICBwdWJsaWMgYWJzdHJhY3Qgc2V0Rm9jdXMoKTogdm9pZDtcblxuICAgIHByb3RlY3RlZCBnZXQgZWxlbWVudCgpOiBIVE1MRWxlbWVudCB7XG4gICAgICAgIC8vIFRPRE86IFJlbW92ZSB3aGVuIGxlZ2FjeSBjb250cm9scyBhcmUgZHJvcHBlZFxuICAgICAgICBjb25zdCBlbCA9IHRoaXMuZWwubmF0aXZlRWxlbWVudC50YWdOYW1lLmluY2x1ZGVzKCctJylcbiAgICAgICAgICAgID8gdGhpcy5lbC5uYXRpdmVFbGVtZW50LnF1ZXJ5U2VsZWN0b3I8SFRNTEVsZW1lbnQ+KCdpbnB1dCx0ZXh0YXJlYScpXG4gICAgICAgICAgICA6IHRoaXMuZWwubmF0aXZlRWxlbWVudDtcblxuICAgICAgICByZXR1cm4gZWwgfHwgdGhpcy5lbC5uYXRpdmVFbGVtZW50O1xuICAgIH1cblxuICAgIHByb3RlY3RlZCBnZXQgaXNUZXh0RmllbGRFbGVtZW50KCk6IGJvb2xlYW4ge1xuICAgICAgICByZXR1cm4gdGhpcy5lbGVtZW50Lm1hdGNoZXMoJ2lucHV0LCB0ZXh0YXJlYSwgW2NvbnRlbnRlZGl0YWJsZV0nKTtcbiAgICB9XG59XG4iXX0=

package/esm2022/directives/auto-focus/handlers/default.handler.mjs

@@ -0,0 +1,19 @@
+import { map, race, skipWhile, take, throttleTime, timer } from 'rxjs';
+import { AbstractTuiAutofocusHandler } from './abstract.handler';
+const TIMEOUT = 1000;
+const NG_ANIMATION_SELECTOR = '.ng-animating';
+export class TuiDefaultAutofocusHandler extends AbstractTuiAutofocusHandler {
+    constructor(el, animationFrame$) {
+        super(el);
+        this.animationFrame$ = animationFrame$;
+    }
+    setFocus() {
+        if (this.isTextFieldElement) {
+            race(timer(TIMEOUT), this.animationFrame$.pipe(throttleTime(100), map(() => this.element.closest(NG_ANIMATION_SELECTOR)), skipWhile(Boolean), take(1))).subscribe(() => this.element.focus({ preventScroll: true }));
+        }
+        else {
+            this.element.focus({ preventScroll: true });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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