refactor(router): Store route injector on ActivatedRoute instance

This eliminates the need to pass around the EnvironmentInjector
everywhere we need the injection context for a route.

Author: atscott

packages/core/test/bundling/router/bundle.golden_symbols.json

@@ -631,7 +631,6 @@
       "getCanActivateChild",
       "getChildRouteGuards",
       "getClosestRElement",
-      "getClosestRouteInjector",
       "getClosureSafeProperty",
       "getComponentDef",
       "getComponentId",

packages/router/src/navigation_transition.ts

@@ -80,7 +80,6 @@ import {UrlHandlingStrategy} from './url_handling_strategy';
 import {UrlSerializer, UrlTree} from './url_tree';
 import {Checks, getAllRouteGuards} from './utils/preactivation';
 import {CREATE_VIEW_TRANSITION} from './utils/view_transition';
-import {getClosestRouteInjector} from './utils/config';
 import {abortSignalToObservable} from './utils/abort_signal_to_observable';
 
 /**
@@ -572,7 +571,10 @@ export class NavigationTransitions {
                 restoredState,
               );
               this.events.next(navStart);
-              const targetSnapshot = createEmptyState(this.rootComponentType).snapshot;
+              const targetSnapshot = createEmptyState(
+                this.rootComponentType,
+                this.environmentInjector,
+              ).snapshot;
 
               this.currentTransition = overallTransitionState = {
                 ...t,
@@ -623,17 +625,12 @@ export class NavigationTransitions {
 
             this.currentTransition = overallTransitionState = {
               ...t,
-              guards: getAllRouteGuards(
-                t.targetSnapshot!,
-                t.currentSnapshot,
-                this.rootContexts,
-                this.environmentInjector,
-              ),
+              guards: getAllRouteGuards(t.targetSnapshot!, t.currentSnapshot, this.rootContexts),
             };
             return overallTransitionState;
           }),
 
-          checkGuards(this.environmentInjector, (evt: Event) => this.events.next(evt)),
+          checkGuards((evt: Event) => this.events.next(evt)),
 
           switchMap((t) => {
             overallTransitionState.guardsResult = t.guardsResult;
@@ -674,7 +671,7 @@ export class NavigationTransitions {
 
             let dataResolved = false;
             return of(t).pipe(
-              resolveData(this.paramsInheritanceStrategy, this.environmentInjector),
+              resolveData(this.paramsInheritanceStrategy),
               tap({
                 next: () => {
                   dataResolved = true;
@@ -708,7 +705,7 @@ export class NavigationTransitions {
               if (route.routeConfig?._loadedComponent) {
                 route.component = route.routeConfig?._loadedComponent;
               } else if (route.routeConfig?.loadComponent) {
-                const injector = getClosestRouteInjector(route) ?? this.environmentInjector;
+                const injector = route._environmentInjector;
                 loaders.push(
                   this.configLoader
                     .loadComponent(injector, route.routeConfig)

packages/router/src/operators/check_guards.ts

@@ -34,7 +34,6 @@ import type {NavigationTransition} from '../navigation_transition';
 import type {ActivatedRouteSnapshot, RouterStateSnapshot} from '../router_state';
 import {UrlSegment, UrlSerializer} from '../url_tree';
 import {wrapIntoObservable} from '../utils/collection';
-import {getClosestRouteInjector} from '../utils/config';
 import {
   CanActivate,
   CanDeactivate,
@@ -54,7 +53,6 @@ import {prioritizedGuardValue} from './prioritized_guard_value';
 import {takeUntilAbort} from '../utils/abort_signal_to_observable';
 
 export function checkGuards(
-  injector: EnvironmentInjector,
   forwardEvent?: (evt: Event) => void,
 ): MonoTypeOperatorFunction<NavigationTransition> {
   return mergeMap((t) => {
@@ -67,15 +65,10 @@ export function checkGuards(
       return of({...t, guardsResult: true});
     }
 
-    return runCanDeactivateChecks(
-      canDeactivateChecks,
-      targetSnapshot!,
-      currentSnapshot,
-      injector,
-    ).pipe(
+    return runCanDeactivateChecks(canDeactivateChecks, targetSnapshot!, currentSnapshot).pipe(
       mergeMap((canDeactivate) => {
         return canDeactivate && isBoolean(canDeactivate)
-          ? runCanActivateChecks(targetSnapshot!, canActivateChecks, injector, forwardEvent)
+          ? runCanActivateChecks(targetSnapshot!, canActivateChecks, forwardEvent)
           : of(canDeactivate);
       }),
       map((guardsResult) => ({...t, guardsResult})),
@@ -87,12 +80,9 @@ function runCanDeactivateChecks(
   checks: CanDeactivate[],
   futureRSS: RouterStateSnapshot,
   currRSS: RouterStateSnapshot,
-  injector: EnvironmentInjector,
 ) {
   return from(checks).pipe(
-    mergeMap((check) =>
-      runCanDeactivate(check.component, check.route, currRSS, futureRSS, injector),
-    ),
+    mergeMap((check) => runCanDeactivate(check.component, check.route, currRSS, futureRSS)),
     first((result) => {
       return result !== true;
     }, true),
@@ -102,16 +92,15 @@ function runCanDeactivateChecks(
 function runCanActivateChecks(
   futureSnapshot: RouterStateSnapshot,
   checks: CanActivate[],
-  injector: EnvironmentInjector,
   forwardEvent?: (evt: Event) => void,
 ) {
   return from(checks).pipe(
     concatMap((check: CanActivate) => {
       return concat(
         fireChildActivationStart(check.route.parent, forwardEvent),
         fireActivationStart(check.route, forwardEvent),
-        runCanActivateChild(futureSnapshot, check.path, injector),
-        runCanActivate(futureSnapshot, check.route, injector),
+        runCanActivateChild(futureSnapshot, check.path),
+        runCanActivate(futureSnapshot, check.route),
       );
     }),
     first((result) => {
@@ -159,14 +148,13 @@ function fireChildActivationStart(
 function runCanActivate(
   futureRSS: RouterStateSnapshot,
   futureARS: ActivatedRouteSnapshot,
-  injector: EnvironmentInjector,
 ): Observable<GuardResult> {
   const canActivate = futureARS.routeConfig ? futureARS.routeConfig.canActivate : null;
   if (!canActivate || canActivate.length === 0) return of(true);
 
   const canActivateObservables = canActivate.map((canActivate) => {
     return defer(() => {
-      const closestInjector = getClosestRouteInjector(futureARS) ?? injector;
+      const closestInjector = futureARS._environmentInjector;
       const guard = getTokenOrFunctionIdentity<CanActivate>(
         canActivate as ProviderToken<CanActivate>,
         closestInjector,
@@ -185,7 +173,6 @@ function runCanActivate(
 function runCanActivateChild(
   futureRSS: RouterStateSnapshot,
   path: ActivatedRouteSnapshot[],
-  injector: EnvironmentInjector,
 ): Observable<GuardResult> {
   const futureARS = path[path.length - 1];
 
@@ -199,7 +186,7 @@ function runCanActivateChild(
     return defer(() => {
       const guardsMapped = d.guards.map(
         (canActivateChild: CanActivateChildFn | ProviderToken<unknown>) => {
-          const closestInjector = getClosestRouteInjector(d.node) ?? injector;
+          const closestInjector = d.node._environmentInjector;
           const guard = getTokenOrFunctionIdentity<{canActivateChild: CanActivateChildFn}>(
             canActivateChild,
             closestInjector,
@@ -223,12 +210,11 @@ function runCanDeactivate(
   currARS: ActivatedRouteSnapshot,
   currRSS: RouterStateSnapshot,
   futureRSS: RouterStateSnapshot,
-  injector: EnvironmentInjector,
 ): Observable<GuardResult> {
   const canDeactivate = currARS && currARS.routeConfig ? currARS.routeConfig.canDeactivate : null;
   if (!canDeactivate || canDeactivate.length === 0) return of(true);
   const canDeactivateObservables = canDeactivate.map((c: any) => {
-    const closestInjector = getClosestRouteInjector(currARS) ?? injector;
+    const closestInjector = currARS._environmentInjector;
     const guard = getTokenOrFunctionIdentity<any>(c, closestInjector);
     const guardVal = isCanDeactivate(guard)
       ? guard.canDeactivate(component, currARS, currRSS, futureRSS)

packages/router/src/operators/resolve_data.ts

@@ -20,15 +20,13 @@ import {
 } 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: 'emptyOnly' | 'always',
-  injector: EnvironmentInjector,
 ): MonoTypeOperatorFunction<NavigationTransition> {
   return mergeMap((t) => {
     const {
@@ -57,7 +55,7 @@ export function resolveData(
     return from(routesNeedingDataUpdates).pipe(
       concatMap((route) => {
         if (routesWithResolversToRun.has(route)) {
-          return runResolve(route, targetSnapshot!, paramsInheritanceStrategy, injector);
+          return runResolve(route, targetSnapshot!, paramsInheritanceStrategy);
         } else {
           route.data = getInherited(route, route.parent, paramsInheritanceStrategy).resolve;
           return of(void 0);
@@ -82,7 +80,6 @@ function runResolve(
   futureARS: ActivatedRouteSnapshot,
   futureRSS: RouterStateSnapshot,
   paramsInheritanceStrategy: 'emptyOnly' | 'always',
-  injector: EnvironmentInjector,
 ) {
   const config = futureARS.routeConfig;
   const resolve = futureARS._resolve;
@@ -91,7 +88,7 @@ function runResolve(
   }
   return defer(() => {
     futureARS.data = getInherited(futureARS, futureARS.parent, paramsInheritanceStrategy).resolve;
-    return resolveNode(resolve, futureARS, futureRSS, injector).pipe(
+    return resolveNode(resolve, futureARS, futureRSS).pipe(
       map((resolvedData: any) => {
         futureARS._resolvedData = resolvedData;
         futureARS.data = {...futureARS.data, ...resolvedData};
@@ -105,7 +102,6 @@ function resolveNode(
   resolve: ResolveData,
   futureARS: ActivatedRouteSnapshot,
   futureRSS: RouterStateSnapshot,
-  injector: EnvironmentInjector,
 ): Observable<any> {
   const keys = getDataKeys(resolve);
   if (keys.length === 0) {
@@ -114,7 +110,7 @@ function resolveNode(
   const data: {[k: string | symbol]: any} = {};
   return from(keys).pipe(
     mergeMap((key) =>
-      getResolver(resolve[key], futureARS, futureRSS, injector).pipe(
+      getResolver(resolve[key], futureARS, futureRSS).pipe(
         first(),
         tap((value: any) => {
           if (value instanceof RedirectCommand) {
@@ -134,9 +130,8 @@ function getResolver(
   injectionToken: ProviderToken<any> | Function,
   futureARS: ActivatedRouteSnapshot,
   futureRSS: RouterStateSnapshot,
-  injector: EnvironmentInjector,
 ): Observable<any> {
-  const closestInjector = getClosestRouteInjector(futureARS) ?? injector;
+  const closestInjector = futureARS._environmentInjector;
   const resolver = getTokenOrFunctionIdentity(injectionToken, closestInjector);
   const resolverValue = resolver.resolve
     ? resolver.resolve(futureARS, futureRSS)

packages/router/src/recognize.ts

@@ -128,6 +128,7 @@ export class Recognizer {
       this.rootComponentType,
       null,
       {},
+      this.injector,
     );
     try {
       const children = await this.processSegmentGroup(
@@ -357,6 +358,7 @@ export class Recognizer {
       route.component ?? route._loadedComponent ?? null,
       route,
       getResolve(route),
+      injector,
     );
     const inherited = getInherited(currentSnapshot, parentRoute, this.paramsInheritanceStrategy);
     currentSnapshot.params = Object.freeze(inherited.params);
@@ -425,6 +427,7 @@ export class Recognizer {
       route.component ?? route._loadedComponent ?? null,
       route,
       getResolve(route),
+      injector,
     );
     const inherited = getInherited(snapshot, parentRoute, this.paramsInheritanceStrategy);
     snapshot.params = Object.freeze(inherited.params);

packages/router/src/recognize_rxjs.ts

@@ -147,6 +147,7 @@ export class Recognizer {
       this.rootComponentType,
       null,
       {},
+      this.injector,
     );
     return this.processSegmentGroup(
       this.injector,
@@ -385,6 +386,7 @@ export class Recognizer {
       route.component ?? route._loadedComponent ?? null,
       route,
       getResolve(route),
+      injector,
     );
     const inherited = getInherited(currentSnapshot, parentRoute, this.paramsInheritanceStrategy);
     currentSnapshot.params = Object.freeze(inherited.params);
@@ -452,6 +454,7 @@ export class Recognizer {
               route.component ?? route._loadedComponent ?? null,
               route,
               getResolve(route),
+              injector,
             );
             const inherited = getInherited(snapshot, parentRoute, this.paramsInheritanceStrategy);
             snapshot.params = Object.freeze(inherited.params);

packages/router/src/router_outlet_context.ts

@@ -10,7 +10,6 @@ import {ComponentRef, EnvironmentInjector, Injectable} from '@angular/core';
 
 import type {RouterOutletContract} from './directives/router_outlet';
 import {ActivatedRoute} from './router_state';
-import {getClosestRouteInjector} from './utils/config';
 
 /**
  * Store contextual information about a `RouterOutlet`
@@ -23,7 +22,7 @@ export class OutletContext {
   children: ChildrenOutletContexts;
   attachRef: ComponentRef<any> | null = null;
   get injector(): EnvironmentInjector {
-    return getClosestRouteInjector(this.route?.snapshot) ?? this.rootInjector;
+    return this.route?.snapshot._environmentInjector ?? this.rootInjector;
   }
 
   constructor(private readonly rootInjector: EnvironmentInjector) {

packages/router/src/router_state.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 
-import {Type} from '@angular/core';
+import {EnvironmentInjector, Type} from '@angular/core';
 import {BehaviorSubject, Observable, of} from 'rxjs';
 import {map} from 'rxjs/operators';
 
@@ -63,8 +63,11 @@ export class RouterState extends Tree<ActivatedRoute> {
   }
 }
 
-export function createEmptyState(rootComponent: Type<any> | null): RouterState {
-  const snapshot = createEmptyStateSnapshot(rootComponent);
+export function createEmptyState(
+  rootComponent: Type<any> | null,
+  injector: EnvironmentInjector,
+): RouterState {
+  const snapshot = createEmptyStateSnapshot(rootComponent, injector);
   const emptyUrl = new BehaviorSubject([new UrlSegment('', {})]);
   const emptyParams = new BehaviorSubject({});
   const emptyData = new BehaviorSubject({});
@@ -84,7 +87,10 @@ export function createEmptyState(rootComponent: Type<any> | null): RouterState {
   return new RouterState(new TreeNode<ActivatedRoute>(activated, []), snapshot);
 }
 
-export function createEmptyStateSnapshot(rootComponent: Type<any> | null): RouterStateSnapshot {
+export function createEmptyStateSnapshot(
+  rootComponent: Type<any> | null,
+  injector: EnvironmentInjector,
+): RouterStateSnapshot {
   const emptyParams = {};
   const emptyData = {};
   const emptyQueryParams = {};
@@ -99,6 +105,7 @@ export function createEmptyStateSnapshot(rootComponent: Type<any> | null): Route
     rootComponent,
     null,
     {},
+    injector,
   );
   return new RouterStateSnapshot('', new TreeNode<ActivatedRouteSnapshot>(activated, []));
 }
@@ -332,6 +339,8 @@ export class ActivatedRouteSnapshot {
   _paramMap?: ParamMap;
   /** @internal */
   _queryParamMap?: ParamMap;
+  /** @internal */
+  readonly _environmentInjector: EnvironmentInjector;
 
   /** The resolved route title */
   get title(): string | undefined {
@@ -376,9 +385,11 @@ export class ActivatedRouteSnapshot {
     public component: Type<any> | null,
     routeConfig: Route | null,
     resolve: ResolveData,
+    environmentInjector: EnvironmentInjector,
   ) {
     this.routeConfig = routeConfig;
     this._resolve = resolve;
+    this._environmentInjector = environmentInjector;
   }
 
   /** The root of the router state */

packages/router/src/statemanager/state_manager.ts

@@ -7,7 +7,7 @@
  */
 
 import {Location} from '@angular/common';
-import {inject, Injectable} from '@angular/core';
+import {EnvironmentInjector, inject, Injectable} from '@angular/core';
 import {SubscriptionLike} from 'rxjs';
 
 import {
@@ -104,7 +104,7 @@ export abstract class StateManager {
     }
   }
 
-  protected routerState = createEmptyState(null);
+  protected routerState = createEmptyState(null, inject(EnvironmentInjector));
 
   /** Returns the current RouterState. */
   getRouterState(): RouterState {