@taiga-ui/cdk 3.58.0 → 3.59.0-canary.1c24449

package/esm2020/abstract/control.mjs

@@ -0,0 +1,189 @@
+import { Directive, HostBinding, Inject, Input, Optional, } from '@angular/core';
+import { NgModel } from '@angular/forms';
+import { tuiAssert } from '@taiga-ui/cdk/classes';
+import { EMPTY_FUNCTION } from '@taiga-ui/cdk/constants';
+import { tuiIsPresent } from '@taiga-ui/cdk/utils';
+import { merge, Subject } from 'rxjs';
+import { delay, distinctUntilChanged, filter, map, startWith, switchMap, takeUntil, } from 'rxjs/operators';
+import { AbstractTuiInteractive } from './interactive';
+import { AbstractTuiValueTransformer } from './value-transformer';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+/**
+ * Basic ControlValueAccessor class to build form components upon
+ */
+export class AbstractTuiControl extends AbstractTuiInteractive {
+    constructor(ngControl, cdr, valueTransformer) {
+        super();
+        this.ngControl = ngControl;
+        this.cdr = cdr;
+        this.valueTransformer = valueTransformer;
+        this.refresh$ = new Subject();
+        this.onTouched = EMPTY_FUNCTION;
+        this.onChange = EMPTY_FUNCTION;
+        this.fallbackValue = this.getFallbackValue();
+        this.destroy$ = new Subject();
+        this.readOnly = false;
+        this.pseudoInvalid = null;
+        if (ngDevMode && this.ngControl === null) {
+            tuiAssert.assert(false, `NgControl not injected in ${this.constructor.name}!\n`, `Use [(ngModel)] or [formControl] or formControlName for correct work.`);
+        }
+        if (this.ngControl) {
+            this.ngControl.valueAccessor = this;
+        }
+    }
+    get computedInvalid() {
+        return (this.interactive &&
+            (this.pseudoInvalid !== null
+                ? this.pseudoInvalid
+                : this.touched && this.invalid));
+    }
+    get value() {
+        return this.previousInternalValue ?? this.fallbackValue;
+    }
+    set value(value) {
+        this.updateValue(value);
+    }
+    get safeCurrentValue() {
+        return this.rawValue ?? this.fallbackValue;
+    }
+    get invalid() {
+        return this.safeNgControlData(({ invalid }) => invalid, false);
+    }
+    get valid() {
+        return this.safeNgControlData(({ valid }) => valid, false);
+    }
+    get touched() {
+        return this.safeNgControlData(({ touched }) => touched, false);
+    }
+    get disabled() {
+        return this.safeNgControlData(({ disabled }) => disabled, false);
+    }
+    get interactive() {
+        return !this.readOnly && !this.computedDisabled;
+    }
+    get control() {
+        return this.safeNgControlData(({ control }) => control, null);
+    }
+    get computedName() {
+        return this.controlName?.toString() ?? null;
+    }
+    get controlName() {
+        return this.ngControl?.name?.toString() ?? null;
+    }
+    get rawValue() {
+        const { ngControl } = this;
+        if (ngControl === null) {
+            return undefined;
+        }
+        const controlValue = ngControl instanceof NgModel && this.previousInternalValue === undefined
+            ? ngControl.viewModel
+            : ngControl.value;
+        return this.fromControlValue(controlValue);
+    }
+    ngOnInit() {
+        this.refresh$
+            .pipe(delay(0), startWith(null), map(() => this.ngControl?.control), filter(tuiIsPresent), distinctUntilChanged(), switchMap(control => merge(control.valueChanges, control.statusChanges)), takeUntil(this.destroy$))
+            .subscribe(() => {
+            this.refreshLocalValue(this.safeCurrentValue);
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    checkControlUpdate() {
+        this.cdr.markForCheck();
+    }
+    registerOnChange(onChange) {
+        this.onChange = (componentValue) => {
+            onChange(this.toControlValue(componentValue));
+        };
+        this.refresh$.next();
+    }
+    registerOnTouched(onTouched) {
+        this.onTouched = onTouched;
+    }
+    setDisabledState() {
+        this.checkControlUpdate();
+    }
+    writeValue(value) {
+        const controlValue = this.ngControl instanceof NgModel && this.previousInternalValue === undefined
+            ? this.ngControl.model
+            : value;
+        this.refreshLocalValue(this.fromControlValue(controlValue));
+    }
+    updateFocused(focused) {
+        if (!focused) {
+            this.controlMarkAsTouched();
+        }
+        super.updateFocused(focused);
+    }
+    /**
+     * @deprecated use `value` setter
+     */
+    updateValue(value) {
+        if (this.disabled || this.valueIdenticalComparator(this.value, value)) {
+            return;
+        }
+        this.previousInternalValue = value;
+        this.controlSetValue(value);
+    }
+    valueIdenticalComparator(oldValue, newValue) {
+        return oldValue === newValue;
+    }
+    safeNgControlData(extractor, defaultFieldValue) {
+        return (this.ngControl && extractor(this.ngControl)) ?? defaultFieldValue;
+    }
+    controlMarkAsTouched() {
+        this.onTouched();
+        this.checkControlUpdate();
+    }
+    controlSetValue(value) {
+        this.onChange(value);
+        this.checkControlUpdate();
+    }
+    refreshLocalValue(value) {
+        this.previousInternalValue = value;
+        this.checkControlUpdate();
+    }
+    fromControlValue(controlValue) {
+        return this.valueTransformer
+            ? this.valueTransformer.fromControlValue(controlValue)
+            : controlValue;
+    }
+    toControlValue(componentValue) {
+        return this.valueTransformer
+            ? this.valueTransformer.toControlValue(componentValue)
+            : componentValue;
+    }
+}
+AbstractTuiControl.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AbstractTuiControl, deps: [{ token: i1.NgControl, optional: true }, { token: i0.ChangeDetectorRef }, { token: AbstractTuiValueTransformer, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+AbstractTuiControl.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.10", type: AbstractTuiControl, inputs: { readOnly: "readOnly", pseudoInvalid: "pseudoInvalid" }, host: { properties: { "class._readonly": "this.readOnly", "class._invalid": "this.computedInvalid" } }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AbstractTuiControl, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i1.NgControl, decorators: [{
+                    type: Optional
+                }] }, { type: i0.ChangeDetectorRef }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [AbstractTuiValueTransformer]
+                }] }]; }, propDecorators: { readOnly: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: [`class._readonly`]
+            }], pseudoInvalid: [{
+                type: Input
+            }], computedInvalid: [{
+                type: HostBinding,
+                args: [`class._invalid`]
+            }] } });
+export function tuiAsControl(useExisting) {
+    return {
+        provide: AbstractTuiControl,
+        useExisting,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"control.js","sourceRoot":"","sources":["../../../../projects/cdk/abstract/control.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    ChangeDetectorRef,\n    Directive,\n    HostBinding,\n    Inject,\n    Input,\n    OnDestroy,\n    OnInit,\n    Optional,\n    Provider,\n    Type,\n} from '@angular/core';\nimport {AbstractControl, ControlValueAccessor, NgControl, NgModel} from '@angular/forms';\nimport {tuiAssert} from '@taiga-ui/cdk/classes';\nimport {EMPTY_FUNCTION} from '@taiga-ui/cdk/constants';\nimport {TuiControlValueTransformer} from '@taiga-ui/cdk/interfaces';\nimport {tuiIsPresent} from '@taiga-ui/cdk/utils';\nimport {merge, Subject} from 'rxjs';\nimport {\n    delay,\n    distinctUntilChanged,\n    filter,\n    map,\n    startWith,\n    switchMap,\n    takeUntil,\n} from 'rxjs/operators';\n\nimport {AbstractTuiInteractive} from './interactive';\nimport {AbstractTuiValueTransformer} from './value-transformer';\n\n/**\n * Basic ControlValueAccessor class to build form components upon\n */\n@Directive()\nexport abstract class AbstractTuiControl<T>\n    extends AbstractTuiInteractive\n    implements OnDestroy, OnInit, ControlValueAccessor\n{\n    private previousInternalValue?: T | null;\n    private readonly refresh$ = new Subject();\n\n    private onTouched = EMPTY_FUNCTION;\n\n    private onChange = EMPTY_FUNCTION;\n\n    protected readonly fallbackValue = this.getFallbackValue();\n\n    protected readonly destroy$ = new Subject<void>();\n\n    @Input()\n    @HostBinding(`class._readonly`)\n    readOnly = false;\n\n    @Input()\n    pseudoInvalid: boolean | null = null;\n\n    constructor(\n        @Optional()\n        private readonly ngControl: NgControl | null,\n        protected readonly cdr: ChangeDetectorRef,\n        @Optional()\n        @Inject(AbstractTuiValueTransformer)\n        protected readonly valueTransformer?: TuiControlValueTransformer<T> | null,\n    ) {\n        super();\n\n        if (ngDevMode && this.ngControl === null) {\n            tuiAssert.assert(\n                false,\n                `NgControl not injected in ${this.constructor.name}!\\n`,\n                `Use [(ngModel)] or [formControl] or formControlName for correct work.`,\n            );\n        }\n\n        if (this.ngControl) {\n            this.ngControl.valueAccessor = this;\n        }\n    }\n\n    protected abstract getFallbackValue(): T;\n\n    @HostBinding(`class._invalid`)\n    get computedInvalid(): boolean {\n        return (\n            this.interactive &&\n            (this.pseudoInvalid !== null\n                ? this.pseudoInvalid\n                : this.touched && this.invalid)\n        );\n    }\n\n    get value(): T {\n        return this.previousInternalValue ?? this.fallbackValue;\n    }\n\n    set value(value: T) {\n        this.updateValue(value);\n    }\n\n    get safeCurrentValue(): T {\n        return this.rawValue ?? this.fallbackValue;\n    }\n\n    get invalid(): boolean {\n        return this.safeNgControlData<boolean>(({invalid}) => invalid, false);\n    }\n\n    get valid(): boolean {\n        return this.safeNgControlData<boolean>(({valid}) => valid, false);\n    }\n\n    get touched(): boolean {\n        return this.safeNgControlData<boolean>(({touched}) => touched, false);\n    }\n\n    get disabled(): boolean {\n        return this.safeNgControlData<boolean>(({disabled}) => disabled, false);\n    }\n\n    get interactive(): boolean {\n        return !this.readOnly && !this.computedDisabled;\n    }\n\n    get control(): AbstractControl | null {\n        return this.safeNgControlData<AbstractControl | null>(\n            ({control}) => control,\n            null,\n        );\n    }\n\n    get computedName(): string | null {\n        return this.controlName?.toString() ?? null;\n    }\n\n    protected get controlName(): string | null {\n        return this.ngControl?.name?.toString() ?? null;\n    }\n\n    private get rawValue(): T | undefined {\n        const {ngControl} = this;\n\n        if (ngControl === null) {\n            return undefined;\n        }\n\n        const controlValue =\n            ngControl instanceof NgModel && this.previousInternalValue === undefined\n                ? ngControl.viewModel\n                : ngControl.value;\n\n        return this.fromControlValue(controlValue);\n    }\n\n    ngOnInit(): void {\n        this.refresh$\n            .pipe(\n                delay(0),\n                startWith(null),\n                map(() => this.ngControl?.control),\n                filter(tuiIsPresent),\n                distinctUntilChanged(),\n                switchMap(control => merge(control.valueChanges, control.statusChanges)),\n                takeUntil(this.destroy$),\n            )\n            .subscribe(() => {\n                this.refreshLocalValue(this.safeCurrentValue);\n            });\n    }\n\n    ngOnDestroy(): void {\n        this.destroy$.next();\n        this.destroy$.complete();\n    }\n\n    checkControlUpdate(): void {\n        this.cdr.markForCheck();\n    }\n\n    registerOnChange(onChange: (value: T | unknown) => void): void {\n        this.onChange = (componentValue: T) => {\n            onChange(this.toControlValue(componentValue));\n        };\n\n        this.refresh$.next();\n    }\n\n    registerOnTouched(onTouched: () => void): void {\n        this.onTouched = onTouched;\n    }\n\n    setDisabledState(): void {\n        this.checkControlUpdate();\n    }\n\n    writeValue(value: T | null): void {\n        const controlValue =\n            this.ngControl instanceof NgModel && this.previousInternalValue === undefined\n                ? this.ngControl.model\n                : value;\n\n        this.refreshLocalValue(this.fromControlValue(controlValue));\n    }\n\n    protected override updateFocused(focused: boolean): void {\n        if (!focused) {\n            this.controlMarkAsTouched();\n        }\n\n        super.updateFocused(focused);\n    }\n\n    /**\n     * @deprecated use `value` setter\n     */\n    protected updateValue(value: T): void {\n        if (this.disabled || this.valueIdenticalComparator(this.value, value)) {\n            return;\n        }\n\n        this.previousInternalValue = value;\n        this.controlSetValue(value);\n    }\n\n    protected valueIdenticalComparator(oldValue: T, newValue: T): boolean {\n        return oldValue === newValue;\n    }\n\n    private safeNgControlData<T>(\n        extractor: (ngControl: NgControl) => T | null | undefined,\n        defaultFieldValue: T,\n    ): T {\n        return (this.ngControl && extractor(this.ngControl)) ?? defaultFieldValue;\n    }\n\n    private controlMarkAsTouched(): void {\n        this.onTouched();\n        this.checkControlUpdate();\n    }\n\n    private controlSetValue(value: T): void {\n        this.onChange(value);\n        this.checkControlUpdate();\n    }\n\n    private refreshLocalValue(value: T | null): void {\n        this.previousInternalValue = value;\n        this.checkControlUpdate();\n    }\n\n    private fromControlValue(controlValue: unknown): T {\n        return this.valueTransformer\n            ? this.valueTransformer.fromControlValue(controlValue)\n            : (controlValue as T);\n    }\n\n    private toControlValue(componentValue: T): unknown {\n        return this.valueTransformer\n            ? this.valueTransformer.toControlValue(componentValue)\n            : componentValue;\n    }\n}\n\nexport function tuiAsControl<T>(useExisting: Type<AbstractTuiControl<T>>): Provider {\n    return {\n        provide: AbstractTuiControl,\n        useExisting,\n    };\n}\n"]}

package/esm2020/abstract/controller.mjs

@@ -0,0 +1,17 @@
+import { Directive } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class AbstractTuiController {
+    constructor() {
+        this.change$ = new Subject();
+    }
+    ngOnChanges() {
+        this.change$.next();
+    }
+}
+AbstractTuiController.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AbstractTuiController, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+AbstractTuiController.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.10", type: AbstractTuiController, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AbstractTuiController, decorators: [{
+            type: Directive
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJvbGxlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2Nkay9hYnN0cmFjdC9jb250cm9sbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxTQUFTLEVBQVksTUFBTSxlQUFlLENBQUM7QUFDbkQsT0FBTyxFQUFDLE9BQU8sRUFBQyxNQUFNLE1BQU0sQ0FBQzs7QUFHN0IsTUFBTSxPQUFnQixxQkFBcUI7SUFEM0M7UUFFYSxZQUFPLEdBQUcsSUFBSSxPQUFPLEVBQVEsQ0FBQztLQUsxQztJQUhHLFdBQVc7UUFDUCxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksRUFBRSxDQUFDO0lBQ3hCLENBQUM7O21IQUxpQixxQkFBcUI7dUdBQXJCLHFCQUFxQjs0RkFBckIscUJBQXFCO2tCQUQxQyxTQUFTIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtEaXJlY3RpdmUsIE9uQ2hhbmdlc30gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge1N1YmplY3R9IGZyb20gJ3J4anMnO1xuXG5ARGlyZWN0aXZlKClcbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBBYnN0cmFjdFR1aUNvbnRyb2xsZXIgaW1wbGVtZW50cyBPbkNoYW5nZXMge1xuICAgIHJlYWRvbmx5IGNoYW5nZSQgPSBuZXcgU3ViamVjdDx2b2lkPigpO1xuXG4gICAgbmdPbkNoYW5nZXMoKTogdm9pZCB7XG4gICAgICAgIHRoaXMuY2hhbmdlJC5uZXh0KCk7XG4gICAgfVxufVxuIl19

package/esm2020/abstract/dialog.directive.mjs

@@ -0,0 +1,36 @@
+import { ChangeDetectorRef, Directive, Inject, TemplateRef, } from '@angular/core';
+import { tuiIfMap } from '@taiga-ui/cdk/observables';
+import { PolymorpheusTemplate } from '@tinkoff/ng-polymorpheus';
+import { Subject } from 'rxjs';
+import { distinctUntilChanged, endWith, ignoreElements, share } from 'rxjs/operators';
+import { AbstractTuiDialogService } from './dialog.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./dialog.service";
+export class AbstractTuiDialogDirective extends PolymorpheusTemplate {
+    constructor(templateRef, cdr, service) {
+        super(templateRef, cdr);
+        this.service = service;
+        this.open$ = new Subject();
+        this.options = {};
+        this.open = false;
+        this.openChange = this.open$.pipe(distinctUntilChanged(), tuiIfMap(() => this.service.open(this, this.options).pipe(ignoreElements(), endWith(false))), share());
+    }
+    ngOnChanges() {
+        this.open$.next(this.open);
+    }
+}
+AbstractTuiDialogDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AbstractTuiDialogDirective, deps: [{ token: TemplateRef }, { token: ChangeDetectorRef }, { token: AbstractTuiDialogService }], target: i0.ɵɵFactoryTarget.Directive });
+AbstractTuiDialogDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.10", type: AbstractTuiDialogDirective, usesInheritance: true, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AbstractTuiDialogDirective, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef, decorators: [{
+                    type: Inject,
+                    args: [TemplateRef]
+                }] }, { type: i0.ChangeDetectorRef, decorators: [{
+                    type: Inject,
+                    args: [ChangeDetectorRef]
+                }] }, { type: i1.AbstractTuiDialogService, decorators: [{
+                    type: Inject,
+                    args: [AbstractTuiDialogService]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/abstract/dialog.service.mjs

@@ -0,0 +1,43 @@
+import { Inject, Injectable } from '@angular/core';
+import { TuiIdService } from '@taiga-ui/cdk/services';
+import { BehaviorSubject, Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@taiga-ui/cdk/services";
+export class AbstractTuiDialogService extends Observable {
+    constructor(idService) {
+        super(observer => this.dialogs$.subscribe(observer));
+        this.idService = idService;
+        this.dialogs$ = new BehaviorSubject([]);
+    }
+    open(content, options = {}) {
+        return new Observable(observer => {
+            const completeWith = (result) => {
+                observer.next(result);
+                observer.complete();
+            };
+            const dialog = {
+                ...this.defaultOptions,
+                ...options,
+                content,
+                completeWith,
+                $implicit: observer,
+                component: this.component,
+                createdAt: Date.now(),
+                id: this.idService.generate(),
+            };
+            this.dialogs$.next([...this.dialogs$.value, dialog]);
+            return () => {
+                this.dialogs$.next(this.dialogs$.value.filter(item => item !== dialog));
+            };
+        });
+    }
+}
+AbstractTuiDialogService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AbstractTuiDialogService, deps: [{ token: TuiIdService }], target: i0.ɵɵFactoryTarget.Injectable });
+AbstractTuiDialogService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AbstractTuiDialogService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AbstractTuiDialogService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.TuiIdService, decorators: [{
+                    type: Inject,
+                    args: [TuiIdService]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/abstract/interactive.mjs

@@ -0,0 +1,84 @@
+import { Directive, EventEmitter, HostBinding, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+const TUI = `tui_interactive_`;
+/**
+ * The most basic class for interactive components
+ */
+export class AbstractTuiInteractive {
+    constructor() {
+        this.pseudoHover = null;
+        this.pseudoActive = null;
+        this.pseudoFocus = null;
+        /**
+         * Determines if component is focusable with keyboard.
+         */
+        this.focusable = true;
+        this.nativeId = ``;
+        /**
+         * Emits 'true' on focus and 'false' on blur.
+         */
+        this.focusedChange = new EventEmitter();
+        this.focusVisibleChange = new EventEmitter();
+        this.focusVisible = false;
+        this.autoIdString = `${TUI}${AbstractTuiInteractive.autoId++}${Date.now()}`;
+    }
+    get computedDisabled() {
+        return this.disabled;
+    }
+    get computedFocusable() {
+        return !this.computedDisabled && (this.focusable || this.focused);
+    }
+    get computedFocused() {
+        return !this.computedDisabled && (this.pseudoFocus ?? this.focused);
+    }
+    get computedFocusVisible() {
+        return !this.computedDisabled && (this.pseudoFocus ?? this.focusVisible);
+    }
+    // TODO: 3.0 Consider removing since native input is exposed
+    get id() {
+        return this.nativeId || this.autoIdString;
+    }
+    updateFocused(focused) {
+        this.focusedChange.emit(focused);
+    }
+    updateFocusVisible(focusVisible) {
+        if (this.focusVisible === focusVisible) {
+            return;
+        }
+        this.focusVisible = focusVisible;
+        this.focusVisibleChange.emit(focusVisible);
+    }
+}
+AbstractTuiInteractive.autoId = 0;
+AbstractTuiInteractive.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AbstractTuiInteractive, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+AbstractTuiInteractive.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.10", type: AbstractTuiInteractive, inputs: { pseudoHover: "pseudoHover", pseudoActive: "pseudoActive", pseudoFocus: "pseudoFocus", focusable: "focusable", nativeId: "nativeId" }, outputs: { focusedChange: "focusedChange", focusVisibleChange: "focusVisibleChange" }, host: { properties: { "attr.data-focused": "this.pseudoFocus", "class._disabled": "this.computedDisabled", "class._focused": "this.computedFocused", "class._focus-visible": "this.computedFocusVisible" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AbstractTuiInteractive, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return []; }, propDecorators: { pseudoHover: [{
+                type: Input
+            }], pseudoActive: [{
+                type: Input
+            }], pseudoFocus: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: [`attr.data-focused`]
+            }], focusable: [{
+                type: Input
+            }], nativeId: [{
+                type: Input
+            }], focusedChange: [{
+                type: Output
+            }], focusVisibleChange: [{
+                type: Output
+            }], computedDisabled: [{
+                type: HostBinding,
+                args: [`class._disabled`]
+            }], computedFocused: [{
+                type: HostBinding,
+                args: [`class._focused`]
+            }], computedFocusVisible: [{
+                type: HostBinding,
+                args: [`class._focus-visible`]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/abstract/multiple-control.mjs

@@ -0,0 +1,17 @@
+import { Directive } from '@angular/core';
+import { AbstractTuiControl } from './control';
+import * as i0 from "@angular/core";
+export class AbstractTuiMultipleControl extends AbstractTuiControl {
+    clear() {
+        this.value = [];
+    }
+    getFallbackValue() {
+        return [];
+    }
+}
+AbstractTuiMultipleControl.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AbstractTuiMultipleControl, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+AbstractTuiMultipleControl.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.10", type: AbstractTuiMultipleControl, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AbstractTuiMultipleControl, decorators: [{
+            type: Directive
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXVsdGlwbGUtY29udHJvbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2Nkay9hYnN0cmFjdC9tdWx0aXBsZS1jb250cm9sLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxTQUFTLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFFeEMsT0FBTyxFQUFDLGtCQUFrQixFQUFDLE1BQU0sV0FBVyxDQUFDOztBQUc3QyxNQUFNLE9BQWdCLDBCQUE4QixTQUFRLGtCQUUzRDtJQUNHLEtBQUs7UUFDRCxJQUFJLENBQUMsS0FBSyxHQUFHLEVBQUUsQ0FBQztJQUNwQixDQUFDO0lBRVMsZ0JBQWdCO1FBQ3RCLE9BQU8sRUFBRSxDQUFDO0lBQ2QsQ0FBQzs7d0hBVGlCLDBCQUEwQjs0R0FBMUIsMEJBQTBCOzRGQUExQiwwQkFBMEI7a0JBRC9DLFNBQVMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0RpcmVjdGl2ZX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7QWJzdHJhY3RUdWlDb250cm9sfSBmcm9tICcuL2NvbnRyb2wnO1xuXG5ARGlyZWN0aXZlKClcbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBBYnN0cmFjdFR1aU11bHRpcGxlQ29udHJvbDxUPiBleHRlbmRzIEFic3RyYWN0VHVpQ29udHJvbDxcbiAgICByZWFkb25seSBUW11cbj4ge1xuICAgIGNsZWFyKCk6IHZvaWQge1xuICAgICAgICB0aGlzLnZhbHVlID0gW107XG4gICAgfVxuXG4gICAgcHJvdGVjdGVkIGdldEZhbGxiYWNrVmFsdWUoKTogcmVhZG9ubHkgVFtdIHtcbiAgICAgICAgcmV0dXJuIFtdO1xuICAgIH1cbn1cbiJdfQ==

package/esm2020/abstract/nullable-control.mjs

@@ -0,0 +1,14 @@
+import { Directive } from '@angular/core';
+import { AbstractTuiControl } from './control';
+import * as i0 from "@angular/core";
+export class AbstractTuiNullableControl extends AbstractTuiControl {
+    getFallbackValue() {
+        return null;
+    }
+}
+AbstractTuiNullableControl.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AbstractTuiNullableControl, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+AbstractTuiNullableControl.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.10", type: AbstractTuiNullableControl, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AbstractTuiNullableControl, decorators: [{
+            type: Directive
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnVsbGFibGUtY29udHJvbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2Nkay9hYnN0cmFjdC9udWxsYWJsZS1jb250cm9sLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxTQUFTLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFFeEMsT0FBTyxFQUFDLGtCQUFrQixFQUFDLE1BQU0sV0FBVyxDQUFDOztBQUc3QyxNQUFNLE9BQWdCLDBCQUE4QixTQUFRLGtCQUE0QjtJQUMxRSxnQkFBZ0I7UUFDdEIsT0FBTyxJQUFJLENBQUM7SUFDaEIsQ0FBQzs7d0hBSGlCLDBCQUEwQjs0R0FBMUIsMEJBQTBCOzRGQUExQiwwQkFBMEI7a0JBRC9DLFNBQVMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0RpcmVjdGl2ZX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7QWJzdHJhY3RUdWlDb250cm9sfSBmcm9tICcuL2NvbnRyb2wnO1xuXG5ARGlyZWN0aXZlKClcbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBBYnN0cmFjdFR1aU51bGxhYmxlQ29udHJvbDxUPiBleHRlbmRzIEFic3RyYWN0VHVpQ29udHJvbDxUIHwgbnVsbD4ge1xuICAgIHByb3RlY3RlZCBnZXRGYWxsYmFja1ZhbHVlKCk6IFQgfCBudWxsIHtcbiAgICAgICAgcmV0dXJuIG51bGw7XG4gICAgfVxufVxuIl19

package/esm2020/abstract/portal-host.mjs

@@ -0,0 +1,50 @@
+import { ComponentFactoryResolver, Directive, ElementRef, Inject, INJECTOR, Injector, ViewChild, ViewContainerRef, } from '@angular/core';
+import { AbstractTuiPortalService } from './portal-service';
+import * as i0 from "@angular/core";
+import * as i1 from "./portal-service";
+/**
+ * Abstract class for host element for dynamically created portals.
+ */
+export class AbstractTuiPortalHostComponent {
+    constructor(injector, el, portalService) {
+        this.injector = injector;
+        this.el = el;
+        portalService.attach(this);
+    }
+    /** @deprecated unused, will be removed in 4.0 **/
+    get clientRect() {
+        return this.el.nativeElement.getBoundingClientRect();
+    }
+    addComponentChild(component) {
+        const parent = component.createInjector(this.injector);
+        const resolver = parent.get(ComponentFactoryResolver);
+        const factory = resolver.resolveComponentFactory(component.component);
+        // TODO: Remove in 4.0
+        const providers = [{ provide: AbstractTuiPortalHostComponent, useValue: this }];
+        const injector = Injector.create({ parent, providers });
+        const ref = this.vcr.createComponent(factory, undefined, injector);
+        ref.changeDetectorRef.detectChanges();
+        return ref;
+    }
+    addTemplateChild(templateRef, context) {
+        return this.vcr.createEmbeddedView(templateRef, context);
+    }
+}
+AbstractTuiPortalHostComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AbstractTuiPortalHostComponent, deps: [{ token: INJECTOR }, { token: ElementRef }, { token: AbstractTuiPortalService }], target: i0.ɵɵFactoryTarget.Directive });
+AbstractTuiPortalHostComponent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.10", type: AbstractTuiPortalHostComponent, viewQueries: [{ propertyName: "vcr", first: true, predicate: ["viewContainer"], descendants: true, read: ViewContainerRef }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AbstractTuiPortalHostComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.Injector, decorators: [{
+                    type: Inject,
+                    args: [INJECTOR]
+                }] }, { type: i0.ElementRef, decorators: [{
+                    type: Inject,
+                    args: [ElementRef]
+                }] }, { type: i1.AbstractTuiPortalService, decorators: [{
+                    type: Inject,
+                    args: [AbstractTuiPortalService]
+                }] }]; }, propDecorators: { vcr: [{
+                type: ViewChild,
+                args: [`viewContainer`, { read: ViewContainerRef }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/abstract/portal-service.mjs

@@ -0,0 +1,39 @@
+import { Injectable } from '@angular/core';
+import { TuiNoHostException } from '@taiga-ui/cdk/exceptions';
+import * as i0 from "@angular/core";
+/**
+ * Abstract service for displaying portals
+ */
+export class AbstractTuiPortalService {
+    get safeHost() {
+        if (!this.host) {
+            throw new TuiNoHostException();
+        }
+        return this.host;
+    }
+    attach(host) {
+        this.host = host;
+    }
+    add(component) {
+        return this.safeHost.addComponentChild(component);
+    }
+    remove({ hostView }) {
+        if (!hostView.destroyed) {
+            hostView.destroy();
+        }
+    }
+    addTemplate(templateRef, context) {
+        return this.safeHost.addTemplateChild(templateRef, context);
+    }
+    removeTemplate(viewRef) {
+        if (!viewRef.destroyed) {
+            viewRef.destroy();
+        }
+    }
+}
+AbstractTuiPortalService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AbstractTuiPortalService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+AbstractTuiPortalService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AbstractTuiPortalService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AbstractTuiPortalService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/abstract/theme-switcher.mjs

@@ -0,0 +1,45 @@
+import { DOCUMENT } from '@angular/common';
+import { Directive, Inject } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Use this abstract class to create your own toggleable themes.
+ * A component extending this class must have CSS variables definitions
+ * and have ViewEncapsulation set to NONE. A boolean input allows to
+ * switch theme on or off.
+ */
+export class AbstractTuiThemeSwitcher {
+    constructor(doc) {
+        this.doc = doc;
+        if (this.style !== null) {
+            this.addTheme();
+            return;
+        }
+        const styles = this.doc.head.querySelectorAll(`style`);
+        this.constructor.style =
+            styles[styles.length - 1];
+    }
+    get style() {
+        return this.constructor.style;
+    }
+    ngOnDestroy() {
+        this.removeTheme();
+    }
+    addTheme() {
+        if (this.style) {
+            this.doc.head.appendChild(this.style);
+        }
+    }
+    removeTheme() {
+        this.style?.remove();
+    }
+}
+AbstractTuiThemeSwitcher.style = null;
+AbstractTuiThemeSwitcher.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AbstractTuiThemeSwitcher, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Directive });
+AbstractTuiThemeSwitcher.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.10", type: AbstractTuiThemeSwitcher, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AbstractTuiThemeSwitcher, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/coercion/coerce-boolean-property.mjs

@@ -0,0 +1,8 @@
+/**
+ * Coerces a data-bound value (typically a string) to a boolean.
+ * @example {@link https://material.angular.io/cdk/coercion/api#functions}
+ */
+export function tuiCoerceBooleanProperty(value) {
+    return value !== null && typeof value !== `undefined` && `${value}` !== `false`;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29lcmNlLWJvb2xlYW4tcHJvcGVydHkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9jZGsvY29lcmNpb24vY29lcmNlLWJvb2xlYW4tcHJvcGVydHkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHO0FBQ0gsTUFBTSxVQUFVLHdCQUF3QixDQUNwQyxLQUF5RTtJQUV6RSxPQUFPLEtBQUssS0FBSyxJQUFJLElBQUksT0FBTyxLQUFLLEtBQUssV0FBVyxJQUFJLEdBQUcsS0FBSyxFQUFFLEtBQUssT0FBTyxDQUFDO0FBQ3BGLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENvZXJjZXMgYSBkYXRhLWJvdW5kIHZhbHVlICh0eXBpY2FsbHkgYSBzdHJpbmcpIHRvIGEgYm9vbGVhbi5cbiAqIEBleGFtcGxlIHtAbGluayBodHRwczovL21hdGVyaWFsLmFuZ3VsYXIuaW8vY2RrL2NvZXJjaW9uL2FwaSNmdW5jdGlvbnN9XG4gKi9cbmV4cG9ydCBmdW5jdGlvbiB0dWlDb2VyY2VCb29sZWFuUHJvcGVydHkoXG4gICAgdmFsdWU6IFJlY29yZDxzdHJpbmcsIGFueT4gfCBib29sZWFuIHwgbnVtYmVyIHwgc3RyaW5nIHwgbnVsbCB8IHVuZGVmaW5lZCxcbik6IGJvb2xlYW4ge1xuICAgIHJldHVybiB2YWx1ZSAhPT0gbnVsbCAmJiB0eXBlb2YgdmFsdWUgIT09IGB1bmRlZmluZWRgICYmIGAke3ZhbHVlfWAgIT09IGBmYWxzZWA7XG59XG4iXX0=