@netgrif/components-core 6.0.1

package/esm5/lib/search/header-search-service/header-search.service.js

@@ -0,0 +1,250 @@
+import { __assign, __values } from "tslib";
+import { Injectable, Optional } from '@angular/core';
+import { SearchService } from '../search-service/search.service';
+import { HeaderType } from '../../header/models/header-type';
+import { filter } from 'rxjs/operators';
+import { HeaderChangeType } from '../../header/models/user-changes/header-change-type';
+import { HeaderMode } from '../../header/models/header-mode';
+import { HeaderColumnType } from '../../header/models/header-column';
+import { CaseMetaField } from '../../header/case-header/case-menta-enum';
+import { CategoryFactory } from '../category-factory/category-factory';
+import { CaseVisualId } from '../models/category/case/case-visual-id';
+import { CaseAuthor } from '../models/category/case/case-author';
+import { CaseCreationDate } from '../models/category/case/case-creation-date';
+import { CaseTitle } from '../models/category/case/case-title';
+import { CaseStringId } from '../models/category/case/case-string-id';
+import { ProcessService } from '../../process/process.service';
+import { CaseSimpleDataset } from '../models/category/case/case-simple-dataset';
+import { TranslateService } from '@ngx-translate/core';
+import { LoggerService } from '../../logger/services/logger.service';
+/**
+ * Acts as an intermediary between the {@link AbstractHeaderService} instances of various types and the {@link SearchService}
+ */
+var HeaderSearchService = /** @class */ (function () {
+    function HeaderSearchService(_categoryFactory, _processService, _translate, _logger, _searchService) {
+        var _this = this;
+        this._categoryFactory = _categoryFactory;
+        this._processService = _processService;
+        this._translate = _translate;
+        this._logger = _logger;
+        this._searchService = _searchService;
+        this._columnToConfiguration = new Map();
+        this._typeToCategory = new Map();
+        [
+            { k: CaseMetaField.VISUAL_ID, v: CaseVisualId },
+            { k: CaseMetaField.TITLE, v: CaseTitle },
+            { k: CaseMetaField.CREATION_DATE, v: CaseCreationDate },
+            { k: CaseMetaField.AUTHOR, v: CaseAuthor },
+            { k: CaseMetaField.MONGO_ID, v: CaseStringId }
+        ].forEach(function (pair) {
+            _this._typeToCategory.set(pair.k, _this._categoryFactory.getWithDefaultOperator(pair.v));
+        });
+        this._typeToCategory.set(HeaderColumnType.IMMEDIATE, this._categoryFactory.get(CaseSimpleDataset));
+    }
+    HeaderSearchService.prototype.ngOnDestroy = function () {
+        var e_1, _a;
+        if (this._headerSub) {
+            this._headerSub.unsubscribe();
+        }
+        if (this._searchSub) {
+            this._searchSub.unsubscribe();
+        }
+        try {
+            for (var _b = __values(this._typeToCategory.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var cat = _c.value;
+                cat.destroy();
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    };
+    Object.defineProperty(HeaderSearchService.prototype, "headerService", {
+        set: function (headerService) {
+            if (headerService.headerType === HeaderType.CASE || headerService.headerType === HeaderType.TASK) {
+                this._headerService = headerService;
+            }
+            if (headerService && this._searchService) {
+                this.initializeHeaderSearch();
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * {@link HeaderSearchService} can only be initialized if it successfully injected a {@link SearchService}
+     * and a {@link AbstractHeaderService} instance of any of the supported types was set into it.
+     *
+     * Currently only task and case header searching is supported.
+     */
+    HeaderSearchService.prototype.initializeHeaderSearch = function () {
+        var _this = this;
+        if (!this._searchService) {
+            this._logger.error('You can\'t call initializeHeaderSearch without providing a SearchService to be injected!');
+            return;
+        }
+        if (!this._headerService) {
+            this._logger.error('You can\'t call initializeHeaderSearch without setting an AbstractHeaderService implementation instance!');
+            return;
+        }
+        this._headerSub = this._headerService.headerChange$
+            .pipe(filter(function (change) { return change.changeType === HeaderChangeType.SEARCH || change.changeType === HeaderChangeType.MODE_CHANGED; }))
+            .subscribe(function (change) {
+            if (change.changeType === HeaderChangeType.SEARCH) {
+                _this.processSearchChange(change.headerType, change.description);
+            }
+            else if (change.description.previousMode === HeaderMode.SEARCH) {
+                _this.processModeChange();
+            }
+        });
+        this._searchSub =
+            this._searchService.predicateRemoved$.subscribe(function (event) { return _this.handlePredicateRemoval(event.index, event.clearInput); });
+    };
+    /**
+     * Pushes all the predicates from the headers into the search interface and clears the header inputs
+     */
+    HeaderSearchService.prototype.processModeChange = function () {
+        var _this = this;
+        var addedPredicateIds = [];
+        this._columnToConfiguration.forEach(function (config) {
+            _this._searchService.removePredicate(config.predicateId);
+            var editableCategory;
+            if (config.type === HeaderColumnType.META) {
+                editableCategory = _this._typeToCategory.get(config.fieldIdentifier).duplicate();
+                editableCategory.selectDefaultOperator();
+                editableCategory.setOperands(config.userInput);
+            }
+            else {
+                var dataset = _this._typeToCategory.get(HeaderColumnType.IMMEDIATE);
+                editableCategory = dataset.transformToCaseDataset(config.fieldType, config.fieldTitle, config.userInput);
+            }
+            addedPredicateIds.push(_this._searchService.addGeneratedLeafPredicate(editableCategory));
+        });
+        this._searchService.show(addedPredicateIds);
+        this._columnToConfiguration.clear();
+    };
+    /**
+     * Transforms the {@link HeaderChange} object into a search predicate
+     */
+    HeaderSearchService.prototype.processSearchChange = function (headerType, changeDescription) {
+        if (headerType === HeaderType.CASE) {
+            this.processCaseSearch(changeDescription);
+        }
+    };
+    /**
+     * Processes the change object and resolves it into the appropriate case search predicate change
+     * @param changeDescription the change object that should be resolved
+     */
+    HeaderSearchService.prototype.processCaseSearch = function (changeDescription) {
+        if (this.emptyInput(changeDescription)) {
+            this.removePredicate(changeDescription.columnIdentifier);
+            return;
+        }
+        if (changeDescription.type === HeaderColumnType.META) {
+            this.processCaseMetaSearch(changeDescription);
+        }
+        else {
+            this.processCaseDataSearch(changeDescription);
+        }
+    };
+    /**
+     * Processes the change object of a case meta header and resolves it into the appropriate case search predicate change
+     * @param changeDescription the change object that should be resolved
+     */
+    HeaderSearchService.prototype.processCaseMetaSearch = function (changeDescription) {
+        var config = {
+            fieldIdentifier: changeDescription.fieldIdentifier,
+            userInput: [changeDescription.searchInput]
+        };
+        var category = this._typeToCategory.get(config.fieldIdentifier);
+        var predicate = category.generatePredicate(config.userInput);
+        this.addPredicate(changeDescription.columnIdentifier, predicate, __assign({ type: HeaderColumnType.META }, config));
+    };
+    /**
+     * Processes the change object of a case immediate data header and resolves it into the appropriate case search predicate change
+     * @param changeDescription the change object that should be resolved
+     */
+    HeaderSearchService.prototype.processCaseDataSearch = function (changeDescription) {
+        var _this = this;
+        this._processService.getNet(changeDescription.petriNetIdentifier).subscribe(function (net) {
+            var config = {
+                fieldType: changeDescription.fieldType,
+                fieldTitle: changeDescription.fieldTitle,
+                userInput: [changeDescription.searchInput]
+            };
+            var category = _this._typeToCategory.get(changeDescription.type);
+            category.configure(changeDescription.fieldIdentifier, config.fieldType, [net.identifier]);
+            var predicate = category.generatePredicate(config.userInput);
+            _this.addPredicate(changeDescription.columnIdentifier, predicate, __assign({ type: HeaderColumnType.IMMEDIATE }, config));
+        });
+    };
+    /**
+     * @param changeDescription information about the search header change
+     * @returns whether the input was cleared
+     */
+    HeaderSearchService.prototype.emptyInput = function (changeDescription) {
+        return changeDescription.searchInput === undefined
+            || changeDescription.searchInput === null
+            || (typeof changeDescription.searchInput === 'string' && changeDescription.searchInput.length === 0);
+    };
+    /**
+     * Updates a Predicate for a given column.
+     * Removes an existing predicate for this column if it exists and adds the new Predicate.
+     * @param column the index of the header column
+     * @param predicate the Predicate that should be added
+     * @param configuration data necessary for the configuration of the {@link Category} that generates the added predicate
+     */
+    HeaderSearchService.prototype.addPredicate = function (column, predicate, configuration) {
+        this.removePredicate(column, !this._columnToConfiguration.has(column));
+        var predicateId = this._searchService.addPredicate(predicate);
+        this._columnToConfiguration.set(column, __assign({ predicateId: predicateId }, configuration));
+    };
+    /**
+     * Removes a predicate that corresponds to the provided column
+     * @param column the index of the column that cleared it's search
+     * @param clearInput whether the corresponding header search input should be cleared
+     */
+    HeaderSearchService.prototype.removePredicate = function (column, clearInput) {
+        if (clearInput === void 0) { clearInput = true; }
+        var predicateConfig = this._columnToConfiguration.get(column);
+        if (predicateConfig !== undefined) {
+            this._searchService.removePredicate(predicateConfig.predicateId, clearInput);
+            this._columnToConfiguration.delete(column);
+        }
+    };
+    /**
+     * @param removedId the id of the removed {@link Predicate}
+     * @param clearInput whether the corresponding header search input should be cleared
+     */
+    HeaderSearchService.prototype.handlePredicateRemoval = function (removedId, clearInput) {
+        if (clearInput === void 0) { clearInput = true; }
+        if (this._headerService && clearInput) {
+            this._headerService.clearHeaderSearch(removedId);
+        }
+        this._columnToConfiguration.delete(removedId);
+    };
+    HeaderSearchService.ctorParameters = function () { return [
+        { type: CategoryFactory },
+        { type: ProcessService },
+        { type: TranslateService },
+        { type: LoggerService },
+        { type: SearchService, decorators: [{ type: Optional }] }
+    ]; };
+    HeaderSearchService.decorators = [
+        { type: Injectable }
+    ];
+    HeaderSearchService.ctorParameters = function () { return [
+        { type: CategoryFactory },
+        { type: ProcessService },
+        { type: TranslateService },
+        { type: LoggerService },
+        { type: SearchService, decorators: [{ type: Optional }] }
+    ]; };
+    return HeaderSearchService;
+}());
+export { HeaderSearchService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"header-search.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/search/header-search-service/header-search.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, OnDestroy, Optional} from '@angular/core';\nimport {SearchService} from '../search-service/search.service';\nimport {AbstractHeaderService} from '../../header/abstract-header-service';\nimport {HeaderType} from '../../header/models/header-type';\nimport {filter} from 'rxjs/operators';\nimport {HeaderChangeType} from '../../header/models/user-changes/header-change-type';\nimport {HeaderMode} from '../../header/models/header-mode';\nimport {ModeChangeDescription} from '../../header/models/user-changes/mode-change-description';\nimport {SearchChangeDescription} from '../../header/models/user-changes/search-change-description';\nimport {HeaderColumnType} from '../../header/models/header-column';\nimport {CaseMetaField} from '../../header/case-header/case-menta-enum';\nimport {CategoryFactory} from '../category-factory/category-factory';\nimport {CaseVisualId} from '../models/category/case/case-visual-id';\nimport {Category} from '../models/category/category';\nimport {CaseAuthor} from '../models/category/case/case-author';\nimport {CaseCreationDate} from '../models/category/case/case-creation-date';\nimport {CaseTitle} from '../models/category/case/case-title';\nimport {CaseStringId} from '../models/category/case/case-string-id';\nimport {Predicate} from '../models/predicate/predicate';\nimport {ProcessService} from '../../process/process.service';\nimport {CaseSimpleDataset} from '../models/category/case/case-simple-dataset';\nimport {TranslateService} from '@ngx-translate/core';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {Subscription} from 'rxjs';\n\n/**\n * Holds the Id of the predicate in the {@link SearchService}\n */\ninterface PredicateId {\n    predicateId: number;\n}\n\n/**\n * Holds the information necessary for the configuration of a {@link Category} class to generate\n * a predicate for a Meta header field\n */\ninterface MetaGeneratorConfiguration {\n    type: HeaderColumnType.META;\n    fieldIdentifier: string;\n    userInput: Array<any>;\n}\n\n/**\n * Holds the information necessary for the configuration of a {@link Category} class to generate\n * a predicate for a Data header field\n */\ninterface DataGeneratorConfiguration {\n    type: HeaderColumnType.IMMEDIATE;\n    fieldType: string;\n    fieldTitle: string;\n    userInput: Array<any>;\n}\n\ntype HeaderConfiguration = PredicateId & (MetaGeneratorConfiguration | DataGeneratorConfiguration);\n\n/**\n * Acts as an intermediary between the {@link AbstractHeaderService} instances of various types and the {@link SearchService}\n */\n@Injectable()\nexport class HeaderSearchService implements OnDestroy {\n\n    protected _headerService: AbstractHeaderService;\n    protected _columnToConfiguration: Map<number, HeaderConfiguration>;\n    protected _typeToCategory: Map<string, Category<any>>;\n    protected _headerSub: Subscription;\n    protected _searchSub: Subscription;\n\n    constructor(protected _categoryFactory: CategoryFactory,\n                protected _processService: ProcessService,\n                protected _translate: TranslateService,\n                protected _logger: LoggerService,\n                @Optional() protected _searchService: SearchService) {\n        this._columnToConfiguration = new Map<number, HeaderConfiguration>();\n        this._typeToCategory = new Map<string, Category<any>>();\n        [\n            {k: CaseMetaField.VISUAL_ID, v: CaseVisualId},\n            {k: CaseMetaField.TITLE, v: CaseTitle},\n            {k: CaseMetaField.CREATION_DATE, v: CaseCreationDate},\n            {k: CaseMetaField.AUTHOR, v: CaseAuthor},\n            {k: CaseMetaField.MONGO_ID, v: CaseStringId}\n        ].forEach(pair => {\n            this._typeToCategory.set(pair.k, this._categoryFactory.getWithDefaultOperator(pair.v));\n        });\n        this._typeToCategory.set(HeaderColumnType.IMMEDIATE, this._categoryFactory.get(CaseSimpleDataset));\n    }\n\n    ngOnDestroy(): void {\n        if (this._headerSub) {\n            this._headerSub.unsubscribe();\n        }\n        if (this._searchSub) {\n            this._searchSub.unsubscribe();\n        }\n        for (const cat of this._typeToCategory.values()) {\n            cat.destroy();\n        }\n    }\n\n    public set headerService(headerService: AbstractHeaderService) {\n        if (headerService.headerType === HeaderType.CASE || headerService.headerType === HeaderType.TASK) {\n            this._headerService = headerService;\n        }\n\n        if (headerService && this._searchService) {\n            this.initializeHeaderSearch();\n        }\n    }\n\n    /**\n     * {@link HeaderSearchService} can only be initialized if it successfully injected a {@link SearchService}\n     * and a {@link AbstractHeaderService} instance of any of the supported types was set into it.\n     *\n     * Currently only task and case header searching is supported.\n     */\n    protected initializeHeaderSearch(): void {\n        if (!this._searchService) {\n            this._logger.error('You can\\'t call initializeHeaderSearch without providing a SearchService to be injected!');\n            return;\n        }\n        if (!this._headerService) {\n            this._logger.error('You can\\'t call initializeHeaderSearch without setting an AbstractHeaderService implementation instance!');\n            return;\n        }\n\n        this._headerSub = this._headerService.headerChange$\n            .pipe(filter(change => change.changeType === HeaderChangeType.SEARCH || change.changeType === HeaderChangeType.MODE_CHANGED))\n            .subscribe(change => {\n                if (change.changeType === HeaderChangeType.SEARCH) {\n                    this.processSearchChange(change.headerType, change.description as SearchChangeDescription);\n                } else if ((change.description as ModeChangeDescription).previousMode === HeaderMode.SEARCH) {\n                    this.processModeChange();\n                }\n            });\n\n        this._searchSub =\n            this._searchService.predicateRemoved$.subscribe(event => this.handlePredicateRemoval(event.index, event.clearInput));\n    }\n\n    /**\n     * Pushes all the predicates from the headers into the search interface and clears the header inputs\n     */\n    protected processModeChange(): void {\n        const addedPredicateIds = [];\n        this._columnToConfiguration.forEach(config => {\n            this._searchService.removePredicate(config.predicateId);\n\n            let editableCategory;\n            if (config.type === HeaderColumnType.META) {\n                editableCategory = this._typeToCategory.get(config.fieldIdentifier).duplicate();\n                editableCategory.selectDefaultOperator();\n                editableCategory.setOperands(config.userInput);\n            } else {\n                const dataset = (this._typeToCategory.get(HeaderColumnType.IMMEDIATE) as CaseSimpleDataset);\n                editableCategory = dataset.transformToCaseDataset(config.fieldType, config.fieldTitle, config.userInput);\n            }\n            addedPredicateIds.push(this._searchService.addGeneratedLeafPredicate(editableCategory));\n        });\n\n        this._searchService.show(addedPredicateIds);\n\n        this._columnToConfiguration.clear();\n    }\n\n    /**\n     * Transforms the {@link HeaderChange} object into a search predicate\n     */\n    protected processSearchChange(headerType: HeaderType, changeDescription: SearchChangeDescription): void {\n        if (headerType === HeaderType.CASE) {\n            this.processCaseSearch(changeDescription);\n        }\n    }\n\n    /**\n     * Processes the change object and resolves it into the appropriate case search predicate change\n     * @param changeDescription the change object that should be resolved\n     */\n    protected processCaseSearch(changeDescription: SearchChangeDescription): void {\n        if (this.emptyInput(changeDescription)) {\n            this.removePredicate(changeDescription.columnIdentifier);\n            return;\n        }\n\n        if (changeDescription.type === HeaderColumnType.META) {\n            this.processCaseMetaSearch(changeDescription);\n        } else {\n            this.processCaseDataSearch(changeDescription);\n        }\n    }\n\n    /**\n     * Processes the change object of a case meta header and resolves it into the appropriate case search predicate change\n     * @param changeDescription the change object that should be resolved\n     */\n    protected processCaseMetaSearch(changeDescription: SearchChangeDescription): void {\n        const config = {\n            fieldIdentifier: changeDescription.fieldIdentifier,\n            userInput: [changeDescription.searchInput]\n        };\n        const category = this._typeToCategory.get(config.fieldIdentifier);\n        const predicate = category.generatePredicate(config.userInput);\n        this.addPredicate(changeDescription.columnIdentifier, predicate, {\n            type: HeaderColumnType.META,\n            ...config\n        });\n    }\n\n    /**\n     * Processes the change object of a case immediate data header and resolves it into the appropriate case search predicate change\n     * @param changeDescription the change object that should be resolved\n     */\n    protected processCaseDataSearch(changeDescription: SearchChangeDescription): void {\n        this._processService.getNet(changeDescription.petriNetIdentifier).subscribe(net => {\n            const config = {\n                fieldType: changeDescription.fieldType,\n                fieldTitle: changeDescription.fieldTitle,\n                userInput: [changeDescription.searchInput]\n            };\n            const category = this._typeToCategory.get(changeDescription.type) as CaseSimpleDataset;\n            category.configure(changeDescription.fieldIdentifier, config.fieldType, [net.identifier]);\n            const predicate = category.generatePredicate(config.userInput);\n            this.addPredicate(changeDescription.columnIdentifier, predicate, {\n                type: HeaderColumnType.IMMEDIATE,\n                ...config\n            });\n        });\n    }\n\n    /**\n     * @param changeDescription information about the search header change\n     * @returns whether the input was cleared\n     */\n    protected emptyInput(changeDescription: SearchChangeDescription): boolean {\n        return changeDescription.searchInput === undefined\n            || changeDescription.searchInput === null\n            || (typeof changeDescription.searchInput === 'string' && changeDescription.searchInput.length === 0);\n    }\n\n    /**\n     * Updates a Predicate for a given column.\n     * Removes an existing predicate for this column if it exists and adds the new Predicate.\n     * @param column the index of the header column\n     * @param predicate the Predicate that should be added\n     * @param configuration data necessary for the configuration of the {@link Category} that generates the added predicate\n     */\n    protected addPredicate(column: number,\n                           predicate: Predicate,\n                           configuration: MetaGeneratorConfiguration | DataGeneratorConfiguration): void {\n\n        this.removePredicate(column, !this._columnToConfiguration.has(column));\n        const predicateId = this._searchService.addPredicate(predicate);\n        this._columnToConfiguration.set(column, {predicateId, ...configuration});\n    }\n\n    /**\n     * Removes a predicate that corresponds to the provided column\n     * @param column the index of the column that cleared it's search\n     * @param clearInput whether the corresponding header search input should be cleared\n     */\n    protected removePredicate(column: number, clearInput = true): void {\n        const predicateConfig = this._columnToConfiguration.get(column);\n        if (predicateConfig !== undefined) {\n            this._searchService.removePredicate(predicateConfig.predicateId, clearInput);\n            this._columnToConfiguration.delete(column);\n        }\n    }\n\n    /**\n     * @param removedId the id of the removed {@link Predicate}\n     * @param clearInput whether the corresponding header search input should be cleared\n     */\n    protected handlePredicateRemoval(removedId: number, clearInput = true): void {\n        if (this._headerService && clearInput) {\n            this._headerService.clearHeaderSearch(removedId);\n        }\n        this._columnToConfiguration.delete(removedId);\n    }\n}\n"]}

package/esm5/lib/search/models/base-filter-injection-token.js

@@ -0,0 +1,6 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * Provides the base filter of a {@link SearchService}
+ */
+export var NAE_BASE_FILTER = new InjectionToken('NaeBaseFilter');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS1maWx0ZXItaW5qZWN0aW9uLXRva2VuLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3NlYXJjaC9tb2RlbHMvYmFzZS1maWx0ZXItaW5qZWN0aW9uLXRva2VuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxjQUFjLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFHN0M7O0dBRUc7QUFDSCxNQUFNLENBQUMsSUFBTSxlQUFlLEdBQUcsSUFBSSxjQUFjLENBQWEsZUFBZSxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0luamVjdGlvblRva2VufSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7QmFzZUZpbHRlcn0gZnJvbSAnLi9iYXNlLWZpbHRlcic7XG5cbi8qKlxuICogUHJvdmlkZXMgdGhlIGJhc2UgZmlsdGVyIG9mIGEge0BsaW5rIFNlYXJjaFNlcnZpY2V9XG4gKi9cbmV4cG9ydCBjb25zdCBOQUVfQkFTRV9GSUxURVIgPSBuZXcgSW5qZWN0aW9uVG9rZW48QmFzZUZpbHRlcj4oJ05hZUJhc2VGaWx0ZXInKTtcbiJdfQ==

package/esm5/lib/search/models/base-filter.js

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

package/esm5/lib/search/models/boolean-operator.js

@@ -0,0 +1,10 @@
+// TODO 23.4.2020 - Same as MergeOperator for Filters, should these Enums be kept separate, or should just one exist?
+/**
+ * Determines the way {@link Predicate}s are combined together.
+ */
+export var BooleanOperator;
+(function (BooleanOperator) {
+    BooleanOperator["AND"] = "AND";
+    BooleanOperator["OR"] = "OR";
+})(BooleanOperator || (BooleanOperator = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYm9vbGVhbi1vcGVyYXRvci5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9zZWFyY2gvbW9kZWxzL2Jvb2xlYW4tb3BlcmF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEscUhBQXFIO0FBQ3JIOztHQUVHO0FBQ0gsTUFBTSxDQUFOLElBQVksZUFHWDtBQUhELFdBQVksZUFBZTtJQUN2Qiw4QkFBVyxDQUFBO0lBQ1gsNEJBQVMsQ0FBQTtBQUNiLENBQUMsRUFIVyxlQUFlLEtBQWYsZUFBZSxRQUcxQiIsInNvdXJjZXNDb250ZW50IjpbIi8vIFRPRE8gMjMuNC4yMDIwIC0gU2FtZSBhcyBNZXJnZU9wZXJhdG9yIGZvciBGaWx0ZXJzLCBzaG91bGQgdGhlc2UgRW51bXMgYmUga2VwdCBzZXBhcmF0ZSwgb3Igc2hvdWxkIGp1c3Qgb25lIGV4aXN0P1xuLyoqXG4gKiBEZXRlcm1pbmVzIHRoZSB3YXkge0BsaW5rIFByZWRpY2F0ZX1zIGFyZSBjb21iaW5lZCB0b2dldGhlci5cbiAqL1xuZXhwb3J0IGVudW0gQm9vbGVhbk9wZXJhdG9yIHtcbiAgICBBTkQgPSAnQU5EJyxcbiAgICBPUiA9ICdPUidcbn1cbiJdfQ==

package/esm5/lib/search/models/category/autocomplete-category.js

@@ -0,0 +1,155 @@
+import { __extends, __read, __values } from "tslib";
+import { Category } from './category';
+import { SearchInputType } from './search-input-type';
+import { BehaviorSubject, combineLatest, ReplaySubject } from 'rxjs';
+import { filter, map, startWith, take } from 'rxjs/operators';
+/**
+ * Represents a Search Category whose values are a known set. The value selection is done with an autocomplete field.
+ *
+ * @typeparam T type of the object that the autocomplete option values use and in turn is used to generate queries
+ */
+var AutocompleteCategory = /** @class */ (function (_super) {
+    __extends(AutocompleteCategory, _super);
+    function AutocompleteCategory(elasticKeywords, allowedOperators, translationPath, log, operatorService) {
+        var _this = _super.call(this, elasticKeywords, allowedOperators, translationPath, SearchInputType.AUTOCOMPLETE, log, operatorService) || this;
+        _this._optionsMap = new Map();
+        _this._options$ = new BehaviorSubject([]);
+        // timeout is used to bypass javascript object initialization bugs.
+        // Injected properties of inherited classes were not set in the function call.
+        _this._timeoutId = setTimeout(function () {
+            _this.createOptions();
+        });
+        return _this;
+    }
+    AutocompleteCategory.prototype.destroy = function () {
+        _super.prototype.destroy.call(this);
+        this._options$.complete();
+        clearTimeout(this._timeoutId);
+    };
+    Object.defineProperty(AutocompleteCategory.prototype, "options", {
+        /**
+         * Options the user can select from for this search Category.
+         */
+        get: function () {
+            return this._options$.value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AutocompleteCategory.prototype, "options$", {
+        /**
+         * An Observable of the options the user can select from for this search Category.
+         *
+         * The Observable is updated when the base set of options changes, not when the available options are
+         * filtered, see [filterOptions()]{@link AutocompleteCategory#filterOptions}.
+         *
+         * The Observable initially contains an empty array and the options may appear at a later point in time
+         * (based on the concrete AutocompleteCategory subclass implementation)
+         */
+        get: function () {
+            return this._options$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Publishes a new value in the [_options$]{@link AutocompleteCategory#_options$} Subject generated from the
+     * [_optionsMap]{@link AutocompleteCategory#_optionsMap}.
+     *
+     * The default implementation iterates trough the [_optionsMap]{@link AutocompleteCategory#_optionsMap} and
+     * creates options with the keys as [text]{@link SearchAutocompleteOption#text}
+     * and values as [value]{@link SearchAutocompleteOption#value}.
+     */
+    AutocompleteCategory.prototype.updateOptions = function () {
+        var e_1, _a;
+        var result = [];
+        try {
+            for (var _b = __values(this._optionsMap.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var entry = _c.value;
+                result.push(this.createSearchAutocompleteOption(entry[0], entry[1]));
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        this._options$.next(result);
+    };
+    /**
+     * The function that is used to filter shown options in the autocomplete field.
+     *
+     * By default the options that start with the input string are returned (case insensitive).
+     *
+     * By default a new value is emitted, whenever either the user input or the base set of options changes.
+     * @param userInput user search input
+     * @returns options that satisfy the autocomplete condition
+     */
+    AutocompleteCategory.prototype.filterOptions = function (userInput) {
+        return combineLatest([
+            userInput.pipe(startWith(''), map(function (input) { return typeof input === 'string' ? input.toLocaleLowerCase() : input.text; })),
+            this.options$
+        ]).pipe(map(function (_a) {
+            var _b = __read(_a, 2), input = _b[0], options = _b[1];
+            return options.filter(function (o) { return o.text.toLocaleLowerCase().startsWith(input); });
+        }));
+    };
+    /**
+     * Adds a new entry or pushes value into an existing entry.
+     * When a new entry is created, it is created as an Array of one element.
+     * @param key where in the map should the value be added
+     * @param value the value that should be added to the map
+     */
+    AutocompleteCategory.prototype.addToMap = function (key, value) {
+        if (this._optionsMap.has(key)) {
+            this._optionsMap.get(key).push(value);
+        }
+        else {
+            this._optionsMap.set(key, [value]);
+        }
+    };
+    AutocompleteCategory.prototype.isOperandValueSelected = function (newValue) {
+        return !(!newValue || typeof newValue === 'string');
+    };
+    /**
+     * Performs a transformation of the `FormControl` value before passing it into the selected `Operator` for query generation.
+     * It is mostly useful only for AutocompleteCategories, where the selected value of the FormControl is an object.
+     *
+     * The default AutocompleteCategory implementation returns the {@link SearchAutocompleteOption} `value` attribute.
+     * @param value the FormControlValue
+     * @returns the value used for query generation
+     */
+    AutocompleteCategory.prototype.transformCategoryValue = function (value) {
+        return value.value;
+    };
+    AutocompleteCategory.prototype.serializeOperandValue = function (valueFormControl) {
+        return valueFormControl.value.text;
+    };
+    /**
+     * @param text the serialized output of the [serializeOperandValue()]{@link Category#serializeOperandValue} method
+     * @returns the deserialized value, that can be set as FormControl value
+     *
+     * This method throws na error if the serialized value is not one of the autocomplete options.
+     */
+    AutocompleteCategory.prototype.deserializeOperandValue = function (text) {
+        var _this = this;
+        var result$ = new ReplaySubject(1);
+        this.options$.pipe(filter(function (o) { return o.length > 0; }), take(1)).subscribe(function () {
+            var value = _this._optionsMap.get(text);
+            if (value === undefined) {
+                throw new Error("The serialized autocomplete value '" + value + "' does not map to any autocomplete options and cannot be deserialized!");
+            }
+            result$.next(_this.createSearchAutocompleteOption(text, value));
+            result$.complete();
+        });
+        return result$.asObservable();
+    };
+    AutocompleteCategory.prototype.createSearchAutocompleteOption = function (text, value) {
+        return { text: text, value: value };
+    };
+    return AutocompleteCategory;
+}(Category));
+export { AutocompleteCategory };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"autocomplete-category.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/search/models/category/autocomplete-category.ts"],"names":[],"mappings":";AAAA,OAAO,EAAC,QAAQ,EAAC,MAAM,YAAY,CAAC;AAGpC,OAAO,EAAC,eAAe,EAAC,MAAM,qBAAqB,CAAC;AAEpD,OAAO,EAAC,eAAe,EAAE,aAAa,EAAc,aAAa,EAAC,MAAM,MAAM,CAAC;AAC/E,OAAO,EAAC,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,IAAI,EAAC,MAAM,gBAAgB,CAAC;AAK5D;;;;GAIG;AACH;IAAsD,wCAAkB;IAiBpE,8BAAsB,eAA8B,EAC9B,gBAAsC,EACtC,eAAuB,EACvB,GAAkB,EAClB,eAAgC;QAJtD,YAKI,kBAAM,eAAe,EAAE,gBAAgB,EAAE,eAAe,EAAE,eAAe,CAAC,YAAY,EAAE,GAAG,EAAE,eAAe,CAAC,SAQhH;QAPG,KAAI,CAAC,WAAW,GAAG,IAAI,GAAG,EAAoB,CAAC;QAC/C,KAAI,CAAC,SAAS,GAAG,IAAI,eAAe,CAA4C,EAAE,CAAC,CAAC;QACpF,mEAAmE;QACnE,8EAA8E;QAC9E,KAAI,CAAC,UAAU,GAAG,UAAU,CAAC;YACzB,KAAI,CAAC,aAAa,EAAE,CAAC;QACzB,CAAC,CAAC,CAAC;;IACP,CAAC;IAED,sCAAO,GAAP;QACI,iBAAM,OAAO,WAAE,CAAC;QAChB,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;QAC1B,YAAY,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAClC,CAAC;IAKD,sBAAW,yCAAO;QAHlB;;WAEG;aACH;YACI,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;QAChC,CAAC;;;OAAA;IAWD,sBAAW,0CAAQ;QATnB;;;;;;;;WAQG;aACH;YACI,OAAO,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,CAAC;QACzC,CAAC;;;OAAA;IAED;;;;;;;OAOG;IACO,4CAAa,GAAvB;;QACI,IAAM,MAAM,GAAG,EAAE,CAAC;;YAClB,KAAoB,IAAA,KAAA,SAAA,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,CAAA,gBAAA,4BAAE;gBAA3C,IAAM,KAAK,WAAA;gBACZ,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,8BAA8B,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;aACxE;;;;;;;;;QACD,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAChC,CAAC;IASD;;;;;;;;OAQG;IACI,4CAAa,GAApB,UAAqB,SAAkE;QAEnF,OAAO,aAAa,CAAC;YACjB,SAAS,CAAC,IAAI,CACV,SAAS,CAAC,EAAE,CAAC,EACb,GAAG,CAAC,UAAA,KAAK,IAAI,OAAA,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,iBAAiB,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,EAAlE,CAAkE,CAAC,CACnF;YACD,IAAI,CAAC,QAAQ;SAChB,CAAC,CAAC,IAAI,CACH,GAAG,CAAC,UAAC,EAAgB;gBAAhB,KAAA,aAAgB,EAAf,KAAK,QAAA,EAAE,OAAO,QAAA;YAChB,OAAO,OAAO,CAAC,MAAM,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,IAAI,CAAC,iBAAiB,EAAE,CAAC,UAAU,CAAC,KAAK,CAAC,EAA5C,CAA4C,CAAC,CAAC;QAC7E,CAAC,CAAC,CACL,CAAC;IACN,CAAC;IAED;;;;;OAKG;IACO,uCAAQ,GAAlB,UAAmB,GAAQ,EAAE,KAAQ;QACjC,IAAI,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;YAC3B,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;SACzC;aAAM;YACH,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;SACtC;IACL,CAAC;IAES,qDAAsB,GAAhC,UAAiC,QAAqD;QAClF,OAAO,CAAC,CAAC,CAAC,QAAQ,IAAI,OAAO,QAAQ,KAAK,QAAQ,CAAC,CAAC;IACxD,CAAC;IAED;;;;;;;OAOG;IACO,qDAAsB,GAAhC,UAAiC,KAAyC;QACtE,OAAO,KAAK,CAAC,KAAK,CAAC;IACvB,CAAC;IAES,oDAAqB,GAA/B,UAAgC,gBAA6B;QACzD,OAAQ,gBAAgB,CAAC,KAA2C,CAAC,IAAI,CAAC;IAC9E,CAAC;IAED;;;;;OAKG;IACO,sDAAuB,GAAjC,UAAkC,IAAa;QAA/C,iBAYC;QAXG,IAAM,OAAO,GAAG,IAAI,aAAa,CAAC,CAAC,CAAC,CAAC;QACrC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,MAAM,GAAG,CAAC,EAAZ,CAAY,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;YAC7D,IAAM,KAAK,GAAG,KAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAc,CAAC,CAAC;YACnD,IAAI,KAAK,KAAK,SAAS,EAAE;gBACrB,MAAM,IAAI,KAAK,CAAC,wCAAsC,KAAK,2EACa,CAAC,CAAC;aAC7E;YACD,OAAO,CAAC,IAAI,CAAC,KAAI,CAAC,8BAA8B,CAAC,IAAc,EAAE,KAAK,CAAC,CAAC,CAAC;YACzE,OAAO,CAAC,QAAQ,EAAE,CAAC;QACvB,CAAC,CAAC,CAAC;QACH,OAAO,OAAO,CAAC,YAAY,EAAE,CAAC;IAClC,CAAC;IAES,6DAA8B,GAAxC,UAAyC,IAAY,EAAE,KAAe;QAClE,OAAO,EAAC,IAAI,MAAA,EAAE,KAAK,OAAA,EAAC,CAAC;IACzB,CAAC;IACL,2BAAC;AAAD,CAAC,AAlKD,CAAsD,QAAQ,GAkK7D","sourcesContent":["import {Category} from './category';\nimport {Operator} from '../operator/operator';\nimport {LoggerService} from '../../../logger/services/logger.service';\nimport {SearchInputType} from './search-input-type';\nimport {SearchAutocompleteOption} from './search-autocomplete-option';\nimport {BehaviorSubject, combineLatest, Observable, ReplaySubject} from 'rxjs';\nimport {filter, map, startWith, take} from 'rxjs/operators';\nimport {AutocompleteOptions} from './autocomplete-options';\nimport {FormControl} from '@angular/forms';\nimport {OperatorService} from '../../operator-service/operator.service';\n\n/**\n * Represents a Search Category whose values are a known set. The value selection is done with an autocomplete field.\n *\n * @typeparam T type of the object that the autocomplete option values use and in turn is used to generate queries\n */\nexport abstract class AutocompleteCategory<T> extends Category<Array<T>> implements AutocompleteOptions {\n\n    /**\n     * Autocomplete categories usually require a map to represent mapping of display names\n     * of their options to objects that are needed to construct their queries.\n     *\n     * You are not required to use this map when you implement your own Category,\n     * but it comes with helpful functions and might save you some time.\n     *\n     * See [options()]{@link AutocompleteCategory#options} and [addToMap()]{@link AutocompleteCategory#addToMap}.\n     */\n    protected _optionsMap: Map<string, Array<T>>;\n\n    protected _options$: BehaviorSubject<Array<SearchAutocompleteOption<Array<T>>>>;\n\n    private readonly _timeoutId: number;\n\n    protected constructor(elasticKeywords: Array<string>,\n                          allowedOperators: Array<Operator<any>>,\n                          translationPath: string,\n                          log: LoggerService,\n                          operatorService: OperatorService) {\n        super(elasticKeywords, allowedOperators, translationPath, SearchInputType.AUTOCOMPLETE, log, operatorService);\n        this._optionsMap = new Map<string, Array<T>>();\n        this._options$ = new BehaviorSubject<Array<SearchAutocompleteOption<Array<T>>>>([]);\n        // timeout is used to bypass javascript object initialization bugs.\n        // Injected properties of inherited classes were not set in the function call.\n        this._timeoutId = setTimeout(() => {\n            this.createOptions();\n        });\n    }\n\n    destroy() {\n        super.destroy();\n        this._options$.complete();\n        clearTimeout(this._timeoutId);\n    }\n\n    /**\n     * Options the user can select from for this search Category.\n     */\n    public get options(): Array<SearchAutocompleteOption<Array<T>>> {\n        return this._options$.value;\n    }\n\n    /**\n     * An Observable of the options the user can select from for this search Category.\n     *\n     * The Observable is updated when the base set of options changes, not when the available options are\n     * filtered, see [filterOptions()]{@link AutocompleteCategory#filterOptions}.\n     *\n     * The Observable initially contains an empty array and the options may appear at a later point in time\n     * (based on the concrete AutocompleteCategory subclass implementation)\n     */\n    public get options$(): Observable<Array<SearchAutocompleteOption<Array<T>>>> {\n        return this._options$.asObservable();\n    }\n\n    /**\n     * Publishes a new value in the [_options$]{@link AutocompleteCategory#_options$} Subject generated from the\n     * [_optionsMap]{@link AutocompleteCategory#_optionsMap}.\n     *\n     * The default implementation iterates trough the [_optionsMap]{@link AutocompleteCategory#_optionsMap} and\n     * creates options with the keys as [text]{@link SearchAutocompleteOption#text}\n     * and values as [value]{@link SearchAutocompleteOption#value}.\n     */\n    protected updateOptions(): void {\n        const result = [];\n        for (const entry of this._optionsMap.entries()) {\n            result.push(this.createSearchAutocompleteOption(entry[0], entry[1]));\n        }\n        this._options$.next(result);\n    }\n\n    /**\n     * Populates the [_options]{@link AutocompleteCategory#_options} field with options for this category.\n     *\n     * You must call this method yourself in an appropriate place of Category creation.\n     */\n    protected abstract createOptions(): void;\n\n    /**\n     * The function that is used to filter shown options in the autocomplete field.\n     *\n     * By default the options that start with the input string are returned (case insensitive).\n     *\n     * By default a new value is emitted, whenever either the user input or the base set of options changes.\n     * @param userInput user search input\n     * @returns options that satisfy the autocomplete condition\n     */\n    public filterOptions(userInput: Observable<string | SearchAutocompleteOption<Array<T>>>):\n        Observable<Array<SearchAutocompleteOption<Array<T>>>> {\n        return combineLatest([\n            userInput.pipe(\n                startWith(''),\n                map(input => typeof input === 'string' ? input.toLocaleLowerCase() : input.text)\n            ),\n            this.options$\n        ]).pipe(\n            map(([input, options]) => {\n                return options.filter(o => o.text.toLocaleLowerCase().startsWith(input));\n            })\n        );\n    }\n\n    /**\n     * Adds a new entry or pushes value into an existing entry.\n     * When a new entry is created, it is created as an Array of one element.\n     * @param key where in the map should the value be added\n     * @param value the value that should be added to the map\n     */\n    protected addToMap(key: any, value: T): void {\n        if (this._optionsMap.has(key)) {\n            this._optionsMap.get(key).push(value);\n        } else {\n            this._optionsMap.set(key, [value]);\n        }\n    }\n\n    protected isOperandValueSelected(newValue: SearchAutocompleteOption<Array<T>> | string): boolean {\n        return !(!newValue || typeof newValue === 'string');\n    }\n\n    /**\n     * Performs a transformation of the `FormControl` value before passing it into the selected `Operator` for query generation.\n     * It is mostly useful only for AutocompleteCategories, where the selected value of the FormControl is an object.\n     *\n     * The default AutocompleteCategory implementation returns the {@link SearchAutocompleteOption} `value` attribute.\n     * @param value the FormControlValue\n     * @returns the value used for query generation\n     */\n    protected transformCategoryValue(value: SearchAutocompleteOption<Array<T>>): Array<T> {\n        return value.value;\n    }\n\n    protected serializeOperandValue(valueFormControl: FormControl): unknown {\n        return (valueFormControl.value as SearchAutocompleteOption<unknown>).text;\n    }\n\n    /**\n     * @param text the serialized output of the [serializeOperandValue()]{@link Category#serializeOperandValue} method\n     * @returns the deserialized value, that can be set as FormControl value\n     *\n     * This method throws na error if the serialized value is not one of the autocomplete options.\n     */\n    protected deserializeOperandValue(text: unknown): Observable<any> {\n        const result$ = new ReplaySubject(1);\n        this.options$.pipe(filter(o => o.length > 0), take(1)).subscribe(() => {\n            const value = this._optionsMap.get(text as string);\n            if (value === undefined) {\n                throw new Error(`The serialized autocomplete value '${value\n                }' does not map to any autocomplete options and cannot be deserialized!`);\n            }\n            result$.next(this.createSearchAutocompleteOption(text as string, value));\n            result$.complete();\n        });\n        return result$.asObservable();\n    }\n\n    protected createSearchAutocompleteOption(text: string, value: Array<T>): SearchAutocompleteOption<Array<T>> {\n        return {text, value};\n    }\n}\n"]}

package/esm5/lib/search/models/category/autocomplete-options.js

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

package/esm5/lib/search/models/category/case/case-author.js

@@ -0,0 +1,29 @@
+import { __extends } from "tslib";
+import { Equals } from '../../operator/equals';
+import { NotEquals } from '../../operator/not-equals';
+import { Categories } from '../categories';
+import { CaseSearch } from './case-search.enum';
+import { NoConfigurationUserAutocompleteCategory } from '../no-configuration-user-autocomplete-category';
+var CaseAuthor = /** @class */ (function (_super) {
+    __extends(CaseAuthor, _super);
+    function CaseAuthor(operators, logger, optionalDependencies) {
+        return _super.call(this, [CaseSearch.AUTHOR], [operators.getOperator(Equals), operators.getOperator(NotEquals)], CaseAuthor._i18n + ".name", logger, operators, 'CaseAuthor', optionalDependencies) || this;
+    }
+    Object.defineProperty(CaseAuthor.prototype, "inputPlaceholder", {
+        get: function () {
+            return CaseAuthor._i18n + ".placeholder";
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CaseAuthor.prototype.duplicate = function () {
+        return new CaseAuthor(this._operatorService, this._log, this._optionalDependencies);
+    };
+    CaseAuthor.prototype.serializeClass = function () {
+        return Categories.CASE_AUTHOR;
+    };
+    CaseAuthor._i18n = 'search.category.case.author';
+    return CaseAuthor;
+}(NoConfigurationUserAutocompleteCategory));
+export { CaseAuthor };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/search/models/category/case/case-creation-date-time.js

@@ -0,0 +1,51 @@
+import { __extends } from "tslib";
+import moment from 'moment';
+import { SearchInputType } from '../search-input-type';
+import { NoConfigurationCategory } from '../no-configuration-category';
+import { Categories } from '../categories';
+import { of } from 'rxjs';
+import { EqualsDateTime } from '../../operator/equals-date-time';
+import { MoreThanDateTime } from '../../operator/more-than-date-time';
+import { MoreThanEqualDateTime } from '../../operator/more-than-equal-date-time';
+import { LessThanEqualDateTime } from '../../operator/less-than-equal-date-time';
+import { InRangeDateTime } from '../../operator/in-range-date-time';
+import { LessThanDateTime } from '../../operator/less-than-date-time';
+import { CaseSearch } from './case-search.enum';
+import { NotEqualsDateTime } from '../../operator/not-equals-date-time';
+var CaseCreationDateTime = /** @class */ (function (_super) {
+    __extends(CaseCreationDateTime, _super);
+    function CaseCreationDateTime(operators, logger) {
+        return _super.call(this, [CaseSearch.CREATION_DATE], [
+            operators.getOperator(EqualsDateTime),
+            operators.getOperator(NotEqualsDateTime),
+            operators.getOperator(MoreThanDateTime),
+            operators.getOperator(MoreThanEqualDateTime),
+            operators.getOperator(LessThanDateTime),
+            operators.getOperator(LessThanEqualDateTime),
+            operators.getOperator(InRangeDateTime)
+        ], CaseCreationDateTime._i18n + ".name", SearchInputType.DATE_TIME, logger, operators) || this;
+    }
+    Object.defineProperty(CaseCreationDateTime.prototype, "inputPlaceholder", {
+        get: function () {
+            return CaseCreationDateTime._i18n + ".placeholder";
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CaseCreationDateTime.prototype.duplicate = function () {
+        return new CaseCreationDateTime(this._operatorService, this._log);
+    };
+    CaseCreationDateTime.prototype.serializeClass = function () {
+        return Categories.CASE_CREATION_DATE_TIME;
+    };
+    CaseCreationDateTime.prototype.serializeOperandValue = function (valueFormControl) {
+        return valueFormControl.value.valueOf();
+    };
+    CaseCreationDateTime.prototype.deserializeOperandValue = function (value) {
+        return of(moment(value));
+    };
+    CaseCreationDateTime._i18n = 'search.category.case.creationDateTime';
+    return CaseCreationDateTime;
+}(NoConfigurationCategory));
+export { CaseCreationDateTime };
+//# sourceMappingURL=data:application/json;base64,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