@netgrif/components-core 6.0.1

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

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

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

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

package/esm2015/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/esm2015/lib/snack-bar/models/snack-bar-injection-data.js

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

package/esm2015/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/esm2015/lib/snack-bar/services/snack-bar.service.js

@@ -0,0 +1,92 @@
+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";
+export class SnackBarService {
+    constructor(_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;
+        }
+    }
+    openSuccessSnackBar(message, verticalPosition = this._verticalPosition, horizontalPosition = this._horizontalPosition, durationInSeconds = this._defaultTimeout, config) {
+        return this._snackBar.openFromComponent(SuccessSnackBarComponent, Object.assign({
+            data: {
+                message,
+                matIconName: 'done',
+                closable: false
+            },
+            duration: durationInSeconds * 1000,
+            horizontalPosition,
+            verticalPosition
+        }, config));
+    }
+    openErrorSnackBar(message, verticalPosition = this._verticalPosition, horizontalPosition = this._horizontalPosition, 
+    // durationInSeconds = this._defaultTimeout,
+    config) {
+        return this._snackBar.openFromComponent(ErrorSnackBarComponent, Object.assign({
+            data: {
+                message,
+                matIconName: 'error',
+                closable: true
+            },
+            // duration: durationInSeconds * 1000, // Error has to be acknowledged to be closed
+            horizontalPosition,
+            verticalPosition
+        }, config));
+    }
+    openWarningSnackBar(message, verticalPosition = this._verticalPosition, horizontalPosition = this._horizontalPosition, durationInSeconds = this._defaultTimeout, config) {
+        return this._snackBar.openFromComponent(WarningSnackBarComponent, Object.assign({
+            data: {
+                message,
+                matIconName: 'warning',
+                closable: false
+            },
+            duration: durationInSeconds * 1000,
+            horizontalPosition,
+            verticalPosition
+        }, config));
+    }
+    openGenericSnackBar(message, matIconName, verticalPosition = this._verticalPosition, horizontalPosition = this._horizontalPosition, durationInSeconds = this._defaultTimeout, config) {
+        return this._snackBar.openFromComponent(GenericSnackBarComponent, Object.assign({
+            data: {
+                message,
+                matIconName,
+                closable: true
+            },
+            duration: durationInSeconds * 1000,
+            horizontalPosition,
+            verticalPosition
+        }, config));
+    }
+}
+SnackBarService.ctorParameters = () => [
+    { 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 = () => [
+    { 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,] }] }
+];
+//# 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":"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","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/esm2015/lib/snack-bar/snack-bar.module.js

@@ -0,0 +1,33 @@
+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';
+export class SnackBarModule {
+}
+SnackBarModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [
+                    GenericSnackBarComponent,
+                    WarningSnackBarComponent,
+                    ErrorSnackBarComponent,
+                    SuccessSnackBarComponent
+                ],
+                imports: [
+                    CommonModule,
+                    MaterialModule,
+                    FlexLayoutModule,
+                    FlexModule
+                ],
+                entryComponents: [
+                    GenericSnackBarComponent,
+                    WarningSnackBarComponent,
+                    ErrorSnackBarComponent,
+                    SuccessSnackBarComponent
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,48 @@
+import { BehaviorSubject, Subject } from 'rxjs';
+/**
+ * Holds the information of tab opened in a tab view.
+ *
+ * See {@link TabView} for more information.
+ */
+export class OpenedTab {
+    /**
+     * @param tabContent - content of the tab
+     * @param uniqueId - unique identifier for the tab
+     */
+    constructor(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
+     */
+    destroy() {
+        this.tabSelected$.complete();
+        this.tabClosed$.complete();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,262 @@
+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.
+ */
+export class TabView {
+    /**
+     * @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
+     */
+    constructor(_viewService, _logger, _initialTabs, _parentInjector) {
+        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: () => this.currentlySelectedTab(),
+            openTab: (tabContent, autoswitch = false) => this.openTab(tabContent, autoswitch),
+            switchToTabIndex: (index) => this.switchToTabIndex(index),
+            switchToTabUniqueId: (uniqueId) => this.switchToTabUniqueId(uniqueId),
+            closeTabIndex: (index, force = false) => this.closeTabIndex(index, force),
+            closeTabUniqueId: (uniqueId, force = false) => this.closeTabUniqueId(uniqueId, force)
+        };
+        this._initialTabs.forEach(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, v => v.order, 'asc').map(tabData => 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
+     */
+    currentlySelectedTab() {
+        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
+     */
+    openTab(tabContent, autoswitch = false, 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;
+        }
+        const newTab = new OpenedTab(tabContent, `${this.uniqueIdCounter.next()}`);
+        const 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;
+        }
+    }
+    findIndexExistingTab(newTab) {
+        if (!this.searchesForOneCaseId(newTab)) {
+            return -1;
+        }
+        return this.openedTabs.findIndex(existingTab => this.searchesForOneCaseId(existingTab) && this.getSearchedCaseId(existingTab) === this.getSearchedCaseId(newTab));
+    }
+    searchesForOneCaseId(tab) {
+        return this.hasCaseFilterParamSet(tab)
+            && !Array.isArray(this.getSearchedCase(tab))
+            && !!this.getSearchedCaseId(tab);
+    }
+    getSearchedCaseId(tab) {
+        return this.getSearchedCase(tab).id;
+    }
+    getSearchedCase(tab) {
+        return tab.injectedObject.baseFilter.getRequestBody().case;
+    }
+    hasCaseFilterParamSet(tab) {
+        return this.hasBaseFilter(tab)
+            && !!(tab.injectedObject.baseFilter.getRequestBody().case);
+    }
+    hasBaseFilter(tab) {
+        return this.hasInjectedObject(tab) && !!(tab.injectedObject.baseFilter);
+    }
+    hasInjectedObject(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
+     */
+    openNewTab(newTab, autoswitch) {
+        let index = this.openedTabs.findIndex(existingTab => 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
+     */
+    switchToTabIndex(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
+     */
+    switchToTabUniqueId(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`
+     */
+    closeTabIndex(index, 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`
+     */
+    closeTabUniqueId(uniqueId, force = false) {
+        const 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
+     */
+    closeTab(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();
+        const 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
+     */
+    initializeTab(index) {
+        this.checkIndexRange(index);
+        const 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(),
+            });
+            const 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 });
+            const injector = Injector.create({ providers, parent: this._parentInjector });
+            tab.portal = new ComponentPortal(tab.tabContentComponent, null, injector);
+            tab.isTabInitialized = true;
+        }
+    }
+    tabChange(event) {
+        if (event.index !== this.selectedIndex) {
+            let 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
+     */
+    getTabIndex(uniqueId) {
+        const index = this.openedTabs.findIndex(tab => tab.uniqueId === uniqueId);
+        if (index === -1) {
+            throw new Error(`No tab with ID ${uniqueId} exists`);
+        }
+        return index;
+    }
+    checkIndexRange(index) {
+        if (index < 0 || index >= this.openedTabs.length) {
+            throw new Error(`No tab with index ${index} exists`);
+        }
+    }
+}
+TabView.DYNAMIC_TAB_VIEW_ID_SEGMENT = 'dynamic';
+//# 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"]}

package/esm2015/lib/tabs/interfaces.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/tabs/public-api.js

@@ -0,0 +1,6 @@
+export * from './interfaces';
+export * from './tab-data-injection-token/tab-data-injection-token';
+export * from './tab-view/abstract-tab-view.component';
+export * from './tab-creation-detector/abstract-tab-creation-detector.component';
+export * from './classes/tab-view';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi90YWJzL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxxREFBcUQsQ0FBQztBQUNwRSxjQUFjLHdDQUF3QyxDQUFDO0FBQ3ZELGNBQWMsa0VBQWtFLENBQUM7QUFDakYsY0FBYyxvQkFBb0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vaW50ZXJmYWNlcyc7XG5leHBvcnQgKiBmcm9tICcuL3RhYi1kYXRhLWluamVjdGlvbi10b2tlbi90YWItZGF0YS1pbmplY3Rpb24tdG9rZW4nO1xuZXhwb3J0ICogZnJvbSAnLi90YWItdmlldy9hYnN0cmFjdC10YWItdmlldy5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi90YWItY3JlYXRpb24tZGV0ZWN0b3IvYWJzdHJhY3QtdGFiLWNyZWF0aW9uLWRldGVjdG9yLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2NsYXNzZXMvdGFiLXZpZXcnO1xuIl19