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

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

@@ -1,23 +1,24 @@
-import { __decorate, __param } from 'tslib';
-import { Injectable, ComponentFactoryResolver, Inject, Injector, INJECTOR, Renderer2, ɵɵdefineInjectable, ɵɵinject, ElementRef, ChangeDetectorRef, NgZone, Self } from '@angular/core';
-import { ReplaySubject, Observable, merge, defer, fromEvent, of, timer } from 'rxjs';
-import { DOCUMENT } from '@angular/common';
-import { TUI_DEFAULT_RENDERER, TUI_SWIPE_OPTIONS, TUI_ZOOM_OPTIONS } from '@taiga-ui/cdk/tokens';
-import { focusVisibleObservable, watch, typedFromEvent, tuiZoneOptimized, tuiZonefree, preventDefault } from '@taiga-ui/cdk/observables';
-import { takeUntil, switchMap, filter, take, mapTo, startWith, distinctUntilChanged, delay, throttleTime, map, switchMapTo, pairwise, repeat, catchError, debounceTime, tap, shareReplay, scan } from 'rxjs/operators';
-import { getActualTarget, getElementObscurers } from '@taiga-ui/cdk/utils/dom';
+import * as i0 from '@angular/core';
+import { Injectable, ComponentFactoryResolver, INJECTOR, Inject, ElementRef, ChangeDetectorRef, NgZone, Self } from '@angular/core';
+import * as i1 from 'rxjs';
+import { ReplaySubject, Observable, defer, merge, fromEvent, of, timer } from 'rxjs';
+import { tuiFocusVisibleObservable, tuiWatch, tuiTypedFromEvent, tuiZoneOptimized, tuiZonefree, tuiPreventDefault } from '@taiga-ui/cdk/observables';
+import { takeUntil, delay, throttleTime, map, startWith, distinctUntilChanged, switchMapTo, filter, pairwise, repeat, catchError, mapTo, debounceTime, switchMap, tap, shareReplay, scan } from 'rxjs/operators';
 import { WINDOW, ANIMATION_FRAME, PERFORMANCE } from '@ng-web-apis/common';
 import { POLLING_TIME, EMPTY_ARRAY } from '@taiga-ui/cdk/constants';
+import { tuiGetElementObscures } from '@taiga-ui/cdk/utils/dom';
+import { DOCUMENT } from '@angular/common';
 import { ResizeObserverService, RESIZE_OBSERVER_SUPPORT, RESIZE_OPTION_BOX } from '@ng-web-apis/resize-observer';
 import { tuiAssert } from '@taiga-ui/cdk/classes';
-import { clamp } from '@taiga-ui/cdk/utils/math';
-import { easeInOutQuad, getSwipeDirection, isPresent } from '@taiga-ui/cdk/utils/miscellaneous';
-import { distanceBetweenTouches } from '@taiga-ui/cdk/utils';
+import { tuiClamp } from '@taiga-ui/cdk/utils/math';
+import { tuiEaseInOutQuad, tuiGetSwipeDirection, tuiIsPresent } from '@taiga-ui/cdk/utils/miscellaneous';
+import { TUI_SWIPE_OPTIONS, TUI_ZOOM_OPTIONS } from '@taiga-ui/cdk/tokens';
+import { tuiDistanceBetweenTouches } from '@taiga-ui/cdk/utils';
 
 /**
  * Observable abstraction over ngOnDestroy to use with takeUntil
  */
-let TuiDestroyService = class TuiDestroyService extends ReplaySubject {
+class TuiDestroyService extends ReplaySubject {
     constructor() {
         super(1);
     }
@@ -25,21 +26,20 @@ let TuiDestroyService = class TuiDestroyService extends ReplaySubject {
         this.next();
         this.complete();
     }
-};
-TuiDestroyService = __decorate([
-    Injectable()
-], TuiDestroyService);
+}
+TuiDestroyService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiDestroyService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+TuiDestroyService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiDestroyService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiDestroyService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
 
 /**
  * Service to use styles with directives
- * @dynamic
  */
-let TuiDirectiveStylesService = class TuiDirectiveStylesService {
-    constructor(resolver, injector, documentRef, renderer) {
+class TuiDirectiveStylesService {
+    constructor(resolver, injector) {
         this.resolver = resolver;
         this.injector = injector;
-        this.documentRef = documentRef;
-        this.renderer = renderer;
         this.map = new Map();
     }
     addComponent(component) {
@@ -47,108 +47,71 @@ let TuiDirectiveStylesService = class TuiDirectiveStylesService {
             this.map.set(component, this.resolver.resolveComponentFactory(component).create(this.injector));
         }
     }
-    /** @deprecated use components approach
-     * TODO: delete in v3.0
-     */
-    addStyle(styles, attribute) {
-        if (this.documentRef.head.querySelector(`style[${attribute}]`)) {
-            return;
-        }
-        const style = this.renderer.createElement(`style`);
-        this.renderer.setProperty(style, `textContent`, styles);
-        this.renderer.setAttribute(style, attribute, ``);
-        this.documentRef.head.appendChild(style);
-    }
-};
-TuiDirectiveStylesService.ctorParameters = () => [
-    { type: ComponentFactoryResolver, decorators: [{ type: Inject, args: [ComponentFactoryResolver,] }] },
-    { type: Injector, decorators: [{ type: Inject, args: [INJECTOR,] }] },
-    { type: Document, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
-    { type: Renderer2, decorators: [{ type: Inject, args: [TUI_DEFAULT_RENDERER,] }] }
-];
-TuiDirectiveStylesService.ɵprov = ɵɵdefineInjectable({ factory: function TuiDirectiveStylesService_Factory() { return new TuiDirectiveStylesService(ɵɵinject(ComponentFactoryResolver), ɵɵinject(INJECTOR), ɵɵinject(DOCUMENT), ɵɵinject(TUI_DEFAULT_RENDERER)); }, token: TuiDirectiveStylesService, providedIn: "root" });
-TuiDirectiveStylesService = __decorate([
-    Injectable({
-        providedIn: `root`,
-    }),
-    __param(0, Inject(ComponentFactoryResolver)),
-    __param(1, Inject(INJECTOR)),
-    __param(2, Inject(DOCUMENT)),
-    __param(3, Inject(TUI_DEFAULT_RENDERER))
-], TuiDirectiveStylesService);
+}
+TuiDirectiveStylesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiDirectiveStylesService, deps: [{ token: ComponentFactoryResolver }, { token: INJECTOR }], target: i0.ɵɵFactoryTarget.Injectable });
+TuiDirectiveStylesService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiDirectiveStylesService, providedIn: `root` });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiDirectiveStylesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: `root`,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ComponentFactoryResolver, decorators: [{
+                    type: Inject,
+                    args: [ComponentFactoryResolver]
+                }] }, { type: i0.Injector, decorators: [{
+                    type: Inject,
+                    args: [INJECTOR]
+                }] }]; } });
 
 /**
  * Service to imitate :focus-visible
  * (https://developer.mozilla.org/en-US/docs/Web/CSS/:focus-visible)
  * in browsers that do not support it
- * @dynamic
  */
-let TuiFocusVisibleService = class TuiFocusVisibleService extends Observable {
+class TuiFocusVisibleService extends Observable {
     constructor({ nativeElement }, changeDetectorRef, destroy$) {
         super(subscriber => this.focusVisible$.subscribe(subscriber));
-        this.focusVisible$ = focusVisibleObservable(nativeElement).pipe(watch(changeDetectorRef), takeUntil(destroy$));
+        this.focusVisible$ = tuiFocusVisibleObservable(nativeElement).pipe(tuiWatch(changeDetectorRef), takeUntil(destroy$));
     }
-};
-TuiFocusVisibleService.ctorParameters = () => [
-    { type: ElementRef, decorators: [{ type: Inject, args: [ElementRef,] }] },
-    { type: ChangeDetectorRef, decorators: [{ type: Inject, args: [ChangeDetectorRef,] }] },
-    { type: Observable, decorators: [{ type: Inject, args: [TuiDestroyService,] }] }
-];
-TuiFocusVisibleService = __decorate([
-    Injectable(),
-    __param(0, Inject(ElementRef)),
-    __param(1, Inject(ChangeDetectorRef)),
-    __param(2, Inject(TuiDestroyService))
-], TuiFocusVisibleService);
+}
+TuiFocusVisibleService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiFocusVisibleService, deps: [{ token: ElementRef }, { token: ChangeDetectorRef }, { token: TuiDestroyService }], target: i0.ɵɵFactoryTarget.Injectable });
+TuiFocusVisibleService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiFocusVisibleService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiFocusVisibleService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.ElementRef, decorators: [{
+                    type: Inject,
+                    args: [ElementRef]
+                }] }, { type: i0.ChangeDetectorRef, decorators: [{
+                    type: Inject,
+                    args: [ChangeDetectorRef]
+                }] }, { type: i1.Observable, decorators: [{
+                    type: Inject,
+                    args: [TuiDestroyService]
+                }] }]; } });
 
-/** @deprecated TODO remove in v3.0 */
-// @dynamic
-let TuiHoveredService = class TuiHoveredService {
-    constructor(documentRef, ngZone) {
-        this.ngZone = ngZone;
-        this.documentEvents$ = merge(typedFromEvent(documentRef, `mousemove`), typedFromEvent(documentRef, `touchstart`, { capture: true }));
-    }
-    createHovered$(target, options = { passive: true }) {
-        return merge(typedFromEvent(target, `mouseenter`, options), typedFromEvent(target, `touchstart`, options)).pipe(switchMap(() => merge(typedFromEvent(target, `mouseleave`, options), this.documentEvents$.pipe(filter(event => !target.contains(getActualTarget(event))), tuiZoneOptimized(this.ngZone), take(1))).pipe(mapTo(false), startWith(true))), distinctUntilChanged());
-    }
-};
-TuiHoveredService.ctorParameters = () => [
-    { type: Document, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
-    { type: NgZone, decorators: [{ type: Inject, args: [NgZone,] }] }
-];
-TuiHoveredService.ɵprov = ɵɵdefineInjectable({ factory: function TuiHoveredService_Factory() { return new TuiHoveredService(ɵɵinject(DOCUMENT), ɵɵinject(NgZone)); }, token: TuiHoveredService, providedIn: "root" });
-TuiHoveredService = __decorate([
-    Injectable({
-        providedIn: `root`,
-    }),
-    __param(0, Inject(DOCUMENT)),
-    __param(1, Inject(NgZone))
-], TuiHoveredService);
-
-var TuiIdService_1;
 const TUI = `tui_`;
 /**
  * Generates unique ids
  */
-let TuiIdService = TuiIdService_1 = class TuiIdService {
+class TuiIdService {
     generate() {
-        return `${TUI}${TuiIdService_1.autoId++}${Date.now()}`;
+        return `${TUI}${TuiIdService.autoId++}${Date.now()}`;
     }
-};
+}
 TuiIdService.autoId = 0;
-TuiIdService.ɵprov = ɵɵdefineInjectable({ factory: function TuiIdService_Factory() { return new TuiIdService(); }, token: TuiIdService, providedIn: "root" });
-TuiIdService = TuiIdService_1 = __decorate([
-    Injectable({
-        providedIn: `root`,
-    })
-], TuiIdService);
+TuiIdService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiIdService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+TuiIdService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiIdService, providedIn: `root` });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiIdService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: `root`,
+                }]
+        }] });
 
 /**
  * Service that subscribes to scroll events of all parent elements
  */
-// Ambient type cannot be used without dynamic https://github.com/angular/angular/issues/23395
-// @dynamic
-let TuiParentsScrollService = class TuiParentsScrollService extends Observable {
+class TuiParentsScrollService extends Observable {
     constructor(elementRef, windowRef) {
         super(subscriber => this.callback$.subscribe(subscriber));
         this.callback$ = defer(() => {
@@ -158,19 +121,21 @@ let TuiParentsScrollService = class TuiParentsScrollService extends Observable {
                 nativeElement = nativeElement.parentElement;
                 eventTargets.push(nativeElement);
             }
-            return merge(...eventTargets.map(element => typedFromEvent(element, `scroll`)));
+            return merge(...eventTargets.map(element => tuiTypedFromEvent(element, `scroll`)));
         });
     }
-};
-TuiParentsScrollService.ctorParameters = () => [
-    { type: ElementRef, decorators: [{ type: Inject, args: [ElementRef,] }] },
-    { type: Window, decorators: [{ type: Inject, args: [WINDOW,] }] }
-];
-TuiParentsScrollService = __decorate([
-    Injectable(),
-    __param(0, Inject(ElementRef)),
-    __param(1, Inject(WINDOW))
-], TuiParentsScrollService);
+}
+TuiParentsScrollService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiParentsScrollService, deps: [{ token: ElementRef }, { token: WINDOW }], target: i0.ɵɵFactoryTarget.Injectable });
+TuiParentsScrollService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiParentsScrollService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiParentsScrollService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.ElementRef, decorators: [{
+                    type: Inject,
+                    args: [ElementRef]
+                }] }, { type: Window, decorators: [{
+                    type: Inject,
+                    args: [WINDOW]
+                }] }]; } });
 
 // @bad TODO: Consider Intersection Observer with fallback to current implementation
 /**
@@ -178,93 +143,101 @@ TuiParentsScrollService = __decorate([
  * and polling with set interval, returns either null or an array
  * of elements that overlap given element edges
  */
-// Ambient type cannot be used without dynamic https://github.com/angular/angular/issues/23395
-// @dynamic
-let TuiObscuredService = class TuiObscuredService extends Observable {
+class TuiObscuredService extends Observable {
     constructor(parentsScroll$, { nativeElement }, ngZone, windowRef, destroy$, animationFrame$) {
         super(subscriber => this.obscured$.subscribe(subscriber));
         this.obscured$ = merge(
         // delay is added so it will not interfere with other listeners
-        merge(parentsScroll$, fromEvent(windowRef, `resize`)).pipe(delay(0)), animationFrame$.pipe(throttleTime(POLLING_TIME))).pipe(map(() => getElementObscurers(nativeElement)), startWith(null), distinctUntilChanged(), tuiZoneOptimized(ngZone), takeUntil(destroy$));
+        merge(parentsScroll$, fromEvent(windowRef, `resize`)).pipe(delay(0)), animationFrame$.pipe(throttleTime(POLLING_TIME))).pipe(map(() => tuiGetElementObscures(nativeElement)), startWith(null), distinctUntilChanged(), tuiZoneOptimized(ngZone), takeUntil(destroy$));
     }
-};
-TuiObscuredService.ctorParameters = () => [
-    { type: TuiParentsScrollService, decorators: [{ type: Inject, args: [TuiParentsScrollService,] }, { type: Self }] },
-    { type: ElementRef, decorators: [{ type: Inject, args: [ElementRef,] }] },
-    { type: NgZone, decorators: [{ type: Inject, args: [NgZone,] }] },
-    { type: Window, decorators: [{ type: Inject, args: [WINDOW,] }] },
-    { type: Observable, decorators: [{ type: Inject, args: [TuiDestroyService,] }] },
-    { type: Observable, decorators: [{ type: Inject, args: [ANIMATION_FRAME,] }] }
-];
-TuiObscuredService = __decorate([
-    Injectable(),
-    __param(0, Inject(TuiParentsScrollService)),
-    __param(0, Self()),
-    __param(1, Inject(ElementRef)),
-    __param(2, Inject(NgZone)),
-    __param(3, Inject(WINDOW)),
-    __param(4, Inject(TuiDestroyService)),
-    __param(5, Inject(ANIMATION_FRAME))
-], TuiObscuredService);
+}
+TuiObscuredService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiObscuredService, deps: [{ token: TuiParentsScrollService, self: true }, { token: ElementRef }, { token: NgZone }, { token: WINDOW }, { token: TuiDestroyService }, { token: ANIMATION_FRAME }], target: i0.ɵɵFactoryTarget.Injectable });
+TuiObscuredService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiObscuredService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiObscuredService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: TuiParentsScrollService, decorators: [{
+                    type: Inject,
+                    args: [TuiParentsScrollService]
+                }, {
+                    type: Self
+                }] }, { type: i0.ElementRef, decorators: [{
+                    type: Inject,
+                    args: [ElementRef]
+                }] }, { type: i0.NgZone, decorators: [{
+                    type: Inject,
+                    args: [NgZone]
+                }] }, { type: Window, decorators: [{
+                    type: Inject,
+                    args: [WINDOW]
+                }] }, { type: i1.Observable, decorators: [{
+                    type: Inject,
+                    args: [TuiDestroyService]
+                }] }, { type: i1.Observable, decorators: [{
+                    type: Inject,
+                    args: [ANIMATION_FRAME]
+                }] }]; } });
 
-/**
- * @dynamic
- */
-let TuiPanService = class TuiPanService extends Observable {
+class TuiPanService extends Observable {
     constructor({ nativeElement }, documentRef) {
         super(subscriber => {
-            merge(typedFromEvent(nativeElement, `touchstart`, { passive: true }), typedFromEvent(nativeElement, `mousedown`))
-                .pipe(switchMapTo(merge(typedFromEvent(documentRef, `touchmove`, {
+            merge(tuiTypedFromEvent(nativeElement, `touchstart`, { passive: true }), tuiTypedFromEvent(nativeElement, `mousedown`))
+                .pipe(switchMapTo(merge(tuiTypedFromEvent(documentRef, `touchmove`, {
                 passive: true,
-            }).pipe(filter(({ touches }) => touches.length < 2), map(({ touches }) => touches[0])), typedFromEvent(documentRef, `mousemove`))), pairwise(), map(([first, second]) => {
+            }).pipe(filter(({ touches }) => touches.length < 2), map(({ touches }) => touches[0])), tuiTypedFromEvent(documentRef, `mousemove`))), pairwise(), map(([first, second]) => {
                 const deltaX = second.clientX - first.clientX;
                 const deltaY = second.clientY - first.clientY;
                 return [deltaX, deltaY];
             }), 
             // eslint-disable-next-line rxjs/no-unsafe-takeuntil
-            takeUntil(merge(typedFromEvent(documentRef, `touchend`), typedFromEvent(documentRef, `mouseup`))), repeat())
+            takeUntil(merge(tuiTypedFromEvent(documentRef, `touchend`), tuiTypedFromEvent(documentRef, `mouseup`))), repeat())
                 .subscribe(subscriber);
         });
     }
-};
-TuiPanService.ctorParameters = () => [
-    { type: ElementRef, decorators: [{ type: Inject, args: [ElementRef,] }] },
-    { type: Document, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
-];
-TuiPanService = __decorate([
-    Injectable(),
-    __param(0, Inject(ElementRef)),
-    __param(1, Inject(DOCUMENT))
-], TuiPanService);
+}
+TuiPanService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiPanService, deps: [{ token: ElementRef }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+TuiPanService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiPanService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiPanService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.ElementRef, decorators: [{
+                    type: Inject,
+                    args: [ElementRef]
+                }] }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
 
-// @dynamic
-let TuiResizeService = class TuiResizeService extends ResizeObserverService {
+class TuiResizeService extends ResizeObserverService {
     constructor(elementRef, ngZone, destroy$, support, box, animationFrame$) {
         super(elementRef, ngZone, support, box);
         return this.pipe(catchError(() => animationFrame$.pipe(throttleTime(POLLING_TIME), map(() => `${elementRef.nativeElement.clientWidth} ${elementRef.nativeElement.clientHeight}`), distinctUntilChanged(), mapTo(EMPTY_ARRAY))), debounceTime(0), tuiZonefree(ngZone), takeUntil(destroy$));
     }
-};
-TuiResizeService.ctorParameters = () => [
-    { type: ElementRef, decorators: [{ type: Inject, args: [ElementRef,] }] },
-    { type: NgZone, decorators: [{ type: Inject, args: [NgZone,] }] },
-    { type: Observable, decorators: [{ type: Inject, args: [TuiDestroyService,] }] },
-    { type: Boolean, decorators: [{ type: Inject, args: [RESIZE_OBSERVER_SUPPORT,] }] },
-    { type: undefined, decorators: [{ type: Inject, args: [RESIZE_OPTION_BOX,] }] },
-    { type: Observable, decorators: [{ type: Inject, args: [ANIMATION_FRAME,] }] }
-];
-TuiResizeService = __decorate([
-    Injectable(),
-    __param(0, Inject(ElementRef)),
-    __param(1, Inject(NgZone)),
-    __param(2, Inject(TuiDestroyService)),
-    __param(3, Inject(RESIZE_OBSERVER_SUPPORT)),
-    __param(4, Inject(RESIZE_OPTION_BOX)),
-    __param(5, Inject(ANIMATION_FRAME))
-], TuiResizeService);
+}
+TuiResizeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiResizeService, deps: [{ token: ElementRef }, { token: NgZone }, { token: TuiDestroyService }, { token: RESIZE_OBSERVER_SUPPORT }, { token: RESIZE_OPTION_BOX }, { token: ANIMATION_FRAME }], target: i0.ɵɵFactoryTarget.Injectable });
+TuiResizeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiResizeService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiResizeService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.ElementRef, decorators: [{
+                    type: Inject,
+                    args: [ElementRef]
+                }] }, { type: i0.NgZone, decorators: [{
+                    type: Inject,
+                    args: [NgZone]
+                }] }, { type: i1.Observable, decorators: [{
+                    type: Inject,
+                    args: [TuiDestroyService]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [RESIZE_OBSERVER_SUPPORT]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [RESIZE_OPTION_BOX]
+                }] }, { type: i1.Observable, decorators: [{
+                    type: Inject,
+                    args: [ANIMATION_FRAME]
+                }] }]; } });
 
 const SCROLL_TIME = 300;
-// @dynamic
-let TuiScrollService = class TuiScrollService {
+class TuiScrollService {
     constructor(performanceRef, animationFrame$) {
         this.performanceRef = performanceRef;
         this.animationFrame$ = animationFrame$;
@@ -279,7 +252,7 @@ let TuiScrollService = class TuiScrollService {
         const deltaLeft = scrollLeft - initialLeft;
         const observable = !duration
             ? of([scrollTop, scrollLeft])
-            : defer(() => of(this.performanceRef.now())).pipe(switchMap(start => this.animationFrame$.pipe(map(now => now - start))), map(elapsed => easeInOutQuad(clamp(elapsed / duration, 0, 1))), map(percent => [
+            : defer(() => of(this.performanceRef.now())).pipe(switchMap(start => this.animationFrame$.pipe(map(now => now - start))), map(elapsed => tuiEaseInOutQuad(tuiClamp(elapsed / duration, 0, 1))), map(percent => [
                 initialTop + deltaTop * percent,
                 initialLeft + deltaLeft * percent,
             ]), takeUntil(timer(duration)));
@@ -288,21 +261,23 @@ let TuiScrollService = class TuiScrollService {
             element.scrollLeft = scrollLeft;
         }));
     }
-};
-TuiScrollService.ctorParameters = () => [
-    { type: Performance, decorators: [{ type: Inject, args: [PERFORMANCE,] }] },
-    { type: Observable, decorators: [{ type: Inject, args: [ANIMATION_FRAME,] }] }
-];
-TuiScrollService.ɵprov = ɵɵdefineInjectable({ factory: function TuiScrollService_Factory() { return new TuiScrollService(ɵɵinject(PERFORMANCE), ɵɵinject(ANIMATION_FRAME)); }, token: TuiScrollService, providedIn: "root" });
-TuiScrollService = __decorate([
-    Injectable({
-        providedIn: `root`,
-    }),
-    __param(0, Inject(PERFORMANCE)),
-    __param(1, Inject(ANIMATION_FRAME))
-], TuiScrollService);
+}
+TuiScrollService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiScrollService, deps: [{ token: PERFORMANCE }, { token: ANIMATION_FRAME }], target: i0.ɵɵFactoryTarget.Injectable });
+TuiScrollService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiScrollService, providedIn: `root` });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiScrollService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: `root`,
+                }]
+        }], ctorParameters: function () { return [{ type: Performance, decorators: [{
+                    type: Inject,
+                    args: [PERFORMANCE]
+                }] }, { type: i1.Observable, decorators: [{
+                    type: Inject,
+                    args: [ANIMATION_FRAME]
+                }] }]; } });
 
-let TuiStaticRequestService = class TuiStaticRequestService {
+class TuiStaticRequestService {
     constructor() {
         this.cache = new Map();
     }
@@ -335,21 +310,20 @@ let TuiStaticRequestService = class TuiStaticRequestService {
         this.cache.set(url, piped);
         return piped;
     }
-};
-TuiStaticRequestService.ɵprov = ɵɵdefineInjectable({ factory: function TuiStaticRequestService_Factory() { return new TuiStaticRequestService(); }, token: TuiStaticRequestService, providedIn: "root" });
-TuiStaticRequestService = __decorate([
-    Injectable({
-        providedIn: `root`,
-    })
-], TuiStaticRequestService);
+}
+TuiStaticRequestService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiStaticRequestService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+TuiStaticRequestService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiStaticRequestService, providedIn: `root` });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiStaticRequestService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: `root`,
+                }]
+        }] });
 
-/**
- * @dynamic
- */
-let TuiSwipeService = class TuiSwipeService extends Observable {
+class TuiSwipeService extends Observable {
     constructor({ nativeElement }, { timeout, threshold }, documentRef) {
         super(subscriber => {
-            merge(typedFromEvent(nativeElement, `touchstart`, { passive: true }), typedFromEvent(documentRef, `touchend`))
+            merge(tuiTypedFromEvent(nativeElement, `touchstart`, { passive: true }), tuiTypedFromEvent(documentRef, `touchend`))
                 .pipe(pairwise(), filter(([first, second]) => !!first.touches.length &&
                 first.touches[0].identifier ===
                     second.changedTouches[0].identifier), map(([start, end]) => {
@@ -364,37 +338,39 @@ let TuiSwipeService = class TuiSwipeService extends Observable {
                     Math.abs(distanceY) > threshold) &&
                     duration < timeout) {
                     return {
-                        direction: getSwipeDirection(distanceX, distanceY),
+                        direction: tuiGetSwipeDirection(distanceX, distanceY),
                         events: [start, end],
                     };
                 }
                 return null;
-            }), filter(isPresent))
+            }), filter(tuiIsPresent))
                 .subscribe(subscriber);
         });
     }
-};
-TuiSwipeService.ctorParameters = () => [
-    { type: ElementRef, decorators: [{ type: Inject, args: [ElementRef,] }] },
-    { type: undefined, decorators: [{ type: Inject, args: [TUI_SWIPE_OPTIONS,] }] },
-    { type: Document, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
-];
-TuiSwipeService = __decorate([
-    Injectable(),
-    __param(0, Inject(ElementRef)),
-    __param(1, Inject(TUI_SWIPE_OPTIONS)),
-    __param(2, Inject(DOCUMENT))
-], TuiSwipeService);
+}
+TuiSwipeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiSwipeService, deps: [{ token: ElementRef }, { token: TUI_SWIPE_OPTIONS }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+TuiSwipeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiSwipeService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiSwipeService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.ElementRef, decorators: [{
+                    type: Inject,
+                    args: [ElementRef]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TUI_SWIPE_OPTIONS]
+                }] }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
 
 const TOUCH_SENSITIVITY = 0.01;
-// @dynamic
-let TuiZoomService = class TuiZoomService extends Observable {
+class TuiZoomService extends Observable {
     constructor({ nativeElement }, { wheelSensitivity }) {
         super(subscriber => {
-            merge(typedFromEvent(nativeElement, `touchstart`, { passive: true }).pipe(filter(({ touches }) => touches.length > 1), switchMap(startEvent => typedFromEvent(nativeElement, `touchmove`, {
+            merge(tuiTypedFromEvent(nativeElement, `touchstart`, { passive: true }).pipe(filter(({ touches }) => touches.length > 1), switchMap(startEvent => tuiTypedFromEvent(nativeElement, `touchmove`, {
                 passive: true,
-            }).pipe(preventDefault(), scan((prev, event) => {
-                const distance = distanceBetweenTouches(event);
+            }).pipe(tuiPreventDefault(), scan((prev, event) => {
+                const distance = tuiDistanceBetweenTouches(event);
                 return {
                     event,
                     distance,
@@ -403,7 +379,7 @@ let TuiZoomService = class TuiZoomService extends Observable {
                 };
             }, {
                 event: startEvent,
-                distance: distanceBetweenTouches(startEvent),
+                distance: tuiDistanceBetweenTouches(startEvent),
                 delta: 0,
             }), map(({ event, delta }) => {
                 const clientX = (event.touches[0].clientX +
@@ -413,7 +389,7 @@ let TuiZoomService = class TuiZoomService extends Observable {
                     event.touches[1].clientY) /
                     2;
                 return { clientX, clientY, delta, event };
-            }), takeUntil(typedFromEvent(nativeElement, `touchend`))))), typedFromEvent(nativeElement, `wheel`, { passive: false }).pipe(preventDefault(), map(wheel => ({
+            }), takeUntil(tuiTypedFromEvent(nativeElement, `touchend`))))), tuiTypedFromEvent(nativeElement, `wheel`, { passive: false }).pipe(tuiPreventDefault(), map(wheel => ({
                 clientX: wheel.clientX,
                 clientY: wheel.clientY,
                 delta: -wheel.deltaY * wheelSensitivity,
@@ -421,20 +397,22 @@ let TuiZoomService = class TuiZoomService extends Observable {
             })))).subscribe(subscriber);
         });
     }
-};
-TuiZoomService.ctorParameters = () => [
-    { type: ElementRef, decorators: [{ type: Inject, args: [ElementRef,] }] },
-    { type: undefined, decorators: [{ type: Inject, args: [TUI_ZOOM_OPTIONS,] }] }
-];
-TuiZoomService = __decorate([
-    Injectable(),
-    __param(0, Inject(ElementRef)),
-    __param(1, Inject(TUI_ZOOM_OPTIONS))
-], TuiZoomService);
+}
+TuiZoomService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiZoomService, deps: [{ token: ElementRef }, { token: TUI_ZOOM_OPTIONS }], target: i0.ɵɵFactoryTarget.Injectable });
+TuiZoomService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiZoomService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiZoomService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.ElementRef, decorators: [{
+                    type: Inject,
+                    args: [ElementRef]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TUI_ZOOM_OPTIONS]
+                }] }]; } });
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { TuiDestroyService, TuiDirectiveStylesService, TuiFocusVisibleService, TuiHoveredService, TuiIdService, TuiObscuredService, TuiPanService, TuiParentsScrollService, TuiResizeService, TuiScrollService, TuiStaticRequestService, TuiSwipeService, TuiZoomService };
+export { TuiDestroyService, TuiDirectiveStylesService, TuiFocusVisibleService, TuiIdService, TuiObscuredService, TuiPanService, TuiParentsScrollService, TuiResizeService, TuiScrollService, TuiStaticRequestService, TuiSwipeService, TuiZoomService };
 //# sourceMappingURL=taiga-ui-cdk-services.js.map