@entake/particle 17.0.0

package/esm2022/app/modules/tooltip/tooltip.directive.mjs

@@ -0,0 +1,381 @@
+import { Directive, HostListener, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Directive to create a tooltip around the host element
+ * TODO: Open/Close animation with AnimationFactory
+ */
+export class TooltipDirective {
+    element;
+    renderer;
+    /**
+     * The number of pixels from the host to offset the tooltip
+     * @private
+     */
+    TOOLTIP_OFFSET = 10;
+    /**
+     * Tooltip text input
+     * @param text the text to set for the tooltip
+     */
+    set particleTooltip(text) {
+        this._text = text;
+        if (!!text) {
+            if (!!this.tooltip?.parentElement) {
+                this.setTooltipText();
+                this.alignTooltip();
+            }
+        }
+        else {
+            this.deleteTooltip();
+        }
+    }
+    get particleTooltip() { return this._text; }
+    /**
+     * The direction of the tooltip around the host element
+     */
+    tooltipPosition = 'bottom';
+    /**
+     * Whether to disable the tooltip
+     * @param disabled disabled or not
+     */
+    set tooltipDisabled(disabled) {
+        this._tooltipDisabled = disabled;
+        if (disabled && !!this.tooltip?.parentElement) {
+            this.deleteTooltip();
+        }
+    }
+    get tooltipDisabled() {
+        return this._tooltipDisabled;
+    }
+    /**
+     * The DIV element housing the tooltip
+     * @private
+     */
+    tooltip = null;
+    /**
+     * The tooltip text
+     * @private
+     */
+    _text = null;
+    /**
+     * Whether or not the tooltip is disabled
+     * @private
+     */
+    _tooltipDisabled = false;
+    /**
+     * Array of scroll unlisten functions
+     * @private
+     */
+    scrollUnlisteners = [];
+    /**
+     * Get window scroll top
+     * @private
+     */
+    static getWindowScrollTop() {
+        const { scrollTop, clientTop } = document.documentElement;
+        return (window.scrollY ?? scrollTop) - (clientTop ?? 0);
+    }
+    /**
+     * Get window scroll left
+     * @private
+     */
+    static getWindowScrollLeft() {
+        const { scrollLeft, clientLeft } = document.documentElement;
+        return (window.scrollX ?? scrollLeft) - (clientLeft ?? 0);
+    }
+    /**
+     * Dependency injection site
+     * @param element the host element
+     * @param renderer the Angular renderer
+     */
+    constructor(element, renderer) {
+        this.element = element;
+        this.renderer = renderer;
+    }
+    /**
+     * Destroy directive, invoke scroll unlisteners
+     */
+    ngOnDestroy() {
+        this.removeScrollListeners();
+    }
+    /**
+     * Handle host mouse enter event
+     */
+    onMouseEnter() {
+        this.showTooltip();
+    }
+    /**
+     * Handle host mouse leave event
+     */
+    onMouseLeave() {
+        this.deleteTooltip();
+    }
+    /**
+     * Handle host click event
+     */
+    onClick() {
+        this.deleteTooltip();
+    }
+    /**
+     * Create tooltip, set the text and align it
+     * @private
+     */
+    showTooltip() {
+        if (!this.tooltipDisabled) {
+            this.createTooltip();
+            this.setTooltipText();
+            this.alignTooltip();
+            this.addScrollListeners();
+        }
+    }
+    /**
+     * Add the tooltip to the DOM
+     * @private
+     */
+    createTooltip() {
+        this.deleteTooltip();
+        this.tooltip = this.renderer.createElement('div');
+        this.renderer.appendChild(document.body, this.tooltip);
+        this.renderer.addClass(this.tooltip, 'particle_tooltip');
+    }
+    /**
+     * Set tooltip text
+     * @private
+     */
+    setTooltipText() {
+        this.renderer.setProperty(this.tooltip, 'innerHTML', this.particleTooltip);
+    }
+    /**
+     * Align the tooltip to the input position or the next best fit
+     * @private
+     */
+    alignTooltip() {
+        switch (this.tooltipPosition) {
+            case 'left':
+                this.renderer.addClass(this.tooltip, 'left');
+                this.alignLeft();
+                if (this.tooltipOutOfWindow()) {
+                    this.renderer.removeClass(this.tooltip, 'left');
+                    this.renderer.addClass(this.tooltip, 'top');
+                    this.alignTop();
+                    if (this.tooltipOutOfWindow()) {
+                        this.renderer.removeClass(this.tooltip, 'top');
+                        this.renderer.addClass(this.tooltip, 'right');
+                        this.alignRight();
+                        if (this.tooltipOutOfWindow()) {
+                            this.renderer.removeClass(this.tooltip, 'right');
+                            this.renderer.addClass(this.tooltip, 'bottom');
+                            this.alignBottom();
+                        }
+                    }
+                }
+                break;
+            case 'top':
+                this.renderer.addClass(this.tooltip, 'top');
+                this.alignTop();
+                if (this.tooltipOutOfWindow()) {
+                    this.renderer.removeClass(this.tooltip, 'top');
+                    this.renderer.addClass(this.tooltip, 'right');
+                    this.alignRight();
+                    if (this.tooltipOutOfWindow()) {
+                        this.renderer.removeClass(this.tooltip, 'right');
+                        this.renderer.addClass(this.tooltip, 'bottom');
+                        this.alignBottom();
+                        if (this.tooltipOutOfWindow()) {
+                            this.renderer.removeClass(this.tooltip, 'bottom');
+                            this.renderer.addClass(this.tooltip, 'left');
+                            this.alignLeft();
+                        }
+                    }
+                }
+                break;
+            case 'right':
+                this.renderer.addClass(this.tooltip, 'right');
+                this.alignRight();
+                if (this.tooltipOutOfWindow()) {
+                    this.renderer.removeClass(this.tooltip, 'right');
+                    this.renderer.addClass(this.tooltip, 'bottom');
+                    this.alignBottom();
+                    if (this.tooltipOutOfWindow()) {
+                        this.renderer.removeClass(this.tooltip, 'bottom');
+                        this.renderer.addClass(this.tooltip, 'left');
+                        this.alignLeft();
+                        if (this.tooltipOutOfWindow()) {
+                            this.renderer.removeClass(this.tooltip, 'left');
+                            this.renderer.addClass(this.tooltip, 'top');
+                            this.alignTop();
+                        }
+                    }
+                }
+                break;
+            case 'bottom':
+                this.renderer.addClass(this.tooltip, 'bottom');
+                this.alignBottom();
+                if (this.tooltipOutOfWindow()) {
+                    this.renderer.removeClass(this.tooltip, 'bottom');
+                    this.renderer.addClass(this.tooltip, 'left');
+                    this.alignLeft();
+                    if (this.tooltipOutOfWindow()) {
+                        this.renderer.removeClass(this.tooltip, 'left');
+                        this.renderer.addClass(this.tooltip, 'top');
+                        this.alignTop();
+                        if (this.tooltipOutOfWindow()) {
+                            this.renderer.removeClass(this.tooltip, 'top');
+                            this.renderer.addClass(this.tooltip, 'right');
+                            this.alignRight();
+                        }
+                    }
+                }
+        }
+    }
+    /**
+     * Align the tooltip to the left of the host
+     * @private
+     */
+    alignLeft() {
+        const hostOffset = this.getHostOffset();
+        const left = hostOffset.left - this.tooltip.offsetWidth - this.TOOLTIP_OFFSET;
+        const top = hostOffset.top + (this.element.nativeElement.offsetHeight - this.tooltip.offsetHeight) / 2;
+        this.renderer.setStyle(this.tooltip, 'left', `${left}px`);
+        this.renderer.setStyle(this.tooltip, 'top', `${top}px`);
+    }
+    /**
+     * Align the tooltip to the right of the host
+     * @private
+     */
+    alignRight() {
+        const hostOffset = this.getHostOffset();
+        const left = hostOffset.left + this.element.nativeElement.offsetWidth + this.TOOLTIP_OFFSET;
+        const top = hostOffset.top + (this.element.nativeElement.offsetHeight - this.tooltip.offsetHeight) / 2;
+        this.renderer.setStyle(this.tooltip, 'left', `${left}px`);
+        this.renderer.setStyle(this.tooltip, 'top', `${top}px`);
+    }
+    /**
+     * Align the tooltip to the top of the host
+     * @private
+     */
+    alignTop() {
+        const hostOffset = this.getHostOffset();
+        const left = hostOffset.left + (this.element.nativeElement.offsetWidth - this.tooltip.offsetWidth) / 2;
+        const top = hostOffset.top - this.tooltip.offsetHeight - this.TOOLTIP_OFFSET;
+        this.renderer.setStyle(this.tooltip, 'left', `${left}px`);
+        this.renderer.setStyle(this.tooltip, 'top', `${top}px`);
+    }
+    /**
+     * Align the tooltip to the bottom of the host
+     * @private
+     */
+    alignBottom() {
+        const hostOffset = this.getHostOffset();
+        const left = hostOffset.left + (this.element.nativeElement.offsetWidth - this.tooltip.offsetWidth) / 2;
+        const top = hostOffset.top + this.element.nativeElement.offsetHeight + this.TOOLTIP_OFFSET;
+        this.renderer.setStyle(this.tooltip, 'left', `${left}px`);
+        this.renderer.setStyle(this.tooltip, 'top', `${top}px`);
+    }
+    /**
+     * Get the host's top and left position offset by window scroll
+     * @private
+     */
+    getHostOffset() {
+        const { left, top } = this.element.nativeElement.getBoundingClientRect();
+        const targetLeft = left + TooltipDirective.getWindowScrollLeft();
+        const targetTop = top + TooltipDirective.getWindowScrollTop();
+        return { left: targetLeft, top: targetTop };
+    }
+    /**
+     * Remove the tooltip from the DOM
+     * @private
+     */
+    deleteTooltip() {
+        if (!!this.tooltip?.parentElement) {
+            this.renderer.removeChild(document.body, this.tooltip);
+            this.tooltip = null;
+        }
+        this.removeScrollListeners();
+    }
+    /**
+     * Checks if the tooltip fits in the window
+     * @private
+     */
+    tooltipOutOfWindow() {
+        const { top, left } = this.tooltip.getBoundingClientRect();
+        const { offsetWidth, offsetHeight } = this.tooltip;
+        const { innerWidth, innerHeight } = window;
+        return (left + offsetWidth > innerWidth) || (left < 0) || (top < 0) || (top + offsetHeight > innerHeight);
+    }
+    /**
+     * Listen for scrolling on all scrollable parents of the host element
+     * @private
+     */
+    addScrollListeners() {
+        const overflowRegex = /(auto|scroll)/;
+        const overflowCheck = (node) => {
+            overflowRegex.lastIndex = 0;
+            const styleDeclaration = window['getComputedStyle'](node, null);
+            return overflowRegex.test(styleDeclaration.getPropertyValue('overflow')) ||
+                overflowRegex.test(styleDeclaration.getPropertyValue('overflowX')) ||
+                overflowRegex.test(styleDeclaration.getPropertyValue('overflowY'));
+        };
+        const parents = this.getParentElements(this.element.nativeElement);
+        for (const parent of parents) {
+            const scrollSelectors = parent.nodeType === 1 && parent.dataset['scrollselectors'];
+            if (scrollSelectors) {
+                const selectors = scrollSelectors.split(',');
+                for (const selector of selectors) {
+                    const el = parent.querySelector(selector);
+                    if (el && overflowCheck(el)) {
+                        this.scrollUnlisteners.push(this.renderer.listen(el, 'scroll', () => this.deleteTooltip()));
+                    }
+                }
+            }
+            else if (parent.nodeType !== 9 && overflowCheck(parent)) {
+                this.scrollUnlisteners.push(this.renderer.listen(parent, 'scroll', () => this.deleteTooltip()));
+            }
+        }
+    }
+    /**
+     * Invoke scroll unlisten functions and clear unlisteners list
+     * @private
+     */
+    removeScrollListeners() {
+        for (const unlisten of this.scrollUnlisteners) {
+            unlisten();
+        }
+        this.scrollUnlisteners = [];
+    }
+    /**
+     * Get the parent elements for the input element
+     * @param element the element to get parents for
+     * @param parents the parent elements
+     * @private
+     */
+    getParentElements(element, parents = []) {
+        const { parentNode } = element;
+        return !parentNode
+            ? parents
+            : this.getParentElements(parentNode, parents.concat([parentNode]));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: TooltipDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.2", type: TooltipDirective, selector: "[particleTooltip]", inputs: { particleTooltip: "particleTooltip", tooltipPosition: "tooltipPosition", tooltipDisabled: "tooltipDisabled" }, host: { listeners: { "mouseenter": "onMouseEnter()", "mouseleave": "onMouseLeave()", "click": "onClick()" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: TooltipDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[particleTooltip]'
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { particleTooltip: [{
+                type: Input
+            }], tooltipPosition: [{
+                type: Input
+            }], tooltipDisabled: [{
+                type: Input
+            }], onMouseEnter: [{
+                type: HostListener,
+                args: ['mouseenter']
+            }], onMouseLeave: [{
+                type: HostListener,
+                args: ['mouseleave']
+            }], onClick: [{
+                type: HostListener,
+                args: ['click']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tooltip.directive.js","sourceRoot":"","sources":["../../../../../src/app/modules/tooltip/tooltip.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {Directive, ElementRef, HostListener, Input, OnDestroy, Renderer2} from '@angular/core';\r\n\r\n/**\r\n * Directive to create a tooltip around the host element\r\n * TODO: Open/Close animation with AnimationFactory\r\n */\r\n@Directive({\r\n  selector: '[particleTooltip]'\r\n\r\n})\r\nexport class TooltipDirective implements OnDestroy {\r\n\r\n  /**\r\n   * The number of pixels from the host to offset the tooltip\r\n   * @private\r\n   */\r\n  private readonly TOOLTIP_OFFSET = 10;\r\n\r\n  /**\r\n   * Tooltip text input\r\n   * @param text the text to set for the tooltip\r\n   */\r\n  @Input()\r\n  set particleTooltip(text: string) {\r\n    this._text = text;\r\n\r\n    if (!!text) {\r\n      if (!!this.tooltip?.parentElement) {\r\n        this.setTooltipText();\r\n        this.alignTooltip();\r\n      }\r\n    } else {\r\n      this.deleteTooltip();\r\n    }\r\n  }\r\n  get particleTooltip(): string { return this._text; }\r\n\r\n  /**\r\n   * The direction of the tooltip around the host element\r\n   */\r\n  @Input()\r\n  tooltipPosition: 'left' | 'right' | 'top' | 'bottom' = 'bottom';\r\n\r\n  /**\r\n   * Whether to disable the tooltip\r\n   * @param disabled disabled or not\r\n   */\r\n  @Input()\r\n  set tooltipDisabled(disabled: boolean) {\r\n    this._tooltipDisabled = disabled;\r\n    if (disabled && !!this.tooltip?.parentElement) {\r\n      this.deleteTooltip();\r\n    }\r\n  }\r\n\r\n  get tooltipDisabled(): boolean {\r\n    return this._tooltipDisabled;\r\n  }\r\n\r\n  /**\r\n   * The DIV element housing the tooltip\r\n   * @private\r\n   */\r\n  private tooltip: HTMLDivElement = null as any;\r\n\r\n  /**\r\n   * The tooltip text\r\n   * @private\r\n   */\r\n  private _text: string = null as any;\r\n\r\n  /**\r\n   * Whether or not the tooltip is disabled\r\n   * @private\r\n   */\r\n  private _tooltipDisabled: boolean = false;\r\n\r\n  /**\r\n   * Array of scroll unlisten functions\r\n   * @private\r\n   */\r\n  private scrollUnlisteners: Array<() => void> = [];\r\n\r\n  /**\r\n   * Get window scroll top\r\n   * @private\r\n   */\r\n  private static getWindowScrollTop(): number {\r\n    const { scrollTop, clientTop } = document.documentElement;\r\n    return (window.scrollY ?? scrollTop) - (clientTop ?? 0);\r\n  }\r\n\r\n  /**\r\n   * Get window scroll left\r\n   * @private\r\n   */\r\n  private static getWindowScrollLeft(): number {\r\n    const { scrollLeft, clientLeft } = document.documentElement;\r\n    return (window.scrollX ?? scrollLeft) - (clientLeft ?? 0);\r\n  }\r\n\r\n  /**\r\n   * Dependency injection site\r\n   * @param element the host element\r\n   * @param renderer the Angular renderer\r\n   */\r\n  constructor(private element: ElementRef<HTMLElement>, private renderer: Renderer2) { }\r\n\r\n  /**\r\n   * Destroy directive, invoke scroll unlisteners\r\n   */\r\n  ngOnDestroy(): void {\r\n    this.removeScrollListeners();\r\n  }\r\n\r\n  /**\r\n   * Handle host mouse enter event\r\n   */\r\n  @HostListener('mouseenter')\r\n  onMouseEnter(): void {\r\n    this.showTooltip();\r\n  }\r\n\r\n  /**\r\n   * Handle host mouse leave event\r\n   */\r\n  @HostListener('mouseleave')\r\n  onMouseLeave(): void {\r\n    this.deleteTooltip();\r\n  }\r\n\r\n  /**\r\n   * Handle host click event\r\n   */\r\n  @HostListener('click')\r\n  onClick(): void {\r\n    this.deleteTooltip();\r\n  }\r\n\r\n  /**\r\n   * Create tooltip, set the text and align it\r\n   * @private\r\n   */\r\n  private showTooltip(): void {\r\n    if (!this.tooltipDisabled) {\r\n      this.createTooltip();\r\n      this.setTooltipText();\r\n      this.alignTooltip();\r\n\r\n      this.addScrollListeners();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Add the tooltip to the DOM\r\n   * @private\r\n   */\r\n  private createTooltip(): void {\r\n    this.deleteTooltip();\r\n\r\n    this.tooltip = this.renderer.createElement('div');\r\n    this.renderer.appendChild(document.body, this.tooltip);\r\n    this.renderer.addClass(this.tooltip, 'particle_tooltip');\r\n  }\r\n\r\n  /**\r\n   * Set tooltip text\r\n   * @private\r\n   */\r\n  private setTooltipText(): void {\r\n    this.renderer.setProperty(this.tooltip, 'innerHTML', this.particleTooltip);\r\n  }\r\n\r\n  /**\r\n   * Align the tooltip to the input position or the next best fit\r\n   * @private\r\n   */\r\n  private alignTooltip(): void {\r\n    switch (this.tooltipPosition) {\r\n      case 'left':\r\n        this.renderer.addClass(this.tooltip, 'left');\r\n        this.alignLeft();\r\n\r\n        if (this.tooltipOutOfWindow()) {\r\n          this.renderer.removeClass(this.tooltip, 'left');\r\n          this.renderer.addClass(this.tooltip, 'top');\r\n          this.alignTop();\r\n\r\n          if (this.tooltipOutOfWindow()) {\r\n            this.renderer.removeClass(this.tooltip, 'top');\r\n            this.renderer.addClass(this.tooltip, 'right');\r\n            this.alignRight();\r\n\r\n            if (this.tooltipOutOfWindow()) {\r\n              this.renderer.removeClass(this.tooltip, 'right');\r\n              this.renderer.addClass(this.tooltip, 'bottom');\r\n              this.alignBottom();\r\n            }\r\n          }\r\n        }\r\n        break;\r\n      case 'top':\r\n        this.renderer.addClass(this.tooltip, 'top');\r\n        this.alignTop();\r\n\r\n        if (this.tooltipOutOfWindow()) {\r\n          this.renderer.removeClass(this.tooltip, 'top');\r\n          this.renderer.addClass(this.tooltip, 'right');\r\n          this.alignRight();\r\n\r\n          if (this.tooltipOutOfWindow()) {\r\n            this.renderer.removeClass(this.tooltip, 'right');\r\n            this.renderer.addClass(this.tooltip, 'bottom');\r\n            this.alignBottom();\r\n\r\n            if (this.tooltipOutOfWindow()) {\r\n              this.renderer.removeClass(this.tooltip, 'bottom');\r\n              this.renderer.addClass(this.tooltip, 'left');\r\n              this.alignLeft();\r\n            }\r\n          }\r\n        }\r\n        break;\r\n      case 'right':\r\n        this.renderer.addClass(this.tooltip, 'right');\r\n        this.alignRight();\r\n\r\n        if (this.tooltipOutOfWindow()) {\r\n          this.renderer.removeClass(this.tooltip, 'right');\r\n          this.renderer.addClass(this.tooltip, 'bottom');\r\n          this.alignBottom();\r\n\r\n          if (this.tooltipOutOfWindow()) {\r\n            this.renderer.removeClass(this.tooltip, 'bottom');\r\n            this.renderer.addClass(this.tooltip, 'left');\r\n            this.alignLeft();\r\n\r\n            if (this.tooltipOutOfWindow()) {\r\n              this.renderer.removeClass(this.tooltip, 'left');\r\n              this.renderer.addClass(this.tooltip, 'top');\r\n              this.alignTop();\r\n            }\r\n          }\r\n        }\r\n        break;\r\n      case 'bottom':\r\n        this.renderer.addClass(this.tooltip, 'bottom');\r\n        this.alignBottom();\r\n\r\n        if (this.tooltipOutOfWindow()) {\r\n          this.renderer.removeClass(this.tooltip, 'bottom');\r\n          this.renderer.addClass(this.tooltip, 'left');\r\n          this.alignLeft();\r\n\r\n          if (this.tooltipOutOfWindow()) {\r\n            this.renderer.removeClass(this.tooltip, 'left');\r\n            this.renderer.addClass(this.tooltip, 'top');\r\n            this.alignTop();\r\n\r\n            if (this.tooltipOutOfWindow()) {\r\n              this.renderer.removeClass(this.tooltip, 'top');\r\n              this.renderer.addClass(this.tooltip, 'right');\r\n              this.alignRight();\r\n            }\r\n          }\r\n        }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Align the tooltip to the left of the host\r\n   * @private\r\n   */\r\n  private alignLeft(): void {\r\n    const hostOffset = this.getHostOffset();\r\n    const left = hostOffset.left - this.tooltip.offsetWidth - this.TOOLTIP_OFFSET;\r\n    const top = hostOffset.top + (this.element.nativeElement.offsetHeight - this.tooltip.offsetHeight) / 2;\r\n\r\n    this.renderer.setStyle(this.tooltip, 'left', `${left}px`);\r\n    this.renderer.setStyle(this.tooltip, 'top', `${top}px`);\r\n  }\r\n\r\n  /**\r\n   * Align the tooltip to the right of the host\r\n   * @private\r\n   */\r\n  private alignRight(): void {\r\n    const hostOffset = this.getHostOffset();\r\n    const left = hostOffset.left + this.element.nativeElement.offsetWidth + this.TOOLTIP_OFFSET;\r\n    const top = hostOffset.top + (this.element.nativeElement.offsetHeight - this.tooltip.offsetHeight) / 2;\r\n\r\n    this.renderer.setStyle(this.tooltip, 'left', `${left}px`);\r\n    this.renderer.setStyle(this.tooltip, 'top', `${top}px`);\r\n  }\r\n\r\n  /**\r\n   * Align the tooltip to the top of the host\r\n   * @private\r\n   */\r\n  private alignTop(): void {\r\n    const hostOffset = this.getHostOffset();\r\n    const left = hostOffset.left + (this.element.nativeElement.offsetWidth - this.tooltip.offsetWidth) / 2;\r\n    const top = hostOffset.top - this.tooltip.offsetHeight - this.TOOLTIP_OFFSET;\r\n\r\n    this.renderer.setStyle(this.tooltip, 'left', `${left}px`);\r\n    this.renderer.setStyle(this.tooltip, 'top', `${top}px`);\r\n  }\r\n\r\n  /**\r\n   * Align the tooltip to the bottom of the host\r\n   * @private\r\n   */\r\n  private alignBottom(): void {\r\n    const hostOffset = this.getHostOffset();\r\n    const left = hostOffset.left + (this.element.nativeElement.offsetWidth - this.tooltip.offsetWidth) / 2;\r\n    const top = hostOffset.top + this.element.nativeElement.offsetHeight + this.TOOLTIP_OFFSET;\r\n\r\n    this.renderer.setStyle(this.tooltip, 'left', `${left}px`);\r\n    this.renderer.setStyle(this.tooltip, 'top', `${top}px`);\r\n  }\r\n\r\n  /**\r\n   * Get the host's top and left position offset by window scroll\r\n   * @private\r\n   */\r\n  private getHostOffset(): { left: number, top: number } {\r\n    const { left, top } = this.element.nativeElement.getBoundingClientRect();\r\n    const targetLeft = left + TooltipDirective.getWindowScrollLeft();\r\n    const targetTop = top + TooltipDirective.getWindowScrollTop();\r\n\r\n    return { left: targetLeft, top: targetTop };\r\n  }\r\n\r\n  /**\r\n   * Remove the tooltip from the DOM\r\n   * @private\r\n   */\r\n  private deleteTooltip(): void {\r\n    if (!!this.tooltip?.parentElement) {\r\n      this.renderer.removeChild(document.body, this.tooltip);\r\n      this.tooltip = null as any;\r\n    }\r\n\r\n    this.removeScrollListeners();\r\n  }\r\n\r\n  /**\r\n   * Checks if the tooltip fits in the window\r\n   * @private\r\n   */\r\n  private tooltipOutOfWindow(): boolean {\r\n    const { top, left } = this.tooltip.getBoundingClientRect();\r\n    const { offsetWidth, offsetHeight } = this.tooltip;\r\n    const { innerWidth, innerHeight } = window;\r\n\r\n    return (left + offsetWidth > innerWidth) || (left < 0) || (top < 0) || (top + offsetHeight > innerHeight);\r\n  }\r\n\r\n  /**\r\n   * Listen for scrolling on all scrollable parents of the host element\r\n   * @private\r\n   */\r\n  private addScrollListeners(): void {\r\n    const overflowRegex = /(auto|scroll)/;\r\n    const overflowCheck = (node: any): boolean => {\r\n      overflowRegex.lastIndex = 0;\r\n      const styleDeclaration = window['getComputedStyle'](node, null);\r\n      return overflowRegex.test(styleDeclaration.getPropertyValue('overflow')) ||\r\n             overflowRegex.test(styleDeclaration.getPropertyValue('overflowX')) ||\r\n             overflowRegex.test(styleDeclaration.getPropertyValue('overflowY'));\r\n    };\r\n\r\n    const parents = this.getParentElements(this.element.nativeElement);\r\n    for (const parent of parents) {\r\n      const scrollSelectors = parent.nodeType === 1 && parent.dataset['scrollselectors'];\r\n      if (scrollSelectors) {\r\n        const selectors = scrollSelectors.split(',');\r\n        for (const selector of selectors) {\r\n          const el = parent.querySelector(selector);\r\n          if (el && overflowCheck(el)) {\r\n            this.scrollUnlisteners.push(\r\n              this.renderer.listen(el, 'scroll', () => this.deleteTooltip())\r\n            );\r\n          }\r\n        }\r\n      } else if (parent.nodeType !== 9 && overflowCheck(parent)) {\r\n        this.scrollUnlisteners.push(\r\n          this.renderer.listen(parent, 'scroll', () => this.deleteTooltip())\r\n        );\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Invoke scroll unlisten functions and clear unlisteners list\r\n   * @private\r\n   */\r\n  private removeScrollListeners(): void {\r\n    for (const unlisten of this.scrollUnlisteners) {\r\n      unlisten();\r\n    }\r\n\r\n    this.scrollUnlisteners = [];\r\n  }\r\n\r\n  /**\r\n   * Get the parent elements for the input element\r\n   * @param element the element to get parents for\r\n   * @param parents the parent elements\r\n   * @private\r\n   */\r\n  private getParentElements(element: any, parents: Array<any> = []): Array<any> {\r\n    const { parentNode } = element;\r\n    return !parentNode\r\n      ? parents\r\n      : this.getParentElements(parentNode, parents.concat([parentNode]));\r\n  }\r\n}\r\n"]}

package/esm2022/app/modules/tooltip/tooltip.module.mjs

@@ -0,0 +1,18 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { TooltipDirective } from './tooltip.directive';
+import * as i0 from "@angular/core";
+export class ParticleTooltipModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: ParticleTooltipModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.2", ngImport: i0, type: ParticleTooltipModule, declarations: [TooltipDirective], imports: [CommonModule], exports: [TooltipDirective] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: ParticleTooltipModule, imports: [CommonModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: ParticleTooltipModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [TooltipDirective],
+                    imports: [CommonModule],
+                    exports: [TooltipDirective]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9vbHRpcC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvYXBwL21vZHVsZXMvdG9vbHRpcC90b29sdGlwLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQzs7QUFPdkQsTUFBTSxPQUFPLHFCQUFxQjt1R0FBckIscUJBQXFCO3dHQUFyQixxQkFBcUIsaUJBSmpCLGdCQUFnQixhQUNyQixZQUFZLGFBQ1osZ0JBQWdCO3dHQUVmLHFCQUFxQixZQUh0QixZQUFZOzsyRkFHWCxxQkFBcUI7a0JBTGpDLFFBQVE7bUJBQUM7b0JBQ1IsWUFBWSxFQUFFLENBQUMsZ0JBQWdCLENBQUM7b0JBQ2hDLE9BQU8sRUFBRSxDQUFDLFlBQVksQ0FBQztvQkFDdkIsT0FBTyxFQUFFLENBQUMsZ0JBQWdCLENBQUM7aUJBQzVCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBUb29sdGlwRGlyZWN0aXZlIH0gZnJvbSAnLi90b29sdGlwLmRpcmVjdGl2ZSc7XG5cbkBOZ01vZHVsZSh7XG4gIGRlY2xhcmF0aW9uczogW1Rvb2x0aXBEaXJlY3RpdmVdLFxuICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlXSxcbiAgZXhwb3J0czogW1Rvb2x0aXBEaXJlY3RpdmVdXG59KVxuZXhwb3J0IGNsYXNzIFBhcnRpY2xlVG9vbHRpcE1vZHVsZSB7IH1cbiJdfQ==