@tanstack/router-core 1.120.4-alpha.19 → 1.120.5

package/src/router.ts

@@ -28,7 +28,7 @@ import { isNotFound } from './not-found'
 import { setupScrollRestoration } from './scroll-restoration'
 import { defaultParseSearch, defaultStringifySearch } from './searchParams'
 import { rootRouteId } from './root'
-import { isRedirect } from './redirect'
+import { isRedirect, isResolvedRedirect } from './redirect'
 import type { SearchParser, SearchSerializer } from './searchParams'
 import type { AnyRedirect, ResolvedRedirect } from './redirect'
 import type {
@@ -165,14 +165,6 @@ export interface RouterOptions<
    * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/preloading#preload-delay)
    */
   defaultPreloadDelay?: number
-  /**
-   * The default `preloadIntentProximity` a route should use if no preloadIntentProximity is provided.
-   *
-   * @default 0
-   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaultpreloadintentproximity-property)
-   * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/preloading#preload-intent-proximity)
-   */
-  defaultPreloadIntentProximity?: number
   /**
    * The default `pendingMs` a route should use if no pendingMs is provided.
    *
@@ -415,7 +407,7 @@ export interface RouterState<
   location: ParsedLocation<FullSearchSchema<TRouteTree>>
   resolvedLocation?: ParsedLocation<FullSearchSchema<TRouteTree>>
   statusCode: number
-  redirect?: AnyRedirect
+  redirect?: ResolvedRedirect
 }
 
 export interface BuildNextOptions {
@@ -601,8 +593,8 @@ export type ParseLocationFn<TRouteTree extends AnyRoute> = (
 ) => ParsedLocation<FullSearchSchema<TRouteTree>>
 
 export type GetMatchRoutesFn = (
-  pathname: string,
-  routePathname: string | undefined,
+  next: ParsedLocation,
+  dest?: BuildNextOptions,
 ) => {
   matchedRoutes: Array<AnyRoute>
   routeParams: Record<string, string>
@@ -844,8 +836,6 @@ export class RouterCore<
   // router can be used in a non-react environment if necessary
   startTransition: StartTransitionFn = (fn) => fn()
 
-  isShell = false
-
   update: UpdateFn<
     TRouteTree,
     TTrailingSlashOption,
@@ -892,6 +882,7 @@ export class RouterCore<
     }
 
     if (
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
       !this.history ||
       (this.options.history && this.options.history !== this.history)
     ) {
@@ -910,6 +901,7 @@ export class RouterCore<
       this.buildRouteTree()
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     if (!this.__store) {
       this.__store = new Store(getInitialRouterState(this.latestLocation), {
         onUpdate: () => {
@@ -928,16 +920,13 @@ export class RouterCore<
     if (
       typeof window !== 'undefined' &&
       'CSS' in window &&
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
       typeof window.CSS?.supports === 'function'
     ) {
       this.isViewTransitionTypesSupported = window.CSS.supports(
         'selector(:active-view-transition-type(a)',
       )
     }
-
-    if ((this.latestLocation.search as any).__TSS_SHELL) {
-      this.isShell = true
-    }
   }
 
   get state() {
@@ -945,29 +934,124 @@ export class RouterCore<
   }
 
   buildRouteTree = () => {
-    const { routesById, routesByPath, flatRoutes } = processRouteTree({
-      routeTree: this.routeTree,
-      initRoute: (route, i) => {
-        route.init({
-          originalIndex: i,
-          defaultSsr: this.options.defaultSsr,
-        })
-      },
-    })
-
-    this.routesById = routesById as RoutesById<TRouteTree>
-    this.routesByPath = routesByPath as RoutesByPath<TRouteTree>
-    this.flatRoutes = flatRoutes as Array<AnyRoute>
+    this.routesById = {} as RoutesById<TRouteTree>
+    this.routesByPath = {} as RoutesByPath<TRouteTree>
 
     const notFoundRoute = this.options.notFoundRoute
-
     if (notFoundRoute) {
       notFoundRoute.init({
         originalIndex: 99999999999,
         defaultSsr: this.options.defaultSsr,
       })
-      this.routesById[notFoundRoute.id] = notFoundRoute
+      ;(this.routesById as any)[notFoundRoute.id] = notFoundRoute
+    }
+
+    const recurseRoutes = (childRoutes: Array<AnyRoute>) => {
+      childRoutes.forEach((childRoute, i) => {
+        childRoute.init({
+          originalIndex: i,
+          defaultSsr: this.options.defaultSsr,
+        })
+
+        const existingRoute = (this.routesById as any)[childRoute.id]
+
+        invariant(
+          !existingRoute,
+          `Duplicate routes found with id: ${String(childRoute.id)}`,
+        )
+        ;(this.routesById as any)[childRoute.id] = childRoute
+
+        if (!childRoute.isRoot && childRoute.path) {
+          const trimmedFullPath = trimPathRight(childRoute.fullPath)
+          if (
+            !(this.routesByPath as any)[trimmedFullPath] ||
+            childRoute.fullPath.endsWith('/')
+          ) {
+            ;(this.routesByPath as any)[trimmedFullPath] = childRoute
+          }
+        }
+
+        const children = childRoute.children
+
+        if (children?.length) {
+          recurseRoutes(children)
+        }
+      })
     }
+
+    recurseRoutes([this.routeTree])
+
+    const scoredRoutes: Array<{
+      child: AnyRoute
+      trimmed: string
+      parsed: ReturnType<typeof parsePathname>
+      index: number
+      scores: Array<number>
+    }> = []
+
+    const routes: Array<AnyRoute> = Object.values(this.routesById)
+
+    routes.forEach((d, i) => {
+      if (d.isRoot || !d.path) {
+        return
+      }
+
+      const trimmed = trimPathLeft(d.fullPath)
+      const parsed = parsePathname(trimmed)
+
+      while (parsed.length > 1 && parsed[0]?.value === '/') {
+        parsed.shift()
+      }
+
+      const scores = parsed.map((segment) => {
+        if (segment.value === '/') {
+          return 0.75
+        }
+
+        if (segment.type === 'param') {
+          return 0.5
+        }
+
+        if (segment.type === 'wildcard') {
+          return 0.25
+        }
+
+        return 1
+      })
+
+      scoredRoutes.push({ child: d, trimmed, parsed, index: i, scores })
+    })
+
+    this.flatRoutes = scoredRoutes
+      .sort((a, b) => {
+        const minLength = Math.min(a.scores.length, b.scores.length)
+
+        // Sort by min available score
+        for (let i = 0; i < minLength; i++) {
+          if (a.scores[i] !== b.scores[i]) {
+            return b.scores[i]! - a.scores[i]!
+          }
+        }
+
+        // Sort by length of score
+        if (a.scores.length !== b.scores.length) {
+          return b.scores.length - a.scores.length
+        }
+
+        // Sort by min available parsed value
+        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
+          }
+        }
+
+        // Sort by original index
+        return a.index - b.index
+      })
+      .map((d, i) => {
+        d.child.rank = i
+        return d.child
+      })
   }
 
   subscribe: SubscribeFn = (eventType, fn) => {
@@ -1081,8 +1165,8 @@ export class RouterCore<
     opts?: MatchRoutesOpts,
   ): Array<AnyRouteMatch> {
     const { foundRoute, matchedRoutes, routeParams } = this.getMatchedRoutes(
-      next.pathname,
-      opts?.dest?.to as string,
+      next,
+      opts?.dest,
     )
     let isGlobalNotFound = false
 
@@ -1363,44 +1447,52 @@ export class RouterCore<
           ...match.__beforeLoadContext,
         }
       }
-
-      // If it's already a success, update headers and head content
-      // These may get updated again if the match is refreshed
-      // due to being stale
-      if (match.status === 'success') {
-        match.headers = route.options.headers?.({
-          loaderData: match.loaderData,
-        })
-        const assetContext = {
-          matches,
-          match,
-          params: match.params,
-          loaderData: match.loaderData,
-        }
-        const headFnContent = route.options.head?.(assetContext)
-        match.links = headFnContent?.links
-        match.headScripts = headFnContent?.scripts
-        match.meta = headFnContent?.meta
-        match.scripts = route.options.scripts?.(assetContext)
-      }
     })
 
     return matches
   }
 
-  getMatchedRoutes: GetMatchRoutesFn = (
-    pathname: string,
-    routePathname: string | undefined,
-  ) => {
-    return getMatchedRoutes({
-      pathname,
-      routePathname,
-      basepath: this.basepath,
-      caseSensitive: this.options.caseSensitive,
-      routesByPath: this.routesByPath,
-      routesById: this.routesById,
-      flatRoutes: this.flatRoutes,
-    })
+  getMatchedRoutes: GetMatchRoutesFn = (next, dest) => {
+    let routeParams: Record<string, string> = {}
+    const trimmedPath = trimPathRight(next.pathname)
+    const getMatchedParams = (route: AnyRoute) => {
+      const result = matchPathname(this.basepath, trimmedPath, {
+        to: route.fullPath,
+        caseSensitive:
+          route.options.caseSensitive ?? this.options.caseSensitive,
+        fuzzy: true,
+      })
+      return result
+    }
+
+    let foundRoute: AnyRoute | undefined =
+      dest?.to !== undefined ? this.routesByPath[dest.to!] : undefined
+    if (foundRoute) {
+      routeParams = getMatchedParams(foundRoute)!
+    } else {
+      foundRoute = this.flatRoutes.find((route) => {
+        const matchedParams = getMatchedParams(route)
+
+        if (matchedParams) {
+          routeParams = matchedParams
+          return true
+        }
+
+        return false
+      })
+    }
+
+    let routeCursor: AnyRoute =
+      foundRoute || (this.routesById as any)[rootRouteId]
+
+    const matchedRoutes: Array<AnyRoute> = [routeCursor]
+
+    while (routeCursor.parentRoute) {
+      routeCursor = routeCursor.parentRoute
+      matchedRoutes.unshift(routeCursor)
+    }
+
+    return { matchedRoutes, routeParams, foundRoute }
   }
 
   cancelMatch = (id: string) => {
@@ -1700,17 +1792,11 @@ export class RouterCore<
         }
       }
 
-      const nextMatches = this.getMatchedRoutes(
-        next.pathname,
-        dest.to as string,
-      )
+      const nextMatches = this.getMatchedRoutes(next, dest)
       const final = build(dest, nextMatches)
 
       if (maskedNext) {
-        const maskedMatches = this.getMatchedRoutes(
-          maskedNext.pathname,
-          maskedDest?.to as string,
-        )
+        const maskedMatches = this.getMatchedRoutes(maskedNext, maskedDest)
         const maskedFinal = build(maskedDest, maskedMatches)
         final.maskedLocation = maskedFinal
       }
@@ -1852,13 +1938,6 @@ export class RouterCore<
   }
 
   navigate: NavigateFn = ({ to, reloadDocument, href, ...rest }) => {
-    if (!reloadDocument && href) {
-      try {
-        new URL(`${href}`)
-        reloadDocument = true
-      } catch {}
-    }
-
     if (reloadDocument) {
       if (!href) {
         const location = this.buildLocation({ to, ...rest } as any)
@@ -1881,30 +1960,10 @@ export class RouterCore<
 
   latestLoadPromise: undefined | Promise<void>
 
-  beforeLoad = () => {
-    // Cancel any pending matches
-    this.cancelMatches()
+  load: LoadFn = async (opts?: { sync?: boolean }): Promise<void> => {
     this.latestLocation = this.parseLocation(this.latestLocation)
 
-    // Match the routes
-    const pendingMatches = this.matchRoutes(this.latestLocation)
-
-    // Ingest the new matches
-    this.__store.setState((s) => ({
-      ...s,
-      status: 'pending',
-      isLoading: true,
-      location: this.latestLocation,
-      pendingMatches,
-      // If a cached moved to pendingMatches, remove it from cachedMatches
-      cachedMatches: s.cachedMatches.filter((d) => {
-        return !pendingMatches.find((e) => e.id === d.id)
-      }),
-    }))
-  }
-
-  load: LoadFn = async (opts?: { sync?: boolean }): Promise<void> => {
-    let redirect: AnyRedirect | undefined
+    let redirect: ResolvedRedirect | undefined
     let notFound: NotFoundError | undefined
 
     let loadPromise: Promise<void>
@@ -1913,10 +1972,36 @@ export class RouterCore<
     loadPromise = new Promise<void>((resolve) => {
       this.startTransition(async () => {
         try {
-          this.beforeLoad()
           const next = this.latestLocation
           const prevLocation = this.state.resolvedLocation
 
+          // Cancel any pending matches
+          this.cancelMatches()
+
+          let pendingMatches!: Array<AnyRouteMatch>
+
+          batch(() => {
+            // this call breaks a route context of destination route after a redirect
+            // we should be fine not eagerly calling this since we call it later
+            // this.clearExpiredCache()
+
+            // Match the routes
+            pendingMatches = this.matchRoutes(next)
+
+            // Ingest the new matches
+            this.__store.setState((s) => ({
+              ...s,
+              status: 'pending',
+              isLoading: true,
+              location: next,
+              pendingMatches,
+              // If a cached moved to pendingMatches, remove it from cachedMatches
+              cachedMatches: s.cachedMatches.filter((d) => {
+                return !pendingMatches.find((e) => e.id === d.id)
+              }),
+            }))
+          })
+
           if (!this.state.redirect) {
             this.emit({
               type: 'onBeforeNavigate',
@@ -1937,7 +2022,7 @@ export class RouterCore<
 
           await this.loadMatches({
             sync: opts?.sync,
-            matches: this.state.pendingMatches as Array<AnyRouteMatch>,
+            matches: pendingMatches,
             location: next,
             // eslint-disable-next-line @typescript-eslint/require-await
             onReady: async () => {
@@ -1998,11 +2083,11 @@ export class RouterCore<
             },
           })
         } catch (err) {
-          if (isRedirect(err)) {
+          if (isResolvedRedirect(err)) {
             redirect = err
             if (!this.isServer) {
               this.navigate({
-                ...redirect.options,
+                ...redirect,
                 replace: true,
                 ignoreBlocker: true,
               })
@@ -2014,7 +2099,7 @@ export class RouterCore<
           this.__store.setState((s) => ({
             ...s,
             statusCode: redirect
-              ? redirect.status
+              ? redirect.statusCode
               : notFound
                 ? 404
                 : s.matches.some((d) => d.status === 'error')
@@ -2170,15 +2255,13 @@ export class RouterCore<
     }
 
     const handleRedirectAndNotFound = (match: AnyRouteMatch, err: any) => {
-      if (isRedirect(err) || isNotFound(err)) {
-        if (isRedirect(err)) {
-          if (err.redirectHandled) {
-            if (!err.options.reloadDocument) {
-              throw err
-            }
-          }
+      if (isResolvedRedirect(err)) {
+        if (!err.reloadDocument) {
+          throw err
         }
+      }
 
+      if (isRedirect(err) || isNotFound(err)) {
         updateMatch(match.id, (prev) => ({
           ...prev,
           status: isRedirect(err)
@@ -2202,9 +2285,7 @@ export class RouterCore<
 
         if (isRedirect(err)) {
           rendered = true
-          err.options._fromLocation = location
-          err.redirectHandled = true
-          err = this.resolveRedirect(err)
+          err = this.resolveRedirect({ ...err, _fromLocation: location })
           throw err
         } else if (isNotFound(err)) {
           this._handleNotFound(matches, err, {
@@ -2508,6 +2589,35 @@ export class RouterCore<
                         !this.state.matches.find((d) => d.id === matchId),
                     }))
 
+                    const executeHead = () => {
+                      const match = this.getMatch(matchId)
+                      // in case of a redirecting match during preload, the match does not exist
+                      if (!match) {
+                        return
+                      }
+                      const assetContext = {
+                        matches,
+                        match,
+                        params: match.params,
+                        loaderData: match.loaderData,
+                      }
+                      const headFnContent = route.options.head?.(assetContext)
+                      const meta = headFnContent?.meta
+                      const links = headFnContent?.links
+                      const headScripts = headFnContent?.scripts
+
+                      const scripts = route.options.scripts?.(assetContext)
+                      const headers = route.options.headers?.(assetContext)
+                      updateMatch(matchId, (prev) => ({
+                        ...prev,
+                        meta,
+                        links,
+                        headScripts,
+                        headers,
+                        scripts,
+                      }))
+                    }
+
                     const runLoader = async () => {
                       try {
                         // If the Matches component rendered
@@ -2548,40 +2658,21 @@ export class RouterCore<
 
                           await potentialPendingMinPromise()
 
-                          const assetContext = {
-                            matches,
-                            match: this.getMatch(matchId)!,
-                            params: this.getMatch(matchId)!.params,
-                            loaderData,
-                          }
-                          const headFnContent =
-                            route.options.head?.(assetContext)
-                          const meta = headFnContent?.meta
-                          const links = headFnContent?.links
-                          const headScripts = headFnContent?.scripts
-
-                          const scripts = route.options.scripts?.(assetContext)
-                          const headers = route.options.headers?.({
-                            loaderData,
-                          })
-
                           // Last but not least, wait for the the components
                           // to be preloaded before we resolve the match
                           await route._componentsPromise
 
-                          updateMatch(matchId, (prev) => ({
-                            ...prev,
-                            error: undefined,
-                            status: 'success',
-                            isFetching: false,
-                            updatedAt: Date.now(),
-                            loaderData,
-                            meta,
-                            links,
-                            headScripts,
-                            headers,
-                            scripts,
-                          }))
+                          batch(() => {
+                            updateMatch(matchId, (prev) => ({
+                              ...prev,
+                              error: undefined,
+                              status: 'success',
+                              isFetching: false,
+                              updatedAt: Date.now(),
+                              loaderData,
+                            }))
+                            executeHead()
+                          })
                         } catch (e) {
                           let error = e
 
@@ -2599,12 +2690,15 @@ export class RouterCore<
                             )
                           }
 
-                          updateMatch(matchId, (prev) => ({
-                            ...prev,
-                            error,
-                            status: 'error',
-                            isFetching: false,
-                          }))
+                          batch(() => {
+                            updateMatch(matchId, (prev) => ({
+                              ...prev,
+                              error,
+                              status: 'error',
+                              isFetching: false,
+                            }))
+                            executeHead()
+                          })
                         }
 
                         this.serverSsr?.onMatchSettled({
@@ -2612,10 +2706,13 @@ export class RouterCore<
                           match: this.getMatch(matchId)!,
                         })
                       } catch (err) {
-                        updateMatch(matchId, (prev) => ({
-                          ...prev,
-                          loaderPromise: undefined,
-                        }))
+                        batch(() => {
+                          updateMatch(matchId, (prev) => ({
+                            ...prev,
+                            loaderPromise: undefined,
+                          }))
+                          executeHead()
+                        })
                         handleRedirectAndNotFound(this.getMatch(matchId)!, err)
                       }
                     }
@@ -2641,8 +2738,8 @@ export class RouterCore<
                             loaderPromise: undefined,
                           }))
                         } catch (err) {
-                          if (isRedirect(err)) {
-                            await this.navigate(err.options)
+                          if (isResolvedRedirect(err)) {
+                            await this.navigate(err)
                           }
                         }
                       })()
@@ -2651,6 +2748,11 @@ export class RouterCore<
                       (loaderShouldRunAsync && sync)
                     ) {
                       await runLoader()
+                    } else {
+                      // if the loader did not run, still update head.
+                      // reason: parent's beforeLoad may have changed the route context
+                      // and only now do we know the route context (and that the loader would not run)
+                      executeHead()
                     }
                   }
                   if (!loaderIsRunningAsync) {
@@ -2727,14 +2829,11 @@ export class RouterCore<
     return this.load({ sync: opts?.sync })
   }
 
-  resolveRedirect = (redirect: AnyRedirect): AnyRedirect => {
-    if (!redirect.options.href) {
-      redirect.options.href = this.buildLocation(redirect.options).href
-      redirect.headers.set('Location', redirect.options.href)
-    }
+  resolveRedirect = (err: AnyRedirect): ResolvedRedirect => {
+    const redirect = err as ResolvedRedirect
 
-    if (!redirect.headers.get('Location')) {
-      redirect.headers.set('Location', redirect.options.href)
+    if (!redirect.href) {
+      redirect.href = this.buildLocation(redirect as any).href
     }
 
     return redirect
@@ -2869,11 +2968,11 @@ export class RouterCore<
       return matches
     } catch (err) {
       if (isRedirect(err)) {
-        if (err.options.reloadDocument) {
+        if (err.reloadDocument) {
           return undefined
         }
         return await this.preloadRoute({
-          ...err.options,
+          ...(err as any),
           _fromLocation: next,
         })
       }
@@ -3107,224 +3206,3 @@ function routeNeedsPreload(route: AnyRoute) {
   }
   return false
 }
-
-interface RouteLike {
-  id: string
-  isRoot?: boolean
-  path?: string
-  fullPath: string
-  rank?: number
-  parentRoute?: RouteLike
-  children?: Array<RouteLike>
-  options?: {
-    caseSensitive?: boolean
-  }
-}
-
-export function processRouteTree<TRouteLike extends RouteLike>({
-  routeTree,
-  initRoute,
-}: {
-  routeTree: TRouteLike
-  initRoute?: (route: TRouteLike, index: number) => void
-}) {
-  const routesById = {} as Record<string, TRouteLike>
-  const routesByPath = {} as Record<string, TRouteLike>
-
-  const recurseRoutes = (childRoutes: Array<TRouteLike>) => {
-    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 = trimPathRight(childRoute.fullPath)
-        if (
-          !routesByPath[trimmedFullPath] ||
-          childRoute.fullPath.endsWith('/')
-        ) {
-          routesByPath[trimmedFullPath] = childRoute
-        }
-      }
-
-      const children = childRoute.children as Array<TRouteLike>
-
-      if (children?.length) {
-        recurseRoutes(children)
-      }
-    })
-  }
-
-  recurseRoutes([routeTree])
-
-  const scoredRoutes: Array<{
-    child: TRouteLike
-    trimmed: string
-    parsed: ReturnType<typeof parsePathname>
-    index: number
-    scores: Array<number>
-  }> = []
-
-  const routes: Array<TRouteLike> = Object.values(routesById)
-
-  routes.forEach((d, i) => {
-    if (d.isRoot || !d.path) {
-      return
-    }
-
-    const trimmed = trimPathLeft(d.fullPath)
-    const parsed = parsePathname(trimmed)
-
-    // Removes the leading slash if it is not the only remaining segment
-    while (parsed.length > 1 && parsed[0]?.value === '/') {
-      parsed.shift()
-    }
-
-    const scores = parsed.map((segment) => {
-      if (segment.value === '/') {
-        return 0.75
-      }
-
-      if (
-        segment.type === 'param' &&
-        segment.prefixSegment &&
-        segment.suffixSegment
-      ) {
-        return 0.55
-      }
-
-      if (segment.type === 'param' && segment.prefixSegment) {
-        return 0.52
-      }
-
-      if (segment.type === 'param' && segment.suffixSegment) {
-        return 0.51
-      }
-
-      if (segment.type === 'param') {
-        return 0.5
-      }
-
-      if (
-        segment.type === 'wildcard' &&
-        segment.prefixSegment &&
-        segment.suffixSegment
-      ) {
-        return 0.3
-      }
-
-      if (segment.type === 'wildcard' && segment.prefixSegment) {
-        return 0.27
-      }
-
-      if (segment.type === 'wildcard' && segment.suffixSegment) {
-        return 0.26
-      }
-
-      if (segment.type === 'wildcard') {
-        return 0.25
-      }
-
-      return 1
-    })
-
-    scoredRoutes.push({ child: d, trimmed, parsed, index: i, scores })
-  })
-
-  const flatRoutes = scoredRoutes
-    .sort((a, b) => {
-      const minLength = Math.min(a.scores.length, b.scores.length)
-
-      // Sort by min available score
-      for (let i = 0; i < minLength; i++) {
-        if (a.scores[i] !== b.scores[i]) {
-          return b.scores[i]! - a.scores[i]!
-        }
-      }
-
-      // Sort by length of score
-      if (a.scores.length !== b.scores.length) {
-        return b.scores.length - a.scores.length
-      }
-
-      // Sort by min available parsed value
-      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
-        }
-      }
-
-      // Sort by original index
-      return a.index - b.index
-    })
-    .map((d, i) => {
-      d.child.rank = i
-      return d.child
-    })
-
-  return { routesById, routesByPath, flatRoutes }
-}
-
-export function getMatchedRoutes<TRouteLike extends RouteLike>({
-  pathname,
-  routePathname,
-  basepath,
-  caseSensitive,
-  routesByPath,
-  routesById,
-  flatRoutes,
-}: {
-  pathname: string
-  routePathname?: string
-  basepath: string
-  caseSensitive?: boolean
-  routesByPath: Record<string, TRouteLike>
-  routesById: Record<string, TRouteLike>
-  flatRoutes: Array<TRouteLike>
-}) {
-  let routeParams: Record<string, string> = {}
-  const trimmedPath = trimPathRight(pathname)
-  const getMatchedParams = (route: TRouteLike) => {
-    const result = matchPathname(basepath, trimmedPath, {
-      to: route.fullPath,
-      caseSensitive: route.options?.caseSensitive ?? caseSensitive,
-      fuzzy: true,
-    })
-    return result
-  }
-
-  let foundRoute: TRouteLike | undefined =
-    routePathname !== undefined ? routesByPath[routePathname] : undefined
-  if (foundRoute) {
-    routeParams = getMatchedParams(foundRoute)!
-  } else {
-    foundRoute = flatRoutes.find((route) => {
-      const matchedParams = getMatchedParams(route)
-
-      if (matchedParams) {
-        routeParams = matchedParams
-        return true
-      }
-
-      return false
-    })
-  }
-
-  let routeCursor: TRouteLike = foundRoute || routesById[rootRouteId]!
-
-  const matchedRoutes: Array<TRouteLike> = [routeCursor]
-
-  while (routeCursor.parentRoute) {
-    routeCursor = routeCursor.parentRoute as TRouteLike
-    matchedRoutes.unshift(routeCursor)
-  }
-
-  return { matchedRoutes, routeParams, foundRoute }
-}