fix(router): inconsistent router state, missing execution of data resolvers

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

@@ -1883,9 +1883,6 @@
   {
     "name": "resetPreOrderHookFlags"
   },
-  {
-    "name": "resolveData"
-  },
   {
     "name": "resolveForwardRef"
   },

packages/router/src/operators/resolve_data.ts

@@ -28,21 +28,25 @@ export function resolveData(
     if (!canActivateChecks.length) {
       return of(t);
     }
-    const routesWithResolversToRun = canActivateChecks.map(check => check.route);
-    const routesWithResolversSet = new Set(routesWithResolversToRun);
-    const routesNeedingDataUpdates =
-        // List all ActivatedRoutes in an array, starting from the parent of the first route to run
-        // resolvers. We go from the parent because the first route might have siblings that also
-        // run resolvers.
-        flattenRouteTree(routesWithResolversToRun[0].parent!)
-            // Remove the parent from the list -- we do not need to recompute its inherited data
-            // because no resolvers at or above it run.
-            .slice(1);
+    // 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<ActivatedRouteSnapshot>();
+    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 (routesWithResolversSet.has(route)) {
+              if (routesWithResolversToRun.has(route)) {
                 return runResolve(route, targetSnapshot!, paramsInheritanceStrategy, injector);
               } else {
                 route.data = getInherited(route, route.parent, paramsInheritanceStrategy).resolve;
@@ -51,7 +55,7 @@ export function resolveData(
             }),
             tap(() => routesProcessed++),
             takeLast(1),
-            mergeMap(_ => routesProcessed === routesNeedingDataUpdates.length ? of(t) : EMPTY),
+            mergeMap(_ => routesProcessed === routesNeedingDataUpdates.size ? of(t) : EMPTY),
         );
   });
 }

packages/router/test/operators/resolve_data.spec.ts

@@ -46,6 +46,44 @@ describe('resolveData operator', () => {
     expect(TestBed.inject(Router).url).toEqual('/');
   });
 
+  it('should run resolvers in different parts of the tree', async () => {
+    let value = 0;
+    let bValue = 0;
+    TestBed.configureTestingModule({
+      providers: [provideRouter([
+        {
+          path: 'a',
+          runGuardsAndResolvers: () => false,
+          children: [{
+            path: '',
+            resolve: {d0: () => ++value},
+            runGuardsAndResolvers: 'always',
+            children: [],
+          }],
+        },
+        {
+          path: 'b',
+          outlet: 'aux',
+          runGuardsAndResolvers: () => false,
+          children: [{
+            path: '',
+            resolve: {d1: () => ++bValue},
+            runGuardsAndResolvers: 'always',
+            children: [],
+          }]
+        },
+      ])]
+    });
+    const router = TestBed.inject(Router);
+    const harness = await RouterTestingHarness.create('/a(aux:b)');
+    expect(router.routerState.root.children[0]?.firstChild?.snapshot.data).toEqual({d0: 1});
+    expect(router.routerState.root.children[1]?.firstChild?.snapshot.data).toEqual({d1: 1});
+
+    await harness.navigateByUrl('/a(aux:b)#new');
+    expect(router.routerState.root.children[0]?.firstChild?.snapshot.data).toEqual({d0: 2});
+    expect(router.routerState.root.children[1]?.firstChild?.snapshot.data).toEqual({d1: 2});
+  });
+
   it('should update children inherited data when resolvers run', async () => {
     let value = 0;
     TestBed.configureTestingModule({