@evotor-dev/ui-kit 6.17.0 → 6.17.2

package/esm2015/lib/components/evo-tooltip/evo-tooltip.component.js

@@ -0,0 +1,102 @@
+import { ChangeDetectionStrategy, Component, HostBinding, } from '@angular/core';
+import { BehaviorSubject, combineLatest, EMPTY, Subject } from 'rxjs';
+import { filter, map, pairwise, startWith, takeUntil, tap } from 'rxjs/operators';
+import { EVO_TOOLTIP_FADEIN_ANIMATION } from './constants/evo-tooltip-fadein.animation';
+import { EvoTooltipPosition } from './enums/evo-tooltip-position';
+import { EVO_TOOLTIP_ARROW_SIZE } from './constants/evo-tooltip-arrow-size';
+import { EVO_TOOLTIP_RADIUS } from './constants/evo-tooltip-radius';
+import { EvoTooltipVariableArrowPosition } from './enums/evo-tooltip-variable-arrow-position';
+import * as i0 from "@angular/core";
+import * as i1 from "./services/evo-tooltip.service";
+import * as i2 from "@angular/common";
+export class EvoTooltipComponent {
+    constructor(elementRef, tooltipService, renderer) {
+        this.elementRef = elementRef;
+        this.tooltipService = tooltipService;
+        this.renderer = renderer;
+        this.position$ = this.tooltipService.position$;
+        this.stringContent$ = this.tooltipService.stringContent$;
+        this.templateContent$ = this.tooltipService.templateContent$;
+        this.visibleArrow$ = this.tooltipService.visibleArrow$;
+        this.styles$ = EMPTY;
+        this.fadeIn = true;
+        this._positionArrowStyles$ = new BehaviorSubject(null);
+        this._destroy$ = new Subject();
+        this.styles$ = combineLatest([this.tooltipService.styles$, this._positionArrowStyles$]).pipe(map(([style1, style2]) => (Object.assign(Object.assign({}, style1), style2))));
+    }
+    ngOnInit() {
+        combineLatest([this.position$, this.tooltipService.parentRef$, this.visibleArrow$])
+            .pipe(filter(([_position, _parentRef, visibleArrow]) => visibleArrow), 
+        // Вычисление стрелки нужно только для угловых позиций
+        filter(([position]) => {
+            switch (position) {
+                case EvoTooltipPosition.TOP:
+                case EvoTooltipPosition.RIGHT:
+                case EvoTooltipPosition.BOTTOM:
+                case EvoTooltipPosition.LEFT:
+                    return false;
+                default:
+                    return true;
+            }
+        }), tap(([_, parentRef]) => {
+            this.setArrowPosition(parentRef);
+        }), takeUntil(this._destroy$))
+            .subscribe();
+    }
+    ngAfterViewInit() {
+        this.tooltipService.tooltipClasses$
+            .pipe(startWith([]), pairwise(), tap(([a, b]) => {
+            (a || []).forEach((oldClass) => this.renderer.removeClass(this.elementRef.nativeElement, oldClass));
+            (b || []).forEach((newClass) => this.renderer.addClass(this.elementRef.nativeElement, newClass));
+        }), takeUntil(this._destroy$))
+            .subscribe();
+    }
+    ngOnDestroy() {
+        this.fadeIn = false;
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+    setArrowPosition(parentRef) {
+        // Для того чтобы стрелка тянулась к центру родителя - берем середину
+        const widthParent = parentRef.nativeElement.offsetWidth / 2;
+        const heightParent = parentRef.nativeElement.offsetHeight / 2;
+        const isParentLonger = widthParent >= this.elementRef.nativeElement.offsetWidth;
+        const isParentHigher = heightParent >= this.elementRef.nativeElement.offsetHeight;
+        // Если середина родителя оказывается меньше тултипа - берем середину родителя иначе размер тултипа
+        // Это проверка на максимальное смещение, смещение стрелки не должно быть больше размера тултипа
+        const width = isParentLonger ? this.elementRef.nativeElement.offsetWidth : widthParent;
+        const height = isParentHigher ? this.elementRef.nativeElement.offsetHeight : heightParent;
+        const positionArrow = (size, isParentBigger) => 
+        // Если середина родителя больше тултипа
+        // То берем размер тултипа и отнимаем размер стрелки и радиуса
+        // Иначе берем середину родителя и отнимаем половину стрелки
+        // Это условие нужно чтобы стрелка не смещалась
+        isParentBigger ? size - EVO_TOOLTIP_ARROW_SIZE - EVO_TOOLTIP_RADIUS : size - EVO_TOOLTIP_ARROW_SIZE / 2;
+        let verticalPositionArrow = positionArrow(height, isParentHigher);
+        let horizontalPositionArrow = positionArrow(width, isParentLonger);
+        // Проверка на минимальное смещение, смещение стрелки не должно быть меньше размера радиуса тултипа 8px
+        horizontalPositionArrow =
+            horizontalPositionArrow > EVO_TOOLTIP_RADIUS ? horizontalPositionArrow : EVO_TOOLTIP_RADIUS;
+        verticalPositionArrow = verticalPositionArrow > EVO_TOOLTIP_RADIUS ? verticalPositionArrow : EVO_TOOLTIP_RADIUS;
+        this._positionArrowStyles$.next({
+            [EvoTooltipVariableArrowPosition.VERTICAL_POSITION_ARROW]: `${verticalPositionArrow}px`,
+            [EvoTooltipVariableArrowPosition.HORIZONTAL_POSITION_ARROW]: `${horizontalPositionArrow}px`,
+        });
+    }
+}
+EvoTooltipComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: EvoTooltipComponent, deps: [{ token: i0.ElementRef }, { token: i1.EvoTooltipService }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
+EvoTooltipComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: EvoTooltipComponent, selector: "evo-tooltip", host: { properties: { "@fadeIn": "this.fadeIn" } }, ngImport: i0, template: "<ng-container\n    *ngIf=\"{position: position$ | async, styles: styles$ | async, visibleArrow: visibleArrow$ | async} as asyncData\"\n>\n    <div\n        class=\"evo-tooltip\"\n        [class]=\"'evo-tooltip_' + asyncData.position\"\n        [class.evo-tooltip_not-arrow]=\"!asyncData.visibleArrow\"\n        [style]=\"asyncData.styles\"\n    >\n        <ng-container *ngIf=\"stringContent$ | async as content; else templateRef\">{{ content }}</ng-container>\n    </div>\n</ng-container>\n\n<ng-template #templateRef>\n    <ng-container *ngIf=\"templateContent$ | async as content\" [ngTemplateOutlet]=\"content\"></ng-container>\n</ng-template>\n", styles: [":host{--evo-tooltip-horizontal-position-arrow: 50%;--evo-tooltip-vertical-position-arrow: 50%;--evo-tooltip-color: #212121;--evo-tooltip-background-color: #FFF8E6;--evo-tooltip-max-width: 300px;--evo-tooltip-padding: 16px;--evo-tooltip-border-radius: 8px}:host:empty{display:none}.evo-tooltip{display:inline-block;position:relative;background-color:var(--evo-tooltip-background-color);color:var(--evo-tooltip-color);padding:var(--evo-tooltip-padding);font:inherit;border-radius:var(--evo-tooltip-border-radius);box-sizing:border-box;max-width:var(--evo-tooltip-max-width);filter:drop-shadow(0 8px 10px rgba(0,0,0,.14)) drop-shadow(0 3px 14px rgba(0,0,0,.12))}.evo-tooltip:empty{display:none}.evo-tooltip:not(.evo-tooltip_not-arrow):before{content:\"\";position:absolute;border-style:solid}.evo-tooltip_top-start:before,.evo-tooltip_top:before,.evo-tooltip_top-end:before{border-width:8px 8px 0 8px;border-color:var(--evo-tooltip-background-color) transparent transparent transparent;bottom:-8px}.evo-tooltip_top-start:before{left:var(--evo-tooltip-horizontal-position-arrow)}.evo-tooltip_top:before{left:50%;transform:translate(-50%)}.evo-tooltip_top-end:before{right:var(--evo-tooltip-horizontal-position-arrow)}.evo-tooltip_right-start:before,.evo-tooltip_right:before,.evo-tooltip_right-end:before{border-width:8px 8px 8px 0;border-color:transparent var(--evo-tooltip-background-color) transparent transparent;left:-8px}.evo-tooltip_right-start:before{top:var(--evo-tooltip-vertical-position-arrow)}.evo-tooltip_right:before{top:50%;transform:translateY(-50%)}.evo-tooltip_right-end:before{bottom:var(--evo-tooltip-vertical-position-arrow)}.evo-tooltip_bottom-start:before,.evo-tooltip_bottom:before,.evo-tooltip_bottom-end:before{border-width:0 8px 8px 8px;border-color:transparent transparent var(--evo-tooltip-background-color) transparent;top:-8px}.evo-tooltip_bottom-start:before{left:var(--evo-tooltip-horizontal-position-arrow)}.evo-tooltip_bottom:before{left:50%;transform:translate(-50%)}.evo-tooltip_bottom-end:before{right:var(--evo-tooltip-horizontal-position-arrow)}.evo-tooltip_left-start:before,.evo-tooltip_left:before,.evo-tooltip_left-end:before{border-width:8px 0 8px 8px;border-color:transparent transparent transparent var(--evo-tooltip-background-color);right:-8px}.evo-tooltip_left-start:before{top:var(--evo-tooltip-vertical-position-arrow)}.evo-tooltip_left:before{top:50%;transform:translateY(-50%)}.evo-tooltip_left-end:before{bottom:var(--evo-tooltip-vertical-position-arrow)}\n"], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }], pipes: { "async": i2.AsyncPipe }, animations: [EVO_TOOLTIP_FADEIN_ANIMATION], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: EvoTooltipComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'evo-tooltip',
+                    templateUrl: './evo-tooltip.component.html',
+                    styleUrls: ['./evo-tooltip.component.scss'],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    animations: [EVO_TOOLTIP_FADEIN_ANIMATION],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.EvoTooltipService }, { type: i0.Renderer2 }]; }, propDecorators: { fadeIn: [{
+                type: HostBinding,
+                args: ['@fadeIn']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"evo-tooltip.component.js","sourceRoot":"","sources":["../../../../../../projects/evo-ui-kit/src/lib/components/evo-tooltip/evo-tooltip.component.ts","../../../../../../projects/evo-ui-kit/src/lib/components/evo-tooltip/evo-tooltip.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n    AfterViewInit,\n    ChangeDetectionStrategy,\n    Component,\n    ElementRef,\n    HostBinding,\n    OnDestroy,\n    OnInit,\n    Renderer2,\n    TemplateRef,\n} from '@angular/core';\nimport {BehaviorSubject, combineLatest, EMPTY, Observable, Subject} from 'rxjs';\nimport {filter, map, pairwise, startWith, takeUntil, tap} from 'rxjs/operators';\nimport {EVO_TOOLTIP_FADEIN_ANIMATION} from './constants/evo-tooltip-fadein.animation';\nimport {EvoTooltipService} from './services/evo-tooltip.service';\nimport {EvoTooltipStyles} from './interfaces/evo-tooltip-styles';\nimport {EvoTooltipPosition} from './enums/evo-tooltip-position';\nimport {EVO_TOOLTIP_ARROW_SIZE} from './constants/evo-tooltip-arrow-size';\nimport {EVO_TOOLTIP_RADIUS} from './constants/evo-tooltip-radius';\nimport {EvoTooltipVariableArrowPosition} from './enums/evo-tooltip-variable-arrow-position';\n\n@Component({\n    selector: 'evo-tooltip',\n    templateUrl: './evo-tooltip.component.html',\n    styleUrls: ['./evo-tooltip.component.scss'],\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    animations: [EVO_TOOLTIP_FADEIN_ANIMATION],\n})\nexport class EvoTooltipComponent implements OnInit, AfterViewInit, OnDestroy {\n    readonly position$: Observable<EvoTooltipPosition> = this.tooltipService.position$;\n    readonly stringContent$: Observable<string> = this.tooltipService.stringContent$;\n    readonly templateContent$: Observable<TemplateRef<unknown>> = this.tooltipService.templateContent$;\n    readonly visibleArrow$: Observable<boolean> = this.tooltipService.visibleArrow$;\n    readonly styles$: Observable<EvoTooltipStyles> = EMPTY;\n\n    @HostBinding('@fadeIn') fadeIn = true;\n\n    private readonly _positionArrowStyles$ = new BehaviorSubject<EvoTooltipStyles>(null);\n    private readonly _destroy$ = new Subject<void>();\n\n    constructor(\n        private readonly elementRef: ElementRef,\n        private readonly tooltipService: EvoTooltipService,\n        private readonly renderer: Renderer2,\n    ) {\n        this.styles$ = combineLatest([this.tooltipService.styles$, this._positionArrowStyles$]).pipe(\n            map(([style1, style2]) => ({...style1, ...style2})),\n        );\n    }\n\n    ngOnInit(): void {\n        combineLatest([this.position$, this.tooltipService.parentRef$, this.visibleArrow$])\n            .pipe(\n                filter(([_position, _parentRef, visibleArrow]) => visibleArrow),\n                // Вычисление стрелки нужно только для угловых позиций\n                filter(([position]) => {\n                    switch (position) {\n                        case EvoTooltipPosition.TOP:\n                        case EvoTooltipPosition.RIGHT:\n                        case EvoTooltipPosition.BOTTOM:\n                        case EvoTooltipPosition.LEFT:\n                            return false;\n                        default:\n                            return true;\n                    }\n                }),\n                tap(([_, parentRef]) => {\n                    this.setArrowPosition(parentRef);\n                }),\n                takeUntil(this._destroy$),\n            )\n            .subscribe();\n    }\n\n    ngAfterViewInit(): void {\n        this.tooltipService.tooltipClasses$\n            .pipe(\n                startWith([]),\n                pairwise(),\n                tap(([a, b]: [string[], string[]]) => {\n                    (a || []).forEach((oldClass) => this.renderer.removeClass(this.elementRef.nativeElement, oldClass));\n                    (b || []).forEach((newClass) => this.renderer.addClass(this.elementRef.nativeElement, newClass));\n                }),\n                takeUntil(this._destroy$),\n            )\n            .subscribe();\n    }\n\n    ngOnDestroy(): void {\n        this.fadeIn = false;\n        this._destroy$.next();\n        this._destroy$.complete();\n    }\n\n    private setArrowPosition(parentRef: ElementRef): void {\n        // Для того чтобы стрелка тянулась к центру родителя - берем середину\n        const widthParent = parentRef.nativeElement.offsetWidth / 2;\n        const heightParent = parentRef.nativeElement.offsetHeight / 2;\n        const isParentLonger = widthParent >= this.elementRef.nativeElement.offsetWidth;\n        const isParentHigher = heightParent >= this.elementRef.nativeElement.offsetHeight;\n        // Если середина родителя оказывается меньше тултипа - берем середину родителя иначе размер тултипа\n        // Это проверка на максимальное смещение, смещение стрелки не должно быть больше размера тултипа\n        const width = isParentLonger ? this.elementRef.nativeElement.offsetWidth : widthParent;\n        const height = isParentHigher ? this.elementRef.nativeElement.offsetHeight : heightParent;\n\n        const positionArrow = (size: number, isParentBigger: boolean): number =>\n            // Если середина родителя больше тултипа\n            // То берем размер тултипа и отнимаем размер стрелки и радиуса\n            // Иначе берем середину родителя и отнимаем половину стрелки\n            // Это условие нужно чтобы стрелка не смещалась\n            isParentBigger ? size - EVO_TOOLTIP_ARROW_SIZE - EVO_TOOLTIP_RADIUS : size - EVO_TOOLTIP_ARROW_SIZE / 2;\n        let verticalPositionArrow = positionArrow(height, isParentHigher);\n        let horizontalPositionArrow = positionArrow(width, isParentLonger);\n\n        // Проверка на минимальное смещение, смещение стрелки не должно быть меньше размера радиуса тултипа 8px\n        horizontalPositionArrow =\n            horizontalPositionArrow > EVO_TOOLTIP_RADIUS ? horizontalPositionArrow : EVO_TOOLTIP_RADIUS;\n        verticalPositionArrow = verticalPositionArrow > EVO_TOOLTIP_RADIUS ? verticalPositionArrow : EVO_TOOLTIP_RADIUS;\n\n        this._positionArrowStyles$.next({\n            [EvoTooltipVariableArrowPosition.VERTICAL_POSITION_ARROW]: `${verticalPositionArrow}px`,\n            [EvoTooltipVariableArrowPosition.HORIZONTAL_POSITION_ARROW]: `${horizontalPositionArrow}px`,\n        });\n    }\n}\n","<ng-container\n    *ngIf=\"{position: position$ | async, styles: styles$ | async, visibleArrow: visibleArrow$ | async} as asyncData\"\n>\n    <div\n        class=\"evo-tooltip\"\n        [class]=\"'evo-tooltip_' + asyncData.position\"\n        [class.evo-tooltip_not-arrow]=\"!asyncData.visibleArrow\"\n        [style]=\"asyncData.styles\"\n    >\n        <ng-container *ngIf=\"stringContent$ | async as content; else templateRef\">{{ content }}</ng-container>\n    </div>\n</ng-container>\n\n<ng-template #templateRef>\n    <ng-container *ngIf=\"templateContent$ | async as content\" [ngTemplateOutlet]=\"content\"></ng-container>\n</ng-template>\n"]}

package/esm2015/lib/components/evo-tooltip/evo-tooltip.module.js

@@ -0,0 +1,20 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { EvoTooltipComponent } from './evo-tooltip.component';
+import { EvoTooltipDirective } from './directives/evo-tooltip.directive';
+import { OverlayModule } from '@angular/cdk/overlay';
+import * as i0 from "@angular/core";
+export class EvoTooltipModule {
+}
+EvoTooltipModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: EvoTooltipModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+EvoTooltipModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: EvoTooltipModule, declarations: [EvoTooltipComponent, EvoTooltipDirective], imports: [OverlayModule, CommonModule], exports: [EvoTooltipDirective] });
+EvoTooltipModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: EvoTooltipModule, imports: [[OverlayModule, CommonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: EvoTooltipModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [OverlayModule, CommonModule],
+                    declarations: [EvoTooltipComponent, EvoTooltipDirective],
+                    exports: [EvoTooltipDirective],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZvLXRvb2x0aXAubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZXZvLXVpLWtpdC9zcmMvbGliL2NvbXBvbmVudHMvZXZvLXRvb2x0aXAvZXZvLXRvb2x0aXAubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxRQUFRLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFDdkMsT0FBTyxFQUFDLFlBQVksRUFBQyxNQUFNLGlCQUFpQixDQUFDO0FBQzdDLE9BQU8sRUFBQyxtQkFBbUIsRUFBQyxNQUFNLHlCQUF5QixDQUFDO0FBQzVELE9BQU8sRUFBQyxtQkFBbUIsRUFBQyxNQUFNLG9DQUFvQyxDQUFDO0FBQ3ZFLE9BQU8sRUFBQyxhQUFhLEVBQUMsTUFBTSxzQkFBc0IsQ0FBQzs7QUFPbkQsTUFBTSxPQUFPLGdCQUFnQjs7OEdBQWhCLGdCQUFnQjsrR0FBaEIsZ0JBQWdCLGlCQUhWLG1CQUFtQixFQUFFLG1CQUFtQixhQUQ3QyxhQUFhLEVBQUUsWUFBWSxhQUUzQixtQkFBbUI7K0dBRXBCLGdCQUFnQixZQUpoQixDQUFDLGFBQWEsRUFBRSxZQUFZLENBQUM7NEZBSTdCLGdCQUFnQjtrQkFMNUIsUUFBUTttQkFBQztvQkFDTixPQUFPLEVBQUUsQ0FBQyxhQUFhLEVBQUUsWUFBWSxDQUFDO29CQUN0QyxZQUFZLEVBQUUsQ0FBQyxtQkFBbUIsRUFBRSxtQkFBbUIsQ0FBQztvQkFDeEQsT0FBTyxFQUFFLENBQUMsbUJBQW1CLENBQUM7aUJBQ2pDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtOZ01vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge0NvbW1vbk1vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7RXZvVG9vbHRpcENvbXBvbmVudH0gZnJvbSAnLi9ldm8tdG9vbHRpcC5jb21wb25lbnQnO1xuaW1wb3J0IHtFdm9Ub29sdGlwRGlyZWN0aXZlfSBmcm9tICcuL2RpcmVjdGl2ZXMvZXZvLXRvb2x0aXAuZGlyZWN0aXZlJztcbmltcG9ydCB7T3ZlcmxheU1vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvY2RrL292ZXJsYXknO1xuXG5ATmdNb2R1bGUoe1xuICAgIGltcG9ydHM6IFtPdmVybGF5TW9kdWxlLCBDb21tb25Nb2R1bGVdLFxuICAgIGRlY2xhcmF0aW9uczogW0V2b1Rvb2x0aXBDb21wb25lbnQsIEV2b1Rvb2x0aXBEaXJlY3RpdmVdLFxuICAgIGV4cG9ydHM6IFtFdm9Ub29sdGlwRGlyZWN0aXZlXSxcbn0pXG5leHBvcnQgY2xhc3MgRXZvVG9vbHRpcE1vZHVsZSB7fVxuIl19

package/esm2015/lib/components/evo-tooltip/index.js

@@ -0,0 +1,2 @@
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9ldm8tdWkta2l0L3NyYy9saWIvY29tcG9uZW50cy9ldm8tdG9vbHRpcC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=

package/esm2015/lib/components/evo-tooltip/interfaces/evo-tooltip-config.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZvLXRvb2x0aXAtY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZXZvLXVpLWtpdC9zcmMvbGliL2NvbXBvbmVudHMvZXZvLXRvb2x0aXAvaW50ZXJmYWNlcy9ldm8tdG9vbHRpcC1jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgRXZvVG9vbHRpcENvbmZpZyB7XG4gICAgLy8gVGhlIGRlZmF1bHQgZGVsYXkgaW4gbXMgYmVmb3JlIGhpZGluZyB0aGUgdG9vbHRpcFxuICAgIGhpZGVEZWxheT86IG51bWJlcjtcbiAgICBzaG93RGVsYXk/OiBudW1iZXI7XG59XG4iXX0=

package/esm2015/lib/components/evo-tooltip/interfaces/evo-tooltip-styles.js

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

package/esm2015/lib/components/evo-tooltip/public-api.js

@@ -0,0 +1,3 @@
+export * from './evo-tooltip.module';
+export * from './directives/evo-tooltip.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2V2by11aS1raXQvc3JjL2xpYi9jb21wb25lbnRzL2V2by10b29sdGlwL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLG9DQUFvQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9ldm8tdG9vbHRpcC5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9kaXJlY3RpdmVzL2V2by10b29sdGlwLmRpcmVjdGl2ZSc7XG4iXX0=

package/esm2015/lib/components/evo-tooltip/services/evo-tooltip.service.js

@@ -0,0 +1,180 @@
+import { Injectable, TemplateRef } from '@angular/core';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { BehaviorSubject, EMPTY, fromEvent, merge, Subject } from 'rxjs';
+import { catchError, debounceTime, filter, first, map } from 'rxjs/operators';
+import { EVO_TOOLTIP_CONFIG } from '../constants/evo-tooltip-config';
+import { EvoTooltipComponent } from '../evo-tooltip.component';
+import { EvoTooltipPosition } from '../enums/evo-tooltip-position';
+import { EVO_CONNECTED_POSITION } from '../constants/evo-tooltip-connected-position';
+import { EVO_PRIORITY_POSITIONS_ORDER } from '../constants/evo-tooltip-priority-positions-order';
+import { EVO_DEFAULT_POSITIONS_ORDER } from '../constants/evo-tooltip-default-positions-order';
+import { EVO_TOOLTIP_ARROW_SIZE } from '../constants/evo-tooltip-arrow-size';
+import { EVO_TOOLTIP_RADIUS } from '../constants/evo-tooltip-radius';
+import { EVO_TOOLTIP_OFFSET } from '../constants/evo-tooltip-offset';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+export class EvoTooltipService {
+    constructor(overlay, overlayPositionBuilder, injector) {
+        this.overlay = overlay;
+        this.overlayPositionBuilder = overlayPositionBuilder;
+        this.injector = injector;
+        this.stringContent$ = EMPTY;
+        this.templateContent$ = EMPTY;
+        this.position$ = EMPTY;
+        this.parentRef$ = EMPTY;
+        this.tooltipClasses$ = EMPTY;
+        this.styles$ = EMPTY;
+        this.visibleArrow$ = EMPTY;
+        this.isOpen$ = EMPTY;
+        this._stringContent$ = new BehaviorSubject(null);
+        this._templateContent$ = new BehaviorSubject(null);
+        this._position$ = new BehaviorSubject(EvoTooltipPosition.BOTTOM);
+        this._parentRef$ = new BehaviorSubject(null);
+        this._tooltipClasses$ = new BehaviorSubject([]);
+        this._config$ = new BehaviorSubject(EVO_TOOLTIP_CONFIG);
+        this._styles$ = new BehaviorSubject(null);
+        this._visibleArrow$ = new BehaviorSubject(true);
+        this._isOpen$ = new Subject();
+        this.stringContent$ = this._stringContent$.asObservable();
+        this.templateContent$ = this._templateContent$.asObservable();
+        this.position$ = this._position$.asObservable();
+        this.parentRef$ = this._parentRef$.asObservable();
+        this.tooltipClasses$ = this._tooltipClasses$.asObservable();
+        this.styles$ = this._styles$.asObservable();
+        this.visibleArrow$ = this._visibleArrow$.asObservable();
+        this.isOpen$ = this._isOpen$.asObservable();
+    }
+    showTooltip(parentRef, content, position, config, targetElement) {
+        this._parentRef$.next(parentRef);
+        this.targetElement = targetElement !== null && targetElement !== void 0 ? targetElement : null;
+        this.setContent(content);
+        this._position$.next(position);
+        this._config$.next(config);
+        this.createOverlay(parentRef, position);
+        this.createPortal();
+        this._isOpen$.next(this.overlayRef.hasAttached());
+        this.initSubscriptions();
+    }
+    hideTooltip() {
+        var _a, _b;
+        if (this.tooltipComponentRef) {
+            this.tooltipComponentRef.destroy();
+            this.tooltipComponentRef = null;
+        }
+        (_a = this.overlayRef) === null || _a === void 0 ? void 0 : _a.detach();
+        this._isOpen$.next(!!((_b = this.overlayRef) === null || _b === void 0 ? void 0 : _b.hasAttached()));
+    }
+    setArrowVisibility(hasArrow) {
+        this._visibleArrow$.next(hasArrow);
+    }
+    setTooltipStyles(tooltipStyles) {
+        this._styles$.next(tooltipStyles);
+    }
+    setTooltipClass(tooltipClassOrClasses) {
+        this._tooltipClasses$.next(!tooltipClassOrClasses
+            ? []
+            : Array.isArray(tooltipClassOrClasses)
+                ? tooltipClassOrClasses
+                : [tooltipClassOrClasses]);
+    }
+    get hasAttached() {
+        var _a, _b;
+        return (_b = (_a = this.overlayRef) === null || _a === void 0 ? void 0 : _a.hasAttached()) !== null && _b !== void 0 ? _b : false;
+    }
+    get config() {
+        return this._config$.value;
+    }
+    get parentRef() {
+        return this._parentRef$.value;
+    }
+    setContent(content) {
+        if (typeof content === 'string') {
+            this._stringContent$.next(content);
+        }
+        else if (content instanceof TemplateRef) {
+            this._templateContent$.next(content);
+        }
+    }
+    createOverlay(elementRef, position) {
+        this.positionStrategy = this.overlayPositionBuilder
+            .flexibleConnectedTo(elementRef)
+            .withPositions(this.getPositions(position));
+        const scrollStrategy = this.overlay.scrollStrategies.reposition();
+        this.overlayRef = this.overlay.create({ positionStrategy: this.positionStrategy, scrollStrategy });
+    }
+    createPortal() {
+        const tooltipPortal = new ComponentPortal(EvoTooltipComponent, null, this.injector);
+        this.tooltipComponentRef = this.overlayRef.attach(tooltipPortal);
+    }
+    initSubscriptions() {
+        var _a, _b, _c;
+        const parentElement = this.targetElement ? this.targetElement : (_a = this.parentRef) === null || _a === void 0 ? void 0 : _a.nativeElement;
+        const overlayElement = this.overlayRef.overlayElement;
+        const mouseLeaveParentElement$ = fromEvent(parentElement, 'mouseleave').pipe(map(() => overlayElement));
+        const mouseLeaveOverlayElement$ = fromEvent(overlayElement, 'mouseleave').pipe(map(() => parentElement));
+        merge(mouseLeaveParentElement$, mouseLeaveOverlayElement$)
+            .pipe(filter((element) => !element.matches(':hover')), debounceTime((_c = (_b = this.config) === null || _b === void 0 ? void 0 : _b.hideDelay) !== null && _c !== void 0 ? _c : EVO_TOOLTIP_CONFIG.hideDelay), filter(() => !parentElement.matches(':hover') && !overlayElement.matches(':hover')), first(), catchError(() => {
+            this.hideTooltip();
+            return EMPTY;
+        }))
+            .subscribe(() => {
+            this.hideTooltip();
+        });
+        this.positionStrategy.positionChanges.subscribe((value) => {
+            this._position$.next(value.connectionPair.panelClass);
+        });
+    }
+    getPositions(position) {
+        return this.getPositionsOrder(position).map((key) => {
+            const offset = EVO_TOOLTIP_OFFSET(this._visibleArrow$.value);
+            const position = Object.assign({}, EVO_CONNECTED_POSITION(offset)[key]);
+            const width = this.parentRef.nativeElement.offsetWidth;
+            const height = this.parentRef.nativeElement.offsetHeight;
+            const maxSize = EVO_TOOLTIP_ARROW_SIZE + EVO_TOOLTIP_RADIUS * 2;
+            // Добавляем смещение тултипа для мелких обьектов
+            if (width <= maxSize) {
+                switch (key) {
+                    case EvoTooltipPosition.BOTTOM_START:
+                    case EvoTooltipPosition.TOP_START:
+                        position.offsetX = -(maxSize - width) / 2;
+                        break;
+                    case EvoTooltipPosition.BOTTOM_END:
+                    case EvoTooltipPosition.TOP_END:
+                        position.offsetX = (maxSize - width) / 2;
+                        break;
+                }
+            }
+            // Добавляем смещение тултипа для мелких обьектов
+            if (height <= maxSize) {
+                switch (key) {
+                    case EvoTooltipPosition.LEFT_START:
+                    case EvoTooltipPosition.RIGHT_START:
+                        position.offsetY = -(maxSize - height) / 2;
+                        break;
+                    case EvoTooltipPosition.LEFT_END:
+                    case EvoTooltipPosition.RIGHT_END:
+                        position.offsetY = (maxSize - height) / 2;
+                        break;
+                }
+            }
+            return position;
+        });
+    }
+    getPositionsOrder(position) {
+        const priorityPositions = EVO_PRIORITY_POSITIONS_ORDER[position];
+        if (priorityPositions) {
+            return [
+                ...priorityPositions,
+                ...EVO_DEFAULT_POSITIONS_ORDER.filter((defaultPosition) => !priorityPositions.includes(defaultPosition)),
+            ];
+        }
+        const indexPositionKey = EVO_DEFAULT_POSITIONS_ORDER.indexOf(position);
+        return EVO_DEFAULT_POSITIONS_ORDER.slice(indexPositionKey).concat(EVO_DEFAULT_POSITIONS_ORDER.slice(0, indexPositionKey));
+    }
+}
+EvoTooltipService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: EvoTooltipService, deps: [{ token: i1.Overlay }, { token: i1.OverlayPositionBuilder }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+EvoTooltipService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: EvoTooltipService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: EvoTooltipService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Overlay }, { type: i1.OverlayPositionBuilder }, { type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"evo-tooltip.service.js","sourceRoot":"","sources":["../../../../../../../projects/evo-ui-kit/src/lib/components/evo-tooltip/services/evo-tooltip.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {ComponentRef, ElementRef, Injectable, Injector, TemplateRef} from '@angular/core';\nimport {ComponentPortal} from '@angular/cdk/portal';\nimport {\n    ConnectedPosition,\n    FlexibleConnectedPositionStrategy,\n    Overlay,\n    OverlayPositionBuilder,\n    OverlayRef,\n} from '@angular/cdk/overlay';\nimport {BehaviorSubject, EMPTY, fromEvent, merge, Observable, Subject} from 'rxjs';\nimport {catchError, debounceTime, filter, first, map} from 'rxjs/operators';\nimport {EvoTooltipConfig} from '../interfaces/evo-tooltip-config';\nimport {EVO_TOOLTIP_CONFIG} from '../constants/evo-tooltip-config';\nimport {EvoTooltipComponent} from '../evo-tooltip.component';\nimport {EvoTooltipPosition} from '../enums/evo-tooltip-position';\nimport {EVO_CONNECTED_POSITION} from '../constants/evo-tooltip-connected-position';\nimport {EVO_PRIORITY_POSITIONS_ORDER} from '../constants/evo-tooltip-priority-positions-order';\nimport {EVO_DEFAULT_POSITIONS_ORDER} from '../constants/evo-tooltip-default-positions-order';\nimport {EVO_TOOLTIP_ARROW_SIZE} from '../constants/evo-tooltip-arrow-size';\nimport {EVO_TOOLTIP_RADIUS} from '../constants/evo-tooltip-radius';\nimport {EvoTooltipStyles} from '../interfaces/evo-tooltip-styles';\nimport {EVO_TOOLTIP_OFFSET} from '../constants/evo-tooltip-offset';\n\n@Injectable()\nexport class EvoTooltipService {\n    readonly stringContent$: Observable<string | null> = EMPTY;\n    readonly templateContent$: Observable<TemplateRef<HTMLElement> | null> = EMPTY;\n    readonly position$: Observable<EvoTooltipPosition> = EMPTY;\n    readonly parentRef$: Observable<ElementRef> = EMPTY;\n    readonly tooltipClasses$: Observable<string[]> = EMPTY;\n    readonly styles$: Observable<EvoTooltipStyles> = EMPTY;\n    readonly visibleArrow$: Observable<boolean> = EMPTY;\n    readonly isOpen$: Observable<boolean> = EMPTY;\n\n    private readonly _stringContent$ = new BehaviorSubject<string | null>(null);\n    private readonly _templateContent$ = new BehaviorSubject<TemplateRef<HTMLElement> | null>(null);\n    private readonly _position$ = new BehaviorSubject<EvoTooltipPosition>(EvoTooltipPosition.BOTTOM);\n    private readonly _parentRef$ = new BehaviorSubject<ElementRef>(null);\n    private readonly _tooltipClasses$ = new BehaviorSubject<string[]>([]);\n    private readonly _config$ = new BehaviorSubject<EvoTooltipConfig>(EVO_TOOLTIP_CONFIG);\n    private readonly _styles$ = new BehaviorSubject<EvoTooltipStyles>(null);\n    private readonly _visibleArrow$ = new BehaviorSubject<boolean>(true);\n    private readonly _isOpen$ = new Subject<boolean>();\n\n    private overlayRef: OverlayRef;\n    private positionStrategy: FlexibleConnectedPositionStrategy;\n    private tooltipComponentRef: ComponentRef<EvoTooltipComponent> | null;\n    private targetElement: EventTarget | null;\n\n    constructor(\n        private readonly overlay: Overlay,\n        private readonly overlayPositionBuilder: OverlayPositionBuilder,\n        private readonly injector: Injector,\n    ) {\n        this.stringContent$ = this._stringContent$.asObservable();\n        this.templateContent$ = this._templateContent$.asObservable();\n        this.position$ = this._position$.asObservable();\n        this.parentRef$ = this._parentRef$.asObservable();\n        this.tooltipClasses$ = this._tooltipClasses$.asObservable();\n        this.styles$ = this._styles$.asObservable();\n        this.visibleArrow$ = this._visibleArrow$.asObservable();\n        this.isOpen$ = this._isOpen$.asObservable();\n    }\n\n    showTooltip(\n        parentRef: ElementRef,\n        content: string | TemplateRef<HTMLElement>,\n        position: EvoTooltipPosition,\n        config: EvoTooltipConfig,\n        targetElement?: EventTarget | null,\n    ): void {\n        this._parentRef$.next(parentRef);\n        this.targetElement = targetElement ?? null;\n\n        this.setContent(content);\n        this._position$.next(position);\n        this._config$.next(config);\n        this.createOverlay(parentRef, position);\n        this.createPortal();\n\n        this._isOpen$.next(this.overlayRef.hasAttached());\n        this.initSubscriptions();\n    }\n\n    hideTooltip(): void {\n        if (this.tooltipComponentRef) {\n            this.tooltipComponentRef.destroy();\n            this.tooltipComponentRef = null;\n        }\n\n        this.overlayRef?.detach();\n        this._isOpen$.next(!!this.overlayRef?.hasAttached());\n    }\n\n    setArrowVisibility(hasArrow: boolean): void {\n        this._visibleArrow$.next(hasArrow);\n    }\n\n    setTooltipStyles(tooltipStyles: EvoTooltipStyles): void {\n        this._styles$.next(tooltipStyles);\n    }\n\n    setTooltipClass(tooltipClassOrClasses: string | string[]): void {\n        this._tooltipClasses$.next(\n            !tooltipClassOrClasses\n                ? []\n                : Array.isArray(tooltipClassOrClasses)\n                ? tooltipClassOrClasses\n                : [tooltipClassOrClasses],\n        );\n    }\n\n    get hasAttached(): boolean {\n        return this.overlayRef?.hasAttached() ?? false;\n    }\n\n    get config(): EvoTooltipConfig {\n        return this._config$.value;\n    }\n\n    private get parentRef(): ElementRef {\n        return this._parentRef$.value;\n    }\n\n    private setContent(content: string | TemplateRef<HTMLElement> | undefined): void {\n        if (typeof content === 'string') {\n            this._stringContent$.next(content);\n        } else if (content instanceof TemplateRef) {\n            this._templateContent$.next(content);\n        }\n    }\n\n    private createOverlay(elementRef: ElementRef, position: EvoTooltipPosition): void {\n        this.positionStrategy = this.overlayPositionBuilder\n            .flexibleConnectedTo(elementRef)\n            .withPositions(this.getPositions(position));\n\n        const scrollStrategy = this.overlay.scrollStrategies.reposition();\n        this.overlayRef = this.overlay.create({positionStrategy: this.positionStrategy, scrollStrategy});\n    }\n\n    private createPortal(): void {\n        const tooltipPortal = new ComponentPortal(EvoTooltipComponent, null, this.injector);\n        this.tooltipComponentRef = this.overlayRef.attach(tooltipPortal);\n    }\n\n    private initSubscriptions(): void {\n        const parentElement = this.targetElement ? this.targetElement : this.parentRef?.nativeElement;\n        const overlayElement = this.overlayRef.overlayElement;\n\n        const mouseLeaveParentElement$ = fromEvent(parentElement, 'mouseleave').pipe(map(() => overlayElement));\n        const mouseLeaveOverlayElement$ = fromEvent(overlayElement, 'mouseleave').pipe(map(() => parentElement));\n\n        merge(mouseLeaveParentElement$, mouseLeaveOverlayElement$)\n            .pipe(\n                filter((element) => !element.matches(':hover')),\n                debounceTime(this.config?.hideDelay ?? EVO_TOOLTIP_CONFIG.hideDelay),\n                filter(() => !parentElement.matches(':hover') && !overlayElement.matches(':hover')),\n                first(),\n                catchError(() => {\n                    this.hideTooltip();\n                    return EMPTY;\n                }),\n            )\n            .subscribe(() => {\n                this.hideTooltip();\n            });\n\n        this.positionStrategy.positionChanges.subscribe((value) => {\n            this._position$.next(value.connectionPair.panelClass as EvoTooltipPosition);\n        });\n    }\n\n    private getPositions(position: EvoTooltipPosition): ConnectedPosition[] {\n        return this.getPositionsOrder(position).map((key) => {\n            const offset = EVO_TOOLTIP_OFFSET(this._visibleArrow$.value);\n            const position = {...EVO_CONNECTED_POSITION(offset)[key]};\n            const width = this.parentRef.nativeElement.offsetWidth;\n            const height = this.parentRef.nativeElement.offsetHeight;\n            const maxSize = EVO_TOOLTIP_ARROW_SIZE + EVO_TOOLTIP_RADIUS * 2;\n\n            // Добавляем смещение тултипа для мелких обьектов\n            if (width <= maxSize) {\n                switch (key) {\n                    case EvoTooltipPosition.BOTTOM_START:\n                    case EvoTooltipPosition.TOP_START:\n                        position.offsetX = -(maxSize - width) / 2;\n                        break;\n                    case EvoTooltipPosition.BOTTOM_END:\n                    case EvoTooltipPosition.TOP_END:\n                        position.offsetX = (maxSize - width) / 2;\n                        break;\n                }\n            }\n\n            // Добавляем смещение тултипа для мелких обьектов\n            if (height <= maxSize) {\n                switch (key) {\n                    case EvoTooltipPosition.LEFT_START:\n                    case EvoTooltipPosition.RIGHT_START:\n                        position.offsetY = -(maxSize - height) / 2;\n                        break;\n                    case EvoTooltipPosition.LEFT_END:\n                    case EvoTooltipPosition.RIGHT_END:\n                        position.offsetY = (maxSize - height) / 2;\n                        break;\n                }\n            }\n\n            return position;\n        });\n    }\n\n    private getPositionsOrder(position: EvoTooltipPosition): EvoTooltipPosition[] {\n        const priorityPositions = EVO_PRIORITY_POSITIONS_ORDER[position];\n\n        if (priorityPositions) {\n            return [\n                ...priorityPositions,\n                ...EVO_DEFAULT_POSITIONS_ORDER.filter(\n                    (defaultPosition) => !priorityPositions.includes(defaultPosition),\n                ),\n            ];\n        }\n\n        const indexPositionKey: number = EVO_DEFAULT_POSITIONS_ORDER.indexOf(position);\n        return EVO_DEFAULT_POSITIONS_ORDER.slice(indexPositionKey).concat(\n            EVO_DEFAULT_POSITIONS_ORDER.slice(0, indexPositionKey),\n        );\n    }\n}\n"]}

package/esm2015/lib/components/evo-tooltip/types/evo-tooltip-position-type.js

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

package/esm2015/lib/services/mutation-observer.service.js

@@ -0,0 +1,59 @@
+import { ElementRef, inject, Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Безопасная обёртка над `MutationObserver`, которая гарантирует,
+ * что код не упадёт в средах, где `MutationObserver` недоступен
+ * (например, серверный рендеринг или тесты без DOM).
+ *
+ * Если `MutationObserver` существует — используется он.
+ * Если нет — используется заглушка с пустыми методами.
+ */
+export const SafeObserver = typeof MutationObserver !== 'undefined'
+    ? MutationObserver
+    : class {
+        observe() { }
+        disconnect() { }
+        takeRecords() {
+            return [];
+        }
+    };
+/**
+ * Сервис `MutationObserverService` предоставляет поток `Observable<MutationRecord[]>`,
+ * который эмитит записи изменений DOM для текущего элемента (`ElementRef`).
+ *
+ * Наблюдает за изменениями потомков, текстового содержимого и вложенных структур (`subtree: true`).
+ *
+ * Используется `SafeObserver`, чтобы гарантировать совместимость с SSR и тестовой средой.
+ *
+ * ⚠️ Важно: требует, чтобы `ElementRef` был доступен через DI-контекст (т.е. работает в компонентах/директивах).
+ *
+ * @example
+ * this.mutationObserverService.subscribe(records => {
+ *   console.log('Mutation detected!', records);
+ * });
+ */
+export class MutationObserverService extends Observable {
+    constructor() {
+        const nativeElement = inject(ElementRef).nativeElement;
+        super((subscriber) => {
+            const observer = new SafeObserver((records) => {
+                subscriber.next(records);
+            });
+            observer.observe(nativeElement, {
+                childList: true,
+                characterData: true,
+                subtree: true,
+            });
+            return () => {
+                observer.disconnect();
+            };
+        });
+    }
+}
+MutationObserverService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MutationObserverService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+MutationObserverService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MutationObserverService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MutationObserverService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/router-link-active.service.js

@@ -0,0 +1,41 @@
+import { Inject, Injectable, NgZone, Optional } from '@angular/core';
+import { RouterLinkActive } from '@angular/router';
+import { EMPTY, merge, Observable, timer } from 'rxjs';
+import { distinctUntilChanged, map } from 'rxjs/operators';
+import { ANIMATION_FRAME } from '../utils/tokens/animation-frame';
+import { evoZoneOptimized } from '../utils/observables/zone-free';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "rxjs";
+/**
+ * Сервис создает поток, отслеживающий состояние активности
+ * `RouterLinkActive` в реальном времени с использованием `requestAnimationFrame`.
+ *
+ * Наследуется от `Observable<boolean>` и эмитит `true` или `false`, когда состояние `isActive`
+ * меняется. Если `RouterLinkActive` не передан — поток будет пустым (`EMPTY`).
+ */
+export class RouterLinkActiveService extends Observable {
+    constructor(routerLinkActive, ngZone, animationFrame$) {
+        const stream$ = routerLinkActive
+            ? merge(timer(0), animationFrame$).pipe(map(() => routerLinkActive.isActive), distinctUntilChanged(), evoZoneOptimized(ngZone))
+            : EMPTY;
+        super((subscriber) => stream$.subscribe(subscriber));
+    }
+}
+RouterLinkActiveService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RouterLinkActiveService, deps: [{ token: RouterLinkActive, optional: true }, { token: NgZone }, { token: ANIMATION_FRAME }], target: i0.ɵɵFactoryTarget.Injectable });
+RouterLinkActiveService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RouterLinkActiveService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RouterLinkActiveService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.RouterLinkActive, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [RouterLinkActive]
+                }] }, { type: i0.NgZone, decorators: [{
+                    type: Inject,
+                    args: [NgZone]
+                }] }, { type: i2.Observable, decorators: [{
+                    type: Inject,
+                    args: [ANIMATION_FRAME]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/utils/observables/zone-free.js

@@ -0,0 +1,64 @@
+import { Observable, pipe } from 'rxjs';
+/**
+ * Кратко:
+ * 🔥 evoZonefull — тащит всё в Angular-зону.
+ * 🧊 evoZonefree — игнорирует Angular-зону, экономит CD.
+ * ⚖️ evoZoneOptimized — как утро с кофе: просыпаешься вовремя и не дергаешь лишний раз change detection.
+ */
+/**
+ * Оператор `evoZonefull` обеспечивает полное выполнение потока внутри зоны Angular.
+ *
+ * Все `next`, `error` и `complete` вызовы оборачиваются в `NgZone.run`, чтобы гарантировать
+ * корректный запуск change detection.
+ *
+ * Используй, если поток формируется вне зоны или ты не уверен, что Angular узнает об изменениях.
+ *
+ * @param zone Сервис `NgZone` из Angular DI.
+ * @returns Оператор, оборачивающий поток в `NgZone.run()`.
+ *
+ * @example
+ * source$.pipe(evoZonefull(this.ngZone)).subscribe(...);
+ */
+export function evoZonefull(zone) {
+    return (source) => new Observable((subscriber) => source.subscribe({
+        next: (value) => zone.run(() => subscriber.next(value)),
+        error: (error) => zone.run(() => subscriber.error(error)),
+        complete: () => zone.run(() => subscriber.complete()),
+    }));
+}
+/**
+ * Оператор `evoZonefree` исполняет весь поток вне зоны Angular.
+ *
+ * Это помогает избежать лишних срабатываний change detection и повысить производительность,
+ * особенно для часто испускаемых потоков (например, `scroll`, `animationFrame`, таймеры).
+ *
+ * Используй, если тебе не нужно обновлять Angular view внутри этого потока.
+ *
+ * @param zone Сервис `NgZone` из Angular DI.
+ * @returns Оператор, исполняющий подписку вне Angular-зоны.
+ *
+ * @example
+ * source$.pipe(evoZonefree(this.ngZone)).subscribe(...);
+ */
+export function evoZonefree(zone) {
+    return (source) => new Observable((subscriber) => zone.runOutsideAngular(() => source.subscribe(subscriber)));
+}
+/**
+ * Оператор `evoZoneOptimized` — комбо из `evoZonefree` и `evoZonefull`.
+ *
+ * Сначала поток исполняется вне Angular-зоны (`runOutsideAngular`), чтобы избежать лишнего
+ * change detection. Но события `next`, `error` и `complete` всё равно возвращаются в Angular-зону.
+ *
+ * Это идеальный баланс, если тебе нужен быстрый поток без лишнего CD, но ты всё равно хочешь,
+ * чтобы Angular знал о результатах.
+ *
+ * @param zone Сервис `NgZone` из Angular DI.
+ * @returns Оператор, оптимизированный по производительности.
+ *
+ * @example
+ * source$.pipe(evoZoneOptimized(this.ngZone)).subscribe(...);
+ */
+export function evoZoneOptimized(zone) {
+    return pipe(evoZonefree(zone), evoZonefull(zone));
+}
+//# sourceMappingURL=data:application/json;base64,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