@tanstack/react-router 1.111.3 → 1.111.7

package/src/redirects.ts

@@ -1,41 +1,9 @@
-import type { AnyRouter, RegisteredRouter } from './router'
 import type {
-  NavigateOptions,
-  PickAsRequired,
-  RoutePaths,
+  AnyRedirect,
+  Redirect,
+  ResolvedRedirect,
 } from '@tanstack/router-core'
-
-export type AnyRedirect = Redirect<any, any, any, any, any>
-
-export type Redirect<
-  TRouter extends AnyRouter = RegisteredRouter,
-  TFrom extends RoutePaths<TRouter['routeTree']> | string = '/',
-  TTo extends string | undefined = '.',
-  TMaskFrom extends RoutePaths<TRouter['routeTree']> | string = TFrom,
-  TMaskTo extends string = '.',
-> = {
-  href?: string
-  /**
-   * @deprecated Use `statusCode` instead
-   **/
-  code?: number
-  statusCode?: number
-  throw?: any
-  headers?: HeadersInit
-} & NavigateOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>
-
-export type ResolvedRedirect<
-  TRouter extends AnyRouter = RegisteredRouter,
-  TFrom extends RoutePaths<TRouter['routeTree']> = '/',
-  TTo extends string = '',
-  TMaskFrom extends RoutePaths<TRouter['routeTree']> = TFrom,
-  TMaskTo extends string = '',
-> = PickAsRequired<
-  Redirect<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>,
-  'code' | 'statusCode' | 'headers'
-> & {
-  href: string
-}
+import type { RegisteredRouter } from './router'
 
 export function redirect<
   TRouter extends RegisteredRouter,

package/src/route.ts

@@ -9,48 +9,30 @@ import { useNavigate } from './useNavigate'
 import { useMatch } from './useMatch'
 import type {
   AnyContext,
-  AnyPathParams,
   AnySchema,
-  AnyValidator,
-  BeforeLoadContextParameter,
-  BuildLocationFn,
   Constrain,
   ConstrainLiteral,
   RootRoute as CoreRootRoute,
   Route as CoreRoute,
-  DefaultValidator,
   ErrorComponentProps,
-  Expand,
-  FullSearchSchemaOption,
-  NavigateFn,
-  NavigateOptions,
-  NoInfer,
   NotFoundRouteProps,
-  ParamsOptions,
-  ParsedLocation,
-  RemountDepsOptions,
-  ResolveAllContext,
-  ResolveAllParamsFromParent,
   ResolveFullPath,
-  ResolveFullSearchSchema,
-  ResolveFullSearchSchemaInput,
   ResolveId,
-  ResolveLoaderData,
   ResolveParams,
   RootRouteId,
+  RootRouteOptions,
   RouteById,
   RouteContext,
-  RouteContextParameter,
   RouteIds,
-  RoutePathOptions,
+  RouteLoaderFn,
+  RouteOptions,
   RoutePathOptionsIntersection,
   RoutePaths,
   RouteTypes,
-  SearchFilter,
-  SearchMiddleware,
   ToMaskOptions,
   TrimPathRight,
-  UpdatableStaticRouteOption,
+  UpdatableRouteOptions,
+  UseNavigateResult,
 } from '@tanstack/router-core'
 import type { UseLoaderDataRoute } from './useLoaderData'
 import type { UseMatchRoute } from './useMatch'
@@ -58,489 +40,19 @@ import type { UseLoaderDepsRoute } from './useLoaderDeps'
 import type { UseParamsRoute } from './useParams'
 import type { UseSearchRoute } from './useSearch'
 import type * as React from 'react'
-import type { UseNavigateResult } from './useNavigate'
-import type {
-  AnyRouteMatch,
-  MakeRouteMatchFromRoute,
-  MakeRouteMatchUnion,
-  RouteMatch,
-} from './Matches'
+import type {} from './Matches'
 import type { AnyRouter, RegisteredRouter, Router } from './router'
 import type { NotFoundError } from './not-found'
 import type { LazyRoute } from './fileRoute'
-
 import type { UseRouteContextRoute } from './useRouteContext'
 
-export type RouteOptions<
-  TParentRoute extends AnyRoute = AnyRoute,
-  TId extends string = string,
-  TCustomId extends string = string,
-  TFullPath extends string = string,
-  TPath extends string = string,
-  TSearchValidator = undefined,
-  TParams = AnyPathParams,
-  TLoaderDeps extends Record<string, any> = {},
-  TLoaderFn = undefined,
-  TRouterContext = {},
-  TRouteContextFn = AnyContext,
-  TBeforeLoadFn = AnyContext,
-> = BaseRouteOptions<
-  TParentRoute,
-  TId,
-  TCustomId,
-  TPath,
-  TSearchValidator,
-  TParams,
-  TLoaderDeps,
-  TLoaderFn,
-  TRouterContext,
-  TRouteContextFn,
-  TBeforeLoadFn
-> &
-  UpdatableRouteOptions<
-    NoInfer<TParentRoute>,
-    NoInfer<TCustomId>,
-    NoInfer<TFullPath>,
-    NoInfer<TParams>,
-    NoInfer<TSearchValidator>,
-    NoInfer<TLoaderFn>,
-    NoInfer<TLoaderDeps>,
-    NoInfer<TRouterContext>,
-    NoInfer<TRouteContextFn>,
-    NoInfer<TBeforeLoadFn>
-  >
-
-export type RouteContextFn<
-  in out TParentRoute extends AnyRoute,
-  in out TSearchValidator,
-  in out TParams,
-  in out TRouterContext,
-> = (
-  ctx: RouteContextOptions<
-    TParentRoute,
-    TSearchValidator,
-    TParams,
-    TRouterContext
-  >,
-) => any
-
-export type BeforeLoadFn<
-  in out TParentRoute extends AnyRoute,
-  in out TSearchValidator,
-  in out TParams,
-  in out TRouterContext,
-  in out TRouteContextFn,
-> = (
-  ctx: BeforeLoadContextOptions<
-    TParentRoute,
-    TSearchValidator,
-    TParams,
-    TRouterContext,
-    TRouteContextFn
-  >,
-) => any
-
-export type FileBaseRouteOptions<
-  TParentRoute extends AnyRoute = AnyRoute,
-  TId extends string = string,
-  TPath extends string = string,
-  TSearchValidator = undefined,
-  TParams = {},
-  TLoaderDeps extends Record<string, any> = {},
-  TLoaderFn = undefined,
-  TRouterContext = {},
-  TRouteContextFn = AnyContext,
-  TBeforeLoadFn = AnyContext,
-  TRemountDepsFn = AnyContext,
-> = ParamsOptions<TPath, TParams> & {
-  validateSearch?: Constrain<TSearchValidator, AnyValidator, DefaultValidator>
-
-  shouldReload?:
-    | boolean
-    | ((
-        match: LoaderFnContext<
-          TParentRoute,
-          TId,
-          TParams,
-          TLoaderDeps,
-          TRouterContext,
-          TRouteContextFn,
-          TBeforeLoadFn
-        >,
-      ) => any)
-
-  context?: Constrain<
-    TRouteContextFn,
-    (
-      ctx: RouteContextOptions<
-        TParentRoute,
-        TParams,
-        TRouterContext,
-        TLoaderDeps
-      >,
-    ) => any
-  >
-
-  // This async function is called before a route is loaded.
-  // If an error is thrown here, the route's loader will not be called.
-  // If thrown during a navigation, the navigation will be cancelled and the error will be passed to the `onError` function.
-  // If thrown during a preload event, the error will be logged to the console.
-  beforeLoad?: Constrain<
-    TBeforeLoadFn,
-    (
-      ctx: BeforeLoadContextOptions<
-        TParentRoute,
-        TSearchValidator,
-        TParams,
-        TRouterContext,
-        TRouteContextFn
-      >,
-    ) => any
-  >
-
-  loaderDeps?: (
-    opts: FullSearchSchemaOption<TParentRoute, TSearchValidator>,
-  ) => TLoaderDeps
-
-  remountDeps?: Constrain<
-    TRemountDepsFn,
-    (
-      opt: RemountDepsOptions<
-        TId,
-        FullSearchSchemaOption<TParentRoute, TSearchValidator>,
-        Expand<ResolveAllParamsFromParent<TParentRoute, TParams>>,
-        TLoaderDeps
-      >,
-    ) => any
-  >
-
-  loader?: Constrain<
-    TLoaderFn,
-    (
-      ctx: LoaderFnContext<
-        TParentRoute,
-        TId,
-        TParams,
-        TLoaderDeps,
-        TRouterContext,
-        TRouteContextFn,
-        TBeforeLoadFn
-      >,
-    ) => any
-  >
-}
-
-export type BaseRouteOptions<
-  TParentRoute extends AnyRoute = AnyRoute,
-  TId extends string = string,
-  TCustomId extends string = string,
-  TPath extends string = string,
-  TSearchValidator = undefined,
-  TParams = {},
-  TLoaderDeps extends Record<string, any> = {},
-  TLoaderFn = undefined,
-  TRouterContext = {},
-  TRouteContextFn = AnyContext,
-  TBeforeLoadFn = AnyContext,
-> = RoutePathOptions<TCustomId, TPath> &
-  FileBaseRouteOptions<
-    TParentRoute,
-    TId,
-    TPath,
-    TSearchValidator,
-    TParams,
-    TLoaderDeps,
-    TLoaderFn,
-    TRouterContext,
-    TRouteContextFn,
-    TBeforeLoadFn
-  > & {
-    getParentRoute: () => TParentRoute
-  }
-
-export interface ContextOptions<
-  in out TParentRoute extends AnyRoute,
-  in out TParams,
-> {
-  abortController: AbortController
-  preload: boolean
-  params: Expand<ResolveAllParamsFromParent<TParentRoute, TParams>>
-  location: ParsedLocation
-  /**
-   * @deprecated Use `throw redirect({ to: '/somewhere' })` instead
-   **/
-  navigate: NavigateFn
-  buildLocation: BuildLocationFn
-  cause: 'preload' | 'enter' | 'stay'
-  matches: Array<MakeRouteMatchUnion>
-}
-
-export interface RouteContextOptions<
-  in out TParentRoute extends AnyRoute,
-  in out TParams,
-  in out TRouterContext,
-  in out TLoaderDeps,
-> extends ContextOptions<TParentRoute, TParams> {
-  deps: TLoaderDeps
-  context: Expand<RouteContextParameter<TParentRoute, TRouterContext>>
-}
-
-export interface BeforeLoadContextOptions<
-  in out TParentRoute extends AnyRoute,
-  in out TSearchValidator,
-  in out TParams,
-  in out TRouterContext,
-  in out TRouteContextFn,
-> extends ContextOptions<TParentRoute, TParams>,
-    FullSearchSchemaOption<TParentRoute, TSearchValidator> {
-  context: Expand<
-    BeforeLoadContextParameter<TParentRoute, TRouterContext, TRouteContextFn>
-  >
-}
-
-type AssetFnContextOptions<
-  in out TRouteId,
-  in out TFullPath,
-  in out TParentRoute extends AnyRoute,
-  in out TParams,
-  in out TSearchValidator,
-  in out TLoaderFn,
-  in out TRouterContext,
-  in out TRouteContextFn,
-  in out TBeforeLoadFn,
-  in out TLoaderDeps,
-> = {
-  matches: Array<
-    RouteMatch<
-      TRouteId,
-      TFullPath,
-      ResolveAllParamsFromParent<TParentRoute, TParams>,
-      ResolveFullSearchSchema<TParentRoute, TSearchValidator>,
-      ResolveLoaderData<TLoaderFn>,
-      ResolveAllContext<
-        TParentRoute,
-        TRouterContext,
-        TRouteContextFn,
-        TBeforeLoadFn
-      >,
-      TLoaderDeps
-    >
-  >
-  match: RouteMatch<
-    TRouteId,
-    TFullPath,
-    ResolveAllParamsFromParent<TParentRoute, TParams>,
-    ResolveFullSearchSchema<TParentRoute, TSearchValidator>,
-    ResolveLoaderData<TLoaderFn>,
-    ResolveAllContext<
-      TParentRoute,
-      TRouterContext,
-      TRouteContextFn,
-      TBeforeLoadFn
-    >,
-    TLoaderDeps
-  >
-  params: ResolveAllParamsFromParent<TParentRoute, TParams>
-  loaderData: ResolveLoaderData<TLoaderFn>
-}
-export interface UpdatableRouteOptions<
-  in out TParentRoute extends AnyRoute,
-  in out TRouteId,
-  in out TFullPath,
-  in out TParams,
-  in out TSearchValidator,
-  in out TLoaderFn,
-  in out TLoaderDeps,
-  in out TRouterContext,
-  in out TRouteContextFn,
-  in out TBeforeLoadFn,
-> extends UpdatableStaticRouteOption {
-  // If true, this route will be matched as case-sensitive
-  caseSensitive?: boolean
-  // If true, this route will be forcefully wrapped in a suspense boundary
-  wrapInSuspense?: boolean
-  // The content to be rendered when the route is matched. If no component is provided, defaults to `<Outlet />`
-  component?: RouteComponent
-  errorComponent?: false | null | ErrorRouteComponent
-  notFoundComponent?: NotFoundRouteComponent
-  pendingComponent?: RouteComponent
-  pendingMs?: number
-  pendingMinMs?: number
-  staleTime?: number
-  gcTime?: number
-  preload?: boolean
-  preloadStaleTime?: number
-  preloadGcTime?: number
-  search?: {
-    middlewares?: Array<
-      SearchMiddleware<
-        ResolveFullSearchSchemaInput<TParentRoute, TSearchValidator>
-      >
-    >
-  }
-  /** 
-  @deprecated Use search.middlewares instead
-  */
-  preSearchFilters?: Array<
-    SearchFilter<ResolveFullSearchSchema<TParentRoute, TSearchValidator>>
-  >
-  /** 
-  @deprecated Use search.middlewares instead
-  */
-  postSearchFilters?: Array<
-    SearchFilter<ResolveFullSearchSchema<TParentRoute, TSearchValidator>>
-  >
-  onCatch?: (error: Error, errorInfo: React.ErrorInfo) => void
-  onError?: (err: any) => void
-  // These functions are called as route matches are loaded, stick around and leave the active
-  // matches
-  onEnter?: (
-    match: RouteMatch<
-      TRouteId,
-      TFullPath,
-      ResolveAllParamsFromParent<TParentRoute, TParams>,
-      ResolveFullSearchSchema<TParentRoute, TSearchValidator>,
-      ResolveLoaderData<TLoaderFn>,
-      ResolveAllContext<
-        TParentRoute,
-        TRouterContext,
-        TRouteContextFn,
-        TBeforeLoadFn
-      >,
-      TLoaderDeps
-    >,
-  ) => void
-  onStay?: (
-    match: RouteMatch<
-      TRouteId,
-      TFullPath,
-      ResolveAllParamsFromParent<TParentRoute, TParams>,
-      ResolveFullSearchSchema<TParentRoute, TSearchValidator>,
-      ResolveLoaderData<TLoaderFn>,
-      ResolveAllContext<
-        TParentRoute,
-        TRouterContext,
-        TRouteContextFn,
-        TBeforeLoadFn
-      >,
-      TLoaderDeps
-    >,
-  ) => void
-  onLeave?: (
-    match: RouteMatch<
-      TRouteId,
-      TFullPath,
-      ResolveAllParamsFromParent<TParentRoute, TParams>,
-      ResolveFullSearchSchema<TParentRoute, TSearchValidator>,
-      ResolveLoaderData<TLoaderFn>,
-      ResolveAllContext<
-        TParentRoute,
-        TRouterContext,
-        TRouteContextFn,
-        TBeforeLoadFn
-      >,
-      TLoaderDeps
-    >,
-  ) => void
-  headers?: (ctx: {
-    loaderData: ResolveLoaderData<TLoaderFn>
-  }) => Record<string, string>
-  head?: (
-    ctx: AssetFnContextOptions<
-      TRouteId,
-      TFullPath,
-      TParentRoute,
-      TParams,
-      TSearchValidator,
-      TLoaderFn,
-      TRouterContext,
-      TRouteContextFn,
-      TBeforeLoadFn,
-      TLoaderDeps
-    >,
-  ) => {
-    links?: AnyRouteMatch['links']
-    scripts?: AnyRouteMatch['headScripts']
-    meta?: AnyRouteMatch['meta']
+declare module '@tanstack/router-core' {
+  export interface UpdatableRouteOptionsExtensions {
+    component?: RouteComponent
+    errorComponent?: false | null | ErrorRouteComponent
+    notFoundComponent?: NotFoundRouteComponent
+    pendingComponent?: RouteComponent
   }
-  scripts?: (
-    ctx: AssetFnContextOptions<
-      TRouteId,
-      TFullPath,
-      TParentRoute,
-      TParams,
-      TSearchValidator,
-      TLoaderFn,
-      TRouterContext,
-      TRouteContextFn,
-      TBeforeLoadFn,
-      TLoaderDeps
-    >,
-  ) => AnyRouteMatch['scripts']
-  ssr?: boolean
-  codeSplitGroupings?: Array<
-    Array<
-      | 'loader'
-      | 'component'
-      | 'pendingComponent'
-      | 'notFoundComponent'
-      | 'errorComponent'
-    >
-  >
-}
-
-export type RouteLoaderFn<
-  in out TParentRoute extends AnyRoute = AnyRoute,
-  in out TId extends string = string,
-  in out TParams = {},
-  in out TLoaderDeps = {},
-  in out TRouterContext = {},
-  in out TRouteContextFn = AnyContext,
-  in out TBeforeLoadFn = AnyContext,
-> = (
-  match: LoaderFnContext<
-    TParentRoute,
-    TId,
-    TParams,
-    TLoaderDeps,
-    TRouterContext,
-    TRouteContextFn,
-    TBeforeLoadFn
-  >,
-) => any
-
-export interface LoaderFnContext<
-  in out TParentRoute extends AnyRoute = AnyRoute,
-  in out TId extends string = string,
-  in out TParams = {},
-  in out TLoaderDeps = {},
-  in out TRouterContext = {},
-  in out TRouteContextFn = AnyContext,
-  in out TBeforeLoadFn = AnyContext,
-> {
-  abortController: AbortController
-  preload: boolean
-  params: Expand<ResolveAllParamsFromParent<TParentRoute, TParams>>
-  deps: TLoaderDeps
-  context: Expand<
-    ResolveAllContext<
-      TParentRoute,
-      TRouterContext,
-      TRouteContextFn,
-      TBeforeLoadFn
-    >
-  >
-  location: ParsedLocation // Do not supply search schema here so as to demotivate people from trying to shortcut loaderDeps
-  /**
-   * @deprecated Use `throw redirect({ to: '/somewhere' })` instead
-   **/
-  navigate: (opts: NavigateOptions<AnyRouter>) => Promise<void> | void
-  // root route does not have a parent match
-  parentMatchPromise: TId extends RootRouteId
-    ? never
-    : Promise<MakeRouteMatchFromRoute<TParentRoute>>
-  cause: 'preload' | 'enter' | 'stay'
-  route: Route
 }
 
 export interface AnyRoute
@@ -1120,37 +632,6 @@ export function createRoute<
 
 export type AnyRootRoute = RootRoute<any, any, any, any, any, any, any, any>
 
-export type RootRouteOptions<
-  TSearchValidator = undefined,
-  TRouterContext = {},
-  TRouteContextFn = AnyContext,
-  TBeforeLoadFn = AnyContext,
-  TLoaderDeps extends Record<string, any> = {},
-  TLoaderFn = undefined,
-> = Omit<
-  RouteOptions<
-    any, // TParentRoute
-    RootRouteId, // TId
-    RootRouteId, // TCustomId
-    '', // TFullPath
-    '', // TPath
-    TSearchValidator,
-    {}, // TParams
-    TLoaderDeps,
-    TLoaderFn,
-    TRouterContext,
-    TRouteContextFn,
-    TBeforeLoadFn
-  >,
-  | 'path'
-  | 'id'
-  | 'getParentRoute'
-  | 'caseSensitive'
-  | 'parseParams'
-  | 'stringifyParams'
-  | 'params'
->
-
 export function createRootRouteWithContext<TRouterContext extends {}>() {
   return <
     TRouteContextFn = AnyContext,

package/src/router.ts

@@ -41,13 +41,19 @@ import type { NoInfer } from '@tanstack/react-store'
 
 import type {
   AnyContext,
+  AnyRedirect,
+  AnyRouteMatch,
   AnySchema,
   AnyValidator,
+  BeforeLoadContextOptions,
   BuildLocationFn,
   CommitLocationOptions,
   ControlledPromise,
   FullSearchSchema,
+  LoaderFnContext,
   MakeRemountDepsOptionsUnion,
+  MakeRouteMatch,
+  MakeRouteMatchUnion,
   Manifest,
   NavigateFn,
   NavigateOptions,
@@ -56,7 +62,9 @@ import type {
   PickAsRequired,
   Register,
   ResolveRelativePath,
+  ResolvedRedirect,
   RouteById,
+  RouteContextOptions,
   RoutePaths,
   RoutesById,
   RoutesByPath,
@@ -71,24 +79,15 @@ import type {
 } from '@tanstack/router-core'
 import type {
   AnyRoute,
-  BeforeLoadContextOptions,
   ErrorRouteComponent,
-  LoaderFnContext,
   NotFoundRouteComponent,
   RootRoute,
   RouteComponent,
-  RouteContextOptions,
   RouteMask,
 } from './route'
 
-import type {
-  AnyRouteMatch,
-  MakeRouteMatch,
-  MakeRouteMatchUnion,
-  MatchRouteOptions,
-} from './Matches'
+import type { MatchRouteOptions } from './Matches'
 
-import type { AnyRedirect, ResolvedRedirect } from './redirects'
 import type { NotFoundError } from './not-found'
 
 declare global {

package/src/typePrimitives.ts

@@ -4,15 +4,18 @@ import type {
   FromPathOption,
   NavigateOptions,
   PathParamOptions,
+  Redirect,
   RouteIds,
   SearchParamOptions,
   ToPathOption,
+  UseParamsResult,
+  UseSearchResult,
 } from '@tanstack/router-core'
 import type { LinkComponentProps } from './link'
-import type { Redirect } from './redirects'
 import type { AnyRouter, RegisteredRouter } from './router'
-import type { UseParamsOptions, UseParamsResult } from './useParams'
-import type { UseSearchOptions, UseSearchResult } from './useSearch'
+
+import type { UseParamsOptions } from './useParams'
+import type { UseSearchOptions } from './useSearch'
 
 export type ValidateFromPath<
   TRouter extends AnyRouter = RegisteredRouter,