@tanstack/router-core 1.136.3 → 1.136.5

package/src/router.ts

@@ -9,21 +9,26 @@ import {
   last,
   replaceEqualDeep,
 } from './utils'
-import { processRouteTree } from './process-route-tree'
+import {
+  findFlatMatch,
+  findRouteMatch,
+  findSingleMatch,
+  processRouteMasks,
+  processRouteTree,
+} from './new-process-route-tree'
 import {
   cleanPath,
   interpolatePath,
-  matchPathname,
   resolvePath,
   trimPath,
   trimPathRight,
 } from './path'
+import { createLRUCache } from './lru-cache'
 import { isNotFound } from './not-found'
 import { setupScrollRestoration } from './scroll-restoration'
 import { defaultParseSearch, defaultStringifySearch } from './searchParams'
 import { rootRouteId } from './root'
 import { isRedirect, redirect } from './redirect'
-import { createLRUCache } from './lru-cache'
 import { loadMatches, loadRouteChunk, routeNeedsPreload } from './load-matches'
 import {
   composeRewrites,
@@ -31,7 +36,7 @@ import {
   executeRewriteOutput,
   rewriteBasepath,
 } from './rewrite'
-import type { ParsePathnameCache } from './path'
+import type { ProcessedTree } from './new-process-route-tree'
 import type { SearchParser, SearchSerializer } from './searchParams'
 import type { AnyRedirect, ResolvedRedirect } from './redirect'
 import type {
@@ -691,10 +696,7 @@ export type ParseLocationFn<TRouteTree extends AnyRoute> = (
   previousLocation?: ParsedLocation<FullSearchSchema<TRouteTree>>,
 ) => ParsedLocation<FullSearchSchema<TRouteTree>>
 
-export type GetMatchRoutesFn = (
-  pathname: string,
-  routePathname: string | undefined,
-) => {
+export type GetMatchRoutesFn = (pathname: string) => {
   matchedRoutes: Array<AnyRoute>
   routeParams: Record<string, string>
   foundRoute: AnyRoute | undefined
@@ -754,6 +756,7 @@ export interface ServerSsr {
   isDehydrated: () => boolean
   onRenderFinished: (listener: () => void) => void
   dehydrate: () => Promise<void>
+  takeBufferedScripts: () => string | undefined
 }
 
 export type AnyRouterWithContext<TContext> = RouterCore<
@@ -901,7 +904,7 @@ export class RouterCore<
   routeTree!: TRouteTree
   routesById!: RoutesById<TRouteTree>
   routesByPath!: RoutesByPath<TRouteTree>
-  flatRoutes!: Array<AnyRoute>
+  processedTree!: ProcessedTree<TRouteTree, any, any>
   isServer!: boolean
   pathParamsDecodeCharMap?: Map<string, string>
 
@@ -1093,18 +1096,22 @@ export class RouterCore<
   }
 
   buildRouteTree = () => {
-    const { routesById, routesByPath, flatRoutes } = processRouteTree({
-      routeTree: this.routeTree,
-      initRoute: (route, i) => {
+    const { routesById, routesByPath, processedTree } = processRouteTree(
+      this.routeTree,
+      this.options.caseSensitive,
+      (route, i) => {
         route.init({
           originalIndex: i,
         })
       },
-    })
+    )
+    if (this.options.routeMasks) {
+      processRouteMasks(this.options.routeMasks, processedTree)
+    }
 
     this.routesById = routesById as RoutesById<TRouteTree>
     this.routesByPath = routesByPath as RoutesByPath<TRouteTree>
-    this.flatRoutes = flatRoutes as Array<AnyRoute>
+    this.processedTree = processedTree
 
     const notFoundRoute = this.options.notFoundRoute
 
@@ -1202,13 +1209,15 @@ export class RouterCore<
     return location
   }
 
+  resolvePathCache = createLRUCache<string, string>(1000)
+
   /** Resolve a path against the router basepath and trailing-slash policy. */
   resolvePathWithBase = (from: string, path: string) => {
     const resolvedPath = resolvePath({
       base: from,
       to: cleanPath(path),
       trailingSlash: this.options.trailingSlash,
-      parseCache: this.parsePathnameCache,
+      cache: this.resolvePathCache,
     })
     return resolvedPath
   }
@@ -1241,7 +1250,6 @@ export class RouterCore<
   ): Array<AnyRouteMatch> {
     const { foundRoute, matchedRoutes, routeParams } = this.getMatchedRoutes(
       next.pathname,
-      opts?.dest?.to as string,
     )
     let isGlobalNotFound = false
 
@@ -1534,21 +1542,11 @@ export class RouterCore<
     return matches
   }
 
-  /** a cache for `parsePathname` */
-  private parsePathnameCache: ParsePathnameCache = createLRUCache(1000)
-
-  getMatchedRoutes: GetMatchRoutesFn = (
-    pathname: string,
-    routePathname: string | undefined,
-  ) => {
+  getMatchedRoutes: GetMatchRoutesFn = (pathname) => {
     return getMatchedRoutes({
       pathname,
-      routePathname,
-      caseSensitive: this.options.caseSensitive,
-      routesByPath: this.routesByPath,
       routesById: this.routesById,
-      flatRoutes: this.flatRoutes,
-      parseCache: this.parsePathnameCache,
+      processedTree: this.processedTree,
     })
   }
 
@@ -1611,10 +1609,7 @@ export class RouterCore<
         process.env.NODE_ENV !== 'production' &&
         dest._isNavigate
       ) {
-        const allFromMatches = this.getMatchedRoutes(
-          dest.from,
-          undefined,
-        ).matchedRoutes
+        const allFromMatches = this.getMatchedRoutes(dest.from).matchedRoutes
 
         const matchedFrom = findLast(allCurrentLocationMatches, (d) => {
           return comparePaths(d.fullPath, dest.from!)
@@ -1665,7 +1660,6 @@ export class RouterCore<
       const interpolatedNextTo = interpolatePath({
         path: nextTo,
         params: nextParams,
-        parseCache: this.parsePathnameCache,
       }).interpolatedPath
 
       const destRoutes = this.matchRoutes(interpolatedNextTo, undefined, {
@@ -1692,7 +1686,6 @@ export class RouterCore<
               path: nextTo,
               params: nextParams,
               decodeCharMap: this.pathParamsDecodeCharMap,
-              parseCache: this.parsePathnameCache,
             }).interpolatedPath,
           )
 
@@ -1785,35 +1778,23 @@ export class RouterCore<
       let maskedNext = maskedDest ? build(maskedDest) : undefined
 
       if (!maskedNext) {
-        let params = {}
+        const params = {}
 
-        const foundMask = this.options.routeMasks?.find((d) => {
-          const match = matchPathname(
+        if (this.options.routeMasks) {
+          const match = findFlatMatch<RouteMask<TRouteTree>>(
             next.pathname,
-            {
-              to: d.from,
-              caseSensitive: false,
-              fuzzy: false,
-            },
-            this.parsePathnameCache,
+            this.processedTree,
           )
-
           if (match) {
-            params = match
-            return true
-          }
-
-          return false
-        })
-
-        if (foundMask) {
-          const { from: _from, ...maskProps } = foundMask
-          maskedDest = {
-            from: opts.from,
-            ...maskProps,
-            params,
+            Object.assign(params, match.params) // Copy params, because they're cached
+            const { from: _from, ...maskProps } = match.route
+            maskedDest = {
+              from: opts.from,
+              ...maskProps,
+              params,
+            }
+            maskedNext = build(maskedDest)
           }
-          maskedNext = build(maskedDest)
         }
       }
 
@@ -2524,31 +2505,31 @@ export class RouterCore<
       ? this.latestLocation
       : this.state.resolvedLocation || this.state.location
 
-    const match = matchPathname(
+    const match = findSingleMatch(
+      next.pathname,
+      opts?.caseSensitive ?? false,
+      opts?.fuzzy ?? false,
       baseLocation.pathname,
-      {
-        ...opts,
-        to: next.pathname,
-      },
-      this.parsePathnameCache,
-    ) as any
+      this.processedTree,
+    )
 
     if (!match) {
       return false
     }
+
     if (location.params) {
-      if (!deepEqual(match, location.params, { partial: true })) {
+      if (!deepEqual(match.params, location.params, { partial: true })) {
         return false
       }
     }
 
-    if (match && (opts?.includeSearch ?? true)) {
+    if (opts?.includeSearch ?? true) {
       return deepEqual(baseLocation.search, next.search, { partial: true })
-        ? match
+        ? match.params
         : false
     }
 
-    return match
+    return match.params
   }
 
   ssr?: {
@@ -2644,70 +2625,21 @@ function validateSearch(validateSearch: AnyValidator, input: unknown): unknown {
  */
 export function getMatchedRoutes<TRouteLike extends RouteLike>({
   pathname,
-  routePathname,
-  caseSensitive,
-  routesByPath,
   routesById,
-  flatRoutes,
-  parseCache,
+  processedTree,
 }: {
   pathname: string
-  routePathname?: string
-  caseSensitive?: boolean
-  routesByPath: Record<string, TRouteLike>
   routesById: Record<string, TRouteLike>
-  flatRoutes: Array<TRouteLike>
-  parseCache?: ParsePathnameCache
+  processedTree: ProcessedTree<any, any, any>
 }) {
-  let routeParams: Record<string, string> = {}
+  const routeParams: Record<string, string> = {}
   const trimmedPath = trimPathRight(pathname)
-  const getMatchedParams = (route: TRouteLike) => {
-    const result = matchPathname(
-      trimmedPath,
-      {
-        to: route.fullPath,
-        caseSensitive: route.options?.caseSensitive ?? caseSensitive,
-        // we need fuzzy matching for `notFoundMode: 'fuzzy'`
-        fuzzy: true,
-      },
-      parseCache,
-    )
-    return result
-  }
 
-  let foundRoute: TRouteLike | undefined =
-    routePathname !== undefined ? routesByPath[routePathname] : undefined
-  if (foundRoute) {
-    routeParams = getMatchedParams(foundRoute)!
-  } else {
-    // iterate over flatRoutes to find the best match
-    // if we find a fuzzy matching route, keep looking for a perfect fit
-    let fuzzyMatch:
-      | { foundRoute: TRouteLike; routeParams: Record<string, string> }
-      | undefined = undefined
-    for (const route of flatRoutes) {
-      const matchedParams = getMatchedParams(route)
-
-      if (matchedParams) {
-        if (
-          route.path !== '/' &&
-          (matchedParams as Record<string, string>)['**']
-        ) {
-          if (!fuzzyMatch) {
-            fuzzyMatch = { foundRoute: route, routeParams: matchedParams }
-          }
-        } else {
-          foundRoute = route
-          routeParams = matchedParams
-          break
-        }
-      }
-    }
-    // did not find a perfect fit, so take the fuzzy matching route if it exists
-    if (!foundRoute && fuzzyMatch) {
-      foundRoute = fuzzyMatch.foundRoute
-      routeParams = fuzzyMatch.routeParams
-    }
+  let foundRoute: TRouteLike | undefined = undefined
+  const match = findRouteMatch<TRouteLike>(trimmedPath, processedTree, true)
+  if (match) {
+    foundRoute = match.route
+    Object.assign(routeParams, match.params) // Copy params, because they're cached
   }
 
   let routeCursor: TRouteLike = foundRoute || routesById[rootRouteId]!

package/src/ssr/constants.ts

@@ -1 +1,2 @@
 export const GLOBAL_TSR = '$_TSR'
+export declare const GLOBAL_SEROVAL: '$R'

package/src/ssr/ssr-client.ts

@@ -6,11 +6,12 @@ import type { AnyRouter } from '../router'
 import type { Manifest } from '../manifest'
 import type { RouteContextOptions } from '../route'
 import type { AnySerializationAdapter } from './serializer/transformer'
-import type { GLOBAL_TSR } from './constants'
+import type { GLOBAL_SEROVAL, GLOBAL_TSR } from './constants'
 
 declare global {
   interface Window {
     [GLOBAL_TSR]?: TsrSsrGlobal
+    [GLOBAL_SEROVAL]?: any
   }
 }
 
@@ -25,6 +26,10 @@ export interface TsrSsrGlobal {
   t?: Map<string, (value: any) => any>
   // this flag indicates whether the transformers were initialized
   initialized?: boolean
+  // router is hydrated and doesnt need the streamed values anymore
+  hydrated?: boolean
+  // stream has ended
+  streamEnd?: boolean
 }
 
 function hydrateMatch(
@@ -165,6 +170,10 @@ export async function hydrate(router: AnyRouter): Promise<any> {
   // Allow the user to handle custom hydration data
   await router.options.hydrate?.(dehydratedData)
 
+  window.$_TSR.hydrated = true
+  // potentially clean up streamed values IF stream has ended already
+  window.$_TSR.c()
+
   // now that all necessary data is hydrated:
   // 1) fully reconstruct the route context
   // 2) execute `head()` and `scripts()` for each match

package/src/ssr/ssr-server.ts

@@ -48,6 +48,54 @@ export function dehydrateMatch(match: AnyRouteMatch): DehydratedMatch {
   return dehydratedMatch
 }
 
+const INITIAL_SCRIPTS = [
+  getCrossReferenceHeader(SCOPE_ID),
+  minifiedTsrBootStrapScript,
+]
+
+class ScriptBuffer {
+  constructor(private router: AnyRouter) {}
+  private _queue: Array<string> = [...INITIAL_SCRIPTS]
+  private _scriptBarrierLifted = false
+
+  enqueue(script: string) {
+    if (this._scriptBarrierLifted && this._queue.length === 0) {
+      queueMicrotask(() => {
+        this.injectBufferedScripts()
+      })
+    }
+    this._queue.push(script)
+  }
+
+  liftBarrier() {
+    if (this._scriptBarrierLifted) return
+    this._scriptBarrierLifted = true
+    if (this._queue.length > 0) {
+      queueMicrotask(() => {
+        this.injectBufferedScripts()
+      })
+    }
+  }
+
+  takeAll() {
+    const bufferedScripts = this._queue
+    this._queue = []
+    if (bufferedScripts.length === 0) {
+      return undefined
+    }
+    bufferedScripts.push(`${GLOBAL_TSR}.c()`)
+    const joinedScripts = bufferedScripts.join(';')
+    return joinedScripts
+  }
+
+  injectBufferedScripts() {
+    const scriptsToInject = this.takeAll()
+    if (scriptsToInject) {
+      this.router.serverSsr!.injectScript(() => scriptsToInject)
+    }
+  }
+}
+
 export function attachRouterServerSsrUtils({
   router,
   manifest,
@@ -58,16 +106,9 @@ export function attachRouterServerSsrUtils({
   router.ssr = {
     manifest,
   }
-  let initialScriptSent = false
-  const getInitialScript = () => {
-    if (initialScriptSent) {
-      return ''
-    }
-    initialScriptSent = true
-    return `${getCrossReferenceHeader(SCOPE_ID)};${minifiedTsrBootStrapScript};`
-  }
   let _dehydrated = false
   const listeners: Array<() => void> = []
+  const scriptBuffer = new ScriptBuffer(router)
 
   router.serverSsr = {
     injectedHtml: [],
@@ -84,7 +125,10 @@ export function attachRouterServerSsrUtils({
     injectScript: (getScript) => {
       return router.serverSsr!.injectHtml(async () => {
         const script = await getScript()
-        return `<script ${router.options.ssr?.nonce ? `nonce='${router.options.ssr.nonce}'` : ''} class='$tsr'>${getInitialScript()}${script};$_TSR.c()</script>`
+        if (!script) {
+          return ''
+        }
+        return `<script${router.options.ssr?.nonce ? `nonce='${router.options.ssr.nonce}' ` : ''} class='$tsr'>${script}</script>`
       })
     },
     dehydrate: async () => {
@@ -104,7 +148,10 @@ export function attachRouterServerSsrUtils({
       if (lastMatchId) {
         dehydratedRouter.lastMatchId = lastMatchId
       }
-      dehydratedRouter.dehydratedData = await router.options.dehydrate?.()
+      const dehydratedData = await router.options.dehydrate?.()
+      if (dehydratedData) {
+        dehydratedRouter.dehydratedData = dehydratedData
+      }
       _dehydrated = true
 
       const p = createControlledPromise<string>()
@@ -115,6 +162,7 @@ export function attachRouterServerSsrUtils({
             | Array<AnySerializationAdapter>
             | undefined
         )?.map((t) => makeSsrSerovalPlugin(t, trackPlugins)) ?? []
+
       crossSerializeStream(dehydratedRouter, {
         refs: new Map(),
         plugins: [...plugins, ...defaultSerovalPlugins],
@@ -123,10 +171,13 @@ export function attachRouterServerSsrUtils({
           if (trackPlugins.didRun) {
             serialized = GLOBAL_TSR + '.p(()=>' + serialized + ')'
           }
-          router.serverSsr!.injectScript(() => serialized)
+          scriptBuffer.enqueue(serialized)
         },
         scopeId: SCOPE_ID,
-        onDone: () => p.resolve(''),
+        onDone: () => {
+          scriptBuffer.enqueue(GLOBAL_TSR + '.streamEnd=true')
+          p.resolve('')
+        },
         onError: (err) => p.reject(err),
       })
       // make sure the stream is kept open until the promise is resolved
@@ -138,6 +189,12 @@ export function attachRouterServerSsrUtils({
     onRenderFinished: (listener) => listeners.push(listener),
     setRenderFinished: () => {
       listeners.forEach((l) => l())
+      scriptBuffer.liftBarrier()
+    },
+    takeBufferedScripts() {
+      const scripts = scriptBuffer.takeAll()
+      scriptBuffer.liftBarrier()
+      return scripts
     },
   }
 }

package/src/ssr/tsrScript.ts

@@ -3,6 +3,10 @@ self.$_TSR = {
     document.querySelectorAll('.\\$tsr').forEach((o) => {
       o.remove()
     })
+    if (this.hydrated && this.streamEnd) {
+      delete self.$_TSR
+      delete self.$R['tsr']
+    }
   },
   p(script) {
     !this.initialized ? this.buffer.push(script) : script()

package/dist/cjs/process-route-tree.cjs

@@ -1,144 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const invariant = require("tiny-invariant");
-const path = require("./path.cjs");
-const SLASH_SCORE = 0.75;
-const STATIC_SEGMENT_SCORE = 1;
-const REQUIRED_PARAM_BASE_SCORE = 0.5;
-const OPTIONAL_PARAM_BASE_SCORE = 0.4;
-const WILDCARD_PARAM_BASE_SCORE = 0.25;
-const STATIC_AFTER_DYNAMIC_BONUS_SCORE = 0.2;
-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 sortRoutes(routes) {
-  const scoredRoutes = [];
-  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 SLASH_SCORE;
-      }
-      if (segment.type === path.SEGMENT_TYPE_PATHNAME) {
-        return STATIC_SEGMENT_SCORE;
-      }
-      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 {
-        baseScore = WILDCARD_PARAM_BASE_SCORE;
-      }
-      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 + STATIC_AFTER_DYNAMIC_BONUS_SCORE
-          );
-        }
-      }
-      return handleParam(segment, baseScore);
-    });
-    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 flatRoutes;
-}
-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 flatRoutes = sortRoutes(Object.values(routesById));
-  return { routesById, routesByPath, flatRoutes };
-}
-exports.processRouteTree = processRouteTree;
-//# sourceMappingURL=process-route-tree.cjs.map

package/dist/cjs/process-route-tree.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"process-route-tree.cjs","sources":["../../src/process-route-tree.ts"],"sourcesContent":["import invariant from 'tiny-invariant'\nimport {\n  SEGMENT_TYPE_OPTIONAL_PARAM,\n  SEGMENT_TYPE_PARAM,\n  SEGMENT_TYPE_PATHNAME,\n  parsePathname,\n  trimPathLeft,\n  trimPathRight,\n} from './path'\nimport type { Segment } from './path'\nimport type { RouteLike } from './route'\n\nconst SLASH_SCORE = 0.75\nconst STATIC_SEGMENT_SCORE = 1\nconst REQUIRED_PARAM_BASE_SCORE = 0.5\nconst OPTIONAL_PARAM_BASE_SCORE = 0.4\nconst WILDCARD_PARAM_BASE_SCORE = 0.25\nconst STATIC_AFTER_DYNAMIC_BONUS_SCORE = 0.2\nconst BOTH_PRESENCE_BASE_SCORE = 0.05\nconst PREFIX_PRESENCE_BASE_SCORE = 0.02\nconst SUFFIX_PRESENCE_BASE_SCORE = 0.01\nconst PREFIX_LENGTH_SCORE_MULTIPLIER = 0.0002\nconst SUFFIX_LENGTH_SCORE_MULTIPLIER = 0.0001\n\nfunction handleParam(segment: Segment, baseScore: number) {\n  if (segment.prefixSegment && segment.suffixSegment) {\n    return (\n      baseScore +\n      BOTH_PRESENCE_BASE_SCORE +\n      PREFIX_LENGTH_SCORE_MULTIPLIER * segment.prefixSegment.length +\n      SUFFIX_LENGTH_SCORE_MULTIPLIER * segment.suffixSegment.length\n    )\n  }\n\n  if (segment.prefixSegment) {\n    return (\n      baseScore +\n      PREFIX_PRESENCE_BASE_SCORE +\n      PREFIX_LENGTH_SCORE_MULTIPLIER * segment.prefixSegment.length\n    )\n  }\n\n  if (segment.suffixSegment) {\n    return (\n      baseScore +\n      SUFFIX_PRESENCE_BASE_SCORE +\n      SUFFIX_LENGTH_SCORE_MULTIPLIER * segment.suffixSegment.length\n    )\n  }\n\n  return baseScore\n}\n\nfunction sortRoutes<TRouteLike extends RouteLike>(\n  routes: ReadonlyArray<TRouteLike>,\n): Array<TRouteLike> {\n  const scoredRoutes: Array<{\n    child: TRouteLike\n    trimmed: string\n    parsed: ReadonlyArray<Segment>\n    index: number\n    scores: Array<number>\n    hasStaticAfter: boolean\n    optionalParamCount: number\n  }> = []\n\n  routes.forEach((d, i) => {\n    if (d.isRoot || !d.path) {\n      return\n    }\n\n    const trimmed = trimPathLeft(d.fullPath)\n    let parsed = parsePathname(trimmed)\n\n    // Removes the leading slash if it is not the only remaining segment\n    let skip = 0\n    while (parsed.length > skip + 1 && parsed[skip]?.value === '/') {\n      skip++\n    }\n    if (skip > 0) parsed = parsed.slice(skip)\n\n    let optionalParamCount = 0\n    let hasStaticAfter = false\n    const scores = parsed.map((segment, index) => {\n      if (segment.value === '/') {\n        return SLASH_SCORE\n      }\n\n      if (segment.type === SEGMENT_TYPE_PATHNAME) {\n        return STATIC_SEGMENT_SCORE\n      }\n\n      let baseScore: number | undefined = undefined\n      if (segment.type === SEGMENT_TYPE_PARAM) {\n        baseScore = REQUIRED_PARAM_BASE_SCORE\n      } else if (segment.type === SEGMENT_TYPE_OPTIONAL_PARAM) {\n        baseScore = OPTIONAL_PARAM_BASE_SCORE\n        optionalParamCount++\n      } else {\n        baseScore = WILDCARD_PARAM_BASE_SCORE\n      }\n\n      // if there is any static segment (that is not an index) after a required / optional param,\n      // we will boost this param so it ranks higher than a required/optional param without a static segment after it\n      // JUST FOR SORTING, NOT FOR MATCHING\n      for (let i = index + 1; i < parsed.length; i++) {\n        const nextSegment = parsed[i]!\n        if (\n          nextSegment.type === SEGMENT_TYPE_PATHNAME &&\n          nextSegment.value !== '/'\n        ) {\n          hasStaticAfter = true\n          return handleParam(\n            segment,\n            baseScore + STATIC_AFTER_DYNAMIC_BONUS_SCORE,\n          )\n        }\n      }\n\n      return handleParam(segment, baseScore)\n    })\n\n    scoredRoutes.push({\n      child: d,\n      trimmed,\n      parsed,\n      index: i,\n      scores,\n      optionalParamCount,\n      hasStaticAfter,\n    })\n  })\n\n  const flatRoutes = scoredRoutes\n    .sort((a, b) => {\n      const minLength = Math.min(a.scores.length, b.scores.length)\n\n      // Sort by segment-by-segment score comparison ONLY for the common prefix\n      for (let i = 0; i < minLength; i++) {\n        if (a.scores[i] !== b.scores[i]) {\n          return b.scores[i]! - a.scores[i]!\n        }\n      }\n\n      // If all common segments have equal scores, then consider length and specificity\n      if (a.scores.length !== b.scores.length) {\n        // If different number of optional parameters, fewer optional parameters wins (more specific)\n        // only if both or none of the routes has static segments after the params\n        if (a.optionalParamCount !== b.optionalParamCount) {\n          if (a.hasStaticAfter === b.hasStaticAfter) {\n            return a.optionalParamCount - b.optionalParamCount\n          } else if (a.hasStaticAfter && !b.hasStaticAfter) {\n            return -1\n          } else if (!a.hasStaticAfter && b.hasStaticAfter) {\n            return 1\n          }\n        }\n\n        // If same number of optional parameters, longer path wins (for static segments)\n        return b.scores.length - a.scores.length\n      }\n\n      // Sort by min available parsed value for alphabetical ordering\n      for (let i = 0; i < minLength; i++) {\n        if (a.parsed[i]!.value !== b.parsed[i]!.value) {\n          return a.parsed[i]!.value > b.parsed[i]!.value ? 1 : -1\n        }\n      }\n\n      // Sort by original index\n      return a.index - b.index\n    })\n    .map((d, i) => {\n      d.child.rank = i\n      return d.child\n    })\n\n  return flatRoutes\n}\n\nexport type ProcessRouteTreeResult<TRouteLike extends RouteLike> = {\n  routesById: Record<string, TRouteLike>\n  routesByPath: Record<string, TRouteLike>\n  flatRoutes: Array<TRouteLike>\n}\n\n/**\n * Build lookup maps and a specificity-sorted flat list from a route tree.\n * Returns `routesById`, `routesByPath`, and `flatRoutes`.\n */\n/**\n * Build lookup maps and a specificity-sorted flat list from a route tree.\n * Returns `routesById`, `routesByPath`, and `flatRoutes`.\n */\nexport function processRouteTree<TRouteLike extends RouteLike>({\n  routeTree,\n  initRoute,\n}: {\n  routeTree: TRouteLike\n  initRoute?: (route: TRouteLike, index: number) => void\n}): ProcessRouteTreeResult<TRouteLike> {\n  const routesById = {} as Record<string, TRouteLike>\n  const routesByPath = {} as Record<string, TRouteLike>\n\n  const recurseRoutes = (childRoutes: Array<TRouteLike>) => {\n    childRoutes.forEach((childRoute, i) => {\n      initRoute?.(childRoute, i)\n\n      const existingRoute = routesById[childRoute.id]\n\n      invariant(\n        !existingRoute,\n        `Duplicate routes found with id: ${String(childRoute.id)}`,\n      )\n\n      routesById[childRoute.id] = childRoute\n\n      if (!childRoute.isRoot && childRoute.path) {\n        const trimmedFullPath = trimPathRight(childRoute.fullPath)\n        if (\n          !routesByPath[trimmedFullPath] ||\n          childRoute.fullPath.endsWith('/')\n        ) {\n          routesByPath[trimmedFullPath] = childRoute\n        }\n      }\n\n      const children = childRoute.children as Array<TRouteLike>\n\n      if (children?.length) {\n        recurseRoutes(children)\n      }\n    })\n  }\n\n  recurseRoutes([routeTree])\n\n  const flatRoutes = sortRoutes(Object.values(routesById))\n\n  return { routesById, routesByPath, flatRoutes }\n}\n"],"names":["trimPathLeft","parsePathname","SEGMENT_TYPE_PATHNAME","SEGMENT_TYPE_PARAM","SEGMENT_TYPE_OPTIONAL_PARAM","i","trimPathRight"],"mappings":"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"}