@netgrif/components-core 6.0.1

package/esm2015/lib/routing/redirect-service/redirect.service.js

@@ -0,0 +1,103 @@
+import { Injectable } from '@angular/core';
+import { ActivatedRoute, ActivatedRouteSnapshot, Params, Router, UrlSegment } from '@angular/router';
+import { LoggerService } from '../../logger/services/logger.service';
+import { ConfigurationService } from '../../configuration/configuration.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../../logger/services/logger.service";
+import * as i3 from "../../configuration/configuration.service";
+export class RedirectService {
+    constructor(_router, _log, _config, _route) {
+        this._router = _router;
+        this._log = _log;
+        this._config = _config;
+        this._route = _route;
+    }
+    get lastUrl() {
+        return this._lastIntendedRoute.url;
+    }
+    set intendedRoute(route) {
+        this._lastIntendedRoute = route;
+    }
+    get queryParams() {
+        return this.lastQueryParams;
+    }
+    redirect(path) {
+        if (!!path) {
+            this._router.navigateByUrl(path).then(log => {
+                this._log.info('Router navigate to path ' + path + ' : ' + log);
+            });
+        }
+        else if (this._lastIntendedRoute && this._lastIntendedRoute._routerState
+            && this._lastIntendedRoute._routerState.url) {
+            this._router.navigateByUrl(this._lastIntendedRoute._routerState.url).then(log => {
+                this._log.info('Router navigate to last path : ' + log);
+            });
+        }
+    }
+    redirectFromUrl() {
+        this.lastQueryParams = this._route.snapshot.queryParams;
+        this._router.navigate([this.parseRedirectPath(this._router.url)], { queryParams: this.lastQueryParams });
+    }
+    resolveLoginPath() {
+        const config = this._config.get();
+        if (!!config.services && !!config.services.auth && !!config.services.auth.loginRedirect) {
+            return config.services.auth.loginRedirect;
+        }
+        const route = this.resolveLoginPathFromViewConfiguration(this._config.get().views, RedirectService.LOGIN_COMPONENT);
+        if (route !== null) {
+            return route;
+        }
+        throw new Error('No login view found in application. Authentication guard can\'t redirect. Add a view with'
+            + ' layout.name="login" to your application, or set the desired redirect path in \'services.auth.loginRedirect\'');
+    }
+    resolveLoginPathFromViewConfiguration(views, searchedLayout) {
+        if (!views || Object.keys(views).length === 0) {
+            return null;
+        }
+        const route = Object.keys(views).find(routeKey => {
+            const layout = views[routeKey].layout;
+            return !!layout && layout.name === searchedLayout;
+        });
+        if (route) {
+            return (views[route].routing && views[route].routing.path) ? views[route].routing.path : null;
+        }
+        for (const routeKey of Object.keys(views)) {
+            const resolved = this.resolveLoginPathFromViewConfiguration(views[routeKey].children, searchedLayout);
+            if (resolved && views[routeKey].routing && views[routeKey].routing.path) {
+                return views[routeKey].routing.path + '/' + resolved;
+            }
+        }
+        return null;
+    }
+    parseRedirectPath(url) {
+        let path;
+        if (url.includes('?')) {
+            path = url.slice(0, url.indexOf('?'));
+        }
+        else {
+            path = url;
+        }
+        return path.replace('/redirect', '');
+    }
+}
+RedirectService.LOGIN_COMPONENT = 'login';
+RedirectService.ctorParameters = () => [
+    { type: Router },
+    { type: LoggerService },
+    { type: ConfigurationService },
+    { type: ActivatedRoute }
+];
+RedirectService.ɵprov = i0.ɵɵdefineInjectable({ factory: function RedirectService_Factory() { return new RedirectService(i0.ɵɵinject(i1.Router), i0.ɵɵinject(i2.LoggerService), i0.ɵɵinject(i3.ConfigurationService), i0.ɵɵinject(i1.ActivatedRoute)); }, token: RedirectService, providedIn: "root" });
+RedirectService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+RedirectService.ctorParameters = () => [
+    { type: Router },
+    { type: LoggerService },
+    { type: ConfigurationService },
+    { type: ActivatedRoute }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"redirect.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/routing/redirect-service/redirect.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from '@angular/core';\nimport {ActivatedRoute, ActivatedRouteSnapshot, Params, Router, UrlSegment} from '@angular/router';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {Views} from '../../../commons/schema';\nimport {ConfigurationService} from '../../configuration/configuration.service';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class RedirectService {\n\n    public static readonly LOGIN_COMPONENT = 'login';\n    protected _lastIntendedRoute: ActivatedRouteSnapshot;\n    private lastQueryParams: Params;\n\n    constructor(protected _router: Router,\n                protected _log: LoggerService,\n                protected _config: ConfigurationService,\n                protected _route: ActivatedRoute) {\n    }\n\n    get lastUrl(): Array<UrlSegment> {\n        return this._lastIntendedRoute.url;\n    }\n\n    set intendedRoute(route: ActivatedRouteSnapshot) {\n        this._lastIntendedRoute = route;\n    }\n\n    get queryParams(): Params {\n        return this.lastQueryParams;\n    }\n\n    public redirect(path?: string) {\n        if (!!path) {\n            this._router.navigateByUrl(path).then(log => {\n                this._log.info('Router navigate to path ' + path + ' : ' + log);\n            });\n        } else if (this._lastIntendedRoute && (this._lastIntendedRoute as any)._routerState\n            && (this._lastIntendedRoute as any)._routerState.url) {\n            this._router.navigateByUrl((this._lastIntendedRoute as any)._routerState.url).then(log => {\n                this._log.info('Router navigate to last path : ' + log);\n            });\n        }\n    }\n\n    public redirectFromUrl() {\n        this.lastQueryParams = this._route.snapshot.queryParams;\n        this._router.navigate([this.parseRedirectPath(this._router.url)], { queryParams: this.lastQueryParams });\n    }\n\n    public resolveLoginPath(): string {\n        const config = this._config.get();\n        if (!!config.services && !!config.services.auth && !!config.services.auth.loginRedirect) {\n            return config.services.auth.loginRedirect;\n        }\n        const route = this.resolveLoginPathFromViewConfiguration(\n            this._config.get().views, RedirectService.LOGIN_COMPONENT);\n        if (route !== null) {\n            return route;\n        }\n        throw new Error('No login view found in application. Authentication guard can\\'t redirect. Add a view with'\n            + ' layout.name=\"login\" to your application, or set the desired redirect path in \\'services.auth.loginRedirect\\'');\n    }\n\n    protected resolveLoginPathFromViewConfiguration(views: Views, searchedLayout: string): string {\n        if (!views || Object.keys(views).length === 0) {\n            return null;\n        }\n        const route = Object.keys(views).find(routeKey => {\n            const layout = views[routeKey].layout;\n            return !!layout && layout.name === searchedLayout;\n        });\n        if (route) {\n            return (views[route].routing && views[route].routing.path) ? views[route].routing.path : null;\n        }\n        for (const routeKey of Object.keys(views)) {\n            const resolved = this.resolveLoginPathFromViewConfiguration(views[routeKey].children, searchedLayout);\n            if (resolved && views[routeKey].routing && views[routeKey].routing.path) {\n                return views[routeKey].routing.path + '/' + resolved;\n            }\n        }\n        return null;\n    }\n\n    public parseRedirectPath(url: string): string {\n        let path: string;\n        if (url.includes('?')) {\n            path = url.slice(0, url.indexOf('?'));\n        } else {\n            path = url;\n        }\n        return path.replace('/redirect', '');\n    }\n}\n"]}

package/esm2015/lib/routing/routing-builder/routing-builder.service.js

@@ -0,0 +1,190 @@
+import { Inject, Injectable, Optional, Type } from '@angular/core';
+import { ConfigurationService } from '../../configuration/configuration.service';
+import { ViewService } from '../view-service/view.service';
+import { Route, Router } from '@angular/router';
+import { AuthenticationGuardService } from '../../authentication/services/guard/authentication-guard.service';
+import { ViewClassInfo } from '../../../commons/view-class-info';
+import { classify } from '../../../commons/angular-cli-devkit-core-strings';
+import { LoggerService } from '../../logger/services/logger.service';
+import { AuthorityGuardService } from '../../authorization/authority/authority-guard.service';
+import { RoleGuardService } from '../../authorization/role/role-guard.service';
+import { GroupGuardService } from '../../authorization/group/group-guard.service';
+import { GroupNavigationConstants } from '../../navigation/model/group-navigation-constants';
+import { NAE_GROUP_NAVIGATION_COMPONENT_RESOLVER_COMPONENT } from '../../navigation/model/group-navigation-component-resolver-component-injection-token';
+import { DynamicNavigationRouteProviderService } from '../dynamic-navigation-route-provider/dynamic-navigation-route-provider.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../../configuration/configuration.service";
+import * as i3 from "../view-service/view.service";
+import * as i4 from "../../logger/services/logger.service";
+import * as i5 from "../dynamic-navigation-route-provider/dynamic-navigation-route-provider.service";
+import * as i6 from "../../navigation/model/group-navigation-component-resolver-component-injection-token";
+/**
+ * Uses the information from nae.json to construct the application's routing
+ */
+export class RoutingBuilderService {
+    constructor(router, _configService, _viewService, _logger, _dynamicNavigationRouteService, _groupNavigationComponentResolverComponent) {
+        this._configService = _configService;
+        this._viewService = _viewService;
+        this._logger = _logger;
+        this._dynamicNavigationRouteService = _dynamicNavigationRouteService;
+        this._groupNavigationComponentResolverComponent = _groupNavigationComponentResolverComponent;
+        this._groupNavigationRouteGenerated = false;
+        router.config.splice(0, router.config.length);
+        for (const [pathSegment, view] of Object.entries(_configService.get().views)) {
+            const route = this.constructRouteObject(view, pathSegment);
+            if (route !== undefined) {
+                router.config.push(route);
+            }
+        }
+        router.config.push(...this.defaultRoutesRedirects());
+    }
+    constructRouteObject(view, configPath, ancestors = []) {
+        var _a, _b;
+        const component = this.resolveComponentClass(view, configPath);
+        if (component === undefined) {
+            return undefined;
+        }
+        if (!view.routing) {
+            this._logger.warn(`nae.json configuration is invalid. View at path '${configPath}'` +
+                ` must define a 'routing' attribute. Skipping this view for routing generation.`);
+            return undefined;
+        }
+        const route = {
+            path: view.routing.path,
+            component
+        };
+        if (((_a = view === null || view === void 0 ? void 0 : view.layout) === null || _a === void 0 ? void 0 : _a.name) === GroupNavigationConstants.GROUP_NAVIGATION_OUTLET) {
+            if (this._groupNavigationRouteGenerated) {
+                this._logger.warn(`Multiple groupNavigationOutlets are present in nae.json. Duplicate entry found at path ${configPath}`);
+            }
+            else {
+                this._logger.debug(`GroupNavigationOutlet found in nae.json at path '${configPath}'`);
+            }
+            const pathNoParams = route.path;
+            route.path = `${pathNoParams}/:${GroupNavigationConstants.GROUP_NAVIGATION_ROUTER_PARAM}`;
+            route.canActivate = [AuthenticationGuardService];
+            const parentPathSegments = ancestors.map(a => a.path);
+            parentPathSegments.push(pathNoParams);
+            this._dynamicNavigationRouteService.route = parentPathSegments.join('/');
+            this._groupNavigationRouteGenerated = true;
+            return route;
+        }
+        if (view.routing.match !== undefined && view.routing.match) {
+            route['pathMatch'] = 'full';
+        }
+        route['canActivate'] = [];
+        if (view.access === 'private'
+            || view.access.hasOwnProperty('role')
+            || view.access.hasOwnProperty('group')
+            || view.access.hasOwnProperty('authority')) {
+            route['canActivate'].push(AuthenticationGuardService);
+        }
+        if (view.access.hasOwnProperty('role')) {
+            route['canActivate'].push(RoleGuardService);
+        }
+        if (view.access.hasOwnProperty('authority')) {
+            route['canActivate'].push(AuthorityGuardService);
+        }
+        if (view.access.hasOwnProperty('group')) {
+            route['canActivate'].push(GroupGuardService);
+        }
+        if (!!view.children) {
+            route['children'] = [];
+            Object.entries(view.children).forEach(([configPathSegment, childView]) => {
+                // TODO check if routes are constructed correctly regarding empty route segments
+                const childRoute = this.constructRouteObject(childView, `${configPath}/${configPathSegment}`, [...ancestors, route]);
+                if (childRoute !== undefined) {
+                    route['children'].push(childRoute);
+                }
+            });
+        }
+        if (((_b = view === null || view === void 0 ? void 0 : view.layout) === null || _b === void 0 ? void 0 : _b.name) === 'tabView') {
+            if (!view.children) {
+                route['children'] = [];
+            }
+            route['children'].push({
+                path: '**',
+                component
+            });
+        }
+        return route;
+    }
+    resolveComponentClass(view, configPath) {
+        let result;
+        if (!!view.component) {
+            result = this._viewService.resolveNameToClass(view.component.class);
+        }
+        else if (!!view.layout) {
+            result = this.resolveComponentClassFromLayout(view, configPath);
+        }
+        else {
+            this._logger.warn(`nae.json configuration is invalid. View at path '${configPath}'` +
+                ` must define either a 'layout' or a 'component' attribute. Skipping this view for routing generation.`);
+            return undefined;
+        }
+        if (result === undefined) {
+            this._logger.warn(`Some views from nae.json configuration have not been created in the project.` +
+                ` Run create-view schematic to rectify this. Skipping this view for routing generation.`);
+            return undefined;
+        }
+        return result;
+    }
+    resolveComponentClassFromLayout(view, configPath) {
+        if (view.layout.name === GroupNavigationConstants.GROUP_NAVIGATION_OUTLET) {
+            return this._groupNavigationComponentResolverComponent;
+        }
+        let className;
+        if (!!view.layout.componentName) {
+            className = `${classify(view.layout.componentName)}Component`;
+        }
+        else {
+            const classInfo = new ViewClassInfo(configPath, view.layout.name, view.layout.componentName);
+            className = classInfo.className;
+        }
+        return this._viewService.resolveNameToClass(className);
+    }
+    defaultRoutesRedirects() {
+        const result = [];
+        const servicesConfig = this._configService.getServicesConfiguration();
+        if (!!servicesConfig && !!servicesConfig.routing) {
+            if (!!servicesConfig.routing.defaultRedirect) {
+                result.push({
+                    path: '',
+                    redirectTo: servicesConfig.routing.defaultRedirect,
+                    pathMatch: 'full'
+                });
+            }
+            if (!!servicesConfig.routing.wildcardRedirect) {
+                result.push({
+                    path: '**',
+                    redirectTo: servicesConfig.routing.wildcardRedirect
+                });
+            }
+        }
+        return result;
+    }
+}
+RoutingBuilderService.ctorParameters = () => [
+    { type: Router },
+    { type: ConfigurationService },
+    { type: ViewService },
+    { type: LoggerService },
+    { type: DynamicNavigationRouteProviderService },
+    { type: Type, decorators: [{ type: Optional }, { type: Inject, args: [NAE_GROUP_NAVIGATION_COMPONENT_RESOLVER_COMPONENT,] }] }
+];
+RoutingBuilderService.ɵprov = i0.ɵɵdefineInjectable({ factory: function RoutingBuilderService_Factory() { return new RoutingBuilderService(i0.ɵɵinject(i1.Router), i0.ɵɵinject(i2.ConfigurationService), i0.ɵɵinject(i3.ViewService), i0.ɵɵinject(i4.LoggerService), i0.ɵɵinject(i5.DynamicNavigationRouteProviderService), i0.ɵɵinject(i6.NAE_GROUP_NAVIGATION_COMPONENT_RESOLVER_COMPONENT, 8)); }, token: RoutingBuilderService, providedIn: "root" });
+RoutingBuilderService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+RoutingBuilderService.ctorParameters = () => [
+    { type: Router },
+    { type: ConfigurationService },
+    { type: ViewService },
+    { type: LoggerService },
+    { type: DynamicNavigationRouteProviderService },
+    { type: Type, decorators: [{ type: Optional }, { type: Inject, args: [NAE_GROUP_NAVIGATION_COMPONENT_RESOLVER_COMPONENT,] }] }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"routing-builder.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/routing/routing-builder/routing-builder.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable, Optional, Type} from '@angular/core';\nimport {ConfigurationService} from '../../configuration/configuration.service';\nimport {ViewService} from '../view-service/view.service';\nimport {Route, Router} from '@angular/router';\nimport {View} from '../../../commons/schema';\nimport {AuthenticationGuardService} from '../../authentication/services/guard/authentication-guard.service';\nimport {ViewClassInfo} from '../../../commons/view-class-info';\nimport {classify} from '../../../commons/angular-cli-devkit-core-strings';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {AuthorityGuardService} from '../../authorization/authority/authority-guard.service';\nimport {RoleGuardService} from '../../authorization/role/role-guard.service';\nimport {GroupGuardService} from '../../authorization/group/group-guard.service';\nimport {GroupNavigationConstants} from '../../navigation/model/group-navigation-constants';\nimport {\n    NAE_GROUP_NAVIGATION_COMPONENT_RESOLVER_COMPONENT\n} from '../../navigation/model/group-navigation-component-resolver-component-injection-token';\nimport {\n    AbstractGroupNavigationComponentResolverComponent\n} from '../../navigation/group-navigation-component-resolver/abstract-group-navigation-component-resolver.component';\nimport {DynamicNavigationRouteProviderService} from '../dynamic-navigation-route-provider/dynamic-navigation-route-provider.service';\n\n\n/**\n * Uses the information from nae.json to construct the application's routing\n */\n@Injectable({\n    providedIn: 'root'\n})\nexport class RoutingBuilderService {\n\n    private _groupNavigationRouteGenerated = false;\n\n    constructor(router: Router,\n                private _configService: ConfigurationService,\n                private _viewService: ViewService,\n                private _logger: LoggerService,\n                private _dynamicNavigationRouteService: DynamicNavigationRouteProviderService,\n                @Optional() @Inject(NAE_GROUP_NAVIGATION_COMPONENT_RESOLVER_COMPONENT)\n                private _groupNavigationComponentResolverComponent: Type<AbstractGroupNavigationComponentResolverComponent>) {\n        router.config.splice(0, router.config.length);\n        for (const [pathSegment, view] of Object.entries(_configService.get().views)) {\n            const route = this.constructRouteObject(view, pathSegment);\n            if (route !== undefined) {\n                router.config.push(route);\n            }\n        }\n        router.config.push(...this.defaultRoutesRedirects());\n    }\n\n    private constructRouteObject(view: View, configPath: string, ancestors: Array<Route> = []): Route | undefined {\n        const component = this.resolveComponentClass(view, configPath);\n        if (component === undefined) {\n            return undefined;\n        }\n        if (!view.routing) {\n            this._logger.warn(`nae.json configuration is invalid. View at path '${configPath}'` +\n                ` must define a 'routing' attribute. Skipping this view for routing generation.`);\n            return undefined;\n        }\n\n        const route: Route = {\n            path: view.routing.path,\n            component\n        };\n\n        if (view?.layout?.name === GroupNavigationConstants.GROUP_NAVIGATION_OUTLET) {\n            if (this._groupNavigationRouteGenerated) {\n                this._logger.warn(`Multiple groupNavigationOutlets are present in nae.json. Duplicate entry found at path ${configPath}`);\n            } else {\n                this._logger.debug(`GroupNavigationOutlet found in nae.json at path '${configPath}'`);\n            }\n\n            const pathNoParams = route.path;\n            route.path = `${pathNoParams}/:${GroupNavigationConstants.GROUP_NAVIGATION_ROUTER_PARAM}`;\n            route.canActivate = [AuthenticationGuardService];\n            const parentPathSegments = ancestors.map(a => a.path);\n            parentPathSegments.push(pathNoParams);\n            this._dynamicNavigationRouteService.route = parentPathSegments.join('/');\n\n            this._groupNavigationRouteGenerated = true;\n            return route;\n        }\n\n        if (view.routing.match !== undefined && view.routing.match) {\n            route['pathMatch'] = 'full';\n        }\n        route['canActivate'] = [];\n        if (view.access === 'private'\n            || view.access.hasOwnProperty('role')\n            || view.access.hasOwnProperty('group')\n            || view.access.hasOwnProperty('authority')) {\n            route['canActivate'].push(AuthenticationGuardService);\n        }\n        if (view.access.hasOwnProperty('role')) {\n            route['canActivate'].push(RoleGuardService);\n        }\n        if (view.access.hasOwnProperty('authority')) {\n            route['canActivate'].push(AuthorityGuardService);\n        }\n        if (view.access.hasOwnProperty('group')) {\n            route['canActivate'].push(GroupGuardService);\n        }\n        if (!!view.children) {\n            route['children'] = [];\n            Object.entries(view.children).forEach(([configPathSegment, childView]) => {\n                // TODO check if routes are constructed correctly regarding empty route segments\n                const childRoute = this.constructRouteObject(childView, `${configPath}/${configPathSegment}`, [...ancestors, route]);\n                if (childRoute !== undefined) {\n                    route['children'].push(childRoute);\n                }\n            });\n        }\n        if (view?.layout?.name === 'tabView') {\n            if (!view.children) {\n                route['children'] = [];\n            }\n            route['children'].push({\n                path: '**',\n                component\n            });\n        }\n\n        return route;\n    }\n\n    private resolveComponentClass(view: View, configPath: string): Type<any> | undefined {\n        let result;\n        if (!!view.component) {\n            result = this._viewService.resolveNameToClass(view.component.class);\n        } else if (!!view.layout) {\n            result = this.resolveComponentClassFromLayout(view, configPath);\n        } else {\n            this._logger.warn(`nae.json configuration is invalid. View at path '${configPath}'` +\n                ` must define either a 'layout' or a 'component' attribute. Skipping this view for routing generation.`);\n            return undefined;\n        }\n        if (result === undefined) {\n            this._logger.warn(`Some views from nae.json configuration have not been created in the project.` +\n                ` Run create-view schematic to rectify this. Skipping this view for routing generation.`);\n            return undefined;\n        }\n        return result;\n    }\n\n    private resolveComponentClassFromLayout(view: View, configPath: string): Type<any> | undefined {\n        if (view.layout.name === GroupNavigationConstants.GROUP_NAVIGATION_OUTLET) {\n            return this._groupNavigationComponentResolverComponent;\n        }\n\n        let className;\n        if (!!view.layout.componentName) {\n            className = `${classify(view.layout.componentName)}Component`;\n        } else {\n            const classInfo = new ViewClassInfo(configPath, view.layout.name, view.layout.componentName);\n            className = classInfo.className;\n        }\n        return this._viewService.resolveNameToClass(className);\n    }\n\n    private defaultRoutesRedirects(): Array<Route> {\n        const result = [];\n        const servicesConfig = this._configService.getServicesConfiguration();\n        if (!!servicesConfig && !!servicesConfig.routing) {\n            if (!!servicesConfig.routing.defaultRedirect) {\n                result.push({\n                    path: '',\n                    redirectTo: servicesConfig.routing.defaultRedirect,\n                    pathMatch: 'full'\n                });\n            }\n            if (!!servicesConfig.routing.wildcardRedirect) {\n                result.push({\n                    path: '**',\n                    redirectTo: servicesConfig.routing.wildcardRedirect\n                });\n            }\n        }\n        return result;\n    }\n}\n"]}

package/esm2015/lib/routing/view-service/model/view-entry.js

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

package/esm2015/lib/routing/view-service/view.service.js

@@ -0,0 +1,35 @@
+import { Type } from '@angular/core';
+/**
+ * Holds information about views in the application. Can be used to resolve view component class objects from their names.
+ */
+export class ViewService {
+    /**
+     * @param componentClasses Class objects of view components that should be dynamically routed
+     * @param configService application's ConfigurationService
+     * @param _router the application's Router
+     * @param _logger application's logging service
+     */
+    constructor(componentClasses, 
+    // TODO 29.4.2021 - remove unused class attributes
+    configService, _router, _logger) {
+        this._router = _router;
+        this._logger = _logger;
+        this._nameToClass = new Map();
+        componentClasses.forEach(component => {
+            if (component instanceof Type) {
+                this._nameToClass.set(component.name, component);
+            }
+            else {
+                this._nameToClass.set(component.id, component.class);
+            }
+        });
+    }
+    /**
+     * @param componentClassName class name of a view component
+     * @returns the Class object with the provided name or `null` if such name is not registered
+     */
+    resolveNameToClass(componentClassName) {
+        return this._nameToClass.get(componentClassName);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/search/advanced-search-component/abstract-advanced-search.component.js

@@ -0,0 +1,49 @@
+import { Subject } from 'rxjs';
+import { Input } from '@angular/core';
+import { BooleanOperator } from '../models/boolean-operator';
+export class AbstractAdvancedSearchComponent {
+    constructor(_searchService, _initializationService) {
+        this._searchService = _searchService;
+        this._initializationService = _initializationService;
+        /**
+         * Whether the contents displayed in this component can be edited by the user or not.
+         *
+         * Defaults to `true`
+         */
+        this.editable = true;
+        this.trackByPredicates = (a, b) => b.value;
+        this.removeChild$ = new Subject();
+        this.removeChild$.subscribe(id => this._removeChildAt(id));
+        if (!this._searchService.hasVisiblePredicates) {
+            this.addChildPredicate();
+        }
+    }
+    ngAfterViewInit() {
+        this._initializationService.completeInitialization();
+    }
+    ngOnDestroy() {
+        this.removeChild$.complete();
+    }
+    getPredicateMap() {
+        const map = new Map();
+        for (const [key, value] of this._searchService.rootPredicate.getPredicateMap().entries()) {
+            if (value.isVisible) {
+                map.set(key, value.getWrappedPredicate());
+            }
+        }
+        return map;
+    }
+    addChildPredicate() {
+        this._searchService.rootPredicate.addNewClausePredicate(BooleanOperator.OR);
+    }
+    _removeChildAt(id) {
+        this._searchService.rootPredicate.removePredicate(id);
+        if (this.getPredicateMap().size === 0) {
+            this.addChildPredicate();
+        }
+    }
+}
+AbstractAdvancedSearchComponent.propDecorators = {
+    editable: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3QtYWR2YW5jZWQtc2VhcmNoLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9zZWFyY2gvYWR2YW5jZWQtc2VhcmNoLWNvbXBvbmVudC9hYnN0cmFjdC1hZHZhbmNlZC1zZWFyY2guY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBLE9BQU8sRUFBQyxPQUFPLEVBQUMsTUFBTSxNQUFNLENBQUM7QUFDN0IsT0FBTyxFQUFnQixLQUFLLEVBQVksTUFBTSxlQUFlLENBQUM7QUFDOUQsT0FBTyxFQUFDLGVBQWUsRUFBQyxNQUFNLDRCQUE0QixDQUFDO0FBSzNELE1BQU0sT0FBTywrQkFBK0I7SUFXeEMsWUFBZ0MsY0FBNkIsRUFDN0Isc0JBQW9FO1FBRHBFLG1CQUFjLEdBQWQsY0FBYyxDQUFlO1FBQzdCLDJCQUFzQixHQUF0QixzQkFBc0IsQ0FBOEM7UUFWcEc7Ozs7V0FJRztRQUNNLGFBQVEsR0FBRyxJQUFJLENBQUM7UUFzQmxCLHNCQUFpQixHQUFHLENBQUMsQ0FBUyxFQUFFLENBQXNDLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUM7UUFoQnRGLElBQUksQ0FBQyxZQUFZLEdBQUcsSUFBSSxPQUFPLEVBQVUsQ0FBQztRQUMxQyxJQUFJLENBQUMsWUFBWSxDQUFDLFNBQVMsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxjQUFjLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQztRQUUzRCxJQUFJLENBQUMsSUFBSSxDQUFDLGNBQWMsQ0FBQyxvQkFBb0IsRUFBRTtZQUMzQyxJQUFJLENBQUMsaUJBQWlCLEVBQUUsQ0FBQztTQUM1QjtJQUNMLENBQUM7SUFFRCxlQUFlO1FBQ1gsSUFBSSxDQUFDLHNCQUFzQixDQUFDLHNCQUFzQixFQUFFLENBQUM7SUFDekQsQ0FBQztJQUVELFdBQVc7UUFDUCxJQUFJLENBQUMsWUFBWSxDQUFDLFFBQVEsRUFBRSxDQUFDO0lBQ2pDLENBQUM7SUFJTSxlQUFlO1FBQ2xCLE1BQU0sR0FBRyxHQUFHLElBQUksR0FBRyxFQUFpRCxDQUFDO1FBRXJFLEtBQUssTUFBTSxDQUFDLEdBQUcsRUFBRSxLQUFLLENBQUMsSUFBSSxJQUFJLENBQUMsY0FBYyxDQUFDLGFBQWEsQ0FBQyxlQUFlLEVBQUUsQ0FBQyxPQUFPLEVBQUUsRUFBRTtZQUN0RixJQUFJLEtBQUssQ0FBQyxTQUFTLEVBQUU7Z0JBQ2pCLEdBQUcsQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLEtBQUssQ0FBQyxtQkFBbUIsRUFBMkMsQ0FBQyxDQUFDO2FBQ3RGO1NBQ0o7UUFFRCxPQUFPLEdBQUcsQ0FBQztJQUNmLENBQUM7SUFFTSxpQkFBaUI7UUFDcEIsSUFBSSxDQUFDLGNBQWMsQ0FBQyxhQUFhLENBQUMscUJBQXFCLENBQUMsZUFBZSxDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQ2hGLENBQUM7SUFFUyxjQUFjLENBQUMsRUFBVTtRQUMvQixJQUFJLENBQUMsY0FBYyxDQUFDLGFBQWEsQ0FBQyxlQUFlLENBQUMsRUFBRSxDQUFDLENBQUM7UUFDdEQsSUFBSSxJQUFJLENBQUMsZUFBZSxFQUFFLENBQUMsSUFBSSxLQUFLLENBQUMsRUFBRTtZQUNuQyxJQUFJLENBQUMsaUJBQWlCLEVBQUUsQ0FBQztTQUM1QjtJQUNMLENBQUM7Ozt1QkE3Q0EsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7RWRpdGFibGVDbGF1c2VQcmVkaWNhdGVXaXRoR2VuZXJhdG9yc30gZnJvbSAnLi4vbW9kZWxzL3ByZWRpY2F0ZS9lZGl0YWJsZS1jbGF1c2UtcHJlZGljYXRlLXdpdGgtZ2VuZXJhdG9ycyc7XG5pbXBvcnQge1NlYXJjaFNlcnZpY2V9IGZyb20gJy4uL3NlYXJjaC1zZXJ2aWNlL3NlYXJjaC5zZXJ2aWNlJztcbmltcG9ydCB7S2V5VmFsdWV9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQge0VkaXRhYmxlUHJlZGljYXRlfSBmcm9tICcuLi9tb2RlbHMvcHJlZGljYXRlL2VkaXRhYmxlLXByZWRpY2F0ZSc7XG5pbXBvcnQge1N1YmplY3R9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHtBZnRlclZpZXdJbml0LCBJbnB1dCwgT25EZXN0cm95fSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7Qm9vbGVhbk9wZXJhdG9yfSBmcm9tICcuLi9tb2RlbHMvYm9vbGVhbi1vcGVyYXRvcic7XG5pbXBvcnQge1xuICAgIEFkdmFuY2VkU2VhcmNoQ29tcG9uZW50SW5pdGlhbGl6YXRpb25TZXJ2aWNlXG59IGZyb20gJy4uL2FkdmFuY2VkLXNlYXJjaC1jb21wb25lbnQtaW5pdGlhbGl6YXRpb24tc2VydmljZS9hZHZhbmNlZC1zZWFyY2gtY29tcG9uZW50LWluaXRpYWxpemF0aW9uLnNlcnZpY2UnO1xuXG5leHBvcnQgY2xhc3MgQWJzdHJhY3RBZHZhbmNlZFNlYXJjaENvbXBvbmVudCBpbXBsZW1lbnRzIEFmdGVyVmlld0luaXQsIE9uRGVzdHJveSB7XG5cbiAgICAvKipcbiAgICAgKiBXaGV0aGVyIHRoZSBjb250ZW50cyBkaXNwbGF5ZWQgaW4gdGhpcyBjb21wb25lbnQgY2FuIGJlIGVkaXRlZCBieSB0aGUgdXNlciBvciBub3QuXG4gICAgICpcbiAgICAgKiBEZWZhdWx0cyB0byBgdHJ1ZWBcbiAgICAgKi9cbiAgICBASW5wdXQoKSBlZGl0YWJsZSA9IHRydWU7XG5cbiAgICBwdWJsaWMgcmVtb3ZlQ2hpbGQkOiBTdWJqZWN0PG51bWJlcj47XG5cbiAgICBwcm90ZWN0ZWQgY29uc3RydWN0b3IocHJvdGVjdGVkIF9zZWFyY2hTZXJ2aWNlOiBTZWFyY2hTZXJ2aWNlLFxuICAgICAgICAgICAgICAgICAgICAgICAgICBwcm90ZWN0ZWQgX2luaXRpYWxpemF0aW9uU2VydmljZTogQWR2YW5jZWRTZWFyY2hDb21wb25lbnRJbml0aWFsaXphdGlvblNlcnZpY2UpIHtcbiAgICAgICAgdGhpcy5yZW1vdmVDaGlsZCQgPSBuZXcgU3ViamVjdDxudW1iZXI+KCk7XG4gICAgICAgIHRoaXMucmVtb3ZlQ2hpbGQkLnN1YnNjcmliZShpZCA9PiB0aGlzLl9yZW1vdmVDaGlsZEF0KGlkKSk7XG5cbiAgICAgICAgaWYgKCF0aGlzLl9zZWFyY2hTZXJ2aWNlLmhhc1Zpc2libGVQcmVkaWNhdGVzKSB7XG4gICAgICAgICAgICB0aGlzLmFkZENoaWxkUHJlZGljYXRlKCk7XG4gICAgICAgIH1cbiAgICB9XG5cbiAgICBuZ0FmdGVyVmlld0luaXQoKTogdm9pZCB7XG4gICAgICAgIHRoaXMuX2luaXRpYWxpemF0aW9uU2VydmljZS5jb21wbGV0ZUluaXRpYWxpemF0aW9uKCk7XG4gICAgfVxuXG4gICAgbmdPbkRlc3Ryb3koKTogdm9pZCB7XG4gICAgICAgIHRoaXMucmVtb3ZlQ2hpbGQkLmNvbXBsZXRlKCk7XG4gICAgfVxuXG4gICAgcHVibGljIHRyYWNrQnlQcmVkaWNhdGVzID0gKGE6IG51bWJlciwgYjogS2V5VmFsdWU8bnVtYmVyLCBFZGl0YWJsZVByZWRpY2F0ZT4pID0+IGIudmFsdWU7XG5cbiAgICBwdWJsaWMgZ2V0UHJlZGljYXRlTWFwKCk6IE1hcDxudW1iZXIsIEVkaXRhYmxlQ2xhdXNlUHJlZGljYXRlV2l0aEdlbmVyYXRvcnM+IHtcbiAgICAgICAgY29uc3QgbWFwID0gbmV3IE1hcDxudW1iZXIsIEVkaXRhYmxlQ2xhdXNlUHJlZGljYXRlV2l0aEdlbmVyYXRvcnM+KCk7XG5cbiAgICAgICAgZm9yIChjb25zdCBba2V5LCB2YWx1ZV0gb2YgdGhpcy5fc2VhcmNoU2VydmljZS5yb290UHJlZGljYXRlLmdldFByZWRpY2F0ZU1hcCgpLmVudHJpZXMoKSkge1xuICAgICAgICAgICAgaWYgKHZhbHVlLmlzVmlzaWJsZSkge1xuICAgICAgICAgICAgICAgIG1hcC5zZXQoa2V5LCB2YWx1ZS5nZXRXcmFwcGVkUHJlZGljYXRlKCkgYXMgRWRpdGFibGVDbGF1c2VQcmVkaWNhdGVXaXRoR2VuZXJhdG9ycyk7XG4gICAgICAgICAgICB9XG4gICAgICAgIH1cblxuICAgICAgICByZXR1cm4gbWFwO1xuICAgIH1cblxuICAgIHB1YmxpYyBhZGRDaGlsZFByZWRpY2F0ZSgpOiB2b2lkIHtcbiAgICAgICAgdGhpcy5fc2VhcmNoU2VydmljZS5yb290UHJlZGljYXRlLmFkZE5ld0NsYXVzZVByZWRpY2F0ZShCb29sZWFuT3BlcmF0b3IuT1IpO1xuICAgIH1cblxuICAgIHByb3RlY3RlZCBfcmVtb3ZlQ2hpbGRBdChpZDogbnVtYmVyKTogdm9pZCB7XG4gICAgICAgIHRoaXMuX3NlYXJjaFNlcnZpY2Uucm9vdFByZWRpY2F0ZS5yZW1vdmVQcmVkaWNhdGUoaWQpO1xuICAgICAgICBpZiAodGhpcy5nZXRQcmVkaWNhdGVNYXAoKS5zaXplID09PSAwKSB7XG4gICAgICAgICAgICB0aGlzLmFkZENoaWxkUHJlZGljYXRlKCk7XG4gICAgICAgIH1cbiAgICB9XG59XG4iXX0=

package/esm2015/lib/search/advanced-search-component-initialization-service/advanced-search-component-initialization.service.js

@@ -0,0 +1,34 @@
+import { Injectable } from '@angular/core';
+import { LoadingEmitter } from '../../utility/loading-emitter';
+/**
+ * This service is used to signal to inputs in advanced search components, whether they should autofocus, or not.
+ *
+ * The inputs should autofocus, when the user interacts with them, but should not auto focus if the first empty predicate is created on
+ * advanced search component initialization.
+ */
+export class AdvancedSearchComponentInitializationService {
+    constructor() {
+        this._initialized = new LoadingEmitter(false);
+    }
+    ngOnDestroy() {
+        this._initialized.complete();
+    }
+    /**
+     * @returns `false` until the [completeInitialization()]{@link AdvancedSearchComponentInitializationService#completeInitialization}
+     * method is called. Returns `true` afterwards.
+     */
+    get isInitialized() {
+        return this._initialized.isActive;
+    }
+    /**
+     * Changes the state to `initialized`.
+     */
+    completeInitialization() {
+        this._initialized.on();
+    }
+}
+AdvancedSearchComponentInitializationService.decorators = [
+    { type: Injectable }
+];
+AdvancedSearchComponentInitializationService.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,94 @@
+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.
+ */
+export class CategoryFactory {
+    constructor(_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
+     */
+    get(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
+     */
+    getWithDefaultOperator(categoryClass) {
+        const 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
+     */
+    getByNameWithDefaultOperator(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
+     */
+    getFromMetadata(metadata) {
+        const result$ = new ReplaySubject(1);
+        const category = this.get(this._categoryResolver.toClass(metadata.category));
+        category.loadFromMetadata(metadata).subscribe(() => {
+            result$.next(category);
+            result$.complete();
+        });
+        return result$.asObservable();
+    }
+}
+CategoryFactory.ctorParameters = () => [
+    { type: OperatorService },
+    { type: LoggerService },
+    { type: SearchIndexResolverService },
+    { type: CategoryResolverService },
+    { type: AllowedNetsService },
+    { type: UserResourceService, decorators: [{ type: Optional }] }
+];
+CategoryFactory.decorators = [
+    { type: Injectable }
+];
+CategoryFactory.ctorParameters = () => [
+    { type: OperatorService },
+    { type: LoggerService },
+    { type: SearchIndexResolverService },
+    { type: CategoryResolverService },
+    { type: AllowedNetsService },
+    { type: UserResourceService, decorators: [{ type: Optional }] }
+];
+//# 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;AAEH,MAAM,OAAO,eAAe;IAIxB,YAAsB,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,GAAG,CAAC,aAAkC;QACzC,OAAO,IAAI,aAAa,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,qBAAqB,CAAC,CAAC;IACrF,CAAC;IAED;;;;OAIG;IACI,sBAAsB,CAAC,aAAkC;QAC5D,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;QACzC,QAAQ,CAAC,qBAAqB,EAAE,CAAC;QACjC,OAAO,QAAQ,CAAC;IACpB,CAAC;IAED;;;;;OAKG;IACI,4BAA4B,CAAC,uBAA+B;QAC/D,OAAO,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,uBAAuB,CAAC,CAAC,CAAC;IAChG,CAAC;IAED;;;;;OAKG;IACI,eAAe,CAAC,QAAmC;QACtD,MAAM,OAAO,GAAG,IAAI,aAAa,CAAgB,CAAC,CAAC,CAAC;QACpD,MAAM,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,GAAG,EAAE;YAC/C,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;;;YA1DiC,eAAe;YACrB,aAAa;YACU,0BAA0B;YACpC,uBAAuB;YACrB,kBAAkB;YACL,mBAAmB,uBAA9D,QAAQ;;;YAVxB,UAAU;;;YAlBH,eAAe;YADf,aAAa;YAKb,0BAA0B;YAE1B,uBAAuB;YACvB,kBAAkB;YAJlB,mBAAmB,uBAyBV,QAAQ","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"]}