@gipisistemas/ng-core 1.0.67 → 1.0.68

package/esm5/shared/components/loading-overlay/loading-overlay.component.js

@@ -0,0 +1,23 @@
+import { __decorate, __metadata } from "tslib";
+import { Component, Input } from '@angular/core';
+var LoadingOverlayComponent = /** @class */ (function () {
+    function LoadingOverlayComponent() {
+    }
+    LoadingOverlayComponent.prototype.ngOnInit = function () {
+    };
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], LoadingOverlayComponent.prototype, "message", void 0);
+    LoadingOverlayComponent = __decorate([
+        Component({
+            selector: 'itss-loading-overlay',
+            template: "<div class=\"overlay\">\n    <img class=\"logo\"\n         src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGQAAACQCAYAAAD+4c5bAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAAXNSR0IArs4c6QAAAARnQU1B\n         AACxjwv8YQUAAA+ASURBVHgB7Z0JkFxVFYbPTBKyDyEmSlgDqAiKcUmCmF1FFkEEt4CIaKlguVUpCYtFsRVLFUEIEJZyRcUK4pZSlCULCRoQA5IIBAoICTGEACFkl2z\n         N/+XeHt7MdM90T7++/Wb6/lV/9aTTM/36/X3uPffcc85tsAwjl8vtoYd9xPeLh4oHi/uKe4t7iQNEXtNT7CE2ig0l/On864q99o0ZM2YsmzVr1gEDBgzY06oAfbZdW7\n         Zs2bhy5coVS5cuHZF/vpSLDwZdJDf4veIocaT4PvEdYi9768bnb37+hjb6X0/zs2wV540cOfKeIUOGXN63b9/+DQ0NjZYi9FlzPG7YsOG1OXPmHKa//wr/7mk1hq5rk\n         B6OFE8wJ8SBYh9zIvS22l1jbtGiRTdKFBs0aNBFspRBjY2NPSwlSIDdX6DevXv3NfclvJ9/1+TDSgQu5nDxRHGMeJA5SxhoToRMQPeML/JN48aN67Vr167zm5qa9kpT\n         FP8ePPTN/zuoIF6IseIZ4gfE4WKTueEok9AN26nrnj569Ogd+ueFWEpPwdJF83AbRBA/N7xbPEkcb26SZrJM9dtWLXhRZowZM6anHs+TpQzuIVgVUFVBdPHMA3hFx4k\n         TxXHiMOuC8KJcP2HChEZ5R+f369evSZqkfv+qJogu/m16mCAeK37S3GTdpSFRduhzXTd+/PiGnTt3njNw4MC9JEovSxGpC+Ktgpv/MfF0cbRlaKKuFHlRJk2alJPLOp\n         WJPk1LSVUQXShe0lHiKeLx4v7WDSFRtiPK2LFjd0qU89MUJTVB/HqCdcS55tYV/a0bw1vKDRMnTuy5adOmqQxfabjEqQiiC8N1ZeL+vjlRUl3VZhVelGtlKTt69ep1c\n         Z8+fQZKlIoiBhUL4i3jNPEH4iFWZ/CiTJcopsXjhfK+BlUiShoW8k3x2+IBVqeQKLtwiUeNGpWTGJfgElsnUZEguojLzYlRlYhoV0J+nTJixIhtw4YNu0qiDLROoNOC\n         6M2n6uECi2gGlqKHm/gZUTSnDCh3+Cp78pUQ/UWCgudaREEsXrz4FrnDF8r7el3zSq6c3y1LEAmBW0cc6jJxsEUUBJaycOHCGdu3b79CYZYNEmVnqb9b8pDlxdhPvFo\n         8wiLaRX5Fr9gX3td5/fv337OUxWM5FkI45GzxQ1Yn64xKgSjz58+frrjXVRs3blxXiqWUdGOlNBHao8WvWGIzJaJjEGaZN2/edTt27LiS7VqJs6O913coiA8Wsgl/qn\n         XR0HmtgaUsWLDgRv04rSNLKcVC2FolLHKkRXQaWMrcuXOv04/TNm/evFGWUlCUdgXxO33sabDT18ciKoJE2SZRrpUWV2IphUTpyELeJR5j3WBzKSvIW4oWjFfLUta3H\n         r6KumGyjn7mdvqOsWyCVfE2kUmSD1XWAqwDkJe1ze96VgWzZ8/+1eTJk5tWr179NXOfYTfa84tJSviI+HbLBhBgs/mbJW4USS5bL/7fnChpgRu0ztxQXTXMnDlzxZQp\n         U+7Tj1s6fLG+HWeJL+ayARZZL4s3i6eLw3MuzbQq0N/uK56QC4PHxePz792zyAUdZm4rttZuLlbwL/EacQ7jr3VzFBuyWATW0s1laHpYvFgiLLA6QhtBZB1klRMeOch\n         qg6fEmeLt4otWZyhkIaw7cHdDp+7gJWEN08R54hZya63OUEgQhqrQ1sGNv1e8VVwgITZbnaLFwjDnskfY7wi918F88RNxvsTYYHWM1hZCiQAVSyGHq8XmxLhXYmy0Ok\n         fr0AkVSyGtg0XdneZc2roXA7QWhJqNQRYOs8Q/ii9YxG40C8Lq1NxkHmoD6lVzru0qn60RYS0thFX5UHO1fSHwT/Hhep/EWyMpyHssXII0wcCfi5ssogWSgpCXG2oT6\n         jnxUbY2LaIFkoKQmxtq/rjDonUUROs5JJSF/MPcsBXRCklBhliY8mSGqQfFNyyiDZKCEDYJUSb9P/GNegwcloKkIKTPh6gbfz6KURxJQRiuQgiy3iKKIilIqK4KWy2i\n         KJKChBpGQkUCuiSSgpBaEyKm1KlSr3pBUhByg9LMbSqG/SyiKJKCsB8RRBBFlvvkXKumiFZICkI4PETeExW7JFFktkdWLZEU5GULF86gi1zMpi+ApCDkQG2zMKBTULS\n         QAkgKQkg81BrhU+KBcR5pi6Qgy82lcIYApQ4kGA+wiBZICvKkOU8rFOiRMjRaSUskBcE6nrdwwxa1i3QRykr9SSbQLIjP/Fhi4ayEUD+Na47KuVrGCGubl/W4+JqFA1\n         ku3xXH5lyniLpHa0EeNbceCbFiB4hAYdA3xCPjfNJ2hxDreMJcSlCosZ3ECkog1oj0nPp3PSfOtRDEN+FaZG4lHXKypdr10/566M62mJpuq0MUqlOfLz5jYeJaSdAB+\n         3Pm+nB9VqLsbXWIQkkNy8X/miuJ3tfCgnI6FoyIsa9EuVuPy2QtHZcNp4v2DnupKtoI4octSso+bOEFAcwpDJk0vGFuudsPoyt0bS9ZGHBfatLUs1jaDxaCxzXJahfe\n         4H2JedHAf464gAlfjxs8800Edlq6XiHDOGm1n7AaoKAg+iau04d/RD8+bc5SagWGDfZPTvHEE/uPiMUsF1eaEyetTg644SQMTjbnZARHe4lxC80dw0NVVVaa6RNuOda\n         zW6JoNyBZyVpzNRyPWkQwdJQ6ytjNCQcMW3FDKQDa7Zflq5vuF/9qEUFQSou/Z8U/i6ssouooRRBcS9zNX1i4oGPdokNBfKb6MvEP4m8toqooqW+vD/TRpeeX4lKLqB\n         pK7lAtUVh8MXTRanyNRVQF5bYMp1Dz7+ItFssKqoKyBPHzCTuKN4t/MVcvGKuhUkTZNYV+N2+NYl0/MheZ5ShV6hNjOk8KKHfIaoaEYX1yifiQuTK1aCkpoNOCAIlCR\n         PiH5jr6sB8f1ykVoiJBgEQhKeJS8S5zjY1jZ58KULEgQKKs0MN55lpmxCrbCpCKIECirDaXoHCRuYS7iE4gNUGARKFDww3mTuKhj2Jsn1EmUhUkASzkCnMWE0MtZaAq\n         gvjY1wvmIsRkuM8Q11pEh6iWhexeQPoNLupOfiyeKd5mpRzNUMeoevcfrEWreupOCLnQCYjkCZIUSO8hhTSu8BMI0Y4pHwMjMPmYxGFO4QiKQ80lwn3UXDfUGH6xQII\n         kgSemh8UcZGIu055cYs4rocX5O8Xh5tpv1KU4wQXJg5RVc4I8IXHohnqIJ0ctcQgZLTjIeCEXa2gtrzUkMvEh/WkIlNMtkTgk5SECotDxAVHIsyWDEcuhgrevJ9dPtm\n         FaydE9/N8dYpaRZOtaww9pL3g+wHM5d94UDgDJ30P9z+T+Yln5xmtp3EDuB2JwZMcHrYpeaHsXkHn4dc1qz6rCW+hY8WcW5vxGHJ7mWpzg34Csw1voY+LdFgbMpc09Z\n         qIghcFNet3CgG3w5g4aUZDCYF461MKghfhRkMJgHhltYcD8+Gr+H1GQVvAeHdYRogqZ4YrOGc198KMgbYErzaHMITxQctteStblR0ES8J0kWHieaGGAR7cy+UQUpCU4\n         EI1C00MsDBiunks+UZOFob6JHDzGl2FdVvrA++Y3B4unWrhmzwjyfPKJoIL4IYHqVvZCEISo7z16XJMBYTg/ZaKFqzrm8yLIs8kngwlCr15znX8uNtcUAHGoO6F7A7U\n         nK61G8P26Pi6eYeE6b7Obmt+4a0aQOcTHhxgOvmPurMR8IJDnzhQn1aqJmb82Sr/ps3K4hQNrjyf9NkQzqi6IPjDvMVz8snhSgZdgLfTLmuTnlmDwa46R4lnmOjeEdH\n         LYzn6o9ZMhLgC/nt4lX7fiR2Kwjfslc53lggwZeh8mbhaAZ4onW9jGzri7DFdLWv9HVecQ/w2kGdpXze0zFANfjC/412zX77EPsrVaE73foWS4PFv8ooU/sYGm1U/55\n         gwtUDVB/FDFmMxQNbaEX2FeYWJlt/A34m36G6+medah/h6fd7B/H+azURb+PBO+ZJyQ/aCFhD78nuI54tZc+Vgv3iWOshShv3eAOE18JVc7kBZ1qdjPQkFv1kM8WVye\n         qwx0JfqTOD5XQYNM/e5h4i3iWnFXrrZ4RCzaaahaQxZDAp5LpVugeF2fEU8QV+mD/N7cPjveydpCw1nOCcfvHWGu6f9x5oamLKQVMVwt9CyI1AXRDcFzwWuZYOmB6yT\n         BAff4dHNeCt929thZYLGngAPB5MwcxDxB9gieE0NDVnK88KooLS/aGzlVQXJuXGSBRapo2m4k19rkCejLSJoQCQJ88xr9a3r7x6wl2nGNJAU+2F4b3NQE8UMFDSzJdt\n         /fqo89rGu1jCIp8G/mOuEVRZoLQ7qYft5cnm5sG94SZJXQcGGJrKPd9rupCCLrIFLK+M5kHuoI8K4EUopotPByRy+sWJCcW2yxqcMkPtgiWoOYFf3G2gQSCyENC2H/g\n         KEKLyjWerQEw9MscxN5SRVkFQki6xiuh6nmRMlK59IsgfDI9dbBRJ5Ep70sP1ThUZGhEQ9kaQtq96ebO6685D76lYQjKBGgA3bdFte0A4anC8RfS4yy2lhVsg6hsKbJ         \n         IlqDKALzxk87cw5KJXMIXUpjB6CWQAzCI99r6OShNJW0Z6J4k3LnDRYByGAnNHKcrwjrFCp1e6eI15jztesZ5OaSOXNaqe5tMVTaL4sh60bxWjHU2R5ZAwLcKV4mrrM\n         KkYp3lHM5VywOOQJvpNWP18U8equ59rmrGlI4zCy1GydRCJuwd/4tc2GU7hzTYmTgHJPbze3/v5JWQkZq4Xdd0GsShUmNXTyyKtgT2ce6H+jVwqkRvxMf0OfuMGBYDl\n         IfWnIu9YcUGyK/5Fqxfdpdiv7zexp0zntaYmyylJH6jcq3JZcwTHYQSyErsBYHjKUFkqKJSxG1xTqWpZmelERVJ9+cy5tl95CdRA4YY44ZYl0HLPQ4ZYiheLb4WLWP8\n         AviDfm9dpKsqUxCFDJCiIFlsWCIyZmbTqonCQlYxVxxc4iSiaDuac5lMx5tLkpMVmO+VUYW5hhcVoYmWt3SOOA+8Q6JELTLak3WCz4hgvUKCWPspdD5h/QdakVCpnbm\n         RaBOfLm5FE8KiOaVG6VNCzVfwEkc5hSGMYYzGr7gKrOGYf7BY0vzGhlycDq42UzKrKyxhvvF+yTCM1ZjZGpFLXFowcRcM9I/UjuC1eRTfnraWy2ZGq3wHMS+NTd+l/+\n         ZG48IbBLhplK1xdxA9iMWsSordY4g0yEOCYSlkFaEE8D+C+ub5PCGY0DYZvex3+a8ovzRrGQH0uKJwCeRacLinBK0OUsCRGQcbwKtBhhbkIbcygAAAABJRU5ErkJggg==\"\n         alt=\"GIPI Sistemas\" />\n    <div class=\"shadow\"></div>\n    <div class=\"text\"\n         *ngIf=\"!message\">\n        Aguarde\n        <span class=\"status-dot\">.</span>\n        <span class=\"status-dot\">.</span>\n        <span class=\"status-dot\">.</span>\n    </div>\n    <div class=\"text\"\n         *ngIf=\"message\">\n        {{ message }}\n    </div>\n</div>\n",
+            styles: [".overlay{position:absolute;top:-20px;width:100%;height:102%;background-color:rgba(0,0,0,.28);z-index:1}.logo{display:block;width:70px;position:absolute;margin:auto;top:0;bottom:0;left:-265px;right:0;-webkit-animation:.5s infinite alternate logo;animation:.5s infinite alternate logo}@-webkit-keyframes logo{0%{top:60px;transform:scaleX(1.7)}40%{transform:scaleX(.8)}100%{top:0}}@keyframes logo{0%{top:60px;transform:scaleX(1.7)}40%{transform:scaleX(.8)}100%{top:0}}.shadow{width:70px;height:4px;position:absolute;margin:auto;top:175px;bottom:0;left:-265px;right:0;border-radius:50%;background-color:rgba(0,0,0,.5);transform-origin:50%;z-index:1;-webkit-filter:blur(4px);filter:blur(4px);-webkit-animation:.5s infinite alternate shadow;animation:.5s infinite alternate shadow}@-webkit-keyframes shadow{0%{transform:scaleX(1.7)}40%{transform:scaleX(1);opacity:.7}100%{transform:scaleX(.8);opacity:.4}}@keyframes shadow{0%{transform:scaleX(1.7)}40%{transform:scaleX(1);opacity:.7}100%{transform:scaleX(.8);opacity:.4}}.text{display:flex;align-items:center;justify-content:center;width:50%;position:absolute;margin:auto;top:35%;bottom:0;left:-13%;right:0;z-index:1;font-size:26px;color:#fff;-webkit-animation:1s linear forwards fadeIn;animation:1s linear forwards fadeIn}.status-dot{-webkit-animation:1s steps(1,start) infinite dot1;animation:1s steps(1,start) infinite dot1}.status-dot:nth-child(2){-webkit-animation:1s steps(1,start) infinite dot2;animation:1s steps(1,start) infinite dot2}.status-dot:nth-child(3){-webkit-animation:1s steps(1,start) infinite dot3;animation:1s steps(1,start) infinite dot3}@-webkit-keyframes fadeIn{67%,from{opacity:0}83.3%,to{opacity:1}}@keyframes fadeIn{67%,from{opacity:0}83.3%,to{opacity:1}}@-webkit-keyframes dot1{from{visibility:hidden}33%,to{visibility:visible}}@keyframes dot1{from{visibility:hidden}33%,to{visibility:visible}}@-webkit-keyframes dot2{33%,from{visibility:hidden}67%,to{visibility:visible}}@keyframes dot2{33%,from{visibility:hidden}67%,to{visibility:visible}}@-webkit-keyframes dot3{67%,from{visibility:hidden}to{visibility:visible}}@keyframes dot3{67%,from{visibility:hidden}to{visibility:visible}}"]
+        }),
+        __metadata("design:paramtypes", [])
+    ], LoadingOverlayComponent);
+    return LoadingOverlayComponent;
+}());
+export { LoadingOverlayComponent };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZGluZy1vdmVybGF5LmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BnaXBpc2lzdGVtYXMvbmctY29yZS8iLCJzb3VyY2VzIjpbInNoYXJlZC9jb21wb25lbnRzL2xvYWRpbmctb3ZlcmxheS9sb2FkaW5nLW92ZXJsYXkuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBVSxNQUFNLGVBQWUsQ0FBQztBQU96RDtJQUlFO0lBQWdCLENBQUM7SUFFakIsMENBQVEsR0FBUjtJQUNBLENBQUM7SUFMUTtRQUFSLEtBQUssRUFBRTs7NERBQWlCO0lBRmQsdUJBQXVCO1FBTG5DLFNBQVMsQ0FBQztZQUNULFFBQVEsRUFBRSxzQkFBc0I7WUFDaEMsMnZNQUErQzs7U0FFaEQsQ0FBQzs7T0FDVyx1QkFBdUIsQ0FTbkM7SUFBRCw4QkFBQztDQUFBLEFBVEQsSUFTQztTQVRZLHVCQUF1QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCwgSW5wdXQsIE9uSW5pdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdpdHNzLWxvYWRpbmctb3ZlcmxheScsXG4gIHRlbXBsYXRlVXJsOiAnLi9sb2FkaW5nLW92ZXJsYXkuY29tcG9uZW50Lmh0bWwnLFxuICBzdHlsZVVybHM6IFsnLi9sb2FkaW5nLW92ZXJsYXkuY29tcG9uZW50LnNjc3MnXVxufSlcbmV4cG9ydCBjbGFzcyBMb2FkaW5nT3ZlcmxheUNvbXBvbmVudCBpbXBsZW1lbnRzIE9uSW5pdCB7XG5cbiAgQElucHV0KCkgbWVzc2FnZTogc3RyaW5nO1xuXG4gIGNvbnN0cnVjdG9yKCkgeyB9XG5cbiAgbmdPbkluaXQoKSB7XG4gIH1cblxufVxuIl19

package/esm5/shared/components/overlay-panel/overlay-panel.component.js

@@ -0,0 +1,366 @@
+import { __decorate, __metadata } from "tslib";
+import { animate, state, style, transition, trigger } from '@angular/animations';
+import { AfterContentInit, ChangeDetectionStrategy, ChangeDetectorRef, Component, ContentChild, ElementRef, EventEmitter, Input, NgZone, OnDestroy, OnInit, Output, Renderer2, TemplateRef, ViewEncapsulation, ViewRef } from '@angular/core';
+import ZIndexUtils from '../../../core/utils/zindex.util';
+import { GIPINgConfig } from '../../api/gipi-ng-config';
+import { GIPIOverlayService } from '../../gipi-components/overlay/shared/overlay-service';
+import { ConnectedOverlayScrollHandler } from '../dom/connected-overlay-scroll-handler';
+import { DomHandler } from '../dom/dom-handler';
+var OverlayPanelComponent = /** @class */ (function () {
+    function OverlayPanelComponent(el, renderer, cd, zone, config, overlayService) {
+        this.el = el;
+        this.renderer = renderer;
+        this.cd = cd;
+        this.zone = zone;
+        this.config = config;
+        this.overlayService = overlayService;
+        this.dismissable = true;
+        this.closeIconSize = 15;
+        this.appendTo = 'body';
+        this.autoZIndex = true;
+        this.baseZIndex = 0;
+        this.focusOnShow = true;
+        this.showTransitionOptions = '.12s cubic-bezier(0, 0, 0.2, 1)';
+        this.hideTransitionOptions = '.1s linear';
+        this.onShow = new EventEmitter();
+        this.onHide = new EventEmitter();
+        this.overlayVisible = false;
+        this.render = false;
+        this.isOverlayAnimationInProgress = false;
+        this.selfClick = false;
+    }
+    OverlayPanelComponent.prototype.ngOnInit = function () {
+    };
+    OverlayPanelComponent.prototype.ngAfterContentInit = function () {
+    };
+    OverlayPanelComponent.prototype.bindDocumentClickListener = function () {
+        var _this = this;
+        if (!this.documentClickListener && this.dismissable) {
+            this.zone.runOutsideAngular(function () {
+                var documentEvent = DomHandler.isIOS() ? 'touchstart' : 'click';
+                var documentTarget = _this.el ? _this.el.nativeElement.ownerDocument : 'document';
+                _this.documentClickListener = _this.renderer.listen(documentTarget, documentEvent, function (event) {
+                    if (!_this.container.contains(event.target) && _this.target !== event.target && !_this.target.contains(event.target) && !_this.selfClick) {
+                        _this.zone.run(function () {
+                            _this.hide();
+                        });
+                    }
+                    _this.selfClick = false;
+                    _this.cd.markForCheck();
+                });
+            });
+        }
+    };
+    OverlayPanelComponent.prototype.unbindDocumentClickListener = function () {
+        if (this.documentClickListener) {
+            this.documentClickListener();
+            this.documentClickListener = null;
+            this.selfClick = false;
+        }
+    };
+    OverlayPanelComponent.prototype.toggle = function (event, target) {
+        var _this = this;
+        if (this.isOverlayAnimationInProgress) {
+            return;
+        }
+        if (this.overlayVisible) {
+            if (this.hasTargetChanged(event, target)) {
+                this.destroyCallback = function () {
+                    _this.show(null, (target || event.currentTarget || event.target));
+                };
+            }
+            this.hide();
+        }
+        else {
+            this.show(event, target);
+        }
+    };
+    OverlayPanelComponent.prototype.show = function (event, target) {
+        if (this.isOverlayAnimationInProgress) {
+            return;
+        }
+        this.target = target || event.currentTarget || event.target;
+        this.overlayVisible = true;
+        this.render = true;
+        this.cd.markForCheck();
+    };
+    OverlayPanelComponent.prototype.onOverlayClick = function (event) {
+        this.overlayService.add({
+            originalEvent: event,
+            target: this.el.nativeElement
+        });
+        this.selfClick = true;
+    };
+    OverlayPanelComponent.prototype.onContentClick = function () {
+        this.selfClick = true;
+    };
+    OverlayPanelComponent.prototype.hasTargetChanged = function (event, target) {
+        return this.target != null && this.target !== (target || event.currentTarget || event.target);
+    };
+    OverlayPanelComponent.prototype.appendContainer = function () {
+        if (this.appendTo) {
+            if (this.appendTo === 'body') {
+                document.body.appendChild(this.container);
+            }
+            else {
+                DomHandler.appendChild(this.container, this.appendTo);
+            }
+        }
+    };
+    OverlayPanelComponent.prototype.restoreAppend = function () {
+        if (this.container && this.appendTo) {
+            this.el.nativeElement.appendChild(this.container);
+        }
+    };
+    OverlayPanelComponent.prototype.align = function () {
+        if (this.autoZIndex) {
+            ZIndexUtils.set('overlay', this.container, this.baseZIndex + this.config.zIndex.overlay);
+        }
+        DomHandler.absolutePosition(this.container, this.target);
+        var containerOffset = DomHandler.getOffset(this.container);
+        var targetOffset = DomHandler.getOffset(this.target);
+        var arrowLeft = 0;
+        if (containerOffset.left < targetOffset.left) {
+            arrowLeft = targetOffset.left - containerOffset.left;
+        }
+        this.container.style.setProperty('--overlayArrowLeft', arrowLeft + "px");
+        if (containerOffset.top < targetOffset.top) {
+            DomHandler.addClass(this.container, 'overlay-panel-flipped');
+        }
+    };
+    OverlayPanelComponent.prototype.onAnimationStart = function (event) {
+        var _this = this;
+        if (event.toState === 'open') {
+            this.container = event.element;
+            this.onShow.emit(null);
+            this.appendContainer();
+            this.align();
+            this.bindDocumentClickListener();
+            this.bindDocumentResizeListener();
+            this.bindScrollListener();
+            if (this.focusOnShow) {
+                this.focus();
+            }
+            this.overlayEventListener = function (e) {
+                if (_this.container && _this.container.contains(e.target)) {
+                    _this.selfClick = true;
+                }
+            };
+            this.overlaySubscription = this.overlayService.clickObservable.subscribe(this.overlayEventListener);
+        }
+        this.isOverlayAnimationInProgress = true;
+    };
+    OverlayPanelComponent.prototype.onAnimationEnd = function (event) {
+        switch (event.toState) {
+            case 'void': {
+                if (this.destroyCallback) {
+                    this.destroyCallback();
+                    this.destroyCallback = null;
+                }
+                if (this.overlaySubscription) {
+                    this.overlaySubscription.unsubscribe();
+                }
+                break;
+            }
+            case 'close': {
+                if (this.autoZIndex) {
+                    ZIndexUtils.clear(this.container);
+                }
+                if (this.overlaySubscription) {
+                    this.overlaySubscription.unsubscribe();
+                }
+                this.onContainerDestroy();
+                this.onHide.emit({});
+                this.render = false;
+                break;
+            }
+        }
+        this.isOverlayAnimationInProgress = false;
+    };
+    OverlayPanelComponent.prototype.focus = function () {
+        var focusable = DomHandler.findSingle(this.container, '[autofocus]');
+        if (focusable) {
+            this.zone.runOutsideAngular(function () {
+                setTimeout(function () { return focusable.focus(); }, 5);
+            });
+        }
+    };
+    OverlayPanelComponent.prototype.hide = function () {
+        if (this.isOverlayAnimationInProgress) {
+            return;
+        }
+        this.overlayVisible = false;
+        this.cd.markForCheck();
+    };
+    OverlayPanelComponent.prototype.onCloseClick = function (event) {
+        this.hide();
+        event.preventDefault();
+    };
+    OverlayPanelComponent.prototype.onWindowResize = function (event) {
+        if (this.overlayVisible && !DomHandler.isTouchDevice()) {
+            this.hide();
+        }
+    };
+    OverlayPanelComponent.prototype.bindDocumentResizeListener = function () {
+        this.documentResizeListener = this.onWindowResize.bind(this);
+        window.addEventListener('resize', this.documentResizeListener);
+    };
+    OverlayPanelComponent.prototype.unbindDocumentResizeListener = function () {
+        if (this.documentResizeListener) {
+            window.removeEventListener('resize', this.documentResizeListener);
+            this.documentResizeListener = null;
+        }
+    };
+    OverlayPanelComponent.prototype.bindScrollListener = function () {
+        var _this = this;
+        if (!this.scrollHandler) {
+            this.scrollHandler = new ConnectedOverlayScrollHandler(this.target, function () {
+                if (_this.overlayVisible) {
+                    _this.hide();
+                }
+            });
+        }
+        this.scrollHandler.bindScrollListener();
+    };
+    OverlayPanelComponent.prototype.unbindScrollListener = function () {
+        if (this.scrollHandler) {
+            this.scrollHandler.unbindScrollListener();
+        }
+    };
+    OverlayPanelComponent.prototype.onContainerDestroy = function () {
+        if (!this.cd.destroyed) {
+            this.target = null;
+        }
+        this.unbindDocumentClickListener();
+        this.unbindDocumentResizeListener();
+        this.unbindScrollListener();
+    };
+    OverlayPanelComponent.prototype.ngOnDestroy = function () {
+        if (this.scrollHandler) {
+            this.scrollHandler.destroy();
+            this.scrollHandler = null;
+        }
+        if (this.container && this.autoZIndex) {
+            ZIndexUtils.clear(this.container);
+        }
+        if (!this.cd.destroyed) {
+            this.target = null;
+        }
+        this.destroyCallback = null;
+        if (this.container) {
+            this.restoreAppend();
+            this.onContainerDestroy();
+        }
+        if (this.overlaySubscription) {
+            this.overlaySubscription.unsubscribe();
+        }
+    };
+    OverlayPanelComponent.ctorParameters = function () { return [
+        { type: ElementRef },
+        { type: Renderer2 },
+        { type: ChangeDetectorRef },
+        { type: NgZone },
+        { type: GIPINgConfig },
+        { type: GIPIOverlayService }
+    ]; };
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], OverlayPanelComponent.prototype, "dismissable", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], OverlayPanelComponent.prototype, "showCloseIcon", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Number)
+    ], OverlayPanelComponent.prototype, "closeIconSize", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object)
+    ], OverlayPanelComponent.prototype, "style", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], OverlayPanelComponent.prototype, "styleClass", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object)
+    ], OverlayPanelComponent.prototype, "appendTo", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], OverlayPanelComponent.prototype, "autoZIndex", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], OverlayPanelComponent.prototype, "ariaCloseLabel", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Number)
+    ], OverlayPanelComponent.prototype, "baseZIndex", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], OverlayPanelComponent.prototype, "focusOnShow", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], OverlayPanelComponent.prototype, "showTransitionOptions", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], OverlayPanelComponent.prototype, "hideTransitionOptions", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], OverlayPanelComponent.prototype, "onShow", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], OverlayPanelComponent.prototype, "onHide", void 0);
+    __decorate([
+        ContentChild('overlayContent', { static: false }),
+        __metadata("design:type", TemplateRef)
+    ], OverlayPanelComponent.prototype, "overlayContentRef", void 0);
+    __decorate([
+        ContentChild('overlayFooter', { static: false }),
+        __metadata("design:type", TemplateRef)
+    ], OverlayPanelComponent.prototype, "overlayFooterRef", void 0);
+    OverlayPanelComponent = __decorate([
+        Component({
+            selector: 'itss-overlay-panel',
+            template: "<div *ngIf=\"render\"\n     [ngClass]=\"'overlay-panel component'\"\n     [ngStyle]=\"style\"\n     [class]=\"styleClass\"\n     (click)=\"onOverlayClick($event)\"\n     [@animation]=\"{value: (overlayVisible ? 'open': 'close'), params: { showTransitionParams: showTransitionOptions, hideTransitionParams: hideTransitionOptions }}\"\n     (@animation.start)=\"onAnimationStart($event)\"\n     (@animation.done)=\"onAnimationEnd($event)\">\n    <div class=\"overlay-panel-content\"\n         (click)=\"onContentClick()\"\n         (mousedown)=\"onContentClick()\">\n        <ng-container *ngTemplateOutlet=\"overlayContentRef\"></ng-container>\n    </div>\n    <div class=\"overlay-panel-footer\"\n         (click)=\"onContentClick()\"\n         (mousedown)=\"onContentClick()\">\n        <div class=\"overlay-panel-footer-divisory\"></div>\n        <div class=\"overlay-panel-footer-content\">\n            <ng-container *ngTemplateOutlet=\"overlayFooterRef\"></ng-container>\n        </div>\n    </div>\n    <button *ngIf=\"showCloseIcon\"\n            type=\"button\"\n            class=\"overlay-panel-close link\"\n            (click)=\"onCloseClick($event)\"\n            (keydown.enter)=\"hide()\"\n            [attr.aria-label]=\"ariaCloseLabel\">\n        X\n    </button>\n</div>",
+            animations: [
+                trigger('animation', [
+                    state('void', style({
+                        transform: 'scaleY(0.8)',
+                        opacity: 0
+                    })),
+                    state('close', style({
+                        opacity: 0
+                    })),
+                    state('open', style({
+                        transform: 'translateY(0)',
+                        opacity: 1
+                    })),
+                    transition('void => open', animate('{{showTransitionParams}}')),
+                    transition('open => close', animate('{{hideTransitionParams}}')),
+                ])
+            ],
+            changeDetection: ChangeDetectionStrategy.OnPush,
+            encapsulation: ViewEncapsulation.None,
+            host: { 'class': 'itss-element' },
+            styles: [".component{font-size:1rem;font-weight:400;box-sizing:border-box}.component:disabled{opacity:.6}.overlay-panel{background:#fff;color:#696969;border:0;border-radius:6px;box-shadow:0 1px 3px rgba(0,0,0,.3);position:absolute;margin-top:10px;top:0;left:0;display:flex;flex-direction:column}.overlay-panel:after,.overlay-panel:before{bottom:100%;left:calc(var(--overlayArrowLeft,0) + 1.25rem);content:\" \";height:0;width:0;position:absolute;pointer-events:none}.overlay-panel:after{border:8px solid rgba(255,255,255,0);border-bottom-color:#fff;margin-left:-8px}.overlay-panel:before{border:10px solid rgba(255,255,255,0);border-bottom-color:#f2f2f2;margin-left:-10px}.overlay-panel .overlay-panel-content{padding:1.25rem 1.25rem .5rem}.overlay-panel .overlay-panel-footer .overlay-panel-footer-divisory{content:\"\";border-top:1px solid #ddd;width:100%}.overlay-panel .overlay-panel-footer .overlay-panel-footer-content{padding:1.25rem}.overlay-panel .overlay-panel-close{background:#696969;color:#fff;width:2rem;height:2rem;transition:background-color .2s,color .2s,box-shadow .2s;border-radius:50%;position:absolute;top:-1rem;right:-1rem;display:flex;justify-content:center;align-items:center;overflow:hidden}.overlay-panel .overlay-panel-close:enabled:hover{background:#919191;color:#fff}.overlay-panel-shifted:after,.overlay-panel-shifted:before{left:auto;right:1.25em;margin-left:auto}.overlay-panel-flipped{margin-top:0;margin-bottom:10px}.overlay-panel-flipped:after,.overlay-panel-flipped:before{bottom:auto;top:100%}.overlay-panel.overlay-panel-flipped:after,.overlay-panel.overlay-panel-flipped:before{border-top-color:#fff;border-bottom-color:transparent}.link{font-size:1rem;border-radius:6px;font-weight:700;text-align:left;margin:0;padding:0;border:none;cursor:pointer;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none}.link:focus{outline:0;outline-offset:0;box-shadow:0 0 0 .2rem #a3a3a3}"]
+        }),
+        __metadata("design:paramtypes", [ElementRef,
+            Renderer2,
+            ChangeDetectorRef,
+            NgZone,
+            GIPINgConfig,
+            GIPIOverlayService])
+    ], OverlayPanelComponent);
+    return OverlayPanelComponent;
+}());
+export { OverlayPanelComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overlay-panel.component.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/components/overlay-panel/overlay-panel.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { animate, AnimationEvent, state, style, transition, trigger } from '@angular/animations';\nimport {\n    AfterContentInit,\n    ChangeDetectionStrategy,\n    ChangeDetectorRef,\n    Component,\n    ContentChild,\n    ElementRef,\n    EventEmitter,\n    Input,\n    NgZone,\n    OnDestroy,\n    OnInit,\n    Output, Renderer2,\n    TemplateRef,\n    ViewEncapsulation,\n    ViewRef\n} from '@angular/core';\nimport { Subscription } from 'rxjs';\n\nimport ZIndexUtils from '../../../core/utils/zindex.util';\nimport { GIPINgConfig } from '../../api/gipi-ng-config';\nimport { GIPIOverlayService } from '../../gipi-components/overlay/shared/overlay-service';\nimport { ConnectedOverlayScrollHandler } from '../dom/connected-overlay-scroll-handler';\nimport { DomHandler } from '../dom/dom-handler';\n\n@Component({\n    selector: 'itss-overlay-panel',\n    templateUrl: './overlay-panel.component.html',\n    styleUrls: ['./overlay-panel.component.scss'],\n    animations: [\n        trigger('animation', [\n            state('void', style({\n                transform: 'scaleY(0.8)',\n                opacity: 0\n            })),\n            state('close', style({\n                opacity: 0\n            })),\n            state('open', style({\n                transform: 'translateY(0)',\n                opacity: 1\n            })),\n            transition('void => open', animate('{{showTransitionParams}}')),\n            transition('open => close', animate('{{hideTransitionParams}}')),\n        ])\n    ],\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    encapsulation: ViewEncapsulation.None,\n    host: { 'class': 'itss-element' }\n})\nexport class OverlayPanelComponent implements AfterContentInit, OnInit, OnDestroy {\n\n    @Input() dismissable: boolean = true;\n\n    @Input() showCloseIcon: boolean;\n\n    @Input() closeIconSize: number = 15;\n\n    @Input() style: any;\n\n    @Input() styleClass: string;\n\n    @Input() appendTo: any = 'body';\n\n    @Input() autoZIndex: boolean = true;\n\n    @Input() ariaCloseLabel: string;\n\n    @Input() baseZIndex: number = 0;\n\n    @Input() focusOnShow: boolean = true;\n\n    @Input() showTransitionOptions: string = '.12s cubic-bezier(0, 0, 0.2, 1)';\n\n    @Input() hideTransitionOptions: string = '.1s linear';\n\n    @Output() onShow: EventEmitter<any> = new EventEmitter();\n\n    @Output() onHide: EventEmitter<any> = new EventEmitter();\n\n    @ContentChild('overlayContent', { static: false }) overlayContentRef: TemplateRef<any>;\n\n    @ContentChild('overlayFooter', { static: false }) overlayFooterRef: TemplateRef<any>;\n\n    container: HTMLDivElement;\n\n    overlayVisible: boolean = false;\n\n    render: boolean = false;\n\n    isOverlayAnimationInProgress: boolean = false;\n\n    selfClick: boolean = false;\n\n    documentClickListener: any;\n\n    target: any;\n\n    willHide: boolean;\n\n    scrollHandler: any;\n\n    documentResizeListener: any;\n\n    destroyCallback: Function;\n\n    overlayEventListener;\n\n    overlaySubscription: Subscription;\n\n    constructor(\n        public el: ElementRef,\n        public renderer: Renderer2,\n        public cd: ChangeDetectorRef,\n        private zone: NgZone,\n        public config: GIPINgConfig,\n        public overlayService: GIPIOverlayService\n    ) { }\n\n    ngOnInit(): void {\n    }\n\n    ngAfterContentInit(): void {\n    }\n\n    bindDocumentClickListener(): void {\n        if (!this.documentClickListener && this.dismissable) {\n            this.zone.runOutsideAngular(() => {\n                const documentEvent: 'touchstart' | 'click' = DomHandler.isIOS() ? 'touchstart' : 'click';\n                const documentTarget: any = this.el ? this.el.nativeElement.ownerDocument : 'document';\n\n                this.documentClickListener = this.renderer.listen(documentTarget, documentEvent, (event) => {\n                    if (!this.container.contains(event.target) && this.target !== event.target && !this.target.contains(event.target) && !this.selfClick) {\n                        this.zone.run(() => {\n                            this.hide();\n                        });\n                    }\n\n                    this.selfClick = false;\n                    this.cd.markForCheck();\n                });\n            });\n        }\n    }\n\n    unbindDocumentClickListener(): void {\n        if (this.documentClickListener) {\n            this.documentClickListener();\n            this.documentClickListener = null;\n            this.selfClick = false;\n        }\n    }\n\n    toggle(event: any, target?: any): void {\n        if (this.isOverlayAnimationInProgress) {\n            return;\n        }\n\n        if (this.overlayVisible) {\n            if (this.hasTargetChanged(event, target)) {\n                this.destroyCallback = () => {\n                    this.show(null, (target || event.currentTarget || event.target));\n                };\n            }\n\n            this.hide();\n        } else {\n            this.show(event, target);\n        }\n    }\n\n    show(event: any, target?: any): void {\n        if (this.isOverlayAnimationInProgress) {\n            return;\n        }\n\n        this.target = target || event.currentTarget || event.target;\n        this.overlayVisible = true;\n        this.render = true;\n        this.cd.markForCheck();\n    }\n\n    onOverlayClick(event: any): void {\n        this.overlayService.add({\n            originalEvent: event,\n            target: this.el.nativeElement\n        });\n\n        this.selfClick = true;\n    }\n\n    onContentClick(): void {\n        this.selfClick = true;\n    }\n\n    hasTargetChanged(event: any, target: any): boolean {\n        return this.target != null && this.target !== (target || event.currentTarget || event.target);\n    }\n\n    appendContainer(): void {\n        if (this.appendTo) {\n            if (this.appendTo === 'body') {\n                document.body.appendChild(this.container);\n            } else {\n                DomHandler.appendChild(this.container, this.appendTo);\n            }\n        }\n    }\n\n    restoreAppend(): void {\n        if (this.container && this.appendTo) {\n            this.el.nativeElement.appendChild(this.container);\n        }\n    }\n\n    align(): void {\n        if (this.autoZIndex) {\n            ZIndexUtils.set('overlay', this.container, this.baseZIndex + this.config.zIndex.overlay);\n        }\n\n        DomHandler.absolutePosition(this.container, this.target);\n\n        const containerOffset: { top: any; left: any; } = DomHandler.getOffset(this.container);\n        const targetOffset: { top: any; left: any; } = DomHandler.getOffset(this.target);\n        let arrowLeft: number = 0;\n\n        if (containerOffset.left < targetOffset.left) {\n            arrowLeft = targetOffset.left - containerOffset.left;\n        }\n        this.container.style.setProperty('--overlayArrowLeft', `${arrowLeft}px`);\n\n        if (containerOffset.top < targetOffset.top) {\n            DomHandler.addClass(this.container, 'overlay-panel-flipped');\n        }\n    }\n\n    onAnimationStart(event: AnimationEvent): void {\n        if (event.toState === 'open') {\n            this.container = event.element;\n            this.onShow.emit(null);\n            this.appendContainer();\n            this.align();\n            this.bindDocumentClickListener();\n            this.bindDocumentResizeListener();\n            this.bindScrollListener();\n\n            if (this.focusOnShow) {\n                this.focus();\n            }\n\n            this.overlayEventListener = e => {\n                if (this.container && this.container.contains(e.target)) {\n                    this.selfClick = true;\n                }\n            };\n\n            this.overlaySubscription = this.overlayService.clickObservable.subscribe(this.overlayEventListener);\n        }\n\n        this.isOverlayAnimationInProgress = true;\n    }\n\n    onAnimationEnd(event: AnimationEvent): void {\n        switch (event.toState) {\n            case 'void': {\n                if (this.destroyCallback) {\n                    this.destroyCallback();\n                    this.destroyCallback = null;\n                }\n\n                if (this.overlaySubscription) {\n                    this.overlaySubscription.unsubscribe();\n                }\n                break;\n            }\n            case 'close': {\n                if (this.autoZIndex) {\n                    ZIndexUtils.clear(this.container);\n                }\n\n                if (this.overlaySubscription) {\n                    this.overlaySubscription.unsubscribe();\n                }\n\n                this.onContainerDestroy();\n                this.onHide.emit({});\n                this.render = false;\n                break;\n            }\n        }\n\n        this.isOverlayAnimationInProgress = false;\n    }\n\n    focus(): void {\n        const focusable: any = DomHandler.findSingle(this.container, '[autofocus]');\n        if (focusable) {\n            this.zone.runOutsideAngular(() => {\n                setTimeout(() => focusable.focus(), 5);\n            });\n        }\n    }\n\n    hide(): void {\n        if (this.isOverlayAnimationInProgress) {\n            return;\n        }\n\n        this.overlayVisible = false;\n        this.cd.markForCheck();\n    }\n\n    onCloseClick(event: any): void {\n        this.hide();\n        event.preventDefault();\n    }\n\n    onWindowResize(event: any): void {\n        if (this.overlayVisible && !DomHandler.isTouchDevice()) {\n            this.hide();\n        }\n    }\n\n    bindDocumentResizeListener(): void {\n        this.documentResizeListener = this.onWindowResize.bind(this);\n        window.addEventListener('resize', this.documentResizeListener);\n    }\n\n    unbindDocumentResizeListener(): void {\n        if (this.documentResizeListener) {\n            window.removeEventListener('resize', this.documentResizeListener);\n            this.documentResizeListener = null;\n        }\n    }\n\n    bindScrollListener(): void {\n        if (!this.scrollHandler) {\n            this.scrollHandler = new ConnectedOverlayScrollHandler(this.target, () => {\n                if (this.overlayVisible) {\n                    this.hide();\n                }\n            });\n        }\n\n        this.scrollHandler.bindScrollListener();\n    }\n\n    unbindScrollListener(): void {\n        if (this.scrollHandler) {\n            this.scrollHandler.unbindScrollListener();\n        }\n    }\n\n    onContainerDestroy(): void {\n        if (!(this.cd as ViewRef).destroyed) {\n            this.target = null;\n        }\n\n        this.unbindDocumentClickListener();\n        this.unbindDocumentResizeListener();\n        this.unbindScrollListener();\n    }\n\n    ngOnDestroy(): void {\n        if (this.scrollHandler) {\n            this.scrollHandler.destroy();\n            this.scrollHandler = null;\n        }\n\n        if (this.container && this.autoZIndex) {\n            ZIndexUtils.clear(this.container);\n        }\n\n        if (!(this.cd as ViewRef).destroyed) {\n            this.target = null;\n        }\n\n        this.destroyCallback = null;\n        if (this.container) {\n            this.restoreAppend();\n            this.onContainerDestroy();\n        }\n\n        if (this.overlaySubscription) {\n            this.overlaySubscription.unsubscribe();\n        }\n    }\n\n}\n"]}

package/esm5/shared/components/popover/popover-ref.js

@@ -0,0 +1,28 @@
+import { Subject } from 'rxjs';
+var PopoverRef = /** @class */ (function () {
+    function PopoverRef(overlay, content, data) {
+        var _this = this;
+        this.overlay = overlay;
+        this.content = content;
+        this.data = data;
+        this.afterClosed = new Subject();
+        this.afterClosed$ = this.afterClosed.asObservable();
+        overlay.backdropClick().subscribe(function () {
+            _this._close('backdropClick', null);
+        });
+    }
+    PopoverRef.prototype.close = function (data) {
+        this._close('close', data);
+    };
+    PopoverRef.prototype._close = function (type, data) {
+        this.overlay.dispose();
+        this.afterClosed.next({
+            type: type,
+            data: data
+        });
+        this.afterClosed.complete();
+    };
+    return PopoverRef;
+}());
+export { PopoverRef };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/shared/components/popover/popover.component.js

@@ -0,0 +1,35 @@
+import { __decorate, __metadata } from "tslib";
+import { Component, TemplateRef } from '@angular/core';
+import { PopoverContent, PopoverRef } from './popover-ref';
+var PopoverComponent = /** @class */ (function () {
+    function PopoverComponent(popoverRef) {
+        this.popoverRef = popoverRef;
+        this.renderMethod = 'component';
+    }
+    PopoverComponent.prototype.ngOnInit = function () {
+        this.content = this.popoverRef.content;
+        if (typeof this.content === 'string') {
+            this.renderMethod = 'text';
+        }
+        if (this.content instanceof TemplateRef) {
+            this.renderMethod = 'template';
+            this.context = {
+                close: this.popoverRef.close.bind(this.popoverRef),
+                data: this.popoverRef.data
+            };
+        }
+    };
+    PopoverComponent.ctorParameters = function () { return [
+        { type: PopoverRef }
+    ]; };
+    PopoverComponent = __decorate([
+        Component({
+            template: "<ng-container [ngSwitch]=\"renderMethod\">\n  <div *ngSwitchCase=\"'text'\"\n       [innerHTML]=\"content\"></div>\n  <ng-container *ngSwitchCase=\"'template'\">\n    <ng-container *ngTemplateOutlet=\"content; context: context\"></ng-container>\n  </ng-container>\n  <ng-container *ngSwitchCase=\"'component'\">\n    <ng-container *ngComponentOutlet=\"content\"></ng-container>\n  </ng-container>\n</ng-container>\n",
+            styles: [""]
+        }),
+        __metadata("design:paramtypes", [PopoverRef])
+    ], PopoverComponent);
+    return PopoverComponent;
+}());
+export { PopoverComponent };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/shared/components/popover/popover.service.js

@@ -0,0 +1,88 @@
+import { __decorate, __metadata } from "tslib";
+import { ElementRef, Injectable, Injector, ViewContainerRef } from '@angular/core';
+import { ConnectionPositionPair, Overlay, OverlayConfig, OverlayRef, PositionStrategy } from '@angular/cdk/overlay';
+import { ComponentPortal, PortalInjector } from '@angular/cdk/portal';
+import { PopoverRef } from './popover-ref';
+import { PopoverComponent } from './popover.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+var PopoverService = /** @class */ (function () {
+    function PopoverService(overlay, injector) {
+        this.overlay = overlay;
+        this.injector = injector;
+    }
+    PopoverService.prototype.open = function (_a) {
+        var origin = _a.origin, content = _a.content, data = _a.data, width = _a.width, height = _a.height, event = _a.event;
+        var overlayRef = this.overlay.create(this.getOverlayConfig({ origin: origin, width: width, height: height, event: event }));
+        var popoverRef = new PopoverRef(overlayRef, content, data);
+        var injector = this.createInjector(popoverRef, this.injector);
+        overlayRef.attach(new ComponentPortal(PopoverComponent, null, injector));
+        return popoverRef;
+    };
+    PopoverService.prototype.getOverlayConfig = function (_a) {
+        var origin = _a.origin, width = _a.width, height = _a.height, event = _a.event;
+        return new OverlayConfig({
+            hasBackdrop: true,
+            width: width,
+            height: height,
+            backdropClass: 'popover-backdrop',
+            positionStrategy: this.getOverlayPosition(origin, event),
+            scrollStrategy: this.overlay.scrollStrategies.reposition()
+        });
+    };
+    PopoverService.prototype.getOverlayPosition = function (origin, event) {
+        // @ts-ignore
+        var offset = event.target.offsetTop - document.querySelector('.mat-sidenav-content').scrollTop;
+        if (event) {
+            return this.overlay.position()
+                .global()
+                .top((offset + 50) + "px")
+                .left((event.clientX - 30) + "px");
+        }
+        return this.overlay.position()
+            .flexibleConnectedTo(origin)
+            .withPositions(this.getPositions())
+            .withFlexibleDimensions(false)
+            .withPush(false);
+    };
+    PopoverService.prototype.updatePosition = function (popoverRef, event) {
+        popoverRef.overlay.updatePositionStrategy(this.overlay.position()
+            .global()
+            .top(event.clientY + "px")
+            .left(event.clientX + "px"));
+    };
+    PopoverService.prototype.createInjector = function (popoverRef, injector) {
+        var tokens = new WeakMap([[PopoverRef, popoverRef]]);
+        return new PortalInjector(injector, tokens);
+    };
+    PopoverService.prototype.getPositions = function () {
+        return [
+            {
+                originX: 'end',
+                originY: 'bottom',
+                overlayX: 'end',
+                overlayY: 'top'
+            },
+            {
+                originX: 'end',
+                originY: 'bottom',
+                overlayX: 'end',
+                overlayY: 'top',
+            },
+        ];
+    };
+    PopoverService.ctorParameters = function () { return [
+        { type: Overlay },
+        { type: Injector }
+    ]; };
+    PopoverService.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function PopoverService_Factory() { return new PopoverService(i0.ɵɵinject(i1.Overlay), i0.ɵɵinject(i0.INJECTOR)); }, token: PopoverService, providedIn: "root" });
+    PopoverService = __decorate([
+        Injectable({
+            providedIn: 'root'
+        }),
+        __metadata("design:paramtypes", [Overlay, Injector])
+    ], PopoverService);
+    return PopoverService;
+}());
+export { PopoverService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"popover.service.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/components/popover/popover.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {ElementRef, Injectable, Injector, ViewContainerRef} from '@angular/core';\nimport {ConnectionPositionPair, Overlay, OverlayConfig, OverlayRef, PositionStrategy} from '@angular/cdk/overlay';\nimport {ComponentPortal, PortalInjector} from '@angular/cdk/portal';\n\nimport {PopoverContent, PopoverRef} from './popover-ref';\nimport {PopoverComponent} from './popover.component';\nimport {ObjectUtil} from '../../../core/utils/object.util';\n\nexport interface PopoverParams<T> {\n    width?: string | number;\n    height?: string | number;\n    origin: ElementRef | HTMLElement;\n    content: PopoverContent;\n    data?: T;\n    event?: MouseEvent;\n}\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class PopoverService {\n\n\n    constructor(private overlay: Overlay, private injector: Injector) {\n    }\n\n    open<T>({origin, content, data, width, height, event}: PopoverParams<T>): PopoverRef<T> {\n        const overlayRef = this.overlay.create(this.getOverlayConfig({origin, width, height, event}));\n        const popoverRef = new PopoverRef<T>(overlayRef, content, data);\n        const injector = this.createInjector(popoverRef, this.injector);\n        overlayRef.attach(new ComponentPortal(PopoverComponent, null, injector));\n\n        return popoverRef;\n    }\n\n    private getOverlayConfig({origin, width, height, event}): OverlayConfig {\n        return new OverlayConfig({\n            hasBackdrop: true,\n            width,\n            height,\n            backdropClass: 'popover-backdrop',\n            positionStrategy: this.getOverlayPosition(origin, event),\n            scrollStrategy: this.overlay.scrollStrategies.reposition()\n        });\n    }\n\n    private getOverlayPosition(origin: ElementRef | HTMLElement, event?: MouseEvent): PositionStrategy {\n        // @ts-ignore\n        const offset = event.target.offsetTop - document.querySelector('.mat-sidenav-content').scrollTop;\n        if (event) {\n            return this.overlay.position()\n                .global()\n                .top(`${(offset + 50)}px`)\n                .left(`${(event.clientX - 30)}px`);\n        }\n        return this.overlay.position()\n            .flexibleConnectedTo(origin)\n            .withPositions(this.getPositions())\n            .withFlexibleDimensions(false)\n            .withPush(false);\n    }\n\n    updatePosition(popoverRef: PopoverRef, event: MouseEvent): void {\n        popoverRef.overlay.updatePositionStrategy(this.overlay.position()\n            .global()\n            .top(`${event.clientY}px`)\n            .left(`${event.clientX}px`));\n    }\n\n    createInjector(popoverRef: PopoverRef, injector: Injector) {\n        const tokens = new WeakMap([[PopoverRef, popoverRef]]);\n        return new PortalInjector(injector, tokens);\n    }\n\n    private getPositions(): ConnectionPositionPair[] {\n        return [\n            {\n                originX: 'end',\n                originY: 'bottom',\n                overlayX: 'end',\n                overlayY: 'top'\n            },\n            {\n                originX: 'end',\n                originY: 'bottom',\n                overlayX: 'end',\n                overlayY: 'top',\n            },\n        ];\n    }\n\n}\n"]}