@i-cell/ids-angular 0.1.0

package/fesm2022/i-cell-ids-angular-tooltip.mjs

@@ -0,0 +1,587 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, input, computed, Component, ViewEncapsulation, ChangeDetectionStrategy, inject, NgZone, ElementRef, ViewContainerRef, signal, effect, Directive } from '@angular/core';
+import { IdsSize, ComponentBase, DirectiveBaseWithDefaults, coerceStringAttribute } from '@i-cell/ids-angular/core';
+import { Subject } from 'rxjs';
+import { FocusMonitor } from '@angular/cdk/a11y';
+import { hasModifierKey } from '@angular/cdk/keycodes';
+import { Overlay } from '@angular/cdk/overlay';
+import { normalizePassiveListenerOptions, Platform } from '@angular/cdk/platform';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { ScrollDispatcher } from '@angular/cdk/scrolling';
+import { DOCUMENT } from '@angular/common';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+
+const IdsTooltipPosition = {
+    NORTH: 'north',
+    NORTHEAST: 'northeast',
+    EAST: 'east',
+    SOUTHEAST: 'southeast',
+    SOUTH: 'south',
+    SOUTHWEST: 'southwest',
+    WEST: 'west',
+    NORTHWEST: 'northwest',
+};
+
+const IdsTooltipVariant = {
+    LIGHT: 'light',
+    DARK: 'dark',
+};
+
+const DEFAULT_SHOW_DELAY = 1_000;
+const DEFAULT_HIDE_DELAY = 1_000;
+const DEFAULT_VIEWPORT_MARGIN = 8;
+const DEFAULT_LONGPRESS_DELAY = 500;
+const DEFAULT_TOUCHEND_HIDE_DELAY = 1500;
+const DEFAULT_SCROLL_DEBOUNCE_TIME = 20;
+const IDS_TOOLTIP_DEFAULT_CONFIG = new InjectionToken('IDS_TOOLTIP_DEFAULT_CONFIG', {
+    providedIn: 'root',
+    factory: IDS_TOOLTIP_DEFAULT_CONFIG_FACTORY,
+});
+function IDS_TOOLTIP_DEFAULT_CONFIG_FACTORY() {
+    return {
+        position: IdsTooltipPosition.NORTH,
+        size: IdsSize.COMPACT,
+        variant: IdsTooltipVariant.DARK,
+        showPointer: true,
+        showDelay: DEFAULT_SHOW_DELAY,
+        hideDelay: DEFAULT_HIDE_DELAY,
+        touchLongPressShowDelay: DEFAULT_LONGPRESS_DELAY,
+        viewPortMargin: DEFAULT_VIEWPORT_MARGIN,
+        touchendHideDelay: DEFAULT_TOUCHEND_HIDE_DELAY,
+        scrollDebounceTime: DEFAULT_SCROLL_DEBOUNCE_TIME,
+    };
+}
+
+function setTooltipFlexibleConnectedPositionStrategy(connectedTo, tooltipPosition) {
+    switch (tooltipPosition) {
+        case IdsTooltipPosition.NORTH:
+            return connectedTo.withPositions([
+                connectedPosition.north,
+                connectedPosition.northwest,
+                connectedPosition.northeast,
+                connectedPosition.south,
+                connectedPosition.southwest,
+                connectedPosition.southeast,
+            ]);
+        case IdsTooltipPosition.NORTHEAST:
+            return connectedTo.withPositions([
+                connectedPosition.northeast,
+                connectedPosition.southeast,
+                connectedPosition.northwest,
+                connectedPosition.southwest,
+            ]);
+        case IdsTooltipPosition.EAST:
+            return connectedTo.withPositions([
+                connectedPosition.east,
+                connectedPosition.northeast,
+                connectedPosition.southeast,
+                connectedPosition.west,
+                connectedPosition.northwest,
+                connectedPosition.southwest,
+            ]);
+        case IdsTooltipPosition.SOUTHEAST:
+            return connectedTo.withPositions([
+                connectedPosition.southeast,
+                connectedPosition.southwest,
+                connectedPosition.northeast,
+                connectedPosition.northwest,
+            ]);
+        case IdsTooltipPosition.SOUTH:
+            return connectedTo.withPositions([
+                connectedPosition.south,
+                connectedPosition.southwest,
+                connectedPosition.southeast,
+                connectedPosition.north,
+                connectedPosition.northwest,
+                connectedPosition.northeast,
+            ]);
+        case IdsTooltipPosition.SOUTHWEST:
+            return connectedTo.withPositions([
+                connectedPosition.southwest,
+                connectedPosition.northwest,
+                connectedPosition.southeast,
+                connectedPosition.northeast,
+            ]);
+        case IdsTooltipPosition.WEST:
+            return connectedTo.withPositions([
+                connectedPosition.west,
+                connectedPosition.northwest,
+                connectedPosition.southwest,
+                connectedPosition.east,
+                connectedPosition.northeast,
+                connectedPosition.southeast,
+            ]);
+        case IdsTooltipPosition.NORTHWEST:
+            return connectedTo.withPositions([
+                connectedPosition.northwest,
+                connectedPosition.southwest,
+                connectedPosition.northeast,
+                connectedPosition.southeast,
+            ]);
+    }
+}
+const connectedPosition = {
+    north: {
+        originX: 'center',
+        originY: 'top',
+        overlayX: 'center',
+        overlayY: 'bottom',
+    },
+    northeast: {
+        originX: 'end',
+        originY: 'top',
+        overlayX: 'start',
+        overlayY: 'bottom',
+    },
+    east: {
+        originX: 'end',
+        originY: 'center',
+        overlayX: 'start',
+        overlayY: 'center',
+    },
+    southeast: {
+        originX: 'end',
+        originY: 'bottom',
+        overlayX: 'start',
+        overlayY: 'top',
+    },
+    south: {
+        originX: 'center',
+        originY: 'bottom',
+        overlayX: 'center',
+        overlayY: 'top',
+    },
+    southwest: {
+        originX: 'start',
+        originY: 'bottom',
+        overlayX: 'end',
+        overlayY: 'top',
+    },
+    west: {
+        originX: 'start',
+        originY: 'center',
+        overlayX: 'end',
+        overlayY: 'center',
+    },
+    northwest: {
+        originX: 'start',
+        originY: 'top',
+        overlayX: 'end',
+        overlayY: 'bottom',
+    },
+};
+
+class IdsTooltipComponent extends ComponentBase {
+    constructor() {
+        super(...arguments);
+        this._onHide = new Subject();
+        this.message = input();
+        this.position = input();
+        this.size = input();
+        this.variant = input();
+        this.textAlign = input();
+        this.mouseLeaveHideDelay = input(0);
+        this.tooltipClass = input();
+        this.showPointer = input();
+        this._hostClasses = computed(() => this._getHostClasses([
+            this.size(),
+            this.variant(),
+            [
+                'position',
+                this.position(),
+            ],
+            [
+                'text-align',
+                this.textAlign(),
+            ],
+            this.showPointer() ? 'pointered' : null,
+        ]));
+    }
+    get _hostName() {
+        return 'tooltip';
+    }
+    get isHideTimerTicking() {
+        return Boolean(this._hideTimeout);
+    }
+    hide(delay) {
+        this._hideTimeout = setTimeout(() => {
+            this._hideTimeout = undefined;
+            this._onHide.next();
+        }, delay);
+    }
+    afterHidden() {
+        return this._onHide;
+    }
+    abortHide() {
+        clearTimeout(this._hideTimeout);
+        this._hideTimeout = undefined;
+    }
+    _handleMouseEnter() {
+        if (this._hideTimeout) {
+            this.abortHide();
+        }
+    }
+    _handleMouseLeave({ relatedTarget }) {
+        if (!relatedTarget || !this.triggerElement?.contains(relatedTarget)) {
+            this.hide(this.mouseLeaveHideDelay());
+        }
+    }
+    ngOnDestroy() {
+        this._onHide.complete();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.2", ngImport: i0, type: IdsTooltipComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "19.1.2", type: IdsTooltipComponent, isStandalone: true, selector: "ids-tooltip", inputs: { message: { classPropertyName: "message", publicName: "message", isSignal: true, isRequired: false, transformFunction: null }, position: { classPropertyName: "position", publicName: "position", isSignal: true, isRequired: false, transformFunction: null }, size: { classPropertyName: "size", publicName: "size", isSignal: true, isRequired: false, transformFunction: null }, variant: { classPropertyName: "variant", publicName: "variant", isSignal: true, isRequired: false, transformFunction: null }, textAlign: { classPropertyName: "textAlign", publicName: "textAlign", isSignal: true, isRequired: false, transformFunction: null }, mouseLeaveHideDelay: { classPropertyName: "mouseLeaveHideDelay", publicName: "mouseLeaveHideDelay", isSignal: true, isRequired: false, transformFunction: null }, tooltipClass: { classPropertyName: "tooltipClass", publicName: "tooltipClass", isSignal: true, isRequired: false, transformFunction: null }, showPointer: { classPropertyName: "showPointer", publicName: "showPointer", isSignal: true, isRequired: false, transformFunction: null } }, host: { attributes: { "aria-hidden": "true" }, listeners: { "mouseenter": "_handleMouseEnter()", "mouseleave": "_handleMouseLeave($event)" }, properties: { "class": "tooltipClass()" } }, usesInheritance: true, ngImport: i0, template: "<div class=\"ids-tooltip__content\">\n  <span>{{ message() }}</span>\n</div>\n", changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.2", ngImport: i0, type: IdsTooltipComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ids-tooltip', imports: [], encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, host: {
+                        '(mouseenter)': '_handleMouseEnter()',
+                        '(mouseleave)': '_handleMouseLeave($event)',
+                        'aria-hidden': 'true',
+                        '[class]': 'tooltipClass()',
+                    }, template: "<div class=\"ids-tooltip__content\">\n  <span>{{ message() }}</span>\n</div>\n" }]
+        }] });
+
+function connectedPositionPairToTooltipPosition(positionPair) {
+    const { originX, originY, overlayX, overlayY } = positionPair;
+    if (originX === 'center' &&
+        originY === 'top' &&
+        overlayX === 'center' &&
+        overlayY === 'bottom') {
+        return IdsTooltipPosition.NORTH;
+    }
+    if (originX === 'end' &&
+        originY === 'top' &&
+        overlayX === 'start' &&
+        overlayY === 'bottom') {
+        return IdsTooltipPosition.NORTHEAST;
+    }
+    if (originX === 'end' &&
+        originY === 'center' &&
+        overlayX === 'start' &&
+        overlayY === 'center') {
+        return IdsTooltipPosition.EAST;
+    }
+    if (originX === 'end' &&
+        originY === 'bottom' &&
+        overlayX === 'start' &&
+        overlayY === 'top') {
+        return IdsTooltipPosition.SOUTHEAST;
+    }
+    if (originX === 'center' &&
+        originY === 'bottom' &&
+        overlayX === 'center' &&
+        overlayY === 'top') {
+        return IdsTooltipPosition.SOUTH;
+    }
+    if (originX === 'start' &&
+        originY === 'bottom' &&
+        overlayX === 'end' &&
+        overlayY === 'top') {
+        return IdsTooltipPosition.SOUTHWEST;
+    }
+    if (originX === 'start' &&
+        originY === 'center' &&
+        overlayX === 'end' &&
+        overlayY === 'center') {
+        return IdsTooltipPosition.WEST;
+    }
+    if (originX === 'start' &&
+        originY === 'top' &&
+        overlayX === 'end' &&
+        overlayY === 'bottom') {
+        return IdsTooltipPosition.NORTHWEST;
+    }
+    return IdsTooltipPosition.EAST;
+}
+
+const defaultConfig = IDS_TOOLTIP_DEFAULT_CONFIG_FACTORY();
+const passiveListenerOptions = normalizePassiveListenerOptions({ passive: true });
+class IdsTooltipDirective extends DirectiveBaseWithDefaults {
+    constructor() {
+        super(...arguments);
+        this._focusMonitor = inject(FocusMonitor);
+        this._platform = inject(Platform);
+        this._ngZone = inject(NgZone);
+        this._elementRef = inject((ElementRef));
+        this._viewContainerRef = inject(ViewContainerRef);
+        this._scrollDispatcher = inject(ScrollDispatcher);
+        this._overlay = inject(Overlay);
+        this._document = inject(DOCUMENT);
+        this._defaultConfig = this._getDefaultConfig(defaultConfig, IDS_TOOLTIP_DEFAULT_CONFIG);
+        this._passiveListeners = [];
+        this._overlayRef = null;
+        this._tooltipInstance = null;
+        this._pointerExitEventsInitialized = false;
+        this._viewportMargin = this._defaultConfig.viewPortMargin;
+        this._currentPosition = signal(null);
+        this.message = input('', { alias: 'idsTooltip', transform: coerceStringAttribute });
+        this.position = input(this._defaultConfig.position, { alias: 'idsTooltipPosition' });
+        this.size = input(this._defaultConfig.size, { alias: 'idsTooltipSize' });
+        this.variant = input(this._defaultConfig.variant, { alias: 'idsTooltipVariant' });
+        this.showDelay = input(this._defaultConfig.showDelay, { alias: 'idsTooltipShowDelay' });
+        this.hideDelay = input(this._defaultConfig.hideDelay, { alias: 'idsTooltipHideDelay' });
+        this.disabled = input(false, { alias: 'idsTooltipDisabled' });
+        this.touchGestures = input('auto', { alias: 'idsTooltipTouchGestures' });
+        this.textAlign = input('auto', { alias: 'idsTooltipTextAlign' });
+        this.tooltipClass = input(undefined, { alias: 'idsTooltipClass' });
+        this.showPointer = input(this._defaultConfig.showPointer, { alias: 'idsTooltipShowPointer' });
+        this._hostClasses = computed(() => this._getHostClasses([]));
+        this._tooltipClassEffect = effect(() => {
+            this._setTooltipInputs(this.message(), this._currentPosition() ?? this.position(), this.size(), this.variant(), this.textAlign(), this.hideDelay(), this.tooltipClass(), this.showPointer());
+        });
+    }
+    get _hostName() {
+        return 'tooltip-trigger';
+    }
+    ngAfterViewInit() {
+        this._setupPointerEnterEventsIfNeeded();
+        this._focusMonitor
+            .monitor(this._elementRef)
+            .pipe(takeUntilDestroyed(this._destroyRef))
+            .subscribe((origin) => {
+            if (!origin) {
+                this._ngZone.run(() => this.hide(0));
+            }
+            else if (origin === 'keyboard') {
+                this._ngZone.run(() => this.show());
+            }
+        });
+    }
+    show() {
+        if (this.disabled() || !this.message() || this._tooltipInstance) {
+            this._tooltipInstance?.abortHide();
+            return;
+        }
+        const overlayRef = this._createOverlay();
+        this._portal =
+            this._portal || new ComponentPortal(IdsTooltipComponent, this._viewContainerRef);
+        this._componentRef = overlayRef.attach(this._portal);
+        this._tooltipInstance = this._componentRef.instance;
+        const instance = this._tooltipInstance;
+        instance.triggerElement = this._elementRef.nativeElement;
+        this._setTooltipInputs(this.message(), this._currentPosition() ?? this.position(), this.size(), this.variant(), this.textAlign(), this.hideDelay(), this.tooltipClass(), this.showPointer());
+        instance
+            .afterHidden()
+            .pipe(takeUntilDestroyed(this._destroyRef))
+            .subscribe(() => {
+            this._detach();
+        });
+    }
+    hide(delay = this.hideDelay()) {
+        if (this._showTimeout) {
+            clearTimeout(this._showTimeout);
+            this._showTimeout = undefined;
+            return;
+        }
+        const instance = this._tooltipInstance;
+        if (instance?.isHideTimerTicking) {
+            return;
+        }
+        if (instance) {
+            instance.hide(delay);
+        }
+    }
+    toggle() {
+        this._tooltipInstance ? this.hide() : this.show();
+    }
+    _createOverlay() {
+        if (this._overlayRef) {
+            this._detach();
+        }
+        const scrollableAncestors = this._scrollDispatcher.getAncestorScrollContainers(this._elementRef);
+        const strategy = this._overlay
+            .position()
+            .flexibleConnectedTo(this._elementRef)
+            .withFlexibleDimensions(false)
+            .withViewportMargin(this._viewportMargin)
+            .withScrollableContainers(scrollableAncestors);
+        strategy.positionChanges.pipe(takeUntilDestroyed(this._destroyRef)).subscribe((change) => {
+            this._updateCurrentPositionClass(change.connectionPair);
+            if (change.scrollableViewProperties.isOverlayClipped && this._tooltipInstance) {
+                this._ngZone.run(() => this.hide(0));
+            }
+        });
+        this._overlayRef = this._overlay.create({
+            positionStrategy: strategy,
+            panelClass: 'ids-tooltip-panel',
+            scrollStrategy: this._overlay.scrollStrategies.reposition({ scrollThrottle: this._defaultConfig.scrollDebounceTime }),
+        });
+        this._updatePosition(this._overlayRef);
+        this._overlayRef
+            .detachments()
+            .pipe(takeUntilDestroyed(this._destroyRef))
+            .subscribe(() => this._detach());
+        this._overlayRef
+            .outsidePointerEvents()
+            .pipe(takeUntilDestroyed(this._destroyRef))
+            .subscribe(() => this._tooltipInstance?.hide(0));
+        this._overlayRef
+            .keydownEvents()
+            .pipe(takeUntilDestroyed(this._destroyRef))
+            .subscribe((event) => {
+            if (this._tooltipInstance && event.key === 'Escape' && !hasModifierKey(event)) {
+                event.preventDefault();
+                event.stopPropagation();
+                this._ngZone.run(() => this.hide(0));
+            }
+        });
+        return this._overlayRef;
+    }
+    _detach() {
+        if (this._overlayRef && this._overlayRef.hasAttached()) {
+            this._overlayRef.detach();
+        }
+        this._componentRef?.destroy();
+        this._tooltipInstance = null;
+    }
+    _updatePosition(overlayRef) {
+        const position = overlayRef.getConfig().positionStrategy;
+        setTooltipFlexibleConnectedPositionStrategy(position, this.position());
+    }
+    _updateCurrentPositionClass(connectionPair) {
+        const newPosition = connectedPositionPairToTooltipPosition(connectionPair);
+        if (newPosition !== this._currentPosition()) {
+            const overlayRef = this._overlayRef;
+            if (overlayRef) {
+                const positionClassPrefix = 'is-tooltip-panel-position-';
+                overlayRef.removePanelClass(positionClassPrefix + this._currentPosition());
+                overlayRef.addPanelClass(positionClassPrefix + newPosition);
+            }
+            this._currentPosition.set(newPosition);
+        }
+    }
+    _setTooltipInputs(message, position, size, variant, textAlign, hideDelay, tooltipClass, showPointer) {
+        if (this._tooltipInstance) {
+            this._componentRef?.setInput('message', message);
+            this._componentRef?.setInput('position', position);
+            this._componentRef?.setInput('size', size);
+            this._componentRef?.setInput('variant', variant);
+            this._componentRef?.setInput('textAlign', textAlign);
+            this._componentRef?.setInput('mouseLeaveHideDelay', hideDelay);
+            this._componentRef?.setInput('tooltipClass', tooltipClass);
+            this._componentRef?.setInput('showPointer', showPointer);
+        }
+    }
+    _setupPointerEnterEventsIfNeeded() {
+        if (this.disabled() || !this.message() || this._passiveListeners.length) {
+            return;
+        }
+        if (this._platformSupportsMouseEvents()) {
+            this._passiveListeners.push([
+                'mouseenter',
+                () => {
+                    this._setupPointerExitEventsIfNeeded();
+                    this._showTimeout = setTimeout(() => {
+                        this._showTimeout = undefined;
+                        this.show();
+                    }, this.showDelay());
+                },
+            ]);
+        }
+        else if (this.touchGestures() !== 'off') {
+            this._disableNativeGesturesIfNecessary();
+            this._passiveListeners.push([
+                'touchstart',
+                () => {
+                    this._setupPointerExitEventsIfNeeded();
+                    clearTimeout(this._touchstartTimeout);
+                    this._touchstartTimeout = setTimeout(() => this.show(), this._defaultConfig.touchLongPressShowDelay);
+                },
+            ]);
+        }
+        this._addListeners(this._passiveListeners);
+    }
+    _wheelListener(event) {
+        if (this._tooltipInstance) {
+            const elementUnderPointer = this._document.elementFromPoint(event.clientX, event.clientY);
+            const element = this._elementRef.nativeElement;
+            if (elementUnderPointer !== element && !element.contains(elementUnderPointer)) {
+                this.hide();
+            }
+        }
+    }
+    _setupPointerExitEventsIfNeeded() {
+        if (this._pointerExitEventsInitialized) {
+            return;
+        }
+        this._pointerExitEventsInitialized = true;
+        const exitListeners = [];
+        if (this._platformSupportsMouseEvents()) {
+            exitListeners.push([
+                'mouseleave',
+                () => {
+                    this.hide();
+                },
+            ], [
+                'wheel',
+                (event) => {
+                    this._wheelListener(event);
+                },
+            ]);
+        }
+        else if (this.touchGestures() !== 'off') {
+            this._disableNativeGesturesIfNecessary();
+            const touchendListener = () => {
+                clearTimeout(this._touchstartTimeout);
+                this.hide(this._defaultConfig.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);
+        });
+    }
+    _disableNativeGesturesIfNecessary() {
+        const gestures = this.touchGestures();
+        if (gestures !== 'off') {
+            const element = this._elementRef.nativeElement;
+            const style = element.style;
+            if (gestures === 'on' || (element.nodeName !== 'INPUT' && element.nodeName !== 'TEXTAREA')) {
+                style.userSelect = 'none';
+            }
+            style.touchAction = 'none';
+        }
+    }
+    _platformSupportsMouseEvents() {
+        return !this._platform.IOS && !this._platform.ANDROID;
+    }
+    ngOnDestroy() {
+        const nativeElement = this._elementRef.nativeElement;
+        clearTimeout(this._touchstartTimeout);
+        if (this._componentRef) {
+            this._tooltipInstance = null;
+        }
+        this._passiveListeners.forEach(([event, listener,]) => {
+            nativeElement.removeEventListener(event, listener, passiveListenerOptions);
+        });
+        this._passiveListeners.length = 0;
+        this._focusMonitor.stopMonitoring(nativeElement);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.2", ngImport: i0, type: IdsTooltipDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "19.1.2", type: IdsTooltipDirective, isStandalone: true, selector: "[idsTooltip]", inputs: { message: { classPropertyName: "message", publicName: "idsTooltip", isSignal: true, isRequired: false, transformFunction: null }, position: { classPropertyName: "position", publicName: "idsTooltipPosition", isSignal: true, isRequired: false, transformFunction: null }, size: { classPropertyName: "size", publicName: "idsTooltipSize", isSignal: true, isRequired: false, transformFunction: null }, variant: { classPropertyName: "variant", publicName: "idsTooltipVariant", isSignal: true, isRequired: false, transformFunction: null }, showDelay: { classPropertyName: "showDelay", publicName: "idsTooltipShowDelay", isSignal: true, isRequired: false, transformFunction: null }, hideDelay: { classPropertyName: "hideDelay", publicName: "idsTooltipHideDelay", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "idsTooltipDisabled", isSignal: true, isRequired: false, transformFunction: null }, touchGestures: { classPropertyName: "touchGestures", publicName: "idsTooltipTouchGestures", isSignal: true, isRequired: false, transformFunction: null }, textAlign: { classPropertyName: "textAlign", publicName: "idsTooltipTextAlign", isSignal: true, isRequired: false, transformFunction: null }, tooltipClass: { classPropertyName: "tooltipClass", publicName: "idsTooltipClass", isSignal: true, isRequired: false, transformFunction: null }, showPointer: { classPropertyName: "showPointer", publicName: "idsTooltipShowPointer", isSignal: true, isRequired: false, transformFunction: null } }, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.2", ngImport: i0, type: IdsTooltipDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[idsTooltip]',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { IDS_TOOLTIP_DEFAULT_CONFIG, IDS_TOOLTIP_DEFAULT_CONFIG_FACTORY, IdsTooltipDirective, IdsTooltipPosition, IdsTooltipVariant };
+//# sourceMappingURL=i-cell-ids-angular-tooltip.mjs.map