@tanstack/router-core 1.155.0 → 1.156.0

package/dist/esm/router.js

@@ -1,6 +1,6 @@
 import { Store, batch } from "@tanstack/store";
 import { createBrowserHistory, parseHref } from "@tanstack/history";
-import { createControlledPromise, isDangerousProtocol, deepEqual, replaceEqualDeep, decodePath, functionalUpdate, last, findLast } from "./utils.js";
+import { createControlledPromise, isDangerousProtocol, deepEqual, replaceEqualDeep, last, decodePath, functionalUpdate, findLast } from "./utils.js";
 import { processRouteTree, processRouteMasks, findSingleMatch, findRouteMatch, findFlatMatch } from "./new-process-route-tree.js";
 import { compileDecodeCharMap, trimPath, resolvePath, cleanPath, trimPathRight, interpolatePath } from "./path.js";
 import { createLRUCache } from "./lru-cache.js";
@@ -95,7 +95,23 @@ class RouterCore {
       }
       if (this.options.routeTree !== this.routeTree) {
         this.routeTree = this.options.routeTree;
-        this.buildRouteTree();
+        let processRouteTreeResult;
+        if (this.isServer && globalThis.__TSR_CACHE__ && globalThis.__TSR_CACHE__.routeTree === this.routeTree) {
+          const cached = globalThis.__TSR_CACHE__;
+          this.resolvePathCache = cached.resolvePathCache;
+          processRouteTreeResult = cached.processRouteTreeResult;
+        } else {
+          this.resolvePathCache = createLRUCache(1e3);
+          processRouteTreeResult = this.buildRouteTree();
+          if (this.isServer && globalThis.__TSR_CACHE__ === void 0) {
+            globalThis.__TSR_CACHE__ = {
+              routeTree: this.routeTree,
+              processRouteTreeResult,
+              resolvePathCache: this.resolvePathCache
+            };
+          }
+        }
+        this.setRoutes(processRouteTreeResult);
       }
       if (!this.__store && this.latestLocation) {
         this.__store = new Store(getInitialRouterState(this.latestLocation), {
@@ -153,7 +169,7 @@ class RouterCore {
       );
     };
     this.buildRouteTree = () => {
-      const { routesById, routesByPath, processedTree } = processRouteTree(
+      const result = processRouteTree(
         this.routeTree,
         this.options.caseSensitive,
         (route, i) => {
@@ -163,18 +179,9 @@ class RouterCore {
         }
       );
       if (this.options.routeMasks) {
-        processRouteMasks(this.options.routeMasks, processedTree);
-      }
-      this.routesById = routesById;
-      this.routesByPath = routesByPath;
-      this.processedTree = processedTree;
-      const notFoundRoute = this.options.notFoundRoute;
-      if (notFoundRoute) {
-        notFoundRoute.init({
-          originalIndex: 99999999999
-        });
-        this.routesById[notFoundRoute.id] = notFoundRoute;
+        processRouteMasks(this.options.routeMasks, result.processedTree);
       }
+      return result;
     };
     this.subscribe = (eventType, fn) => {
       const listener = {
@@ -229,7 +236,6 @@ class RouterCore {
       }
       return location;
     };
-    this.resolvePathCache = createLRUCache(1e3);
     this.resolvePathWithBase = (from, path) => {
       const resolvedPath = resolvePath({
         base: from,
@@ -284,26 +290,23 @@ class RouterCore {
     this.buildLocation = (opts) => {
       const build = (dest = {}) => {
         const currentLocation = dest._fromLocation || this.pendingBuiltLocation || this.latestLocation;
-        const allCurrentLocationMatches = this.matchRoutes(currentLocation, {
-          _buildLocation: true
-        });
-        const lastMatch = last(allCurrentLocationMatches);
+        const lightweightResult = this.matchRoutesLightweight(currentLocation);
         if (dest.from && process.env.NODE_ENV !== "production" && dest._isNavigate) {
           const allFromMatches = this.getMatchedRoutes(dest.from).matchedRoutes;
-          const matchedFrom = findLast(allCurrentLocationMatches, (d) => {
+          const matchedFrom = findLast(lightweightResult.matchedRoutes, (d) => {
             return comparePaths(d.fullPath, dest.from);
           });
           const matchedCurrent = findLast(allFromMatches, (d) => {
-            return comparePaths(d.fullPath, lastMatch.fullPath);
+            return comparePaths(d.fullPath, lightweightResult.fullPath);
           });
           if (!matchedFrom && !matchedCurrent) {
             console.warn(`Could not find match for from: ${dest.from}`);
           }
         }
-        const defaultedFromPath = dest.unsafeRelative === "path" ? currentLocation.pathname : dest.from ?? lastMatch.fullPath;
+        const defaultedFromPath = dest.unsafeRelative === "path" ? currentLocation.pathname : dest.from ?? lightweightResult.fullPath;
         const fromPath = this.resolvePathWithBase(defaultedFromPath, ".");
-        const fromSearch = lastMatch.search;
-        const fromParams = { ...lastMatch.params };
+        const fromSearch = lightweightResult.search;
+        const fromParams = { ...lightweightResult.params };
         const nextTo = dest.to ? this.resolvePathWithBase(fromPath, `${dest.to}`) : this.resolvePathWithBase(fromPath, ".");
         const nextParams = dest.params === false || dest.params === null ? {} : (dest.params ?? true) === true ? fromParams : Object.assign(
           fromParams,
@@ -1032,6 +1035,22 @@ class RouterCore {
   get state() {
     return this.__store.state;
   }
+  setRoutes({
+    routesById,
+    routesByPath,
+    processedTree
+  }) {
+    this.routesById = routesById;
+    this.routesByPath = routesByPath;
+    this.processedTree = processedTree;
+    const notFoundRoute = this.options.notFoundRoute;
+    if (notFoundRoute) {
+      notFoundRoute.init({
+        originalIndex: 99999999999
+      });
+      this.routesById[notFoundRoute.id] = notFoundRoute;
+    }
+  }
   get looseRoutesById() {
     return this.routesById;
   }
@@ -1110,32 +1129,18 @@ class RouterCore {
       const strictParams = existingMatch?._strictParams ?? usedParams;
       let paramsError = void 0;
       if (!existingMatch) {
-        if (route.options.skipRouteOnParseError) {
-          for (const key in usedParams) {
-            if (key in parsedParams) {
-              strictParams[key] = parsedParams[key];
-            }
+        try {
+          extractStrictParams(route, usedParams, parsedParams, strictParams);
+        } catch (err) {
+          if (isNotFound(err) || isRedirect(err)) {
+            paramsError = err;
+          } else {
+            paramsError = new PathParamError(err.message, {
+              cause: err
+            });
           }
-        } else {
-          const strictParseParams = route.options.params?.parse ?? route.options.parseParams;
-          if (strictParseParams) {
-            try {
-              Object.assign(
-                strictParams,
-                strictParseParams(strictParams)
-              );
-            } catch (err) {
-              if (isNotFound(err) || isRedirect(err)) {
-                paramsError = err;
-              } else {
-                paramsError = new PathParamError(err.message, {
-                  cause: err
-                });
-              }
-              if (opts?.throwOnError) {
-                throw paramsError;
-              }
-            }
+          if (opts?.throwOnError) {
+            throw paramsError;
           }
         }
       }
@@ -1204,7 +1209,7 @@ class RouterCore {
     matches.forEach((match, index) => {
       const route = this.looseRoutesById[match.routeId];
       const existingMatch = this.getMatch(match.id);
-      if (!existingMatch && opts?._buildLocation !== true) {
+      if (!existingMatch) {
         const parentMatch = matches[index - 1];
         const parentContext = getParentContext(parentMatch);
         if (route.options.context) {
@@ -1231,6 +1236,53 @@ class RouterCore {
     });
     return matches;
   }
+  /**
+   * Lightweight route matching for buildLocation.
+   * Only computes fullPath, accumulated search, and params - skipping expensive
+   * operations like AbortController, ControlledPromise, loaderDeps, and full match objects.
+   */
+  matchRoutesLightweight(location) {
+    const { matchedRoutes, routeParams, parsedParams } = this.getMatchedRoutes(
+      location.pathname
+    );
+    const lastRoute = last(matchedRoutes);
+    const accumulatedSearch = { ...location.search };
+    for (const route of matchedRoutes) {
+      try {
+        Object.assign(
+          accumulatedSearch,
+          validateSearch(route.options.validateSearch, accumulatedSearch)
+        );
+      } catch {
+      }
+    }
+    const lastStateMatch = last(this.state.matches);
+    const canReuseParams = lastStateMatch && lastStateMatch.routeId === lastRoute.id && location.pathname === this.state.location.pathname;
+    let params;
+    if (canReuseParams) {
+      params = lastStateMatch.params;
+    } else {
+      const strictParams = { ...routeParams };
+      for (const route of matchedRoutes) {
+        try {
+          extractStrictParams(
+            route,
+            routeParams,
+            parsedParams ?? {},
+            strictParams
+          );
+        } catch {
+        }
+      }
+      params = strictParams;
+    }
+    return {
+      matchedRoutes,
+      fullPath: lastRoute.fullPath,
+      search: accumulatedSearch,
+      params
+    };
+  }
 }
 class SearchParamError extends Error {
 }
@@ -1393,6 +1445,21 @@ function findGlobalNotFoundRouteId(notFoundMode, routes) {
   }
   return rootRouteId;
 }
+function extractStrictParams(route, referenceParams, parsedParams, accumulatedParams) {
+  const parseParams = route.options.params?.parse ?? route.options.parseParams;
+  if (parseParams) {
+    if (route.options.skipRouteOnParseError) {
+      for (const key in referenceParams) {
+        if (key in parsedParams) {
+          accumulatedParams[key] = parsedParams[key];
+        }
+      }
+    } else {
+      const result = parseParams(accumulatedParams);
+      Object.assign(accumulatedParams, result);
+    }
+  }
+}
 export {
   PathParamError,
   RouterCore,