@netgrif/components-core 6.0.1

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

@@ -0,0 +1,32 @@
+import { __extends } from "tslib";
+import { Predicate } from './predicate';
+/**
+ * Base class for editable predicates that allows them to notify their parent predicate tree nodes about updates to their queries.
+ */
+var EditablePredicate = /** @class */ (function (_super) {
+    __extends(EditablePredicate, _super);
+    function EditablePredicate(parentNotifier, initiallyVisible) {
+        if (initiallyVisible === void 0) { initiallyVisible = true; }
+        var _this = _super.call(this, initiallyVisible) || this;
+        _this._parentNotifier = parentNotifier;
+        return _this;
+    }
+    /**
+     * Notify the parent `Predicate` that this `Predicate` updated its `Query`
+     */
+    EditablePredicate.prototype.notifyParentPredicate = function () {
+        if (this._parentNotifier && !this._parentNotifier.isStopped) {
+            this._parentNotifier.next();
+        }
+    };
+    Object.defineProperty(EditablePredicate.prototype, "parentNotifier", {
+        set: function (parentNotifier) {
+            this._parentNotifier = parentNotifier;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return EditablePredicate;
+}(Predicate));
+export { EditablePredicate };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,24 @@
+import { __extends } from "tslib";
+import { Predicate } from './predicate';
+/**
+ * The simples type of `Predicate`. Represents a leaf node in the predicate tree.
+ */
+var ElementaryPredicate = /** @class */ (function (_super) {
+    __extends(ElementaryPredicate, _super);
+    function ElementaryPredicate(_query, initiallyVisible) {
+        if (initiallyVisible === void 0) { initiallyVisible = true; }
+        var _this = _super.call(this, initiallyVisible) || this;
+        _this._query = _query;
+        return _this;
+    }
+    Object.defineProperty(ElementaryPredicate.prototype, "query", {
+        get: function () {
+            return this._query;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return ElementaryPredicate;
+}(Predicate));
+export { ElementaryPredicate };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWxlbWVudGFyeS1wcmVkaWNhdGUuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvc2VhcmNoL21vZGVscy9wcmVkaWNhdGUvZWxlbWVudGFyeS1wcmVkaWNhdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBQyxTQUFTLEVBQUMsTUFBTSxhQUFhLENBQUM7QUFHdEM7O0dBRUc7QUFDSDtJQUF5Qyx1Q0FBUztJQUU5Qyw2QkFBc0IsTUFBYSxFQUFFLGdCQUF1QjtRQUF2QixpQ0FBQSxFQUFBLHVCQUF1QjtRQUE1RCxZQUNJLGtCQUFNLGdCQUFnQixDQUFDLFNBQzFCO1FBRnFCLFlBQU0sR0FBTixNQUFNLENBQU87O0lBRW5DLENBQUM7SUFFRCxzQkFBSSxzQ0FBSzthQUFUO1lBQ0ksT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDO1FBQ3ZCLENBQUM7OztPQUFBO0lBRUwsMEJBQUM7QUFBRCxDQUFDLEFBVkQsQ0FBeUMsU0FBUyxHQVVqRCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7UHJlZGljYXRlfSBmcm9tICcuL3ByZWRpY2F0ZSc7XG5pbXBvcnQge1F1ZXJ5fSBmcm9tICcuLi9xdWVyeS9xdWVyeSc7XG5cbi8qKlxuICogVGhlIHNpbXBsZXMgdHlwZSBvZiBgUHJlZGljYXRlYC4gUmVwcmVzZW50cyBhIGxlYWYgbm9kZSBpbiB0aGUgcHJlZGljYXRlIHRyZWUuXG4gKi9cbmV4cG9ydCBjbGFzcyBFbGVtZW50YXJ5UHJlZGljYXRlIGV4dGVuZHMgUHJlZGljYXRlIHtcblxuICAgIGNvbnN0cnVjdG9yKHByb3RlY3RlZCBfcXVlcnk6IFF1ZXJ5LCBpbml0aWFsbHlWaXNpYmxlID0gdHJ1ZSkge1xuICAgICAgICBzdXBlcihpbml0aWFsbHlWaXNpYmxlKTtcbiAgICB9XG5cbiAgICBnZXQgcXVlcnkoKTogUXVlcnkge1xuICAgICAgICByZXR1cm4gdGhpcy5fcXVlcnk7XG4gICAgfVxuXG59XG4iXX0=

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

@@ -0,0 +1,114 @@
+import { __extends } from "tslib";
+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.
+ */
+var PredicateWithGenerator = /** @class */ (function (_super) {
+    __extends(PredicateWithGenerator, _super);
+    /**
+     * @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
+     */
+    function PredicateWithGenerator(_predicate, _generator, initiallyVisible) {
+        var _this = _super.call(this) || this;
+        _this._predicate = _predicate;
+        _this._generator = _generator;
+        _this._visible = initiallyVisible !== null && initiallyVisible !== void 0 ? initiallyVisible : !_generator;
+        _this.initializeMetadataGenerator();
+        _this.initializeFilterTextSegmentsGenerator();
+        return _this;
+    }
+    Object.defineProperty(PredicateWithGenerator.prototype, "query", {
+        get: function () {
+            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: function (query) {
+            if (this._predicate instanceof EditableElementaryPredicate) {
+                this._predicate.query = query;
+            }
+            else {
+                throw new Error('The wrapped predicate cannot have its query set');
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PredicateWithGenerator.prototype, "generator", {
+        /**
+         * @returns the Category that generates the predicate, or `undefined` if none was provided during the creation of this instance.
+         */
+        get: function () {
+            return this._generator;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * @returns the wrapped Predicate
+     */
+    PredicateWithGenerator.prototype.getWrappedPredicate = function () {
+        return this._predicate;
+    };
+    Object.defineProperty(PredicateWithGenerator.prototype, "wrappedPredicate", {
+        /**
+         * @returns result [getWrappedPredicate()]{@link PredicateWithGenerator#getWrappedPredicate}
+         */
+        get: function () {
+            return this.getWrappedPredicate();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PredicateWithGenerator.prototype.show = function () {
+        _super.prototype.show.call(this);
+        this._predicate.show();
+    };
+    /**
+     * Cleans-up the inner state of this object.
+     */
+    PredicateWithGenerator.prototype.destroy = function () {
+        if (this._generator !== undefined) {
+            this.generator.destroy();
+        }
+    };
+    PredicateWithGenerator.prototype.initializeMetadataGenerator = function () {
+        var _this = this;
+        this._metadataGenerator = function () {
+            try {
+                return _this._predicate.createGeneratorMetadata();
+            }
+            catch (e) {
+                if (_this._generator && _this._generator.providesPredicate) {
+                    return _this._generator.createMetadata();
+                }
+                throw e;
+            }
+        };
+    };
+    PredicateWithGenerator.prototype.initializeFilterTextSegmentsGenerator = function () {
+        var _this = this;
+        this._filterTextSegmentsGenerator = function () {
+            var segments = _this._predicate.createFilterTextSegments();
+            if (segments.length > 0) {
+                return segments;
+            }
+            if (_this._generator && _this._generator.providesPredicate) {
+                return _this._generator.createFilterTextSegments();
+            }
+            return [];
+        };
+    };
+    return PredicateWithGenerator;
+}(Predicate));
+export { PredicateWithGenerator };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,110 @@
+import { __read, __spread, __values } from "tslib";
+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.
+ */
+var Predicate = /** @class */ (function () {
+    /**
+     * @param initiallyVisible whether the predicate should be initially displayed or not
+     */
+    function Predicate(initiallyVisible) {
+        if (initiallyVisible === void 0) { initiallyVisible = true; }
+        this._visible = !!initiallyVisible;
+        this._metadataGenerator = function () {
+            throw new Error('This predicate has no metadata generator registered!');
+        };
+        this._filterTextSegmentsGenerator = function () {
+            return [];
+        };
+    }
+    Object.defineProperty(Predicate.prototype, "isVisible", {
+        /**
+         * @returns whether the Predicate should be displayed, or not
+         */
+        get: function () {
+            return this._visible;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * 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)
+     */
+    Predicate.combineTextSegmentsWithBooleanOperator = function (predicates, operator, wrapWithBrackets) {
+        var e_1, _a;
+        if (wrapWithBrackets === void 0) { wrapWithBrackets = false; }
+        var result = [];
+        var first = true;
+        var hasTwo = false;
+        try {
+            for (var predicates_1 = __values(predicates), predicates_1_1 = predicates_1.next(); !predicates_1_1.done; predicates_1_1 = predicates_1.next()) {
+                var predicate = predicates_1_1.value;
+                var 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.apply(result, __spread(textSegments));
+                    first = false;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (predicates_1_1 && !predicates_1_1.done && (_a = predicates_1.return)) _a.call(predicates_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        if (hasTwo && wrapWithBrackets) {
+            result.push({ segment: ')' });
+        }
+        return result;
+    };
+    /**
+     * Sets the predicates state to `visible`
+     */
+    Predicate.prototype.show = function () {
+        this._visible = true;
+    };
+    Predicate.prototype.setMetadataGenerator = function (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.
+     */
+    Predicate.prototype.createGeneratorMetadata = function () {
+        return this._metadataGenerator();
+    };
+    Predicate.prototype.setFilterTextSegmentsGenerator = function (filterTextSegmentsGenerator) {
+        this._filterTextSegmentsGenerator = filterTextSegmentsGenerator;
+    };
+    /**
+     * @returns an Array containing text segments representing the content of this predicate.
+     * The default implementation returns an empty array.
+     */
+    Predicate.prototype.createFilterTextSegments = function () {
+        return this._filterTextSegmentsGenerator();
+    };
+    return Predicate;
+}());
+export { Predicate };
+//# 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;IAMI;;OAEG;IACH,mBAAsB,gBAAuB;QAAvB,iCAAA,EAAA,uBAAuB;QACzC,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC,gBAAgB,CAAC;QACnC,IAAI,CAAC,kBAAkB,GAAG;YACtB,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;QAC5E,CAAC,CAAC;QACF,IAAI,CAAC,4BAA4B,GAAG;YAChC,OAAO,EAAE,CAAC;QACd,CAAC,CAAC;IACN,CAAC;IAKD,sBAAW,gCAAS;QAHpB;;WAEG;aACH;YACI,OAAO,IAAI,CAAC,QAAQ,CAAC;QACzB,CAAC;;;OAAA;IAQD;;;;;;OAMG;IACW,gDAAsC,GAApD,UAAqD,UAA0D,EAC1D,QAAyB,EACzB,gBAAwB;;QAAxB,iCAAA,EAAA,wBAAwB;QACzE,IAAM,MAAM,GAA6B,EAAE,CAAC;QAC5C,IAAI,KAAK,GAAG,IAAI,CAAC;QACjB,IAAI,MAAM,GAAG,KAAK,CAAC;;YACnB,KAAwB,IAAA,eAAA,SAAA,UAAU,CAAA,sCAAA,8DAAE;gBAA/B,IAAM,SAAS,uBAAA;gBAChB,IAAM,YAAY,GAAG,SAAS,CAAC,wBAAwB,EAAE,CAAC;gBAC1D,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE;oBACzB,IAAI,CAAC,KAAK,EAAE;wBACR,IAAI,CAAC,MAAM,IAAI,gBAAgB,EAAE;4BAC7B,MAAM,CAAC,OAAO,CAAC,EAAC,OAAO,EAAE,GAAG,EAAC,CAAC,CAAC;4BAC/B,MAAM,GAAG,IAAI,CAAC;yBACjB;wBACD,IAAI,gBAAgB,EAAE;4BAClB,MAAM,CAAC,IAAI,CAAC,EAAC,OAAO,EAAE,GAAG,EAAC,CAAC,CAAC;yBAC/B;wBACD,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;wBACvG,IAAI,gBAAgB,EAAE;4BAClB,MAAM,CAAC,IAAI,CAAC,EAAC,OAAO,EAAE,GAAG,EAAC,CAAC,CAAC;yBAC/B;qBACJ;oBACD,MAAM,CAAC,IAAI,OAAX,MAAM,WAAS,YAAY,GAAE;oBAC7B,KAAK,GAAG,KAAK,CAAC;iBACjB;aACJ;;;;;;;;;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,wBAAI,GAAX;QACI,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;IACzB,CAAC;IAEM,wCAAoB,GAA3B,UAA4B,iBAAsD;QAC9E,IAAI,CAAC,kBAAkB,GAAG,iBAAiB,CAAC;IAChD,CAAC;IAED;;;OAGG;IACI,2CAAuB,GAA9B;QACI,OAAO,IAAI,CAAC,kBAAkB,EAAE,CAAC;IACrC,CAAC;IAEM,kDAA8B,GAArC,UAAsC,2BAA2D;QAC7F,IAAI,CAAC,4BAA4B,GAAG,2BAA2B,CAAC;IACpE,CAAC;IAED;;;OAGG;IACI,4CAAwB,GAA/B;QACI,OAAO,IAAI,CAAC,4BAA4B,EAAE,CAAC;IAC/C,CAAC;IACL,gBAAC;AAAD,CAAC,AArGD,IAqGC","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/esm5/lib/search/models/predicate-removal-event.js

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

package/esm5/lib/search/models/query/query.js

@@ -0,0 +1,83 @@
+/**
+ * Abstraction of queries, so that their implementation can be replaced as needed.
+ */
+var Query = /** @class */ (function () {
+    /**
+     * @param _value see [value]{@link Query#value} for the specification of this attribute.
+     * @param _empty use `true` if the Query object represents an empty query
+     */
+    function Query(_value, _empty) {
+        if (_empty === void 0) { _empty = false; }
+        this._value = _value;
+        this._empty = _empty;
+        if (!this._value || this._value === '') {
+            this._empty = true;
+        }
+    }
+    Object.defineProperty(Query.prototype, "value", {
+        /**
+         * @returns an Elastic search Query string query wrapped in braces.
+         *
+         * See Elasticsearch's
+         * [documentation]{@link https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-query-string-query.html}
+         * for more information about Query string queries.
+         */
+        get: function () {
+            return this._value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Query.prototype, "isEmpty", {
+        /**
+         * @returns whether this Query object represents an empty query or not
+         */
+        get: function () {
+            return this._empty;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Combines multiple queries into one with the provided operator.
+     * @param queries queries that should be combined. Empty queries in the input array are ignored.
+     * @param operator operator that is used to combine the queries
+     * @returns a single query that is the combination of the non-empty queries in the input array. If the input array is empty an
+     * [empty query]{@link Query#emptyQuery} will be returned.
+     */
+    Query.combineQueries = function (queries, operator) {
+        var realQueries = queries.filter(function (q) { return !q.isEmpty; });
+        if (realQueries.length === 0) {
+            return Query.emptyQuery();
+        }
+        if (realQueries.length === 1) {
+            return new Query(realQueries[0].value);
+        }
+        var combinedQuery = realQueries.map(function (q) { return q.value; }).join(" " + operator + " ");
+        return new Query("(" + combinedQuery + ")");
+    };
+    /**
+     * Returns a `Query` with it's `value` set to an empty string.
+     */
+    Query.emptyQuery = function () {
+        return new Query('', true);
+    };
+    /**
+     * @param query the query that should be compared
+     * @returns `true` if and only if the queries are equal.
+     * Returns `false` if the queries are not equal, or if attempting to tell the queries apart is too complicated.
+     * More specifically the method can always tell apart empty queries and if poth queries are non-empty then their values are compared.
+     */
+    Query.prototype.equals = function (query) {
+        if (this.isEmpty && query.isEmpty) {
+            return true;
+        }
+        if (this.isEmpty || query.isEmpty) {
+            return false;
+        }
+        return this.value === query.value;
+    };
+    return Query;
+}());
+export { Query };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/search/models/search-index.js

@@ -0,0 +1,76 @@
+export var SearchIndex;
+(function (SearchIndex) {
+    /**
+     * Indexed as TEXT
+     *
+     * Used by all fields
+     */
+    SearchIndex["FULLTEXT"] = "fulltextValue";
+    /**
+     * Indexed as BOOLEAN
+     *
+     * Used by BooleanFields
+     */
+    SearchIndex["BOOLEAN"] = "booleanValue";
+    /**
+     * Indexed as DATE
+     *
+     * Used by both Date and DateTime Fields
+     */
+    SearchIndex["DATE"] = "dateValue";
+    /**
+     * Indexed as LONG
+     *
+     * Used by both Date and DateTime Fields
+     */
+    SearchIndex["TIMESTAMP"] = "timestampValue";
+    /**
+     * Indexed as TEXT
+     *
+     * Used by both File and FileList Fields
+     */
+    SearchIndex["FILE_NAME"] = "fileNameValue";
+    /**
+     * Indexed as KEYWORD
+     *
+     * Used by both File and FileList Fields
+     */
+    SearchIndex["FILE_EXTENSION"] = "fileExtensionValue";
+    /**
+     * Indexed as TEXT
+     *
+     * Used by Text, Enumeration, EnumerationMap, Multichoice and MultichoiceMap Fields
+     */
+    SearchIndex["TEXT"] = "textValue";
+    /**
+     * Indexed as KEYWORD
+     *
+     * Used by EnumerationMap and MultichoiceMap Fields
+     */
+    SearchIndex["KEY"] = "keyValue";
+    /**
+     * Indexed as DOUBLE
+     *
+     * Used by Number Fields
+     */
+    SearchIndex["NUMBER"] = "numberValue";
+    /**
+     * Indexed as TEXT
+     *
+     * Used by User and UserListFields
+     */
+    SearchIndex["EMAIL"] = "emailValue";
+    /**
+     * Indexed as TEXT
+     *
+     * Used by User and UserListFields
+     */
+    SearchIndex["FULL_NAME"] = "fullNameValue";
+    /**
+     * Indexed as LONG
+     *
+     * Used by User and UserListFields
+     */
+    SearchIndex["USER_ID"] = "userIdValue";
+})(SearchIndex || (SearchIndex = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/search/models/wrap-result.js

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

package/esm5/lib/search/operator-service/operator-resolver.service.js

@@ -0,0 +1,113 @@
+import { Injectable } from '@angular/core';
+import { Operators } from '../models/operator/operators';
+import { Equals } from '../models/operator/equals';
+import { EqualsDate } from '../models/operator/equals-date';
+import { EqualsDateTime } from '../models/operator/equals-date-time';
+import { InRange } from '../models/operator/in-range';
+import { InRangeDate } from '../models/operator/in-range-date';
+import { InRangeDateTime } from '../models/operator/in-range-date-time';
+import { IsNull } from '../models/operator/is-null';
+import { LessThan } from '../models/operator/less-than';
+import { LessThanDate } from '../models/operator/less-than-date';
+import { LessThanDateTime } from '../models/operator/less-than-date-time';
+import { Like } from '../models/operator/like';
+import { MoreThan } from '../models/operator/more-than';
+import { MoreThanDate } from '../models/operator/more-than-date';
+import { MoreThanDateTime } from '../models/operator/more-than-date-time';
+import { NotEquals } from '../models/operator/not-equals';
+import { NotEqualsDate } from '../models/operator/not-equals-date';
+import { Substring } from '../models/operator/substring';
+import { LessThanEqual } from '../models/operator/less-than-equal';
+import { MoreThanEqual } from '../models/operator/more-than-equal';
+import { MoreThanEqualDate } from '../models/operator/more-than-equal-date';
+import { MoreThanEqualDateTime } from '../models/operator/more-than-equal-date-time';
+import { LessThanEqualDate } from '../models/operator/less-than-equal-date';
+import { LessThanEqualDateTime } from '../models/operator/less-than-equal-date-time';
+import { NotEqualsDateTime } from '../models/operator/not-equals-date-time';
+import * as i0 from "@angular/core";
+/**
+ * A service that resolves {@link Operators} (or custom string) into a concrete (@link Operator) implementation class.
+ */
+var OperatorResolverService = /** @class */ (function () {
+    function OperatorResolverService() {
+    }
+    /**
+     * Resolves the operators in the {@link Operators} enum into their corresponding classes.
+     * Passes all unresolved values into the [toCustomClass()]{@link OperatorResolverService#toCustomClass} method.
+     * @param operator a serialized representation of the {@link Operator} class
+     */
+    OperatorResolverService.prototype.toClass = function (operator) {
+        switch (operator) {
+            default:
+                return this.toCustomClass(operator);
+            case Operators.EQUALS:
+                return Equals;
+            case Operators.EQUALS_DATE:
+                return EqualsDate;
+            case Operators.EQUALS_DATE_TIME:
+                return EqualsDateTime;
+            case Operators.IN_RANGE:
+                return InRange;
+            case Operators.IN_RANGE_DATE:
+                return InRangeDate;
+            case Operators.IN_RANGE_DATE_TIME:
+                return InRangeDateTime;
+            case Operators.IS_NULL:
+                return IsNull;
+            case Operators.LESS_THAN:
+                return LessThan;
+            case Operators.LESS_THAN_DATE:
+                return LessThanDate;
+            case Operators.LESS_THAN_DATE_TIME:
+                return LessThanDateTime;
+            case Operators.LESS_THAN_EQUAL:
+                return LessThanEqual;
+            case Operators.LESS_THAN_EQUAL_DATE:
+                return LessThanEqualDate;
+            case Operators.LESS_THAN_EQUAL_DATE_TIME:
+                return LessThanEqualDateTime;
+            case Operators.LIKE:
+                return Like;
+            case Operators.MORE_THAN:
+                return MoreThan;
+            case Operators.MORE_THAN_DATE:
+                return MoreThanDate;
+            case Operators.MORE_THAN_DATE_TIME:
+                return MoreThanDateTime;
+            case Operators.MORE_THAN_EQUAL:
+                return MoreThanEqual;
+            case Operators.MORE_THAN_EQUAL_DATE:
+                return MoreThanEqualDate;
+            case Operators.MORE_THAN_EQUAL_DATE_TIME:
+                return MoreThanEqualDateTime;
+            case Operators.NOT_EQUALS:
+                return NotEquals;
+            case Operators.NOT_EQUALS_DATE:
+                return NotEqualsDate;
+            case Operators.NOT_EQUALS_DATE_TIME:
+                return NotEqualsDateTime;
+            case Operators.SUBSTRING:
+                return Substring;
+        }
+    };
+    /**
+     * Should resolve any custom operators into their corresponding class objects.
+     *
+     * If you implement any custom {@link Operator} classes, you should override this method to resolve them after serialization.
+     *
+     * @param operator the serialized string provided by your [Operator.serialize()]{@link Operator#serialize} implementation
+     * @returns `undefined`
+     */
+    OperatorResolverService.prototype.toCustomClass = function (operator) {
+        return undefined;
+    };
+    OperatorResolverService.ɵprov = i0.ɵɵdefineInjectable({ factory: function OperatorResolverService_Factory() { return new OperatorResolverService(); }, token: OperatorResolverService, providedIn: "root" });
+    OperatorResolverService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    return OperatorResolverService;
+}());
+export { OperatorResolverService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"operator-resolver.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/search/operator-service/operator-resolver.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, Type} from '@angular/core';\nimport {Operator} from '../models/operator/operator';\nimport {Operators} from '../models/operator/operators';\nimport {Equals} from '../models/operator/equals';\nimport {EqualsDate} from '../models/operator/equals-date';\nimport {EqualsDateTime} from '../models/operator/equals-date-time';\nimport {InRange} from '../models/operator/in-range';\nimport {InRangeDate} from '../models/operator/in-range-date';\nimport {InRangeDateTime} from '../models/operator/in-range-date-time';\nimport {IsNull} from '../models/operator/is-null';\nimport {LessThan} from '../models/operator/less-than';\nimport {LessThanDate} from '../models/operator/less-than-date';\nimport {LessThanDateTime} from '../models/operator/less-than-date-time';\nimport {Like} from '../models/operator/like';\nimport {MoreThan} from '../models/operator/more-than';\nimport {MoreThanDate} from '../models/operator/more-than-date';\nimport {MoreThanDateTime} from '../models/operator/more-than-date-time';\nimport {NotEquals} from '../models/operator/not-equals';\nimport {NotEqualsDate} from '../models/operator/not-equals-date';\nimport {Substring} from '../models/operator/substring';\nimport {LessThanEqual} from '../models/operator/less-than-equal';\nimport {MoreThanEqual} from '../models/operator/more-than-equal';\nimport {MoreThanEqualDate} from '../models/operator/more-than-equal-date';\nimport {MoreThanEqualDateTime} from '../models/operator/more-than-equal-date-time';\nimport {LessThanEqualDate} from '../models/operator/less-than-equal-date';\nimport {LessThanEqualDateTime} from '../models/operator/less-than-equal-date-time';\nimport {NotEqualsDateTime} from '../models/operator/not-equals-date-time';\n\n/**\n * A service that resolves {@link Operators} (or custom string) into a concrete (@link Operator) implementation class.\n */\n@Injectable({\n    providedIn: 'root'\n})\nexport class OperatorResolverService {\n\n    /**\n     * Resolves the operators in the {@link Operators} enum into their corresponding classes.\n     * Passes all unresolved values into the [toCustomClass()]{@link OperatorResolverService#toCustomClass} method.\n     * @param operator a serialized representation of the {@link Operator} class\n     */\n    public toClass(operator: Operators | string): Type<Operator<any>> | undefined {\n        switch (operator) {\n            default:\n                return this.toCustomClass(operator);\n            case Operators.EQUALS:\n                return Equals;\n            case Operators.EQUALS_DATE:\n                return EqualsDate;\n            case Operators.EQUALS_DATE_TIME:\n                return EqualsDateTime;\n            case Operators.IN_RANGE:\n                return InRange;\n            case Operators.IN_RANGE_DATE:\n                return InRangeDate;\n            case Operators.IN_RANGE_DATE_TIME:\n                return InRangeDateTime;\n            case Operators.IS_NULL:\n                return IsNull;\n            case Operators.LESS_THAN:\n                return LessThan;\n            case Operators.LESS_THAN_DATE:\n                return LessThanDate;\n            case Operators.LESS_THAN_DATE_TIME:\n                return LessThanDateTime;\n            case Operators.LESS_THAN_EQUAL:\n                return LessThanEqual;\n            case Operators.LESS_THAN_EQUAL_DATE:\n                return LessThanEqualDate;\n            case Operators.LESS_THAN_EQUAL_DATE_TIME:\n                return LessThanEqualDateTime;\n            case Operators.LIKE:\n                return Like;\n            case Operators.MORE_THAN:\n                return MoreThan;\n            case Operators.MORE_THAN_DATE:\n                return MoreThanDate;\n            case Operators.MORE_THAN_DATE_TIME:\n                return MoreThanDateTime;\n            case Operators.MORE_THAN_EQUAL:\n                return MoreThanEqual;\n            case Operators.MORE_THAN_EQUAL_DATE:\n                return MoreThanEqualDate;\n            case Operators.MORE_THAN_EQUAL_DATE_TIME:\n                return MoreThanEqualDateTime;\n            case Operators.NOT_EQUALS:\n                return NotEquals;\n            case Operators.NOT_EQUALS_DATE:\n                return NotEqualsDate;\n            case Operators.NOT_EQUALS_DATE_TIME:\n                return NotEqualsDateTime;\n            case Operators.SUBSTRING:\n                return Substring;\n        }\n    }\n\n    /**\n     * Should resolve any custom operators into their corresponding class objects.\n     *\n     * If you implement any custom {@link Operator} classes, you should override this method to resolve them after serialization.\n     *\n     * @param operator the serialized string provided by your [Operator.serialize()]{@link Operator#serialize} implementation\n     * @returns `undefined`\n     */\n    protected toCustomClass(operator: string): Type<Operator<any>> | undefined {\n        return undefined;\n    }\n}\n"]}