@angular/router 13.0.0-next.9 → 13.0.0-rc.3

package/esm2020/src/operators/apply_redirects.mjs

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { map, switchMap } from 'rxjs/operators';
+import { applyRedirects as applyRedirectsFn } from '../apply_redirects';
+export function applyRedirects(moduleInjector, configLoader, urlSerializer, config) {
+    return switchMap(t => applyRedirectsFn(moduleInjector, configLoader, urlSerializer, t.extractedUrl, config)
+        .pipe(map(urlAfterRedirects => ({ ...t, urlAfterRedirects }))));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/operators/check_guards.mjs

@@ -0,0 +1,138 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { concat, defer, from, of } from 'rxjs';
+import { concatMap, first, map, mergeMap } from 'rxjs/operators';
+import { ActivationStart, ChildActivationStart } from '../events';
+import { wrapIntoObservable } from '../utils/collection';
+import { getCanActivateChild, getToken } from '../utils/preactivation';
+import { isBoolean, isCanActivate, isCanActivateChild, isCanDeactivate, isFunction } from '../utils/type_guards';
+import { prioritizedGuardValue } from './prioritized_guard_value';
+export function checkGuards(moduleInjector, forwardEvent) {
+    return mergeMap(t => {
+        const { targetSnapshot, currentSnapshot, guards: { canActivateChecks, canDeactivateChecks } } = t;
+        if (canDeactivateChecks.length === 0 && canActivateChecks.length === 0) {
+            return of({ ...t, guardsResult: true });
+        }
+        return runCanDeactivateChecks(canDeactivateChecks, targetSnapshot, currentSnapshot, moduleInjector)
+            .pipe(mergeMap(canDeactivate => {
+            return canDeactivate && isBoolean(canDeactivate) ?
+                runCanActivateChecks(targetSnapshot, canActivateChecks, moduleInjector, forwardEvent) :
+                of(canDeactivate);
+        }), map(guardsResult => ({ ...t, guardsResult })));
+    });
+}
+function runCanDeactivateChecks(checks, futureRSS, currRSS, moduleInjector) {
+    return from(checks).pipe(mergeMap(check => runCanDeactivate(check.component, check.route, currRSS, futureRSS, moduleInjector)), first(result => {
+        return result !== true;
+    }, true));
+}
+function runCanActivateChecks(futureSnapshot, checks, moduleInjector, forwardEvent) {
+    return from(checks).pipe(concatMap((check) => {
+        return concat(fireChildActivationStart(check.route.parent, forwardEvent), fireActivationStart(check.route, forwardEvent), runCanActivateChild(futureSnapshot, check.path, moduleInjector), runCanActivate(futureSnapshot, check.route, moduleInjector));
+    }), first(result => {
+        return result !== true;
+    }, true));
+}
+/**
+ * This should fire off `ActivationStart` events for each route being activated at this
+ * level.
+ * In other words, if you're activating `a` and `b` below, `path` will contain the
+ * `ActivatedRouteSnapshot`s for both and we will fire `ActivationStart` for both. Always
+ * return
+ * `true` so checks continue to run.
+ */
+function fireActivationStart(snapshot, forwardEvent) {
+    if (snapshot !== null && forwardEvent) {
+        forwardEvent(new ActivationStart(snapshot));
+    }
+    return of(true);
+}
+/**
+ * This should fire off `ChildActivationStart` events for each route being activated at this
+ * level.
+ * In other words, if you're activating `a` and `b` below, `path` will contain the
+ * `ActivatedRouteSnapshot`s for both and we will fire `ChildActivationStart` for both. Always
+ * return
+ * `true` so checks continue to run.
+ */
+function fireChildActivationStart(snapshot, forwardEvent) {
+    if (snapshot !== null && forwardEvent) {
+        forwardEvent(new ChildActivationStart(snapshot));
+    }
+    return of(true);
+}
+function runCanActivate(futureRSS, futureARS, moduleInjector) {
+    const canActivate = futureARS.routeConfig ? futureARS.routeConfig.canActivate : null;
+    if (!canActivate || canActivate.length === 0)
+        return of(true);
+    const canActivateObservables = canActivate.map((c) => {
+        return defer(() => {
+            const guard = getToken(c, futureARS, moduleInjector);
+            let observable;
+            if (isCanActivate(guard)) {
+                observable = wrapIntoObservable(guard.canActivate(futureARS, futureRSS));
+            }
+            else if (isFunction(guard)) {
+                observable = wrapIntoObservable(guard(futureARS, futureRSS));
+            }
+            else {
+                throw new Error('Invalid CanActivate guard');
+            }
+            return observable.pipe(first());
+        });
+    });
+    return of(canActivateObservables).pipe(prioritizedGuardValue());
+}
+function runCanActivateChild(futureRSS, path, moduleInjector) {
+    const futureARS = path[path.length - 1];
+    const canActivateChildGuards = path.slice(0, path.length - 1)
+        .reverse()
+        .map(p => getCanActivateChild(p))
+        .filter(_ => _ !== null);
+    const canActivateChildGuardsMapped = canActivateChildGuards.map((d) => {
+        return defer(() => {
+            const guardsMapped = d.guards.map((c) => {
+                const guard = getToken(c, d.node, moduleInjector);
+                let observable;
+                if (isCanActivateChild(guard)) {
+                    observable = wrapIntoObservable(guard.canActivateChild(futureARS, futureRSS));
+                }
+                else if (isFunction(guard)) {
+                    observable = wrapIntoObservable(guard(futureARS, futureRSS));
+                }
+                else {
+                    throw new Error('Invalid CanActivateChild guard');
+                }
+                return observable.pipe(first());
+            });
+            return of(guardsMapped).pipe(prioritizedGuardValue());
+        });
+    });
+    return of(canActivateChildGuardsMapped).pipe(prioritizedGuardValue());
+}
+function runCanDeactivate(component, currARS, currRSS, futureRSS, moduleInjector) {
+    const canDeactivate = currARS && currARS.routeConfig ? currARS.routeConfig.canDeactivate : null;
+    if (!canDeactivate || canDeactivate.length === 0)
+        return of(true);
+    const canDeactivateObservables = canDeactivate.map((c) => {
+        const guard = getToken(c, currARS, moduleInjector);
+        let observable;
+        if (isCanDeactivate(guard)) {
+            observable = wrapIntoObservable(guard.canDeactivate(component, currARS, currRSS, futureRSS));
+        }
+        else if (isFunction(guard)) {
+            observable = wrapIntoObservable(guard(component, currARS, currRSS, futureRSS));
+        }
+        else {
+            throw new Error('Invalid CanDeactivate guard');
+        }
+        return observable.pipe(first());
+    });
+    return of(canDeactivateObservables).pipe(prioritizedGuardValue());
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"check_guards.js","sourceRoot":"","sources":["../../../../../../../packages/router/src/operators/check_guards.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Injector} from '@angular/core';\nimport {concat, defer, from, MonoTypeOperatorFunction, Observable, of} from 'rxjs';\nimport {concatMap, first, map, mergeMap} from 'rxjs/operators';\n\nimport {ActivationStart, ChildActivationStart, Event} from '../events';\nimport {CanActivateChildFn, CanActivateFn, CanDeactivateFn} from '../interfaces';\nimport {NavigationTransition} from '../router';\nimport {ActivatedRouteSnapshot, RouterStateSnapshot} from '../router_state';\nimport {UrlTree} from '../url_tree';\nimport {wrapIntoObservable} from '../utils/collection';\nimport {CanActivate, CanDeactivate, getCanActivateChild, getToken} from '../utils/preactivation';\nimport {isBoolean, isCanActivate, isCanActivateChild, isCanDeactivate, isFunction} from '../utils/type_guards';\n\nimport {prioritizedGuardValue} from './prioritized_guard_value';\n\nexport function checkGuards(moduleInjector: Injector, forwardEvent?: (evt: Event) => void):\n    MonoTypeOperatorFunction<NavigationTransition> {\n  return mergeMap(t => {\n    const {targetSnapshot, currentSnapshot, guards: {canActivateChecks, canDeactivateChecks}} = t;\n    if (canDeactivateChecks.length === 0 && canActivateChecks.length === 0) {\n      return of({...t, guardsResult: true});\n    }\n\n    return runCanDeactivateChecks(\n               canDeactivateChecks, targetSnapshot!, currentSnapshot, moduleInjector)\n        .pipe(\n            mergeMap(canDeactivate => {\n              return canDeactivate && isBoolean(canDeactivate) ?\n                  runCanActivateChecks(\n                      targetSnapshot!, canActivateChecks, moduleInjector, forwardEvent) :\n                  of(canDeactivate);\n            }),\n            map(guardsResult => ({...t, guardsResult})));\n  });\n}\n\nfunction runCanDeactivateChecks(\n    checks: CanDeactivate[], futureRSS: RouterStateSnapshot, currRSS: RouterStateSnapshot,\n    moduleInjector: Injector) {\n  return from(checks).pipe(\n      mergeMap(\n          check =>\n              runCanDeactivate(check.component, check.route, currRSS, futureRSS, moduleInjector)),\n      first(result => {\n        return result !== true;\n      }, true as boolean | UrlTree));\n}\n\nfunction runCanActivateChecks(\n    futureSnapshot: RouterStateSnapshot, checks: CanActivate[], moduleInjector: Injector,\n    forwardEvent?: (evt: Event) => void) {\n  return from(checks).pipe(\n      concatMap((check: CanActivate) => {\n        return concat(\n            fireChildActivationStart(check.route.parent, forwardEvent),\n            fireActivationStart(check.route, forwardEvent),\n            runCanActivateChild(futureSnapshot, check.path, moduleInjector),\n            runCanActivate(futureSnapshot, check.route, moduleInjector));\n      }),\n      first(result => {\n        return result !== true;\n      }, true as boolean | UrlTree));\n}\n\n/**\n * This should fire off `ActivationStart` events for each route being activated at this\n * level.\n * In other words, if you're activating `a` and `b` below, `path` will contain the\n * `ActivatedRouteSnapshot`s for both and we will fire `ActivationStart` for both. Always\n * return\n * `true` so checks continue to run.\n */\nfunction fireActivationStart(\n    snapshot: ActivatedRouteSnapshot|null,\n    forwardEvent?: (evt: Event) => void): Observable<boolean> {\n  if (snapshot !== null && forwardEvent) {\n    forwardEvent(new ActivationStart(snapshot));\n  }\n  return of(true);\n}\n\n/**\n * This should fire off `ChildActivationStart` events for each route being activated at this\n * level.\n * In other words, if you're activating `a` and `b` below, `path` will contain the\n * `ActivatedRouteSnapshot`s for both and we will fire `ChildActivationStart` for both. Always\n * return\n * `true` so checks continue to run.\n */\nfunction fireChildActivationStart(\n    snapshot: ActivatedRouteSnapshot|null,\n    forwardEvent?: (evt: Event) => void): Observable<boolean> {\n  if (snapshot !== null && forwardEvent) {\n    forwardEvent(new ChildActivationStart(snapshot));\n  }\n  return of(true);\n}\n\nfunction runCanActivate(\n    futureRSS: RouterStateSnapshot, futureARS: ActivatedRouteSnapshot,\n    moduleInjector: Injector): Observable<boolean|UrlTree> {\n  const canActivate = futureARS.routeConfig ? futureARS.routeConfig.canActivate : null;\n  if (!canActivate || canActivate.length === 0) return of(true);\n\n  const canActivateObservables = canActivate.map((c: any) => {\n    return defer(() => {\n      const guard = getToken(c, futureARS, moduleInjector);\n      let observable;\n      if (isCanActivate(guard)) {\n        observable = wrapIntoObservable(guard.canActivate(futureARS, futureRSS));\n      } else if (isFunction<CanActivateFn>(guard)) {\n        observable = wrapIntoObservable(guard(futureARS, futureRSS));\n      } else {\n        throw new Error('Invalid CanActivate guard');\n      }\n      return observable.pipe(first());\n    });\n  });\n  return of(canActivateObservables).pipe(prioritizedGuardValue());\n}\n\nfunction runCanActivateChild(\n    futureRSS: RouterStateSnapshot, path: ActivatedRouteSnapshot[],\n    moduleInjector: Injector): Observable<boolean|UrlTree> {\n  const futureARS = path[path.length - 1];\n\n  const canActivateChildGuards = path.slice(0, path.length - 1)\n                                     .reverse()\n                                     .map(p => getCanActivateChild(p))\n                                     .filter(_ => _ !== null);\n\n  const canActivateChildGuardsMapped = canActivateChildGuards.map((d: any) => {\n    return defer(() => {\n      const guardsMapped = d.guards.map((c: any) => {\n        const guard = getToken(c, d.node, moduleInjector);\n        let observable;\n        if (isCanActivateChild(guard)) {\n          observable = wrapIntoObservable(guard.canActivateChild(futureARS, futureRSS));\n        } else if (isFunction<CanActivateChildFn>(guard)) {\n          observable = wrapIntoObservable(guard(futureARS, futureRSS));\n        } else {\n          throw new Error('Invalid CanActivateChild guard');\n        }\n        return observable.pipe(first());\n      });\n      return of(guardsMapped).pipe(prioritizedGuardValue());\n    });\n  });\n  return of(canActivateChildGuardsMapped).pipe(prioritizedGuardValue());\n}\n\nfunction runCanDeactivate(\n    component: Object|null, currARS: ActivatedRouteSnapshot, currRSS: RouterStateSnapshot,\n    futureRSS: RouterStateSnapshot, moduleInjector: Injector): Observable<boolean|UrlTree> {\n  const canDeactivate = currARS && currARS.routeConfig ? currARS.routeConfig.canDeactivate : null;\n  if (!canDeactivate || canDeactivate.length === 0) return of(true);\n  const canDeactivateObservables = canDeactivate.map((c: any) => {\n    const guard = getToken(c, currARS, moduleInjector);\n    let observable;\n    if (isCanDeactivate(guard)) {\n      observable = wrapIntoObservable(guard.canDeactivate(component!, currARS, currRSS, futureRSS));\n    } else if (isFunction<CanDeactivateFn<any>>(guard)) {\n      observable = wrapIntoObservable(guard(component, currARS, currRSS, futureRSS));\n    } else {\n      throw new Error('Invalid CanDeactivate guard');\n    }\n    return observable.pipe(first());\n  });\n  return of(canDeactivateObservables).pipe(prioritizedGuardValue());\n}\n"]}

package/esm2020/src/operators/recognize.mjs

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { map, mergeMap } from 'rxjs/operators';
+import { recognize as recognizeFn } from '../recognize';
+export function recognize(rootComponentType, config, serializer, paramsInheritanceStrategy, relativeLinkResolution) {
+    return mergeMap(t => recognizeFn(rootComponentType, config, t.urlAfterRedirects, serializer(t.urlAfterRedirects), paramsInheritanceStrategy, relativeLinkResolution)
+        .pipe(map(targetSnapshot => ({ ...t, targetSnapshot }))));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/operators/resolve_data.mjs

@@ -0,0 +1,59 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { EMPTY, from, of } from 'rxjs';
+import { concatMap, map, mergeMap, takeLast, tap } from 'rxjs/operators';
+import { inheritedParamsDataResolve } from '../router_state';
+import { wrapIntoObservable } from '../utils/collection';
+import { getToken } from '../utils/preactivation';
+export function resolveData(paramsInheritanceStrategy, moduleInjector) {
+    return mergeMap(t => {
+        const { targetSnapshot, guards: { canActivateChecks } } = t;
+        if (!canActivateChecks.length) {
+            return of(t);
+        }
+        let canActivateChecksResolved = 0;
+        return from(canActivateChecks)
+            .pipe(concatMap(check => runResolve(check.route, targetSnapshot, paramsInheritanceStrategy, moduleInjector)), tap(() => canActivateChecksResolved++), takeLast(1), mergeMap(_ => canActivateChecksResolved === canActivateChecks.length ? of(t) : EMPTY));
+    });
+}
+function runResolve(futureARS, futureRSS, paramsInheritanceStrategy, moduleInjector) {
+    const resolve = futureARS._resolve;
+    return resolveNode(resolve, futureARS, futureRSS, moduleInjector)
+        .pipe(map((resolvedData) => {
+        futureARS._resolvedData = resolvedData;
+        futureARS.data = {
+            ...futureARS.data,
+            ...inheritedParamsDataResolve(futureARS, paramsInheritanceStrategy).resolve
+        };
+        return null;
+    }));
+}
+function resolveNode(resolve, futureARS, futureRSS, moduleInjector) {
+    const keys = Object.keys(resolve);
+    if (keys.length === 0) {
+        return of({});
+    }
+    const data = {};
+    return from(keys).pipe(mergeMap((key) => getResolver(resolve[key], futureARS, futureRSS, moduleInjector)
+        .pipe(tap((value) => {
+        data[key] = value;
+    }))), takeLast(1), mergeMap(() => {
+        // Ensure all resolvers returned values, otherwise don't emit any "next" and just complete
+        // the chain which will cancel navigation
+        if (Object.keys(data).length === keys.length) {
+            return of(data);
+        }
+        return EMPTY;
+    }));
+}
+function getResolver(injectionToken, futureARS, futureRSS, moduleInjector) {
+    const resolver = getToken(injectionToken, futureARS, moduleInjector);
+    return resolver.resolve ? wrapIntoObservable(resolver.resolve(futureARS, futureRSS)) :
+        wrapIntoObservable(resolver(futureARS, futureRSS));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/recognize.mjs

@@ -0,0 +1,262 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Observable, of } from 'rxjs';
+import { ActivatedRouteSnapshot, inheritedParamsDataResolve, RouterStateSnapshot } from './router_state';
+import { PRIMARY_OUTLET } from './shared';
+import { last } from './utils/collection';
+import { getOutlet, sortByMatchingOutlets } from './utils/config';
+import { isImmediateMatch, match, noLeftoversInUrl, split } from './utils/config_matching';
+import { TreeNode } from './utils/tree';
+class NoMatch {
+}
+function newObservableError(e) {
+    // TODO(atscott): This pattern is used throughout the router code and can be `throwError` instead.
+    return new Observable((obs) => obs.error(e));
+}
+export function recognize(rootComponentType, config, urlTree, url, paramsInheritanceStrategy = 'emptyOnly', relativeLinkResolution = 'legacy') {
+    try {
+        const result = new Recognizer(rootComponentType, config, urlTree, url, paramsInheritanceStrategy, relativeLinkResolution)
+            .recognize();
+        if (result === null) {
+            return newObservableError(new NoMatch());
+        }
+        else {
+            return of(result);
+        }
+    }
+    catch (e) {
+        // Catch the potential error from recognize due to duplicate outlet matches and return as an
+        // `Observable` error instead.
+        return newObservableError(e);
+    }
+}
+export class Recognizer {
+    constructor(rootComponentType, config, urlTree, url, paramsInheritanceStrategy, relativeLinkResolution) {
+        this.rootComponentType = rootComponentType;
+        this.config = config;
+        this.urlTree = urlTree;
+        this.url = url;
+        this.paramsInheritanceStrategy = paramsInheritanceStrategy;
+        this.relativeLinkResolution = relativeLinkResolution;
+    }
+    recognize() {
+        const rootSegmentGroup = split(this.urlTree.root, [], [], this.config.filter(c => c.redirectTo === undefined), this.relativeLinkResolution)
+            .segmentGroup;
+        const children = this.processSegmentGroup(this.config, rootSegmentGroup, PRIMARY_OUTLET);
+        if (children === null) {
+            return null;
+        }
+        // Use Object.freeze to prevent readers of the Router state from modifying it outside of a
+        // navigation, resulting in the router being out of sync with the browser.
+        const root = new ActivatedRouteSnapshot([], Object.freeze({}), Object.freeze({ ...this.urlTree.queryParams }), this.urlTree.fragment, {}, PRIMARY_OUTLET, this.rootComponentType, null, this.urlTree.root, -1, {});
+        const rootNode = new TreeNode(root, children);
+        const routeState = new RouterStateSnapshot(this.url, rootNode);
+        this.inheritParamsAndData(routeState._root);
+        return routeState;
+    }
+    inheritParamsAndData(routeNode) {
+        const route = routeNode.value;
+        const i = inheritedParamsDataResolve(route, this.paramsInheritanceStrategy);
+        route.params = Object.freeze(i.params);
+        route.data = Object.freeze(i.data);
+        routeNode.children.forEach(n => this.inheritParamsAndData(n));
+    }
+    processSegmentGroup(config, segmentGroup, outlet) {
+        if (segmentGroup.segments.length === 0 && segmentGroup.hasChildren()) {
+            return this.processChildren(config, segmentGroup);
+        }
+        return this.processSegment(config, segmentGroup, segmentGroup.segments, outlet);
+    }
+    /**
+     * Matches every child outlet in the `segmentGroup` to a `Route` in the config. Returns `null` if
+     * we cannot find a match for _any_ of the children.
+     *
+     * @param config - The `Routes` to match against
+     * @param segmentGroup - The `UrlSegmentGroup` whose children need to be matched against the
+     *     config.
+     */
+    processChildren(config, segmentGroup) {
+        const children = [];
+        for (const childOutlet of Object.keys(segmentGroup.children)) {
+            const child = segmentGroup.children[childOutlet];
+            // Sort the config so that routes with outlets that match the one being activated appear
+            // first, followed by routes for other outlets, which might match if they have an empty path.
+            const sortedConfig = sortByMatchingOutlets(config, childOutlet);
+            const outletChildren = this.processSegmentGroup(sortedConfig, child, childOutlet);
+            if (outletChildren === null) {
+                // Configs must match all segment children so because we did not find a match for this
+                // outlet, return `null`.
+                return null;
+            }
+            children.push(...outletChildren);
+        }
+        // Because we may have matched two outlets to the same empty path segment, we can have multiple
+        // activated results for the same outlet. We should merge the children of these results so the
+        // final return value is only one `TreeNode` per outlet.
+        const mergedChildren = mergeEmptyPathMatches(children);
+        if (typeof ngDevMode === 'undefined' || ngDevMode) {
+            // This should really never happen - we are only taking the first match for each outlet and
+            // merge the empty path matches.
+            checkOutletNameUniqueness(mergedChildren);
+        }
+        sortActivatedRouteSnapshots(mergedChildren);
+        return mergedChildren;
+    }
+    processSegment(config, segmentGroup, segments, outlet) {
+        for (const r of config) {
+            const children = this.processSegmentAgainstRoute(r, segmentGroup, segments, outlet);
+            if (children !== null) {
+                return children;
+            }
+        }
+        if (noLeftoversInUrl(segmentGroup, segments, outlet)) {
+            return [];
+        }
+        return null;
+    }
+    processSegmentAgainstRoute(route, rawSegment, segments, outlet) {
+        if (route.redirectTo || !isImmediateMatch(route, rawSegment, segments, outlet))
+            return null;
+        let snapshot;
+        let consumedSegments = [];
+        let rawSlicedSegments = [];
+        if (route.path === '**') {
+            const params = segments.length > 0 ? last(segments).parameters : {};
+            snapshot = new ActivatedRouteSnapshot(segments, params, Object.freeze({ ...this.urlTree.queryParams }), this.urlTree.fragment, getData(route), getOutlet(route), route.component, route, getSourceSegmentGroup(rawSegment), getPathIndexShift(rawSegment) + segments.length, getResolve(route));
+        }
+        else {
+            const result = match(rawSegment, route, segments);
+            if (!result.matched) {
+                return null;
+            }
+            consumedSegments = result.consumedSegments;
+            rawSlicedSegments = segments.slice(result.lastChild);
+            snapshot = new ActivatedRouteSnapshot(consumedSegments, result.parameters, Object.freeze({ ...this.urlTree.queryParams }), this.urlTree.fragment, getData(route), getOutlet(route), route.component, route, getSourceSegmentGroup(rawSegment), getPathIndexShift(rawSegment) + consumedSegments.length, getResolve(route));
+        }
+        const childConfig = getChildConfig(route);
+        const { segmentGroup, slicedSegments } = split(rawSegment, consumedSegments, rawSlicedSegments, 
+        // Filter out routes with redirectTo because we are trying to create activated route
+        // snapshots and don't handle redirects here. That should have been done in
+        // `applyRedirects`.
+        childConfig.filter(c => c.redirectTo === undefined), this.relativeLinkResolution);
+        if (slicedSegments.length === 0 && segmentGroup.hasChildren()) {
+            const children = this.processChildren(childConfig, segmentGroup);
+            if (children === null) {
+                return null;
+            }
+            return [new TreeNode(snapshot, children)];
+        }
+        if (childConfig.length === 0 && slicedSegments.length === 0) {
+            return [new TreeNode(snapshot, [])];
+        }
+        const matchedOnOutlet = getOutlet(route) === outlet;
+        // If we matched a config due to empty path match on a different outlet, we need to continue
+        // passing the current outlet for the segment rather than switch to PRIMARY.
+        // Note that we switch to primary when we have a match because outlet configs look like this:
+        // {path: 'a', outlet: 'a', children: [
+        //  {path: 'b', component: B},
+        //  {path: 'c', component: C},
+        // ]}
+        // Notice that the children of the named outlet are configured with the primary outlet
+        const children = this.processSegment(childConfig, segmentGroup, slicedSegments, matchedOnOutlet ? PRIMARY_OUTLET : outlet);
+        if (children === null) {
+            return null;
+        }
+        return [new TreeNode(snapshot, children)];
+    }
+}
+function sortActivatedRouteSnapshots(nodes) {
+    nodes.sort((a, b) => {
+        if (a.value.outlet === PRIMARY_OUTLET)
+            return -1;
+        if (b.value.outlet === PRIMARY_OUTLET)
+            return 1;
+        return a.value.outlet.localeCompare(b.value.outlet);
+    });
+}
+function getChildConfig(route) {
+    if (route.children) {
+        return route.children;
+    }
+    if (route.loadChildren) {
+        return route._loadedConfig.routes;
+    }
+    return [];
+}
+function hasEmptyPathConfig(node) {
+    const config = node.value.routeConfig;
+    return config && config.path === '' && config.redirectTo === undefined;
+}
+/**
+ * Finds `TreeNode`s with matching empty path route configs and merges them into `TreeNode` with the
+ * children from each duplicate. This is necessary because different outlets can match a single
+ * empty path route config and the results need to then be merged.
+ */
+function mergeEmptyPathMatches(nodes) {
+    const result = [];
+    // The set of nodes which contain children that were merged from two duplicate empty path nodes.
+    const mergedNodes = new Set();
+    for (const node of nodes) {
+        if (!hasEmptyPathConfig(node)) {
+            result.push(node);
+            continue;
+        }
+        const duplicateEmptyPathNode = result.find(resultNode => node.value.routeConfig === resultNode.value.routeConfig);
+        if (duplicateEmptyPathNode !== undefined) {
+            duplicateEmptyPathNode.children.push(...node.children);
+            mergedNodes.add(duplicateEmptyPathNode);
+        }
+        else {
+            result.push(node);
+        }
+    }
+    // For each node which has children from multiple sources, we need to recompute a new `TreeNode`
+    // by also merging those children. This is necessary when there are multiple empty path configs in
+    // a row. Put another way: whenever we combine children of two nodes, we need to also check if any
+    // of those children can be combined into a single node as well.
+    for (const mergedNode of mergedNodes) {
+        const mergedChildren = mergeEmptyPathMatches(mergedNode.children);
+        result.push(new TreeNode(mergedNode.value, mergedChildren));
+    }
+    return result.filter(n => !mergedNodes.has(n));
+}
+function checkOutletNameUniqueness(nodes) {
+    const names = {};
+    nodes.forEach(n => {
+        const routeWithSameOutletName = names[n.value.outlet];
+        if (routeWithSameOutletName) {
+            const p = routeWithSameOutletName.url.map(s => s.toString()).join('/');
+            const c = n.value.url.map(s => s.toString()).join('/');
+            throw new Error(`Two segments cannot have the same outlet name: '${p}' and '${c}'.`);
+        }
+        names[n.value.outlet] = n.value;
+    });
+}
+function getSourceSegmentGroup(segmentGroup) {
+    let s = segmentGroup;
+    while (s._sourceSegment) {
+        s = s._sourceSegment;
+    }
+    return s;
+}
+function getPathIndexShift(segmentGroup) {
+    let s = segmentGroup;
+    let res = (s._segmentIndexShift ? s._segmentIndexShift : 0);
+    while (s._sourceSegment) {
+        s = s._sourceSegment;
+        res += (s._segmentIndexShift ? s._segmentIndexShift : 0);
+    }
+    return res - 1;
+}
+function getData(route) {
+    return route.data || {};
+}
+function getResolve(route) {
+    return route.resolve || {};
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recognize.js","sourceRoot":"","sources":["../../../../../../packages/router/src/recognize.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Type} from '@angular/core';\nimport {Observable, Observer, of} from 'rxjs';\n\nimport {Data, ResolveData, Route, Routes} from './config';\nimport {ActivatedRouteSnapshot, inheritedParamsDataResolve, ParamsInheritanceStrategy, RouterStateSnapshot} from './router_state';\nimport {PRIMARY_OUTLET} from './shared';\nimport {UrlSegment, UrlSegmentGroup, UrlTree} from './url_tree';\nimport {last} from './utils/collection';\nimport {getOutlet, sortByMatchingOutlets} from './utils/config';\nimport {isImmediateMatch, match, noLeftoversInUrl, split} from './utils/config_matching';\nimport {TreeNode} from './utils/tree';\n\nclass NoMatch {}\n\nfunction newObservableError(e: unknown): Observable<RouterStateSnapshot> {\n  // TODO(atscott): This pattern is used throughout the router code and can be `throwError` instead.\n  return new Observable<RouterStateSnapshot>((obs: Observer<RouterStateSnapshot>) => obs.error(e));\n}\n\nexport function recognize(\n    rootComponentType: Type<any>|null, config: Routes, urlTree: UrlTree, url: string,\n    paramsInheritanceStrategy: ParamsInheritanceStrategy = 'emptyOnly',\n    relativeLinkResolution: 'legacy'|'corrected' = 'legacy'): Observable<RouterStateSnapshot> {\n  try {\n    const result = new Recognizer(\n                       rootComponentType, config, urlTree, url, paramsInheritanceStrategy,\n                       relativeLinkResolution)\n                       .recognize();\n    if (result === null) {\n      return newObservableError(new NoMatch());\n    } else {\n      return of(result);\n    }\n  } catch (e) {\n    // Catch the potential error from recognize due to duplicate outlet matches and return as an\n    // `Observable` error instead.\n    return newObservableError(e);\n  }\n}\n\nexport class Recognizer {\n  constructor(\n      private rootComponentType: Type<any>|null, private config: Routes, private urlTree: UrlTree,\n      private url: string, private paramsInheritanceStrategy: ParamsInheritanceStrategy,\n      private relativeLinkResolution: 'legacy'|'corrected') {}\n\n  recognize(): RouterStateSnapshot|null {\n    const rootSegmentGroup =\n        split(\n            this.urlTree.root, [], [], this.config.filter(c => c.redirectTo === undefined),\n            this.relativeLinkResolution)\n            .segmentGroup;\n\n    const children = this.processSegmentGroup(this.config, rootSegmentGroup, PRIMARY_OUTLET);\n    if (children === null) {\n      return null;\n    }\n\n    // Use Object.freeze to prevent readers of the Router state from modifying it outside of a\n    // navigation, resulting in the router being out of sync with the browser.\n    const root = new ActivatedRouteSnapshot(\n        [], Object.freeze({}), Object.freeze({...this.urlTree.queryParams}), this.urlTree.fragment,\n        {}, PRIMARY_OUTLET, this.rootComponentType, null, this.urlTree.root, -1, {});\n\n    const rootNode = new TreeNode<ActivatedRouteSnapshot>(root, children);\n    const routeState = new RouterStateSnapshot(this.url, rootNode);\n    this.inheritParamsAndData(routeState._root);\n    return routeState;\n  }\n\n  inheritParamsAndData(routeNode: TreeNode<ActivatedRouteSnapshot>): void {\n    const route = routeNode.value;\n\n    const i = inheritedParamsDataResolve(route, this.paramsInheritanceStrategy);\n    route.params = Object.freeze(i.params);\n    route.data = Object.freeze(i.data);\n\n    routeNode.children.forEach(n => this.inheritParamsAndData(n));\n  }\n\n  processSegmentGroup(config: Route[], segmentGroup: UrlSegmentGroup, outlet: string):\n      TreeNode<ActivatedRouteSnapshot>[]|null {\n    if (segmentGroup.segments.length === 0 && segmentGroup.hasChildren()) {\n      return this.processChildren(config, segmentGroup);\n    }\n\n    return this.processSegment(config, segmentGroup, segmentGroup.segments, outlet);\n  }\n\n  /**\n   * Matches every child outlet in the `segmentGroup` to a `Route` in the config. Returns `null` if\n   * we cannot find a match for _any_ of the children.\n   *\n   * @param config - The `Routes` to match against\n   * @param segmentGroup - The `UrlSegmentGroup` whose children need to be matched against the\n   *     config.\n   */\n  processChildren(config: Route[], segmentGroup: UrlSegmentGroup):\n      TreeNode<ActivatedRouteSnapshot>[]|null {\n    const children: Array<TreeNode<ActivatedRouteSnapshot>> = [];\n    for (const childOutlet of Object.keys(segmentGroup.children)) {\n      const child = segmentGroup.children[childOutlet];\n      // Sort the config so that routes with outlets that match the one being activated appear\n      // first, followed by routes for other outlets, which might match if they have an empty path.\n      const sortedConfig = sortByMatchingOutlets(config, childOutlet);\n      const outletChildren = this.processSegmentGroup(sortedConfig, child, childOutlet);\n      if (outletChildren === null) {\n        // Configs must match all segment children so because we did not find a match for this\n        // outlet, return `null`.\n        return null;\n      }\n      children.push(...outletChildren);\n    }\n    // Because we may have matched two outlets to the same empty path segment, we can have multiple\n    // activated results for the same outlet. We should merge the children of these results so the\n    // final return value is only one `TreeNode` per outlet.\n    const mergedChildren = mergeEmptyPathMatches(children);\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      // This should really never happen - we are only taking the first match for each outlet and\n      // merge the empty path matches.\n      checkOutletNameUniqueness(mergedChildren);\n    }\n    sortActivatedRouteSnapshots(mergedChildren);\n    return mergedChildren;\n  }\n\n  processSegment(\n      config: Route[], segmentGroup: UrlSegmentGroup, segments: UrlSegment[],\n      outlet: string): TreeNode<ActivatedRouteSnapshot>[]|null {\n    for (const r of config) {\n      const children = this.processSegmentAgainstRoute(r, segmentGroup, segments, outlet);\n      if (children !== null) {\n        return children;\n      }\n    }\n    if (noLeftoversInUrl(segmentGroup, segments, outlet)) {\n      return [];\n    }\n\n    return null;\n  }\n\n  processSegmentAgainstRoute(\n      route: Route, rawSegment: UrlSegmentGroup, segments: UrlSegment[],\n      outlet: string): TreeNode<ActivatedRouteSnapshot>[]|null {\n    if (route.redirectTo || !isImmediateMatch(route, rawSegment, segments, outlet)) return null;\n\n    let snapshot: ActivatedRouteSnapshot;\n    let consumedSegments: UrlSegment[] = [];\n    let rawSlicedSegments: UrlSegment[] = [];\n\n    if (route.path === '**') {\n      const params = segments.length > 0 ? last(segments)!.parameters : {};\n      snapshot = new ActivatedRouteSnapshot(\n          segments, params, Object.freeze({...this.urlTree.queryParams}), this.urlTree.fragment,\n          getData(route), getOutlet(route), route.component!, route,\n          getSourceSegmentGroup(rawSegment), getPathIndexShift(rawSegment) + segments.length,\n          getResolve(route));\n    } else {\n      const result = match(rawSegment, route, segments);\n      if (!result.matched) {\n        return null;\n      }\n      consumedSegments = result.consumedSegments;\n      rawSlicedSegments = segments.slice(result.lastChild);\n\n      snapshot = new ActivatedRouteSnapshot(\n          consumedSegments, result.parameters, Object.freeze({...this.urlTree.queryParams}),\n          this.urlTree.fragment, getData(route), getOutlet(route), route.component!, route,\n          getSourceSegmentGroup(rawSegment),\n          getPathIndexShift(rawSegment) + consumedSegments.length, getResolve(route));\n    }\n\n    const childConfig: Route[] = getChildConfig(route);\n\n    const {segmentGroup, slicedSegments} = split(\n        rawSegment, consumedSegments, rawSlicedSegments,\n        // Filter out routes with redirectTo because we are trying to create activated route\n        // snapshots and don't handle redirects here. That should have been done in\n        // `applyRedirects`.\n        childConfig.filter(c => c.redirectTo === undefined), this.relativeLinkResolution);\n\n    if (slicedSegments.length === 0 && segmentGroup.hasChildren()) {\n      const children = this.processChildren(childConfig, segmentGroup);\n      if (children === null) {\n        return null;\n      }\n      return [new TreeNode<ActivatedRouteSnapshot>(snapshot, children)];\n    }\n\n    if (childConfig.length === 0 && slicedSegments.length === 0) {\n      return [new TreeNode<ActivatedRouteSnapshot>(snapshot, [])];\n    }\n\n    const matchedOnOutlet = getOutlet(route) === outlet;\n    // If we matched a config due to empty path match on a different outlet, we need to continue\n    // passing the current outlet for the segment rather than switch to PRIMARY.\n    // Note that we switch to primary when we have a match because outlet configs look like this:\n    // {path: 'a', outlet: 'a', children: [\n    //  {path: 'b', component: B},\n    //  {path: 'c', component: C},\n    // ]}\n    // Notice that the children of the named outlet are configured with the primary outlet\n    const children = this.processSegment(\n        childConfig, segmentGroup, slicedSegments, matchedOnOutlet ? PRIMARY_OUTLET : outlet);\n    if (children === null) {\n      return null;\n    }\n    return [new TreeNode<ActivatedRouteSnapshot>(snapshot, children)];\n  }\n}\n\nfunction sortActivatedRouteSnapshots(nodes: TreeNode<ActivatedRouteSnapshot>[]): void {\n  nodes.sort((a, b) => {\n    if (a.value.outlet === PRIMARY_OUTLET) return -1;\n    if (b.value.outlet === PRIMARY_OUTLET) return 1;\n    return a.value.outlet.localeCompare(b.value.outlet);\n  });\n}\n\nfunction getChildConfig(route: Route): Route[] {\n  if (route.children) {\n    return route.children;\n  }\n\n  if (route.loadChildren) {\n    return route._loadedConfig!.routes;\n  }\n\n  return [];\n}\n\nfunction hasEmptyPathConfig(node: TreeNode<ActivatedRouteSnapshot>) {\n  const config = node.value.routeConfig;\n  return config && config.path === '' && config.redirectTo === undefined;\n}\n\n/**\n * Finds `TreeNode`s with matching empty path route configs and merges them into `TreeNode` with the\n * children from each duplicate. This is necessary because different outlets can match a single\n * empty path route config and the results need to then be merged.\n */\nfunction mergeEmptyPathMatches(nodes: Array<TreeNode<ActivatedRouteSnapshot>>):\n    Array<TreeNode<ActivatedRouteSnapshot>> {\n  const result: Array<TreeNode<ActivatedRouteSnapshot>> = [];\n  // The set of nodes which contain children that were merged from two duplicate empty path nodes.\n  const mergedNodes: Set<TreeNode<ActivatedRouteSnapshot>> = new Set();\n\n  for (const node of nodes) {\n    if (!hasEmptyPathConfig(node)) {\n      result.push(node);\n      continue;\n    }\n\n    const duplicateEmptyPathNode =\n        result.find(resultNode => node.value.routeConfig === resultNode.value.routeConfig);\n    if (duplicateEmptyPathNode !== undefined) {\n      duplicateEmptyPathNode.children.push(...node.children);\n      mergedNodes.add(duplicateEmptyPathNode);\n    } else {\n      result.push(node);\n    }\n  }\n  // For each node which has children from multiple sources, we need to recompute a new `TreeNode`\n  // by also merging those children. This is necessary when there are multiple empty path configs in\n  // a row. Put another way: whenever we combine children of two nodes, we need to also check if any\n  // of those children can be combined into a single node as well.\n  for (const mergedNode of mergedNodes) {\n    const mergedChildren = mergeEmptyPathMatches(mergedNode.children);\n    result.push(new TreeNode(mergedNode.value, mergedChildren));\n  }\n  return result.filter(n => !mergedNodes.has(n));\n}\n\nfunction checkOutletNameUniqueness(nodes: TreeNode<ActivatedRouteSnapshot>[]): void {\n  const names: {[k: string]: ActivatedRouteSnapshot} = {};\n  nodes.forEach(n => {\n    const routeWithSameOutletName = names[n.value.outlet];\n    if (routeWithSameOutletName) {\n      const p = routeWithSameOutletName.url.map(s => s.toString()).join('/');\n      const c = n.value.url.map(s => s.toString()).join('/');\n      throw new Error(`Two segments cannot have the same outlet name: '${p}' and '${c}'.`);\n    }\n    names[n.value.outlet] = n.value;\n  });\n}\n\nfunction getSourceSegmentGroup(segmentGroup: UrlSegmentGroup): UrlSegmentGroup {\n  let s = segmentGroup;\n  while (s._sourceSegment) {\n    s = s._sourceSegment;\n  }\n  return s;\n}\n\nfunction getPathIndexShift(segmentGroup: UrlSegmentGroup): number {\n  let s = segmentGroup;\n  let res = (s._segmentIndexShift ? s._segmentIndexShift : 0);\n  while (s._sourceSegment) {\n    s = s._sourceSegment;\n    res += (s._segmentIndexShift ? s._segmentIndexShift : 0);\n  }\n  return res - 1;\n}\n\nfunction getData(route: Route): Data {\n  return route.data || {};\n}\n\nfunction getResolve(route: Route): ResolveData {\n  return route.resolve || {};\n}\n"]}