@tanstack/react-router 1.28.3 → 1.28.5

package/dist/cjs/router.cjs

@@ -597,42 +597,51 @@ class Router {
         });
         return updated;
       };
-      const handleMatchSpecialError = (match, err) => {
-        updateMatch(match.id, (prev) => ({
-          ...prev,
-          status: redirects.isRedirect(err) ? "redirected" : notFound.isNotFound(err) ? "notFound" : "error",
-          isFetching: false,
-          error: err
-        }));
-        if (!err.routeId) {
-          err.routeId = match.routeId;
-        }
-        throw err;
-      };
       try {
         await new Promise((resolveAll, rejectAll) => {
           ;
           (async () => {
             var _a, _b;
             try {
+              const handleRedirectAndNotFound = (match, err) => {
+                if (redirects.isRedirect(err) || notFound.isNotFound(err)) {
+                  updateMatch(match.id, (prev) => ({
+                    ...prev,
+                    status: redirects.isRedirect(err) ? "redirected" : notFound.isNotFound(err) ? "notFound" : "error",
+                    isFetching: false,
+                    error: err
+                  }));
+                  if (!err.routeId) {
+                    ;
+                    err.routeId = match.routeId;
+                  }
+                  if (redirects.isRedirect(err)) {
+                    const redirect = this.resolveRedirect(err);
+                    if (!preload && !this.isServer) {
+                      this.navigate({ ...redirect, replace: true });
+                    }
+                    throw redirect;
+                  } else if (notFound.isNotFound(err)) {
+                    if (!preload)
+                      this.handleNotFound(matches, err);
+                    throw err;
+                  }
+                }
+              };
               for (let [index, match] of matches.entries()) {
                 const parentMatch = matches[index - 1];
                 const route2 = this.looseRoutesById[match.routeId];
                 const abortController = new AbortController();
-                const handleSerialError = (err, code) => {
+                const handleSerialError = (err, routerCode) => {
                   var _a2, _b2;
-                  err.routerCode = code;
+                  err.routerCode = routerCode;
                   firstBadMatchIndex = firstBadMatchIndex ?? index;
-                  if (redirects.isRedirect(err) || notFound.isNotFound(err)) {
-                    handleMatchSpecialError(match, err);
-                  }
+                  handleRedirectAndNotFound(match, err);
                   try {
                     (_b2 = (_a2 = route2.options).onError) == null ? void 0 : _b2.call(_a2, err);
                   } catch (errorHandlerErr) {
                     err = errorHandlerErr;
-                    if (redirects.isRedirect(err) || notFound.isNotFound(err)) {
-                      handleMatchSpecialError(match, errorHandlerErr);
-                    }
+                    handleRedirectAndNotFound(match, err);
                   }
                   matches[index] = match = {
                     ...match,
@@ -681,15 +690,15 @@ class Router {
                     ...parentContext,
                     ...beforeLoadContext
                   };
-                  matches[index] = match = {
-                    ...match,
+                  matches[index] = match = updateMatch(match.id, (prev) => ({
+                    ...prev,
                     routeContext: utils.replaceEqualDeep(
                       match.routeContext,
                       beforeLoadContext
                     ),
                     context: utils.replaceEqualDeep(match.context, context),
                     abortController
-                  };
+                  }));
                 } catch (err) {
                   handleSerialError(err, "BEFORE_LOAD");
                   break;
@@ -701,11 +710,6 @@ class Router {
                 validResolvedMatches.map(async (match, index) => {
                   const parentMatchPromise = matchPromises[index - 1];
                   const route2 = this.looseRoutesById[match.routeId];
-                  const handleError = (err) => {
-                    if (redirects.isRedirect(err) || notFound.isNotFound(err)) {
-                      handleMatchSpecialError(match, err);
-                    }
-                  };
                   const loaderContext = {
                     params: match.params,
                     deps: match.loaderDeps,
@@ -775,7 +779,7 @@ class Router {
                       const loaderData = await loaderPromise;
                       if (latestPromise = checkLatest())
                         return await latestPromise;
-                      handleError(loaderData);
+                      handleRedirectAndNotFound(match, loaderData);
                       if (latestPromise = checkLatest())
                         return await latestPromise;
                       await potentialPendingMinPromise();
@@ -805,12 +809,12 @@ class Router {
                       await potentialPendingMinPromise();
                       if (latestPromise = checkLatest())
                         return await latestPromise;
-                      handleError(e);
+                      handleRedirectAndNotFound(match, e);
                       try {
                         (_i = (_h = route2.options).onError) == null ? void 0 : _i.call(_h, e);
                       } catch (onErrorError) {
                         error = onErrorError;
-                        handleError(onErrorError);
+                        handleRedirectAndNotFound(match, onErrorError);
                       }
                       matches[index] = match = updateMatch(match.id, (prev) => ({
                         ...prev,
@@ -832,32 +836,21 @@ class Router {
                     ...match,
                     preload: !!preload && !this.state.matches.find((d) => d.id === match.id)
                   };
-                  const fetchWithRedirect = async () => {
+                  const fetchWithRedirectAndNotFound = async () => {
                     try {
                       await fetch();
                     } catch (err) {
                       if (latestPromise = checkLatest())
                         return await latestPromise;
-                      if (redirects.isRedirect(err)) {
-                        const redirect = this.resolveRedirect(err);
-                        if (!preload && !this.isServer) {
-                          this.navigate({ ...redirect, replace: true });
-                        }
-                        throw redirect;
-                      } else if (notFound.isNotFound(err)) {
-                        if (!preload)
-                          this.handleNotFound(matches, err);
-                        throw err;
-                      }
-                      handleError(err);
+                      handleRedirectAndNotFound(match, err);
                     }
                   };
                   if (match.status === "success" && (match.invalid || (shouldReload ?? age > staleAge))) {
-                    fetchWithRedirect();
+                    fetchWithRedirectAndNotFound();
                     return;
                   }
                   if (match.status !== "success") {
-                    await fetchWithRedirect();
+                    await fetchWithRedirectAndNotFound();
                   }
                 })
               );