@netgrif/components-core 6.0.1

package/esm5/lib/search/category-factory/category-factory.js

@@ -0,0 +1,96 @@
+import { Injectable, Optional } from '@angular/core';
+import { LoggerService } from '../../logger/services/logger.service';
+import { OperatorService } from '../operator-service/operator.service';
+import { UserResourceService } from '../../resources/engine-endpoint/user-resource.service';
+import { SearchIndexResolverService } from '../search-keyword-resolver-service/search-index-resolver.service';
+import { CategoryResolverService } from './category-resolver.service';
+import { AllowedNetsService } from '../../allowed-nets/services/allowed-nets.service';
+import { ReplaySubject } from 'rxjs';
+/**
+ * Can be used to generate {@link Category} class instances.
+ *
+ * Can only generate instances of Categories that take {@link OperatorService} as their first argument, {@link LoggerService} as their
+ * second argument and {@link OptionalDependencies} object is passed as the third. `null` is passed as the third argument otherwise.
+ * You can extend this class to support your Categories, but make sure that an injection token for this classes name
+ * is still provided for the library components that use it.
+ */
+var CategoryFactory = /** @class */ (function () {
+    function CategoryFactory(_operators, _log, _searchIndexResolverService, _categoryResolver, _allowedNetsService, _userResourceService) {
+        this._operators = _operators;
+        this._log = _log;
+        this._searchIndexResolverService = _searchIndexResolverService;
+        this._categoryResolver = _categoryResolver;
+        this._allowedNetsService = _allowedNetsService;
+        this._userResourceService = _userResourceService;
+        this._optionalDependencies = {
+            categoryFactory: this,
+            searchIndexResolver: this._searchIndexResolverService,
+            allowedNetsService: this._allowedNetsService,
+            userResourceService: this._userResourceService,
+        };
+    }
+    /**
+     * Create an instance of {@link Category} class.
+     * @param categoryClass the class that should be instantiated
+     * @returns a new instance of the provided class
+     */
+    CategoryFactory.prototype.get = function (categoryClass) {
+        return new categoryClass(this._operators, this._log, this._optionalDependencies);
+    };
+    /**
+     * Create an instance of {@link Category} class and preselects it's default operator.
+     * @param categoryClass the class that should be instantiated
+     * @returns a new instance of the provided class with the default operator selected
+     */
+    CategoryFactory.prototype.getWithDefaultOperator = function (categoryClass) {
+        var category = this.get(categoryClass);
+        category.selectDefaultOperator();
+        return category;
+    };
+    /**
+     * Attempts to deserialize the provided `string` into a {@link Category} class,
+     * create an instance from it and preselect it's default operator.
+     * @param serializedCategoryClass the serialized form of a {@Link Category} class
+     * @returns a new instance of the provided class with the default operator selected
+     */
+    CategoryFactory.prototype.getByNameWithDefaultOperator = function (serializedCategoryClass) {
+        return this.getWithDefaultOperator(this._categoryResolver.toClass(serializedCategoryClass));
+    };
+    /**
+     * Reconstructs a {@link Category} from saved metadata. The category is NOT in its initial state.
+     * It is in its final state instead and immediately provides a search predicate.
+     * @param metadata - the saved metadata generated by a previous {@link Category} instance
+     * @returns an Observable, that emits the deserialized Category, once the deserialization finishes
+     */
+    CategoryFactory.prototype.getFromMetadata = function (metadata) {
+        var result$ = new ReplaySubject(1);
+        var category = this.get(this._categoryResolver.toClass(metadata.category));
+        category.loadFromMetadata(metadata).subscribe(function () {
+            result$.next(category);
+            result$.complete();
+        });
+        return result$.asObservable();
+    };
+    CategoryFactory.ctorParameters = function () { return [
+        { type: OperatorService },
+        { type: LoggerService },
+        { type: SearchIndexResolverService },
+        { type: CategoryResolverService },
+        { type: AllowedNetsService },
+        { type: UserResourceService, decorators: [{ type: Optional }] }
+    ]; };
+    CategoryFactory.decorators = [
+        { type: Injectable }
+    ];
+    CategoryFactory.ctorParameters = function () { return [
+        { type: OperatorService },
+        { type: LoggerService },
+        { type: SearchIndexResolverService },
+        { type: CategoryResolverService },
+        { type: AllowedNetsService },
+        { type: UserResourceService, decorators: [{ type: Optional }] }
+    ]; };
+    return CategoryFactory;
+}());
+export { CategoryFactory };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"category-factory.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/search/category-factory/category-factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAE,QAAQ,EAAO,MAAM,eAAe,CAAC;AACzD,OAAO,EAAC,aAAa,EAAC,MAAM,sCAAsC,CAAC;AACnE,OAAO,EAAC,eAAe,EAAC,MAAM,sCAAsC,CAAC;AAGrE,OAAO,EAAC,mBAAmB,EAAC,MAAM,uDAAuD,CAAC;AAC1F,OAAO,EAAC,0BAA0B,EAAC,MAAM,kEAAkE,CAAC;AAE5G,OAAO,EAAC,uBAAuB,EAAC,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAC,kBAAkB,EAAC,MAAM,kDAAkD,CAAC;AACpF,OAAO,EAAa,aAAa,EAAC,MAAM,MAAM,CAAC;AAE/C;;;;;;;GAOG;AACH;IAKI,yBAAsB,UAA2B,EAC3B,IAAmB,EACnB,2BAAuD,EACvD,iBAA0C,EAC1C,mBAAuC,EAC3B,oBAAyC;QALrD,eAAU,GAAV,UAAU,CAAiB;QAC3B,SAAI,GAAJ,IAAI,CAAe;QACnB,gCAA2B,GAA3B,2BAA2B,CAA4B;QACvD,sBAAiB,GAAjB,iBAAiB,CAAyB;QAC1C,wBAAmB,GAAnB,mBAAmB,CAAoB;QAC3B,yBAAoB,GAApB,oBAAoB,CAAqB;QACvE,IAAI,CAAC,qBAAqB,GAAG;YACzB,eAAe,EAAE,IAAI;YACrB,mBAAmB,EAAE,IAAI,CAAC,2BAA2B;YACrD,kBAAkB,EAAE,IAAI,CAAC,mBAAmB;YAC5C,mBAAmB,EAAE,IAAI,CAAC,oBAAoB;SACjD,CAAC;IACN,CAAC;IAED;;;;OAIG;IACI,6BAAG,GAAV,UAAW,aAAkC;QACzC,OAAO,IAAI,aAAa,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,qBAAqB,CAAC,CAAC;IACrF,CAAC;IAED;;;;OAIG;IACI,gDAAsB,GAA7B,UAA8B,aAAkC;QAC5D,IAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;QACzC,QAAQ,CAAC,qBAAqB,EAAE,CAAC;QACjC,OAAO,QAAQ,CAAC;IACpB,CAAC;IAED;;;;;OAKG;IACI,sDAA4B,GAAnC,UAAoC,uBAA+B;QAC/D,OAAO,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,uBAAuB,CAAC,CAAC,CAAC;IAChG,CAAC;IAED;;;;;OAKG;IACI,yCAAe,GAAtB,UAAuB,QAAmC;QACtD,IAAM,OAAO,GAAG,IAAI,aAAa,CAAgB,CAAC,CAAC,CAAC;QACpD,IAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC;QAC7E,QAAQ,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC;YAC1C,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACvB,OAAO,CAAC,QAAQ,EAAE,CAAC;QACvB,CAAC,CAAC,CAAC;QACH,OAAO,OAAO,CAAC,YAAY,EAAE,CAAC;IAClC,CAAC;;gBA1DiC,eAAe;gBACrB,aAAa;gBACU,0BAA0B;gBACpC,uBAAuB;gBACrB,kBAAkB;gBACL,mBAAmB,uBAA9D,QAAQ;;;gBAVxB,UAAU;;;gBAlBH,eAAe;gBADf,aAAa;gBAKb,0BAA0B;gBAE1B,uBAAuB;gBACvB,kBAAkB;gBAJlB,mBAAmB,uBAyBV,QAAQ;;IAsDzB,sBAAC;CAAA,AAhED,IAgEC;SA/DY,eAAe","sourcesContent":["import {Injectable, Optional, Type} from '@angular/core';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {OperatorService} from '../operator-service/operator.service';\nimport {Category} from '../models/category/category';\nimport {OptionalDependencies} from './optional-dependencies';\nimport {UserResourceService} from '../../resources/engine-endpoint/user-resource.service';\nimport {SearchIndexResolverService} from '../search-keyword-resolver-service/search-index-resolver.service';\nimport {CategoryGeneratorMetadata} from '../models/persistance/generator-metadata';\nimport {CategoryResolverService} from './category-resolver.service';\nimport {AllowedNetsService} from '../../allowed-nets/services/allowed-nets.service';\nimport {Observable, ReplaySubject} from 'rxjs';\n\n/**\n * Can be used to generate {@link Category} class instances.\n *\n * Can only generate instances of Categories that take {@link OperatorService} as their first argument, {@link LoggerService} as their\n * second argument and {@link OptionalDependencies} object is passed as the third. `null` is passed as the third argument otherwise.\n * You can extend this class to support your Categories, but make sure that an injection token for this classes name\n * is still provided for the library components that use it.\n */\n@Injectable()\nexport class CategoryFactory {\n\n    protected _optionalDependencies: OptionalDependencies;\n\n    constructor(protected _operators: OperatorService,\n                protected _log: LoggerService,\n                protected _searchIndexResolverService: SearchIndexResolverService,\n                protected _categoryResolver: CategoryResolverService,\n                protected _allowedNetsService: AllowedNetsService,\n                @Optional() protected _userResourceService: UserResourceService) {\n        this._optionalDependencies = {\n            categoryFactory: this,\n            searchIndexResolver: this._searchIndexResolverService,\n            allowedNetsService: this._allowedNetsService,\n            userResourceService: this._userResourceService,\n        };\n    }\n\n    /**\n     * Create an instance of {@link Category} class.\n     * @param categoryClass the class that should be instantiated\n     * @returns a new instance of the provided class\n     */\n    public get(categoryClass: Type<Category<any>>): Category<any> {\n        return new categoryClass(this._operators, this._log, this._optionalDependencies);\n    }\n\n    /**\n     * Create an instance of {@link Category} class and preselects it's default operator.\n     * @param categoryClass the class that should be instantiated\n     * @returns a new instance of the provided class with the default operator selected\n     */\n    public getWithDefaultOperator(categoryClass: Type<Category<any>>): Category<any> {\n        const category = this.get(categoryClass);\n        category.selectDefaultOperator();\n        return category;\n    }\n\n    /**\n     * Attempts to deserialize the provided `string` into a {@link Category} class,\n     * create an instance from it and preselect it's default operator.\n     * @param serializedCategoryClass the serialized form of a {@Link Category} class\n     * @returns a new instance of the provided class with the default operator selected\n     */\n    public getByNameWithDefaultOperator(serializedCategoryClass: string): Category<any> {\n        return this.getWithDefaultOperator(this._categoryResolver.toClass(serializedCategoryClass));\n    }\n\n    /**\n     * Reconstructs a {@link Category} from saved metadata. The category is NOT in its initial state.\n     * It is in its final state instead and immediately provides a search predicate.\n     * @param metadata - the saved metadata generated by a previous {@link Category} instance\n     * @returns an Observable, that emits the deserialized Category, once the deserialization finishes\n     */\n    public getFromMetadata(metadata: CategoryGeneratorMetadata): Observable<Category<any>> {\n        const result$ = new ReplaySubject<Category<any>>(1);\n        const category = this.get(this._categoryResolver.toClass(metadata.category));\n        category.loadFromMetadata(metadata).subscribe(() => {\n            result$.next(category);\n            result$.complete();\n        });\n        return result$.asObservable();\n    }\n}\n"]}

package/esm5/lib/search/category-factory/category-resolver.service.js

@@ -0,0 +1,152 @@
+import { Injectable } from '@angular/core';
+import { Categories } from '../models/category/categories';
+import { Category } from '../models/category/category';
+import { CaseAuthor } from '../models/category/case/case-author';
+import { CaseCreationDate } from '../models/category/case/case-creation-date';
+import { CaseDataset } from '../models/category/case/case-dataset';
+import { CaseProcess } from '../models/category/case/case-process';
+import { CaseRole } from '../models/category/case/case-role';
+import { CaseSimpleDataset } from '../models/category/case/case-simple-dataset';
+import { CaseTask } from '../models/category/case/case-task';
+import { CaseTitle } from '../models/category/case/case-title';
+import { CaseVisualId } from '../models/category/case/case-visual-id';
+import { CaseStringId } from '../models/category/case/case-string-id';
+import { TaskAssignee } from '../models/category/task/task-assignee';
+import { TaskProcess } from '../models/category/task/task-process';
+import { TaskRole } from '../models/category/task/task-role';
+import { TaskTask } from '../models/category/task/task-task';
+import { CaseCreationDateTime } from '../models/category/case/case-creation-date-time';
+import * as i0 from "@angular/core";
+/**
+ * A service that resolves {@link Categories} (or custom string) into a concrete {@link Category} implementation class and vice versa.
+ */
+var CategoryResolverService = /** @class */ (function () {
+    function CategoryResolverService() {
+        this._classToStringTable = {};
+        this._stringToClassTable = {};
+        this.registerDefaultPairings();
+    }
+    /**
+     * Registers the default class - serialisation pairings for all the {@link Category} classes provided by this library.
+     */
+    CategoryResolverService.prototype.registerDefaultPairings = function () {
+        var _this = this;
+        [
+            // Case
+            {
+                classReference: CaseAuthor,
+                serialized: Categories.CASE_AUTHOR
+            }, {
+                classReference: CaseCreationDate,
+                serialized: Categories.CASE_CREATION_DATE
+            }, {
+                classReference: CaseCreationDateTime,
+                serialized: Categories.CASE_CREATION_DATE_TIME
+            }, {
+                classReference: CaseDataset,
+                serialized: Categories.CASE_DATASET
+            }, {
+                classReference: CaseProcess,
+                serialized: Categories.CASE_PROCESS
+            }, {
+                classReference: CaseRole,
+                serialized: Categories.CASE_ROLE
+            }, {
+                classReference: CaseSimpleDataset,
+                serialized: Categories.CASE_SIMPLE_DATASET
+            }, {
+                classReference: CaseTask,
+                serialized: Categories.CASE_TASK
+            }, {
+                classReference: CaseTitle,
+                serialized: Categories.CASE_TITLE
+            }, {
+                classReference: CaseVisualId,
+                serialized: Categories.CASE_VISUAL_ID
+            }, {
+                classReference: CaseStringId,
+                serialized: Categories.CASE_STRING_ID
+            },
+            // Task
+            {
+                classReference: TaskAssignee,
+                serialized: Categories.TASK_ASSIGNEE
+            }, {
+                classReference: TaskProcess,
+                serialized: Categories.TASK_PROCESS
+            }, {
+                classReference: TaskRole,
+                serialized: Categories.TASK_ROLE
+            }, {
+                classReference: TaskTask,
+                serialized: Categories.TASK_TASK
+            }
+        ].forEach(function (pair) { return _this.registerPair(pair); });
+    };
+    /**
+     * Resolves the categories from the {@link Categories} enum into their corresponding classes.
+     * Passes all unresolved values into the [toCustomClass()]{@link CategoryResolverService#toCustomClass} method - this
+     * behavior is deprecated in 5.6.0.
+     * @param category a serialized representation of the {@link Category} class
+     */
+    CategoryResolverService.prototype.toClass = function (category) {
+        var _a;
+        return (_a = this._stringToClassTable[category]) !== null && _a !== void 0 ? _a : this.toCustomClass(category);
+    };
+    /**
+     * Resolves a {@link Category} class or a class instance into its corresponding serialisation.
+     * @param category a class reference or a class instance
+     * @returns the associated serialisation or `undefined` if no serialisation was associated
+     */
+    CategoryResolverService.prototype.serialize = function (category) {
+        if (category instanceof Category) {
+            // @ts-ignore
+            return this._classToStringTable[category.constructor];
+        }
+        // @ts-ignore
+        return this._classToStringTable[category];
+    };
+    /**
+     * Should resolve any custom categories into their corresponding class objects.
+     *
+     * If you implement any custom {@link Category} classes, you should override this method to resolve them after serialization.
+     *
+     * @param category the serialized string provided by your [Category.serialize()]{@link Category#serializeClass} implementation
+     * @returns `undefined`
+     *
+     * @deprecated in 5.6.0 - use the [registerPair]{@link CategoryResolverService#registerPair} method to register
+     * both transformations instead.
+     */
+    CategoryResolverService.prototype.toCustomClass = function (category) {
+        return undefined;
+    };
+    /**
+     * Adds the given mapping to the look-up tables
+     *
+     * @returns a new pair where: The class is the previous string association. The string is the previous class association.
+     * One or both of the values in the returned pair may be `undefined`.
+     */
+    CategoryResolverService.prototype.registerPair = function (pair) {
+        var associatedClass = this._stringToClassTable[pair.serialized];
+        this._stringToClassTable[pair.serialized] = pair.classReference;
+        // non-string/number object keys are supported by javascript but are lacking typescript support
+        // @ts-ignore
+        var associatedString = this._classToStringTable[pair.classReference];
+        // @ts-ignore
+        this._classToStringTable[pair.classReference] = pair.serialized;
+        return {
+            classReference: associatedClass,
+            serialized: associatedString
+        };
+    };
+    CategoryResolverService.ɵprov = i0.ɵɵdefineInjectable({ factory: function CategoryResolverService_Factory() { return new CategoryResolverService(); }, token: CategoryResolverService, providedIn: "root" });
+    CategoryResolverService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    CategoryResolverService.ctorParameters = function () { return []; };
+    return CategoryResolverService;
+}());
+export { CategoryResolverService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"category-resolver.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/search/category-factory/category-resolver.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, Type} from '@angular/core';\nimport {Categories} from '../models/category/categories';\nimport {Category} from '../models/category/category';\nimport {CaseAuthor} from '../models/category/case/case-author';\nimport {CaseCreationDate} from '../models/category/case/case-creation-date';\nimport {CaseDataset} from '../models/category/case/case-dataset';\nimport {CaseProcess} from '../models/category/case/case-process';\nimport {CaseRole} from '../models/category/case/case-role';\nimport {CaseSimpleDataset} from '../models/category/case/case-simple-dataset';\nimport {CaseTask} from '../models/category/case/case-task';\nimport {CaseTitle} from '../models/category/case/case-title';\nimport {CaseVisualId} from '../models/category/case/case-visual-id';\nimport {CaseStringId} from '../models/category/case/case-string-id';\nimport {TaskAssignee} from '../models/category/task/task-assignee';\nimport {TaskProcess} from '../models/category/task/task-process';\nimport {TaskRole} from '../models/category/task/task-role';\nimport {TaskTask} from '../models/category/task/task-task';\nimport {CaseCreationDateTime} from '../models/category/case/case-creation-date-time';\nimport {CategorySerialisationPair} from './category-serialisation-pair';\n\n/**\n * A service that resolves {@link Categories} (or custom string) into a concrete {@link Category} implementation class and vice versa.\n */\n@Injectable({\n    providedIn: 'root'\n})\nexport class CategoryResolverService {\n\n    private readonly _classToStringTable;\n    private readonly _stringToClassTable;\n\n    constructor() {\n        this._classToStringTable = {};\n        this._stringToClassTable = {};\n        this.registerDefaultPairings();\n    }\n\n    /**\n     * Registers the default class - serialisation pairings for all the {@link Category} classes provided by this library.\n     */\n    private registerDefaultPairings(): void {\n        [\n            // Case\n            {\n                classReference: CaseAuthor,\n                serialized: Categories.CASE_AUTHOR\n            }, {\n                classReference: CaseCreationDate,\n                serialized: Categories.CASE_CREATION_DATE\n            }, {\n                classReference: CaseCreationDateTime,\n                serialized: Categories.CASE_CREATION_DATE_TIME\n            }, {\n                classReference: CaseDataset,\n                serialized: Categories.CASE_DATASET\n            }, {\n                classReference: CaseProcess,\n                serialized: Categories.CASE_PROCESS\n            }, {\n                classReference: CaseRole,\n                serialized: Categories.CASE_ROLE\n            }, {\n                classReference: CaseSimpleDataset,\n                serialized: Categories.CASE_SIMPLE_DATASET\n            }, {\n                classReference: CaseTask,\n                serialized: Categories.CASE_TASK\n            }, {\n                classReference: CaseTitle,\n                serialized: Categories.CASE_TITLE\n            }, {\n                classReference: CaseVisualId,\n                serialized: Categories.CASE_VISUAL_ID\n            }, {\n                classReference: CaseStringId,\n                serialized: Categories.CASE_STRING_ID\n            },\n            // Task\n            {\n                classReference: TaskAssignee,\n                serialized: Categories.TASK_ASSIGNEE\n            }, {\n                classReference: TaskProcess,\n                serialized: Categories.TASK_PROCESS\n            }, {\n                classReference: TaskRole,\n                serialized: Categories.TASK_ROLE\n            }, {\n                classReference: TaskTask,\n                serialized: Categories.TASK_TASK\n            }\n        ].forEach(pair => this.registerPair(pair));\n    }\n\n    /**\n     * Resolves the categories from the {@link Categories} enum into their corresponding classes.\n     * Passes all unresolved values into the [toCustomClass()]{@link CategoryResolverService#toCustomClass} method - this\n     * behavior is deprecated in 5.6.0.\n     * @param category a serialized representation of the {@link Category} class\n     */\n    public toClass(category: Categories | string): Type<Category<any>> | undefined {\n        return this._stringToClassTable[category] ?? this.toCustomClass(category);\n    }\n\n    /**\n     * Resolves a {@link Category} class or a class instance into its corresponding serialisation.\n     * @param category a class reference or a class instance\n     * @returns the associated serialisation or `undefined` if no serialisation was associated\n     */\n    public serialize(category: Type<Category<any>> | Category<any>): Categories | string | undefined {\n        if (category instanceof Category) {\n            // @ts-ignore\n            return this._classToStringTable[category.constructor];\n        }\n        // @ts-ignore\n        return this._classToStringTable[category];\n    }\n\n    /**\n     * Should resolve any custom categories into their corresponding class objects.\n     *\n     * If you implement any custom {@link Category} classes, you should override this method to resolve them after serialization.\n     *\n     * @param category the serialized string provided by your [Category.serialize()]{@link Category#serializeClass} implementation\n     * @returns `undefined`\n     *\n     * @deprecated in 5.6.0 - use the [registerPair]{@link CategoryResolverService#registerPair} method to register\n     * both transformations instead.\n     */\n    protected toCustomClass(category: string): Type<Category<any>> | undefined {\n        return undefined;\n    }\n\n    /**\n     * Adds the given mapping to the look-up tables\n     *\n     * @returns a new pair where: The class is the previous string association. The string is the previous class association.\n     * One or both of the values in the returned pair may be `undefined`.\n     */\n    protected registerPair(pair: CategorySerialisationPair): CategorySerialisationPair {\n        const associatedClass = this._stringToClassTable[pair.serialized];\n        this._stringToClassTable[pair.serialized] = pair.classReference;\n\n        // non-string/number object keys are supported by javascript but are lacking typescript support\n        // @ts-ignore\n        const associatedString = this._classToStringTable[pair.classReference];\n        // @ts-ignore\n        this._classToStringTable[pair.classReference] = pair.serialized;\n\n        return {\n            classReference: associatedClass,\n            serialized: associatedString\n        };\n    }\n}\n"]}

package/esm5/lib/search/category-factory/category-serialisation-pair.js

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

package/esm5/lib/search/category-factory/default-categories-factories.js

@@ -0,0 +1,67 @@
+import { CaseTitle } from '../models/category/case/case-title';
+import { CaseVisualId } from '../models/category/case/case-visual-id';
+import { CaseStringId } from '../models/category/case/case-string-id';
+import { CaseAuthor } from '../models/category/case/case-author';
+import { CaseProcess } from '../models/category/case/case-process';
+import { CaseTask } from '../models/category/case/case-task';
+import { CaseCreationDate } from '../models/category/case/case-creation-date';
+import { CaseDataset } from '../models/category/case/case-dataset';
+import { TaskAssignee } from '../models/category/task/task-assignee';
+import { TaskProcess } from '../models/category/task/task-process';
+import { TaskRole } from '../models/category/task/task-role';
+import { TaskTask } from '../models/category/task/task-task';
+import { CaseCreationDateTime } from '../models/category/case/case-creation-date-time';
+/**
+ * Creates the default case search categories.
+ *
+ * Depends on {@link CategoryFactory}.
+ *
+ * The created categories cannot be used to generate any predicates, as their inner state is preemptively destroyed to avoid memory leaks
+ * caused by uncompleted Subjects. They should only be used to create new Category instances with the help of the
+ * [duplicate()]{@link Category#duplicate} method.
+ *
+ * @returns an Array containing the default case search categories: {@link CaseDataset}, {@link CaseTitle}, {@link CaseCreationDate},
+ * {@link CaseProcess}, {@link CaseTask}, {@link CaseAuthor}, {@link CaseVisualId} and {@link CaseStringId}
+ *
+ * @deprecated in 5.6.0 - Use the {@link NAE_DEFAULT_CASE_SEARCH_CATEGORIES} injection token instead
+ */
+export function defaultCaseSearchCategoriesFactory(factory) {
+    var cats = [
+        factory.get(CaseDataset),
+        factory.get(CaseTitle),
+        factory.get(CaseCreationDate),
+        factory.get(CaseCreationDateTime),
+        factory.get(CaseProcess),
+        factory.get(CaseTask),
+        factory.get(CaseAuthor),
+        factory.get(CaseVisualId),
+        factory.get(CaseStringId),
+    ];
+    cats.forEach(function (cat) { return cat.destroy(); });
+    return cats;
+}
+/**
+ * Creates the default task search categories.
+ *
+ * Depends on {@link CategoryFactory}.
+ *
+ * The created categories cannot be used to generate any predicates, as their inner state is preemptively destroyed to avoid memory leaks
+ * caused by uncompleted Subjects. They should only be used to create new Category instances with the help of the
+ * [duplicate()]{@link Category#duplicate} method.
+ *
+ * @returns an Array containing the default task search categories: {@link TaskAssignee}, {@link TaskTask}, {@link TaskProcess}
+ * and {@link TaskRole}
+ *
+ * @deprecated in 5.6.0 - Use the {@link NAE_DEFAULT_TASK_SEARCH_CATEGORIES} injection token instead
+ */
+export function defaultTaskSearchCategoriesFactory(factory) {
+    var cats = [
+        factory.get(TaskAssignee),
+        factory.get(TaskTask),
+        factory.get(TaskProcess),
+        factory.get(TaskRole),
+    ];
+    cats.forEach(function (cat) { return cat.destroy(); });
+    return cats;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/search/category-factory/default-search-categories.module.js

@@ -0,0 +1,54 @@
+import { NgModule } from '@angular/core';
+import { NAE_DEFAULT_CASE_SEARCH_CATEGORIES, NAE_DEFAULT_TASK_SEARCH_CATEGORIES } from './search-categories-injection-token';
+import { CaseDataset } from '../models/category/case/case-dataset';
+import { CaseTitle } from '../models/category/case/case-title';
+import { CaseCreationDate } from '../models/category/case/case-creation-date';
+import { CaseProcess } from '../models/category/case/case-process';
+import { CaseTask } from '../models/category/case/case-task';
+import { CaseAuthor } from '../models/category/case/case-author';
+import { CaseVisualId } from '../models/category/case/case-visual-id';
+import { TaskAssignee } from '../models/category/task/task-assignee';
+import { TaskTask } from '../models/category/task/task-task';
+import { TaskProcess } from '../models/category/task/task-process';
+import { TaskRole } from '../models/category/task/task-role';
+import { CaseCreationDateTime } from '../models/category/case/case-creation-date-time';
+import { CaseStringId } from '../models/category/case/case-string-id';
+var ɵ0 = [
+    CaseDataset,
+    CaseTitle,
+    CaseCreationDate,
+    CaseCreationDateTime,
+    CaseProcess,
+    CaseTask,
+    CaseAuthor,
+    CaseVisualId,
+    CaseStringId,
+], ɵ1 = [
+    TaskAssignee,
+    TaskTask,
+    TaskProcess,
+    TaskRole,
+];
+var DefaultSearchCategoriesModule = /** @class */ (function () {
+    function DefaultSearchCategoriesModule() {
+    }
+    DefaultSearchCategoriesModule.decorators = [
+        { type: NgModule, args: [{
+                    declarations: [],
+                    imports: [],
+                    providers: [
+                        {
+                            provide: NAE_DEFAULT_CASE_SEARCH_CATEGORIES,
+                            useValue: ɵ0
+                        }, {
+                            provide: NAE_DEFAULT_TASK_SEARCH_CATEGORIES,
+                            useValue: ɵ1
+                        }
+                    ]
+                },] }
+    ];
+    return DefaultSearchCategoriesModule;
+}());
+export { DefaultSearchCategoriesModule };
+export { ɵ0, ɵ1 };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/search/category-factory/optional-dependencies.js

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

package/esm5/lib/search/category-factory/search-categories-injection-token.js

@@ -0,0 +1,24 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * Contains the search categories that can be used with the [SearchComponent]{@link AbstractSearchComponent} that injects them.
+ *
+ * The search component is universal and the categories provided with this token are what determines what query objects
+ * are going to be constructed.
+ *
+ * The token content with the type `Array<Category<any>>` has been deprecated in 5.6.0 in favor of the new type `Array<Type<Category<any>>>`
+ * but remains for backwards-compatibility.
+ */
+export var NAE_SEARCH_CATEGORIES = new InjectionToken('NaeSearchCategories');
+/**
+ * Contains a list of classes that represent the default case search categories.
+ *
+ * The default search categories can be overridden by providing this injection token with a new set of categories in the `AppComponent`.
+ */
+export var NAE_DEFAULT_CASE_SEARCH_CATEGORIES = new InjectionToken('NaeDefaultCaseSearchCategories');
+/**
+ * Contains a list of classes that represent the default task search categories.
+ *
+ * The default search categories can be overridden by providing this injection token with a new set of categories in the `AppComponent`.
+ */
+export var NAE_DEFAULT_TASK_SEARCH_CATEGORIES = new InjectionToken('NaeDefaultTaskSearchCategories');
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/search/fulltext-search-component/abstract-fulltext-search.component.js

@@ -0,0 +1,20 @@
+import { FormControl } from '@angular/forms';
+import { debounceTime, filter, map } from 'rxjs/operators';
+var AbstractFulltextSearchComponent = /** @class */ (function () {
+    function AbstractFulltextSearchComponent(_searchService) {
+        var _this = this;
+        this._searchService = _searchService;
+        this.fullTextFormControl = new FormControl();
+        this.fullTextFormControl.valueChanges.pipe(debounceTime(600), filter(function (newValue) { return typeof newValue === 'string'; }), map(function (newValue) { return newValue.trim(); })).subscribe(function (fulltext) {
+            if (fulltext.length === 0) {
+                _this._searchService.clearFullTextFilter();
+            }
+            else {
+                _this._searchService.setFullTextFilter(fulltext);
+            }
+        });
+    }
+    return AbstractFulltextSearchComponent;
+}());
+export { AbstractFulltextSearchComponent };
+//# sourceMappingURL=data:application/json;base64,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