@taiga-ui/cdk 2.61.0 → 3.0.0-rc.2

package/fesm2015/taiga-ui-cdk-abstract.js

@@ -1,26 +1,28 @@
-import { __decorate, __param } from 'tslib';
-import { EventEmitter, Input, Output, HostBinding, Directive, ChangeDetectorRef, Inject, Injectable, TemplateRef, Injector, ElementRef, ViewChild, ViewContainerRef } from '@angular/core';
-import { NgModel, NgControl } from '@angular/forms';
+import { __decorate } from 'tslib';
+import * as i0 from '@angular/core';
+import { EventEmitter, Directive, Input, Output, HostBinding, Injectable, Inject, TemplateRef, ChangeDetectorRef, ComponentFactoryResolver, Injector, INJECTOR, ElementRef, ViewContainerRef, ViewChild } from '@angular/core';
+import * as i1 from '@angular/forms';
+import { NgModel } from '@angular/forms';
 import { tuiAssert } from '@taiga-ui/cdk/classes';
 import { EMPTY_FUNCTION } from '@taiga-ui/cdk/constants';
 import { tuiDefaultProp } from '@taiga-ui/cdk/decorators';
 import { Subject, merge, Observable, BehaviorSubject, EMPTY } from 'rxjs';
 import { takeUntil, switchMap, ignoreElements, endWith } from 'rxjs/operators';
 import { PolymorpheusTemplate } from '@tinkoff/ng-polymorpheus';
+import * as i1$1 from '@taiga-ui/cdk/services';
 import { TuiIdService } from '@taiga-ui/cdk/services';
 import { TuiNoHostException } from '@taiga-ui/cdk/exceptions';
 import { DOCUMENT } from '@angular/common';
 
-var AbstractTuiInteractive_1;
 const TUI = `tui_interactive_`;
 /**
  * The most basic class for interactive components
  */
-let AbstractTuiInteractive = AbstractTuiInteractive_1 = class AbstractTuiInteractive {
+class AbstractTuiInteractive {
     constructor() {
-        this.pseudoHovered = null;
-        this.pseudoPressed = null;
-        this.pseudoFocused = null;
+        this.pseudoHover = null;
+        this.pseudoActive = null;
+        this.pseudoFocus = null;
         /**
          * Determines if component is focusable with keyboard.
          */
@@ -30,62 +32,28 @@ let AbstractTuiInteractive = AbstractTuiInteractive_1 = class AbstractTuiInterac
          * Emits 'true' on focus and 'false' on blur.
          */
         this.focusedChange = new EventEmitter();
-        /** @deprecated use `tuiPressedChange` directive */
-        this.pressedChange = new EventEmitter();
-        /** @deprecated use `tuiHoveredChange` directive */
-        this.hoveredChange = new EventEmitter();
         this.focusVisibleChange = new EventEmitter();
-        /** @deprecated use `tuiHoveredChange` directive */
-        this.hovered = false;
-        /** @deprecated use `tuiPressedChange` directive */
-        this.pressed = false;
         this.focusVisible = false;
-        this.autoIdString = `${TUI}${AbstractTuiInteractive_1.autoId++}${Date.now()}`;
+        this.autoIdString = `${TUI}${AbstractTuiInteractive.autoId++}${Date.now()}`;
     }
     get computedDisabled() {
         return this.disabled;
     }
-    /** @deprecated */
-    get computedHovered() {
-        var _a;
-        return !this.computedDisabled && ((_a = this.pseudoHovered) !== null && _a !== void 0 ? _a : this.hovered);
-    }
-    /** @deprecated */
-    get computedPressed() {
-        var _a;
-        return !this.computedDisabled && ((_a = this.pseudoPressed) !== null && _a !== void 0 ? _a : this.pressed);
-    }
     get computedFocusable() {
         return !this.computedDisabled && (this.focusable || this.focused);
     }
     get computedFocused() {
         var _a;
-        return !this.computedDisabled && ((_a = this.pseudoFocused) !== null && _a !== void 0 ? _a : this.focused);
+        return !this.computedDisabled && ((_a = this.pseudoFocus) !== null && _a !== void 0 ? _a : this.focused);
     }
     get computedFocusVisible() {
         var _a;
-        return !this.computedDisabled && ((_a = this.pseudoFocused) !== null && _a !== void 0 ? _a : this.focusVisible);
+        return !this.computedDisabled && ((_a = this.pseudoFocus) !== null && _a !== void 0 ? _a : this.focusVisible);
     }
     // TODO: 3.0 Consider removing since native input is exposed
     get id() {
         return this.nativeId ? this.nativeId : this.autoIdString;
     }
-    /** @deprecated */
-    updateHovered(hovered) {
-        if (this.hovered === hovered) {
-            return;
-        }
-        this.hovered = hovered;
-        this.hoveredChange.emit(hovered);
-    }
-    /** @deprecated */
-    updatePressed(pressed) {
-        if (this.pressed === pressed) {
-            return;
-        }
-        this.pressed = pressed;
-        this.pressedChange.emit(pressed);
-    }
     updateFocused(focused) {
         this.focusedChange.emit(focused);
     }
@@ -96,63 +64,56 @@ let AbstractTuiInteractive = AbstractTuiInteractive_1 = class AbstractTuiInterac
         this.focusVisible = focusVisible;
         this.focusVisibleChange.emit(focusVisible);
     }
-};
+}
 AbstractTuiInteractive.autoId = 0;
+AbstractTuiInteractive.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AbstractTuiInteractive, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+AbstractTuiInteractive.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.16", type: AbstractTuiInteractive, inputs: { pseudoHover: "pseudoHover", pseudoActive: "pseudoActive", pseudoFocus: "pseudoFocus", focusable: "focusable", nativeId: "nativeId" }, outputs: { focusedChange: "focusedChange", focusVisibleChange: "focusVisibleChange" }, host: { properties: { "class._disabled": "this.computedDisabled", "class._focused": "this.computedFocused", "class._focus-visible": "this.computedFocusVisible" } }, ngImport: i0 });
 __decorate([
-    Input(),
     tuiDefaultProp()
-], AbstractTuiInteractive.prototype, "pseudoHovered", void 0);
+], AbstractTuiInteractive.prototype, "pseudoHover", void 0);
 __decorate([
-    Input(),
     tuiDefaultProp()
-], AbstractTuiInteractive.prototype, "pseudoPressed", void 0);
+], AbstractTuiInteractive.prototype, "pseudoActive", void 0);
 __decorate([
-    Input(),
     tuiDefaultProp()
-], AbstractTuiInteractive.prototype, "pseudoFocused", void 0);
+], AbstractTuiInteractive.prototype, "pseudoFocus", void 0);
 __decorate([
-    Input(),
     tuiDefaultProp()
 ], AbstractTuiInteractive.prototype, "focusable", void 0);
 __decorate([
-    Input(),
     tuiDefaultProp()
 ], AbstractTuiInteractive.prototype, "nativeId", void 0);
-__decorate([
-    Output()
-], AbstractTuiInteractive.prototype, "focusedChange", void 0);
-__decorate([
-    Output()
-], AbstractTuiInteractive.prototype, "pressedChange", void 0);
-__decorate([
-    Output()
-], AbstractTuiInteractive.prototype, "hoveredChange", void 0);
-__decorate([
-    Output()
-], AbstractTuiInteractive.prototype, "focusVisibleChange", void 0);
-__decorate([
-    HostBinding(`class._disabled`)
-], AbstractTuiInteractive.prototype, "computedDisabled", null);
-__decorate([
-    HostBinding(`class._hovered`)
-], AbstractTuiInteractive.prototype, "computedHovered", null);
-__decorate([
-    HostBinding(`class._pressed`)
-], AbstractTuiInteractive.prototype, "computedPressed", null);
-__decorate([
-    HostBinding(`class._focused`)
-], AbstractTuiInteractive.prototype, "computedFocused", null);
-__decorate([
-    HostBinding(`class._focus-visible`)
-], AbstractTuiInteractive.prototype, "computedFocusVisible", null);
-AbstractTuiInteractive = AbstractTuiInteractive_1 = __decorate([
-    Directive()
-], AbstractTuiInteractive);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AbstractTuiInteractive, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return []; }, propDecorators: { pseudoHover: [{
+                type: Input
+            }], pseudoActive: [{
+                type: Input
+            }], pseudoFocus: [{
+                type: Input
+            }], 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`]
+            }] } });
 
 /**
  * Basic ControlValueAccessor class to build form components upon
  */
-let AbstractTuiControl = class AbstractTuiControl extends AbstractTuiInteractive {
+class AbstractTuiControl extends AbstractTuiInteractive {
     constructor(ngControl, changeDetectorRef, valueTransformer) {
         super();
         this.ngControl = ngControl;
@@ -296,33 +257,36 @@ let AbstractTuiControl = class AbstractTuiControl extends AbstractTuiInteractive
             ? this.valueTransformer.toControlValue(componentValue)
             : componentValue;
     }
-};
-AbstractTuiControl.ctorParameters = () => [
-    { type: NgControl },
-    { type: ChangeDetectorRef },
-    { type: undefined }
-];
+}
+AbstractTuiControl.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AbstractTuiControl, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive });
+AbstractTuiControl.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.16", type: AbstractTuiControl, inputs: { readOnly: "readOnly", pseudoInvalid: "pseudoInvalid" }, host: { properties: { "class._readonly": "this.readOnly", "class._invalid": "this.computedInvalid" } }, usesInheritance: true, ngImport: i0 });
 __decorate([
-    Input(),
-    HostBinding(`class._readonly`),
     tuiDefaultProp()
 ], AbstractTuiControl.prototype, "readOnly", void 0);
 __decorate([
-    Input(),
     tuiDefaultProp()
 ], AbstractTuiControl.prototype, "pseudoInvalid", void 0);
-__decorate([
-    HostBinding(`class._invalid`)
-], AbstractTuiControl.prototype, "computedInvalid", null);
-AbstractTuiControl = __decorate([
-    Directive()
-], AbstractTuiControl);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AbstractTuiControl, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i1.NgControl }, { type: i0.ChangeDetectorRef }, { type: undefined }]; }, propDecorators: { readOnly: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: [`class._readonly`]
+            }], pseudoInvalid: [{
+                type: Input
+            }], computedInvalid: [{
+                type: HostBinding,
+                args: [`class._invalid`]
+            }] } });
+function tuiAsControl(useExisting) {
+    return {
+        provide: AbstractTuiControl,
+        useExisting,
+    };
+}
 
-/**
- * @deprecated
- * TODO: 3.0 replace with {@link AbstractTuiController}
- */
-class TuiController {
+class AbstractTuiController {
     constructor() {
         this.change$ = new Subject();
     }
@@ -330,10 +294,13 @@ class TuiController {
         this.change$.next();
     }
 }
-class AbstractTuiController extends TuiController {
-}
+AbstractTuiController.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AbstractTuiController, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+AbstractTuiController.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.16", type: AbstractTuiController, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AbstractTuiController, decorators: [{
+            type: Directive
+        }] });
 
-let AbstractTuiDialogService = class AbstractTuiDialogService extends Observable {
+class AbstractTuiDialogService extends Observable {
     constructor(idService) {
         super(observer => this.dialogs$.subscribe(observer));
         this.idService = idService;
@@ -353,16 +320,17 @@ let AbstractTuiDialogService = class AbstractTuiDialogService extends Observable
             };
         });
     }
-};
-AbstractTuiDialogService.ctorParameters = () => [
-    { type: TuiIdService, decorators: [{ type: Inject, args: [TuiIdService,] }] }
-];
-AbstractTuiDialogService = __decorate([
-    Injectable(),
-    __param(0, Inject(TuiIdService))
-], AbstractTuiDialogService);
+}
+AbstractTuiDialogService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AbstractTuiDialogService, deps: [{ token: TuiIdService }], target: i0.ɵɵFactoryTarget.Injectable });
+AbstractTuiDialogService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AbstractTuiDialogService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AbstractTuiDialogService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1$1.TuiIdService, decorators: [{
+                    type: Inject,
+                    args: [TuiIdService]
+                }] }]; } });
 
-let AbstractTuiDialogDirective = class AbstractTuiDialogDirective extends PolymorpheusTemplate {
+class AbstractTuiDialogDirective extends PolymorpheusTemplate {
     constructor(templateRef, changeDetectorRef, service) {
         super(templateRef, changeDetectorRef);
         this.service = service;
@@ -377,44 +345,51 @@ let AbstractTuiDialogDirective = class AbstractTuiDialogDirective extends Polymo
     set open(open) {
         this.open$.next(open);
     }
-};
-AbstractTuiDialogDirective.ctorParameters = () => [
-    { type: TemplateRef, decorators: [{ type: Inject, args: [TemplateRef,] }] },
-    { type: ChangeDetectorRef, decorators: [{ type: Inject, args: [ChangeDetectorRef,] }] },
-    { type: AbstractTuiDialogService, decorators: [{ type: Inject, args: [AbstractTuiDialogService,] }] }
-];
-AbstractTuiDialogDirective = __decorate([
-    Directive(),
-    __param(0, Inject(TemplateRef)),
-    __param(1, Inject(ChangeDetectorRef)),
-    __param(2, Inject(AbstractTuiDialogService))
-], AbstractTuiDialogDirective);
+}
+AbstractTuiDialogDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AbstractTuiDialogDirective, deps: [{ token: TemplateRef }, { token: ChangeDetectorRef }, { token: AbstractTuiDialogService }], target: i0.ɵɵFactoryTarget.Directive });
+AbstractTuiDialogDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.16", type: AbstractTuiDialogDirective, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", 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: AbstractTuiDialogService, decorators: [{
+                    type: Inject,
+                    args: [AbstractTuiDialogService]
+                }] }]; } });
 
-let AbstractTuiMultipleControl = class AbstractTuiMultipleControl extends AbstractTuiControl {
+class AbstractTuiMultipleControl extends AbstractTuiControl {
     clear() {
         this.updateValue([]);
     }
     getFallbackValue() {
         return [];
     }
-};
-AbstractTuiMultipleControl = __decorate([
-    Directive()
-], AbstractTuiMultipleControl);
+}
+AbstractTuiMultipleControl.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AbstractTuiMultipleControl, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+AbstractTuiMultipleControl.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.16", type: AbstractTuiMultipleControl, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AbstractTuiMultipleControl, decorators: [{
+            type: Directive
+        }] });
 
-let AbstractTuiNullableControl = class AbstractTuiNullableControl extends AbstractTuiControl {
+class AbstractTuiNullableControl extends AbstractTuiControl {
     getFallbackValue() {
         return null;
     }
-};
-AbstractTuiNullableControl = __decorate([
-    Directive()
-], AbstractTuiNullableControl);
+}
+AbstractTuiNullableControl.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AbstractTuiNullableControl, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+AbstractTuiNullableControl.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.16", type: AbstractTuiNullableControl, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AbstractTuiNullableControl, decorators: [{
+            type: Directive
+        }] });
 
 /**
  * Abstract service for displaying portals
  */
-let AbstractTuiPortalService = class AbstractTuiPortalService {
+class AbstractTuiPortalService {
     get safeHost() {
         if (!this.host) {
             throw new TuiNoHostException();
@@ -424,8 +399,8 @@ let AbstractTuiPortalService = class AbstractTuiPortalService {
     attach(host) {
         this.host = host;
     }
-    add(componentFactory, injector) {
-        return this.safeHost.addComponentChild(componentFactory, injector);
+    add(component) {
+        return this.safeHost.addComponentChild(component);
     }
     remove({ hostView }) {
         hostView.destroy();
@@ -436,60 +411,64 @@ let AbstractTuiPortalService = class AbstractTuiPortalService {
     removeTemplate(viewRef) {
         viewRef.destroy();
     }
-};
-AbstractTuiPortalService = __decorate([
-    Injectable()
-], AbstractTuiPortalService);
+}
+AbstractTuiPortalService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AbstractTuiPortalService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+AbstractTuiPortalService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AbstractTuiPortalService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AbstractTuiPortalService, decorators: [{
+            type: Injectable
+        }] });
 
-var AbstractTuiPortalHostComponent_1;
 /**
  * Abstract class for host element for dynamically created portals.
  */
-let AbstractTuiPortalHostComponent = AbstractTuiPortalHostComponent_1 = class AbstractTuiPortalHostComponent {
-    constructor(elementRef, portalService) {
+class AbstractTuiPortalHostComponent {
+    constructor(injector, elementRef, portalService) {
+        this.injector = injector;
         this.elementRef = elementRef;
         portalService.attach(this);
     }
     get clientRect() {
         return this.elementRef.nativeElement.getBoundingClientRect();
     }
-    addComponentChild(componentFactory, injector) {
-        return this.viewContainerRef.createComponent(componentFactory, undefined, Injector.create({
-            parent: injector,
-            providers: [
-                {
-                    provide: AbstractTuiPortalHostComponent_1,
-                    useValue: this,
-                },
-            ],
-        }));
+    addComponentChild(component) {
+        const parent = component.createInjector(this.injector);
+        const resolver = parent.get(ComponentFactoryResolver);
+        const factory = resolver.resolveComponentFactory(component.component);
+        const providers = [{ provide: AbstractTuiPortalHostComponent, useValue: this }];
+        const injector = Injector.create({ parent, providers });
+        const ref = this.viewContainerRef.createComponent(factory, undefined, injector);
+        ref.changeDetectorRef.detectChanges();
+        return ref;
     }
     addTemplateChild(templateRef, context) {
         return this.viewContainerRef.createEmbeddedView(templateRef, context);
     }
-};
-AbstractTuiPortalHostComponent.ctorParameters = () => [
-    { type: ElementRef, decorators: [{ type: Inject, args: [ElementRef,] }] },
-    { type: AbstractTuiPortalService, decorators: [{ type: Inject, args: [AbstractTuiPortalService,] }] }
-];
-__decorate([
-    ViewChild(`viewContainer`, { read: ViewContainerRef })
-], AbstractTuiPortalHostComponent.prototype, "viewContainerRef", void 0);
-AbstractTuiPortalHostComponent = AbstractTuiPortalHostComponent_1 = __decorate([
-    Directive(),
-    __param(0, Inject(ElementRef)),
-    __param(1, Inject(AbstractTuiPortalService))
-], AbstractTuiPortalHostComponent);
+}
+AbstractTuiPortalHostComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AbstractTuiPortalHostComponent, deps: [{ token: INJECTOR }, { token: ElementRef }, { token: AbstractTuiPortalService }], target: i0.ɵɵFactoryTarget.Directive });
+AbstractTuiPortalHostComponent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.16", type: AbstractTuiPortalHostComponent, viewQueries: [{ propertyName: "viewContainerRef", first: true, predicate: ["viewContainer"], descendants: true, read: ViewContainerRef }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", 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: AbstractTuiPortalService, decorators: [{
+                    type: Inject,
+                    args: [AbstractTuiPortalService]
+                }] }]; }, propDecorators: { viewContainerRef: [{
+                type: ViewChild,
+                args: [`viewContainer`, { read: ViewContainerRef }]
+            }] } });
 
-var AbstractTuiThemeSwitcher_1;
 /**
  * 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.
- * @dynamic
  */
-let AbstractTuiThemeSwitcher = AbstractTuiThemeSwitcher_1 = class AbstractTuiThemeSwitcher {
+class AbstractTuiThemeSwitcher {
     constructor(documentRef) {
         this.documentRef = documentRef;
         if (this.style !== null) {
@@ -516,19 +495,20 @@ let AbstractTuiThemeSwitcher = AbstractTuiThemeSwitcher_1 = class AbstractTuiThe
             this.documentRef.head.removeChild(this.style);
         }
     }
-};
+}
 AbstractTuiThemeSwitcher.style = null;
-AbstractTuiThemeSwitcher.ctorParameters = () => [
-    { type: Document, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
-];
-AbstractTuiThemeSwitcher = AbstractTuiThemeSwitcher_1 = __decorate([
-    Directive(),
-    __param(0, Inject(DOCUMENT))
-], AbstractTuiThemeSwitcher);
+AbstractTuiThemeSwitcher.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AbstractTuiThemeSwitcher, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Directive });
+AbstractTuiThemeSwitcher.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.16", type: AbstractTuiThemeSwitcher, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AbstractTuiThemeSwitcher, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AbstractTuiControl, AbstractTuiController, AbstractTuiDialogDirective, AbstractTuiDialogService, AbstractTuiInteractive, AbstractTuiMultipleControl, AbstractTuiNullableControl, AbstractTuiPortalHostComponent, AbstractTuiPortalService, AbstractTuiThemeSwitcher, TuiController };
+export { AbstractTuiControl, AbstractTuiController, AbstractTuiDialogDirective, AbstractTuiDialogService, AbstractTuiInteractive, AbstractTuiMultipleControl, AbstractTuiNullableControl, AbstractTuiPortalHostComponent, AbstractTuiPortalService, AbstractTuiThemeSwitcher, tuiAsControl };
 //# sourceMappingURL=taiga-ui-cdk-abstract.js.map