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

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

@@ -1,91 +1,59 @@
-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, 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_';
+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.
          */
         this.focusable = true;
-        this.nativeId = '';
+        this.nativeId = ``;
         /**
          * 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;
@@ -165,7 +126,7 @@ let AbstractTuiControl = class AbstractTuiControl extends AbstractTuiInteractive
         this.readOnly = false;
         this.pseudoInvalid = null;
         if (this.ngControl === null) {
-            tuiAssert.assert(false, `NgControl not injected in ${this.constructor.name}!\n`, 'Use [(ngModel)] or [formControl] or formControlName for correct work.');
+            tuiAssert.assert(false, `NgControl not injected in ${this.constructor.name}!\n`, `Use [(ngModel)] or [formControl] or formControlName for correct work.`);
         }
         else {
             this.ngControl.valueAccessor = this;
@@ -296,33 +257,30 @@ 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`]
+            }] } });
 
-/**
- * @deprecated
- * TODO: 3.0 replace with {@link AbstractTuiController}
- */
-class TuiController {
+class AbstractTuiController {
     constructor() {
         this.change$ = new Subject();
     }
@@ -330,10 +288,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 +314,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 +339,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();
@@ -436,16 +405,17 @@ 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 {
+class AbstractTuiPortalHostComponent {
     constructor(elementRef, portalService) {
         this.elementRef = elementRef;
         portalService.attach(this);
@@ -458,7 +428,7 @@ let AbstractTuiPortalHostComponent = AbstractTuiPortalHostComponent_1 = class Ab
             parent: injector,
             providers: [
                 {
-                    provide: AbstractTuiPortalHostComponent_1,
+                    provide: AbstractTuiPortalHostComponent,
                     useValue: this,
                 },
             ],
@@ -467,21 +437,22 @@ let AbstractTuiPortalHostComponent = AbstractTuiPortalHostComponent_1 = class Ab
     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: 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.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
@@ -489,14 +460,14 @@ var AbstractTuiThemeSwitcher_1;
  * switch theme on or off.
  * @dynamic
  */
-let AbstractTuiThemeSwitcher = AbstractTuiThemeSwitcher_1 = class AbstractTuiThemeSwitcher {
+class AbstractTuiThemeSwitcher {
     constructor(documentRef) {
         this.documentRef = documentRef;
         if (this.style !== null) {
             this.addTheme();
             return;
         }
-        const styles = this.documentRef.head.querySelectorAll('style');
+        const styles = this.documentRef.head.querySelectorAll(`style`);
         this.constructor.style =
             styles[styles.length - 1];
     }
@@ -516,19 +487,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 };
 //# sourceMappingURL=taiga-ui-cdk-abstract.js.map