@netgrif/components-core 6.0.1

package/esm5/lib/snack-bar/models/abstract-snack-bar.js

@@ -0,0 +1,20 @@
+import { Inject } from '@angular/core';
+import { MAT_SNACK_BAR_DATA, MatSnackBarRef } from '@angular/material/snack-bar';
+var SnackBar = /** @class */ (function () {
+    function SnackBar(snackBarRef, data) {
+        this.snackBarRef = snackBarRef;
+        this.data = data;
+    }
+    SnackBar.prototype.onDismiss = function () {
+        this.snackBarRef.dismiss();
+    };
+    SnackBar.prototype.ngOnInit = function () {
+    };
+    SnackBar.ctorParameters = function () { return [
+        { type: MatSnackBarRef },
+        { type: undefined, decorators: [{ type: Inject, args: [MAT_SNACK_BAR_DATA,] }] }
+    ]; };
+    return SnackBar;
+}());
+export { SnackBar };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3Qtc25hY2stYmFyLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3NuYWNrLWJhci9tb2RlbHMvYWJzdHJhY3Qtc25hY2stYmFyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxNQUFNLEVBQVMsTUFBTSxlQUFlLENBQUM7QUFFN0MsT0FBTyxFQUFDLGtCQUFrQixFQUFFLGNBQWMsRUFBQyxNQUFNLDZCQUE2QixDQUFDO0FBRS9FO0lBRUksa0JBQTZCLFdBQThCLEVBQXFDLElBQTJCO1FBQTlGLGdCQUFXLEdBQVgsV0FBVyxDQUFtQjtRQUFxQyxTQUFJLEdBQUosSUFBSSxDQUF1QjtJQUMzSCxDQUFDO0lBRUQsNEJBQVMsR0FBVDtRQUNJLElBQUksQ0FBQyxXQUFXLENBQUMsT0FBTyxFQUFFLENBQUM7SUFDL0IsQ0FBQztJQUVELDJCQUFRLEdBQVI7SUFDQSxDQUFDOztnQkFadUIsY0FBYztnREFJd0IsTUFBTSxTQUFDLGtCQUFrQjs7SUFTM0YsZUFBQztDQUFBLEFBWEQsSUFXQztTQVhxQixRQUFRIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtJbmplY3QsIE9uSW5pdH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge1NuYWNrQmFySW5qZWN0aW9uRGF0YX0gZnJvbSAnLi9zbmFjay1iYXItaW5qZWN0aW9uLWRhdGEnO1xuaW1wb3J0IHtNQVRfU05BQ0tfQkFSX0RBVEEsIE1hdFNuYWNrQmFyUmVmfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9zbmFjay1iYXInO1xuXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgU25hY2tCYXI8VD4gaW1wbGVtZW50cyBPbkluaXQge1xuXG4gICAgcHJvdGVjdGVkIGNvbnN0cnVjdG9yKHB1YmxpYyBzbmFja0JhclJlZjogTWF0U25hY2tCYXJSZWY8VD4sIEBJbmplY3QoTUFUX1NOQUNLX0JBUl9EQVRBKSBwdWJsaWMgZGF0YTogU25hY2tCYXJJbmplY3Rpb25EYXRhKSB7XG4gICAgfVxuXG4gICAgb25EaXNtaXNzKCkge1xuICAgICAgICB0aGlzLnNuYWNrQmFyUmVmLmRpc21pc3MoKTtcbiAgICB9XG5cbiAgICBuZ09uSW5pdCgpIHtcbiAgICB9XG59XG4iXX0=

package/esm5/lib/snack-bar/models/injection-token-snackbar.js

@@ -0,0 +1,4 @@
+import { InjectionToken } from '@angular/core';
+export var NAE_SNACKBAR_VERTICAL_POSITION = new InjectionToken('NaeSnackBarVerticalPosition');
+export var NAE_SNACKBAR_HORIZONTAL_POSITION = new InjectionToken('NaeSnackBarHorizontalPosition');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5qZWN0aW9uLXRva2VuLXNuYWNrYmFyLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3NuYWNrLWJhci9tb2RlbHMvaW5qZWN0aW9uLXRva2VuLXNuYWNrYmFyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxjQUFjLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFHN0MsTUFBTSxDQUFDLElBQU0sOEJBQThCLEdBQUcsSUFBSSxjQUFjLENBQTJCLDZCQUE2QixDQUFDLENBQUM7QUFDMUgsTUFBTSxDQUFDLElBQU0sZ0NBQWdDLEdBQUcsSUFBSSxjQUFjLENBQTZCLCtCQUErQixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0luamVjdGlvblRva2VufSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7U25hY2tCYXJIb3Jpem9udGFsUG9zaXRpb24sIFNuYWNrQmFyVmVydGljYWxQb3NpdGlvbn0gZnJvbSAnLi9zbmFjay1iYXItZW51bXMnO1xuXG5leHBvcnQgY29uc3QgTkFFX1NOQUNLQkFSX1ZFUlRJQ0FMX1BPU0lUSU9OID0gbmV3IEluamVjdGlvblRva2VuPFNuYWNrQmFyVmVydGljYWxQb3NpdGlvbj4oJ05hZVNuYWNrQmFyVmVydGljYWxQb3NpdGlvbicpO1xuZXhwb3J0IGNvbnN0IE5BRV9TTkFDS0JBUl9IT1JJWk9OVEFMX1BPU0lUSU9OID0gbmV3IEluamVjdGlvblRva2VuPFNuYWNrQmFySG9yaXpvbnRhbFBvc2l0aW9uPignTmFlU25hY2tCYXJIb3Jpem9udGFsUG9zaXRpb24nKTtcbiJdfQ==

package/esm5/lib/snack-bar/models/snack-bar-enums.js

@@ -0,0 +1,12 @@
+export var SnackBarVerticalPosition;
+(function (SnackBarVerticalPosition) {
+    SnackBarVerticalPosition["BOTTOM"] = "bottom";
+    SnackBarVerticalPosition["TOP"] = "top";
+})(SnackBarVerticalPosition || (SnackBarVerticalPosition = {}));
+export var SnackBarHorizontalPosition;
+(function (SnackBarHorizontalPosition) {
+    SnackBarHorizontalPosition["LEFT"] = "left";
+    SnackBarHorizontalPosition["CENTER"] = "center";
+    SnackBarHorizontalPosition["RIGHT"] = "right";
+})(SnackBarHorizontalPosition || (SnackBarHorizontalPosition = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic25hY2stYmFyLWVudW1zLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3NuYWNrLWJhci9tb2RlbHMvc25hY2stYmFyLWVudW1zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLHdCQUdYO0FBSEQsV0FBWSx3QkFBd0I7SUFDaEMsNkNBQWlCLENBQUE7SUFDakIsdUNBQVcsQ0FBQTtBQUNmLENBQUMsRUFIVyx3QkFBd0IsS0FBeEIsd0JBQXdCLFFBR25DO0FBRUQsTUFBTSxDQUFOLElBQVksMEJBSVg7QUFKRCxXQUFZLDBCQUEwQjtJQUNsQywyQ0FBYSxDQUFBO0lBQ2IsK0NBQWlCLENBQUE7SUFDakIsNkNBQWUsQ0FBQTtBQUNuQixDQUFDLEVBSlcsMEJBQTBCLEtBQTFCLDBCQUEwQixRQUlyQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIFNuYWNrQmFyVmVydGljYWxQb3NpdGlvbiB7XG4gICAgQk9UVE9NID0gJ2JvdHRvbScsXG4gICAgVE9QID0gJ3RvcCdcbn1cblxuZXhwb3J0IGVudW0gU25hY2tCYXJIb3Jpem9udGFsUG9zaXRpb24ge1xuICAgIExFRlQgPSAnbGVmdCcsXG4gICAgQ0VOVEVSID0gJ2NlbnRlcicsXG4gICAgUklHSFQgPSAncmlnaHQnXG59XG4iXX0=

package/esm5/lib/snack-bar/models/snack-bar-injection-data.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic25hY2stYmFyLWluamVjdGlvbi1kYXRhLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3NuYWNrLWJhci9tb2RlbHMvc25hY2stYmFyLWluamVjdGlvbi1kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIFNuYWNrQmFySW5qZWN0aW9uRGF0YSB7XG4gICAgbWVzc2FnZTogc3RyaW5nO1xuICAgIG1hdEljb25OYW1lOiBzdHJpbmc7XG4gICAgY2xvc2FibGU/OiBib29sZWFuO1xufVxuIl19

package/esm5/lib/snack-bar/public-api.js

@@ -0,0 +1,15 @@
+// COMPONENTS
+export * from './components/generic-snack-bar/generic-snack-bar.component';
+export * from './components/success-snack-bar/success-snack-bar.component';
+export * from './components/warning-snack-bar/warning-snack-bar.component';
+export * from './components/error-snack-bar/error-snack-bar.component';
+// MODULES
+export * from './snack-bar.module';
+// SERVICES
+export * from './services/snack-bar.service';
+// MODELS
+export * from './models/snack-bar-injection-data';
+export * from './models/abstract-snack-bar';
+export * from './models/injection-token-snackbar';
+export * from './models/snack-bar-enums';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9zbmFjay1iYXIvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxhQUFhO0FBQ2IsY0FBYyw0REFBNEQsQ0FBQztBQUMzRSxjQUFjLDREQUE0RCxDQUFDO0FBQzNFLGNBQWMsNERBQTRELENBQUM7QUFDM0UsY0FBYyx3REFBd0QsQ0FBQztBQUV2RSxVQUFVO0FBQ1YsY0FBYyxvQkFBb0IsQ0FBQztBQUVuQyxXQUFXO0FBQ1gsY0FBYyw4QkFBOEIsQ0FBQztBQUU3QyxTQUFTO0FBQ1QsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYywwQkFBMEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENPTVBPTkVOVFNcbmV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50cy9nZW5lcmljLXNuYWNrLWJhci9nZW5lcmljLXNuYWNrLWJhci5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9jb21wb25lbnRzL3N1Y2Nlc3Mtc25hY2stYmFyL3N1Y2Nlc3Mtc25hY2stYmFyLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudHMvd2FybmluZy1zbmFjay1iYXIvd2FybmluZy1zbmFjay1iYXIuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50cy9lcnJvci1zbmFjay1iYXIvZXJyb3Itc25hY2stYmFyLmNvbXBvbmVudCc7XG5cbi8vIE1PRFVMRVNcbmV4cG9ydCAqIGZyb20gJy4vc25hY2stYmFyLm1vZHVsZSc7XG5cbi8vIFNFUlZJQ0VTXG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL3NuYWNrLWJhci5zZXJ2aWNlJztcblxuLy8gTU9ERUxTXG5leHBvcnQgKiBmcm9tICcuL21vZGVscy9zbmFjay1iYXItaW5qZWN0aW9uLWRhdGEnO1xuZXhwb3J0ICogZnJvbSAnLi9tb2RlbHMvYWJzdHJhY3Qtc25hY2stYmFyJztcbmV4cG9ydCAqIGZyb20gJy4vbW9kZWxzL2luamVjdGlvbi10b2tlbi1zbmFja2Jhcic7XG5leHBvcnQgKiBmcm9tICcuL21vZGVscy9zbmFjay1iYXItZW51bXMnO1xuIl19

package/esm5/lib/snack-bar/services/snack-bar.service.js

@@ -0,0 +1,105 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { GenericSnackBarComponent } from '../components/generic-snack-bar/generic-snack-bar.component';
+import { SuccessSnackBarComponent } from '../components/success-snack-bar/success-snack-bar.component';
+import { ErrorSnackBarComponent } from '../components/error-snack-bar/error-snack-bar.component';
+import { WarningSnackBarComponent } from '../components/warning-snack-bar/warning-snack-bar.component';
+import { MatSnackBar, MatSnackBarConfig, MatSnackBarRef } from '@angular/material/snack-bar';
+import { SnackBarHorizontalPosition, SnackBarVerticalPosition } from '../models/snack-bar-enums';
+import { NAE_SNACKBAR_HORIZONTAL_POSITION, NAE_SNACKBAR_VERTICAL_POSITION } from '../models/injection-token-snackbar';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/snack-bar";
+import * as i2 from "../models/injection-token-snackbar";
+var SnackBarService = /** @class */ (function () {
+    function SnackBarService(_snackBar, naeVerticalPosition, naeHorizontalPosition) {
+        this._snackBar = _snackBar;
+        this._defaultTimeout = 2.5;
+        this._verticalPosition = SnackBarVerticalPosition.BOTTOM;
+        this._horizontalPosition = SnackBarHorizontalPosition.CENTER;
+        if (naeVerticalPosition) {
+            this._verticalPosition = naeVerticalPosition;
+        }
+        if (naeHorizontalPosition) {
+            this._horizontalPosition = naeHorizontalPosition;
+        }
+    }
+    SnackBarService.prototype.openSuccessSnackBar = function (message, verticalPosition, horizontalPosition, durationInSeconds, config) {
+        if (verticalPosition === void 0) { verticalPosition = this._verticalPosition; }
+        if (horizontalPosition === void 0) { horizontalPosition = this._horizontalPosition; }
+        if (durationInSeconds === void 0) { durationInSeconds = this._defaultTimeout; }
+        return this._snackBar.openFromComponent(SuccessSnackBarComponent, Object.assign({
+            data: {
+                message: message,
+                matIconName: 'done',
+                closable: false
+            },
+            duration: durationInSeconds * 1000,
+            horizontalPosition: horizontalPosition,
+            verticalPosition: verticalPosition
+        }, config));
+    };
+    SnackBarService.prototype.openErrorSnackBar = function (message, verticalPosition, horizontalPosition, 
+    // durationInSeconds = this._defaultTimeout,
+    config) {
+        if (verticalPosition === void 0) { verticalPosition = this._verticalPosition; }
+        if (horizontalPosition === void 0) { horizontalPosition = this._horizontalPosition; }
+        return this._snackBar.openFromComponent(ErrorSnackBarComponent, Object.assign({
+            data: {
+                message: message,
+                matIconName: 'error',
+                closable: true
+            },
+            // duration: durationInSeconds * 1000, // Error has to be acknowledged to be closed
+            horizontalPosition: horizontalPosition,
+            verticalPosition: verticalPosition
+        }, config));
+    };
+    SnackBarService.prototype.openWarningSnackBar = function (message, verticalPosition, horizontalPosition, durationInSeconds, config) {
+        if (verticalPosition === void 0) { verticalPosition = this._verticalPosition; }
+        if (horizontalPosition === void 0) { horizontalPosition = this._horizontalPosition; }
+        if (durationInSeconds === void 0) { durationInSeconds = this._defaultTimeout; }
+        return this._snackBar.openFromComponent(WarningSnackBarComponent, Object.assign({
+            data: {
+                message: message,
+                matIconName: 'warning',
+                closable: false
+            },
+            duration: durationInSeconds * 1000,
+            horizontalPosition: horizontalPosition,
+            verticalPosition: verticalPosition
+        }, config));
+    };
+    SnackBarService.prototype.openGenericSnackBar = function (message, matIconName, verticalPosition, horizontalPosition, durationInSeconds, config) {
+        if (verticalPosition === void 0) { verticalPosition = this._verticalPosition; }
+        if (horizontalPosition === void 0) { horizontalPosition = this._horizontalPosition; }
+        if (durationInSeconds === void 0) { durationInSeconds = this._defaultTimeout; }
+        return this._snackBar.openFromComponent(GenericSnackBarComponent, Object.assign({
+            data: {
+                message: message,
+                matIconName: matIconName,
+                closable: true
+            },
+            duration: durationInSeconds * 1000,
+            horizontalPosition: horizontalPosition,
+            verticalPosition: verticalPosition
+        }, config));
+    };
+    SnackBarService.ctorParameters = function () { return [
+        { type: MatSnackBar },
+        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NAE_SNACKBAR_VERTICAL_POSITION,] }] },
+        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NAE_SNACKBAR_HORIZONTAL_POSITION,] }] }
+    ]; };
+    SnackBarService.ɵprov = i0.ɵɵdefineInjectable({ factory: function SnackBarService_Factory() { return new SnackBarService(i0.ɵɵinject(i1.MatSnackBar), i0.ɵɵinject(i2.NAE_SNACKBAR_VERTICAL_POSITION, 8), i0.ɵɵinject(i2.NAE_SNACKBAR_HORIZONTAL_POSITION, 8)); }, token: SnackBarService, providedIn: "root" });
+    SnackBarService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    SnackBarService.ctorParameters = function () { return [
+        { type: MatSnackBar },
+        { type: SnackBarVerticalPosition, decorators: [{ type: Optional }, { type: Inject, args: [NAE_SNACKBAR_VERTICAL_POSITION,] }] },
+        { type: SnackBarHorizontalPosition, decorators: [{ type: Optional }, { type: Inject, args: [NAE_SNACKBAR_HORIZONTAL_POSITION,] }] }
+    ]; };
+    return SnackBarService;
+}());
+export { SnackBarService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"snack-bar.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/snack-bar/services/snack-bar.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAC,MAAM,eAAe,CAAC;AAC3D,OAAO,EAAC,wBAAwB,EAAC,MAAM,6DAA6D,CAAC;AACrG,OAAO,EAAC,wBAAwB,EAAC,MAAM,6DAA6D,CAAC;AACrG,OAAO,EAAC,sBAAsB,EAAC,MAAM,yDAAyD,CAAC;AAC/F,OAAO,EAAC,wBAAwB,EAAC,MAAM,6DAA6D,CAAC;AAErG,OAAO,EAAC,WAAW,EAAE,iBAAiB,EAAE,cAAc,EAAC,MAAM,6BAA6B,CAAC;AAC3F,OAAO,EAAC,0BAA0B,EAAE,wBAAwB,EAAC,MAAM,2BAA2B,CAAC;AAC/F,OAAO,EAAC,gCAAgC,EAAE,8BAA8B,EAAC,MAAM,oCAAoC,CAAC;;;;AAEpH;IASI,yBAAoB,SAAsB,EACsB,mBAA6C,EAC3C,qBAAiD;QAF/F,cAAS,GAAT,SAAS,CAAa;QAJlC,oBAAe,GAAG,GAAG,CAAC;QAO1B,IAAI,CAAC,iBAAiB,GAAG,wBAAwB,CAAC,MAAM,CAAC;QACzD,IAAI,CAAC,mBAAmB,GAAG,0BAA0B,CAAC,MAAM,CAAC;QAC7D,IAAI,mBAAmB,EAAE;YACrB,IAAI,CAAC,iBAAiB,GAAG,mBAAmB,CAAC;SAChD;QACD,IAAI,qBAAqB,EAAE;YACvB,IAAI,CAAC,mBAAmB,GAAG,qBAAqB,CAAC;SACpD;IACL,CAAC;IAEM,6CAAmB,GAA1B,UAA2B,OAAe,EACf,gBAAyC,EACzC,kBAA6C,EAC7C,iBAAwC,EACxC,MAAiD;QAHjD,iCAAA,EAAA,mBAAmB,IAAI,CAAC,iBAAiB;QACzC,mCAAA,EAAA,qBAAqB,IAAI,CAAC,mBAAmB;QAC7C,kCAAA,EAAA,oBAAoB,IAAI,CAAC,eAAe;QAE/D,OAAO,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC,wBAAwB,EAAE,MAAM,CAAC,MAAM,CAAC;YAC5E,IAAI,EAAE;gBACF,OAAO,SAAA;gBACP,WAAW,EAAE,MAAM;gBACnB,QAAQ,EAAE,KAAK;aAClB;YACD,QAAQ,EAAE,iBAAiB,GAAG,IAAI;YAClC,kBAAkB,oBAAA;YAClB,gBAAgB,kBAAA;SACnB,EAAE,MAAM,CAAC,CAAC,CAAC;IAChB,CAAC;IAEM,2CAAiB,GAAxB,UAAyB,OAAe,EACf,gBAAyC,EACzC,kBAA6C;IAC7C,4CAA4C;IAC5C,MAAiD;QAHjD,iCAAA,EAAA,mBAAmB,IAAI,CAAC,iBAAiB;QACzC,mCAAA,EAAA,qBAAqB,IAAI,CAAC,mBAAmB;QAGlE,OAAO,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC,sBAAsB,EAAE,MAAM,CAAC,MAAM,CAAC;YAC1E,IAAI,EAAE;gBACF,OAAO,SAAA;gBACP,WAAW,EAAE,OAAO;gBACpB,QAAQ,EAAE,IAAI;aACjB;YACD,mFAAmF;YACnF,kBAAkB,oBAAA;YAClB,gBAAgB,kBAAA;SACnB,EAAE,MAAM,CAAC,CAAC,CAAC;IAChB,CAAC;IAEM,6CAAmB,GAA1B,UAA2B,OAAe,EACf,gBAAyC,EACzC,kBAA6C,EAC7C,iBAAwC,EACxC,MAAiD;QAHjD,iCAAA,EAAA,mBAAmB,IAAI,CAAC,iBAAiB;QACzC,mCAAA,EAAA,qBAAqB,IAAI,CAAC,mBAAmB;QAC7C,kCAAA,EAAA,oBAAoB,IAAI,CAAC,eAAe;QAE/D,OAAO,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC,wBAAwB,EAAE,MAAM,CAAC,MAAM,CAAC;YAC5E,IAAI,EAAE;gBACF,OAAO,SAAA;gBACP,WAAW,EAAE,SAAS;gBACtB,QAAQ,EAAE,KAAK;aAClB;YACD,QAAQ,EAAE,iBAAiB,GAAG,IAAI;YAClC,kBAAkB,oBAAA;YAClB,gBAAgB,kBAAA;SACnB,EAAE,MAAM,CAAC,CAAC,CAAC;IAChB,CAAC;IAEM,6CAAmB,GAA1B,UAA2B,OAAe,EACf,WAAmB,EACnB,gBAAyC,EACzC,kBAA6C,EAC7C,iBAAwC,EACxC,MAAiD;QAHjD,iCAAA,EAAA,mBAAmB,IAAI,CAAC,iBAAiB;QACzC,mCAAA,EAAA,qBAAqB,IAAI,CAAC,mBAAmB;QAC7C,kCAAA,EAAA,oBAAoB,IAAI,CAAC,eAAe;QAE/D,OAAO,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC,wBAAwB,EAAE,MAAM,CAAC,MAAM,CAAC;YAC5E,IAAI,EAAE;gBACF,OAAO,SAAA;gBACP,WAAW,aAAA;gBACX,QAAQ,EAAE,IAAI;aACjB;YACD,QAAQ,EAAE,iBAAiB,GAAG,IAAI;YAClC,kBAAkB,oBAAA;YAClB,gBAAgB,kBAAA;SACnB,EAAE,MAAM,CAAC,CAAC,CAAC;IAChB,CAAC;;gBAhF8B,WAAW;gDAC7B,QAAQ,YAAI,MAAM,SAAC,8BAA8B;gDACjD,QAAQ,YAAI,MAAM,SAAC,gCAAgC;;;;gBAXnE,UAAU,SAAC;oBACR,UAAU,EAAE,MAAM;iBACrB;;;gBANO,WAAW;gBACiB,wBAAwB,uBAa3C,QAAQ,YAAI,MAAM,SAAC,8BAA8B;gBAb1D,0BAA0B,uBAcjB,QAAQ,YAAI,MAAM,SAAC,gCAAgC;;0BArBpE;CAoGC,AA1FD,IA0FC;SAvFY,eAAe","sourcesContent":["import {Inject, Injectable, Optional} from '@angular/core';\nimport {GenericSnackBarComponent} from '../components/generic-snack-bar/generic-snack-bar.component';\nimport {SuccessSnackBarComponent} from '../components/success-snack-bar/success-snack-bar.component';\nimport {ErrorSnackBarComponent} from '../components/error-snack-bar/error-snack-bar.component';\nimport {WarningSnackBarComponent} from '../components/warning-snack-bar/warning-snack-bar.component';\nimport {SnackBarInjectionData} from '../models/snack-bar-injection-data';\nimport {MatSnackBar, MatSnackBarConfig, MatSnackBarRef} from '@angular/material/snack-bar';\nimport {SnackBarHorizontalPosition, SnackBarVerticalPosition} from '../models/snack-bar-enums';\nimport {NAE_SNACKBAR_HORIZONTAL_POSITION, NAE_SNACKBAR_VERTICAL_POSITION} from '../models/injection-token-snackbar';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class SnackBarService {\n\n    private _defaultTimeout = 2.5;\n    private _verticalPosition: SnackBarVerticalPosition;\n    private _horizontalPosition: SnackBarHorizontalPosition;\n\n    constructor(private _snackBar: MatSnackBar,\n                @Optional() @Inject(NAE_SNACKBAR_VERTICAL_POSITION) naeVerticalPosition: SnackBarVerticalPosition,\n                @Optional() @Inject(NAE_SNACKBAR_HORIZONTAL_POSITION) naeHorizontalPosition: SnackBarHorizontalPosition) {\n        this._verticalPosition = SnackBarVerticalPosition.BOTTOM;\n        this._horizontalPosition = SnackBarHorizontalPosition.CENTER;\n        if (naeVerticalPosition) {\n            this._verticalPosition = naeVerticalPosition;\n        }\n        if (naeHorizontalPosition) {\n            this._horizontalPosition = naeHorizontalPosition;\n        }\n    }\n\n    public openSuccessSnackBar(message: string,\n                               verticalPosition = this._verticalPosition,\n                               horizontalPosition = this._horizontalPosition,\n                               durationInSeconds = this._defaultTimeout,\n                               config?: MatSnackBarConfig<SnackBarInjectionData>): MatSnackBarRef<SuccessSnackBarComponent> {\n        return this._snackBar.openFromComponent(SuccessSnackBarComponent, Object.assign({\n            data: {\n                message,\n                matIconName: 'done',\n                closable: false\n            },\n            duration: durationInSeconds * 1000,\n            horizontalPosition,\n            verticalPosition\n        }, config));\n    }\n\n    public openErrorSnackBar(message: string,\n                             verticalPosition = this._verticalPosition,\n                             horizontalPosition = this._horizontalPosition,\n                             // durationInSeconds = this._defaultTimeout,\n                             config?: MatSnackBarConfig<SnackBarInjectionData>): MatSnackBarRef<ErrorSnackBarComponent> {\n        return this._snackBar.openFromComponent(ErrorSnackBarComponent, Object.assign({\n            data: {\n                message,\n                matIconName: 'error',\n                closable: true\n            },\n            // duration: durationInSeconds * 1000, // Error has to be acknowledged to be closed\n            horizontalPosition,\n            verticalPosition\n        }, config));\n    }\n\n    public openWarningSnackBar(message: string,\n                               verticalPosition = this._verticalPosition,\n                               horizontalPosition = this._horizontalPosition,\n                               durationInSeconds = this._defaultTimeout,\n                               config?: MatSnackBarConfig<SnackBarInjectionData>): MatSnackBarRef<WarningSnackBarComponent> {\n        return this._snackBar.openFromComponent(WarningSnackBarComponent, Object.assign({\n            data: {\n                message,\n                matIconName: 'warning',\n                closable: false\n            },\n            duration: durationInSeconds * 1000,\n            horizontalPosition,\n            verticalPosition\n        }, config));\n    }\n\n    public openGenericSnackBar(message: string,\n                               matIconName: string,\n                               verticalPosition = this._verticalPosition,\n                               horizontalPosition = this._horizontalPosition,\n                               durationInSeconds = this._defaultTimeout,\n                               config?: MatSnackBarConfig<SnackBarInjectionData>): MatSnackBarRef<GenericSnackBarComponent> {\n        return this._snackBar.openFromComponent(GenericSnackBarComponent, Object.assign({\n            data: {\n                message,\n                matIconName,\n                closable: true\n            },\n            duration: durationInSeconds * 1000,\n            horizontalPosition,\n            verticalPosition\n        }, config));\n    }\n}\n"]}

package/esm5/lib/snack-bar/snack-bar.module.js

@@ -0,0 +1,37 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { GenericSnackBarComponent } from './components/generic-snack-bar/generic-snack-bar.component';
+import { MaterialModule } from '../material/material.module';
+import { WarningSnackBarComponent } from './components/warning-snack-bar/warning-snack-bar.component';
+import { ErrorSnackBarComponent } from './components/error-snack-bar/error-snack-bar.component';
+import { SuccessSnackBarComponent } from './components/success-snack-bar/success-snack-bar.component';
+import { FlexLayoutModule, FlexModule } from '@angular/flex-layout';
+var SnackBarModule = /** @class */ (function () {
+    function SnackBarModule() {
+    }
+    SnackBarModule.decorators = [
+        { type: NgModule, args: [{
+                    declarations: [
+                        GenericSnackBarComponent,
+                        WarningSnackBarComponent,
+                        ErrorSnackBarComponent,
+                        SuccessSnackBarComponent
+                    ],
+                    imports: [
+                        CommonModule,
+                        MaterialModule,
+                        FlexLayoutModule,
+                        FlexModule
+                    ],
+                    entryComponents: [
+                        GenericSnackBarComponent,
+                        WarningSnackBarComponent,
+                        ErrorSnackBarComponent,
+                        SuccessSnackBarComponent
+                    ]
+                },] }
+    ];
+    return SnackBarModule;
+}());
+export { SnackBarModule };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/tabs/classes/opened-tab.js

@@ -0,0 +1,50 @@
+import { BehaviorSubject, Subject } from 'rxjs';
+/**
+ * Holds the information of tab opened in a tab view.
+ *
+ * See {@link TabView} for more information.
+ */
+var OpenedTab = /** @class */ (function () {
+    /**
+     * @param tabContent - content of the tab
+     * @param uniqueId - unique identifier for the tab
+     */
+    function OpenedTab(tabContent, uniqueId) {
+        this.uniqueId = uniqueId;
+        /**
+         * See [TabContent.injectedObject]{@link TabContent#injectedObject}.
+         */
+        this.injectedObject = {};
+        /**
+         * See [TabContent.order]{@link TabContent#order}.
+         */
+        this.order = 0;
+        /**
+         * See [TabContent.initial]{@link TabContent#initial}.
+         */
+        this.initial = false;
+        /**
+         * See [TabContent.parentUniqueId]{@link TabContent#parentUniqueId}.
+         */
+        this.parentUniqueId = undefined;
+        /**
+         * Whether the tab was initialized after it's creation.
+         *
+         * See [TabGroup.initializeTab()]{@link TabView#initializeTab} for more information.
+         */
+        this.isTabInitialized = false;
+        Object.assign(this, tabContent);
+        this.tabSelected$ = new BehaviorSubject(false);
+        this.tabClosed$ = new Subject();
+    }
+    /**
+     * Closes the stream held in this object
+     */
+    OpenedTab.prototype.destroy = function () {
+        this.tabSelected$.complete();
+        this.tabClosed$.complete();
+    };
+    return OpenedTab;
+}());
+export { OpenedTab };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/tabs/classes/tab-view.js

@@ -0,0 +1,283 @@
+import { OpenedTab } from './opened-tab';
+import { Injector } from '@angular/core';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { orderBy } from 'natural-orderby';
+import { NAE_TAB_DATA } from '../tab-data-injection-token/tab-data-injection-token';
+import { IncrementingCounter } from '../../utility/incrementing-counter';
+import { NAE_VIEW_ID_SEGMENT } from '../../user/models/view-id-injection-tokens';
+/**
+ * Holds the logic for tab management in {@link AbstractTabViewComponent}.
+ * If you want to implement your own TabViewComponent, you might want to extend this class to hold your logic.
+ */
+var TabView = /** @class */ (function () {
+    /**
+     * @param _viewService [ViewService]{@link ViewService} reference
+     * @param _logger [Logger]{@link LoggerService} reference
+     * @param _initialTabs Tabs that should be initially opened in the tab view
+     * @param _parentInjector `Injector` instance of the [TabViewComponent]{@link AbstractTabViewComponent},
+     * to be passed onto each tab, so that the dependency injection tree is not broken
+     */
+    function TabView(_viewService, _logger, _initialTabs, _parentInjector) {
+        var _this = this;
+        this._viewService = _viewService;
+        this._logger = _logger;
+        this._initialTabs = _initialTabs;
+        this._parentInjector = _parentInjector;
+        /**
+         * Holds the index of the currently selected tab.
+         *
+         * Selected index initializes to `0`.
+         */
+        this.selectedIndex = 0;
+        this.uniqueIdCounter = new IncrementingCounter();
+        /**
+         * @ignore
+         * Holds a reference to an object that hides some public attributes and methods from tabs.
+         */
+        this.tabViewInterface = {
+            currentlySelectedTab: function () { return _this.currentlySelectedTab(); },
+            openTab: function (tabContent, autoswitch) {
+                if (autoswitch === void 0) { autoswitch = false; }
+                return _this.openTab(tabContent, autoswitch);
+            },
+            switchToTabIndex: function (index) { return _this.switchToTabIndex(index); },
+            switchToTabUniqueId: function (uniqueId) { return _this.switchToTabUniqueId(uniqueId); },
+            closeTabIndex: function (index, force) {
+                if (force === void 0) { force = false; }
+                return _this.closeTabIndex(index, force);
+            },
+            closeTabUniqueId: function (uniqueId, force) {
+                if (force === void 0) { force = false; }
+                return _this.closeTabUniqueId(uniqueId, force);
+            }
+        };
+        this._initialTabs.forEach(function (tab) {
+            if (tab.order === undefined) {
+                tab.order = 0;
+            }
+            tab.initial = true;
+        });
+        // orderBy is a stable sort
+        // Native javascript implementation has undefined stability and it depends on it's implementation (browser)
+        this.openedTabs = orderBy(this._initialTabs, function (v) { return v.order; }, 'asc').map(function (tabData) {
+            return new OpenedTab(tabData, "" + _this.uniqueIdCounter.next());
+        });
+        if (this.openedTabs.length > 0) {
+            this.openedTabs[0].tabSelected$.next(true);
+        }
+    }
+    /**
+     * @returns the index of the currently selected tab
+     */
+    TabView.prototype.currentlySelectedTab = function () {
+        return this.selectedIndex;
+    };
+    /**
+     * Opens a new tab with the provided content.
+     * @param tabContent - content of the new tab
+     * @param autoswitch - whether the newly opened tab should be switched to. Defaults to `false`.
+     * @param openExisting - whether the opened tab already existing should be switched to existing one. Defaults to `true`.
+     * @returns the `tabUniqueId` of the newly opened tab
+     */
+    TabView.prototype.openTab = function (tabContent, autoswitch, openExisting) {
+        if (autoswitch === void 0) { autoswitch = false; }
+        if (openExisting === void 0) { openExisting = true; }
+        if (tabContent.initial) {
+            this._logger.warn("'initial' attribute is not meant to be used with new tabs and will be ignored");
+            delete tabContent.initial;
+        }
+        var newTab = new OpenedTab(tabContent, "" + this.uniqueIdCounter.next());
+        var indexExisting = this.findIndexExistingTab(newTab);
+        if (indexExisting === -1 || !openExisting) {
+            return this.openNewTab(newTab, autoswitch);
+        }
+        else {
+            this.openedTabs[this.selectedIndex].tabSelected$.next(false);
+            this.selectedIndex = indexExisting;
+            this.openedTabs[this.selectedIndex].tabSelected$.next(true);
+            return this.openedTabs[indexExisting].uniqueId;
+        }
+    };
+    TabView.prototype.findIndexExistingTab = function (newTab) {
+        var _this = this;
+        if (!this.searchesForOneCaseId(newTab)) {
+            return -1;
+        }
+        return this.openedTabs.findIndex(function (existingTab) {
+            return _this.searchesForOneCaseId(existingTab) && _this.getSearchedCaseId(existingTab) === _this.getSearchedCaseId(newTab);
+        });
+    };
+    TabView.prototype.searchesForOneCaseId = function (tab) {
+        return this.hasCaseFilterParamSet(tab)
+            && !Array.isArray(this.getSearchedCase(tab))
+            && !!this.getSearchedCaseId(tab);
+    };
+    TabView.prototype.getSearchedCaseId = function (tab) {
+        return this.getSearchedCase(tab).id;
+    };
+    TabView.prototype.getSearchedCase = function (tab) {
+        return tab.injectedObject.baseFilter.getRequestBody().case;
+    };
+    TabView.prototype.hasCaseFilterParamSet = function (tab) {
+        return this.hasBaseFilter(tab)
+            && !!(tab.injectedObject.baseFilter.getRequestBody().case);
+    };
+    TabView.prototype.hasBaseFilter = function (tab) {
+        return this.hasInjectedObject(tab) && !!(tab.injectedObject.baseFilter);
+    };
+    TabView.prototype.hasInjectedObject = function (tab) {
+        return !!tab.injectedObject;
+    };
+    /**
+     * Adds a new tab into the correct position based on its `order` property.
+     * @param newTab the tab that should be opened
+     * @param autoswitch whether the new tab should be switched to after it is created
+     * @returns the `uniqueId` of the opened tab
+     */
+    TabView.prototype.openNewTab = function (newTab, autoswitch) {
+        var index = this.openedTabs.findIndex(function (existingTab) { return existingTab.order > newTab.order; });
+        if (index === -1) {
+            index = this.openedTabs.length;
+        }
+        this.openedTabs.splice(index, 0, newTab);
+        if (autoswitch || this.openedTabs.length === 1) {
+            this.openedTabs[this.selectedIndex].tabSelected$.next(false);
+            this.selectedIndex = index;
+            this.openedTabs[this.selectedIndex].tabSelected$.next(true);
+        }
+        return newTab.uniqueId;
+    };
+    /**
+     * Switches to a tab with the given `index`.
+     *
+     * Throws an error if the `index` is invalid.
+     * @param index - index of the tab that should be switched to
+     */
+    TabView.prototype.switchToTabIndex = function (index) {
+        this.checkIndexRange(index);
+        this.openedTabs[this.selectedIndex].tabSelected$.next(false);
+        this.selectedIndex = index;
+        this.openedTabs[this.selectedIndex].tabSelected$.next(true);
+    };
+    /**
+     * Switches to a tab with the given `uniqueId`.
+     *
+     * Throws an error if the `uniqueId` is invalid.
+     * @param uniqueId - id of the tab that should be switched to
+     */
+    TabView.prototype.switchToTabUniqueId = function (uniqueId) {
+        this.openedTabs[this.selectedIndex].tabSelected$.next(false);
+        this.selectedIndex = this.getTabIndex(uniqueId);
+        this.openedTabs[this.selectedIndex].tabSelected$.next(true);
+    };
+    /**
+     * Closes the tab with the given `index`.
+     *
+     * Throws an error if the `index` is invalid.
+     *
+     * Throws an error if the tab has it's `canBeClosed` property set to `false`.
+     * @param index index of the tab that should be closed
+     * @param force when `true` closes a tab even if it's `cantBeClosed` attribute is set to `true`
+     */
+    TabView.prototype.closeTabIndex = function (index, force) {
+        if (force === void 0) { force = false; }
+        this.closeTab(index, force, "Tab at index " + index + " can't be closed");
+    };
+    /**
+     * Closes the tab with the given `uniqueId`. Throws an error if the `uniqueId` is invalid.
+     * Throws an error if the tab has it's `canBeClosed` property set to `false`.
+     * @param uniqueId - id of the tab that should be closed
+     * @param force when `true` closes a tab even if it's `cantBeClosed` attribute is set to `true`
+     */
+    TabView.prototype.closeTabUniqueId = function (uniqueId, force) {
+        if (force === void 0) { force = false; }
+        var index = this.getTabIndex(uniqueId);
+        this.closeTab(index, force, "Tab with ID " + uniqueId + " can't be closed");
+    };
+    /**
+     * Closes the tab at the given index.
+     *
+     * If the conditions for closing a tab are not met throws an `Error` with the given message.
+     * @param index index of the tab that should be closed
+     * @param force when `true` closes a tab even if it's `cantBeClosed` attribute is set to `true`
+     * @param error the message that should be displayed if the conditions for closing a tab are not met
+     */
+    TabView.prototype.closeTab = function (index, force, error) {
+        this.checkIndexRange(index);
+        if (!force && !this.openedTabs[index].canBeClosed) {
+            throw new Error(error);
+        }
+        if (index === this.selectedIndex && this.openedTabs[index].parentUniqueId) {
+            this.switchToTabUniqueId(this.openedTabs[index].parentUniqueId);
+        }
+        if (index === this.selectedIndex && this.selectedIndex + 1 < this.openedTabs.length) {
+            this.openedTabs[index + 1].tabSelected$.next(true);
+        }
+        this.openedTabs[index].tabClosed$.next();
+        var deleted = this.openedTabs.splice(index, 1);
+        deleted[0].destroy();
+        if (index < this.selectedIndex) {
+            this.selectedIndex = this.selectedIndex - 1;
+        }
+    };
+    /**
+     * Initializes the tab if it wasn't initialized yet.
+     * Creates a new {@link ComponentPortal} for the tab and provides the data for the tab under the `NAE_TAB_DATA` injection token.
+     * @param index - index of the tab that should be initialized
+     */
+    TabView.prototype.initializeTab = function (index) {
+        this.checkIndexRange(index);
+        var tab = this.openedTabs[index];
+        if (!tab.isTabInitialized) {
+            Object.assign(tab.injectedObject, {
+                tabUniqueId: tab.uniqueId,
+                tabViewRef: this.tabViewInterface,
+                tabSelected$: tab.tabSelected$.asObservable(),
+                tabClosed$: tab.tabClosed$.asObservable(),
+            });
+            var providers = [
+                { provide: NAE_TAB_DATA, useValue: tab.injectedObject }
+            ];
+            providers.push({ provide: NAE_VIEW_ID_SEGMENT, useValue: tab.initial ? tab.uniqueId : TabView.DYNAMIC_TAB_VIEW_ID_SEGMENT });
+            var injector = Injector.create({ providers: providers, parent: this._parentInjector });
+            tab.portal = new ComponentPortal(tab.tabContentComponent, null, injector);
+            tab.isTabInitialized = true;
+        }
+    };
+    TabView.prototype.tabChange = function (event) {
+        if (event.index !== this.selectedIndex) {
+            var tab = this.openedTabs[this.selectedIndex];
+            if (tab) {
+                tab.tabSelected$.next(false);
+            }
+            tab = this.openedTabs[event.index];
+            if (tab) {
+                tab.tabSelected$.next(true);
+            }
+            this.selectedIndex = event.index;
+        }
+    };
+    /**
+     * Transforms a tab `uniqueId` into it's index.
+     *
+     * Throws an error if no tab with the given `uniqueId` exists.
+     * @param uniqueId - id of the tab that we want to find index for
+     * @returns index of the tab with the given id
+     */
+    TabView.prototype.getTabIndex = function (uniqueId) {
+        var index = this.openedTabs.findIndex(function (tab) { return tab.uniqueId === uniqueId; });
+        if (index === -1) {
+            throw new Error("No tab with ID " + uniqueId + " exists");
+        }
+        return index;
+    };
+    TabView.prototype.checkIndexRange = function (index) {
+        if (index < 0 || index >= this.openedTabs.length) {
+            throw new Error("No tab with index " + index + " exists");
+        }
+    };
+    TabView.DYNAMIC_TAB_VIEW_ID_SEGMENT = 'dynamic';
+    return TabView;
+}());
+export { TabView };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tab-view.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/tabs/classes/tab-view.ts"],"names":[],"mappings":"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","sourcesContent":["import {InjectedTabData, TabContent, TabViewInterface} from '../interfaces';\nimport {OpenedTab} from './opened-tab';\nimport {Injector, StaticProvider} from '@angular/core';\nimport {ComponentPortal} from '@angular/cdk/portal';\nimport {orderBy} from 'natural-orderby';\nimport {NAE_TAB_DATA} from '../tab-data-injection-token/tab-data-injection-token';\nimport {ViewService} from '../../routing/view-service/view.service';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {InjectedTabbedTaskViewData} from '../../view/task-view/models/injected-tabbed-task-view-data';\nimport {TaskSearchCaseQuery, TaskSearchRequestBody} from '../../filter/models/task-search-request-body';\nimport {MatTabChangeEvent} from '@angular/material/tabs';\nimport {IncrementingCounter} from '../../utility/incrementing-counter';\nimport {NAE_VIEW_ID_SEGMENT} from '../../user/models/view-id-injection-tokens';\n\n/**\n * Holds the logic for tab management in {@link AbstractTabViewComponent}.\n * If you want to implement your own TabViewComponent, you might want to extend this class to hold your logic.\n */\nexport class TabView implements TabViewInterface {\n\n    public static readonly DYNAMIC_TAB_VIEW_ID_SEGMENT = 'dynamic';\n\n    /**\n     * Holds the tabs that are opened in the tab view, and allows them to be bound to HTML.\n     */\n    public openedTabs: Array<OpenedTab>;\n    /**\n     * Holds the index of the currently selected tab.\n     *\n     * Selected index initializes to `0`.\n     */\n    public selectedIndex = 0;\n\n    private uniqueIdCounter = new IncrementingCounter();\n    /**\n     * @ignore\n     * Holds a reference to an object that hides some public attributes and methods from tabs.\n     */\n    private tabViewInterface: TabViewInterface = {\n        currentlySelectedTab: () => this.currentlySelectedTab(),\n        openTab: (tabContent: TabContent, autoswitch = false) => this.openTab(tabContent, autoswitch),\n        switchToTabIndex: (index: number) => this.switchToTabIndex(index),\n        switchToTabUniqueId: (uniqueId: string) => this.switchToTabUniqueId(uniqueId),\n        closeTabIndex: (index: number, force = false) => this.closeTabIndex(index, force),\n        closeTabUniqueId: (uniqueId: string, force = false) => this.closeTabUniqueId(uniqueId, force)\n    };\n\n    /**\n     * @param _viewService [ViewService]{@link ViewService} reference\n     * @param _logger [Logger]{@link LoggerService} reference\n     * @param _initialTabs Tabs that should be initially opened in the tab view\n     * @param _parentInjector `Injector` instance of the [TabViewComponent]{@link AbstractTabViewComponent},\n     * to be passed onto each tab, so that the dependency injection tree is not broken\n     */\n    constructor(private _viewService: ViewService,\n                private _logger: LoggerService,\n                private _initialTabs: Array<TabContent>,\n                private _parentInjector: Injector) {\n        this._initialTabs.forEach(tab => {\n            if (tab.order === undefined) {\n                tab.order = 0;\n            }\n            tab.initial = true;\n        });\n\n        // orderBy is a stable sort\n        // Native javascript implementation has undefined stability and it depends on it's implementation (browser)\n        this.openedTabs = orderBy(this._initialTabs, v => v.order, 'asc').map(tabData =>\n            new OpenedTab(tabData, `${this.uniqueIdCounter.next()}`));\n        if (this.openedTabs.length > 0) {\n            this.openedTabs[0].tabSelected$.next(true);\n        }\n    }\n\n    /**\n     * @returns the index of the currently selected tab\n     */\n    public currentlySelectedTab(): number {\n        return this.selectedIndex;\n    }\n\n    /**\n     * Opens a new tab with the provided content.\n     * @param tabContent - content of the new tab\n     * @param autoswitch - whether the newly opened tab should be switched to. Defaults to `false`.\n     * @param openExisting - whether the opened tab already existing should be switched to existing one. Defaults to `true`.\n     * @returns the `tabUniqueId` of the newly opened tab\n     */\n    public openTab(tabContent: TabContent, autoswitch = false, openExisting = true): string {\n        if (tabContent.initial) {\n            this._logger.warn(`'initial' attribute is not meant to be used with new tabs and will be ignored`);\n            delete tabContent.initial;\n        }\n\n        const newTab = new OpenedTab(tabContent, `${this.uniqueIdCounter.next()}`);\n        const indexExisting = this.findIndexExistingTab(newTab);\n        if (indexExisting === -1 || !openExisting) {\n            return this.openNewTab(newTab, autoswitch);\n        } else {\n            this.openedTabs[this.selectedIndex].tabSelected$.next(false);\n            this.selectedIndex = indexExisting;\n            this.openedTabs[this.selectedIndex].tabSelected$.next(true);\n            return this.openedTabs[indexExisting].uniqueId;\n        }\n    }\n\n    protected findIndexExistingTab(newTab: OpenedTab) {\n        if (!this.searchesForOneCaseId(newTab)) {\n            return -1;\n        }\n        return this.openedTabs.findIndex(existingTab =>\n            this.searchesForOneCaseId(existingTab) && this.getSearchedCaseId(existingTab) === this.getSearchedCaseId(newTab));\n    }\n\n    private searchesForOneCaseId(tab: OpenedTab): boolean {\n        return this.hasCaseFilterParamSet(tab)\n            && !Array.isArray(this.getSearchedCase(tab))\n            && !!this.getSearchedCaseId(tab);\n    }\n\n    private getSearchedCaseId(tab: OpenedTab): string {\n        return (this.getSearchedCase(tab) as TaskSearchCaseQuery).id;\n    }\n\n    private getSearchedCase(tab: OpenedTab): TaskSearchCaseQuery | Array<TaskSearchCaseQuery> {\n        return ((tab.injectedObject as InjectedTabbedTaskViewData).baseFilter.getRequestBody() as TaskSearchRequestBody).case;\n    }\n\n    private hasCaseFilterParamSet(tab: OpenedTab): boolean {\n        return this.hasBaseFilter(tab)\n            && !!(((tab.injectedObject as InjectedTabbedTaskViewData).baseFilter.getRequestBody() as TaskSearchRequestBody).case);\n    }\n\n    private hasBaseFilter(tab: OpenedTab): boolean {\n        return this.hasInjectedObject(tab) && !!((tab.injectedObject as InjectedTabbedTaskViewData).baseFilter);\n    }\n\n    private hasInjectedObject(tab: OpenedTab): boolean {\n        return !!tab.injectedObject;\n    }\n\n    /**\n     * Adds a new tab into the correct position based on its `order` property.\n     * @param newTab the tab that should be opened\n     * @param autoswitch whether the new tab should be switched to after it is created\n     * @returns the `uniqueId` of the opened tab\n     */\n    protected openNewTab(newTab: OpenedTab, autoswitch: boolean): string {\n        let index = this.openedTabs.findIndex(existingTab => existingTab.order > newTab.order);\n        if (index === -1) {\n            index = this.openedTabs.length;\n        }\n        this.openedTabs.splice(index, 0, newTab);\n\n        if (autoswitch || this.openedTabs.length === 1) {\n            this.openedTabs[this.selectedIndex].tabSelected$.next(false);\n            this.selectedIndex = index;\n            this.openedTabs[this.selectedIndex].tabSelected$.next(true);\n        }\n        return newTab.uniqueId;\n    }\n\n    /**\n     * Switches to a tab with the given `index`.\n     *\n     * Throws an error if the `index` is invalid.\n     * @param index - index of the tab that should be switched to\n     */\n    public switchToTabIndex(index: number): void {\n        this.checkIndexRange(index);\n        this.openedTabs[this.selectedIndex].tabSelected$.next(false);\n        this.selectedIndex = index;\n        this.openedTabs[this.selectedIndex].tabSelected$.next(true);\n    }\n\n    /**\n     * Switches to a tab with the given `uniqueId`.\n     *\n     * Throws an error if the `uniqueId` is invalid.\n     * @param uniqueId - id of the tab that should be switched to\n     */\n    public switchToTabUniqueId(uniqueId: string): void {\n        this.openedTabs[this.selectedIndex].tabSelected$.next(false);\n        this.selectedIndex = this.getTabIndex(uniqueId);\n        this.openedTabs[this.selectedIndex].tabSelected$.next(true);\n    }\n\n    /**\n     * Closes the tab with the given `index`.\n     *\n     * Throws an error if the `index` is invalid.\n     *\n     * Throws an error if the tab has it's `canBeClosed` property set to `false`.\n     * @param index index of the tab that should be closed\n     * @param force when `true` closes a tab even if it's `cantBeClosed` attribute is set to `true`\n     */\n    public closeTabIndex(index: number, force = false): void {\n        this.closeTab(index, force, `Tab at index ${index} can't be closed`);\n    }\n\n    /**\n     * Closes the tab with the given `uniqueId`. Throws an error if the `uniqueId` is invalid.\n     * Throws an error if the tab has it's `canBeClosed` property set to `false`.\n     * @param uniqueId - id of the tab that should be closed\n     * @param force when `true` closes a tab even if it's `cantBeClosed` attribute is set to `true`\n     */\n    public closeTabUniqueId(uniqueId: string, force = false): void {\n        const index = this.getTabIndex(uniqueId);\n        this.closeTab(index, force, `Tab with ID ${uniqueId} can't be closed`);\n    }\n\n    /**\n     * Closes the tab at the given index.\n     *\n     * If the conditions for closing a tab are not met throws an `Error` with the given message.\n     * @param index index of the tab that should be closed\n     * @param force when `true` closes a tab even if it's `cantBeClosed` attribute is set to `true`\n     * @param error the message that should be displayed if the conditions for closing a tab are not met\n     */\n    protected closeTab(index: number, force: boolean, error: string): void {\n        this.checkIndexRange(index);\n        if (!force && !this.openedTabs[index].canBeClosed) {\n            throw new Error(error);\n        }\n        if (index === this.selectedIndex && this.openedTabs[index].parentUniqueId) {\n            this.switchToTabUniqueId(this.openedTabs[index].parentUniqueId);\n        }\n        if (index === this.selectedIndex && this.selectedIndex + 1 < this.openedTabs.length) {\n            this.openedTabs[index + 1].tabSelected$.next(true);\n        }\n        this.openedTabs[index].tabClosed$.next();\n        const deleted = this.openedTabs.splice(index, 1);\n        deleted[0].destroy();\n        if (index < this.selectedIndex) {\n            this.selectedIndex = this.selectedIndex - 1;\n        }\n    }\n\n    /**\n     * Initializes the tab if it wasn't initialized yet.\n     * Creates a new {@link ComponentPortal} for the tab and provides the data for the tab under the `NAE_TAB_DATA` injection token.\n     * @param index - index of the tab that should be initialized\n     */\n    public initializeTab(index: number): void {\n        this.checkIndexRange(index);\n        const tab = this.openedTabs[index];\n        if (!tab.isTabInitialized) {\n            Object.assign(tab.injectedObject, {\n                tabUniqueId: tab.uniqueId,\n                tabViewRef: this.tabViewInterface,\n                tabSelected$: tab.tabSelected$.asObservable(),\n                tabClosed$: tab.tabClosed$.asObservable(),\n            } as InjectedTabData);\n\n            const providers: Array<StaticProvider> = [\n                {provide: NAE_TAB_DATA, useValue: tab.injectedObject}\n            ];\n            providers.push({provide: NAE_VIEW_ID_SEGMENT, useValue: tab.initial ? tab.uniqueId : TabView.DYNAMIC_TAB_VIEW_ID_SEGMENT});\n\n            const injector = Injector.create({providers, parent: this._parentInjector});\n\n            tab.portal = new ComponentPortal(tab.tabContentComponent, null, injector);\n            tab.isTabInitialized = true;\n        }\n    }\n\n    public tabChange(event: MatTabChangeEvent) {\n        if (event.index !== this.selectedIndex) {\n            let tab = this.openedTabs[this.selectedIndex];\n            if (tab) {\n                tab.tabSelected$.next(false);\n            }\n            tab = this.openedTabs[event.index];\n            if (tab) {\n                tab.tabSelected$.next(true);\n            }\n            this.selectedIndex = event.index;\n        }\n    }\n\n    /**\n     * Transforms a tab `uniqueId` into it's index.\n     *\n     * Throws an error if no tab with the given `uniqueId` exists.\n     * @param uniqueId - id of the tab that we want to find index for\n     * @returns index of the tab with the given id\n     */\n    private getTabIndex(uniqueId: string): number {\n        const index = this.openedTabs.findIndex(tab => tab.uniqueId === uniqueId);\n        if (index === -1) {\n            throw new Error(`No tab with ID ${uniqueId} exists`);\n        }\n        return index;\n    }\n\n    private checkIndexRange(index: number): void {\n        if (index < 0 || index >= this.openedTabs.length) {\n            throw new Error(`No tab with index ${index} exists`);\n        }\n    }\n}\n"]}