@tanstack/router-core 1.124.2 → 1.125.0

package/dist/cjs/router.cjs

@@ -112,8 +112,7 @@ class RouterCore {
         routeTree: this.routeTree,
         initRoute: (route, i) => {
           route.init({
-            originalIndex: i,
-            defaultSsr: this.options.defaultSsr
+            originalIndex: i
           });
         }
       });
@@ -123,8 +122,7 @@ class RouterCore {
       const notFoundRoute = this.options.notFoundRoute;
       if (notFoundRoute) {
         notFoundRoute.init({
-          originalIndex: 99999999999,
-          defaultSsr: this.options.defaultSsr
+          originalIndex: 99999999999
         });
         this.routesById[notFoundRoute.id] = notFoundRoute;
       }
@@ -498,7 +496,10 @@ class RouterCore {
           throw redirect.redirect({ href: nextLocation.href });
         }
       }
-      const pendingMatches = this.matchRoutes(this.latestLocation);
+      let pendingMatches = this.matchRoutes(this.latestLocation);
+      if (this.isShell) {
+        pendingMatches = pendingMatches.slice(0, 1);
+      }
       this.__store.setState((s) => ({
         ...s,
         status: "pending",
@@ -693,12 +694,41 @@ class RouterCore {
       const triggerOnReady = async () => {
         if (!rendered) {
           rendered = true;
+          if (!allPreload && !this.isServer) {
+            matches.forEach((match) => {
+              const {
+                id: matchId,
+                routeId,
+                _forcePending,
+                minPendingPromise
+              } = match;
+              const route = this.looseRoutesById[routeId];
+              const pendingMinMs = route.options.pendingMinMs ?? this.options.defaultPendingMinMs;
+              if (_forcePending && pendingMinMs && !minPendingPromise) {
+                const minPendingPromise2 = utils.createControlledPromise();
+                updateMatch(matchId, (prev) => ({
+                  ...prev,
+                  minPendingPromise: minPendingPromise2
+                }));
+                setTimeout(() => {
+                  minPendingPromise2.resolve();
+                  updateMatch(matchId, (prev) => ({
+                    ...prev,
+                    minPendingPromise: void 0
+                  }));
+                }, pendingMinMs);
+              }
+            });
+          }
           await (onReady == null ? void 0 : onReady());
         }
       };
       const resolvePreload = (matchId) => {
         return !!(allPreload && !this.state.matches.find((d) => d.id === matchId));
       };
+      if (!this.isServer && this.state.matches.find((d) => d._forcePending)) {
+        triggerOnReady();
+      }
       const handleRedirectAndNotFound = (match, err) => {
         var _a, _b, _c, _d;
         if (redirect.isRedirect(err) || notFound.isNotFound(err)) {
@@ -741,6 +771,18 @@ class RouterCore {
           }
         }
       };
+      const shouldSkipLoader = (matchId) => {
+        const match = this.getMatch(matchId);
+        if (!this.isServer && match._dehydrated) {
+          return true;
+        }
+        if (this.isServer) {
+          if (match.ssr === false) {
+            return true;
+          }
+        }
+        return false;
+      };
       try {
         await new Promise((resolveAll, rejectAll) => {
           ;
@@ -781,8 +823,60 @@ class RouterCore {
               for (const [index, { id: matchId, routeId }] of matches.entries()) {
                 const existingMatch = this.getMatch(matchId);
                 const parentMatchId = (_a = matches[index - 1]) == null ? void 0 : _a.id;
+                const parentMatch = parentMatchId ? this.getMatch(parentMatchId) : void 0;
                 const route = this.looseRoutesById[routeId];
                 const pendingMs = route.options.pendingMs ?? this.options.defaultPendingMs;
+                if (this.isServer) {
+                  const defaultSsr = this.options.defaultSsr ?? true;
+                  let ssr;
+                  if ((parentMatch == null ? void 0 : parentMatch.ssr) === false) {
+                    ssr = false;
+                  } else {
+                    let tempSsr;
+                    if (route.options.ssr === void 0) {
+                      tempSsr = defaultSsr;
+                    } else if (typeof route.options.ssr === "function") {
+                      let makeMaybe = function(value, error) {
+                        if (error) {
+                          return { status: "error", error };
+                        }
+                        return { status: "success", value };
+                      };
+                      const { search, params } = this.getMatch(matchId);
+                      const ssrFnContext = {
+                        search: makeMaybe(search, existingMatch.searchError),
+                        params: makeMaybe(params, existingMatch.paramsError),
+                        location,
+                        matches: matches.map((match) => ({
+                          index: match.index,
+                          pathname: match.pathname,
+                          fullPath: match.fullPath,
+                          staticData: match.staticData,
+                          id: match.id,
+                          routeId: match.routeId,
+                          search: makeMaybe(match.search, match.searchError),
+                          params: makeMaybe(match.params, match.paramsError),
+                          ssr: match.ssr
+                        }))
+                      };
+                      tempSsr = await route.options.ssr(ssrFnContext) ?? defaultSsr;
+                    } else {
+                      tempSsr = route.options.ssr;
+                    }
+                    if (tempSsr === true && (parentMatch == null ? void 0 : parentMatch.ssr) === "data-only") {
+                      ssr = "data-only";
+                    } else {
+                      ssr = tempSsr;
+                    }
+                  }
+                  updateMatch(matchId, (prev) => ({
+                    ...prev,
+                    ssr
+                  }));
+                }
+                if (shouldSkipLoader(matchId)) {
+                  continue;
+                }
                 const shouldPending = !!(onReady && !this.isServer && !resolvePreload(matchId) && (route.options.loader || route.options.beforeLoad || routeNeedsPreload(route)) && typeof pendingMs === "number" && pendingMs !== Infinity && (route.options.pendingComponent ?? ((_b = this.options) == null ? void 0 : _b.defaultPendingComponent)));
                 let executeBeforeLoad = true;
                 if (
@@ -835,7 +929,7 @@ class RouterCore {
                     if (searchError) {
                       handleSerialError(index, searchError, "VALIDATE_SEARCH");
                     }
-                    const getParentMatchContext = () => parentMatchId ? this.getMatch(parentMatchId).context : this.options.context ?? {};
+                    const parentMatchContext = (parentMatch == null ? void 0 : parentMatch.context) ?? this.options.context ?? {};
                     updateMatch(matchId, (prev) => ({
                       ...prev,
                       isFetching: "beforeLoad",
@@ -843,7 +937,7 @@ class RouterCore {
                       abortController,
                       pendingTimeout,
                       context: {
-                        ...getParentMatchContext(),
+                        ...parentMatchContext,
                         ...prev.__routeContext
                       }
                     }));
@@ -870,7 +964,7 @@ class RouterCore {
                         ...prev,
                         __beforeLoadContext: beforeLoadContext,
                         context: {
-                          ...getParentMatchContext(),
+                          ...parentMatchContext,
                           ...prev.__routeContext,
                           ...beforeLoadContext
                         },
@@ -896,10 +990,61 @@ class RouterCore {
               validResolvedMatches.forEach(({ id: matchId, routeId }, index) => {
                 matchPromises.push(
                   (async () => {
+                    var _a2, _b2;
                     let loaderShouldRunAsync = false;
                     let loaderIsRunningAsync = false;
+                    const route = this.looseRoutesById[routeId];
+                    const executeHead = async () => {
+                      var _a3, _b3, _c2, _d2, _e, _f;
+                      const match = this.getMatch(matchId);
+                      if (!match) {
+                        return;
+                      }
+                      const assetContext = {
+                        matches,
+                        match,
+                        params: match.params,
+                        loaderData: match.loaderData
+                      };
+                      const headFnContent = await ((_b3 = (_a3 = route.options).head) == null ? void 0 : _b3.call(_a3, assetContext));
+                      const meta = headFnContent == null ? void 0 : headFnContent.meta;
+                      const links = headFnContent == null ? void 0 : headFnContent.links;
+                      const headScripts = headFnContent == null ? void 0 : headFnContent.scripts;
+                      const styles = headFnContent == null ? void 0 : headFnContent.styles;
+                      const scripts = await ((_d2 = (_c2 = route.options).scripts) == null ? void 0 : _d2.call(_c2, assetContext));
+                      const headers = await ((_f = (_e = route.options).headers) == null ? void 0 : _f.call(_e, assetContext));
+                      return {
+                        meta,
+                        links,
+                        headScripts,
+                        headers,
+                        scripts,
+                        styles
+                      };
+                    };
+                    const potentialPendingMinPromise = async () => {
+                      const latestMatch = this.getMatch(matchId);
+                      if (latestMatch.minPendingPromise) {
+                        await latestMatch.minPendingPromise;
+                      }
+                    };
                     const prevMatch = this.getMatch(matchId);
-                    if (prevMatch.loaderPromise) {
+                    if (shouldSkipLoader(matchId)) {
+                      if (this.isServer) {
+                        const head = await executeHead();
+                        updateMatch(matchId, (prev) => ({
+                          ...prev,
+                          ...head
+                        }));
+                        (_a2 = this.serverSsr) == null ? void 0 : _a2.onMatchSettled({
+                          router: this,
+                          match: this.getMatch(matchId)
+                        });
+                        return this.getMatch(matchId);
+                      } else {
+                        await potentialPendingMinPromise();
+                      }
+                    } else if (prevMatch.loaderPromise) {
                       if (prevMatch.status === "success" && !sync && !prevMatch.preload) {
                         return this.getMatch(matchId);
                       }
@@ -910,7 +1055,6 @@ class RouterCore {
                       }
                     } else {
                       const parentMatchPromise = matchPromises[index - 1];
-                      const route = this.looseRoutesById[routeId];
                       const getLoaderContext = () => {
                         const {
                           params,
@@ -943,55 +1087,28 @@ class RouterCore {
                         loaderPromise: utils.createControlledPromise(),
                         preload: !!preload && !this.state.matches.find((d) => d.id === matchId)
                       }));
-                      const executeHead = async () => {
-                        var _a2, _b2, _c2, _d2, _e, _f;
-                        const match = this.getMatch(matchId);
-                        if (!match) {
-                          return;
-                        }
-                        const assetContext = {
-                          matches,
-                          match,
-                          params: match.params,
-                          loaderData: match.loaderData
-                        };
-                        const headFnContent = await ((_b2 = (_a2 = route.options).head) == null ? void 0 : _b2.call(_a2, assetContext));
-                        const meta = headFnContent == null ? void 0 : headFnContent.meta;
-                        const links = headFnContent == null ? void 0 : headFnContent.links;
-                        const headScripts = headFnContent == null ? void 0 : headFnContent.scripts;
-                        const styles = headFnContent == null ? void 0 : headFnContent.styles;
-                        const scripts = await ((_d2 = (_c2 = route.options).scripts) == null ? void 0 : _d2.call(_c2, assetContext));
-                        const headers = await ((_f = (_e = route.options).headers) == null ? void 0 : _f.call(_e, assetContext));
-                        return {
-                          meta,
-                          links,
-                          headScripts,
-                          headers,
-                          scripts,
-                          styles
-                        };
-                      };
                       const runLoader = async () => {
-                        var _a2, _b2, _c2, _d2, _e;
+                        var _a3, _b3, _c2, _d2, _e;
                         try {
-                          const potentialPendingMinPromise = async () => {
-                            const latestMatch = this.getMatch(matchId);
-                            if (latestMatch.minPendingPromise) {
-                              await latestMatch.minPendingPromise;
-                            }
-                          };
                           try {
-                            this.loadRouteChunk(route);
+                            if (!this.isServer || this.isServer && this.getMatch(matchId).ssr === true) {
+                              this.loadRouteChunk(route);
+                            }
                             updateMatch(matchId, (prev) => ({
                               ...prev,
                               isFetching: "loader"
                             }));
-                            const loaderData = await ((_b2 = (_a2 = route.options).loader) == null ? void 0 : _b2.call(_a2, getLoaderContext()));
+                            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 head = await executeHead();
                             await potentialPendingMinPromise();
                             await route._componentsPromise;
                             updateMatch(matchId, (prev) => ({
@@ -1000,11 +1117,6 @@ class RouterCore {
                               status: "success",
                               isFetching: false,
                               updatedAt: Date.now(),
-                              loaderData
-                            }));
-                            const head = await executeHead();
-                            updateMatch(matchId, (prev) => ({
-                              ...prev,
                               ...head
                             }));
                           } catch (e) {
@@ -1043,10 +1155,10 @@ class RouterCore {
                           handleRedirectAndNotFound(this.getMatch(matchId), err);
                         }
                       };
-                      const { status, invalid } = this.getMatch(matchId);
+                      const { status, invalid, _forcePending } = this.getMatch(matchId);
                       loaderShouldRunAsync = status === "success" && (invalid || (shouldReload ?? age > staleAge));
                       if (preload && route.options.preload === false) {
-                      } else if (loaderShouldRunAsync && !sync) {
+                      } else if (loaderShouldRunAsync && !sync && !_forcePending) {
                         loaderIsRunningAsync = true;
                         (async () => {
                           try {
@@ -1067,11 +1179,18 @@ class RouterCore {
                       } else if (status !== "success" || loaderShouldRunAsync && sync) {
                         await runLoader();
                       } else {
+                        if (_forcePending) {
+                          await potentialPendingMinPromise();
+                        }
                         const head = await executeHead();
                         updateMatch(matchId, (prev) => ({
                           ...prev,
                           ...head
                         }));
+                        (_b2 = this.serverSsr) == null ? void 0 : _b2.onMatchSettled({
+                          router: this,
+                          match: this.getMatch(matchId)
+                        });
                       }
                     }
                     if (!loaderIsRunningAsync) {
@@ -1083,7 +1202,9 @@ class RouterCore {
                       ...prev,
                       isFetching: loaderIsRunningAsync ? prev.isFetching : false,
                       loaderPromise: loaderIsRunningAsync ? prev.loaderPromise : void 0,
-                      invalid: false
+                      invalid: false,
+                      _dehydrated: void 0,
+                      _forcePending: void 0
                     }));
                     return this.getMatch(matchId);
                   })()