@agorapulse/ui-components 0.0.3 → 1.0.0-SNAPSHOT

package/esm2022/tooltip/tooltip.directive.mjs

@@ -0,0 +1,412 @@
+import { DestroyRef, Directive, ElementRef, Input, NgZone, TemplateRef, ViewContainerRef, inject, } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import DOMPurify from 'dompurify';
+import { TooltipService } from './tooltip.service';
+import * as i0 from "@angular/core";
+export class TooltipDirective {
+    elementRef = inject(ElementRef);
+    zone = inject(NgZone);
+    viewContainerRef = inject(ViewContainerRef);
+    destroyRef = inject(DestroyRef);
+    apTooltipPosition = 'top';
+    content;
+    apTooltipShowDelay = 80;
+    apTooltipHideDelay;
+    apTooltipDuration;
+    apTooltipDisabled;
+    apTooltipTemplateContext;
+    apTooltipVirtualScrollElement;
+    clickListener = undefined;
+    container = undefined;
+    hideTimeout;
+    mouseEnterListener = undefined;
+    mouseLeaveListener = undefined;
+    nativeElement = this.elementRef.nativeElement;
+    showTimeout;
+    tooltipText;
+    ngOnInit() {
+        if (this.apTooltipVirtualScrollElement) {
+            this.apTooltipVirtualScrollElement.renderedRangeStream.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(range => {
+                if (range.start === 0 && range.end === 0) {
+                    this.deactivate();
+                }
+            });
+        }
+    }
+    ngAfterViewInit() {
+        this.zone.runOutsideAngular(() => {
+            this.mouseEnterListener = this.onMouseEnter.bind(this);
+            this.mouseLeaveListener = this.onMouseLeave.bind(this);
+            this.clickListener = this.onInputClick.bind(this);
+            this.nativeElement.addEventListener('mouseenter', this.mouseEnterListener);
+            this.nativeElement.addEventListener('click', this.clickListener);
+            this.nativeElement.addEventListener('mouseleave', this.mouseLeaveListener);
+        });
+    }
+    ngOnDestroy() {
+        if (this.container) {
+            this.deactivate();
+        }
+        if (this.mouseEnterListener) {
+            this.nativeElement.removeEventListener('mouseenter', this.mouseEnterListener);
+        }
+        if (this.clickListener) {
+            this.nativeElement.removeEventListener('click', this.clickListener);
+        }
+        if (this.mouseLeaveListener) {
+            this.nativeElement.removeEventListener('mouseleave', this.mouseLeaveListener);
+        }
+        this.mouseEnterListener = undefined;
+        this.mouseLeaveListener = undefined;
+        this.clickListener = undefined;
+    }
+    onMouseEnter() {
+        if (!this.container) {
+            this.activate();
+        }
+    }
+    onMouseLeave() {
+        this.deactivate();
+    }
+    onInputClick() {
+        this.deactivate();
+    }
+    activate() {
+        this.clearHideTimeout();
+        if (this.apTooltipShowDelay) {
+            this.showTimeout = window.setTimeout(() => {
+                this.show();
+            }, this.apTooltipShowDelay);
+        }
+        else {
+            this.show();
+        }
+        if (this.apTooltipDuration) {
+            const duration = this.apTooltipShowDelay ? this.apTooltipDuration + this.apTooltipShowDelay : this.apTooltipDuration;
+            this.hideTimeout = window.setTimeout(() => {
+                this.remove();
+            }, duration);
+        }
+    }
+    deactivate() {
+        this.clearShowTimeout();
+        if (this.apTooltipHideDelay) {
+            this.clearHideTimeout();
+            this.hideTimeout = window.setTimeout(() => {
+                this.remove();
+            }, this.apTooltipHideDelay);
+        }
+        else {
+            this.remove();
+        }
+    }
+    show() {
+        if (!this.content || this.apTooltipDisabled) {
+            return;
+        }
+        this.create();
+        this.align();
+    }
+    create() {
+        if (this.container) {
+            this.clearHideTimeout();
+            this.remove();
+        }
+        this.container = document.createElement('div');
+        this.container.setAttribute('role', 'tooltip');
+        const contentContainer = document.createElement('div');
+        contentContainer.classList.add('ap-content-container');
+        const svgNamespace = 'http://www.w3.org/2000/svg';
+        const arrowSvg = document.createElementNS(svgNamespace, 'svg');
+        arrowSvg.classList.add('ap-tooltip-arrow');
+        arrowSvg.setAttribute('xmlns', svgNamespace);
+        arrowSvg.setAttribute('viewBox', '0 0 16 8');
+        arrowSvg.setAttribute('fill', 'none');
+        const path = document.createElementNS(svgNamespace, 'path');
+        path.setAttribute('d', 'M6.68299 1.15238C7.43705 0.492586 8.56296 0.492588 9.31701 1.15238L16 7L0 7L6.68299 1.15238Z');
+        arrowSvg.appendChild(path);
+        this.tooltipText = document.createElement('div');
+        this.tooltipText.className = 'ap-tooltip-text';
+        this.updateText();
+        contentContainer.appendChild(this.tooltipText);
+        contentContainer.appendChild(arrowSvg);
+        this.container.appendChild(contentContainer);
+        document.body.appendChild(this.container);
+        this.container.classList.add('ap-tooltip');
+        if (this.content instanceof TemplateRef) {
+            this.container.classList.add('ap-tooltip-custom-template');
+        }
+        this.setCssVariables();
+    }
+    align() {
+        switch (this.apTooltipPosition) {
+            case 'top-left':
+                this.alignTopLeft();
+                if (this.isOutOfBounds()) {
+                    this.alignBottom();
+                    if (this.isOutOfBounds()) {
+                        this.alignRight();
+                        if (this.isOutOfBounds()) {
+                            this.alignLeft();
+                        }
+                    }
+                }
+                break;
+            case 'top-right':
+                this.alignTopRight();
+                if (this.isOutOfBounds()) {
+                    this.alignBottom();
+                    if (this.isOutOfBounds()) {
+                        this.alignRight();
+                        if (this.isOutOfBounds()) {
+                            this.alignLeft();
+                        }
+                    }
+                }
+                break;
+            case 'top':
+                this.alignTop();
+                if (this.isOutOfBounds()) {
+                    this.alignBottom();
+                    if (this.isOutOfBounds()) {
+                        this.alignRight();
+                        if (this.isOutOfBounds()) {
+                            this.alignLeft();
+                        }
+                    }
+                }
+                break;
+            case 'bottom':
+                this.alignBottom();
+                if (this.isOutOfBounds()) {
+                    this.alignTop();
+                    if (this.isOutOfBounds()) {
+                        this.alignRight();
+                        if (this.isOutOfBounds()) {
+                            this.alignLeft();
+                        }
+                    }
+                }
+                break;
+            case 'bottom-left':
+                this.alignBottomLeft();
+                if (this.isOutOfBounds()) {
+                    this.alignTop();
+                    if (this.isOutOfBounds()) {
+                        this.alignRight();
+                        if (this.isOutOfBounds()) {
+                            this.alignLeft();
+                        }
+                    }
+                }
+                break;
+            case 'bottom-right':
+                this.alignBottomRight();
+                if (this.isOutOfBounds()) {
+                    this.alignTop();
+                    if (this.isOutOfBounds()) {
+                        this.alignRight();
+                        if (this.isOutOfBounds()) {
+                            this.alignLeft();
+                        }
+                    }
+                }
+                break;
+            case 'left':
+                this.alignLeft();
+                if (this.isOutOfBounds()) {
+                    this.alignRight();
+                    if (this.isOutOfBounds()) {
+                        this.alignTop();
+                        if (this.isOutOfBounds()) {
+                            this.alignBottom();
+                        }
+                    }
+                }
+                break;
+            case 'right':
+                this.alignRight();
+                if (this.isOutOfBounds()) {
+                    this.alignLeft();
+                    if (this.isOutOfBounds()) {
+                        this.alignTop();
+                        if (this.isOutOfBounds()) {
+                            this.alignBottom();
+                        }
+                    }
+                }
+                break;
+        }
+    }
+    alignRight() {
+        this.preAlign('right');
+        if (this.container) {
+            const hostOffset = this.getHostOffset();
+            const left = hostOffset.left + TooltipService.getOuterWidth(this.nativeElement) + TooltipService.defaultOffset;
+            const top = hostOffset.top + (TooltipService.getOuterHeight(this.nativeElement) - TooltipService.getOuterHeight(this.container)) / 2;
+            this.container.style.left = left + 'px';
+            this.container.style.top = top + 'px';
+        }
+    }
+    alignLeft() {
+        this.preAlign('left');
+        if (this.container) {
+            const hostOffset = this.getHostOffset();
+            const left = hostOffset.left - TooltipService.getOuterWidth(this.container) - TooltipService.defaultOffset;
+            const top = hostOffset.top + (TooltipService.getOuterHeight(this.nativeElement) - TooltipService.getOuterHeight(this.container)) / 2;
+            this.container.style.left = left + 'px';
+            this.container.style.top = top + 'px';
+        }
+    }
+    alignTop() {
+        this.preAlign('top');
+        if (this.container) {
+            const hostOffset = this.getHostOffset();
+            const left = hostOffset.left + (TooltipService.getOuterWidth(this.nativeElement) - TooltipService.getOuterWidth(this.container)) / 2;
+            const top = hostOffset.top - TooltipService.getOuterHeight(this.container) - TooltipService.defaultOffset;
+            this.container.style.left = left + 'px';
+            this.container.style.top = top + 'px';
+        }
+    }
+    alignTopLeft() {
+        this.preAlign('top-left');
+        if (this.container) {
+            const hostOffset = this.getHostOffset();
+            const left = hostOffset.left;
+            const top = hostOffset.top - TooltipService.getOuterHeight(this.container) - TooltipService.defaultOffset;
+            this.container.style.left = left + 'px';
+            this.container.style.top = top + 'px';
+        }
+    }
+    alignTopRight() {
+        this.preAlign('top-right');
+        if (this.container) {
+            const hostOffset = this.getHostOffset();
+            const left = hostOffset.left + TooltipService.getOuterWidth(this.nativeElement) - TooltipService.getOuterWidth(this.container);
+            const top = hostOffset.top - TooltipService.getOuterHeight(this.container) - TooltipService.defaultOffset;
+            this.container.style.left = left + 'px';
+            this.container.style.top = top + 'px';
+        }
+    }
+    alignBottom() {
+        this.preAlign('bottom');
+        if (this.container) {
+            const hostOffset = this.getHostOffset();
+            const left = hostOffset.left + (TooltipService.getOuterWidth(this.nativeElement) - TooltipService.getOuterWidth(this.container)) / 2;
+            const top = hostOffset.top + TooltipService.getOuterHeight(this.nativeElement) + TooltipService.defaultOffset;
+            this.container.style.left = left + 'px';
+            this.container.style.top = top + 'px';
+        }
+    }
+    alignBottomLeft() {
+        this.preAlign('bottom-left');
+        if (this.container) {
+            const hostOffset = this.getHostOffset();
+            const left = hostOffset.left;
+            const top = hostOffset.top + TooltipService.getOuterHeight(this.nativeElement) + TooltipService.defaultOffset;
+            this.container.style.left = left + 'px';
+            this.container.style.top = top + 'px';
+        }
+    }
+    alignBottomRight() {
+        this.preAlign('bottom-right');
+        if (this.container) {
+            const hostOffset = this.getHostOffset();
+            const left = hostOffset.left + (TooltipService.getOuterWidth(this.nativeElement) - TooltipService.getOuterWidth(this.container));
+            const top = hostOffset.top + TooltipService.getOuterHeight(this.nativeElement) + TooltipService.defaultOffset;
+            this.container.style.left = left + 'px';
+            this.container.style.top = top + 'px';
+        }
+    }
+    preAlign(position) {
+        if (this.container) {
+            this.container.style.left = -999 + 'px';
+            this.container.style.top = -999 + 'px';
+            const defaultClassName = 'ap-tooltip-' + position;
+            this.container.classList.add(defaultClassName);
+        }
+    }
+    getHostOffset() {
+        const offset = this.nativeElement.getBoundingClientRect();
+        const targetLeft = offset.left + TooltipService.getWindowScrollLeft();
+        const targetTop = offset.top + TooltipService.getWindowScrollTop();
+        return { left: targetLeft, top: targetTop };
+    }
+    isOutOfBounds() {
+        if (this.container) {
+            const offset = this.container.getBoundingClientRect();
+            const targetTop = offset.top;
+            const targetLeft = offset.left;
+            const width = TooltipService.getOuterWidth(this.container);
+            const height = TooltipService.getOuterHeight(this.container);
+            const viewport = TooltipService.getViewport();
+            return targetLeft + width > viewport.width || targetLeft < 0 || targetTop < 0 || targetTop + height > viewport.height;
+        }
+        else {
+            return false;
+        }
+    }
+    remove() {
+        if (this.container && this.container.parentElement) {
+            document.body.removeChild(this.container);
+        }
+        this.clearTimeouts();
+        this.container = undefined;
+    }
+    clearShowTimeout() {
+        if (this.showTimeout) {
+            clearTimeout(this.showTimeout);
+            this.showTimeout = undefined;
+        }
+    }
+    clearHideTimeout() {
+        if (this.hideTimeout) {
+            clearTimeout(this.hideTimeout);
+            this.hideTimeout = undefined;
+        }
+    }
+    clearTimeouts() {
+        this.clearShowTimeout();
+        this.clearHideTimeout();
+    }
+    updateText() {
+        if (this.content instanceof TemplateRef) {
+            const embeddedViewRef = this.viewContainerRef.createEmbeddedView(this.content);
+            embeddedViewRef.context = this.apTooltipTemplateContext;
+            embeddedViewRef.detectChanges();
+            embeddedViewRef.rootNodes.forEach(node => this.tooltipText?.appendChild(node));
+        }
+        else if (this.tooltipText) {
+            this.tooltipText.innerHTML = this.content ? DOMPurify.sanitize(this.content) : '';
+        }
+    }
+    setCssVariables() {
+        if (this.container) {
+            this.container.style.setProperty('--ap-tooltip-height', this.container.offsetHeight + 'px');
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.10", ngImport: i0, type: TooltipDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.10", type: TooltipDirective, isStandalone: true, selector: "[apTooltip]", inputs: { apTooltipPosition: "apTooltipPosition", content: ["apTooltip", "content"], apTooltipShowDelay: "apTooltipShowDelay", apTooltipHideDelay: "apTooltipHideDelay", apTooltipDuration: "apTooltipDuration", apTooltipDisabled: "apTooltipDisabled", apTooltipTemplateContext: "apTooltipTemplateContext", apTooltipVirtualScrollElement: "apTooltipVirtualScrollElement" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.10", ngImport: i0, type: TooltipDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[apTooltip]', standalone: true }]
+        }], propDecorators: { apTooltipPosition: [{
+                type: Input
+            }], content: [{
+                type: Input,
+                args: ['apTooltip']
+            }], apTooltipShowDelay: [{
+                type: Input
+            }], apTooltipHideDelay: [{
+                type: Input
+            }], apTooltipDuration: [{
+                type: Input
+            }], apTooltipDisabled: [{
+                type: Input
+            }], apTooltipTemplateContext: [{
+                type: Input
+            }], apTooltipVirtualScrollElement: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tooltip.directive.js","sourceRoot":"","sources":["../../../../libs/ui-components/tooltip/src/tooltip.directive.ts"],"names":[],"mappings":"AACA,OAAO,EAEH,UAAU,EACV,SAAS,EACT,UAAU,EACV,KAAK,EACL,MAAM,EAGN,WAAW,EACX,gBAAgB,EAChB,MAAM,GACT,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,SAAS,MAAM,WAAW,CAAC;AAClC,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;;AAGnD,MAAM,OAAO,gBAAgB;IACR,UAAU,GAAe,MAAM,CAAC,UAAU,CAAC,CAAC;IAC5C,IAAI,GAAW,MAAM,CAAC,MAAM,CAAC,CAAC;IAC9B,gBAAgB,GAAqB,MAAM,CAAC,gBAAgB,CAAC,CAAC;IAC9D,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;IAExC,iBAAiB,GASR,KAAK,CAAC;IAEJ,OAAO,CAAuD;IAEzE,kBAAkB,GAAuB,EAAE,CAAC;IAE5C,kBAAkB,CAAqB;IAEvC,iBAAiB,CAAqB;IAEtC,iBAAiB,CAAsB;IAEvC,wBAAwB,CAAkB;IAE1C,6BAA6B,CAAuC;IAE7E,aAAa,GAA6B,SAAS,CAAC;IAEpD,SAAS,GAA4B,SAAS,CAAC;IAE/C,WAAW,CAAqB;IAEhC,kBAAkB,GAA6B,SAAS,CAAC;IAEzD,kBAAkB,GAA6B,SAAS,CAAC;IAEzD,aAAa,GAAgB,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC;IAE3D,WAAW,CAAqB;IAEhC,WAAW,CAA0B;IAErC,QAAQ;QACJ,IAAI,IAAI,CAAC,6BAA6B,EAAE;YACpC,IAAI,CAAC,6BAA6B,CAAC,mBAAmB,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE;gBAC/G,IAAI,KAAK,CAAC,KAAK,KAAK,CAAC,IAAI,KAAK,CAAC,GAAG,KAAK,CAAC,EAAE;oBACtC,IAAI,CAAC,UAAU,EAAE,CAAC;iBACrB;YACL,CAAC,CAAC,CAAC;SACN;IACL,CAAC;IAED,eAAe;QACX,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAC7B,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACvD,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACvD,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAClD,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,YAAY,EAAE,IAAI,CAAC,kBAAkB,CAAC,CAAC;YAC3E,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;YACjE,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,YAAY,EAAE,IAAI,CAAC,kBAAkB,CAAC,CAAC;QAC/E,CAAC,CAAC,CAAC;IACP,CAAC;IAED,WAAW;QACP,IAAI,IAAI,CAAC,SAAS,EAAE;YAChB,IAAI,CAAC,UAAU,EAAE,CAAC;SACrB;QACD,IAAI,IAAI,CAAC,kBAAkB,EAAE;YACzB,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,YAAY,EAAE,IAAI,CAAC,kBAAkB,CAAC,CAAC;SACjF;QACD,IAAI,IAAI,CAAC,aAAa,EAAE;YACpB,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,OAAO,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;SACvE;QACD,IAAI,IAAI,CAAC,kBAAkB,EAAE;YACzB,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,YAAY,EAAE,IAAI,CAAC,kBAAkB,CAAC,CAAC;SACjF;QACD,IAAI,CAAC,kBAAkB,GAAG,SAAS,CAAC;QACpC,IAAI,CAAC,kBAAkB,GAAG,SAAS,CAAC;QACpC,IAAI,CAAC,aAAa,GAAG,SAAS,CAAC;IACnC,CAAC;IAED,YAAY;QACR,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;YACjB,IAAI,CAAC,QAAQ,EAAE,CAAC;SACnB;IACL,CAAC;IAED,YAAY;QACR,IAAI,CAAC,UAAU,EAAE,CAAC;IACtB,CAAC;IAED,YAAY;QACR,IAAI,CAAC,UAAU,EAAE,CAAC;IACtB,CAAC;IAED,QAAQ;QACJ,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,IAAI,IAAI,CAAC,kBAAkB,EAAE;YACzB,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE;gBACtC,IAAI,CAAC,IAAI,EAAE,CAAC;YAChB,CAAC,EAAE,IAAI,CAAC,kBAAkB,CAAC,CAAC;SAC/B;aAAM;YACH,IAAI,CAAC,IAAI,EAAE,CAAC;SACf;QAED,IAAI,IAAI,CAAC,iBAAiB,EAAE;YACxB,MAAM,QAAQ,GAAG,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC;YACrH,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE;gBACtC,IAAI,CAAC,MAAM,EAAE,CAAC;YAClB,CAAC,EAAE,QAAQ,CAAC,CAAC;SAChB;IACL,CAAC;IAED,UAAU;QACN,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,IAAI,IAAI,CAAC,kBAAkB,EAAE;YACzB,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACxB,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE;gBACtC,IAAI,CAAC,MAAM,EAAE,CAAC;YAClB,CAAC,EAAE,IAAI,CAAC,kBAAkB,CAAC,CAAC;SAC/B;aAAM;YACH,IAAI,CAAC,MAAM,EAAE,CAAC;SACjB;IACL,CAAC;IAED,IAAI;QACA,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,iBAAiB,EAAE;YACzC,OAAO;SACV;QAED,IAAI,CAAC,MAAM,EAAE,CAAC;QACd,IAAI,CAAC,KAAK,EAAE,CAAC;IACjB,CAAC;IAED,MAAM;QACF,IAAI,IAAI,CAAC,SAAS,EAAE;YAChB,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACxB,IAAI,CAAC,MAAM,EAAE,CAAC;SACjB;QAED,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QAC/C,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;QAC/C,MAAM,gBAAgB,GAAG,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QACvD,gBAAgB,CAAC,SAAS,CAAC,GAAG,CAAC,sBAAsB,CAAC,CAAC;QAEvD,MAAM,YAAY,GAAG,4BAA4B,CAAC;QAClD,MAAM,QAAQ,GAAG,QAAQ,CAAC,eAAe,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;QAC/D,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;QAC3C,QAAQ,CAAC,YAAY,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;QAC7C,QAAQ,CAAC,YAAY,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;QAC7C,QAAQ,CAAC,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACtC,MAAM,IAAI,GAAG,QAAQ,CAAC,eAAe,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;QAC5D,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE,8FAA8F,CAAC,CAAC;QACvH,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QAE3B,IAAI,CAAC,WAAW,GAAG,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QACjD,IAAI,CAAC,WAAW,CAAC,SAAS,GAAG,iBAAiB,CAAC;QAC/C,IAAI,CAAC,UAAU,EAAE,CAAC;QAElB,gBAAgB,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAC/C,gBAAgB,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;QACvC,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,gBAAgB,CAAC,CAAC;QAC7C,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC1C,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;QAE3C,IAAI,IAAI,CAAC,OAAO,YAAY,WAAW,EAAE;YACrC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,CAAC,4BAA4B,CAAC,CAAC;SAC9D;QACD,IAAI,CAAC,eAAe,EAAE,CAAC;IAC3B,CAAC;IAED,KAAK;QACD,QAAQ,IAAI,CAAC,iBAAiB,EAAE;YAC5B,KAAK,UAAU;gBACX,IAAI,CAAC,YAAY,EAAE,CAAC;gBACpB,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE;oBACtB,IAAI,CAAC,WAAW,EAAE,CAAC;oBACnB,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE;wBACtB,IAAI,CAAC,UAAU,EAAE,CAAC;wBAClB,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE;4BACtB,IAAI,CAAC,SAAS,EAAE,CAAC;yBACpB;qBACJ;iBACJ;gBACD,MAAM;YACV,KAAK,WAAW;gBACZ,IAAI,CAAC,aAAa,EAAE,CAAC;gBACrB,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE;oBACtB,IAAI,CAAC,WAAW,EAAE,CAAC;oBACnB,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE;wBACtB,IAAI,CAAC,UAAU,EAAE,CAAC;wBAClB,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE;4BACtB,IAAI,CAAC,SAAS,EAAE,CAAC;yBACpB;qBACJ;iBACJ;gBACD,MAAM;YACV,KAAK,KAAK;gBACN,IAAI,CAAC,QAAQ,EAAE,CAAC;gBAChB,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE;oBACtB,IAAI,CAAC,WAAW,EAAE,CAAC;oBACnB,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE;wBACtB,IAAI,CAAC,UAAU,EAAE,CAAC;wBAElB,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE;4BACtB,IAAI,CAAC,SAAS,EAAE,CAAC;yBACpB;qBACJ;iBACJ;gBACD,MAAM;YAEV,KAAK,QAAQ;gBACT,IAAI,CAAC,WAAW,EAAE,CAAC;gBACnB,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE;oBACtB,IAAI,CAAC,QAAQ,EAAE,CAAC;oBAChB,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE;wBACtB,IAAI,CAAC,UAAU,EAAE,CAAC;wBAElB,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE;4BACtB,IAAI,CAAC,SAAS,EAAE,CAAC;yBACpB;qBACJ;iBACJ;gBACD,MAAM;YAEV,KAAK,aAAa;gBACd,IAAI,CAAC,eAAe,EAAE,CAAC;gBACvB,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE;oBACtB,IAAI,CAAC,QAAQ,EAAE,CAAC;oBAChB,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE;wBACtB,IAAI,CAAC,UAAU,EAAE,CAAC;wBAElB,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE;4BACtB,IAAI,CAAC,SAAS,EAAE,CAAC;yBACpB;qBACJ;iBACJ;gBACD,MAAM;YAEV,KAAK,cAAc;gBACf,IAAI,CAAC,gBAAgB,EAAE,CAAC;gBACxB,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE;oBACtB,IAAI,CAAC,QAAQ,EAAE,CAAC;oBAChB,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE;wBACtB,IAAI,CAAC,UAAU,EAAE,CAAC;wBAElB,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE;4BACtB,IAAI,CAAC,SAAS,EAAE,CAAC;yBACpB;qBACJ;iBACJ;gBACD,MAAM;YAEV,KAAK,MAAM;gBACP,IAAI,CAAC,SAAS,EAAE,CAAC;gBACjB,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE;oBACtB,IAAI,CAAC,UAAU,EAAE,CAAC;oBAElB,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE;wBACtB,IAAI,CAAC,QAAQ,EAAE,CAAC;wBAEhB,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE;4BACtB,IAAI,CAAC,WAAW,EAAE,CAAC;yBACtB;qBACJ;iBACJ;gBACD,MAAM;YAEV,KAAK,OAAO;gBACR,IAAI,CAAC,UAAU,EAAE,CAAC;gBAClB,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE;oBACtB,IAAI,CAAC,SAAS,EAAE,CAAC;oBAEjB,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE;wBACtB,IAAI,CAAC,QAAQ,EAAE,CAAC;wBAEhB,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE;4BACtB,IAAI,CAAC,WAAW,EAAE,CAAC;yBACtB;qBACJ;iBACJ;gBACD,MAAM;SACb;IACL,CAAC;IAED,UAAU;QACN,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QACvB,IAAI,IAAI,CAAC,SAAS,EAAE;YAChB,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;YACxC,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,GAAG,cAAc,CAAC,aAAa,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,cAAc,CAAC,aAAa,CAAC;YAC/G,MAAM,GAAG,GACL,UAAU,CAAC,GAAG,GAAG,CAAC,cAAc,CAAC,cAAc,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,cAAc,CAAC,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC;YAC7H,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;YACxC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,GAAG,GAAG,GAAG,IAAI,CAAC;SACzC;IACL,CAAC;IAED,SAAS;QACL,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QACtB,IAAI,IAAI,CAAC,SAAS,EAAE;YAChB,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;YACxC,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,GAAG,cAAc,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,cAAc,CAAC,aAAa,CAAC;YAC3G,MAAM,GAAG,GACL,UAAU,CAAC,GAAG,GAAG,CAAC,cAAc,CAAC,cAAc,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,cAAc,CAAC,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC;YAC7H,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;YACxC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,GAAG,GAAG,GAAG,IAAI,CAAC;SACzC;IACL,CAAC;IAED,QAAQ;QACJ,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QACrB,IAAI,IAAI,CAAC,SAAS,EAAE;YAChB,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;YACxC,MAAM,IAAI,GACN,UAAU,CAAC,IAAI,GAAG,CAAC,cAAc,CAAC,aAAa,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,cAAc,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC;YAC5H,MAAM,GAAG,GAAG,UAAU,CAAC,GAAG,GAAG,cAAc,CAAC,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,cAAc,CAAC,aAAa,CAAC;YAC1G,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;YACxC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,GAAG,GAAG,GAAG,IAAI,CAAC;SACzC;IACL,CAAC;IAED,YAAY;QACR,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;QAC1B,IAAI,IAAI,CAAC,SAAS,EAAE;YAChB,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;YACxC,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC;YAC7B,MAAM,GAAG,GAAG,UAAU,CAAC,GAAG,GAAG,cAAc,CAAC,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,cAAc,CAAC,aAAa,CAAC;YAC1G,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;YACxC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,GAAG,GAAG,GAAG,IAAI,CAAC;SACzC;IACL,CAAC;IAED,aAAa;QACT,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;QAC3B,IAAI,IAAI,CAAC,SAAS,EAAE;YAChB,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;YACxC,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,GAAG,cAAc,CAAC,aAAa,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,cAAc,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YAC/H,MAAM,GAAG,GAAG,UAAU,CAAC,GAAG,GAAG,cAAc,CAAC,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,cAAc,CAAC,aAAa,CAAC;YAC1G,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;YACxC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,GAAG,GAAG,GAAG,IAAI,CAAC;SACzC;IACL,CAAC;IAED,WAAW;QACP,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;QACxB,IAAI,IAAI,CAAC,SAAS,EAAE;YAChB,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;YACxC,MAAM,IAAI,GACN,UAAU,CAAC,IAAI,GAAG,CAAC,cAAc,CAAC,aAAa,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,cAAc,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC;YAC5H,MAAM,GAAG,GAAG,UAAU,CAAC,GAAG,GAAG,cAAc,CAAC,cAAc,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,cAAc,CAAC,aAAa,CAAC;YAC9G,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;YACxC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,GAAG,GAAG,GAAG,IAAI,CAAC;SACzC;IACL,CAAC;IAED,eAAe;QACX,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;QAC7B,IAAI,IAAI,CAAC,SAAS,EAAE;YAChB,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;YACxC,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC;YAC7B,MAAM,GAAG,GAAG,UAAU,CAAC,GAAG,GAAG,cAAc,CAAC,cAAc,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,cAAc,CAAC,aAAa,CAAC;YAC9G,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;YACxC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,GAAG,GAAG,GAAG,IAAI,CAAC;SACzC;IACL,CAAC;IAED,gBAAgB;QACZ,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;QAC9B,IAAI,IAAI,CAAC,SAAS,EAAE;YAChB,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;YACxC,MAAM,IAAI,GACN,UAAU,CAAC,IAAI,GAAG,CAAC,cAAc,CAAC,aAAa,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,cAAc,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;YACxH,MAAM,GAAG,GAAG,UAAU,CAAC,GAAG,GAAG,cAAc,CAAC,cAAc,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,cAAc,CAAC,aAAa,CAAC;YAC9G,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;YACxC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,GAAG,GAAG,GAAG,IAAI,CAAC;SACzC;IACL,CAAC;IAED,QAAQ,CAAC,QAAgB;QACrB,IAAI,IAAI,CAAC,SAAS,EAAE;YAChB,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,GAAG,GAAG,IAAI,CAAC;YACxC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,IAAI,CAAC;YAEvC,MAAM,gBAAgB,GAAG,aAAa,GAAG,QAAQ,CAAC;YAClD,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;SAClD;IACL,CAAC;IAED,aAAa;QACT,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,qBAAqB,EAAE,CAAC;QAC1D,MAAM,UAAU,GAAG,MAAM,CAAC,IAAI,GAAG,cAAc,CAAC,mBAAmB,EAAE,CAAC;QACtE,MAAM,SAAS,GAAG,MAAM,CAAC,GAAG,GAAG,cAAc,CAAC,kBAAkB,EAAE,CAAC;QAEnE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,SAAS,EAAE,CAAC;IAChD,CAAC;IAED,aAAa;QACT,IAAI,IAAI,CAAC,SAAS,EAAE;YAChB,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,qBAAqB,EAAE,CAAC;YACtD,MAAM,SAAS,GAAG,MAAM,CAAC,GAAG,CAAC;YAC7B,MAAM,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC;YAC/B,MAAM,KAAK,GAAG,cAAc,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YAC3D,MAAM,MAAM,GAAG,cAAc,CAAC,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YAC7D,MAAM,QAAQ,GAAG,cAAc,CAAC,WAAW,EAAE,CAAC;YAE9C,OAAO,UAAU,GAAG,KAAK,GAAG,QAAQ,CAAC,KAAK,IAAI,UAAU,GAAG,CAAC,IAAI,SAAS,GAAG,CAAC,IAAI,SAAS,GAAG,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC;SACzH;aAAM;YACH,OAAO,KAAK,CAAC;SAChB;IACL,CAAC;IAED,MAAM;QACF,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE;YAChD,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;SAC7C;QAED,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC/B,CAAC;IAED,gBAAgB;QACZ,IAAI,IAAI,CAAC,WAAW,EAAE;YAClB,YAAY,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAC/B,IAAI,CAAC,WAAW,GAAG,SAAS,CAAC;SAChC;IACL,CAAC;IAED,gBAAgB;QACZ,IAAI,IAAI,CAAC,WAAW,EAAE;YAClB,YAAY,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAC/B,IAAI,CAAC,WAAW,GAAG,SAAS,CAAC;SAChC;IACL,CAAC;IAED,aAAa;QACT,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,IAAI,CAAC,gBAAgB,EAAE,CAAC;IAC5B,CAAC;IAED,UAAU;QACN,IAAI,IAAI,CAAC,OAAO,YAAY,WAAW,EAAE;YACrC,MAAM,eAAe,GAAG,IAAI,CAAC,gBAAgB,CAAC,kBAAkB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC/E,eAAe,CAAC,OAAO,GAAG,IAAI,CAAC,wBAAwB,CAAC;YACxD,eAAe,CAAC,aAAa,EAAE,CAAC;YAChC,eAAe,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC;SAClF;aAAM,IAAI,IAAI,CAAC,WAAW,EAAE;YACzB,IAAI,CAAC,WAAW,CAAC,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;SACrF;IACL,CAAC;IAED,eAAe;QACX,IAAI,IAAI,CAAC,SAAS,EAAE;YAChB,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,WAAW,CAAC,qBAAqB,EAAE,IAAI,CAAC,SAAS,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;SAC/F;IACL,CAAC;wGA3cQ,gBAAgB;4FAAhB,gBAAgB;;4FAAhB,gBAAgB;kBAD5B,SAAS;mBAAC,EAAE,QAAQ,EAAE,aAAa,EAAE,UAAU,EAAE,IAAI,EAAE;8BAO3C,iBAAiB;sBAAzB,KAAK;gBAWc,OAAO;sBAA1B,KAAK;uBAAC,WAAW;gBAET,kBAAkB;sBAA1B,KAAK;gBAEG,kBAAkB;sBAA1B,KAAK;gBAEG,iBAAiB;sBAAzB,KAAK;gBAEG,iBAAiB;sBAAzB,KAAK;gBAEG,wBAAwB;sBAAhC,KAAK;gBAEG,6BAA6B;sBAArC,KAAK","sourcesContent":["import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';\nimport {\n    AfterViewInit,\n    DestroyRef,\n    Directive,\n    ElementRef,\n    Input,\n    NgZone,\n    OnDestroy,\n    OnInit,\n    TemplateRef,\n    ViewContainerRef,\n    inject,\n} from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport DOMPurify from 'dompurify';\nimport { TooltipService } from './tooltip.service';\n\n@Directive({ selector: '[apTooltip]', standalone: true })\nexport class TooltipDirective implements AfterViewInit, OnDestroy, OnInit {\n    private readonly elementRef: ElementRef = inject(ElementRef);\n    private readonly zone: NgZone = inject(NgZone);\n    private readonly viewContainerRef: ViewContainerRef = inject(ViewContainerRef);\n    private readonly destroyRef = inject(DestroyRef);\n\n    @Input() apTooltipPosition:\n        | 'right'\n        | 'left'\n        | 'top'\n        | 'bottom'\n        | 'bottom-left'\n        | 'bottom-right'\n        | 'top-left'\n        | 'top-right'\n        | undefined = 'top';\n\n    @Input('apTooltip') content: string | TemplateRef<HTMLElement> | undefined | null;\n\n    @Input() apTooltipShowDelay: number | undefined = 80;\n\n    @Input() apTooltipHideDelay: number | undefined;\n\n    @Input() apTooltipDuration: number | undefined;\n\n    @Input() apTooltipDisabled: boolean | undefined;\n\n    @Input() apTooltipTemplateContext: any | undefined;\n\n    @Input() apTooltipVirtualScrollElement: CdkVirtualScrollViewport | undefined;\n\n    clickListener: (() => void) | undefined = undefined;\n\n    container: HTMLElement | undefined = undefined;\n\n    hideTimeout: number | undefined;\n\n    mouseEnterListener: (() => void) | undefined = undefined;\n\n    mouseLeaveListener: (() => void) | undefined = undefined;\n\n    nativeElement: HTMLElement = this.elementRef.nativeElement;\n\n    showTimeout: number | undefined;\n\n    tooltipText: HTMLElement | undefined;\n\n    ngOnInit(): void {\n        if (this.apTooltipVirtualScrollElement) {\n            this.apTooltipVirtualScrollElement.renderedRangeStream.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(range => {\n                if (range.start === 0 && range.end === 0) {\n                    this.deactivate();\n                }\n            });\n        }\n    }\n\n    ngAfterViewInit(): void {\n        this.zone.runOutsideAngular(() => {\n            this.mouseEnterListener = this.onMouseEnter.bind(this);\n            this.mouseLeaveListener = this.onMouseLeave.bind(this);\n            this.clickListener = this.onInputClick.bind(this);\n            this.nativeElement.addEventListener('mouseenter', this.mouseEnterListener);\n            this.nativeElement.addEventListener('click', this.clickListener);\n            this.nativeElement.addEventListener('mouseleave', this.mouseLeaveListener);\n        });\n    }\n\n    ngOnDestroy(): void {\n        if (this.container) {\n            this.deactivate();\n        }\n        if (this.mouseEnterListener) {\n            this.nativeElement.removeEventListener('mouseenter', this.mouseEnterListener);\n        }\n        if (this.clickListener) {\n            this.nativeElement.removeEventListener('click', this.clickListener);\n        }\n        if (this.mouseLeaveListener) {\n            this.nativeElement.removeEventListener('mouseleave', this.mouseLeaveListener);\n        }\n        this.mouseEnterListener = undefined;\n        this.mouseLeaveListener = undefined;\n        this.clickListener = undefined;\n    }\n\n    onMouseEnter(): void {\n        if (!this.container) {\n            this.activate();\n        }\n    }\n\n    onMouseLeave(): void {\n        this.deactivate();\n    }\n\n    onInputClick(): void {\n        this.deactivate();\n    }\n\n    activate(): void {\n        this.clearHideTimeout();\n        if (this.apTooltipShowDelay) {\n            this.showTimeout = window.setTimeout(() => {\n                this.show();\n            }, this.apTooltipShowDelay);\n        } else {\n            this.show();\n        }\n\n        if (this.apTooltipDuration) {\n            const duration = this.apTooltipShowDelay ? this.apTooltipDuration + this.apTooltipShowDelay : this.apTooltipDuration;\n            this.hideTimeout = window.setTimeout(() => {\n                this.remove();\n            }, duration);\n        }\n    }\n\n    deactivate(): void {\n        this.clearShowTimeout();\n        if (this.apTooltipHideDelay) {\n            this.clearHideTimeout();\n            this.hideTimeout = window.setTimeout(() => {\n                this.remove();\n            }, this.apTooltipHideDelay);\n        } else {\n            this.remove();\n        }\n    }\n\n    show(): void {\n        if (!this.content || this.apTooltipDisabled) {\n            return;\n        }\n\n        this.create();\n        this.align();\n    }\n\n    create(): void {\n        if (this.container) {\n            this.clearHideTimeout();\n            this.remove();\n        }\n\n        this.container = document.createElement('div');\n        this.container.setAttribute('role', 'tooltip');\n        const contentContainer = document.createElement('div');\n        contentContainer.classList.add('ap-content-container');\n\n        const svgNamespace = 'http://www.w3.org/2000/svg';\n        const arrowSvg = document.createElementNS(svgNamespace, 'svg');\n        arrowSvg.classList.add('ap-tooltip-arrow');\n        arrowSvg.setAttribute('xmlns', svgNamespace);\n        arrowSvg.setAttribute('viewBox', '0 0 16 8');\n        arrowSvg.setAttribute('fill', 'none');\n        const path = document.createElementNS(svgNamespace, 'path');\n        path.setAttribute('d', 'M6.68299 1.15238C7.43705 0.492586 8.56296 0.492588 9.31701 1.15238L16 7L0 7L6.68299 1.15238Z');\n        arrowSvg.appendChild(path);\n\n        this.tooltipText = document.createElement('div');\n        this.tooltipText.className = 'ap-tooltip-text';\n        this.updateText();\n\n        contentContainer.appendChild(this.tooltipText);\n        contentContainer.appendChild(arrowSvg);\n        this.container.appendChild(contentContainer);\n        document.body.appendChild(this.container);\n        this.container.classList.add('ap-tooltip');\n\n        if (this.content instanceof TemplateRef) {\n            this.container.classList.add('ap-tooltip-custom-template');\n        }\n        this.setCssVariables();\n    }\n\n    align(): void {\n        switch (this.apTooltipPosition) {\n            case 'top-left':\n                this.alignTopLeft();\n                if (this.isOutOfBounds()) {\n                    this.alignBottom();\n                    if (this.isOutOfBounds()) {\n                        this.alignRight();\n                        if (this.isOutOfBounds()) {\n                            this.alignLeft();\n                        }\n                    }\n                }\n                break;\n            case 'top-right':\n                this.alignTopRight();\n                if (this.isOutOfBounds()) {\n                    this.alignBottom();\n                    if (this.isOutOfBounds()) {\n                        this.alignRight();\n                        if (this.isOutOfBounds()) {\n                            this.alignLeft();\n                        }\n                    }\n                }\n                break;\n            case 'top':\n                this.alignTop();\n                if (this.isOutOfBounds()) {\n                    this.alignBottom();\n                    if (this.isOutOfBounds()) {\n                        this.alignRight();\n\n                        if (this.isOutOfBounds()) {\n                            this.alignLeft();\n                        }\n                    }\n                }\n                break;\n\n            case 'bottom':\n                this.alignBottom();\n                if (this.isOutOfBounds()) {\n                    this.alignTop();\n                    if (this.isOutOfBounds()) {\n                        this.alignRight();\n\n                        if (this.isOutOfBounds()) {\n                            this.alignLeft();\n                        }\n                    }\n                }\n                break;\n\n            case 'bottom-left':\n                this.alignBottomLeft();\n                if (this.isOutOfBounds()) {\n                    this.alignTop();\n                    if (this.isOutOfBounds()) {\n                        this.alignRight();\n\n                        if (this.isOutOfBounds()) {\n                            this.alignLeft();\n                        }\n                    }\n                }\n                break;\n\n            case 'bottom-right':\n                this.alignBottomRight();\n                if (this.isOutOfBounds()) {\n                    this.alignTop();\n                    if (this.isOutOfBounds()) {\n                        this.alignRight();\n\n                        if (this.isOutOfBounds()) {\n                            this.alignLeft();\n                        }\n                    }\n                }\n                break;\n\n            case 'left':\n                this.alignLeft();\n                if (this.isOutOfBounds()) {\n                    this.alignRight();\n\n                    if (this.isOutOfBounds()) {\n                        this.alignTop();\n\n                        if (this.isOutOfBounds()) {\n                            this.alignBottom();\n                        }\n                    }\n                }\n                break;\n\n            case 'right':\n                this.alignRight();\n                if (this.isOutOfBounds()) {\n                    this.alignLeft();\n\n                    if (this.isOutOfBounds()) {\n                        this.alignTop();\n\n                        if (this.isOutOfBounds()) {\n                            this.alignBottom();\n                        }\n                    }\n                }\n                break;\n        }\n    }\n\n    alignRight(): void {\n        this.preAlign('right');\n        if (this.container) {\n            const hostOffset = this.getHostOffset();\n            const left = hostOffset.left + TooltipService.getOuterWidth(this.nativeElement) + TooltipService.defaultOffset;\n            const top =\n                hostOffset.top + (TooltipService.getOuterHeight(this.nativeElement) - TooltipService.getOuterHeight(this.container)) / 2;\n            this.container.style.left = left + 'px';\n            this.container.style.top = top + 'px';\n        }\n    }\n\n    alignLeft(): void {\n        this.preAlign('left');\n        if (this.container) {\n            const hostOffset = this.getHostOffset();\n            const left = hostOffset.left - TooltipService.getOuterWidth(this.container) - TooltipService.defaultOffset;\n            const top =\n                hostOffset.top + (TooltipService.getOuterHeight(this.nativeElement) - TooltipService.getOuterHeight(this.container)) / 2;\n            this.container.style.left = left + 'px';\n            this.container.style.top = top + 'px';\n        }\n    }\n\n    alignTop(): void {\n        this.preAlign('top');\n        if (this.container) {\n            const hostOffset = this.getHostOffset();\n            const left =\n                hostOffset.left + (TooltipService.getOuterWidth(this.nativeElement) - TooltipService.getOuterWidth(this.container)) / 2;\n            const top = hostOffset.top - TooltipService.getOuterHeight(this.container) - TooltipService.defaultOffset;\n            this.container.style.left = left + 'px';\n            this.container.style.top = top + 'px';\n        }\n    }\n\n    alignTopLeft(): void {\n        this.preAlign('top-left');\n        if (this.container) {\n            const hostOffset = this.getHostOffset();\n            const left = hostOffset.left;\n            const top = hostOffset.top - TooltipService.getOuterHeight(this.container) - TooltipService.defaultOffset;\n            this.container.style.left = left + 'px';\n            this.container.style.top = top + 'px';\n        }\n    }\n\n    alignTopRight(): void {\n        this.preAlign('top-right');\n        if (this.container) {\n            const hostOffset = this.getHostOffset();\n            const left = hostOffset.left + TooltipService.getOuterWidth(this.nativeElement) - TooltipService.getOuterWidth(this.container);\n            const top = hostOffset.top - TooltipService.getOuterHeight(this.container) - TooltipService.defaultOffset;\n            this.container.style.left = left + 'px';\n            this.container.style.top = top + 'px';\n        }\n    }\n\n    alignBottom(): void {\n        this.preAlign('bottom');\n        if (this.container) {\n            const hostOffset = this.getHostOffset();\n            const left =\n                hostOffset.left + (TooltipService.getOuterWidth(this.nativeElement) - TooltipService.getOuterWidth(this.container)) / 2;\n            const top = hostOffset.top + TooltipService.getOuterHeight(this.nativeElement) + TooltipService.defaultOffset;\n            this.container.style.left = left + 'px';\n            this.container.style.top = top + 'px';\n        }\n    }\n\n    alignBottomLeft(): void {\n        this.preAlign('bottom-left');\n        if (this.container) {\n            const hostOffset = this.getHostOffset();\n            const left = hostOffset.left;\n            const top = hostOffset.top + TooltipService.getOuterHeight(this.nativeElement) + TooltipService.defaultOffset;\n            this.container.style.left = left + 'px';\n            this.container.style.top = top + 'px';\n        }\n    }\n\n    alignBottomRight(): void {\n        this.preAlign('bottom-right');\n        if (this.container) {\n            const hostOffset = this.getHostOffset();\n            const left =\n                hostOffset.left + (TooltipService.getOuterWidth(this.nativeElement) - TooltipService.getOuterWidth(this.container));\n            const top = hostOffset.top + TooltipService.getOuterHeight(this.nativeElement) + TooltipService.defaultOffset;\n            this.container.style.left = left + 'px';\n            this.container.style.top = top + 'px';\n        }\n    }\n\n    preAlign(position: string) {\n        if (this.container) {\n            this.container.style.left = -999 + 'px';\n            this.container.style.top = -999 + 'px';\n\n            const defaultClassName = 'ap-tooltip-' + position;\n            this.container.classList.add(defaultClassName);\n        }\n    }\n\n    getHostOffset() {\n        const offset = this.nativeElement.getBoundingClientRect();\n        const targetLeft = offset.left + TooltipService.getWindowScrollLeft();\n        const targetTop = offset.top + TooltipService.getWindowScrollTop();\n\n        return { left: targetLeft, top: targetTop };\n    }\n\n    isOutOfBounds(): boolean {\n        if (this.container) {\n            const offset = this.container.getBoundingClientRect();\n            const targetTop = offset.top;\n            const targetLeft = offset.left;\n            const width = TooltipService.getOuterWidth(this.container);\n            const height = TooltipService.getOuterHeight(this.container);\n            const viewport = TooltipService.getViewport();\n\n            return targetLeft + width > viewport.width || targetLeft < 0 || targetTop < 0 || targetTop + height > viewport.height;\n        } else {\n            return false;\n        }\n    }\n\n    remove(): void {\n        if (this.container && this.container.parentElement) {\n            document.body.removeChild(this.container);\n        }\n\n        this.clearTimeouts();\n        this.container = undefined;\n    }\n\n    clearShowTimeout() {\n        if (this.showTimeout) {\n            clearTimeout(this.showTimeout);\n            this.showTimeout = undefined;\n        }\n    }\n\n    clearHideTimeout() {\n        if (this.hideTimeout) {\n            clearTimeout(this.hideTimeout);\n            this.hideTimeout = undefined;\n        }\n    }\n\n    clearTimeouts() {\n        this.clearShowTimeout();\n        this.clearHideTimeout();\n    }\n\n    updateText() {\n        if (this.content instanceof TemplateRef) {\n            const embeddedViewRef = this.viewContainerRef.createEmbeddedView(this.content);\n            embeddedViewRef.context = this.apTooltipTemplateContext;\n            embeddedViewRef.detectChanges();\n            embeddedViewRef.rootNodes.forEach(node => this.tooltipText?.appendChild(node));\n        } else if (this.tooltipText) {\n            this.tooltipText.innerHTML = this.content ? DOMPurify.sanitize(this.content) : '';\n        }\n    }\n\n    setCssVariables(): void {\n        if (this.container) {\n            this.container.style.setProperty('--ap-tooltip-height', this.container.offsetHeight + 'px');\n        }\n    }\n}\n"]}

package/esm2022/tooltip/tooltip.service.mjs

@@ -0,0 +1,29 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class TooltipService {
+    static defaultOffset = 12;
+    static getOuterWidth(el) {
+        return el.offsetWidth;
+    }
+    static getOuterHeight(el) {
+        return el.offsetHeight;
+    }
+    static getViewport() {
+        const win = window, d = document, e = d.documentElement, g = d.getElementsByTagName('body')[0], w = win.innerWidth || e.clientWidth || g.clientWidth, h = win.innerHeight || e.clientHeight || g.clientHeight;
+        return { width: w, height: h };
+    }
+    static getWindowScrollLeft() {
+        const doc = document.documentElement;
+        return (window.pageXOffset || doc.scrollLeft) - (doc.clientLeft || 0);
+    }
+    static getWindowScrollTop() {
+        const doc = document.documentElement;
+        return (window.pageYOffset || doc.scrollTop) - (doc.clientTop || 0);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.10", ngImport: i0, type: TooltipService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.10", ngImport: i0, type: TooltipService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.10", ngImport: i0, type: TooltipService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/fesm2022/agorapulse-ui-components-add-comment.mjs

@@ -0,0 +1,78 @@
+import { NgTemplateOutlet } from '@angular/common';
+import * as i0 from '@angular/core';
+import { EventEmitter, booleanAttribute, forwardRef, Component, ChangeDetectionStrategy, Input, Output } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { ButtonComponent } from '@agorapulse/ui-components/button';
+import * as i1 from '@angular/material/input';
+import { MatInputModule } from '@angular/material/input';
+import { AutosizeTextareaDirective } from '@agorapulse/ui-components/directives';
+import * as i2 from '@angular/cdk/bidi';
+
+/* eslint-disable @typescript-eslint/no-empty-function */
+class AddCommentComponent {
+    placeholder = 'Add a comment';
+    customTemplate;
+    disable = false;
+    action = new EventEmitter();
+    _commentValue = '';
+    get commentValue() {
+        return this._commentValue;
+    }
+    set commentValue(value) {
+        this._commentValue = value;
+        this.propagateChange(value);
+    }
+    propagateChange = () => { };
+    registerOnChange(fn) {
+        this.propagateChange = fn;
+    }
+    registerOnTouched(fn) { }
+    setDisabledState(isDisabled) {
+        this.disable = isDisabled;
+    }
+    writeValue(obj) {
+        this._commentValue = obj != undefined ? obj : '';
+        this.propagateChange(this._commentValue);
+    }
+    onChange(event) {
+        const value = event.target.value;
+        this._commentValue = value != undefined ? value : '';
+        this.propagateChange(value);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.10", ngImport: i0, type: AddCommentComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "16.1.0", version: "16.2.10", type: AddCommentComponent, isStandalone: true, selector: "ap-add-comment", inputs: { placeholder: "placeholder", customTemplate: "customTemplate", disable: ["disable", "disable", booleanAttribute] }, outputs: { action: "action" }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => AddCommentComponent),
+                multi: true,
+            },
+        ], ngImport: i0, template: "<div class=\"add-comment\">\n    <textarea\n        apAutosize\n        dir=\"auto\"\n        matInput\n        rows=\"1\"\n        [placeholder]=\"placeholder\"\n        [value]=\"_commentValue\"\n        (keyup)=\"onChange($event)\"\n        (change)=\"onChange($event)\"></textarea>\n\n    <ng-template\n        #defaultTemplate\n        let-action=\"action\">\n        <div class=\"default-template\">\n            <ap-button\n                name=\"\"\n                [config]=\"{\n                    style: 'stroked',\n                    color: 'grey'\n                }\"\n                (click)=\"action.emit('send')\">\n                Send\n            </ap-button>\n        </div>\n    </ng-template>\n\n    <ng-template\n        [ngTemplateOutlet]=\"customTemplate || defaultTemplate\"\n        [ngTemplateOutletContext]=\"{\n            action: action\n        }\" />\n</div>\n", styles: ["[color=facebook]{color:#0866ff}[bgcolor=facebook],[hcolor=facebook]:hover{background-color:#0866ff}[border=facebook]{border:1px solid #0866ff}[color=google]{color:#4e85e8}[bgcolor=google],[hcolor=google]:hover{background-color:#4e85e8}[border=google]{border:1px solid #4e85e8}[color=instagram]{color:#e1306c}[bgcolor=instagram],[hcolor=instagram]:hover{background-color:#e1306c}[border=instagram]{border:1px solid #e1306c}[color=instagrammagenta]{color:#c13584}[bgcolor=instagrammagenta],[hcolor=instagrammagenta]:hover{background-color:#c13584}[border=instagrammagenta]{border:1px solid #c13584}[color=instagramblue]{color:#5851db}[bgcolor=instagramblue],[hcolor=instagramblue]:hover{background-color:#5851db}[border=instagramblue]{border:1px solid #5851db}[color=instagrampurple]{color:#833ab4}[bgcolor=instagrampurple],[hcolor=instagrampurple]:hover{background-color:#833ab4}[border=instagrampurple]{border:1px solid #833ab4}[color=instagramorange]{color:#f56040}[bgcolor=instagramorange],[hcolor=instagramorange]:hover{background-color:#f56040}[border=instagramorange]{border:1px solid #f56040}[color=instagramyellow]{color:#ffdc80}[bgcolor=instagramyellow],[hcolor=instagramyellow]:hover{background-color:#ffdc80}[border=instagramyellow]{border:1px solid #ffdc80}[color=linkedin]{color:#2c67bc}[bgcolor=linkedin],[hcolor=linkedin]:hover{background-color:#2c67bc}[border=linkedin]{border:1px solid #2c67bc}[color=twitter]{color:#55acee}[bgcolor=twitter],[hcolor=twitter]:hover{background-color:#55acee}[border=twitter]{border:1px solid #55acee}[color=youtube]{color:red}[bgcolor=youtube],[hcolor=youtube]:hover{background-color:red}[border=youtube]{border:1px solid #ff0000}[color=blood-orange]{color:#ff4d00}[bgcolor=blood-orange],[hcolor=blood-orange]:hover{background-color:#ff4d00}[border=blood-orange]{border:1px solid #ff4d00}[color=pinkish-orange]{color:#ff7b49}[bgcolor=pinkish-orange],[hcolor=pinkish-orange]:hover{background-color:#ff7b49}[border=pinkish-orange]{border:1px solid #ff7b49}[color=charcoal-grey]{color:#2a2f34}[bgcolor=charcoal-grey],[hcolor=charcoal-grey]:hover{background-color:#2a2f34}[border=charcoal-grey]{border:1px solid #2a2f34}[color=azure]{color:#00aeef}[bgcolor=azure],[hcolor=azure]:hover{background-color:#00aeef}[border=azure]{border:1px solid #00aeef}[color=light-azure]{color:#eaf5fd}[bgcolor=light-azure],[hcolor=light-azure]:hover{background-color:#eaf5fd}[border=light-azure]{border:1px solid #eaf5fd}[color=blue-grey]{color:#8d98a9}[bgcolor=blue-grey],[hcolor=blue-grey]:hover{background-color:#8d98a9}[border=blue-grey]{border:1px solid #8d98a9}[color=silver]{color:#ced0da}[bgcolor=silver],[hcolor=silver]:hover{background-color:#ced0da}[border=silver]{border:1px solid #ced0da}[color=pale-grey]{color:#dfe3e9}[bgcolor=pale-grey],[hcolor=pale-grey]:hover{background-color:#dfe3e9}[border=pale-grey]{border:1px solid #dfe3e9}[color=grey-white]{color:#f5f7f8}[bgcolor=grey-white],[hcolor=grey-white]:hover{background-color:#f5f7f8}[border=grey-white]{border:1px solid #f5f7f8}[color=cool-grey]{color:#b4bbc6}[bgcolor=cool-grey],[hcolor=cool-grey]:hover{background-color:#b4bbc6}[border=cool-grey]{border:1px solid #b4bbc6}[color=black]{color:#344563}[bgcolor=black],[hcolor=black]:hover{background-color:#344563}[border=black]{border:1px solid #344563}[color=grey-blue]{color:#68768c}[bgcolor=grey-blue],[hcolor=grey-blue]:hover{background-color:#68768c}[border=grey-blue]{border:1px solid #68768c}[color=strawberry]{color:#f4282d}[bgcolor=strawberry],[hcolor=strawberry]:hover{background-color:#f4282d}[border=strawberry]{border:1px solid #f4282d}[color=light-strawberry]{color:#f8eded}[bgcolor=light-strawberry],[hcolor=light-strawberry]:hover{background-color:#f8eded}[border=light-strawberry]{border:1px solid #f8eded}[color=white]{color:#fff}[bgcolor=white],[hcolor=white]:hover{background-color:#fff}[border=white]{border:1px solid #ffffff}[color=cool-green]{color:#33c15d}[bgcolor=cool-green],[hcolor=cool-green]:hover{background-color:#33c15d}[border=cool-green]{border:1px solid #33c15d}[color=light-green]{color:#ebfaef}[bgcolor=light-green],[hcolor=light-green]:hover{background-color:#ebfaef}[border=light-green]{border:1px solid #ebfaef}[color=transparent]{color:transparent}[bgcolor=transparent],[hcolor=transparent]:hover{background-color:transparent}[border=transparent]{border:1px solid transparent}[color=c0]{color:#a566a5}[bgcolor=c0],[hcolor=c0]:hover{background-color:#a566a5}[border=c0]{border:1px solid #a566a5}[color=c1]{color:#c7ab82}[bgcolor=c1],[hcolor=c1]:hover{background-color:#c7ab82}[border=c1]{border:1px solid #c7ab82}[color=c2]{color:#f2713c}[bgcolor=c2],[hcolor=c2]:hover{background-color:#f2713c}[border=c2]{border:1px solid #f2713c}[color=c3]{color:#ffd006}[bgcolor=c3],[hcolor=c3]:hover{background-color:#ffd006}[border=c3]{border:1px solid #ffd006}[color=c4]{color:#94c5aa}[bgcolor=c4],[hcolor=c4]:hover{background-color:#94c5aa}[border=c4]{border:1px solid #94c5aa}[color=c5]{color:#2a9d8f}[bgcolor=c5],[hcolor=c5]:hover{background-color:#2a9d8f}[border=c5]{border:1px solid #2a9d8f}[color=c6]{color:#78acd8}[bgcolor=c6],[hcolor=c6]:hover{background-color:#78acd8}[border=c6]{border:1px solid #78acd8}[color=c7]{color:#525a9e}[bgcolor=c7],[hcolor=c7]:hover{background-color:#525a9e}[border=c7]{border:1px solid #525a9e}[color=c8]{color:#6a2459}[bgcolor=c8],[hcolor=c8]:hover{background-color:#6a2459}[border=c8]{border:1px solid #6a2459}[color=c9]{color:#74729e}[bgcolor=c9],[hcolor=c9]:hover{background-color:#74729e}[border=c9]{border:1px solid #74729e}.add-comment{border:1px solid #d6dae0;border-radius:4px;display:flex;flex-direction:column}.add-comment:focus-within{border:1px solid #178dfe}.add-comment:not(:focus-within):hover{border-color:#aeb5c1}.add-comment textarea{border:none;background:transparent;color:#858fa1;padding:0;margin:6px 16px}.add-comment textarea:focus,.add-comment input:focus{outline:none}.add-comment .default-template{display:flex;flex-direction:row-reverse}.add-comment .default-template button{background-color:#fff!important;width:90px;margin-right:8px;margin-bottom:8px;align-self:end}.add-comment .default-template button:hover{border-color:#d6dae0!important}.add-comment .default-template button:active{border-color:#aeb5c1!important}\n"], dependencies: [{ kind: "directive", type: AutosizeTextareaDirective, selector: "textarea[apAutosize]" }, { kind: "ngmodule", type: MatInputModule }, { kind: "directive", type: i1.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { kind: "directive", type: i2.Dir, selector: "[dir]", inputs: ["dir"], outputs: ["dirChange"], exportAs: ["dir"] }, { kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: ButtonComponent, selector: "ap-button", inputs: ["ariaLabel", "disabled", "name", "form", "config", "loading", "locked", "menuTrigger", "symbolPosition", "ionicModalEnabled"], outputs: ["menuOpened", "menuClosed", "click", "focus", "blur"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.10", ngImport: i0, type: AddCommentComponent, decorators: [{
+            type: Component,
+            args: [{ changeDetection: ChangeDetectionStrategy.OnPush, selector: 'ap-add-comment', standalone: true, imports: [AutosizeTextareaDirective, MatInputModule, NgTemplateOutlet, ButtonComponent], providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => AddCommentComponent),
+                            multi: true,
+                        },
+                    ], template: "<div class=\"add-comment\">\n    <textarea\n        apAutosize\n        dir=\"auto\"\n        matInput\n        rows=\"1\"\n        [placeholder]=\"placeholder\"\n        [value]=\"_commentValue\"\n        (keyup)=\"onChange($event)\"\n        (change)=\"onChange($event)\"></textarea>\n\n    <ng-template\n        #defaultTemplate\n        let-action=\"action\">\n        <div class=\"default-template\">\n            <ap-button\n                name=\"\"\n                [config]=\"{\n                    style: 'stroked',\n                    color: 'grey'\n                }\"\n                (click)=\"action.emit('send')\">\n                Send\n            </ap-button>\n        </div>\n    </ng-template>\n\n    <ng-template\n        [ngTemplateOutlet]=\"customTemplate || defaultTemplate\"\n        [ngTemplateOutletContext]=\"{\n            action: action\n        }\" />\n</div>\n", styles: ["[color=facebook]{color:#0866ff}[bgcolor=facebook],[hcolor=facebook]:hover{background-color:#0866ff}[border=facebook]{border:1px solid #0866ff}[color=google]{color:#4e85e8}[bgcolor=google],[hcolor=google]:hover{background-color:#4e85e8}[border=google]{border:1px solid #4e85e8}[color=instagram]{color:#e1306c}[bgcolor=instagram],[hcolor=instagram]:hover{background-color:#e1306c}[border=instagram]{border:1px solid #e1306c}[color=instagrammagenta]{color:#c13584}[bgcolor=instagrammagenta],[hcolor=instagrammagenta]:hover{background-color:#c13584}[border=instagrammagenta]{border:1px solid #c13584}[color=instagramblue]{color:#5851db}[bgcolor=instagramblue],[hcolor=instagramblue]:hover{background-color:#5851db}[border=instagramblue]{border:1px solid #5851db}[color=instagrampurple]{color:#833ab4}[bgcolor=instagrampurple],[hcolor=instagrampurple]:hover{background-color:#833ab4}[border=instagrampurple]{border:1px solid #833ab4}[color=instagramorange]{color:#f56040}[bgcolor=instagramorange],[hcolor=instagramorange]:hover{background-color:#f56040}[border=instagramorange]{border:1px solid #f56040}[color=instagramyellow]{color:#ffdc80}[bgcolor=instagramyellow],[hcolor=instagramyellow]:hover{background-color:#ffdc80}[border=instagramyellow]{border:1px solid #ffdc80}[color=linkedin]{color:#2c67bc}[bgcolor=linkedin],[hcolor=linkedin]:hover{background-color:#2c67bc}[border=linkedin]{border:1px solid #2c67bc}[color=twitter]{color:#55acee}[bgcolor=twitter],[hcolor=twitter]:hover{background-color:#55acee}[border=twitter]{border:1px solid #55acee}[color=youtube]{color:red}[bgcolor=youtube],[hcolor=youtube]:hover{background-color:red}[border=youtube]{border:1px solid #ff0000}[color=blood-orange]{color:#ff4d00}[bgcolor=blood-orange],[hcolor=blood-orange]:hover{background-color:#ff4d00}[border=blood-orange]{border:1px solid #ff4d00}[color=pinkish-orange]{color:#ff7b49}[bgcolor=pinkish-orange],[hcolor=pinkish-orange]:hover{background-color:#ff7b49}[border=pinkish-orange]{border:1px solid #ff7b49}[color=charcoal-grey]{color:#2a2f34}[bgcolor=charcoal-grey],[hcolor=charcoal-grey]:hover{background-color:#2a2f34}[border=charcoal-grey]{border:1px solid #2a2f34}[color=azure]{color:#00aeef}[bgcolor=azure],[hcolor=azure]:hover{background-color:#00aeef}[border=azure]{border:1px solid #00aeef}[color=light-azure]{color:#eaf5fd}[bgcolor=light-azure],[hcolor=light-azure]:hover{background-color:#eaf5fd}[border=light-azure]{border:1px solid #eaf5fd}[color=blue-grey]{color:#8d98a9}[bgcolor=blue-grey],[hcolor=blue-grey]:hover{background-color:#8d98a9}[border=blue-grey]{border:1px solid #8d98a9}[color=silver]{color:#ced0da}[bgcolor=silver],[hcolor=silver]:hover{background-color:#ced0da}[border=silver]{border:1px solid #ced0da}[color=pale-grey]{color:#dfe3e9}[bgcolor=pale-grey],[hcolor=pale-grey]:hover{background-color:#dfe3e9}[border=pale-grey]{border:1px solid #dfe3e9}[color=grey-white]{color:#f5f7f8}[bgcolor=grey-white],[hcolor=grey-white]:hover{background-color:#f5f7f8}[border=grey-white]{border:1px solid #f5f7f8}[color=cool-grey]{color:#b4bbc6}[bgcolor=cool-grey],[hcolor=cool-grey]:hover{background-color:#b4bbc6}[border=cool-grey]{border:1px solid #b4bbc6}[color=black]{color:#344563}[bgcolor=black],[hcolor=black]:hover{background-color:#344563}[border=black]{border:1px solid #344563}[color=grey-blue]{color:#68768c}[bgcolor=grey-blue],[hcolor=grey-blue]:hover{background-color:#68768c}[border=grey-blue]{border:1px solid #68768c}[color=strawberry]{color:#f4282d}[bgcolor=strawberry],[hcolor=strawberry]:hover{background-color:#f4282d}[border=strawberry]{border:1px solid #f4282d}[color=light-strawberry]{color:#f8eded}[bgcolor=light-strawberry],[hcolor=light-strawberry]:hover{background-color:#f8eded}[border=light-strawberry]{border:1px solid #f8eded}[color=white]{color:#fff}[bgcolor=white],[hcolor=white]:hover{background-color:#fff}[border=white]{border:1px solid #ffffff}[color=cool-green]{color:#33c15d}[bgcolor=cool-green],[hcolor=cool-green]:hover{background-color:#33c15d}[border=cool-green]{border:1px solid #33c15d}[color=light-green]{color:#ebfaef}[bgcolor=light-green],[hcolor=light-green]:hover{background-color:#ebfaef}[border=light-green]{border:1px solid #ebfaef}[color=transparent]{color:transparent}[bgcolor=transparent],[hcolor=transparent]:hover{background-color:transparent}[border=transparent]{border:1px solid transparent}[color=c0]{color:#a566a5}[bgcolor=c0],[hcolor=c0]:hover{background-color:#a566a5}[border=c0]{border:1px solid #a566a5}[color=c1]{color:#c7ab82}[bgcolor=c1],[hcolor=c1]:hover{background-color:#c7ab82}[border=c1]{border:1px solid #c7ab82}[color=c2]{color:#f2713c}[bgcolor=c2],[hcolor=c2]:hover{background-color:#f2713c}[border=c2]{border:1px solid #f2713c}[color=c3]{color:#ffd006}[bgcolor=c3],[hcolor=c3]:hover{background-color:#ffd006}[border=c3]{border:1px solid #ffd006}[color=c4]{color:#94c5aa}[bgcolor=c4],[hcolor=c4]:hover{background-color:#94c5aa}[border=c4]{border:1px solid #94c5aa}[color=c5]{color:#2a9d8f}[bgcolor=c5],[hcolor=c5]:hover{background-color:#2a9d8f}[border=c5]{border:1px solid #2a9d8f}[color=c6]{color:#78acd8}[bgcolor=c6],[hcolor=c6]:hover{background-color:#78acd8}[border=c6]{border:1px solid #78acd8}[color=c7]{color:#525a9e}[bgcolor=c7],[hcolor=c7]:hover{background-color:#525a9e}[border=c7]{border:1px solid #525a9e}[color=c8]{color:#6a2459}[bgcolor=c8],[hcolor=c8]:hover{background-color:#6a2459}[border=c8]{border:1px solid #6a2459}[color=c9]{color:#74729e}[bgcolor=c9],[hcolor=c9]:hover{background-color:#74729e}[border=c9]{border:1px solid #74729e}.add-comment{border:1px solid #d6dae0;border-radius:4px;display:flex;flex-direction:column}.add-comment:focus-within{border:1px solid #178dfe}.add-comment:not(:focus-within):hover{border-color:#aeb5c1}.add-comment textarea{border:none;background:transparent;color:#858fa1;padding:0;margin:6px 16px}.add-comment textarea:focus,.add-comment input:focus{outline:none}.add-comment .default-template{display:flex;flex-direction:row-reverse}.add-comment .default-template button{background-color:#fff!important;width:90px;margin-right:8px;margin-bottom:8px;align-self:end}.add-comment .default-template button:hover{border-color:#d6dae0!important}.add-comment .default-template button:active{border-color:#aeb5c1!important}\n"] }]
+        }], propDecorators: { placeholder: [{
+                type: Input
+            }], customTemplate: [{
+                type: Input
+            }], disable: [{
+                type: Input,
+                args: [{
+                        transform: booleanAttribute,
+                    }]
+            }], action: [{
+                type: Output
+            }] } });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AddCommentComponent };
+//# sourceMappingURL=agorapulse-ui-components-add-comment.mjs.map