@netgrif/components-core 6.0.1

package/esm2015/lib/header/abstract-header.component.js

@@ -0,0 +1,159 @@
+import { Input } from '@angular/core';
+import { CaseHeaderService } from './case-header/case-header.service';
+import { TaskHeaderService } from './task-header/task-header.service';
+import { WorkflowHeaderService } from './workflow-header/workflow-header.service';
+import { HeaderType } from './models/header-type';
+import { HeaderMode } from './models/header-mode';
+import { HeaderSearchService } from '../search/header-search-service/header-search.service';
+import { FormControl, Validators } from '@angular/forms';
+import { stopPropagation } from '../utility/stop-propagation';
+export class AbstractHeaderComponent {
+    constructor(_injector, _translate, _overflowService) {
+        this._injector = _injector;
+        this._translate = _translate;
+        this._overflowService = _overflowService;
+        this.DEFAULT_COLUMN_COUNT = 6;
+        this.DEFAULT_COLUMN_WIDTH = 190;
+        this.type = HeaderType.CASE;
+        this.hideEditMode = false;
+        this.headerModeEnum = HeaderMode;
+        this.headerTypeEnum = HeaderType;
+        this._initHeaderCount = undefined;
+        this._initResponsiveHeaders = undefined;
+        (this._overflowService !== null) ?
+            this.initializeFormControls(true) :
+            this.initializeFormControls(false);
+    }
+    set maxHeaderColumns(count) {
+        if (this.headerService) {
+            this.headerService.headerColumnCount = count;
+        }
+        else {
+            this._initHeaderCount = count;
+        }
+        if (this._overflowService === null || (this._overflowService !== null && !this._overflowService.initializedCount)) {
+            this.columnCountControl.setValue(count);
+        }
+    }
+    set responsiveHeaders(responsive) {
+        if (this.headerService) {
+            this.headerService.responsiveHeaders = responsive;
+        }
+        else {
+            this._initResponsiveHeaders = responsive;
+        }
+    }
+    ngOnInit() {
+        this.resolveHeaderService();
+        this.initializedHeaderSearch();
+        if (this._initHeaderCount !== undefined) {
+            this.headerService.headerColumnCount = this._initHeaderCount;
+        }
+        if (this._initResponsiveHeaders !== undefined) {
+            this.headerService.responsiveHeaders = this._initResponsiveHeaders;
+        }
+        this.headerService.preferenceColumnCount$.subscribe(value => this.columnCountControl.setValue(value));
+    }
+    ngOnDestroy() {
+        if (this.canOverflow) {
+            this.subColumnWidthControl.unsubscribe();
+            this.subColumnCountControl.unsubscribe();
+            this.subOverflowControl.unsubscribe();
+        }
+    }
+    /**
+     * Injects the correct {@link AbstractHeaderService} instance based on this component's type
+     */
+    resolveHeaderService() {
+        switch (this.type) {
+            case HeaderType.CASE:
+                this.headerService = this._injector.get(CaseHeaderService);
+                break;
+            case HeaderType.TASK:
+                this.headerService = this._injector.get(TaskHeaderService);
+                break;
+            case HeaderType.WORKFLOW:
+                this.headerService = this._injector.get(WorkflowHeaderService);
+                break;
+        }
+    }
+    /**
+     * Sets the correct {@link AbstractHeaderService} instance to the {@link HeaderSearchService}
+     */
+    initializedHeaderSearch() {
+        if (this.type === HeaderType.CASE) {
+            this._headerSearch = this._injector.get(HeaderSearchService);
+            this._headerSearch.headerService = this.headerService;
+        }
+    }
+    clickStop($event) {
+        stopPropagation($event);
+    }
+    getMinWidth() {
+        return (this._overflowService && this._overflowService.overflowMode) ? `${this._overflowService.columnWidth}px` : '0';
+    }
+    confirmEditMode() {
+        if (!this.overflowControl.value || (this.overflowControl.value && this.columnWidthControl.valid && this.columnWidthControl.valid)) {
+            this.headerService.confirmEditMode();
+        }
+    }
+    getErrorMessageWidth() {
+        return this.buildErrorMessage(this.columnWidthControl, 180);
+    }
+    getErrorMessageCount() {
+        return this.buildErrorMessage(this.columnCountControl, 1);
+    }
+    buildErrorMessage(formControlRef, minNumber) {
+        if (formControlRef.hasError('required')) {
+            return this._translate.instant('dataField.validations.required');
+        }
+        if (formControlRef.hasError('min')) {
+            return this._translate.instant('dataField.validations.min', { length: minNumber });
+        }
+        return '';
+    }
+    initializeFormControls(exist) {
+        this.canOverflow = exist;
+        this.overflowControl = new FormControl(exist ? this._overflowService.overflowMode : false);
+        this.columnCountControl = new FormControl(exist ? this._overflowService.columnCount : this.DEFAULT_COLUMN_COUNT, [
+            Validators.required,
+            Validators.min(1)
+        ]);
+        this.columnWidthControl = new FormControl(exist ? this._overflowService.columnWidth : this.DEFAULT_COLUMN_WIDTH, [
+            Validators.required,
+            Validators.min(180)
+        ]);
+        if (exist) {
+            this.initializeValueChanges();
+        }
+    }
+    initializeValueChanges() {
+        this.subOverflowControl = this.overflowControl.valueChanges.subscribe(value => {
+            this._overflowService.overflowMode = value;
+        });
+        this.subColumnCountControl = this.columnCountControl.valueChanges.subscribe(value => {
+            if (this.columnCountControl.valid) {
+                this._overflowService.columnCount = value;
+                if (this.headerService && this.type === HeaderType.CASE) {
+                    this.headerService.headerColumnCount = value;
+                    this.headerService.updateColumnCount();
+                }
+            }
+        });
+        this.subColumnWidthControl = this.columnWidthControl.valueChanges.subscribe(value => {
+            if (this.columnWidthControl.valid) {
+                this._overflowService.columnWidth = value;
+                if (this.headerService && this.type === HeaderType.CASE) {
+                    this.headerService.updateColumnCount();
+                }
+            }
+        });
+    }
+}
+AbstractHeaderComponent.propDecorators = {
+    type: [{ type: Input }],
+    hideEditMode: [{ type: Input }],
+    maxHeaderColumns: [{ type: Input }],
+    responsiveHeaders: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-header.component.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/header/abstract-header.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,EAAoB,MAAM,eAAe,CAAC;AAEjE,OAAO,EAAC,iBAAiB,EAAC,MAAM,mCAAmC,CAAC;AACpE,OAAO,EAAC,iBAAiB,EAAC,MAAM,mCAAmC,CAAC;AACpE,OAAO,EAAC,qBAAqB,EAAC,MAAM,2CAA2C,CAAC;AAChF,OAAO,EAAC,UAAU,EAAC,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAC,UAAU,EAAC,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAC,mBAAmB,EAAC,MAAM,uDAAuD,CAAC;AAC1F,OAAO,EAAC,WAAW,EAAE,UAAU,EAAC,MAAM,gBAAgB,CAAC;AAGvD,OAAO,EAAC,eAAe,EAAC,MAAM,6BAA6B,CAAC;AAG5D,MAAM,OAAgB,uBAAuB;IAsBzC,YAAsB,SAAmB,EACnB,UAA4B,EAC5B,gBAAiC;QAFjC,cAAS,GAAT,SAAS,CAAU;QACnB,eAAU,GAAV,UAAU,CAAkB;QAC5B,qBAAgB,GAAhB,gBAAgB,CAAiB;QAtBpC,yBAAoB,GAAG,CAAC,CAAC;QACzB,yBAAoB,GAAG,GAAG,CAAC;QAErC,SAAI,GAAe,UAAU,CAAC,IAAI,CAAC;QACnC,iBAAY,GAAG,KAAK,CAAC;QAGd,mBAAc,GAAG,UAAU,CAAC;QAC5B,mBAAc,GAAG,UAAU,CAAC;QASlC,qBAAgB,GAAW,SAAS,CAAC;QACrC,2BAAsB,GAAY,SAAS,CAAC;QAKlD,CAAC,IAAI,CAAC,gBAAgB,KAAK,IAAI,CAAC,CAAC,CAAC;YAC9B,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,CAAC,CAAC;YACnC,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAAC;IAC3C,CAAC;IAED,IACW,gBAAgB,CAAC,KAAa;QACrC,IAAI,IAAI,CAAC,aAAa,EAAE;YACpB,IAAI,CAAC,aAAa,CAAC,iBAAiB,GAAG,KAAK,CAAC;SAChD;aAAM;YACH,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;SACjC;QACD,IAAI,IAAI,CAAC,gBAAgB,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC,gBAAgB,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,gBAAgB,CAAC,EAAE;YAC/G,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;SAC3C;IACL,CAAC;IAED,IACW,iBAAiB,CAAC,UAAmB;QAC5C,IAAI,IAAI,CAAC,aAAa,EAAE;YACpB,IAAI,CAAC,aAAa,CAAC,iBAAiB,GAAG,UAAU,CAAC;SACrD;aAAM;YACH,IAAI,CAAC,sBAAsB,GAAG,UAAU,CAAC;SAC5C;IACL,CAAC;IAED,QAAQ;QACJ,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAC5B,IAAI,CAAC,uBAAuB,EAAE,CAAC;QAC/B,IAAI,IAAI,CAAC,gBAAgB,KAAK,SAAS,EAAE;YACrC,IAAI,CAAC,aAAa,CAAC,iBAAiB,GAAG,IAAI,CAAC,gBAAgB,CAAC;SAChE;QACD,IAAI,IAAI,CAAC,sBAAsB,KAAK,SAAS,EAAE;YAC3C,IAAI,CAAC,aAAa,CAAC,iBAAiB,GAAG,IAAI,CAAC,sBAAsB,CAAC;SACtE;QACD,IAAI,CAAC,aAAa,CAAC,sBAAsB,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;IAC1G,CAAC;IAED,WAAW;QACP,IAAI,IAAI,CAAC,WAAW,EAAE;YAClB,IAAI,CAAC,qBAAqB,CAAC,WAAW,EAAE,CAAC;YACzC,IAAI,CAAC,qBAAqB,CAAC,WAAW,EAAE,CAAC;YACzC,IAAI,CAAC,kBAAkB,CAAC,WAAW,EAAE,CAAC;SACzC;IACL,CAAC;IAED;;OAEG;IACO,oBAAoB;QAC1B,QAAQ,IAAI,CAAC,IAAI,EAAE;YACf,KAAK,UAAU,CAAC,IAAI;gBAChB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;gBAC3D,MAAM;YACV,KAAK,UAAU,CAAC,IAAI;gBAChB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;gBAC3D,MAAM;YACV,KAAK,UAAU,CAAC,QAAQ;gBACpB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC;gBAC/D,MAAM;SACb;IACL,CAAC;IAED;;OAEG;IACO,uBAAuB;QAC7B,IAAI,IAAI,CAAC,IAAI,KAAK,UAAU,CAAC,IAAI,EAAE;YAC/B,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAAC;YAC7D,IAAI,CAAC,aAAa,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC;SACzD;IACL,CAAC;IAED,SAAS,CAAC,MAAM;QACZ,eAAe,CAAC,MAAM,CAAC,CAAC;IAC5B,CAAC;IAED,WAAW;QACP,OAAO,CAAC,IAAI,CAAC,gBAAgB,IAAI,IAAI,CAAC,gBAAgB,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC,WAAW,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC;IAC1H,CAAC;IAED,eAAe;QACX,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,KAAK,IAAI,IAAI,CAAC,kBAAkB,CAAC,KAAK,IAAI,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,EAAE;YAC/H,IAAI,CAAC,aAAa,CAAC,eAAe,EAAE,CAAC;SACxC;IACL,CAAC;IAED,oBAAoB;QAChB,OAAO,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,kBAAkB,EAAE,GAAG,CAAC,CAAC;IAChE,CAAC;IAED,oBAAoB;QAChB,OAAO,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,kBAAkB,EAAE,CAAC,CAAC,CAAC;IAC9D,CAAC;IAED,iBAAiB,CAAC,cAA2B,EAAE,SAAS;QACpD,IAAI,cAAc,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE;YACrC,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,gCAAgC,CAAC,CAAC;SACpE;QACD,IAAI,cAAc,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE;YAChC,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,2BAA2B,EAAE,EAAC,MAAM,EAAE,SAAS,EAAC,CAAC,CAAC;SACpF;QACD,OAAO,EAAE,CAAC;IACd,CAAC;IAES,sBAAsB,CAAC,KAAc;QAC3C,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;QACzB,IAAI,CAAC,eAAe,GAAG,IAAI,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QAC3F,IAAI,CAAC,kBAAkB,GAAG,IAAI,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,oBAAoB,EAAE;YAC7G,UAAU,CAAC,QAAQ;YACnB,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC;SAAC,CAAC,CAAC;QACxB,IAAI,CAAC,kBAAkB,GAAG,IAAI,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,oBAAoB,EAAE;YAC7G,UAAU,CAAC,QAAQ;YACnB,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC;SAAC,CAAC,CAAC;QAE1B,IAAI,KAAK,EAAE;YACP,IAAI,CAAC,sBAAsB,EAAE,CAAC;SACjC;IACL,CAAC;IAES,sBAAsB;QAC5B,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,eAAe,CAAC,YAAY,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE;YAC1E,IAAI,CAAC,gBAAgB,CAAC,YAAY,GAAG,KAAK,CAAC;QAC/C,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE;YAChF,IAAI,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE;gBAC/B,IAAI,CAAC,gBAAgB,CAAC,WAAW,GAAG,KAAK,CAAC;gBAC1C,IAAI,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,IAAI,KAAK,UAAU,CAAC,IAAI,EAAE;oBACrD,IAAI,CAAC,aAAa,CAAC,iBAAiB,GAAG,KAAK,CAAC;oBAC5C,IAAI,CAAC,aAAmC,CAAC,iBAAiB,EAAE,CAAC;iBACjE;aACJ;QACL,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE;YAChF,IAAI,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE;gBAC/B,IAAI,CAAC,gBAAgB,CAAC,WAAW,GAAG,KAAK,CAAC;gBAC1C,IAAI,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,IAAI,KAAK,UAAU,CAAC,IAAI,EAAE;oBACpD,IAAI,CAAC,aAAmC,CAAC,iBAAiB,EAAE,CAAC;iBACjE;aACJ;QACL,CAAC,CAAC,CAAC;IACP,CAAC;;;mBAjKA,KAAK;2BACL,KAAK;+BAwBL,KAAK;gCAYL,KAAK","sourcesContent":["import {Injector, Input, OnDestroy, OnInit} from '@angular/core';\nimport {AbstractHeaderService} from './abstract-header-service';\nimport {CaseHeaderService} from './case-header/case-header.service';\nimport {TaskHeaderService} from './task-header/task-header.service';\nimport {WorkflowHeaderService} from './workflow-header/workflow-header.service';\nimport {HeaderType} from './models/header-type';\nimport {HeaderMode} from './models/header-mode';\nimport {HeaderSearchService} from '../search/header-search-service/header-search.service';\nimport {FormControl, Validators} from '@angular/forms';\nimport {TranslateService} from '@ngx-translate/core';\nimport {OverflowService} from './services/overflow.service';\nimport {stopPropagation} from '../utility/stop-propagation';\nimport {Subscription} from 'rxjs';\n\nexport abstract class AbstractHeaderComponent implements OnInit, OnDestroy {\n\n    protected readonly DEFAULT_COLUMN_COUNT = 6;\n    protected readonly DEFAULT_COLUMN_WIDTH = 190;\n\n    @Input() type: HeaderType = HeaderType.CASE;\n    @Input() hideEditMode = false;\n    public headerService: AbstractHeaderService;\n    protected _headerSearch: HeaderSearchService;\n    public readonly headerModeEnum = HeaderMode;\n    public readonly headerTypeEnum = HeaderType;\n    public overflowControl: FormControl;\n    public columnCountControl: FormControl;\n    public columnWidthControl: FormControl;\n    public canOverflow: boolean;\n    public subOverflowControl: Subscription;\n    public subColumnCountControl: Subscription;\n    public subColumnWidthControl: Subscription;\n\n    protected _initHeaderCount: number = undefined;\n    protected _initResponsiveHeaders: boolean = undefined;\n\n    constructor(protected _injector: Injector,\n                protected _translate: TranslateService,\n                protected _overflowService: OverflowService) {\n        (this._overflowService !== null) ?\n            this.initializeFormControls(true) :\n            this.initializeFormControls(false);\n    }\n\n    @Input()\n    public set maxHeaderColumns(count: number) {\n        if (this.headerService) {\n            this.headerService.headerColumnCount = count;\n        } else {\n            this._initHeaderCount = count;\n        }\n        if (this._overflowService === null || (this._overflowService !== null && !this._overflowService.initializedCount)) {\n            this.columnCountControl.setValue(count);\n        }\n    }\n\n    @Input()\n    public set responsiveHeaders(responsive: boolean) {\n        if (this.headerService) {\n            this.headerService.responsiveHeaders = responsive;\n        } else {\n            this._initResponsiveHeaders = responsive;\n        }\n    }\n\n    ngOnInit(): void {\n        this.resolveHeaderService();\n        this.initializedHeaderSearch();\n        if (this._initHeaderCount !== undefined) {\n            this.headerService.headerColumnCount = this._initHeaderCount;\n        }\n        if (this._initResponsiveHeaders !== undefined) {\n            this.headerService.responsiveHeaders = this._initResponsiveHeaders;\n        }\n        this.headerService.preferenceColumnCount$.subscribe(value => this.columnCountControl.setValue(value));\n    }\n\n    ngOnDestroy(): void {\n        if (this.canOverflow) {\n            this.subColumnWidthControl.unsubscribe();\n            this.subColumnCountControl.unsubscribe();\n            this.subOverflowControl.unsubscribe();\n        }\n    }\n\n    /**\n     * Injects the correct {@link AbstractHeaderService} instance based on this component's type\n     */\n    protected resolveHeaderService() {\n        switch (this.type) {\n            case HeaderType.CASE:\n                this.headerService = this._injector.get(CaseHeaderService);\n                break;\n            case HeaderType.TASK:\n                this.headerService = this._injector.get(TaskHeaderService);\n                break;\n            case HeaderType.WORKFLOW:\n                this.headerService = this._injector.get(WorkflowHeaderService);\n                break;\n        }\n    }\n\n    /**\n     * Sets the correct {@link AbstractHeaderService} instance to the {@link HeaderSearchService}\n     */\n    protected initializedHeaderSearch() {\n        if (this.type === HeaderType.CASE) {\n            this._headerSearch = this._injector.get(HeaderSearchService);\n            this._headerSearch.headerService = this.headerService;\n        }\n    }\n\n    clickStop($event) {\n        stopPropagation($event);\n    }\n\n    getMinWidth() {\n        return (this._overflowService && this._overflowService.overflowMode) ? `${this._overflowService.columnWidth}px` : '0';\n    }\n\n    confirmEditMode() {\n        if (!this.overflowControl.value || (this.overflowControl.value && this.columnWidthControl.valid && this.columnWidthControl.valid)) {\n            this.headerService.confirmEditMode();\n        }\n    }\n\n    getErrorMessageWidth() {\n        return this.buildErrorMessage(this.columnWidthControl, 180);\n    }\n\n    getErrorMessageCount() {\n        return this.buildErrorMessage(this.columnCountControl, 1);\n    }\n\n    buildErrorMessage(formControlRef: FormControl, minNumber) {\n        if (formControlRef.hasError('required')) {\n            return this._translate.instant('dataField.validations.required');\n        }\n        if (formControlRef.hasError('min')) {\n            return this._translate.instant('dataField.validations.min', {length: minNumber});\n        }\n        return '';\n    }\n\n    protected initializeFormControls(exist: boolean) {\n        this.canOverflow = exist;\n        this.overflowControl = new FormControl(exist ? this._overflowService.overflowMode : false);\n        this.columnCountControl = new FormControl(exist ? this._overflowService.columnCount : this.DEFAULT_COLUMN_COUNT, [\n            Validators.required,\n            Validators.min(1)]);\n        this.columnWidthControl = new FormControl(exist ? this._overflowService.columnWidth : this.DEFAULT_COLUMN_WIDTH, [\n            Validators.required,\n            Validators.min(180)]);\n\n        if (exist) {\n            this.initializeValueChanges();\n        }\n    }\n\n    protected initializeValueChanges() {\n        this.subOverflowControl = this.overflowControl.valueChanges.subscribe(value => {\n            this._overflowService.overflowMode = value;\n        });\n        this.subColumnCountControl = this.columnCountControl.valueChanges.subscribe(value => {\n            if (this.columnCountControl.valid) {\n                this._overflowService.columnCount = value;\n                if (this.headerService && this.type === HeaderType.CASE) {\n                    this.headerService.headerColumnCount = value;\n                    (this.headerService as CaseHeaderService).updateColumnCount();\n                }\n            }\n        });\n        this.subColumnWidthControl = this.columnWidthControl.valueChanges.subscribe(value => {\n            if (this.columnWidthControl.valid) {\n                this._overflowService.columnWidth = value;\n                if (this.headerService && this.type === HeaderType.CASE) {\n                    (this.headerService as CaseHeaderService).updateColumnCount();\n                }\n            }\n        });\n    }\n}\n"]}

package/esm2015/lib/header/case-header/case-header.service.js

@@ -0,0 +1,81 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { AbstractHeaderService } from '../abstract-header-service';
+import { HeaderType } from '../models/header-type';
+import { HeaderColumn, HeaderColumnType } from '../models/header-column';
+import { CaseMetaField } from './case-menta-enum';
+import { UserPreferenceService } from '../../user/services/user-preference.service';
+import { LoggerService } from '../../logger/services/logger.service';
+import { NAE_DEFAULT_HEADERS } from '../models/default-headers-token';
+import { OverflowService } from '../services/overflow.service';
+import { ViewIdService } from '../../user/services/view-id.service';
+import { AllowedNetsService } from '../../allowed-nets/services/allowed-nets.service';
+export class CaseHeaderService extends AbstractHeaderService {
+    constructor(_allowedNetsService, preferences, logger, viewIdService, overflowService, naeDefaultHeaders) {
+        super(HeaderType.CASE, preferences, viewIdService, logger);
+        this._allowedNetsService = _allowedNetsService;
+        this.overflowService = overflowService;
+        this.subAllowedNets = _allowedNetsService.allowedNets$.subscribe(allowedNets => {
+            this.setAllowedNets(allowedNets);
+            if (naeDefaultHeaders && Array.isArray(naeDefaultHeaders) && naeDefaultHeaders.length > 0) {
+                this.initDefaultHeaders = naeDefaultHeaders;
+                this.initializeDefaultHeaderState();
+            }
+            else {
+                this.loadHeadersFromPreferences();
+            }
+            this.loading.off();
+        });
+    }
+    createMetaHeaders() {
+        return [
+            new HeaderColumn(HeaderColumnType.META, CaseMetaField.VISUAL_ID, 'headers.caseMeta.visualID', 'text'),
+            new HeaderColumn(HeaderColumnType.META, CaseMetaField.MONGO_ID, 'headers.caseMeta.mongoID', 'text', false),
+            new HeaderColumn(HeaderColumnType.META, CaseMetaField.TITLE, 'headers.caseMeta.title', 'text'),
+            new HeaderColumn(HeaderColumnType.META, CaseMetaField.AUTHOR, 'headers.caseMeta.author', 'text'),
+            new HeaderColumn(HeaderColumnType.META, CaseMetaField.CREATION_DATE, 'headers.caseMeta.creationDate', 'date'),
+        ];
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this.subAllowedNets.unsubscribe();
+    }
+    updateColumnCount() {
+        this.updateHeaderColumnCount();
+    }
+    saveState() {
+        if (this.overflowService) {
+            this.overflowService.saveState();
+        }
+    }
+    saveNewState() {
+        if (this.overflowService) {
+            this.overflowService.saveNewState();
+        }
+        this.updateHeaderColumnCount();
+    }
+    restoreLastState() {
+        if (this.overflowService) {
+            this.overflowService.restoreLastState();
+        }
+    }
+}
+CaseHeaderService.ctorParameters = () => [
+    { type: AllowedNetsService },
+    { type: UserPreferenceService },
+    { type: LoggerService },
+    { type: ViewIdService, decorators: [{ type: Optional }] },
+    { type: OverflowService, decorators: [{ type: Optional }] },
+    { type: Array, decorators: [{ type: Optional }, { type: Inject, args: [NAE_DEFAULT_HEADERS,] }] }
+];
+CaseHeaderService.decorators = [
+    { type: Injectable }
+];
+CaseHeaderService.ctorParameters = () => [
+    { type: AllowedNetsService },
+    { type: UserPreferenceService },
+    { type: LoggerService },
+    { type: ViewIdService, decorators: [{ type: Optional }] },
+    { type: OverflowService, decorators: [{ type: Optional }] },
+    { type: Array, decorators: [{ type: Optional }, { type: Inject, args: [NAE_DEFAULT_HEADERS,] }] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/header/case-header/case-menta-enum.js

@@ -0,0 +1,9 @@
+export var CaseMetaField;
+(function (CaseMetaField) {
+    CaseMetaField["MONGO_ID"] = "mongoId";
+    CaseMetaField["VISUAL_ID"] = "visualId";
+    CaseMetaField["TITLE"] = "title";
+    CaseMetaField["AUTHOR"] = "author";
+    CaseMetaField["CREATION_DATE"] = "creationDate";
+})(CaseMetaField || (CaseMetaField = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FzZS1tZW50YS1lbnVtLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL2hlYWRlci9jYXNlLWhlYWRlci9jYXNlLW1lbnRhLWVudW0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksYUFNWDtBQU5ELFdBQVksYUFBYTtJQUNyQixxQ0FBb0IsQ0FBQTtJQUNwQix1Q0FBc0IsQ0FBQTtJQUN0QixnQ0FBZSxDQUFBO0lBQ2Ysa0NBQWlCLENBQUE7SUFDakIsK0NBQThCLENBQUE7QUFDbEMsQ0FBQyxFQU5XLGFBQWEsS0FBYixhQUFhLFFBTXhCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gQ2FzZU1ldGFGaWVsZCB7XG4gICAgTU9OR09fSUQgPSAnbW9uZ29JZCcsXG4gICAgVklTVUFMX0lEID0gJ3Zpc3VhbElkJyxcbiAgICBUSVRMRSA9ICd0aXRsZScsXG4gICAgQVVUSE9SID0gJ2F1dGhvcicsXG4gICAgQ1JFQVRJT05fREFURSA9ICdjcmVhdGlvbkRhdGUnLFxufVxuIl19

package/esm2015/lib/header/header-modes/abstract-header-mode.component.js

@@ -0,0 +1,12 @@
+import { Input } from '@angular/core';
+export class AbstractHeaderModeComponent {
+    constructor() {
+    }
+    getMinWidth() {
+        return this.overflowWidth;
+    }
+}
+AbstractHeaderModeComponent.propDecorators = {
+    overflowWidth: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3QtaGVhZGVyLW1vZGUuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL2hlYWRlci9oZWFkZXItbW9kZXMvYWJzdHJhY3QtaGVhZGVyLW1vZGUuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxLQUFLLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFFcEMsTUFBTSxPQUFnQiwyQkFBMkI7SUFLN0M7SUFDQSxDQUFDO0lBRUQsV0FBVztRQUNQLE9BQU8sSUFBSSxDQUFDLGFBQWEsQ0FBQztJQUM5QixDQUFDOzs7NEJBUkEsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7SW5wdXR9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgQWJzdHJhY3RIZWFkZXJNb2RlQ29tcG9uZW50IHtcblxuICAgIEBJbnB1dCgpXG4gICAgcHVibGljIG92ZXJmbG93V2lkdGg6IHN0cmluZztcblxuICAgIGNvbnN0cnVjdG9yKCkge1xuICAgIH1cblxuICAgIGdldE1pbldpZHRoKCkge1xuICAgICAgICByZXR1cm4gdGhpcy5vdmVyZmxvd1dpZHRoO1xuICAgIH1cbn1cbiJdfQ==

package/esm2015/lib/header/header-modes/edit-mode/abstract-edit-mode.component.js

@@ -0,0 +1,73 @@
+import { Input } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { map, startWith } from 'rxjs/operators';
+import { orderBy } from 'natural-orderby';
+import { AbstractHeaderModeComponent } from '../abstract-header-mode.component';
+export class AbstractEditModeComponent extends AbstractHeaderModeComponent {
+    constructor(_translate, _log) {
+        super();
+        this._translate = _translate;
+        this._log = _log;
+        this.formControls = [];
+        this.filterOptions = [];
+        this.renderSelection = (header) => {
+            return header ? this._translate.instant(header.title) : '';
+        };
+    }
+    ngOnInit() {
+        this.subHeader = this.headerService.headerColumnCount$.subscribe(newCount => this.updateHeaderCount(newCount));
+    }
+    ngOnDestroy() {
+        this.subHeader.unsubscribe();
+    }
+    updateHeaderCount(newCount) {
+        if (this.formControls.length > newCount) {
+            this.formControls = this.formControls.slice(0, newCount);
+            this.filterOptions = this.filterOptions.slice(0, newCount);
+            return;
+        }
+        while (this.formControls.length < newCount) {
+            const i = this.formControls.length;
+            const formControl = new FormControl();
+            formControl.setValue(this.headerService.headerState.selectedHeaders[i]);
+            this.formControls.push(formControl);
+            this.filterOptions.push(formControl.valueChanges.pipe(startWith(''), map(inputText => this._filter(inputText))));
+        }
+    }
+    _filter(value) {
+        let filterValue;
+        if (typeof value === 'string') {
+            filterValue = value.toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+        }
+        else {
+            filterValue = '';
+        }
+        const arrayGroup = [];
+        arrayGroup.push(...this.headerService.fieldsGroup);
+        const meta = arrayGroup.splice(0, 1);
+        // TODO IMPROVEMENT 17.7.2020 - don't sort the fieldsGroup array here, but sort it once in the headerService and maintain
+        //  the sorted order there
+        meta.push(...orderBy(arrayGroup, v => v.groupTitle, 'asc'));
+        meta.forEach(group => group.fields = orderBy(group.fields, v => v.title, 'asc'));
+        return meta.map(group => ({
+            groupTitle: group.groupTitle,
+            fields: group.fields.filter(option => this.checkImmediateTitle(option) &&
+                this._translate.instant(option.title).toLowerCase().normalize('NFD')
+                    .replace(/[\u0300-\u036f]/g, '').indexOf(filterValue) === 0)
+        })).filter(group => group.fields.length > 0);
+    }
+    headerColumnSelected(columnIndex, newHeaderColumn) {
+        this.headerService.headerColumnSelected(columnIndex, newHeaderColumn);
+    }
+    checkImmediateTitle(option) {
+        if (option.title === undefined || option.title === '') {
+            this._log.warn('Immediate field in column [' + option.uniqueId + '] does not have a title');
+            return false;
+        }
+        return true;
+    }
+}
+AbstractEditModeComponent.propDecorators = {
+    headerService: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-edit-mode.component.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/header/header-modes/edit-mode/abstract-edit-mode.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Input, OnDestroy, OnInit} from '@angular/core';\nimport {AbstractHeaderService} from '../../abstract-header-service';\nimport {HeaderColumn} from '../../models/header-column';\nimport {FormControl} from '@angular/forms';\nimport {map, startWith} from 'rxjs/operators';\nimport {TranslateService} from '@ngx-translate/core';\nimport {FieldsGroup} from '../../models/fields-group';\nimport {orderBy} from 'natural-orderby';\nimport {Observable, Subscription} from 'rxjs';\nimport {LoggerService} from '../../../logger/services/logger.service';\nimport {AbstractHeaderModeComponent} from '../abstract-header-mode.component';\n\nexport interface HeaderOption {\n    groupTitle: string;\n    fields: Array<HeaderColumn>;\n}\n\nexport abstract class AbstractEditModeComponent extends AbstractHeaderModeComponent implements OnInit, OnDestroy {\n    public formControls: Array<FormControl> = [];\n    public filterOptions: Array<Observable<Array<HeaderOption>>> = [];\n    protected subHeader: Subscription;\n\n    @Input() public headerService: AbstractHeaderService;\n\n    protected constructor(protected _translate: TranslateService,\n                          protected _log: LoggerService) {\n        super();\n    }\n\n    ngOnInit(): void {\n        this.subHeader = this.headerService.headerColumnCount$.subscribe(newCount => this.updateHeaderCount(newCount));\n    }\n\n    ngOnDestroy(): void {\n        this.subHeader.unsubscribe();\n    }\n\n    protected updateHeaderCount(newCount: number): void {\n        if (this.formControls.length > newCount) {\n            this.formControls = this.formControls.slice(0, newCount);\n            this.filterOptions = this.filterOptions.slice(0, newCount);\n            return;\n        }\n\n        while (this.formControls.length < newCount) {\n            const i = this.formControls.length;\n            const formControl = new FormControl();\n            formControl.setValue(this.headerService.headerState.selectedHeaders[i]);\n            this.formControls.push(formControl);\n            this.filterOptions.push(formControl.valueChanges.pipe(\n                startWith(''),\n                map(inputText => this._filter(inputText)))\n            );\n        }\n    }\n\n    protected _filter(value): Array<HeaderOption> {\n        let filterValue;\n        if (typeof value === 'string') {\n            filterValue = (value as string).toLowerCase().normalize('NFD').replace(/[\\u0300-\\u036f]/g, '');\n        } else {\n            filterValue = '';\n        }\n\n        const arrayGroup: Array<FieldsGroup> = [];\n        arrayGroup.push(...this.headerService.fieldsGroup);\n        const meta = arrayGroup.splice(0, 1);\n        // TODO IMPROVEMENT 17.7.2020 - don't sort the fieldsGroup array here, but sort it once in the headerService and maintain\n        //  the sorted order there\n        meta.push(...orderBy(arrayGroup, v => v.groupTitle, 'asc'));\n        meta.forEach(group => group.fields = orderBy(group.fields, v => v.title, 'asc'));\n\n        return meta.map(group => ({\n            groupTitle: group.groupTitle,\n            fields: group.fields.filter(option => this.checkImmediateTitle(option) &&\n                this._translate.instant(option.title).toLowerCase().normalize('NFD')\n                .replace(/[\\u0300-\\u036f]/g, '').indexOf(filterValue) === 0)\n        })).filter(group => group.fields.length > 0);\n    }\n\n    public headerColumnSelected(columnIndex: number, newHeaderColumn: HeaderColumn) {\n        this.headerService.headerColumnSelected(columnIndex, newHeaderColumn);\n    }\n\n    public renderSelection = (header) => {\n        return header ? this._translate.instant(header.title) : '';\n    }\n\n    private checkImmediateTitle(option: HeaderColumn): boolean {\n        if (option.title === undefined || option.title === '') {\n            this._log.warn('Immediate field in column [' + option.uniqueId + '] does not have a title');\n            return false;\n        }\n        return true;\n    }\n}\n"]}

package/esm2015/lib/header/header-modes/loading-mode/abstract-loading-mode.component.js

@@ -0,0 +1,13 @@
+import { Input } from '@angular/core';
+import { AbstractHeaderModeComponent } from '../abstract-header-mode.component';
+export class AbstractLoadingModeComponent extends AbstractHeaderModeComponent {
+    constructor() {
+        super();
+    }
+    ngOnInit() {
+    }
+}
+AbstractLoadingModeComponent.propDecorators = {
+    headerService: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3QtbG9hZGluZy1tb2RlLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9oZWFkZXIvaGVhZGVyLW1vZGVzL2xvYWRpbmctbW9kZS9hYnN0cmFjdC1sb2FkaW5nLW1vZGUuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxLQUFLLEVBQVMsTUFBTSxlQUFlLENBQUM7QUFFNUMsT0FBTyxFQUFDLDJCQUEyQixFQUFDLE1BQU0sbUNBQW1DLENBQUM7QUFFOUUsTUFBTSxPQUFnQiw0QkFBNkIsU0FBUSwyQkFBMkI7SUFLbEY7UUFDSSxLQUFLLEVBQUUsQ0FBQztJQUNaLENBQUM7SUFFRCxRQUFRO0lBQ1IsQ0FBQzs7OzRCQVJBLEtBQUsiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0lucHV0LCBPbkluaXR9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHtBYnN0cmFjdEhlYWRlclNlcnZpY2V9IGZyb20gJy4uLy4uL2Fic3RyYWN0LWhlYWRlci1zZXJ2aWNlJztcbmltcG9ydCB7QWJzdHJhY3RIZWFkZXJNb2RlQ29tcG9uZW50fSBmcm9tICcuLi9hYnN0cmFjdC1oZWFkZXItbW9kZS5jb21wb25lbnQnO1xuXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgQWJzdHJhY3RMb2FkaW5nTW9kZUNvbXBvbmVudCBleHRlbmRzIEFic3RyYWN0SGVhZGVyTW9kZUNvbXBvbmVudCBpbXBsZW1lbnRzIE9uSW5pdCB7XG5cbiAgICBASW5wdXQoKVxuICAgIHB1YmxpYyBoZWFkZXJTZXJ2aWNlOiBBYnN0cmFjdEhlYWRlclNlcnZpY2U7XG5cbiAgICBjb25zdHJ1Y3RvcigpIHtcbiAgICAgICAgc3VwZXIoKTtcbiAgICB9XG5cbiAgICBuZ09uSW5pdCgpOiB2b2lkIHtcbiAgICB9XG5cbn1cbiJdfQ==

package/esm2015/lib/header/header-modes/search-mode/abstract-search-mode.component.js

@@ -0,0 +1,86 @@
+import { Input } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { debounceTime, map } from 'rxjs/operators';
+import { UserValue } from '../../../data-fields/user-field/models/user-value';
+import { AbstractHeaderModeComponent } from '../abstract-header-mode.component';
+export class AbstractSearchModeComponent extends AbstractHeaderModeComponent {
+    constructor(_sideMenuService) {
+        super();
+        this._sideMenuService = _sideMenuService;
+        /**
+         * The time that must elapse since last keypress in search input before a search request is sent
+         */
+        this.SEARCH_DEBOUNCE_TIME = 600;
+        this.formControls = [];
+    }
+    ngOnInit() {
+        this.subHeaderColumn = this.headerService.headerColumnCount$.subscribe(newCount => this.updateHeaderCount(newCount));
+        this.subClearHeader = this.headerService.clearHeaderSearch$.subscribe(columnNumber => this.clearInput(columnNumber));
+    }
+    ngOnDestroy() {
+        this.subClearHeader.unsubscribe();
+        this.subHeaderColumn.unsubscribe();
+    }
+    /**
+     * Updates the underlying objects to match the new desired number of columns.
+     *
+     * If the new number of columns is greater than the current one, the columns will be filled with default/blank values.
+     *
+     * If the new number of columns is smaller than the current one, the superfluous columns will be removed.
+     *
+     * @param newCount the new number of columns
+     */
+    updateHeaderCount(newCount) {
+        if (newCount < this.formControls.length) {
+            this.formControls = this.formControls.slice(0, newCount);
+            return;
+        }
+        while (this.formControls.length < newCount) {
+            this.addNewColumn();
+        }
+    }
+    /**
+     * Adds a new column to the headers search and binds it's FormControl to the service
+     */
+    addNewColumn() {
+        const formControl = new FormControl();
+        const i = this.formControls.length;
+        formControl.valueChanges.pipe(debounceTime(this.SEARCH_DEBOUNCE_TIME), map(value => value instanceof UserValue ? value.id : value)).subscribe(value => {
+            this.headerService.headerSearchInputChanged(i, value);
+        });
+        this.formControls.push(formControl);
+    }
+    /**
+     * Opens a user assign side menu component and sets the selected user as value of the form control object
+     * that corresponds to the given column.
+     *
+     * If no user is selected the value of the corresponding form control si cleared.
+     * @param column the index of the columns that should have it's form control value set to the selected user
+     * @param component is the component that we want to open
+     */
+    selectAbstractUser(column, component) {
+        let valueReturned = false;
+        this._sideMenuService.open(component).onClose.subscribe($event => {
+            if ($event.data) {
+                this.formControls[column].setValue($event.data);
+                valueReturned = true;
+            }
+            else if (!valueReturned) {
+                this.formControls[column].setValue(undefined);
+            }
+        });
+    }
+    /**
+     * Clears the value of the form control object in the given column
+     * @param column the index of the column that should have it's value cleared
+     */
+    clearInput(column) {
+        if (column >= 0 && column < this.formControls.length) {
+            this.formControls[column].setValue(undefined);
+        }
+    }
+}
+AbstractSearchModeComponent.propDecorators = {
+    headerService: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-search-mode.component.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/header/header-modes/search-mode/abstract-search-mode.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Input, OnDestroy, OnInit, Type} from '@angular/core';\nimport {AbstractHeaderService} from '../../abstract-header-service';\nimport {FormControl} from '@angular/forms';\nimport {debounceTime, map} from 'rxjs/operators';\nimport {UserValue} from '../../../data-fields/user-field/models/user-value';\nimport {SideMenuService} from '../../../side-menu/services/side-menu.service';\nimport {Subscription} from 'rxjs';\nimport {AbstractHeaderModeComponent} from '../abstract-header-mode.component';\n\nexport abstract class AbstractSearchModeComponent extends AbstractHeaderModeComponent implements OnInit, OnDestroy {\n\n    /**\n     * The time that must elapse since last keypress in search input before a search request is sent\n     */\n    protected SEARCH_DEBOUNCE_TIME = 600;\n    protected subHeaderColumn: Subscription;\n    protected subClearHeader: Subscription;\n\n    public formControls: Array<FormControl> = [];\n\n    @Input()\n    public headerService: AbstractHeaderService;\n\n    constructor(protected _sideMenuService: SideMenuService) {\n        super();\n    }\n\n    ngOnInit() {\n        this.subHeaderColumn = this.headerService.headerColumnCount$.subscribe(newCount => this.updateHeaderCount(newCount));\n        this.subClearHeader = this.headerService.clearHeaderSearch$.subscribe(columnNumber => this.clearInput(columnNumber));\n    }\n\n    ngOnDestroy(): void {\n        this.subClearHeader.unsubscribe();\n        this.subHeaderColumn.unsubscribe();\n    }\n\n    /**\n     * Updates the underlying objects to match the new desired number of columns.\n     *\n     * If the new number of columns is greater than the current one, the columns will be filled with default/blank values.\n     *\n     * If the new number of columns is smaller than the current one, the superfluous columns will be removed.\n     *\n     * @param newCount the new number of columns\n     */\n    protected updateHeaderCount(newCount: number): void {\n        if (newCount < this.formControls.length) {\n            this.formControls = this.formControls.slice(0, newCount);\n            return;\n        }\n\n        while (this.formControls.length < newCount) {\n            this.addNewColumn();\n        }\n    }\n\n    /**\n     * Adds a new column to the headers search and binds it's FormControl to the service\n     */\n    protected addNewColumn(): void {\n        const formControl = new FormControl();\n        const i = this.formControls.length;\n        formControl.valueChanges.pipe(\n            debounceTime(this.SEARCH_DEBOUNCE_TIME),\n            map(value => value instanceof UserValue ? value.id : value)\n        ).subscribe(value => {\n            this.headerService.headerSearchInputChanged(i, value);\n        });\n        this.formControls.push(formControl);\n    }\n\n    /**\n     * Opens a user assign side menu component and sets the selected user as value of the form control object\n     * that corresponds to the given column.\n     *\n     * If no user is selected the value of the corresponding form control si cleared.\n     * @param column the index of the columns that should have it's form control value set to the selected user\n     * @param component is the component that we want to open\n     */\n    public selectAbstractUser(column: number, component: Type<any>): void {\n        let valueReturned = false;\n        this._sideMenuService.open(component).onClose.subscribe($event => {\n            if ($event.data) {\n                this.formControls[column].setValue($event.data as UserValue);\n                valueReturned = true;\n            } else if (!valueReturned) {\n                this.formControls[column].setValue(undefined);\n            }\n        });\n    }\n\n    /**\n     * Clears the value of the form control object in the given column\n     * @param column the index of the column that should have it's value cleared\n     */\n    protected clearInput(column: number): void {\n        if (column >= 0 && column < this.formControls.length) {\n            this.formControls[column].setValue(undefined);\n        }\n    }\n}\n"]}

package/esm2015/lib/header/header-modes/sort-mode/abstract-sort-mode.component.js

@@ -0,0 +1,15 @@
+import { Input } from '@angular/core';
+import { AbstractHeaderModeComponent } from '../abstract-header-mode.component';
+export class AbstractSortModeComponent extends AbstractHeaderModeComponent {
+    constructor() {
+        super();
+    }
+    sortHeaderChanged(sortEvent) {
+        const firstDash = sortEvent.active.indexOf('-');
+        this.headerService.sortHeaderChanged(parseInt(sortEvent.active.substring(0, firstDash), 10), sortEvent.active.substr(firstDash + 1, sortEvent.active.length), sortEvent.direction);
+    }
+}
+AbstractSortModeComponent.propDecorators = {
+    headerService: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/header/header-state.js

@@ -0,0 +1,43 @@
+import { HeaderMode } from './models/header-mode';
+import { BehaviorSubject } from 'rxjs';
+/**
+ * Keeps the current state of the header
+ */
+export class HeaderState {
+    constructor(initialHeaders) {
+        this.mode = HeaderMode.SORT;
+        this._lastMode = HeaderMode.SORT;
+        this._selectedHeaders$ = new BehaviorSubject(initialHeaders);
+    }
+    get selectedHeaders$() {
+        return this._selectedHeaders$.asObservable();
+    }
+    get selectedHeaders() {
+        return this._selectedHeaders$.getValue();
+    }
+    saveState() {
+        this._lastMode = this.mode;
+        this._lastSelectedHeaders = this._selectedHeaders$.getValue();
+    }
+    restoreLastMode() {
+        this.mode = this._lastMode;
+    }
+    restoreLastState() {
+        this.mode = this._lastMode;
+        this._selectedHeaders$.next(this._lastSelectedHeaders);
+    }
+    updateSelectedHeaders(newSelectedHeaders) {
+        this._selectedHeaders$.next(newSelectedHeaders);
+    }
+    asInterface() {
+        return {
+            mode: this.mode,
+            selectedHeaders$: this.selectedHeaders$,
+            selectedHeaders: this.selectedHeaders,
+            saveState: this.saveState,
+            restoreLastState: this.restoreLastState,
+            restoreLastMode: this.restoreLastMode
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/header/models/default-headers-token.js

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export const NAE_DEFAULT_HEADERS = new InjectionToken('NaeDefaultHeaders');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdC1oZWFkZXJzLXRva2VuLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL2hlYWRlci9tb2RlbHMvZGVmYXVsdC1oZWFkZXJzLXRva2VuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxjQUFjLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFDN0MsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUcsSUFBSSxjQUFjLENBQWdCLG1CQUFtQixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0luamVjdGlvblRva2VufSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmV4cG9ydCBjb25zdCBOQUVfREVGQVVMVF9IRUFERVJTID0gbmV3IEluamVjdGlvblRva2VuPEFycmF5PHN0cmluZz4+KCdOYWVEZWZhdWx0SGVhZGVycycpO1xuIl19

package/esm2015/lib/header/models/fields-group.js

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

package/esm2015/lib/header/models/header-column.js

@@ -0,0 +1,22 @@
+export var HeaderColumnType;
+(function (HeaderColumnType) {
+    HeaderColumnType["META"] = "meta";
+    HeaderColumnType["IMMEDIATE"] = "immediate";
+})(HeaderColumnType || (HeaderColumnType = {}));
+export class HeaderColumn {
+    constructor(type, fieldIdentifier, title, fieldType, initial = true, petriNetIdentifier) {
+        this.type = type;
+        this.fieldIdentifier = fieldIdentifier;
+        this.title = title;
+        this.fieldType = fieldType;
+        this.initial = initial;
+        this.petriNetIdentifier = petriNetIdentifier;
+        if (this.type === HeaderColumnType.IMMEDIATE && !this.petriNetIdentifier) {
+            throw new Error('HeaderColumn instances of type IMMEDIATE cannot be created without a petriNetIdentifier!');
+        }
+    }
+    get uniqueId() {
+        return `${this.type === HeaderColumnType.IMMEDIATE ? this.petriNetIdentifier : 'meta'}-${this.fieldIdentifier}`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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