@tanstack/router-core 1.171.16 → 1.171.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/router-core",
-  "version": "1.171.16",
+  "version": "1.171.18",
   "description": "Modern and scalable routing for React applications",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -168,9 +168,9 @@
   },
   "dependencies": {
     "cookie-es": "^3.0.0",
-    "seroval": "^1.5.4",
-    "seroval-plugins": "^1.5.4",
-    "@tanstack/history": "1.162.0"
+    "seroval": "^1.6.2",
+    "seroval-plugins": "^1.6.2",
+    "@tanstack/history": "1.162.1"
   },
   "devDependencies": {
     "@tanstack/store": "^0.9.3",

package/src/new-process-route-tree.ts

@@ -199,16 +199,18 @@ function parseSegments<TRouteLike extends RouteLike>(
   start: number,
   node: AnySegmentNode<TRouteLike>,
   depth: number,
+  /** Each dynamic sibling list is recorded once, when it first needs sorting. */
+  dynamicListsToSort?: Array<Array<DynamicSegmentNode<TRouteLike>>>,
   onRoute?: (route: TRouteLike) => void,
 ) {
   onRoute?.(route)
   let cursor = start
   {
     const path = route.fullPath ?? route.from
+    const options = route.options
     const length = path.length
-    const caseSensitive = route.options?.caseSensitive ?? defaultCaseSensitive
-    const parseParams =
-      route.options?.params?.parse ?? route.options?.parseParams
+    const caseSensitive = options?.caseSensitive ?? defaultCaseSensitive
+    const parseParams = options?.params?.parse ?? options?.parseParams
     while (cursor < length) {
       const segment = parseSegment(path, cursor, data)
       let nextNode: AnySegmentNode<TRouteLike>
@@ -220,81 +222,29 @@ function parseSegments<TRouteLike extends RouteLike>(
       switch (kind) {
         case SEGMENT_TYPE_PATHNAME: {
           const value = path.substring(segment[2], segment[3])
+          let name = value
+          let staticChildren: Map<string, StaticSegmentNode<TRouteLike>>
           if (caseSensitive) {
-            const existingNode = node.static?.get(value)
-            if (existingNode) {
-              nextNode = existingNode
-            } else {
-              node.static ??= new Map()
-              const next = createStaticNode<TRouteLike>(
-                route.fullPath ?? route.from,
-              )
-              next.parent = node
-              next.depth = depth
-              nextNode = next
-              node.static.set(value, next)
-            }
+            staticChildren = node.static ??= new Map()
           } else {
-            const name = value.toLowerCase()
-            const existingNode = node.staticInsensitive?.get(name)
-            if (existingNode) {
-              nextNode = existingNode
-            } else {
-              node.staticInsensitive ??= new Map()
-              const next = createStaticNode<TRouteLike>(
-                route.fullPath ?? route.from,
-              )
-              next.parent = node
-              next.depth = depth
-              nextNode = next
-              node.staticInsensitive.set(name, next)
-            }
+            name = value.toLowerCase()
+            staticChildren = node.staticInsensitive ??= new Map()
           }
-          break
-        }
-        case SEGMENT_TYPE_PARAM: {
-          const prefix_raw = path.substring(start, segment[1])
-          const suffix_raw = path.substring(segment[4], end)
-          const actuallyCaseSensitive =
-            caseSensitive && !!(prefix_raw || suffix_raw)
-          const prefix = !prefix_raw
-            ? undefined
-            : actuallyCaseSensitive
-              ? prefix_raw
-              : prefix_raw.toLowerCase()
-          const suffix = !suffix_raw
-            ? undefined
-            : actuallyCaseSensitive
-              ? suffix_raw
-              : suffix_raw.toLowerCase()
-          const existingNode =
-            !parseParams &&
-            node.dynamic?.find(
-              (s) =>
-                !s.parse &&
-                s.caseSensitive === actuallyCaseSensitive &&
-                s.prefix === prefix &&
-                s.suffix === suffix,
-            )
+          const existingNode = staticChildren.get(name)
           if (existingNode) {
             nextNode = existingNode
           } else {
-            const next = createDynamicNode<TRouteLike>(
-              SEGMENT_TYPE_PARAM,
-              route.fullPath ?? route.from,
-              actuallyCaseSensitive,
-              prefix,
-              suffix,
-            )
-            nextNode = next
-            next.depth = depth
+            const next = createStaticNode<TRouteLike>(path)
             next.parent = node
-            node.dynamic ??= []
-            node.dynamic.push(next)
+            next.depth = depth
+            nextNode = next
+            staticChildren.set(name, next)
           }
           break
         }
-        case SEGMENT_TYPE_OPTIONAL_PARAM: {
+        case SEGMENT_TYPE_PARAM:
+        case SEGMENT_TYPE_OPTIONAL_PARAM:
+        case SEGMENT_TYPE_WILDCARD: {
           const prefix_raw = path.substring(start, segment[1])
           const suffix_raw = path.substring(segment[4], end)
           const actuallyCaseSensitive =
@@ -309,9 +259,18 @@ function parseSegments<TRouteLike extends RouteLike>(
             : actuallyCaseSensitive
               ? suffix_raw
               : suffix_raw.toLowerCase()
+          const siblings =
+            kind === SEGMENT_TYPE_PARAM
+              ? node.dynamic
+              : kind === SEGMENT_TYPE_OPTIONAL_PARAM
+                ? node.optional
+                : node.wildcard
           const existingNode =
+            // Keep wildcard aliases as separate match candidates, even when
+            // they have the same shape and no parser.
+            kind !== SEGMENT_TYPE_WILDCARD &&
             !parseParams &&
-            node.optional?.find(
+            siblings?.find(
               (s) =>
                 !s.parse &&
                 s.caseSensitive === actuallyCaseSensitive &&
@@ -322,8 +281,8 @@ function parseSegments<TRouteLike extends RouteLike>(
             nextNode = existingNode
           } else {
             const next = createDynamicNode<TRouteLike>(
-              SEGMENT_TYPE_OPTIONAL_PARAM,
-              route.fullPath ?? route.from,
+              kind,
+              path,
               actuallyCaseSensitive,
               prefix,
               suffix,
@@ -331,39 +290,21 @@ function parseSegments<TRouteLike extends RouteLike>(
             nextNode = next
             next.parent = node
             next.depth = depth
-            node.optional ??= []
-            node.optional.push(next)
+            let nodes: Array<DynamicSegmentNode<TRouteLike>>
+            if (kind === SEGMENT_TYPE_PARAM) {
+              nodes = node.dynamic ??= []
+            } else if (kind === SEGMENT_TYPE_OPTIONAL_PARAM) {
+              nodes = node.optional ??= []
+            } else {
+              nodes = node.wildcard ??= []
+            }
+            nodes.push(next)
+            if (nodes.length === 2) {
+              dynamicListsToSort?.push(nodes)
+            }
           }
           break
         }
-        case SEGMENT_TYPE_WILDCARD: {
-          const prefix_raw = path.substring(start, segment[1])
-          const suffix_raw = path.substring(segment[4], end)
-          const actuallyCaseSensitive =
-            caseSensitive && !!(prefix_raw || suffix_raw)
-          const prefix = !prefix_raw
-            ? undefined
-            : actuallyCaseSensitive
-              ? prefix_raw
-              : prefix_raw.toLowerCase()
-          const suffix = !suffix_raw
-            ? undefined
-            : actuallyCaseSensitive
-              ? suffix_raw
-              : suffix_raw.toLowerCase()
-          const next = createDynamicNode<TRouteLike>(
-            SEGMENT_TYPE_WILDCARD,
-            route.fullPath ?? route.from,
-            actuallyCaseSensitive,
-            prefix,
-            suffix,
-          )
-          nextNode = next
-          next.parent = node
-          next.depth = depth
-          node.wildcard ??= []
-          node.wildcard.push(next)
-        }
       }
       node = nextNode
     }
@@ -376,9 +317,7 @@ function parseSegments<TRouteLike extends RouteLike>(
       route.id &&
       route.id.charCodeAt(route.id.lastIndexOf('/') + 1) === 95 /* '_' */
     ) {
-      const pathlessNode = createStaticNode<TRouteLike>(
-        route.fullPath ?? route.from,
-      )
+      const pathlessNode = createStaticNode<TRouteLike>(path)
       pathlessNode.kind = SEGMENT_TYPE_PATHLESS
       pathlessNode.parent = node
       depth++
@@ -391,9 +330,7 @@ function parseSegments<TRouteLike extends RouteLike>(
     const isLeaf = (route.path || !route.children) && !route.isRoot
     // create index node
     if (isLeaf && path.endsWith('/')) {
-      const indexNode = createStaticNode<TRouteLike>(
-        route.fullPath ?? route.from,
-      )
+      const indexNode = createStaticNode<TRouteLike>(path)
       indexNode.kind = SEGMENT_TYPE_INDEX
       indexNode.parent = node
       depth++
@@ -403,12 +340,12 @@ function parseSegments<TRouteLike extends RouteLike>(
     }
 
     node.parse = parseParams ?? null
-    node.priority = route.options?.params?.priority ?? 0
+    node.priority = options?.params?.priority ?? 0
 
     // make node "matchable"
     if (isLeaf && !node.route) {
       node.route = route
-      node.fullPath = route.fullPath ?? route.from
+      node.fullPath = path
     }
   }
   if (route.children)
@@ -420,6 +357,7 @@ function parseSegments<TRouteLike extends RouteLike>(
         cursor,
         node,
         depth,
+        dynamicListsToSort,
         onRoute,
       )
     }
@@ -464,42 +402,6 @@ function sortDynamic(
   return 0
 }
 
-function sortTreeNodes(node: SegmentNode<RouteLike>) {
-  if (node.pathless) {
-    for (const child of node.pathless) {
-      sortTreeNodes(child)
-    }
-  }
-  if (node.static) {
-    for (const child of node.static.values()) {
-      sortTreeNodes(child)
-    }
-  }
-  if (node.staticInsensitive) {
-    for (const child of node.staticInsensitive.values()) {
-      sortTreeNodes(child)
-    }
-  }
-  if (node.dynamic?.length) {
-    node.dynamic.sort(sortDynamic)
-    for (const child of node.dynamic) {
-      sortTreeNodes(child)
-    }
-  }
-  if (node.optional?.length) {
-    node.optional.sort(sortDynamic)
-    for (const child of node.optional) {
-      sortTreeNodes(child)
-    }
-  }
-  if (node.wildcard?.length) {
-    node.wildcard.sort(sortDynamic)
-    for (const child of node.wildcard) {
-      sortTreeNodes(child)
-    }
-  }
-}
-
 function createStaticNode<T extends RouteLike>(
   fullPath: string,
 ): StaticSegmentNode<T> {
@@ -663,10 +565,13 @@ export function processRouteMasks<
 ) {
   const segmentTree = createStaticNode<TRouteLike>('/')
   const data = new Uint16Array(6)
+  const dynamicListsToSort: Array<Array<DynamicSegmentNode<TRouteLike>>> = []
   for (const route of routeList) {
-    parseSegments(false, data, route, 1, segmentTree, 0)
+    parseSegments(false, data, route, 1, segmentTree, 0, dynamicListsToSort)
+  }
+  for (const nodes of dynamicListsToSort) {
+    nodes.sort(sortDynamic)
   }
-  sortTreeNodes(segmentTree)
   processedTree.masksTree = segmentTree
   processedTree.flatCache = createLRUCache<
     string,
@@ -789,34 +694,46 @@ export function processRouteTree<
 ): ProcessRouteTreeResult<TRouteLike> {
   const segmentTree = createStaticNode<TRouteLike>(routeTree.fullPath)
   const data = new Uint16Array(6)
+  const dynamicListsToSort: Array<Array<DynamicSegmentNode<TRouteLike>>> = []
   const routesById = {} as Record<string, TRouteLike>
   const routesByPath = {} as Record<string, TRouteLike>
   let index = 0
-  parseSegments(caseSensitive, data, routeTree, 1, segmentTree, 0, (route) => {
-    initRoute?.(route, index)
+  parseSegments(
+    caseSensitive,
+    data,
+    routeTree,
+    1,
+    segmentTree,
+    0,
+    dynamicListsToSort,
+    (route) => {
+      initRoute?.(route, index)
+
+      if (route.id in routesById) {
+        if (process.env.NODE_ENV !== 'production') {
+          throw new Error(
+            `Invariant failed: Duplicate routes found with id: ${String(route.id)}`,
+          )
+        }
 
-    if (route.id in routesById) {
-      if (process.env.NODE_ENV !== 'production') {
-        throw new Error(
-          `Invariant failed: Duplicate routes found with id: ${String(route.id)}`,
-        )
+        invariant()
       }
 
-      invariant()
-    }
-
-    routesById[route.id] = route
+      routesById[route.id] = route
 
-    if (index !== 0 && route.path) {
-      const trimmedFullPath = trimPathRight(route.fullPath)
-      if (!routesByPath[trimmedFullPath] || route.fullPath.endsWith('/')) {
-        routesByPath[trimmedFullPath] = route
+      if (index !== 0 && route.path) {
+        const trimmedFullPath = trimPathRight(route.fullPath)
+        if (!routesByPath[trimmedFullPath] || route.fullPath.endsWith('/')) {
+          routesByPath[trimmedFullPath] = route
+        }
       }
-    }
 
-    index++
-  })
-  sortTreeNodes(segmentTree)
+      index++
+    },
+  )
+  for (const nodes of dynamicListsToSort) {
+    nodes.sort(sortDynamic)
+  }
   const processedTree: ProcessedTree<TRouteLike, any, any> = {
     segmentTree,
     singleCache: createLRUCache<string, AnySegmentNode<any>>(1000),
@@ -992,8 +909,6 @@ type MatchStackFrame<T extends RouteLike> = {
   node: AnySegmentNode<T>
   /** index of the segment of path */
   index: number
-  /** how many nodes between `node` and the root of the segment tree */
-  depth: number
   /**
    * Bitmask of skipped optional segments.
    *
@@ -1043,7 +958,6 @@ function getNodeMatch<T extends RouteLike>(
       node: segmentTree,
       index: 1,
       skipped: 0,
-      depth: 1,
       statics: 0,
       dynamics: 0,
       optionals: 0,
@@ -1055,7 +969,7 @@ function getNodeMatch<T extends RouteLike>(
 
   while (stack.length) {
     const frame = stack.pop()!
-    const { node, index, skipped, depth, statics, dynamics, optionals } = frame
+    const { node, index, skipped, statics, dynamics, optionals } = frame
     let { extract, rawParams } = frame
 
     // Wildcard candidates are pushed speculatively as fallbacks in case a
@@ -1112,7 +1026,6 @@ function getNodeMatch<T extends RouteLike>(
         node: node.index,
         index,
         skipped,
-        depth: depth + 1,
         statics,
         dynamics,
         optionals,
@@ -1165,7 +1078,6 @@ function getNodeMatch<T extends RouteLike>(
           node: segment,
           index: partsLength,
           skipped,
-          depth: depth + 1,
           statics,
           dynamics,
           optionals,
@@ -1177,16 +1089,15 @@ function getNodeMatch<T extends RouteLike>(
 
     // 4. Try optional match
     if (node.optional) {
-      const nextSkipped = skipped | (1 << depth)
-      const nextDepth = depth + 1
+      // A skipped optional is keyed by the child node's trie depth.
+      const nextSkipped = skipped | (1 << (node.depth + 1))
       for (let i = node.optional.length - 1; i >= 0; i--) {
         const segment = node.optional[i]!
-        // when skipping, node and depth advance by 1, but index doesn't
+        // when skipping, the node advances by 1, but the index doesn't
         stack.push({
           node: segment,
           index,
           skipped: nextSkipped,
-          depth: nextDepth,
           statics,
           dynamics,
           optionals,
@@ -1209,7 +1120,6 @@ function getNodeMatch<T extends RouteLike>(
             node: segment,
             index: index + 1,
             skipped,
-            depth: nextDepth,
             statics,
             dynamics,
             optionals: optionals + segmentScore(partsLength, index),
@@ -1236,7 +1146,6 @@ function getNodeMatch<T extends RouteLike>(
           node: segment,
           index: index + 1,
           skipped,
-          depth: depth + 1,
           statics,
           dynamics: dynamics + segmentScore(partsLength, index),
           optionals,
@@ -1256,7 +1165,6 @@ function getNodeMatch<T extends RouteLike>(
           node: match,
           index: index + 1,
           skipped,
-          depth: depth + 1,
           statics: statics + segmentScore(partsLength, index),
           dynamics,
           optionals,
@@ -1274,7 +1182,6 @@ function getNodeMatch<T extends RouteLike>(
           node: match,
           index: index + 1,
           skipped,
-          depth: depth + 1,
           statics: statics + segmentScore(partsLength, index),
           dynamics,
           optionals,
@@ -1286,14 +1193,12 @@ function getNodeMatch<T extends RouteLike>(
 
     // 0. Try pathless match
     if (node.pathless) {
-      const nextDepth = depth + 1
       for (let i = node.pathless.length - 1; i >= 0; i--) {
         const segment = node.pathless[i]!
         stack.push({
           node: segment,
           index,
           skipped,
-          depth: nextDepth,
           statics,
           dynamics,
           optionals,
@@ -1380,6 +1285,6 @@ function isFrameMoreSpecific(
                 (prev.node.kind === SEGMENT_TYPE_INDEX) ||
                 ((next.node.kind === SEGMENT_TYPE_INDEX) ===
                   (prev.node.kind === SEGMENT_TYPE_INDEX) &&
-                  next.depth > prev.depth)))))))
+                  next.node.depth > prev.node.depth)))))))
   )
 }