@tanstack/router-core 1.131.7 → 1.131.13

package/package.json

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

package/src/router.ts

@@ -1393,8 +1393,8 @@ export class RouterCore<
     if (!match) return
 
     match.abortController.abort()
-    match._nonReactive.pendingTimeout = undefined
     clearTimeout(match._nonReactive.pendingTimeout)
+    match._nonReactive.pendingTimeout = undefined
   }
 
   cancelMatches = () => {
@@ -2121,50 +2121,52 @@ export class RouterCore<
       triggerOnReady()
     }
 
-    const handleRedirectAndNotFound = (match: AnyRouteMatch, err: any) => {
-      if (isRedirect(err) || isNotFound(err)) {
-        if (isRedirect(err)) {
-          if (err.redirectHandled) {
-            if (!err.options.reloadDocument) {
-              throw err
-            }
-          }
-        }
+    const handleRedirectAndNotFound = (
+      match: AnyRouteMatch | undefined,
+      err: unknown,
+    ) => {
+      if (!isRedirect(err) && !isNotFound(err)) return
+
+      if (
+        isRedirect(err) &&
+        err.redirectHandled &&
+        !err.options.reloadDocument
+      ) {
+        throw err
+      }
 
+      // in case of a redirecting match during preload, the match does not exist
+      if (match) {
         match._nonReactive.beforeLoadPromise?.resolve()
         match._nonReactive.loaderPromise?.resolve()
         match._nonReactive.beforeLoadPromise = undefined
         match._nonReactive.loaderPromise = undefined
 
+        const status = isRedirect(err) ? 'redirected' : 'notFound'
+
         updateMatch(match.id, (prev) => ({
           ...prev,
-          status: isRedirect(err)
-            ? 'redirected'
-            : isNotFound(err)
-              ? 'notFound'
-              : 'error',
+          status,
           isFetching: false,
           error: err,
         }))
 
-        if (!(err as any).routeId) {
-          ;(err as any).routeId = match.routeId
+        if (isNotFound(err) && !err.routeId) {
+          err.routeId = match.routeId
         }
 
         match._nonReactive.loadPromise?.resolve()
+      }
 
-        if (isRedirect(err)) {
-          rendered = true
-          err.options._fromLocation = location
-          err.redirectHandled = true
-          err = this.resolveRedirect(err)
-          throw err
-        } else if (isNotFound(err)) {
-          this._handleNotFound(matches, err, {
-            updateMatch,
-          })
-          throw err
-        }
+      if (isRedirect(err)) {
+        rendered = true
+        err.options._fromLocation = location
+        err.redirectHandled = true
+        err = this.resolveRedirect(err)
+        throw err
+      } else {
+        this._handleNotFound(matches, err, updateMatch)
+        throw err
       }
     }
 
@@ -2204,13 +2206,13 @@ export class RouterCore<
 
               err.routerCode = routerCode
               firstBadMatchIndex = firstBadMatchIndex ?? index
-              handleRedirectAndNotFound(this.getMatch(matchId)!, err)
+              handleRedirectAndNotFound(this.getMatch(matchId), err)
 
               try {
                 route.options.onError?.(err)
               } catch (errorHandlerErr) {
                 err = errorHandlerErr
-                handleRedirectAndNotFound(this.getMatch(matchId)!, err)
+                handleRedirectAndNotFound(this.getMatch(matchId), err)
               }
 
               updateMatch(matchId, (prev) => {
@@ -2465,35 +2467,45 @@ export class RouterCore<
                   let loaderIsRunningAsync = false
                   const route = this.looseRoutesById[routeId]!
 
-                  const executeHead = async () => {
+                  const executeHead = () => {
                     const match = this.getMatch(matchId)
                     // in case of a redirecting match during preload, the match does not exist
                     if (!match) {
                       return
                     }
+                    if (
+                      !route.options.head &&
+                      !route.options.scripts &&
+                      !route.options.headers
+                    ) {
+                      return
+                    }
                     const assetContext = {
                       matches,
                       match,
                       params: match.params,
                       loaderData: match.loaderData,
                     }
-                    const headFnContent =
-                      await route.options.head?.(assetContext)
-                    const meta = headFnContent?.meta
-                    const links = headFnContent?.links
-                    const headScripts = headFnContent?.scripts
-                    const styles = headFnContent?.styles
-
-                    const scripts = await route.options.scripts?.(assetContext)
-                    const headers = await route.options.headers?.(assetContext)
-                    return {
-                      meta,
-                      links,
-                      headScripts,
-                      headers,
-                      scripts,
-                      styles,
-                    }
+
+                    return Promise.all([
+                      route.options.head?.(assetContext),
+                      route.options.scripts?.(assetContext),
+                      route.options.headers?.(assetContext),
+                    ]).then(([headFnContent, scripts, headers]) => {
+                      const meta = headFnContent?.meta
+                      const links = headFnContent?.links
+                      const headScripts = headFnContent?.scripts
+                      const styles = headFnContent?.styles
+
+                      return {
+                        meta,
+                        links,
+                        headScripts,
+                        headers,
+                        scripts,
+                        styles,
+                      }
+                    })
                   }
 
                   const potentialPendingMinPromise = async () => {
@@ -2506,11 +2518,14 @@ export class RouterCore<
                   const prevMatch = this.getMatch(matchId)!
                   if (shouldSkipLoader(matchId)) {
                     if (this.isServer) {
-                      const head = await executeHead()
-                      updateMatch(matchId, (prev) => ({
-                        ...prev,
-                        ...head,
-                      }))
+                      const headResult = executeHead()
+                      if (headResult) {
+                        const head = await headResult
+                        updateMatch(matchId, (prev) => ({
+                          ...prev,
+                          ...head,
+                        }))
+                      }
                       return this.getMatch(matchId)!
                     }
                   }
@@ -2622,7 +2637,7 @@ export class RouterCore<
                             await route.options.loader?.(getLoaderContext())
 
                           handleRedirectAndNotFound(
-                            this.getMatch(matchId)!,
+                            this.getMatch(matchId),
                             loaderData,
                           )
                           updateMatch(matchId, (prev) => ({
@@ -2634,7 +2649,8 @@ export class RouterCore<
                           // so we need to wait for it to resolve before
                           // we can use the options
                           await route._lazyPromise
-                          const head = await executeHead()
+                          const headResult = executeHead()
+                          const head = headResult ? await headResult : undefined
                           await potentialPendingMinPromise()
 
                           // Last but not least, wait for the the components
@@ -2653,18 +2669,19 @@ export class RouterCore<
 
                           await potentialPendingMinPromise()
 
-                          handleRedirectAndNotFound(this.getMatch(matchId)!, e)
+                          handleRedirectAndNotFound(this.getMatch(matchId), e)
 
                           try {
                             route.options.onError?.(e)
                           } catch (onErrorError) {
                             error = onErrorError
                             handleRedirectAndNotFound(
-                              this.getMatch(matchId)!,
+                              this.getMatch(matchId),
                               onErrorError,
                             )
                           }
-                          const head = await executeHead()
+                          const headResult = executeHead()
+                          const head = headResult ? await headResult : undefined
                           updateMatch(matchId, (prev) => ({
                             ...prev,
                             error,
@@ -2674,16 +2691,20 @@ export class RouterCore<
                           }))
                         }
                       } catch (err) {
-                        const head = await executeHead()
-
-                        updateMatch(matchId, (prev) => {
-                          prev._nonReactive.loaderPromise = undefined
-                          return {
-                            ...prev,
-                            ...head,
+                        const match = this.getMatch(matchId)
+                        // in case of a redirecting match during preload, the match does not exist
+                        if (match) {
+                          const headResult = executeHead()
+                          if (headResult) {
+                            const head = await headResult
+                            updateMatch(matchId, (prev) => ({
+                              ...prev,
+                              ...head,
+                            }))
                           }
-                        })
-                        handleRedirectAndNotFound(this.getMatch(matchId)!, err)
+                          match._nonReactive.loaderPromise = undefined
+                        }
+                        handleRedirectAndNotFound(match, err)
                       }
                     }
 
@@ -2718,11 +2739,14 @@ export class RouterCore<
                       // if the loader did not run, still update head.
                       // reason: parent's beforeLoad may have changed the route context
                       // and only now do we know the route context (and that the loader would not run)
-                      const head = await executeHead()
-                      updateMatch(matchId, (prev) => ({
-                        ...prev,
-                        ...head,
-                      }))
+                      const headResult = executeHead()
+                      if (headResult) {
+                        const head = await headResult
+                        updateMatch(matchId, (prev) => ({
+                          ...prev,
+                          ...head,
+                        }))
+                      }
                     }
                   }
                   if (!loaderIsRunningAsync) {
@@ -3035,14 +3059,10 @@ export class RouterCore<
   _handleNotFound = (
     matches: Array<AnyRouteMatch>,
     err: NotFoundError,
-    {
-      updateMatch = this.updateMatch,
-    }: {
-      updateMatch?: (
-        id: string,
-        updater: (match: AnyRouteMatch) => AnyRouteMatch,
-      ) => void
-    } = {},
+    updateMatch: (
+      id: string,
+      updater: (match: AnyRouteMatch) => AnyRouteMatch,
+    ) => void = this.updateMatch,
   ) => {
     // Find the route that should handle the not found error
     // First check if a specific route is requested to show the error
@@ -3088,9 +3108,7 @@ export class RouterCore<
 
     if ((err as any).routerCode === 'BEFORE_LOAD' && routeCursor.parentRoute) {
       err.routeId = routeCursor.parentRoute.id
-      this._handleNotFound(matches, err, {
-        updateMatch,
-      })
+      this._handleNotFound(matches, err, updateMatch)
     }
   }