@netgrif/components-core 6.0.1

package/esm2015/lib/search/search-service/search.service.js

@@ -0,0 +1,306 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { BooleanOperator } from '../models/boolean-operator';
+import { Filter } from '../../filter/models/filter';
+import { BehaviorSubject, forkJoin, Observable, Subject } from 'rxjs';
+import { SimpleFilter } from '../../filter/models/simple-filter';
+import { MergeOperator } from '../../filter/models/merge-operator';
+import { distinctUntilChanged, map, tap } from 'rxjs/operators';
+import { EditableClausePredicateWithGenerators } from '../models/predicate/editable-clause-predicate-with-generators';
+import { NAE_BASE_FILTER } from '../models/base-filter-injection-token';
+import { LoggerService } from '../../logger/services/logger.service';
+import { CategoryFactory } from '../category-factory/category-factory';
+import { LoadingEmitter } from '../../utility/loading-emitter';
+/**
+ * Holds information about the filter that is currently applied to the view component, that provides this services.
+ */
+export class SearchService {
+    /**
+     * The {@link Predicate} tree root uses an [AND]{@link BooleanOperator#AND} operator to combine the Predicates.
+     * @param _log {@link LoggerService}
+     * @param _categoryFactory a {@link CategoryFactory} instance. This dependency is optional.
+     * It is required if we want to load predicate filter from saved metadata
+     * @param baseFilter Filter that should be applied to the view when no searching is being performed.
+     * Injected trough the {@link NAE_BASE_FILTER} injection token.
+     */
+    constructor(_log, _categoryFactory, baseFilter) {
+        this._log = _log;
+        this._categoryFactory = _categoryFactory;
+        if (baseFilter.filter instanceof Filter) {
+            this._baseFilter = baseFilter.filter.clone();
+        }
+        else if (baseFilter.filter instanceof Observable) {
+            this._baseFilter = new SimpleFilter('', baseFilter.filterType, { process: { identifier: '__EMPTY__' } });
+        }
+        else {
+            throw new Error('Unsupported BaseFilter input! You must provide the NAE_BASE_FILTER injection token with proper values!');
+        }
+        this._predicateQueryChanged$ = new Subject();
+        this._rootPredicate = new EditableClausePredicateWithGenerators(BooleanOperator.AND, this._predicateQueryChanged$, undefined, true);
+        this._activeFilter = new BehaviorSubject(this._baseFilter);
+        this._predicateRemoved$ = new Subject();
+        this._loadingFromMetadata$ = new LoadingEmitter();
+        if (baseFilter.filter instanceof Observable) {
+            this.subFilter = baseFilter.filter.subscribe((filter) => {
+                this._baseFilter = filter.clone();
+                this.updateActiveFilter();
+            });
+        }
+        this.predicateQueryChanged$.subscribe(() => {
+            this.updateActiveFilter();
+        });
+    }
+    ngOnDestroy() {
+        this._predicateRemoved$.complete();
+        this._activeFilter.complete();
+        this._predicateQueryChanged$.complete();
+        if (this.subFilter) {
+            this.subFilter.unsubscribe();
+        }
+        this._loadingFromMetadata$.complete();
+        this._rootPredicate.destroy();
+    }
+    /**
+     * @returns the Filter that is currently applied to the view
+     */
+    get activeFilter() {
+        return this._activeFilter.getValue();
+    }
+    /**
+     * @returns an `Observable` that updates every time the active Filter changes.
+     */
+    get activeFilter$() {
+        return this._activeFilter.asObservable();
+    }
+    /**
+     * @returns `true` if a filter other than the base filter is currently applied.
+     * Returns `false` if only the base filter is currently applied.
+     */
+    get additionalFiltersApplied() {
+        return !this._rootPredicate.query.isEmpty || !!this._fullTextFilter;
+    }
+    /**
+     * @returns `true` if any visible predicates are applied.
+     * Returns `false` if there are no predicates, or if there are only hidden predicates applied
+     */
+    get hasVisiblePredicates() {
+        for (const predicate of this._rootPredicate.getPredicateMap().values()) {
+            if (predicate.isVisible) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * @returns a copy of the base filter
+     */
+    get baseFilter() {
+        return this._baseFilter.clone();
+    }
+    /**
+     * @returns an Observable that emits the index of the removed predicate whenever a predicate is removed
+     */
+    get predicateRemoved$() {
+        return this._predicateRemoved$.asObservable();
+    }
+    /**
+     * @returns the root predicate of the search service, that can be used to generate search requests with custom queries
+     */
+    get rootPredicate() {
+        return this._rootPredicate;
+    }
+    /**
+     * @returns the type of the filter held in this search service instance
+     */
+    get filterType() {
+        return this.baseFilter.type;
+    }
+    /**
+     * @returns whether the search service is currently loading its state from metadata or not.
+     *
+     * See [loadFromMetadata()]{@link SearchService#loadFromMetadata}
+     */
+    get loadingFromMetadata() {
+        return this._loadingFromMetadata$.value;
+    }
+    /**
+     * @returns an `Observable` that emits `true` if the search service is currently loading its state from metadata,
+     * emits `false` otherwise.
+     *
+     * See [loadFromMetadata()]{@link SearchService#loadFromMetadata}
+     */
+    get loadingFromMetadata$() {
+        return this._loadingFromMetadata$.asObservable();
+    }
+    /**
+     * @returns an Observable that emits whenever the root predicates query changes
+     */
+    get predicateQueryChanged$() {
+        return this._predicateQueryChanged$.asObservable().pipe(map(() => this._rootPredicate.query), distinctUntilChanged((prev, curr) => prev && prev.equals(curr)));
+    }
+    /**
+     * Adds a {@link Predicate} to the Predicate root and updates the active Filter.
+     *
+     * Predicates added this way will not be visible in the search GUI.
+     * If you want to make sure your predicates are visible (and editable)
+     * use the [addGeneratedLeafPredicate()]{@link SearchService#addGeneratedLeafPredicate} method instead.
+     * @param newPredicate Predicate that should be added to the search queries.
+     * @returns the index of the added Predicate
+     */
+    addPredicate(newPredicate) {
+        return this._rootPredicate.addPredicate(newPredicate, false);
+    }
+    /**
+     * Adds a new hidden branch of the predicate tree with a singular leaf node containing the provided Query.
+     *
+     * This can be used to add predicates to the search tree (think header search),
+     * which can be made visible and editable in the search GUI later.
+     * @param generator the generator that is in such state, that it generates the Query, that should be added as branch/leaf.
+     * If the generator doesn't currently generate a query a node with an empty query will be added.
+     */
+    addGeneratedLeafPredicate(generator) {
+        const branchId = this._rootPredicate.addNewClausePredicate(BooleanOperator.OR, false);
+        const branch = this._rootPredicate.getPredicateMap().get(branchId).getWrappedPredicate();
+        branch.addNewPredicateFromGenerator(generator);
+        return branchId;
+    }
+    /**
+     * Removes the {@link Predicate} object from the provided index. If the index is invalid does nothing.
+     * Updates the the active Filter if the Predicate tree was affected.
+     * @param index index of the Predicate that should be removed
+     * @param clearInput whether the input, that corresponds to the predicate should be cleared
+     */
+    removePredicate(index, clearInput = true) {
+        if (this._rootPredicate.removePredicate(index)) {
+            this._predicateRemoved$.next({ index, clearInput });
+        }
+    }
+    /**
+     * Removes all {@link Predicate} objects that contribute to the search. Updates the active Filter if it was affected.
+     *
+     * @param clearHidden whether the hidden predicates should be cleared as well
+     */
+    clearPredicates(clearHidden = false) {
+        if (this._rootPredicate.getPredicateMap().size > 0) {
+            for (const [id, predicate] of this._rootPredicate.getPredicateMap().entries()) {
+                if (clearHidden || predicate.isVisible) {
+                    this.removePredicate(id);
+                }
+            }
+            this.updateActiveFilter();
+        }
+    }
+    /**
+     * Adds a {@link Filter} with the [fullText]{@link CaseSearchRequestBody#fullText} attribute set to the provided value.
+     * If full text filter is already set, it will be replaced.
+     * @param searchedSubstring value that should be searched on all full text fields
+     */
+    setFullTextFilter(searchedSubstring) {
+        this._fullTextFilter = new SimpleFilter('', this._baseFilter.type, { fullText: searchedSubstring });
+        this.updateActiveFilter();
+    }
+    /**
+     * Clears the full text filter (if set). If the full text filter is not set, does nothing.
+     */
+    clearFullTextFilter() {
+        const wasFulltextSet = this._fullTextFilter !== undefined;
+        this._fullTextFilter = undefined;
+        if (wasFulltextSet) {
+            this.updateActiveFilter();
+        }
+    }
+    /**
+     * Shows the predicates with the given ids. Skips ids that don't exist.
+     * @param predicateIds the ids of the predicates that should be shown.
+     */
+    show(predicateIds) {
+        this._rootPredicate.showPredicates(predicateIds);
+    }
+    /**
+     * Reads the current query from the predicate tree, combines it with the base Filter and full text Filter (if set)
+     * and updates the active Filter.
+     */
+    updateActiveFilter() {
+        let additionalFilter;
+        if (!this._rootPredicate.query.isEmpty) {
+            additionalFilter = new SimpleFilter('', this._baseFilter.type, { query: this._rootPredicate.query.value });
+        }
+        if (this._fullTextFilter) {
+            if (additionalFilter) {
+                additionalFilter = additionalFilter.merge(this._fullTextFilter, MergeOperator.AND);
+            }
+            else {
+                additionalFilter = this._fullTextFilter;
+            }
+        }
+        if (additionalFilter) {
+            this._activeFilter.next(this._baseFilter.merge(additionalFilter, MergeOperator.AND));
+        }
+        else {
+            this._activeFilter.next(this._baseFilter.clone());
+        }
+    }
+    /**
+     * @returns `undefined` if the predicate tree contains no complete query.
+     * Otherwise returns the serialized form of the completed queries in the predicate tree.
+     */
+    createPredicateMetadata() {
+        return this._rootPredicate.createGeneratorMetadata();
+    }
+    /**
+     * Replaces the current predicate filter by the one corresponding to the provided generator metadata.
+     *
+     * The {@link CategoryFactory} instance must be provided for this service if we want to use this method. Logs an error and does nothing.
+     *
+     * The `filterType` of this search service must match the `filterType` of the provided metadata. Otherwise an error is thrown.
+     *
+     * @param metadata the serialized state of the predicate tree that should be restored to this search service
+     */
+    loadFromMetadata(metadata) {
+        if (this._categoryFactory === null) {
+            this._log.error('A CategoryFactory instance must be provided for the SearchService'
+                + ' if you want to reconstruct a predicate filter from saved metadata');
+            return;
+        }
+        if (metadata.filterType !== this.filterType) {
+            throw Error(`The filter type of the provided metadata (${metadata.filterType}) does not match the filter type of the search service (${this.filterType})!`);
+        }
+        this.clearPredicates(true);
+        this._loadingFromMetadata$.on();
+        const generatorObservables = [];
+        for (const clause of metadata.predicateMetadata) {
+            const branchId = this._rootPredicate.addNewClausePredicate(BooleanOperator.OR);
+            const branchPredicate = this._rootPredicate.getPredicateMap().get(branchId)
+                .getWrappedPredicate();
+            for (const predicate of clause) {
+                const localBranchReference = branchPredicate;
+                generatorObservables.push(this._categoryFactory.getFromMetadata(predicate).pipe(tap(generator => {
+                    localBranchReference.addNewPredicateFromGenerator(generator);
+                })));
+            }
+        }
+        forkJoin(generatorObservables).subscribe(() => {
+            this._loadingFromMetadata$.off();
+            this.updateActiveFilter();
+        });
+    }
+    /**
+     * @returns an Array of filter text segments that correspond to the currently displayed completed predicates
+     */
+    createFilterTextSegments() {
+        return this._rootPredicate.createFilterTextSegments();
+    }
+}
+SearchService.ctorParameters = () => [
+    { type: LoggerService },
+    { type: CategoryFactory, decorators: [{ type: Optional }] },
+    { type: undefined, decorators: [{ type: Inject, args: [NAE_BASE_FILTER,] }] }
+];
+SearchService.decorators = [
+    { type: Injectable }
+];
+SearchService.ctorParameters = () => [
+    { type: LoggerService },
+    { type: CategoryFactory, decorators: [{ type: Optional }] },
+    { type: undefined, decorators: [{ type: Inject, args: [NAE_BASE_FILTER,] }] }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/search/search-service/search.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable, OnDestroy, Optional} from '@angular/core';\nimport {BooleanOperator} from '../models/boolean-operator';\nimport {Filter} from '../../filter/models/filter';\nimport {BehaviorSubject, forkJoin, Observable, Subject, Subscription} from 'rxjs';\nimport {Predicate} from '../models/predicate/predicate';\nimport {SimpleFilter} from '../../filter/models/simple-filter';\nimport {MergeOperator} from '../../filter/models/merge-operator';\nimport {PredicateRemovalEvent} from '../models/predicate-removal-event';\nimport {Query} from '../models/query/query';\nimport {distinctUntilChanged, map, tap} from 'rxjs/operators';\nimport {EditableClausePredicateWithGenerators} from '../models/predicate/editable-clause-predicate-with-generators';\nimport {Category} from '../models/category/category';\nimport {PredicateTreeMetadata} from '../models/persistance/generator-metadata';\nimport {NAE_BASE_FILTER} from '../models/base-filter-injection-token';\nimport {BaseFilter} from '../models/base-filter';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {CategoryFactory} from '../category-factory/category-factory';\nimport {FilterType} from '../../filter/models/filter-type';\nimport {LoadingEmitter} from '../../utility/loading-emitter';\nimport {FilterMetadata} from '../models/persistance/filter-metadata';\nimport {FilterTextSegment} from '../models/persistance/filter-text-segment';\n\n/**\n * Holds information about the filter that is currently applied to the view component, that provides this services.\n */\n@Injectable()\nexport class SearchService implements OnDestroy {\n\n    /**\n     * {@link Filter} that is applied to the view, even if the user doesn't search anything.\n     */\n    protected _baseFilter: Filter;\n    /**\n     * Holds the {@link Predicate} tree root for user search queries.\n     */\n    protected _rootPredicate: EditableClausePredicateWithGenerators;\n    /**\n     * Holds the {@link Filter} that is currently being applied to the view.\n     */\n    protected _activeFilter: BehaviorSubject<Filter>;\n    /**\n     * Holds the full text {@link Filter} if set, `undefined` otherwise.\n     */\n    protected _fullTextFilter: SimpleFilter | undefined;\n    /**\n     * The index of a removed {@link Predicate} is emmited into this stream\n     */\n    protected _predicateRemoved$: Subject<PredicateRemovalEvent>;\n    protected _loadingFromMetadata$: LoadingEmitter;\n    /**\n     * The `rootPredicate` uses this stream to notify the search service about changes to the held query\n     */\n    private readonly _predicateQueryChanged$: Subject<void>;\n    private readonly subFilter: Subscription;\n\n    /**\n     * The {@link Predicate} tree root uses an [AND]{@link BooleanOperator#AND} operator to combine the Predicates.\n     * @param _log {@link LoggerService}\n     * @param _categoryFactory a {@link CategoryFactory} instance. This dependency is optional.\n     * It is required if we want to load predicate filter from saved metadata\n     * @param baseFilter Filter that should be applied to the view when no searching is being performed.\n     * Injected trough the {@link NAE_BASE_FILTER} injection token.\n     */\n    constructor(protected _log: LoggerService,\n                @Optional() protected _categoryFactory: CategoryFactory,\n                @Inject(NAE_BASE_FILTER) baseFilter: BaseFilter) {\n        if (baseFilter.filter instanceof Filter) {\n            this._baseFilter = baseFilter.filter.clone();\n        } else if (baseFilter.filter instanceof Observable) {\n            this._baseFilter = new SimpleFilter('', baseFilter.filterType, {process: {identifier: '__EMPTY__'}});\n        } else {\n            throw new Error('Unsupported BaseFilter input! You must provide the NAE_BASE_FILTER injection token with proper values!');\n        }\n\n        this._predicateQueryChanged$ = new Subject<void>();\n        this._rootPredicate = new EditableClausePredicateWithGenerators(BooleanOperator.AND, this._predicateQueryChanged$, undefined, true);\n        this._activeFilter = new BehaviorSubject<Filter>(this._baseFilter);\n        this._predicateRemoved$ = new Subject<PredicateRemovalEvent>();\n        this._loadingFromMetadata$ = new LoadingEmitter();\n\n        if (baseFilter.filter instanceof Observable) {\n            this.subFilter = baseFilter.filter.subscribe((filter) => {\n                this._baseFilter = filter.clone();\n                this.updateActiveFilter();\n            });\n        }\n\n        this.predicateQueryChanged$.subscribe(() => {\n            this.updateActiveFilter();\n        });\n    }\n\n    ngOnDestroy(): void {\n        this._predicateRemoved$.complete();\n        this._activeFilter.complete();\n        this._predicateQueryChanged$.complete();\n        if (this.subFilter) {\n            this.subFilter.unsubscribe();\n        }\n        this._loadingFromMetadata$.complete();\n        this._rootPredicate.destroy();\n    }\n\n    /**\n     * @returns the Filter that is currently applied to the view\n     */\n    public get activeFilter(): Filter {\n        return this._activeFilter.getValue();\n    }\n\n    /**\n     * @returns an `Observable` that updates every time the active Filter changes.\n     */\n    public get activeFilter$(): Observable<Filter> {\n        return this._activeFilter.asObservable();\n    }\n\n    /**\n     * @returns `true` if a filter other than the base filter is currently applied.\n     * Returns `false` if only the base filter is currently applied.\n     */\n    public get additionalFiltersApplied(): boolean {\n        return !this._rootPredicate.query.isEmpty || !!this._fullTextFilter;\n    }\n\n    /**\n     * @returns `true` if any visible predicates are applied.\n     * Returns `false` if there are no predicates, or if there are only hidden predicates applied\n     */\n    public get hasVisiblePredicates(): boolean {\n        for (const predicate of this._rootPredicate.getPredicateMap().values()) {\n            if (predicate.isVisible) {\n                return true;\n            }\n        }\n        return false;\n    }\n\n    /**\n     * @returns a copy of the base filter\n     */\n    public get baseFilter(): Filter {\n        return this._baseFilter.clone();\n    }\n\n    /**\n     * @returns an Observable that emits the index of the removed predicate whenever a predicate is removed\n     */\n    public get predicateRemoved$(): Observable<PredicateRemovalEvent> {\n        return this._predicateRemoved$.asObservable();\n    }\n\n    /**\n     * @returns the root predicate of the search service, that can be used to generate search requests with custom queries\n     */\n    public get rootPredicate(): EditableClausePredicateWithGenerators {\n        return this._rootPredicate;\n    }\n\n    /**\n     * @returns the type of the filter held in this search service instance\n     */\n    public get filterType(): FilterType {\n        return this.baseFilter.type;\n    }\n\n    /**\n     * @returns whether the search service is currently loading its state from metadata or not.\n     *\n     * See [loadFromMetadata()]{@link SearchService#loadFromMetadata}\n     */\n    public get loadingFromMetadata(): boolean {\n        return this._loadingFromMetadata$.value;\n    }\n\n    /**\n     * @returns an `Observable` that emits `true` if the search service is currently loading its state from metadata,\n     * emits `false` otherwise.\n     *\n     * See [loadFromMetadata()]{@link SearchService#loadFromMetadata}\n     */\n    public get loadingFromMetadata$(): Observable<boolean> {\n        return this._loadingFromMetadata$.asObservable();\n    }\n\n    /**\n     * @returns an Observable that emits whenever the root predicates query changes\n     */\n    protected get predicateQueryChanged$(): Observable<Query> {\n        return this._predicateQueryChanged$.asObservable().pipe(\n            map(() => this._rootPredicate.query),\n            distinctUntilChanged((prev, curr) => prev && prev.equals(curr))\n        );\n    }\n\n    /**\n     * Adds a {@link Predicate} to the Predicate root and updates the active Filter.\n     *\n     * Predicates added this way will not be visible in the search GUI.\n     * If you want to make sure your predicates are visible (and editable)\n     * use the [addGeneratedLeafPredicate()]{@link SearchService#addGeneratedLeafPredicate} method instead.\n     * @param newPredicate Predicate that should be added to the search queries.\n     * @returns the index of the added Predicate\n     */\n    public addPredicate(newPredicate: Predicate): number {\n        return this._rootPredicate.addPredicate(newPredicate, false);\n    }\n\n    /**\n     * Adds a new hidden branch of the predicate tree with a singular leaf node containing the provided Query.\n     *\n     * This can be used to add predicates to the search tree (think header search),\n     * which can be made visible and editable in the search GUI later.\n     * @param generator the generator that is in such state, that it generates the Query, that should be added as branch/leaf.\n     * If the generator doesn't currently generate a query a node with an empty query will be added.\n     */\n    public addGeneratedLeafPredicate(generator: Category<any>): number {\n        const branchId = this._rootPredicate.addNewClausePredicate(BooleanOperator.OR, false);\n        const branch = (\n            this._rootPredicate.getPredicateMap().get(branchId).getWrappedPredicate() as unknown as EditableClausePredicateWithGenerators\n        );\n        branch.addNewPredicateFromGenerator(generator);\n        return branchId;\n    }\n\n    /**\n     * Removes the {@link Predicate} object from the provided index. If the index is invalid does nothing.\n     * Updates the the active Filter if the Predicate tree was affected.\n     * @param index index of the Predicate that should be removed\n     * @param clearInput whether the input, that corresponds to the predicate should be cleared\n     */\n    public removePredicate(index: number, clearInput = true): void {\n        if (this._rootPredicate.removePredicate(index)) {\n            this._predicateRemoved$.next({index, clearInput});\n        }\n    }\n\n    /**\n     * Removes all {@link Predicate} objects that contribute to the search. Updates the active Filter if it was affected.\n     *\n     * @param clearHidden whether the hidden predicates should be cleared as well\n     */\n    public clearPredicates(clearHidden = false): void {\n        if (this._rootPredicate.getPredicateMap().size > 0) {\n            for (const [id, predicate] of this._rootPredicate.getPredicateMap().entries()) {\n                if (clearHidden || predicate.isVisible) {\n                    this.removePredicate(id);\n                }\n            }\n            this.updateActiveFilter();\n        }\n    }\n\n    /**\n     * Adds a {@link Filter} with the [fullText]{@link CaseSearchRequestBody#fullText} attribute set to the provided value.\n     * If full text filter is already set, it will be replaced.\n     * @param searchedSubstring value that should be searched on all full text fields\n     */\n    public setFullTextFilter(searchedSubstring: string): void {\n        this._fullTextFilter = new SimpleFilter('', this._baseFilter.type, {fullText: searchedSubstring});\n        this.updateActiveFilter();\n    }\n\n    /**\n     * Clears the full text filter (if set). If the full text filter is not set, does nothing.\n     */\n    public clearFullTextFilter(): void {\n        const wasFulltextSet = this._fullTextFilter !== undefined;\n        this._fullTextFilter = undefined;\n        if (wasFulltextSet) {\n            this.updateActiveFilter();\n        }\n    }\n\n    /**\n     * Shows the predicates with the given ids. Skips ids that don't exist.\n     * @param predicateIds the ids of the predicates that should be shown.\n     */\n    public show(predicateIds: Array<number>): void {\n        this._rootPredicate.showPredicates(predicateIds);\n    }\n\n    /**\n     * Reads the current query from the predicate tree, combines it with the base Filter and full text Filter (if set)\n     * and updates the active Filter.\n     */\n    protected updateActiveFilter(): void {\n        let additionalFilter: Filter;\n        if (!this._rootPredicate.query.isEmpty) {\n            additionalFilter = new SimpleFilter('', this._baseFilter.type, {query: this._rootPredicate.query.value});\n        }\n        if (this._fullTextFilter) {\n            if (additionalFilter) {\n                additionalFilter = additionalFilter.merge(this._fullTextFilter, MergeOperator.AND);\n            } else {\n                additionalFilter = this._fullTextFilter;\n            }\n        }\n        if (additionalFilter) {\n            this._activeFilter.next(this._baseFilter.merge(additionalFilter, MergeOperator.AND));\n        } else {\n            this._activeFilter.next(this._baseFilter.clone());\n        }\n    }\n\n    /**\n     * @returns `undefined` if the predicate tree contains no complete query.\n     * Otherwise returns the serialized form of the completed queries in the predicate tree.\n     */\n    public createPredicateMetadata(): PredicateTreeMetadata | undefined {\n        return this._rootPredicate.createGeneratorMetadata() as PredicateTreeMetadata;\n    }\n\n    /**\n     * Replaces the current predicate filter by the one corresponding to the provided generator metadata.\n     *\n     * The {@link CategoryFactory} instance must be provided for this service if we want to use this method. Logs an error and does nothing.\n     *\n     * The `filterType` of this search service must match the `filterType` of the provided metadata. Otherwise an error is thrown.\n     *\n     * @param metadata the serialized state of the predicate tree that should be restored to this search service\n     */\n    public loadFromMetadata(metadata: FilterMetadata) {\n        if (this._categoryFactory === null) {\n            this._log.error('A CategoryFactory instance must be provided for the SearchService'\n                + ' if you want to reconstruct a predicate filter from saved metadata');\n            return;\n        }\n\n        if (metadata.filterType !== this.filterType) {\n            throw Error(`The filter type of the provided metadata (${metadata.filterType\n            }) does not match the filter type of the search service (${this.filterType})!`);\n        }\n\n        this.clearPredicates(true);\n        this._loadingFromMetadata$.on();\n\n        const generatorObservables = [];\n\n        for (const clause of metadata.predicateMetadata) {\n            const branchId = this._rootPredicate.addNewClausePredicate(BooleanOperator.OR);\n            const branchPredicate = (\n                this._rootPredicate.getPredicateMap().get(branchId)\n                    .getWrappedPredicate() as unknown as EditableClausePredicateWithGenerators\n            );\n            for (const predicate of clause) {\n                const localBranchReference = branchPredicate;\n                generatorObservables.push(\n                    this._categoryFactory.getFromMetadata(predicate).pipe(tap(generator => {\n                        localBranchReference.addNewPredicateFromGenerator(generator);\n                    }))\n                );\n            }\n        }\n\n        forkJoin(generatorObservables).subscribe(() => {\n            this._loadingFromMetadata$.off();\n            this.updateActiveFilter();\n        });\n    }\n\n    /**\n     * @returns an Array of filter text segments that correspond to the currently displayed completed predicates\n     */\n    public createFilterTextSegments(): Array<FilterTextSegment> {\n        return this._rootPredicate.createFilterTextSegments();\n    }\n}\n"]}

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

@@ -0,0 +1,163 @@
+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.
+ *
+ */
+export class AbstractFilterSelectorComponent {
+    /**
+     * 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 -
+     */
+    constructor(_sideMenuControl, _filterRepository) {
+        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 = (item, searchInput) => {
+            return item.title
+                ? item.title.toLocaleLowerCase().includes(searchInput.toLocaleLowerCase())
+                : item.id.toLocaleLowerCase().includes(searchInput.toLocaleLowerCase());
+        };
+        const filterConstraints = _sideMenuControl.data;
+        let caseFilters = [];
+        let taskFilters = [];
+        if (filterConstraints && filterConstraints.filterIdsConstraint) {
+            const filters = this._filterRepository.getFilters(filterConstraints.filterIdsConstraint);
+            filters.forEach(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(newValue => this.filterFilters(newValue));
+    }
+    ngOnDestroy() {
+        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
+     */
+    filterSelected(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.
+     */
+    filterSelectionConfirmed() {
+        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
+     */
+    caseFilterSelected(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
+     */
+    taskFilterSelected(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
+     */
+    filterFilters(newValue) {
+        this.caseFilters.filter(newValue);
+        this.taskFilters.filter(newValue);
+    }
+}
+AbstractFilterSelectorComponent.ctorParameters = () => [
+    { type: SideMenuControl, decorators: [{ type: Inject, args: [NAE_SIDE_MENU_CONTROL,] }] },
+    { type: FilterRepository }
+];
+AbstractFilterSelectorComponent.propDecorators = {
+    caseFilterList: [{ type: ViewChild, args: ['caseFilterList',] }],
+    taskFilterList: [{ type: ViewChild, args: ['taskFilterList',] }]
+};
+//# 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/esm2015/lib/side-menu/content-components/filter-selector/filter-selector-list-item/abstract-filter-selector-list-item.component.js

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

package/esm2015/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/esm2015/lib/side-menu/content-components/filter-selector/model/filtered-array.js

@@ -0,0 +1,32 @@
+/**
+ * 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.
+ */
+export class FilteredArray {
+    /**
+     * @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.
+     */
+    constructor(_unfiltered, _filterPredicate) {
+        this._unfiltered = _unfiltered;
+        this._filterPredicate = _filterPredicate;
+        this.filtered = [];
+        this.filtered.push(...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
+     */
+    filter(data) {
+        this.filtered.splice(0, this.filtered.length);
+        this._unfiltered.forEach(item => {
+            if (this._filterPredicate(item, data)) {
+                this.filtered.push(item);
+            }
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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