@netgrif/components-core 6.0.1

package/esm2015/lib/search/models/predicate/clause-predicate.js

@@ -0,0 +1,78 @@
+import { Predicate } from './predicate';
+import { Query } from '../query/query';
+/**
+ * Represents a clause of {@link Predicate}s combined with a {@link BooleanOperator}.
+ */
+export class ClausePredicate extends Predicate {
+    /**
+     * @param predicates Predicates that should be combined into one
+     * @param _operator Operator that is used to combine the predicates
+     * @param initiallyVisible whether the predicate should be initially displayed or not
+     * @param _bracketSubPredicateText whether the individual sub predicates are wrapped in brackets when a textual representation
+     * is generated
+     */
+    constructor(predicates, _operator, initiallyVisible = true, _bracketSubPredicateText = false) {
+        super(initiallyVisible);
+        this._operator = _operator;
+        this._bracketSubPredicateText = _bracketSubPredicateText;
+        this._predicates = [];
+        this._predicates.push(...predicates);
+        this.updateQuery();
+        this.initializeFilterTextSegmentsGenerator();
+    }
+    get query() {
+        return this._query;
+    }
+    /**
+     * Adds another {@link Predicate} to the clause and updates this {@link Predicate}'s {@link Query}.
+     * @param newPredicate - the Predicate that should be added to the clause
+     * @returns the index of the added Predicate, that can be used to remove it.
+     * Note that removing predicates with a lower index shifts the order of indices.
+     */
+    addPredicate(newPredicate) {
+        this._predicates.push(newPredicate);
+        this.updateQuery();
+        return this._predicates.length - 1;
+    }
+    /**
+     * Removes the {@link Predicate} at the given `index` from this clause and updates this {@link Predicate}'s {@link Query}.
+     * If the `index` is invalid does nothing.
+     * @param index index of the {@link Predicate} in this clause that should be removed
+     * @returns whether a predicate was removed, or not
+     */
+    removePredicate(index) {
+        if (index >= 0 && index < this._predicates.length) {
+            this._predicates.splice(index, 1);
+            this.updateQuery();
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Sets this predicate and all its sub-predicates to visible.
+     */
+    showAll() {
+        this.show();
+        this._predicates.forEach(p => p.show());
+    }
+    /**
+     * Updates the value of the [_query]{@link ClausePredicate#_query} attribute.
+     *
+     * See [combineQueries()]{@link Query#combineQueries} for more information.
+     */
+    updateQuery() {
+        this._query = Query.combineQueries(this.queries, this._operator);
+    }
+    /**
+     * @returns the `Array` of {@link Query} objects stored within this object's [_predicates]{@link ClausePredicate#_predicates} attribute.
+     */
+    get queries() {
+        return this._predicates.map(p => p.query);
+    }
+    initializeFilterTextSegmentsGenerator() {
+        this._filterTextSegmentsGenerator = () => {
+            return Predicate.combineTextSegmentsWithBooleanOperator(this._predicates, this._operator, this._bracketSubPredicateText);
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/search/models/predicate/editable-clause-predicate-with-generators.js

@@ -0,0 +1,47 @@
+import { EditableClausePredicate } from './editable-clause-predicate';
+import { PredicateWithGenerator } from './predicate-with-generator';
+import { EditablePredicateWithGenerator } from './editable-predicate-with-generator';
+export class EditableClausePredicateWithGenerators extends EditableClausePredicate {
+    constructor(operator, parentNotifier, initiallyVisible = true, bracketSubPredicateText = false) {
+        super(operator, parentNotifier, initiallyVisible, bracketSubPredicateText);
+        this._metadataGenerator = () => {
+            const result = [];
+            for (const predicate of this._predicates.values()) {
+                const metadata = predicate.createGeneratorMetadata();
+                if (metadata !== undefined) {
+                    result.push(metadata);
+                }
+            }
+            return result.length > 0 ? result : undefined;
+        };
+    }
+    addNewClausePredicate(operator, initiallyVisible = true) {
+        return this.addPredicate(new EditableClausePredicateWithGenerators(operator, this._childUpdated$, initiallyVisible));
+    }
+    addPredicate(predicate, initiallyVisible = true) {
+        return super.addPredicate(new PredicateWithGenerator(predicate, undefined, initiallyVisible));
+    }
+    /**
+     * Creates a new editable predicate from the provided generator {@link Category} instance,
+     * connects it to the update notifications stream and adds it to the predicate subtree.
+     * @param generator
+     * @param initiallyVisible
+     */
+    addNewPredicateFromGenerator(generator, initiallyVisible = true) {
+        const predicate = new EditablePredicateWithGenerator(generator, initiallyVisible);
+        predicate.parentNotifier = this._childUpdated$;
+        return super.addPredicate(predicate);
+    }
+    getPredicateMap() {
+        return this._predicates;
+    }
+    /**
+     * Cleans-up the inner state of this object
+     */
+    destroy() {
+        for (const predicate of this._predicates.values()) {
+            predicate.destroy();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWRpdGFibGUtY2xhdXNlLXByZWRpY2F0ZS13aXRoLWdlbmVyYXRvcnMuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvc2VhcmNoL21vZGVscy9wcmVkaWNhdGUvZWRpdGFibGUtY2xhdXNlLXByZWRpY2F0ZS13aXRoLWdlbmVyYXRvcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLHVCQUF1QixFQUFDLE1BQU0sNkJBQTZCLENBQUM7QUFHcEUsT0FBTyxFQUFDLHNCQUFzQixFQUFDLE1BQU0sNEJBQTRCLENBQUM7QUFHbEUsT0FBTyxFQUFDLDhCQUE4QixFQUFDLE1BQU0scUNBQXFDLENBQUM7QUFFbkYsTUFBTSxPQUFPLHFDQUFzQyxTQUFRLHVCQUF1QjtJQUk5RSxZQUFZLFFBQXlCLEVBQUUsY0FBOEIsRUFBRSxnQkFBZ0IsR0FBRyxJQUFJLEVBQUUsdUJBQXVCLEdBQUcsS0FBSztRQUMzSCxLQUFLLENBQUMsUUFBUSxFQUFFLGNBQWMsRUFBRSxnQkFBZ0IsRUFBRSx1QkFBdUIsQ0FBQyxDQUFDO1FBQzNFLElBQUksQ0FBQyxrQkFBa0IsR0FBRyxHQUFHLEVBQUU7WUFDM0IsTUFBTSxNQUFNLEdBQUcsRUFBRSxDQUFDO1lBQ2xCLEtBQUssTUFBTSxTQUFTLElBQUksSUFBSSxDQUFDLFdBQVcsQ0FBQyxNQUFNLEVBQUUsRUFBRTtnQkFDL0MsTUFBTSxRQUFRLEdBQUcsU0FBUyxDQUFDLHVCQUF1QixFQUFFLENBQUM7Z0JBQ3JELElBQUksUUFBUSxLQUFLLFNBQVMsRUFBRTtvQkFDeEIsTUFBTSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztpQkFDekI7YUFDSjtZQUNELE9BQU8sTUFBTSxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDO1FBQ2xELENBQUMsQ0FBQztJQUNOLENBQUM7SUFFRCxxQkFBcUIsQ0FBQyxRQUF5QixFQUFFLGdCQUFnQixHQUFHLElBQUk7UUFDcEUsT0FBTyxJQUFJLENBQUMsWUFBWSxDQUFDLElBQUkscUNBQXFDLENBQUMsUUFBUSxFQUFFLElBQUksQ0FBQyxjQUFjLEVBQUUsZ0JBQWdCLENBQUMsQ0FBQyxDQUFDO0lBQ3pILENBQUM7SUFFRCxZQUFZLENBQUMsU0FBb0IsRUFBRSxnQkFBZ0IsR0FBRyxJQUFJO1FBQ3RELE9BQU8sS0FBSyxDQUFDLFlBQVksQ0FBQyxJQUFJLHNCQUFzQixDQUFDLFNBQVMsRUFBRSxTQUFTLEVBQUUsZ0JBQWdCLENBQUMsQ0FBQyxDQUFDO0lBQ2xHLENBQUM7SUFFRDs7Ozs7T0FLRztJQUNILDRCQUE0QixDQUFDLFNBQXdCLEVBQUUsZ0JBQWdCLEdBQUcsSUFBSTtRQUMxRSxNQUFNLFNBQVMsR0FBRyxJQUFJLDhCQUE4QixDQUFDLFNBQVMsRUFBRSxnQkFBZ0IsQ0FBQyxDQUFDO1FBQ2xGLFNBQVMsQ0FBQyxjQUFjLEdBQUcsSUFBSSxDQUFDLGNBQWMsQ0FBQztRQUMvQyxPQUFPLEtBQUssQ0FBQyxZQUFZLENBQUMsU0FBUyxDQUFDLENBQUM7SUFDekMsQ0FBQztJQUVELGVBQWU7UUFDWCxPQUFPLElBQUksQ0FBQyxXQUFXLENBQUM7SUFDNUIsQ0FBQztJQUVEOztPQUVHO0lBQ0gsT0FBTztRQUNILEtBQUssTUFBTSxTQUFTLElBQUksSUFBSSxDQUFDLFdBQVcsQ0FBQyxNQUFNLEVBQUUsRUFBRTtZQUMvQyxTQUFTLENBQUMsT0FBTyxFQUFFLENBQUM7U0FDdkI7SUFDTCxDQUFDO0NBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0VkaXRhYmxlQ2xhdXNlUHJlZGljYXRlfSBmcm9tICcuL2VkaXRhYmxlLWNsYXVzZS1wcmVkaWNhdGUnO1xuaW1wb3J0IHtCb29sZWFuT3BlcmF0b3J9IGZyb20gJy4uL2Jvb2xlYW4tb3BlcmF0b3InO1xuaW1wb3J0IHtTdWJqZWN0fSBmcm9tICdyeGpzJztcbmltcG9ydCB7UHJlZGljYXRlV2l0aEdlbmVyYXRvcn0gZnJvbSAnLi9wcmVkaWNhdGUtd2l0aC1nZW5lcmF0b3InO1xuaW1wb3J0IHtQcmVkaWNhdGV9IGZyb20gJy4vcHJlZGljYXRlJztcbmltcG9ydCB7Q2F0ZWdvcnl9IGZyb20gJy4uL2NhdGVnb3J5L2NhdGVnb3J5JztcbmltcG9ydCB7RWRpdGFibGVQcmVkaWNhdGVXaXRoR2VuZXJhdG9yfSBmcm9tICcuL2VkaXRhYmxlLXByZWRpY2F0ZS13aXRoLWdlbmVyYXRvcic7XG5cbmV4cG9ydCBjbGFzcyBFZGl0YWJsZUNsYXVzZVByZWRpY2F0ZVdpdGhHZW5lcmF0b3JzIGV4dGVuZHMgRWRpdGFibGVDbGF1c2VQcmVkaWNhdGUge1xuXG4gICAgcHJvdGVjdGVkIF9wcmVkaWNhdGVzOiBNYXA8bnVtYmVyLCBQcmVkaWNhdGVXaXRoR2VuZXJhdG9yPjtcblxuICAgIGNvbnN0cnVjdG9yKG9wZXJhdG9yOiBCb29sZWFuT3BlcmF0b3IsIHBhcmVudE5vdGlmaWVyPzogU3ViamVjdDx2b2lkPiwgaW5pdGlhbGx5VmlzaWJsZSA9IHRydWUsIGJyYWNrZXRTdWJQcmVkaWNhdGVUZXh0ID0gZmFsc2UpIHtcbiAgICAgICAgc3VwZXIob3BlcmF0b3IsIHBhcmVudE5vdGlmaWVyLCBpbml0aWFsbHlWaXNpYmxlLCBicmFja2V0U3ViUHJlZGljYXRlVGV4dCk7XG4gICAgICAgIHRoaXMuX21ldGFkYXRhR2VuZXJhdG9yID0gKCkgPT4ge1xuICAgICAgICAgICAgY29uc3QgcmVzdWx0ID0gW107XG4gICAgICAgICAgICBmb3IgKGNvbnN0IHByZWRpY2F0ZSBvZiB0aGlzLl9wcmVkaWNhdGVzLnZhbHVlcygpKSB7XG4gICAgICAgICAgICAgICAgY29uc3QgbWV0YWRhdGEgPSBwcmVkaWNhdGUuY3JlYXRlR2VuZXJhdG9yTWV0YWRhdGEoKTtcbiAgICAgICAgICAgICAgICBpZiAobWV0YWRhdGEgIT09IHVuZGVmaW5lZCkge1xuICAgICAgICAgICAgICAgICAgICByZXN1bHQucHVzaChtZXRhZGF0YSk7XG4gICAgICAgICAgICAgICAgfVxuICAgICAgICAgICAgfVxuICAgICAgICAgICAgcmV0dXJuIHJlc3VsdC5sZW5ndGggPiAwID8gcmVzdWx0IDogdW5kZWZpbmVkO1xuICAgICAgICB9O1xuICAgIH1cblxuICAgIGFkZE5ld0NsYXVzZVByZWRpY2F0ZShvcGVyYXRvcjogQm9vbGVhbk9wZXJhdG9yLCBpbml0aWFsbHlWaXNpYmxlID0gdHJ1ZSk6IG51bWJlciB7XG4gICAgICAgIHJldHVybiB0aGlzLmFkZFByZWRpY2F0ZShuZXcgRWRpdGFibGVDbGF1c2VQcmVkaWNhdGVXaXRoR2VuZXJhdG9ycyhvcGVyYXRvciwgdGhpcy5fY2hpbGRVcGRhdGVkJCwgaW5pdGlhbGx5VmlzaWJsZSkpO1xuICAgIH1cblxuICAgIGFkZFByZWRpY2F0ZShwcmVkaWNhdGU6IFByZWRpY2F0ZSwgaW5pdGlhbGx5VmlzaWJsZSA9IHRydWUpOiBudW1iZXIge1xuICAgICAgICByZXR1cm4gc3VwZXIuYWRkUHJlZGljYXRlKG5ldyBQcmVkaWNhdGVXaXRoR2VuZXJhdG9yKHByZWRpY2F0ZSwgdW5kZWZpbmVkLCBpbml0aWFsbHlWaXNpYmxlKSk7XG4gICAgfVxuXG4gICAgLyoqXG4gICAgICogQ3JlYXRlcyBhIG5ldyBlZGl0YWJsZSBwcmVkaWNhdGUgZnJvbSB0aGUgcHJvdmlkZWQgZ2VuZXJhdG9yIHtAbGluayBDYXRlZ29yeX0gaW5zdGFuY2UsXG4gICAgICogY29ubmVjdHMgaXQgdG8gdGhlIHVwZGF0ZSBub3RpZmljYXRpb25zIHN0cmVhbSBhbmQgYWRkcyBpdCB0byB0aGUgcHJlZGljYXRlIHN1YnRyZWUuXG4gICAgICogQHBhcmFtIGdlbmVyYXRvclxuICAgICAqIEBwYXJhbSBpbml0aWFsbHlWaXNpYmxlXG4gICAgICovXG4gICAgYWRkTmV3UHJlZGljYXRlRnJvbUdlbmVyYXRvcihnZW5lcmF0b3I6IENhdGVnb3J5PGFueT4sIGluaXRpYWxseVZpc2libGUgPSB0cnVlKTogbnVtYmVyIHtcbiAgICAgICAgY29uc3QgcHJlZGljYXRlID0gbmV3IEVkaXRhYmxlUHJlZGljYXRlV2l0aEdlbmVyYXRvcihnZW5lcmF0b3IsIGluaXRpYWxseVZpc2libGUpO1xuICAgICAgICBwcmVkaWNhdGUucGFyZW50Tm90aWZpZXIgPSB0aGlzLl9jaGlsZFVwZGF0ZWQkO1xuICAgICAgICByZXR1cm4gc3VwZXIuYWRkUHJlZGljYXRlKHByZWRpY2F0ZSk7XG4gICAgfVxuXG4gICAgZ2V0UHJlZGljYXRlTWFwKCk6IE1hcDxudW1iZXIsIFByZWRpY2F0ZVdpdGhHZW5lcmF0b3I+IHtcbiAgICAgICAgcmV0dXJuIHRoaXMuX3ByZWRpY2F0ZXM7XG4gICAgfVxuXG4gICAgLyoqXG4gICAgICogQ2xlYW5zLXVwIHRoZSBpbm5lciBzdGF0ZSBvZiB0aGlzIG9iamVjdFxuICAgICAqL1xuICAgIGRlc3Ryb3koKTogdm9pZCB7XG4gICAgICAgIGZvciAoY29uc3QgcHJlZGljYXRlIG9mIHRoaXMuX3ByZWRpY2F0ZXMudmFsdWVzKCkpIHtcbiAgICAgICAgICAgIHByZWRpY2F0ZS5kZXN0cm95KCk7XG4gICAgICAgIH1cbiAgICB9XG59XG4iXX0=

package/esm2015/lib/search/models/predicate/editable-clause-predicate.js

@@ -0,0 +1,116 @@
+import { Subject } from 'rxjs';
+import { EditableElementaryPredicate } from './editable-elementary-predicate';
+import { IncrementingCounter } from '../../../utility/incrementing-counter';
+import { Query } from '../query/query';
+import { EditablePredicate } from './editable-predicate';
+import { Predicate } from './predicate';
+/**
+ * A complex, editable `Predicate`. Represents an inner node in the predicate tree, that can process changes of `Query` objects
+ * held by its child nodes. It can notify the parent tree node about changes to the held `Query`.
+ */
+export class EditableClausePredicate extends EditablePredicate {
+    constructor(_operator, parentNotifier, initiallyVisible = true, _bracketSubPredicateText = false) {
+        super(parentNotifier, initiallyVisible);
+        this._operator = _operator;
+        this._bracketSubPredicateText = _bracketSubPredicateText;
+        this._predicates = new Map();
+        this._childUpdated$ = new Subject();
+        this._childCounter = new IncrementingCounter();
+        this._query = Query.emptyQuery();
+        this.initializeFilterTextSegmentsGenerator();
+        this._childUpdated$.subscribe(() => {
+            this.updateQueryAndNotify();
+        });
+    }
+    ngOnDestroy() {
+        this._childUpdated$.complete();
+    }
+    get query() {
+        return this._query;
+    }
+    show() {
+        super.show();
+        this.showAll();
+    }
+    /**
+     * Shows the predicates with the given ids. Skips ids that don't exist.
+     * @param predicateIds the ids of the predicates that should be shown.
+     */
+    showPredicates(predicateIds) {
+        predicateIds.forEach(id => {
+            if (this._predicates.has(id)) {
+                this._predicates.get(id).show();
+            }
+        });
+    }
+    /**
+     * Adds new child predicate of type {@link EditableElementaryPredicate}
+     * @param initiallyVisible whether the new predicate should be initially visible
+     */
+    addNewElementaryPredicate(initiallyVisible = true) {
+        return this.addPredicate(new EditableElementaryPredicate(this._childUpdated$, initiallyVisible));
+    }
+    /**
+     * Adds new child predicate of type {@link EditableClausePredicate}
+     * @param operator the operator of the child clause predicate
+     * @param initiallyVisible whether the new predicate should be initially visible
+     */
+    addNewClausePredicate(operator, initiallyVisible = true) {
+        return this.addPredicate(new EditableClausePredicate(operator, this._childUpdated$, initiallyVisible));
+    }
+    /**
+     * Generates an id for the new predicate, adds it into the map and updates the query
+     *
+     * If you want to add an editable predicate, use one of the other methods, so that this predicate can react to changes.
+     * @param predicate the new predicate
+     */
+    addPredicate(predicate) {
+        const id = this._childCounter.next();
+        this._predicates.set(id, predicate);
+        this.updateQueryAndNotify();
+        return id;
+    }
+    removePredicate(id) {
+        const r = this._predicates.delete(id);
+        this.updateQueryAndNotify();
+        return r;
+    }
+    getPredicateMap() {
+        return this._predicates;
+    }
+    /**
+     * Updates the `Query` and notifies the parent.
+     */
+    updateQueryAndNotify() {
+        this.updateQuery();
+        this.notifyParentPredicate();
+    }
+    /**
+     * Updates the value of the [_query]{@link ClausePredicate#_query} attribute.
+     *
+     * See [combineQueries()]{@link Query#combineQueries} for more information.
+     */
+    updateQuery() {
+        this._query = Query.combineQueries(this.queries, this._operator);
+    }
+    /**
+     * @returns the `Array` of {@link Query} objects stored within this object's [_predicates]{@link ClausePredicate#_predicates} attribute.
+     */
+    get queries() {
+        return Array.from(this._predicates.values()).map(p => p.query);
+    }
+    /**
+     * Sets this predicate and all its sub-predicates to visible.
+     */
+    showAll() {
+        for (const p of this._predicates.values()) {
+            p.show();
+        }
+    }
+    initializeFilterTextSegmentsGenerator() {
+        this._filterTextSegmentsGenerator = () => {
+            return Predicate.combineTextSegmentsWithBooleanOperator(this._predicates.values(), this._operator, this._bracketSubPredicateText);
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"editable-clause-predicate.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/search/models/predicate/editable-clause-predicate.ts"],"names":[],"mappings":"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","sourcesContent":["import {BooleanOperator} from '../boolean-operator';\nimport {Subject} from 'rxjs';\nimport {EditableElementaryPredicate} from './editable-elementary-predicate';\nimport {IncrementingCounter} from '../../../utility/incrementing-counter';\nimport {OnDestroy} from '@angular/core';\nimport {Query} from '../query/query';\nimport {EditablePredicate} from './editable-predicate';\nimport {Predicate} from './predicate';\n\n\n/**\n * A complex, editable `Predicate`. Represents an inner node in the predicate tree, that can process changes of `Query` objects\n * held by its child nodes. It can notify the parent tree node about changes to the held `Query`.\n */\nexport class EditableClausePredicate extends EditablePredicate implements OnDestroy {\n\n    protected _predicates: Map<number, Predicate>;\n    protected _childUpdated$: Subject<void>;\n    protected _childCounter: IncrementingCounter;\n    protected _query: Query;\n\n    constructor(protected _operator: BooleanOperator,\n                parentNotifier?: Subject<void>,\n                initiallyVisible = true,\n                protected _bracketSubPredicateText = false) {\n        super(parentNotifier, initiallyVisible);\n        this._predicates = new Map<number, Predicate>();\n        this._childUpdated$ = new Subject<void>();\n        this._childCounter = new IncrementingCounter();\n        this._query = Query.emptyQuery();\n        this.initializeFilterTextSegmentsGenerator();\n\n        this._childUpdated$.subscribe(() => {\n            this.updateQueryAndNotify();\n        });\n    }\n\n    ngOnDestroy(): void {\n        this._childUpdated$.complete();\n    }\n\n    get query(): Query {\n        return this._query;\n    }\n\n    show() {\n        super.show();\n        this.showAll();\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 showPredicates(predicateIds: Array<number>): void {\n        predicateIds.forEach(id => {\n            if (this._predicates.has(id)) {\n                this._predicates.get(id).show();\n            }\n        });\n    }\n\n    /**\n     * Adds new child predicate of type {@link EditableElementaryPredicate}\n     * @param initiallyVisible whether the new predicate should be initially visible\n     */\n    addNewElementaryPredicate(initiallyVisible = true): number {\n        return this.addPredicate(new EditableElementaryPredicate(this._childUpdated$, initiallyVisible));\n    }\n\n    /**\n     * Adds new child predicate of type {@link EditableClausePredicate}\n     * @param operator the operator of the child clause predicate\n     * @param initiallyVisible whether the new predicate should be initially visible\n     */\n    addNewClausePredicate(operator: BooleanOperator, initiallyVisible = true): number {\n        return this.addPredicate(new EditableClausePredicate(operator, this._childUpdated$, initiallyVisible));\n    }\n\n    /**\n     * Generates an id for the new predicate, adds it into the map and updates the query\n     *\n     * If you want to add an editable predicate, use one of the other methods, so that this predicate can react to changes.\n     * @param predicate the new predicate\n     */\n    public addPredicate(predicate: Predicate): number {\n        const id = this._childCounter.next();\n        this._predicates.set(id, predicate);\n        this.updateQueryAndNotify();\n        return id;\n    }\n\n    removePredicate(id: number): boolean {\n        const r = this._predicates.delete(id);\n        this.updateQueryAndNotify();\n        return r;\n    }\n\n    public getPredicateMap(): Map<number, Predicate> {\n        return this._predicates;\n    }\n\n    /**\n     * Updates the `Query` and notifies the parent.\n     */\n    protected updateQueryAndNotify(): void {\n        this.updateQuery();\n        this.notifyParentPredicate();\n    }\n\n    /**\n     * Updates the value of the [_query]{@link ClausePredicate#_query} attribute.\n     *\n     * See [combineQueries()]{@link Query#combineQueries} for more information.\n     */\n    protected updateQuery(): void {\n        this._query = Query.combineQueries(this.queries, this._operator);\n    }\n\n    /**\n     * @returns the `Array` of {@link Query} objects stored within this object's [_predicates]{@link ClausePredicate#_predicates} attribute.\n     */\n    protected get queries(): Array<Query> {\n        return Array.from(this._predicates.values()).map(p => p.query);\n    }\n\n    /**\n     * Sets this predicate and all its sub-predicates to visible.\n     */\n    protected showAll(): void {\n        for (const p of this._predicates.values()) {\n            p.show();\n        }\n    }\n\n    private initializeFilterTextSegmentsGenerator() {\n        this._filterTextSegmentsGenerator = () => {\n            return Predicate.combineTextSegmentsWithBooleanOperator(this._predicates.values(),\n                this._operator, this._bracketSubPredicateText);\n        };\n    }\n}\n"]}

package/esm2015/lib/search/models/predicate/editable-elementary-predicate.js

@@ -0,0 +1,20 @@
+import { Query } from '../query/query';
+import { EditablePredicate } from './editable-predicate';
+/**
+ * A simple, editable type of `Predicate`. Represents a leaf node in the predicate tree, that can change the `Query` it holds
+ * and can notify the parent tree node about changes.
+ */
+export class EditableElementaryPredicate extends EditablePredicate {
+    constructor(parentNotifier, initiallyVisible = true) {
+        super(parentNotifier, initiallyVisible);
+        this._query = Query.emptyQuery();
+    }
+    get query() {
+        return this._query;
+    }
+    set query(query) {
+        this._query = query;
+        this.notifyParentPredicate();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWRpdGFibGUtZWxlbWVudGFyeS1wcmVkaWNhdGUuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvc2VhcmNoL21vZGVscy9wcmVkaWNhdGUvZWRpdGFibGUtZWxlbWVudGFyeS1wcmVkaWNhdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFDLEtBQUssRUFBQyxNQUFNLGdCQUFnQixDQUFDO0FBQ3JDLE9BQU8sRUFBQyxpQkFBaUIsRUFBQyxNQUFNLHNCQUFzQixDQUFDO0FBRXZEOzs7R0FHRztBQUNILE1BQU0sT0FBTywyQkFBNEIsU0FBUSxpQkFBaUI7SUFJOUQsWUFBWSxjQUE4QixFQUFFLGdCQUFnQixHQUFHLElBQUk7UUFDL0QsS0FBSyxDQUFDLGNBQWMsRUFBRSxnQkFBZ0IsQ0FBQyxDQUFDO1FBQ3hDLElBQUksQ0FBQyxNQUFNLEdBQUcsS0FBSyxDQUFDLFVBQVUsRUFBRSxDQUFDO0lBQ3JDLENBQUM7SUFFRCxJQUFJLEtBQUs7UUFDTCxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUM7SUFDdkIsQ0FBQztJQUVELElBQUksS0FBSyxDQUFDLEtBQVk7UUFDbEIsSUFBSSxDQUFDLE1BQU0sR0FBRyxLQUFLLENBQUM7UUFDcEIsSUFBSSxDQUFDLHFCQUFxQixFQUFFLENBQUM7SUFDakMsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtTdWJqZWN0fSBmcm9tICdyeGpzJztcbmltcG9ydCB7UXVlcnl9IGZyb20gJy4uL3F1ZXJ5L3F1ZXJ5JztcbmltcG9ydCB7RWRpdGFibGVQcmVkaWNhdGV9IGZyb20gJy4vZWRpdGFibGUtcHJlZGljYXRlJztcblxuLyoqXG4gKiBBIHNpbXBsZSwgZWRpdGFibGUgdHlwZSBvZiBgUHJlZGljYXRlYC4gUmVwcmVzZW50cyBhIGxlYWYgbm9kZSBpbiB0aGUgcHJlZGljYXRlIHRyZWUsIHRoYXQgY2FuIGNoYW5nZSB0aGUgYFF1ZXJ5YCBpdCBob2xkc1xuICogYW5kIGNhbiBub3RpZnkgdGhlIHBhcmVudCB0cmVlIG5vZGUgYWJvdXQgY2hhbmdlcy5cbiAqL1xuZXhwb3J0IGNsYXNzIEVkaXRhYmxlRWxlbWVudGFyeVByZWRpY2F0ZSBleHRlbmRzIEVkaXRhYmxlUHJlZGljYXRlIHtcblxuICAgIHByb3RlY3RlZCBfcXVlcnk6IFF1ZXJ5O1xuXG4gICAgY29uc3RydWN0b3IocGFyZW50Tm90aWZpZXI/OiBTdWJqZWN0PHZvaWQ+LCBpbml0aWFsbHlWaXNpYmxlID0gdHJ1ZSkge1xuICAgICAgICBzdXBlcihwYXJlbnROb3RpZmllciwgaW5pdGlhbGx5VmlzaWJsZSk7XG4gICAgICAgIHRoaXMuX3F1ZXJ5ID0gUXVlcnkuZW1wdHlRdWVyeSgpO1xuICAgIH1cblxuICAgIGdldCBxdWVyeSgpOiBRdWVyeSB7XG4gICAgICAgIHJldHVybiB0aGlzLl9xdWVyeTtcbiAgICB9XG5cbiAgICBzZXQgcXVlcnkocXVlcnk6IFF1ZXJ5KSB7XG4gICAgICAgIHRoaXMuX3F1ZXJ5ID0gcXVlcnk7XG4gICAgICAgIHRoaXMubm90aWZ5UGFyZW50UHJlZGljYXRlKCk7XG4gICAgfVxufVxuIl19

package/esm2015/lib/search/models/predicate/editable-predicate-with-generator.js

@@ -0,0 +1,37 @@
+import { PredicateWithGenerator } from './predicate-with-generator';
+import { EditableElementaryPredicate } from './editable-elementary-predicate';
+/**
+ * An editable predicate wrapper, that can contain a generator of a Predicate.
+ *
+ * This class is used to transfer editable search predicates added by other means into the search GUI and
+ * bind them to the search predicate update notifications.
+ */
+export class EditablePredicateWithGenerator extends PredicateWithGenerator {
+    /**
+     * Creates a new `EditablePredicateWithGenerator` instance from a generator.
+     *
+     * The created wrapped {@link EditablePredicate} instance has no parent notifier set.
+     * If you want it to send notifications to a parent predicate you must add it yourself.
+     * @param generator the generator generating the predicate
+     * @param initiallyVisible whether the predicate is initially visible
+     * @returns a new `EditablePredicateWithGenerator` instance, with the predicate set to the predicate generated by the generator.
+     * If the generator generates no predicate, it will be set to an empty predicate.
+     */
+    constructor(generator, initiallyVisible) {
+        const predicate = new EditableElementaryPredicate(undefined, initiallyVisible);
+        if (generator.providesPredicate) {
+            predicate.query = generator.generatedPredicate.query;
+        }
+        super(predicate, generator, initiallyVisible);
+    }
+    /**
+     * Sets the `parentNotifier` on the wrapped {@link EditablePredicate} instance.
+     */
+    set parentNotifier(parentNotifier) {
+        this.getWrappedPredicate().parentNotifier = parentNotifier;
+    }
+    getWrappedPredicate() {
+        return super.getWrappedPredicate();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/search/models/predicate/editable-predicate.js

@@ -0,0 +1,22 @@
+import { Predicate } from './predicate';
+/**
+ * Base class for editable predicates that allows them to notify their parent predicate tree nodes about updates to their queries.
+ */
+export class EditablePredicate extends Predicate {
+    constructor(parentNotifier, initiallyVisible = true) {
+        super(initiallyVisible);
+        this._parentNotifier = parentNotifier;
+    }
+    /**
+     * Notify the parent `Predicate` that this `Predicate` updated its `Query`
+     */
+    notifyParentPredicate() {
+        if (this._parentNotifier && !this._parentNotifier.isStopped) {
+            this._parentNotifier.next();
+        }
+    }
+    set parentNotifier(parentNotifier) {
+        this._parentNotifier = parentNotifier;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/search/models/predicate/elementary-predicate.js

@@ -0,0 +1,14 @@
+import { Predicate } from './predicate';
+/**
+ * The simples type of `Predicate`. Represents a leaf node in the predicate tree.
+ */
+export class ElementaryPredicate extends Predicate {
+    constructor(_query, initiallyVisible = true) {
+        super(initiallyVisible);
+        this._query = _query;
+    }
+    get query() {
+        return this._query;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWxlbWVudGFyeS1wcmVkaWNhdGUuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvc2VhcmNoL21vZGVscy9wcmVkaWNhdGUvZWxlbWVudGFyeS1wcmVkaWNhdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFNBQVMsRUFBQyxNQUFNLGFBQWEsQ0FBQztBQUd0Qzs7R0FFRztBQUNILE1BQU0sT0FBTyxtQkFBb0IsU0FBUSxTQUFTO0lBRTlDLFlBQXNCLE1BQWEsRUFBRSxnQkFBZ0IsR0FBRyxJQUFJO1FBQ3hELEtBQUssQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDO1FBRE4sV0FBTSxHQUFOLE1BQU0sQ0FBTztJQUVuQyxDQUFDO0lBRUQsSUFBSSxLQUFLO1FBQ0wsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDO0lBQ3ZCLENBQUM7Q0FFSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7UHJlZGljYXRlfSBmcm9tICcuL3ByZWRpY2F0ZSc7XG5pbXBvcnQge1F1ZXJ5fSBmcm9tICcuLi9xdWVyeS9xdWVyeSc7XG5cbi8qKlxuICogVGhlIHNpbXBsZXMgdHlwZSBvZiBgUHJlZGljYXRlYC4gUmVwcmVzZW50cyBhIGxlYWYgbm9kZSBpbiB0aGUgcHJlZGljYXRlIHRyZWUuXG4gKi9cbmV4cG9ydCBjbGFzcyBFbGVtZW50YXJ5UHJlZGljYXRlIGV4dGVuZHMgUHJlZGljYXRlIHtcblxuICAgIGNvbnN0cnVjdG9yKHByb3RlY3RlZCBfcXVlcnk6IFF1ZXJ5LCBpbml0aWFsbHlWaXNpYmxlID0gdHJ1ZSkge1xuICAgICAgICBzdXBlcihpbml0aWFsbHlWaXNpYmxlKTtcbiAgICB9XG5cbiAgICBnZXQgcXVlcnkoKTogUXVlcnkge1xuICAgICAgICByZXR1cm4gdGhpcy5fcXVlcnk7XG4gICAgfVxuXG59XG4iXX0=

package/esm2015/lib/search/models/predicate/predicate-with-generator.js

@@ -0,0 +1,95 @@
+import { Predicate } from './predicate';
+import { EditableElementaryPredicate } from './editable-elementary-predicate';
+/**
+ * A predicate wrapper, that can contain a generator of a Predicate.
+ *
+ * This class is used to transfer search predicates added by other means into the search GUI.
+ */
+export class PredicateWithGenerator extends Predicate {
+    /**
+     * @param _predicate the wrapped predicate
+     * @param _generator the `Category` instance that generates this predicate.
+     * If a generator is provided, the predicate is marked as initially hidden.
+     * @param initiallyVisible overrides the initial visibility inferred from the presence/absence of the generator
+     */
+    constructor(_predicate, _generator, initiallyVisible) {
+        super();
+        this._predicate = _predicate;
+        this._generator = _generator;
+        this._visible = initiallyVisible !== null && initiallyVisible !== void 0 ? initiallyVisible : !_generator;
+        this.initializeMetadataGenerator();
+        this.initializeFilterTextSegmentsGenerator();
+    }
+    get query() {
+        return this._predicate.query;
+    }
+    /**
+     * Can only be called if the wrapped predicate allows setting of the query.
+     * Throws an error otherwise.
+     * @param query the new query
+     */
+    set query(query) {
+        if (this._predicate instanceof EditableElementaryPredicate) {
+            this._predicate.query = query;
+        }
+        else {
+            throw new Error('The wrapped predicate cannot have its query set');
+        }
+    }
+    /**
+     * @returns the Category that generates the predicate, or `undefined` if none was provided during the creation of this instance.
+     */
+    get generator() {
+        return this._generator;
+    }
+    /**
+     * @returns the wrapped Predicate
+     */
+    getWrappedPredicate() {
+        return this._predicate;
+    }
+    /**
+     * @returns result [getWrappedPredicate()]{@link PredicateWithGenerator#getWrappedPredicate}
+     */
+    get wrappedPredicate() {
+        return this.getWrappedPredicate();
+    }
+    show() {
+        super.show();
+        this._predicate.show();
+    }
+    /**
+     * Cleans-up the inner state of this object.
+     */
+    destroy() {
+        if (this._generator !== undefined) {
+            this.generator.destroy();
+        }
+    }
+    initializeMetadataGenerator() {
+        this._metadataGenerator = () => {
+            try {
+                return this._predicate.createGeneratorMetadata();
+            }
+            catch (e) {
+                if (this._generator && this._generator.providesPredicate) {
+                    return this._generator.createMetadata();
+                }
+                throw e;
+            }
+        };
+    }
+    initializeFilterTextSegmentsGenerator() {
+        this._filterTextSegmentsGenerator = () => {
+            const segments = this._predicate.createFilterTextSegments();
+            if (segments.length > 0) {
+                return segments;
+            }
+            if (this._generator && this._generator.providesPredicate) {
+                return this._generator.createFilterTextSegments();
+            }
+            return [];
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/search/models/predicate/predicate.js

@@ -0,0 +1,90 @@
+import { BooleanOperator } from '../boolean-operator';
+/**
+ * Building block of search queries. Represents any node in a tree of predicates, that are combined with {@link BooleanOperator}s to create
+ * a search query.
+ *
+ * See {@link SearchService} for more information.
+ */
+export class Predicate {
+    /**
+     * @param initiallyVisible whether the predicate should be initially displayed or not
+     */
+    constructor(initiallyVisible = true) {
+        this._visible = !!initiallyVisible;
+        this._metadataGenerator = () => {
+            throw new Error('This predicate has no metadata generator registered!');
+        };
+        this._filterTextSegmentsGenerator = () => {
+            return [];
+        };
+    }
+    /**
+     * @returns whether the Predicate should be displayed, or not
+     */
+    get isVisible() {
+        return this._visible;
+    }
+    /**
+     * Combines the text segments of the predicates with the given operator and wraps the individual predicates in brackets optionaly
+     * @param predicates sources of text segments that are to be combined with a boolean operator
+     * @param operator boolean operator used to combine the individual predicate text segments
+     * @param wrapWithBrackets whether the individual predicate text segments should be wrapped in braces or not
+     * (if only one predicate is provided it is never wrapped)
+     */
+    static combineTextSegmentsWithBooleanOperator(predicates, operator, wrapWithBrackets = false) {
+        const result = [];
+        let first = true;
+        let hasTwo = false;
+        for (const predicate of predicates) {
+            const textSegments = predicate.createFilterTextSegments();
+            if (textSegments.length > 0) {
+                if (!first) {
+                    if (!hasTwo && wrapWithBrackets) {
+                        result.unshift({ segment: '(' });
+                        hasTwo = true;
+                    }
+                    if (wrapWithBrackets) {
+                        result.push({ segment: ')' });
+                    }
+                    result.push({ segment: operator === BooleanOperator.AND ? 'search.and' : 'search.or', uppercase: true });
+                    if (wrapWithBrackets) {
+                        result.push({ segment: '(' });
+                    }
+                }
+                result.push(...textSegments);
+                first = false;
+            }
+        }
+        if (hasTwo && wrapWithBrackets) {
+            result.push({ segment: ')' });
+        }
+        return result;
+    }
+    /**
+     * Sets the predicates state to `visible`
+     */
+    show() {
+        this._visible = true;
+    }
+    setMetadataGenerator(metadataGenerator) {
+        this._metadataGenerator = metadataGenerator;
+    }
+    /**
+     * @returns an object containing the necessary information for the reconstruction of the entire predicate tree in serializable form.
+     * Returns `undefined` if the predicate tree rooted at this node is incomplete and would evaluate into an empty filter.
+     */
+    createGeneratorMetadata() {
+        return this._metadataGenerator();
+    }
+    setFilterTextSegmentsGenerator(filterTextSegmentsGenerator) {
+        this._filterTextSegmentsGenerator = filterTextSegmentsGenerator;
+    }
+    /**
+     * @returns an Array containing text segments representing the content of this predicate.
+     * The default implementation returns an empty array.
+     */
+    createFilterTextSegments() {
+        return this._filterTextSegmentsGenerator();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"predicate.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/search/models/predicate/predicate.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,eAAe,EAAC,MAAM,qBAAqB,CAAC;AAEpD;;;;;GAKG;AACH,MAAM,OAAgB,SAAS;IAM3B;;OAEG;IACH,YAAsB,gBAAgB,GAAG,IAAI;QACzC,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC,gBAAgB,CAAC;QACnC,IAAI,CAAC,kBAAkB,GAAG,GAAG,EAAE;YAC3B,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;QAC5E,CAAC,CAAC;QACF,IAAI,CAAC,4BAA4B,GAAG,GAAG,EAAE;YACrC,OAAO,EAAE,CAAC;QACd,CAAC,CAAC;IACN,CAAC;IAED;;OAEG;IACH,IAAW,SAAS;QAChB,OAAO,IAAI,CAAC,QAAQ,CAAC;IACzB,CAAC;IAQD;;;;;;OAMG;IACI,MAAM,CAAC,sCAAsC,CAAC,UAA0D,EAC1D,QAAyB,EACzB,gBAAgB,GAAG,KAAK;QACzE,MAAM,MAAM,GAA6B,EAAE,CAAC;QAC5C,IAAI,KAAK,GAAG,IAAI,CAAC;QACjB,IAAI,MAAM,GAAG,KAAK,CAAC;QACnB,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE;YAChC,MAAM,YAAY,GAAG,SAAS,CAAC,wBAAwB,EAAE,CAAC;YAC1D,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE;gBACzB,IAAI,CAAC,KAAK,EAAE;oBACR,IAAI,CAAC,MAAM,IAAI,gBAAgB,EAAE;wBAC7B,MAAM,CAAC,OAAO,CAAC,EAAC,OAAO,EAAE,GAAG,EAAC,CAAC,CAAC;wBAC/B,MAAM,GAAG,IAAI,CAAC;qBACjB;oBACD,IAAI,gBAAgB,EAAE;wBAClB,MAAM,CAAC,IAAI,CAAC,EAAC,OAAO,EAAE,GAAG,EAAC,CAAC,CAAC;qBAC/B;oBACD,MAAM,CAAC,IAAI,CAAC,EAAC,OAAO,EAAE,QAAQ,KAAK,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,WAAW,EAAE,SAAS,EAAE,IAAI,EAAC,CAAC,CAAC;oBACvG,IAAI,gBAAgB,EAAE;wBAClB,MAAM,CAAC,IAAI,CAAC,EAAC,OAAO,EAAE,GAAG,EAAC,CAAC,CAAC;qBAC/B;iBACJ;gBACD,MAAM,CAAC,IAAI,CAAC,GAAG,YAAY,CAAC,CAAC;gBAC7B,KAAK,GAAG,KAAK,CAAC;aACjB;SACJ;QACD,IAAI,MAAM,IAAI,gBAAgB,EAAE;YAC5B,MAAM,CAAC,IAAI,CAAC,EAAC,OAAO,EAAE,GAAG,EAAC,CAAC,CAAC;SAC/B;QACD,OAAO,MAAM,CAAC;IAClB,CAAC;IAED;;OAEG;IACI,IAAI;QACP,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;IACzB,CAAC;IAEM,oBAAoB,CAAC,iBAAsD;QAC9E,IAAI,CAAC,kBAAkB,GAAG,iBAAiB,CAAC;IAChD,CAAC;IAED;;;OAGG;IACI,uBAAuB;QAC1B,OAAO,IAAI,CAAC,kBAAkB,EAAE,CAAC;IACrC,CAAC;IAEM,8BAA8B,CAAC,2BAA2D;QAC7F,IAAI,CAAC,4BAA4B,GAAG,2BAA2B,CAAC;IACpE,CAAC;IAED;;;OAGG;IACI,wBAAwB;QAC3B,OAAO,IAAI,CAAC,4BAA4B,EAAE,CAAC;IAC/C,CAAC;CACJ","sourcesContent":["import {Query} from '../query/query';\nimport {GeneratorMetadata} from '../persistance/generator-metadata';\nimport {FilterTextSegment} from '../persistance/filter-text-segment';\nimport {BooleanOperator} from '../boolean-operator';\n\n/**\n * Building block of search queries. Represents any node in a tree of predicates, that are combined with {@link BooleanOperator}s to create\n * a search query.\n *\n * See {@link SearchService} for more information.\n */\nexport abstract class Predicate {\n\n    protected _visible: boolean;\n    protected _metadataGenerator: () => GeneratorMetadata | undefined;\n    protected _filterTextSegmentsGenerator: () => Array<FilterTextSegment>;\n\n    /**\n     * @param initiallyVisible whether the predicate should be initially displayed or not\n     */\n    protected constructor(initiallyVisible = true) {\n        this._visible = !!initiallyVisible;\n        this._metadataGenerator = () => {\n            throw new Error('This predicate has no metadata generator registered!');\n        };\n        this._filterTextSegmentsGenerator = () => {\n            return [];\n        };\n    }\n\n    /**\n     * @returns whether the Predicate should be displayed, or not\n     */\n    public get isVisible(): boolean {\n        return this._visible;\n    }\n\n    /**\n     * @returns the {@link Query} object that corresponds to the `Query` for the entire subtree of Predicates, with\n     * this Predicate as it's root node.\n     */\n    public abstract get query(): Query;\n\n    /**\n     * Combines the text segments of the predicates with the given operator and wraps the individual predicates in brackets optionaly\n     * @param predicates sources of text segments that are to be combined with a boolean operator\n     * @param operator boolean operator used to combine the individual predicate text segments\n     * @param wrapWithBrackets whether the individual predicate text segments should be wrapped in braces or not\n     * (if only one predicate is provided it is never wrapped)\n     */\n    public static combineTextSegmentsWithBooleanOperator(predicates: IterableIterator<Predicate> | Array<Predicate>,\n                                                         operator: BooleanOperator,\n                                                         wrapWithBrackets = false): Array<FilterTextSegment> {\n        const result: Array<FilterTextSegment> = [];\n        let first = true;\n        let hasTwo = false;\n        for (const predicate of predicates) {\n            const textSegments = predicate.createFilterTextSegments();\n            if (textSegments.length > 0) {\n                if (!first) {\n                    if (!hasTwo && wrapWithBrackets) {\n                        result.unshift({segment: '('});\n                        hasTwo = true;\n                    }\n                    if (wrapWithBrackets) {\n                        result.push({segment: ')'});\n                    }\n                    result.push({segment: operator === BooleanOperator.AND ? 'search.and' : 'search.or', uppercase: true});\n                    if (wrapWithBrackets) {\n                        result.push({segment: '('});\n                    }\n                }\n                result.push(...textSegments);\n                first = false;\n            }\n        }\n        if (hasTwo && wrapWithBrackets) {\n            result.push({segment: ')'});\n        }\n        return result;\n    }\n\n    /**\n     * Sets the predicates state to `visible`\n     */\n    public show(): void {\n        this._visible = true;\n    }\n\n    public setMetadataGenerator(metadataGenerator: () => GeneratorMetadata | undefined) {\n        this._metadataGenerator = metadataGenerator;\n    }\n\n    /**\n     * @returns an object containing the necessary information for the reconstruction of the entire predicate tree in serializable form.\n     * Returns `undefined` if the predicate tree rooted at this node is incomplete and would evaluate into an empty filter.\n     */\n    public createGeneratorMetadata(): GeneratorMetadata | undefined {\n        return this._metadataGenerator();\n    }\n\n    public setFilterTextSegmentsGenerator(filterTextSegmentsGenerator: () => Array<FilterTextSegment>) {\n        this._filterTextSegmentsGenerator = filterTextSegmentsGenerator;\n    }\n\n    /**\n     * @returns an Array containing text segments representing the content of this predicate.\n     * The default implementation returns an empty array.\n     */\n    public createFilterTextSegments(): Array<FilterTextSegment> {\n        return this._filterTextSegmentsGenerator();\n    }\n}\n"]}

package/esm2015/lib/search/models/predicate-removal-event.js

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