@tanstack/router-core 1.154.13 → 1.155.0

package/dist/esm/router.js

@@ -2,7 +2,7 @@ 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 { processRouteTree, processRouteMasks, findSingleMatch, findRouteMatch, findFlatMatch } from "./new-process-route-tree.js";
-import { trimPath, resolvePath, cleanPath, trimPathRight, interpolatePath } from "./path.js";
+import { compileDecodeCharMap, trimPath, resolvePath, cleanPath, trimPathRight, interpolatePath } from "./path.js";
 import { createLRUCache } from "./lru-cache.js";
 import { isNotFound } from "./not-found.js";
 import { setupScrollRestoration } from "./scroll-restoration.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();
@@ -68,12 +69,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 = compileDecodeCharMap(
+          this.options.pathParamsAllowedCharacters
+        );
       if (!this.history || this.options.history && this.options.history !== this.history) {
         if (!this.options.history) {
           if (!this.isServer) {
@@ -248,9 +247,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 +315,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
             );
@@ -345,7 +342,7 @@ class RouterCore {
           interpolatePath({
             path: nextTo,
             params: nextParams,
-            decodeCharMap: this.pathParamsDecodeCharMap
+            decoder: this.pathParamsDecoder
           }).interpolatedPath
         );
         let nextSearch = fromSearch;
@@ -379,31 +376,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 +460,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 +613,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 +630,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 +651,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 +1008,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 +1036,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 +1088,6 @@ class RouterCore {
           return [parentSearch, {}, searchParamError];
         }
       })();
-      if (!canUseCachedSearch) {
-        validatedSearchesToCache.push({
-          search: preMatchSearch,
-          strictSearch: strictMatchSearch
-        });
-      }
       const loaderDeps = route.options.loaderDeps?.({
         search: preMatchSearch
       }) ?? "";
@@ -1166,7 +1095,7 @@ class RouterCore {
       const { interpolatedPath, usedParams } = interpolatePath({
         path: route.fullPath,
         params: routeParams,
-        decodeCharMap: this.pathParamsDecodeCharMap
+        decoder: this.pathParamsDecoder
       });
       const matchId = (
         // route.id for disambiguation
@@ -1272,13 +1201,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 +1229,7 @@ class RouterCore {
         };
       }
     });
-    return { matches, rawParams };
+    return matches;
   }
 }
 class SearchParamError extends Error {
@@ -1366,7 +1288,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,64 +1298,6 @@ 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,
@@ -1533,8 +1397,6 @@ export {
   PathParamError,
   RouterCore,
   SearchParamError,
-  buildMatchSnapshot,
-  buildMatchSnapshotFromRoutes,
   defaultSerializeError,
   getInitialRouterState,
   getLocationChangeInfo,