@netgrif/components-core 6.0.1

package/esm5/lib/routing/dynamic-navigation-route-provider/dynamic-navigation-route-provider.service.js

@@ -0,0 +1,42 @@
+import { Injectable } from '@angular/core';
+import { ConfigurationService } from '../../configuration/configuration.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../configuration/configuration.service";
+var DynamicNavigationRouteProviderService = /** @class */ (function () {
+    function DynamicNavigationRouteProviderService(_config) {
+        this._config = _config;
+    }
+    Object.defineProperty(DynamicNavigationRouteProviderService.prototype, "route", {
+        /**
+         * @Returns the configuration set by the {@link RoutingBuilderService} or if dynamic navigation is not used the value set in the
+         * nae.json
+         */
+        get: function () {
+            var _a, _b;
+            if (this._route !== undefined) {
+                return this._route;
+            }
+            return (_b = (_a = this._config.getServicesConfiguration()) === null || _a === void 0 ? void 0 : _a.groupNavigation) === null || _b === void 0 ? void 0 : _b.groupNavigationRoute;
+        },
+        set: function (route) {
+            this._route = route;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DynamicNavigationRouteProviderService.ctorParameters = function () { return [
+        { type: ConfigurationService }
+    ]; };
+    DynamicNavigationRouteProviderService.ɵprov = i0.ɵɵdefineInjectable({ factory: function DynamicNavigationRouteProviderService_Factory() { return new DynamicNavigationRouteProviderService(i0.ɵɵinject(i1.ConfigurationService)); }, token: DynamicNavigationRouteProviderService, providedIn: "root" });
+    DynamicNavigationRouteProviderService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    DynamicNavigationRouteProviderService.ctorParameters = function () { return [
+        { type: ConfigurationService }
+    ]; };
+    return DynamicNavigationRouteProviderService;
+}());
+export { DynamicNavigationRouteProviderService };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,7 @@
+/* SERVICES */
+export * from './view-service/view.service';
+export * from './view-service/model/view-entry';
+export * from './routing-builder/routing-builder.service';
+export * from './redirect-service/redirect.service';
+export * from './dynamic-navigation-route-provider/dynamic-navigation-route-provider.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9yb3V0aW5nL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYztBQUNkLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLDJDQUEyQyxDQUFDO0FBQzFELGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYywrRUFBK0UsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIFNFUlZJQ0VTICovXG5leHBvcnQgKiBmcm9tICcuL3ZpZXctc2VydmljZS92aWV3LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi92aWV3LXNlcnZpY2UvbW9kZWwvdmlldy1lbnRyeSc7XG5leHBvcnQgKiBmcm9tICcuL3JvdXRpbmctYnVpbGRlci9yb3V0aW5nLWJ1aWxkZXIuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3JlZGlyZWN0LXNlcnZpY2UvcmVkaXJlY3Quc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2R5bmFtaWMtbmF2aWdhdGlvbi1yb3V0ZS1wcm92aWRlci9keW5hbWljLW5hdmlnYXRpb24tcm91dGUtcHJvdmlkZXIuc2VydmljZSc7XG4iXX0=

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

@@ -0,0 +1,130 @@
+import { __values } from "tslib";
+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";
+var RedirectService = /** @class */ (function () {
+    function RedirectService(_router, _log, _config, _route) {
+        this._router = _router;
+        this._log = _log;
+        this._config = _config;
+        this._route = _route;
+    }
+    Object.defineProperty(RedirectService.prototype, "lastUrl", {
+        get: function () {
+            return this._lastIntendedRoute.url;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RedirectService.prototype, "intendedRoute", {
+        set: function (route) {
+            this._lastIntendedRoute = route;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RedirectService.prototype, "queryParams", {
+        get: function () {
+            return this.lastQueryParams;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    RedirectService.prototype.redirect = function (path) {
+        var _this = this;
+        if (!!path) {
+            this._router.navigateByUrl(path).then(function (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(function (log) {
+                _this._log.info('Router navigate to last path : ' + log);
+            });
+        }
+    };
+    RedirectService.prototype.redirectFromUrl = function () {
+        this.lastQueryParams = this._route.snapshot.queryParams;
+        this._router.navigate([this.parseRedirectPath(this._router.url)], { queryParams: this.lastQueryParams });
+    };
+    RedirectService.prototype.resolveLoginPath = function () {
+        var config = this._config.get();
+        if (!!config.services && !!config.services.auth && !!config.services.auth.loginRedirect) {
+            return config.services.auth.loginRedirect;
+        }
+        var 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\'');
+    };
+    RedirectService.prototype.resolveLoginPathFromViewConfiguration = function (views, searchedLayout) {
+        var e_1, _a;
+        if (!views || Object.keys(views).length === 0) {
+            return null;
+        }
+        var route = Object.keys(views).find(function (routeKey) {
+            var layout = views[routeKey].layout;
+            return !!layout && layout.name === searchedLayout;
+        });
+        if (route) {
+            return (views[route].routing && views[route].routing.path) ? views[route].routing.path : null;
+        }
+        try {
+            for (var _b = __values(Object.keys(views)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var routeKey = _c.value;
+                var resolved = this.resolveLoginPathFromViewConfiguration(views[routeKey].children, searchedLayout);
+                if (resolved && views[routeKey].routing && views[routeKey].routing.path) {
+                    return views[routeKey].routing.path + '/' + resolved;
+                }
+            }
+        }
+        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; }
+        }
+        return null;
+    };
+    RedirectService.prototype.parseRedirectPath = function (url) {
+        var path;
+        if (url.includes('?')) {
+            path = url.slice(0, url.indexOf('?'));
+        }
+        else {
+            path = url;
+        }
+        return path.replace('/redirect', '');
+    };
+    RedirectService.LOGIN_COMPONENT = 'login';
+    RedirectService.ctorParameters = function () { return [
+        { 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 = function () { return [
+        { type: Router },
+        { type: LoggerService },
+        { type: ConfigurationService },
+        { type: ActivatedRoute }
+    ]; };
+    return RedirectService;
+}());
+export { RedirectService };
+//# 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/esm5/lib/routing/routing-builder/routing-builder.service.js

@@ -0,0 +1,207 @@
+import { __read, __spread, __values } from "tslib";
+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
+ */
+var RoutingBuilderService = /** @class */ (function () {
+    function RoutingBuilderService(router, _configService, _viewService, _logger, _dynamicNavigationRouteService, _groupNavigationComponentResolverComponent) {
+        var e_1, _a, _b;
+        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);
+        try {
+            for (var _c = __values(Object.entries(_configService.get().views)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var _e = __read(_d.value, 2), pathSegment = _e[0], view = _e[1];
+                var route = this.constructRouteObject(view, pathSegment);
+                if (route !== undefined) {
+                    router.config.push(route);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        (_b = router.config).push.apply(_b, __spread(this.defaultRoutesRedirects()));
+    }
+    RoutingBuilderService.prototype.constructRouteObject = function (view, configPath, ancestors) {
+        var _this = this;
+        var _a, _b;
+        if (ancestors === void 0) { ancestors = []; }
+        var 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;
+        }
+        var route = {
+            path: view.routing.path,
+            component: 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 + "'");
+            }
+            var pathNoParams = route.path;
+            route.path = pathNoParams + "/:" + GroupNavigationConstants.GROUP_NAVIGATION_ROUTER_PARAM;
+            route.canActivate = [AuthenticationGuardService];
+            var parentPathSegments = ancestors.map(function (a) { return 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(function (_a) {
+                var _b = __read(_a, 2), configPathSegment = _b[0], childView = _b[1];
+                // TODO check if routes are constructed correctly regarding empty route segments
+                var childRoute = _this.constructRouteObject(childView, configPath + "/" + configPathSegment, __spread(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: component
+            });
+        }
+        return route;
+    };
+    RoutingBuilderService.prototype.resolveComponentClass = function (view, configPath) {
+        var 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;
+    };
+    RoutingBuilderService.prototype.resolveComponentClassFromLayout = function (view, configPath) {
+        if (view.layout.name === GroupNavigationConstants.GROUP_NAVIGATION_OUTLET) {
+            return this._groupNavigationComponentResolverComponent;
+        }
+        var className;
+        if (!!view.layout.componentName) {
+            className = classify(view.layout.componentName) + "Component";
+        }
+        else {
+            var classInfo = new ViewClassInfo(configPath, view.layout.name, view.layout.componentName);
+            className = classInfo.className;
+        }
+        return this._viewService.resolveNameToClass(className);
+    };
+    RoutingBuilderService.prototype.defaultRoutesRedirects = function () {
+        var result = [];
+        var 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 = function () { return [
+        { 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 = function () { return [
+        { type: Router },
+        { type: ConfigurationService },
+        { type: ViewService },
+        { type: LoggerService },
+        { type: DynamicNavigationRouteProviderService },
+        { type: Type, decorators: [{ type: Optional }, { type: Inject, args: [NAE_GROUP_NAVIGATION_COMPONENT_RESOLVER_COMPONENT,] }] }
+    ]; };
+    return RoutingBuilderService;
+}());
+export { RoutingBuilderService };
+//# 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/esm5/lib/routing/view-service/model/view-entry.js

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

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

@@ -0,0 +1,38 @@
+import { Type } from '@angular/core';
+/**
+ * Holds information about views in the application. Can be used to resolve view component class objects from their names.
+ */
+var ViewService = /** @class */ (function () {
+    /**
+     * @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
+     */
+    function ViewService(componentClasses, 
+    // TODO 29.4.2021 - remove unused class attributes
+    configService, _router, _logger) {
+        var _this = this;
+        this._router = _router;
+        this._logger = _logger;
+        this._nameToClass = new Map();
+        componentClasses.forEach(function (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
+     */
+    ViewService.prototype.resolveNameToClass = function (componentClassName) {
+        return this._nameToClass.get(componentClassName);
+    };
+    return ViewService;
+}());
+export { ViewService };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,64 @@
+import { __read, __values } from "tslib";
+import { Subject } from 'rxjs';
+import { Input } from '@angular/core';
+import { BooleanOperator } from '../models/boolean-operator';
+var AbstractAdvancedSearchComponent = /** @class */ (function () {
+    function AbstractAdvancedSearchComponent(_searchService, _initializationService) {
+        var _this = this;
+        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 = function (a, b) { return b.value; };
+        this.removeChild$ = new Subject();
+        this.removeChild$.subscribe(function (id) { return _this._removeChildAt(id); });
+        if (!this._searchService.hasVisiblePredicates) {
+            this.addChildPredicate();
+        }
+    }
+    AbstractAdvancedSearchComponent.prototype.ngAfterViewInit = function () {
+        this._initializationService.completeInitialization();
+    };
+    AbstractAdvancedSearchComponent.prototype.ngOnDestroy = function () {
+        this.removeChild$.complete();
+    };
+    AbstractAdvancedSearchComponent.prototype.getPredicateMap = function () {
+        var e_1, _a;
+        var map = new Map();
+        try {
+            for (var _b = __values(this._searchService.rootPredicate.getPredicateMap().entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), key = _d[0], value = _d[1];
+                if (value.isVisible) {
+                    map.set(key, value.getWrappedPredicate());
+                }
+            }
+        }
+        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; }
+        }
+        return map;
+    };
+    AbstractAdvancedSearchComponent.prototype.addChildPredicate = function () {
+        this._searchService.rootPredicate.addNewClausePredicate(BooleanOperator.OR);
+    };
+    AbstractAdvancedSearchComponent.prototype._removeChildAt = function (id) {
+        this._searchService.rootPredicate.removePredicate(id);
+        if (this.getPredicateMap().size === 0) {
+            this.addChildPredicate();
+        }
+    };
+    AbstractAdvancedSearchComponent.propDecorators = {
+        editable: [{ type: Input }]
+    };
+    return AbstractAdvancedSearchComponent;
+}());
+export { AbstractAdvancedSearchComponent };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3QtYWR2YW5jZWQtc2VhcmNoLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9zZWFyY2gvYWR2YW5jZWQtc2VhcmNoLWNvbXBvbmVudC9hYnN0cmFjdC1hZHZhbmNlZC1zZWFyY2guY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFJQSxPQUFPLEVBQUMsT0FBTyxFQUFDLE1BQU0sTUFBTSxDQUFDO0FBQzdCLE9BQU8sRUFBZ0IsS0FBSyxFQUFZLE1BQU0sZUFBZSxDQUFDO0FBQzlELE9BQU8sRUFBQyxlQUFlLEVBQUMsTUFBTSw0QkFBNEIsQ0FBQztBQUszRDtJQVdJLHlDQUFnQyxjQUE2QixFQUM3QixzQkFBb0U7UUFEcEcsaUJBUUM7UUFSK0IsbUJBQWMsR0FBZCxjQUFjLENBQWU7UUFDN0IsMkJBQXNCLEdBQXRCLHNCQUFzQixDQUE4QztRQVZwRzs7OztXQUlHO1FBQ00sYUFBUSxHQUFHLElBQUksQ0FBQztRQXNCbEIsc0JBQWlCLEdBQUcsVUFBQyxDQUFTLEVBQUUsQ0FBc0MsSUFBSyxPQUFBLENBQUMsQ0FBQyxLQUFLLEVBQVAsQ0FBTyxDQUFDO1FBaEJ0RixJQUFJLENBQUMsWUFBWSxHQUFHLElBQUksT0FBTyxFQUFVLENBQUM7UUFDMUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxTQUFTLENBQUMsVUFBQSxFQUFFLElBQUksT0FBQSxLQUFJLENBQUMsY0FBYyxDQUFDLEVBQUUsQ0FBQyxFQUF2QixDQUF1QixDQUFDLENBQUM7UUFFM0QsSUFBSSxDQUFDLElBQUksQ0FBQyxjQUFjLENBQUMsb0JBQW9CLEVBQUU7WUFDM0MsSUFBSSxDQUFDLGlCQUFpQixFQUFFLENBQUM7U0FDNUI7SUFDTCxDQUFDO0lBRUQseURBQWUsR0FBZjtRQUNJLElBQUksQ0FBQyxzQkFBc0IsQ0FBQyxzQkFBc0IsRUFBRSxDQUFDO0lBQ3pELENBQUM7SUFFRCxxREFBVyxHQUFYO1FBQ0ksSUFBSSxDQUFDLFlBQVksQ0FBQyxRQUFRLEVBQUUsQ0FBQztJQUNqQyxDQUFDO0lBSU0seURBQWUsR0FBdEI7O1FBQ0ksSUFBTSxHQUFHLEdBQUcsSUFBSSxHQUFHLEVBQWlELENBQUM7O1lBRXJFLEtBQTJCLElBQUEsS0FBQSxTQUFBLElBQUksQ0FBQyxjQUFjLENBQUMsYUFBYSxDQUFDLGVBQWUsRUFBRSxDQUFDLE9BQU8sRUFBRSxDQUFBLGdCQUFBLDRCQUFFO2dCQUEvRSxJQUFBLEtBQUEsbUJBQVksRUFBWCxHQUFHLFFBQUEsRUFBRSxLQUFLLFFBQUE7Z0JBQ2xCLElBQUksS0FBSyxDQUFDLFNBQVMsRUFBRTtvQkFDakIsR0FBRyxDQUFDLEdBQUcsQ0FBQyxHQUFHLEVBQUUsS0FBSyxDQUFDLG1CQUFtQixFQUEyQyxDQUFDLENBQUM7aUJBQ3RGO2FBQ0o7Ozs7Ozs7OztRQUVELE9BQU8sR0FBRyxDQUFDO0lBQ2YsQ0FBQztJQUVNLDJEQUFpQixHQUF4QjtRQUNJLElBQUksQ0FBQyxjQUFjLENBQUMsYUFBYSxDQUFDLHFCQUFxQixDQUFDLGVBQWUsQ0FBQyxFQUFFLENBQUMsQ0FBQztJQUNoRixDQUFDO0lBRVMsd0RBQWMsR0FBeEIsVUFBeUIsRUFBVTtRQUMvQixJQUFJLENBQUMsY0FBYyxDQUFDLGFBQWEsQ0FBQyxlQUFlLENBQUMsRUFBRSxDQUFDLENBQUM7UUFDdEQsSUFBSSxJQUFJLENBQUMsZUFBZSxFQUFFLENBQUMsSUFBSSxLQUFLLENBQUMsRUFBRTtZQUNuQyxJQUFJLENBQUMsaUJBQWlCLEVBQUUsQ0FBQztTQUM1QjtJQUNMLENBQUM7OzJCQTdDQSxLQUFLOztJQThDVixzQ0FBQztDQUFBLEFBckRELElBcURDO1NBckRZLCtCQUErQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7RWRpdGFibGVDbGF1c2VQcmVkaWNhdGVXaXRoR2VuZXJhdG9yc30gZnJvbSAnLi4vbW9kZWxzL3ByZWRpY2F0ZS9lZGl0YWJsZS1jbGF1c2UtcHJlZGljYXRlLXdpdGgtZ2VuZXJhdG9ycyc7XG5pbXBvcnQge1NlYXJjaFNlcnZpY2V9IGZyb20gJy4uL3NlYXJjaC1zZXJ2aWNlL3NlYXJjaC5zZXJ2aWNlJztcbmltcG9ydCB7S2V5VmFsdWV9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQge0VkaXRhYmxlUHJlZGljYXRlfSBmcm9tICcuLi9tb2RlbHMvcHJlZGljYXRlL2VkaXRhYmxlLXByZWRpY2F0ZSc7XG5pbXBvcnQge1N1YmplY3R9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHtBZnRlclZpZXdJbml0LCBJbnB1dCwgT25EZXN0cm95fSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7Qm9vbGVhbk9wZXJhdG9yfSBmcm9tICcuLi9tb2RlbHMvYm9vbGVhbi1vcGVyYXRvcic7XG5pbXBvcnQge1xuICAgIEFkdmFuY2VkU2VhcmNoQ29tcG9uZW50SW5pdGlhbGl6YXRpb25TZXJ2aWNlXG59IGZyb20gJy4uL2FkdmFuY2VkLXNlYXJjaC1jb21wb25lbnQtaW5pdGlhbGl6YXRpb24tc2VydmljZS9hZHZhbmNlZC1zZWFyY2gtY29tcG9uZW50LWluaXRpYWxpemF0aW9uLnNlcnZpY2UnO1xuXG5leHBvcnQgY2xhc3MgQWJzdHJhY3RBZHZhbmNlZFNlYXJjaENvbXBvbmVudCBpbXBsZW1lbnRzIEFmdGVyVmlld0luaXQsIE9uRGVzdHJveSB7XG5cbiAgICAvKipcbiAgICAgKiBXaGV0aGVyIHRoZSBjb250ZW50cyBkaXNwbGF5ZWQgaW4gdGhpcyBjb21wb25lbnQgY2FuIGJlIGVkaXRlZCBieSB0aGUgdXNlciBvciBub3QuXG4gICAgICpcbiAgICAgKiBEZWZhdWx0cyB0byBgdHJ1ZWBcbiAgICAgKi9cbiAgICBASW5wdXQoKSBlZGl0YWJsZSA9IHRydWU7XG5cbiAgICBwdWJsaWMgcmVtb3ZlQ2hpbGQkOiBTdWJqZWN0PG51bWJlcj47XG5cbiAgICBwcm90ZWN0ZWQgY29uc3RydWN0b3IocHJvdGVjdGVkIF9zZWFyY2hTZXJ2aWNlOiBTZWFyY2hTZXJ2aWNlLFxuICAgICAgICAgICAgICAgICAgICAgICAgICBwcm90ZWN0ZWQgX2luaXRpYWxpemF0aW9uU2VydmljZTogQWR2YW5jZWRTZWFyY2hDb21wb25lbnRJbml0aWFsaXphdGlvblNlcnZpY2UpIHtcbiAgICAgICAgdGhpcy5yZW1vdmVDaGlsZCQgPSBuZXcgU3ViamVjdDxudW1iZXI+KCk7XG4gICAgICAgIHRoaXMucmVtb3ZlQ2hpbGQkLnN1YnNjcmliZShpZCA9PiB0aGlzLl9yZW1vdmVDaGlsZEF0KGlkKSk7XG5cbiAgICAgICAgaWYgKCF0aGlzLl9zZWFyY2hTZXJ2aWNlLmhhc1Zpc2libGVQcmVkaWNhdGVzKSB7XG4gICAgICAgICAgICB0aGlzLmFkZENoaWxkUHJlZGljYXRlKCk7XG4gICAgICAgIH1cbiAgICB9XG5cbiAgICBuZ0FmdGVyVmlld0luaXQoKTogdm9pZCB7XG4gICAgICAgIHRoaXMuX2luaXRpYWxpemF0aW9uU2VydmljZS5jb21wbGV0ZUluaXRpYWxpemF0aW9uKCk7XG4gICAgfVxuXG4gICAgbmdPbkRlc3Ryb3koKTogdm9pZCB7XG4gICAgICAgIHRoaXMucmVtb3ZlQ2hpbGQkLmNvbXBsZXRlKCk7XG4gICAgfVxuXG4gICAgcHVibGljIHRyYWNrQnlQcmVkaWNhdGVzID0gKGE6IG51bWJlciwgYjogS2V5VmFsdWU8bnVtYmVyLCBFZGl0YWJsZVByZWRpY2F0ZT4pID0+IGIudmFsdWU7XG5cbiAgICBwdWJsaWMgZ2V0UHJlZGljYXRlTWFwKCk6IE1hcDxudW1iZXIsIEVkaXRhYmxlQ2xhdXNlUHJlZGljYXRlV2l0aEdlbmVyYXRvcnM+IHtcbiAgICAgICAgY29uc3QgbWFwID0gbmV3IE1hcDxudW1iZXIsIEVkaXRhYmxlQ2xhdXNlUHJlZGljYXRlV2l0aEdlbmVyYXRvcnM+KCk7XG5cbiAgICAgICAgZm9yIChjb25zdCBba2V5LCB2YWx1ZV0gb2YgdGhpcy5fc2VhcmNoU2VydmljZS5yb290UHJlZGljYXRlLmdldFByZWRpY2F0ZU1hcCgpLmVudHJpZXMoKSkge1xuICAgICAgICAgICAgaWYgKHZhbHVlLmlzVmlzaWJsZSkge1xuICAgICAgICAgICAgICAgIG1hcC5zZXQoa2V5LCB2YWx1ZS5nZXRXcmFwcGVkUHJlZGljYXRlKCkgYXMgRWRpdGFibGVDbGF1c2VQcmVkaWNhdGVXaXRoR2VuZXJhdG9ycyk7XG4gICAgICAgICAgICB9XG4gICAgICAgIH1cblxuICAgICAgICByZXR1cm4gbWFwO1xuICAgIH1cblxuICAgIHB1YmxpYyBhZGRDaGlsZFByZWRpY2F0ZSgpOiB2b2lkIHtcbiAgICAgICAgdGhpcy5fc2VhcmNoU2VydmljZS5yb290UHJlZGljYXRlLmFkZE5ld0NsYXVzZVByZWRpY2F0ZShCb29sZWFuT3BlcmF0b3IuT1IpO1xuICAgIH1cblxuICAgIHByb3RlY3RlZCBfcmVtb3ZlQ2hpbGRBdChpZDogbnVtYmVyKTogdm9pZCB7XG4gICAgICAgIHRoaXMuX3NlYXJjaFNlcnZpY2Uucm9vdFByZWRpY2F0ZS5yZW1vdmVQcmVkaWNhdGUoaWQpO1xuICAgICAgICBpZiAodGhpcy5nZXRQcmVkaWNhdGVNYXAoKS5zaXplID09PSAwKSB7XG4gICAgICAgICAgICB0aGlzLmFkZENoaWxkUHJlZGljYXRlKCk7XG4gICAgICAgIH1cbiAgICB9XG59XG4iXX0=

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

@@ -0,0 +1,40 @@
+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.
+ */
+var AdvancedSearchComponentInitializationService = /** @class */ (function () {
+    function AdvancedSearchComponentInitializationService() {
+        this._initialized = new LoadingEmitter(false);
+    }
+    AdvancedSearchComponentInitializationService.prototype.ngOnDestroy = function () {
+        this._initialized.complete();
+    };
+    Object.defineProperty(AdvancedSearchComponentInitializationService.prototype, "isInitialized", {
+        /**
+         * @returns `false` until the [completeInitialization()]{@link AdvancedSearchComponentInitializationService#completeInitialization}
+         * method is called. Returns `true` afterwards.
+         */
+        get: function () {
+            return this._initialized.isActive;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Changes the state to `initialized`.
+     */
+    AdvancedSearchComponentInitializationService.prototype.completeInitialization = function () {
+        this._initialized.on();
+    };
+    AdvancedSearchComponentInitializationService.decorators = [
+        { type: Injectable }
+    ];
+    AdvancedSearchComponentInitializationService.ctorParameters = function () { return []; };
+    return AdvancedSearchComponentInitializationService;
+}());
+export { AdvancedSearchComponentInitializationService };
+//# sourceMappingURL=data:application/json;base64,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