@tanstack/router-core 1.131.12 → 1.131.14

package/dist/esm/router.js

@@ -1,7 +1,7 @@
 import { Store, batch } from "@tanstack/store";
 import { createMemoryHistory, createBrowserHistory, parseHref } from "@tanstack/history";
 import invariant from "tiny-invariant";
-import { pick, createControlledPromise, deepEqual, replaceEqualDeep, last, functionalUpdate } from "./utils.js";
+import { pick, createControlledPromise, isPromise, deepEqual, replaceEqualDeep, last, functionalUpdate } from "./utils.js";
 import { trimPath, resolvePath, cleanPath, matchPathname, trimPathRight, interpolatePath, joinPaths, trimPathLeft, parsePathname, SEGMENT_TYPE_PARAM, SEGMENT_TYPE_OPTIONAL_PARAM, SEGMENT_TYPE_WILDCARD, SEGMENT_TYPE_PATHNAME } from "./path.js";
 import { isNotFound } from "./not-found.js";
 import { setupScrollRestoration } from "./scroll-restoration.js";
@@ -727,42 +727,36 @@ class RouterCore {
       }
       const handleRedirectAndNotFound = (match, err) => {
         var _a, _b, _c;
-        if (isRedirect(err) || isNotFound(err)) {
-          if (isRedirect(err)) {
-            if (err.redirectHandled) {
-              if (!err.options.reloadDocument) {
-                throw err;
-              }
-            }
-          }
-          if (match) {
-            (_a = match._nonReactive.beforeLoadPromise) == null ? void 0 : _a.resolve();
-            (_b = match._nonReactive.loaderPromise) == null ? void 0 : _b.resolve();
-            match._nonReactive.beforeLoadPromise = void 0;
-            match._nonReactive.loaderPromise = void 0;
-            updateMatch(match.id, (prev) => ({
-              ...prev,
-              status: isRedirect(err) ? "redirected" : isNotFound(err) ? "notFound" : "error",
-              isFetching: false,
-              error: err
-            }));
-            if (!err.routeId) {
-              err.routeId = match.routeId;
-            }
-            (_c = match._nonReactive.loadPromise) == null ? void 0 : _c.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) && !isNotFound(err)) return;
+        if (isRedirect(err) && err.redirectHandled && !err.options.reloadDocument) {
+          throw err;
+        }
+        if (match) {
+          (_a = match._nonReactive.beforeLoadPromise) == null ? void 0 : _a.resolve();
+          (_b = match._nonReactive.loaderPromise) == null ? void 0 : _b.resolve();
+          match._nonReactive.beforeLoadPromise = void 0;
+          match._nonReactive.loaderPromise = void 0;
+          const status = isRedirect(err) ? "redirected" : "notFound";
+          updateMatch(match.id, (prev) => ({
+            ...prev,
+            status,
+            isFetching: false,
+            error: err
+          }));
+          if (isNotFound(err) && !err.routeId) {
+            err.routeId = match.routeId;
           }
+          (_c = match._nonReactive.loadPromise) == null ? void 0 : _c.resolve();
+        }
+        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;
         }
       };
       const shouldSkipLoader = (matchId) => {
@@ -1015,11 +1009,9 @@ class RouterCore {
                         };
                       });
                     };
-                    const potentialPendingMinPromise = async () => {
+                    const potentialPendingMinPromise = () => {
                       const latestMatch = this.getMatch(matchId);
-                      if (latestMatch._nonReactive.minPendingPromise) {
-                        await latestMatch._nonReactive.minPendingPromise;
-                      }
+                      return latestMatch._nonReactive.minPendingPromise;
                     };
                     const prevMatch = this.getMatch(matchId);
                     if (shouldSkipLoader(matchId)) {
@@ -1083,27 +1075,36 @@ class RouterCore {
                         var _a3, _b3, _c2, _d2;
                         try {
                           try {
-                            if (!this.isServer || this.isServer && this.getMatch(matchId).ssr === true) {
+                            if (!this.isServer || this.getMatch(matchId).ssr === true) {
                               this.loadRouteChunk(route);
                             }
-                            updateMatch(matchId, (prev) => ({
-                              ...prev,
-                              isFetching: "loader"
-                            }));
-                            const loaderData = await ((_b3 = (_a3 = route.options).loader) == null ? void 0 : _b3.call(_a3, getLoaderContext()));
-                            handleRedirectAndNotFound(
-                              this.getMatch(matchId),
-                              loaderData
-                            );
-                            updateMatch(matchId, (prev) => ({
-                              ...prev,
-                              loaderData
-                            }));
-                            await route._lazyPromise;
+                            const loaderResult = (_b3 = (_a3 = route.options).loader) == null ? void 0 : _b3.call(_a3, getLoaderContext());
+                            const loaderResultIsPromise = route.options.loader && isPromise(loaderResult);
+                            const willLoadSomething = !!(loaderResultIsPromise || route._lazyPromise || route._componentsPromise || route.options.head || route.options.scripts || route.options.headers || this.getMatch(matchId)._nonReactive.minPendingPromise);
+                            if (willLoadSomething) {
+                              updateMatch(matchId, (prev) => ({
+                                ...prev,
+                                isFetching: "loader"
+                              }));
+                            }
+                            if (route.options.loader) {
+                              const loaderData = loaderResultIsPromise ? await loaderResult : loaderResult;
+                              handleRedirectAndNotFound(
+                                this.getMatch(matchId),
+                                loaderData
+                              );
+                              updateMatch(matchId, (prev) => ({
+                                ...prev,
+                                loaderData
+                              }));
+                            }
+                            if (route._lazyPromise) await route._lazyPromise;
                             const headResult = executeHead();
                             const head = headResult ? await headResult : void 0;
-                            await potentialPendingMinPromise();
-                            await route._componentsPromise;
+                            const pendingPromise = potentialPendingMinPromise();
+                            if (pendingPromise) await pendingPromise;
+                            if (route._componentsPromise)
+                              await route._componentsPromise;
                             updateMatch(matchId, (prev) => ({
                               ...prev,
                               error: void 0,
@@ -1291,27 +1292,36 @@ class RouterCore {
       this.clearCache({ filter });
     };
     this.loadRouteChunk = (route) => {
-      if (route._lazyPromise === void 0) {
+      if (!route._lazyLoaded && route._lazyPromise === void 0) {
         if (route.lazyFn) {
           route._lazyPromise = route.lazyFn().then((lazyRoute) => {
             const { id: _id, ...options2 } = lazyRoute.options;
             Object.assign(route.options, options2);
+            route._lazyLoaded = true;
+            route._lazyPromise = void 0;
           });
         } else {
-          route._lazyPromise = Promise.resolve();
+          route._lazyLoaded = true;
         }
       }
-      if (route._componentsPromise === void 0) {
-        route._componentsPromise = route._lazyPromise.then(
-          () => Promise.all(
-            componentTypes.map(async (type) => {
-              const component = route.options[type];
-              if (component == null ? void 0 : component.preload) {
-                await component.preload();
-              }
-            })
-          )
-        );
+      if (!route._componentsLoaded && route._componentsPromise === void 0) {
+        const loadComponents = () => {
+          var _a;
+          const preloads = [];
+          for (const type of componentTypes) {
+            const preload = (_a = route.options[type]) == null ? void 0 : _a.preload;
+            if (preload) preloads.push(preload());
+          }
+          if (preloads.length)
+            return Promise.all(preloads).then(() => {
+              route._componentsLoaded = true;
+              route._componentsPromise = void 0;
+            });
+          route._componentsLoaded = true;
+          route._componentsPromise = void 0;
+          return;
+        };
+        route._componentsPromise = route._lazyPromise ? route._lazyPromise.then(loadComponents) : loadComponents();
       }
       return route._componentsPromise;
     };
@@ -1409,9 +1419,7 @@ class RouterCore {
       }
       return match;
     };
-    this._handleNotFound = (matches, err, {
-      updateMatch = this.updateMatch
-    } = {}) => {
+    this._handleNotFound = (matches, err, updateMatch = this.updateMatch) => {
       var _a;
       const routeCursor = this.routesById[err.routeId ?? ""] ?? this.routeTree;
       const matchesByRouteId = {};
@@ -1438,9 +1446,7 @@ class RouterCore {
       }));
       if (err.routerCode === "BEFORE_LOAD" && routeCursor.parentRoute) {
         err.routeId = routeCursor.parentRoute.id;
-        this._handleNotFound(matches, err, {
-          updateMatch
-        });
+        this._handleNotFound(matches, err, updateMatch);
       }
     };
     this.hasNotFoundMatch = () => {