@alauda/ui 6.5.10-beta.2 → 6.5.10-beta.4

package/esm2020/tooltip/base-tooltip.mjs

@@ -0,0 +1,322 @@
+import { OverlayConfig, } from '@angular/cdk/overlay';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { Directive, EventEmitter, } from '@angular/core';
+import { ReplaySubject, merge, debounceTime, takeUntil, first, filter, Subject, delay, } from 'rxjs';
+import { sleep } from '../utils';
+import { TooltipComponent } from './tooltip.component';
+import { TooltipTrigger } from './tooltip.types';
+import { getOriginPosition, getOverlayPosition } from './utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+export const DISPLAY_DELAY = 50;
+export const HIDDEN_DELAY = 150;
+export class BaseTooltip {
+    constructor(overlay, viewContainerRef, elRef, renderer, cdr, ngZone) {
+        this.overlay = overlay;
+        this.viewContainerRef = viewContainerRef;
+        this.elRef = elRef;
+        this.renderer = renderer;
+        this.cdr = cdr;
+        this.ngZone = ngZone;
+        this.hideOnClick = false;
+        this.disableAnimation = true;
+        this.visibleChange = new EventEmitter();
+        this.componentClass = TooltipComponent;
+        this.hostHovered = false;
+        this.tooltipHovered = false;
+        this.listeners = [];
+        this.inputContent$$ = new ReplaySubject(1);
+        this.inputType$$ = new ReplaySubject(1);
+        this.inputPosition$$ = new ReplaySubject(1);
+        this.inputClass$$ = new ReplaySubject(1);
+        this.inputContext$$ = new ReplaySubject(1);
+        this.tooltipChanged$ = merge(this.inputContent$$, this.inputType$$, this.inputPosition$$, this.inputClass$$, this.inputContext$$);
+        this.destroy$ = new Subject();
+        this._position = 'top';
+        this._trigger = TooltipTrigger.Hover;
+        this._disabled = false;
+        this.tooltipChanged$.pipe(debounceTime(0)).subscribe(() => {
+            this.updatePosition();
+        });
+    }
+    set content(value) {
+        this._content = value;
+        this.inputContent$$.next(value);
+    }
+    get content() {
+        return this._content;
+    }
+    set context(value) {
+        this._context = value;
+        this.inputContext$$.next(value);
+    }
+    get context() {
+        return this._context;
+    }
+    set class(value) {
+        this.inputClass$$.next(value);
+    }
+    set type(value) {
+        if (!value) {
+            return;
+        }
+        this.inputType$$.next(value);
+    }
+    set position(value) {
+        if (!value || value === this._position) {
+            return;
+        }
+        this._position = value;
+        this.inputPosition$$.next(value);
+        this._disposeTooltip();
+    }
+    get position() {
+        return this._position;
+    }
+    set trigger(value) {
+        if (!value || value === this._trigger) {
+            return;
+        }
+        this._trigger = value;
+        this._disposeTooltip();
+        this.ngZone.run(this.updateListeners, this);
+    }
+    get trigger() {
+        return this._trigger;
+    }
+    set disabled(value) {
+        this._disabled = value;
+        if (value) {
+            this._disposeTooltip();
+        }
+    }
+    get disabled() {
+        return this._disabled;
+    }
+    get isCreated() {
+        return !!this.overlayRef;
+    }
+    _updateTransformOrigin() {
+        // @ts-ignore
+        const overlayRef = this.overlayRef;
+        const positionStrategy = overlayRef._positionStrategy;
+        const hasExactPosition = positionStrategy._hasExactPosition(); // 是不是应用了精确定位
+        if (!hasExactPosition) {
+            return;
+        }
+        // 如果是精确定位，也就是预设位置空间不足以承载弹出元素，被重新指定新的弹出位置
+        const paneRect = positionStrategy._pane.getBoundingClientRect(); // 弹出pane元素Rect
+        const triggerElReact = this.elRef.nativeElement.getBoundingClientRect(); // 触发点Rect
+        const position = positionStrategy._lastPosition; // 当前策略位置（调整后的最佳的）
+        let xOrigin;
+        const yOrigin = position.overlayY;
+        if (position.overlayX === 'center') {
+            xOrigin = 'center';
+        }
+        else {
+            xOrigin = position.overlayX === 'start' ? 'left' : 'right';
+        }
+        const origins = [xOrigin, yOrigin];
+        if (xOrigin === 'center' ||
+            (xOrigin === 'left' &&
+                ![triggerElReact.right, triggerElReact.left].includes(paneRect.left)) ||
+            (xOrigin === 'right' &&
+                ![triggerElReact.right, triggerElReact.left].includes(paneRect.right))) {
+            const originLeft = triggerElReact.left - paneRect.left + triggerElReact.width / 2;
+            origins[0] = Math.min(originLeft, paneRect.width) + 'px';
+        }
+        if (yOrigin === 'center' ||
+            (yOrigin === 'top' &&
+                ![triggerElReact.bottom, triggerElReact.top].includes(paneRect.top)) || // 位置没有被完全被颠倒的
+            (yOrigin === 'bottom' &&
+                ![triggerElReact.bottom, triggerElReact.top].includes(paneRect.bottom)) // 位置没有被完全被颠倒的
+        ) {
+            const originTop = triggerElReact.top - paneRect.top + triggerElReact.height / 2;
+            origins[1] = Math.min(originTop, paneRect.height) + 'px';
+        }
+        const aniEls = positionStrategy._boundingBox.querySelectorAll(positionStrategy._transformOriginSelector);
+        Array.from(aniEls).forEach(el => {
+            el.style.transformOrigin = origins.join(' ');
+        });
+    }
+    _createTooltip() {
+        if (this.disabled || this.isCreated) {
+            return;
+        }
+        this._disposeTooltip();
+        this.overlayRef = this.createOverlay();
+        const portal = new ComponentPortal(this.componentClass, this.viewContainerRef);
+        this.componentIns = this.overlayRef.attach(portal).instance;
+        this.componentIns.setupInputs({
+            inputClass$: this.inputClass$$.asObservable(),
+            inputContent$: this.inputContent$$.asObservable(),
+            inputContext$: this.inputContext$$.asObservable(),
+            inputPosition$: this.inputPosition$$.asObservable(),
+            inputType$: this.inputType$$.asObservable(),
+            disableAnimation: this.disableAnimation,
+        });
+        this.componentIns.hide$.pipe(takeUntil(this.destroy$)).subscribe(() => {
+            this._disposeTooltip();
+        });
+        if (!this.disableAnimation) {
+            merge(this.componentIns.beforeHide$, this.componentIns.beforeShow$.pipe(delay(0)))
+                .pipe(takeUntil(this.destroy$))
+                .subscribe(this._updateTransformOrigin.bind(this));
+        }
+        if (this.trigger === TooltipTrigger.Hover) {
+            this.componentIns.hover$
+                .pipe(takeUntil(this.componentIns.destroy$))
+                .subscribe(hovered => {
+                this.onTooltipHovered(hovered);
+            });
+        }
+        if (this.trigger === TooltipTrigger.Hover ||
+            this.trigger === TooltipTrigger.Click) {
+            this.unlistenBody = this.renderer.listen('body', 'click', this.onBodyClick.bind(this));
+        }
+        this.componentIns?.show();
+        this.cdr.markForCheck();
+        this.visibleChange.emit(true);
+    }
+    _disposeTooltip() {
+        this.componentIns?.animating$$
+            .pipe(filter(animating => !animating), first())
+            .subscribe(() => {
+            if (this.overlayRef) {
+                this.overlayRef.dispose();
+                this.overlayRef = null;
+                this.componentIns = null;
+                this.tooltipHovered = false;
+                if (this.unlistenBody) {
+                    this.unlistenBody();
+                    this.unlistenBody = null;
+                }
+                this.visibleChange.emit(false);
+            }
+        });
+    }
+    toggleTooltip() {
+        if (this.isCreated) {
+            this.hide();
+        }
+        else {
+            this.show();
+        }
+    }
+    show() {
+        this._createTooltip();
+    }
+    hide() {
+        if (this.disableAnimation) {
+            // 如果禁用了动画就立即销毁，而不是等动画完成事件后才销毁
+            this._disposeTooltip();
+        }
+        else {
+            this.componentIns?.hide();
+        }
+    }
+    updatePosition() {
+        if (this.overlayRef) {
+            this.overlayRef.updatePosition();
+        }
+    }
+    ngAfterViewInit() {
+        if (this.trigger === TooltipTrigger.Hover) {
+            this.updateListeners();
+        }
+    }
+    ngOnDestroy() {
+        this.destroy$.next(null);
+        this.destroy$.complete();
+        this._disposeTooltip();
+        this.clearListeners();
+    }
+    updateListeners() {
+        this.clearListeners();
+        switch (this.trigger) {
+            case TooltipTrigger.Click:
+                this.listeners.push(this.renderer.listen(this.elRef.nativeElement, 'click', this.onClick.bind(this)));
+                break;
+            case TooltipTrigger.Hover:
+                this.listeners.push(this.renderer.listen(this.elRef.nativeElement, 'mouseenter', this.onMouseEnter.bind(this)), this.renderer.listen(this.elRef.nativeElement, 'mouseleave', this.onMouseLeave.bind(this)));
+                break;
+            case TooltipTrigger.Focus:
+                this.listeners.push(this.renderer.listen(this.elRef.nativeElement, 'focus', this.onFocus.bind(this)), this.renderer.listen(this.elRef.nativeElement, 'blur', this.onBlur.bind(this)));
+                break;
+            case TooltipTrigger.Manual:
+                break;
+        }
+    }
+    clearListeners() {
+        this.listeners.forEach(unListen => {
+            unListen();
+        });
+        this.listeners = [];
+    }
+    createOverlay() {
+        const originPosition = getOriginPosition(this.position);
+        const overlayPosition = getOverlayPosition(this.position);
+        const positionStrategy = this.overlay
+            .position()
+            .flexibleConnectedTo(this.elRef)
+            .withGrowAfterOpen(true)
+            .withTransformOriginOn('.aui-tooltip')
+            .withPositions([
+            { ...originPosition.main, ...overlayPosition.main },
+            { ...originPosition.fallback, ...overlayPosition.fallback },
+        ]);
+        const scrollStrategy = this.overlay.scrollStrategies.reposition();
+        const config = new OverlayConfig({
+            positionStrategy,
+            scrollStrategy,
+        });
+        return this.overlay.create(config);
+    }
+    async onMouseEnter() {
+        this.hostHovered = true;
+        if (!this.isCreated) {
+            await sleep(DISPLAY_DELAY);
+            if (this.hostHovered) {
+                this._createTooltip();
+            }
+        }
+    }
+    async onMouseLeave() {
+        this.hostHovered = false;
+        await sleep(HIDDEN_DELAY);
+        if (!this.tooltipHovered && !this.hostHovered) {
+            this.hide();
+        }
+    }
+    async onTooltipHovered(hovered) {
+        this.tooltipHovered = hovered;
+        if (!hovered) {
+            await sleep(HIDDEN_DELAY);
+            if (!this.tooltipHovered && !this.hostHovered) {
+                this.hide();
+            }
+        }
+    }
+    onClick() {
+        this.toggleTooltip();
+    }
+    onBodyClick(event) {
+        if (!this.elRef.nativeElement.contains(event.target) &&
+            (this.hideOnClick ||
+                !this.componentIns.elRef.nativeElement.contains(event.target))) {
+            this.hide();
+        }
+    }
+    onFocus() {
+        this._createTooltip();
+    }
+    onBlur() {
+        this.hide();
+    }
+}
+BaseTooltip.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: BaseTooltip, deps: [{ token: i1.Overlay }, { token: i0.ViewContainerRef }, { token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.ChangeDetectorRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });
+BaseTooltip.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.8", type: BaseTooltip, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: BaseTooltip, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i1.Overlay }, { type: i0.ViewContainerRef }, { type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.ChangeDetectorRef }, { type: i0.NgZone }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-tooltip.js","sourceRoot":"","sources":["../../../src/tooltip/base-tooltip.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ConnectedPosition,\n  Overlay,\n  OverlayConfig,\n  OverlayRef,\n} from '@angular/cdk/overlay';\nimport { ComponentPortal, ComponentType } from '@angular/cdk/portal';\nimport {\n  AfterViewInit,\n  ChangeDetectorRef,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  NgZone,\n  OnDestroy,\n  Renderer2,\n  TemplateRef,\n  ViewContainerRef,\n} from '@angular/core';\nimport {\n  ReplaySubject,\n  merge,\n  debounceTime,\n  takeUntil,\n  first,\n  filter,\n  Subject,\n  delay,\n} from 'rxjs';\n\nimport { sleep } from '../utils';\n\nimport { TooltipComponent } from './tooltip.component';\nimport { TooltipTrigger, TooltipType } from './tooltip.types';\nimport { getOriginPosition, getOverlayPosition } from './utils';\n\nexport interface TooltipInterface {\n  content: string | TemplateRef<any>;\n  context: any;\n  class: string;\n  type: TooltipType;\n  position: string;\n  trigger: TooltipTrigger;\n  disabled: boolean;\n  hideOnClick: boolean;\n  visibleChange: EventEmitter<boolean>;\n}\n\nexport const DISPLAY_DELAY = 50;\nexport const HIDDEN_DELAY = 150;\n\n// @ts-ignore\ninterface HackOverlayRef extends OverlayRef {\n  _positionStrategy: {\n    _hasExactPosition: () => boolean;\n    _pane: HTMLElement;\n    _lastPosition: ConnectedPosition | null;\n    _boundingBox: HTMLElement;\n    _transformOriginSelector: string;\n  };\n}\n\n@Directive()\nexport class BaseTooltip<T = any>\n  implements TooltipInterface, AfterViewInit, OnDestroy\n{\n  set content(value: string | TemplateRef<any>) {\n    this._content = value;\n    this.inputContent$$.next(value);\n  }\n\n  get content() {\n    return this._content;\n  }\n\n  set context(value: T) {\n    this._context = value;\n    this.inputContext$$.next(value);\n  }\n\n  get context() {\n    return this._context;\n  }\n\n  set class(value: string) {\n    this.inputClass$$.next(value);\n  }\n\n  set type(value: TooltipType) {\n    if (!value) {\n      return;\n    }\n    this.inputType$$.next(value);\n  }\n\n  set position(value: string) {\n    if (!value || value === this._position) {\n      return;\n    }\n    this._position = value;\n    this.inputPosition$$.next(value);\n    this._disposeTooltip();\n  }\n\n  get position() {\n    return this._position;\n  }\n\n  set trigger(value) {\n    if (!value || value === this._trigger) {\n      return;\n    }\n    this._trigger = value;\n    this._disposeTooltip();\n    this.ngZone.run(this.updateListeners, this);\n  }\n\n  get trigger() {\n    return this._trigger;\n  }\n\n  set disabled(value) {\n    this._disabled = value;\n    if (value) {\n      this._disposeTooltip();\n    }\n  }\n\n  get disabled() {\n    return this._disabled;\n  }\n\n  hideOnClick = false;\n  disableAnimation = true;\n\n  visibleChange = new EventEmitter<boolean>();\n\n  overlayRef: OverlayRef;\n  protected componentClass: ComponentType<any> = TooltipComponent;\n  protected componentIns: TooltipComponent;\n  protected hostHovered = false;\n  protected tooltipHovered = false;\n  protected listeners: Array<() => void> = [];\n  protected unlistenBody: () => void;\n\n  protected inputContent$$ = new ReplaySubject<string | TemplateRef<any>>(1);\n  protected inputType$$ = new ReplaySubject<TooltipType>(1);\n  protected inputPosition$$ = new ReplaySubject<string>(1);\n  protected inputClass$$ = new ReplaySubject<string>(1);\n  protected inputContext$$ = new ReplaySubject<any>(1);\n\n  protected tooltipChanged$ = merge(\n    this.inputContent$$,\n    this.inputType$$,\n    this.inputPosition$$,\n    this.inputClass$$,\n    this.inputContext$$,\n  );\n\n  protected destroy$ = new Subject();\n\n  protected _position = 'top';\n  protected _trigger = TooltipTrigger.Hover;\n  protected _disabled = false;\n  protected _context: T;\n  protected _content: string | TemplateRef<unknown>;\n\n  get isCreated() {\n    return !!this.overlayRef;\n  }\n\n  constructor(\n    protected overlay: Overlay,\n    protected viewContainerRef: ViewContainerRef,\n    protected elRef: ElementRef<HTMLInputElement>,\n    protected renderer: Renderer2,\n    protected cdr: ChangeDetectorRef,\n    protected ngZone: NgZone,\n  ) {\n    this.tooltipChanged$.pipe(debounceTime(0)).subscribe(() => {\n      this.updatePosition();\n    });\n  }\n\n  private _updateTransformOrigin() {\n    // @ts-ignore\n    const overlayRef = this.overlayRef as HackOverlayRef;\n    const positionStrategy = overlayRef._positionStrategy;\n    const hasExactPosition = positionStrategy._hasExactPosition(); // 是不是应用了精确定位\n    if (!hasExactPosition) {\n      return;\n    }\n    // 如果是精确定位，也就是预设位置空间不足以承载弹出元素，被重新指定新的弹出位置\n    const paneRect = positionStrategy._pane.getBoundingClientRect(); // 弹出pane元素Rect\n    const triggerElReact = this.elRef.nativeElement.getBoundingClientRect(); // 触发点Rect\n\n    const position = positionStrategy._lastPosition; // 当前策略位置（调整后的最佳的）\n    let xOrigin: 'left' | 'right' | 'center';\n    const yOrigin: 'top' | 'bottom' | 'center' = position.overlayY;\n    if (position.overlayX === 'center') {\n      xOrigin = 'center';\n    } else {\n      xOrigin = position.overlayX === 'start' ? 'left' : 'right';\n    }\n\n    const origins: string[] = [xOrigin, yOrigin];\n    if (\n      xOrigin === 'center' ||\n      (xOrigin === 'left' &&\n        ![triggerElReact.right, triggerElReact.left].includes(paneRect.left)) ||\n      (xOrigin === 'right' &&\n        ![triggerElReact.right, triggerElReact.left].includes(paneRect.right))\n    ) {\n      const originLeft =\n        triggerElReact.left - paneRect.left + triggerElReact.width / 2;\n      origins[0] = Math.min(originLeft, paneRect.width) + 'px';\n    }\n    if (\n      yOrigin === 'center' ||\n      (yOrigin === 'top' &&\n        ![triggerElReact.bottom, triggerElReact.top].includes(paneRect.top)) || // 位置没有被完全被颠倒的\n      (yOrigin === 'bottom' &&\n        ![triggerElReact.bottom, triggerElReact.top].includes(paneRect.bottom)) // 位置没有被完全被颠倒的\n    ) {\n      const originTop =\n        triggerElReact.top - paneRect.top + triggerElReact.height / 2;\n      origins[1] = Math.min(originTop, paneRect.height) + 'px';\n    }\n    const aniEls = positionStrategy._boundingBox.querySelectorAll<HTMLElement>(\n      positionStrategy._transformOriginSelector,\n    );\n    Array.from(aniEls).forEach(el => {\n      el.style.transformOrigin = origins.join(' ');\n    });\n  }\n\n  _createTooltip() {\n    if (this.disabled || this.isCreated) {\n      return;\n    }\n    this._disposeTooltip();\n    this.overlayRef = this.createOverlay();\n    const portal = new ComponentPortal(\n      this.componentClass,\n      this.viewContainerRef,\n    );\n    this.componentIns = this.overlayRef.attach(portal).instance;\n    this.componentIns.setupInputs({\n      inputClass$: this.inputClass$$.asObservable(),\n      inputContent$: this.inputContent$$.asObservable(),\n      inputContext$: this.inputContext$$.asObservable(),\n      inputPosition$: this.inputPosition$$.asObservable(),\n      inputType$: this.inputType$$.asObservable(),\n      disableAnimation: this.disableAnimation,\n    });\n    this.componentIns.hide$.pipe(takeUntil(this.destroy$)).subscribe(() => {\n      this._disposeTooltip();\n    });\n\n    if (!this.disableAnimation) {\n      merge(\n        this.componentIns.beforeHide$,\n        this.componentIns.beforeShow$.pipe(delay(0)),\n      )\n        .pipe(takeUntil(this.destroy$))\n        .subscribe(this._updateTransformOrigin.bind(this));\n    }\n\n    if (this.trigger === TooltipTrigger.Hover) {\n      this.componentIns.hover$\n        .pipe(takeUntil(this.componentIns.destroy$))\n        .subscribe(hovered => {\n          this.onTooltipHovered(hovered);\n        });\n    }\n    if (\n      this.trigger === TooltipTrigger.Hover ||\n      this.trigger === TooltipTrigger.Click\n    ) {\n      this.unlistenBody = this.renderer.listen(\n        'body',\n        'click',\n        this.onBodyClick.bind(this),\n      );\n    }\n\n    this.componentIns?.show();\n    this.cdr.markForCheck();\n\n    this.visibleChange.emit(true);\n  }\n\n  _disposeTooltip() {\n    this.componentIns?.animating$$\n      .pipe(\n        filter(animating => !animating),\n        first(),\n      )\n      .subscribe(() => {\n        if (this.overlayRef) {\n          this.overlayRef.dispose();\n          this.overlayRef = null;\n          this.componentIns = null;\n          this.tooltipHovered = false;\n          if (this.unlistenBody) {\n            this.unlistenBody();\n            this.unlistenBody = null;\n          }\n          this.visibleChange.emit(false);\n        }\n      });\n  }\n\n  toggleTooltip() {\n    if (this.isCreated) {\n      this.hide();\n    } else {\n      this.show();\n    }\n  }\n\n  show() {\n    this._createTooltip();\n  }\n\n  hide() {\n    if (this.disableAnimation) {\n      // 如果禁用了动画就立即销毁，而不是等动画完成事件后才销毁\n      this._disposeTooltip();\n    } else {\n      this.componentIns?.hide();\n    }\n  }\n\n  updatePosition() {\n    if (this.overlayRef) {\n      this.overlayRef.updatePosition();\n    }\n  }\n\n  ngAfterViewInit() {\n    if (this.trigger === TooltipTrigger.Hover) {\n      this.updateListeners();\n    }\n  }\n\n  ngOnDestroy() {\n    this.destroy$.next(null);\n    this.destroy$.complete();\n    this._disposeTooltip();\n    this.clearListeners();\n  }\n\n  protected updateListeners() {\n    this.clearListeners();\n    switch (this.trigger) {\n      case TooltipTrigger.Click:\n        this.listeners.push(\n          this.renderer.listen(\n            this.elRef.nativeElement,\n            'click',\n            this.onClick.bind(this) as () => void,\n          ),\n        );\n        break;\n      case TooltipTrigger.Hover:\n        this.listeners.push(\n          this.renderer.listen(\n            this.elRef.nativeElement,\n            'mouseenter',\n            this.onMouseEnter.bind(this) as () => void,\n          ),\n          this.renderer.listen(\n            this.elRef.nativeElement,\n            'mouseleave',\n            this.onMouseLeave.bind(this) as () => void,\n          ),\n        );\n        break;\n      case TooltipTrigger.Focus:\n        this.listeners.push(\n          this.renderer.listen(\n            this.elRef.nativeElement,\n            'focus',\n            this.onFocus.bind(this),\n          ),\n          this.renderer.listen(\n            this.elRef.nativeElement,\n            'blur',\n            this.onBlur.bind(this),\n          ),\n        );\n        break;\n      case TooltipTrigger.Manual:\n        break;\n    }\n  }\n\n  protected clearListeners() {\n    this.listeners.forEach(unListen => {\n      unListen();\n    });\n    this.listeners = [];\n  }\n\n  protected createOverlay(): OverlayRef {\n    const originPosition = getOriginPosition(this.position);\n    const overlayPosition = getOverlayPosition(this.position);\n\n    const positionStrategy = this.overlay\n      .position()\n      .flexibleConnectedTo(this.elRef)\n      .withGrowAfterOpen(true)\n      .withTransformOriginOn('.aui-tooltip')\n      .withPositions([\n        { ...originPosition.main, ...overlayPosition.main },\n        { ...originPosition.fallback, ...overlayPosition.fallback },\n      ]);\n\n    const scrollStrategy = this.overlay.scrollStrategies.reposition();\n\n    const config = new OverlayConfig({\n      positionStrategy,\n      scrollStrategy,\n    });\n    return this.overlay.create(config);\n  }\n\n  protected async onMouseEnter() {\n    this.hostHovered = true;\n    if (!this.isCreated) {\n      await sleep(DISPLAY_DELAY);\n      if (this.hostHovered) {\n        this._createTooltip();\n      }\n    }\n  }\n\n  protected async onMouseLeave() {\n    this.hostHovered = false;\n    await sleep(HIDDEN_DELAY);\n    if (!this.tooltipHovered && !this.hostHovered) {\n      this.hide();\n    }\n  }\n\n  protected async onTooltipHovered(hovered: boolean) {\n    this.tooltipHovered = hovered;\n    if (!hovered) {\n      await sleep(HIDDEN_DELAY);\n      if (!this.tooltipHovered && !this.hostHovered) {\n        this.hide();\n      }\n    }\n  }\n\n  protected onClick() {\n    this.toggleTooltip();\n  }\n\n  protected onBodyClick(event: Event) {\n    if (\n      !this.elRef.nativeElement.contains(event.target as Node) &&\n      (this.hideOnClick ||\n        !this.componentIns.elRef.nativeElement.contains(event.target as Node))\n    ) {\n      this.hide();\n    }\n  }\n\n  protected onFocus() {\n    this._createTooltip();\n  }\n\n  protected onBlur() {\n    this.hide();\n  }\n}\n"]}

package/esm2020/tooltip/tooltip-active.directive.mjs

@@ -0,0 +1,49 @@
+import { Directive, Input, } from '@angular/core';
+import { Subject, takeUntil } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./base-tooltip";
+export class TooltipActiveDirective {
+    constructor(tooltipDirective, el, renderer) {
+        this.el = el;
+        this.renderer = renderer;
+        this.customClass = '';
+        this.destroy$ = new Subject();
+        tooltipDirective.visibleChange
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(visible => {
+            this[visible ? 'addClass' : 'removeClass']();
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.next(null);
+        this.destroy$.complete();
+    }
+    addClass() {
+        const classArr = typeof this.customClass === 'string'
+            ? this.customClass.split(' ')
+            : this.customClass;
+        classArr.forEach(name => {
+            this.renderer.addClass(this.el.nativeElement, name);
+        });
+    }
+    removeClass() {
+        const classArr = typeof this.customClass === 'string'
+            ? this.customClass.split(' ')
+            : this.customClass;
+        classArr.forEach(name => {
+            this.renderer.removeClass(this.el.nativeElement, name);
+        });
+    }
+}
+TooltipActiveDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: TooltipActiveDirective, deps: [{ token: i1.BaseTooltip }, { token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+TooltipActiveDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.8", type: TooltipActiveDirective, selector: "[auiTooltipActive]", inputs: { customClass: ["auiTooltipActive", "customClass"] }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: TooltipActiveDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[auiTooltipActive]',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.BaseTooltip }, { type: i0.ElementRef }, { type: i0.Renderer2 }]; }, propDecorators: { customClass: [{
+                type: Input,
+                args: ['auiTooltipActive']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/tooltip/tooltip-copy.directive.mjs

@@ -0,0 +1,82 @@
+import { Directive, HostBinding, HostListener, Input, } from '@angular/core';
+import { takeUntil } from 'rxjs';
+import { BaseTooltip } from './base-tooltip';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+import * as i2 from "./tooltip-intl";
+export class TooltipCopyDirective extends BaseTooltip {
+    constructor(overlay, viewContainerRef, elRef, renderer, cdr, ngZone, toolTipIntl) {
+        super(overlay, viewContainerRef, elRef, renderer, cdr, ngZone);
+        this.toolTipIntl = toolTipIntl;
+        this.className = true;
+        this.disableAnimation = false;
+    }
+    get auiTooltipCopy() {
+        return this._copyText || this.elRef.nativeElement.textContent;
+    }
+    set auiTooltipCopy(value) {
+        this._copyText = value;
+    }
+    get auiTooltipCopyTip() {
+        return this._copyTip || this.toolTipIntl.copyTip;
+    }
+    set auiTooltipCopyTip(value) {
+        this._copyTip = value;
+    }
+    get auiTooltipCopySuccessTip() {
+        return this._copySuccessTip || this.toolTipIntl.copySuccessTip;
+    }
+    set auiTooltipCopySuccessTip(value) {
+        this._copySuccessTip = value;
+    }
+    get auiTooltipCopyFailTip() {
+        return this._copyFailTip || this.toolTipIntl.copyFailTip;
+    }
+    set auiTooltipCopyFailTip(value) {
+        this._copyFailTip = value;
+    }
+    ngOnInit() {
+        this.content = this.auiTooltipCopyTip;
+        this.visibleChange.pipe(takeUntil(this.destroy$)).subscribe(() => {
+            this.content = this.auiTooltipCopyTip;
+        });
+    }
+    async onSourceClick() {
+        if (!this.disabled) {
+            try {
+                await navigator.clipboard.writeText(this.auiTooltipCopy);
+                this.content = this.auiTooltipCopySuccessTip;
+            }
+            catch {
+                this.content = this.auiTooltipCopyFailTip;
+            }
+        }
+    }
+}
+TooltipCopyDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: TooltipCopyDirective, deps: [{ token: i1.Overlay }, { token: i0.ViewContainerRef }, { token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.ChangeDetectorRef }, { token: i0.NgZone }, { token: i2.TooltipCopyIntl }], target: i0.ɵɵFactoryTarget.Directive });
+TooltipCopyDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.8", type: TooltipCopyDirective, selector: "[auiTooltipCopy]", inputs: { position: ["auiTooltipPosition", "position"], disabled: ["auiTooltipDisabled", "disabled"], disableAnimation: ["auiDisableAnimation", "disableAnimation"], auiTooltipCopy: "auiTooltipCopy", auiTooltipCopyTip: "auiTooltipCopyTip", auiTooltipCopySuccessTip: "auiTooltipCopySuccessTip", auiTooltipCopyFailTip: "auiTooltipCopyFailTip" }, host: { listeners: { "click": "onSourceClick()" }, properties: { "class.aui-tooltip-copy": "this.className" } }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: TooltipCopyDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[auiTooltipCopy]',
+                    inputs: ['position:auiTooltipPosition', 'disabled:auiTooltipDisabled'],
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Overlay }, { type: i0.ViewContainerRef }, { type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.ChangeDetectorRef }, { type: i0.NgZone }, { type: i2.TooltipCopyIntl }]; }, propDecorators: { className: [{
+                type: HostBinding,
+                args: ['class.aui-tooltip-copy']
+            }], disableAnimation: [{
+                type: Input,
+                args: ['auiDisableAnimation']
+            }], auiTooltipCopy: [{
+                type: Input
+            }], auiTooltipCopyTip: [{
+                type: Input
+            }], auiTooltipCopySuccessTip: [{
+                type: Input
+            }], auiTooltipCopyFailTip: [{
+                type: Input
+            }], onSourceClick: [{
+                type: HostListener,
+                args: ['click']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/tooltip/tooltip-intl.mjs

@@ -0,0 +1,29 @@
+import { Injectable, Optional, SkipSelf } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Texts to render on the code editor.
+ */
+export class TooltipCopyIntl {
+    constructor() {
+        this.copyTip = 'Click to copy';
+        this.copySuccessTip = 'Copied to clipboard';
+        this.copyFailTip = 'Copy failed';
+    }
+}
+TooltipCopyIntl.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: TooltipCopyIntl, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+TooltipCopyIntl.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: TooltipCopyIntl });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: TooltipCopyIntl, decorators: [{
+            type: Injectable
+        }] });
+// eslint-disable-next-line sonar/function-name
+export function TOOLTIP_COPY_INTL_PROVIDER_FACTORY(parentIntl) {
+    return parentIntl || new TooltipCopyIntl();
+}
+/** @docs-private */
+export const TOOLTIP_COPY_INTL_INTL_PROVIDER = {
+    // If there is already an CodeEditorIntl available, use that. Otherwise, provide a new one.
+    provide: TooltipCopyIntl,
+    deps: [[new Optional(), new SkipSelf(), TooltipCopyIntl]],
+    useFactory: TOOLTIP_COPY_INTL_PROVIDER_FACTORY,
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9vbHRpcC1pbnRsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3Rvb2x0aXAvdG9vbHRpcC1pbnRsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsUUFBUSxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFFL0Q7O0dBRUc7QUFFSCxNQUFNLE9BQU8sZUFBZTtJQUQ1QjtRQUVFLFlBQU8sR0FBRyxlQUFlLENBQUM7UUFFMUIsbUJBQWMsR0FBRyxxQkFBcUIsQ0FBQztRQUV2QyxnQkFBVyxHQUFHLGFBQWEsQ0FBQztLQUM3Qjs7NEdBTlksZUFBZTtnSEFBZixlQUFlOzJGQUFmLGVBQWU7a0JBRDNCLFVBQVU7O0FBU1gsK0NBQStDO0FBQy9DLE1BQU0sVUFBVSxrQ0FBa0MsQ0FDaEQsVUFBMkI7SUFFM0IsT0FBTyxVQUFVLElBQUksSUFBSSxlQUFlLEVBQUUsQ0FBQztBQUM3QyxDQUFDO0FBRUQsb0JBQW9CO0FBQ3BCLE1BQU0sQ0FBQyxNQUFNLCtCQUErQixHQUFHO0lBQzdDLDJGQUEyRjtJQUMzRixPQUFPLEVBQUUsZUFBZTtJQUN4QixJQUFJLEVBQUUsQ0FBQyxDQUFDLElBQUksUUFBUSxFQUFFLEVBQUUsSUFBSSxRQUFRLEVBQUUsRUFBRSxlQUFlLENBQUMsQ0FBQztJQUN6RCxVQUFVLEVBQUUsa0NBQWtDO0NBQy9DLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlLCBPcHRpb25hbCwgU2tpcFNlbGYgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuLyoqXG4gKiBUZXh0cyB0byByZW5kZXIgb24gdGhlIGNvZGUgZWRpdG9yLlxuICovXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgVG9vbHRpcENvcHlJbnRsIHtcbiAgY29weVRpcCA9ICdDbGljayB0byBjb3B5JztcblxuICBjb3B5U3VjY2Vzc1RpcCA9ICdDb3BpZWQgdG8gY2xpcGJvYXJkJztcblxuICBjb3B5RmFpbFRpcCA9ICdDb3B5IGZhaWxlZCc7XG59XG5cbi8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBzb25hci9mdW5jdGlvbi1uYW1lXG5leHBvcnQgZnVuY3Rpb24gVE9PTFRJUF9DT1BZX0lOVExfUFJPVklERVJfRkFDVE9SWShcbiAgcGFyZW50SW50bDogVG9vbHRpcENvcHlJbnRsLFxuKSB7XG4gIHJldHVybiBwYXJlbnRJbnRsIHx8IG5ldyBUb29sdGlwQ29weUludGwoKTtcbn1cblxuLyoqIEBkb2NzLXByaXZhdGUgKi9cbmV4cG9ydCBjb25zdCBUT09MVElQX0NPUFlfSU5UTF9JTlRMX1BST1ZJREVSID0ge1xuICAvLyBJZiB0aGVyZSBpcyBhbHJlYWR5IGFuIENvZGVFZGl0b3JJbnRsIGF2YWlsYWJsZSwgdXNlIHRoYXQuIE90aGVyd2lzZSwgcHJvdmlkZSBhIG5ldyBvbmUuXG4gIHByb3ZpZGU6IFRvb2x0aXBDb3B5SW50bCxcbiAgZGVwczogW1tuZXcgT3B0aW9uYWwoKSwgbmV3IFNraXBTZWxmKCksIFRvb2x0aXBDb3B5SW50bF1dLFxuICB1c2VGYWN0b3J5OiBUT09MVElQX0NPUFlfSU5UTF9QUk9WSURFUl9GQUNUT1JZLFxufTtcbiJdfQ==