@tanstack/react-router 1.45.11 → 1.45.14

package/src/index.tsx

@@ -3,18 +3,27 @@ export {
   createBrowserHistory,
   createHashHistory,
   createMemoryHistory,
-  type BlockerFn,
-  type HistoryLocation,
-  type RouterHistory,
-  type ParsedPath,
-  type HistoryState,
+} from '@tanstack/history'
+export type {
+  BlockerFn,
+  HistoryLocation,
+  RouterHistory,
+  ParsedPath,
+  HistoryState,
 } from '@tanstack/history'
 export { default as invariant } from 'tiny-invariant'
 export { default as warning } from 'tiny-warning'
-export { useAwaited, Await, type AwaitOptions } from './awaited'
+
+export { useAwaited, Await } from './awaited'
+export type { AwaitOptions } from './awaited'
+
 export { ScriptOnce } from './ScriptOnce'
-export { defer, type DeferredPromiseState, type DeferredPromise } from './defer'
+
+export { defer } from './defer'
+export type { DeferredPromiseState, DeferredPromise } from './defer'
+
 export { CatchBoundary, ErrorComponent } from './CatchBoundary'
+
 export {
   FileRoute,
   createFileRoute,
@@ -22,46 +31,48 @@ export {
   LazyRoute,
   createLazyRoute,
   createLazyFileRoute,
-  type FileRoutesByPath,
-  type LazyRouteOptions,
 } from './fileRoute'
+export type { FileRoutesByPath, LazyRouteOptions } from './fileRoute'
+
 export * from './history'
+
 export { lazyRouteComponent } from './lazyRouteComponent'
-export {
-  useLinkProps,
-  createLink,
-  Link,
-  type CleanPath,
-  type Split,
-  type ParsePathParams,
-  type Join,
-  type Last,
-  type RemoveTrailingSlashes,
-  type RemoveLeadingSlashes,
-  type SearchPaths,
-  type SearchRelativePathAutoComplete,
-  type RelativeToParentPathAutoComplete,
-  type RelativeToCurrentPathAutoComplete,
-  type AbsolutePathAutoComplete,
-  type RelativeToPathAutoComplete,
-  type NavigateOptions,
-  type ToOptions,
-  type ToMaskOptions,
-  type ToSubOptions,
-  type ResolveRoute,
-  type SearchParamOptions,
-  type PathParamOptions,
-  type ToPathOption,
-  type ActiveOptions,
-  type LinkOptions,
-  type CheckPath,
-  type ResolveRelativePath,
-  type UseLinkPropsOptions,
-  type ActiveLinkOptions,
-  type LinkProps,
-  type LinkComponent,
+
+export { useLinkProps, createLink, Link } from './link'
+export type {
+  CleanPath,
+  Split,
+  ParsePathParams,
+  Join,
+  Last,
+  RemoveTrailingSlashes,
+  RemoveLeadingSlashes,
+  SearchPaths,
+  SearchRelativePathAutoComplete,
+  RelativeToParentPathAutoComplete,
+  RelativeToCurrentPathAutoComplete,
+  AbsolutePathAutoComplete,
+  RelativeToPathAutoComplete,
+  NavigateOptions,
+  ToOptions,
+  ToMaskOptions,
+  ToSubOptions,
+  ResolveRoute,
+  SearchParamOptions,
+  PathParamOptions,
+  ToPathOption,
+  ActiveOptions,
+  LinkOptions,
+  CheckPath,
+  ResolveRelativePath,
+  UseLinkPropsOptions,
+  ActiveLinkOptions,
+  LinkProps,
+  LinkComponent,
 } from './link'
-export { type ParsedLocation } from './location'
+
+export type { ParsedLocation } from './location'
+
 export {
   Matches,
   useMatchRoute,
@@ -69,18 +80,27 @@ export {
   useMatches,
   useParentMatches,
   useChildMatches,
-  type RouteMatch,
-  type AnyRouteMatch,
-  type MatchRouteOptions,
-  type UseMatchRouteOptions,
-  type MakeMatchRouteOptions,
 } from './Matches'
+export type {
+  RouteMatch,
+  AnyRouteMatch,
+  MatchRouteOptions,
+  UseMatchRouteOptions,
+  MakeMatchRouteOptions,
+} from './Matches'
+
 export { matchContext } from './matchContext'
+
 export { Match, Outlet } from './Match'
+
 export { isServerSideError, defaultDeserializeError } from './isServerSideError'
+
 export { useMatch } from './useMatch'
+
 export { useLoaderDeps } from './useLoaderDeps'
+
 export { useLoaderData } from './useLoaderData'
+
 export {
   joinPaths,
   cleanPath,
@@ -93,17 +113,17 @@ export {
   matchPathname,
   removeBasepath,
   matchByPath,
-  type Segment,
 } from './path'
+export type { Segment } from './path'
+
 export { encode, decode } from './qss'
-export {
-  redirect,
-  isRedirect,
-  type AnyRedirect,
-  type Redirect,
-  type ResolvedRedirect,
-} from './redirects'
-export { rootRouteId, type RootRouteId } from './root'
+
+export { redirect, isRedirect } from './redirects'
+export type { AnyRedirect, Redirect, ResolvedRedirect } from './redirects'
+
+export { rootRouteId } from './root'
+export type { RootRouteId } from './root'
+
 export {
   RouteApi,
   getRouteApi,
@@ -115,65 +135,69 @@ export {
   createRootRouteWithContext,
   createRouteMask,
   NotFoundRoute,
-  type AnyPathParams,
-  type SearchSchemaInput,
-  type AnySearchSchema,
-  type AnyContext,
-  type RouteContext,
-  type PreloadableObj,
-  type RoutePathOptions,
-  type StaticDataRouteOption,
-  type RoutePathOptionsIntersection,
-  type RouteOptions,
-  type FileBaseRouteOptions,
-  type BaseRouteOptions,
-  type UpdatableRouteOptions,
-  type UpdatableStaticRouteOption,
-  type MetaDescriptor,
-  type RouteLinkEntry,
-  type ParseParamsFn,
-  type SearchSchemaValidator,
-  type SearchSchemaValidatorObj,
-  type SearchSchemaValidatorFn,
-  type RouteLoaderFn,
-  type LoaderFnContext,
-  type SearchFilter,
-  type ResolveId,
-  type InferFullSearchSchema,
-  type InferFullSearchSchemaInput,
-  type ResolveFullSearchSchema,
-  type ResolveFullSearchSchemaInput,
-  type AnyRoute,
-  type RouteConstraints,
-  type AnyRootRoute,
-  type ResolveFullPath,
-  type RouteMask,
-  type ErrorRouteProps,
-  type ErrorComponentProps,
-  type NotFoundRouteProps,
-  type ReactNode,
-  type SyncRouteComponent,
-  type AsyncRouteComponent,
-  type RouteComponent,
-  type ErrorRouteComponent,
-  type NotFoundRouteComponent,
-  type TrimPath,
-  type TrimPathLeft,
-  type TrimPathRight,
-  type RootRouteOptions,
-  type AnyRouteWithContext,
 } from './route'
-export {
-  type ParseRoute,
-  type RoutesById,
-  type RouteById,
-  type RouteIds,
-  type RoutesByPath,
-  type RouteByPath,
-  type RoutePaths,
-  type FullSearchSchema,
-  type AllParams,
+export type {
+  AnyPathParams,
+  SearchSchemaInput,
+  AnySearchSchema,
+  AnyContext,
+  RouteContext,
+  PreloadableObj,
+  RoutePathOptions,
+  StaticDataRouteOption,
+  RoutePathOptionsIntersection,
+  RouteOptions,
+  FileBaseRouteOptions,
+  BaseRouteOptions,
+  UpdatableRouteOptions,
+  UpdatableStaticRouteOption,
+  MetaDescriptor,
+  RouteLinkEntry,
+  ParseParamsFn,
+  SearchSchemaValidator,
+  SearchSchemaValidatorObj,
+  SearchSchemaValidatorFn,
+  RouteLoaderFn,
+  LoaderFnContext,
+  SearchFilter,
+  ResolveId,
+  InferFullSearchSchema,
+  InferFullSearchSchemaInput,
+  ResolveFullSearchSchema,
+  ResolveFullSearchSchemaInput,
+  AnyRoute,
+  RouteConstraints,
+  AnyRootRoute,
+  ResolveFullPath,
+  RouteMask,
+  ErrorRouteProps,
+  ErrorComponentProps,
+  NotFoundRouteProps,
+  ReactNode,
+  SyncRouteComponent,
+  AsyncRouteComponent,
+  RouteComponent,
+  ErrorRouteComponent,
+  NotFoundRouteComponent,
+  TrimPath,
+  TrimPathLeft,
+  TrimPathRight,
+  RootRouteOptions,
+  AnyRouteWithContext,
+} from './route'
+
+export type {
+  ParseRoute,
+  RoutesById,
+  RouteById,
+  RouteIds,
+  RoutesByPath,
+  RouteByPath,
+  RoutePaths,
+  FullSearchSchema,
+  AllParams,
 } from './routeInfo'
+
 export {
   componentTypes,
   createRouter,
@@ -183,62 +207,76 @@ export {
   PathParamError,
   getInitialRouterState,
   defaultSerializeError,
-  type Register,
-  type AnyRouter,
-  type RegisteredRouter,
-  type HydrationCtx,
-  type RouterContextOptions,
-  type TrailingSlashOption,
-  type RouterOptions,
-  type RouterTransformer,
-  type RouterErrorSerializer,
-  type RouterState,
-  type ListenerFn,
-  type BuildNextOptions,
-  type DehydratedRouterState,
-  type DehydratedRouteMatch,
-  type DehydratedRouter,
-  type RouterConstructorOptions,
-  type RouterEvents,
-  type RouterEvent,
-  type RouterListener,
-  type AnyRouterWithContext,
 } from './router'
-export {
-  RouterProvider,
-  RouterContextProvider,
-  type RouterProps,
-  type CommitLocationOptions,
-  type MatchLocation,
-  type NavigateFn,
-  type BuildLocationFn,
-  type InjectedHtmlEntry,
+export type {
+  Register,
+  AnyRouter,
+  RegisteredRouter,
+  HydrationCtx,
+  RouterContextOptions,
+  TrailingSlashOption,
+  RouterOptions,
+  RouterTransformer,
+  RouterErrorSerializer,
+  RouterState,
+  ListenerFn,
+  BuildNextOptions,
+  DehydratedRouterState,
+  DehydratedRouteMatch,
+  DehydratedRouter,
+  RouterConstructorOptions,
+  RouterEvents,
+  RouterEvent,
+  RouterListener,
+  AnyRouterWithContext,
+} from './router'
+
+export { RouterProvider, RouterContextProvider } from './RouterProvider'
+export type {
+  RouterProps,
+  CommitLocationOptions,
+  MatchLocation,
+  NavigateFn,
+  BuildLocationFn,
+  InjectedHtmlEntry,
 } from './RouterProvider'
+
 export {
   useScrollRestoration,
   useElementScrollRestoration,
   ScrollRestoration,
-  type ScrollRestorationOptions,
 } from './scroll-restoration'
+export type { ScrollRestorationOptions } from './scroll-restoration'
+
 export {
   defaultParseSearch,
   defaultStringifySearch,
   parseSearchWith,
   stringifySearchWith,
-  type SearchSerializer,
-  type SearchParser,
 } from './searchParams'
+export type { SearchSerializer, SearchParser } from './searchParams'
+
 export { useBlocker, Block } from './useBlocker'
-export { useNavigate, Navigate, type UseNavigateResult } from './useNavigate'
+
+export { useNavigate, Navigate } from './useNavigate'
+export type { UseNavigateResult } from './useNavigate'
+
 export { useParams } from './useParams'
+
 export { useSearch } from './useSearch'
+
 export {
   getRouterContext, // SSR
 } from './routerContext'
+
 export { useRouteContext } from './useRouteContext'
+
 export { useRouter } from './useRouter'
+
 export { useRouterState } from './useRouterState'
+
 export { useLocation } from './useLocation'
+
 export {
   escapeJSON, // SSR
   useLayoutEffect, // SSR
@@ -251,12 +289,16 @@ export {
   useStableCallback,
   shallow,
 } from './utils'
+
 export {
   notFound,
   isNotFound,
   CatchNotFound,
   DefaultGlobalNotFound,
-  type NotFoundError,
 } from './not-found'
-export { type Manifest, type RouterManagedTag } from './manifest'
-export { createControlledPromise, type ControlledPromise } from './utils'
+export type { NotFoundError } from './not-found'
+
+export type { Manifest, RouterManagedTag } from './manifest'
+
+export { createControlledPromise } from './utils'
+export type { ControlledPromise } from './utils'

package/src/not-found.tsx

@@ -1,10 +1,9 @@
-// eslint-disable-next-line ts/consistent-type-imports
 import * as React from 'react'
 import { CatchBoundary } from './CatchBoundary'
 import { useRouterState } from './useRouterState'
+import type { ErrorInfo } from 'react'
 import type { RegisteredRouter } from './router'
 import type { RouteIds } from './routeInfo'
-import type { ErrorInfo } from 'react'
 
 export type NotFoundError = {
   /**

package/src/renderRouteNotFound.tsx

@@ -1,8 +1,8 @@
 import * as React from 'react'
 import warning from 'tiny-warning'
 import { DefaultGlobalNotFound } from './not-found'
-import { type AnyRouter } from './router'
-import { type AnyRoute } from './route'
+import type { AnyRouter } from './router'
+import type { AnyRoute } from './route'
 
 export function renderRouteNotFound(
   router: AnyRouter,

package/src/route.ts

@@ -8,15 +8,15 @@ import { useSearch } from './useSearch'
 import { notFound } from './not-found'
 import { useNavigate } from './useNavigate'
 import { rootRouteId } from './root'
+import type * as React from 'react'
 import type { RootRouteId } from './root'
 import type { UseNavigateResult } from './useNavigate'
-import type * as React from 'react'
 import type { MakeRouteMatch, RouteMatch } from './Matches'
 import type { NavigateOptions, ParsePathParams, ToSubOptions } from './link'
 import type { ParsedLocation } from './location'
 import type { RouteById, RouteIds, RoutePaths } from './routeInfo'
 import type { AnyRouter, RegisteredRouter, Router } from './router'
-import type { Assign, Expand, IsAny, NoInfer, PickRequired } from './utils'
+import type { Assign, Expand, NoInfer, PickRequired } from './utils'
 import type { BuildLocationFn, NavigateFn } from './RouterProvider'
 import type { NotFoundError } from './not-found'
 import type { LazyRoute } from './fileRoute'
@@ -719,7 +719,7 @@ export class Route<
 
     const isRoot = !options?.path && !options?.id
 
-    // eslint-disable-next-line ts/no-unnecessary-condition
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     this.parentRoute = this.options?.getParentRoute?.()
 
     if (isRoot) {

package/src/routeInfo.ts

@@ -1,6 +1,6 @@
 import type { AnyRoute } from './route'
 import type { AnyRouter, TrailingSlashOption } from './router'
-import type { Expand, MergeUnion } from './utils'
+import type { MergeUnion } from './utils'
 
 export type ParseRoute<TRouteTree, TAcc = TRouteTree> = TRouteTree extends {
   types: { children: infer TChildren }

package/src/router.ts

@@ -26,13 +26,13 @@ import {
 import { isRedirect, isResolvedRedirect } from './redirects'
 import { isNotFound } from './not-found'
 import type * as React from 'react'
-import type { Manifest } from './manifest'
 import type {
   HistoryLocation,
   HistoryState,
   RouterHistory,
 } from '@tanstack/history'
-
+import type { NoInfer } from '@tanstack/react-store'
+import type { Manifest } from './manifest'
 import type {
   AnyContext,
   AnyRoute,
@@ -70,13 +70,9 @@ import type {
   CommitLocationOptions,
   NavigateFn,
 } from './RouterProvider'
-
 import type { AnyRedirect, ResolvedRedirect } from './redirects'
-
 import type { NotFoundError } from './not-found'
 import type { NavigateOptions, ResolveRelativePath, ToOptions } from './link'
-import type { NoInfer } from '@tanstack/react-store'
-import type { DeferredPromiseState } from './defer'
 
 //
 
@@ -639,7 +635,7 @@ export class Router<
     }
 
     if (
-      // eslint-disable-next-line ts/no-unnecessary-condition
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
       !this.history ||
       (this.options.history && this.options.history !== this.history)
     ) {
@@ -658,7 +654,7 @@ export class Router<
       this.buildRouteTree()
     }
 
-    // eslint-disable-next-line ts/no-unnecessary-condition
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     if (!this.__store) {
       this.__store = new Store(getInitialRouterState(this.latestLocation), {
         onUpdate: () => {
@@ -1546,9 +1542,9 @@ export class Router<
           await this.loadMatches({
             matches: pendingMatches,
             location: next,
-            // eslint-disable-next-line ts/require-await
+            // eslint-disable-next-line @typescript-eslint/require-await
             onReady: async () => {
-              // eslint-disable-next-line ts/require-await
+              // eslint-disable-next-line @typescript-eslint/require-await
               this.startViewTransition(async () => {
                 // this.viewTransitionPromise = createControlledPromise<true>()
 

package/src/useLoaderData.tsx

@@ -1,17 +1,18 @@
-import { type RegisteredRouter } from './router'
-import { type AnyRoute } from './route'
 import { useMatch } from './useMatch'
+import type { RegisteredRouter } from './router'
+import type { AnyRoute } from './route'
 import type { MakeRouteMatch } from './Matches'
 import type { RouteIds } from './routeInfo'
 import type { StrictOrFrom } from './utils'
 
 export type UseLoaderDataOptions<
+  TRouteTree extends AnyRoute,
   TFrom,
   TStrict extends boolean,
-  TRouteMatch,
+  TRouteMatch extends MakeRouteMatch<TRouteTree, TFrom, TStrict>,
   TSelected,
 > = StrictOrFrom<TFrom, TStrict> & {
-  select?: (match: TRouteMatch) => TSelected
+  select?: (match: Required<TRouteMatch>['loaderData']) => TSelected
 }
 
 export function useLoaderData<
@@ -25,13 +26,19 @@ export function useLoaderData<
   > = MakeRouteMatch<TRouteTree, TFrom, TStrict>,
   TSelected = Required<TRouteMatch>['loaderData'],
 >(
-  opts: UseLoaderDataOptions<TFrom, TStrict, TRouteMatch, TSelected>,
+  opts: UseLoaderDataOptions<
+    TRouteTree,
+    TFrom,
+    TStrict,
+    TRouteMatch,
+    TSelected
+  >,
 ): TSelected {
   return useMatch<TRouteTree, TFrom, TStrict, TRouteMatch, TSelected>({
     ...opts,
     select: (s) => {
       return typeof opts.select === 'function'
-        ? opts.select(s.loaderData as TRouteMatch)
+        ? opts.select(s.loaderData)
         : (s.loaderData as TSelected)
     },
   })

package/src/useLoaderDeps.tsx

@@ -1,6 +1,6 @@
-import { type RegisteredRouter } from './router'
-import { type AnyRoute } from './route'
 import { useMatch } from './useMatch'
+import type { RegisteredRouter } from './router'
+import type { AnyRoute } from './route'
 import type { MakeRouteMatch } from './Matches'
 import type { RouteIds } from './routeInfo'
 import type { StrictOrFrom } from './utils'

package/src/useMatch.tsx

@@ -1,9 +1,9 @@
 import * as React from 'react'
 import invariant from 'tiny-invariant'
 import { useRouterState } from './useRouterState'
-import { type RegisteredRouter } from './router'
-import { type AnyRoute } from './route'
 import { matchContext } from './matchContext'
+import type { RegisteredRouter } from './router'
+import type { AnyRoute } from './route'
 import type { MakeRouteMatch } from './Matches'
 import type { RouteIds } from './routeInfo'
 import type { StrictOrFrom } from './utils'

package/src/useNavigate.tsx

@@ -1,7 +1,5 @@
 import * as React from 'react'
-import { useMatch } from './useMatch'
 import { useRouter } from './useRouter'
-
 import type { FromPathOption, NavigateOptions } from './link'
 import type { RoutePaths } from './routeInfo'
 import type { AnyRouter, RegisteredRouter } from './router'
@@ -58,7 +56,6 @@ export function Navigate<
   TMaskTo extends string = '',
 >(props: NavigateOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>): null {
   const { navigate } = useRouter()
-  const match = useMatch({ strict: false })
 
   React.useEffect(() => {
     navigate({

package/src/useRouter.tsx

@@ -1,7 +1,7 @@
 import * as React from 'react'
 import warning from 'tiny-warning'
 import { getRouterContext } from './routerContext'
-import type { AnyRouter, RegisteredRouter, Router } from './router'
+import type { AnyRouter, RegisteredRouter } from './router'
 
 export function useRouter<TRouter extends AnyRouter = RegisteredRouter>(opts?: {
   warn?: boolean

package/src/useRouterState.tsx

@@ -1,6 +1,6 @@
 import { useStore } from '@tanstack/react-store'
 import { useRouter } from './useRouter'
-import type { AnyRouter, RegisteredRouter, Router, RouterState } from './router'
+import type { AnyRouter, RegisteredRouter, RouterState } from './router'
 
 export function useRouterState<
   TRouter extends AnyRouter = RegisteredRouter,

package/src/utils.ts

@@ -40,7 +40,7 @@ export type MakeDifferenceOptional<TLeft, TRight> = Omit<
 }
 
 // from https://stackoverflow.com/a/53955431
-// eslint-disable-next-line ts/naming-convention
+// eslint-disable-next-line @typescript-eslint/naming-convention
 export type IsUnion<T, U extends T = T> = (
   T extends any ? (U extends T ? false : true) : never
 ) extends false