@tanstack/router-core 1.132.0-alpha.8 → 1.132.2

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());
+      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 = {
@@ -111,7 +130,7 @@ class RouterCore {
       );
     };
     this.buildRouteTree = () => {
-      const { routesById, routesByPath, flatRoutes } = processRouteTree({
+      const { routesById, routesByPath, flatRoutes } = processRouteTree.processRouteTree({
         routeTree: this.routeTree,
         initRoute: (route, i) => {
           route.init({
@@ -149,19 +168,24 @@ class RouterCore {
     };
     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)
         };
       };
@@ -181,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;
@@ -207,7 +229,6 @@ class RouterCore {
       return getMatchedRoutes({
         pathname,
         routePathname,
-        basepath: this.basepath,
         caseSensitive: this.options.caseSensitive,
         routesByPath: this.routesByPath,
         routesById: this.routesById,
@@ -315,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
         };
       };
@@ -332,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,
@@ -358,8 +383,7 @@ class RouterCore {
           }
         }
         if (maskedNext) {
-          const maskedFinal = build(maskedDest);
-          next.maskedLocation = maskedFinal;
+          next.maskedLocation = maskedNext;
         }
         return next;
       };
@@ -393,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();
@@ -429,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 }
         );
@@ -482,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);
@@ -829,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,
@@ -915,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;
@@ -972,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
@@ -988,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) {
@@ -995,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
         };
@@ -1006,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,
@@ -1015,7 +1040,7 @@ class RouterCore {
           status,
           isFetching: false,
           error: void 0,
-          paramsError: parseErrors[index],
+          paramsError,
           __routeContext: void 0,
           _nonReactive: {
             loadPromise: utils.createControlledPromise()
@@ -1127,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,
@@ -1270,7 +1165,6 @@ function getMatchedRoutes({
   const trimmedPath = path.trimPathRight(pathname);
   const getMatchedParams = (route) => {
     const result = path.matchPathname(
-      basepath,
       trimmedPath,
       {
         to: route.fullPath,
@@ -1400,5 +1294,4 @@ exports.getInitialRouterState = getInitialRouterState;
 exports.getLocationChangeInfo = getLocationChangeInfo;
 exports.getMatchedRoutes = getMatchedRoutes;
 exports.lazyFn = lazyFn;
-exports.processRouteTree = processRouteTree;
 //# sourceMappingURL=router.cjs.map