@angular/router
Version:
Angular - the routing library
88 lines • 16 kB
JavaScript
/**
* @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 { runInInjectionContext } from '@angular/core';
import { EMPTY, from, of, throwError } from 'rxjs';
import { catchError, concatMap, first, map, mapTo, mergeMap, takeLast, tap } from 'rxjs/operators';
import { getInherited, hasStaticTitle } from '../router_state';
import { RouteTitleKey } from '../shared';
import { getDataKeys, wrapIntoObservable } from '../utils/collection';
import { getClosestRouteInjector } from '../utils/config';
import { getTokenOrFunctionIdentity } from '../utils/preactivation';
import { isEmptyError } from '../utils/type_guards';
export function resolveData(paramsInheritanceStrategy, injector) {
return mergeMap(t => {
const { targetSnapshot, guards: { canActivateChecks } } = t;
if (!canActivateChecks.length) {
return of(t);
}
// Iterating a Set in javascript happens in insertion order so it is safe to use a `Set` to
// preserve the correct order that the resolvers should run in.
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set#description
const routesWithResolversToRun = new Set(canActivateChecks.map(check => check.route));
const routesNeedingDataUpdates = new Set();
for (const route of routesWithResolversToRun) {
if (routesNeedingDataUpdates.has(route)) {
continue;
}
// All children under the route with a resolver to run need to recompute inherited data.
for (const newRoute of flattenRouteTree(route)) {
routesNeedingDataUpdates.add(newRoute);
}
}
let routesProcessed = 0;
return from(routesNeedingDataUpdates)
.pipe(concatMap(route => {
if (routesWithResolversToRun.has(route)) {
return runResolve(route, targetSnapshot, paramsInheritanceStrategy, injector);
}
else {
route.data = getInherited(route, route.parent, paramsInheritanceStrategy).resolve;
return of(void 0);
}
}), tap(() => routesProcessed++), takeLast(1), mergeMap(_ => routesProcessed === routesNeedingDataUpdates.size ? of(t) : EMPTY));
});
}
/**
* Returns the `ActivatedRouteSnapshot` tree as an array, using DFS to traverse the route tree.
*/
function flattenRouteTree(route) {
const descendants = route.children.map(child => flattenRouteTree(child)).flat();
return [route, ...descendants];
}
function runResolve(futureARS, futureRSS, paramsInheritanceStrategy, injector) {
const config = futureARS.routeConfig;
const resolve = futureARS._resolve;
if (config?.title !== undefined && !hasStaticTitle(config)) {
resolve[RouteTitleKey] = config.title;
}
return resolveNode(resolve, futureARS, futureRSS, injector).pipe(map((resolvedData) => {
futureARS._resolvedData = resolvedData;
futureARS.data = getInherited(futureARS, futureARS.parent, paramsInheritanceStrategy).resolve;
return null;
}));
}
function resolveNode(resolve, futureARS, futureRSS, injector) {
const keys = getDataKeys(resolve);
if (keys.length === 0) {
return of({});
}
const data = {};
return from(keys).pipe(mergeMap(key => getResolver(resolve[key], futureARS, futureRSS, injector)
.pipe(first(), tap((value) => {
data[key] = value;
}))), takeLast(1), mapTo(data), catchError((e) => isEmptyError(e) ? EMPTY : throwError(e)));
}
function getResolver(injectionToken, futureARS, futureRSS, injector) {
const closestInjector = getClosestRouteInjector(futureARS) ?? injector;
const resolver = getTokenOrFunctionIdentity(injectionToken, closestInjector);
const resolverValue = resolver.resolve ?
resolver.resolve(futureARS, futureRSS) :
runInInjectionContext(closestInjector, () => resolver(futureARS, futureRSS));
return wrapIntoObservable(resolverValue);
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resolve_data.js","sourceRoot":"","sources":["../../../../../../../packages/router/src/operators/resolve_data.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 {EnvironmentInjector, ProviderToken, runInInjectionContext} from '@angular/core';\nimport {EMPTY, from, MonoTypeOperatorFunction, Observable, of, throwError} from 'rxjs';\nimport {catchError, concatMap, first, map, mapTo, mergeMap, takeLast, tap} from 'rxjs/operators';\n\nimport {ResolveData} from '../models';\nimport {NavigationTransition} from '../navigation_transition';\nimport {ActivatedRouteSnapshot, getInherited, hasStaticTitle, RouterStateSnapshot} from '../router_state';\nimport {RouteTitleKey} from '../shared';\nimport {getDataKeys, wrapIntoObservable} from '../utils/collection';\nimport {getClosestRouteInjector} from '../utils/config';\nimport {getTokenOrFunctionIdentity} from '../utils/preactivation';\nimport {isEmptyError} from '../utils/type_guards';\n\nexport function resolveData(\n    paramsInheritanceStrategy: 'emptyOnly'|'always',\n    injector: EnvironmentInjector): MonoTypeOperatorFunction<NavigationTransition> {\n  return mergeMap(t => {\n    const {targetSnapshot, guards: {canActivateChecks}} = t;\n\n    if (!canActivateChecks.length) {\n      return of(t);\n    }\n    // Iterating a Set in javascript  happens in insertion order so it is safe to use a `Set` to\n    // preserve the correct order that the resolvers should run in.\n    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set#description\n    const routesWithResolversToRun = new Set(canActivateChecks.map(check => check.route));\n    const routesNeedingDataUpdates = new Set<ActivatedRouteSnapshot>();\n    for (const route of routesWithResolversToRun) {\n      if (routesNeedingDataUpdates.has(route)) {\n        continue;\n      }\n      // All children under the route with a resolver to run need to recompute inherited data.\n      for (const newRoute of flattenRouteTree(route)) {\n        routesNeedingDataUpdates.add(newRoute);\n      }\n    }\n    let routesProcessed = 0;\n    return from(routesNeedingDataUpdates)\n        .pipe(\n            concatMap(route => {\n              if (routesWithResolversToRun.has(route)) {\n                return runResolve(route, targetSnapshot!, paramsInheritanceStrategy, injector);\n              } else {\n                route.data = getInherited(route, route.parent, paramsInheritanceStrategy).resolve;\n                return of(void 0);\n              }\n            }),\n            tap(() => routesProcessed++),\n            takeLast(1),\n            mergeMap(_ => routesProcessed === routesNeedingDataUpdates.size ? of(t) : EMPTY),\n        );\n  });\n}\n\n/**\n *  Returns the `ActivatedRouteSnapshot` tree as an array, using DFS to traverse the route tree.\n */\nfunction flattenRouteTree(route: ActivatedRouteSnapshot): ActivatedRouteSnapshot[] {\n  const descendants = route.children.map(child => flattenRouteTree(child)).flat();\n  return [route, ...descendants];\n}\n\nfunction runResolve(\n    futureARS: ActivatedRouteSnapshot, futureRSS: RouterStateSnapshot,\n    paramsInheritanceStrategy: 'emptyOnly'|'always', injector: EnvironmentInjector) {\n  const config = futureARS.routeConfig;\n  const resolve = futureARS._resolve;\n  if (config?.title !== undefined && !hasStaticTitle(config)) {\n    resolve[RouteTitleKey] = config.title;\n  }\n  return resolveNode(resolve, futureARS, futureRSS, injector).pipe(map((resolvedData: any) => {\n    futureARS._resolvedData = resolvedData;\n    futureARS.data = getInherited(futureARS, futureARS.parent, paramsInheritanceStrategy).resolve;\n    return null;\n  }));\n}\n\nfunction resolveNode(\n    resolve: ResolveData, futureARS: ActivatedRouteSnapshot, futureRSS: RouterStateSnapshot,\n    injector: EnvironmentInjector): Observable<any> {\n  const keys = getDataKeys(resolve);\n  if (keys.length === 0) {\n    return of({});\n  }\n  const data: {[k: string|symbol]: any} = {};\n  return from(keys).pipe(\n      mergeMap(\n          key => getResolver(resolve[key], futureARS, futureRSS, injector)\n                     .pipe(first(), tap((value: any) => {\n                             data[key] = value;\n                           }))),\n      takeLast(1),\n      mapTo(data),\n      catchError((e: unknown) => isEmptyError(e as Error) ? EMPTY : throwError(e)),\n  );\n}\n\nfunction getResolver(\n    injectionToken: ProviderToken<any>|Function, futureARS: ActivatedRouteSnapshot,\n    futureRSS: RouterStateSnapshot, injector: EnvironmentInjector): Observable<any> {\n  const closestInjector = getClosestRouteInjector(futureARS) ?? injector;\n  const resolver = getTokenOrFunctionIdentity(injectionToken, closestInjector);\n  const resolverValue = resolver.resolve ?\n      resolver.resolve(futureARS, futureRSS) :\n      runInInjectionContext(closestInjector, () => resolver(futureARS, futureRSS));\n  return wrapIntoObservable(resolverValue);\n}\n"]}