@c8y/ngx-components 1021.21.0 → 1021.22.0

package/esm2022/core/router/router.service.mjs

@@ -1,12 +1,12 @@
 import { importProvidersFrom, Injectable, InjectionToken, Injector } from '@angular/core';
 import { Router, ROUTES } from '@angular/router';
-import { ViewContext } from './router.model';
-import { ContextRouteService } from './context-route.service';
-import { distinctUntilChanged, filter, shareReplay, take } from 'rxjs/operators';
-import { fromTriggerOnce, hookGeneric, getInjectedHooks, InjectionType, ExtensionPointWithoutStateForPlugins } from '../common/extension-hooks';
-import { PluginsResolveService } from '../plugins';
 import { flatten } from 'lodash';
+import { distinctUntilChanged, filter, shareReplay, take } from 'rxjs/operators';
+import { ExtensionPointWithoutStateForPlugins, fromTriggerOnce, getInjectedHooks, hookGeneric, InjectionType } from '../common/extension-hooks';
 import { OptionsService } from '../common/options.service';
+import { PluginsResolveService } from '../plugins';
+import { ContextRouteService } from './context-route.service';
+import { ViewContext } from './router.model';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/router";
 import * as i2 from "./context-route.service";
@@ -114,16 +114,17 @@ export class RouterService extends ExtensionPointWithoutStateForPlugins {
         // Empty route needs to be last as of navigation to angularjs routes
         // if ** route hit, the angularjs routes are loaded.
         const emptyRoute = this.router.config.find(r => r.path === '**');
+        const rootContextRoutes = this.findAllRootContextRoutes([...this.router.config, ...routes]);
         this.router.resetConfig([
             ...this.router.config.filter(r => r.path !== '**'),
-            ...routes.map((r) => this.convertRoute(this.router.config, r)),
+            ...routes.map((r) => this.convertRoute(rootContextRoutes, r)),
             emptyRoute
         ].filter(Boolean));
     }
-    convertRoute(initialConfig, route) {
+    convertRoute(rootContextRoutes, route) {
         if (route.context) {
-            initialConfig.forEach((r) => {
-                if (r.data && r.data.context === route.context) {
+            rootContextRoutes.forEach((r) => {
+                if (r.rootContext === route.context) {
                     r.children = [route, ...(r.children || [])];
                 }
             });
@@ -131,6 +132,19 @@ export class RouterService extends ExtensionPointWithoutStateForPlugins {
         }
         return route;
     }
+    findAllRootContextRoutes(routes) {
+        const result = [];
+        routes.forEach(route => {
+            if (route.rootContext) {
+                result.push(route);
+            }
+            if (route.children) {
+                const childRoutes = this.findAllRootContextRoutes(route.children);
+                result.push(...childRoutes);
+            }
+        });
+        return result;
+    }
     resolveRouterForChildRoutes(moduleRef, remoteNgModule) {
         // NOTE: stolen from lazy loaded routes from Angular itself.
         // https://github.com/angular/angular/blob/da58801f95c66c201e332189af25702bdd722f3f/packages/router/src/router_config_loader.ts#L103-L108
@@ -152,4 +166,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImpor
                     providedIn: 'root'
                 }]
         }], ctorParameters: () => [{ type: i0.Injector }, { type: i1.Router }, { type: i2.ContextRouteService }, { type: i3.PluginsResolveService }, { type: i4.OptionsService }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"router.service.js","sourceRoot":"","sources":["../../../../core/router/router.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  importProvidersFrom,\n  Injectable,\n  InjectionToken,\n  Injector,\n  NgModuleRef\n} from '@angular/core';\nimport { Router, ROUTES } from '@angular/router';\nimport { RouteFactory, Route, ViewContext } from './router.model';\nimport { ContextRouteService } from './context-route.service';\nimport { IManagedObject } from '@c8y/client';\nimport { Observable } from 'rxjs';\nimport { distinctUntilChanged, filter, shareReplay, take } from 'rxjs/operators';\nimport {\n  ExtensionFactory,\n  fromTriggerOnce,\n  GenericHookType,\n  hookGeneric,\n  getInjectedHooks,\n  InjectionType,\n  ExtensionPointWithoutStateForPlugins,\n  GenericHookOptions\n} from '../common/extension-hooks';\nimport { PluginsResolveService } from '../plugins';\nimport { flatten } from 'lodash';\nimport { OptionsService } from '../common/options.service';\n\n/**\n * An extension HOOK can use either a pure value:\n * ```typescript\n *  { provide: HOOK_X, useValue: { ...hookValue }, multi: true }\n * ```\n *\n * Or an array to directly register multiple:\n * ```typescript\n *  { provide: HOOK_X, useValue: [{ ...hookValues }], multi: true }\n * ```\n *\n * Or an ExtensionFactory which allows to define a get() function. This function\n * gets called on each navigation with the current route and can return values\n * async (observable or promise).\n * ```typescript\n *  { provide: HOOK_X, useFactory: { get: (route) => doSomethingAsync(route) }, multi: true }\n * ```\n */\nexport type RouteExtension = Route | Route[] | ExtensionFactory<Route>;\n\n/**\n * A hook to use for Multi Provider extension.\n * @deprecated Consider using the `hookRoute` function instead.\n */\nexport const HOOK_ROUTE = new InjectionToken<RouteFactory>('HOOK_ROUTE');\n\n/**\n * You can either provide a single `Route` as parameter:\n * ```typescript\n *  hookRoute(...)\n * ```\n *\n * Or an array to directly register multiple:\n * ```typescript\n *  hookRoute([...])\n * ```\n *\n * Or you provide an Service that implements `ExtensionFactory<Route>`\n * ```typescript\n *  export class MyRouteFactory implements ExtensionFactory<Route> {...}\n *  ...\n *  hookRoute(MyRouteFactory)\n * ```\n * A typed alternative to `HOOK_ROUTE`.\n * @param route The `Route`'s or `ExtensionFactory` to be provided.\n * @returns An `Provider` to be provided in your module.\n */\nexport function hookRoute(route: GenericHookType<Route>, options?: Partial<GenericHookOptions>) {\n  return hookGeneric<Route>(route, HOOK_ROUTE, options);\n}\n\n/**\n * A service which defines routes for the application. You can use\n * HOOK_ROUTES or pass\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class RouterService extends ExtensionPointWithoutStateForPlugins<Route> {\n  readonly state = new Map<string, Route>();\n\n  constructor(\n    rootInjector: Injector,\n    public router: Router,\n    private contextRouteService: ContextRouteService,\n    plugins: PluginsResolveService,\n    options: OptionsService\n  ) {\n    super(rootInjector, plugins);\n    this.items$ = this.setupItemsObservable();\n\n    // We are doing a self subscription to add the new routes\n    // to the router configuration.\n    this.items$.subscribe((routes: Route[]) => {\n      const toAddRoutes = routes.filter((route: Route) => {\n        const path = `${route.context || ''}${route.path}`;\n        const isAlreadyAdded = this.state.has(path);\n        if (!isAlreadyAdded) {\n          this.state.set(path, route);\n        }\n        return !isAlreadyAdded;\n      });\n      this.addRoute(toAddRoutes);\n    });\n\n    plugins.pluginDetails$.subscribe(({ moduleRef, remoteNgModule }) => {\n      this.resolveRouterForChildRoutes(moduleRef, remoteNgModule);\n    });\n\n    // only needed in case of pure angular application\n    // otherwise handled by bridge service\n    if (!options.upgrade) {\n      plugins.allPluginsLoaded$\n        .pipe(\n          filter(tmp => !!tmp),\n          take(1)\n        )\n        .subscribe(() => {\n          this.router.initialNavigation();\n        });\n    }\n  }\n\n  /**\n   * Refresh the current context\n   */\n  refresh() {\n    super.refresh();\n    this.contextRouteService.refreshContext();\n  }\n\n  /**\n   * Add a new route to the router configuration or a context.\n   * @param route The route to add\n   */\n  addRoute(route: Route | Route[]) {\n    this.addRoutes(Array.isArray(route) ? route : [route]);\n  }\n\n  /**\n   * Determines if the given MO is an group or an device and returns\n   * the correct href to link correctly to that MO.\n   * @param groupOrDevice The MO of a group or the device.\n   * @param prefix How should the link be prefixed.\n   */\n  getHref(groupOrDevice: IManagedObject, prefix = '#/'): string {\n    if (groupOrDevice.c8y_IsDeviceGroup || groupOrDevice.c8y_IsDynamicGroup) {\n      return `${prefix}${ViewContext.Group.replace(':id', groupOrDevice.id)}`;\n    }\n    return `${prefix}${ViewContext.Device.replace(':id', groupOrDevice.id)}`;\n  }\n\n  protected setupItemsObservable(): Observable<Route[]> {\n    return fromTriggerOnce<Route>(this.router, this.refresh$, [\n      getInjectedHooks<Route>(HOOK_ROUTE, this.injectors, InjectionType.ROUTE),\n      () => this.factories\n    ]).pipe(distinctUntilChanged(), shareReplay(1));\n  }\n\n  private addRoutes(routes) {\n    // Empty route needs to be last as of navigation to angularjs routes\n    // if ** route hit, the angularjs routes are loaded.\n    const emptyRoute = this.router.config.find(r => r.path === '**');\n    this.router.resetConfig(\n      [\n        ...this.router.config.filter(r => r.path !== '**'),\n        ...routes.map((r: Route) => this.convertRoute(this.router.config, r)),\n        emptyRoute\n      ].filter(Boolean)\n    );\n  }\n\n  private convertRoute(initialConfig, route: Route) {\n    if (route.context) {\n      initialConfig.forEach((r: Route) => {\n        if (r.data && r.data.context === route.context) {\n          r.children = [route, ...(r.children || [])];\n        }\n      });\n      return;\n    }\n    return route;\n  }\n\n  private resolveRouterForChildRoutes(moduleRef: NgModuleRef<any>, remoteNgModule: any) {\n    // NOTE: stolen from lazy loaded routes from Angular itself.\n    // https://github.com/angular/angular/blob/da58801f95c66c201e332189af25702bdd722f3f/packages/router/src/router_config_loader.ts#L103-L108\n    const rawRoutes = flatten(moduleRef.injector.get(ROUTES, [], { self: true, optional: true }));\n\n    if (rawRoutes.length > 0) {\n      const routeWithInjector = rawRoutes.map(route => {\n        route.providers = [importProvidersFrom(remoteNgModule)];\n        return route;\n      });\n      this.addRoute(routeWithInjector);\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"router.service.js","sourceRoot":"","sources":["../../../../core/router/router.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  importProvidersFrom,\n  Injectable,\n  InjectionToken,\n  Injector,\n  NgModuleRef\n} from '@angular/core';\nimport { Router, Routes, ROUTES } from '@angular/router';\nimport { IManagedObject } from '@c8y/client';\nimport { flatten } from 'lodash';\nimport { Observable } from 'rxjs';\nimport { distinctUntilChanged, filter, shareReplay, take } from 'rxjs/operators';\nimport {\n  ExtensionFactory,\n  ExtensionPointWithoutStateForPlugins,\n  fromTriggerOnce,\n  GenericHookOptions,\n  GenericHookType,\n  getInjectedHooks,\n  hookGeneric,\n  InjectionType\n} from '../common/extension-hooks';\nimport { OptionsService } from '../common/options.service';\nimport { PluginsResolveService } from '../plugins';\nimport { ContextRouteService } from './context-route.service';\nimport { Route, RouteFactory, ViewContext, ViewContextRootRoute } from './router.model';\n\n/**\n * An extension HOOK can use either a pure value:\n * ```typescript\n *  { provide: HOOK_X, useValue: { ...hookValue }, multi: true }\n * ```\n *\n * Or an array to directly register multiple:\n * ```typescript\n *  { provide: HOOK_X, useValue: [{ ...hookValues }], multi: true }\n * ```\n *\n * Or an ExtensionFactory which allows to define a get() function. This function\n * gets called on each navigation with the current route and can return values\n * async (observable or promise).\n * ```typescript\n *  { provide: HOOK_X, useFactory: { get: (route) => doSomethingAsync(route) }, multi: true }\n * ```\n */\nexport type RouteExtension = Route | Route[] | ExtensionFactory<Route>;\n\n/**\n * A hook to use for Multi Provider extension.\n * @deprecated Consider using the `hookRoute` function instead.\n */\nexport const HOOK_ROUTE = new InjectionToken<RouteFactory>('HOOK_ROUTE');\n\n/**\n * You can either provide a single `Route` as parameter:\n * ```typescript\n *  hookRoute(...)\n * ```\n *\n * Or an array to directly register multiple:\n * ```typescript\n *  hookRoute([...])\n * ```\n *\n * Or you provide an Service that implements `ExtensionFactory<Route>`\n * ```typescript\n *  export class MyRouteFactory implements ExtensionFactory<Route> {...}\n *  ...\n *  hookRoute(MyRouteFactory)\n * ```\n * A typed alternative to `HOOK_ROUTE`.\n * @param route The `Route`'s or `ExtensionFactory` to be provided.\n * @returns An `Provider` to be provided in your module.\n */\nexport function hookRoute(route: GenericHookType<Route>, options?: Partial<GenericHookOptions>) {\n  return hookGeneric<Route>(route, HOOK_ROUTE, options);\n}\n\n/**\n * A service which defines routes for the application. You can use\n * HOOK_ROUTES or pass\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class RouterService extends ExtensionPointWithoutStateForPlugins<Route> {\n  readonly state = new Map<string, Route>();\n\n  constructor(\n    rootInjector: Injector,\n    public router: Router,\n    private contextRouteService: ContextRouteService,\n    plugins: PluginsResolveService,\n    options: OptionsService\n  ) {\n    super(rootInjector, plugins);\n    this.items$ = this.setupItemsObservable();\n\n    // We are doing a self subscription to add the new routes\n    // to the router configuration.\n    this.items$.subscribe((routes: Route[]) => {\n      const toAddRoutes = routes.filter((route: Route) => {\n        const path = `${route.context || ''}${route.path}`;\n        const isAlreadyAdded = this.state.has(path);\n        if (!isAlreadyAdded) {\n          this.state.set(path, route);\n        }\n        return !isAlreadyAdded;\n      });\n      this.addRoute(toAddRoutes);\n    });\n\n    plugins.pluginDetails$.subscribe(({ moduleRef, remoteNgModule }) => {\n      this.resolveRouterForChildRoutes(moduleRef, remoteNgModule);\n    });\n\n    // only needed in case of pure angular application\n    // otherwise handled by bridge service\n    if (!options.upgrade) {\n      plugins.allPluginsLoaded$\n        .pipe(\n          filter(tmp => !!tmp),\n          take(1)\n        )\n        .subscribe(() => {\n          this.router.initialNavigation();\n        });\n    }\n  }\n\n  /**\n   * Refresh the current context\n   */\n  refresh() {\n    super.refresh();\n    this.contextRouteService.refreshContext();\n  }\n\n  /**\n   * Add a new route to the router configuration or a context.\n   * @param route The route to add\n   */\n  addRoute(route: Route | Route[]) {\n    this.addRoutes(Array.isArray(route) ? route : [route]);\n  }\n\n  /**\n   * Determines if the given MO is an group or an device and returns\n   * the correct href to link correctly to that MO.\n   * @param groupOrDevice The MO of a group or the device.\n   * @param prefix How should the link be prefixed.\n   */\n  getHref(groupOrDevice: IManagedObject, prefix = '#/'): string {\n    if (groupOrDevice.c8y_IsDeviceGroup || groupOrDevice.c8y_IsDynamicGroup) {\n      return `${prefix}${ViewContext.Group.replace(':id', groupOrDevice.id)}`;\n    }\n    return `${prefix}${ViewContext.Device.replace(':id', groupOrDevice.id)}`;\n  }\n\n  protected setupItemsObservable(): Observable<Route[]> {\n    return fromTriggerOnce<Route>(this.router, this.refresh$, [\n      getInjectedHooks<Route>(HOOK_ROUTE, this.injectors, InjectionType.ROUTE),\n      () => this.factories\n    ]).pipe(distinctUntilChanged(), shareReplay(1));\n  }\n\n  private addRoutes(routes) {\n    // Empty route needs to be last as of navigation to angularjs routes\n    // if ** route hit, the angularjs routes are loaded.\n    const emptyRoute = this.router.config.find(r => r.path === '**');\n    const rootContextRoutes = this.findAllRootContextRoutes([...this.router.config, ...routes]);\n    this.router.resetConfig(\n      [\n        ...this.router.config.filter(r => r.path !== '**'),\n        ...routes.map((r: Route) => this.convertRoute(rootContextRoutes, r)),\n        emptyRoute\n      ].filter(Boolean)\n    );\n  }\n\n  private convertRoute(rootContextRoutes: Routes, route: Route) {\n    if (route.context) {\n      rootContextRoutes.forEach((r: ViewContextRootRoute) => {\n        if (r.rootContext === route.context) {\n          r.children = [route, ...(r.children || [])];\n        }\n      });\n      return;\n    }\n    return route;\n  }\n\n  private findAllRootContextRoutes(routes: Routes): ViewContextRootRoute[] {\n    const result: ViewContextRootRoute[] = [];\n    routes.forEach(route => {\n      if ((route as ViewContextRootRoute).rootContext) {\n        result.push(route as ViewContextRootRoute);\n      }\n      if (route.children) {\n        const childRoutes = this.findAllRootContextRoutes(route.children);\n        result.push(...childRoutes);\n      }\n    });\n    return result;\n  }\n\n  private resolveRouterForChildRoutes(moduleRef: NgModuleRef<any>, remoteNgModule: any) {\n    // NOTE: stolen from lazy loaded routes from Angular itself.\n    // https://github.com/angular/angular/blob/da58801f95c66c201e332189af25702bdd722f3f/packages/router/src/router_config_loader.ts#L103-L108\n    const rawRoutes = flatten(moduleRef.injector.get(ROUTES, [], { self: true, optional: true }));\n\n    if (rawRoutes.length > 0) {\n      const routeWithInjector = rawRoutes.map(route => {\n        route.providers = [importProvidersFrom(remoteNgModule)];\n        return route;\n      });\n      this.addRoute(routeWithInjector);\n    }\n  }\n}\n"]}

package/esm2022/core/router/scoped-context-route.service.mjs

@@ -0,0 +1,152 @@
+import { DestroyRef, Injectable, Injector } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { ActivationEnd, ActivationStart, ChildActivationEnd, PRIMARY_OUTLET, Router } from '@angular/router';
+import { ApiService } from '@c8y/ngx-components/api';
+import { NEVER, Subject } from 'rxjs';
+import { filter, map, merge, switchMap } from 'rxjs/operators';
+import { TabsService } from '../tabs/tabs.service';
+import { RouterTabsResolver } from './router-tabs.resolver';
+import { ViewContext } from './router.model';
+import { ViewContextServices } from './view-context.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./router-tabs.resolver";
+import * as i2 from "../tabs/tabs.service";
+import * as i3 from "@angular/router";
+import * as i4 from "@c8y/ngx-components/api";
+/**
+ * A service which is injected into the context route component to handle the context data.
+ */
+export class ScopedContextRouteService {
+    constructor(tabsResolver, tabsService, router, apiService, injector, destroyRef) {
+        this.tabsResolver = tabsResolver;
+        this.tabsService = tabsService;
+        this.router = router;
+        this.apiService = apiService;
+        this.injector = injector;
+        this.destroyRef = destroyRef;
+        this.lastAddedTabs = [];
+        this.refreshTrigger$ = new Subject();
+        this.ID_REGEX = /([0-9]+)/;
+    }
+    /**
+     * Indicates that the data is loading
+     * @returns An boolean observable which indicates if the data is loading.
+     */
+    isLoading$() {
+        return this.router.events.pipe(filter(e => (e instanceof ActivationStart || e instanceof ChildActivationEnd) &&
+            e.snapshot.routeConfig?.rootContext === this.currentContext), map(e => e instanceof ActivationStart), takeUntilDestroyed(this.destroyRef));
+    }
+    /**
+     * Initializes the context route.
+     * @param route The current activated route.
+     */
+    init(route) {
+        this.currentContext = route.routeConfig.rootContext;
+        if (!this.currentContext) {
+            throw new Error(`${ScopedContextRouteService.name} should not be used on a route without a rootContext`);
+        }
+        this.router.events
+            .pipe(filter(e => e instanceof ActivationEnd), takeUntilDestroyed(this.destroyRef))
+            .subscribe((e) => this.redirectToFirstTab(e));
+        route.data
+            .pipe(merge(this.updatedContext(route), this.refreshTrigger$), switchMap(() => this.tabsResolver.resolve(route.snapshot)), takeUntilDestroyed(this.destroyRef))
+            .subscribe(tabs => this.updateTabs(tabs));
+    }
+    /**
+     * Destroys the service.
+     */
+    ngOnDestroy() {
+        this.lastAddedTabs.forEach(t => this.tabsService.remove(t));
+    }
+    /**
+     * Refreshes the context.
+     */
+    refreshContext() {
+        this.refreshTrigger$.next();
+    }
+    /**
+     * Sets an API hook to refresh the contextData on changes.
+     * @param activatedRoute The current activated route.
+     */
+    updatedContext(route) {
+        const { data } = route.snapshot;
+        const serviceInstance = ViewContextServices.contextToService(data.context);
+        if (serviceInstance) {
+            const service = this.injector.get(serviceInstance);
+            const detailsUrlRegex = service
+                .getDetailUrl(data.contextData)
+                .replace(/\d+/g, '?\\d*');
+            const contextRegex = new RegExp(detailsUrlRegex, 'i');
+            const childrenRegex = new RegExp(`${detailsUrlRegex}/child`, 'i');
+            const filterResponse = ({ url, method }) => {
+                const contextChanged = contextRegex.test(url) && ['POST', 'PUT'].includes(method);
+                const childrenAffected = childrenRegex.test(url) && ['POST', 'DELETE'].includes(method);
+                return contextChanged || childrenAffected;
+            };
+            return this.apiService.hookResponse(filterResponse);
+        }
+        return NEVER;
+    }
+    updateTabs(tabs = []) {
+        this.lastAddedTabs.forEach(t => this.tabsService.remove(t));
+        this.lastAddedTabs = tabs;
+        tabs.forEach(t => this.tabsService.add(t));
+        this.redirectToFirstTab();
+    }
+    redirectToFirstTab(event) {
+        if (event) {
+            if (this.needsRedirect(event)) {
+                const tab = this.tabsService.sortTabs(event.snapshot.data.tabs)?.[0];
+                if (!tab) {
+                    return;
+                }
+                const currentContextId = (this.router.url.match(this.ID_REGEX) || []).shift();
+                const tabPathId = (tab.path.match(this.ID_REGEX) || []).shift();
+                if (currentContextId === tabPathId) {
+                    this.router.navigateByUrl(tab.path, { replaceUrl: true });
+                }
+            }
+        }
+        else {
+            const currentContextId = (this.router.url.match(this.ID_REGEX) || []).shift();
+            if (this.needsRedirectLegacy()) {
+                this.tabsService.firstTab$.pipe(filter((tab) => !!tab?.path)).subscribe((tab) => {
+                    const tabPathId = (tab.path.match(this.ID_REGEX) || []).shift();
+                    if (currentContextId === tabPathId) {
+                        this.router.navigateByUrl(tab.path, { replaceUrl: true });
+                    }
+                });
+            }
+        }
+    }
+    needsRedirectLegacy() {
+        const tree = this.router.parseUrl(this.router.url);
+        const groups = tree.root.children[PRIMARY_OUTLET];
+        const context = this.getMatchingContextRoute(this.router.url);
+        if (!context) {
+            return groups.segments.length === 2;
+        }
+        return context.split('/').length === groups.segments.length;
+    }
+    needsRedirect(event) {
+        const contextRoute = event.snapshot.routeConfig;
+        if (!contextRoute.rootContext) {
+            return false;
+        }
+        const contextRouteFromUrl = this.getMatchingContextRoute(this.router.url);
+        return contextRoute.rootContext === contextRouteFromUrl;
+    }
+    getMatchingContextRoute(url) {
+        const viewContexts = Object.values(ViewContext);
+        // replace all :id placeholders with a regex matcher for a number
+        const regexMatchers = viewContexts.map(context => `^/${context.replace(/:id/g, '([0-9]+)')}$`);
+        const matchingRegexContext = regexMatchers.find(context => new RegExp(context).test(url));
+        return matchingRegexContext ? viewContexts[regexMatchers.indexOf(matchingRegexContext)] : null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: ScopedContextRouteService, deps: [{ token: i1.RouterTabsResolver }, { token: i2.TabsService }, { token: i3.Router }, { token: i4.ApiService }, { token: i0.Injector }, { token: i0.DestroyRef }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: ScopedContextRouteService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: ScopedContextRouteService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.RouterTabsResolver }, { type: i2.TabsService }, { type: i3.Router }, { type: i4.ApiService }, { type: i0.Injector }, { type: i0.DestroyRef }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scoped-context-route.service.js","sourceRoot":"","sources":["../../../../core/router/scoped-context-route.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { DestroyRef, Injectable, Injector, OnDestroy, Type } from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport {\n  ActivatedRoute,\n  ActivationEnd,\n  ActivationStart,\n  ChildActivationEnd,\n  PRIMARY_OUTLET,\n  Router,\n  UrlSegmentGroup,\n  UrlTree\n} from '@angular/router';\nimport { ApiCall, ApiService } from '@c8y/ngx-components/api';\nimport { NEVER, Observable, Subject } from 'rxjs';\nimport { filter, map, merge, switchMap } from 'rxjs/operators';\nimport { Tab } from '../tabs/tab.model';\nimport { TabsService } from '../tabs/tabs.service';\nimport { RouterTabsResolver } from './router-tabs.resolver';\nimport { ViewContext, ViewContextRootRoute } from './router.model';\nimport { ViewContextServices } from './view-context.service';\n\n/**\n * A service which is injected into the context route component to handle the context data.\n */\n@Injectable()\nexport class ScopedContextRouteService implements OnDestroy {\n  private lastAddedTabs = [];\n  private refreshTrigger$ = new Subject<void>();\n  private ID_REGEX = /([0-9]+)/;\n\n  /**\n   * The context used by this service.\n   */\n  private currentContext: ViewContext;\n\n  constructor(\n    private tabsResolver: RouterTabsResolver,\n    private tabsService: TabsService,\n    private router: Router,\n    private apiService: ApiService,\n    private injector: Injector,\n    private destroyRef: DestroyRef\n  ) {}\n\n  /**\n   * Indicates that the data is loading\n   * @returns An boolean observable which indicates if the data is loading.\n   */\n  isLoading$(): Observable<boolean> {\n    return this.router.events.pipe(\n      filter(\n        e =>\n          (e instanceof ActivationStart || e instanceof ChildActivationEnd) &&\n          (e.snapshot.routeConfig as ViewContextRootRoute)?.rootContext === this.currentContext\n      ),\n      map(e => e instanceof ActivationStart),\n      takeUntilDestroyed(this.destroyRef)\n    );\n  }\n\n  /**\n   * Initializes the context route.\n   * @param route The current activated route.\n   */\n  init(route: ActivatedRoute): void {\n    this.currentContext = (route.routeConfig as ViewContextRootRoute).rootContext;\n    if (!this.currentContext) {\n      throw new Error(\n        `${ScopedContextRouteService.name} should not be used on a route without a rootContext`\n      );\n    }\n\n    this.router.events\n      .pipe(\n        filter(e => e instanceof ActivationEnd),\n        takeUntilDestroyed(this.destroyRef)\n      )\n      .subscribe((e: ActivationEnd) => this.redirectToFirstTab(e));\n\n    route.data\n      .pipe(\n        merge(this.updatedContext(route), this.refreshTrigger$),\n        switchMap(() => this.tabsResolver.resolve(route.snapshot)),\n        takeUntilDestroyed(this.destroyRef)\n      )\n      .subscribe(tabs => this.updateTabs(tabs));\n  }\n\n  /**\n   * Destroys the service.\n   */\n  ngOnDestroy(): void {\n    this.lastAddedTabs.forEach(t => this.tabsService.remove(t));\n  }\n\n  /**\n   * Refreshes the context.\n   */\n  refreshContext() {\n    this.refreshTrigger$.next();\n  }\n\n  /**\n   * Sets an API hook to refresh the contextData on changes.\n   * @param activatedRoute The current activated route.\n   */\n  private updatedContext(route: ActivatedRoute): Observable<ApiCall> {\n    const { data } = route.snapshot;\n    const serviceInstance = ViewContextServices.contextToService(data.context);\n    if (serviceInstance) {\n      const service = this.injector.get(\n        serviceInstance as Type<InstanceType<typeof serviceInstance>>\n      );\n      const detailsUrlRegex = (service as typeof service & { getDetailUrl?: (...args) => string })\n        .getDetailUrl(data.contextData)\n        .replace(/\\d+/g, '?\\\\d*');\n      const contextRegex = new RegExp(detailsUrlRegex, 'i');\n      const childrenRegex = new RegExp(`${detailsUrlRegex}/child`, 'i');\n      const filterResponse = ({ url, method }) => {\n        const contextChanged = contextRegex.test(url) && ['POST', 'PUT'].includes(method);\n        const childrenAffected = childrenRegex.test(url) && ['POST', 'DELETE'].includes(method);\n        return contextChanged || childrenAffected;\n      };\n      return this.apiService.hookResponse(filterResponse);\n    }\n    return NEVER;\n  }\n\n  private updateTabs(tabs = []) {\n    this.lastAddedTabs.forEach(t => this.tabsService.remove(t));\n    this.lastAddedTabs = tabs;\n    tabs.forEach(t => this.tabsService.add(t));\n    this.redirectToFirstTab();\n  }\n\n  private redirectToFirstTab(event?: ActivationEnd) {\n    if (event) {\n      if (this.needsRedirect(event)) {\n        const tab = this.tabsService.sortTabs(event.snapshot.data.tabs)?.[0];\n        if (!tab) {\n          return;\n        }\n        const currentContextId = (this.router.url.match(this.ID_REGEX) || []).shift();\n        const tabPathId = (tab.path.match(this.ID_REGEX) || []).shift();\n        if (currentContextId === tabPathId) {\n          this.router.navigateByUrl(tab.path, { replaceUrl: true });\n        }\n      }\n    } else {\n      const currentContextId = (this.router.url.match(this.ID_REGEX) || []).shift();\n\n      if (this.needsRedirectLegacy()) {\n        this.tabsService.firstTab$.pipe(filter((tab: Tab) => !!tab?.path)).subscribe((tab: Tab) => {\n          const tabPathId = (tab.path.match(this.ID_REGEX) || []).shift();\n          if (currentContextId === tabPathId) {\n            this.router.navigateByUrl(tab.path, { replaceUrl: true });\n          }\n        });\n      }\n    }\n  }\n\n  private needsRedirectLegacy(): boolean {\n    const tree: UrlTree = this.router.parseUrl(this.router.url);\n    const groups: UrlSegmentGroup = tree.root.children[PRIMARY_OUTLET];\n\n    const context = this.getMatchingContextRoute(this.router.url);\n    if (!context) {\n      return groups.segments.length === 2;\n    }\n    return context.split('/').length === groups.segments.length;\n  }\n\n  private needsRedirect(event: ActivationEnd): boolean {\n    const contextRoute: ViewContextRootRoute = event.snapshot.routeConfig as ViewContextRootRoute;\n    if (!contextRoute.rootContext) {\n      return false;\n    }\n    const contextRouteFromUrl = this.getMatchingContextRoute(this.router.url);\n    return contextRoute.rootContext === contextRouteFromUrl;\n  }\n\n  private getMatchingContextRoute(url: string): ViewContext {\n    const viewContexts = Object.values(ViewContext);\n    // replace all :id placeholders with a regex matcher for a number\n    const regexMatchers = viewContexts.map(context => `^/${context.replace(/:id/g, '([0-9]+)')}$`);\n    const matchingRegexContext = regexMatchers.find(context => new RegExp(context).test(url));\n    return matchingRegexContext ? viewContexts[regexMatchers.indexOf(matchingRegexContext)] : null;\n  }\n}\n"]}

package/esm2022/core/router/view-context.service.mjs

@@ -1,23 +1,66 @@
-import { ApplicationService, InventoryService, TenantService, UserService } from '@c8y/client';
+import { AlarmService, ApplicationService, InventoryService, TenantService, UserService } from '@c8y/client';
 import { ViewContext } from './router.model';
 export class ViewContextServices {
     static { this.services = {
-        [ViewContext.Device]: InventoryService,
-        [ViewContext.Group]: InventoryService,
-        [ViewContext.User]: UserService,
-        [ViewContext.Application]: ApplicationService,
-        [ViewContext.Microservice]: ApplicationService,
-        [ViewContext.Extension]: ApplicationService,
-        [ViewContext.Feature]: ApplicationService,
-        [ViewContext.SubscribedApplications]: ApplicationService,
-        [ViewContext.Tenant]: TenantService,
-        [ViewContext.Report]: InventoryService,
-        [ViewContext.Service]: InventoryService,
-        [ViewContext.DatapointLibrary]: InventoryService,
-        [ViewContext.Simulators]: InventoryService
+        [ViewContext.Device]: { service: InventoryService, path: ViewContext.Device, autoRoute: true },
+        [ViewContext.Group]: { service: InventoryService, path: ViewContext.Group, autoRoute: true },
+        [ViewContext.User]: { service: UserService, path: ViewContext.User, autoRoute: true },
+        [ViewContext.Application]: {
+            service: ApplicationService,
+            path: ViewContext.Application,
+            autoRoute: true
+        },
+        [ViewContext.Microservice]: {
+            service: ApplicationService,
+            path: ViewContext.Microservice,
+            autoRoute: true
+        },
+        [ViewContext.Extension]: {
+            service: ApplicationService,
+            path: ViewContext.Extension,
+            autoRoute: true
+        },
+        [ViewContext.Feature]: {
+            service: ApplicationService,
+            path: ViewContext.Feature,
+            autoRoute: true
+        },
+        [ViewContext.SubscribedApplications]: {
+            service: ApplicationService,
+            path: ViewContext.SubscribedApplications,
+            autoRoute: true
+        },
+        [ViewContext.Tenant]: { service: TenantService, path: ViewContext.Tenant, autoRoute: true },
+        [ViewContext.Report]: { service: InventoryService, path: ViewContext.Report, autoRoute: true },
+        [ViewContext.Service]: {
+            service: InventoryService,
+            path: ViewContext.Service,
+            autoRoute: true
+        },
+        [ViewContext.DatapointLibrary]: {
+            service: InventoryService,
+            path: ViewContext.DatapointLibrary,
+            autoRoute: true
+        },
+        [ViewContext.Simulators]: {
+            service: InventoryService,
+            path: ViewContext.Simulators,
+            autoRoute: true
+        },
+        [ViewContext.Alarms]: { service: AlarmService, path: ':id', autoRoute: false },
+        [ViewContext.GroupAlarms]: { service: AlarmService, path: ':id', autoRoute: false },
+        [ViewContext.DeviceAlarms]: { service: AlarmService, path: ':id', autoRoute: false },
+        [ViewContext.SimulatorsAlarms]: { service: AlarmService, path: ':id', autoRoute: false },
+        [ViewContext.ServiceAlarms]: { service: AlarmService, path: ':id', autoRoute: false }
     }; }
     static contextToService(context) {
-        return ViewContextServices.services[context];
+        return ViewContextServices.services[context]?.service;
+    }
+    static getPath(context) {
+        return ViewContextServices.services[context]?.path;
+    }
+    static isAutoRoute(context) {
+        return ViewContextServices.services[context]?.autoRoute;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/fesm2022/c8y-ngx-components-alarms-cockpit.mjs

@@ -1,19 +1,10 @@
 import * as i0 from '@angular/core';
 import { NgModule } from '@angular/core';
 import { NavigatorNode, gettext, ViewContext } from '@c8y/ngx-components';
-import { AlarmEmptyComponent, AlarmInfoComponent, AlarmsModule, ALARMS_PATH, AlarmsComponent } from '@c8y/ngx-components/alarms';
+import * as i1 from '@c8y/ngx-components/alarms';
+import { AlarmsModule, ALARMS_PATH, AlarmsComponent, getChildrenForViewContext, getViewContextRoutes } from '@c8y/ngx-components/alarms';
 
 function alarmsCockpitRouteAndNodeConfig() {
-    const children = [
-        {
-            path: '',
-            component: AlarmEmptyComponent
-        },
-        {
-            path: ':id',
-            component: AlarmInfoComponent
-        }
-    ];
     return AlarmsModule.config({
         rootNavigatorNode: new NavigatorNode({
             label: gettext('Alarms'),
@@ -29,7 +20,7 @@ function alarmsCockpitRouteAndNodeConfig() {
                 path: ALARMS_PATH,
                 component: AlarmsComponent,
                 data: { title: true },
-                children
+                children: getChildrenForViewContext(ViewContext.Alarms)
             },
             {
                 context: ViewContext.Group,
@@ -39,7 +30,7 @@ function alarmsCockpitRouteAndNodeConfig() {
                 label: gettext('Alarms'),
                 component: AlarmsComponent,
                 featureId: 'alarms',
-                children
+                children: getChildrenForViewContext(ViewContext.GroupAlarms)
             },
             {
                 context: ViewContext.Device,
@@ -49,14 +40,19 @@ function alarmsCockpitRouteAndNodeConfig() {
                 label: gettext('Alarms'),
                 component: AlarmsComponent,
                 featureId: 'alarms',
-                children
-            }
+                children: getChildrenForViewContext(ViewContext.DeviceAlarms)
+            },
+            ...getViewContextRoutes([
+                ViewContext.Alarms,
+                ViewContext.GroupAlarms,
+                ViewContext.DeviceAlarms
+            ])
         ]
     });
 }
 class CockpitAlarmsModule extends AlarmsModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: CockpitAlarmsModule, deps: null, target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.9", ngImport: i0, type: CockpitAlarmsModule, imports: [AlarmsModule] }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.9", ngImport: i0, type: CockpitAlarmsModule, imports: [i1.AlarmsModule] }); }
     static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: CockpitAlarmsModule, imports: [alarmsCockpitRouteAndNodeConfig()] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: CockpitAlarmsModule, decorators: [{

package/fesm2022/c8y-ngx-components-alarms-cockpit.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"c8y-ngx-components-alarms-cockpit.mjs","sources":["../../alarms/cockpit/index.ts","../../alarms/cockpit/c8y-ngx-components-alarms-cockpit.ts"],"sourcesContent":["import { ModuleWithProviders, NgModule } from '@angular/core';\nimport { NavigatorNode, ViewContext, gettext } from '@c8y/ngx-components';\nimport {\n  ALARMS_PATH,\n  AlarmEmptyComponent,\n  AlarmInfoComponent,\n  AlarmsComponent,\n  AlarmsModule\n} from '@c8y/ngx-components/alarms';\n\nexport function alarmsCockpitRouteAndNodeConfig(): ModuleWithProviders<AlarmsModule> {\n  const children = [\n    {\n      path: '',\n      component: AlarmEmptyComponent\n    },\n    {\n      path: ':id',\n      component: AlarmInfoComponent\n    }\n  ];\n  return AlarmsModule.config({\n    rootNavigatorNode: new NavigatorNode({\n      label: gettext('Alarms'),\n      icon: 'bell',\n      priority: 1000,\n      path: `/${ALARMS_PATH}`,\n      featureId: 'alarms',\n      parent: '',\n      routerLinkExact: false\n    }),\n    route: [\n      {\n        path: ALARMS_PATH,\n        component: AlarmsComponent,\n        data: { title: true },\n        children\n      },\n      {\n        context: ViewContext.Group,\n        path: ALARMS_PATH,\n        priority: 800,\n        icon: 'bell',\n        label: gettext('Alarms'),\n        component: AlarmsComponent,\n        featureId: 'alarms',\n        children\n      },\n      {\n        context: ViewContext.Device,\n        path: ALARMS_PATH,\n        priority: 800,\n        icon: 'bell',\n        label: gettext('Alarms'),\n        component: AlarmsComponent,\n        featureId: 'alarms',\n        children\n      }\n    ]\n  });\n}\n\n@NgModule({\n  imports: [alarmsCockpitRouteAndNodeConfig()]\n})\nexport class CockpitAlarmsModule extends AlarmsModule {}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;;;;SAUgB,+BAA+B,GAAA;AAC7C,IAAA,MAAM,QAAQ,GAAG;AACf,QAAA;AACE,YAAA,IAAI,EAAE,EAAE;AACR,YAAA,SAAS,EAAE,mBAAmB;AAC/B,SAAA;AACD,QAAA;AACE,YAAA,IAAI,EAAE,KAAK;AACX,YAAA,SAAS,EAAE,kBAAkB;AAC9B,SAAA;KACF,CAAC;IACF,OAAO,YAAY,CAAC,MAAM,CAAC;QACzB,iBAAiB,EAAE,IAAI,aAAa,CAAC;AACnC,YAAA,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC;AACxB,YAAA,IAAI,EAAE,MAAM;AACZ,YAAA,QAAQ,EAAE,IAAI;YACd,IAAI,EAAE,CAAI,CAAA,EAAA,WAAW,CAAE,CAAA;AACvB,YAAA,SAAS,EAAE,QAAQ;AACnB,YAAA,MAAM,EAAE,EAAE;AACV,YAAA,eAAe,EAAE,KAAK;SACvB,CAAC;AACF,QAAA,KAAK,EAAE;AACL,YAAA;AACE,gBAAA,IAAI,EAAE,WAAW;AACjB,gBAAA,SAAS,EAAE,eAAe;AAC1B,gBAAA,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE;gBACrB,QAAQ;AACT,aAAA;AACD,YAAA;gBACE,OAAO,EAAE,WAAW,CAAC,KAAK;AAC1B,gBAAA,IAAI,EAAE,WAAW;AACjB,gBAAA,QAAQ,EAAE,GAAG;AACb,gBAAA,IAAI,EAAE,MAAM;AACZ,gBAAA,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC;AACxB,gBAAA,SAAS,EAAE,eAAe;AAC1B,gBAAA,SAAS,EAAE,QAAQ;gBACnB,QAAQ;AACT,aAAA;AACD,YAAA;gBACE,OAAO,EAAE,WAAW,CAAC,MAAM;AAC3B,gBAAA,IAAI,EAAE,WAAW;AACjB,gBAAA,QAAQ,EAAE,GAAG;AACb,gBAAA,IAAI,EAAE,MAAM;AACZ,gBAAA,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC;AACxB,gBAAA,SAAS,EAAE,eAAe;AAC1B,gBAAA,SAAS,EAAE,QAAQ;gBACnB,QAAQ;AACT,aAAA;AACF,SAAA;AACF,KAAA,CAAC,CAAC;AACL,CAAC;AAKK,MAAO,mBAAoB,SAAQ,YAAY,CAAA;8GAAxC,mBAAmB,EAAA,IAAA,EAAA,IAAA,EAAA,MAAA,EAAA,EAAA,CAAA,eAAA,CAAA,QAAA,EAAA,CAAA,CAAA,EAAA;+GAAnB,mBAAmB,EAAA,OAAA,EAAA,CAAA,YAAA,CAAA,EAAA,CAAA,CAAA,EAAA;+GAAnB,mBAAmB,EAAA,OAAA,EAAA,CAFpB,+BAA+B,EAAE,CAAA,EAAA,CAAA,CAAA,EAAA;;2FAEhC,mBAAmB,EAAA,UAAA,EAAA,CAAA;kBAH/B,QAAQ;AAAC,YAAA,IAAA,EAAA,CAAA;AACR,oBAAA,OAAO,EAAE,CAAC,+BAA+B,EAAE,CAAC;AAC7C,iBAAA,CAAA;;;AChED;;AAEG;;;;"}
+{"version":3,"file":"c8y-ngx-components-alarms-cockpit.mjs","sources":["../../alarms/cockpit/index.ts","../../alarms/cockpit/c8y-ngx-components-alarms-cockpit.ts"],"sourcesContent":["import { ModuleWithProviders, NgModule } from '@angular/core';\nimport { NavigatorNode, ViewContext, gettext } from '@c8y/ngx-components';\nimport {\n  ALARMS_PATH,\n  AlarmsComponent,\n  AlarmsModule,\n  getChildrenForViewContext,\n  getViewContextRoutes\n} from '@c8y/ngx-components/alarms';\n\nexport function alarmsCockpitRouteAndNodeConfig(): ModuleWithProviders<AlarmsModule> {\n  return AlarmsModule.config({\n    rootNavigatorNode: new NavigatorNode({\n      label: gettext('Alarms'),\n      icon: 'bell',\n      priority: 1000,\n      path: `/${ALARMS_PATH}`,\n      featureId: 'alarms',\n      parent: '',\n      routerLinkExact: false\n    }),\n    route: [\n      {\n        path: ALARMS_PATH,\n        component: AlarmsComponent,\n        data: { title: true },\n        children: getChildrenForViewContext(ViewContext.Alarms)\n      },\n      {\n        context: ViewContext.Group,\n        path: ALARMS_PATH,\n        priority: 800,\n        icon: 'bell',\n        label: gettext('Alarms'),\n        component: AlarmsComponent,\n        featureId: 'alarms',\n        children: getChildrenForViewContext(ViewContext.GroupAlarms)\n      },\n      {\n        context: ViewContext.Device,\n        path: ALARMS_PATH,\n        priority: 800,\n        icon: 'bell',\n        label: gettext('Alarms'),\n        component: AlarmsComponent,\n        featureId: 'alarms',\n        children: getChildrenForViewContext(ViewContext.DeviceAlarms)\n      },\n      ...getViewContextRoutes([\n        ViewContext.Alarms,\n        ViewContext.GroupAlarms,\n        ViewContext.DeviceAlarms\n      ])\n    ]\n  });\n}\n\n@NgModule({\n  imports: [alarmsCockpitRouteAndNodeConfig()]\n})\nexport class CockpitAlarmsModule extends AlarmsModule {}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;;;;;SAUgB,+BAA+B,GAAA;IAC7C,OAAO,YAAY,CAAC,MAAM,CAAC;QACzB,iBAAiB,EAAE,IAAI,aAAa,CAAC;AACnC,YAAA,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC;AACxB,YAAA,IAAI,EAAE,MAAM;AACZ,YAAA,QAAQ,EAAE,IAAI;YACd,IAAI,EAAE,CAAI,CAAA,EAAA,WAAW,CAAE,CAAA;AACvB,YAAA,SAAS,EAAE,QAAQ;AACnB,YAAA,MAAM,EAAE,EAAE;AACV,YAAA,eAAe,EAAE,KAAK;SACvB,CAAC;AACF,QAAA,KAAK,EAAE;AACL,YAAA;AACE,gBAAA,IAAI,EAAE,WAAW;AACjB,gBAAA,SAAS,EAAE,eAAe;AAC1B,gBAAA,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE;AACrB,gBAAA,QAAQ,EAAE,yBAAyB,CAAC,WAAW,CAAC,MAAM,CAAC;AACxD,aAAA;AACD,YAAA;gBACE,OAAO,EAAE,WAAW,CAAC,KAAK;AAC1B,gBAAA,IAAI,EAAE,WAAW;AACjB,gBAAA,QAAQ,EAAE,GAAG;AACb,gBAAA,IAAI,EAAE,MAAM;AACZ,gBAAA,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC;AACxB,gBAAA,SAAS,EAAE,eAAe;AAC1B,gBAAA,SAAS,EAAE,QAAQ;AACnB,gBAAA,QAAQ,EAAE,yBAAyB,CAAC,WAAW,CAAC,WAAW,CAAC;AAC7D,aAAA;AACD,YAAA;gBACE,OAAO,EAAE,WAAW,CAAC,MAAM;AAC3B,gBAAA,IAAI,EAAE,WAAW;AACjB,gBAAA,QAAQ,EAAE,GAAG;AACb,gBAAA,IAAI,EAAE,MAAM;AACZ,gBAAA,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC;AACxB,gBAAA,SAAS,EAAE,eAAe;AAC1B,gBAAA,SAAS,EAAE,QAAQ;AACnB,gBAAA,QAAQ,EAAE,yBAAyB,CAAC,WAAW,CAAC,YAAY,CAAC;AAC9D,aAAA;AACD,YAAA,GAAG,oBAAoB,CAAC;AACtB,gBAAA,WAAW,CAAC,MAAM;AAClB,gBAAA,WAAW,CAAC,WAAW;AACvB,gBAAA,WAAW,CAAC,YAAY;aACzB,CAAC;AACH,SAAA;AACF,KAAA,CAAC,CAAC;AACL,CAAC;AAKK,MAAO,mBAAoB,SAAQ,YAAY,CAAA;8GAAxC,mBAAmB,EAAA,IAAA,EAAA,IAAA,EAAA,MAAA,EAAA,EAAA,CAAA,eAAA,CAAA,QAAA,EAAA,CAAA,CAAA,EAAA;+GAAnB,mBAAmB,EAAA,OAAA,EAAA,CAAA,EAAA,CAAA,YAAA,CAAA,EAAA,CAAA,CAAA,EAAA;+GAAnB,mBAAmB,EAAA,OAAA,EAAA,CAFpB,+BAA+B,EAAE,CAAA,EAAA,CAAA,CAAA,EAAA;;2FAEhC,mBAAmB,EAAA,UAAA,EAAA,CAAA;kBAH/B,QAAQ;AAAC,YAAA,IAAA,EAAA,CAAA;AACR,oBAAA,OAAO,EAAE,CAAC,+BAA+B,EAAE,CAAC;AAC7C,iBAAA,CAAA;;;AC3DD;;AAEG;;;;"}

package/fesm2022/c8y-ngx-components-alarms-devicemanagement.mjs

@@ -1,17 +1,7 @@
 import { NavigatorNode, gettext, ViewContext } from '@c8y/ngx-components';
-import { AlarmEmptyComponent, AlarmInfoComponent, AlarmsModule, ALARMS_PATH, AlarmsComponent } from '@c8y/ngx-components/alarms';
+import { AlarmsModule, ALARMS_PATH, AlarmsComponent, getChildrenForViewContext, getViewContextRoutes } from '@c8y/ngx-components/alarms';
 
 function alarmsDeviceManagementRouteAndNodeConfig() {
-    const children = [
-        {
-            path: '',
-            component: AlarmEmptyComponent
-        },
-        {
-            path: ':id',
-            component: AlarmInfoComponent
-        }
-    ];
     return AlarmsModule.config({
         rootNavigatorNode: new NavigatorNode({
             label: gettext('Alarms'),
@@ -27,7 +17,7 @@ function alarmsDeviceManagementRouteAndNodeConfig() {
                 path: ALARMS_PATH,
                 component: AlarmsComponent,
                 data: { title: true },
-                children
+                children: getChildrenForViewContext(ViewContext.Alarms)
             },
             {
                 context: ViewContext.Group,
@@ -37,7 +27,7 @@ function alarmsDeviceManagementRouteAndNodeConfig() {
                 label: gettext('Alarms'),
                 component: AlarmsComponent,
                 featureId: 'alarms',
-                children
+                children: getChildrenForViewContext(ViewContext.GroupAlarms)
             },
             {
                 context: ViewContext.Device,
@@ -47,7 +37,7 @@ function alarmsDeviceManagementRouteAndNodeConfig() {
                 label: gettext('Alarms'),
                 component: AlarmsComponent,
                 featureId: 'alarms',
-                children
+                children: getChildrenForViewContext(ViewContext.DeviceAlarms)
             },
             {
                 context: ViewContext.Service,
@@ -57,7 +47,7 @@ function alarmsDeviceManagementRouteAndNodeConfig() {
                 label: gettext('Alarms'),
                 component: AlarmsComponent,
                 featureId: 'alarms',
-                children
+                children: getChildrenForViewContext(ViewContext.ServiceAlarms)
             },
             {
                 context: ViewContext.Simulators,
@@ -67,8 +57,15 @@ function alarmsDeviceManagementRouteAndNodeConfig() {
                 label: gettext('Alarms'),
                 component: AlarmsComponent,
                 featureId: 'alarms',
-                children
-            }
+                children: getChildrenForViewContext(ViewContext.SimulatorsAlarms)
+            },
+            ...getViewContextRoutes([
+                ViewContext.Alarms,
+                ViewContext.GroupAlarms,
+                ViewContext.DeviceAlarms,
+                ViewContext.ServiceAlarms,
+                ViewContext.SimulatorsAlarms
+            ])
         ]
     });
 }

package/fesm2022/c8y-ngx-components-alarms-devicemanagement.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"c8y-ngx-components-alarms-devicemanagement.mjs","sources":["../../alarms/devicemanagement/index.ts","../../alarms/devicemanagement/c8y-ngx-components-alarms-devicemanagement.ts"],"sourcesContent":["import { ModuleWithProviders } from '@angular/core';\nimport { NavigatorNode, ViewContext, gettext } from '@c8y/ngx-components';\nimport {\n  ALARMS_PATH,\n  AlarmEmptyComponent,\n  AlarmInfoComponent,\n  AlarmsComponent,\n  AlarmsModule\n} from '@c8y/ngx-components/alarms';\n\nexport function alarmsDeviceManagementRouteAndNodeConfig(): ModuleWithProviders<AlarmsModule> {\n  const children = [\n    {\n      path: '',\n      component: AlarmEmptyComponent\n    },\n    {\n      path: ':id',\n      component: AlarmInfoComponent\n    }\n  ];\n  return AlarmsModule.config({\n    rootNavigatorNode: new NavigatorNode({\n      label: gettext('Alarms'),\n      icon: 'bell',\n      priority: 3000,\n      path: `/${ALARMS_PATH}`,\n      featureId: 'alarms',\n      parent: 'Overviews',\n      routerLinkExact: false\n    }),\n    route: [\n      {\n        path: ALARMS_PATH,\n        component: AlarmsComponent,\n        data: { title: true },\n        children\n      },\n      {\n        context: ViewContext.Group,\n        path: ALARMS_PATH,\n        priority: 800,\n        icon: 'bell',\n        label: gettext('Alarms'),\n        component: AlarmsComponent,\n        featureId: 'alarms',\n        children\n      },\n      {\n        context: ViewContext.Device,\n        path: ALARMS_PATH,\n        priority: 800,\n        icon: 'bell',\n        label: gettext('Alarms'),\n        component: AlarmsComponent,\n        featureId: 'alarms',\n        children\n      },\n      {\n        context: ViewContext.Service,\n        path: ALARMS_PATH,\n        priority: 800,\n        icon: 'bell',\n        label: gettext('Alarms'),\n        component: AlarmsComponent,\n        featureId: 'alarms',\n        children\n      },\n      {\n        context: ViewContext.Simulators,\n        path: ALARMS_PATH,\n        priority: -2,\n        icon: 'bell',\n        label: gettext('Alarms'),\n        component: AlarmsComponent,\n        featureId: 'alarms',\n        children\n      }\n    ]\n  });\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;;SAUgB,wCAAwC,GAAA;AACtD,IAAA,MAAM,QAAQ,GAAG;AACf,QAAA;AACE,YAAA,IAAI,EAAE,EAAE;AACR,YAAA,SAAS,EAAE,mBAAmB;AAC/B,SAAA;AACD,QAAA;AACE,YAAA,IAAI,EAAE,KAAK;AACX,YAAA,SAAS,EAAE,kBAAkB;AAC9B,SAAA;KACF,CAAC;IACF,OAAO,YAAY,CAAC,MAAM,CAAC;QACzB,iBAAiB,EAAE,IAAI,aAAa,CAAC;AACnC,YAAA,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC;AACxB,YAAA,IAAI,EAAE,MAAM;AACZ,YAAA,QAAQ,EAAE,IAAI;YACd,IAAI,EAAE,CAAI,CAAA,EAAA,WAAW,CAAE,CAAA;AACvB,YAAA,SAAS,EAAE,QAAQ;AACnB,YAAA,MAAM,EAAE,WAAW;AACnB,YAAA,eAAe,EAAE,KAAK;SACvB,CAAC;AACF,QAAA,KAAK,EAAE;AACL,YAAA;AACE,gBAAA,IAAI,EAAE,WAAW;AACjB,gBAAA,SAAS,EAAE,eAAe;AAC1B,gBAAA,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE;gBACrB,QAAQ;AACT,aAAA;AACD,YAAA;gBACE,OAAO,EAAE,WAAW,CAAC,KAAK;AAC1B,gBAAA,IAAI,EAAE,WAAW;AACjB,gBAAA,QAAQ,EAAE,GAAG;AACb,gBAAA,IAAI,EAAE,MAAM;AACZ,gBAAA,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC;AACxB,gBAAA,SAAS,EAAE,eAAe;AAC1B,gBAAA,SAAS,EAAE,QAAQ;gBACnB,QAAQ;AACT,aAAA;AACD,YAAA;gBACE,OAAO,EAAE,WAAW,CAAC,MAAM;AAC3B,gBAAA,IAAI,EAAE,WAAW;AACjB,gBAAA,QAAQ,EAAE,GAAG;AACb,gBAAA,IAAI,EAAE,MAAM;AACZ,gBAAA,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC;AACxB,gBAAA,SAAS,EAAE,eAAe;AAC1B,gBAAA,SAAS,EAAE,QAAQ;gBACnB,QAAQ;AACT,aAAA;AACD,YAAA;gBACE,OAAO,EAAE,WAAW,CAAC,OAAO;AAC5B,gBAAA,IAAI,EAAE,WAAW;AACjB,gBAAA,QAAQ,EAAE,GAAG;AACb,gBAAA,IAAI,EAAE,MAAM;AACZ,gBAAA,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC;AACxB,gBAAA,SAAS,EAAE,eAAe;AAC1B,gBAAA,SAAS,EAAE,QAAQ;gBACnB,QAAQ;AACT,aAAA;AACD,YAAA;gBACE,OAAO,EAAE,WAAW,CAAC,UAAU;AAC/B,gBAAA,IAAI,EAAE,WAAW;gBACjB,QAAQ,EAAE,CAAC,CAAC;AACZ,gBAAA,IAAI,EAAE,MAAM;AACZ,gBAAA,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC;AACxB,gBAAA,SAAS,EAAE,eAAe;AAC1B,gBAAA,SAAS,EAAE,QAAQ;gBACnB,QAAQ;AACT,aAAA;AACF,SAAA;AACF,KAAA,CAAC,CAAC;AACL;;AChFA;;AAEG;;;;"}
+{"version":3,"file":"c8y-ngx-components-alarms-devicemanagement.mjs","sources":["../../alarms/devicemanagement/index.ts","../../alarms/devicemanagement/c8y-ngx-components-alarms-devicemanagement.ts"],"sourcesContent":["import { ModuleWithProviders } from '@angular/core';\nimport { NavigatorNode, ViewContext, gettext } from '@c8y/ngx-components';\nimport {\n  ALARMS_PATH,\n  AlarmsComponent,\n  AlarmsModule,\n  getChildrenForViewContext,\n  getViewContextRoutes\n} from '@c8y/ngx-components/alarms';\n\nexport function alarmsDeviceManagementRouteAndNodeConfig(): ModuleWithProviders<AlarmsModule> {\n  return AlarmsModule.config({\n    rootNavigatorNode: new NavigatorNode({\n      label: gettext('Alarms'),\n      icon: 'bell',\n      priority: 3000,\n      path: `/${ALARMS_PATH}`,\n      featureId: 'alarms',\n      parent: 'Overviews',\n      routerLinkExact: false\n    }),\n    route: [\n      {\n        path: ALARMS_PATH,\n        component: AlarmsComponent,\n        data: { title: true },\n        children: getChildrenForViewContext(ViewContext.Alarms)\n      },\n      {\n        context: ViewContext.Group,\n        path: ALARMS_PATH,\n        priority: 800,\n        icon: 'bell',\n        label: gettext('Alarms'),\n        component: AlarmsComponent,\n        featureId: 'alarms',\n        children: getChildrenForViewContext(ViewContext.GroupAlarms)\n      },\n      {\n        context: ViewContext.Device,\n        path: ALARMS_PATH,\n        priority: 800,\n        icon: 'bell',\n        label: gettext('Alarms'),\n        component: AlarmsComponent,\n        featureId: 'alarms',\n        children: getChildrenForViewContext(ViewContext.DeviceAlarms)\n      },\n      {\n        context: ViewContext.Service,\n        path: ALARMS_PATH,\n        priority: 800,\n        icon: 'bell',\n        label: gettext('Alarms'),\n        component: AlarmsComponent,\n        featureId: 'alarms',\n        children: getChildrenForViewContext(ViewContext.ServiceAlarms)\n      },\n      {\n        context: ViewContext.Simulators,\n        path: ALARMS_PATH,\n        priority: -2,\n        icon: 'bell',\n        label: gettext('Alarms'),\n        component: AlarmsComponent,\n        featureId: 'alarms',\n        children: getChildrenForViewContext(ViewContext.SimulatorsAlarms)\n      },\n      ...getViewContextRoutes([\n        ViewContext.Alarms,\n        ViewContext.GroupAlarms,\n        ViewContext.DeviceAlarms,\n        ViewContext.ServiceAlarms,\n        ViewContext.SimulatorsAlarms\n      ])\n    ]\n  });\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;;SAUgB,wCAAwC,GAAA;IACtD,OAAO,YAAY,CAAC,MAAM,CAAC;QACzB,iBAAiB,EAAE,IAAI,aAAa,CAAC;AACnC,YAAA,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC;AACxB,YAAA,IAAI,EAAE,MAAM;AACZ,YAAA,QAAQ,EAAE,IAAI;YACd,IAAI,EAAE,CAAI,CAAA,EAAA,WAAW,CAAE,CAAA;AACvB,YAAA,SAAS,EAAE,QAAQ;AACnB,YAAA,MAAM,EAAE,WAAW;AACnB,YAAA,eAAe,EAAE,KAAK;SACvB,CAAC;AACF,QAAA,KAAK,EAAE;AACL,YAAA;AACE,gBAAA,IAAI,EAAE,WAAW;AACjB,gBAAA,SAAS,EAAE,eAAe;AAC1B,gBAAA,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE;AACrB,gBAAA,QAAQ,EAAE,yBAAyB,CAAC,WAAW,CAAC,MAAM,CAAC;AACxD,aAAA;AACD,YAAA;gBACE,OAAO,EAAE,WAAW,CAAC,KAAK;AAC1B,gBAAA,IAAI,EAAE,WAAW;AACjB,gBAAA,QAAQ,EAAE,GAAG;AACb,gBAAA,IAAI,EAAE,MAAM;AACZ,gBAAA,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC;AACxB,gBAAA,SAAS,EAAE,eAAe;AAC1B,gBAAA,SAAS,EAAE,QAAQ;AACnB,gBAAA,QAAQ,EAAE,yBAAyB,CAAC,WAAW,CAAC,WAAW,CAAC;AAC7D,aAAA;AACD,YAAA;gBACE,OAAO,EAAE,WAAW,CAAC,MAAM;AAC3B,gBAAA,IAAI,EAAE,WAAW;AACjB,gBAAA,QAAQ,EAAE,GAAG;AACb,gBAAA,IAAI,EAAE,MAAM;AACZ,gBAAA,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC;AACxB,gBAAA,SAAS,EAAE,eAAe;AAC1B,gBAAA,SAAS,EAAE,QAAQ;AACnB,gBAAA,QAAQ,EAAE,yBAAyB,CAAC,WAAW,CAAC,YAAY,CAAC;AAC9D,aAAA;AACD,YAAA;gBACE,OAAO,EAAE,WAAW,CAAC,OAAO;AAC5B,gBAAA,IAAI,EAAE,WAAW;AACjB,gBAAA,QAAQ,EAAE,GAAG;AACb,gBAAA,IAAI,EAAE,MAAM;AACZ,gBAAA,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC;AACxB,gBAAA,SAAS,EAAE,eAAe;AAC1B,gBAAA,SAAS,EAAE,QAAQ;AACnB,gBAAA,QAAQ,EAAE,yBAAyB,CAAC,WAAW,CAAC,aAAa,CAAC;AAC/D,aAAA;AACD,YAAA;gBACE,OAAO,EAAE,WAAW,CAAC,UAAU;AAC/B,gBAAA,IAAI,EAAE,WAAW;gBACjB,QAAQ,EAAE,CAAC,CAAC;AACZ,gBAAA,IAAI,EAAE,MAAM;AACZ,gBAAA,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC;AACxB,gBAAA,SAAS,EAAE,eAAe;AAC1B,gBAAA,SAAS,EAAE,QAAQ;AACnB,gBAAA,QAAQ,EAAE,yBAAyB,CAAC,WAAW,CAAC,gBAAgB,CAAC;AAClE,aAAA;AACD,YAAA,GAAG,oBAAoB,CAAC;AACtB,gBAAA,WAAW,CAAC,MAAM;AAClB,gBAAA,WAAW,CAAC,WAAW;AACvB,gBAAA,WAAW,CAAC,YAAY;AACxB,gBAAA,WAAW,CAAC,aAAa;AACzB,gBAAA,WAAW,CAAC,gBAAgB;aAC7B,CAAC;AACH,SAAA;AACF,KAAA,CAAC,CAAC;AACL;;AC7EA;;AAEG;;;;"}