@scion/workbench 17.0.0-beta.9 → 18.0.0-beta.10

package/esm2022/lib/routing/routing.util.mjs

@@ -0,0 +1,215 @@
+/*
+ * Copyright (c) 2018-2024 Swiss Federal Railways
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+import { ActivationEnd, ActivationStart, ChildrenOutletContexts, NavigationStart, PRIMARY_OUTLET, Router } from '@angular/router';
+import { DIALOG_ID_PREFIX, MESSAGE_BOX_ID_PREFIX, POPUP_ID_PREFIX, VIEW_ID_PREFIX } from '../workbench.constants';
+import { inject } from '@angular/core';
+import { EMPTY, iif, of, pairwise, race, switchMap } from 'rxjs';
+import { filter, map, startWith, take } from 'rxjs/operators';
+/**
+ * Provides utility functions for router operations.
+ */
+export const Routing = {
+    /**
+     * Converts given URL segments into an array of commands that can be passed to the Angular router for navigation.
+     */
+    segmentsToCommands: (segments) => {
+        const commands = new Array();
+        segments.forEach(segment => {
+            if (segment.path) {
+                commands.push(segment.path);
+            }
+            if (segment.parameters && Object.keys(segment.parameters).length) {
+                commands.push(segment.parameters);
+            }
+        });
+        return commands;
+    },
+    /**
+     * Constructs URL segments from given commands, resolving any relative navigational symbols.
+     *
+     * This function must be called inside an injection context.
+     */
+    commandsToSegments: (commands, options) => {
+        // Ignore `relativeTo` for absolute commands.
+        const isAbsolutePath = typeof commands[0] === 'string' && commands[0].startsWith('/');
+        const relativeTo = isAbsolutePath ? null : (options?.relativeTo || null);
+        // Angular throws the error 'NG04003: Root segment cannot have matrix parameters' when passing an empty path command
+        // followed by a matrix params object, but not when passing matrix params as the first command. For consistency, when
+        // passing matrix params as the first command, we prepend an empty path for Angular to throw the same error.
+        if (typeof commands[0] === 'object' && (!relativeTo || Routing.hasEmptyPathFromRoot(relativeTo))) {
+            commands = ['', ...commands];
+        }
+        const urlTree = inject(Router).createUrlTree(commands, { relativeTo });
+        return urlTree.root.children[relativeTo?.pathFromRoot[1]?.outlet ?? PRIMARY_OUTLET]?.segments ?? [];
+    },
+    /**
+     * Parses the given path and matrix parameters into an array of commands that can be passed to the Angular router for navigation.
+     *
+     * This function must be called inside an injection context.
+     */
+    pathToCommands: (path) => {
+        const urlTree = inject(Router).parseUrl(path);
+        const segments = urlTree.root.children[PRIMARY_OUTLET]?.segments;
+        if (!segments) {
+            throw Error(`[RouterError] Cannot match any routes for path '${path}'.`);
+        }
+        return Routing.segmentsToCommands(segments);
+    },
+    /**
+     * Resolves the effective (=leaf) {@link ActivatedRoute} activated in a router outlet.
+     *
+     * Depending on the route hierarchy, when navigating to a child route with component-less parent routes, the route of an outlet may not be the effectively activated child route.
+     */
+    resolveEffectiveRoute: (route) => {
+        return route.firstChild ? Routing.resolveEffectiveRoute(route.firstChild) : route;
+    },
+    /**
+     * Resolves the effective (=leaf) {@link OutletContext} of a router outlet.
+     *
+     * Depending on the route hierarchy, when navigating to a child route with component-less parent routes, the context of an outlet may not be the effectively activated child context.
+     */
+    resolveEffectiveOutletContext: (outletContext) => {
+        const childOutletContext = outletContext?.children.getContext(PRIMARY_OUTLET);
+        return childOutletContext ? Routing.resolveEffectiveOutletContext(childOutletContext) : outletContext;
+    },
+    /**
+     * Looks for requested data on given route, or its parent route(s) if not found.
+     */
+    lookupRouteData: (activatedRoute, dataKey) => {
+        return activatedRoute.pathFromRoot.reduceRight((resolvedData, route) => resolvedData ?? route.data[dataKey], undefined);
+    },
+    /**
+     * Tests if the given outlet matches the format of the view outlet.
+     */
+    isViewOutlet: (outlet) => {
+        return outlet?.startsWith(VIEW_ID_PREFIX) ?? false;
+    },
+    /**
+     * Tests if the given outlet matches the format of a popup outlet.
+     */
+    isPopupOutlet: (outlet) => {
+        return outlet?.startsWith(POPUP_ID_PREFIX) ?? false;
+    },
+    /**
+     * Tests if the given outlet matches the format of a dialog outlet.
+     */
+    isDialogOutlet: (outlet) => {
+        return outlet?.startsWith(DIALOG_ID_PREFIX) ?? false;
+    },
+    /**
+     * Tests if the given outlet matches the format of a message box outlet.
+     */
+    isMessageBoxOutlet: (outlet) => {
+        return outlet?.startsWith(MESSAGE_BOX_ID_PREFIX) ?? false;
+    },
+    /**
+     * Reads view outlets from given URL.
+     *
+     * A view outlet contains the URL segments of a view contained in the workbench layout.
+     */
+    parseViewOutlets: (url) => {
+        const viewOutlets = new Map();
+        Object.entries(url.root.children).forEach(([outlet, segmentGroup]) => {
+            if (Routing.isViewOutlet(outlet)) {
+                viewOutlets.set(outlet, segmentGroup.segments);
+            }
+        });
+        return viewOutlets;
+    },
+    /**
+     * Tests if given route has an empty path from root.
+     */
+    hasEmptyPathFromRoot(route) {
+        return route.snapshot.pathFromRoot.flatMap(route => route.url).filter(segment => segment.path.length).length === 0;
+    },
+    /**
+     * Observes the route activation for the specified outlet.
+     *
+     * The observable emits after the previous component has been destroyed (if any) but before constructing the new component.
+     *
+     * Options to control when to emit:
+     * - `routeChange`: Emit only when navigating the outlet to a different route.
+     * - `routeOrParamChange`: Emit when navigating the outlet to a different route or changing params (named path params or matrix params).
+     * - `always`: Emit at every navigation, even if the outlet is not the target of the navigation.
+     *
+     * This method must be called within an injection context.
+     *
+     * Note: Listening for route activations/deactivations on the router outlet alone is insufficient for nested routes, as the outlet does not report
+     * activations/deactivations of child routes.
+     *
+     * @param outlet - Specifies the outlet to observe.
+     * @param options - Controls when to emit the observable.
+     * @return An observable emitting a tuple of the previous and current route snapshots.
+     */
+    activatedRoute$(outlet, options) {
+        const router = inject(Router);
+        const childrenOutletContexts = inject(ChildrenOutletContexts);
+        const onNavigationStart$ = router.events.pipe(filterNavigationStart());
+        const onActivationStart$ = router.events.pipe(filterActivationStart(), filterByOutlet(outlet));
+        const onActivationEnd$ = router.events.pipe(filterActivationEnd(), filterByOutlet(outlet));
+        // On each navigation start (`NavigationStart`), subscribe to the outlet's `ActivationStart` event and then to the outlet's deactivate event,
+        // enabling continuing of the execution chain after the previous component has been destroyed.
+        //
+        // If `emitOn` is set to `always`, additionally subscribe to the outlet's `ActivationEnd` event, since no activation (`ActivationStart`) occurs if
+        // the outlet is not navigated (e.g., navigating another outlet or updating query params).
+        //
+        // Note that Angular activates nested routes from parent to child and deactivates them from child to parent, triggering multiple `ActivationStart`
+        // and `ActivationEnd` events. For the outlet, the latest `ActivationStart` and the first `ActivationEnd` events are relevant.
+        //
+        // `ActivationStart` is emitted only if the outlet is actually navigated (route or parameter change), whereas `ActivationEnd` is always emitted.
+        //
+        // If a navigation is currently in progress, start immediately, allowing subscriptions even during ongoing navigation, such as after the navigation
+        // has started.
+        return iif(() => !router.getCurrentNavigation(), onNavigationStart$, onNavigationStart$.pipe(startWith(undefined)))
+            .pipe(
+        // Subscribe to the outlet's `ActivationStart` (and also `ActivationEnd` if the `emitOn` option is set to `always`).
+        switchMap(() => options.emitOn === 'always' ? race(onActivationStart$, onActivationEnd$.pipe(take(1))) : onActivationStart$), map(event => event.snapshot), startWith(null), // initialize pairwise operator
+        pairwise(), switchMap(([previous, current]) => {
+            // If the route hasn't changed and `emitOn` is set to `always` or `routeOrParamChange`, emit immediately since no deactivation will occur.
+            const routeChanged = previous?.routeConfig !== current.routeConfig;
+            if (!routeChanged) {
+                return options.emitOn === 'routeChange' ? EMPTY : of([previous, current]);
+            }
+            // If there's no previously activated component in the outlet, emit immediately since no deactivation will occur.
+            const outletContext = Routing.resolveEffectiveOutletContext(childrenOutletContexts.getContext(outlet));
+            if (!outletContext?.outlet?.isActivated) {
+                return of([previous, current]);
+            }
+            // Delay emission until the previously activated component has been destroyed by subscribing to the outlet's deactivation event.
+            // Nested routes activate from parent to child, canceling "deactivation" subscriptions of parent outlets, so only the deactivation of the actual outlet is emitted.
+            return outletContext.outlet.deactivateEvents.pipe(map(() => [previous, current]));
+        }));
+        /**
+         * Filters {@link NavigationStart} router events.
+         */
+        function filterNavigationStart() {
+            return filter((event) => event instanceof NavigationStart);
+        }
+        /**
+         * Filters {@link ActivationStart} router events.
+         */
+        function filterActivationStart() {
+            return filter((event) => event instanceof ActivationStart);
+        }
+        /**
+         * Filters {@link ActivationEnd} router events. This event is emitted for each outlet regardless of whether it has been navigated or not.
+         */
+        function filterActivationEnd() {
+            return filter((event) => event instanceof ActivationEnd);
+        }
+        /**
+         * Filters router events for the specified outlet.
+         */
+        function filterByOutlet(outlet) {
+            return filter(event => event.snapshot.pathFromRoot[1]?.outlet === outlet);
+        }
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"routing.util.js","sourceRoot":"","sources":["../../../../../../projects/scion/workbench/src/lib/routing/routing.util.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2018-2024 Swiss Federal Railways\n *\n * This program and the accompanying materials are made\n * available under the terms of the Eclipse Public License 2.0\n * which is available at https://www.eclipse.org/legal/epl-2.0/\n *\n * SPDX-License-Identifier: EPL-2.0\n */\n\nimport {ActivatedRoute, ActivatedRouteSnapshot, ActivationEnd, ActivationStart, ChildrenOutletContexts, Event, NavigationStart, OutletContext, PRIMARY_OUTLET, Router, RouterEvent, UrlSegment, UrlTree} from '@angular/router';\nimport {Commands} from '../routing/routing.model';\nimport {DIALOG_ID_PREFIX, MESSAGE_BOX_ID_PREFIX, POPUP_ID_PREFIX, VIEW_ID_PREFIX} from '../workbench.constants';\nimport {inject} from '@angular/core';\nimport {ViewId} from '../view/workbench-view.model';\nimport {EMPTY, iif, MonoTypeOperatorFunction, Observable, of, OperatorFunction, pairwise, race, switchMap} from 'rxjs';\nimport {filter, map, startWith, take} from 'rxjs/operators';\n\n/**\n * Provides utility functions for router operations.\n */\nexport const Routing = {\n\n  /**\n   * Converts given URL segments into an array of commands that can be passed to the Angular router for navigation.\n   */\n  segmentsToCommands: (segments: UrlSegment[]): Commands => {\n    const commands = new Array<any>();\n\n    segments.forEach(segment => {\n      if (segment.path) {\n        commands.push(segment.path);\n      }\n      if (segment.parameters && Object.keys(segment.parameters).length) {\n        commands.push(segment.parameters);\n      }\n    });\n\n    return commands;\n  },\n\n  /**\n   * Constructs URL segments from given commands, resolving any relative navigational symbols.\n   *\n   * This function must be called inside an injection context.\n   */\n  commandsToSegments: (commands: Commands, options?: {relativeTo?: ActivatedRoute | null}): UrlSegment[] => {\n    // Ignore `relativeTo` for absolute commands.\n    const isAbsolutePath = typeof commands[0] === 'string' && commands[0].startsWith('/');\n    const relativeTo = isAbsolutePath ? null : (options?.relativeTo || null);\n\n    // Angular throws the error 'NG04003: Root segment cannot have matrix parameters' when passing an empty path command\n    // followed by a matrix params object, but not when passing matrix params as the first command. For consistency, when\n    // passing matrix params as the first command, we prepend an empty path for Angular to throw the same error.\n    if (typeof commands[0] === 'object' && (!relativeTo || Routing.hasEmptyPathFromRoot(relativeTo))) {\n      commands = ['', ...commands];\n    }\n\n    const urlTree = inject(Router).createUrlTree(commands, {relativeTo});\n    return urlTree.root.children[relativeTo?.pathFromRoot[1]?.outlet ?? PRIMARY_OUTLET]?.segments ?? [];\n  },\n\n  /**\n   * Parses the given path and matrix parameters into an array of commands that can be passed to the Angular router for navigation.\n   *\n   * This function must be called inside an injection context.\n   */\n  pathToCommands: (path: string): Commands => {\n    const urlTree = inject(Router).parseUrl(path);\n    const segments = urlTree.root.children[PRIMARY_OUTLET]?.segments;\n    if (!segments) {\n      throw Error(`[RouterError] Cannot match any routes for path '${path}'.`);\n    }\n    return Routing.segmentsToCommands(segments);\n  },\n\n  /**\n   * Resolves the effective (=leaf) {@link ActivatedRoute} activated in a router outlet.\n   *\n   * Depending on the route hierarchy, when navigating to a child route with component-less parent routes, the route of an outlet may not be the effectively activated child route.\n   */\n  resolveEffectiveRoute: (route: ActivatedRoute): ActivatedRoute => {\n    return route.firstChild ? Routing.resolveEffectiveRoute(route.firstChild) : route;\n  },\n\n  /**\n   * Resolves the effective (=leaf) {@link OutletContext} of a router outlet.\n   *\n   * Depending on the route hierarchy, when navigating to a child route with component-less parent routes, the context of an outlet may not be the effectively activated child context.\n   */\n  resolveEffectiveOutletContext: (outletContext: OutletContext | null): OutletContext | null => {\n    const childOutletContext = outletContext?.children.getContext(PRIMARY_OUTLET);\n    return childOutletContext ? Routing.resolveEffectiveOutletContext(childOutletContext) : outletContext;\n  },\n\n  /**\n   * Looks for requested data on given route, or its parent route(s) if not found.\n   */\n  lookupRouteData: <T>(activatedRoute: ActivatedRouteSnapshot, dataKey: string): T | undefined => {\n    return activatedRoute.pathFromRoot.reduceRight((resolvedData, route) => resolvedData ?? route.data[dataKey], undefined);\n  },\n\n  /**\n   * Tests if the given outlet matches the format of the view outlet.\n   */\n  isViewOutlet: (outlet: string | undefined | null): outlet is ViewId => {\n    return outlet?.startsWith(VIEW_ID_PREFIX) ?? false;\n  },\n\n  /**\n   * Tests if the given outlet matches the format of a popup outlet.\n   */\n  isPopupOutlet: (outlet: string | undefined | null): outlet is `popup.${string}` => {\n    return outlet?.startsWith(POPUP_ID_PREFIX) ?? false;\n  },\n\n  /**\n   * Tests if the given outlet matches the format of a dialog outlet.\n   */\n  isDialogOutlet: (outlet: string | undefined | null): outlet is `dialog.${string}` => {\n    return outlet?.startsWith(DIALOG_ID_PREFIX) ?? false;\n  },\n\n  /**\n   * Tests if the given outlet matches the format of a message box outlet.\n   */\n  isMessageBoxOutlet: (outlet: string | undefined | null): outlet is `messagebox.${string}` => {\n    return outlet?.startsWith(MESSAGE_BOX_ID_PREFIX) ?? false;\n  },\n\n  /**\n   * Reads view outlets from given URL.\n   *\n   * A view outlet contains the URL segments of a view contained in the workbench layout.\n   */\n  parseViewOutlets: (url: UrlTree): Map<ViewId, UrlSegment[]> => {\n    const viewOutlets = new Map<ViewId, UrlSegment[]>();\n    Object.entries(url.root.children).forEach(([outlet, segmentGroup]) => {\n      if (Routing.isViewOutlet(outlet)) {\n        viewOutlets.set(outlet, segmentGroup.segments);\n      }\n    });\n    return viewOutlets;\n  },\n\n  /**\n   * Tests if given route has an empty path from root.\n   */\n  hasEmptyPathFromRoot(route: ActivatedRoute): boolean {\n    return route.snapshot.pathFromRoot.flatMap(route => route.url).filter(segment => segment.path.length).length === 0;\n  },\n\n  /**\n   * Observes the route activation for the specified outlet.\n   *\n   * The observable emits after the previous component has been destroyed (if any) but before constructing the new component.\n   *\n   * Options to control when to emit:\n   * - `routeChange`: Emit only when navigating the outlet to a different route.\n   * - `routeOrParamChange`: Emit when navigating the outlet to a different route or changing params (named path params or matrix params).\n   * - `always`: Emit at every navigation, even if the outlet is not the target of the navigation.\n   *\n   * This method must be called within an injection context.\n   *\n   * Note: Listening for route activations/deactivations on the router outlet alone is insufficient for nested routes, as the outlet does not report\n   * activations/deactivations of child routes.\n   *\n   * @param outlet - Specifies the outlet to observe.\n   * @param options - Controls when to emit the observable.\n   * @return An observable emitting a tuple of the previous and current route snapshots.\n   */\n  activatedRoute$(outlet: string, options: {emitOn: 'routeChange' | 'routeOrParamChange' | 'always'}): Observable<[ActivatedRouteSnapshot | null, ActivatedRouteSnapshot]> {\n    const router = inject(Router);\n    const childrenOutletContexts = inject(ChildrenOutletContexts);\n\n    const onNavigationStart$ = router.events.pipe(filterNavigationStart());\n    const onActivationStart$ = router.events.pipe(filterActivationStart(), filterByOutlet(outlet));\n    const onActivationEnd$ = router.events.pipe(filterActivationEnd(), filterByOutlet(outlet));\n\n    // On each navigation start (`NavigationStart`), subscribe to the outlet's `ActivationStart` event and then to the outlet's deactivate event,\n    // enabling continuing of the execution chain after the previous component has been destroyed.\n    //\n    // If `emitOn` is set to `always`, additionally subscribe to the outlet's `ActivationEnd` event, since no activation (`ActivationStart`) occurs if\n    // the outlet is not navigated (e.g., navigating another outlet or updating query params).\n    //\n    // Note that Angular activates nested routes from parent to child and deactivates them from child to parent, triggering multiple `ActivationStart`\n    // and `ActivationEnd` events. For the outlet, the latest `ActivationStart` and the first `ActivationEnd` events are relevant.\n    //\n    // `ActivationStart` is emitted only if the outlet is actually navigated (route or parameter change), whereas `ActivationEnd` is always emitted.\n    //\n    // If a navigation is currently in progress, start immediately, allowing subscriptions even during ongoing navigation, such as after the navigation\n    // has started.\n    return iif(() => !router.getCurrentNavigation(), onNavigationStart$, onNavigationStart$.pipe(startWith(undefined)))\n      .pipe(\n        // Subscribe to the outlet's `ActivationStart` (and also `ActivationEnd` if the `emitOn` option is set to `always`).\n        switchMap(() => options.emitOn === 'always' ? race(onActivationStart$, onActivationEnd$.pipe(take(1))) : onActivationStart$),\n        map(event => event.snapshot),\n        startWith(null as unknown as ActivatedRouteSnapshot), // initialize pairwise operator\n        pairwise(),\n        switchMap(([previous, current]: [ActivatedRouteSnapshot | null, ActivatedRouteSnapshot]): Observable<[ActivatedRouteSnapshot | null, ActivatedRouteSnapshot]> => {\n          // If the route hasn't changed and `emitOn` is set to `always` or `routeOrParamChange`, emit immediately since no deactivation will occur.\n          const routeChanged = previous?.routeConfig !== current.routeConfig;\n          if (!routeChanged) {\n            return options.emitOn === 'routeChange' ? EMPTY : of([previous, current]);\n          }\n\n          // If there's no previously activated component in the outlet, emit immediately since no deactivation will occur.\n          const outletContext = Routing.resolveEffectiveOutletContext(childrenOutletContexts.getContext(outlet));\n          if (!outletContext?.outlet?.isActivated) {\n            return of([previous, current]);\n          }\n\n          // Delay emission until the previously activated component has been destroyed by subscribing to the outlet's deactivation event.\n          // Nested routes activate from parent to child, canceling \"deactivation\" subscriptions of parent outlets, so only the deactivation of the actual outlet is emitted.\n          return outletContext.outlet.deactivateEvents!.pipe(map(() => [previous, current]));\n        }),\n      );\n\n    /**\n     * Filters {@link NavigationStart} router events.\n     */\n    function filterNavigationStart(): OperatorFunction<Event | RouterEvent, NavigationStart> {\n      return filter((event: Event | RouterEvent): event is NavigationStart => event instanceof NavigationStart);\n    }\n\n    /**\n     * Filters {@link ActivationStart} router events.\n     */\n    function filterActivationStart(): OperatorFunction<Event | RouterEvent, ActivationStart> {\n      return filter((event: Event | RouterEvent): event is ActivationStart => event instanceof ActivationStart);\n    }\n\n    /**\n     * Filters {@link ActivationEnd} router events. This event is emitted for each outlet regardless of whether it has been navigated or not.\n     */\n    function filterActivationEnd(): OperatorFunction<Event | RouterEvent, ActivationEnd> {\n      return filter((event: Event | RouterEvent): event is ActivationEnd => event instanceof ActivationEnd);\n    }\n\n    /**\n     * Filters router events for the specified outlet.\n     */\n    function filterByOutlet<T extends ActivationStart | ActivationEnd>(outlet: string): MonoTypeOperatorFunction<T> {\n      return filter(event => event.snapshot.pathFromRoot[1]?.outlet === outlet);\n    }\n  },\n} as const;\n\n"]}

package/esm2022/lib/routing/url-segment-matcher.mjs

@@ -43,4 +43,4 @@ export class UrlSegmentMatcher {
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/routing/workbench-auxiliary-route-installer.service.mjs

@@ -0,0 +1,110 @@
+/*
+* Copyright (c) 2018-2024 Swiss Federal Railways
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* SPDX-License-Identifier: EPL-2.0
+*/
+import { Component, Injectable, InjectionToken } from '@angular/core';
+import { PRIMARY_OUTLET } from '@angular/router';
+import PageNotFoundComponent from '../page-not-found/page-not-found.component';
+import { WorkbenchRouteData } from './workbench-route-data';
+import { ɵEmptyOutletComponent } from './empty-outlet/empty-outlet.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../workbench-config";
+import * as i2 from "@angular/router";
+/**
+ * Facilitates the registration of auxiliary routes of top-level routes.
+ */
+export class WorkbenchAuxiliaryRouteInstaller {
+    constructor(_workbenchConfig, _router) {
+        this._workbenchConfig = _workbenchConfig;
+        this._router = _router;
+    }
+    /**
+     * Registers an auxiliary route for each top-level route, enabling navigation in the specified router outlet(s).
+     *
+     * @param outlets - Specifies outlets for which to create auxiliary routes.
+     * @param config - Specifies the config of the auxiliary routes.
+     */
+    registerAuxiliaryRoutes(outlets, config = {}) {
+        if (!outlets.length) {
+            return [];
+        }
+        const registeredRoutes = outlets.map(outlet => ({
+            path: '',
+            outlet,
+            providers: [{ provide: WORKBENCH_AUXILIARY_ROUTE_OUTLET, useValue: outlet }],
+            component: ɵEmptyOutletComponent,
+            children: [
+                ...this._router.config
+                    .filter(route => !route.outlet || route.outlet === PRIMARY_OUTLET)
+                    .map(route => ({ ...route, data: { ...route.data, [WorkbenchRouteData.ɵoutlet]: outlet } })),
+                // Register wildcard route to display "Page Not Found".
+                {
+                    path: '**',
+                    loadComponent: () => this._workbenchConfig.pageNotFoundComponent ?? PageNotFoundComponent,
+                    data: { [WorkbenchRouteData.title]: 'Page Not Found', [WorkbenchRouteData.cssClass]: 'e2e-page-not-found' },
+                    canMatch: config.canMatchNotFoundPage,
+                },
+                // Register wildcard route to display blank page.
+                {
+                    path: '**',
+                    component: BlankComponent,
+                },
+            ],
+        }));
+        this.replaceRouterConfig([
+            ...this._router.config,
+            ...registeredRoutes,
+        ]);
+        return registeredRoutes;
+    }
+    /**
+     * Unregisters auxiliary routes for the given outlet.
+     */
+    unregisterAuxiliaryRoutes(outlets) {
+        const outletsToRemove = new Set(outlets);
+        function shouldRemoveRoute(route) {
+            return !!route.outlet && outletsToRemove.has(route.outlet);
+        }
+        this.replaceRouterConfig(this._router.config.filter(route => !shouldRemoveRoute(route)));
+    }
+    /**
+     * Replaces the router configuration to install or uninstall auxiliary routes.
+     */
+    replaceRouterConfig(config) {
+        // Note:
+        //   - Do not use Router.resetConfig(...) which would destroy any currently routed component because copying all routes
+        //   - Do not assign the router a new Routes object (Router.config = ...) to allow resolution of routes added during `NavigationStart` (since Angular 7.x)
+        //     (because Angular uses a reference to the Routes object during route navigation)
+        const newRoutes = [...config];
+        this._router.config.splice(0, this._router.config.length, ...newRoutes);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: WorkbenchAuxiliaryRouteInstaller, deps: [{ token: i1.WorkbenchConfig }, { token: i2.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: WorkbenchAuxiliaryRouteInstaller, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: WorkbenchAuxiliaryRouteInstaller, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.WorkbenchConfig }, { type: i2.Router }] });
+/**
+ * DI token to inject the outlet name of a workbench auxiliary route.
+ *
+ * Can be injected in a `CanMatch` guard to obtain a reference to the workbench element.
+ */
+export const WORKBENCH_AUXILIARY_ROUTE_OUTLET = new InjectionToken('ɵWORKBENCH_AUXILIARY_ROUTE_OUTLET');
+/**
+ * Component to display if the outlet has not yet been navigated or no navigation information is available.
+ */
+export class BlankComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: BlankComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.0.2", type: BlankComponent, isStandalone: true, selector: "wb-blank", ngImport: i0, template: '', isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: BlankComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'wb-blank', template: '', standalone: true }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workbench-auxiliary-route-installer.service.js","sourceRoot":"","sources":["../../../../../../projects/scion/workbench/src/lib/routing/workbench-auxiliary-route-installer.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n* Copyright (c) 2018-2024 Swiss Federal Railways\n*\n* This program and the accompanying materials are made\n* available under the terms of the Eclipse Public License 2.0\n* which is available at https://www.eclipse.org/legal/epl-2.0/\n*\n* SPDX-License-Identifier: EPL-2.0\n*/\n\nimport {Component, Injectable, InjectionToken} from '@angular/core';\nimport {CanMatchFn, PRIMARY_OUTLET, Route, Router, Routes} from '@angular/router';\nimport {WorkbenchConfig} from '../workbench-config';\nimport PageNotFoundComponent from '../page-not-found/page-not-found.component';\nimport {WorkbenchRouteData} from './workbench-route-data';\nimport {ɵEmptyOutletComponent} from './empty-outlet/empty-outlet.component';\n\n/**\n * Facilitates the registration of auxiliary routes of top-level routes.\n */\n@Injectable({providedIn: 'root'})\nexport class WorkbenchAuxiliaryRouteInstaller {\n\n  constructor(private _workbenchConfig: WorkbenchConfig, private _router: Router) {\n  }\n\n  /**\n   * Registers an auxiliary route for each top-level route, enabling navigation in the specified router outlet(s).\n   *\n   * @param outlets - Specifies outlets for which to create auxiliary routes.\n   * @param config - Specifies the config of the auxiliary routes.\n   */\n  public registerAuxiliaryRoutes(outlets: string[], config: AuxiliaryRouteConfig = {}): Routes {\n    if (!outlets.length) {\n      return [];\n    }\n\n    const registeredRoutes = outlets.map(outlet => ({\n      path: '',\n      outlet,\n      providers: [{provide: WORKBENCH_AUXILIARY_ROUTE_OUTLET, useValue: outlet}],\n      component: ɵEmptyOutletComponent,\n      children: [\n        ...this._router.config\n          .filter(route => !route.outlet || route.outlet === PRIMARY_OUTLET)\n          .map(route => ({...route, data: {...route.data, [WorkbenchRouteData.ɵoutlet]: outlet}})),\n        // Register wildcard route to display \"Page Not Found\".\n        {\n          path: '**',\n          loadComponent: () => this._workbenchConfig.pageNotFoundComponent ?? PageNotFoundComponent,\n          data: {[WorkbenchRouteData.title]: 'Page Not Found', [WorkbenchRouteData.cssClass]: 'e2e-page-not-found'},\n          canMatch: config.canMatchNotFoundPage,\n        },\n        // Register wildcard route to display blank page.\n        {\n          path: '**',\n          component: BlankComponent,\n        },\n      ],\n    } satisfies Route));\n\n    this.replaceRouterConfig([\n      ...this._router.config,\n      ...registeredRoutes,\n    ]);\n\n    return registeredRoutes;\n  }\n\n  /**\n   * Unregisters auxiliary routes for the given outlet.\n   */\n  public unregisterAuxiliaryRoutes(outlets: string[]): void {\n    const outletsToRemove = new Set<string>(outlets);\n\n    function shouldRemoveRoute(route: Route): boolean {\n      return !!route.outlet && outletsToRemove.has(route.outlet);\n    }\n\n    this.replaceRouterConfig(this._router.config.filter(route => !shouldRemoveRoute(route)));\n  }\n\n  /**\n   * Replaces the router configuration to install or uninstall auxiliary routes.\n   */\n  private replaceRouterConfig(config: Routes): void {\n    // Note:\n    //   - Do not use Router.resetConfig(...) which would destroy any currently routed component because copying all routes\n    //   - Do not assign the router a new Routes object (Router.config = ...) to allow resolution of routes added during `NavigationStart` (since Angular 7.x)\n    //     (because Angular uses a reference to the Routes object during route navigation)\n    const newRoutes: Routes = [...config];\n    this._router.config.splice(0, this._router.config.length, ...newRoutes);\n  }\n}\n\n/**\n * Configures auxiliary routes.\n */\nexport interface AuxiliaryRouteConfig {\n  /**\n   * Specifies \"CanMatch\" guard(s) to install on the wildcard route (`**`),\n   * selected by the router if no route matches the requested URL.\n   */\n  canMatchNotFoundPage?: Array<CanMatchFn>;\n}\n\n/**\n * DI token to inject the outlet name of a workbench auxiliary route.\n *\n * Can be injected in a `CanMatch` guard to obtain a reference to the workbench element.\n */\nexport const WORKBENCH_AUXILIARY_ROUTE_OUTLET = new InjectionToken<string>('ɵWORKBENCH_AUXILIARY_ROUTE_OUTLET');\n\n/**\n * Component to display if the outlet has not yet been navigated or no navigation information is available.\n */\n@Component({selector: 'wb-blank', template: '', standalone: true})\nexport class BlankComponent {\n}\n"]}

package/esm2022/lib/routing/workbench-dialog-differ.mjs

@@ -8,7 +8,7 @@
  * SPDX-License-Identifier: EPL-2.0
  */
 import { Injectable } from '@angular/core';
-import { RouterUtils } from './router.util';
+import { Routing } from './routing.util';
 import * as i0 from "@angular/core";
 /**
  * Stateful differ for finding added/removed dialogs.
@@ -21,13 +21,13 @@ export class WorkbenchDialogDiffer {
      * Computes differences in the URL since last time {@link WorkbenchDialogDiffer#diff} was invoked.
      */
     diff(urlTree) {
-        const dialogOutlets = Object.keys(urlTree.root.children).filter(RouterUtils.isDialogOutlet);
+        const dialogOutlets = Object.keys(urlTree.root.children).filter(Routing.isDialogOutlet);
         return new WorkbenchDialogDiff(this._dialogDiffer.diff(dialogOutlets));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: WorkbenchDialogDiffer, deps: [{ token: i0.IterableDiffers }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: WorkbenchDialogDiffer, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: WorkbenchDialogDiffer, deps: [{ token: i0.IterableDiffers }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: WorkbenchDialogDiffer, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: WorkbenchDialogDiffer, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: WorkbenchDialogDiffer, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [{ type: i0.IterableDiffers }] });
@@ -48,4 +48,4 @@ export class WorkbenchDialogDiff {
             .join(', ')}`;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/routing/workbench-layout-differ.mjs

@@ -8,7 +8,6 @@
  * SPDX-License-Identifier: EPL-2.0
  */
 import { Injectable } from '@angular/core';
-import { RouterUtils } from './router.util';
 import * as i0 from "@angular/core";
 /**
  * Stateful differ for finding added/removed workbench layout elements.
@@ -21,24 +20,18 @@ export class WorkbenchLayoutDiffer {
     /**
      * Computes differences in the layout since last time {@link WorkbenchLayoutDiffer#diff} was invoked.
      */
-    diff(workbenchLayout, urlTree) {
+    diff(workbenchLayout) {
         const parts = workbenchLayout?.parts().map(part => part.id);
-        // Create view diff based on views in the layout plus outlets in the URL, required because the layout is unavailable during initial navigation.
-        // Otherwise, the initial navigation for a URL with outlets of views contained in the workbench grid would fail as their view routes would be
-        // registered too late.
-        const views = new Set([
-            ...RouterUtils.parseViewOutlets(urlTree).keys(),
-            ...(workbenchLayout?.views().map(view => view.id) ?? []),
-        ]);
+        const views = workbenchLayout?.views().map(view => view.id);
         return new WorkbenchLayoutDiff({
             parts: this._partsDiffer.diff(parts),
             views: this._viewsDiffer.diff(views),
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: WorkbenchLayoutDiffer, deps: [{ token: i0.IterableDiffers }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: WorkbenchLayoutDiffer, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: WorkbenchLayoutDiffer, deps: [{ token: i0.IterableDiffers }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: WorkbenchLayoutDiffer, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: WorkbenchLayoutDiffer, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: WorkbenchLayoutDiffer, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [{ type: i0.IterableDiffers }] });
@@ -65,4 +58,4 @@ export class WorkbenchLayoutDiff {
             .join(', ')}`;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ya2JlbmNoLWxheW91dC1kaWZmZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zY2lvbi93b3JrYmVuY2gvc3JjL2xpYi9yb3V0aW5nL3dvcmtiZW5jaC1sYXlvdXQtZGlmZmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7OztHQVFHO0FBRUgsT0FBTyxFQUFDLFVBQVUsRUFBbUQsTUFBTSxlQUFlLENBQUM7O0FBSTNGOztHQUVHO0FBRUgsTUFBTSxPQUFPLHFCQUFxQjtJQUtoQyxZQUFZLE9BQXdCO1FBQ2xDLElBQUksQ0FBQyxZQUFZLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQyxNQUFNLEVBQVUsQ0FBQztRQUN0RCxJQUFJLENBQUMsWUFBWSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLENBQUMsTUFBTSxFQUFVLENBQUM7SUFDeEQsQ0FBQztJQUVEOztPQUVHO0lBQ0ksSUFBSSxDQUFDLGVBQXdDO1FBQ2xELE1BQU0sS0FBSyxHQUFHLGVBQWUsRUFBRSxLQUFLLEVBQUUsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLENBQUM7UUFDNUQsTUFBTSxLQUFLLEdBQUcsZUFBZSxFQUFFLEtBQUssRUFBRSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUM1RCxPQUFPLElBQUksbUJBQW1CLENBQUM7WUFDN0IsS0FBSyxFQUFFLElBQUksQ0FBQyxZQUFZLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQztZQUNwQyxLQUFLLEVBQUUsSUFBSSxDQUFDLFlBQVksQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDO1NBQ3JDLENBQUMsQ0FBQztJQUNMLENBQUM7OEdBcEJVLHFCQUFxQjtrSEFBckIscUJBQXFCLGNBRFQsTUFBTTs7MkZBQ2xCLHFCQUFxQjtrQkFEakMsVUFBVTttQkFBQyxFQUFDLFVBQVUsRUFBRSxNQUFNLEVBQUM7O0FBd0JoQzs7R0FFRztBQUNILE1BQU0sT0FBTyxtQkFBbUI7SUFROUIsWUFBWSxPQUF1RjtRQU5uRixlQUFVLEdBQUcsSUFBSSxLQUFLLEVBQVUsQ0FBQztRQUNqQyxpQkFBWSxHQUFHLElBQUksS0FBSyxFQUFVLENBQUM7UUFFbkMsZUFBVSxHQUFHLElBQUksS0FBSyxFQUFVLENBQUM7UUFDakMsaUJBQVksR0FBRyxJQUFJLEtBQUssRUFBVSxDQUFDO1FBR2pELE9BQU8sQ0FBQyxLQUFLLEVBQUUsZ0JBQWdCLENBQUMsQ0FBQyxFQUFDLElBQUksRUFBQyxFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO1FBQ3hFLE9BQU8sQ0FBQyxLQUFLLEVBQUUsa0JBQWtCLENBQUMsQ0FBQyxFQUFDLElBQUksRUFBQyxFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsWUFBWSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO1FBRTVFLE9BQU8sQ0FBQyxLQUFLLEVBQUUsZ0JBQWdCLENBQUMsQ0FBQyxFQUFDLElBQUksRUFBQyxFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO1FBQ3hFLE9BQU8sQ0FBQyxLQUFLLEVBQUUsa0JBQWtCLENBQUMsQ0FBQyxFQUFDLElBQUksRUFBQyxFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsWUFBWSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO0lBQzlFLENBQUM7SUFFTSxRQUFRO1FBQ2IsT0FBTyxHQUFHLElBQUksS0FBSyxFQUFVO2FBQzFCLE1BQU0sQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsZUFBZSxJQUFJLENBQUMsVUFBVSxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQzthQUN2RSxNQUFNLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLGlCQUFpQixJQUFJLENBQUMsWUFBWSxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQzthQUM3RSxNQUFNLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLGVBQWUsSUFBSSxDQUFDLFVBQVUsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7YUFDdkUsTUFBTSxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxpQkFBaUIsSUFBSSxDQUFDLFlBQVksR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7YUFDN0UsSUFBSSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUM7SUFDbEIsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIENvcHlyaWdodCAoYykgMjAxOC0yMDIzIFN3aXNzIEZlZGVyYWwgUmFpbHdheXNcbiAqXG4gKiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIGFyZSBtYWRlXG4gKiBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIDIuMFxuICogd2hpY2ggaXMgYXZhaWxhYmxlIGF0IGh0dHBzOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC0yLjAvXG4gKlxuICogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEVQTC0yLjBcbiAqL1xuXG5pbXBvcnQge0luamVjdGFibGUsIEl0ZXJhYmxlQ2hhbmdlcywgSXRlcmFibGVEaWZmZXIsIEl0ZXJhYmxlRGlmZmVyc30gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge8m1V29ya2JlbmNoTGF5b3V0fSBmcm9tICcuLi9sYXlvdXQvybV3b3JrYmVuY2gtbGF5b3V0JztcbmltcG9ydCB7Vmlld0lkfSBmcm9tICcuLi92aWV3L3dvcmtiZW5jaC12aWV3Lm1vZGVsJztcblxuLyoqXG4gKiBTdGF0ZWZ1bCBkaWZmZXIgZm9yIGZpbmRpbmcgYWRkZWQvcmVtb3ZlZCB3b3JrYmVuY2ggbGF5b3V0IGVsZW1lbnRzLlxuICovXG5ASW5qZWN0YWJsZSh7cHJvdmlkZWRJbjogJ3Jvb3QnfSlcbmV4cG9ydCBjbGFzcyBXb3JrYmVuY2hMYXlvdXREaWZmZXIge1xuXG4gIHByaXZhdGUgX3BhcnRzRGlmZmVyOiBJdGVyYWJsZURpZmZlcjxzdHJpbmc+O1xuICBwcml2YXRlIF92aWV3c0RpZmZlcjogSXRlcmFibGVEaWZmZXI8Vmlld0lkPjtcblxuICBjb25zdHJ1Y3RvcihkaWZmZXJzOiBJdGVyYWJsZURpZmZlcnMpIHtcbiAgICB0aGlzLl9wYXJ0c0RpZmZlciA9IGRpZmZlcnMuZmluZChbXSkuY3JlYXRlPHN0cmluZz4oKTtcbiAgICB0aGlzLl92aWV3c0RpZmZlciA9IGRpZmZlcnMuZmluZChbXSkuY3JlYXRlPFZpZXdJZD4oKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBDb21wdXRlcyBkaWZmZXJlbmNlcyBpbiB0aGUgbGF5b3V0IHNpbmNlIGxhc3QgdGltZSB7QGxpbmsgV29ya2JlbmNoTGF5b3V0RGlmZmVyI2RpZmZ9IHdhcyBpbnZva2VkLlxuICAgKi9cbiAgcHVibGljIGRpZmYod29ya2JlbmNoTGF5b3V0OiDJtVdvcmtiZW5jaExheW91dCB8IG51bGwpOiBXb3JrYmVuY2hMYXlvdXREaWZmIHtcbiAgICBjb25zdCBwYXJ0cyA9IHdvcmtiZW5jaExheW91dD8ucGFydHMoKS5tYXAocGFydCA9PiBwYXJ0LmlkKTtcbiAgICBjb25zdCB2aWV3cyA9IHdvcmtiZW5jaExheW91dD8udmlld3MoKS5tYXAodmlldyA9PiB2aWV3LmlkKTtcbiAgICByZXR1cm4gbmV3IFdvcmtiZW5jaExheW91dERpZmYoe1xuICAgICAgcGFydHM6IHRoaXMuX3BhcnRzRGlmZmVyLmRpZmYocGFydHMpLFxuICAgICAgdmlld3M6IHRoaXMuX3ZpZXdzRGlmZmVyLmRpZmYodmlld3MpLFxuICAgIH0pO1xuICB9XG59XG5cbi8qKlxuICogTGlzdHMgdGhlIGxheW91dCBlbGVtZW50cyBhZGRlZC9yZW1vdmVkIGluIHRoZSBjdXJyZW50IG5hdmlnYXRpb24uXG4gKi9cbmV4cG9ydCBjbGFzcyBXb3JrYmVuY2hMYXlvdXREaWZmIHtcblxuICBwdWJsaWMgcmVhZG9ubHkgYWRkZWRQYXJ0cyA9IG5ldyBBcnJheTxzdHJpbmc+KCk7XG4gIHB1YmxpYyByZWFkb25seSByZW1vdmVkUGFydHMgPSBuZXcgQXJyYXk8c3RyaW5nPigpO1xuXG4gIHB1YmxpYyByZWFkb25seSBhZGRlZFZpZXdzID0gbmV3IEFycmF5PFZpZXdJZD4oKTtcbiAgcHVibGljIHJlYWRvbmx5IHJlbW92ZWRWaWV3cyA9IG5ldyBBcnJheTxWaWV3SWQ+KCk7XG5cbiAgY29uc3RydWN0b3IoY2hhbmdlczoge3BhcnRzOiBJdGVyYWJsZUNoYW5nZXM8c3RyaW5nPiB8IG51bGw7IHZpZXdzOiBJdGVyYWJsZUNoYW5nZXM8Vmlld0lkPiB8IG51bGx9KSB7XG4gICAgY2hhbmdlcy5wYXJ0cz8uZm9yRWFjaEFkZGVkSXRlbSgoe2l0ZW19KSA9PiB0aGlzLmFkZGVkUGFydHMucHVzaChpdGVtKSk7XG4gICAgY2hhbmdlcy5wYXJ0cz8uZm9yRWFjaFJlbW92ZWRJdGVtKCh7aXRlbX0pID0+IHRoaXMucmVtb3ZlZFBhcnRzLnB1c2goaXRlbSkpO1xuXG4gICAgY2hhbmdlcy52aWV3cz8uZm9yRWFjaEFkZGVkSXRlbSgoe2l0ZW19KSA9PiB0aGlzLmFkZGVkVmlld3MucHVzaChpdGVtKSk7XG4gICAgY2hhbmdlcy52aWV3cz8uZm9yRWFjaFJlbW92ZWRJdGVtKCh7aXRlbX0pID0+IHRoaXMucmVtb3ZlZFZpZXdzLnB1c2goaXRlbSkpO1xuICB9XG5cbiAgcHVibGljIHRvU3RyaW5nKCk6IHN0cmluZyB7XG4gICAgcmV0dXJuIGAke25ldyBBcnJheTxzdHJpbmc+KClcbiAgICAgIC5jb25jYXQodGhpcy5hZGRlZFBhcnRzLmxlbmd0aCA/IGBhZGRlZFBhcnRzPVske3RoaXMuYWRkZWRQYXJ0c31dYCA6IFtdKVxuICAgICAgLmNvbmNhdCh0aGlzLnJlbW92ZWRQYXJ0cy5sZW5ndGggPyBgcmVtb3ZlZFBhcnRzPVske3RoaXMucmVtb3ZlZFBhcnRzfV1gIDogW10pXG4gICAgICAuY29uY2F0KHRoaXMuYWRkZWRWaWV3cy5sZW5ndGggPyBgYWRkZWRWaWV3cz1bJHt0aGlzLmFkZGVkVmlld3N9XWAgOiBbXSlcbiAgICAgIC5jb25jYXQodGhpcy5yZW1vdmVkVmlld3MubGVuZ3RoID8gYHJlbW92ZWRWaWV3cz1bJHt0aGlzLnJlbW92ZWRWaWV3c31dYCA6IFtdKVxuICAgICAgLmpvaW4oJywgJyl9YDtcbiAgfVxufVxuIl19

package/esm2022/lib/routing/workbench-message-box-differ.mjs

@@ -8,7 +8,7 @@
  * SPDX-License-Identifier: EPL-2.0
  */
 import { Injectable } from '@angular/core';
-import { RouterUtils } from './router.util';
+import { Routing } from './routing.util';
 import * as i0 from "@angular/core";
 /**
  * Stateful differ for finding added/removed message boxes.
@@ -21,13 +21,13 @@ export class WorkbenchMessageBoxDiffer {
      * Computes differences in the URL since last time {@link WorkbenchMessageBoxDiffer#diff} was invoked.
      */
     diff(urlTree) {
-        const messageBoxOutlets = Object.keys(urlTree.root.children).filter(RouterUtils.isMessageBoxOutlet);
+        const messageBoxOutlets = Object.keys(urlTree.root.children).filter(Routing.isMessageBoxOutlet);
         return new WorkbenchMessageBoxDiff(this._messageBoxDiffer.diff(messageBoxOutlets));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: WorkbenchMessageBoxDiffer, deps: [{ token: i0.IterableDiffers }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: WorkbenchMessageBoxDiffer, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: WorkbenchMessageBoxDiffer, deps: [{ token: i0.IterableDiffers }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: WorkbenchMessageBoxDiffer, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: WorkbenchMessageBoxDiffer, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: WorkbenchMessageBoxDiffer, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [{ type: i0.IterableDiffers }] });
@@ -48,4 +48,4 @@ export class WorkbenchMessageBoxDiff {
             .join(', ')}`;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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