@tanstack/react-router 1.8.4 → 1.10.0

package/src/Matches.tsx

@@ -7,6 +7,8 @@ import { useRouter } from './useRouter'
 import { ResolveRelativePath, ToOptions } from './link'
 import { AnyRoute, ReactNode, RootSearchSchema } from './route'
 import {
+  AllParams,
+  FullSearchSchema,
   ParseRoute,
   RouteById,
   RouteByPath,
@@ -14,18 +16,21 @@ import {
   RoutePaths,
 } from './routeInfo'
 import { RegisteredRouter, RouterState } from './router'
-import { DeepOptional, NoInfer, StrictOrFrom, pick } from './utils'
+import { DeepOptional, Expand, NoInfer, StrictOrFrom, pick } from './utils'
 
 export const matchContext = React.createContext<string | undefined>(undefined)
 
 export interface RouteMatch<
-  TRouteTree extends AnyRoute = AnyRoute,
+  TRouteTree extends AnyRoute = RegisteredRouter['routeTree'],
   TRouteId extends RouteIds<TRouteTree> = ParseRoute<TRouteTree>['id'],
+  TReturnIntersection extends boolean = false,
 > {
   id: string
   routeId: TRouteId
   pathname: string
-  params: RouteById<TRouteTree, TRouteId>['types']['allParams']
+  params: TReturnIntersection extends false
+    ? RouteById<TRouteTree, TRouteId>['types']['allParams']
+    : Expand<Partial<AllParams<TRouteTree>>>
   status: 'pending' | 'success' | 'error'
   isFetching: boolean
   showPending: boolean
@@ -37,10 +42,14 @@ export interface RouteMatch<
   loaderData?: RouteById<TRouteTree, TRouteId>['types']['loaderData']
   routeContext: RouteById<TRouteTree, TRouteId>['types']['routeContext']
   context: RouteById<TRouteTree, TRouteId>['types']['allContext']
-  search: Exclude<
-    RouteById<TRouteTree, TRouteId>['types']['fullSearchSchema'],
-    RootSearchSchema
-  >
+  search: TReturnIntersection extends false
+    ? Exclude<
+        RouteById<TRouteTree, TRouteId>['types']['fullSearchSchema'],
+        RootSearchSchema
+      >
+    : Expand<
+        Partial<Omit<FullSearchSchema<TRouteTree>, keyof RootSearchSchema>>
+      >
   fetchCount: number
   abortController: AbortController
   cause: 'preload' | 'enter' | 'stay'
@@ -48,6 +57,9 @@ export interface RouteMatch<
   preload: boolean
   invalid: boolean
   pendingPromise?: Promise<void>
+  meta?: JSX.IntrinsicElements['meta'][]
+  links?: JSX.IntrinsicElements['link'][]
+  scripts?: JSX.IntrinsicElements['script'][]
 }
 
 export type AnyRouteMatch = RouteMatch<any, any>
@@ -298,7 +310,9 @@ export function MatchRoute<
   return !!params ? props.children : null
 }
 
-export function getRenderedMatches(state: RouterState) {
+export function getRenderedMatches<
+  TRouteTree extends AnyRoute = RegisteredRouter['routeTree'],
+>(state: RouterState<TRouteTree>) {
   return state.pendingMatches?.some((d) => d.showPending)
     ? state.pendingMatches
     : state.matches
@@ -307,10 +321,11 @@ export function getRenderedMatches(state: RouterState) {
 export function useMatch<
   TRouteTree extends AnyRoute = RegisteredRouter['routeTree'],
   TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>,
-  TRouteMatchState = RouteMatch<TRouteTree, TFrom>,
+  TReturnIntersection extends boolean = false,
+  TRouteMatchState = RouteMatch<TRouteTree, TFrom, TReturnIntersection>,
   TSelected = TRouteMatchState,
 >(
-  opts: StrictOrFrom<TFrom> & {
+  opts: StrictOrFrom<TFrom, TReturnIntersection> & {
     select?: (match: TRouteMatchState) => TSelected
   },
 ): TSelected {
@@ -364,26 +379,44 @@ export function useMatch<
   return matchSelection as any
 }
 
-export function useMatches<T = RouteMatch[]>(opts?: {
-  select?: (matches: RouteMatch[]) => T
+export function useMatches<
+  TRouteTree extends AnyRoute = RegisteredRouter['routeTree'],
+  TRouteId extends RouteIds<TRouteTree> = ParseRoute<TRouteTree>['id'],
+  TReturnIntersection extends boolean = false,
+  TRouteMatch = RouteMatch<TRouteTree, TRouteId, TReturnIntersection>,
+  T = TRouteMatch[],
+>(opts?: {
+  select?: (matches: TRouteMatch[]) => T
+  experimental_returnIntersection?: TReturnIntersection
 }): T {
   return useRouterState({
     select: (state) => {
-      let matches = getRenderedMatches(state)
-      return opts?.select ? opts.select(matches) : (matches as T)
+      const matches = getRenderedMatches(state)
+      return opts?.select
+        ? opts.select(matches as TRouteMatch[])
+        : (matches as T)
     },
   })
 }
 
-export function useParentMatches<T = RouteMatch[]>(opts?: {
-  select?: (matches: RouteMatch[]) => T
+export function useParentMatches<
+  TRouteTree extends AnyRoute = RegisteredRouter['routeTree'],
+  TRouteId extends RouteIds<TRouteTree> = ParseRoute<TRouteTree>['id'],
+  TReturnIntersection extends boolean = false,
+  TRouteMatch = RouteMatch<TRouteTree, TRouteId, TReturnIntersection>,
+  T = TRouteMatch[],
+>(opts?: {
+  select?: (matches: TRouteMatch[]) => T
+  experimental_returnIntersection?: TReturnIntersection
 }): T {
   const contextMatchId = React.useContext(matchContext)
 
   return useMatches({
     select: (matches) => {
       matches = matches.slice(matches.findIndex((d) => d.id === contextMatchId))
-      return opts?.select ? opts.select(matches) : (matches as T)
+      return opts?.select
+        ? opts.select(matches as TRouteMatch[])
+        : (matches as T)
     },
   })
 }

package/src/RouterProvider.tsx

@@ -43,8 +43,13 @@ export type NavigateFn<TRouteTree extends AnyRoute> = <
   opts: NavigateOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo>,
 ) => Promise<void>
 
-export type BuildLocationFn<TRouteTree extends AnyRoute> = (
-  opts: ToOptions<TRouteTree> & {
+export type BuildLocationFn<TRouteTree extends AnyRoute> = <
+  TFrom extends RoutePaths<TRouteTree> | string = RoutePaths<TRouteTree>,
+  TTo extends string = '',
+  TMaskFrom extends RoutePaths<TRouteTree> | string = TFrom,
+  TMaskTo extends string = '',
+>(
+  opts: ToOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> & {
     leaveParams?: boolean
   },
 ) => ParsedLocation

package/src/fileRoute.ts

@@ -10,6 +10,7 @@ import {
   RouteOptions,
   UpdatableRouteOptions,
   Route,
+  createRoute,
   RootRouteId,
   TrimPathLeft,
   RouteConstraints,
@@ -17,8 +18,14 @@ import {
   SearchSchemaInput,
   LoaderFnContext,
   RouteLoaderFn,
+  AnyPathParams,
+  AnySearchSchema,
 } from './route'
 import { Assign, Expand, IsAny } from './utils'
+import { useMatch, useLoaderDeps, useLoaderData } from './Matches'
+import { useSearch } from './useSearch'
+import { useParams } from './useParams'
+import warning from 'tiny-warning'
 
 export interface FileRoutesByPath {
   // '/': {
@@ -77,12 +84,34 @@ export type ResolveFilePath<
 export type FileRoutePath<
   TParentRoute extends AnyRoute,
   TFilePath extends string,
-> = ResolveFilePath<TParentRoute, TFilePath> extends `_${infer _}`
-  ? ''
-  : ResolveFilePath<TParentRoute, TFilePath> extends `/_${infer _}`
+> =
+  ResolveFilePath<TParentRoute, TFilePath> extends `_${infer _}`
     ? ''
-    : ResolveFilePath<TParentRoute, TFilePath>
+    : ResolveFilePath<TParentRoute, TFilePath> extends `/_${infer _}`
+      ? ''
+      : ResolveFilePath<TParentRoute, TFilePath>
 
+export function createFileRoute<
+  TFilePath extends keyof FileRoutesByPath,
+  TParentRoute extends AnyRoute = FileRoutesByPath[TFilePath]['parentRoute'],
+  TId extends RouteConstraints['TId'] = TFilePath,
+  TPath extends RouteConstraints['TPath'] = FileRoutePath<
+    TParentRoute,
+    TFilePath
+  >,
+  TFullPath extends RouteConstraints['TFullPath'] = ResolveFullPath<
+    TParentRoute,
+    RemoveUnderScores<TPath>
+  >,
+>(path: TFilePath) {
+  return new FileRoute<TFilePath, TParentRoute, TId, TPath, TFullPath>(path)
+    .createRoute
+}
+
+/** 
+  @deprecated It's no longer recommended to use the `FileRoute` class directly.
+  Instead, use `createFileRoute('/path/to/file')(options)` to create a file route.
+*/
 export class FileRoute<
   TFilePath extends keyof FileRoutesByPath,
   TParentRoute extends AnyRoute = FileRoutesByPath[TFilePath]['parentRoute'],
@@ -163,7 +192,7 @@ export class FileRoute<
       >,
       'getParentRoute' | 'path' | 'id'
     > &
-      UpdatableRouteOptions<TFullSearchSchema>,
+      UpdatableRouteOptions<TFullSearchSchema, TLoaderData>,
   ): Route<
     TParentRoute,
     TPath,
@@ -186,12 +215,21 @@ export class FileRoute<
     TChildren,
     TRouteTree
   > => {
-    const route = new Route(options as any)
+    warning(
+      false,
+      'FileRoute is deprecated and will be removed in the next major version. Use the createFileRoute(path)(options) function instead.',
+    )
+    const route = createRoute(options as any)
     ;(route as any).isRoot = false
     return route as any
   }
 }
 
+/** 
+  @deprecated It's recommended not to split loaders into separate files.
+  Instead, place the loader function in the the main route file, inside the
+  `createFileRoute('/path/to/file)(options)` options.
+*/
 export function FileRouteLoader<
   TFilePath extends keyof FileRoutesByPath,
   TRoute extends FileRoutesByPath[TFilePath]['preLoaderRoute'],
@@ -212,5 +250,74 @@ export function FileRouteLoader<
   TRoute['types']['routeContext'],
   NoInfer<TLoaderData>
 > {
+  warning(
+    false,
+    `FileRouteLoader is deprecated and will be removed in the next major version. Please place the loader function in the the main route file, inside the \`createFileRoute('/path/to/file')(options)\` options`,
+  )
   return (loaderFn) => loaderFn
 }
+
+export type LazyRouteOptions = Pick<
+  UpdatableRouteOptions<AnySearchSchema, any>,
+  'component' | 'errorComponent' | 'pendingComponent'
+>
+
+export class LazyRoute<TRoute extends AnyRoute> {
+  options: {
+    id: string
+  } & LazyRouteOptions
+
+  constructor(
+    opts: {
+      id: string
+    } & LazyRouteOptions,
+  ) {
+    this.options = opts
+  }
+
+  useMatch = <TSelected = TRoute['types']['allContext']>(opts?: {
+    select?: (s: TRoute['types']['allContext']) => TSelected
+  }): TSelected => {
+    return useMatch({ select: opts?.select, from: this.options.id })
+  }
+
+  useRouteContext = <TSelected = TRoute['types']['allContext']>(opts?: {
+    select?: (s: TRoute['types']['allContext']) => TSelected
+  }): TSelected => {
+    return useMatch({
+      from: this.options.id,
+      select: (d: any) => (opts?.select ? opts.select(d.context) : d.context),
+    })
+  }
+
+  useSearch = <TSelected = TRoute['types']['fullSearchSchema']>(opts?: {
+    select?: (s: TRoute['types']['fullSearchSchema']) => TSelected
+  }): TSelected => {
+    return useSearch({ ...opts, from: this.options.id })
+  }
+
+  useParams = <TSelected = TRoute['types']['allParams']>(opts?: {
+    select?: (s: TRoute['types']['allParams']) => TSelected
+  }): TSelected => {
+    return useParams({ ...opts, from: this.options.id })
+  }
+
+  useLoaderDeps = <TSelected = TRoute['types']['loaderDeps']>(opts?: {
+    select?: (s: TRoute['types']['loaderDeps']) => TSelected
+  }): TSelected => {
+    return useLoaderDeps({ ...opts, from: this.options.id } as any)
+  }
+
+  useLoaderData = <TSelected = TRoute['types']['loaderData']>(opts?: {
+    select?: (s: TRoute['types']['loaderData']) => TSelected
+  }): TSelected => {
+    return useLoaderData({ ...opts, from: this.options.id } as any)
+  }
+}
+
+export function createLazyFileRoute<
+  TFilePath extends keyof FileRoutesByPath,
+  TRoute extends FileRoutesByPath[TFilePath]['preLoaderRoute'],
+>(id: TFilePath) {
+  return (opts: LazyRouteOptions) => new LazyRoute<TRoute>({ id, ...opts })
+}

package/src/route.ts

@@ -9,15 +9,9 @@ import { RouteById, RouteIds, RoutePaths } from './routeInfo'
 import { AnyRouter, RegisteredRouter } from './router'
 import { useParams } from './useParams'
 import { useSearch } from './useSearch'
-import {
-  Assign,
-  Expand,
-  IsAny,
-  NoInfer,
-  PickRequired,
-  UnionToIntersection,
-} from './utils'
+import { Assign, Expand, IsAny, NoInfer, UnionToIntersection } from './utils'
 import { BuildLocationFn, NavigateFn } from './RouterProvider'
+import { LazyRoute } from '.'
 
 export const rootRouteId = '__root__' as const
 export type RootRouteId = typeof rootRouteId
@@ -81,7 +75,7 @@ export type RouteOptions<
   TLoaderDeps,
   TLoaderData
 > &
-  UpdatableRouteOptions<NoInfer<TFullSearchSchema>>
+  UpdatableRouteOptions<NoInfer<TFullSearchSchema>, NoInfer<TLoaderData>>
 
 export type ParamsFallback<
   TPath extends string,
@@ -178,6 +172,7 @@ type BeforeLoadFn<
 
 export type UpdatableRouteOptions<
   TFullSearchSchema extends Record<string, any>,
+  TLoaderData extends any,
 > = {
   // test?: (args: TAllContext) => void
   // If true, this route will be matched as case-sensitive
@@ -188,6 +183,7 @@ export type UpdatableRouteOptions<
   component?: RouteComponent
   errorComponent?: false | null | ErrorRouteComponent
   pendingComponent?: RouteComponent
+  lazy?: () => Promise<LazyRoute<any>>
   pendingMs?: number
   pendingMinMs?: number
   staleTime?: number
@@ -206,8 +202,30 @@ export type UpdatableRouteOptions<
   onEnter?: (match: AnyRouteMatch) => void
   onStay?: (match: AnyRouteMatch) => void
   onLeave?: (match: AnyRouteMatch) => void
+  meta?: (ctx: { loaderData: TLoaderData }) => JSX.IntrinsicElements['meta'][]
+  links?: () => JSX.IntrinsicElements['link'][]
+  scripts?: () => JSX.IntrinsicElements['script'][]
 }
 
+export type MetaDescriptor =
+  | { charSet: 'utf-8' }
+  | { title: string }
+  | { name: string; content: string }
+  | { property: string; content: string }
+  | { httpEquiv: string; content: string }
+  | { 'script:ld+json': LdJsonObject }
+  | { tagName: 'meta' | 'link'; [name: string]: string }
+  | { [name: string]: unknown }
+
+type LdJsonObject = { [Key in string]: LdJsonValue } & {
+  [Key in string]?: LdJsonValue | undefined
+}
+type LdJsonArray = LdJsonValue[] | readonly LdJsonValue[]
+type LdJsonPrimitive = string | number | boolean | null
+type LdJsonValue = LdJsonPrimitive | LdJsonObject | LdJsonArray
+
+export type RouteLinkEntry = {}
+
 export type ParseParamsOption<TPath extends string, TParams> = ParseParamsFn<
   TPath,
   TParams
@@ -455,6 +473,32 @@ export type RouteConstraints = {
 //   }
 // }
 
+export function getRouteApi<
+  TId extends RouteIds<RegisteredRouter['routeTree']>,
+  TRoute extends AnyRoute = RouteById<RegisteredRouter['routeTree'], TId>,
+  TFullSearchSchema extends Record<
+    string,
+    any
+  > = TRoute['types']['fullSearchSchema'],
+  TAllParams extends AnyPathParams = TRoute['types']['allParams'],
+  TAllContext extends Record<string, any> = TRoute['types']['allContext'],
+  TLoaderDeps extends Record<string, any> = TRoute['types']['loaderDeps'],
+  TLoaderData extends any = TRoute['types']['loaderData'],
+>(id: TId) {
+  return new RouteApi<
+    TId,
+    TRoute,
+    TFullSearchSchema,
+    TAllParams,
+    TAllContext,
+    TLoaderDeps,
+    TLoaderData
+  >({ id })
+}
+
+/**
+ * @deprecated Use the `getRouteApi` function instead.
+ */
 export class RouteApi<
   TId extends RouteIds<RegisteredRouter['routeTree']>,
   TRoute extends AnyRoute = RouteById<RegisteredRouter['routeTree'], TId>,
@@ -513,6 +557,9 @@ export class RouteApi<
   }
 }
 
+/**
+ * @deprecated Use the `createRoute` function instead.
+ */
 export class Route<
   TParentRoute extends RouteConstraints['TParentRoute'] = AnyRoute,
   TPath extends RouteConstraints['TPath'] = '/',
@@ -792,7 +839,7 @@ export class Route<
     >
   }
 
-  update = (options: UpdatableRouteOptions<TFullSearchSchema>) => {
+  update = (options: UpdatableRouteOptions<TFullSearchSchema, TLoaderData>) => {
     Object.assign(this.options, options)
     return this
   }
@@ -838,6 +885,103 @@ export class Route<
   }
 }
 
+export function createRoute<
+  TParentRoute extends RouteConstraints['TParentRoute'] = AnyRoute,
+  TPath extends RouteConstraints['TPath'] = '/',
+  TFullPath extends RouteConstraints['TFullPath'] = ResolveFullPath<
+    TParentRoute,
+    TPath
+  >,
+  TCustomId extends RouteConstraints['TCustomId'] = string,
+  TId extends RouteConstraints['TId'] = ResolveId<
+    TParentRoute,
+    TCustomId,
+    TPath
+  >,
+  TSearchSchemaInput extends RouteConstraints['TSearchSchema'] = {},
+  TSearchSchema extends RouteConstraints['TSearchSchema'] = {},
+  TSearchSchemaUsed extends Record<
+    string,
+    any
+  > = TSearchSchemaInput extends SearchSchemaInput
+    ? Omit<TSearchSchemaInput, keyof SearchSchemaInput>
+    : TSearchSchema,
+  TFullSearchSchemaInput extends Record<
+    string,
+    any
+  > = ResolveFullSearchSchemaInput<TParentRoute, TSearchSchemaUsed>,
+  TFullSearchSchema extends
+    RouteConstraints['TFullSearchSchema'] = ResolveFullSearchSchema<
+    TParentRoute,
+    TSearchSchema
+  >,
+  TParams extends RouteConstraints['TParams'] = Expand<
+    Record<ParsePathParams<TPath>, string>
+  >,
+  TAllParams extends RouteConstraints['TAllParams'] = ResolveAllParams<
+    TParentRoute,
+    TParams
+  >,
+  TRouteContextReturn extends RouteConstraints['TRouteContext'] = RouteContext,
+  TRouteContext extends RouteConstraints['TRouteContext'] = [
+    TRouteContextReturn,
+  ] extends [never]
+    ? RouteContext
+    : TRouteContextReturn,
+  TAllContext extends Expand<
+    Assign<IsAny<TParentRoute['types']['allContext'], {}>, TRouteContext>
+  > = Expand<
+    Assign<IsAny<TParentRoute['types']['allContext'], {}>, TRouteContext>
+  >,
+  TRouterContext extends RouteConstraints['TRouterContext'] = AnyContext,
+  TLoaderDeps extends Record<string, any> = {},
+  TLoaderData extends any = unknown,
+  TChildren extends RouteConstraints['TChildren'] = unknown,
+  TRouteTree extends RouteConstraints['TRouteTree'] = AnyRoute,
+>(
+  options: RouteOptions<
+    TParentRoute,
+    TCustomId,
+    TPath,
+    TSearchSchemaInput,
+    TSearchSchema,
+    TSearchSchemaUsed,
+    TFullSearchSchemaInput,
+    TFullSearchSchema,
+    TParams,
+    TAllParams,
+    TRouteContextReturn,
+    TRouteContext,
+    TRouterContext,
+    TAllContext,
+    TLoaderDeps,
+    TLoaderData
+  >,
+) {
+  return new Route<
+    TParentRoute,
+    TPath,
+    TFullPath,
+    TCustomId,
+    TId,
+    TSearchSchemaInput,
+    TSearchSchema,
+    TSearchSchemaUsed,
+    TFullSearchSchemaInput,
+    TFullSearchSchema,
+    TParams,
+    TAllParams,
+    TRouteContextReturn,
+    TRouteContext,
+    TAllContext,
+    TRouterContext,
+    TLoaderDeps,
+    TLoaderData,
+    TChildren,
+    TRouteTree
+  >(options)
+}
+
 export type AnyRootRoute = RootRoute<any, any, any, any, any, any, any, any>
 
 export function rootRouteWithContext<TRouterContext extends {}>() {
@@ -878,15 +1022,15 @@ export function rootRouteWithContext<TRouterContext extends {}>() {
       | 'parseParams'
       | 'stringifyParams'
     >,
-  ): RootRoute<
-    TSearchSchemaInput,
-    TSearchSchema,
-    TSearchSchemaUsed,
-    TRouteContextReturn,
-    TRouteContext,
-    TRouterContext
-  > => {
-    return new RootRoute(options) as any
+  ) => {
+    return createRootRoute<
+      TSearchSchemaInput,
+      TSearchSchema,
+      TSearchSchemaUsed,
+      TRouteContextReturn,
+      TRouteContext,
+      TRouterContext
+    >(options as any)
   }
 }
 
@@ -894,6 +1038,9 @@ export type RootSearchSchema = {
   __TRootSearchSchema__: '__TRootSearchSchema__'
 }
 
+/**
+ * @deprecated `RootRoute` is now an internal implementation detail. Use `createRootRoute()` instead.
+ */
 export class RootRoute<
   TSearchSchemaInput extends Record<string, any> = RootSearchSchema,
   TSearchSchema extends Record<string, any> = RootSearchSchema,
@@ -959,6 +1106,57 @@ export class RootRoute<
   }
 }
 
+export function createRootRoute<
+  TSearchSchemaInput extends Record<string, any> = RootSearchSchema,
+  TSearchSchema extends Record<string, any> = RootSearchSchema,
+  TSearchSchemaUsed extends Record<string, any> = RootSearchSchema,
+  TRouteContextReturn extends RouteContext = RouteContext,
+  TRouteContext extends RouteContext = [TRouteContextReturn] extends [never]
+    ? RouteContext
+    : TRouteContextReturn,
+  TRouterContext extends {} = {},
+  TLoaderDeps extends Record<string, any> = {},
+  TLoaderData extends any = unknown,
+>(
+  options?: Omit<
+    RouteOptions<
+      AnyRoute, // TParentRoute
+      RootRouteId, // TCustomId
+      '', // TPath
+      TSearchSchemaInput, // TSearchSchemaInput
+      TSearchSchema, // TSearchSchema
+      TSearchSchemaUsed,
+      TSearchSchemaUsed, // TFullSearchSchemaInput
+      TSearchSchema, // TFullSearchSchema
+      {}, // TParams
+      {}, // TAllParams
+      TRouteContextReturn, // TRouteContextReturn
+      TRouteContext, // TRouteContext
+      TRouterContext,
+      Assign<TRouterContext, TRouteContext>, // TAllContext
+      TLoaderDeps,
+      TLoaderData
+    >,
+    | 'path'
+    | 'id'
+    | 'getParentRoute'
+    | 'caseSensitive'
+    | 'parseParams'
+    | 'stringifyParams'
+  >,
+) {
+  return new RootRoute<
+    TSearchSchemaInput,
+    TSearchSchema,
+    TSearchSchemaUsed,
+    TRouteContextReturn,
+    TRouteContext,
+    TRouterContext,
+    TLoaderDeps,
+    TLoaderData
+  >(options)
+}
+
 export type ResolveFullPath<
   TParentRoute extends AnyRoute,
   TPath extends string,
@@ -1019,10 +1217,18 @@ export function createRouteMask<
   return opts as any
 }
 
+/**
+ * @deprecated Use `ErrorComponentProps` instead.
+ */
 export type ErrorRouteProps = {
   error: unknown
   info: { componentStack: string }
 }
+
+export type ErrorComponentProps = {
+  error: unknown
+  info: { componentStack: string }
+}
 //
 
 export type ReactNode = any
@@ -1038,7 +1244,7 @@ export type AsyncRouteComponent<TProps> = SyncRouteComponent<TProps> & {
 export type RouteComponent<TProps = any> = SyncRouteComponent<TProps> &
   AsyncRouteComponent<TProps>
 
-export type ErrorRouteComponent = RouteComponent<ErrorRouteProps>
+export type ErrorRouteComponent = RouteComponent<ErrorComponentProps>
 
 export class NotFoundRoute<
   TParentRoute extends AnyRootRoute,