@tanstack/react-router 1.97.20 → 1.97.21

package/src/link.tsx

@@ -2,18 +2,40 @@
 
 import * as React from 'react'
 import { flushSync } from 'react-dom'
-import { useRouterState } from './useRouterState'
-import { useRouter } from './useRouter'
 import {
   deepEqual,
+  exactPathTest,
   functionalUpdate,
+  preloadWarning,
+  removeTrailingSlash,
+} from '@tanstack/router-core'
+import { useRouterState } from './useRouterState'
+import { useRouter } from './useRouter'
+
+import {
   useForwardedRef,
   useIntersectionObserver,
   useLayoutEffect,
 } from './utils'
-import { exactPathTest, removeTrailingSlash } from './path'
+
 import { useMatch } from './useMatch'
-import type { ParsedLocation } from './location'
+import type {
+  Constrain,
+  ConstrainLiteral,
+  Expand,
+  IsRequiredParams,
+  LinkOptionsProps,
+  MakeDifferenceOptional,
+  NoInfer,
+  NonNullableUpdater,
+  ParsedLocation,
+  PickRequired,
+  RemoveTrailingSlashes,
+  ResolveRelativePath,
+  Updater,
+  ViewTransitionOptions,
+  WithoutEmpty,
+} from '@tanstack/router-core'
 import type { HistoryState, ParsedHistoryState } from '@tanstack/history'
 import type {
   AllParams,
@@ -28,57 +50,13 @@ import type {
   RouteToPath,
   ToPath,
 } from './routeInfo'
-import type {
-  AnyRouter,
-  RegisteredRouter,
-  ViewTransitionOptions,
-} from './router'
-import type {
-  Constrain,
-  ConstrainLiteral,
-  Expand,
-  MakeDifferenceOptional,
-  NoInfer,
-  NonNullableUpdater,
-  PickRequired,
-  Updater,
-  WithoutEmpty,
-} from './utils'
+import type { AnyRouter, RegisteredRouter } from './router'
 import type { ReactNode } from 'react'
 import type {
   ValidateLinkOptions,
   ValidateLinkOptionsArray,
 } from './typePrimitives'
 
-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
-
-export type AddTrailingSlash<T> = T extends `${string}/` ? T : `${T & string}/`
-
-export type RemoveTrailingSlashes<T> = T extends `${string}/`
-  ? T extends `${infer R}/`
-    ? R
-    : T
-  : T
-
-export type AddLeadingSlash<T> = T extends `/${string}` ? T : `/${T & string}`
-
-export type RemoveLeadingSlashes<T> = T extends `/${string}`
-  ? T extends `/${infer R}`
-    ? R
-    : T
-  : T
-
 export type FindDescendantToPaths<
   TRouter extends AnyRouter,
   TPrefix extends string,
@@ -404,9 +382,6 @@ export interface MakeRequiredSearchParams<
   search: MakeRequiredParamsReducer<TRouter, 'SEARCH', TFrom, TTo> & {}
 }
 
-export type IsRequiredParams<TParams> =
-  Record<never, never> extends TParams ? never : true
-
 export type IsRequired<
   TRouter extends AnyRouter,
   TParamVariant extends ParamVariant,
@@ -451,13 +426,6 @@ export type FromPathOption<TRouter extends AnyRouter, TFrom> = ConstrainLiteral<
   RoutePaths<TRouter['routeTree']>
 >
 
-export interface ActiveOptions {
-  exact?: boolean
-  includeHash?: boolean
-  includeSearch?: boolean
-  explicitUndefined?: boolean
-}
-
 export type LinkOptions<
   TRouter extends AnyRouter = RegisteredRouter,
   TFrom extends string = string,
@@ -466,99 +434,6 @@ export type LinkOptions<
   TMaskTo extends string = '.',
 > = NavigateOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & LinkOptionsProps
 
-export interface LinkOptionsProps {
-  /**
-   * The standard anchor tag target attribute
-   */
-  target?: HTMLAnchorElement['target']
-  /**
-   * Configurable options to determine if the link should be considered active or not
-   * @default {exact:true,includeHash:true}
-   */
-  activeOptions?: ActiveOptions
-  /**
-   * The preloading strategy for this link
-   * - `false` - No preloading
-   * - `'intent'` - Preload the linked route on hover and cache it for this many milliseconds in hopes that the user will eventually navigate there.
-   * - `'viewport'` - Preload the linked route when it enters the viewport
-   */
-  preload?: false | 'intent' | 'viewport' | 'render'
-  /**
-   * When a preload strategy is set, this delays the preload by this many milliseconds.
-   * If the user exits the link before this delay, the preload will be cancelled.
-   */
-  preloadDelay?: number
-  /**
-   * Control whether the link should be disabled or not
-   * If set to `true`, the link will be rendered without an `href` attribute
-   * @default false
-   */
-  disabled?: boolean
-}
-
-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
-    ? TRest extends ''
-      ? TAcc
-      : `${TAcc}${TSegment}`
-    : RemoveLastSegment<TRest, `${TAcc}${TSegment}/`>
-  : TAcc
-
-export type ResolveCurrentPath<
-  TFrom extends string,
-  TTo extends string,
-> = TTo extends '.'
-  ? TFrom
-  : TTo extends './'
-    ? AddTrailingSlash<TFrom>
-    : TTo & `./${string}` extends never
-      ? never
-      : TTo extends `./${infer TRest}`
-        ? AddLeadingSlash<JoinPath<TFrom, TRest>>
-        : never
-
-export type ResolveParentPath<
-  TFrom extends string,
-  TTo extends string,
-> = TTo extends '../' | '..'
-  ? TFrom extends '' | '/'
-    ? never
-    : AddLeadingSlash<RemoveLastSegment<TFrom>>
-  : TTo & `../${string}` extends never
-    ? AddLeadingSlash<JoinPath<TFrom, TTo>>
-    : TFrom extends '' | '/'
-      ? never
-      : TTo extends `../${infer ToRest}`
-        ? ResolveParentPath<RemoveLastSegment<TFrom>, ToRest>
-        : AddLeadingSlash<JoinPath<TFrom, TTo>>
-
-export type ResolveRelativePath<TFrom, TTo = '.'> = string extends TFrom
-  ? TTo
-  : string extends TTo
-    ? TFrom
-    : undefined extends TTo
-      ? TFrom
-      : TTo extends string
-        ? TFrom extends string
-          ? TTo extends `/${string}`
-            ? TTo
-            : TTo extends `..${string}`
-              ? ResolveParentPath<TFrom, TTo>
-              : TTo extends `.${string}`
-                ? ResolveCurrentPath<TFrom, TTo>
-                : AddLeadingSlash<JoinPath<TFrom, TTo>>
-          : never
-        : never
-
 // type Test1 = ResolveRelativePath<'/', '/posts'>
 // //   ^?
 // type Test4 = ResolveRelativePath<'/posts/1/comments', '../..'>
@@ -577,13 +452,10 @@ export type ResolveRelativePath<TFrom, TTo = '.'> = string extends TFrom
 // //   ^?
 // type Test11 = ResolveRelativePath<'/posts/1/comments', './1/2'>
 // //   ^?
-
 type LinkCurrentTargetElement = {
   preloadTimeout?: null | ReturnType<typeof setTimeout>
 }
 
-const preloadWarning = 'Error preloading route! ☝️'
-
 export function useLinkProps<
   TRouter extends AnyRouter = RegisteredRouter,
   const TFrom extends string = string,

package/src/redirects.ts

@@ -1,7 +1,7 @@
 import type { NavigateOptions } from './link'
 import type { RoutePaths } from './routeInfo'
 import type { AnyRouter, RegisteredRouter } from './router'
-import type { PickAsRequired } from './utils'
+import type { PickAsRequired } from '@tanstack/router-core'
 
 export type AnyRedirect = Redirect<any, any, any, any, any>
 

package/src/route.ts

@@ -1,20 +1,56 @@
 import invariant from 'tiny-invariant'
-import { joinPaths, trimPathLeft } from './path'
+import { joinPaths, rootRouteId, trimPathLeft } from '@tanstack/router-core'
 import { useLoaderData } from './useLoaderData'
 import { useLoaderDeps } from './useLoaderDeps'
 import { useParams } from './useParams'
 import { useSearch } from './useSearch'
 import { notFound } from './not-found'
 import { useNavigate } from './useNavigate'
-import { rootRouteId } from './root'
 import { useMatch } from './useMatch'
+import type {
+  AnyContext,
+  AnyPathParams,
+  AnySchema,
+  AnyValidator,
+  Assign,
+  Constrain,
+  ConstrainLiteral,
+  ContextAsyncReturnType,
+  ContextReturnType,
+  DefaultValidator,
+  ErrorComponentProps,
+  Expand,
+  InferAllContext,
+  InferAllParams,
+  InferFullSearchSchema,
+  InferFullSearchSchemaInput,
+  IntersectAssign,
+  NoInfer,
+  NotFoundRouteProps,
+  ParamsOptions,
+  ParsedLocation,
+  ResolveId,
+  ResolveLoaderData,
+  ResolveParams,
+  ResolveRouteContext,
+  ResolveSearchValidatorInput,
+  ResolveValidatorOutput,
+  RootRouteId,
+  RouteContext,
+  RoutePathOptions,
+  RoutePathOptionsIntersection,
+  RoutePrefix,
+  SearchFilter,
+  SearchMiddleware,
+  TrimPathRight,
+  UpdatableStaticRouteOption,
+} from '@tanstack/router-core'
 import type { UseLoaderDataRoute } from './useLoaderData'
 import type { UseMatchRoute } from './useMatch'
 import type { UseLoaderDepsRoute } from './useLoaderDeps'
 import type { UseParamsRoute } from './useParams'
 import type { UseSearchRoute } from './useSearch'
 import type * as React from 'react'
-import type { RootRouteId } from './root'
 import type { UseNavigateResult } from './useNavigate'
 import type {
   AnyRouteMatch,
@@ -22,63 +58,14 @@ import type {
   MakeRouteMatchUnion,
   RouteMatch,
 } from './Matches'
-import type { NavigateOptions, ParsePathParams, ToMaskOptions } from './link'
-import type { ParsedLocation } from './location'
+import type { NavigateOptions, ToMaskOptions } from './link'
 import type { RouteById, RouteIds, RoutePaths } from './routeInfo'
 import type { AnyRouter, RegisteredRouter, Router } from './router'
-import type {
-  Assign,
-  Constrain,
-  ConstrainLiteral,
-  Expand,
-  IntersectAssign,
-  NoInfer,
-} from './utils'
 import type { BuildLocationFn, NavigateFn } from './RouterProvider'
 import type { NotFoundError } from './not-found'
 import type { LazyRoute } from './fileRoute'
-import type {
-  AnySchema,
-  AnyStandardSchemaValidator,
-  AnyValidator,
-  AnyValidatorAdapter,
-  AnyValidatorObj,
-  DefaultValidator,
-  ResolveSearchValidatorInput,
-  ResolveValidatorOutput,
-  StandardSchemaValidator,
-  ValidatorAdapter,
-  ValidatorFn,
-  ValidatorObj,
-} from './validators'
-import type { UseRouteContextRoute } from './useRouteContext'
-
-export type AnyPathParams = {}
-
-export type SearchSchemaInput = {
-  __TSearchSchemaInput__: 'TSearchSchemaInput'
-}
-
-export type AnyContext = {}
-
-export interface RouteContext {}
-
-export type PreloadableObj = { preload?: () => Promise<void> }
-
-export type RoutePathOptions<TCustomId, TPath> =
-  | {
-      path: TPath
-    }
-  | {
-      id: TCustomId
-    }
 
-export interface StaticDataRouteOption {}
-
-export type RoutePathOptionsIntersection<TCustomId, TPath> = {
-  path: TPath
-  id: TCustomId
-}
+import type { UseRouteContextRoute } from './useRouteContext'
 
 export type RouteOptions<
   TParentRoute extends AnyRoute = AnyRoute,
@@ -119,49 +106,6 @@ export type RouteOptions<
     NoInfer<TBeforeLoadFn>
   >
 
-export type ParseSplatParams<TPath extends string> = TPath &
-  `${string}$` extends never
-  ? TPath & `${string}$/${string}` extends never
-    ? never
-    : '_splat'
-  : '_splat'
-
-export interface SplatParams {
-  _splat?: string
-}
-
-export type ResolveParams<TPath extends string> =
-  ParseSplatParams<TPath> extends never
-    ? Record<ParsePathParams<TPath>, string>
-    : Record<ParsePathParams<TPath>, string> & SplatParams
-
-export type ParseParamsFn<in out TPath extends string, in out TParams> = (
-  rawParams: ResolveParams<TPath>,
-) => TParams extends Record<ParsePathParams<TPath>, any>
-  ? TParams
-  : Record<ParsePathParams<TPath>, any>
-
-export type StringifyParamsFn<in out TPath extends string, in out TParams> = (
-  params: TParams,
-) => ResolveParams<TPath>
-
-export type ParamsOptions<in out TPath extends string, in out TParams> = {
-  params?: {
-    parse?: ParseParamsFn<TPath, TParams>
-    stringify?: StringifyParamsFn<TPath, TParams>
-  }
-
-  /** 
-  @deprecated Use params.parse instead
-  */
-  parseParams?: ParseParamsFn<TPath, TParams>
-
-  /** 
-  @deprecated Use params.stringify instead
-  */
-  stringifyParams?: StringifyParamsFn<TPath, TParams>
-}
-
 export interface FullSearchSchemaOption<
   in out TParentRoute extends AnyRoute,
   in out TSearchValidator,
@@ -487,51 +431,6 @@ export interface UpdatableRouteOptions<
   ssr?: boolean
 }
 
-interface RequiredStaticDataRouteOption {
-  staticData: StaticDataRouteOption
-}
-
-interface OptionalStaticDataRouteOption {
-  staticData?: StaticDataRouteOption
-}
-
-export type UpdatableStaticRouteOption = {} extends StaticDataRouteOption
-  ? OptionalStaticDataRouteOption
-  : RequiredStaticDataRouteOption
-
-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 }
-  | Record<string, unknown>
-
-type LdJsonObject = { [Key in string]: LdJsonValue } & {
-  [Key in string]?: LdJsonValue | undefined
-}
-type LdJsonArray = Array<LdJsonValue> | ReadonlyArray<LdJsonValue>
-type LdJsonPrimitive = string | number | boolean | null
-type LdJsonValue = LdJsonPrimitive | LdJsonObject | LdJsonArray
-
-export type RouteLinkEntry = {}
-
-export type SearchValidator<TInput, TOutput> =
-  | ValidatorObj<TInput, TOutput>
-  | ValidatorFn<TInput, TOutput>
-  | ValidatorAdapter<TInput, TOutput>
-  | StandardSchemaValidator<TInput, TOutput>
-  | undefined
-
-export type AnySearchValidator = SearchValidator<any, any>
-
-export type DefaultSearchValidator = SearchValidator<
-  Record<string, unknown>,
-  AnySchema
->
-
 export type RouteLoaderFn<
   in out TParentRoute extends AnyRoute = AnyRoute,
   in out TId extends string = string,
@@ -586,92 +485,6 @@ export interface LoaderFnContext<
   route: Route
 }
 
-export type SearchFilter<TInput, TResult = TInput> = (prev: TInput) => TResult
-
-export type SearchMiddlewareContext<TSearchSchema> = {
-  search: TSearchSchema
-  next: (newSearch: TSearchSchema) => TSearchSchema
-}
-
-export type SearchMiddleware<TSearchSchema> = (
-  ctx: SearchMiddlewareContext<TSearchSchema>,
-) => TSearchSchema
-
-export type ResolveId<
-  TParentRoute,
-  TCustomId extends string,
-  TPath extends string,
-> = TParentRoute extends { id: infer TParentId extends string }
-  ? RoutePrefix<TParentId, string extends TCustomId ? TPath : TCustomId>
-  : RootRouteId
-
-export type InferFullSearchSchema<TRoute> = TRoute extends {
-  types: {
-    fullSearchSchema: infer TFullSearchSchema
-  }
-}
-  ? TFullSearchSchema
-  : {}
-
-export type InferFullSearchSchemaInput<TRoute> = TRoute extends {
-  types: {
-    fullSearchSchemaInput: infer TFullSearchSchemaInput
-  }
-}
-  ? TFullSearchSchemaInput
-  : {}
-
-export type InferAllParams<TRoute> = TRoute extends {
-  types: {
-    allParams: infer TAllParams
-  }
-}
-  ? TAllParams
-  : {}
-
-export type InferAllContext<TRoute> = unknown extends TRoute
-  ? TRoute
-  : TRoute extends {
-        types: {
-          allContext: infer TAllContext
-        }
-      }
-    ? TAllContext
-    : {}
-
-export type ResolveSearchSchemaFnInput<TSearchValidator> =
-  TSearchValidator extends (input: infer TSearchSchemaInput) => any
-    ? TSearchSchemaInput extends SearchSchemaInput
-      ? Omit<TSearchSchemaInput, keyof SearchSchemaInput>
-      : ResolveSearchSchemaFn<TSearchValidator>
-    : AnySchema
-
-export type ResolveSearchSchemaInput<TSearchValidator> =
-  TSearchValidator extends AnyStandardSchemaValidator
-    ? NonNullable<TSearchValidator['~standard']['types']>['input']
-    : TSearchValidator extends AnyValidatorAdapter
-      ? TSearchValidator['types']['input']
-      : TSearchValidator extends AnyValidatorObj
-        ? ResolveSearchSchemaFnInput<TSearchValidator['parse']>
-        : ResolveSearchSchemaFnInput<TSearchValidator>
-
-export type ResolveSearchSchemaFn<TSearchValidator> = TSearchValidator extends (
-  ...args: any
-) => infer TSearchSchema
-  ? TSearchSchema
-  : AnySchema
-
-export type ResolveSearchSchema<TSearchValidator> =
-  unknown extends TSearchValidator
-    ? TSearchValidator
-    : TSearchValidator extends AnyStandardSchemaValidator
-      ? NonNullable<TSearchValidator['~standard']['types']>['output']
-      : TSearchValidator extends AnyValidatorAdapter
-        ? TSearchValidator['types']['output']
-        : TSearchValidator extends AnyValidatorObj
-          ? ResolveSearchSchemaFn<TSearchValidator['parse']>
-          : ResolveSearchSchemaFn<TSearchValidator>
-
 export type ResolveFullSearchSchema<
   TParentRoute extends AnyRoute,
   TSearchValidator,
@@ -690,32 +503,6 @@ export type ResolveFullSearchSchemaInput<
   ResolveSearchValidatorInput<TSearchValidator>
 >
 
-export type LooseReturnType<T> = T extends (
-  ...args: Array<any>
-) => infer TReturn
-  ? TReturn
-  : never
-
-export type LooseAsyncReturnType<T> = T extends (
-  ...args: Array<any>
-) => infer TReturn
-  ? TReturn extends Promise<infer TReturn>
-    ? TReturn
-    : TReturn
-  : never
-
-export type ContextReturnType<TContextFn> = unknown extends TContextFn
-  ? TContextFn
-  : LooseReturnType<TContextFn> extends never
-    ? AnyContext
-    : LooseReturnType<TContextFn>
-
-export type ContextAsyncReturnType<TContextFn> = unknown extends TContextFn
-  ? TContextFn
-  : LooseAsyncReturnType<TContextFn> extends never
-    ? AnyContext
-    : LooseAsyncReturnType<TContextFn>
-
 export type RouteContextParameter<
   TParentRoute extends AnyRoute,
   TRouterContext,
@@ -723,10 +510,6 @@ export type RouteContextParameter<
   ? TRouterContext
   : Assign<TRouterContext, InferAllContext<TParentRoute>>
 
-export type ResolveRouteContext<TRouteContextFn, TBeforeLoadFn> = Assign<
-  ContextReturnType<TRouteContextFn>,
-  ContextAsyncReturnType<TBeforeLoadFn>
->
 export type BeforeLoadContextParameter<
   TParentRoute extends AnyRoute,
   TRouterContext,
@@ -746,12 +529,6 @@ export type ResolveAllContext<
   ContextAsyncReturnType<TBeforeLoadFn>
 >
 
-export type ResolveLoaderData<TLoaderFn> = unknown extends TLoaderFn
-  ? TLoaderFn
-  : LooseAsyncReturnType<TLoaderFn> extends never
-    ? {}
-    : LooseAsyncReturnType<TLoaderFn>
-
 export interface AnyRoute
   extends Route<
     any,
@@ -1530,37 +1307,6 @@ export type ResolveFullPath<
   TPrefixed = RoutePrefix<TParentRoute['fullPath'], TPath>,
 > = TPrefixed extends RootRouteId ? '/' : TPrefixed
 
-type RoutePrefix<
-  TPrefix extends string,
-  TPath extends string,
-> = string extends TPath
-  ? RootRouteId
-  : TPath extends string
-    ? TPrefix extends RootRouteId
-      ? TPath extends '/'
-        ? '/'
-        : `/${TrimPath<TPath>}`
-      : `${TPrefix}/${TPath}` extends '/'
-        ? '/'
-        : `/${TrimPathLeft<`${TrimPathRight<TPrefix>}/${TrimPath<TPath>}`>}`
-    : never
-
-export type TrimPath<T extends string> = '' extends T
-  ? ''
-  : TrimPathRight<TrimPathLeft<T>>
-
-export type TrimPathLeft<T extends string> =
-  T extends `${RootRouteId}/${infer U}`
-    ? TrimPathLeft<U>
-    : T extends `/${infer U}`
-      ? TrimPathLeft<U>
-      : T
-export type TrimPathRight<T extends string> = T extends '/'
-  ? '/'
-  : T extends `${infer U}/`
-    ? TrimPathRight<U>
-    : T
-
 export type RouteMask<TRouteTree extends AnyRoute> = {
   routeTree: TRouteTree
   from: RoutePaths<TRouteTree>
@@ -1584,26 +1330,6 @@ export function createRouteMask<
   return opts as any
 }
 
-/**
- * @deprecated Use `ErrorComponentProps` instead.
- */
-export type ErrorRouteProps = {
-  error: unknown
-  info?: { componentStack: string }
-  reset: () => void
-}
-
-export type ErrorComponentProps = {
-  error: Error
-  info?: { componentStack: string }
-  reset: () => void
-}
-export type NotFoundRouteProps = {
-  // TODO: Make sure this is `| null | undefined` (this is for global not-founds)
-  data: unknown
-}
-//
-
 export type ReactNode = any
 
 export type SyncRouteComponent<TProps> =

package/src/routeInfo.ts

@@ -1,8 +1,12 @@
 import type { InferFileRouteTypes } from './fileRoute'
-import type { AddTrailingSlash, RemoveTrailingSlashes } from './link'
+import type {
+  AddTrailingSlash,
+  PartialMergeAll,
+  RemoveTrailingSlashes,
+  TrailingSlashOption,
+} from '@tanstack/router-core'
 import type { AnyRoute } from './route'
-import type { AnyRouter, TrailingSlashOption } from './router'
-import type { PartialMergeAll } from './utils'
+import type { AnyRouter } from './router'
 
 export type ParseRoute<TRouteTree, TAcc = TRouteTree> = TRouteTree extends {
   types: { children: infer TChildren }