@tanstack/router-core 1.131.17 → 1.131.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/router-core",
-  "version": "1.131.17",
+  "version": "1.131.19",
   "description": "Modern and scalable routing for React applications",
   "author": "Tanner Linsley",
   "license": "MIT",

package/src/router.ts

@@ -2697,10 +2697,12 @@ export class RouterCore<
             this.getMatch(matchId),
             loaderData,
           )
-          innerLoadContext.updateMatch(matchId, (prev) => ({
-            ...prev,
-            loaderData,
-          }))
+          if (loaderData !== undefined) {
+            innerLoadContext.updateMatch(matchId, (prev) => ({
+              ...prev,
+              loaderData,
+            }))
+          }
         }
 
         // Lazy option can modify the route options,
@@ -2837,14 +2839,16 @@ export class RouterCore<
             )
           : shouldReloadOption
 
-      innerLoadContext.updateMatch(matchId, (prev) => {
-        prev._nonReactive.loaderPromise = createControlledPromise<void>()
-        return {
+      const nextPreload =
+        !!preload && !this.state.matches.some((d) => d.id === matchId)
+      const match = this.getMatch(matchId)!
+      match._nonReactive.loaderPromise = createControlledPromise<void>()
+      if (nextPreload !== match.preload) {
+        innerLoadContext.updateMatch(matchId, (prev) => ({
           ...prev,
-          preload:
-            !!preload && !this.state.matches.some((d) => d.id === matchId),
-        }
-      })
+          preload: nextPreload,
+        }))
+      }
 
       // If the route is successful and still fresh, just resolve
       const { status, invalid } = this.getMatch(matchId)!
@@ -2886,23 +2890,24 @@ export class RouterCore<
         }
       }
     }
+    const match = this.getMatch(matchId)!
     if (!loaderIsRunningAsync) {
-      const match = this.getMatch(matchId)!
       match._nonReactive.loaderPromise?.resolve()
       match._nonReactive.loadPromise?.resolve()
     }
 
-    innerLoadContext.updateMatch(matchId, (prev) => {
-      clearTimeout(prev._nonReactive.pendingTimeout)
-      prev._nonReactive.pendingTimeout = undefined
-      if (!loaderIsRunningAsync) prev._nonReactive.loaderPromise = undefined
-      prev._nonReactive.dehydrated = undefined
-      return {
+    clearTimeout(match._nonReactive.pendingTimeout)
+    match._nonReactive.pendingTimeout = undefined
+    if (!loaderIsRunningAsync) match._nonReactive.loaderPromise = undefined
+    match._nonReactive.dehydrated = undefined
+    const nextIsFetching = loaderIsRunningAsync ? match.isFetching : false
+    if (nextIsFetching !== match.isFetching || match.invalid !== false) {
+      innerLoadContext.updateMatch(matchId, (prev) => ({
         ...prev,
-        isFetching: loaderIsRunningAsync ? prev.isFetching : false,
+        isFetching: nextIsFetching,
         invalid: false,
-      }
-    })
+      }))
+    }
     return this.getMatch(matchId)!
   }
 
@@ -2925,33 +2930,22 @@ export class RouterCore<
     }
 
     try {
-      await new Promise<void>((resolveAll, rejectAll) => {
-        ;(async () => {
-          try {
-            // Execute all beforeLoads one by one
-            for (let i = 0; i < innerLoadContext.matches.length; i++) {
-              const beforeLoad = this.handleBeforeLoad(innerLoadContext, i)
-              if (isPromise(beforeLoad)) await beforeLoad
-            }
-
-            // Execute all loaders in parallel
-            const max =
-              innerLoadContext.firstBadMatchIndex ??
-              innerLoadContext.matches.length
-            for (let i = 0; i < max; i++) {
-              innerLoadContext.matchPromises.push(
-                this.loadRouteMatch(innerLoadContext, i),
-              )
-            }
+      // Execute all beforeLoads one by one
+      for (let i = 0; i < innerLoadContext.matches.length; i++) {
+        const beforeLoad = this.handleBeforeLoad(innerLoadContext, i)
+        if (isPromise(beforeLoad)) await beforeLoad
+      }
 
-            await Promise.all(innerLoadContext.matchPromises)
+      // Execute all loaders in parallel
+      const max =
+        innerLoadContext.firstBadMatchIndex ?? innerLoadContext.matches.length
+      for (let i = 0; i < max; i++) {
+        innerLoadContext.matchPromises.push(
+          this.loadRouteMatch(innerLoadContext, i),
+        )
+      }
+      await Promise.all(innerLoadContext.matchPromises)
 
-            resolveAll()
-          } catch (err) {
-            rejectAll(err)
-          }
-        })()
-      })
       const readyPromise = this.triggerOnReady(innerLoadContext)
       if (isPromise(readyPromise)) await readyPromise
     } catch (err) {