@tanstack/router-core 1.131.16 → 1.131.18

package/dist/esm/router.js

@@ -859,10 +859,7 @@ class RouterCore {
       const match = this.getMatch(matchId);
       if (shouldPending && match._nonReactive.pendingTimeout === void 0) {
         const pendingTimeout = setTimeout(() => {
-          try {
-            this.triggerOnReady(innerLoadContext);
-          } catch {
-          }
+          this.triggerOnReady(innerLoadContext);
         }, pendingMs);
         match._nonReactive.pendingTimeout = pendingTimeout;
       }
@@ -885,103 +882,122 @@ class RouterCore {
       return existingMatch._nonReactive.beforeLoadPromise ? existingMatch._nonReactive.beforeLoadPromise.then(then) : then();
     };
     this.executeBeforeLoad = (innerLoadContext, matchId, index, route) => {
-      var _a, _b, _c;
+      var _a;
+      const match = this.getMatch(matchId);
+      match._nonReactive.beforeLoadPromise = createControlledPromise();
+      const prevLoadPromise = match._nonReactive.loadPromise;
+      match._nonReactive.loadPromise = createControlledPromise(() => {
+        prevLoadPromise == null ? void 0 : prevLoadPromise.resolve();
+      });
+      const { paramsError, searchError } = match;
+      if (paramsError) {
+        this.handleSerialError(
+          innerLoadContext,
+          index,
+          paramsError,
+          "PARSE_PARAMS"
+        );
+      }
+      if (searchError) {
+        this.handleSerialError(
+          innerLoadContext,
+          index,
+          searchError,
+          "VALIDATE_SEARCH"
+        );
+      }
+      this.setupPendingTimeout(innerLoadContext, matchId, route);
+      const abortController = new AbortController();
+      const parentMatchId = (_a = innerLoadContext.matches[index - 1]) == null ? void 0 : _a.id;
+      const parentMatch = parentMatchId ? this.getMatch(parentMatchId) : void 0;
+      const parentMatchContext = (parentMatch == null ? void 0 : parentMatch.context) ?? this.options.context ?? void 0;
+      const context = { ...parentMatchContext, ...match.__routeContext };
+      let isPending = false;
+      const pending = () => {
+        if (isPending) return;
+        isPending = true;
+        innerLoadContext.updateMatch(matchId, (prev) => ({
+          ...prev,
+          isFetching: "beforeLoad",
+          fetchCount: prev.fetchCount + 1,
+          abortController,
+          context
+        }));
+      };
       const resolve = () => {
-        innerLoadContext.updateMatch(matchId, (prev) => {
-          var _a2;
-          (_a2 = prev._nonReactive.beforeLoadPromise) == null ? void 0 : _a2.resolve();
-          prev._nonReactive.beforeLoadPromise = void 0;
-          return {
-            ...prev,
-            isFetching: false
-          };
-        });
+        var _a2;
+        (_a2 = match._nonReactive.beforeLoadPromise) == null ? void 0 : _a2.resolve();
+        match._nonReactive.beforeLoadPromise = void 0;
+        innerLoadContext.updateMatch(matchId, (prev) => ({
+          ...prev,
+          isFetching: false
+        }));
       };
-      try {
-        const match = this.getMatch(matchId);
-        match._nonReactive.beforeLoadPromise = createControlledPromise();
-        const prevLoadPromise = match._nonReactive.loadPromise;
-        match._nonReactive.loadPromise = createControlledPromise(() => {
-          prevLoadPromise == null ? void 0 : prevLoadPromise.resolve();
+      if (!route.options.beforeLoad) {
+        batch(() => {
+          pending();
+          resolve();
         });
-        const { paramsError, searchError } = this.getMatch(matchId);
-        if (paramsError) {
-          this.handleSerialError(
-            innerLoadContext,
-            index,
-            paramsError,
-            "PARSE_PARAMS"
-          );
+        return;
+      }
+      const { search, params, cause } = match;
+      const preload = this.resolvePreload(innerLoadContext, matchId);
+      const beforeLoadFnContext = {
+        search,
+        abortController,
+        params,
+        preload,
+        context,
+        location: innerLoadContext.location,
+        navigate: (opts) => this.navigate({ ...opts, _fromLocation: innerLoadContext.location }),
+        buildLocation: this.buildLocation,
+        cause: preload ? "preload" : cause,
+        matches: innerLoadContext.matches
+      };
+      const updateContext = (beforeLoadContext2) => {
+        if (beforeLoadContext2 === void 0) {
+          batch(() => {
+            pending();
+            resolve();
+          });
+          return;
         }
-        if (searchError) {
+        if (isRedirect(beforeLoadContext2) || isNotFound(beforeLoadContext2)) {
+          pending();
           this.handleSerialError(
             innerLoadContext,
             index,
-            searchError,
-            "VALIDATE_SEARCH"
+            beforeLoadContext2,
+            "BEFORE_LOAD"
           );
         }
-        this.setupPendingTimeout(innerLoadContext, matchId, route);
-        const abortController = new AbortController();
-        const parentMatchId = (_a = innerLoadContext.matches[index - 1]) == null ? void 0 : _a.id;
-        const parentMatch = parentMatchId ? this.getMatch(parentMatchId) : void 0;
-        const parentMatchContext = (parentMatch == null ? void 0 : parentMatch.context) ?? this.options.context ?? void 0;
-        innerLoadContext.updateMatch(matchId, (prev) => ({
-          ...prev,
-          isFetching: "beforeLoad",
-          fetchCount: prev.fetchCount + 1,
-          abortController,
-          context: {
-            ...parentMatchContext,
-            ...prev.__routeContext
-          }
-        }));
-        const { search, params, context, cause } = this.getMatch(matchId);
-        const preload = this.resolvePreload(innerLoadContext, matchId);
-        const beforeLoadFnContext = {
-          search,
-          abortController,
-          params,
-          preload,
-          context,
-          location: innerLoadContext.location,
-          navigate: (opts) => this.navigate({ ...opts, _fromLocation: innerLoadContext.location }),
-          buildLocation: this.buildLocation,
-          cause: preload ? "preload" : cause,
-          matches: innerLoadContext.matches
-        };
-        const updateContext = (beforeLoadContext2) => {
-          if (isRedirect(beforeLoadContext2) || isNotFound(beforeLoadContext2)) {
-            this.handleSerialError(
-              innerLoadContext,
-              index,
-              beforeLoadContext2,
-              "BEFORE_LOAD"
-            );
-          }
+        batch(() => {
+          pending();
           innerLoadContext.updateMatch(matchId, (prev) => ({
             ...prev,
             __beforeLoadContext: beforeLoadContext2,
             context: {
-              ...parentMatchContext,
-              ...prev.__routeContext,
+              ...prev.context,
               ...beforeLoadContext2
-            },
-            abortController
+            }
           }));
-        };
-        const beforeLoadContext = (_c = (_b = route.options).beforeLoad) == null ? void 0 : _c.call(_b, beforeLoadFnContext);
+          resolve();
+        });
+      };
+      let beforeLoadContext;
+      try {
+        beforeLoadContext = route.options.beforeLoad(beforeLoadFnContext);
         if (isPromise(beforeLoadContext)) {
-          return beforeLoadContext.then(updateContext).catch((err) => {
+          pending();
+          return beforeLoadContext.catch((err) => {
             this.handleSerialError(innerLoadContext, index, err, "BEFORE_LOAD");
-          }).then(resolve);
-        } else {
-          updateContext(beforeLoadContext);
+          }).then(updateContext);
         }
       } catch (err) {
+        pending();
         this.handleSerialError(innerLoadContext, index, err, "BEFORE_LOAD");
       }
-      resolve();
+      updateContext(beforeLoadContext);
       return;
     };
     this.handleBeforeLoad = (innerLoadContext, index) => {
@@ -1097,10 +1113,12 @@ class RouterCore {
               this.getMatch(matchId),
               loaderData
             );
-            innerLoadContext.updateMatch(matchId, (prev) => ({
-              ...prev,
-              loaderData
-            }));
+            if (loaderData !== void 0) {
+              innerLoadContext.updateMatch(matchId, (prev) => ({
+                ...prev,
+                loaderData
+              }));
+            }
           }
           if (route._lazyPromise) await route._lazyPromise;
           const headResult = this.executeHead(innerLoadContext, matchId, route);
@@ -1118,7 +1136,8 @@ class RouterCore {
           }));
         } catch (e) {
           let error = e;
-          await this.potentialPendingMinPromise(matchId);
+          const pendingPromise = this.potentialPendingMinPromise(matchId);
+          if (pendingPromise) await pendingPromise;
           this.handleRedirectAndNotFound(
             innerLoadContext,
             this.getMatch(matchId),
@@ -1184,9 +1203,9 @@ class RouterCore {
           return this.getMatch(matchId);
         }
         await prevMatch._nonReactive.loaderPromise;
-        const match = this.getMatch(matchId);
-        if (match.error) {
-          this.handleRedirectAndNotFound(innerLoadContext, match, match.error);
+        const match2 = this.getMatch(matchId);
+        if (match2.error) {
+          this.handleRedirectAndNotFound(innerLoadContext, match2, match2.error);
         }
       } else {
         const age = Date.now() - this.getMatch(matchId).updatedAt;
@@ -1196,13 +1215,15 @@ class RouterCore {
         const shouldReload = typeof shouldReloadOption === "function" ? shouldReloadOption(
           this.getLoaderContext(innerLoadContext, matchId, index, route)
         ) : shouldReloadOption;
-        innerLoadContext.updateMatch(matchId, (prev) => {
-          prev._nonReactive.loaderPromise = createControlledPromise();
-          return {
+        const nextPreload = !!preload && !this.state.matches.some((d) => d.id === matchId);
+        const match2 = this.getMatch(matchId);
+        match2._nonReactive.loaderPromise = createControlledPromise();
+        if (nextPreload !== match2.preload) {
+          innerLoadContext.updateMatch(matchId, (prev) => ({
             ...prev,
-            preload: !!preload && !this.state.matches.some((d) => d.id === matchId)
-          };
-        });
+            preload: nextPreload
+          }));
+        }
         const { status, invalid } = this.getMatch(matchId);
         loaderShouldRunAsync = status === "success" && (invalid || (shouldReload ?? age > staleAge));
         if (preload && route.options.preload === false) ;
@@ -1212,10 +1233,10 @@ class RouterCore {
             var _a2, _b2;
             try {
               await this.runLoader(innerLoadContext, matchId, index, route);
-              const match = this.getMatch(matchId);
-              (_a2 = match._nonReactive.loaderPromise) == null ? void 0 : _a2.resolve();
-              (_b2 = match._nonReactive.loadPromise) == null ? void 0 : _b2.resolve();
-              match._nonReactive.loaderPromise = void 0;
+              const match3 = this.getMatch(matchId);
+              (_a2 = match3._nonReactive.loaderPromise) == null ? void 0 : _a2.resolve();
+              (_b2 = match3._nonReactive.loadPromise) == null ? void 0 : _b2.resolve();
+              match3._nonReactive.loaderPromise = void 0;
             } catch (err) {
               if (isRedirect(err)) {
                 await this.navigate(err.options);
@@ -1235,22 +1256,23 @@ class RouterCore {
           }
         }
       }
+      const match = this.getMatch(matchId);
       if (!loaderIsRunningAsync) {
-        const match = this.getMatch(matchId);
         (_a = match._nonReactive.loaderPromise) == null ? void 0 : _a.resolve();
         (_b = match._nonReactive.loadPromise) == null ? void 0 : _b.resolve();
       }
-      innerLoadContext.updateMatch(matchId, (prev) => {
-        clearTimeout(prev._nonReactive.pendingTimeout);
-        prev._nonReactive.pendingTimeout = void 0;
-        if (!loaderIsRunningAsync) prev._nonReactive.loaderPromise = void 0;
-        prev._nonReactive.dehydrated = void 0;
-        return {
+      clearTimeout(match._nonReactive.pendingTimeout);
+      match._nonReactive.pendingTimeout = void 0;
+      if (!loaderIsRunningAsync) match._nonReactive.loaderPromise = void 0;
+      match._nonReactive.dehydrated = void 0;
+      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);
     };
     this.loadMatches = async (baseContext) => {