VLEX/BPM-UI/node_modules/ngx-tooltip/ngx-tooltip.system.js

var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
System.register("ngx-tooltip/TooltipContent", ["@angular/core"], function (exports_1, context_1) {
    "use strict";
    var __moduleName = context_1 && context_1.id;
    var core_1, TooltipContent;
    return {
        setters: [
            function (core_1_1) {
                core_1 = core_1_1;
            }
        ],
        execute: function () {
            TooltipContent = (function () {
                // -------------------------------------------------------------------------
                // Constructor
                // -------------------------------------------------------------------------
                function TooltipContent(element, cdr) {
                    this.element = element;
                    this.cdr = cdr;
                    this.placement = "bottom";
                    this.animation = true;
                    // -------------------------------------------------------------------------
                    // Properties
                    // -------------------------------------------------------------------------
                    this.top = -100000;
                    this.left = -100000;
                    this.isIn = false;
                    this.isFade = false;
                }
                // -------------------------------------------------------------------------
                // Lifecycle callbacks
                // -------------------------------------------------------------------------
                TooltipContent.prototype.ngAfterViewInit = function () {
                    this.show();
                    this.cdr.detectChanges();
                };
                // -------------------------------------------------------------------------
                // Public Methods
                // -------------------------------------------------------------------------
                TooltipContent.prototype.show = function () {
                    if (!this.hostElement)
                        return;
                    var p = this.positionElements(this.hostElement, this.element.nativeElement.children[0], this.placement);
                    this.top = p.top;
                    this.left = p.left;
                    this.isIn = true;
                    if (this.animation)
                        this.isFade = true;
                };
                TooltipContent.prototype.hide = function () {
                    this.top = -100000;
                    this.left = -100000;
                    this.isIn = true;
                    if (this.animation)
                        this.isFade = false;
                };
                // -------------------------------------------------------------------------
                // Private Methods
                // -------------------------------------------------------------------------
                TooltipContent.prototype.positionElements = function (hostEl, targetEl, positionStr, appendToBody) {
                    if (appendToBody === void 0) { appendToBody = false; }
                    var positionStrParts = positionStr.split("-");
                    var pos0 = positionStrParts[0];
                    var pos1 = positionStrParts[1] || "center";
                    var hostElPos = appendToBody ? this.offset(hostEl) : this.position(hostEl);
                    var targetElWidth = targetEl.offsetWidth;
                    var targetElHeight = targetEl.offsetHeight;
                    var shiftWidth = {
                        center: function () {
                            return hostElPos.left + hostElPos.width / 2 - targetElWidth / 2;
                        },
                        left: function () {
                            return hostElPos.left;
                        },
                        right: function () {
                            return hostElPos.left + hostElPos.width;
                        }
                    };
                    var shiftHeight = {
                        center: function () {
                            return hostElPos.top + hostElPos.height / 2 - targetElHeight / 2;
                        },
                        top: function () {
                            return hostElPos.top;
                        },
                        bottom: function () {
                            return hostElPos.top + hostElPos.height;
                        }
                    };
                    var targetElPos;
                    switch (pos0) {
                        case "right":
                            targetElPos = {
                                top: shiftHeight[pos1](),
                                left: shiftWidth[pos0]()
                            };
                            break;
                        case "left":
                            targetElPos = {
                                top: shiftHeight[pos1](),
                                left: hostElPos.left - targetElWidth
                            };
                            break;
                        case "bottom":
                            targetElPos = {
                                top: shiftHeight[pos0](),
                                left: shiftWidth[pos1]()
                            };
                            break;
                        default:
                            targetElPos = {
                                top: hostElPos.top - targetElHeight,
                                left: shiftWidth[pos1]()
                            };
                            break;
                    }
                    return targetElPos;
                };
                TooltipContent.prototype.position = function (nativeEl) {
                    var offsetParentBCR = { top: 0, left: 0 };
                    var elBCR = this.offset(nativeEl);
                    var offsetParentEl = this.parentOffsetEl(nativeEl);
                    if (offsetParentEl !== window.document) {
                        offsetParentBCR = this.offset(offsetParentEl);
                        offsetParentBCR.top += offsetParentEl.clientTop - offsetParentEl.scrollTop;
                        offsetParentBCR.left += offsetParentEl.clientLeft - offsetParentEl.scrollLeft;
                    }
                    var boundingClientRect = nativeEl.getBoundingClientRect();
                    return {
                        width: boundingClientRect.width || nativeEl.offsetWidth,
                        height: boundingClientRect.height || nativeEl.offsetHeight,
                        top: elBCR.top - offsetParentBCR.top,
                        left: elBCR.left - offsetParentBCR.left
                    };
                };
                TooltipContent.prototype.offset = function (nativeEl) {
                    var boundingClientRect = nativeEl.getBoundingClientRect();
                    return {
                        width: boundingClientRect.width || nativeEl.offsetWidth,
                        height: boundingClientRect.height || nativeEl.offsetHeight,
                        top: boundingClientRect.top + (window.pageYOffset || window.document.documentElement.scrollTop),
                        left: boundingClientRect.left + (window.pageXOffset || window.document.documentElement.scrollLeft)
                    };
                };
                TooltipContent.prototype.getStyle = function (nativeEl, cssProp) {
                    if (nativeEl.currentStyle)
                        return nativeEl.currentStyle[cssProp];
                    if (window.getComputedStyle)
                        return window.getComputedStyle(nativeEl)[cssProp];
                    // finally try and get inline style
                    return nativeEl.style[cssProp];
                };
                TooltipContent.prototype.isStaticPositioned = function (nativeEl) {
                    return (this.getStyle(nativeEl, "position") || "static") === "static";
                };
                TooltipContent.prototype.parentOffsetEl = function (nativeEl) {
                    var offsetParent = nativeEl.offsetParent || window.document;
                    while (offsetParent && offsetParent !== window.document && this.isStaticPositioned(offsetParent)) {
                        offsetParent = offsetParent.offsetParent;
                    }
                    return offsetParent || window.document;
                };
                return TooltipContent;
            }());
            __decorate([
                core_1.Input(),
                __metadata("design:type", HTMLElement)
            ], TooltipContent.prototype, "hostElement", void 0);
            __decorate([
                core_1.Input(),
                __metadata("design:type", String)
            ], TooltipContent.prototype, "content", void 0);
            __decorate([
                core_1.Input(),
                __metadata("design:type", String)
            ], TooltipContent.prototype, "placement", void 0);
            __decorate([
                core_1.Input(),
                __metadata("design:type", Boolean)
            ], TooltipContent.prototype, "animation", void 0);
            TooltipContent = __decorate([
                core_1.Component({
                    selector: "tooltip-content",
                    template: "\n<div class=\"tooltip {{ placement }}\"\n     [style.top]=\"top + 'px'\"\n     [style.left]=\"left + 'px'\"\n     [class.in]=\"isIn\"\n     [class.fade]=\"isFade\"\n     role=\"tooltip\">\n    <div class=\"tooltip-arrow\"></div> \n    <div class=\"tooltip-inner\">\n        <ng-content></ng-content>\n        {{ content }}\n    </div> \n</div>\n"
                }),
                __metadata("design:paramtypes", [core_1.ElementRef,
                    core_1.ChangeDetectorRef])
            ], TooltipContent);
            exports_1("TooltipContent", TooltipContent);
        }
    };
});
System.register("ngx-tooltip/Tooltip", ["@angular/core", "ngx-tooltip/TooltipContent"], function (exports_2, context_2) {
    "use strict";
    var __moduleName = context_2 && context_2.id;
    var core_2, TooltipContent_1, Tooltip;
    return {
        setters: [
            function (core_2_1) {
                core_2 = core_2_1;
            },
            function (TooltipContent_1_1) {
                TooltipContent_1 = TooltipContent_1_1;
            }
        ],
        execute: function () {
            Tooltip = (function () {
                // -------------------------------------------------------------------------
                // Constructor
                // -------------------------------------------------------------------------
                function Tooltip(viewContainerRef, resolver) {
                    this.viewContainerRef = viewContainerRef;
                    this.resolver = resolver;
                    this.tooltipAnimation = true;
                    this.tooltipPlacement = "bottom";
                }
                // -------------------------------------------------------------------------
                // Public Methods
                // -------------------------------------------------------------------------
                Tooltip.prototype.show = function () {
                    if (this.tooltipDisabled || this.visible)
                        return;
                    this.visible = true;
                    if (typeof this.content === "string") {
                        var factory = this.resolver.resolveComponentFactory(TooltipContent_1.TooltipContent);
                        if (!this.visible)
                            return;
                        this.tooltip = this.viewContainerRef.createComponent(factory);
                        this.tooltip.instance.hostElement = this.viewContainerRef.element.nativeElement;
                        this.tooltip.instance.content = this.content;
                        this.tooltip.instance.placement = this.tooltipPlacement;
                        this.tooltip.instance.animation = this.tooltipAnimation;
                    }
                    else {
                        var tooltip = this.content;
                        tooltip.hostElement = this.viewContainerRef.element.nativeElement;
                        tooltip.placement = this.tooltipPlacement;
                        tooltip.animation = this.tooltipAnimation;
                        tooltip.show();
                    }
                };
                Tooltip.prototype.hide = function () {
                    if (!this.visible)
                        return;
                    this.visible = false;
                    if (this.tooltip)
                        this.tooltip.destroy();
                    if (this.content instanceof TooltipContent_1.TooltipContent)
                        this.content.hide();
                };
                return Tooltip;
            }());
            __decorate([
                core_2.Input("tooltip"),
                __metadata("design:type", Object)
            ], Tooltip.prototype, "content", void 0);
            __decorate([
                core_2.Input(),
                __metadata("design:type", Boolean)
            ], Tooltip.prototype, "tooltipDisabled", void 0);
            __decorate([
                core_2.Input(),
                __metadata("design:type", Boolean)
            ], Tooltip.prototype, "tooltipAnimation", void 0);
            __decorate([
                core_2.Input(),
                __metadata("design:type", String)
            ], Tooltip.prototype, "tooltipPlacement", void 0);
            __decorate([
                core_2.HostListener("focusin"),
                core_2.HostListener("mouseenter"),
                __metadata("design:type", Function),
                __metadata("design:paramtypes", []),
                __metadata("design:returntype", void 0)
            ], Tooltip.prototype, "show", null);
            __decorate([
                core_2.HostListener("focusout"),
                core_2.HostListener("mouseleave"),
                __metadata("design:type", Function),
                __metadata("design:paramtypes", []),
                __metadata("design:returntype", void 0)
            ], Tooltip.prototype, "hide", null);
            Tooltip = __decorate([
                core_2.Directive({
                    selector: "[tooltip]"
                }),
                __metadata("design:paramtypes", [core_2.ViewContainerRef,
                    core_2.ComponentFactoryResolver])
            ], Tooltip);
            exports_2("Tooltip", Tooltip);
        }
    };
});
System.register("ngx-tooltip/index", ["@angular/core", "@angular/common", "ngx-tooltip/Tooltip", "ngx-tooltip/TooltipContent"], function (exports_3, context_3) {
    "use strict";
    var __moduleName = context_3 && context_3.id;
    var core_3, common_1, Tooltip_1, TooltipContent_2, TooltipModule;
    var exportedNames_1 = {
        "TooltipModule": true
    };
    function exportStar_1(m) {
        var exports = {};
        for (var n in m) {
            if (n !== "default" && !exportedNames_1.hasOwnProperty(n)) exports[n] = m[n];
        }
        exports_3(exports);
    }
    return {
        setters: [
            function (core_3_1) {
                core_3 = core_3_1;
            },
            function (common_1_1) {
                common_1 = common_1_1;
            },
            function (Tooltip_1_1) {
                Tooltip_1 = Tooltip_1_1;
                exportStar_1(Tooltip_1_1);
            },
            function (TooltipContent_2_1) {
                TooltipContent_2 = TooltipContent_2_1;
                exportStar_1(TooltipContent_2_1);
            }
        ],
        execute: function () {
            TooltipModule = (function () {
                function TooltipModule() {
                }
                return TooltipModule;
            }());
            TooltipModule = __decorate([
                core_3.NgModule({
                    imports: [
                        common_1.CommonModule
                    ],
                    declarations: [
                        Tooltip_1.Tooltip,
                        TooltipContent_2.TooltipContent,
                    ],
                    exports: [
                        Tooltip_1.Tooltip,
                        TooltipContent_2.TooltipContent,
                    ],
                    entryComponents: [
                        TooltipContent_2.TooltipContent
                    ]
                })
            ], TooltipModule);
            exports_3("TooltipModule", TooltipModule);
        }
    };
});
System.register("ngx-tooltip", ["ngx-tooltip/index"], function (exports_4, context_4) {
    "use strict";
    var __moduleName = context_4 && context_4.id;
    function exportStar_2(m) {
        var exports = {};
        for (var n in m) {
            if (n !== "default") exports[n] = m[n];
        }
        exports_4(exports);
    }
    return {
        setters: [
            function (index_1_1) {
                exportStar_2(index_1_1);
            }
        ],
        execute: function () {
        }
    };
});