@spartan-ng/brain 0.0.1-alpha.373 → 0.0.1-alpha.379

package/esm2022/tooltip/lib/brn-tooltip-trigger.directive.mjs

@@ -0,0 +1,689 @@
+/**
+ * We are building on shoulders of giants here and adapt the implementation provided by the incredible Angular
+ * team: https://github.com/angular/components/blob/main/src/material/tooltip/tooltip.ts
+ * Check them out! Give them a try! Leave a star! Their work is incredible!
+ */
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { AriaDescriber, FocusMonitor } from '@angular/cdk/a11y';
+import { Directionality } from '@angular/cdk/bidi';
+import { hasModifierKey } from '@angular/cdk/keycodes';
+import { Overlay, ScrollDispatcher, } from '@angular/cdk/overlay';
+import { Platform, normalizePassiveListenerOptions } from '@angular/cdk/platform';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { DOCUMENT } from '@angular/common';
+import { Directive, ElementRef, InjectionToken, Input, NgZone, ViewContainerRef, booleanAttribute, effect, inject, isDevMode, numberAttribute, signal, } from '@angular/core';
+import { brnDevMode } from '@spartan-ng/ui-core';
+import { Subject } from 'rxjs';
+import { take, takeUntil } from 'rxjs/operators';
+import { BrnTooltipContentComponent } from './brn-tooltip-content.component';
+import { BrnTooltipDirective } from './brn-tooltip.directive';
+import * as i0 from "@angular/core";
+/** Time in ms to throttle repositioning after scroll events. */
+export const SCROLL_THROTTLE_MS = 20;
+export function getBrnTooltipInvalidPositionError(position) {
+    return Error(`Tooltip position "${position}" is invalid.`);
+}
+/** Injection token that determines the scroll handling while a tooltip is visible. */
+export const BRN_TOOLTIP_SCROLL_STRATEGY = new InjectionToken('brn-tooltip-scroll-strategy');
+export const BRN_TOOLTIP_SCROLL_STRATEGY_FACTORY_PROVIDER = {
+    provide: BRN_TOOLTIP_SCROLL_STRATEGY,
+    deps: [Overlay],
+    useFactory: (overlay) => () => overlay.scrollStrategies.reposition({ scrollThrottle: SCROLL_THROTTLE_MS }),
+};
+export function BRN_TOOLTIP_DEFAULT_OPTIONS_FACTORY() {
+    return {
+        showDelay: 0,
+        hideDelay: 0,
+        touchendHideDelay: 1500,
+    };
+}
+export const BRN_TOOLTIP_DEFAULT_OPTIONS = new InjectionToken('mat-tooltip-default-options', {
+    providedIn: 'root',
+    factory: BRN_TOOLTIP_DEFAULT_OPTIONS_FACTORY,
+});
+const PANEL_CLASS = 'tooltip-panel';
+/** Options used to bind passive event listeners. */
+const passiveListenerOptions = normalizePassiveListenerOptions({ passive: true });
+/**
+ * Time between the user putting the pointer on a tooltip
+ * trigger and the long press event being fired.
+ */
+const LONGPRESS_DELAY = 500;
+// These constants were taken from MDC's `numbers` object.
+const MIN_VIEWPORT_TOOLTIP_THRESHOLD = 8;
+const UNBOUNDED_ANCHOR_GAP = 8;
+export class BrnTooltipTriggerDirective {
+    _tooltipDirective = inject(BrnTooltipDirective, { optional: true });
+    _tooltipComponent = BrnTooltipContentComponent;
+    _cssClassPrefix = 'brn';
+    _destroyed = new Subject();
+    _passiveListeners = [];
+    _defaultOptions = inject(BRN_TOOLTIP_DEFAULT_OPTIONS, { optional: true });
+    _overlay = inject(Overlay);
+    _elementRef = inject((ElementRef));
+    _scrollDispatcher = inject(ScrollDispatcher);
+    _viewContainerRef = inject(ViewContainerRef);
+    _ngZone = inject(NgZone);
+    _platform = inject(Platform);
+    _ariaDescriber = inject(AriaDescriber);
+    _focusMonitor = inject(FocusMonitor);
+    _dir = inject(Directionality);
+    _scrollStrategy = inject(BRN_TOOLTIP_SCROLL_STRATEGY);
+    _document = inject(DOCUMENT);
+    _portal;
+    _viewInitialized = false;
+    _pointerExitEventsInitialized = false;
+    _viewportMargin = 8;
+    _currentPosition;
+    _touchstartTimeout;
+    _overlayRef = null;
+    _tooltipInstance = null;
+    /** Allows the user to define the position of the tooltip relative to the parent element */
+    _position = signal('above');
+    get position() {
+        return this._position();
+    }
+    set position(value) {
+        if (value !== this._position()) {
+            this._position.set(value);
+            if (this._overlayRef) {
+                this._updatePosition(this._overlayRef);
+                this._tooltipInstance?.show(0);
+                this._overlayRef.updatePosition();
+            }
+        }
+    }
+    /**
+     * Whether tooltip should be relative to the click or touch origin
+     * instead of outside the element bounding box.
+     */
+    _positionAtOrigin = signal(false);
+    get positionAtOrigin() {
+        return this._positionAtOrigin();
+    }
+    set positionAtOrigin(value) {
+        this._positionAtOrigin.set(value);
+        this._detach();
+        this._overlayRef = null;
+    }
+    /** Disables the display of the tooltip. */
+    _disabled = signal(false);
+    get disabled() {
+        return this._disabled();
+    }
+    set disabled(value) {
+        this._disabled.set(value);
+        // If tooltip is disabled, hide immediately.
+        if (value) {
+            this.hide(0);
+        }
+        else {
+            this._setupPointerEnterEventsIfNeeded();
+        }
+    }
+    /** The default delay in ms before showing the tooltip after show is called */
+    _showDelay = signal(0);
+    get showDelay() {
+        return this._showDelay();
+    }
+    set showDelay(value) {
+        this._showDelay.set(value);
+    }
+    /** The default delay in ms before hiding the tooltip after hide is called */
+    _hideDelay = signal(0);
+    get hideDelay() {
+        return this._hideDelay();
+    }
+    set hideDelay(value) {
+        this._hideDelay.set(value);
+        if (this._tooltipInstance) {
+            this._tooltipInstance._mouseLeaveHideDelay = this._hideDelay();
+        }
+    }
+    /** The default duration in ms that exit animation takes before hiding */
+    _exitAnimationDuration = signal(0);
+    get exitAnimationDuration() {
+        return this._exitAnimationDuration();
+    }
+    set exitAnimationDuration(value) {
+        this._exitAnimationDuration.set(value);
+        if (this._tooltipInstance) {
+            this._tooltipInstance._exitAnimationDuration = this._exitAnimationDuration();
+        }
+    }
+    /** The default delay in ms before hiding the tooltip after hide is called */
+    _tooltipContentClasses = signal('');
+    get tooltipContentClasses() {
+        return this._tooltipContentClasses();
+    }
+    set tooltipContentClasses(value) {
+        this._tooltipContentClasses.set(value ?? '');
+        if (this._tooltipInstance) {
+            this._tooltipInstance._tooltipClasses.set(value ?? '');
+        }
+    }
+    /**
+     * How touch gestures should be handled by the tooltip. On touch devices the tooltip directive
+     * uses a long press gesture to show and hide, however it can conflict with the native browser
+     * gestures. To work around the conflict, Angular Material disables native gestures on the
+     * trigger, but that might not be desirable on particular elements (e.g. inputs and draggable
+     * elements). The different values for this option configure the touch event handling as follows:
+     * - `auto` - Enables touch gestures for all elements, but tries to avoid conflicts with native
+     *   browser gestures on particular elements. In particular, it allows text selection on inputs
+     *   and textareas, and preserves the native browser dragging on elements marked as `draggable`.
+     * - `on` - Enables touch gestures for all elements and disables native
+     *   browser gestures with no exceptions.
+     * - `off` - Disables touch gestures. Note that this will prevent the tooltip from
+     *   showing on touch devices.
+     */
+    _touchGestures = signal('auto');
+    set touchGestures(value) {
+        this._touchGestures.set(value);
+    }
+    get touchGestures() {
+        return this._touchGestures();
+    }
+    /** The message to be used to describe the aria in the tooltip */
+    _ariaDescribedBy = '';
+    get ariaDescribedBy() {
+        return this._ariaDescribedBy;
+    }
+    set ariaDescribedBy(value) {
+        this._ariaDescriber.removeDescription(this._elementRef.nativeElement, this._ariaDescribedBy, 'tooltip');
+        // If the message is not a string (e.g. number), convert it to a string and trim it.
+        // Must convert with `String(value)`, not `${value}`, otherwise Closure Compiler optimises
+        // away the string-conversion: https://github.com/angular/components/issues/20684
+        this._ariaDescribedBy = value !== null ? String(value).trim() : '';
+        if (this._ariaDescribedBy && !this._isTooltipVisible()) {
+            this._ngZone.runOutsideAngular(() => {
+                // The `AriaDescriber` has some functionality that avoids adding a description if it's the
+                // same as the `aria-label` of an element, however we can't know whether the tooltip trigger
+                // has a data-bound `aria-label` or when it'll be set for the first time. We can avoid the
+                // issue by deferring the description by a tick so Angular has time to set the `aria-label`.
+                Promise.resolve().then(() => {
+                    this._ariaDescriber.describe(this._elementRef.nativeElement, this._ariaDescribedBy, 'tooltip');
+                });
+            });
+        }
+    }
+    /** The content to be displayed in the tooltip */
+    _content = null;
+    get content() {
+        return this._content;
+    }
+    set content(value) {
+        this._content = value;
+        if (!this._content && this._isTooltipVisible()) {
+            this.hide(0);
+        }
+        else {
+            this._setupPointerEnterEventsIfNeeded();
+            this._updateTooltipContent();
+        }
+    }
+    constructor() {
+        if (this._defaultOptions) {
+            this._showDelay.set(this._defaultOptions.showDelay);
+            this._hideDelay.set(this._defaultOptions.hideDelay);
+            if (this._defaultOptions.position) {
+                this.position = this._defaultOptions.position;
+            }
+            if (this._defaultOptions.positionAtOrigin) {
+                this.positionAtOrigin = this._defaultOptions.positionAtOrigin;
+            }
+            if (this._defaultOptions.touchGestures) {
+                this.touchGestures = this._defaultOptions.touchGestures;
+            }
+        }
+        this._dir.change.pipe(takeUntil(this._destroyed)).subscribe(() => {
+            if (this._overlayRef) {
+                this._updatePosition(this._overlayRef);
+            }
+        });
+        this._viewportMargin = MIN_VIEWPORT_TOOLTIP_THRESHOLD;
+        if (this._tooltipDirective) {
+            effect(() => {
+                if (this._tooltipDirective) {
+                    this.content = this._tooltipDirective.tooltipTemplate();
+                }
+            });
+        }
+    }
+    ngAfterViewInit() {
+        // This needs to happen after view init so the initial values for all inputs have been set.
+        this._viewInitialized = true;
+        this._setupPointerEnterEventsIfNeeded();
+        this._focusMonitor
+            .monitor(this._elementRef)
+            .pipe(takeUntil(this._destroyed))
+            .subscribe((origin) => {
+            // Note that the focus monitor runs outside the Angular zone.
+            if (!origin) {
+                this._ngZone.run(() => this.hide(0));
+            }
+            else if (origin === 'keyboard') {
+                this._ngZone.run(() => this.show());
+            }
+        });
+        if (brnDevMode && !this._ariaDescribedBy) {
+            console.warn('BrnTooltip: "aria-describedby" attribute is required for accessibility');
+        }
+    }
+    /**
+     * Dispose the tooltip when destroyed.
+     */
+    ngOnDestroy() {
+        const nativeElement = this._elementRef.nativeElement;
+        clearTimeout(this._touchstartTimeout);
+        if (this._overlayRef) {
+            this._overlayRef.dispose();
+            this._tooltipInstance = null;
+        }
+        // Clean up the event listeners set in the constructor
+        this._passiveListeners.forEach(([event, listener]) => nativeElement.removeEventListener(event, listener, passiveListenerOptions));
+        this._passiveListeners.length = 0;
+        this._destroyed.next();
+        this._destroyed.complete();
+        this._ariaDescriber.removeDescription(nativeElement, this._ariaDescribedBy, 'tooltip');
+        this._focusMonitor.stopMonitoring(nativeElement);
+    }
+    /** Shows the tooltip after the delay in ms, defaults to tooltip-delay-show or 0ms if no input */
+    show(delay = this.showDelay, origin) {
+        if (this.disabled || this._isTooltipVisible()) {
+            this._tooltipInstance?._cancelPendingAnimations();
+            return;
+        }
+        const overlayRef = this._createOverlay(origin);
+        this._detach();
+        this._portal = this._portal || new ComponentPortal(this._tooltipComponent, this._viewContainerRef);
+        const instance = (this._tooltipInstance = overlayRef.attach(this._portal).instance);
+        instance._triggerElement = this._elementRef.nativeElement;
+        instance._mouseLeaveHideDelay = this._hideDelay();
+        instance._tooltipClasses.set(this._tooltipContentClasses());
+        instance._exitAnimationDuration = this._exitAnimationDuration();
+        instance.side.set(this._currentPosition ?? 'above');
+        instance.afterHidden.pipe(takeUntil(this._destroyed)).subscribe(() => this._detach());
+        this._updateTooltipContent();
+        instance.show(delay);
+    }
+    /** Hides the tooltip after the delay in ms, defaults to tooltip-delay-hide or 0ms if no input */
+    hide(delay = this.hideDelay, exitAnimationDuration = this.exitAnimationDuration) {
+        const instance = this._tooltipInstance;
+        if (instance) {
+            if (instance.isVisible()) {
+                instance.hide(delay, exitAnimationDuration);
+            }
+            else {
+                instance._cancelPendingAnimations();
+                this._detach();
+            }
+        }
+    }
+    toggle(origin) {
+        this._isTooltipVisible() ? this.hide() : this.show(undefined, origin);
+    }
+    _isTooltipVisible() {
+        return !!this._tooltipInstance && this._tooltipInstance.isVisible();
+    }
+    _createOverlay(origin) {
+        if (this._overlayRef) {
+            const existingStrategy = this._overlayRef.getConfig().positionStrategy;
+            if ((!this.positionAtOrigin || !origin) && existingStrategy._origin instanceof ElementRef) {
+                return this._overlayRef;
+            }
+            this._detach();
+        }
+        const scrollableAncestors = this._scrollDispatcher.getAncestorScrollContainers(this._elementRef);
+        // Create connected position strategy that listens for scroll events to reposition.
+        const strategy = this._overlay
+            .position()
+            .flexibleConnectedTo(this.positionAtOrigin ? origin || this._elementRef : this._elementRef)
+            .withTransformOriginOn(`.${this._cssClassPrefix}-tooltip`)
+            .withFlexibleDimensions(false)
+            .withViewportMargin(this._viewportMargin)
+            .withScrollableContainers(scrollableAncestors);
+        strategy.positionChanges.pipe(takeUntil(this._destroyed)).subscribe((change) => {
+            this._updateCurrentPositionClass(change.connectionPair);
+            if (this._tooltipInstance) {
+                if (change.scrollableViewProperties.isOverlayClipped && this._tooltipInstance.isVisible()) {
+                    // After position changes occur and the overlay is clipped by
+                    // a parent scrollable then close the tooltip.
+                    this._ngZone.run(() => this.hide(0));
+                }
+            }
+        });
+        this._overlayRef = this._overlay.create({
+            direction: this._dir,
+            positionStrategy: strategy,
+            panelClass: `${this._cssClassPrefix}-${PANEL_CLASS}`,
+            scrollStrategy: this._scrollStrategy(),
+        });
+        this._updatePosition(this._overlayRef);
+        this._overlayRef
+            .detachments()
+            .pipe(takeUntil(this._destroyed))
+            .subscribe(() => this._detach());
+        this._overlayRef
+            .outsidePointerEvents()
+            .pipe(takeUntil(this._destroyed))
+            .subscribe(() => this._tooltipInstance?._handleBodyInteraction());
+        this._overlayRef
+            .keydownEvents()
+            .pipe(takeUntil(this._destroyed))
+            .subscribe((event) => {
+            if (this._isTooltipVisible() && event.key === 'Escape' && !hasModifierKey(event)) {
+                event.preventDefault();
+                event.stopPropagation();
+                this._ngZone.run(() => this.hide(0));
+            }
+        });
+        if (this._defaultOptions?.disableTooltipInteractivity) {
+            this._overlayRef.addPanelClass(`${this._cssClassPrefix}-tooltip-panel-non-interactive`);
+        }
+        return this._overlayRef;
+    }
+    _detach() {
+        if (this._overlayRef?.hasAttached()) {
+            this._overlayRef.detach();
+        }
+        this._tooltipInstance = null;
+    }
+    _updatePosition(overlayRef) {
+        const position = overlayRef.getConfig().positionStrategy;
+        const origin = this._getOrigin();
+        const overlay = this._getOverlayPosition();
+        position.withPositions([
+            this._addOffset({ ...origin.main, ...overlay.main }),
+            this._addOffset({ ...origin.fallback, ...overlay.fallback }),
+        ]);
+    }
+    /** Adds the configured offset to a position. Used as a hook for child classes. */
+    _addOffset(position) {
+        const offset = UNBOUNDED_ANCHOR_GAP;
+        const isLtr = !this._dir || this._dir.value === 'ltr';
+        if (position.originY === 'top') {
+            position.offsetY = -offset;
+        }
+        else if (position.originY === 'bottom') {
+            position.offsetY = offset;
+        }
+        else if (position.originX === 'start') {
+            position.offsetX = isLtr ? -offset : offset;
+        }
+        else if (position.originX === 'end') {
+            position.offsetX = isLtr ? offset : -offset;
+        }
+        return position;
+    }
+    /**
+     * Returns the origin position and a fallback position based on the user's position preference.
+     * The fallback position is the inverse of the origin (e.g. `'below' -> 'above'`).
+     */
+    _getOrigin() {
+        const isLtr = !this._dir || this._dir.value === 'ltr';
+        const position = this.position;
+        let originPosition;
+        if (position === 'above' || position === 'below') {
+            originPosition = { originX: 'center', originY: position === 'above' ? 'top' : 'bottom' };
+        }
+        else if (position === 'before' || (position === 'left' && isLtr) || (position === 'right' && !isLtr)) {
+            originPosition = { originX: 'start', originY: 'center' };
+        }
+        else if (position === 'after' || (position === 'right' && isLtr) || (position === 'left' && !isLtr)) {
+            originPosition = { originX: 'end', originY: 'center' };
+        }
+        else if (typeof isDevMode() === 'undefined' || isDevMode()) {
+            throw getBrnTooltipInvalidPositionError(position);
+        }
+        const { x, y } = this._invertPosition(originPosition.originX, originPosition.originY);
+        return {
+            main: originPosition,
+            fallback: { originX: x, originY: y },
+        };
+    }
+    /** Returns the overlay position and a fallback position based on the user's preference */
+    _getOverlayPosition() {
+        const isLtr = !this._dir || this._dir.value === 'ltr';
+        const position = this.position;
+        let overlayPosition;
+        if (position === 'above') {
+            overlayPosition = { overlayX: 'center', overlayY: 'bottom' };
+        }
+        else if (position === 'below') {
+            overlayPosition = { overlayX: 'center', overlayY: 'top' };
+        }
+        else if (position === 'before' || (position === 'left' && isLtr) || (position === 'right' && !isLtr)) {
+            overlayPosition = { overlayX: 'end', overlayY: 'center' };
+        }
+        else if (position === 'after' || (position === 'right' && isLtr) || (position === 'left' && !isLtr)) {
+            overlayPosition = { overlayX: 'start', overlayY: 'center' };
+        }
+        else if (typeof isDevMode() === 'undefined' || isDevMode()) {
+            throw getBrnTooltipInvalidPositionError(position);
+        }
+        const { x, y } = this._invertPosition(overlayPosition.overlayX, overlayPosition.overlayY);
+        return {
+            main: overlayPosition,
+            fallback: { overlayX: x, overlayY: y },
+        };
+    }
+    /** Updates the tooltip message and repositions the overlay according to the new message length */
+    _updateTooltipContent() {
+        // Must wait for the template to be painted to the tooltip so that the overlay can properly
+        // calculate the correct positioning based on the size of the tek-pate.
+        if (this._tooltipInstance) {
+            this._tooltipInstance.content = this.content;
+            this._tooltipInstance._markForCheck();
+            this._ngZone.onMicrotaskEmpty.pipe(take(1), takeUntil(this._destroyed)).subscribe(() => {
+                if (this._tooltipInstance) {
+                    this._overlayRef?.updatePosition();
+                }
+            });
+        }
+    }
+    /** Inverts an overlay position. */
+    _invertPosition(x, y) {
+        if (this.position === 'above' || this.position === 'below') {
+            if (y === 'top') {
+                y = 'bottom';
+            }
+            else if (y === 'bottom') {
+                y = 'top';
+            }
+        }
+        else {
+            if (x === 'end') {
+                x = 'start';
+            }
+            else if (x === 'start') {
+                x = 'end';
+            }
+        }
+        return { x, y };
+    }
+    /** Updates the class on the overlay panel based on the current position of the tooltip. */
+    _updateCurrentPositionClass(connectionPair) {
+        const { overlayY, originX, originY } = connectionPair;
+        let newPosition;
+        // If the overlay is in the middle along the Y axis,
+        // it means that it's either before or after.
+        if (overlayY === 'center') {
+            // Note that since this information is used for styling, we want to
+            // resolve `start` and `end` to their real values, otherwise consumers
+            // would have to remember to do it themselves on each consumption.
+            if (this._dir && this._dir.value === 'rtl') {
+                newPosition = originX === 'end' ? 'left' : 'right';
+            }
+            else {
+                newPosition = originX === 'start' ? 'left' : 'right';
+            }
+        }
+        else {
+            newPosition = overlayY === 'bottom' && originY === 'top' ? 'above' : 'below';
+        }
+        if (newPosition !== this._currentPosition) {
+            this._tooltipInstance?.side.set(newPosition);
+            this._currentPosition = newPosition;
+        }
+    }
+    /** Binds the pointer events to the tooltip trigger. */
+    _setupPointerEnterEventsIfNeeded() {
+        // Optimization: Defer hooking up events if there's no content or the tooltip is disabled.
+        if (this._disabled() || !this.content || !this._viewInitialized || this._passiveListeners.length) {
+            return;
+        }
+        // The mouse events shouldn't be bound on mobile devices, because they can prevent the
+        // first tap from firing its click event or can cause the tooltip to open for clicks.
+        if (this._platformSupportsMouseEvents()) {
+            this._passiveListeners.push([
+                'mouseenter',
+                (event) => {
+                    this._setupPointerExitEventsIfNeeded();
+                    let point = undefined;
+                    if (event.x !== undefined && event.y !== undefined) {
+                        point = event;
+                    }
+                    this.show(undefined, point);
+                },
+            ]);
+        }
+        else if (this.touchGestures !== 'off') {
+            this._disableNativeGesturesIfNecessary();
+            this._passiveListeners.push([
+                'touchstart',
+                (event) => {
+                    const touch = event.targetTouches?.[0];
+                    const origin = touch ? { x: touch.clientX, y: touch.clientY } : undefined;
+                    // Note that it's important that we don't `preventDefault` here,
+                    // because it can prevent click events from firing on the element.
+                    this._setupPointerExitEventsIfNeeded();
+                    clearTimeout(this._touchstartTimeout);
+                    this._touchstartTimeout = setTimeout(() => this.show(undefined, origin), LONGPRESS_DELAY);
+                },
+            ]);
+        }
+        this._addListeners(this._passiveListeners);
+    }
+    _setupPointerExitEventsIfNeeded() {
+        if (this._pointerExitEventsInitialized) {
+            return;
+        }
+        this._pointerExitEventsInitialized = true;
+        const exitListeners = [];
+        if (this._platformSupportsMouseEvents()) {
+            exitListeners.push([
+                'mouseleave',
+                (event) => {
+                    const newTarget = event.relatedTarget;
+                    if (!newTarget || !this._overlayRef?.overlayElement.contains(newTarget)) {
+                        this.hide();
+                    }
+                },
+            ], ['wheel', (event) => this._wheelListener(event)]);
+        }
+        else if (this.touchGestures !== 'off') {
+            this._disableNativeGesturesIfNecessary();
+            const touchendListener = () => {
+                clearTimeout(this._touchstartTimeout);
+                this.hide(this._defaultOptions?.touchendHideDelay);
+            };
+            exitListeners.push(['touchend', touchendListener], ['touchcancel', touchendListener]);
+        }
+        this._addListeners(exitListeners);
+        this._passiveListeners.push(...exitListeners);
+    }
+    _addListeners(listeners) {
+        listeners.forEach(([event, listener]) => {
+            this._elementRef.nativeElement.addEventListener(event, listener, passiveListenerOptions);
+        });
+    }
+    _platformSupportsMouseEvents() {
+        return !this._platform.IOS && !this._platform.ANDROID;
+    }
+    /** Listener for the `wheel` event on the element. */
+    _wheelListener(event) {
+        if (this._isTooltipVisible()) {
+            const elementUnderPointer = this._document.elementFromPoint(event.clientX, event.clientY);
+            const element = this._elementRef.nativeElement;
+            // On non-touch devices we depend on the `mouseleave` event to close the tooltip, but it
+            // won't fire if the user scrolls away using the wheel without moving their cursor. We
+            // work around it by finding the element under the user's cursor and closing the tooltip
+            // if it's not the trigger.
+            if (elementUnderPointer !== element && !element.contains(elementUnderPointer)) {
+                this.hide();
+            }
+        }
+    }
+    /** Disables the native browser gestures, based on how the tooltip has been configured. */
+    _disableNativeGesturesIfNecessary() {
+        const gestures = this.touchGestures;
+        if (gestures !== 'off') {
+            const element = this._elementRef.nativeElement;
+            const style = element.style;
+            // If gestures are set to `auto`, we don't disable text selection on inputs and
+            // textareas, because it prevents the user from typing into them on iOS Safari.
+            if (gestures === 'on' || (element.nodeName !== 'INPUT' && element.nodeName !== 'TEXTAREA')) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                style.userSelect = style.msUserSelect = style.webkitUserSelect = style.MozUserSelect = 'none';
+            }
+            // If we have `auto` gestures and the element uses native HTML dragging,
+            // we don't set `-webkit-user-drag` because it prevents the native behavior.
+            if (gestures === 'on' || !element.draggable) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                style.webkitUserDrag = 'none';
+            }
+            style.touchAction = 'none';
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            style.webkitTapHighlightColor = 'transparent';
+        }
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnTooltipTriggerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    /** @nocollapse */ static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "18.2.5", type: BrnTooltipTriggerDirective, isStandalone: true, selector: "[brnTooltipTrigger]", inputs: { position: "position", positionAtOrigin: ["positionAtOrigin", "positionAtOrigin", booleanAttribute], disabled: ["brnTooltipDisabled", "disabled", booleanAttribute], showDelay: ["showDelay", "showDelay", numberAttribute], hideDelay: ["hideDelay", "hideDelay", numberAttribute], exitAnimationDuration: ["exitAnimationDuration", "exitAnimationDuration", numberAttribute], tooltipContentClasses: "tooltipContentClasses", touchGestures: "touchGestures", ariaDescribedBy: ["aria-describedby", "ariaDescribedBy"], content: ["brnTooltipTrigger", "content"] }, host: { properties: { "class.brn-tooltip-disabled": "disabled" }, classAttribute: "brn-tooltip-trigger" }, providers: [BRN_TOOLTIP_SCROLL_STRATEGY_FACTORY_PROVIDER], exportAs: ["brnTooltipTrigger"], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnTooltipTriggerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[brnTooltipTrigger]',
+                    standalone: true,
+                    exportAs: 'brnTooltipTrigger',
+                    providers: [BRN_TOOLTIP_SCROLL_STRATEGY_FACTORY_PROVIDER],
+                    host: {
+                        class: 'brn-tooltip-trigger',
+                        '[class.brn-tooltip-disabled]': 'disabled',
+                    },
+                }]
+        }], ctorParameters: () => [], propDecorators: { position: [{
+                type: Input
+            }], positionAtOrigin: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute, alias: 'brnTooltipDisabled' }]
+            }], showDelay: [{
+                type: Input,
+                args: [{ transform: numberAttribute }]
+            }], hideDelay: [{
+                type: Input,
+                args: [{ transform: numberAttribute }]
+            }], exitAnimationDuration: [{
+                type: Input,
+                args: [{ transform: numberAttribute }]
+            }], tooltipContentClasses: [{
+                type: Input
+            }], touchGestures: [{
+                type: Input
+            }], ariaDescribedBy: [{
+                type: Input,
+                args: ['aria-describedby']
+            }], content: [{
+                type: Input,
+                args: ['brnTooltipTrigger']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"brn-tooltip-trigger.directive.js","sourceRoot":"","sources":["../../../../../../libs/brain/tooltip/src/lib/brn-tooltip-trigger.directive.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * We are building on shoulders of giants here and adapt the implementation provided by the incredible Angular\n * team: https://github.com/angular/components/blob/main/src/material/tooltip/tooltip.ts\n * Check them out! Give them a try! Leave a star! Their work is incredible!\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport { AriaDescriber, FocusMonitor } from '@angular/cdk/a11y';\nimport { Directionality } from '@angular/cdk/bidi';\nimport { hasModifierKey } from '@angular/cdk/keycodes';\nimport {\n\ttype ConnectedPosition,\n\ttype ConnectionPositionPair,\n\ttype FlexibleConnectedPositionStrategy,\n\ttype HorizontalConnectionPos,\n\ttype OriginConnectionPosition,\n\tOverlay,\n\ttype OverlayConnectionPosition,\n\ttype OverlayRef,\n\tScrollDispatcher,\n\ttype ScrollStrategy,\n\ttype VerticalConnectionPos,\n} from '@angular/cdk/overlay';\nimport { Platform, normalizePassiveListenerOptions } from '@angular/cdk/platform';\nimport { ComponentPortal } from '@angular/cdk/portal';\nimport { DOCUMENT } from '@angular/common';\nimport {\n\ttype AfterViewInit,\n\tDirective,\n\tElementRef,\n\tInjectionToken,\n\tInput,\n\tNgZone,\n\ttype OnDestroy,\n\ttype TemplateRef,\n\tViewContainerRef,\n\tbooleanAttribute,\n\teffect,\n\tinject,\n\tisDevMode,\n\tnumberAttribute,\n\tsignal,\n} from '@angular/core';\nimport { brnDevMode } from '@spartan-ng/ui-core';\nimport { Subject } from 'rxjs';\nimport { take, takeUntil } from 'rxjs/operators';\nimport { BrnTooltipContentComponent } from './brn-tooltip-content.component';\nimport { BrnTooltipDirective } from './brn-tooltip.directive';\n\nexport type TooltipPosition = 'left' | 'right' | 'above' | 'below' | 'before' | 'after';\nexport type TooltipTouchGestures = 'auto' | 'on' | 'off';\n\n/** Time in ms to throttle repositioning after scroll events. */\nexport const SCROLL_THROTTLE_MS = 20;\n\nexport function getBrnTooltipInvalidPositionError(position: string) {\n\treturn Error(`Tooltip position \"${position}\" is invalid.`);\n}\n\n/** Injection token that determines the scroll handling while a tooltip is visible. */\nexport const BRN_TOOLTIP_SCROLL_STRATEGY = new InjectionToken<() => ScrollStrategy>('brn-tooltip-scroll-strategy');\nexport const BRN_TOOLTIP_SCROLL_STRATEGY_FACTORY_PROVIDER = {\n\tprovide: BRN_TOOLTIP_SCROLL_STRATEGY,\n\tdeps: [Overlay],\n\tuseFactory:\n\t\t(overlay: Overlay): (() => ScrollStrategy) =>\n\t\t() =>\n\t\t\toverlay.scrollStrategies.reposition({ scrollThrottle: SCROLL_THROTTLE_MS }),\n};\n\nexport function BRN_TOOLTIP_DEFAULT_OPTIONS_FACTORY(): BrnTooltipOptions {\n\treturn {\n\t\tshowDelay: 0,\n\t\thideDelay: 0,\n\t\ttouchendHideDelay: 1500,\n\t};\n}\n\nexport const BRN_TOOLTIP_DEFAULT_OPTIONS = new InjectionToken<BrnTooltipOptions>('mat-tooltip-default-options', {\n\tprovidedIn: 'root',\n\tfactory: BRN_TOOLTIP_DEFAULT_OPTIONS_FACTORY,\n});\n\nexport interface BrnTooltipOptions {\n\t/** Default delay when the tooltip is shown. */\n\tshowDelay: number;\n\t/** Default delay when the tooltip is hidden. */\n\thideDelay: number;\n\t/** Default delay when hiding the tooltip on a touch device. */\n\ttouchendHideDelay: number;\n\t/** Default touch gesture handling for tooltips. */\n\ttouchGestures?: TooltipTouchGestures;\n\t/** Default position for tooltips. */\n\tposition?: TooltipPosition;\n\t/**\n\t * Default value for whether tooltips should be positioned near the click or touch origin\n\t * instead of outside the element bounding box.\n\t */\n\tpositionAtOrigin?: boolean;\n\t/** Disables the ability for the user to interact with the tooltip element. */\n\tdisableTooltipInteractivity?: boolean;\n}\n\nconst PANEL_CLASS = 'tooltip-panel';\n\n/** Options used to bind passive event listeners. */\nconst passiveListenerOptions = normalizePassiveListenerOptions({ passive: true });\n\n/**\n * Time between the user putting the pointer on a tooltip\n * trigger and the long press event being fired.\n */\nconst LONGPRESS_DELAY = 500;\n\n// These constants were taken from MDC's `numbers` object.\nconst MIN_VIEWPORT_TOOLTIP_THRESHOLD = 8;\nconst UNBOUNDED_ANCHOR_GAP = 8;\n\n@Directive({\n\tselector: '[brnTooltipTrigger]',\n\tstandalone: true,\n\texportAs: 'brnTooltipTrigger',\n\tproviders: [BRN_TOOLTIP_SCROLL_STRATEGY_FACTORY_PROVIDER],\n\thost: {\n\t\tclass: 'brn-tooltip-trigger',\n\t\t'[class.brn-tooltip-disabled]': 'disabled',\n\t},\n})\nexport class BrnTooltipTriggerDirective implements OnDestroy, AfterViewInit {\n\tprivate readonly _tooltipDirective = inject(BrnTooltipDirective, { optional: true });\n\tprivate readonly _tooltipComponent = BrnTooltipContentComponent;\n\tprivate readonly _cssClassPrefix: string = 'brn';\n\tprivate readonly _destroyed = new Subject<void>();\n\tprivate readonly _passiveListeners: (readonly [string, EventListenerOrEventListenerObject])[] = [];\n\tprivate readonly _defaultOptions = inject(BRN_TOOLTIP_DEFAULT_OPTIONS, { optional: true });\n\tprivate readonly _overlay = inject(Overlay);\n\tprivate readonly _elementRef = inject(ElementRef<HTMLElement>);\n\tprivate readonly _scrollDispatcher = inject(ScrollDispatcher);\n\tprivate readonly _viewContainerRef = inject(ViewContainerRef);\n\tprivate readonly _ngZone = inject(NgZone);\n\tprivate readonly _platform = inject(Platform);\n\tprivate readonly _ariaDescriber = inject(AriaDescriber);\n\tprivate readonly _focusMonitor = inject(FocusMonitor);\n\tprivate readonly _dir = inject(Directionality);\n\tprivate readonly _scrollStrategy = inject(BRN_TOOLTIP_SCROLL_STRATEGY);\n\tprivate readonly _document = inject(DOCUMENT);\n\n\tprivate _portal?: ComponentPortal<BrnTooltipContentComponent>;\n\tprivate _viewInitialized = false;\n\tprivate _pointerExitEventsInitialized = false;\n\tprivate readonly _viewportMargin = 8;\n\tprivate _currentPosition?: TooltipPosition;\n\tprivate _touchstartTimeout?: ReturnType<typeof setTimeout>;\n\n\tprivate _overlayRef: OverlayRef | null = null;\n\tprivate _tooltipInstance: BrnTooltipContentComponent | null = null;\n\n\t/** Allows the user to define the position of the tooltip relative to the parent element */\n\tprivate readonly _position = signal<TooltipPosition>('above');\n\t@Input()\n\tpublic get position(): TooltipPosition {\n\t\treturn this._position();\n\t}\n\n\tpublic set position(value: TooltipPosition) {\n\t\tif (value !== this._position()) {\n\t\t\tthis._position.set(value);\n\n\t\t\tif (this._overlayRef) {\n\t\t\t\tthis._updatePosition(this._overlayRef);\n\t\t\t\tthis._tooltipInstance?.show(0);\n\t\t\t\tthis._overlayRef.updatePosition();\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Whether tooltip should be relative to the click or touch origin\n\t * instead of outside the element bounding box.\n\t */\n\tprivate readonly _positionAtOrigin = signal(false);\n\t@Input({ transform: booleanAttribute })\n\tpublic get positionAtOrigin(): boolean {\n\t\treturn this._positionAtOrigin();\n\t}\n\n\tpublic set positionAtOrigin(value: boolean) {\n\t\tthis._positionAtOrigin.set(value);\n\t\tthis._detach();\n\t\tthis._overlayRef = null;\n\t}\n\n\t/** Disables the display of the tooltip. */\n\tprivate readonly _disabled = signal(false);\n\t@Input({ transform: booleanAttribute, alias: 'brnTooltipDisabled' })\n\tpublic get disabled(): boolean {\n\t\treturn this._disabled();\n\t}\n\n\tpublic set disabled(value: boolean) {\n\t\tthis._disabled.set(value);\n\n\t\t// If tooltip is disabled, hide immediately.\n\t\tif (value) {\n\t\t\tthis.hide(0);\n\t\t} else {\n\t\t\tthis._setupPointerEnterEventsIfNeeded();\n\t\t}\n\t}\n\n\t/** The default delay in ms before showing the tooltip after show is called */\n\tprivate readonly _showDelay = signal(0);\n\t@Input({ transform: numberAttribute })\n\tpublic get showDelay(): number {\n\t\treturn this._showDelay();\n\t}\n\n\tpublic set showDelay(value: number) {\n\t\tthis._showDelay.set(value);\n\t}\n\n\t/** The default delay in ms before hiding the tooltip after hide is called */\n\tprivate readonly _hideDelay = signal(0);\n\t@Input({ transform: numberAttribute })\n\tpublic get hideDelay(): number {\n\t\treturn this._hideDelay();\n\t}\n\n\tpublic set hideDelay(value: number) {\n\t\tthis._hideDelay.set(value);\n\n\t\tif (this._tooltipInstance) {\n\t\t\tthis._tooltipInstance._mouseLeaveHideDelay = this._hideDelay();\n\t\t}\n\t}\n\n\t/** The default duration in ms that exit animation takes before hiding */\n\tprivate readonly _exitAnimationDuration = signal(0);\n\t@Input({ transform: numberAttribute })\n\tpublic get exitAnimationDuration(): number {\n\t\treturn this._exitAnimationDuration();\n\t}\n\n\tpublic set exitAnimationDuration(value: number) {\n\t\tthis._exitAnimationDuration.set(value);\n\n\t\tif (this._tooltipInstance) {\n\t\t\tthis._tooltipInstance._exitAnimationDuration = this._exitAnimationDuration();\n\t\t}\n\t}\n\n\t/** The default delay in ms before hiding the tooltip after hide is called */\n\tprivate readonly _tooltipContentClasses = signal('');\n\t@Input()\n\tpublic get tooltipContentClasses(): string {\n\t\treturn this._tooltipContentClasses();\n\t}\n\n\tpublic set tooltipContentClasses(value: string | null | undefined) {\n\t\tthis._tooltipContentClasses.set(value ?? '');\n\n\t\tif (this._tooltipInstance) {\n\t\t\tthis._tooltipInstance._tooltipClasses.set(value ?? '');\n\t\t}\n\t}\n\n\t/**\n\t * How touch gestures should be handled by the tooltip. On touch devices the tooltip directive\n\t * uses a long press gesture to show and hide, however it can conflict with the native browser\n\t * gestures. To work around the conflict, Angular Material disables native gestures on the\n\t * trigger, but that might not be desirable on particular elements (e.g. inputs and draggable\n\t * elements). The different values for this option configure the touch event handling as follows:\n\t * - `auto` - Enables touch gestures for all elements, but tries to avoid conflicts with native\n\t *   browser gestures on particular elements. In particular, it allows text selection on inputs\n\t *   and textareas, and preserves the native browser dragging on elements marked as `draggable`.\n\t * - `on` - Enables touch gestures for all elements and disables native\n\t *   browser gestures with no exceptions.\n\t * - `off` - Disables touch gestures. Note that this will prevent the tooltip from\n\t *   showing on touch devices.\n\t */\n\tprivate readonly _touchGestures = signal<TooltipTouchGestures>('auto');\n\t@Input()\n\tpublic set touchGestures(value: TooltipTouchGestures) {\n\t\tthis._touchGestures.set(value);\n\t}\n\n\tpublic get touchGestures() {\n\t\treturn this._touchGestures();\n\t}\n\n\t/** The message to be used to describe the aria in the tooltip */\n\tprivate _ariaDescribedBy = '';\n\t@Input('aria-describedby')\n\tpublic get ariaDescribedBy() {\n\t\treturn this._ariaDescribedBy;\n\t}\n\n\tpublic set ariaDescribedBy(value: string) {\n\t\tthis._ariaDescriber.removeDescription(this._elementRef.nativeElement, this._ariaDescribedBy, 'tooltip');\n\n\t\t// If the message is not a string (e.g. number), convert it to a string and trim it.\n\t\t// Must convert with `String(value)`, not `${value}`, otherwise Closure Compiler optimises\n\t\t// away the string-conversion: https://github.com/angular/components/issues/20684\n\t\tthis._ariaDescribedBy = value !== null ? String(value).trim() : '';\n\n\t\tif (this._ariaDescribedBy && !this._isTooltipVisible()) {\n\t\t\tthis._ngZone.runOutsideAngular(() => {\n\t\t\t\t// The `AriaDescriber` has some functionality that avoids adding a description if it's the\n\t\t\t\t// same as the `aria-label` of an element, however we can't know whether the tooltip trigger\n\t\t\t\t// has a data-bound `aria-label` or when it'll be set for the first time. We can avoid the\n\t\t\t\t// issue by deferring the description by a tick so Angular has time to set the `aria-label`.\n\t\t\t\tPromise.resolve().then(() => {\n\t\t\t\t\tthis._ariaDescriber.describe(this._elementRef.nativeElement, this._ariaDescribedBy, 'tooltip');\n\t\t\t\t});\n\t\t\t});\n\t\t}\n\t}\n\n\t/** The content to be displayed in the tooltip */\n\tprivate _content: string | TemplateRef<unknown> | null = null;\n\t@Input('brnTooltipTrigger')\n\tpublic get content() {\n\t\treturn this._content;\n\t}\n\n\tpublic set content(value: string | TemplateRef<unknown> | null) {\n\t\tthis._content = value;\n\n\t\tif (!this._content && this._isTooltipVisible()) {\n\t\t\tthis.hide(0);\n\t\t} else {\n\t\t\tthis._setupPointerEnterEventsIfNeeded();\n\t\t\tthis._updateTooltipContent();\n\t\t}\n\t}\n\n\tconstructor() {\n\t\tif (this._defaultOptions) {\n\t\t\tthis._showDelay.set(this._defaultOptions.showDelay);\n\t\t\tthis._hideDelay.set(this._defaultOptions.hideDelay);\n\n\t\t\tif (this._defaultOptions.position) {\n\t\t\t\tthis.position = this._defaultOptions.position;\n\t\t\t}\n\n\t\t\tif (this._defaultOptions.positionAtOrigin) {\n\t\t\t\tthis.positionAtOrigin = this._defaultOptions.positionAtOrigin;\n\t\t\t}\n\n\t\t\tif (this._defaultOptions.touchGestures) {\n\t\t\t\tthis.touchGestures = this._defaultOptions.touchGestures;\n\t\t\t}\n\t\t}\n\n\t\tthis._dir.change.pipe(takeUntil(this._destroyed)).subscribe(() => {\n\t\t\tif (this._overlayRef) {\n\t\t\t\tthis._updatePosition(this._overlayRef);\n\t\t\t}\n\t\t});\n\n\t\tthis._viewportMargin = MIN_VIEWPORT_TOOLTIP_THRESHOLD;\n\n\t\tif (this._tooltipDirective) {\n\t\t\teffect(() => {\n\t\t\t\tif (this._tooltipDirective) {\n\t\t\t\t\tthis.content = this._tooltipDirective.tooltipTemplate();\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t}\n\n\tngAfterViewInit() {\n\t\t// This needs to happen after view init so the initial values for all inputs have been set.\n\t\tthis._viewInitialized = true;\n\t\tthis._setupPointerEnterEventsIfNeeded();\n\n\t\tthis._focusMonitor\n\t\t\t.monitor(this._elementRef)\n\t\t\t.pipe(takeUntil(this._destroyed))\n\t\t\t.subscribe((origin) => {\n\t\t\t\t// Note that the focus monitor runs outside the Angular zone.\n\t\t\t\tif (!origin) {\n\t\t\t\t\tthis._ngZone.run(() => this.hide(0));\n\t\t\t\t} else if (origin === 'keyboard') {\n\t\t\t\t\tthis._ngZone.run(() => this.show());\n\t\t\t\t}\n\t\t\t});\n\n\t\tif (brnDevMode && !this._ariaDescribedBy) {\n\t\t\tconsole.warn('BrnTooltip: \"aria-describedby\" attribute is required for accessibility');\n\t\t}\n\t}\n\n\t/**\n\t * Dispose the tooltip when destroyed.\n\t */\n\tngOnDestroy() {\n\t\tconst nativeElement = this._elementRef.nativeElement;\n\n\t\tclearTimeout(this._touchstartTimeout);\n\n\t\tif (this._overlayRef) {\n\t\t\tthis._overlayRef.dispose();\n\t\t\tthis._tooltipInstance = null;\n\t\t}\n\n\t\t// Clean up the event listeners set in the constructor\n\t\tthis._passiveListeners.forEach(([event, listener]) =>\n\t\t\tnativeElement.removeEventListener(event, listener, passiveListenerOptions),\n\t\t);\n\t\tthis._passiveListeners.length = 0;\n\n\t\tthis._destroyed.next();\n\t\tthis._destroyed.complete();\n\n\t\tthis._ariaDescriber.removeDescription(nativeElement, this._ariaDescribedBy, 'tooltip');\n\t\tthis._focusMonitor.stopMonitoring(nativeElement);\n\t}\n\n\t/** Shows the tooltip after the delay in ms, defaults to tooltip-delay-show or 0ms if no input */\n\tshow(delay: number = this.showDelay, origin?: { x: number; y: number }): void {\n\t\tif (this.disabled || this._isTooltipVisible()) {\n\t\t\tthis._tooltipInstance?._cancelPendingAnimations();\n\t\t\treturn;\n\t\t}\n\n\t\tconst overlayRef = this._createOverlay(origin);\n\t\tthis._detach();\n\t\tthis._portal = this._portal || new ComponentPortal(this._tooltipComponent, this._viewContainerRef);\n\t\tconst instance = (this._tooltipInstance = overlayRef.attach(this._portal).instance);\n\t\tinstance._triggerElement = this._elementRef.nativeElement;\n\t\tinstance._mouseLeaveHideDelay = this._hideDelay();\n\t\tinstance._tooltipClasses.set(this._tooltipContentClasses());\n\t\tinstance._exitAnimationDuration = this._exitAnimationDuration();\n\t\tinstance.side.set(this._currentPosition ?? 'above');\n\t\tinstance.afterHidden.pipe(takeUntil(this._destroyed)).subscribe(() => this._detach());\n\t\tthis._updateTooltipContent();\n\t\tinstance.show(delay);\n\t}\n\n\t/** Hides the tooltip after the delay in ms, defaults to tooltip-delay-hide or 0ms if no input */\n\thide(delay: number = this.hideDelay, exitAnimationDuration: number = this.exitAnimationDuration): void {\n\t\tconst instance = this._tooltipInstance;\n\t\tif (instance) {\n\t\t\tif (instance.isVisible()) {\n\t\t\t\tinstance.hide(delay, exitAnimationDuration);\n\t\t\t} else {\n\t\t\t\tinstance._cancelPendingAnimations();\n\t\t\t\tthis._detach();\n\t\t\t}\n\t\t}\n\t}\n\n\ttoggle(origin?: { x: number; y: number }): void {\n\t\tthis._isTooltipVisible() ? this.hide() : this.show(undefined, origin);\n\t}\n\n\t_isTooltipVisible(): boolean {\n\t\treturn !!this._tooltipInstance && this._tooltipInstance.isVisible();\n\t}\n\n\tprivate _createOverlay(origin?: { x: number; y: number }): OverlayRef {\n\t\tif (this._overlayRef) {\n\t\t\tconst existingStrategy = this._overlayRef.getConfig().positionStrategy as FlexibleConnectedPositionStrategy;\n\n\t\t\tif ((!this.positionAtOrigin || !origin) && existingStrategy._origin instanceof ElementRef) {\n\t\t\t\treturn this._overlayRef;\n\t\t\t}\n\n\t\t\tthis._detach();\n\t\t}\n\n\t\tconst scrollableAncestors = this._scrollDispatcher.getAncestorScrollContainers(this._elementRef);\n\n\t\t// Create connected position strategy that listens for scroll events to reposition.\n\t\tconst strategy = this._overlay\n\t\t\t.position()\n\t\t\t.flexibleConnectedTo(this.positionAtOrigin ? origin || this._elementRef : this._elementRef)\n\t\t\t.withTransformOriginOn(`.${this._cssClassPrefix}-tooltip`)\n\t\t\t.withFlexibleDimensions(false)\n\t\t\t.withViewportMargin(this._viewportMargin)\n\t\t\t.withScrollableContainers(scrollableAncestors);\n\n\t\tstrategy.positionChanges.pipe(takeUntil(this._destroyed)).subscribe((change) => {\n\t\t\tthis._updateCurrentPositionClass(change.connectionPair);\n\n\t\t\tif (this._tooltipInstance) {\n\t\t\t\tif (change.scrollableViewProperties.isOverlayClipped && this._tooltipInstance.isVisible()) {\n\t\t\t\t\t// After position changes occur and the overlay is clipped by\n\t\t\t\t\t// a parent scrollable then close the tooltip.\n\t\t\t\t\tthis._ngZone.run(() => this.hide(0));\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\n\t\tthis._overlayRef = this._overlay.create({\n\t\t\tdirection: this._dir,\n\t\t\tpositionStrategy: strategy,\n\t\t\tpanelClass: `${this._cssClassPrefix}-${PANEL_CLASS}`,\n\t\t\tscrollStrategy: this._scrollStrategy(),\n\t\t});\n\n\t\tthis._updatePosition(this._overlayRef);\n\n\t\tthis._overlayRef\n\t\t\t.detachments()\n\t\t\t.pipe(takeUntil(this._destroyed))\n\t\t\t.subscribe(() => this._detach());\n\n\t\tthis._overlayRef\n\t\t\t.outsidePointerEvents()\n\t\t\t.pipe(takeUntil(this._destroyed))\n\t\t\t.subscribe(() => this._tooltipInstance?._handleBodyInteraction());\n\n\t\tthis._overlayRef\n\t\t\t.keydownEvents()\n\t\t\t.pipe(takeUntil(this._destroyed))\n\t\t\t.subscribe((event) => {\n\t\t\t\tif (this._isTooltipVisible() && event.key === 'Escape' && !hasModifierKey(event)) {\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t\tthis._ngZone.run(() => this.hide(0));\n\t\t\t\t}\n\t\t\t});\n\n\t\tif (this._defaultOptions?.disableTooltipInteractivity) {\n\t\t\tthis._overlayRef.addPanelClass(`${this._cssClassPrefix}-tooltip-panel-non-interactive`);\n\t\t}\n\n\t\treturn this._overlayRef;\n\t}\n\n\tprivate _detach() {\n\t\tif (this._overlayRef?.hasAttached()) {\n\t\t\tthis._overlayRef.detach();\n\t\t}\n\n\t\tthis._tooltipInstance = null;\n\t}\n\n\tprivate _updatePosition(overlayRef: OverlayRef) {\n\t\tconst position = overlayRef.getConfig().positionStrategy as FlexibleConnectedPositionStrategy;\n\t\tconst origin = this._getOrigin();\n\t\tconst overlay = this._getOverlayPosition();\n\n\t\tposition.withPositions([\n\t\t\tthis._addOffset({ ...origin.main, ...overlay.main }),\n\t\t\tthis._addOffset({ ...origin.fallback, ...overlay.fallback }),\n\t\t]);\n\t}\n\n\t/** Adds the configured offset to a position. Used as a hook for child classes. */\n\tprotected _addOffset(position: ConnectedPosition): ConnectedPosition {\n\t\tconst offset = UNBOUNDED_ANCHOR_GAP;\n\t\tconst isLtr = !this._dir || this._dir.value === 'ltr';\n\n\t\tif (position.originY === 'top') {\n\t\t\tposition.offsetY = -offset;\n\t\t} else if (position.originY === 'bottom') {\n\t\t\tposition.offsetY = offset;\n\t\t} else if (position.originX === 'start') {\n\t\t\tposition.offsetX = isLtr ? -offset : offset;\n\t\t} else if (position.originX === 'end') {\n\t\t\tposition.offsetX = isLtr ? offset : -offset;\n\t\t}\n\n\t\treturn position;\n\t}\n\n\t/**\n\t * Returns the origin position and a fallback position based on the user's position preference.\n\t * The fallback position is the inverse of the origin (e.g. `'below' -> 'above'`).\n\t */\n\t_getOrigin(): { main: OriginConnectionPosition; fallback: OriginConnectionPosition } {\n\t\tconst isLtr = !this._dir || this._dir.value === 'ltr';\n\t\tconst position = this.position;\n\t\tlet originPosition: OriginConnectionPosition;\n\n\t\tif (position === 'above' || position === 'below') {\n\t\t\toriginPosition = { originX: 'center', originY: position === 'above' ? 'top' : 'bottom' };\n\t\t} else if (position === 'before' || (position === 'left' && isLtr) || (position === 'right' && !isLtr)) {\n\t\t\toriginPosition = { originX: 'start', originY: 'center' };\n\t\t} else if (position === 'after' || (position === 'right' && isLtr) || (position === 'left' && !isLtr)) {\n\t\t\toriginPosition = { originX: 'end', originY: 'center' };\n\t\t} else if (typeof isDevMode() === 'undefined' || isDevMode()) {\n\t\t\tthrow getBrnTooltipInvalidPositionError(position);\n\t\t}\n\n\t\tconst { x, y } = this._invertPosition(originPosition!.originX, originPosition!.originY);\n\n\t\treturn {\n\t\t\tmain: originPosition!,\n\t\t\tfallback: { originX: x, originY: y },\n\t\t};\n\t}\n\n\t/** Returns the overlay position and a fallback position based on the user's preference */\n\t_getOverlayPosition(): { main: OverlayConnectionPosition; fallback: OverlayConnectionPosition } {\n\t\tconst isLtr = !this._dir || this._dir.value === 'ltr';\n\t\tconst position = this.position;\n\t\tlet overlayPosition: OverlayConnectionPosition;\n\n\t\tif (position === 'above') {\n\t\t\toverlayPosition = { overlayX: 'center', overlayY: 'bottom' };\n\t\t} else if (position === 'below') {\n\t\t\toverlayPosition = { overlayX: 'center', overlayY: 'top' };\n\t\t} else if (position === 'before' || (position === 'left' && isLtr) || (position === 'right' && !isLtr)) {\n\t\t\toverlayPosition = { overlayX: 'end', overlayY: 'center' };\n\t\t} else if (position === 'after' || (position === 'right' && isLtr) || (position === 'left' && !isLtr)) {\n\t\t\toverlayPosition = { overlayX: 'start', overlayY: 'center' };\n\t\t} else if (typeof isDevMode() === 'undefined' || isDevMode()) {\n\t\t\tthrow getBrnTooltipInvalidPositionError(position);\n\t\t}\n\n\t\tconst { x, y } = this._invertPosition(overlayPosition!.overlayX, overlayPosition!.overlayY);\n\n\t\treturn {\n\t\t\tmain: overlayPosition!,\n\t\t\tfallback: { overlayX: x, overlayY: y },\n\t\t};\n\t}\n\n\t/** Updates the tooltip message and repositions the overlay according to the new message length */\n\tprivate _updateTooltipContent() {\n\t\t// Must wait for the template to be painted to the tooltip so that the overlay can properly\n\t\t// calculate the correct positioning based on the size of the tek-pate.\n\t\tif (this._tooltipInstance) {\n\t\t\tthis._tooltipInstance.content = this.content;\n\t\t\tthis._tooltipInstance._markForCheck();\n\n\t\t\tthis._ngZone.onMicrotaskEmpty.pipe(take(1), takeUntil(this._destroyed)).subscribe(() => {\n\t\t\t\tif (this._tooltipInstance) {\n\t\t\t\t\tthis._overlayRef?.updatePosition();\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t}\n\n\t/** Inverts an overlay position. */\n\tprivate _invertPosition(x: HorizontalConnectionPos, y: VerticalConnectionPos) {\n\t\tif (this.position === 'above' || this.position === 'below') {\n\t\t\tif (y === 'top') {\n\t\t\t\ty = 'bottom';\n\t\t\t} else if (y === 'bottom') {\n\t\t\t\ty = 'top';\n\t\t\t}\n\t\t} else {\n\t\t\tif (x === 'end') {\n\t\t\t\tx = 'start';\n\t\t\t} else if (x === 'start') {\n\t\t\t\tx = 'end';\n\t\t\t}\n\t\t}\n\n\t\treturn { x, y };\n\t}\n\n\t/** Updates the class on the overlay panel based on the current position of the tooltip. */\n\tprivate _updateCurrentPositionClass(connectionPair: ConnectionPositionPair): void {\n\t\tconst { overlayY, originX, originY } = connectionPair;\n\t\tlet newPosition: TooltipPosition;\n\n\t\t// If the overlay is in the middle along the Y axis,\n\t\t// it means that it's either before or after.\n\t\tif (overlayY === 'center') {\n\t\t\t// Note that since this information is used for styling, we want to\n\t\t\t// resolve `start` and `end` to their real values, otherwise consumers\n\t\t\t// would have to remember to do it themselves on each consumption.\n\t\t\tif (this._dir && this._dir.value === 'rtl') {\n\t\t\t\tnewPosition = originX === 'end' ? 'left' : 'right';\n\t\t\t} else {\n\t\t\t\tnewPosition = originX === 'start' ? 'left' : 'right';\n\t\t\t}\n\t\t} else {\n\t\t\tnewPosition = overlayY === 'bottom' && originY === 'top' ? 'above' : 'below';\n\t\t}\n\n\t\tif (newPosition !== this._currentPosition) {\n\t\t\tthis._tooltipInstance?.side.set(newPosition);\n\t\t\tthis._currentPosition = newPosition;\n\t\t}\n\t}\n\n\t/** Binds the pointer events to the tooltip trigger. */\n\tprivate _setupPointerEnterEventsIfNeeded() {\n\t\t// Optimization: Defer hooking up events if there's no content or the tooltip is disabled.\n\t\tif (this._disabled() || !this.content || !this._viewInitialized || this._passiveListeners.length) {\n\t\t\treturn;\n\t\t}\n\n\t\t// The mouse events shouldn't be bound on mobile devices, because they can prevent the\n\t\t// first tap from firing its click event or can cause the tooltip to open for clicks.\n\t\tif (this._platformSupportsMouseEvents()) {\n\t\t\tthis._passiveListeners.push([\n\t\t\t\t'mouseenter',\n\t\t\t\t(event) => {\n\t\t\t\t\tthis._setupPointerExitEventsIfNeeded();\n\t\t\t\t\tlet point = undefined;\n\t\t\t\t\tif ((event as MouseEvent).x !== undefined && (event as MouseEvent).y !== undefined) {\n\t\t\t\t\t\tpoint = event as MouseEvent;\n\t\t\t\t\t}\n\t\t\t\t\tthis.show(undefined, point);\n\t\t\t\t},\n\t\t\t]);\n\t\t} else if (this.touchGestures !== 'off') {\n\t\t\tthis._disableNativeGesturesIfNecessary();\n\n\t\t\tthis._passiveListeners.push([\n\t\t\t\t'touchstart',\n\t\t\t\t(event) => {\n\t\t\t\t\tconst touch = (event as TouchEvent).targetTouches?.[0];\n\t\t\t\t\tconst origin = touch ? { x: touch.clientX, y: touch.clientY } : undefined;\n\t\t\t\t\t// Note that it's important that we don't `preventDefault` here,\n\t\t\t\t\t// because it can prevent click events from firing on the element.\n\t\t\t\t\tthis._setupPointerExitEventsIfNeeded();\n\t\t\t\t\tclearTimeout(this._touchstartTimeout);\n\t\t\t\t\tthis._touchstartTimeout = setTimeout(() => this.show(undefined, origin), LONGPRESS_DELAY);\n\t\t\t\t},\n\t\t\t]);\n\t\t}\n\n\t\tthis._addListeners(this._passiveListeners);\n\t}\n\n\tprivate _setupPointerExitEventsIfNeeded() {\n\t\tif (this._pointerExitEventsInitialized) {\n\t\t\treturn;\n\t\t}\n\t\tthis._pointerExitEventsInitialized = true;\n\n\t\tconst exitListeners: (readonly [string, EventListenerOrEventListenerObject])[] = [];\n\t\tif (this._platformSupportsMouseEvents()) {\n\t\t\texitListeners.push(\n\t\t\t\t[\n\t\t\t\t\t'mouseleave',\n\t\t\t\t\t(event) => {\n\t\t\t\t\t\tconst newTarget = (event as MouseEvent).relatedTarget as Node | null;\n\t\t\t\t\t\tif (!newTarget || !this._overlayRef?.overlayElement.contains(newTarget)) {\n\t\t\t\t\t\t\tthis.hide();\n\t\t\t\t\t\t}\n\t\t\t\t\t},\n\t\t\t\t],\n\t\t\t\t['wheel', (event) => this._wheelListener(event as WheelEvent)],\n\t\t\t);\n\t\t} else if (this.touchGestures !== 'off') {\n\t\t\tthis._disableNativeGesturesIfNecessary();\n\t\t\tconst touchendListener = () => {\n\t\t\t\tclearTimeout(this._touchstartTimeout);\n\t\t\t\tthis.hide(this._defaultOptions?.touchendHideDelay);\n\t\t\t};\n\n\t\t\texitListeners.push(['touchend', touchendListener], ['touchcancel', touchendListener]);\n\t\t}\n\n\t\tthis._addListeners(exitListeners);\n\t\tthis._passiveListeners.push(...exitListeners);\n\t}\n\n\tprivate _addListeners(listeners: (readonly [string, EventListenerOrEventListenerObject])[]) {\n\t\tlisteners.forEach(([event, listener]) => {\n\t\t\tthis._elementRef.nativeElement.addEventListener(event, listener, passiveListenerOptions);\n\t\t});\n\t}\n\n\tprivate _platformSupportsMouseEvents() {\n\t\treturn !this._platform.IOS && !this._platform.ANDROID;\n\t}\n\n\t/** Listener for the `wheel` event on the element. */\n\tprivate _wheelListener(event: WheelEvent) {\n\t\tif (this._isTooltipVisible()) {\n\t\t\tconst elementUnderPointer = this._document.elementFromPoint(event.clientX, event.clientY);\n\t\t\tconst element = this._elementRef.nativeElement;\n\n\t\t\t// On non-touch devices we depend on the `mouseleave` event to close the tooltip, but it\n\t\t\t// won't fire if the user scrolls away using the wheel without moving their cursor. We\n\t\t\t// work around it by finding the element under the user's cursor and closing the tooltip\n\t\t\t// if it's not the trigger.\n\t\t\tif (elementUnderPointer !== element && !element.contains(elementUnderPointer)) {\n\t\t\t\tthis.hide();\n\t\t\t}\n\t\t}\n\t}\n\n\t/** Disables the native browser gestures, based on how the tooltip has been configured. */\n\tprivate _disableNativeGesturesIfNecessary() {\n\t\tconst gestures = this.touchGestures;\n\n\t\tif (gestures !== 'off') {\n\t\t\tconst element = this._elementRef.nativeElement;\n\t\t\tconst style = element.style;\n\n\t\t\t// If gestures are set to `auto`, we don't disable text selection on inputs and\n\t\t\t// textareas, because it prevents the user from typing into them on iOS Safari.\n\t\t\tif (gestures === 'on' || (element.nodeName !== 'INPUT' && element.nodeName !== 'TEXTAREA')) {\n\t\t\t\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t\t\t\tstyle.userSelect = (style as any).msUserSelect = style.webkitUserSelect = (style as any).MozUserSelect = 'none';\n\t\t\t}\n\n\t\t\t// If we have `auto` gestures and the element uses native HTML dragging,\n\t\t\t// we don't set `-webkit-user-drag` because it prevents the native behavior.\n\t\t\tif (gestures === 'on' || !element.draggable) {\n\t\t\t\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t\t\t\t(style as any).webkitUserDrag = 'none';\n\t\t\t}\n\n\t\t\tstyle.touchAction = 'none';\n\t\t\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t\t\t(style as any).webkitTapHighlightColor = 'transparent';\n\t\t}\n\t}\n}\n"]}