@tanstack/router-core 1.153.1 → 1.153.2

package/dist/cjs/index.d.cts

@@ -6,7 +6,7 @@ export type { IsRequiredParams, AddTrailingSlash, RemoveTrailingSlashes, AddLead
 export { componentTypes } from './load-matches.cjs';
 export type { RouteToPath, TrailingSlashOptionByRouter, ParseRoute, CodeRouteToPath, RouteIds, FullSearchSchema, FullSearchSchemaInput, AllParams, RouteById, AllContext, RoutePaths, RoutesById, RoutesByPath, AllLoaderData, RouteByPath, } from './routeInfo.cjs';
 export type { InferFileRouteTypes, FileRouteTypes, FileRoutesByPath, CreateFileRoute, LazyRoute, LazyRouteOptions, CreateLazyFileRoute, } from './fileRoute.cjs';
-export type { ParsedLocation } from './location.cjs';
+export type { MatchSnapshot, ParsedLocation, ValidatedSearchEntry, } from './location.cjs';
 export type { Manifest, RouterManagedTag } from './manifest.cjs';
 export { isMatch } from './Matches.cjs';
 export type { AnyMatchAndValue, FindValueByIndex, FindValueByKey, CreateMatchAndValue, NextMatchAndValue, IsMatchKeyOf, IsMatchPath, IsMatchResult, IsMatchParse, IsMatch, RouteMatch, RouteMatchExtensions, MakeRouteMatchUnion, MakeRouteMatch, AnyRouteMatch, MakeRouteMatchFromRoute, MatchRouteOptions, } from './Matches.cjs';

package/dist/cjs/location.d.cts

@@ -1,5 +1,32 @@
 import { ParsedHistoryState } from '@tanstack/history';
 import { AnySchema } from './validators.cjs';
+/**
+ * Per-route validated search result cached in snapshot.
+ */
+export interface ValidatedSearchEntry {
+    /** Merged search (parent + this route's validated) */
+    search: Record<string, unknown>;
+    /** Strict search (only this route's validated fields) */
+    strictSearch: Record<string, unknown>;
+}
+/**
+ * Match snapshot stored in history state for fast-path on back/forward navigation.
+ * Allows skipping path matching by storing route IDs and params.
+ */
+export interface MatchSnapshot {
+    /** Ordered route IDs that matched */
+    routeIds: Array<string>;
+    /** Raw path params extracted from the URL */
+    params: Record<string, string>;
+    /** Parsed/validated path params */
+    parsedParams: Record<string, unknown>;
+    /** Route ID that should show global not found, if any */
+    globalNotFoundRouteId?: string;
+    /** Search string when snapshot was created (for cache invalidation) */
+    searchStr?: string;
+    /** Per-route validated search results (parallel to routeIds) */
+    validatedSearches?: Array<ValidatedSearchEntry>;
+}
 export interface ParsedLocation<TSearchObj extends AnySchema = {}> {
     /**
      * The full path of the location, including pathname, search, and hash.

package/dist/cjs/router.cjs

@@ -49,7 +49,6 @@ class RouterCore {
     this.tempLocationKey = `${Math.round(
       Math.random() * 1e7
     )}`;
-    this.resetNextScroll = true;
     this.shouldViewTransition = void 0;
     this.isViewTransitionTypesSupported = void 0;
     this.subscribers = /* @__PURE__ */ new Set();
@@ -317,9 +316,13 @@ class RouterCore {
           path: nextTo,
           params: nextParams
         }).interpolatedPath;
-        const destRoutes = this.matchRoutes(interpolatedNextTo, void 0, {
+        const destMatches = this.matchRoutes(interpolatedNextTo, void 0, {
           _buildLocation: true
-        }).map((d) => this.looseRoutesById[d.routeId]);
+        });
+        const destRoutes = destMatches.map(
+          (d) => this.looseRoutesById[d.routeId]
+        );
+        const globalNotFoundMatch = destMatches.find((m) => m.globalNotFound);
         if (Object.keys(nextParams).length > 0) {
           for (const route of destRoutes) {
             const fn = route.options.params?.stringify ?? route.options.stringifyParams;
@@ -370,19 +373,27 @@ class RouterCore {
         const hashStr = hash ? `#${hash}` : "";
         let nextState = dest.state === true ? currentLocation.state : dest.state ? utils.functionalUpdate(dest.state, currentLocation.state) : {};
         nextState = utils.replaceEqualDeep(currentLocation.state, nextState);
+        const matchSnapshot = buildMatchSnapshotFromRoutes({
+          routes: destRoutes,
+          params: nextParams,
+          searchStr,
+          globalNotFoundRouteId: globalNotFoundMatch?.routeId
+        });
         const fullPath = `${nextPathname}${searchStr}${hashStr}`;
         const url = new URL(fullPath, this.origin);
         const rewrittenUrl = rewrite.executeRewriteOutput(this.rewrite, url);
+        const encodedHref = url.href.replace(url.origin, "");
         return {
           publicHref: rewrittenUrl.pathname + rewrittenUrl.search + rewrittenUrl.hash,
-          href: fullPath,
+          href: encodedHref,
           url: rewrittenUrl,
           pathname: nextPathname,
           search: nextSearch,
           searchStr,
           state: nextState,
           hash: hash ?? "",
-          unmaskOnReload: dest.unmaskOnReload
+          unmaskOnReload: dest.unmaskOnReload,
+          _matchSnapshot: matchSnapshot
         };
       };
       const buildWithMatches = (dest = {}, maskedDest) => {
@@ -425,7 +436,7 @@ class RouterCore {
       }
       return buildWithMatches(opts);
     };
-    this.commitLocation = ({
+    this.commitLocation = async ({
       viewTransition,
       ignoreBlocker,
       ...next
@@ -454,53 +465,73 @@ class RouterCore {
       });
       if (isSameUrl && isSameState()) {
         this.load();
-      } else {
-        let {
-          // eslint-disable-next-line prefer-const
-          maskedLocation,
-          // eslint-disable-next-line prefer-const
-          hashScrollIntoView,
-          // don't pass url into history since it is a URL instance that cannot be serialized
-          // eslint-disable-next-line prefer-const
-          url: _url,
-          ...nextHistory
-        } = next;
-        if (maskedLocation) {
-          nextHistory = {
-            ...maskedLocation,
-            state: {
-              ...maskedLocation.state,
-              __tempKey: void 0,
-              __tempLocation: {
-                ...nextHistory,
-                search: nextHistory.searchStr,
-                state: {
-                  ...nextHistory.state,
-                  __tempKey: void 0,
-                  __tempLocation: void 0,
-                  __TSR_key: void 0,
-                  key: void 0
-                  // TODO: Remove in v2 - use __TSR_key instead
-                }
+        return this.commitLocationPromise;
+      }
+      let {
+        // eslint-disable-next-line prefer-const
+        maskedLocation,
+        // eslint-disable-next-line prefer-const
+        hashScrollIntoView,
+        // don't pass url into history since it is a URL instance that cannot be serialized
+        // eslint-disable-next-line prefer-const
+        url: _url,
+        ...nextHistory
+      } = next;
+      if (maskedLocation) {
+        nextHistory = {
+          ...maskedLocation,
+          state: {
+            ...maskedLocation.state,
+            __tempKey: void 0,
+            __tempLocation: {
+              ...nextHistory,
+              search: nextHistory.searchStr,
+              state: {
+                ...nextHistory.state,
+                __tempKey: void 0,
+                __tempLocation: void 0,
+                __TSR_key: void 0,
+                key: void 0
+                // TODO: Remove in v2 - use __TSR_key instead
               }
             }
-          };
-          if (nextHistory.unmaskOnReload ?? this.options.unmaskOnReload ?? false) {
-            nextHistory.state.__tempKey = this.tempLocationKey;
           }
+        };
+        if (nextHistory.unmaskOnReload ?? this.options.unmaskOnReload ?? false) {
+          nextHistory.state.__tempKey = this.tempLocationKey;
         }
-        nextHistory.state.__hashScrollIntoViewOptions = hashScrollIntoView ?? this.options.defaultHashScrollIntoView ?? true;
-        this.shouldViewTransition = viewTransition;
-        this.history[next.replace ? "replace" : "push"](
-          nextHistory.publicHref,
-          nextHistory.state,
-          { ignoreBlocker }
-        );
       }
-      this.resetNextScroll = next.resetScroll ?? true;
-      if (!this.history.subscribers.size) {
-        this.load();
+      nextHistory.state.__hashScrollIntoViewOptions = hashScrollIntoView ?? this.options.defaultHashScrollIntoView ?? true;
+      nextHistory.state.__TSR_resetScroll = next.resetScroll ?? true;
+      this.shouldViewTransition = viewTransition;
+      nextHistory.state.__TSR_sessionId = this.sessionId;
+      nextHistory.state.__TSR_matches = next._matchSnapshot ?? buildMatchSnapshot({
+        matchResult: this.getMatchedRoutes(next.pathname),
+        pathname: next.pathname,
+        searchStr: next.searchStr,
+        notFoundRoute: this.options.notFoundRoute,
+        notFoundMode: this.options.notFoundMode
+      });
+      const precomputedLocation = {
+        ...next,
+        publicHref: nextHistory.publicHref,
+        state: nextHistory.state,
+        maskedLocation
+      };
+      const result = await this.history[next.replace ? "replace" : "push"](
+        nextHistory.publicHref,
+        nextHistory.state,
+        { ignoreBlocker, skipTransitionerLoad: true }
+      );
+      if (result.type === "BLOCKED") {
+        this.commitLocationPromise?.resolve();
+        return this.commitLocationPromise;
+      }
+      if (this.history.location.href !== nextHistory.publicHref) {
+        return this.commitLocationPromise;
       }
+      this.latestLocation = precomputedLocation;
+      this.load({ _skipUpdateLatestLocation: true });
       return this.commitLocationPromise;
     };
     this.buildAndCommitLocation = ({
@@ -607,9 +638,11 @@ class RouterCore {
         _isNavigate: true
       });
     };
-    this.beforeLoad = () => {
+    this.beforeLoad = (opts) => {
       this.cancelMatches();
-      this.updateLatestLocation();
+      if (!opts?._skipUpdateLatestLocation) {
+        this.updateLatestLocation();
+      }
       if (this.isServer) {
         const nextLocation = this.buildLocation({
           to: this.latestLocation.pathname,
@@ -624,7 +657,8 @@ class RouterCore {
           throw redirect.redirect({ href });
         }
       }
-      const pendingMatches = this.matchRoutes(this.latestLocation);
+      const snapshot = this.latestLocation.state.__TSR_sessionId === this.sessionId ? this.latestLocation.state.__TSR_matches : void 0;
+      const pendingMatches = this.matchRoutes(this.latestLocation, { snapshot });
       this.__store.setState((s) => ({
         ...s,
         status: "pending",
@@ -645,7 +679,9 @@ class RouterCore {
       loadPromise = new Promise((resolve) => {
         this.startTransition(async () => {
           try {
-            this.beforeLoad();
+            this.beforeLoad({
+              _skipUpdateLatestLocation: opts?._skipUpdateLatestLocation
+            });
             const next = this.latestLocation;
             const prevLocation = this.state.resolvedLocation;
             if (!this.state.redirect) {
@@ -1002,6 +1038,7 @@ class RouterCore {
         (d) => d.status === "notFound" || d.globalNotFound
       );
     };
+    this.sessionId = typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : `${Date.now()}-${Math.random().toString(36).slice(2)}`;
     this.update({
       defaultPreloadDelay: 50,
       defaultPendingMs: 1e3,
@@ -1030,46 +1067,67 @@ class RouterCore {
     return this.routesById;
   }
   matchRoutesInternal(next, opts) {
-    const matchedRoutesResult = this.getMatchedRoutes(next.pathname);
-    const { foundRoute, routeParams, parsedParams } = matchedRoutesResult;
-    let { matchedRoutes } = matchedRoutesResult;
-    let isGlobalNotFound = false;
-    if (
-      // If we found a route, and it's not an index route and we have left over path
-      foundRoute ? foundRoute.path !== "/" && routeParams["**"] : (
-        // Or if we didn't find a route and we have left over path
-        path.trimPathRight(next.pathname)
-      )
-    ) {
-      if (this.options.notFoundRoute) {
-        matchedRoutes = [...matchedRoutes, this.options.notFoundRoute];
-      } else {
-        isGlobalNotFound = true;
-      }
-    }
-    const globalNotFoundRouteId = (() => {
-      if (!isGlobalNotFound) {
-        return void 0;
+    const snapshot = opts?.snapshot;
+    const snapshotValid = snapshot && snapshot.routeIds.length > 0 && snapshot.routeIds.every((id) => this.routesById[id]);
+    let matchedRoutes;
+    let routeParams;
+    let globalNotFoundRouteId;
+    let parsedParams;
+    if (snapshotValid) {
+      matchedRoutes = snapshot.routeIds.map((id) => this.routesById[id]);
+      routeParams = { ...snapshot.params };
+      globalNotFoundRouteId = snapshot.globalNotFoundRouteId;
+      parsedParams = snapshot.parsedParams;
+    } else {
+      const matchedRoutesResult = this.getMatchedRoutes(next.pathname);
+      const { foundRoute, routeParams: rp } = matchedRoutesResult;
+      routeParams = rp;
+      matchedRoutes = matchedRoutesResult.matchedRoutes;
+      parsedParams = matchedRoutesResult.parsedParams;
+      let isGlobalNotFound = false;
+      if (
+        // If we found a route, and it's not an index route and we have left over path
+        foundRoute ? foundRoute.path !== "/" && routeParams["**"] : (
+          // Or if we didn't find a route and we have left over path
+          path.trimPathRight(next.pathname)
+        )
+      ) {
+        if (this.options.notFoundRoute) {
+          matchedRoutes = [...matchedRoutes, this.options.notFoundRoute];
+        } else {
+          isGlobalNotFound = true;
+        }
       }
-      if (this.options.notFoundMode !== "root") {
-        for (let i = matchedRoutes.length - 1; i >= 0; i--) {
-          const route = matchedRoutes[i];
-          if (route.children) {
-            return route.id;
+      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;
-    })();
+        return root.rootRouteId;
+      })();
+    }
     const matches = [];
     const getParentContext = (parentMatch) => {
       const parentMatchId = parentMatch?.id;
       const parentContext = !parentMatchId ? this.options.context ?? void 0 : parentMatch.context ?? this.options.context ?? void 0;
       return parentContext;
     };
+    const canUseCachedSearch = snapshotValid && snapshot.searchStr === next.searchStr && snapshot.validatedSearches?.length === matchedRoutes.length;
+    const validatedSearchesToCache = [];
     matchedRoutes.forEach((route, index) => {
       const parentMatch = matches[index - 1];
       const [preMatchSearch, strictMatchSearch, searchError] = (() => {
+        if (canUseCachedSearch) {
+          const cached = snapshot.validatedSearches[index];
+          return [cached.search, cached.strictSearch, void 0];
+        }
         const parentSearch = parentMatch?.search ?? next.search;
         const parentStrictSearch = parentMatch?._strictSearch ?? void 0;
         try {
@@ -1095,6 +1153,12 @@ class RouterCore {
           return [parentSearch, {}, searchParamError];
         }
       })();
+      if (!canUseCachedSearch) {
+        validatedSearchesToCache.push({
+          search: preMatchSearch,
+          strictSearch: strictMatchSearch
+        });
+      }
       const loaderDeps = route.options.loaderDeps?.({
         search: preMatchSearch
       }) ?? "";
@@ -1208,6 +1272,13 @@ class RouterCore {
       };
       matches.push(match);
     });
+    if (!canUseCachedSearch && validatedSearchesToCache.length > 0) {
+      const existingSnapshot = next.state?.__TSR_matches;
+      if (existingSnapshot) {
+        existingSnapshot.searchStr = next.searchStr;
+        existingSnapshot.validatedSearches = validatedSearchesToCache;
+      }
+    }
     matches.forEach((match, index) => {
       const route = this.looseRoutesById[match.routeId];
       const existingMatch = this.getMatch(match.id);
@@ -1295,7 +1366,7 @@ function getMatchedRoutes({
   const routeParams = {};
   const trimmedPath = path.trimPathRight(pathname);
   let foundRoute = void 0;
-  let parsedParams = void 0;
+  let parsedParams = {};
   const match = newProcessRouteTree.findRouteMatch(trimmedPath, processedTree, true);
   if (match) {
     foundRoute = match.route;
@@ -1305,6 +1376,64 @@ function getMatchedRoutes({
   const matchedRoutes = match?.branch || [routesById[root.rootRouteId]];
   return { matchedRoutes, routeParams, foundRoute, parsedParams };
 }
+function buildMatchSnapshot({
+  matchResult,
+  pathname,
+  searchStr,
+  notFoundRoute,
+  notFoundMode
+}) {
+  const snapshot = {
+    routeIds: matchResult.matchedRoutes.map((r) => r.id),
+    params: matchResult.routeParams,
+    parsedParams: matchResult.parsedParams,
+    searchStr
+  };
+  const isGlobalNotFound = matchResult.foundRoute ? matchResult.foundRoute.path !== "/" && matchResult.routeParams["**"] : path.trimPathRight(pathname);
+  if (isGlobalNotFound) {
+    if (notFoundRoute) {
+      snapshot.globalNotFoundRouteId = notFoundRoute.id;
+    } else {
+      if (notFoundMode !== "root") {
+        for (let i = matchResult.matchedRoutes.length - 1; i >= 0; i--) {
+          const route = matchResult.matchedRoutes[i];
+          if (route.children) {
+            snapshot.globalNotFoundRouteId = route.id;
+            break;
+          }
+        }
+      }
+      if (!snapshot.globalNotFoundRouteId) {
+        snapshot.globalNotFoundRouteId = root.rootRouteId;
+      }
+    }
+  }
+  return snapshot;
+}
+function buildMatchSnapshotFromRoutes({
+  routes,
+  params,
+  searchStr,
+  globalNotFoundRouteId
+}) {
+  const stringParams = {};
+  for (const key in params) {
+    const value = params[key];
+    if (value != null) {
+      stringParams[key] = String(value);
+    }
+  }
+  const snapshot = {
+    routeIds: routes.map((r) => r.id),
+    params: stringParams,
+    parsedParams: params,
+    searchStr
+  };
+  if (globalNotFoundRouteId) {
+    snapshot.globalNotFoundRouteId = globalNotFoundRouteId;
+  }
+  return snapshot;
+}
 function applySearchMiddleware({
   search,
   dest,
@@ -1385,6 +1514,8 @@ function applySearchMiddleware({
 exports.PathParamError = PathParamError;
 exports.RouterCore = RouterCore;
 exports.SearchParamError = SearchParamError;
+exports.buildMatchSnapshot = buildMatchSnapshot;
+exports.buildMatchSnapshotFromRoutes = buildMatchSnapshotFromRoutes;
 exports.defaultSerializeError = defaultSerializeError;
 exports.getInitialRouterState = getInitialRouterState;
 exports.getLocationChangeInfo = getLocationChangeInfo;