@tanstack/router-core 1.154.12 → 1.154.14

package/dist/esm/router.js

@@ -47,6 +47,7 @@ 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();
@@ -248,9 +249,9 @@ class RouterCore {
             search: locationSearchOrOpts
           },
           opts
-        ).matches;
+        );
       }
-      return this.matchRoutesInternal(pathnameOrNext, locationSearchOrOpts).matches;
+      return this.matchRoutesInternal(pathnameOrNext, locationSearchOrOpts);
     };
     this.getMatchedRoutes = (pathname) => {
       return getMatchedRoutes({
@@ -316,14 +317,12 @@ class RouterCore {
         }).interpolatedPath;
         const destMatchResult = this.getMatchedRoutes(interpolatedNextTo);
         let destRoutes = destMatchResult.matchedRoutes;
-        const rawParams = destMatchResult.routeParams;
         const isGlobalNotFound = destMatchResult.foundRoute ? destMatchResult.foundRoute.path !== "/" && destMatchResult.routeParams["**"] : trimPathRight(interpolatedNextTo);
-        let globalNotFoundRouteId;
         if (isGlobalNotFound) {
           if (this.options.notFoundRoute) {
             destRoutes = [...destRoutes, this.options.notFoundRoute];
           } else {
-            globalNotFoundRouteId = findGlobalNotFoundRouteId(
+            findGlobalNotFoundRouteId(
               this.options.notFoundMode,
               destRoutes
             );
@@ -379,31 +378,19 @@ class RouterCore {
         const hashStr = hash ? `#${hash}` : "";
         let nextState = dest.state === true ? currentLocation.state : dest.state ? functionalUpdate(dest.state, currentLocation.state) : {};
         nextState = replaceEqualDeep(currentLocation.state, nextState);
-        const snapshotParams = {
-          ...rawParams,
-          ...nextParams
-        };
-        const matchSnapshot = buildMatchSnapshotFromRoutes({
-          routes: destRoutes,
-          params: snapshotParams,
-          searchStr,
-          globalNotFoundRouteId
-        });
         const fullPath = `${nextPathname}${searchStr}${hashStr}`;
         const url = new URL(fullPath, this.origin);
         const rewrittenUrl = executeRewriteOutput(this.rewrite, url);
-        const encodedHref = url.href.replace(url.origin, "");
         return {
           publicHref: rewrittenUrl.pathname + rewrittenUrl.search + rewrittenUrl.hash,
-          href: encodedHref,
+          href: fullPath,
           url: rewrittenUrl,
           pathname: nextPathname,
           search: nextSearch,
           searchStr,
           state: nextState,
           hash: hash ?? "",
-          unmaskOnReload: dest.unmaskOnReload,
-          _matchSnapshot: matchSnapshot
+          unmaskOnReload: dest.unmaskOnReload
         };
       };
       const buildWithMatches = (dest = {}, maskedDest) => {
@@ -475,73 +462,53 @@ class RouterCore {
       });
       if (isSameUrl && isSameState()) {
         this.load();
-        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
+      } 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
+                }
               }
             }
+          };
+          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 }
+        );
       }
-      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.resetNextScroll = next.resetScroll ?? true;
+      if (!this.history.subscribers.size) {
+        this.load();
       }
-      this.latestLocation = precomputedLocation;
-      this.load({ _skipUpdateLatestLocation: true });
       return this.commitLocationPromise;
     };
     this.buildAndCommitLocation = ({
@@ -648,11 +615,9 @@ class RouterCore {
         _isNavigate: true
       });
     };
-    this.beforeLoad = (opts) => {
+    this.beforeLoad = () => {
       this.cancelMatches();
-      if (!opts?._skipUpdateLatestLocation) {
-        this.updateLatestLocation();
-      }
+      this.updateLatestLocation();
       if (this.isServer) {
         const nextLocation = this.buildLocation({
           to: this.latestLocation.pathname,
@@ -667,8 +632,7 @@ class RouterCore {
           throw redirect({ href });
         }
       }
-      const snapshot = this.latestLocation.state.__TSR_sessionId === this.sessionId ? this.latestLocation.state.__TSR_matches : void 0;
-      const pendingMatches = this.matchRoutes(this.latestLocation, { snapshot });
+      const pendingMatches = this.matchRoutes(this.latestLocation);
       this.__store.setState((s) => ({
         ...s,
         status: "pending",
@@ -689,9 +653,7 @@ class RouterCore {
       loadPromise = new Promise((resolve) => {
         this.startTransition(async () => {
           try {
-            this.beforeLoad({
-              _skipUpdateLatestLocation: opts?._skipUpdateLatestLocation
-            });
+            this.beforeLoad();
             const next = this.latestLocation;
             const prevLocation = this.state.resolvedLocation;
             if (!this.state.redirect) {
@@ -1048,7 +1010,6 @@ 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,
@@ -1077,57 +1038,33 @@ class RouterCore {
     return this.routesById;
   }
   matchRoutesInternal(next, opts) {
-    const snapshot = opts?.snapshot;
-    const snapshotValid = snapshot && snapshot.routeIds.length > 0 && snapshot.routeIds.every((id) => this.routesById[id]);
-    let matchedRoutes;
-    let routeParams;
-    let rawParams;
-    let globalNotFoundRouteId;
-    let parsedParams;
-    if (snapshotValid) {
-      matchedRoutes = snapshot.routeIds.map((id) => this.routesById[id]);
-      routeParams = { ...snapshot.params };
-      rawParams = { ...snapshot.params };
-      globalNotFoundRouteId = snapshot.globalNotFoundRouteId;
-      parsedParams = snapshot.parsedParams;
-    } else {
-      const matchedRoutesResult = this.getMatchedRoutes(next.pathname);
-      const { foundRoute, routeParams: rp } = matchedRoutesResult;
-      routeParams = rp;
-      rawParams = { ...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
-          trimPathRight(next.pathname)
-        )
-      ) {
-        if (this.options.notFoundRoute) {
-          matchedRoutes = [...matchedRoutes, this.options.notFoundRoute];
-        } else {
-          isGlobalNotFound = true;
-        }
+    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
+        trimPathRight(next.pathname)
+      )
+    ) {
+      if (this.options.notFoundRoute) {
+        matchedRoutes = [...matchedRoutes, this.options.notFoundRoute];
+      } else {
+        isGlobalNotFound = true;
       }
-      globalNotFoundRouteId = isGlobalNotFound ? findGlobalNotFoundRouteId(this.options.notFoundMode, matchedRoutes) : void 0;
     }
+    const globalNotFoundRouteId = isGlobalNotFound ? findGlobalNotFoundRouteId(this.options.notFoundMode, matchedRoutes) : void 0;
     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 {
@@ -1153,12 +1090,6 @@ class RouterCore {
           return [parentSearch, {}, searchParamError];
         }
       })();
-      if (!canUseCachedSearch) {
-        validatedSearchesToCache.push({
-          search: preMatchSearch,
-          strictSearch: strictMatchSearch
-        });
-      }
       const loaderDeps = route.options.loaderDeps?.({
         search: preMatchSearch
       }) ?? "";
@@ -1272,13 +1203,6 @@ 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);
@@ -1307,7 +1231,7 @@ class RouterCore {
         };
       }
     });
-    return { matches, rawParams };
+    return matches;
   }
 }
 class SearchParamError extends Error {
@@ -1366,7 +1290,7 @@ function getMatchedRoutes({
   const routeParams = {};
   const trimmedPath = trimPathRight(pathname);
   let foundRoute = void 0;
-  let parsedParams = {};
+  let parsedParams = void 0;
   const match = findRouteMatch(trimmedPath, processedTree, true);
   if (match) {
     foundRoute = match.route;
@@ -1376,140 +1300,89 @@ function getMatchedRoutes({
   const matchedRoutes = match?.branch || [routesById[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["**"] : 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 = 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,
   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 functionalUpdate(dest.search, search2);
+    return 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") {
@@ -1526,8 +1399,6 @@ export {
   PathParamError,
   RouterCore,
   SearchParamError,
-  buildMatchSnapshot,
-  buildMatchSnapshotFromRoutes,
   defaultSerializeError,
   getInitialRouterState,
   getLocationChangeInfo,