@tanstack/react-router 1.89.2 → 1.91.0

package/src/link.tsx

@@ -35,6 +35,7 @@ import type {
 } from './router'
 import type {
   Constrain,
+  ConstrainLiteral,
   Expand,
   MakeDifferenceOptional,
   NoInfer,
@@ -45,96 +46,55 @@ import type {
 } from './utils'
 import type { ReactNode } from 'react'
 
-export type CleanPath<T extends string> = T extends `${infer L}//${infer R}`
-  ? CleanPath<`${CleanPath<L>}/${CleanPath<R>}`>
-  : T extends `${infer L}//`
-    ? `${CleanPath<L>}/`
-    : T extends `//${infer L}`
-      ? `/${CleanPath<L>}`
-      : T
-
-export type Split<TValue, TIncludeTrailingSlash = true> = TValue extends unknown
-  ? string extends TValue
-    ? Array<string>
-    : TValue extends string
-      ? CleanPath<TValue> extends ''
-        ? []
-        : TIncludeTrailingSlash extends true
-          ? CleanPath<TValue> extends `${infer T}/`
-            ? [...Split<T>, '/']
-            : CleanPath<TValue> extends `/${infer U}`
-              ? Split<U>
-              : CleanPath<TValue> extends `${infer T}/${infer U}`
-                ? [...Split<T>, ...Split<U>]
-                : [TValue]
-          : CleanPath<TValue> extends `${infer T}/${infer U}`
-            ? [...Split<T>, ...Split<U>]
-            : TValue extends string
-              ? [TValue]
-              : never
-      : never
-  : never
-
-export type ParsePathParams<
-  T extends string,
-  TAcc = never,
-> = T extends `${string}$${string}`
-  ? T extends `${string}$${infer TPossiblyParam}`
-    ? TPossiblyParam extends `${string}/${string}`
-      ? TPossiblyParam extends `${infer TParam}/${infer TRest}`
-        ? ParsePathParams<TRest, TParam extends '' ? TAcc : TParam | TAcc>
-        : never
-      : TPossiblyParam extends ''
-        ? TAcc
-        : TPossiblyParam | TAcc
+export type ParsePathParams<T extends string, TAcc = never> = T &
+  `${string}$${string}` extends never
+  ? TAcc
+  : T extends `${string}$${infer TPossiblyParam}`
+    ? TPossiblyParam extends ''
+      ? TAcc
+      : TPossiblyParam & `${string}/${string}` extends never
+        ? TPossiblyParam | TAcc
+        : TPossiblyParam extends `${infer TParam}/${infer TRest}`
+          ? ParsePathParams<TRest, TParam extends '' ? TAcc : TParam | TAcc>
+          : never
     : TAcc
-  : TAcc
-
-export type Join<T, TDelimiter extends string = '/'> = T extends []
-  ? ''
-  : T extends [infer L extends string]
-    ? L
-    : T extends [
-          infer L extends string,
-          ...infer Tail extends [...Array<string>],
-        ]
-      ? CleanPath<`${L}${TDelimiter}${Join<Tail>}`>
-      : never
 
-export type Last<T extends Array<any>> = T extends [...infer _, infer L]
-  ? L
-  : never
+export type AddTrailingSlash<T> = T & `${string}/` extends never
+  ? `${T & string}/`
+  : T
 
-export type AddTrailingSlash<T> = T extends `${string}/` ? T : `${T & string}/`
+export type RemoveTrailingSlashes<T> = T & `${string}/` extends never
+  ? T
+  : T extends `${infer R}/`
+    ? R
+    : T
 
-export type RemoveTrailingSlashes<T> = T extends `${infer R}/` ? R : T
+export type AddLeadingSlash<T> = T & `/${string}` extends never
+  ? `/${T & string}`
+  : T
 
-export type RemoveLeadingSlashes<T> = T extends `/${infer R}` ? R : T
+export type RemoveLeadingSlashes<T> = T & `/${string}` extends never
+  ? T
+  : T extends `/${infer R}`
+    ? R
+    : T
 
-export type ResolvePaths<TRouter extends AnyRouter, TSearchPath> =
-  RouteByPath<
-    TRouter['routeTree'],
-    RemoveTrailingSlashes<TSearchPath>
-  > extends never
-    ? RouteToPath<TRouter, TRouter['routeTree']>
-    : RouteToPath<
-        TRouter,
-        RouteByPath<TRouter['routeTree'], RemoveTrailingSlashes<TSearchPath>>
-      >
+export type FindDescendantPaths<
+  TRouter extends AnyRouter,
+  TPrefix extends string,
+> = `${TPrefix}${string}` & RouteToPath<TRouter>
 
 export type SearchPaths<
   TRouter extends AnyRouter,
-  TSearchPath extends string,
-  TPaths = ResolvePaths<TRouter, TSearchPath>,
-  TPrefix extends string = `${RemoveTrailingSlashes<TSearchPath>}/`,
-  TFilteredPaths = TPaths & `${TPrefix}${string}`,
-> = TFilteredPaths extends `${TPrefix}${infer TRest}` ? TRest : never
+  TPrefix extends string,
+  TPaths = FindDescendantPaths<TRouter, TPrefix>,
+> = TPaths extends `${TPrefix}${infer TRest}` ? TRest : never
 
 export type SearchRelativePathAutoComplete<
   TRouter extends AnyRouter,
   TTo extends string,
   TSearchPath extends string,
-> = `${TTo}/${SearchPaths<TRouter, TSearchPath>}`
+> = `${TTo}${SearchPaths<TRouter, TSearchPath>}`
 
 export type RelativeToParentPathAutoComplete<
   TRouter extends AnyRouter,
@@ -153,7 +113,9 @@ export type RelativeToCurrentPathAutoComplete<
   TRouter extends AnyRouter,
   TFrom extends string,
   TTo extends string,
-  TResolvedPath extends string = ResolveRelativePath<TFrom, TTo>,
+  TResolvedPath extends string = RemoveTrailingSlashes<
+    ResolveRelativePath<TFrom, TTo>
+  >,
 > =
   | SearchRelativePathAutoComplete<TRouter, TTo, TResolvedPath>
   | CurrentPath<TrailingSlashOptionByRouter<TRouter>>
@@ -166,7 +128,7 @@ export type AbsolutePathAutoComplete<
       ? CurrentPath<TrailingSlashOptionByRouter<TRouter>>
       : TFrom extends `/`
         ? never
-        : SearchPaths<TRouter, TFrom> extends ''
+        : FindDescendantPaths<TRouter, TFrom> extends never
           ? never
           : CurrentPath<TrailingSlashOptionByRouter<TRouter>>)
   | (string extends TFrom
@@ -174,7 +136,7 @@ export type AbsolutePathAutoComplete<
       : TFrom extends `/`
         ? never
         : ParentPath<TrailingSlashOptionByRouter<TRouter>>)
-  | RouteToPath<TRouter, TRouter['routeTree']>
+  | RouteToPath<TRouter>
   | (TFrom extends '/'
       ? never
       : string extends TFrom
@@ -185,21 +147,23 @@ export type RelativeToPathAutoComplete<
   TRouter extends AnyRouter,
   TFrom extends string,
   TTo extends string,
-> = string extends TFrom
-  ? AbsolutePathAutoComplete<TRouter, TFrom>
-  : TTo extends `..${string}`
-    ? RelativeToParentPathAutoComplete<
-        TRouter,
-        TFrom,
-        RemoveTrailingSlashes<TTo>
-      >
-    : TTo extends `.${string}`
-      ? RelativeToCurrentPathAutoComplete<
+> = string extends TTo
+  ? string
+  : string extends TFrom
+    ? AbsolutePathAutoComplete<TRouter, TFrom>
+    : TTo & `..${string}` extends never
+      ? TTo & `.${string}` extends never
+        ? AbsolutePathAutoComplete<TRouter, TFrom>
+        : RelativeToCurrentPathAutoComplete<
+            TRouter,
+            TFrom,
+            RemoveTrailingSlashes<TTo>
+          >
+      : RelativeToParentPathAutoComplete<
           TRouter,
           TFrom,
           RemoveTrailingSlashes<TTo>
         >
-      : AbsolutePathAutoComplete<TRouter, TFrom>
 
 export type NavigateOptions<
   TRouter extends AnyRouter = RegisteredRouter,
@@ -451,33 +415,19 @@ export type ToPathOption<
   TRouter extends AnyRouter = AnyRouter,
   TFrom extends string = string,
   TTo extends string | undefined = string,
-> =
-  | CheckPath<TRouter, TTo, never, TFrom, TTo>
-  | RelativeToPathAutoComplete<
-      TRouter,
-      NoInfer<TFrom> extends string ? NoInfer<TFrom> : '',
-      NoInfer<TTo> & string
-    >
-
-export type CheckFromPath<
-  TRouter extends AnyRouter,
-  TPass,
-  TFail,
+> = ConstrainLiteral<
+  TTo,
+  RelativeToPathAutoComplete<
+    TRouter,
+    NoInfer<TFrom> extends string ? NoInfer<TFrom> : '',
+    NoInfer<TTo> & string
+  >
+>
+
+export type FromPathOption<TRouter extends AnyRouter, TFrom> = ConstrainLiteral<
   TFrom,
-> = string extends TFrom
-  ? TPass
-  : RouteByPath<TRouter['routeTree'], TFrom> extends never
-    ? TFail
-    : TPass
-
-export type FromPathOption<TRouter extends AnyRouter, TFrom> =
-  | CheckFromPath<
-      TRouter,
-      string extends TFrom ? TFrom & {} : TFrom,
-      never,
-      TFrom
-    >
-  | RoutePaths<TRouter['routeTree']>
+  RoutePaths<TRouter['routeTree']>
+>
 
 export interface ActiveOptions {
   exact?: boolean
@@ -524,16 +474,41 @@ export interface LinkOptionsProps {
   disabled?: boolean
 }
 
-export type CheckPath<TRouter extends AnyRouter, TPass, TFail, TFrom, TTo> =
-  string extends ResolveRelativePath<TFrom, TTo>
-    ? TPass
-    : ResolveRelativePath<TFrom, TTo> extends CatchAllPaths<
-          TrailingSlashOptionByRouter<TRouter>
+type JoinPath<TLeft extends string, TRight extends string> = TRight extends ''
+  ? TLeft
+  : TLeft extends ''
+    ? TRight
+    : `${RemoveTrailingSlashes<TLeft>}/${RemoveLeadingSlashes<TRight>}`
+
+type RemoveLastSegment<
+  T extends string,
+  TAcc extends string = '',
+> = T extends `${infer TSegment}/${infer TRest}`
+  ? TRest & `${string}/${string}` extends never
+    ? `${TAcc}${TSegment}`
+    : RemoveLastSegment<TRest, `${TAcc}${TSegment}/`>
+  : TAcc
+
+export type ResolveCurrentPath<TFrom, TTo> = TTo extends '.'
+  ? TFrom
+  : TTo extends './'
+    ? AddTrailingSlash<TFrom>
+    : TTo & `./${string}` extends never
+      ? never
+      : TTo extends `./${infer TRest}`
+        ? ResolveRelativePath<TFrom, TRest>
+        : never
+
+export type ResolveParentPath<TFrom extends string, TTo> = TTo extends '../'
+  ? RemoveLastSegment<TFrom>
+  : TTo & `..${string}` extends never
+    ? never
+    : TTo extends `..${infer ToRest}`
+      ? ResolveRelativePath<
+          RemoveLastSegment<TFrom>,
+          RemoveLeadingSlashes<ToRest>
         >
-      ? TPass
-      : ResolveRoute<TRouter, TFrom, TTo> extends never
-        ? TFail
-        : TPass
+      : never
 
 export type ResolveRelativePath<TFrom, TTo = '.'> = string extends TFrom
   ? TTo
@@ -543,25 +518,13 @@ export type ResolveRelativePath<TFrom, TTo = '.'> = string extends TFrom
       ? TFrom
       : TFrom extends string
         ? TTo extends string
-          ? TTo extends '.'
-            ? TFrom
-            : TTo extends `./`
-              ? Join<[TFrom, '/']>
-              : TTo extends `./${infer TRest}`
-                ? ResolveRelativePath<TFrom, TRest>
-                : TTo extends `/${infer TRest}`
-                  ? TTo
-                  : Split<TTo> extends ['..', ...infer ToRest]
-                    ? Split<TFrom> extends [...infer FromRest, infer FromTail]
-                      ? ToRest extends ['/']
-                        ? Join<['/', ...FromRest, '/']>
-                        : ResolveRelativePath<Join<FromRest>, Join<ToRest>>
-                      : never
-                    : Split<TTo> extends ['.', ...infer ToRest]
-                      ? ToRest extends ['/']
-                        ? Join<[TFrom, '/']>
-                        : ResolveRelativePath<TFrom, Join<ToRest>>
-                      : CleanPath<Join<['/', ...Split<TFrom>, ...Split<TTo>]>>
+          ? TTo & `..${string}` extends never
+            ? TTo & `.${string}` extends never
+              ? TTo & `/${string}` extends never
+                ? AddLeadingSlash<JoinPath<TFrom, TTo>>
+                : TTo
+              : ResolveCurrentPath<TFrom, TTo>
+            : ResolveParentPath<TFrom, TTo>
           : never
         : never
 

package/src/route.ts

@@ -26,7 +26,13 @@ import type { NavigateOptions, ParsePathParams, ToMaskOptions } from './link'
 import type { ParsedLocation } from './location'
 import type { RouteById, RouteIds, RoutePaths } from './routeInfo'
 import type { AnyRouter, RegisteredRouter, Router } from './router'
-import type { Assign, Constrain, Expand, NoInfer } from './utils'
+import type {
+  Assign,
+  Constrain,
+  ConstrainLiteral,
+  Expand,
+  NoInfer,
+} from './utils'
 import type { BuildLocationFn, NavigateFn } from './RouterProvider'
 import type { NotFoundError } from './not-found'
 import type { LazyRoute } from './fileRoute'
@@ -112,11 +118,12 @@ export type RouteOptions<
     NoInfer<TBeforeLoadFn>
   >
 
-export type ParseSplatParams<TPath extends string> = TPath extends `${string}$`
-  ? '_splat'
-  : TPath extends `${string}$/${string}`
-    ? '_splat'
-    : never
+export type ParseSplatParams<TPath extends string> = TPath &
+  `${string}$` extends never
+  ? TPath & `${string}$/${string}` extends never
+    ? never
+    : '_splat'
+  : '_splat'
 
 export interface SplatParams {
   _splat?: string
@@ -794,7 +801,7 @@ export type RouteTypesById<TRouter extends AnyRouter, TId> = RouteById<
 >['types']
 
 export function getRouteApi<TId, TRouter extends AnyRouter = RegisteredRouter>(
-  id: Constrain<TId, RouteIds<TRouter['routeTree']>>,
+  id: ConstrainLiteral<TId, RouteIds<TRouter['routeTree']>>,
 ) {
   return new RouteApi<TId, TRouter>({ id })
 }

package/src/routeInfo.ts

@@ -114,9 +114,7 @@ export type RouteToPathNeverTrailingSlash<TRoute extends AnyRoute> =
   TRoute['path'] extends '/'
     ? TRoute['fullPath'] extends '/'
       ? TRoute['fullPath']
-      : TRoute['fullPath'] extends `${infer TRest}/`
-        ? TRest
-        : TRoute['fullPath']
+      : RemoveTrailingSlashes<TRoute['fullPath']>
     : TRoute['fullPath']
 
 export type RouteToPathPreserveTrailingSlash<TRoute extends AnyRoute> =
@@ -139,11 +137,9 @@ export type RouteToByRouter<
   TRoute extends AnyRoute,
 > = RouteToPathByTrailingSlashOption<TRoute>[TrailingSlashOptionByRouter<TRouter>]
 
-export type CodeRouteToPath<
-  TRouter extends AnyRouter,
-  TRouteTree extends AnyRoute,
-> =
-  ParseRouteWithoutBranches<TRouteTree> extends infer TRoute extends AnyRoute
+export type CodeRouteToPath<TRouter extends AnyRouter> =
+  ParseRouteWithoutBranches<TRouter['routeTree']> extends infer TRoute extends
+    AnyRoute
     ? TRoute extends any
       ? RouteToByRouter<TRouter, TRoute>
       : never
@@ -159,13 +155,10 @@ export type FileRouteToPath<
     ? AddTrailingSlash<TTo>
     : TTo | AddTrailingSlash<TTo>
 
-export type RouteToPath<
-  TRouter extends AnyRouter,
-  TRouteTree extends AnyRoute,
-> = unknown extends TRouter
+export type RouteToPath<TRouter extends AnyRouter> = unknown extends TRouter
   ? string
   : InferFileRouteTypes<TRouter['routeTree']> extends never
-    ? CodeRouteToPath<TRouter, TRouteTree>
+    ? CodeRouteToPath<TRouter>
     : FileRouteToPath<TRouter>
 
 export type CodeRoutesByToPath<TRouter extends AnyRouter> =

package/src/router.ts

@@ -1058,6 +1058,7 @@ export class Router<
 
   parseLocation = (
     previousLocation?: ParsedLocation<FullSearchSchema<TRouteTree>>,
+    locationToParse?: HistoryLocation,
   ): ParsedLocation<FullSearchSchema<TRouteTree>> => {
     const parse = ({
       pathname,
@@ -1078,7 +1079,7 @@ export class Router<
       }
     }
 
-    const location = parse(this.history.location)
+    const location = parse(locationToParse ?? this.history.location)
 
     const { __tempLocation, __tempKey } = location.state
 
@@ -2552,37 +2553,7 @@ export class Router<
 
                         // Actually run the loader and handle the result
                         try {
-                          if (route._lazyPromise === undefined) {
-                            if (route.lazyFn) {
-                              route._lazyPromise = route
-                                .lazyFn()
-                                .then((lazyRoute) => {
-                                  // explicitly don't copy over the lazy route's id
-                                  const { id: _id, ...options } =
-                                    lazyRoute.options
-                                  Object.assign(route.options, options)
-                                })
-                            } else {
-                              route._lazyPromise = Promise.resolve()
-                            }
-                          }
-
-                          // If for some reason lazy resolves more lazy components...
-                          // We'll wait for that before pre attempt to preload any
-                          // components themselves.
-                          if (route._componentsPromise === undefined) {
-                            route._componentsPromise = route._lazyPromise.then(
-                              () =>
-                                Promise.all(
-                                  componentTypes.map(async (type) => {
-                                    const component = route.options[type]
-                                    if ((component as any)?.preload) {
-                                      await (component as any).preload()
-                                    }
-                                  }),
-                                ),
-                            )
-                          }
+                          this.loadRouteChunk(route)
 
                           updateMatch(matchId, (prev) => ({
                             ...prev,
@@ -2820,6 +2791,37 @@ export class Router<
     this.clearCache({ filter })
   }
 
+  loadRouteChunk = (route: AnyRoute) => {
+    if (route._lazyPromise === undefined) {
+      if (route.lazyFn) {
+        route._lazyPromise = route.lazyFn().then((lazyRoute) => {
+          // explicitly don't copy over the lazy route's id
+          const { id: _id, ...options } = lazyRoute.options
+          Object.assign(route.options, options)
+        })
+      } else {
+        route._lazyPromise = Promise.resolve()
+      }
+    }
+
+    // If for some reason lazy resolves more lazy components...
+    // We'll wait for that before pre attempt to preload any
+    // components themselves.
+    if (route._componentsPromise === undefined) {
+      route._componentsPromise = route._lazyPromise.then(() =>
+        Promise.all(
+          componentTypes.map(async (type) => {
+            const component = route.options[type]
+            if ((component as any)?.preload) {
+              await (component as any).preload()
+            }
+          }),
+        ),
+      )
+    }
+    return route._componentsPromise
+  }
+
   preloadRoute = async <
     TFrom extends RoutePaths<TRouteTree> | string = string,
     TTo extends string | undefined = undefined,

package/src/typePrimitives.ts

@@ -0,0 +1,168 @@
+import type {
+  FromPathOption,
+  NavigateOptions,
+  PathParamOptions,
+  SearchParamOptions,
+  ToPathOption,
+} from './link'
+import type { RouteIds } from './routeInfo'
+import type { AnyRouter, RegisteredRouter } from './router'
+import type { UseParamsOptions, UseParamsResult } from './useParams'
+import type { UseSearchOptions, UseSearchResult } from './useSearch'
+import type { Constrain, ConstrainLiteral } from './utils'
+
+export type ValidateFromPath<
+  TFrom,
+  TRouter extends AnyRouter = RegisteredRouter,
+> = FromPathOption<TRouter, TFrom>
+
+export type ValidateToPath<
+  TTo extends string | undefined,
+  TFrom extends string = string,
+  TRouter extends AnyRouter = RegisteredRouter,
+> = ToPathOption<TRouter, TFrom, TTo>
+
+export type ValidateSearch<
+  TTo extends string | undefined,
+  TFrom extends string = string,
+  TRouter extends AnyRouter = RegisteredRouter,
+> = SearchParamOptions<TRouter, TFrom, TTo>
+
+export type ValidateParams<
+  TTo extends string | undefined,
+  TFrom extends string = string,
+  TRouter extends AnyRouter = RegisteredRouter,
+> = PathParamOptions<TRouter, TFrom, TTo>
+
+/**
+ * @internal
+ */
+export type InferFrom<TOptions> = TOptions extends {
+  from: infer TFrom extends string
+}
+  ? TFrom
+  : string
+
+/**
+ * @internal
+ */
+export type InferTo<TOptions> = TOptions extends {
+  to: infer TTo extends string
+}
+  ? TTo
+  : undefined
+
+/**
+ * @internal
+ */
+export type InferMaskTo<TOptions> = TOptions extends {
+  mask: { to: infer TTo extends string }
+}
+  ? TTo
+  : string
+
+export type InferMaskFrom<TOptions> = TOptions extends {
+  mask: { from: infer TFrom extends string }
+}
+  ? TFrom
+  : string
+
+export type ValidateNavigateOptions<
+  TOptions,
+  TRouter extends AnyRouter = RegisteredRouter,
+> = Constrain<
+  TOptions,
+  NavigateOptions<
+    TRouter,
+    InferFrom<TOptions>,
+    InferTo<TOptions>,
+    InferMaskFrom<TOptions>,
+    InferMaskTo<TOptions>
+  >
+>
+
+export type ValidateNavigateOptionsArray<TOptions extends ReadonlyArray<any>> =
+  { [K in keyof TOptions]: ValidateNavigateOptions<TOptions[K]> }
+
+export type ValidateId<
+  TId extends string,
+  TRouter extends AnyRouter = RegisteredRouter,
+> = ConstrainLiteral<TId, RouteIds<TRouter['routeTree']>>
+
+/**
+ * @internal
+ */
+export type InferStrict<TOptions> = TOptions extends {
+  strict: infer TStrict extends boolean
+}
+  ? TStrict
+  : true
+
+/**
+ * @internal
+ */
+export type InferSelected<TOptions> = TOptions extends {
+  select: (...args: Array<any>) => infer TSelected
+}
+  ? TSelected
+  : unknown
+
+/**
+ * @internal
+ */
+export type InferStructuralSharing<TOptions> = TOptions extends {
+  structuralSharing: infer TStructuralSharing
+}
+  ? TStructuralSharing
+  : unknown
+
+export type ValidateUseSearchOptions<
+  TOptions,
+  TRouter extends AnyRouter = RegisteredRouter,
+> = Constrain<
+  TOptions,
+  UseSearchOptions<
+    TRouter,
+    InferFrom<TOptions>,
+    InferStrict<TOptions>,
+    InferSelected<TOptions>,
+    InferStructuralSharing<TOptions>
+  >
+>
+
+export type ValidateUseSearchResult<
+  TOptions,
+  TRouter extends AnyRouter = RegisteredRouter,
+> = UseSearchResult<
+  TRouter,
+  InferFrom<TOptions>,
+  InferStrict<TOptions>,
+  InferSelected<TOptions>
+>
+
+export type ValidateUseParamsOptions<
+  TOptions,
+  TRouter extends AnyRouter = RegisteredRouter,
+> = Constrain<
+  TOptions,
+  UseParamsOptions<
+    TRouter,
+    InferFrom<TOptions>,
+    InferStrict<TOptions>,
+    InferSelected<TOptions>,
+    InferSelected<TOptions>
+  >
+>
+
+export type ValidateUseParamsResult<
+  TOptions,
+  TRouter extends AnyRouter = RegisteredRouter,
+> = Constrain<
+  TOptions,
+  UseParamsResult<
+    TRouter,
+    InferFrom<TOptions>,
+    InferStrict<TOptions>,
+    InferSelected<TOptions>
+  >
+>