@tanstack/router-core 1.145.11 → 1.146.1

package/dist/cjs/router.d.cts

@@ -460,8 +460,12 @@ export type InvalidateFn<TRouter extends AnyRouter> = (opts?: {
 export type ParseLocationFn<TRouteTree extends AnyRoute> = (locationToParse: HistoryLocation, previousLocation?: ParsedLocation<FullSearchSchema<TRouteTree>>) => ParsedLocation<FullSearchSchema<TRouteTree>>;
 export type GetMatchRoutesFn = (pathname: string) => {
     matchedRoutes: ReadonlyArray<AnyRoute>;
+    /** exhaustive params, still in their string form */
     routeParams: Record<string, string>;
+    /** partial params, parsed from routeParams during matching */
+    parsedParams: Record<string, unknown> | undefined;
     foundRoute: AnyRoute | undefined;
+    parseError?: unknown;
 };
 export type EmitFn = (routerEvent: RouterEvent) => void;
 export type LoadFn = (opts?: {
@@ -693,5 +697,6 @@ export declare function getMatchedRoutes<TRouteLike extends RouteLike>({ pathnam
     matchedRoutes: readonly TRouteLike[];
     routeParams: Record<string, string>;
     foundRoute: TRouteLike | undefined;
+    parsedParams: Record<string, unknown> | undefined;
 };
 export {};

package/dist/esm/new-process-route-tree.d.ts

@@ -4,6 +4,7 @@ export declare const SEGMENT_TYPE_PARAM = 1;
 export declare const SEGMENT_TYPE_WILDCARD = 2;
 export declare const SEGMENT_TYPE_OPTIONAL_PARAM = 3;
 declare const SEGMENT_TYPE_INDEX = 4;
+declare const SEGMENT_TYPE_PATHLESS = 5;
 /**
  * All the kinds of segments that can be present in a route path.
  */
@@ -11,7 +12,7 @@ export type SegmentKind = typeof SEGMENT_TYPE_PATHNAME | typeof SEGMENT_TYPE_PAR
 /**
  * All the kinds of segments that can be present in the segment tree.
  */
-type ExtendedSegmentKind = SegmentKind | typeof SEGMENT_TYPE_INDEX;
+type ExtendedSegmentKind = SegmentKind | typeof SEGMENT_TYPE_INDEX | typeof SEGMENT_TYPE_PATHLESS;
 type ParsedSegment = Uint16Array & {
     /** segment type (0 = pathname, 1 = param, 2 = wildcard, 3 = optional param) */
     0: SegmentKind;
@@ -50,7 +51,7 @@ start: number,
 /** A Uint16Array (length: 6) to populate with the parsed segment data. */
 output?: Uint16Array): ParsedSegment;
 type StaticSegmentNode<T extends RouteLike> = SegmentNode<T> & {
-    kind: typeof SEGMENT_TYPE_PATHNAME | typeof SEGMENT_TYPE_INDEX;
+    kind: typeof SEGMENT_TYPE_PATHNAME | typeof SEGMENT_TYPE_PATHLESS | typeof SEGMENT_TYPE_INDEX;
 };
 type DynamicSegmentNode<T extends RouteLike> = SegmentNode<T> & {
     kind: typeof SEGMENT_TYPE_PARAM | typeof SEGMENT_TYPE_WILDCARD | typeof SEGMENT_TYPE_OPTIONAL_PARAM;
@@ -61,6 +62,7 @@ type DynamicSegmentNode<T extends RouteLike> = SegmentNode<T> & {
 type AnySegmentNode<T extends RouteLike> = StaticSegmentNode<T> | DynamicSegmentNode<T>;
 type SegmentNode<T extends RouteLike> = {
     kind: ExtendedSegmentKind;
+    pathless: Array<StaticSegmentNode<T>> | null;
     /** Exact index segment (highest priority) */
     index: StaticSegmentNode<T> | null;
     /** Static segments (2nd priority) */
@@ -79,14 +81,28 @@ type SegmentNode<T extends RouteLike> = {
     fullPath: string;
     parent: AnySegmentNode<T> | null;
     depth: number;
+    /** route.options.params.parse function, set on the last node of the route */
+    parse: null | ((params: Record<string, string>) => any);
+    /** options.skipRouteOnParseError.params ?? false */
+    skipOnParamError: boolean;
+    /** options.skipRouteOnParseError.priority ?? 0 */
+    parsingPriority: number;
 };
 type RouteLike = {
+    id?: string;
     path?: string;
     children?: Array<RouteLike>;
     parentRoute?: RouteLike;
     isRoot?: boolean;
     options?: {
+        skipRouteOnParseError?: {
+            params?: boolean;
+            priority?: number;
+        };
         caseSensitive?: boolean;
+        params?: {
+            parse?: (params: Record<string, string>) => any;
+        };
     };
 } & ({
     fullPath: string;
@@ -127,7 +143,16 @@ path: string,
 /** The `processedTree` returned by the initial `processRouteTree` call. */
 processedTree: ProcessedTree<any, T, any>): {
     route: T;
-    params: Record<string, string>;
+    /**
+     * The raw (unparsed) params extracted from the path.
+     * This will be the exhaustive list of all params defined in the route's path.
+     */
+    rawParams: Record<string, string>;
+    /**
+     * The accumlulated parsed params of each route in the branch that had `skipRouteOnParseError` enabled.
+     * Will not contain all params defined in the route's path. Those w/ a `params.parse` but no `skipRouteOnParseError` will need to be parsed separately.
+     */
+    parsedParams?: Record<string, unknown>;
 } | null;
 /**
  * @deprecated keep until v2 so that `router.matchRoute` can keep not caring about the actual route tree
@@ -138,13 +163,23 @@ export declare function findSingleMatch(from: string, caseSensitive: boolean, fu
     route: {
         from: string;
     };
-    params: Record<string, string>;
+    /**
+     * The raw (unparsed) params extracted from the path.
+     * This will be the exhaustive list of all params defined in the route's path.
+     */
+    rawParams: Record<string, string>;
+    /**
+     * The accumlulated parsed params of each route in the branch that had `skipRouteOnParseError` enabled.
+     * Will not contain all params defined in the route's path. Those w/ a `params.parse` but no `skipRouteOnParseError` will need to be parsed separately.
+     */
+    parsedParams?: Record<string, unknown>;
 } | null;
 type RouteMatch<T extends Extract<RouteLike, {
     fullPath: string;
 }>> = {
     route: T;
-    params: Record<string, string>;
+    rawParams: Record<string, string>;
+    parsedParams?: Record<string, unknown>;
     branch: ReadonlyArray<T>;
 };
 export declare function findRouteMatch<T extends Extract<RouteLike, {
@@ -182,6 +217,15 @@ initRoute?: (route: TRouteLike, index: number) => void): {
 };
 declare function findMatch<T extends RouteLike>(path: string, segmentTree: AnySegmentNode<T>, fuzzy?: boolean): {
     route: T;
-    params: Record<string, string>;
+    /**
+     * The raw (unparsed) params extracted from the path.
+     * This will be the exhaustive list of all params defined in the route's path.
+     */
+    rawParams: Record<string, string>;
+    /**
+     * The accumlulated parsed params of each route in the branch that had `skipRouteOnParseError` enabled.
+     * Will not contain all params defined in the route's path. Those w/ a `params.parse` but no `skipRouteOnParseError` will need to be parsed separately.
+     */
+    parsedParams?: Record<string, unknown>;
 } | null;
 export {};

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

@@ -6,6 +6,7 @@ const SEGMENT_TYPE_PARAM = 1;
 const SEGMENT_TYPE_WILDCARD = 2;
 const SEGMENT_TYPE_OPTIONAL_PARAM = 3;
 const SEGMENT_TYPE_INDEX = 4;
+const SEGMENT_TYPE_PATHLESS = 5;
 const PARAM_W_CURLY_BRACES_RE = /^([^{]*)\{\$([a-zA-Z_$][a-zA-Z0-9_$]*)\}([^}]*)$/;
 const OPTIONAL_PARAM_W_CURLY_BRACES_RE = /^([^{]*)\{-\$([a-zA-Z_$][a-zA-Z0-9_$]*)\}([^}]*)$/;
 const WILDCARD_W_CURLY_BRACES_RE = /^([^{]*)\{\$\}([^}]*)$/;
@@ -96,6 +97,7 @@ function parseSegments(defaultCaseSensitive, data, route, start, node, depth, on
     const path = route.fullPath ?? route.from;
     const length = path.length;
     const caseSensitive = route.options?.caseSensitive ?? defaultCaseSensitive;
+    const skipOnParamError = !!(route.options?.params?.parse && route.options?.skipRouteOnParseError?.params);
     while (cursor < length) {
       const segment = parseSegment(path, cursor, data);
       let nextNode;
@@ -145,8 +147,8 @@ function parseSegments(defaultCaseSensitive, data, route, start, node, depth, on
           const actuallyCaseSensitive = caseSensitive && !!(prefix_raw || suffix_raw);
           const prefix = !prefix_raw ? void 0 : actuallyCaseSensitive ? prefix_raw : prefix_raw.toLowerCase();
           const suffix = !suffix_raw ? void 0 : actuallyCaseSensitive ? suffix_raw : suffix_raw.toLowerCase();
-          const existingNode = node.dynamic?.find(
-            (s) => s.caseSensitive === actuallyCaseSensitive && s.prefix === prefix && s.suffix === suffix
+          const existingNode = !skipOnParamError && node.dynamic?.find(
+            (s) => !s.skipOnParamError && s.caseSensitive === actuallyCaseSensitive && s.prefix === prefix && s.suffix === suffix
           );
           if (existingNode) {
             nextNode = existingNode;
@@ -172,8 +174,8 @@ function parseSegments(defaultCaseSensitive, data, route, start, node, depth, on
           const actuallyCaseSensitive = caseSensitive && !!(prefix_raw || suffix_raw);
           const prefix = !prefix_raw ? void 0 : actuallyCaseSensitive ? prefix_raw : prefix_raw.toLowerCase();
           const suffix = !suffix_raw ? void 0 : actuallyCaseSensitive ? suffix_raw : suffix_raw.toLowerCase();
-          const existingNode = node.optional?.find(
-            (s) => s.caseSensitive === actuallyCaseSensitive && s.prefix === prefix && s.suffix === suffix
+          const existingNode = !skipOnParamError && node.optional?.find(
+            (s) => !s.skipOnParamError && s.caseSensitive === actuallyCaseSensitive && s.prefix === prefix && s.suffix === suffix
           );
           if (existingNode) {
             nextNode = existingNode;
@@ -215,6 +217,18 @@ function parseSegments(defaultCaseSensitive, data, route, start, node, depth, on
       }
       node = nextNode;
     }
+    if (skipOnParamError && route.children && !route.isRoot && route.id && route.id.charCodeAt(route.id.lastIndexOf("/") + 1) === 95) {
+      const pathlessNode = createStaticNode(
+        route.fullPath ?? route.from
+      );
+      pathlessNode.kind = SEGMENT_TYPE_PATHLESS;
+      pathlessNode.parent = node;
+      depth++;
+      pathlessNode.depth = depth;
+      node.pathless ??= [];
+      node.pathless.push(pathlessNode);
+      node = pathlessNode;
+    }
     const isLeaf = (route.path || !route.children) && !route.isRoot;
     if (isLeaf && path.endsWith("/")) {
       const indexNode = createStaticNode(
@@ -227,6 +241,9 @@ function parseSegments(defaultCaseSensitive, data, route, start, node, depth, on
       node.index = indexNode;
       node = indexNode;
     }
+    node.parse = route.options?.params?.parse ?? null;
+    node.skipOnParamError = skipOnParamError;
+    node.parsingPriority = route.options?.skipRouteOnParseError?.priority ?? 0;
     if (isLeaf && !node.route) {
       node.route = route;
       node.fullPath = route.fullPath ?? route.from;
@@ -246,6 +263,10 @@ function parseSegments(defaultCaseSensitive, data, route, start, node, depth, on
     }
 }
 function sortDynamic(a, b) {
+  if (a.skipOnParamError && !b.skipOnParamError) return -1;
+  if (!a.skipOnParamError && b.skipOnParamError) return 1;
+  if (a.skipOnParamError && b.skipOnParamError && (a.parsingPriority || b.parsingPriority))
+    return b.parsingPriority - a.parsingPriority;
   if (a.prefix && b.prefix && a.prefix !== b.prefix) {
     if (a.prefix.startsWith(b.prefix)) return -1;
     if (b.prefix.startsWith(a.prefix)) return 1;
@@ -263,6 +284,11 @@ function sortDynamic(a, b) {
   return 0;
 }
 function sortTreeNodes(node) {
+  if (node.pathless) {
+    for (const child of node.pathless) {
+      sortTreeNodes(child);
+    }
+  }
   if (node.static) {
     for (const child of node.static.values()) {
       sortTreeNodes(child);
@@ -296,6 +322,7 @@ function createStaticNode(fullPath) {
   return {
     kind: SEGMENT_TYPE_PATHNAME,
     depth: 0,
+    pathless: null,
     index: null,
     static: null,
     staticInsensitive: null,
@@ -304,13 +331,17 @@ function createStaticNode(fullPath) {
     wildcard: null,
     route: null,
     fullPath,
-    parent: null
+    parent: null,
+    parse: null,
+    skipOnParamError: false,
+    parsingPriority: 0
   };
 }
 function createDynamicNode(kind, fullPath, caseSensitive, prefix, suffix) {
   return {
     kind,
     depth: 0,
+    pathless: null,
     index: null,
     static: null,
     staticInsensitive: null,
@@ -320,6 +351,9 @@ function createDynamicNode(kind, fullPath, caseSensitive, prefix, suffix) {
     route: null,
     fullPath,
     parent: null,
+    parse: null,
+    skipOnParamError: false,
+    parsingPriority: 0,
     caseSensitive,
     prefix,
     suffix
@@ -412,19 +446,21 @@ function findMatch(path, segmentTree, fuzzy = false) {
   const parts = path.split("/");
   const leaf = getNodeMatch(path, parts, segmentTree, fuzzy);
   if (!leaf) return null;
-  const params = extractParams(path, parts, leaf);
-  if ("**" in leaf) params["**"] = leaf["**"];
-  const route = leaf.node.route;
+  const [rawParams] = extractParams(path, parts, leaf);
   return {
-    route,
-    params
+    route: leaf.node.route,
+    rawParams,
+    parsedParams: leaf.parsedParams
   };
 }
 function extractParams(path, parts, leaf) {
   const list = buildBranch(leaf.node);
   let nodeParts = null;
-  const params = {};
-  for (let partIndex = 0, nodeIndex = 0, pathIndex = 0; nodeIndex < list.length; partIndex++, nodeIndex++, pathIndex++) {
+  const rawParams = {};
+  let partIndex = leaf.extract?.part ?? 0;
+  let nodeIndex = leaf.extract?.node ?? 0;
+  let pathIndex = leaf.extract?.path ?? 0;
+  for (; nodeIndex < list.length; partIndex++, nodeIndex++, pathIndex++) {
     const node = list[nodeIndex];
     const part = parts[partIndex];
     const currentPathIndex = pathIndex;
@@ -441,10 +477,10 @@ function extractParams(path, parts, leaf) {
           nodePart.length - sufLength - 1
         );
         const value = part.substring(preLength, part.length - sufLength);
-        params[name] = decodeURIComponent(value);
+        rawParams[name] = decodeURIComponent(value);
       } else {
         const name = nodePart.substring(1);
-        params[name] = decodeURIComponent(part);
+        rawParams[name] = decodeURIComponent(part);
       }
     } else if (node.kind === SEGMENT_TYPE_OPTIONAL_PARAM) {
       if (leaf.skipped & 1 << nodeIndex) {
@@ -460,7 +496,7 @@ function extractParams(path, parts, leaf) {
         nodePart.length - sufLength - 1
       );
       const value = node.suffix || node.prefix ? part.substring(preLength, part.length - sufLength) : part;
-      if (value) params[name] = decodeURIComponent(value);
+      if (value) rawParams[name] = decodeURIComponent(value);
     } else if (node.kind === SEGMENT_TYPE_WILDCARD) {
       const n = node;
       const value = path.substring(
@@ -468,12 +504,13 @@ function extractParams(path, parts, leaf) {
         path.length - (n.suffix?.length ?? 0)
       );
       const splat = decodeURIComponent(value);
-      params["*"] = splat;
-      params._splat = splat;
+      rawParams["*"] = splat;
+      rawParams._splat = splat;
       break;
     }
   }
-  return params;
+  if (leaf.rawParams) Object.assign(rawParams, leaf.rawParams);
+  return [rawParams, { part: partIndex, node: nodeIndex, path: pathIndex }];
 }
 function buildRouteBranch(route) {
   const list = [route];
@@ -514,7 +551,15 @@ function getNodeMatch(path, parts, segmentTree, fuzzy) {
   let bestMatch = null;
   while (stack.length) {
     const frame = stack.pop();
-    let { node, index, skipped, depth, statics, dynamics, optionals } = frame;
+    const { node, index, skipped, depth, statics, dynamics, optionals } = frame;
+    let { extract, rawParams, parsedParams } = frame;
+    if (node.skipOnParamError) {
+      const result = validateMatchParams(path, parts, frame);
+      if (!result) continue;
+      rawParams = frame.rawParams;
+      extract = frame.extract;
+      parsedParams = frame.parsedParams;
+    }
     if (fuzzy && node.route && node.kind !== SEGMENT_TYPE_INDEX && isFrameMoreSpecific(bestFuzzy, frame)) {
       bestFuzzy = frame;
     }
@@ -523,7 +568,8 @@ function getNodeMatch(path, parts, segmentTree, fuzzy) {
       if (node.route && !pathIsIndex && isFrameMoreSpecific(bestMatch, frame)) {
         bestMatch = frame;
       }
-      if (!node.optional && !node.wildcard && !node.index) continue;
+      if (!node.optional && !node.wildcard && !node.index && !node.pathless)
+        continue;
     }
     const part = isBeyondPath ? void 0 : parts[index];
     let lowerPart;
@@ -535,8 +581,15 @@ function getNodeMatch(path, parts, segmentTree, fuzzy) {
         depth: depth + 1,
         statics,
         dynamics,
-        optionals
+        optionals,
+        extract,
+        rawParams,
+        parsedParams
       };
+      if (node.index.skipOnParamError) {
+        const result = validateMatchParams(path, parts, indexFrame);
+        if (!result) continue;
+      }
       if (statics === partsLength && !dynamics && !optionals && !skipped) {
         return indexFrame;
       }
@@ -558,15 +611,23 @@ function getNodeMatch(path, parts, segmentTree, fuzzy) {
           const casePart = segment.caseSensitive ? end : end.toLowerCase();
           if (casePart !== suffix) continue;
         }
-        wildcardMatch = {
+        const frame2 = {
           node: segment,
           index: partsLength,
           skipped,
           depth,
           statics,
           dynamics,
-          optionals
+          optionals,
+          extract,
+          rawParams,
+          parsedParams
         };
+        if (segment.skipOnParamError) {
+          const result = validateMatchParams(path, parts, frame2);
+          if (!result) continue;
+        }
+        wildcardMatch = frame2;
         break;
       }
     }
@@ -582,7 +643,10 @@ function getNodeMatch(path, parts, segmentTree, fuzzy) {
           depth: nextDepth,
           statics,
           dynamics,
-          optionals
+          optionals,
+          extract,
+          rawParams,
+          parsedParams
         });
       }
       if (!isBeyondPath) {
@@ -601,7 +665,10 @@ function getNodeMatch(path, parts, segmentTree, fuzzy) {
             depth: nextDepth,
             statics,
             dynamics,
-            optionals: optionals + 1
+            optionals: optionals + 1,
+            extract,
+            rawParams,
+            parsedParams
           });
         }
       }
@@ -622,7 +689,10 @@ function getNodeMatch(path, parts, segmentTree, fuzzy) {
           depth: depth + 1,
           statics,
           dynamics: dynamics + 1,
-          optionals
+          optionals,
+          extract,
+          rawParams,
+          parsedParams
         });
       }
     }
@@ -638,7 +708,10 @@ function getNodeMatch(path, parts, segmentTree, fuzzy) {
           depth: depth + 1,
           statics: statics + 1,
           dynamics,
-          optionals
+          optionals,
+          extract,
+          rawParams,
+          parsedParams
         });
       }
     }
@@ -652,7 +725,28 @@ function getNodeMatch(path, parts, segmentTree, fuzzy) {
           depth: depth + 1,
           statics: statics + 1,
           dynamics,
-          optionals
+          optionals,
+          extract,
+          rawParams,
+          parsedParams
+        });
+      }
+    }
+    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,
+          extract,
+          rawParams,
+          parsedParams
         });
       }
     }
@@ -668,14 +762,24 @@ function getNodeMatch(path, parts, segmentTree, fuzzy) {
       sliceIndex += parts[i].length;
     }
     const splat = sliceIndex === path.length ? "/" : path.slice(sliceIndex);
-    return {
-      node: bestFuzzy.node,
-      skipped: bestFuzzy.skipped,
-      "**": decodeURIComponent(splat)
-    };
+    bestFuzzy.rawParams ??= {};
+    bestFuzzy.rawParams["**"] = decodeURIComponent(splat);
+    return bestFuzzy;
   }
   return null;
 }
+function validateMatchParams(path, parts, frame) {
+  try {
+    const [rawParams, state] = extractParams(path, parts, frame);
+    frame.rawParams = rawParams;
+    frame.extract = state;
+    const parsed = frame.node.parse(rawParams);
+    frame.parsedParams = Object.assign({}, frame.parsedParams, parsed);
+    return true;
+  } catch {
+    return null;
+  }
+}
 function isFrameMoreSpecific(prev, next) {
   if (!prev) return true;
   return next.statics > prev.statics || next.statics === prev.statics && (next.dynamics > prev.dynamics || next.dynamics === prev.dynamics && (next.optionals > prev.optionals || next.optionals === prev.optionals && ((next.node.kind === SEGMENT_TYPE_INDEX) > (prev.node.kind === SEGMENT_TYPE_INDEX) || next.node.kind === SEGMENT_TYPE_INDEX === (prev.node.kind === SEGMENT_TYPE_INDEX) && next.depth > prev.depth)));