@tanstack/router-core 1.131.39 → 1.131.40

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

@@ -2,9 +2,12 @@
 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;
@@ -40,7 +43,10 @@ function sortRoutes(routes) {
     let hasStaticAfter = false;
     const scores = parsed.map((segment, index) => {
       if (segment.value === "/") {
-        return 0.75;
+        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) {
@@ -48,20 +54,20 @@ function sortRoutes(routes) {
       } else if (segment.type === path.SEGMENT_TYPE_OPTIONAL_PARAM) {
         baseScore = OPTIONAL_PARAM_BASE_SCORE;
         optionalParamCount++;
-      } else if (segment.type === path.SEGMENT_TYPE_WILDCARD) {
+      } else {
         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);
-          }
+      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);
       }
-      return 1;
+      return handleParam(segment, baseScore);
     });
     scoredRoutes.push({
       child: d,

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

@@ -1 +1 @@
-{"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  SEGMENT_TYPE_WILDCARD,\n  parsePathname,\n  trimPathLeft,\n  trimPathRight,\n} from './path'\nimport type { Segment } from './path'\nimport type { RouteLike } from './route'\n\nconst REQUIRED_PARAM_BASE_SCORE = 0.5\nconst OPTIONAL_PARAM_BASE_SCORE = 0.4\nconst WILDCARD_PARAM_BASE_SCORE = 0.25\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 0.75\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 if (segment.type === SEGMENT_TYPE_WILDCARD) {\n        baseScore = WILDCARD_PARAM_BASE_SCORE\n      }\n\n      if (baseScore) {\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(segment, baseScore + 0.2)\n          }\n        }\n\n        return handleParam(segment, baseScore)\n      }\n\n      return 1\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\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_PARAM","SEGMENT_TYPE_OPTIONAL_PARAM","SEGMENT_TYPE_WILDCARD","i","SEGMENT_TYPE_PATHNAME","trimPathRight"],"mappings":"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"}
+{"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\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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"}

package/dist/esm/process-route-tree.js

@@ -1,8 +1,11 @@
 import invariant from "tiny-invariant";
-import { trimPathRight, trimPathLeft, parsePathname, SEGMENT_TYPE_PARAM, SEGMENT_TYPE_OPTIONAL_PARAM, SEGMENT_TYPE_WILDCARD, SEGMENT_TYPE_PATHNAME } from "./path.js";
+import { trimPathRight, trimPathLeft, parsePathname, SEGMENT_TYPE_PATHNAME, SEGMENT_TYPE_PARAM, SEGMENT_TYPE_OPTIONAL_PARAM } from "./path.js";
+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;
@@ -38,7 +41,10 @@ function sortRoutes(routes) {
     let hasStaticAfter = false;
     const scores = parsed.map((segment, index) => {
       if (segment.value === "/") {
-        return 0.75;
+        return SLASH_SCORE;
+      }
+      if (segment.type === SEGMENT_TYPE_PATHNAME) {
+        return STATIC_SEGMENT_SCORE;
       }
       let baseScore = void 0;
       if (segment.type === SEGMENT_TYPE_PARAM) {
@@ -46,20 +52,20 @@ function sortRoutes(routes) {
       } else if (segment.type === SEGMENT_TYPE_OPTIONAL_PARAM) {
         baseScore = OPTIONAL_PARAM_BASE_SCORE;
         optionalParamCount++;
-      } else if (segment.type === SEGMENT_TYPE_WILDCARD) {
+      } else {
         baseScore = WILDCARD_PARAM_BASE_SCORE;
       }
-      if (baseScore) {
-        for (let i2 = index + 1; i2 < parsed.length; i2++) {
-          const nextSegment = parsed[i2];
-          if (nextSegment.type === SEGMENT_TYPE_PATHNAME && nextSegment.value !== "/") {
-            hasStaticAfter = true;
-            return handleParam(segment, baseScore + 0.2);
-          }
+      for (let i2 = index + 1; i2 < parsed.length; i2++) {
+        const nextSegment = parsed[i2];
+        if (nextSegment.type === SEGMENT_TYPE_PATHNAME && nextSegment.value !== "/") {
+          hasStaticAfter = true;
+          return handleParam(
+            segment,
+            baseScore + STATIC_AFTER_DYNAMIC_BONUS_SCORE
+          );
         }
-        return handleParam(segment, baseScore);
       }
-      return 1;
+      return handleParam(segment, baseScore);
     });
     scoredRoutes.push({
       child: d,

package/dist/esm/process-route-tree.js.map

@@ -1 +1 @@
-{"version":3,"file":"process-route-tree.js","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  SEGMENT_TYPE_WILDCARD,\n  parsePathname,\n  trimPathLeft,\n  trimPathRight,\n} from './path'\nimport type { Segment } from './path'\nimport type { RouteLike } from './route'\n\nconst REQUIRED_PARAM_BASE_SCORE = 0.5\nconst OPTIONAL_PARAM_BASE_SCORE = 0.4\nconst WILDCARD_PARAM_BASE_SCORE = 0.25\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 0.75\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 if (segment.type === SEGMENT_TYPE_WILDCARD) {\n        baseScore = WILDCARD_PARAM_BASE_SCORE\n      }\n\n      if (baseScore) {\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(segment, baseScore + 0.2)\n          }\n        }\n\n        return handleParam(segment, baseScore)\n      }\n\n      return 1\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\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":["i"],"mappings":"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"}
+{"version":3,"file":"process-route-tree.js","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\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":["i"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/router-core",
-  "version": "1.131.39",
+  "version": "1.131.40",
   "description": "Modern and scalable routing for React applications",
   "author": "Tanner Linsley",
   "license": "MIT",

package/src/process-route-tree.ts

@@ -3,7 +3,6 @@ import {
   SEGMENT_TYPE_OPTIONAL_PARAM,
   SEGMENT_TYPE_PARAM,
   SEGMENT_TYPE_PATHNAME,
-  SEGMENT_TYPE_WILDCARD,
   parsePathname,
   trimPathLeft,
   trimPathRight,
@@ -11,9 +10,12 @@ import {
 import type { Segment } from './path'
 import type { RouteLike } from './route'
 
+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
@@ -81,7 +83,11 @@ function sortRoutes<TRouteLike extends RouteLike>(
     let hasStaticAfter = false
     const scores = parsed.map((segment, index) => {
       if (segment.value === '/') {
-        return 0.75
+        return SLASH_SCORE
+      }
+
+      if (segment.type === SEGMENT_TYPE_PATHNAME) {
+        return STATIC_SEGMENT_SCORE
       }
 
       let baseScore: number | undefined = undefined
@@ -90,29 +96,28 @@ function sortRoutes<TRouteLike extends RouteLike>(
       } else if (segment.type === SEGMENT_TYPE_OPTIONAL_PARAM) {
         baseScore = OPTIONAL_PARAM_BASE_SCORE
         optionalParamCount++
-      } else if (segment.type === SEGMENT_TYPE_WILDCARD) {
+      } else {
         baseScore = WILDCARD_PARAM_BASE_SCORE
       }
 
-      if (baseScore) {
-        // if there is any static segment (that is not an index) after a required / optional param,
-        // we will boost this param so it ranks higher than a required/optional param without a static segment after it
-        // JUST FOR SORTING, NOT FOR MATCHING
-        for (let i = index + 1; i < parsed.length; i++) {
-          const nextSegment = parsed[i]!
-          if (
-            nextSegment.type === SEGMENT_TYPE_PATHNAME &&
-            nextSegment.value !== '/'
-          ) {
-            hasStaticAfter = true
-            return handleParam(segment, baseScore + 0.2)
-          }
+      // if there is any static segment (that is not an index) after a required / optional param,
+      // we will boost this param so it ranks higher than a required/optional param without a static segment after it
+      // JUST FOR SORTING, NOT FOR MATCHING
+      for (let i = index + 1; i < parsed.length; i++) {
+        const nextSegment = parsed[i]!
+        if (
+          nextSegment.type === SEGMENT_TYPE_PATHNAME &&
+          nextSegment.value !== '/'
+        ) {
+          hasStaticAfter = true
+          return handleParam(
+            segment,
+            baseScore + STATIC_AFTER_DYNAMIC_BONUS_SCORE,
+          )
         }
-
-        return handleParam(segment, baseScore)
       }
 
-      return 1
+      return handleParam(segment, baseScore)
     })
 
     scoredRoutes.push({