@gipisistemas/ng-core 1.1.0 → 1.1.2

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

@@ -0,0 +1,21 @@
+import { __decorate, __metadata } from "tslib";
+import { Component, Input } from '@angular/core';
+let LoadingOverlayComponent = class LoadingOverlayComponent {
+    constructor() { }
+    ngOnInit() {
+    }
+};
+__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);
+export { LoadingOverlayComponent };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZGluZy1vdmVybGF5LmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BnaXBpc2lzdGVtYXMvbmctY29yZS8iLCJzb3VyY2VzIjpbInNoYXJlZC9jb21wb25lbnRzL2xvYWRpbmctb3ZlcmxheS9sb2FkaW5nLW92ZXJsYXkuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBVSxNQUFNLGVBQWUsQ0FBQztBQU96RCxJQUFhLHVCQUF1QixHQUFwQyxNQUFhLHVCQUF1QjtJQUlsQyxnQkFBZ0IsQ0FBQztJQUVqQixRQUFRO0lBQ1IsQ0FBQztDQUVGLENBQUE7QUFQVTtJQUFSLEtBQUssRUFBRTs7d0RBQWlCO0FBRmQsdUJBQXVCO0lBTG5DLFNBQVMsQ0FBQztRQUNULFFBQVEsRUFBRSxzQkFBc0I7UUFDaEMsMnZNQUErQzs7S0FFaEQsQ0FBQzs7R0FDVyx1QkFBdUIsQ0FTbkM7U0FUWSx1QkFBdUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQsIElucHV0LCBPbkluaXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnaXRzcy1sb2FkaW5nLW92ZXJsYXknLFxuICB0ZW1wbGF0ZVVybDogJy4vbG9hZGluZy1vdmVybGF5LmNvbXBvbmVudC5odG1sJyxcbiAgc3R5bGVVcmxzOiBbJy4vbG9hZGluZy1vdmVybGF5LmNvbXBvbmVudC5zY3NzJ11cbn0pXG5leHBvcnQgY2xhc3MgTG9hZGluZ092ZXJsYXlDb21wb25lbnQgaW1wbGVtZW50cyBPbkluaXQge1xuXG4gIEBJbnB1dCgpIG1lc3NhZ2U6IHN0cmluZztcblxuICBjb25zdHJ1Y3RvcigpIHsgfVxuXG4gIG5nT25Jbml0KCkge1xuICB9XG5cbn1cbiJdfQ==

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

@@ -0,0 +1,361 @@
+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';
+let OverlayPanelComponent = class OverlayPanelComponent {
+    constructor(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;
+    }
+    ngOnInit() {
+    }
+    ngAfterContentInit() {
+    }
+    bindDocumentClickListener() {
+        if (!this.documentClickListener && this.dismissable) {
+            this.zone.runOutsideAngular(() => {
+                const documentEvent = DomHandler.isIOS() ? 'touchstart' : 'click';
+                const documentTarget = this.el ? this.el.nativeElement.ownerDocument : 'document';
+                this.documentClickListener = this.renderer.listen(documentTarget, documentEvent, (event) => {
+                    if (!this.container.contains(event.target) && this.target !== event.target && !this.target.contains(event.target) && !this.selfClick) {
+                        this.zone.run(() => {
+                            this.hide();
+                        });
+                    }
+                    this.selfClick = false;
+                    this.cd.markForCheck();
+                });
+            });
+        }
+    }
+    unbindDocumentClickListener() {
+        if (this.documentClickListener) {
+            this.documentClickListener();
+            this.documentClickListener = null;
+            this.selfClick = false;
+        }
+    }
+    toggle(event, target) {
+        if (this.isOverlayAnimationInProgress) {
+            return;
+        }
+        if (this.overlayVisible) {
+            if (this.hasTargetChanged(event, target)) {
+                this.destroyCallback = () => {
+                    this.show(null, (target || event.currentTarget || event.target));
+                };
+            }
+            this.hide();
+        }
+        else {
+            this.show(event, target);
+        }
+    }
+    show(event, target) {
+        if (this.isOverlayAnimationInProgress) {
+            return;
+        }
+        this.target = target || event.currentTarget || event.target;
+        this.overlayVisible = true;
+        this.render = true;
+        this.cd.markForCheck();
+    }
+    onOverlayClick(event) {
+        this.overlayService.add({
+            originalEvent: event,
+            target: this.el.nativeElement
+        });
+        this.selfClick = true;
+    }
+    onContentClick() {
+        this.selfClick = true;
+    }
+    hasTargetChanged(event, target) {
+        return this.target != null && this.target !== (target || event.currentTarget || event.target);
+    }
+    appendContainer() {
+        if (this.appendTo) {
+            if (this.appendTo === 'body') {
+                document.body.appendChild(this.container);
+            }
+            else {
+                DomHandler.appendChild(this.container, this.appendTo);
+            }
+        }
+    }
+    restoreAppend() {
+        if (this.container && this.appendTo) {
+            this.el.nativeElement.appendChild(this.container);
+        }
+    }
+    align() {
+        if (this.autoZIndex) {
+            ZIndexUtils.set('overlay', this.container, this.baseZIndex + this.config.zIndex.overlay);
+        }
+        DomHandler.absolutePosition(this.container, this.target);
+        const containerOffset = DomHandler.getOffset(this.container);
+        const targetOffset = DomHandler.getOffset(this.target);
+        let 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');
+        }
+    }
+    onAnimationStart(event) {
+        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 = e => {
+                if (this.container && this.container.contains(e.target)) {
+                    this.selfClick = true;
+                }
+            };
+            this.overlaySubscription = this.overlayService.clickObservable.subscribe(this.overlayEventListener);
+        }
+        this.isOverlayAnimationInProgress = true;
+    }
+    onAnimationEnd(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;
+    }
+    focus() {
+        const focusable = DomHandler.findSingle(this.container, '[autofocus]');
+        if (focusable) {
+            this.zone.runOutsideAngular(() => {
+                setTimeout(() => focusable.focus(), 5);
+            });
+        }
+    }
+    hide() {
+        if (this.isOverlayAnimationInProgress) {
+            return;
+        }
+        this.overlayVisible = false;
+        this.cd.markForCheck();
+    }
+    onCloseClick(event) {
+        this.hide();
+        event.preventDefault();
+    }
+    onWindowResize(event) {
+        if (this.overlayVisible && !DomHandler.isTouchDevice()) {
+            this.hide();
+        }
+    }
+    bindDocumentResizeListener() {
+        this.documentResizeListener = this.onWindowResize.bind(this);
+        window.addEventListener('resize', this.documentResizeListener);
+    }
+    unbindDocumentResizeListener() {
+        if (this.documentResizeListener) {
+            window.removeEventListener('resize', this.documentResizeListener);
+            this.documentResizeListener = null;
+        }
+    }
+    bindScrollListener() {
+        if (!this.scrollHandler) {
+            this.scrollHandler = new ConnectedOverlayScrollHandler(this.target, () => {
+                if (this.overlayVisible) {
+                    this.hide();
+                }
+            });
+        }
+        this.scrollHandler.bindScrollListener();
+    }
+    unbindScrollListener() {
+        if (this.scrollHandler) {
+            this.scrollHandler.unbindScrollListener();
+        }
+    }
+    onContainerDestroy() {
+        if (!this.cd.destroyed) {
+            this.target = null;
+        }
+        this.unbindDocumentClickListener();
+        this.unbindDocumentResizeListener();
+        this.unbindScrollListener();
+    }
+    ngOnDestroy() {
+        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 = () => [
+    { 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);
+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/esm2015/shared/components/popover/popover-ref.js

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

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

@@ -0,0 +1,34 @@
+import { __decorate, __metadata } from "tslib";
+import { Component, TemplateRef } from '@angular/core';
+import { PopoverContent, PopoverRef } from './popover-ref';
+let PopoverComponent = class PopoverComponent {
+    constructor(popoverRef) {
+        this.popoverRef = popoverRef;
+        this.renderMethod = 'component';
+    }
+    ngOnInit() {
+        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 = () => [
+    { 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);
+export { PopoverComponent };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,85 @@
+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";
+let PopoverService = class PopoverService {
+    constructor(overlay, injector) {
+        this.overlay = overlay;
+        this.injector = injector;
+    }
+    open({ origin, content, data, width, height, event }) {
+        const overlayRef = this.overlay.create(this.getOverlayConfig({ origin, width, height, event }));
+        const popoverRef = new PopoverRef(overlayRef, content, data);
+        const injector = this.createInjector(popoverRef, this.injector);
+        overlayRef.attach(new ComponentPortal(PopoverComponent, null, injector));
+        return popoverRef;
+    }
+    getOverlayConfig({ origin, width, height, event }) {
+        return new OverlayConfig({
+            hasBackdrop: true,
+            width,
+            height,
+            backdropClass: 'popover-backdrop',
+            positionStrategy: this.getOverlayPosition(origin, event),
+            scrollStrategy: this.overlay.scrollStrategies.reposition()
+        });
+    }
+    getOverlayPosition(origin, event) {
+        // @ts-ignore
+        const 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);
+    }
+    updatePosition(popoverRef, event) {
+        popoverRef.overlay.updatePositionStrategy(this.overlay.position()
+            .global()
+            .top(`${event.clientY}px`)
+            .left(`${event.clientX}px`));
+    }
+    createInjector(popoverRef, injector) {
+        const tokens = new WeakMap([[PopoverRef, popoverRef]]);
+        return new PortalInjector(injector, tokens);
+    }
+    getPositions() {
+        return [
+            {
+                originX: 'end',
+                originY: 'bottom',
+                overlayX: 'end',
+                overlayY: 'top'
+            },
+            {
+                originX: 'end',
+                originY: 'bottom',
+                overlayX: 'end',
+                overlayY: 'top',
+            },
+        ];
+    }
+};
+PopoverService.ctorParameters = () => [
+    { 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);
+export { PopoverService };
+//# sourceMappingURL=data:application/json;base64,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