@tanstack/router-core 1.132.0-alpha.4 → 1.132.0

package/dist/cjs/router.cjs

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const store = require("@tanstack/store");
 const history = require("@tanstack/history");
-const invariant = require("tiny-invariant");
 const utils = require("./utils.cjs");
+const processRouteTree = require("./process-route-tree.cjs");
 const path = require("./path.cjs");
 const notFound = require("./not-found.cjs");
 const scrollRestoration = require("./scroll-restoration.cjs");
@@ -12,6 +12,7 @@ const root = require("./root.cjs");
 const redirect = require("./redirect.cjs");
 const lruCache = require("./lru-cache.cjs");
 const loadMatches = require("./load-matches.cjs");
+const rewrite = require("./rewrite.cjs");
 function defaultSerializeError(err) {
   if (err instanceof Error) {
     const obj = {
@@ -56,7 +57,6 @@ class RouterCore {
           "The notFoundRoute API is deprecated and will be removed in the next major version. See https://tanstack.com/router/v1/docs/framework/react/guide/not-found-errors#migrating-from-notfoundroute for more info."
         );
       }
-      const previousOptions = this.options;
       this.options = {
         ...this.options,
         ...newOptions
@@ -68,24 +68,43 @@ class RouterCore {
           char
         ])
       ) : void 0;
-      if (!this.basepath || newOptions.basepath && newOptions.basepath !== previousOptions.basepath) {
-        if (newOptions.basepath === void 0 || newOptions.basepath === "" || newOptions.basepath === "/") {
-          this.basepath = "/";
+      if (!this.history || this.options.history && this.options.history !== this.history) {
+        if (!this.options.history) {
+          if (!this.isServer) {
+            this.history = history.createBrowserHistory();
+          }
         } else {
-          this.basepath = `/${path.trimPath(newOptions.basepath)}`;
+          this.history = this.options.history;
         }
       }
-      if (!this.history || this.options.history && this.options.history !== this.history) {
-        this.history = this.options.history ?? (this.isServer ? history.createMemoryHistory({
-          initialEntries: [this.basepath || "/"]
-        }) : history.createBrowserHistory());
-        this.latestLocation = this.parseLocation();
+      if (this.options.basepath) {
+        const basepathRewrite = rewrite.rewriteBasepath({
+          basepath: this.options.basepath
+        });
+        if (this.options.rewrite) {
+          this.rewrite = rewrite.composeRewrites([basepathRewrite, this.options.rewrite]);
+        } else {
+          this.rewrite = basepathRewrite;
+        }
+      } else {
+        this.rewrite = this.options.rewrite;
+      }
+      this.origin = this.options.origin;
+      if (!this.origin) {
+        if (!this.isServer) {
+          this.origin = window.origin;
+        } else {
+          this.origin = "http://localhost";
+        }
+      }
+      if (this.history) {
+        this.updateLatestLocation();
       }
       if (this.options.routeTree !== this.routeTree) {
         this.routeTree = this.options.routeTree;
         this.buildRouteTree();
       }
-      if (!this.__store) {
+      if (!this.__store && this.latestLocation) {
         this.__store = new store.Store(getInitialRouterState(this.latestLocation), {
           onUpdate: () => {
             this.__store.state = {
@@ -104,8 +123,14 @@ class RouterCore {
         );
       }
     };
+    this.updateLatestLocation = () => {
+      this.latestLocation = this.parseLocation(
+        this.history.location,
+        this.latestLocation
+      );
+    };
     this.buildRouteTree = () => {
-      const { routesById, routesByPath, flatRoutes } = processRouteTree({
+      const { routesById, routesByPath, flatRoutes } = processRouteTree.processRouteTree({
         routeTree: this.routeTree,
         initRoute: (route, i) => {
           route.init({
@@ -141,25 +166,30 @@ class RouterCore {
         }
       });
     };
-    this.parseLocation = (previousLocation, locationToParse) => {
+    this.parseLocation = (locationToParse, previousLocation) => {
       const parse = ({
-        pathname,
-        search,
-        hash,
+        href,
         state
       }) => {
-        const parsedSearch = this.options.parseSearch(search);
+        const fullUrl = new URL(href, this.origin);
+        const url = rewrite.executeRewriteInput(this.rewrite, fullUrl);
+        const parsedSearch = this.options.parseSearch(url.search);
         const searchStr = this.options.stringifySearch(parsedSearch);
+        url.search = searchStr;
+        const fullPath = url.href.replace(url.origin, "");
+        const { pathname, hash } = url;
         return {
+          href: fullPath,
+          publicHref: href,
+          url: url.href,
           pathname,
           searchStr,
           search: utils.replaceEqualDeep(previousLocation?.search, parsedSearch),
           hash: hash.split("#").reverse()[0] ?? "",
-          href: `${pathname}${searchStr}${hash}`,
           state: utils.replaceEqualDeep(previousLocation?.state, state)
         };
       };
-      const location = parse(locationToParse ?? this.history.location);
+      const location = parse(locationToParse);
       const { __tempLocation, __tempKey } = location.state;
       if (__tempLocation && (!__tempKey || __tempKey === this.tempLocationKey)) {
         const parsedTempLocation = parse(__tempLocation);
@@ -175,11 +205,9 @@ class RouterCore {
     };
     this.resolvePathWithBase = (from, path$1) => {
       const resolvedPath = path.resolvePath({
-        basepath: this.basepath,
         base: from,
         to: path.cleanPath(path$1),
         trailingSlash: this.options.trailingSlash,
-        caseSensitive: this.options.caseSensitive,
         parseCache: this.parsePathnameCache
       });
       return resolvedPath;
@@ -201,7 +229,6 @@ class RouterCore {
       return getMatchedRoutes({
         pathname,
         routePathname,
-        basepath: this.basepath,
         caseSensitive: this.options.caseSensitive,
         routesByPath: this.routesByPath,
         routesById: this.routesById,
@@ -228,30 +255,23 @@ class RouterCore {
           _buildLocation: true
         });
         const lastMatch = utils.last(allCurrentLocationMatches);
-        let fromPath = this.resolvePathWithBase(lastMatch.fullPath, ".");
-        const toPath = dest.to ? this.resolvePathWithBase(fromPath, `${dest.to}`) : this.resolvePathWithBase(fromPath, ".");
-        const routeIsChanging = !!dest.to && !comparePaths(dest.to.toString(), fromPath) && !comparePaths(toPath, fromPath);
-        if (dest.unsafeRelative === "path") {
-          fromPath = currentLocation.pathname;
-        } else if (routeIsChanging && dest.from) {
-          fromPath = dest.from;
-          if (process.env.NODE_ENV !== "production" && dest._isNavigate) {
-            const allFromMatches = this.getMatchedRoutes(
-              dest.from,
-              void 0
-            ).matchedRoutes;
-            const matchedFrom = utils.findLast(allCurrentLocationMatches, (d) => {
-              return comparePaths(d.fullPath, fromPath);
-            });
-            const matchedCurrent = utils.findLast(allFromMatches, (d) => {
-              return comparePaths(d.fullPath, currentLocation.pathname);
-            });
-            if (!matchedFrom && !matchedCurrent) {
-              console.warn(`Could not find match for from: ${fromPath}`);
-            }
+        if (dest.from && process.env.NODE_ENV !== "production" && dest._isNavigate) {
+          const allFromMatches = this.getMatchedRoutes(
+            dest.from,
+            void 0
+          ).matchedRoutes;
+          const matchedFrom = utils.findLast(allCurrentLocationMatches, (d) => {
+            return comparePaths(d.fullPath, dest.from);
+          });
+          const matchedCurrent = utils.findLast(allFromMatches, (d) => {
+            return comparePaths(d.fullPath, lastMatch.fullPath);
+          });
+          if (!matchedFrom && !matchedCurrent) {
+            console.warn(`Could not find match for from: ${dest.from}`);
           }
         }
-        fromPath = this.resolvePathWithBase(fromPath, ".");
+        const defaultedFromPath = dest.unsafeRelative === "path" ? currentLocation.pathname : dest.from ?? lastMatch.fullPath;
+        const fromPath = this.resolvePathWithBase(defaultedFromPath, ".");
         const fromSearch = lastMatch.search;
         const fromParams = { ...lastMatch.params };
         const nextTo = dest.to ? this.resolvePathWithBase(fromPath, `${dest.to}`) : this.resolvePathWithBase(fromPath, ".");
@@ -316,13 +336,18 @@ 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 fullPath = `${nextPathname}${searchStr}${hashStr}`;
+        const url = new URL(fullPath, this.origin);
+        const rewrittenUrl = rewrite.executeRewriteOutput(this.rewrite, url);
         return {
+          publicHref: rewrittenUrl.pathname + rewrittenUrl.search + rewrittenUrl.hash,
+          href: fullPath,
+          url: rewrittenUrl.href,
           pathname: nextPathname,
           search: nextSearch,
           searchStr,
           state: nextState,
           hash: hash ?? "",
-          href: `${nextPathname}${searchStr}${hashStr}`,
           unmaskOnReload: dest.unmaskOnReload
         };
       };
@@ -333,7 +358,6 @@ class RouterCore {
           let params = {};
           const foundMask = this.options.routeMasks?.find((d) => {
             const match = path.matchPathname(
-              this.basepath,
               next.pathname,
               {
                 to: d.from,
@@ -359,8 +383,7 @@ class RouterCore {
           }
         }
         if (maskedNext) {
-          const maskedFinal = build(maskedDest);
-          next.maskedLocation = maskedFinal;
+          next.maskedLocation = maskedNext;
         }
         return next;
       };
@@ -394,7 +417,7 @@ class RouterCore {
         });
         return isEqual;
       };
-      const isSameUrl = this.latestLocation.href === next.href;
+      const isSameUrl = path.trimPathRight(this.latestLocation.href) === path.trimPathRight(next.href);
       const previousCommitPromise = this.commitLocationPromise;
       this.commitLocationPromise = utils.createControlledPromise(() => {
         previousCommitPromise?.resolve();
@@ -430,7 +453,7 @@ class RouterCore {
         nextHistory.state.__hashScrollIntoViewOptions = hashScrollIntoView ?? this.options.defaultHashScrollIntoView ?? true;
         this.shouldViewTransition = viewTransition;
         this.history[next.replace ? "replace" : "push"](
-          nextHistory.href,
+          nextHistory.publicHref,
           nextHistory.state,
           { ignoreBlocker }
         );
@@ -483,7 +506,7 @@ class RouterCore {
       if (reloadDocument) {
         if (!href) {
           const location = this.buildLocation({ to, ...rest });
-          href = this.history.createHref(location.href);
+          href = location.href;
         }
         if (rest.replace) {
           window.location.replace(href);
@@ -501,7 +524,7 @@ class RouterCore {
     };
     this.beforeLoad = () => {
       this.cancelMatches();
-      this.latestLocation = this.parseLocation(this.latestLocation);
+      this.updateLatestLocation();
       if (this.isServer) {
         const nextLocation = this.buildLocation({
           to: this.latestLocation.pathname,
@@ -830,7 +853,6 @@ class RouterCore {
       const pending = opts?.pending === void 0 ? !this.state.isLoading : opts.pending;
       const baseLocation = pending ? this.latestLocation : this.state.resolvedLocation || this.state.location;
       const match = path.matchPathname(
-        this.basepath,
         baseLocation.pathname,
         {
           ...opts,
@@ -916,25 +938,6 @@ class RouterCore {
       }
       return root.rootRouteId;
     })();
-    const parseErrors = matchedRoutes.map((route) => {
-      let parsedParamsError;
-      const parseParams = route.options.params?.parse ?? route.options.parseParams;
-      if (parseParams) {
-        try {
-          const parsedParams = parseParams(routeParams);
-          Object.assign(routeParams, parsedParams);
-        } catch (err) {
-          parsedParamsError = new PathParamError(err.message, {
-            cause: err
-          });
-          if (opts?.throwOnError) {
-            throw parsedParamsError;
-          }
-          return parsedParamsError;
-        }
-      }
-      return;
-    });
     const matches = [];
     const getParentContext = (parentMatch) => {
       const parentMatchId = parentMatch?.id;
@@ -973,7 +976,7 @@ class RouterCore {
         search: preMatchSearch
       }) ?? "";
       const loaderDepsHash = loaderDeps ? JSON.stringify(loaderDeps) : "";
-      const { usedParams, interpolatedPath } = path.interpolatePath({
+      const { interpolatedPath, usedParams } = path.interpolatePath({
         path: route.fullPath,
         params: routeParams,
         decodeCharMap: this.pathParamsDecodeCharMap
@@ -989,6 +992,27 @@ class RouterCore {
       const previousMatch = this.state.matches.find(
         (d) => d.routeId === route.id
       );
+      const strictParams = existingMatch?._strictParams ?? usedParams;
+      let paramsError = void 0;
+      if (!existingMatch) {
+        const strictParseParams = route.options.params?.parse ?? route.options.parseParams;
+        if (strictParseParams) {
+          try {
+            Object.assign(
+              strictParams,
+              strictParseParams(strictParams)
+            );
+          } catch (err) {
+            paramsError = new PathParamError(err.message, {
+              cause: err
+            });
+            if (opts?.throwOnError) {
+              throw paramsError;
+            }
+          }
+        }
+      }
+      Object.assign(routeParams, strictParams);
       const cause = previousMatch ? "stay" : "enter";
       let match;
       if (existingMatch) {
@@ -996,7 +1020,7 @@ class RouterCore {
           ...existingMatch,
           cause,
           params: previousMatch ? utils.replaceEqualDeep(previousMatch.params, routeParams) : routeParams,
-          _strictParams: usedParams,
+          _strictParams: strictParams,
           search: previousMatch ? utils.replaceEqualDeep(previousMatch.search, preMatchSearch) : utils.replaceEqualDeep(existingMatch.search, preMatchSearch),
           _strictSearch: strictMatchSearch
         };
@@ -1007,8 +1031,8 @@ class RouterCore {
           index,
           routeId: route.id,
           params: previousMatch ? utils.replaceEqualDeep(previousMatch.params, routeParams) : routeParams,
-          _strictParams: usedParams,
-          pathname: path.joinPaths([this.basepath, interpolatedPath]),
+          _strictParams: strictParams,
+          pathname: interpolatedPath,
           updatedAt: Date.now(),
           search: previousMatch ? utils.replaceEqualDeep(previousMatch.search, preMatchSearch) : preMatchSearch,
           _strictSearch: strictMatchSearch,
@@ -1016,7 +1040,7 @@ class RouterCore {
           status,
           isFetching: false,
           error: void 0,
-          paramsError: parseErrors[index],
+          paramsError,
           __routeContext: void 0,
           _nonReactive: {
             loadPromise: utils.createControlledPromise()
@@ -1128,139 +1152,9 @@ function validateSearch(validateSearch2, input) {
   }
   return {};
 }
-const REQUIRED_PARAM_BASE_SCORE = 0.5;
-const OPTIONAL_PARAM_BASE_SCORE = 0.4;
-const WILDCARD_PARAM_BASE_SCORE = 0.25;
-const BOTH_PRESENCE_BASE_SCORE = 0.05;
-const PREFIX_PRESENCE_BASE_SCORE = 0.02;
-const SUFFIX_PRESENCE_BASE_SCORE = 0.01;
-const PREFIX_LENGTH_SCORE_MULTIPLIER = 2e-4;
-const SUFFIX_LENGTH_SCORE_MULTIPLIER = 1e-4;
-function handleParam(segment, baseScore) {
-  if (segment.prefixSegment && segment.suffixSegment) {
-    return baseScore + BOTH_PRESENCE_BASE_SCORE + PREFIX_LENGTH_SCORE_MULTIPLIER * segment.prefixSegment.length + SUFFIX_LENGTH_SCORE_MULTIPLIER * segment.suffixSegment.length;
-  }
-  if (segment.prefixSegment) {
-    return baseScore + PREFIX_PRESENCE_BASE_SCORE + PREFIX_LENGTH_SCORE_MULTIPLIER * segment.prefixSegment.length;
-  }
-  if (segment.suffixSegment) {
-    return baseScore + SUFFIX_PRESENCE_BASE_SCORE + SUFFIX_LENGTH_SCORE_MULTIPLIER * segment.suffixSegment.length;
-  }
-  return baseScore;
-}
-function processRouteTree({
-  routeTree,
-  initRoute
-}) {
-  const routesById = {};
-  const routesByPath = {};
-  const recurseRoutes = (childRoutes) => {
-    childRoutes.forEach((childRoute, i) => {
-      initRoute?.(childRoute, i);
-      const existingRoute = routesById[childRoute.id];
-      invariant(
-        !existingRoute,
-        `Duplicate routes found with id: ${String(childRoute.id)}`
-      );
-      routesById[childRoute.id] = childRoute;
-      if (!childRoute.isRoot && childRoute.path) {
-        const trimmedFullPath = path.trimPathRight(childRoute.fullPath);
-        if (!routesByPath[trimmedFullPath] || childRoute.fullPath.endsWith("/")) {
-          routesByPath[trimmedFullPath] = childRoute;
-        }
-      }
-      const children = childRoute.children;
-      if (children?.length) {
-        recurseRoutes(children);
-      }
-    });
-  };
-  recurseRoutes([routeTree]);
-  const scoredRoutes = [];
-  const routes = Object.values(routesById);
-  routes.forEach((d, i) => {
-    if (d.isRoot || !d.path) {
-      return;
-    }
-    const trimmed = path.trimPathLeft(d.fullPath);
-    let parsed = path.parsePathname(trimmed);
-    let skip = 0;
-    while (parsed.length > skip + 1 && parsed[skip]?.value === "/") {
-      skip++;
-    }
-    if (skip > 0) parsed = parsed.slice(skip);
-    let optionalParamCount = 0;
-    let hasStaticAfter = false;
-    const scores = parsed.map((segment, index) => {
-      if (segment.value === "/") {
-        return 0.75;
-      }
-      let baseScore = void 0;
-      if (segment.type === path.SEGMENT_TYPE_PARAM) {
-        baseScore = REQUIRED_PARAM_BASE_SCORE;
-      } else if (segment.type === path.SEGMENT_TYPE_OPTIONAL_PARAM) {
-        baseScore = OPTIONAL_PARAM_BASE_SCORE;
-        optionalParamCount++;
-      } else if (segment.type === path.SEGMENT_TYPE_WILDCARD) {
-        baseScore = WILDCARD_PARAM_BASE_SCORE;
-      }
-      if (baseScore) {
-        for (let i2 = index + 1; i2 < parsed.length; i2++) {
-          const nextSegment = parsed[i2];
-          if (nextSegment.type === path.SEGMENT_TYPE_PATHNAME && nextSegment.value !== "/") {
-            hasStaticAfter = true;
-            return handleParam(segment, baseScore + 0.2);
-          }
-        }
-        return handleParam(segment, baseScore);
-      }
-      return 1;
-    });
-    scoredRoutes.push({
-      child: d,
-      trimmed,
-      parsed,
-      index: i,
-      scores,
-      optionalParamCount,
-      hasStaticAfter
-    });
-  });
-  const flatRoutes = scoredRoutes.sort((a, b) => {
-    const minLength = Math.min(a.scores.length, b.scores.length);
-    for (let i = 0; i < minLength; i++) {
-      if (a.scores[i] !== b.scores[i]) {
-        return b.scores[i] - a.scores[i];
-      }
-    }
-    if (a.scores.length !== b.scores.length) {
-      if (a.optionalParamCount !== b.optionalParamCount) {
-        if (a.hasStaticAfter === b.hasStaticAfter) {
-          return a.optionalParamCount - b.optionalParamCount;
-        } else if (a.hasStaticAfter && !b.hasStaticAfter) {
-          return -1;
-        } else if (!a.hasStaticAfter && b.hasStaticAfter) {
-          return 1;
-        }
-      }
-      return b.scores.length - a.scores.length;
-    }
-    for (let i = 0; i < minLength; i++) {
-      if (a.parsed[i].value !== b.parsed[i].value) {
-        return a.parsed[i].value > b.parsed[i].value ? 1 : -1;
-      }
-    }
-    return a.index - b.index;
-  }).map((d, i) => {
-    d.child.rank = i;
-    return d.child;
-  });
-  return { routesById, routesByPath, flatRoutes };
-}
 function getMatchedRoutes({
   pathname,
   routePathname,
-  basepath,
   caseSensitive,
   routesByPath,
   routesById,
@@ -1271,7 +1165,6 @@ function getMatchedRoutes({
   const trimmedPath = path.trimPathRight(pathname);
   const getMatchedParams = (route) => {
     const result = path.matchPathname(
-      basepath,
       trimmedPath,
       {
         to: route.fullPath,
@@ -1401,5 +1294,4 @@ exports.getInitialRouterState = getInitialRouterState;
 exports.getLocationChangeInfo = getLocationChangeInfo;
 exports.getMatchedRoutes = getMatchedRoutes;
 exports.lazyFn = lazyFn;
-exports.processRouteTree = processRouteTree;
 //# sourceMappingURL=router.cjs.map