@netgrif/components-core 6.0.1

package/esm5/lib/filter/models/case-search-request-body.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/filter/models/filter-type.js

@@ -0,0 +1,11 @@
+/**
+ * Determines the type of resource the Filter can search for.
+ *
+ * See {@link Filter} for more information.
+ */
+export var FilterType;
+(function (FilterType) {
+    FilterType["TASK"] = "Task";
+    FilterType["CASE"] = "Case";
+})(FilterType || (FilterType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsdGVyLXR5cGUuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvZmlsdGVyL21vZGVscy9maWx0ZXItdHlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBQ0gsTUFBTSxDQUFOLElBQVksVUFHWDtBQUhELFdBQVksVUFBVTtJQUNsQiwyQkFBYSxDQUFBO0lBQ2IsMkJBQWEsQ0FBQTtBQUNqQixDQUFDLEVBSFcsVUFBVSxLQUFWLFVBQVUsUUFHckIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIERldGVybWluZXMgdGhlIHR5cGUgb2YgcmVzb3VyY2UgdGhlIEZpbHRlciBjYW4gc2VhcmNoIGZvci5cbiAqXG4gKiBTZWUge0BsaW5rIEZpbHRlcn0gZm9yIG1vcmUgaW5mb3JtYXRpb24uXG4gKi9cbmV4cG9ydCBlbnVtIEZpbHRlclR5cGUge1xuICAgIFRBU0sgPSAnVGFzaycsXG4gICAgQ0FTRSA9ICdDYXNlJyxcbn1cbiJdfQ==

package/esm5/lib/filter/models/filter.js

@@ -0,0 +1,71 @@
+/**
+ * Abstraction of backend search requests that defines a limited set of operations on them.
+ */
+var Filter = /** @class */ (function () {
+    /**
+     * If no name is provided the filter will be identified by it's ID when necessary.
+     * @param _id identifier of the filter
+     * @param _type type of resources that the filter can query
+     * @param _title human readable filter name
+     */
+    function Filter(_id, _type, _title) {
+        if (_title === void 0) { _title = ''; }
+        this._id = _id;
+        this._type = _type;
+        this._title = _title;
+    }
+    Object.defineProperty(Filter.prototype, "id", {
+        /**
+         * Unique filter identifier
+         */
+        get: function () {
+            return this._id;
+        },
+        set: function (id) {
+            this._id = id;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Filter.prototype, "type", {
+        /**
+         * Determines the type of resource this Filter can filter.
+         */
+        get: function () {
+            return this._type;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Filter.prototype, "title", {
+        /**
+         * Human readable filter title.
+         *
+         * Defaults to empty string.
+         */
+        get: function () {
+            return this._title;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Returns the necessary request params for the filter. Default implementation returns an empty object.
+     * The params are added on top of the request when sending it to the backend by the respective service methods.
+     * @returns an empty object `{}`
+     */
+    Filter.prototype.getRequestParams = function () {
+        return {};
+    };
+    /**
+     * Creates a deep copy of a simple object.
+     * @param obj object that should be copied
+     * @returns a deep copy of the argument
+     */
+    Filter.prototype.deepCopy = function (obj) {
+        return JSON.parse(JSON.stringify(obj));
+    };
+    return Filter;
+}());
+export { Filter };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/filter/models/filters-filter-injection-token.js

@@ -0,0 +1,9 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * Used for providing any additional constraints to the filter case filtering, when
+ * user filters are loaded via the {@link UserFiltersService}.
+ *
+ * The provided filter must be of type `Case` as it is used for the filtering of cases representing saved user filters.
+ */
+export var NAE_FILTERS_FILTER = new InjectionToken('NaeFiltersFilter');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsdGVycy1maWx0ZXItaW5qZWN0aW9uLXRva2VuLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL2ZpbHRlci9tb2RlbHMvZmlsdGVycy1maWx0ZXItaW5qZWN0aW9uLXRva2VuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxjQUFjLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFHN0M7Ozs7O0dBS0c7QUFDSCxNQUFNLENBQUMsSUFBTSxrQkFBa0IsR0FBRyxJQUFJLGNBQWMsQ0FBUyxrQkFBa0IsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtJbmplY3Rpb25Ub2tlbn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge0ZpbHRlcn0gZnJvbSAnLi9maWx0ZXInO1xuXG4vKipcbiAqIFVzZWQgZm9yIHByb3ZpZGluZyBhbnkgYWRkaXRpb25hbCBjb25zdHJhaW50cyB0byB0aGUgZmlsdGVyIGNhc2UgZmlsdGVyaW5nLCB3aGVuXG4gKiB1c2VyIGZpbHRlcnMgYXJlIGxvYWRlZCB2aWEgdGhlIHtAbGluayBVc2VyRmlsdGVyc1NlcnZpY2V9LlxuICpcbiAqIFRoZSBwcm92aWRlZCBmaWx0ZXIgbXVzdCBiZSBvZiB0eXBlIGBDYXNlYCBhcyBpdCBpcyB1c2VkIGZvciB0aGUgZmlsdGVyaW5nIG9mIGNhc2VzIHJlcHJlc2VudGluZyBzYXZlZCB1c2VyIGZpbHRlcnMuXG4gKi9cbmV4cG9ydCBjb25zdCBOQUVfRklMVEVSU19GSUxURVIgPSBuZXcgSW5qZWN0aW9uVG9rZW48RmlsdGVyPignTmFlRmlsdGVyc0ZpbHRlcicpO1xuIl19

package/esm5/lib/filter/models/merge-operator.js

@@ -0,0 +1,11 @@
+/**
+ * Determines whether the combination of Filters is an union (AND) or an intersection (OR).
+ *
+ * See {@link MergedFilter} for more information.
+ */
+export var MergeOperator;
+(function (MergeOperator) {
+    MergeOperator["AND"] = "AND";
+    MergeOperator["OR"] = "OR";
+})(MergeOperator || (MergeOperator = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVyZ2Utb3BlcmF0b3IuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvZmlsdGVyL21vZGVscy9tZXJnZS1vcGVyYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBQ0gsTUFBTSxDQUFOLElBQVksYUFHWDtBQUhELFdBQVksYUFBYTtJQUNyQiw0QkFBVyxDQUFBO0lBQ1gsMEJBQVMsQ0FBQTtBQUNiLENBQUMsRUFIVyxhQUFhLEtBQWIsYUFBYSxRQUd4QiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRGV0ZXJtaW5lcyB3aGV0aGVyIHRoZSBjb21iaW5hdGlvbiBvZiBGaWx0ZXJzIGlzIGFuIHVuaW9uIChBTkQpIG9yIGFuIGludGVyc2VjdGlvbiAoT1IpLlxuICpcbiAqIFNlZSB7QGxpbmsgTWVyZ2VkRmlsdGVyfSBmb3IgbW9yZSBpbmZvcm1hdGlvbi5cbiAqL1xuZXhwb3J0IGVudW0gTWVyZ2VPcGVyYXRvciB7XG4gICAgQU5EID0gJ0FORCcsXG4gICAgT1IgPSAnT1InLFxufVxuIl19

package/esm5/lib/filter/models/merged-filter-params.js

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

package/esm5/lib/filter/models/merged-filter.js

@@ -0,0 +1,120 @@
+import { __extends, __read, __spread } from "tslib";
+import { Filter } from './filter';
+import { MergeOperator } from './merge-operator';
+import { FilterType } from './filter-type';
+/**
+ * Represents an union or an intersection of {@link SimpleFilter}s and allows limited manipulation with it.
+ */
+var MergedFilter = /** @class */ (function (_super) {
+    __extends(MergedFilter, _super);
+    /**
+     * @param id identifier of the filter
+     * @param type type of resources that the filter can query
+     * @param filterBodies `Array` of search requests matching this filter's type
+     * @param _operator boolean operator that is used to combine the filters
+     * @param title human readable filter name
+     */
+    function MergedFilter(id, type, filterBodies, _operator, title) {
+        var _this = _super.call(this, id, type, title) || this;
+        _this._operator = _operator;
+        _this._filters = [];
+        filterBodies.forEach(function (body) {
+            _this._filters.push(_this.deepCopy(body));
+        });
+        return _this;
+    }
+    /**
+     * Creates a filter with the provided body and the provided type
+     * @param filterBody the body of the new filter
+     * @param operator the merge operator that is used to combine the filters
+     * @param type the type of the new filter. Type must match the type of the body.
+     * @returns a filter with the given body, operator and type. `id` of the new filter is set to an empty string.
+     */
+    MergedFilter.fromQuery = function (filterBody, operator, type) {
+        return new MergedFilter('', type, filterBody, operator);
+    };
+    /**
+     * Creates a case filter with the provided body
+     * @param filterBody the body of the new filter
+     * @param operator the merge operator that is used to combine the filters
+     * @returns a case filter with the given body and operator. `id` of the new filter is set to an empty string.
+     */
+    MergedFilter.fromCaseQuery = function (filterBody, operator) {
+        return MergedFilter.fromQuery(filterBody, operator, FilterType.CASE);
+    };
+    /**
+     * Creates a task filter with the provided body
+     * @param filterBody the body of the new filter
+     * @param operator the merge operator that is used to combine the filters
+     * @returns a task filter with the given body and operator. `id` of the new filter is set to an empty string.
+     */
+    MergedFilter.fromTaskQuery = function (filterBody, operator) {
+        return MergedFilter.fromQuery(filterBody, operator, FilterType.TASK);
+    };
+    Object.defineProperty(MergedFilter.prototype, "operator", {
+        get: function () {
+            return this._operator;
+        },
+        set: function (operator) {
+            this._operator = operator;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * See [Filter.clone()]{@link Filter#clone}
+     */
+    MergedFilter.prototype.clone = function () {
+        return new MergedFilter(this.id, this.type, this._filters, this._operator, this.title);
+    };
+    /**
+     * Filters that are merged must share the same type and the same merge operator.
+     *
+     * See [Filter.merge()]{@link Filter#merge} for information about parameters.
+     */
+    MergedFilter.prototype.merge = function (filter, operator) {
+        if (filter.type !== this.type) {
+            throw new Error('Can\'t merge filters with different types');
+        }
+        if (this._operator !== operator || (filter instanceof MergedFilter && filter._operator !== this._operator)) {
+            throw new Error('Can\'t merge filters with different merge operators');
+        }
+        var id = "" + this.id + (operator === MergeOperator.AND ? '&' : '|') + filter.id;
+        var combinedFilters = [];
+        combinedFilters.push.apply(combinedFilters, __spread(this._filters));
+        var otherFilters = filter.getRequestBody();
+        if (Array.isArray(otherFilters)) {
+            combinedFilters.push.apply(combinedFilters, __spread(otherFilters));
+        }
+        else {
+            combinedFilters.push(otherFilters);
+        }
+        return new MergedFilter(id, this.type, combinedFilters, this._operator);
+    };
+    /**
+     * See [Filter.getRequestBody()]{@link Filter#getRequestBody}
+     */
+    MergedFilter.prototype.getRequestBody = function () {
+        return this.deepCopy(this._filters);
+    };
+    /**
+     * See [Filter.bodyContainsQuery()]{@link Filter#bodyContainsQuery}
+     */
+    MergedFilter.prototype.bodyContainsQuery = function () {
+        return this._filters.some(function (f) { return f.query !== undefined && f.query !== null; });
+    };
+    /**
+     * Returns the necessary request params for the filter.
+     * @returns params with `operation` set to either `AND` or `OR` based on this object's `_operator` property.
+     *
+     * See {@link MergedFilterParams} for more information.
+     */
+    MergedFilter.prototype.getRequestParams = function () {
+        return {
+            operation: this._operator
+        };
+    };
+    return MergedFilter;
+}(Filter));
+export { MergedFilter };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"merged-filter.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/filter/models/merged-filter.ts"],"names":[],"mappings":"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","sourcesContent":["import {Filter} from './filter';\nimport {MergeOperator} from './merge-operator';\nimport {TaskSearchRequestBody} from './task-search-request-body';\nimport {CaseSearchRequestBody} from './case-search-request-body';\nimport {FilterType} from './filter-type';\nimport {Params} from '../../resources/resource-provider.service';\nimport {MergedFilterParams} from './merged-filter-params';\n\n/**\n * Represents an union or an intersection of {@link SimpleFilter}s and allows limited manipulation with it.\n */\nexport class MergedFilter extends Filter {\n\n    /**\n     * @ignore\n     * Stores the underlying filter data\n     */\n    private readonly _filters: Array<CaseSearchRequestBody> | Array<TaskSearchRequestBody>;\n\n    /**\n     * Creates a filter with the provided body and the provided type\n     * @param filterBody the body of the new filter\n     * @param operator the merge operator that is used to combine the filters\n     * @param type the type of the new filter. Type must match the type of the body.\n     * @returns a filter with the given body, operator and type. `id` of the new filter is set to an empty string.\n     */\n    public static fromQuery(filterBody: Array<CaseSearchRequestBody> | Array<TaskSearchRequestBody>, operator: MergeOperator,\n                            type: FilterType): Filter {\n        return new MergedFilter('', type, filterBody, operator);\n    }\n\n    /**\n     * Creates a case filter with the provided body\n     * @param filterBody the body of the new filter\n     * @param operator the merge operator that is used to combine the filters\n     * @returns a case filter with the given body and operator. `id` of the new filter is set to an empty string.\n     */\n    public static fromCaseQuery(filterBody: Array<CaseSearchRequestBody>, operator: MergeOperator): Filter {\n        return MergedFilter.fromQuery(filterBody, operator, FilterType.CASE);\n    }\n\n    /**\n     * Creates a task filter with the provided body\n     * @param filterBody the body of the new filter\n     * @param operator the merge operator that is used to combine the filters\n     * @returns a task filter with the given body and operator. `id` of the new filter is set to an empty string.\n     */\n    public static fromTaskQuery(filterBody: Array<TaskSearchRequestBody>, operator: MergeOperator): Filter {\n        return MergedFilter.fromQuery(filterBody, operator, FilterType.TASK);\n    }\n\n    /**\n     * @param id identifier of the filter\n     * @param type type of resources that the filter can query\n     * @param filterBodies `Array` of search requests matching this filter's type\n     * @param _operator boolean operator that is used to combine the filters\n     * @param title human readable filter name\n     */\n    constructor(id: string, type: FilterType, filterBodies: Array<CaseSearchRequestBody> | Array<TaskSearchRequestBody>,\n                protected _operator: MergeOperator, title?: string) {\n        super(id, type, title);\n        this._filters = [];\n        filterBodies.forEach(body => {\n            this._filters.push(this.deepCopy(body));\n        });\n    }\n\n    public set operator(operator: MergeOperator) {\n        this._operator = operator;\n    }\n\n    public get operator(): MergeOperator {\n        return this._operator;\n    }\n\n    /**\n     * See [Filter.clone()]{@link Filter#clone}\n     */\n    clone(): Filter {\n        return new MergedFilter(this.id, this.type, this._filters, this._operator, this.title);\n    }\n\n    /**\n     * Filters that are merged must share the same type and the same merge operator.\n     *\n     * See [Filter.merge()]{@link Filter#merge} for information about parameters.\n     */\n    merge(filter: Filter, operator: MergeOperator): MergedFilter {\n        if (filter.type !== this.type) {\n            throw new Error('Can\\'t merge filters with different types');\n        }\n        if (this._operator !== operator || (filter instanceof MergedFilter && filter._operator !== this._operator)) {\n            throw new Error('Can\\'t merge filters with different merge operators');\n        }\n\n        const id = `${this.id}${operator === MergeOperator.AND ? '&' : '|'}${filter.id}`;\n\n        const combinedFilters: Array<CaseSearchRequestBody> | Array<TaskSearchRequestBody> = [];\n        combinedFilters.push(...this._filters);\n        const otherFilters = filter.getRequestBody();\n        if (Array.isArray(otherFilters)) {\n            combinedFilters.push(...otherFilters);\n        } else {\n            combinedFilters.push(otherFilters);\n        }\n\n        return new MergedFilter(id, this.type, combinedFilters, this._operator);\n    }\n\n    /**\n     * See [Filter.getRequestBody()]{@link Filter#getRequestBody}\n     */\n    getRequestBody(): Array<TaskSearchRequestBody> | Array<CaseSearchRequestBody> {\n        return this.deepCopy(this._filters) as Array<CaseSearchRequestBody> | Array<TaskSearchRequestBody>;\n    }\n\n    /**\n     * See [Filter.bodyContainsQuery()]{@link Filter#bodyContainsQuery}\n     */\n    bodyContainsQuery(): boolean {\n        return this._filters.some(f => f.query !== undefined && f.query !== null);\n    }\n\n    /**\n     * Returns the necessary request params for the filter.\n     * @returns params with `operation` set to either `AND` or `OR` based on this object's `_operator` property.\n     *\n     * See {@link MergedFilterParams} for more information.\n     */\n    getRequestParams(): MergedFilterParams & Params {\n        return {\n            operation: this._operator\n        };\n    }\n}\n"]}

package/esm5/lib/filter/models/simple-filter.js

@@ -0,0 +1,96 @@
+import { __extends } from "tslib";
+import { Filter } from './filter';
+import { MergedFilter } from './merged-filter';
+import { FilterType } from './filter-type';
+/**
+ * Holds backend search request data and allows limited manipulation with it.
+ */
+var SimpleFilter = /** @class */ (function (_super) {
+    __extends(SimpleFilter, _super);
+    /**
+     * @param id identifier of the filter
+     * @param type type of resources that the filter can query
+     * @param filterBody search request matching this filter's `type`
+     * @param title human readable filter name
+     */
+    function SimpleFilter(id, type, filterBody, title) {
+        var _this = _super.call(this, id, type, title) || this;
+        _this._filter = _this.deepCopy(filterBody);
+        return _this;
+    }
+    /**
+     * Create an empty filter of provided type
+     * @param type type of resources that the filter can query
+     * @returns a filter with empty body of the provided type. `id` of the new filter is set to an empty string.
+     */
+    SimpleFilter.empty = function (type) {
+        return new SimpleFilter('', type, {});
+    };
+    /**
+     * Equivalent to calling `SimpleFilter.empty(FilterType.CASE)`.
+     * @returns a filter with empty body that can be used to search cases
+     */
+    SimpleFilter.emptyCaseFilter = function () {
+        return SimpleFilter.empty(FilterType.CASE);
+    };
+    /**
+     * Equivalent to calling `SimpleFilter.empty(FilterType.TASK)`.
+     * @returns a filter with empty body that can be used to search tasks
+     */
+    SimpleFilter.emptyTaskFilter = function () {
+        return SimpleFilter.empty(FilterType.TASK);
+    };
+    /**
+     * Creates a filter with the provided body and the provided type
+     * @param filterBody the body of the new filter
+     * @param type the type of the new filter. Type must match the type of the body.
+     * @returns a filter with the given body and type. `id` of the new filter is set to an empty string.
+     */
+    SimpleFilter.fromQuery = function (filterBody, type) {
+        return new SimpleFilter('', type, filterBody);
+    };
+    /**
+     * Creates a case filter with the provided body
+     * @param filterBody the body of the new filter
+     * @returns a case filter with the given body. `id` of the new filter is set to an empty string.
+     */
+    SimpleFilter.fromCaseQuery = function (filterBody) {
+        return SimpleFilter.fromQuery(filterBody, FilterType.CASE);
+    };
+    /**
+     * Creates a task filter with the provided body
+     * @param filterBody the body of the new filter
+     * @returns a task filter with the given body. `id` of the new filter is set to an empty string.
+     */
+    SimpleFilter.fromTaskQuery = function (filterBody) {
+        return SimpleFilter.fromQuery(filterBody, FilterType.TASK);
+    };
+    /**
+     * See [Filter.clone()]{@link Filter#clone}
+     */
+    SimpleFilter.prototype.clone = function () {
+        return new SimpleFilter(this.id, this.type, this._filter, this.title);
+    };
+    /**
+     * See [Filter.merge()]{@link Filter#merge}
+     */
+    SimpleFilter.prototype.merge = function (filter, operator) {
+        var temp = new MergedFilter(this.id, this.type, [this._filter], operator, this.title);
+        return temp.merge(filter, operator);
+    };
+    /**
+     * See [Filter.bodyContainsQuery()]{@link Filter#bodyContainsQuery}
+     */
+    SimpleFilter.prototype.bodyContainsQuery = function () {
+        return this._filter.query !== undefined && this._filter.query !== null;
+    };
+    /**
+     * See [Filter.getRequestBody()]{@link Filter#getRequestBody}
+     */
+    SimpleFilter.prototype.getRequestBody = function () {
+        return this.deepCopy(this._filter);
+    };
+    return SimpleFilter;
+}(Filter));
+export { SimpleFilter };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"simple-filter.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/filter/models/simple-filter.ts"],"names":[],"mappings":";AAAA,OAAO,EAAC,MAAM,EAAC,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAC,YAAY,EAAC,MAAM,iBAAiB,CAAC;AAG7C,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AAEzC;;GAEG;AACH;IAAkC,gCAAM;IA6DpC;;;;;OAKG;IACH,sBAAY,EAAU,EAAE,IAAgB,EAAE,UAAyD,EAAE,KAAc;QAAnH,YACI,kBAAM,EAAE,EAAE,IAAI,EAAE,KAAK,CAAC,SAEzB;QADG,KAAI,CAAC,OAAO,GAAG,KAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;;IAC7C,CAAC;IA9DD;;;;OAIG;IACW,kBAAK,GAAnB,UAAoB,IAAgB;QAChC,OAAO,IAAI,YAAY,CAAC,EAAE,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC;IAC1C,CAAC;IAED;;;OAGG;IACW,4BAAe,GAA7B;QACI,OAAO,YAAY,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;IAC/C,CAAC;IAED;;;OAGG;IACW,4BAAe,GAA7B;QACI,OAAO,YAAY,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;IAC/C,CAAC;IAED;;;;;OAKG;IACW,sBAAS,GAAvB,UAAwB,UAAyD,EAAE,IAAgB;QAC/F,OAAO,IAAI,YAAY,CAAC,EAAE,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC;IAClD,CAAC;IAED;;;;OAIG;IACW,0BAAa,GAA3B,UAA4B,UAAiC;QACzD,OAAO,YAAY,CAAC,SAAS,CAAC,UAAU,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC;IAC/D,CAAC;IAED;;;;OAIG;IACW,0BAAa,GAA3B,UAA4B,UAAiC;QACzD,OAAO,YAAY,CAAC,SAAS,CAAC,UAAU,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC;IAC/D,CAAC;IAaD;;OAEG;IACH,4BAAK,GAAL;QACI,OAAO,IAAI,YAAY,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;IAC1E,CAAC;IAED;;OAEG;IACH,4BAAK,GAAL,UAAM,MAAc,EAAE,QAAuB;QACzC,IAAM,IAAI,GAAG,IAAI,YAAY,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;QACxF,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IACxC,CAAC;IAED;;OAEG;IACH,wCAAiB,GAAjB;QACI,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,KAAK,SAAS,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,KAAK,IAAI,CAAC;IAC3E,CAAC;IAED;;OAEG;IACH,qCAAc,GAAd;QACI,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAkD,CAAC;IACxF,CAAC;IACL,mBAAC;AAAD,CAAC,AApGD,CAAkC,MAAM,GAoGvC","sourcesContent":["import {Filter} from './filter';\nimport {MergeOperator} from './merge-operator';\nimport {MergedFilter} from './merged-filter';\nimport {TaskSearchRequestBody} from './task-search-request-body';\nimport {CaseSearchRequestBody} from './case-search-request-body';\nimport {FilterType} from './filter-type';\n\n/**\n * Holds backend search request data and allows limited manipulation with it.\n */\nexport class SimpleFilter extends Filter {\n\n    /**\n     * @ignore\n     * Stores the underlying filter data\n     */\n    private readonly _filter: CaseSearchRequestBody | TaskSearchRequestBody;\n\n    /**\n     * Create an empty filter of provided type\n     * @param type type of resources that the filter can query\n     * @returns a filter with empty body of the provided type. `id` of the new filter is set to an empty string.\n     */\n    public static empty(type: FilterType): Filter {\n        return new SimpleFilter('', type, {});\n    }\n\n    /**\n     * Equivalent to calling `SimpleFilter.empty(FilterType.CASE)`.\n     * @returns a filter with empty body that can be used to search cases\n     */\n    public static emptyCaseFilter(): Filter {\n        return SimpleFilter.empty(FilterType.CASE);\n    }\n\n    /**\n     * Equivalent to calling `SimpleFilter.empty(FilterType.TASK)`.\n     * @returns a filter with empty body that can be used to search tasks\n     */\n    public static emptyTaskFilter(): Filter {\n        return SimpleFilter.empty(FilterType.TASK);\n    }\n\n    /**\n     * Creates a filter with the provided body and the provided type\n     * @param filterBody the body of the new filter\n     * @param type the type of the new filter. Type must match the type of the body.\n     * @returns a filter with the given body and type. `id` of the new filter is set to an empty string.\n     */\n    public static fromQuery(filterBody: CaseSearchRequestBody | TaskSearchRequestBody, type: FilterType): Filter {\n        return new SimpleFilter('', type, filterBody);\n    }\n\n    /**\n     * Creates a case filter with the provided body\n     * @param filterBody the body of the new filter\n     * @returns a case filter with the given body. `id` of the new filter is set to an empty string.\n     */\n    public static fromCaseQuery(filterBody: CaseSearchRequestBody): Filter {\n        return SimpleFilter.fromQuery(filterBody, FilterType.CASE);\n    }\n\n    /**\n     * Creates a task filter with the provided body\n     * @param filterBody the body of the new filter\n     * @returns a task filter with the given body. `id` of the new filter is set to an empty string.\n     */\n    public static fromTaskQuery(filterBody: TaskSearchRequestBody): Filter {\n        return SimpleFilter.fromQuery(filterBody, FilterType.TASK);\n    }\n\n    /**\n     * @param id identifier of the filter\n     * @param type type of resources that the filter can query\n     * @param filterBody search request matching this filter's `type`\n     * @param title human readable filter name\n     */\n    constructor(id: string, type: FilterType, filterBody: CaseSearchRequestBody | TaskSearchRequestBody, title?: string) {\n        super(id, type, title);\n        this._filter = this.deepCopy(filterBody);\n    }\n\n    /**\n     * See [Filter.clone()]{@link Filter#clone}\n     */\n    clone(): Filter {\n        return new SimpleFilter(this.id, this.type, this._filter, this.title);\n    }\n\n    /**\n     * See [Filter.merge()]{@link Filter#merge}\n     */\n    merge(filter: Filter, operator: MergeOperator): MergedFilter {\n        const temp = new MergedFilter(this.id, this.type, [this._filter], operator, this.title);\n        return temp.merge(filter, operator);\n    }\n\n    /**\n     * See [Filter.bodyContainsQuery()]{@link Filter#bodyContainsQuery}\n     */\n    bodyContainsQuery(): boolean {\n        return this._filter.query !== undefined && this._filter.query !== null;\n    }\n\n    /**\n     * See [Filter.getRequestBody()]{@link Filter#getRequestBody}\n     */\n    getRequestBody(): TaskSearchRequestBody | CaseSearchRequestBody {\n        return this.deepCopy(this._filter) as CaseSearchRequestBody | TaskSearchRequestBody;\n    }\n}\n"]}

package/esm5/lib/filter/models/task-search-request-body.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/filter/models/user-filter-constants.js

@@ -0,0 +1,39 @@
+/**
+ * Holds all identifiers of the Filter process in an accessible manner
+ */
+export var UserFilterConstants;
+(function (UserFilterConstants) {
+    /**
+     * Identifier of the filter process
+     */
+    UserFilterConstants["FILTER_NET_IDENTIFIER"] = "filter";
+    /**
+     * Transition ID of the "Set filter metadata" transition used for setting filter metadata to new filter cases
+     */
+    UserFilterConstants["SET_FILTER_METADATA_TRANSITION_ID"] = "frontend_create";
+    /**
+     * Transition ID of the "New Filter" transition displayed in the side menu
+     */
+    UserFilterConstants["NEW_FILTER_TRANSITION_ID"] = "newFilter";
+    /**
+     * ID of the field containing the saved filter
+     */
+    UserFilterConstants["FILTER_FIELD_ID"] = "filter";
+    /**
+     * ID of the field containing the saved filter type
+     */
+    UserFilterConstants["FILTER_TYPE_FIELD_ID"] = "filter_type";
+    /**
+     * ID of the field containing the viewId of the filters origin (if the filter originates from an app view)
+     */
+    UserFilterConstants["ORIGIN_VIEW_ID_FIELD_ID"] = "origin_view_id";
+    /**
+     * ID of the field containing the filter case ID
+     */
+    UserFilterConstants["FILTER_CASE_ID_FIELD_ID"] = "filter_case_id";
+    /**
+     * ID of the field containing the filter case ID of the parent filter (if the filter has a filter parent)
+     */
+    UserFilterConstants["PARENT_FILTER_CASE_ID_FIELD_ID"] = "parent_filter_id";
+})(UserFilterConstants || (UserFilterConstants = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/filter/public-api.js

@@ -0,0 +1,18 @@
+/* SERVICES */
+export * from './filter.repository';
+export * from './user-filters.service';
+/* CLASSES */
+export * from './models/filter';
+export * from './models/simple-filter';
+export * from './models/merged-filter';
+/* ENUMS */
+export * from './models/merge-operator';
+export * from './models/filter-type';
+export * from './models/user-filter-constants';
+/* INTERFACES */
+export * from './models/case-search-request-body';
+export * from './models/task-search-request-body';
+export * from './models/merged-filter-params';
+/* TOKENS */
+export * from './models/filters-filter-injection-token';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9maWx0ZXIvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjO0FBQ2QsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHdCQUF3QixDQUFDO0FBRXZDLGFBQWE7QUFDYixjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyx3QkFBd0IsQ0FBQztBQUV2QyxXQUFXO0FBQ1gsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsZ0NBQWdDLENBQUM7QUFFL0MsZ0JBQWdCO0FBQ2hCLGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLCtCQUErQixDQUFDO0FBRTlDLFlBQVk7QUFDWixjQUFjLHlDQUF5QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyogU0VSVklDRVMgKi9cbmV4cG9ydCAqIGZyb20gJy4vZmlsdGVyLnJlcG9zaXRvcnknO1xuZXhwb3J0ICogZnJvbSAnLi91c2VyLWZpbHRlcnMuc2VydmljZSc7XG5cbi8qIENMQVNTRVMgKi9cbmV4cG9ydCAqIGZyb20gJy4vbW9kZWxzL2ZpbHRlcic7XG5leHBvcnQgKiBmcm9tICcuL21vZGVscy9zaW1wbGUtZmlsdGVyJztcbmV4cG9ydCAqIGZyb20gJy4vbW9kZWxzL21lcmdlZC1maWx0ZXInO1xuXG4vKiBFTlVNUyAqL1xuZXhwb3J0ICogZnJvbSAnLi9tb2RlbHMvbWVyZ2Utb3BlcmF0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9tb2RlbHMvZmlsdGVyLXR5cGUnO1xuZXhwb3J0ICogZnJvbSAnLi9tb2RlbHMvdXNlci1maWx0ZXItY29uc3RhbnRzJztcblxuLyogSU5URVJGQUNFUyAqL1xuZXhwb3J0ICogZnJvbSAnLi9tb2RlbHMvY2FzZS1zZWFyY2gtcmVxdWVzdC1ib2R5JztcbmV4cG9ydCAqIGZyb20gJy4vbW9kZWxzL3Rhc2stc2VhcmNoLXJlcXVlc3QtYm9keSc7XG5leHBvcnQgKiBmcm9tICcuL21vZGVscy9tZXJnZWQtZmlsdGVyLXBhcmFtcyc7XG5cbi8qIFRPS0VOUyAqL1xuZXhwb3J0ICogZnJvbSAnLi9tb2RlbHMvZmlsdGVycy1maWx0ZXItaW5qZWN0aW9uLXRva2VuJztcbiJdfQ==