@tanstack/router-core 1.154.14 → 1.156.0

package/dist/cjs/path.d.cts

@@ -27,10 +27,19 @@ interface ResolvePathOptions {
  * and supporting relative segments (`.`/`..`) and absolute `to` values.
  */
 export declare function resolvePath({ base, to, trailingSlash, cache, }: ResolvePathOptions): string;
+/**
+ * Create a pre-compiled decode config from allowed characters.
+ * This should be called once at router initialization.
+ */
+export declare function compileDecodeCharMap(pathParamsAllowedCharacters: ReadonlyArray<string>): (encoded: string) => string;
 interface InterpolatePathOptions {
     path?: string;
     params: Record<string, unknown>;
-    decodeCharMap?: Map<string, string>;
+    /**
+     * A function that decodes a path parameter value.
+     * Obtained from `compileDecodeCharMap(pathParamsAllowedCharacters)`.
+     */
+    decoder?: (encoded: string) => string;
 }
 type InterPolatePathResult = {
     interpolatedPath: string;
@@ -43,5 +52,5 @@ type InterPolatePathResult = {
  * - Encodes params safely (configurable allowed characters)
  * - Supports `{-$optional}` segments, `{prefix{$id}suffix}` and `{$}` wildcards
  */
-export declare function interpolatePath({ path, params, decodeCharMap, }: InterpolatePathOptions): InterPolatePathResult;
+export declare function interpolatePath({ path, params, decoder, }: InterpolatePathOptions): InterPolatePathResult;
 export {};

package/dist/cjs/router.cjs

@@ -71,12 +71,10 @@ class RouterCore {
         ...newOptions
       };
       this.isServer = this.options.isServer ?? typeof document === "undefined";
-      this.pathParamsDecodeCharMap = this.options.pathParamsAllowedCharacters ? new Map(
-        this.options.pathParamsAllowedCharacters.map((char) => [
-          encodeURIComponent(char),
-          char
-        ])
-      ) : void 0;
+      if (this.options.pathParamsAllowedCharacters)
+        this.pathParamsDecoder = path.compileDecodeCharMap(
+          this.options.pathParamsAllowedCharacters
+        );
       if (!this.history || this.options.history && this.options.history !== this.history) {
         if (!this.options.history) {
           if (!this.isServer) {
@@ -99,7 +97,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 = lruCache.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.Store(getInitialRouterState(this.latestLocation), {
@@ -157,7 +171,7 @@ class RouterCore {
       );
     };
     this.buildRouteTree = () => {
-      const { routesById, routesByPath, processedTree } = newProcessRouteTree.processRouteTree(
+      const result = newProcessRouteTree.processRouteTree(
         this.routeTree,
         this.options.caseSensitive,
         (route, i) => {
@@ -167,18 +181,9 @@ class RouterCore {
         }
       );
       if (this.options.routeMasks) {
-        newProcessRouteTree.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;
+        newProcessRouteTree.processRouteMasks(this.options.routeMasks, result.processedTree);
       }
+      return result;
     };
     this.subscribe = (eventType, fn) => {
       const listener = {
@@ -233,7 +238,6 @@ class RouterCore {
       }
       return location;
     };
-    this.resolvePathCache = lruCache.createLRUCache(1e3);
     this.resolvePathWithBase = (from, path$1) => {
       const resolvedPath = path.resolvePath({
         base: from,
@@ -288,26 +292,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 = utils.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 = utils.findLast(allCurrentLocationMatches, (d) => {
+          const matchedFrom = utils.findLast(lightweightResult.matchedRoutes, (d) => {
             return comparePaths(d.fullPath, dest.from);
           });
           const matchedCurrent = utils.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,
@@ -346,7 +347,7 @@ class RouterCore {
           path.interpolatePath({
             path: nextTo,
             params: nextParams,
-            decodeCharMap: this.pathParamsDecodeCharMap
+            decoder: this.pathParamsDecoder
           }).interpolatedPath
         );
         let nextSearch = fromSearch;
@@ -1036,6 +1037,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;
   }
@@ -1099,7 +1116,7 @@ class RouterCore {
       const { interpolatedPath, usedParams } = path.interpolatePath({
         path: route.fullPath,
         params: routeParams,
-        decodeCharMap: this.pathParamsDecodeCharMap
+        decoder: this.pathParamsDecoder
       });
       const matchId = (
         // route.id for disambiguation
@@ -1114,32 +1131,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 (notFound.isNotFound(err) || redirect.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 (notFound.isNotFound(err) || redirect.isRedirect(err)) {
-                paramsError = err;
-              } else {
-                paramsError = new PathParamError(err.message, {
-                  cause: err
-                });
-              }
-              if (opts?.throwOnError) {
-                throw paramsError;
-              }
-            }
+          if (opts?.throwOnError) {
+            throw paramsError;
           }
         }
       }
@@ -1208,7 +1211,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) {
@@ -1235,6 +1238,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 = utils.last(matchedRoutes);
+    const accumulatedSearch = { ...location.search };
+    for (const route of matchedRoutes) {
+      try {
+        Object.assign(
+          accumulatedSearch,
+          validateSearch(route.options.validateSearch, accumulatedSearch)
+        );
+      } catch {
+      }
+    }
+    const lastStateMatch = utils.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 {
 }
@@ -1397,6 +1447,21 @@ function findGlobalNotFoundRouteId(notFoundMode, routes) {
   }
   return root.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);
+    }
+  }
+}
 exports.PathParamError = PathParamError;
 exports.RouterCore = RouterCore;
 exports.SearchParamError = SearchParamError;