@progressio_resources/gravity-design-system 1.0.6 → 1.0.8

package/esm2020/lib/vendor/gravity-tooltip/gravity-tooltip.directive.mjs

@@ -0,0 +1,480 @@
+import { Directive, EventEmitter, HostListener, Inject, Input, Optional, Output } from '@angular/core';
+import { GravityTooltipComponent } from './gravity-tooltip.component';
+import { TooltipOptionsService } from './options.service';
+import { backwardCompatibilityOptions, defaultOptions } from './options';
+import * as i0 from "@angular/core";
+export class GravityTooltipDirective {
+    set options(value) {
+        if (value && defaultOptions) {
+            this._options = value;
+        }
+    }
+    get options() {
+        return this._options;
+    }
+    // Content type
+    set contentTypeBackwardCompatibility(value) {
+        if (value) {
+            this._contentType = value;
+        }
+    }
+    set contentType(value) {
+        if (value) {
+            this._contentType = value;
+        }
+    }
+    get contentType() {
+        return this._contentType;
+    }
+    // z-index
+    set zIndexBackwardCompatibility(value) {
+        if (value) {
+            this._zIndex = value;
+        }
+    }
+    set zIndex(value) {
+        if (value) {
+            this._zIndex = value;
+        }
+    }
+    get zIndex() {
+        return this._zIndex;
+    }
+    // Animation duration
+    set animationDurationBackwardCompatibility(value) {
+        if (value) {
+            this._animationDuration = value;
+        }
+    }
+    set animationDuration(value) {
+        if (value) {
+            this._animationDuration = value;
+        }
+    }
+    get animationDuration() {
+        return this._animationDuration;
+    }
+    // Tooltip class
+    set tooltipClassBackwardCompatibility(value) {
+        if (value) {
+            this._tooltipClass = value;
+        }
+    }
+    set tooltipClass(value) {
+        if (value) {
+            this._tooltipClass = value;
+        }
+    }
+    get tooltipClass() {
+        return this._tooltipClass;
+    }
+    // Max width
+    set maxWidthBackwardCompatibility(value) {
+        if (value) {
+            this._maxWidth = value;
+        }
+    }
+    set maxWidth(value) {
+        if (value) {
+            this._maxWidth = value;
+        }
+    }
+    get maxWidth() {
+        return this._maxWidth;
+    }
+    // Show delay
+    set showDelayBackwardCompatibility(value) {
+        if (value) {
+            this._showDelay = value;
+        }
+    }
+    set showDelay(value) {
+        if (value) {
+            this._showDelay = value;
+        }
+    }
+    get showDelay() {
+        return this._showDelay;
+    }
+    // Hide delay
+    set hideDelayBackwardCompatibility(value) {
+        if (value) {
+            this._hideDelay = value;
+        }
+    }
+    set hideDelay(value) {
+        if (value) {
+            this._hideDelay = value;
+        }
+    }
+    get hideDelay() {
+        return this._hideDelay;
+    }
+    get isTooltipDestroyed() {
+        return this.componentRef && this.componentRef.hostView.destroyed;
+    }
+    get destroyDelay() {
+        if (this._destroyDelay) {
+            return this._destroyDelay;
+        }
+        else {
+            return Number(this.getHideDelay()) + Number(this.options['animationDuration']);
+        }
+    }
+    set destroyDelay(value) {
+        this._destroyDelay = value;
+    }
+    get tooltipPosition() {
+        if (this.options['position']) {
+            return this.options['position'];
+        }
+        else {
+            return this.elementPosition;
+        }
+    }
+    constructor(initOptions, elementRef, componentFactoryResolver, appRef, injector) {
+        this.initOptions = initOptions;
+        this.elementRef = elementRef;
+        this.componentFactoryResolver = componentFactoryResolver;
+        this.appRef = appRef;
+        this.injector = injector;
+        this._options = {};
+        this._contentType = "string";
+        this.events = new EventEmitter();
+    }
+    onMouseEnter() {
+        if (this.isDisplayOnHover == false) {
+            return;
+        }
+        this.show();
+    }
+    onMouseLeave() {
+        if (this.options['trigger'] === 'hover') {
+            this.destroyTooltip();
+        }
+    }
+    onClick() {
+        if (this.isDisplayOnClick == false) {
+            return;
+        }
+        this.show();
+        this.hideAfterClickTimeoutId = window.setTimeout(() => {
+            this.destroyTooltip();
+        }, this.options['hideDelayAfterClick']);
+    }
+    ngOnInit() {
+    }
+    ngOnChanges(changes) {
+        this.initOptions = this.renameProperties(this.initOptions);
+        let changedOptions = this.getProperties(changes);
+        changedOptions = this.renameProperties(changedOptions);
+        this.applyOptionsDefault(defaultOptions, changedOptions);
+    }
+    ngOnDestroy() {
+        this.destroyTooltip({
+            fast: true
+        });
+        if (this.componentSubscribe) {
+            this.componentSubscribe.unsubscribe();
+        }
+    }
+    getShowDelay() {
+        return this.options['showDelay'];
+    }
+    getHideDelay() {
+        const hideDelay = this.options['hideDelay'];
+        const hideDelayTouchscreen = this.options['hideDelayTouchscreen'];
+        return this.isTouchScreen ? hideDelayTouchscreen : hideDelay;
+    }
+    getProperties(changes) {
+        let directiveProperties = {};
+        let customProperties = {};
+        let allProperties;
+        for (var prop in changes) {
+            if (prop !== 'options' && prop !== 'tooltipValue') {
+                directiveProperties[prop] = changes[prop].currentValue;
+            }
+            if (prop === 'options') {
+                customProperties = changes[prop].currentValue;
+            }
+        }
+        allProperties = Object.assign({}, customProperties, directiveProperties);
+        return allProperties;
+    }
+    renameProperties(options) {
+        for (var prop in options) {
+            if (backwardCompatibilityOptions[prop]) {
+                options[backwardCompatibilityOptions[prop]] = options[prop];
+                delete options[prop];
+            }
+        }
+        return options;
+    }
+    getElementPosition() {
+        this.elementPosition = this.elementRef.nativeElement.getBoundingClientRect();
+    }
+    createTooltip() {
+        this.clearTimeouts();
+        this.getElementPosition();
+        this.createTimeoutId = window.setTimeout(() => {
+            this.appendComponentToBody(GravityTooltipComponent);
+        }, this.getShowDelay());
+        this.showTimeoutId = window.setTimeout(() => {
+            this.showTooltipElem();
+        }, this.getShowDelay());
+    }
+    destroyTooltip(options = {
+        fast: false
+    }) {
+        this.clearTimeouts();
+        if (this.isTooltipDestroyed == false) {
+            this.hideTimeoutId = window.setTimeout(() => {
+                this.hideTooltip();
+            }, options.fast ? 0 : this.getHideDelay());
+            this.destroyTimeoutId = window.setTimeout(() => {
+                if (!this.componentRef || this.isTooltipDestroyed) {
+                    return;
+                }
+                this.appRef.detachView(this.componentRef.hostView);
+                this.componentRef.destroy();
+                this.events.emit({
+                    type: 'hidden',
+                    position: this.tooltipPosition
+                });
+            }, options.fast ? 0 : this.destroyDelay);
+        }
+    }
+    showTooltipElem() {
+        this.clearTimeouts();
+        this.componentRef.instance.show = true;
+        this.events.emit({
+            type: 'show',
+            position: this.tooltipPosition
+        });
+    }
+    hideTooltip() {
+        if (!this.componentRef || this.isTooltipDestroyed) {
+            return;
+        }
+        this.componentRef.instance.show = false;
+        this.events.emit({
+            type: 'hide',
+            position: this.tooltipPosition
+        });
+    }
+    appendComponentToBody(component) {
+        this.componentRef = this.componentFactoryResolver
+            .resolveComponentFactory(component)
+            .create(this.injector);
+        this.componentRef.instance.data = {
+            value: this.tooltipValue,
+            element: this.elementRef.nativeElement,
+            elementPosition: this.tooltipPosition,
+            options: this.options
+        };
+        this.appRef.attachView(this.componentRef.hostView);
+        const domElem = this.componentRef.hostView.rootNodes[0];
+        document.body.appendChild(domElem);
+        this.componentSubscribe = this.componentRef.instance.events.subscribe((event) => {
+            this.handleEvents(event);
+        });
+    }
+    clearTimeouts() {
+        if (this.createTimeoutId) {
+            clearTimeout(this.createTimeoutId);
+        }
+        if (this.showTimeoutId) {
+            clearTimeout(this.showTimeoutId);
+        }
+        if (this.hideTimeoutId) {
+            clearTimeout(this.hideTimeoutId);
+        }
+        if (this.destroyTimeoutId) {
+            clearTimeout(this.destroyTimeoutId);
+        }
+    }
+    get isDisplayOnHover() {
+        if (this.options['display'] == false) {
+            return false;
+        }
+        if (this.options['displayTouchscreen'] == false && this.isTouchScreen) {
+            return false;
+        }
+        return this.options['trigger'] === 'hover';
+    }
+    get isDisplayOnClick() {
+        if (this.options['display'] == false) {
+            return false;
+        }
+        if (this.options['displayTouchscreen'] == false && this.isTouchScreen) {
+            return false;
+        }
+        return this.options['trigger'] == 'click';
+    }
+    get isTouchScreen() {
+        var prefixes = ' -webkit- -moz- -o- -ms- '.split(' ');
+        var mq = function (query) {
+            return window.matchMedia(query).matches;
+        };
+        if (('ontouchstart' in window)) {
+            return true;
+        }
+        // include the 'heartz' as a way to have a non matching MQ to help terminate the join
+        // https://git.io/vznFH
+        var query = ['(', prefixes.join('touch-enabled),('), 'heartz', ')'].join('');
+        return mq(query);
+    }
+    applyOptionsDefault(defaultOptions, options) {
+        this.options = Object.assign({}, defaultOptions, this.initOptions || {}, this.options, options);
+    }
+    handleEvents(event) {
+        if (event.type === 'shown') {
+            this.events.emit({
+                type: 'shown',
+                position: this.tooltipPosition
+            });
+        }
+    }
+    show() {
+        if (!this.tooltipValue) {
+            return;
+        }
+        if (!this.componentRef || this.isTooltipDestroyed) {
+            this.createTooltip();
+        }
+        else if (!this.isTooltipDestroyed) {
+            this.showTooltipElem();
+        }
+    }
+    hide() {
+        this.destroyTooltip();
+    }
+}
+GravityTooltipDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: GravityTooltipDirective, deps: [{ token: TooltipOptionsService, optional: true }, { token: i0.ElementRef }, { token: i0.ComponentFactoryResolver }, { token: i0.ApplicationRef }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Directive });
+GravityTooltipDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.5", type: GravityTooltipDirective, selector: "[tooltip]", inputs: { options: "options", tooltipValue: ["tooltip", "tooltipValue"], placement: "placement", autoPlacement: "autoPlacement", contentTypeBackwardCompatibility: ["content-type", "contentTypeBackwardCompatibility"], contentType: "contentType", hideDelayMobile: ["hide-delay-mobile", "hideDelayMobile"], hideDelayTouchscreen: "hideDelayTouchscreen", zIndexBackwardCompatibility: ["z-index", "zIndexBackwardCompatibility"], zIndex: "zIndex", animationDurationBackwardCompatibility: ["animation-duration", "animationDurationBackwardCompatibility"], animationDuration: "animationDuration", trigger: "trigger", tooltipClassBackwardCompatibility: ["tooltip-class", "tooltipClassBackwardCompatibility"], tooltipClass: "tooltipClass", display: "display", displayMobile: ["display-mobile", "displayMobile"], displayTouchscreen: "displayTouchscreen", shadow: "shadow", theme: "theme", offset: "offset", width: "width", maxWidthBackwardCompatibility: ["max-width", "maxWidthBackwardCompatibility"], maxWidth: "maxWidth", id: "id", showDelayBackwardCompatibility: ["show-delay", "showDelayBackwardCompatibility"], showDelay: "showDelay", hideDelayBackwardCompatibility: ["hide-delay", "hideDelayBackwardCompatibility"], hideDelay: "hideDelay", hideDelayAfterClick: "hideDelayAfterClick", pointerEvents: "pointerEvents", position: "position" }, outputs: { events: "events" }, host: { listeners: { "focusin": "onMouseEnter()", "mouseenter": "onMouseEnter()", "focusout": "onMouseLeave()", "mouseleave": "onMouseLeave()", "click": "onClick()" } }, exportAs: ["tooltip"], usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: GravityTooltipDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tooltip]',
+                    exportAs: 'tooltip',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [TooltipOptionsService]
+                }] }, { type: i0.ElementRef }, { type: i0.ComponentFactoryResolver }, { type: i0.ApplicationRef }, { type: i0.Injector }]; }, propDecorators: { options: [{
+                type: Input,
+                args: ['options']
+            }], tooltipValue: [{
+                type: Input,
+                args: ['tooltip']
+            }], placement: [{
+                type: Input,
+                args: ['placement']
+            }], autoPlacement: [{
+                type: Input,
+                args: ['autoPlacement']
+            }], contentTypeBackwardCompatibility: [{
+                type: Input,
+                args: ['content-type']
+            }], contentType: [{
+                type: Input,
+                args: ['contentType']
+            }], hideDelayMobile: [{
+                type: Input,
+                args: ['hide-delay-mobile']
+            }], hideDelayTouchscreen: [{
+                type: Input,
+                args: ['hideDelayTouchscreen']
+            }], zIndexBackwardCompatibility: [{
+                type: Input,
+                args: ['z-index']
+            }], zIndex: [{
+                type: Input,
+                args: ['zIndex']
+            }], animationDurationBackwardCompatibility: [{
+                type: Input,
+                args: ['animation-duration']
+            }], animationDuration: [{
+                type: Input,
+                args: ['animationDuration']
+            }], trigger: [{
+                type: Input,
+                args: ['trigger']
+            }], tooltipClassBackwardCompatibility: [{
+                type: Input,
+                args: ['tooltip-class']
+            }], tooltipClass: [{
+                type: Input,
+                args: ['tooltipClass']
+            }], display: [{
+                type: Input,
+                args: ['display']
+            }], displayMobile: [{
+                type: Input,
+                args: ['display-mobile']
+            }], displayTouchscreen: [{
+                type: Input,
+                args: ['displayTouchscreen']
+            }], shadow: [{
+                type: Input,
+                args: ['shadow']
+            }], theme: [{
+                type: Input,
+                args: ['theme']
+            }], offset: [{
+                type: Input,
+                args: ['offset']
+            }], width: [{
+                type: Input,
+                args: ['width']
+            }], maxWidthBackwardCompatibility: [{
+                type: Input,
+                args: ['max-width']
+            }], maxWidth: [{
+                type: Input,
+                args: ['maxWidth']
+            }], id: [{
+                type: Input,
+                args: ['id']
+            }], showDelayBackwardCompatibility: [{
+                type: Input,
+                args: ['show-delay']
+            }], showDelay: [{
+                type: Input,
+                args: ['showDelay']
+            }], hideDelayBackwardCompatibility: [{
+                type: Input,
+                args: ['hide-delay']
+            }], hideDelay: [{
+                type: Input,
+                args: ['hideDelay']
+            }], hideDelayAfterClick: [{
+                type: Input,
+                args: ['hideDelayAfterClick']
+            }], pointerEvents: [{
+                type: Input,
+                args: ['pointerEvents']
+            }], position: [{
+                type: Input,
+                args: ['position']
+            }], events: [{
+                type: Output
+            }], onMouseEnter: [{
+                type: HostListener,
+                args: ['focusin']
+            }, {
+                type: HostListener,
+                args: ['mouseenter']
+            }], onMouseLeave: [{
+                type: HostListener,
+                args: ['focusout']
+            }, {
+                type: HostListener,
+                args: ['mouseleave']
+            }], onClick: [{
+                type: HostListener,
+                args: ['click']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gravity-tooltip.directive.js","sourceRoot":"","sources":["../../../../../../projects/gravity-design-system/src/lib/vendor/gravity-tooltip/gravity-tooltip.directive.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,SAAS,EAGT,YAAY,EACZ,YAAY,EACZ,MAAM,EAEN,KAAK,EAEL,QAAQ,EACR,MAAM,EAGP,MAAM,eAAe,CAAC;AACvB,OAAO,EAAC,uBAAuB,EAAC,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAC,qBAAqB,EAAC,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAC,4BAA4B,EAAE,cAAc,EAAC,MAAM,WAAW,CAAC;;AAevE,MAAM,OAAO,uBAAuB;IAsBlC,IAAsB,OAAO,CAAC,KAAqB;QACjD,IAAI,KAAK,IAAI,cAAc,EAAE;YAC3B,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;SACvB;IACH,CAAC;IAED,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAMD,eAAe;IACf,IAA2B,gCAAgC,CAAC,KAAqC;QAC/F,IAAI,KAAK,EAAE;YACT,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;SAC3B;IACH,CAAC;IAED,IAA0B,WAAW,CAAC,KAAqC;QACzE,IAAI,KAAK,EAAE;YACT,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;SAC3B;IACH,CAAC;IAED,IAAI,WAAW;QACb,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAKD,UAAU;IACV,IAAsB,2BAA2B,CAAC,KAAa;QAC7D,IAAI,KAAK,EAAE;YACT,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;SACtB;IACH,CAAC;IAED,IAAqB,MAAM,CAAC,KAAa;QACvC,IAAI,KAAK,EAAE;YACT,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;SACtB;IACH,CAAC;IAED,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,qBAAqB;IACrB,IAAiC,sCAAsC,CAAC,KAAa;QACnF,IAAI,KAAK,EAAE;YACT,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;SACjC;IACH,CAAC;IAED,IAAgC,iBAAiB,CAAC,KAAa;QAC7D,IAAI,KAAK,EAAE;YACT,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;SACjC;IACH,CAAC;IAED,IAAI,iBAAiB;QACnB,OAAO,IAAI,CAAC,kBAAkB,CAAC;IACjC,CAAC;IAKD,gBAAgB;IAChB,IAA4B,iCAAiC,CAAC,KAAa;QACzE,IAAI,KAAK,EAAE;YACT,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;SAC5B;IACH,CAAC;IAED,IAA2B,YAAY,CAAC,KAAa;QACnD,IAAI,KAAK,EAAE;YACT,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;SAC5B;IACH,CAAC;IAED,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAUD,YAAY;IACZ,IAAwB,6BAA6B,CAAC,KAAa;QACjE,IAAI,KAAK,EAAE;YACT,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;SACxB;IACH,CAAC;IAED,IAAuB,QAAQ,CAAC,KAAa;QAC3C,IAAI,KAAK,EAAE;YACT,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;SACxB;IACH,CAAC;IAED,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAKD,aAAa;IACb,IAAyB,8BAA8B,CAAC,KAAa;QACnE,IAAI,KAAK,EAAE;YACT,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;SACzB;IACH,CAAC;IAED,IAAwB,SAAS,CAAC,KAAa;QAC7C,IAAI,KAAK,EAAE;YACT,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;SACzB;IACH,CAAC;IAED,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAED,aAAa;IACb,IAAyB,8BAA8B,CAAC,KAAa;QACnE,IAAI,KAAK,EAAE;YACT,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;SACzB;IACH,CAAC;IAED,IAAwB,SAAS,CAAC,KAAa;QAC7C,IAAI,KAAK,EAAE;YACT,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;SACzB;IACH,CAAC;IAED,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAMD,IAAI,kBAAkB;QACpB,OAAO,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,SAAS,CAAC;IACnE,CAAC;IAED,IAAI,YAAY;QACd,IAAI,IAAI,CAAC,aAAa,EAAE;YACtB,OAAO,IAAI,CAAC,aAAa,CAAC;SAC3B;aAAM;YACL,OAAO,MAAM,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC,CAAC;SAChF;IACH,CAAC;IAED,IAAI,YAAY,CAAC,KAAa;QAC5B,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;IAC7B,CAAC;IAED,IAAI,eAAe;QACjB,IAAI,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE;YAC5B,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;SACjC;aAAM;YACL,OAAO,IAAI,CAAC,eAAe,CAAC;SAC7B;IACH,CAAC;IAID,YACqD,WAAgB,EAC3D,UAAsB,EACtB,wBAAkD,EAClD,MAAsB,EACtB,QAAkB;QAJyB,gBAAW,GAAX,WAAW,CAAK;QAC3D,eAAU,GAAV,UAAU,CAAY;QACtB,6BAAwB,GAAxB,wBAAwB,CAA0B;QAClD,WAAM,GAAN,MAAM,CAAgB;QACtB,aAAQ,GAAR,QAAQ,CAAU;QArM5B,aAAQ,GAAQ,EAAE,CAAC;QAInB,iBAAY,GAAmC,QAAQ,CAAC;QA0L9C,WAAM,GAAsB,IAAI,YAAY,EAAO,CAAC;IAQ9D,CAAC;IAID,YAAY;QACV,IAAI,IAAI,CAAC,gBAAgB,IAAI,KAAK,EAAE;YAClC,OAAO;SACR;QAED,IAAI,CAAC,IAAI,EAAE,CAAC;IACd,CAAC;IAID,YAAY;QACV,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,OAAO,EAAE;YACvC,IAAI,CAAC,cAAc,EAAE,CAAC;SACvB;IACH,CAAC;IAGD,OAAO;QACL,IAAI,IAAI,CAAC,gBAAgB,IAAI,KAAK,EAAE;YAClC,OAAO;SACR;QAED,IAAI,CAAC,IAAI,EAAE,CAAC;QACZ,IAAI,CAAC,uBAAuB,GAAG,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE;YACpD,IAAI,CAAC,cAAc,EAAE,CAAC;QACxB,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,qBAAqB,CAAC,CAAC,CAAA;IACzC,CAAC;IAED,QAAQ;IACR,CAAC;IAED,WAAW,CAAC,OAAsB;QAChC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAC3D,IAAI,cAAc,GAAG,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QACjD,cAAc,GAAG,IAAI,CAAC,gBAAgB,CAAC,cAAc,CAAC,CAAC;QAEvD,IAAI,CAAC,mBAAmB,CAAC,cAAc,EAAE,cAAc,CAAC,CAAC;IAC3D,CAAC;IAED,WAAW;QACT,IAAI,CAAC,cAAc,CAAC;YAClB,IAAI,EAAE,IAAI;SACX,CAAC,CAAC;QAEH,IAAI,IAAI,CAAC,kBAAkB,EAAE;YAC3B,IAAI,CAAC,kBAAkB,CAAC,WAAW,EAAE,CAAC;SACvC;IACH,CAAC;IAED,YAAY;QACV,OAAO,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;IACnC,CAAC;IAED,YAAY;QACV,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;QAC5C,MAAM,oBAAoB,GAAG,IAAI,CAAC,OAAO,CAAC,sBAAsB,CAAC,CAAC;QAElE,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAC,SAAS,CAAC;IAC/D,CAAC;IAED,aAAa,CAAC,OAAsB;QAClC,IAAI,mBAAmB,GAAQ,EAAE,CAAC;QAClC,IAAI,gBAAgB,GAAQ,EAAE,CAAC;QAC/B,IAAI,aAAkB,CAAC;QAEvB,KAAK,IAAI,IAAI,IAAI,OAAO,EAAE;YACxB,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,cAAc,EAAE;gBACjD,mBAAmB,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,YAAY,CAAC;aACxD;YACD,IAAI,IAAI,KAAK,SAAS,EAAE;gBACtB,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,YAAY,CAAC;aAC/C;SACF;QAED,aAAa,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,gBAAgB,EAAE,mBAAmB,CAAC,CAAC;QACzE,OAAO,aAAa,CAAC;IACvB,CAAC;IAED,gBAAgB,CAAC,OAAY;QAC3B,KAAK,IAAI,IAAI,IAAI,OAAO,EAAE;YACxB,IAAI,4BAA4B,CAAC,IAAI,CAAC,EAAE;gBACtC,OAAO,CAAC,4BAA4B,CAAC,IAAI,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;gBAC5D,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC;aACtB;SACF;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,kBAAkB;QAChB,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,qBAAqB,EAAE,CAAC;IAC/E,CAAC;IAED,aAAa;QACX,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAE1B,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE;YAC5C,IAAI,CAAC,qBAAqB,CAAC,uBAAuB,CAAC,CAAC;QACtD,CAAC,EAAE,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC;QAExB,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE;YAC1C,IAAI,CAAC,eAAe,EAAE,CAAC;QACzB,CAAC,EAAE,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC;IAC1B,CAAC;IAED,cAAc,CAAC,OAAO,GAAG;QACvB,IAAI,EAAE,KAAK;KACZ;QACC,IAAI,CAAC,aAAa,EAAE,CAAC;QAErB,IAAI,IAAI,CAAC,kBAAkB,IAAI,KAAK,EAAE;YACpC,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE;gBAC1C,IAAI,CAAC,WAAW,EAAE,CAAC;YACrB,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC;YAE3C,IAAI,CAAC,gBAAgB,GAAG,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE;gBAC7C,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,kBAAkB,EAAE;oBACjD,OAAO;iBACR;gBAED,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;gBACnD,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,CAAC;gBAC5B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;oBACf,IAAI,EAAE,QAAQ;oBACd,QAAQ,EAAE,IAAI,CAAC,eAAe;iBAC/B,CAAC,CAAC;YACL,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;SAC1C;IACH,CAAC;IAED,eAAe;QACb,IAAI,CAAC,aAAa,EAAE,CAAC;QACP,IAAI,CAAC,YAAY,CAAC,QAAS,CAAC,IAAI,GAAG,IAAI,CAAC;QACtD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;YACf,IAAI,EAAE,MAAM;YACZ,QAAQ,EAAE,IAAI,CAAC,eAAe;SAC/B,CAAC,CAAC;IACL,CAAC;IAED,WAAW;QACT,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,kBAAkB,EAAE;YACjD,OAAO;SACR;QACa,IAAI,CAAC,YAAY,CAAC,QAAS,CAAC,IAAI,GAAG,KAAK,CAAC;QACvD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;YACf,IAAI,EAAE,MAAM;YACZ,QAAQ,EAAE,IAAI,CAAC,eAAe;SAC/B,CAAC,CAAC;IACL,CAAC;IAED,qBAAqB,CAAC,SAAc;QAClC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,wBAAwB;aAC9C,uBAAuB,CAAC,SAAS,CAAC;aAClC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAEX,IAAI,CAAC,YAAY,CAAC,QAAS,CAAC,IAAI,GAAG;YAC/C,KAAK,EAAE,IAAI,CAAC,YAAY;YACxB,OAAO,EAAE,IAAI,CAAC,UAAU,CAAC,aAAa;YACtC,eAAe,EAAE,IAAI,CAAC,eAAe;YACrC,OAAO,EAAE,IAAI,CAAC,OAAO;SACtB,CAAA;QACD,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;QACnD,MAAM,OAAO,GAAI,IAAI,CAAC,YAAY,CAAC,QAAiC,CAAC,SAAS,CAAC,CAAC,CAAgB,CAAC;QACjG,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QAEnC,IAAI,CAAC,kBAAkB,GAAiB,IAAI,CAAC,YAAY,CAAC,QAAS,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,KAAU,EAAE,EAAE;YAClG,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;QAC3B,CAAC,CAAC,CAAC;IACL,CAAC;IAED,aAAa;QACX,IAAI,IAAI,CAAC,eAAe,EAAE;YACxB,YAAY,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;SACpC;QAED,IAAI,IAAI,CAAC,aAAa,EAAE;YACtB,YAAY,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;SAClC;QAED,IAAI,IAAI,CAAC,aAAa,EAAE;YACtB,YAAY,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;SAClC;QAED,IAAI,IAAI,CAAC,gBAAgB,EAAE;YACzB,YAAY,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;SACrC;IACH,CAAC;IAED,IAAI,gBAAgB;QAClB,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,KAAK,EAAE;YACpC,OAAO,KAAK,CAAC;SACd;QAED,IAAI,IAAI,CAAC,OAAO,CAAC,oBAAoB,CAAC,IAAI,KAAK,IAAI,IAAI,CAAC,aAAa,EAAE;YACrE,OAAO,KAAK,CAAC;SACd;QAED,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,OAAO,CAAC;IAC7C,CAAC;IAED,IAAI,gBAAgB;QAClB,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,KAAK,EAAE;YACpC,OAAO,KAAK,CAAC;SACd;QAED,IAAI,IAAI,CAAC,OAAO,CAAC,oBAAoB,CAAC,IAAI,KAAK,IAAI,IAAI,CAAC,aAAa,EAAE;YACrE,OAAO,KAAK,CAAC;SACd;QAED,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,OAAO,CAAC;IAG5C,CAAC;IAED,IAAI,aAAa;QACf,IAAI,QAAQ,GAAG,2BAA2B,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACtD,IAAI,EAAE,GAAG,UAAU,KAAU;YAC3B,OAAO,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC;QAC1C,CAAC,CAAA;QAED,IAAI,CAAC,cAAc,IAAI,MAAM,CAAC,EAAE;YAC9B,OAAO,IAAI,CAAC;SACb;QAED,qFAAqF;QACrF,uBAAuB;QACvB,IAAI,KAAK,GAAG,CAAC,GAAG,EAAE,QAAQ,CAAC,IAAI,CAAC,kBAAkB,CAAC,EAAE,QAAQ,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAC7E,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;IACnB,CAAC;IAED,mBAAmB,CAAC,cAAmB,EAAE,OAAY;QACnD,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,cAAc,EAAE,IAAI,CAAC,WAAW,IAAI,EAAE,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAClG,CAAC;IAED,YAAY,CAAC,KAAU;QACrB,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO,EAAE;YAC1B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;gBACf,IAAI,EAAE,OAAO;gBACb,QAAQ,EAAE,IAAI,CAAC,eAAe;aAC/B,CAAC,CAAC;SACJ;IACH,CAAC;IAEM,IAAI;QACT,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE;YACtB,OAAO;SACR;QAED,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,kBAAkB,EAAE;YACjD,IAAI,CAAC,aAAa,EAAE,CAAC;SACtB;aAAM,IAAI,CAAC,IAAI,CAAC,kBAAkB,EAAE;YACnC,IAAI,CAAC,eAAe,EAAE,CAAC;SACxB;IACH,CAAC;IAEM,IAAI;QACT,IAAI,CAAC,cAAc,EAAE,CAAC;IACxB,CAAC;;oHAtdU,uBAAuB,kBA2MZ,qBAAqB;wGA3MhC,uBAAuB;2FAAvB,uBAAuB;kBALnC,SAAS;mBAAC;oBACT,QAAQ,EAAE,WAAW;oBACrB,QAAQ,EAAE,SAAS;iBACpB;;0BA6MI,QAAQ;;0BAAI,MAAM;2BAAC,qBAAqB;gKArLrB,OAAO;sBAA5B,KAAK;uBAAC,SAAS;gBAUE,YAAY;sBAA7B,KAAK;uBAAC,SAAS;gBACI,SAAS;sBAA5B,KAAK;uBAAC,WAAW;gBACM,aAAa;sBAApC,KAAK;uBAAC,eAAe;gBAGK,gCAAgC;sBAA1D,KAAK;uBAAC,cAAc;gBAMK,WAAW;sBAApC,KAAK;uBAAC,aAAa;gBAUQ,eAAe;sBAA1C,KAAK;uBAAC,mBAAmB;gBACK,oBAAoB;sBAAlD,KAAK;uBAAC,sBAAsB;gBAGP,2BAA2B;sBAAhD,KAAK;uBAAC,SAAS;gBAMK,MAAM;sBAA1B,KAAK;uBAAC,QAAQ;gBAWkB,sCAAsC;sBAAtE,KAAK;uBAAC,oBAAoB;gBAMK,iBAAiB;sBAAhD,KAAK;uBAAC,mBAAmB;gBAWR,OAAO;sBAAxB,KAAK;uBAAC,SAAS;gBAGY,iCAAiC;sBAA5D,KAAK;uBAAC,eAAe;gBAMK,YAAY;sBAAtC,KAAK;uBAAC,cAAc;gBAUH,OAAO;sBAAxB,KAAK;uBAAC,SAAS;gBACS,aAAa;sBAArC,KAAK;uBAAC,gBAAgB;gBACM,kBAAkB;sBAA9C,KAAK;uBAAC,oBAAoB;gBACV,MAAM;sBAAtB,KAAK;uBAAC,QAAQ;gBACC,KAAK;sBAApB,KAAK;uBAAC,OAAO;gBACG,MAAM;sBAAtB,KAAK;uBAAC,QAAQ;gBACC,KAAK;sBAApB,KAAK;uBAAC,OAAO;gBAGU,6BAA6B;sBAApD,KAAK;uBAAC,WAAW;gBAMK,QAAQ;sBAA9B,KAAK;uBAAC,UAAU;gBAWJ,EAAE;sBAAd,KAAK;uBAAC,IAAI;gBAGc,8BAA8B;sBAAtD,KAAK;uBAAC,YAAY;gBAMK,SAAS;sBAAhC,KAAK;uBAAC,WAAW;gBAWO,8BAA8B;sBAAtD,KAAK;uBAAC,YAAY;gBAMK,SAAS;sBAAhC,KAAK;uBAAC,WAAW;gBAUY,mBAAmB;sBAAhD,KAAK;uBAAC,qBAAqB;gBACJ,aAAa;sBAApC,KAAK;uBAAC,eAAe;gBACH,QAAQ;sBAA1B,KAAK;uBAAC,UAAU;gBA0BP,MAAM;sBAAf,MAAM;gBAYP,YAAY;sBAFX,YAAY;uBAAC,SAAS;;sBACtB,YAAY;uBAAC,YAAY;gBAW1B,YAAY;sBAFX,YAAY;uBAAC,UAAU;;sBACvB,YAAY;uBAAC,YAAY;gBAQ1B,OAAO;sBADN,YAAY;uBAAC,OAAO","sourcesContent":["import {\n  ApplicationRef,\n  ComponentFactoryResolver,\n  Directive,\n  ElementRef,\n  EmbeddedViewRef,\n  EventEmitter,\n  HostListener,\n  Inject,\n  Injector,\n  Input,\n  OnChanges,\n  Optional,\n  Output,\n  SimpleChanges,\n  TemplateRef\n} from '@angular/core';\nimport {GravityTooltipComponent} from './gravity-tooltip.component';\nimport {TooltipOptionsService} from './options.service';\nimport {backwardCompatibilityOptions, defaultOptions} from './options';\nimport {TooltipOptions} from './options.interface';\n\nexport interface AdComponent {\n  data: any;\n  show: boolean;\n  close: boolean;\n  events: any;\n}\n\n@Directive({\n  selector: '[tooltip]',\n  exportAs: 'tooltip',\n})\n\nexport class GravityTooltipDirective implements OnChanges {\n\n  hideTimeoutId!: number;\n  destroyTimeoutId!: number;\n  hideAfterClickTimeoutId!: number;\n  createTimeoutId!: number;\n  showTimeoutId!: number;\n  componentRef: any;\n  elementPosition: any;\n  _id: any;\n  _options: any = {};\n  _defaultOptions: any;\n  _destroyDelay!: number;\n  componentSubscribe: any;\n  _contentType: \"string\" | \"html\" | \"template\" = \"string\";\n  _showDelay!: number;\n  _hideDelay!: number;\n  _zIndex!: number;\n  _tooltipClass!: string;\n  _animationDuration!: number;\n  _maxWidth!: string;\n\n  @Input('options') set options(value: TooltipOptions) {\n    if (value && defaultOptions) {\n      this._options = value;\n    }\n  }\n\n  get options() {\n    return this._options;\n  }\n\n  @Input('tooltip') tooltipValue!: string | TemplateRef<any>;\n  @Input('placement') placement!: string;\n  @Input('autoPlacement') autoPlacement!: boolean;\n\n  // Content type\n  @Input('content-type') set contentTypeBackwardCompatibility(value: \"string\" | \"html\" | \"template\") {\n    if (value) {\n      this._contentType = value;\n    }\n  }\n\n  @Input('contentType') set contentType(value: \"string\" | \"html\" | \"template\") {\n    if (value) {\n      this._contentType = value;\n    }\n  }\n\n  get contentType() {\n    return this._contentType;\n  }\n\n  @Input('hide-delay-mobile') hideDelayMobile!: number;\n  @Input('hideDelayTouchscreen') hideDelayTouchscreen!: number;\n\n  // z-index\n  @Input('z-index') set zIndexBackwardCompatibility(value: number) {\n    if (value) {\n      this._zIndex = value;\n    }\n  }\n\n  @Input('zIndex') set zIndex(value: number) {\n    if (value) {\n      this._zIndex = value;\n    }\n  }\n\n  get zIndex() {\n    return this._zIndex;\n  }\n\n  // Animation duration\n  @Input('animation-duration') set animationDurationBackwardCompatibility(value: number) {\n    if (value) {\n      this._animationDuration = value;\n    }\n  }\n\n  @Input('animationDuration') set animationDuration(value: number) {\n    if (value) {\n      this._animationDuration = value;\n    }\n  }\n\n  get animationDuration() {\n    return this._animationDuration;\n  }\n\n\n  @Input('trigger') trigger!: string;\n\n  // Tooltip class\n  @Input('tooltip-class') set tooltipClassBackwardCompatibility(value: string) {\n    if (value) {\n      this._tooltipClass = value;\n    }\n  }\n\n  @Input('tooltipClass') set tooltipClass(value: string) {\n    if (value) {\n      this._tooltipClass = value;\n    }\n  }\n\n  get tooltipClass() {\n    return this._tooltipClass;\n  }\n\n  @Input('display') display!: boolean;\n  @Input('display-mobile') displayMobile!: boolean;\n  @Input('displayTouchscreen') displayTouchscreen!: boolean;\n  @Input('shadow') shadow!: boolean;\n  @Input('theme') theme!: \"dark\" | \"light\";\n  @Input('offset') offset!: number;\n  @Input('width') width!: string;\n\n  // Max width\n  @Input('max-width') set maxWidthBackwardCompatibility(value: string) {\n    if (value) {\n      this._maxWidth = value;\n    }\n  }\n\n  @Input('maxWidth') set maxWidth(value: string) {\n    if (value) {\n      this._maxWidth = value;\n    }\n  }\n\n  get maxWidth() {\n    return this._maxWidth;\n  }\n\n\n  @Input('id') id: any;\n\n  // Show delay\n  @Input('show-delay') set showDelayBackwardCompatibility(value: number) {\n    if (value) {\n      this._showDelay = value;\n    }\n  }\n\n  @Input('showDelay') set showDelay(value: number) {\n    if (value) {\n      this._showDelay = value;\n    }\n  }\n\n  get showDelay() {\n    return this._showDelay;\n  }\n\n  // Hide delay\n  @Input('hide-delay') set hideDelayBackwardCompatibility(value: number) {\n    if (value) {\n      this._hideDelay = value;\n    }\n  }\n\n  @Input('hideDelay') set hideDelay(value: number) {\n    if (value) {\n      this._hideDelay = value;\n    }\n  }\n\n  get hideDelay() {\n    return this._hideDelay;\n  }\n\n  @Input('hideDelayAfterClick') hideDelayAfterClick!: number;\n  @Input('pointerEvents') pointerEvents!: 'auto' | 'none';\n  @Input('position') position!: { top: number, left: number };\n\n  get isTooltipDestroyed() {\n    return this.componentRef && this.componentRef.hostView.destroyed;\n  }\n\n  get destroyDelay() {\n    if (this._destroyDelay) {\n      return this._destroyDelay;\n    } else {\n      return Number(this.getHideDelay()) + Number(this.options['animationDuration']);\n    }\n  }\n\n  set destroyDelay(value: number) {\n    this._destroyDelay = value;\n  }\n\n  get tooltipPosition() {\n    if (this.options['position']) {\n      return this.options['position'];\n    } else {\n      return this.elementPosition;\n    }\n  }\n\n  @Output() events: EventEmitter<any> = new EventEmitter<any>();\n\n  constructor(\n    @Optional() @Inject(TooltipOptionsService) private initOptions: any,\n    private elementRef: ElementRef,\n    private componentFactoryResolver: ComponentFactoryResolver,\n    private appRef: ApplicationRef,\n    private injector: Injector) {\n  }\n\n  @HostListener('focusin')\n  @HostListener('mouseenter')\n  onMouseEnter() {\n    if (this.isDisplayOnHover == false) {\n      return;\n    }\n\n    this.show();\n  }\n\n  @HostListener('focusout')\n  @HostListener('mouseleave')\n  onMouseLeave() {\n    if (this.options['trigger'] === 'hover') {\n      this.destroyTooltip();\n    }\n  }\n\n  @HostListener('click')\n  onClick() {\n    if (this.isDisplayOnClick == false) {\n      return;\n    }\n\n    this.show();\n    this.hideAfterClickTimeoutId = window.setTimeout(() => {\n      this.destroyTooltip();\n    }, this.options['hideDelayAfterClick'])\n  }\n\n  ngOnInit(): void {\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    this.initOptions = this.renameProperties(this.initOptions);\n    let changedOptions = this.getProperties(changes);\n    changedOptions = this.renameProperties(changedOptions);\n\n    this.applyOptionsDefault(defaultOptions, changedOptions);\n  }\n\n  ngOnDestroy(): void {\n    this.destroyTooltip({\n      fast: true\n    });\n\n    if (this.componentSubscribe) {\n      this.componentSubscribe.unsubscribe();\n    }\n  }\n\n  getShowDelay() {\n    return this.options['showDelay'];\n  }\n\n  getHideDelay() {\n    const hideDelay = this.options['hideDelay'];\n    const hideDelayTouchscreen = this.options['hideDelayTouchscreen'];\n\n    return this.isTouchScreen ? hideDelayTouchscreen : hideDelay;\n  }\n\n  getProperties(changes: SimpleChanges) {\n    let directiveProperties: any = {};\n    let customProperties: any = {};\n    let allProperties: any;\n\n    for (var prop in changes) {\n      if (prop !== 'options' && prop !== 'tooltipValue') {\n        directiveProperties[prop] = changes[prop].currentValue;\n      }\n      if (prop === 'options') {\n        customProperties = changes[prop].currentValue;\n      }\n    }\n\n    allProperties = Object.assign({}, customProperties, directiveProperties);\n    return allProperties;\n  }\n\n  renameProperties(options: any) {\n    for (var prop in options) {\n      if (backwardCompatibilityOptions[prop]) {\n        options[backwardCompatibilityOptions[prop]] = options[prop];\n        delete options[prop];\n      }\n    }\n\n    return options;\n  }\n\n  getElementPosition(): void {\n    this.elementPosition = this.elementRef.nativeElement.getBoundingClientRect();\n  }\n\n  createTooltip(): void {\n    this.clearTimeouts();\n    this.getElementPosition();\n\n    this.createTimeoutId = window.setTimeout(() => {\n      this.appendComponentToBody(GravityTooltipComponent);\n    }, this.getShowDelay());\n\n    this.showTimeoutId = window.setTimeout(() => {\n      this.showTooltipElem();\n    }, this.getShowDelay());\n  }\n\n  destroyTooltip(options = {\n    fast: false\n  }): void {\n    this.clearTimeouts();\n\n    if (this.isTooltipDestroyed == false) {\n      this.hideTimeoutId = window.setTimeout(() => {\n        this.hideTooltip();\n      }, options.fast ? 0 : this.getHideDelay());\n\n      this.destroyTimeoutId = window.setTimeout(() => {\n        if (!this.componentRef || this.isTooltipDestroyed) {\n          return;\n        }\n\n        this.appRef.detachView(this.componentRef.hostView);\n        this.componentRef.destroy();\n        this.events.emit({\n          type: 'hidden',\n          position: this.tooltipPosition\n        });\n      }, options.fast ? 0 : this.destroyDelay);\n    }\n  }\n\n  showTooltipElem(): void {\n    this.clearTimeouts();\n    (<AdComponent>this.componentRef.instance).show = true;\n    this.events.emit({\n      type: 'show',\n      position: this.tooltipPosition\n    });\n  }\n\n  hideTooltip(): void {\n    if (!this.componentRef || this.isTooltipDestroyed) {\n      return;\n    }\n    (<AdComponent>this.componentRef.instance).show = false;\n    this.events.emit({\n      type: 'hide',\n      position: this.tooltipPosition\n    });\n  }\n\n  appendComponentToBody(component: any): void {\n    this.componentRef = this.componentFactoryResolver\n      .resolveComponentFactory(component)\n      .create(this.injector);\n\n    (<AdComponent>this.componentRef.instance).data = {\n      value: this.tooltipValue,\n      element: this.elementRef.nativeElement,\n      elementPosition: this.tooltipPosition,\n      options: this.options\n    }\n    this.appRef.attachView(this.componentRef.hostView);\n    const domElem = (this.componentRef.hostView as EmbeddedViewRef<any>).rootNodes[0] as HTMLElement;\n    document.body.appendChild(domElem);\n\n    this.componentSubscribe = (<AdComponent>this.componentRef.instance).events.subscribe((event: any) => {\n      this.handleEvents(event);\n    });\n  }\n\n  clearTimeouts(): void {\n    if (this.createTimeoutId) {\n      clearTimeout(this.createTimeoutId);\n    }\n\n    if (this.showTimeoutId) {\n      clearTimeout(this.showTimeoutId);\n    }\n\n    if (this.hideTimeoutId) {\n      clearTimeout(this.hideTimeoutId);\n    }\n\n    if (this.destroyTimeoutId) {\n      clearTimeout(this.destroyTimeoutId);\n    }\n  }\n\n  get isDisplayOnHover(): boolean {\n    if (this.options['display'] == false) {\n      return false;\n    }\n\n    if (this.options['displayTouchscreen'] == false && this.isTouchScreen) {\n      return false;\n    }\n\n    return this.options['trigger'] === 'hover';\n  }\n\n  get isDisplayOnClick(): boolean {\n    if (this.options['display'] == false) {\n      return false;\n    }\n\n    if (this.options['displayTouchscreen'] == false && this.isTouchScreen) {\n      return false;\n    }\n\n    return this.options['trigger'] == 'click';\n\n\n  }\n\n  get isTouchScreen() {\n    var prefixes = ' -webkit- -moz- -o- -ms- '.split(' ');\n    var mq = function (query: any) {\n      return window.matchMedia(query).matches;\n    }\n\n    if (('ontouchstart' in window)) {\n      return true;\n    }\n\n    // include the 'heartz' as a way to have a non matching MQ to help terminate the join\n    // https://git.io/vznFH\n    var query = ['(', prefixes.join('touch-enabled),('), 'heartz', ')'].join('');\n    return mq(query);\n  }\n\n  applyOptionsDefault(defaultOptions: any, options: any): void {\n    this.options = Object.assign({}, defaultOptions, this.initOptions || {}, this.options, options);\n  }\n\n  handleEvents(event: any) {\n    if (event.type === 'shown') {\n      this.events.emit({\n        type: 'shown',\n        position: this.tooltipPosition\n      });\n    }\n  }\n\n  public show() {\n    if (!this.tooltipValue) {\n      return;\n    }\n\n    if (!this.componentRef || this.isTooltipDestroyed) {\n      this.createTooltip();\n    } else if (!this.isTooltipDestroyed) {\n      this.showTooltipElem();\n    }\n  }\n\n  public hide() {\n    this.destroyTooltip();\n  }\n}\n"]}

package/esm2020/lib/vendor/gravity-tooltip/gravity-tooltip.module.mjs

@@ -0,0 +1,41 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { GravityTooltipDirective } from './gravity-tooltip.directive';
+import { GravityTooltipComponent } from './gravity-tooltip.component';
+import { TooltipOptionsService } from './options.service';
+import * as i0 from "@angular/core";
+export class GravityTooltipModule {
+    static forRoot(initOptions) {
+        return {
+            ngModule: GravityTooltipModule,
+            providers: [
+                {
+                    provide: TooltipOptionsService,
+                    useValue: initOptions
+                }
+            ]
+        };
+    }
+}
+GravityTooltipModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: GravityTooltipModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+GravityTooltipModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.1.5", ngImport: i0, type: GravityTooltipModule, declarations: [GravityTooltipDirective,
+        GravityTooltipComponent], imports: [CommonModule], exports: [GravityTooltipDirective,
+        GravityTooltipComponent] });
+GravityTooltipModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: GravityTooltipModule, imports: [CommonModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: GravityTooltipModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        GravityTooltipDirective,
+                        GravityTooltipComponent
+                    ],
+                    imports: [
+                        CommonModule
+                    ],
+                    exports: [
+                        GravityTooltipDirective,
+                        GravityTooltipComponent
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/vendor/gravity-tooltip/index.mjs

@@ -0,0 +1,4 @@
+export * from './gravity-tooltip.component';
+export * from './gravity-tooltip.directive';
+export * from './gravity-tooltip.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9ncmF2aXR5LWRlc2lnbi1zeXN0ZW0vc3JjL2xpYi92ZW5kb3IvZ3Jhdml0eS10b29sdGlwL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLDBCQUEwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9ncmF2aXR5LXRvb2x0aXAuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vZ3Jhdml0eS10b29sdGlwLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2dyYXZpdHktdG9vbHRpcC5tb2R1bGUnO1xuIl19

package/esm2020/lib/vendor/gravity-tooltip/options.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9ucy5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9ncmF2aXR5LWRlc2lnbi1zeXN0ZW0vc3JjL2xpYi92ZW5kb3IvZ3Jhdml0eS10b29sdGlwL29wdGlvbnMuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIFRvb2x0aXBPcHRpb25zIHtcbiAgJ3BsYWNlbWVudCc/OiBzdHJpbmc7XG4gICdhdXRvUGxhY2VtZW50Jz86IGJvb2xlYW47XG4gICdjb250ZW50LXR5cGUnPzogJ3N0cmluZycgfCAnaHRtbCcgfCAndGVtcGxhdGUnO1xuICAnY29udGVudFR5cGUnPzogJ3N0cmluZycgfCAnaHRtbCcgfCAndGVtcGxhdGUnO1xuICAnZGVsYXknPzogbnVtYmVyO1xuICAnc2hvdy1kZWxheSc/OiBudW1iZXI7XG4gICdzaG93RGVsYXknPzogbnVtYmVyO1xuICAnaGlkZS1kZWxheSc/OiBudW1iZXI7XG4gICdoaWRlRGVsYXknPzogbnVtYmVyO1xuICAnaGlkZS1kZWxheS1tb2JpbGUnPzogbnVtYmVyO1xuICAnaGlkZURlbGF5TW9iaWxlJz86IG51bWJlcjtcbiAgJ2hpZGVEZWxheVRvdWNoc2NyZWVuJz86IG51bWJlcjtcbiAgJ3otaW5kZXgnPzogbnVtYmVyO1xuICAnekluZGV4Jz86IG51bWJlcjtcbiAgJ2FuaW1hdGlvbi1kdXJhdGlvbic/OiBudW1iZXI7XG4gICdhbmltYXRpb25EdXJhdGlvbic/OiBudW1iZXI7XG4gICdhbmltYXRpb24tZHVyYXRpb24tZGVmYXVsdCc/OiBudW1iZXI7XG4gICdhbmltYXRpb25EdXJhdGlvbkRlZmF1bHQnPzogbnVtYmVyO1xuICAndHJpZ2dlcic/OiBzdHJpbmc7XG4gICd0b29sdGlwLWNsYXNzJz86IHN0cmluZztcbiAgJ3Rvb2x0aXBDbGFzcyc/OiBzdHJpbmc7XG4gICdkaXNwbGF5Jz86IGJvb2xlYW47XG4gICdkaXNwbGF5LW1vYmlsZSc/OiBib29sZWFuO1xuICAnZGlzcGxheU1vYmlsZSc/OiBib29sZWFuO1xuICAnZGlzcGxheVRvdWNoc2NyZWVuJz86IGJvb2xlYW47XG4gICdzaGFkb3cnPzogYm9vbGVhbjtcbiAgJ3RoZW1lJz86IFwiZGFya1wiIHwgXCJsaWdodFwiO1xuICAnb2Zmc2V0Jz86IG51bWJlcjtcbiAgJ3dpZHRoJz86IHN0cmluZztcbiAgJ21heC13aWR0aCc/OiBzdHJpbmc7XG4gICdtYXhXaWR0aCc/OiBzdHJpbmc7XG4gICdpZCc/OiBzdHJpbmcgfCBudW1iZXI7XG4gICdoaWRlRGVsYXlBZnRlckNsaWNrJz86IG51bWJlcjtcbiAgJ3BvaW50ZXJFdmVudHMnPzogJ2F1dG8nIHwgJ25vbmUnO1xuICAncG9zaXRpb24nPzogeyB0b3A6IG51bWJlciwgbGVmdDogbnVtYmVyIH07XG59XG4iXX0=

package/esm2020/lib/vendor/gravity-tooltip/options.mjs

@@ -0,0 +1,38 @@
+export const defaultOptions = {
+    'placement': 'top',
+    'autoPlacement': true,
+    'contentType': 'string',
+    'showDelay': 0,
+    'hideDelay': 300,
+    'hideDelayMobile': 0,
+    'hideDelayTouchscreen': 0,
+    'zIndex': 0,
+    'animationDuration': 300,
+    'animationDurationDefault': 300,
+    'trigger': 'hover',
+    'tooltipClass': '',
+    'display': true,
+    'displayMobile': true,
+    'displayTouchscreen': true,
+    'shadow': true,
+    'theme': 'dark',
+    'offset': 8,
+    'maxWidth': '',
+    'id': false,
+    'hideDelayAfterClick': 2000
+};
+export const backwardCompatibilityOptions = {
+    'delay': 'showDelay',
+    'show-delay': 'showDelay',
+    'hide-delay': 'hideDelay',
+    'hide-delay-mobile': 'hideDelayTouchscreen',
+    'hideDelayMobile': 'hideDelayTouchscreen',
+    'z-index': 'zIndex',
+    'animation-duration': 'animationDuration',
+    'animation-duration-default': 'animationDurationDefault',
+    'tooltip-class': 'tooltipClass',
+    'display-mobile': 'displayTouchscreen',
+    'displayMobile': 'displayTouchscreen',
+    'max-width': 'maxWidth'
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/vendor/gravity-tooltip/options.service.mjs

@@ -0,0 +1,7 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * This is not a real service, but it looks like it from the outside.
+ * It's just an InjectionToken used to import the config (initOptions) object, provided from the outside
+ */
+export const TooltipOptionsService = new InjectionToken('TooltipOptions');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9ucy5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZ3Jhdml0eS1kZXNpZ24tc3lzdGVtL3NyYy9saWIvdmVuZG9yL2dyYXZpdHktdG9vbHRpcC9vcHRpb25zLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUcvQzs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxxQkFBcUIsR0FBRyxJQUFJLGNBQWMsQ0FBaUIsZ0JBQWdCLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBUb29sdGlwT3B0aW9ucyB9IGZyb20gJy4vb3B0aW9ucy5pbnRlcmZhY2UnO1xuXG4vKipcbiAqIFRoaXMgaXMgbm90IGEgcmVhbCBzZXJ2aWNlLCBidXQgaXQgbG9va3MgbGlrZSBpdCBmcm9tIHRoZSBvdXRzaWRlLlxuICogSXQncyBqdXN0IGFuIEluamVjdGlvblRva2VuIHVzZWQgdG8gaW1wb3J0IHRoZSBjb25maWcgKGluaXRPcHRpb25zKSBvYmplY3QsIHByb3ZpZGVkIGZyb20gdGhlIG91dHNpZGVcbiAqL1xuZXhwb3J0IGNvbnN0IFRvb2x0aXBPcHRpb25zU2VydmljZSA9IG5ldyBJbmplY3Rpb25Ub2tlbjxUb29sdGlwT3B0aW9ucz4oJ1Rvb2x0aXBPcHRpb25zJyk7XG4iXX0=