@tanstack/router-core 1.154.8 → 1.154.13

package/dist/cjs/router.cjs

@@ -316,14 +316,21 @@ class RouterCore {
           path: nextTo,
           params: nextParams
         }).interpolatedPath;
-        const { matches: destMatches, rawParams } = this.matchRoutesInternal(
-          { pathname: interpolatedNextTo },
-          { _buildLocation: true }
-        );
-        const destRoutes = destMatches.map(
-          (d) => this.looseRoutesById[d.routeId]
-        );
-        const globalNotFoundMatch = destMatches.find((m) => m.globalNotFound);
+        const destMatchResult = this.getMatchedRoutes(interpolatedNextTo);
+        let destRoutes = destMatchResult.matchedRoutes;
+        const rawParams = destMatchResult.routeParams;
+        const isGlobalNotFound = destMatchResult.foundRoute ? destMatchResult.foundRoute.path !== "/" && destMatchResult.routeParams["**"] : path.trimPathRight(interpolatedNextTo);
+        let globalNotFoundRouteId;
+        if (isGlobalNotFound) {
+          if (this.options.notFoundRoute) {
+            destRoutes = [...destRoutes, this.options.notFoundRoute];
+          } else {
+            globalNotFoundRouteId = findGlobalNotFoundRouteId(
+              this.options.notFoundMode,
+              destRoutes
+            );
+          }
+        }
         if (Object.keys(nextParams).length > 0) {
           for (const route of destRoutes) {
             const fn = route.options.params?.stringify ?? route.options.stringifyParams;
@@ -382,7 +389,7 @@ class RouterCore {
           routes: destRoutes,
           params: snapshotParams,
           searchStr,
-          globalNotFoundRouteId: globalNotFoundMatch?.routeId
+          globalNotFoundRouteId
         });
         const fullPath = `${nextPathname}${searchStr}${hashStr}`;
         const url = new URL(fullPath, this.origin);
@@ -1106,20 +1113,7 @@ class RouterCore {
           isGlobalNotFound = true;
         }
       }
-      globalNotFoundRouteId = (() => {
-        if (!isGlobalNotFound) {
-          return void 0;
-        }
-        if (this.options.notFoundMode !== "root") {
-          for (let i = matchedRoutes.length - 1; i >= 0; i--) {
-            const route = matchedRoutes[i];
-            if (route.children) {
-              return route.id;
-            }
-          }
-        }
-        return root.rootRouteId;
-      })();
+      globalNotFoundRouteId = isGlobalNotFound ? findGlobalNotFoundRouteId(this.options.notFoundMode, matchedRoutes) : void 0;
     }
     const matches = [];
     const getParentContext = (parentMatch) => {
@@ -1448,76 +1442,94 @@ function applySearchMiddleware({
   destRoutes,
   _includeValidateSearch
 }) {
-  const allMiddlewares = destRoutes.reduce(
-    (acc, route) => {
-      const middlewares = [];
-      if ("search" in route.options) {
-        if (route.options.search?.middlewares) {
-          middlewares.push(...route.options.search.middlewares);
+  const middleware = buildMiddlewareChain(destRoutes);
+  return middleware(search, dest, _includeValidateSearch ?? false);
+}
+function buildMiddlewareChain(destRoutes) {
+  const context = {
+    dest: null,
+    _includeValidateSearch: false,
+    middlewares: []
+  };
+  for (const route of destRoutes) {
+    if ("search" in route.options) {
+      if (route.options.search?.middlewares) {
+        context.middlewares.push(...route.options.search.middlewares);
+      }
+    } else if (route.options.preSearchFilters || route.options.postSearchFilters) {
+      const legacyMiddleware = ({ search, next }) => {
+        let nextSearch = search;
+        if ("preSearchFilters" in route.options && route.options.preSearchFilters) {
+          nextSearch = route.options.preSearchFilters.reduce(
+            (prev, next2) => next2(prev),
+            search
+          );
         }
-      } else if (route.options.preSearchFilters || route.options.postSearchFilters) {
-        const legacyMiddleware = ({
-          search: search2,
-          next
-        }) => {
-          let nextSearch = search2;
-          if ("preSearchFilters" in route.options && route.options.preSearchFilters) {
-            nextSearch = route.options.preSearchFilters.reduce(
-              (prev, next2) => next2(prev),
-              search2
-            );
-          }
-          const result = next(nextSearch);
-          if ("postSearchFilters" in route.options && route.options.postSearchFilters) {
-            return route.options.postSearchFilters.reduce(
-              (prev, next2) => next2(prev),
-              result
-            );
-          }
+        const result = next(nextSearch);
+        if ("postSearchFilters" in route.options && route.options.postSearchFilters) {
+          return route.options.postSearchFilters.reduce(
+            (prev, next2) => next2(prev),
+            result
+          );
+        }
+        return result;
+      };
+      context.middlewares.push(legacyMiddleware);
+    }
+    if (route.options.validateSearch) {
+      const validate = ({ search, next }) => {
+        const result = next(search);
+        if (!context._includeValidateSearch) return result;
+        try {
+          const validatedSearch = {
+            ...result,
+            ...validateSearch(route.options.validateSearch, result) ?? void 0
+          };
+          return validatedSearch;
+        } catch {
           return result;
-        };
-        middlewares.push(legacyMiddleware);
-      }
-      if (_includeValidateSearch && route.options.validateSearch) {
-        const validate = ({ search: search2, next }) => {
-          const result = next(search2);
-          try {
-            const validatedSearch = {
-              ...result,
-              ...validateSearch(route.options.validateSearch, result) ?? void 0
-            };
-            return validatedSearch;
-          } catch {
-            return result;
-          }
-        };
-        middlewares.push(validate);
-      }
-      return acc.concat(middlewares);
-    },
-    []
-  ) ?? [];
-  const final = ({ search: search2 }) => {
+        }
+      };
+      context.middlewares.push(validate);
+    }
+  }
+  const final = ({ search }) => {
+    const dest = context.dest;
     if (!dest.search) {
       return {};
     }
     if (dest.search === true) {
-      return search2;
+      return search;
     }
-    return utils.functionalUpdate(dest.search, search2);
+    return utils.functionalUpdate(dest.search, search);
   };
-  allMiddlewares.push(final);
-  const applyNext = (index, currentSearch) => {
-    if (index >= allMiddlewares.length) {
+  context.middlewares.push(final);
+  const applyNext = (index, currentSearch, middlewares) => {
+    if (index >= middlewares.length) {
       return currentSearch;
     }
-    const middleware = allMiddlewares[index];
+    const middleware = middlewares[index];
     const next = (newSearch) => {
-      return applyNext(index + 1, newSearch);
+      return applyNext(index + 1, newSearch, middlewares);
     };
     return middleware({ search: currentSearch, next });
   };
-  return applyNext(0, search);
+  return function middleware(search, dest, _includeValidateSearch) {
+    context.dest = dest;
+    context._includeValidateSearch = _includeValidateSearch;
+    return applyNext(0, search, context.middlewares);
+  };
+}
+function findGlobalNotFoundRouteId(notFoundMode, routes) {
+  if (notFoundMode !== "root") {
+    for (let i = routes.length - 1; i >= 0; i--) {
+      const route = routes[i];
+      if (route.children) {
+        return route.id;
+      }
+    }
+  }
+  return root.rootRouteId;
 }
 exports.PathParamError = PathParamError;
 exports.RouterCore = RouterCore;