@netgrif/components-core 6.0.1

package/esm5/lib/navigation/quick-panel/components/language-selector/abstract-language-selector.component.js

@@ -0,0 +1,59 @@
+import { Input } from '@angular/core';
+var AbstractLanguageSelectorComponent = /** @class */ (function () {
+    function AbstractLanguageSelectorComponent(_select) {
+        var _this = this;
+        this._select = _select;
+        /**
+         * ISO 639-1
+         */
+        this.langMenuItems = [
+            {
+                key: 'sk-SK',
+                value: 'sk'
+            },
+            {
+                key: 'de-DE',
+                value: 'de'
+            },
+            {
+                key: 'en-US',
+                value: 'en',
+                flag: 'gb'
+            }
+        ];
+        this._flagOverrides = new Map();
+        this.langMenuItems.forEach(function (option) {
+            if (option.flag !== undefined) {
+                _this._flagOverrides.set(option.key, option.flag);
+            }
+        });
+    }
+    AbstractLanguageSelectorComponent.prototype.ngOnInit = function () {
+    };
+    Object.defineProperty(AbstractLanguageSelectorComponent.prototype, "flagCountryCode", {
+        get: function () {
+            return this.flagCode(this.language);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AbstractLanguageSelectorComponent.prototype.flagCode = function (languageCode) {
+        if (this._flagOverrides.has(languageCode)) {
+            return this._flagOverrides.get(languageCode);
+        }
+        if (languageCode.includes('-')) {
+            return languageCode.split('-')[1].toLowerCase();
+        }
+        return languageCode.toLowerCase();
+    };
+    AbstractLanguageSelectorComponent.prototype.setLang = function (lang) {
+        this.language = lang;
+        this._select.setLanguage(lang, true);
+    };
+    AbstractLanguageSelectorComponent.propDecorators = {
+        language: [{ type: Input }]
+    };
+    return AbstractLanguageSelectorComponent;
+}());
+export { AbstractLanguageSelectorComponent };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3QtbGFuZ3VhZ2Utc2VsZWN0b3IuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL25hdmlnYXRpb24vcXVpY2stcGFuZWwvY29tcG9uZW50cy9sYW5ndWFnZS1zZWxlY3Rvci9hYnN0cmFjdC1sYW5ndWFnZS1zZWxlY3Rvci5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLEtBQUssRUFBUyxNQUFNLGVBQWUsQ0FBQztBQUc1QztJQXdCSSwyQ0FBZ0MsT0FBd0I7UUFBeEQsaUJBT0M7UUFQK0IsWUFBTyxHQUFQLE9BQU8sQ0FBaUI7UUFsQnhEOztXQUVHO1FBQ0ksa0JBQWEsR0FBRztZQUNuQjtnQkFDSSxHQUFHLEVBQUUsT0FBTztnQkFDWixLQUFLLEVBQUUsSUFBSTthQUNkO1lBQ0Q7Z0JBQ0ksR0FBRyxFQUFFLE9BQU87Z0JBQ1osS0FBSyxFQUFFLElBQUk7YUFDZDtZQUNEO2dCQUNJLEdBQUcsRUFBRSxPQUFPO2dCQUNaLEtBQUssRUFBRSxJQUFJO2dCQUNYLElBQUksRUFBRSxJQUFJO2FBQ2I7U0FBQyxDQUFDO1FBR0gsSUFBSSxDQUFDLGNBQWMsR0FBRyxJQUFJLEdBQUcsRUFBa0IsQ0FBQztRQUNoRCxJQUFJLENBQUMsYUFBYSxDQUFDLE9BQU8sQ0FBQyxVQUFBLE1BQU07WUFDN0IsSUFBSSxNQUFNLENBQUMsSUFBSSxLQUFLLFNBQVMsRUFBRTtnQkFDM0IsS0FBSSxDQUFDLGNBQWMsQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLEdBQUcsRUFBRSxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUM7YUFDcEQ7UUFDTCxDQUFDLENBQUMsQ0FBQztJQUNQLENBQUM7SUFFRCxvREFBUSxHQUFSO0lBQ0EsQ0FBQztJQUVELHNCQUFJLDhEQUFlO2FBQW5CO1lBQ0ksT0FBTyxJQUFJLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztRQUN4QyxDQUFDOzs7T0FBQTtJQUVELG9EQUFRLEdBQVIsVUFBUyxZQUFvQjtRQUN6QixJQUFJLElBQUksQ0FBQyxjQUFjLENBQUMsR0FBRyxDQUFDLFlBQVksQ0FBQyxFQUFFO1lBQ3ZDLE9BQU8sSUFBSSxDQUFDLGNBQWMsQ0FBQyxHQUFHLENBQUMsWUFBWSxDQUFDLENBQUM7U0FDaEQ7UUFDRCxJQUFJLFlBQVksQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLEVBQUU7WUFDNUIsT0FBTyxZQUFZLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLFdBQVcsRUFBRSxDQUFDO1NBQ25EO1FBQ0QsT0FBTyxZQUFZLENBQUMsV0FBVyxFQUFFLENBQUM7SUFDdEMsQ0FBQztJQUVELG1EQUFPLEdBQVAsVUFBUSxJQUFZO1FBQ2hCLElBQUksQ0FBQyxRQUFRLEdBQUcsSUFBSSxDQUFDO1FBQ3JCLElBQUksQ0FBQyxPQUFPLENBQUMsV0FBVyxDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsQ0FBQztJQUN6QyxDQUFDOzsyQkFuREEsS0FBSzs7SUFvRFYsd0NBQUM7Q0FBQSxBQXRERCxJQXNEQztTQXREcUIsaUNBQWlDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtJbnB1dCwgT25Jbml0fSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7TGFuZ3VhZ2VTZXJ2aWNlfSBmcm9tICcuLi8uLi8uLi8uLi90cmFuc2xhdGUvbGFuZ3VhZ2Uuc2VydmljZSc7XG5cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBBYnN0cmFjdExhbmd1YWdlU2VsZWN0b3JDb21wb25lbnQgaW1wbGVtZW50cyBPbkluaXQge1xuXG4gICAgQElucHV0KCkgcHVibGljIGxhbmd1YWdlOiBzdHJpbmc7XG5cbiAgICBwcm90ZWN0ZWQgX2ZsYWdPdmVycmlkZXM6IE1hcDxzdHJpbmcsIHN0cmluZz47XG5cbiAgICAvKipcbiAgICAgKiBJU08gNjM5LTFcbiAgICAgKi9cbiAgICBwdWJsaWMgbGFuZ01lbnVJdGVtcyA9IFtcbiAgICAgICAge1xuICAgICAgICAgICAga2V5OiAnc2stU0snLFxuICAgICAgICAgICAgdmFsdWU6ICdzaydcbiAgICAgICAgfSxcbiAgICAgICAge1xuICAgICAgICAgICAga2V5OiAnZGUtREUnLFxuICAgICAgICAgICAgdmFsdWU6ICdkZSdcbiAgICAgICAgfSxcbiAgICAgICAge1xuICAgICAgICAgICAga2V5OiAnZW4tVVMnLFxuICAgICAgICAgICAgdmFsdWU6ICdlbicsXG4gICAgICAgICAgICBmbGFnOiAnZ2InXG4gICAgICAgIH1dO1xuXG4gICAgcHJvdGVjdGVkIGNvbnN0cnVjdG9yKHByb3RlY3RlZCBfc2VsZWN0OiBMYW5ndWFnZVNlcnZpY2UpIHtcbiAgICAgICAgdGhpcy5fZmxhZ092ZXJyaWRlcyA9IG5ldyBNYXA8c3RyaW5nLCBzdHJpbmc+KCk7XG4gICAgICAgIHRoaXMubGFuZ01lbnVJdGVtcy5mb3JFYWNoKG9wdGlvbiA9PiB7XG4gICAgICAgICAgICBpZiAob3B0aW9uLmZsYWcgIT09IHVuZGVmaW5lZCkge1xuICAgICAgICAgICAgICAgIHRoaXMuX2ZsYWdPdmVycmlkZXMuc2V0KG9wdGlvbi5rZXksIG9wdGlvbi5mbGFnKTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgfSk7XG4gICAgfVxuXG4gICAgbmdPbkluaXQoKTogdm9pZCB7XG4gICAgfVxuXG4gICAgZ2V0IGZsYWdDb3VudHJ5Q29kZSgpOiBzdHJpbmcge1xuICAgICAgICByZXR1cm4gdGhpcy5mbGFnQ29kZSh0aGlzLmxhbmd1YWdlKTtcbiAgICB9XG5cbiAgICBmbGFnQ29kZShsYW5ndWFnZUNvZGU6IHN0cmluZyk6IHN0cmluZyB7XG4gICAgICAgIGlmICh0aGlzLl9mbGFnT3ZlcnJpZGVzLmhhcyhsYW5ndWFnZUNvZGUpKSB7XG4gICAgICAgICAgICByZXR1cm4gdGhpcy5fZmxhZ092ZXJyaWRlcy5nZXQobGFuZ3VhZ2VDb2RlKTtcbiAgICAgICAgfVxuICAgICAgICBpZiAobGFuZ3VhZ2VDb2RlLmluY2x1ZGVzKCctJykpIHtcbiAgICAgICAgICAgIHJldHVybiBsYW5ndWFnZUNvZGUuc3BsaXQoJy0nKVsxXS50b0xvd2VyQ2FzZSgpO1xuICAgICAgICB9XG4gICAgICAgIHJldHVybiBsYW5ndWFnZUNvZGUudG9Mb3dlckNhc2UoKTtcbiAgICB9XG5cbiAgICBzZXRMYW5nKGxhbmc6IHN0cmluZykge1xuICAgICAgICB0aGlzLmxhbmd1YWdlID0gbGFuZztcbiAgICAgICAgdGhpcy5fc2VsZWN0LnNldExhbmd1YWdlKGxhbmcsIHRydWUpO1xuICAgIH1cbn1cbiJdfQ==

package/esm5/lib/navigation/quick-panel/components/logout-shortcut/abstract-logout-shortcut.component.js

@@ -0,0 +1,24 @@
+var AbstractLogoutShortcutComponent = /** @class */ (function () {
+    function AbstractLogoutShortcutComponent(_user, _log, _config, _router) {
+        this._user = _user;
+        this._log = _log;
+        this._config = _config;
+        this._router = _router;
+    }
+    AbstractLogoutShortcutComponent.prototype.ngOnInit = function () {
+    };
+    AbstractLogoutShortcutComponent.prototype.logout = function () {
+        var _this = this;
+        this._user.logout().subscribe(function () {
+            _this._log.debug('User is logged out');
+            if (_this._config.get().services && _this._config.get().services.auth && _this._config.get().services.auth.logoutRedirect) {
+                var redirectPath = _this._config.get().services.auth.logoutRedirect;
+                _this._log.info('Redirecting to ' + redirectPath);
+                _this._router.navigate([redirectPath]);
+            }
+        });
+    };
+    return AbstractLogoutShortcutComponent;
+}());
+export { AbstractLogoutShortcutComponent };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/navigation/quick-panel/components/paper-view.service.js

@@ -0,0 +1,44 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+var PaperViewService = /** @class */ (function () {
+    function PaperViewService() {
+        var paper = localStorage.getItem('PaperView');
+        if (paper === null) {
+            this._paperView = false;
+            localStorage.setItem('PaperView', 'false');
+        }
+        else {
+            if (paper === 'true') {
+                this._paperView = true;
+            }
+            else if (paper === 'false') {
+                this._paperView = false;
+            }
+            else {
+                this._paperView = false;
+                localStorage.setItem('PaperView', 'false');
+            }
+        }
+    }
+    Object.defineProperty(PaperViewService.prototype, "paperView", {
+        get: function () {
+            return this._paperView;
+        },
+        set: function (bool) {
+            this._paperView = bool;
+            localStorage.setItem('PaperView', "" + bool);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PaperViewService.ɵprov = i0.ɵɵdefineInjectable({ factory: function PaperViewService_Factory() { return new PaperViewService(); }, token: PaperViewService, providedIn: "root" });
+    PaperViewService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    PaperViewService.ctorParameters = function () { return []; };
+    return PaperViewService;
+}());
+export { PaperViewService };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/navigation/quick-panel/public-api.js

@@ -0,0 +1,8 @@
+/* COMPONENTS */
+export * from './components/abstract-quick-panel.component';
+export * from './components/internal-link/abstract-internal-link.component';
+export * from './components/logout-shortcut/abstract-logout-shortcut.component';
+export * from './components/language-selector/abstract-language-selector.component';
+/* SERVICES */
+export * from './components/paper-view.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9uYXZpZ2F0aW9uL3F1aWNrLXBhbmVsL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsZ0JBQWdCO0FBQ2hCLGNBQWMsNkNBQTZDLENBQUM7QUFDNUQsY0FBYyw2REFBNkQsQ0FBQztBQUM1RSxjQUFjLGlFQUFpRSxDQUFDO0FBQ2hGLGNBQWMscUVBQXFFLENBQUM7QUFFcEYsY0FBYztBQUNkLGNBQWMsaUNBQWlDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiBDT01QT05FTlRTICovXG5leHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudHMvYWJzdHJhY3QtcXVpY2stcGFuZWwuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50cy9pbnRlcm5hbC1saW5rL2Fic3RyYWN0LWludGVybmFsLWxpbmsuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50cy9sb2dvdXQtc2hvcnRjdXQvYWJzdHJhY3QtbG9nb3V0LXNob3J0Y3V0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudHMvbGFuZ3VhZ2Utc2VsZWN0b3IvYWJzdHJhY3QtbGFuZ3VhZ2Utc2VsZWN0b3IuY29tcG9uZW50JztcblxuLyogU0VSVklDRVMgKi9cbmV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50cy9wYXBlci12aWV3LnNlcnZpY2UnO1xuIl19

package/esm5/lib/navigation/utility/filter-extraction.service.js

@@ -0,0 +1,89 @@
+import { Injectable } from '@angular/core';
+import { extractFilterFromFilterField } from './navigation-item-task-utility-methods';
+import { getFieldFromDataGroups, getFieldIndexFromDataGroups } from '../../utility/get-field';
+import { UserFilterConstants } from '../../filter/models/user-filter-constants';
+import { FilterRepository } from '../../filter/filter.repository';
+import { TextField } from '../../data-fields/text-field/models/text-field';
+import { LoggerService } from '../../logger/services/logger.service';
+import { MergeOperator } from '../../filter/models/merge-operator';
+import { TaskResourceService } from '../../resources/engine-endpoint/task-resource.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../filter/filter.repository";
+import * as i2 from "../../resources/engine-endpoint/task-resource.service";
+import * as i3 from "../../logger/services/logger.service";
+/**
+ * This service is able to load the full saved filter including all of its ancestor filters.
+ */
+var FilterExtractionService = /** @class */ (function () {
+    function FilterExtractionService(_filterRepository, _taskResourceService, _log) {
+        this._filterRepository = _filterRepository;
+        this._taskResourceService = _taskResourceService;
+        this._log = _log;
+    }
+    FilterExtractionService.prototype.extractCompleteFilterFromData = function (dataSection) {
+        var filterIndex = getFieldIndexFromDataGroups(dataSection, UserFilterConstants.FILTER_FIELD_ID);
+        if (filterIndex === undefined) {
+            return undefined;
+        }
+        var filterSegment;
+        try {
+            filterSegment = extractFilterFromFilterField(dataSection[filterIndex.dataGroupIndex].fields[filterIndex.fieldIndex]);
+        }
+        catch (e) {
+            throw new Error('Filter segment could not be extracted from filter field');
+        }
+        var parentFilter = this.extractCompleteFilterFromData(dataSection.slice(filterIndex.dataGroupIndex + 1));
+        if (parentFilter !== undefined) {
+            return filterSegment.merge(parentFilter, MergeOperator.AND);
+        }
+        // Is the filter view rooted?
+        var rootViewIdField = getFieldFromDataGroups(dataSection, UserFilterConstants.ORIGIN_VIEW_ID_FIELD_ID);
+        if (rootViewIdField === undefined) {
+            return filterSegment;
+        }
+        var rootViewFilter = this.extractViewFilter(rootViewIdField);
+        if (rootViewFilter !== undefined) {
+            return filterSegment.merge(rootViewFilter, MergeOperator.AND);
+        }
+        return filterSegment;
+    };
+    FilterExtractionService.prototype.extractViewFilter = function (originViewIdField) {
+        var _a, _b;
+        if (originViewIdField === undefined || !(originViewIdField instanceof TextField)) {
+            throw new Error('Could not extract origin view id field from task data');
+        }
+        var originViewId = originViewIdField.value;
+        var match = originViewId.match(FilterExtractionService.UNTABBED_VIEW_ID_EXTRACTOR);
+        if (match === null) {
+            throw new Error('Unexpected state. View Id of origin app view could not be extracted');
+        }
+        var originUntabbedViewId = originViewId.substring(0, originViewId.length - ((_b = (_a = match[1]) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0));
+        var appOriginFilter = this._filterRepository.getFilter(originUntabbedViewId);
+        if (appOriginFilter === undefined) {
+            this._log.error("Could not retrieve origin app filter with id '" + originUntabbedViewId + "'. Falling back to empty filter");
+            return undefined;
+        }
+        return appOriginFilter;
+    };
+    // the same regexs is used in a backend filter process action. Please keep them in sync
+    FilterExtractionService.UNTABBED_VIEW_ID_EXTRACTOR = '^.*?(-\\d+)?$';
+    FilterExtractionService.ctorParameters = function () { return [
+        { type: FilterRepository },
+        { type: TaskResourceService },
+        { type: LoggerService }
+    ]; };
+    FilterExtractionService.ɵprov = i0.ɵɵdefineInjectable({ factory: function FilterExtractionService_Factory() { return new FilterExtractionService(i0.ɵɵinject(i1.FilterRepository), i0.ɵɵinject(i2.TaskResourceService), i0.ɵɵinject(i3.LoggerService)); }, token: FilterExtractionService, providedIn: "root" });
+    FilterExtractionService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    FilterExtractionService.ctorParameters = function () { return [
+        { type: FilterRepository },
+        { type: TaskResourceService },
+        { type: LoggerService }
+    ]; };
+    return FilterExtractionService;
+}());
+export { FilterExtractionService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filter-extraction.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/navigation/utility/filter-extraction.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from '@angular/core';\nimport {Filter} from '../../filter/models/filter';\nimport {DataGroup} from '../../resources/interface/data-groups';\nimport {extractFilterFromFilterField} from './navigation-item-task-utility-methods';\nimport {getFieldFromDataGroups, getFieldIndexFromDataGroups} from '../../utility/get-field';\nimport {UserFilterConstants} from '../../filter/models/user-filter-constants';\nimport {FilterRepository} from '../../filter/filter.repository';\nimport {TextField} from '../../data-fields/text-field/models/text-field';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {MergeOperator} from '../../filter/models/merge-operator';\nimport {TaskResourceService} from '../../resources/engine-endpoint/task-resource.service';\nimport {FilterField} from '../../data-fields/filter-field/models/filter-field';\nimport {DataField} from '../../data-fields/models/abstract-data-field';\n\n/**\n * This service is able to load the full saved filter including all of its ancestor filters.\n */\n@Injectable({\n    providedIn: 'root'\n})\nexport class FilterExtractionService {\n\n    // the same regexs is used in a backend filter process action. Please keep them in sync\n    protected static readonly UNTABBED_VIEW_ID_EXTRACTOR = '^.*?(-\\\\d+)?$';\n\n    constructor(protected _filterRepository: FilterRepository,\n                protected _taskResourceService: TaskResourceService,\n                protected _log: LoggerService) {\n    }\n\n    public extractCompleteFilterFromData(dataSection: Array<DataGroup>): Filter | undefined {\n        const filterIndex = getFieldIndexFromDataGroups(dataSection, UserFilterConstants.FILTER_FIELD_ID);\n\n        if (filterIndex === undefined) {\n            return undefined;\n        }\n\n        let filterSegment: Filter;\n        try {\n            filterSegment = extractFilterFromFilterField(\n                dataSection[filterIndex.dataGroupIndex].fields[filterIndex.fieldIndex] as FilterField\n            );\n        } catch (e) {\n            throw new Error('Filter segment could not be extracted from filter field');\n        }\n\n        const parentFilter = this.extractCompleteFilterFromData(dataSection.slice(filterIndex.dataGroupIndex + 1));\n\n        if (parentFilter !== undefined) {\n            return filterSegment.merge(parentFilter, MergeOperator.AND);\n        }\n\n        // Is the filter view rooted?\n        const rootViewIdField = getFieldFromDataGroups(dataSection, UserFilterConstants.ORIGIN_VIEW_ID_FIELD_ID);\n        if (rootViewIdField === undefined) {\n            return filterSegment;\n        }\n\n        const rootViewFilter = this.extractViewFilter(rootViewIdField);\n        if (rootViewFilter !== undefined) {\n            return filterSegment.merge(rootViewFilter, MergeOperator.AND);\n        }\n        return filterSegment;\n    }\n\n    protected extractViewFilter(originViewIdField: DataField<any>): Filter | undefined {\n        if (originViewIdField === undefined || !(originViewIdField instanceof TextField)) {\n            throw new Error('Could not extract origin view id field from task data');\n        }\n        const originViewId = originViewIdField.value;\n\n        const match = originViewId.match(FilterExtractionService.UNTABBED_VIEW_ID_EXTRACTOR);\n        if (match === null) {\n            throw new Error('Unexpected state. View Id of origin app view could not be extracted');\n        }\n        const originUntabbedViewId = originViewId.substring(0, originViewId.length - (match[1]?.length ?? 0));\n        const appOriginFilter = this._filterRepository.getFilter(originUntabbedViewId);\n        if (appOriginFilter === undefined) {\n            this._log.error(`Could not retrieve origin app filter with id '${originUntabbedViewId}'. Falling back to empty filter`);\n            return undefined;\n        }\n        return appOriginFilter;\n    }\n\n}\n"]}

package/esm5/lib/navigation/utility/navigation-item-task-utility-methods.js

@@ -0,0 +1,78 @@
+import { getFieldFromDataGroups } from '../../utility/get-field';
+import { GroupNavigationConstants } from '../model/group-navigation-constants';
+import { UserFilterConstants } from '../../filter/models/user-filter-constants';
+import { FilterField } from '../../data-fields/filter-field/models/filter-field';
+import { SimpleFilter } from '../../filter/models/simple-filter';
+/**
+ * Extracts the item name and item icon (if any) rom a section of the navigation item task data.
+ * @param dataSection an array containing the data groups that correspond to a single navigation entry
+ */
+export function extractIconAndTitle(dataSection) {
+    var result = { name: '' };
+    if (dataSection.length === 0) {
+        throw new Error('The provided task data does not belong to a Navigation menu item task. Icon and title cannot be extracted');
+    }
+    var nameField = getFieldFromDataGroups(dataSection, GroupNavigationConstants.NAVIGATION_ENTRY_TITLE_FIELD_ID_SUFFIX);
+    if (nameField === undefined) {
+        throw new Error('Navigation entry name could not be resolved');
+    }
+    result.name = nameField.value;
+    var useIcon = getFieldFromDataGroups(dataSection, GroupNavigationConstants.NAVIGATION_ENTRY_ICON_ENABLED_FIELD_ID_SUFFIX);
+    if (useIcon !== undefined && useIcon.value) {
+        var icon = getFieldFromDataGroups(dataSection, GroupNavigationConstants.NAVIGATION_ENTRY_ICON_FIELD_ID_SUFFIX);
+        if (icon === undefined) {
+            this._log.error('Navigation entry icon could not be resolved, but is enabled. Icon was ignored');
+        }
+        else {
+            result.icon = icon.value;
+        }
+    }
+    return result;
+}
+/**
+ * Based on provided parameter extracts allowed or banned roles into an Array of strings from a section of the navigation item task data.
+ * Each item has format ROLE_IMPORT_ID:NET_IMPORT_ID
+ * @param dataSection an array containing the data groups that correspond to a single navigation entry
+ * @param roleFieldId ID of field containing banned or allowed role IDs
+ * @returns an Array of string values representing role IDs
+ */
+export function extractRoles(dataSection, roleFieldId) {
+    if (dataSection.length === 0) {
+        throw new Error('The provided task data does not belong to a Navigation menu item task. Role entries cannot be extracted');
+    }
+    var roleIds = getFieldFromDataGroups(dataSection, roleFieldId);
+    if (roleIds === undefined) {
+        throw new Error('Navigation entry role authorization field could not be resolved');
+    }
+    return roleIds.choices.map(function (choice) { return choice.key; });
+}
+/**
+ * Extracts the data and creates a filter object from the navigation item task data.
+ * @param dataSection an array containing the data groups that correspond to a single navigation entry
+ */
+export function extractFilterFromData(dataSection) {
+    return extractFilterFromFilterField(extractFilterFieldFromData(dataSection));
+}
+/**
+ * Extracts the filter field from the navigation item task data.
+ * @param dataSection an array containing the data groups that correspond to a single navigation entry
+ * @returns The extracted {@link FilterField} or `undefined` if it could not be extracted.
+ */
+export function extractFilterFieldFromData(dataSection) {
+    var filterField = getFieldFromDataGroups(dataSection, UserFilterConstants.FILTER_FIELD_ID);
+    if (filterField === undefined || !(filterField instanceof FilterField)) {
+        throw new Error("Filter could not be extracted. The provided datagroups do not contain a filter field with ID '" + UserFilterConstants.FILTER_FIELD_ID + "'");
+    }
+    return filterField;
+}
+/**
+ * @returns a {@link SimpleFilter} containing the filter stored in the provided {@link FilterField}.
+ * Throws an error if this is not possible.
+ */
+export function extractFilterFromFilterField(filterField) {
+    if (filterField === undefined || !(filterField instanceof FilterField)) {
+        throw new Error('Filter could not be resolved');
+    }
+    return SimpleFilter.fromQuery({ query: filterField.value }, filterField.filterMetadata.filterType);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"navigation-item-task-utility-methods.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/navigation/utility/navigation-item-task-utility-methods.ts"],"names":[],"mappings":"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","sourcesContent":["import {GroupNavigationItemLabel} from '../model/group-navigation-item-label';\nimport {DataGroup} from '../../resources/interface/data-groups';\nimport {getFieldFromDataGroups} from '../../utility/get-field';\nimport {GroupNavigationConstants} from '../model/group-navigation-constants';\nimport {Filter} from '../../filter/models/filter';\nimport {UserFilterConstants} from '../../filter/models/user-filter-constants';\nimport {FilterField} from '../../data-fields/filter-field/models/filter-field';\nimport {SimpleFilter} from '../../filter/models/simple-filter';\nimport {MultichoiceField} from '../../data-fields/multichoice-field/models/multichoice-field';\n\n/**\n * Extracts the item name and item icon (if any) rom a section of the navigation item task data.\n * @param dataSection an array containing the data groups that correspond to a single navigation entry\n */\nexport function extractIconAndTitle(dataSection: Array<DataGroup>): GroupNavigationItemLabel {\n    const result: GroupNavigationItemLabel = {name: ''};\n\n    if (dataSection.length === 0) {\n        throw new Error('The provided task data does not belong to a Navigation menu item task. Icon and title cannot be extracted');\n    }\n\n    const nameField = getFieldFromDataGroups(dataSection, GroupNavigationConstants.NAVIGATION_ENTRY_TITLE_FIELD_ID_SUFFIX);\n\n    if (nameField === undefined) {\n        throw new Error('Navigation entry name could not be resolved');\n    }\n    result.name = nameField.value;\n\n    const useIcon = getFieldFromDataGroups(dataSection, GroupNavigationConstants.NAVIGATION_ENTRY_ICON_ENABLED_FIELD_ID_SUFFIX);\n    if (useIcon !== undefined && useIcon.value) {\n        const icon = getFieldFromDataGroups(dataSection, GroupNavigationConstants.NAVIGATION_ENTRY_ICON_FIELD_ID_SUFFIX);\n        if (icon === undefined) {\n            this._log.error('Navigation entry icon could not be resolved, but is enabled. Icon was ignored');\n        } else {\n            result.icon = icon.value;\n        }\n    }\n    return result;\n}\n\n/**\n * Based on provided parameter extracts allowed or banned roles into an Array of strings from a section of the navigation item task data.\n * Each item has format ROLE_IMPORT_ID:NET_IMPORT_ID\n * @param dataSection an array containing the data groups that correspond to a single navigation entry\n * @param roleFieldId ID of field containing banned or allowed role IDs\n * @returns an Array of string values representing role IDs\n */\nexport function extractRoles(dataSection: Array<DataGroup>, roleFieldId: string): Array<string> {\n    if (dataSection.length === 0) {\n        throw new Error('The provided task data does not belong to a Navigation menu item task. Role entries cannot be extracted');\n    }\n\n    const roleIds = getFieldFromDataGroups(dataSection, roleFieldId);\n    if (roleIds === undefined) {\n        throw new Error('Navigation entry role authorization field could not be resolved');\n    }\n\n    return (roleIds as unknown as MultichoiceField).choices.map(choice => choice.key);\n}\n\n/**\n * Extracts the data and creates a filter object from the navigation item task data.\n * @param dataSection an array containing the data groups that correspond to a single navigation entry\n */\nexport function extractFilterFromData(dataSection: Array<DataGroup>): Filter {\n    return extractFilterFromFilterField(extractFilterFieldFromData(dataSection));\n}\n\n/**\n * Extracts the filter field from the navigation item task data.\n * @param dataSection an array containing the data groups that correspond to a single navigation entry\n * @returns The extracted {@link FilterField} or `undefined` if it could not be extracted.\n */\nexport function extractFilterFieldFromData(dataSection: Array<DataGroup>): FilterField | undefined {\n    const filterField = getFieldFromDataGroups(dataSection, UserFilterConstants.FILTER_FIELD_ID);\n\n    if (filterField === undefined || !(filterField instanceof FilterField)) {\n        throw new Error(`Filter could not be extracted. The provided datagroups do not contain a filter field with ID '${\n            UserFilterConstants.FILTER_FIELD_ID}'`);\n    }\n\n    return filterField;\n}\n\n/**\n * @returns a {@link SimpleFilter} containing the filter stored in the provided {@link FilterField}.\n * Throws an error if this is not possible.\n */\nexport function extractFilterFromFilterField(filterField: FilterField): Filter {\n    if (filterField === undefined || !(filterField instanceof FilterField)) {\n        throw new Error('Filter could not be resolved');\n    }\n    return SimpleFilter.fromQuery({query: filterField.value}, filterField.filterMetadata.filterType);\n}\n"]}

package/esm5/lib/panel/abstract/featured-value.js

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

package/esm5/lib/panel/abstract/panel-with-header-binding.js

@@ -0,0 +1,50 @@
+import { HeaderColumnType } from '../../header/models/header-column';
+var PanelWithHeaderBinding = /** @class */ (function () {
+    function PanelWithHeaderBinding() {
+        this.featuredFieldsValues = [];
+    }
+    PanelWithHeaderBinding.prototype.ngOnInit = function () {
+        var _this = this;
+        this.sub = this.selectedHeaders$.subscribe(function (newSelectedHeaders) {
+            _this._lastSelectedHeaders = newSelectedHeaders;
+            _this.resolveFeaturedFieldsValues();
+        });
+    };
+    PanelWithHeaderBinding.prototype.ngOnDestroy = function () {
+        this.sub.unsubscribe();
+    };
+    /**
+     * If the event was cause by selecting some text, it will not propagate
+     * @param event
+     */
+    PanelWithHeaderBinding.prototype.preventSelectionClick = function (event) {
+        if (event.view.getSelection().type === 'Range') {
+            event.stopPropagation();
+        }
+    };
+    PanelWithHeaderBinding.prototype.resolveFeaturedFieldsValues = function () {
+        if (!this._lastSelectedHeaders) {
+            return;
+        }
+        this.featuredFieldsValues.splice(0, this.featuredFieldsValues.length);
+        this.firstFeaturedValue = this.getFeaturedValue(this._lastSelectedHeaders[0]).value;
+        for (var i = 1; i < this._lastSelectedHeaders.length; i++) {
+            this.featuredFieldsValues.push(this.getFeaturedValue(this._lastSelectedHeaders[i]));
+        }
+    };
+    PanelWithHeaderBinding.prototype.getFeaturedValue = function (selectedHeader) {
+        if (!selectedHeader) {
+            return { value: '', icon: '', type: '' };
+        }
+        if (selectedHeader.type === HeaderColumnType.META) {
+            return this.getFeaturedMetaValue(selectedHeader);
+        }
+        if (selectedHeader.type === HeaderColumnType.IMMEDIATE) {
+            return this.getFeaturedImmediateValue(selectedHeader);
+        }
+        return { value: '', icon: '', type: '' };
+    };
+    return PanelWithHeaderBinding;
+}());
+export { PanelWithHeaderBinding };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/panel/abstract/panel-with-immediate-data.js

@@ -0,0 +1,67 @@
+import { __extends } from "tslib";
+import { PanelWithHeaderBinding } from './panel-with-header-binding';
+import { toMoment } from '../../resources/types/nae-date-type';
+import { DATE_FORMAT_STRING, DATE_TIME_FORMAT_STRING } from '../../moment/time-formats';
+var PanelWithImmediateData = /** @class */ (function (_super) {
+    __extends(PanelWithImmediateData, _super);
+    function PanelWithImmediateData(_translate, _currencyPipe) {
+        var _this = _super.call(this) || this;
+        _this._translate = _translate;
+        _this._currencyPipe = _currencyPipe;
+        return _this;
+    }
+    PanelWithImmediateData.prototype.ngOnDestroy = function () {
+        _super.prototype.ngOnDestroy.call(this);
+    };
+    PanelWithImmediateData.prototype.parseImmediateValue = function (immediate) {
+        var _a, _b, _c;
+        if (immediate && immediate.value !== undefined || immediate && immediate.type === 'button') {
+            switch (immediate.type) {
+                case 'date':
+                    return { value: toMoment(immediate.value).format(DATE_FORMAT_STRING), icon: 'event', type: immediate.type };
+                case 'dateTime':
+                    return { value: toMoment(immediate.value).format(DATE_TIME_FORMAT_STRING), icon: 'event', type: immediate.type };
+                case 'enumeration':
+                    return { value: immediate.value.defaultValue, icon: undefined, type: immediate.type };
+                case 'multichoice':
+                    return { value: immediate.value.map(function (it) { return it.defaultValue; }).join(', '), icon: undefined, type: immediate.type };
+                case 'file':
+                    return { value: (_a = immediate.value) === null || _a === void 0 ? void 0 : _a.name, icon: 'insert_drive_file', type: immediate.type };
+                case 'fileList':
+                    return { value: (_b = immediate.value) === null || _b === void 0 ? void 0 : _b.namesPaths.map(function (obj) { return obj.name; }).join(', '), icon: 'file_copy', type: immediate.type };
+                case 'user':
+                    return { value: immediate.value.fullName, icon: 'account_circle', type: immediate.type };
+                case 'boolean':
+                    return { value: this._translate.instant('dataField.values.boolean.' + immediate.value),
+                        icon: undefined, type: immediate.type };
+                case 'button':
+                    return { value: immediate.placeholder && immediate.placeholder.defaultValue !== undefined
+                            ? immediate.placeholder.defaultValue : (immediate.name && immediate.name.defaultValue !== undefined
+                            ? immediate.name.defaultValue : this._translate.instant('dialog.submit')), icon: undefined, type: immediate.type };
+                case 'filter':
+                    return { value: undefined, icon: undefined, type: immediate.type,
+                        filterMetadata: { filterMetadata: immediate.filterMetadata, allowedNets: immediate.allowedNets } };
+                case 'number':
+                    if (immediate.format !== undefined) {
+                        return this.formatCurrencyPipe(immediate.value, immediate.format.code, immediate.format.fractionSize, immediate.format.locale, immediate.type);
+                    }
+                    else if (((_c = immediate.component) === null || _c === void 0 ? void 0 : _c.name) === 'currency') {
+                        return this.formatCurrencyPipe(immediate.value, immediate.component.properties['code'], immediate.component.properties['fractionSize'], immediate.component.properties['locale'], immediate.type);
+                    }
+                    return { value: immediate.value, icon: undefined, type: immediate.type };
+                default:
+                    return { value: immediate.value, icon: undefined, type: immediate.type };
+            }
+        }
+        else {
+            return { value: '', icon: '', type: '' };
+        }
+    };
+    PanelWithImmediateData.prototype.formatCurrencyPipe = function (value, code, fraction, locale, type) {
+        return { value: this._currencyPipe.transform(parseFloat(value), code, 'symbol', '1.' + fraction + '-' + fraction, locale),
+            icon: undefined, type: type };
+    };
+    return PanelWithImmediateData;
+}(PanelWithHeaderBinding));
+export { PanelWithImmediateData };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"panel-with-immediate-data.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/panel/abstract/panel-with-immediate-data.ts"],"names":[],"mappings":"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","sourcesContent":["import {PanelWithHeaderBinding} from './panel-with-header-binding';\nimport {NaeDate, toMoment} from '../../resources/types/nae-date-type';\nimport {DATE_FORMAT_STRING, DATE_TIME_FORMAT_STRING} from '../../moment/time-formats';\nimport {TranslateService} from '@ngx-translate/core';\nimport {OnDestroy} from '@angular/core';\nimport {FeaturedValue} from './featured-value';\nimport {CurrencyPipe} from '@angular/common';\nimport {ImmediateData} from '../../resources/interface/immediate-data';\n\nexport abstract class PanelWithImmediateData extends PanelWithHeaderBinding implements OnDestroy {\n    protected constructor(protected _translate: TranslateService, protected _currencyPipe: CurrencyPipe) {\n        super();\n    }\n\n    ngOnDestroy(): void {\n        super.ngOnDestroy();\n    }\n\n    protected parseImmediateValue(immediate: ImmediateData): FeaturedValue {\n        if (immediate && immediate.value !== undefined || immediate && immediate.type === 'button') {\n            switch (immediate.type) {\n                case 'date':\n                    return {value: toMoment(immediate.value as NaeDate).format(DATE_FORMAT_STRING), icon: 'event', type: immediate.type};\n                case 'dateTime':\n                    return {value: toMoment(immediate.value as NaeDate).format(DATE_TIME_FORMAT_STRING),\n                        icon: 'event', type: immediate.type};\n                case 'enumeration':\n                    return {value: immediate.value.defaultValue, icon: undefined, type: immediate.type};\n                case 'multichoice':\n                    return {value: immediate.value.map(it => it.defaultValue).join(', '), icon: undefined, type: immediate.type};\n                case 'file':\n                    return {value: immediate.value?.name, icon: 'insert_drive_file', type: immediate.type};\n                case 'fileList':\n                    return {value: immediate.value?.namesPaths.map(obj => obj.name).join(', '),\n                        icon: 'file_copy', type: immediate.type};\n                case 'user':\n                    return {value: immediate.value.fullName, icon: 'account_circle', type: immediate.type};\n                case 'boolean':\n                    return {value: this._translate.instant('dataField.values.boolean.' + immediate.value),\n                        icon: undefined, type: immediate.type};\n                case 'button':\n                    return {value: (immediate as any).placeholder && (immediate as any).placeholder.defaultValue !== undefined\n                            ? (immediate as any).placeholder.defaultValue : (immediate.name && immediate.name.defaultValue !== undefined\n                                ? immediate.name.defaultValue : this._translate.instant('dialog.submit')),\n                        icon: undefined, type: immediate.type};\n                case 'filter':\n                    return {value: undefined, icon: undefined, type: immediate.type,\n                        filterMetadata: {filterMetadata: immediate.filterMetadata, allowedNets: immediate.allowedNets}};\n                case 'number':\n                    if (immediate.format !== undefined) {\n                        return this.formatCurrencyPipe(immediate.value, immediate.format.code, immediate.format.fractionSize,\n                            immediate.format.locale, immediate.type);\n                    } else if (immediate.component?.name === 'currency') {\n                        return this.formatCurrencyPipe(immediate.value, immediate.component.properties['code'],\n                            immediate.component.properties['fractionSize'], immediate.component.properties['locale'], immediate.type);\n                    }\n                    return {value: immediate.value, icon: undefined, type: immediate.type};\n                default:\n                    return {value: immediate.value, icon: undefined, type: immediate.type};\n            }\n        } else {\n            return {value: '', icon: '', type: ''};\n        }\n    }\n\n    protected formatCurrencyPipe(value: any, code: string, fraction: number, locale: string, type: string) {\n        return {value:\n                this._currencyPipe.transform(\n                parseFloat(value),\n                code,\n                'symbol',\n                '1.' + fraction + '-' + fraction,\n                locale),\n                icon: undefined, type};\n    }\n}\n"]}

package/esm5/lib/panel/abstract/tabbed-virtual-scroll.component.js

@@ -0,0 +1,35 @@
+import { Inject, Optional } from '@angular/core';
+import { NAE_TAB_DATA } from '../../tabs/tab-data-injection-token/tab-data-injection-token';
+import { filter, take } from 'rxjs/operators';
+var TabbedVirtualScrollComponent = /** @class */ (function () {
+    function TabbedVirtualScrollComponent(injectedTabData) {
+        var _this = this;
+        this._showVirtualScroll = false;
+        if (injectedTabData === null) {
+            this._showVirtualScroll = true;
+        }
+        else {
+            this._sub = injectedTabData.tabSelected$.pipe(filter(function (bool) { return bool; }), take(1)).subscribe(function () {
+                _this._showVirtualScroll = true;
+            });
+        }
+    }
+    TabbedVirtualScrollComponent.prototype.ngOnDestroy = function () {
+        if (this._sub) {
+            this._sub.unsubscribe();
+        }
+    };
+    Object.defineProperty(TabbedVirtualScrollComponent.prototype, "showVirtualScroll", {
+        get: function () {
+            return this._showVirtualScroll;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TabbedVirtualScrollComponent.ctorParameters = function () { return [
+        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NAE_TAB_DATA,] }] }
+    ]; };
+    return TabbedVirtualScrollComponent;
+}());
+export { TabbedVirtualScrollComponent };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,46 @@
+import { EventEmitter, Input, Output, ViewChild } from '@angular/core';
+var AbstractPanelComponent = /** @class */ (function () {
+    function AbstractPanelComponent(_caseListFontColorService) {
+        this._caseListFontColorService = _caseListFontColorService;
+        this.expansionDisabled = false;
+        this.preventExpand = false;
+        this.stopLoading = new EventEmitter();
+        this.getExpansionPanelRef = new EventEmitter();
+    }
+    AbstractPanelComponent.prototype.ngOnDestroy = function () {
+        this.stopLoading.complete();
+        this.getExpansionPanelRef.complete();
+    };
+    AbstractPanelComponent.prototype.ngAfterViewInit = function () {
+        this.getExpansionPanelRef.emit(this.matExpansionPanel);
+    };
+    AbstractPanelComponent.prototype.emitExpand = function () {
+        this.stopLoading.emit();
+    };
+    AbstractPanelComponent.prototype.emitCollapse = function () {
+        this.stopLoading.emit();
+    };
+    AbstractPanelComponent.prototype.expandPanel = function () {
+        if (this.preventExpand) {
+            this.matExpansionPanel.close();
+        }
+    };
+    AbstractPanelComponent.prototype.getCaseFontColor = function () {
+        return this._caseListFontColorService.computeCaseFontColor(this.caseColor);
+    };
+    AbstractPanelComponent.propDecorators = {
+        expansionDisabled: [{ type: Input }],
+        preventExpand: [{ type: Input }],
+        panelHeader: [{ type: Input }],
+        panelContent: [{ type: Input }],
+        first: [{ type: Input }],
+        last: [{ type: Input }],
+        caseColor: [{ type: Input }],
+        stopLoading: [{ type: Output }],
+        getExpansionPanelRef: [{ type: Output }],
+        matExpansionPanel: [{ type: ViewChild, args: ['matExpansionPanel',] }]
+    };
+    return AbstractPanelComponent;
+}());
+export { AbstractPanelComponent };
+//# sourceMappingURL=data:application/json;base64,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