@netgrif/components-core 6.0.1

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

@@ -0,0 +1,171 @@
+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';
+var AbstractHeaderComponent = /** @class */ (function () {
+    function AbstractHeaderComponent(_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);
+    }
+    Object.defineProperty(AbstractHeaderComponent.prototype, "maxHeaderColumns", {
+        set: function (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);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AbstractHeaderComponent.prototype, "responsiveHeaders", {
+        set: function (responsive) {
+            if (this.headerService) {
+                this.headerService.responsiveHeaders = responsive;
+            }
+            else {
+                this._initResponsiveHeaders = responsive;
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AbstractHeaderComponent.prototype.ngOnInit = function () {
+        var _this = this;
+        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(function (value) { return _this.columnCountControl.setValue(value); });
+    };
+    AbstractHeaderComponent.prototype.ngOnDestroy = function () {
+        if (this.canOverflow) {
+            this.subColumnWidthControl.unsubscribe();
+            this.subColumnCountControl.unsubscribe();
+            this.subOverflowControl.unsubscribe();
+        }
+    };
+    /**
+     * Injects the correct {@link AbstractHeaderService} instance based on this component's type
+     */
+    AbstractHeaderComponent.prototype.resolveHeaderService = function () {
+        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}
+     */
+    AbstractHeaderComponent.prototype.initializedHeaderSearch = function () {
+        if (this.type === HeaderType.CASE) {
+            this._headerSearch = this._injector.get(HeaderSearchService);
+            this._headerSearch.headerService = this.headerService;
+        }
+    };
+    AbstractHeaderComponent.prototype.clickStop = function ($event) {
+        stopPropagation($event);
+    };
+    AbstractHeaderComponent.prototype.getMinWidth = function () {
+        return (this._overflowService && this._overflowService.overflowMode) ? this._overflowService.columnWidth + "px" : '0';
+    };
+    AbstractHeaderComponent.prototype.confirmEditMode = function () {
+        if (!this.overflowControl.value || (this.overflowControl.value && this.columnWidthControl.valid && this.columnWidthControl.valid)) {
+            this.headerService.confirmEditMode();
+        }
+    };
+    AbstractHeaderComponent.prototype.getErrorMessageWidth = function () {
+        return this.buildErrorMessage(this.columnWidthControl, 180);
+    };
+    AbstractHeaderComponent.prototype.getErrorMessageCount = function () {
+        return this.buildErrorMessage(this.columnCountControl, 1);
+    };
+    AbstractHeaderComponent.prototype.buildErrorMessage = function (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 '';
+    };
+    AbstractHeaderComponent.prototype.initializeFormControls = function (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();
+        }
+    };
+    AbstractHeaderComponent.prototype.initializeValueChanges = function () {
+        var _this = this;
+        this.subOverflowControl = this.overflowControl.valueChanges.subscribe(function (value) {
+            _this._overflowService.overflowMode = value;
+        });
+        this.subColumnCountControl = this.columnCountControl.valueChanges.subscribe(function (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(function (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 }]
+    };
+    return AbstractHeaderComponent;
+}());
+export { AbstractHeaderComponent };
+//# 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":"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","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/esm5/lib/header/case-header/case-header.service.js

@@ -0,0 +1,86 @@
+import { __extends } from "tslib";
+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';
+var CaseHeaderService = /** @class */ (function (_super) {
+    __extends(CaseHeaderService, _super);
+    function CaseHeaderService(_allowedNetsService, preferences, logger, viewIdService, overflowService, naeDefaultHeaders) {
+        var _this = _super.call(this, HeaderType.CASE, preferences, viewIdService, logger) || this;
+        _this._allowedNetsService = _allowedNetsService;
+        _this.overflowService = overflowService;
+        _this.subAllowedNets = _allowedNetsService.allowedNets$.subscribe(function (allowedNets) {
+            _this.setAllowedNets(allowedNets);
+            if (naeDefaultHeaders && Array.isArray(naeDefaultHeaders) && naeDefaultHeaders.length > 0) {
+                _this.initDefaultHeaders = naeDefaultHeaders;
+                _this.initializeDefaultHeaderState();
+            }
+            else {
+                _this.loadHeadersFromPreferences();
+            }
+            _this.loading.off();
+        });
+        return _this;
+    }
+    CaseHeaderService.prototype.createMetaHeaders = function () {
+        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'),
+        ];
+    };
+    CaseHeaderService.prototype.ngOnDestroy = function () {
+        _super.prototype.ngOnDestroy.call(this);
+        this.subAllowedNets.unsubscribe();
+    };
+    CaseHeaderService.prototype.updateColumnCount = function () {
+        this.updateHeaderColumnCount();
+    };
+    CaseHeaderService.prototype.saveState = function () {
+        if (this.overflowService) {
+            this.overflowService.saveState();
+        }
+    };
+    CaseHeaderService.prototype.saveNewState = function () {
+        if (this.overflowService) {
+            this.overflowService.saveNewState();
+        }
+        this.updateHeaderColumnCount();
+    };
+    CaseHeaderService.prototype.restoreLastState = function () {
+        if (this.overflowService) {
+            this.overflowService.restoreLastState();
+        }
+    };
+    CaseHeaderService.ctorParameters = function () { return [
+        { 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 = function () { return [
+        { 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,] }] }
+    ]; };
+    return CaseHeaderService;
+}(AbstractHeaderService));
+export { CaseHeaderService };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/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/esm5/lib/header/header-modes/abstract-header-mode.component.js

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

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

@@ -0,0 +1,81 @@
+import { __extends, __read, __spread } from "tslib";
+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';
+var AbstractEditModeComponent = /** @class */ (function (_super) {
+    __extends(AbstractEditModeComponent, _super);
+    function AbstractEditModeComponent(_translate, _log) {
+        var _this = _super.call(this) || this;
+        _this._translate = _translate;
+        _this._log = _log;
+        _this.formControls = [];
+        _this.filterOptions = [];
+        _this.renderSelection = function (header) {
+            return header ? _this._translate.instant(header.title) : '';
+        };
+        return _this;
+    }
+    AbstractEditModeComponent.prototype.ngOnInit = function () {
+        var _this = this;
+        this.subHeader = this.headerService.headerColumnCount$.subscribe(function (newCount) { return _this.updateHeaderCount(newCount); });
+    };
+    AbstractEditModeComponent.prototype.ngOnDestroy = function () {
+        this.subHeader.unsubscribe();
+    };
+    AbstractEditModeComponent.prototype.updateHeaderCount = function (newCount) {
+        var _this = this;
+        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) {
+            var i = this.formControls.length;
+            var formControl = new FormControl();
+            formControl.setValue(this.headerService.headerState.selectedHeaders[i]);
+            this.formControls.push(formControl);
+            this.filterOptions.push(formControl.valueChanges.pipe(startWith(''), map(function (inputText) { return _this._filter(inputText); })));
+        }
+    };
+    AbstractEditModeComponent.prototype._filter = function (value) {
+        var _this = this;
+        var filterValue;
+        if (typeof value === 'string') {
+            filterValue = value.toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+        }
+        else {
+            filterValue = '';
+        }
+        var arrayGroup = [];
+        arrayGroup.push.apply(arrayGroup, __spread(this.headerService.fieldsGroup));
+        var 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.apply(meta, __spread(orderBy(arrayGroup, function (v) { return v.groupTitle; }, 'asc')));
+        meta.forEach(function (group) { return group.fields = orderBy(group.fields, function (v) { return v.title; }, 'asc'); });
+        return meta.map(function (group) { return ({
+            groupTitle: group.groupTitle,
+            fields: group.fields.filter(function (option) { return _this.checkImmediateTitle(option) &&
+                _this._translate.instant(option.title).toLowerCase().normalize('NFD')
+                    .replace(/[\u0300-\u036f]/g, '').indexOf(filterValue) === 0; })
+        }); }).filter(function (group) { return group.fields.length > 0; });
+    };
+    AbstractEditModeComponent.prototype.headerColumnSelected = function (columnIndex, newHeaderColumn) {
+        this.headerService.headerColumnSelected(columnIndex, newHeaderColumn);
+    };
+    AbstractEditModeComponent.prototype.checkImmediateTitle = function (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 }]
+    };
+    return AbstractEditModeComponent;
+}(AbstractHeaderModeComponent));
+export { AbstractEditModeComponent };
+//# 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/esm5/lib/header/header-modes/loading-mode/abstract-loading-mode.component.js

@@ -0,0 +1,17 @@
+import { __extends } from "tslib";
+import { Input } from '@angular/core';
+import { AbstractHeaderModeComponent } from '../abstract-header-mode.component';
+var AbstractLoadingModeComponent = /** @class */ (function (_super) {
+    __extends(AbstractLoadingModeComponent, _super);
+    function AbstractLoadingModeComponent() {
+        return _super.call(this) || this;
+    }
+    AbstractLoadingModeComponent.prototype.ngOnInit = function () {
+    };
+    AbstractLoadingModeComponent.propDecorators = {
+        headerService: [{ type: Input }]
+    };
+    return AbstractLoadingModeComponent;
+}(AbstractHeaderModeComponent));
+export { AbstractLoadingModeComponent };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3QtbG9hZGluZy1tb2RlLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9oZWFkZXIvaGVhZGVyLW1vZGVzL2xvYWRpbmctbW9kZS9hYnN0cmFjdC1sb2FkaW5nLW1vZGUuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUMsS0FBSyxFQUFTLE1BQU0sZUFBZSxDQUFDO0FBRTVDLE9BQU8sRUFBQywyQkFBMkIsRUFBQyxNQUFNLG1DQUFtQyxDQUFDO0FBRTlFO0lBQTJELGdEQUEyQjtJQUtsRjtlQUNJLGlCQUFPO0lBQ1gsQ0FBQztJQUVELCtDQUFRLEdBQVI7SUFDQSxDQUFDOztnQ0FSQSxLQUFLOztJQVVWLG1DQUFDO0NBQUEsQUFaRCxDQUEyRCwyQkFBMkIsR0FZckY7U0FacUIsNEJBQTRCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtJbnB1dCwgT25Jbml0fSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7QWJzdHJhY3RIZWFkZXJTZXJ2aWNlfSBmcm9tICcuLi8uLi9hYnN0cmFjdC1oZWFkZXItc2VydmljZSc7XG5pbXBvcnQge0Fic3RyYWN0SGVhZGVyTW9kZUNvbXBvbmVudH0gZnJvbSAnLi4vYWJzdHJhY3QtaGVhZGVyLW1vZGUuY29tcG9uZW50JztcblxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEFic3RyYWN0TG9hZGluZ01vZGVDb21wb25lbnQgZXh0ZW5kcyBBYnN0cmFjdEhlYWRlck1vZGVDb21wb25lbnQgaW1wbGVtZW50cyBPbkluaXQge1xuXG4gICAgQElucHV0KClcbiAgICBwdWJsaWMgaGVhZGVyU2VydmljZTogQWJzdHJhY3RIZWFkZXJTZXJ2aWNlO1xuXG4gICAgY29uc3RydWN0b3IoKSB7XG4gICAgICAgIHN1cGVyKCk7XG4gICAgfVxuXG4gICAgbmdPbkluaXQoKTogdm9pZCB7XG4gICAgfVxuXG59XG4iXX0=

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

@@ -0,0 +1,94 @@
+import { __extends } from "tslib";
+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';
+var AbstractSearchModeComponent = /** @class */ (function (_super) {
+    __extends(AbstractSearchModeComponent, _super);
+    function AbstractSearchModeComponent(_sideMenuService) {
+        var _this = _super.call(this) || this;
+        _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 = [];
+        return _this;
+    }
+    AbstractSearchModeComponent.prototype.ngOnInit = function () {
+        var _this = this;
+        this.subHeaderColumn = this.headerService.headerColumnCount$.subscribe(function (newCount) { return _this.updateHeaderCount(newCount); });
+        this.subClearHeader = this.headerService.clearHeaderSearch$.subscribe(function (columnNumber) { return _this.clearInput(columnNumber); });
+    };
+    AbstractSearchModeComponent.prototype.ngOnDestroy = function () {
+        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
+     */
+    AbstractSearchModeComponent.prototype.updateHeaderCount = function (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
+     */
+    AbstractSearchModeComponent.prototype.addNewColumn = function () {
+        var _this = this;
+        var formControl = new FormControl();
+        var i = this.formControls.length;
+        formControl.valueChanges.pipe(debounceTime(this.SEARCH_DEBOUNCE_TIME), map(function (value) { return value instanceof UserValue ? value.id : value; })).subscribe(function (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
+     */
+    AbstractSearchModeComponent.prototype.selectAbstractUser = function (column, component) {
+        var _this = this;
+        var valueReturned = false;
+        this._sideMenuService.open(component).onClose.subscribe(function ($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
+     */
+    AbstractSearchModeComponent.prototype.clearInput = function (column) {
+        if (column >= 0 && column < this.formControls.length) {
+            this.formControls[column].setValue(undefined);
+        }
+    };
+    AbstractSearchModeComponent.propDecorators = {
+        headerService: [{ type: Input }]
+    };
+    return AbstractSearchModeComponent;
+}(AbstractHeaderModeComponent));
+export { AbstractSearchModeComponent };
+//# 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/esm5/lib/header/header-modes/sort-mode/abstract-sort-mode.component.js

@@ -0,0 +1,19 @@
+import { __extends } from "tslib";
+import { Input } from '@angular/core';
+import { AbstractHeaderModeComponent } from '../abstract-header-mode.component';
+var AbstractSortModeComponent = /** @class */ (function (_super) {
+    __extends(AbstractSortModeComponent, _super);
+    function AbstractSortModeComponent() {
+        return _super.call(this) || this;
+    }
+    AbstractSortModeComponent.prototype.sortHeaderChanged = function (sortEvent) {
+        var 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 }]
+    };
+    return AbstractSortModeComponent;
+}(AbstractHeaderModeComponent));
+export { AbstractSortModeComponent };
+//# sourceMappingURL=data:application/json;base64,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