@netgrif/components-core 6.0.1

package/esm5/lib/side-menu/content-components/filter-selector/abstract-filter-selector.component.js

@@ -0,0 +1,166 @@
+import { Inject, ViewChild } from '@angular/core';
+import { NAE_SIDE_MENU_CONTROL } from '../../side-menu-injection-token';
+import { SideMenuControl } from '../../models/side-menu-control';
+import { FilterRepository } from '../../../filter/filter.repository';
+import { FilteredArray } from './model/filtered-array';
+import { FilterType } from '../../../filter/models/filter-type';
+import { FormControl } from '@angular/forms';
+/**
+ * Allows user to choose a {@link Filter} from the {@link FilterRepository}.
+ *
+ * Publishes events to the {@link SideMenuControl} object when:
+ *
+ * - filter is selected by the user. Message: `New selected filter`, Data: is either the selected filter or `undefined` if the user
+ * deselected the filter
+ *
+ * - filter selection is confirmed by the user. Message: `Selected filter was confirmed`, Data: the selected filter. If the user didn't
+ * select any filter this event will not be published.
+ *
+ */
+var AbstractFilterSelectorComponent = /** @class */ (function () {
+    /**
+     * Retrieves the {@link Filter} objects from the {@link FilterRepository} and instantiates this component.
+     *
+     * Filters that are available for selection can be set using the injected data. See {@link FilterSelectorInjectionData}
+     * for more information.
+     * @param _sideMenuControl -
+     * @param _filterRepository -
+     */
+    function AbstractFilterSelectorComponent(_sideMenuControl, _filterRepository) {
+        var _this = this;
+        this._sideMenuControl = _sideMenuControl;
+        this._filterRepository = _filterRepository;
+        /**
+         * @ignore
+         * Stores the predicate used for filtering of filters with {@linkFilteredArray}.
+         * @param item some filter from the list
+         * @param searchInput value the user is searching for
+         */
+        this._filterPredicate = function (item, searchInput) {
+            return item.title
+                ? item.title.toLocaleLowerCase().includes(searchInput.toLocaleLowerCase())
+                : item.id.toLocaleLowerCase().includes(searchInput.toLocaleLowerCase());
+        };
+        var filterConstraints = _sideMenuControl.data;
+        var caseFilters = [];
+        var taskFilters = [];
+        if (filterConstraints && filterConstraints.filterIdsConstraint) {
+            var filters = this._filterRepository.getFilters(filterConstraints.filterIdsConstraint);
+            filters.forEach(function (filter) {
+                if (filter.type === FilterType.CASE &&
+                    (!filterConstraints.filterTypeConstraint || filterConstraints.filterTypeConstraint === FilterType.CASE)) {
+                    caseFilters.push(filter);
+                }
+                else if (filter.type === FilterType.TASK &&
+                    (!filterConstraints.filterTypeConstraint || filterConstraints.filterTypeConstraint === FilterType.TASK)) {
+                    taskFilters.push(filter);
+                }
+            });
+        }
+        else {
+            if (!filterConstraints ||
+                !filterConstraints.filterTypeConstraint ||
+                filterConstraints.filterTypeConstraint === FilterType.CASE) {
+                caseFilters = this._filterRepository.getFilters(this._filterRepository.getCaseFilterList());
+            }
+            if (!filterConstraints ||
+                !filterConstraints.filterTypeConstraint ||
+                filterConstraints.filterTypeConstraint === FilterType.TASK) {
+                taskFilters = this._filterRepository.getFilters(this._filterRepository.getTaskFilterList());
+            }
+        }
+        this.caseFilters = new FilteredArray(caseFilters, this._filterPredicate);
+        this.taskFilters = new FilteredArray(taskFilters, this._filterPredicate);
+        this.searchFormControl = new FormControl();
+        this.subValue = this.searchFormControl.valueChanges.subscribe(function (newValue) { return _this.filterFilters(newValue); });
+    }
+    AbstractFilterSelectorComponent.prototype.ngOnDestroy = function () {
+        this.subValue.unsubscribe();
+    };
+    /**
+     * @ignore
+     * Changes the currently selected filter and publishes an event about this to the output stream in {@link SideMenuControl}.
+     * @param filter the newly selected filter
+     */
+    AbstractFilterSelectorComponent.prototype.filterSelected = function (filter) {
+        this._selectedFilter = filter;
+        this._sideMenuControl.publish({
+            opened: true,
+            message: 'New selected filter',
+            data: this._selectedFilter
+        });
+    };
+    /**
+     * @ignore
+     * Closes the side menu and publishes an event with the currently selected filter.
+     */
+    AbstractFilterSelectorComponent.prototype.filterSelectionConfirmed = function () {
+        if (this._selectedFilter !== undefined) {
+            this._sideMenuControl.close({
+                opened: false,
+                message: 'Selected filter was confirmed',
+                data: this._selectedFilter
+            });
+        }
+    };
+    /**
+     * @ignore
+     * Clears selection of task filters and ensures that only one case filter can be selected at once.
+     * @param event list change event published byt the material component
+     */
+    AbstractFilterSelectorComponent.prototype.caseFilterSelected = function (event) {
+        if (event.options[0].selected) {
+            this.filterSelected(event.options[0].value);
+            if (this.taskFilterList) {
+                this.taskFilterList.deselectAll();
+            }
+            // TODO 20.4.2020 - change to [multiple] input attribute on MatSelectionList in HTML,
+            //  once Covalent supports material 9.1.0 or above
+            this.caseFilterList.deselectAll();
+            event.options[0].selected = true;
+        }
+        else {
+            this.filterSelected(undefined);
+        }
+    };
+    /**
+     * @ignore
+     * Clears selection of case filters and ensures that only one task filter can be selected at once.
+     * @param event list change event published byt the material component
+     */
+    AbstractFilterSelectorComponent.prototype.taskFilterSelected = function (event) {
+        if (event.options[0].selected) {
+            this.filterSelected(event.options[0].value);
+            if (this.caseFilterList) {
+                this.caseFilterList.deselectAll();
+            }
+            // TODO 20.4.2020 - change to [multiple] input attribute on MatSelectionList in HTML,
+            //  once Covalent supports material 9.1.0 or above
+            this.taskFilterList.deselectAll();
+            event.options[0].selected = true;
+        }
+        else {
+            this.filterSelected(undefined);
+        }
+    };
+    /**
+     * @ignore
+     * Filters both lists of filters based on user search input.
+     * @param newValue user search input value
+     */
+    AbstractFilterSelectorComponent.prototype.filterFilters = function (newValue) {
+        this.caseFilters.filter(newValue);
+        this.taskFilters.filter(newValue);
+    };
+    AbstractFilterSelectorComponent.ctorParameters = function () { return [
+        { type: SideMenuControl, decorators: [{ type: Inject, args: [NAE_SIDE_MENU_CONTROL,] }] },
+        { type: FilterRepository }
+    ]; };
+    AbstractFilterSelectorComponent.propDecorators = {
+        caseFilterList: [{ type: ViewChild, args: ['caseFilterList',] }],
+        taskFilterList: [{ type: ViewChild, args: ['taskFilterList',] }]
+    };
+    return AbstractFilterSelectorComponent;
+}());
+export { AbstractFilterSelectorComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-filter-selector.component.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/side-menu/content-components/filter-selector/abstract-filter-selector.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, OnDestroy, ViewChild} from '@angular/core';\nimport {NAE_SIDE_MENU_CONTROL} from '../../side-menu-injection-token';\nimport {SideMenuControl} from '../../models/side-menu-control';\nimport {FilterRepository} from '../../../filter/filter.repository';\nimport {Filter} from '../../../filter/models/filter';\nimport {FilterSelectorInjectionData} from './model/filter-selector-injection-data';\nimport {FilteredArray} from './model/filtered-array';\nimport {FilterType} from '../../../filter/models/filter-type';\nimport {FormControl} from '@angular/forms';\nimport {MatSelectionList, MatSelectionListChange} from '@angular/material/list';\nimport {Subscription} from 'rxjs';\n\n/**\n * Allows user to choose a {@link Filter} from the {@link FilterRepository}.\n *\n * Publishes events to the {@link SideMenuControl} object when:\n *\n * - filter is selected by the user. Message: `New selected filter`, Data: is either the selected filter or `undefined` if the user\n * deselected the filter\n *\n * - filter selection is confirmed by the user. Message: `Selected filter was confirmed`, Data: the selected filter. If the user didn't\n * select any filter this event will not be published.\n *\n */\nexport abstract class AbstractFilterSelectorComponent implements OnDestroy {\n\n    /**\n     * @ignore\n     * Case filters bound to HTML\n     */\n    public caseFilters: FilteredArray<Filter>;\n    /**\n     * @ignore\n     * Task filters bound to html\n     */\n    public taskFilters: FilteredArray<Filter>;\n    /**\n     * @ignore\n     * Task filters bound to html\n     */\n    protected subValue: Subscription;\n    /**\n     * @ignore\n     * `FormControl` for the search input\n     */\n    public searchFormControl: FormControl;\n\n    /**\n     * @ignore\n     * Currently selected filter. `undefined` if no filter is selected.\n     */\n    protected _selectedFilter: Filter;\n\n    /**\n     * @ignore\n     * Reference to the `mat-selection-list` component, that holds the list of case filters.\n     */\n    @ViewChild('caseFilterList') caseFilterList: MatSelectionList;\n    /**\n     * @ignore\n     * Reference to the `mat-selection-list` component, that holds the list of task filters.\n     */\n    @ViewChild('taskFilterList') taskFilterList: MatSelectionList;\n\n    /**\n     * @ignore\n     * Stores the predicate used for filtering of filters with {@linkFilteredArray}.\n     * @param item some filter from the list\n     * @param searchInput value the user is searching for\n     */\n    protected _filterPredicate = (item: Filter, searchInput: string) => {\n        return item.title\n        ? item.title.toLocaleLowerCase().includes(searchInput.toLocaleLowerCase())\n        : item.id.toLocaleLowerCase().includes(searchInput.toLocaleLowerCase());\n    }\n\n    /**\n     * Retrieves the {@link Filter} objects from the {@link FilterRepository} and instantiates this component.\n     *\n     * Filters that are available for selection can be set using the injected data. See {@link FilterSelectorInjectionData}\n     * for more information.\n     * @param _sideMenuControl -\n     * @param _filterRepository -\n     */\n    constructor(@Inject(NAE_SIDE_MENU_CONTROL) protected _sideMenuControl: SideMenuControl,\n                protected _filterRepository: FilterRepository) {\n        const filterConstraints = _sideMenuControl.data as FilterSelectorInjectionData;\n\n        let caseFilters = [];\n        let taskFilters = [];\n        if (filterConstraints && filterConstraints.filterIdsConstraint) {\n            const filters = this._filterRepository.getFilters(filterConstraints.filterIdsConstraint);\n            filters.forEach(filter => {\n                if (filter.type === FilterType.CASE &&\n                    (!filterConstraints.filterTypeConstraint || filterConstraints.filterTypeConstraint === FilterType.CASE)) {\n                    caseFilters.push(filter);\n                } else if (filter.type === FilterType.TASK &&\n                    (!filterConstraints.filterTypeConstraint || filterConstraints.filterTypeConstraint === FilterType.TASK)) {\n                    taskFilters.push(filter);\n                }\n            });\n        } else {\n            if (!filterConstraints ||\n                !filterConstraints.filterTypeConstraint ||\n                filterConstraints.filterTypeConstraint === FilterType.CASE) {\n                caseFilters = this._filterRepository.getFilters(this._filterRepository.getCaseFilterList());\n            }\n            if (!filterConstraints ||\n                !filterConstraints.filterTypeConstraint ||\n                filterConstraints.filterTypeConstraint === FilterType.TASK) {\n                taskFilters = this._filterRepository.getFilters(this._filterRepository.getTaskFilterList());\n            }\n        }\n\n        this.caseFilters = new FilteredArray<Filter>(caseFilters, this._filterPredicate);\n        this.taskFilters = new FilteredArray<Filter>(taskFilters, this._filterPredicate);\n\n        this.searchFormControl = new FormControl();\n        this.subValue = this.searchFormControl.valueChanges.subscribe(newValue => this.filterFilters(newValue));\n    }\n\n    ngOnDestroy(): void {\n        this.subValue.unsubscribe();\n    }\n\n    /**\n     * @ignore\n     * Changes the currently selected filter and publishes an event about this to the output stream in {@link SideMenuControl}.\n     * @param filter the newly selected filter\n     */\n    public filterSelected(filter: Filter): void {\n        this._selectedFilter = filter;\n        this._sideMenuControl.publish({\n            opened: true,\n            message: 'New selected filter',\n            data: this._selectedFilter\n        });\n    }\n\n    /**\n     * @ignore\n     * Closes the side menu and publishes an event with the currently selected filter.\n     */\n    public filterSelectionConfirmed(): void {\n        if (this._selectedFilter !== undefined) {\n            this._sideMenuControl.close({\n                opened: false,\n                message: 'Selected filter was confirmed',\n                data: this._selectedFilter\n            });\n        }\n    }\n\n    /**\n     * @ignore\n     * Clears selection of task filters and ensures that only one case filter can be selected at once.\n     * @param event list change event published byt the material component\n     */\n    public caseFilterSelected(event: MatSelectionListChange): void {\n        if (event.options[0].selected) {\n            this.filterSelected(event.options[0].value);\n            if (this.taskFilterList) {\n                this.taskFilterList.deselectAll();\n            }\n            // TODO 20.4.2020 - change to [multiple] input attribute on MatSelectionList in HTML,\n            //  once Covalent supports material 9.1.0 or above\n            this.caseFilterList.deselectAll();\n            event.options[0].selected = true;\n        } else {\n            this.filterSelected(undefined);\n        }\n    }\n\n    /**\n     * @ignore\n     * Clears selection of case filters and ensures that only one task filter can be selected at once.\n     * @param event list change event published byt the material component\n     */\n    public taskFilterSelected(event: MatSelectionListChange): void {\n        if (event.options[0].selected) {\n            this.filterSelected(event.options[0].value);\n            if (this.caseFilterList) {\n                this.caseFilterList.deselectAll();\n            }\n            // TODO 20.4.2020 - change to [multiple] input attribute on MatSelectionList in HTML,\n            //  once Covalent supports material 9.1.0 or above\n            this.taskFilterList.deselectAll();\n            event.options[0].selected = true;\n        } else {\n            this.filterSelected(undefined);\n        }\n    }\n\n    /**\n     * @ignore\n     * Filters both lists of filters based on user search input.\n     * @param newValue user search input value\n     */\n    public filterFilters(newValue: string): void {\n        this.caseFilters.filter(newValue);\n        this.taskFilters.filter(newValue);\n    }\n}\n"]}

package/esm5/lib/side-menu/content-components/filter-selector/filter-selector-list-item/abstract-filter-selector-list-item.component.js

@@ -0,0 +1,26 @@
+import { Input } from '@angular/core';
+/**
+ * @ignore
+ * Renders a single filter in the selection list.
+ */
+var AbstractFilterSelectorListItemComponent = /** @class */ (function () {
+    function AbstractFilterSelectorListItemComponent() {
+    }
+    /**
+     * Sets the text bound to HTML, to either the filter title (if it exists), or to it's ID.
+     */
+    AbstractFilterSelectorListItemComponent.prototype.ngOnInit = function () {
+        if (this.filter.title) {
+            this.text = this.filter.title;
+        }
+        else {
+            this.text = this.filter.id;
+        }
+    };
+    AbstractFilterSelectorListItemComponent.propDecorators = {
+        filter: [{ type: Input }]
+    };
+    return AbstractFilterSelectorListItemComponent;
+}());
+export { AbstractFilterSelectorListItemComponent };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3QtZmlsdGVyLXNlbGVjdG9yLWxpc3QtaXRlbS5jb21wb25lbnQuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvc2lkZS1tZW51L2NvbnRlbnQtY29tcG9uZW50cy9maWx0ZXItc2VsZWN0b3IvZmlsdGVyLXNlbGVjdG9yLWxpc3QtaXRlbS9hYnN0cmFjdC1maWx0ZXItc2VsZWN0b3ItbGlzdC1pdGVtLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsS0FBSyxFQUFTLE1BQU0sZUFBZSxDQUFDO0FBRzVDOzs7R0FHRztBQUNIO0lBQUE7SUFzQkEsQ0FBQztJQVhHOztPQUVHO0lBQ0gsMERBQVEsR0FBUjtRQUNJLElBQUksSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLEVBQUU7WUFDbkIsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQztTQUNqQzthQUFNO1lBQ0gsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQztTQUM5QjtJQUNMLENBQUM7O3lCQWZBLEtBQUs7O0lBaUJWLDhDQUFDO0NBQUEsQUF0QkQsSUFzQkM7U0F0QnFCLHVDQUF1QyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7SW5wdXQsIE9uSW5pdH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge0ZpbHRlcn0gZnJvbSAnLi4vLi4vLi4vLi4vZmlsdGVyL21vZGVscy9maWx0ZXInO1xuXG4vKipcbiAqIEBpZ25vcmVcbiAqIFJlbmRlcnMgYSBzaW5nbGUgZmlsdGVyIGluIHRoZSBzZWxlY3Rpb24gbGlzdC5cbiAqL1xuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEFic3RyYWN0RmlsdGVyU2VsZWN0b3JMaXN0SXRlbUNvbXBvbmVudCBpbXBsZW1lbnRzIE9uSW5pdCB7XG5cbiAgICAvKipcbiAgICAgKiBGaWx0ZXIgdGhhdCBzaG91bGQgYmUgcmVuZGVyZWRcbiAgICAgKi9cbiAgICBASW5wdXQoKSBmaWx0ZXI6IEZpbHRlcjtcbiAgICAvKipcbiAgICAgKiBUZXh0IHRoYXQgaXMgYm91bmQgdG8gSFRNTFxuICAgICAqL1xuICAgIHB1YmxpYyB0ZXh0OiBzdHJpbmc7XG5cbiAgICAvKipcbiAgICAgKiBTZXRzIHRoZSB0ZXh0IGJvdW5kIHRvIEhUTUwsIHRvIGVpdGhlciB0aGUgZmlsdGVyIHRpdGxlIChpZiBpdCBleGlzdHMpLCBvciB0byBpdCdzIElELlxuICAgICAqL1xuICAgIG5nT25Jbml0KCk6IHZvaWQge1xuICAgICAgICBpZiAodGhpcy5maWx0ZXIudGl0bGUpIHtcbiAgICAgICAgICAgIHRoaXMudGV4dCA9IHRoaXMuZmlsdGVyLnRpdGxlO1xuICAgICAgICB9IGVsc2Uge1xuICAgICAgICAgICAgdGhpcy50ZXh0ID0gdGhpcy5maWx0ZXIuaWQ7XG4gICAgICAgIH1cbiAgICB9XG5cbn1cbiJdfQ==

package/esm5/lib/side-menu/content-components/filter-selector/model/filter-selector-injection-data.js

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

package/esm5/lib/side-menu/content-components/filter-selector/model/filtered-array.js

@@ -0,0 +1,37 @@
+import { __read, __spread } from "tslib";
+/**
+ * Simple class that generalizes filtering of array of elements.
+ * Filtered Results are contained in a separate array and can be bound to HTML.
+ * @typeparam T type of elements contained in the arrays.
+ */
+var FilteredArray = /** @class */ (function () {
+    /**
+     * @param _unfiltered elements that can be filtered
+     * @param _filterPredicate predicate that is used to filter elements of the provided array. It should return `true` if `item` with
+     * the given `data` should appear in the filtered array.
+     */
+    function FilteredArray(_unfiltered, _filterPredicate) {
+        var _a;
+        this._unfiltered = _unfiltered;
+        this._filterPredicate = _filterPredicate;
+        this.filtered = [];
+        (_a = this.filtered).push.apply(_a, __spread(this._unfiltered));
+    }
+    /**
+     * Applies the filter predicate on all items of the unfiltered array.
+     * Each item that returns `true` will be included in the filtered array.
+     * @param data data that is sent to the {@link FilteredArray#_filterPredicate} for evaluation
+     */
+    FilteredArray.prototype.filter = function (data) {
+        var _this = this;
+        this.filtered.splice(0, this.filtered.length);
+        this._unfiltered.forEach(function (item) {
+            if (_this._filterPredicate(item, data)) {
+                _this.filtered.push(item);
+            }
+        });
+    };
+    return FilteredArray;
+}());
+export { FilteredArray };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsdGVyZWQtYXJyYXkuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvc2lkZS1tZW51L2NvbnRlbnQtY29tcG9uZW50cy9maWx0ZXItc2VsZWN0b3IvbW9kZWwvZmlsdGVyZWQtYXJyYXkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7O0dBSUc7QUFDSDtJQU9JOzs7O09BSUc7SUFDSCx1QkFBb0IsV0FBcUIsRUFBVSxnQkFBaUQ7O1FBQWhGLGdCQUFXLEdBQVgsV0FBVyxDQUFVO1FBQVUscUJBQWdCLEdBQWhCLGdCQUFnQixDQUFpQztRQUNoRyxJQUFJLENBQUMsUUFBUSxHQUFHLEVBQUUsQ0FBQztRQUNuQixDQUFBLEtBQUEsSUFBSSxDQUFDLFFBQVEsQ0FBQSxDQUFDLElBQUksb0JBQUksSUFBSSxDQUFDLFdBQVcsR0FBRTtJQUM1QyxDQUFDO0lBRUQ7Ozs7T0FJRztJQUNJLDhCQUFNLEdBQWIsVUFBYyxJQUFTO1FBQXZCLGlCQU9DO1FBTkcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUMsQ0FBQyxFQUFFLElBQUksQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUFDLENBQUM7UUFDOUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxPQUFPLENBQUMsVUFBQSxJQUFJO1lBQ3pCLElBQUksS0FBSSxDQUFDLGdCQUFnQixDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsRUFBRTtnQkFDbkMsS0FBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7YUFDNUI7UUFDTCxDQUFDLENBQUMsQ0FBQztJQUNQLENBQUM7SUFDTCxvQkFBQztBQUFELENBQUMsQUE5QkQsSUE4QkMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFNpbXBsZSBjbGFzcyB0aGF0IGdlbmVyYWxpemVzIGZpbHRlcmluZyBvZiBhcnJheSBvZiBlbGVtZW50cy5cbiAqIEZpbHRlcmVkIFJlc3VsdHMgYXJlIGNvbnRhaW5lZCBpbiBhIHNlcGFyYXRlIGFycmF5IGFuZCBjYW4gYmUgYm91bmQgdG8gSFRNTC5cbiAqIEB0eXBlcGFyYW0gVCB0eXBlIG9mIGVsZW1lbnRzIGNvbnRhaW5lZCBpbiB0aGUgYXJyYXlzLlxuICovXG5leHBvcnQgY2xhc3MgRmlsdGVyZWRBcnJheTxUPiB7XG5cbiAgICAvKipcbiAgICAgKiBDb250YWlucyBhbGwgdGhlIGVsZW1lbnRzIGZyb20gdGhlIHByb3ZpZGVkIGFycmF5LCB0aGF0IG1hdGNoIHRoZSBwcm92aWRlZCBwcmVkaWNhdGUuXG4gICAgICovXG4gICAgcHVibGljIGZpbHRlcmVkOiBBcnJheTxUPjtcblxuICAgIC8qKlxuICAgICAqIEBwYXJhbSBfdW5maWx0ZXJlZCBlbGVtZW50cyB0aGF0IGNhbiBiZSBmaWx0ZXJlZFxuICAgICAqIEBwYXJhbSBfZmlsdGVyUHJlZGljYXRlIHByZWRpY2F0ZSB0aGF0IGlzIHVzZWQgdG8gZmlsdGVyIGVsZW1lbnRzIG9mIHRoZSBwcm92aWRlZCBhcnJheS4gSXQgc2hvdWxkIHJldHVybiBgdHJ1ZWAgaWYgYGl0ZW1gIHdpdGhcbiAgICAgKiB0aGUgZ2l2ZW4gYGRhdGFgIHNob3VsZCBhcHBlYXIgaW4gdGhlIGZpbHRlcmVkIGFycmF5LlxuICAgICAqL1xuICAgIGNvbnN0cnVjdG9yKHByaXZhdGUgX3VuZmlsdGVyZWQ6IEFycmF5PFQ+LCBwcml2YXRlIF9maWx0ZXJQcmVkaWNhdGU6IChpdGVtOiBULCBkYXRhOiBhbnkpID0+IGJvb2xlYW4pIHtcbiAgICAgICAgdGhpcy5maWx0ZXJlZCA9IFtdO1xuICAgICAgICB0aGlzLmZpbHRlcmVkLnB1c2goLi4udGhpcy5fdW5maWx0ZXJlZCk7XG4gICAgfVxuXG4gICAgLyoqXG4gICAgICogQXBwbGllcyB0aGUgZmlsdGVyIHByZWRpY2F0ZSBvbiBhbGwgaXRlbXMgb2YgdGhlIHVuZmlsdGVyZWQgYXJyYXkuXG4gICAgICogRWFjaCBpdGVtIHRoYXQgcmV0dXJucyBgdHJ1ZWAgd2lsbCBiZSBpbmNsdWRlZCBpbiB0aGUgZmlsdGVyZWQgYXJyYXkuXG4gICAgICogQHBhcmFtIGRhdGEgZGF0YSB0aGF0IGlzIHNlbnQgdG8gdGhlIHtAbGluayBGaWx0ZXJlZEFycmF5I19maWx0ZXJQcmVkaWNhdGV9IGZvciBldmFsdWF0aW9uXG4gICAgICovXG4gICAgcHVibGljIGZpbHRlcihkYXRhOiBhbnkpOiB2b2lkIHtcbiAgICAgICAgdGhpcy5maWx0ZXJlZC5zcGxpY2UoMCwgdGhpcy5maWx0ZXJlZC5sZW5ndGgpO1xuICAgICAgICB0aGlzLl91bmZpbHRlcmVkLmZvckVhY2goaXRlbSA9PiB7XG4gICAgICAgICAgICBpZiAodGhpcy5fZmlsdGVyUHJlZGljYXRlKGl0ZW0sIGRhdGEpKSB7XG4gICAgICAgICAgICAgICAgdGhpcy5maWx0ZXJlZC5wdXNoKGl0ZW0pO1xuICAgICAgICAgICAgfVxuICAgICAgICB9KTtcbiAgICB9XG59XG4iXX0=

package/esm5/lib/side-menu/content-components/import-net/abstract-import-net.component.js

@@ -0,0 +1,152 @@
+import { __values } from "tslib";
+import { FormControl } from '@angular/forms';
+import { ProgressType } from '../../../resources/resource-provider.service';
+var FileUploadModel = /** @class */ (function () {
+    function FileUploadModel() {
+    }
+    return FileUploadModel;
+}());
+export { FileUploadModel };
+var AbstractImportNetComponent = /** @class */ (function () {
+    function AbstractImportNetComponent(_sideMenuControl, _petriNetResource, _log, _snackbar, _translate) {
+        this._sideMenuControl = _sideMenuControl;
+        this._petriNetResource = _petriNetResource;
+        this._log = _log;
+        this._snackbar = _snackbar;
+        this._translate = _translate;
+        this.files = {};
+        this.releaseTypes = ['Major', 'Minor', 'Patch'];
+        this.releaseTypeControl = new FormControl(this.releaseTypes[0]);
+        this._response = undefined;
+    }
+    AbstractImportNetComponent.prototype.ngOnInit = function () {
+    };
+    AbstractImportNetComponent.prototype.ngAfterViewInit = function () {
+        var _this = this;
+        this._fileInput = document.getElementById('sidemenu-fileUpload');
+        this._fileInput.onchange = function () {
+            var e_1, _a;
+            try {
+                for (var _b = __values(Array.from(Array(_this._fileInput.files.length).keys())), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var fileIndex = _c.value;
+                    var file = _this._fileInput.files[fileIndex];
+                    if (_this.files[file.name]) {
+                        var knownFile = _this.files[file.name].data;
+                        if (knownFile.type !== file.type || knownFile.lastModified !== file.lastModified) {
+                            _this.files[file.name] = _this.setupFile(file);
+                        }
+                    }
+                    else {
+                        _this.files[file.name] = _this.setupFile(file);
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            _this.uploadFiles();
+        };
+    };
+    Object.defineProperty(AbstractImportNetComponent.prototype, "fileList", {
+        get: function () {
+            return Object.values(this.files);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AbstractImportNetComponent.prototype, "isAllFinished", {
+        get: function () {
+            return Object.values(this.files).every(function (file) { return !file.inProgress && file.progress === 100; });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AbstractImportNetComponent.prototype.onProcessFileChosen = function () {
+        if (this._fileInput) {
+            this._fileInput.click();
+        }
+    };
+    AbstractImportNetComponent.prototype.cancelFile = function (file) {
+        file.sub.unsubscribe();
+        this.removeFile(file);
+    };
+    AbstractImportNetComponent.prototype.retryFile = function (file) {
+        this.uploadFile(file);
+    };
+    AbstractImportNetComponent.prototype.close = function () {
+        this._sideMenuControl.close({
+            opened: false,
+            message: 'All process files were processed',
+            data: this._response ? { net: this._response.net } : undefined
+        });
+    };
+    AbstractImportNetComponent.prototype.setupFile = function (file) {
+        return {
+            data: file, stringId: '', downloading: false, inProgress: false, progress: 0, completed: false, uploaded: false
+        };
+    };
+    AbstractImportNetComponent.prototype.uploadFiles = function () {
+        var _this = this;
+        this._fileInput.value = '';
+        this.fileList.filter(function (fileModel) { return !fileModel.completed && fileModel.progress === 0; }).forEach(function (file) {
+            _this.uploadFile(file);
+        });
+    };
+    AbstractImportNetComponent.prototype.removeFile = function (file) {
+        if (this.files[file.data.name]) {
+            delete this.files[file.data.name];
+            this._sideMenuControl.publish({
+                opened: true,
+                message: 'Process ' + file.data.name + ' was deleted from the list',
+                data: file
+            });
+        }
+    };
+    AbstractImportNetComponent.prototype.uploadFile = function (file) {
+        var _this = this;
+        var fileFormData = new FormData();
+        fileFormData.append('file', file.data);
+        fileFormData.append('meta', this.releaseTypeControl.value.toString().toUpperCase());
+        file.inProgress = true;
+        file.completed = false;
+        file.error = false;
+        file.sub = this._petriNetResource.importPetriNet(fileFormData).subscribe(function (response) {
+            if (response.type && response.type === ProgressType.UPLOAD) {
+                file.progress = response.progress;
+                if (file.progress === 100) {
+                    file.uploaded = true;
+                }
+            }
+            else {
+                _this._log.info(response.success);
+                _this._response = response.outcome;
+                file.inProgress = false;
+                file.completed = true;
+                _this._snackbar.openSuccessSnackBar(response.outcome.message === undefined
+                    ? _this._translate.instant('workflow.snackBar.uploadSuccess')
+                    : response.outcome.message);
+                _this._sideMenuControl.publish({
+                    opened: true,
+                    message: response.outcome.message === undefined
+                        ? 'Process ' + file.data.name + ' successfully uploaded'
+                        : response.outcome.message,
+                    data: { net: response.outcome.net }
+                });
+            }
+        }, function (error) {
+            var _a, _b;
+            file.inProgress = false;
+            file.completed = false;
+            file.error = true;
+            _this._log.error('Importing process file has failed!', error);
+            _this._snackbar.openErrorSnackBar(_this._translate.instant('workflow.snackBar.uploadFailed') + " " + ((_b = (_a = error === null || error === void 0 ? void 0 : error.error) === null || _a === void 0 ? void 0 : _a.message) !== null && _b !== void 0 ? _b : ''));
+        });
+    };
+    return AbstractImportNetComponent;
+}());
+export { AbstractImportNetComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-import-net.component.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/side-menu/content-components/import-net/abstract-import-net.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {AfterViewInit, OnInit} from '@angular/core';\nimport {FormControl} from '@angular/forms';\nimport {SideMenuControl} from '../../models/side-menu-control';\nimport {PetriNetResourceService} from '../../../resources/engine-endpoint/petri-net-resource.service';\nimport {LoggerService} from '../../../logger/services/logger.service';\nimport {EventOutcomeMessageResource} from '../../../resources/interface/message-resource';\nimport {ProgressType, ProviderProgress} from '../../../resources/resource-provider.service';\nimport {SnackBarService} from '../../../snack-bar/services/snack-bar.service';\nimport {FileUploadDataModel} from '../../../data-fields/file-field/models/file-field';\nimport {Subscription} from 'rxjs';\nimport {TranslateService} from '@ngx-translate/core';\nimport {PetriNetEventOutcome} from '../../../event/model/event-outcomes/petrinet-outcomes/petri-net-event-outcome';\n\nexport class FileUploadModel {\n    stringId: string;\n    data: File | FileUploadDataModel;\n    inProgress: boolean;\n    progress: number;\n    completed: boolean;\n    error?: boolean;\n    uploaded?: boolean;\n    downloading: boolean;\n    sub?: Subscription;\n}\n\ninterface FileList {\n    [key: string]: FileUploadModel;\n}\n\nexport abstract class AbstractImportNetComponent implements OnInit, AfterViewInit {\n\n    public files: FileList = {};\n    public releaseTypes: Array<string> = ['Major', 'Minor', 'Patch'];\n    public releaseTypeControl = new FormControl(this.releaseTypes[0]);\n\n    protected _response: PetriNetEventOutcome = undefined;\n    protected _fileInput: HTMLInputElement;\n\n    constructor(protected _sideMenuControl: SideMenuControl,\n                protected _petriNetResource: PetriNetResourceService,\n                protected _log: LoggerService,\n                protected _snackbar: SnackBarService,\n                protected _translate: TranslateService) {\n    }\n\n    ngOnInit() {\n    }\n\n    ngAfterViewInit(): void {\n        this._fileInput = document.getElementById('sidemenu-fileUpload') as HTMLInputElement;\n        this._fileInput.onchange = () => {\n            for (const fileIndex of Array.from(Array(this._fileInput.files.length).keys())) {\n                const file = this._fileInput.files[fileIndex];\n                if (this.files[file.name]) {\n                    const knownFile = this.files[file.name].data as File;\n                    if (knownFile.type !== file.type || knownFile.lastModified !== file.lastModified) {\n                        this.files[file.name] = this.setupFile(file);\n                    }\n                } else {\n                    this.files[file.name] = this.setupFile(file);\n                }\n            }\n            this.uploadFiles();\n        };\n    }\n\n    get fileList(): Array<FileUploadModel> {\n        return Object.values(this.files);\n    }\n\n    get isAllFinished(): boolean {\n        return Object.values(this.files).every(file => !file.inProgress && file.progress === 100);\n    }\n\n    public onProcessFileChosen() {\n        if (this._fileInput) {\n            this._fileInput.click();\n        }\n    }\n\n    public cancelFile(file: FileUploadModel) {\n        file.sub.unsubscribe();\n        this.removeFile(file);\n    }\n\n    public retryFile(file: FileUploadModel) {\n        this.uploadFile(file);\n    }\n\n    public close(): void {\n        this._sideMenuControl.close({\n            opened: false,\n            message: 'All process files were processed',\n            data: this._response ? { net: this._response.net } : undefined\n        });\n    }\n\n    protected setupFile(file: File): FileUploadModel {\n        return {\n            data: file, stringId: '', downloading: false, inProgress: false, progress: 0, completed: false, uploaded: false\n        };\n    }\n\n    protected uploadFiles() {\n        this._fileInput.value = '';\n\n        this.fileList.filter(fileModel => !fileModel.completed && fileModel.progress === 0).forEach(file => {\n            this.uploadFile(file);\n        });\n    }\n\n    protected removeFile(file: FileUploadModel) {\n        if (this.files[file.data.name]) {\n            delete this.files[file.data.name];\n            this._sideMenuControl.publish({\n                opened: true,\n                message: 'Process ' + file.data.name + ' was deleted from the list',\n                data: file\n            });\n        }\n    }\n\n    protected uploadFile(file: FileUploadModel) {\n        const fileFormData = new FormData();\n        fileFormData.append('file', file.data as File);\n        fileFormData.append('meta', this.releaseTypeControl.value.toString().toUpperCase());\n\n        file.inProgress = true;\n        file.completed = false;\n        file.error = false;\n        file.sub = this._petriNetResource.importPetriNet(fileFormData).subscribe((response: EventOutcomeMessageResource) => {\n            if ((response as ProviderProgress).type && (response as ProviderProgress).type === ProgressType.UPLOAD) {\n                file.progress = (response as ProviderProgress).progress;\n                if (file.progress === 100) {\n                    file.uploaded = true;\n                }\n            } else {\n                this._log.info(response.success);\n                this._response = response.outcome as PetriNetEventOutcome;\n                file.inProgress = false;\n                file.completed = true;\n                this._snackbar.openSuccessSnackBar(response.outcome.message === undefined\n                    ? this._translate.instant('workflow.snackBar.uploadSuccess')\n                    : response.outcome.message);\n                this._sideMenuControl.publish({\n                    opened: true,\n                    message: response.outcome.message === undefined\n                        ? 'Process ' + file.data.name + ' successfully uploaded'\n                        : response.outcome.message\n                    ,\n                    data: {net: (response.outcome as PetriNetEventOutcome).net}\n                });\n            }\n        }, error => {\n            file.inProgress = false;\n            file.completed = false;\n            file.error = true;\n            this._log.error('Importing process file has failed!', error);\n            this._snackbar.openErrorSnackBar(\n                `${this._translate.instant('workflow.snackBar.uploadFailed')} ${error?.error?.message ?? ''}`);\n        });\n    }\n\n}\n"]}

package/esm5/lib/side-menu/content-components/injection-tokens.js

@@ -0,0 +1,8 @@
+import { InjectionToken } from '@angular/core';
+export var NAE_USER_ASSIGN_COMPONENT = new InjectionToken('NaeUserAssignComponent');
+export var NAE_FILES_UPLOAD_COMPONENT = new InjectionToken('NaeFilesUploadComponent');
+export var NAE_NEW_CASE_COMPONENT = new InjectionToken('NaeNewCaseComponent');
+export var NAE_OPTION_SELECTOR_COMPONENT = new InjectionToken('NaeOptionSelectorComponent');
+export var NAE_SAVE_FILTER_COMPONENT = new InjectionToken('NaeSaveFilterComponent');
+export var NAE_LOAD_FILTER_COMPONENT = new InjectionToken('NaeLoadFilterComponent');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5qZWN0aW9uLXRva2Vucy5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9zaWRlLW1lbnUvY29udGVudC1jb21wb25lbnRzL2luamVjdGlvbi10b2tlbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLGNBQWMsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUc3QyxNQUFNLENBQUMsSUFBTSx5QkFBeUIsR0FBRyxJQUFJLGNBQWMsQ0FBeUIsd0JBQXdCLENBQUMsQ0FBQztBQUM5RyxNQUFNLENBQUMsSUFBTSwwQkFBMEIsR0FBRyxJQUFJLGNBQWMsQ0FBeUIseUJBQXlCLENBQUMsQ0FBQztBQUNoSCxNQUFNLENBQUMsSUFBTSxzQkFBc0IsR0FBRyxJQUFJLGNBQWMsQ0FBeUIscUJBQXFCLENBQUMsQ0FBQztBQUN4RyxNQUFNLENBQUMsSUFBTSw2QkFBNkIsR0FBRyxJQUFJLGNBQWMsQ0FBeUIsNEJBQTRCLENBQUMsQ0FBQztBQUN0SCxNQUFNLENBQUMsSUFBTSx5QkFBeUIsR0FBRyxJQUFJLGNBQWMsQ0FBeUIsd0JBQXdCLENBQUMsQ0FBQztBQUM5RyxNQUFNLENBQUMsSUFBTSx5QkFBeUIsR0FBRyxJQUFJLGNBQWMsQ0FBeUIsd0JBQXdCLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7SW5qZWN0aW9uVG9rZW59IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHtDb21wb25lbnRUeXBlfSBmcm9tICdAYW5ndWxhci9jZGsvcG9ydGFsJztcblxuZXhwb3J0IGNvbnN0IE5BRV9VU0VSX0FTU0lHTl9DT01QT05FTlQgPSBuZXcgSW5qZWN0aW9uVG9rZW48Q29tcG9uZW50VHlwZTx1bmtub3duPj4oJ05hZVVzZXJBc3NpZ25Db21wb25lbnQnKTtcbmV4cG9ydCBjb25zdCBOQUVfRklMRVNfVVBMT0FEX0NPTVBPTkVOVCA9IG5ldyBJbmplY3Rpb25Ub2tlbjxDb21wb25lbnRUeXBlPHVua25vd24+PignTmFlRmlsZXNVcGxvYWRDb21wb25lbnQnKTtcbmV4cG9ydCBjb25zdCBOQUVfTkVXX0NBU0VfQ09NUE9ORU5UID0gbmV3IEluamVjdGlvblRva2VuPENvbXBvbmVudFR5cGU8dW5rbm93bj4+KCdOYWVOZXdDYXNlQ29tcG9uZW50Jyk7XG5leHBvcnQgY29uc3QgTkFFX09QVElPTl9TRUxFQ1RPUl9DT01QT05FTlQgPSBuZXcgSW5qZWN0aW9uVG9rZW48Q29tcG9uZW50VHlwZTx1bmtub3duPj4oJ05hZU9wdGlvblNlbGVjdG9yQ29tcG9uZW50Jyk7XG5leHBvcnQgY29uc3QgTkFFX1NBVkVfRklMVEVSX0NPTVBPTkVOVCA9IG5ldyBJbmplY3Rpb25Ub2tlbjxDb21wb25lbnRUeXBlPHVua25vd24+PignTmFlU2F2ZUZpbHRlckNvbXBvbmVudCcpO1xuZXhwb3J0IGNvbnN0IE5BRV9MT0FEX0ZJTFRFUl9DT01QT05FTlQgPSBuZXcgSW5qZWN0aW9uVG9rZW48Q29tcG9uZW50VHlwZTx1bmtub3duPj4oJ05hZUxvYWRGaWx0ZXJDb21wb25lbnQnKTtcbiJdfQ==

package/esm5/lib/side-menu/content-components/load-filter/abstract-load-filter.component.js

@@ -0,0 +1,47 @@
+import { __extends } from "tslib";
+import { Inject } from '@angular/core';
+import { NAE_SIDE_MENU_CONTROL } from '../../side-menu-injection-token';
+import { SideMenuControl } from '../../models/side-menu-control';
+import { LoggerService } from '../../../logger/services/logger.service';
+import { AbstractCaseView } from '../../../view/case-view/abstract-case-view';
+import { CaseViewService } from '../../../view/case-view/service/case-view-service';
+import { getImmediateData } from '../../../utility/get-immediate-data';
+import { UserFilterConstants } from '../../../filter/models/user-filter-constants';
+import { SimpleFilter } from '../../../filter/models/simple-filter';
+var AbstractLoadFilterComponent = /** @class */ (function (_super) {
+    __extends(AbstractLoadFilterComponent, _super);
+    function AbstractLoadFilterComponent(_sideMenuControl, _log, caseViewService) {
+        var _this = _super.call(this, caseViewService) || this;
+        _this._sideMenuControl = _sideMenuControl;
+        _this._log = _log;
+        if (_this._sideMenuControl.data) {
+            _this._injectedData = _this._sideMenuControl.data;
+        }
+        return _this;
+    }
+    AbstractLoadFilterComponent.prototype.handleCaseClick = function (clickedCase) {
+        var immediate = getImmediateData(clickedCase, UserFilterConstants.FILTER_FIELD_ID);
+        this._sideMenuControl.close({
+            opened: false,
+            message: 'Filter selected',
+            data: {
+                allowedNets: immediate.allowedNets,
+                filterMetadata: immediate.filterMetadata,
+                originViewId: getImmediateData(clickedCase, UserFilterConstants.ORIGIN_VIEW_ID_FIELD_ID).value,
+                filterCase: clickedCase,
+                filterCaseId: clickedCase.stringId,
+                filter: new SimpleFilter(clickedCase.stringId, immediate.filterMetadata.filterType, {
+                    query: immediate.value
+                }, clickedCase.title)
+            }
+        });
+    };
+    AbstractLoadFilterComponent.ctorParameters = function () { return [
+        { type: SideMenuControl, decorators: [{ type: Inject, args: [NAE_SIDE_MENU_CONTROL,] }] },
+        { type: LoggerService },
+        { type: CaseViewService }
+    ]; };
+    return AbstractLoadFilterComponent;
+}(AbstractCaseView));
+export { AbstractLoadFilterComponent };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/side-menu/content-components/load-filter/model/load-filter-injection-data.js

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