@alauda/ui 6.5.10-beta → 6.5.10-beta.1

package/esm2022/tooltip/base-tooltip.mjs

@@ -0,0 +1,329 @@
+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 {
+    overlay;
+    viewContainerRef;
+    elRef;
+    renderer;
+    cdr;
+    ngZone;
+    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;
+    }
+    hideOnClick = false;
+    disableAnimation = true;
+    visibleChange = new EventEmitter();
+    overlayRef;
+    componentClass = TooltipComponent;
+    componentIns;
+    hostHovered = false;
+    tooltipHovered = false;
+    listeners = [];
+    unlistenBody;
+    inputContent$$ = new ReplaySubject(1);
+    inputType$$ = new ReplaySubject(1);
+    inputPosition$$ = new ReplaySubject(1);
+    inputClass$$ = new ReplaySubject(1);
+    inputContext$$ = new ReplaySubject(1);
+    tooltipChanged$ = merge(this.inputContent$$, this.inputType$$, this.inputPosition$$, this.inputClass$$, this.inputContext$$);
+    destroy$ = new Subject();
+    _position = 'top';
+    _trigger = TooltipTrigger.Hover;
+    _disabled = false;
+    _context;
+    _content;
+    get isCreated() {
+        return !!this.overlayRef;
+    }
+    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.tooltipChanged$.pipe(debounceTime(0)).subscribe(() => {
+            this.updatePosition();
+        });
+    }
+    _updateTransformOrigin() {
+        const overlayRef = this.overlayRef;
+        const positionStrategy = overlayRef._positionStrategy;
+        const hasExactPosition = positionStrategy._hasExactPosition();
+        if (!hasExactPosition) {
+            return;
+        }
+        const paneRect = positionStrategy._pane.getBoundingClientRect();
+        const triggerElReact = this.elRef.nativeElement.getBoundingClientRect();
+        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();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", 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 });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.4", type: BaseTooltip, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", 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/esm2022/tooltip/tooltip-active.directive.mjs

@@ -0,0 +1,51 @@
+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 {
+    el;
+    renderer;
+    customClass = '';
+    destroy$ = new Subject();
+    constructor(tooltipDirective, el, renderer) {
+        this.el = el;
+        this.renderer = renderer;
+        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);
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: TooltipActiveDirective, deps: [{ token: i1.BaseTooltip }, { token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.4", type: TooltipActiveDirective, selector: "[auiTooltipActive]", inputs: { customClass: ["auiTooltipActive", "customClass"] }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", 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/esm2022/tooltip/tooltip-copy.directive.mjs

@@ -0,0 +1,87 @@
+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 {
+    toolTipIntl;
+    className = true;
+    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;
+    }
+    _copyText;
+    _copyTip;
+    _copySuccessTip;
+    _copyFailTip;
+    constructor(overlay, viewContainerRef, elRef, renderer, cdr, ngZone, toolTipIntl) {
+        super(overlay, viewContainerRef, elRef, renderer, cdr, ngZone);
+        this.toolTipIntl = toolTipIntl;
+    }
+    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;
+            }
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", 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 });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.4", 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: "16.1.4", 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/esm2022/tooltip/tooltip-intl.mjs

@@ -0,0 +1,21 @@
+import { Injectable, Optional, SkipSelf } from '@angular/core';
+import * as i0 from "@angular/core";
+export class TooltipCopyIntl {
+    copyTip = 'Click to copy';
+    copySuccessTip = 'Copied to clipboard';
+    copyFailTip = 'Copy failed';
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: TooltipCopyIntl, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: TooltipCopyIntl });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: TooltipCopyIntl, decorators: [{
+            type: Injectable
+        }] });
+export function TOOLTIP_COPY_INTL_PROVIDER_FACTORY(parentIntl) {
+    return parentIntl || new TooltipCopyIntl();
+}
+export const TOOLTIP_COPY_INTL_INTL_PROVIDER = {
+    provide: TooltipCopyIntl,
+    deps: [[new Optional(), new SkipSelf(), TooltipCopyIntl]],
+    useFactory: TOOLTIP_COPY_INTL_PROVIDER_FACTORY,
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9vbHRpcC1pbnRsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3Rvb2x0aXAvdG9vbHRpcC1pbnRsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsUUFBUSxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFNL0QsTUFBTSxPQUFPLGVBQWU7SUFDMUIsT0FBTyxHQUFHLGVBQWUsQ0FBQztJQUUxQixjQUFjLEdBQUcscUJBQXFCLENBQUM7SUFFdkMsV0FBVyxHQUFHLGFBQWEsQ0FBQzt1R0FMakIsZUFBZTsyR0FBZixlQUFlOzsyRkFBZixlQUFlO2tCQUQzQixVQUFVOztBQVVYLE1BQU0sVUFBVSxrQ0FBa0MsQ0FDaEQsVUFBMkI7SUFFM0IsT0FBTyxVQUFVLElBQUksSUFBSSxlQUFlLEVBQUUsQ0FBQztBQUM3QyxDQUFDO0FBR0QsTUFBTSxDQUFDLE1BQU0sK0JBQStCLEdBQUc7SUFFN0MsT0FBTyxFQUFFLGVBQWU7SUFDeEIsSUFBSSxFQUFFLENBQUMsQ0FBQyxJQUFJLFFBQVEsRUFBRSxFQUFFLElBQUksUUFBUSxFQUFFLEVBQUUsZUFBZSxDQUFDLENBQUM7SUFDekQsVUFBVSxFQUFFLGtDQUFrQztDQUMvQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSwgT3B0aW9uYWwsIFNraXBTZWxmIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbi8qKlxuICogVGV4dHMgdG8gcmVuZGVyIG9uIHRoZSBjb2RlIGVkaXRvci5cbiAqL1xuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIFRvb2x0aXBDb3B5SW50bCB7XG4gIGNvcHlUaXAgPSAnQ2xpY2sgdG8gY29weSc7XG5cbiAgY29weVN1Y2Nlc3NUaXAgPSAnQ29waWVkIHRvIGNsaXBib2FyZCc7XG5cbiAgY29weUZhaWxUaXAgPSAnQ29weSBmYWlsZWQnO1xufVxuXG4vLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgc29uYXIvZnVuY3Rpb24tbmFtZVxuZXhwb3J0IGZ1bmN0aW9uIFRPT0xUSVBfQ09QWV9JTlRMX1BST1ZJREVSX0ZBQ1RPUlkoXG4gIHBhcmVudEludGw6IFRvb2x0aXBDb3B5SW50bCxcbikge1xuICByZXR1cm4gcGFyZW50SW50bCB8fCBuZXcgVG9vbHRpcENvcHlJbnRsKCk7XG59XG5cbi8qKiBAZG9jcy1wcml2YXRlICovXG5leHBvcnQgY29uc3QgVE9PTFRJUF9DT1BZX0lOVExfSU5UTF9QUk9WSURFUiA9IHtcbiAgLy8gSWYgdGhlcmUgaXMgYWxyZWFkeSBhbiBDb2RlRWRpdG9ySW50bCBhdmFpbGFibGUsIHVzZSB0aGF0LiBPdGhlcndpc2UsIHByb3ZpZGUgYSBuZXcgb25lLlxuICBwcm92aWRlOiBUb29sdGlwQ29weUludGwsXG4gIGRlcHM6IFtbbmV3IE9wdGlvbmFsKCksIG5ldyBTa2lwU2VsZigpLCBUb29sdGlwQ29weUludGxdXSxcbiAgdXNlRmFjdG9yeTogVE9PTFRJUF9DT1BZX0lOVExfUFJPVklERVJfRkFDVE9SWSxcbn07XG4iXX0=