@angular/router
Version:
Angular - the routing library
92 lines • 17.2 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.dev/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 { RedirectCommand } from '../models';
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';
import { redirectingNavigationError } from '../navigation_canceling_error';
import { DefaultUrlSerializer } from '../url_tree';
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) => {
if (value instanceof RedirectCommand) {
throw redirectingNavigationError(new DefaultUrlSerializer(), 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":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAqC,qBAAqB,EAAC,MAAM,eAAe,CAAC;AACxF,OAAO,EAAC,KAAK,EAAE,IAAI,EAAwC,EAAE,EAAE,UAAU,EAAC,MAAM,MAAM,CAAC;AACvF,OAAO,EAAC,UAAU,EAAE,SAAS,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,GAAG,EAAC,MAAM,gBAAgB,CAAC;AAEjG,OAAO,EAAC,eAAe,EAAc,MAAM,WAAW,CAAC;AAEvD,OAAO,EAEL,YAAY,EACZ,cAAc,GAEf,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAC,aAAa,EAAC,MAAM,WAAW,CAAC;AACxC,OAAO,EAAC,WAAW,EAAE,kBAAkB,EAAC,MAAM,qBAAqB,CAAC;AACpE,OAAO,EAAC,uBAAuB,EAAC,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAC,0BAA0B,EAAC,MAAM,wBAAwB,CAAC;AAClE,OAAO,EAAC,YAAY,EAAC,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAC,0BAA0B,EAAC,MAAM,+BAA+B,CAAC;AACzE,OAAO,EAAC,oBAAoB,EAAC,MAAM,aAAa,CAAC;AAEjD,MAAM,UAAU,WAAW,CACzB,yBAAiD,EACjD,QAA6B;IAE7B,OAAO,QAAQ,CAAC,CAAC,CAAC,EAAE,EAAE;QACpB,MAAM,EACJ,cAAc,EACd,MAAM,EAAE,EAAC,iBAAiB,EAAC,GAC5B,GAAG,CAAC,CAAC;QAEN,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,CAAC;YAC9B,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC;QACf,CAAC;QACD,4FAA4F;QAC5F,+DAA+D;QAC/D,mGAAmG;QACnG,MAAM,wBAAwB,GAAG,IAAI,GAAG,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;QACxF,MAAM,wBAAwB,GAAG,IAAI,GAAG,EAA0B,CAAC;QACnE,KAAK,MAAM,KAAK,IAAI,wBAAwB,EAAE,CAAC;YAC7C,IAAI,wBAAwB,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;gBACxC,SAAS;YACX,CAAC;YACD,wFAAwF;YACxF,KAAK,MAAM,QAAQ,IAAI,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC/C,wBAAwB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YACzC,CAAC;QACH,CAAC;QACD,IAAI,eAAe,GAAG,CAAC,CAAC;QACxB,OAAO,IAAI,CAAC,wBAAwB,CAAC,CAAC,IAAI,CACxC,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE;YAClB,IAAI,wBAAwB,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;gBACxC,OAAO,UAAU,CAAC,KAAK,EAAE,cAAe,EAAE,yBAAyB,EAAE,QAAQ,CAAC,CAAC;YACjF,CAAC;iBAAM,CAAC;gBACN,KAAK,CAAC,IAAI,GAAG,YAAY,CAAC,KAAK,EAAE,KAAK,CAAC,MAAM,EAAE,yBAAyB,CAAC,CAAC,OAAO,CAAC;gBAClF,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;YACpB,CAAC;QACH,CAAC,CAAC,EACF,GAAG,CAAC,GAAG,EAAE,CAAC,eAAe,EAAE,CAAC,EAC5B,QAAQ,CAAC,CAAC,CAAC,EACX,QAAQ,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,eAAe,KAAK,wBAAwB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CACrF,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;GAEG;AACH,SAAS,gBAAgB,CAAC,KAA6B;IACrD,MAAM,WAAW,GAAG,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IAClF,OAAO,CAAC,KAAK,EAAE,GAAG,WAAW,CAAC,CAAC;AACjC,CAAC;AAED,SAAS,UAAU,CACjB,SAAiC,EACjC,SAA8B,EAC9B,yBAAiD,EACjD,QAA6B;IAE7B,MAAM,MAAM,GAAG,SAAS,CAAC,WAAW,CAAC;IACrC,MAAM,OAAO,GAAG,SAAS,CAAC,QAAQ,CAAC;IACnC,IAAI,MAAM,EAAE,KAAK,KAAK,SAAS,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE,CAAC;QAC3D,OAAO,CAAC,aAAa,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;IACxC,CAAC;IACD,OAAO,WAAW,CAAC,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAC,IAAI,CAC9D,GAAG,CAAC,CAAC,YAAiB,EAAE,EAAE;QACxB,SAAS,CAAC,aAAa,GAAG,YAAY,CAAC;QACvC,SAAS,CAAC,IAAI,GAAG,YAAY,CAAC,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,yBAAyB,CAAC,CAAC,OAAO,CAAC;QAC9F,OAAO,IAAI,CAAC;IACd,CAAC,CAAC,CACH,CAAC;AACJ,CAAC;AAED,SAAS,WAAW,CAClB,OAAoB,EACpB,SAAiC,EACjC,SAA8B,EAC9B,QAA6B;IAE7B,MAAM,IAAI,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;IAClC,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACtB,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;IAChB,CAAC;IACD,MAAM,IAAI,GAAgC,EAAE,CAAC;IAC7C,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CACpB,QAAQ,CAAC,CAAC,GAAG,EAAE,EAAE,CACf,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAC,IAAI,CAC5D,KAAK,EAAE,EACP,GAAG,CAAC,CAAC,KAAU,EAAE,EAAE;QACjB,IAAI,KAAK,YAAY,eAAe,EAAE,CAAC;YACrC,MAAM,0BAA0B,CAAC,IAAI,oBAAoB,EAAE,EAAE,KAAK,CAAC,CAAC;QACtE,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;IACpB,CAAC,CAAC,CACH,CACF,EACD,QAAQ,CAAC,CAAC,CAAC,EACX,KAAK,CAAC,IAAI,CAAC,EACX,UAAU,CAAC,CAAC,CAAU,EAAE,EAAE,CAAC,CAAC,YAAY,CAAC,CAAU,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAC/E,CAAC;AACJ,CAAC;AAED,SAAS,WAAW,CAClB,cAA6C,EAC7C,SAAiC,EACjC,SAA8B,EAC9B,QAA6B;IAE7B,MAAM,eAAe,GAAG,uBAAuB,CAAC,SAAS,CAAC,IAAI,QAAQ,CAAC;IACvE,MAAM,QAAQ,GAAG,0BAA0B,CAAC,cAAc,EAAE,eAAe,CAAC,CAAC;IAC7E,MAAM,aAAa,GAAG,QAAQ,CAAC,OAAO;QACpC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,SAAS,EAAE,SAAS,CAAC;QACxC,CAAC,CAAC,qBAAqB,CAAC,eAAe,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC;IACjF,OAAO,kBAAkB,CAAC,aAAa,CAAC,CAAC;AAC3C,CAAC","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.dev/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 {RedirectCommand, ResolveData} from '../models';\nimport {NavigationTransition} from '../navigation_transition';\nimport {\n  ActivatedRouteSnapshot,\n  getInherited,\n  hasStaticTitle,\n  RouterStateSnapshot,\n} 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';\nimport {redirectingNavigationError} from '../navigation_canceling_error';\nimport {DefaultUrlSerializer} from '../url_tree';\n\nexport function resolveData(\n  paramsInheritanceStrategy: 'emptyOnly' | 'always',\n  injector: EnvironmentInjector,\n): MonoTypeOperatorFunction<NavigationTransition> {\n  return mergeMap((t) => {\n    const {\n      targetSnapshot,\n      guards: {canActivateChecks},\n    } = 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).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,\n  futureRSS: RouterStateSnapshot,\n  paramsInheritanceStrategy: 'emptyOnly' | 'always',\n  injector: EnvironmentInjector,\n) {\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(\n    map((resolvedData: any) => {\n      futureARS._resolvedData = resolvedData;\n      futureARS.data = getInherited(futureARS, futureARS.parent, paramsInheritanceStrategy).resolve;\n      return null;\n    }),\n  );\n}\n\nfunction resolveNode(\n  resolve: ResolveData,\n  futureARS: ActivatedRouteSnapshot,\n  futureRSS: RouterStateSnapshot,\n  injector: EnvironmentInjector,\n): 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((key) =>\n      getResolver(resolve[key], futureARS, futureRSS, injector).pipe(\n        first(),\n        tap((value: any) => {\n          if (value instanceof RedirectCommand) {\n            throw redirectingNavigationError(new DefaultUrlSerializer(), value);\n          }\n          data[key] = value;\n        }),\n      ),\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,\n  futureARS: ActivatedRouteSnapshot,\n  futureRSS: RouterStateSnapshot,\n  injector: EnvironmentInjector,\n): 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"]}