@tanstack/react-router 0.0.1-beta.209 → 0.0.1-beta.210

package/build/types/CatchBoundary.d.ts

@@ -0,0 +1,33 @@
+import * as React from 'react';
+export declare function CatchBoundary(props: {
+    resetKey: string;
+    children: any;
+    errorComponent?: any;
+    onCatch: (error: any) => void;
+}): JSX.Element;
+export declare class CatchBoundaryImpl extends React.Component<{
+    resetKey: string;
+    children: (props: {
+        error: any;
+        reset: () => void;
+    }) => any;
+    onCatch?: (error: any) => void;
+}> {
+    state: any;
+    static getDerivedStateFromError(error: any): {
+        error: any;
+    };
+    componentDidUpdate(prevProps: Readonly<{
+        resetKey: string;
+        children: (props: {
+            error: any;
+            reset: () => void;
+        }) => any;
+        onCatch?: ((error: any, info: any) => void) | undefined;
+    }>, prevState: any): void;
+    componentDidCatch(error: any): void;
+    render(): any;
+}
+export declare function ErrorComponent({ error }: {
+    error: any;
+}): JSX.Element;

package/build/types/Matches.d.ts

@@ -0,0 +1,31 @@
+import * as React from 'react';
+import { RouteMatch } from './RouterProvider';
+import { ResolveRelativePath, ToOptions } from './link';
+import { AnyRoute, ReactNode } from './route';
+import { RouteById, RouteByPath, RouteIds, RoutePaths } from './routeInfo';
+import { RegisteredRouter } from './router';
+import { NoInfer, StrictOrFrom } from './utils';
+export declare function Matches(): JSX.Element;
+export declare function Match({ matches }: {
+    matches: RouteMatch[];
+}): JSX.Element;
+export declare function Outlet(): JSX.Element | null;
+export interface MatchRouteOptions {
+    pending?: boolean;
+    caseSensitive?: boolean;
+    includeSearch?: boolean;
+    fuzzy?: boolean;
+}
+export type MakeUseMatchRouteOptions<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = '/', TMaskTo extends string = ''> = ToOptions<AnyRoute, TFrom, TTo, TMaskFrom, TMaskTo> & MatchRouteOptions;
+export declare function useMatchRoute<TRouteTree extends AnyRoute = RegisteredRouter['routeTree']>(): <TFrom extends RoutePaths<TRouteTree> = "/", TTo extends string = "", TMaskFrom extends RoutePaths<TRouteTree> = "/", TMaskTo extends string = "", TResolved extends string = ResolveRelativePath<TFrom, NoInfer<TTo>>>(opts: MakeUseMatchRouteOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo>) => false | RouteById<TRouteTree, TResolved>["types"]["allParams"];
+export type MakeMatchRouteOptions<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = '/', TMaskTo extends string = ''> = ToOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> & MatchRouteOptions & {
+    children?: ((params?: RouteByPath<TRouteTree, ResolveRelativePath<TFrom, NoInfer<TTo>>>['types']['allParams']) => ReactNode) | React.ReactNode;
+};
+export declare function MatchRoute<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = '/', TMaskTo extends string = ''>(props: MakeMatchRouteOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo>): any;
+export declare function useMatch<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>, TStrict extends boolean = true, TRouteMatchState = RouteMatch<TRouteTree, TFrom>, TSelected = TRouteMatchState>(opts: StrictOrFrom<TFrom> & {
+    select?: (match: TRouteMatchState) => TSelected;
+}): TStrict extends true ? TRouteMatchState : TRouteMatchState | undefined;
+export declare const matchesContext: React.Context<RouteMatch<AnyRoute, any>[]>;
+export declare function useMatches<T = RouteMatch[]>(opts?: {
+    select?: (matches: RouteMatch[]) => T;
+}): T;

package/build/types/RouterProvider.d.ts

@@ -1,17 +1,16 @@
+import { RouterHistory } from '@tanstack/history';
 import * as React from 'react';
-import { RegisteredRouter, DehydratedRouteMatch, RouterOptions } from './router';
-import { ParsedLocation } from './location';
-import { RouteMatch } from './RouteMatch';
-import { NoInfer } from './utils';
-import { RouterProps } from './react';
-import { RouteById, RoutePaths, RoutesById } from './routeInfo';
 import { LinkInfo, LinkOptions, NavigateOptions, ResolveRelativePath, ToOptions } from './link';
-import { RouterHistory } from '.';
+import { ParsedLocation } from './location';
 import { AnyRoute } from './route';
-import { RouterState } from './router';
+import { FullSearchSchema, ParseRoute, RouteById, RouteIds, RoutePaths, RoutesById } from './routeInfo';
+import { BuildNextOptions, DehydratedRouteMatch, RegisteredRouter, Router, RouterOptions, RouterState } from './router';
+import { NoInfer } from './utils';
+import { MatchRouteOptions } from './Matches';
 export interface CommitLocationOptions {
     replace?: boolean;
     resetScroll?: boolean;
+    startTransition?: boolean;
 }
 export interface MatchLocation {
     to?: string | number | null;
@@ -19,20 +18,15 @@ export interface MatchLocation {
     caseSensitive?: boolean;
     from?: string;
 }
-export interface MatchRouteOptions {
-    pending?: boolean;
-    caseSensitive?: boolean;
-    includeSearch?: boolean;
-    fuzzy?: boolean;
-}
-export type BuildLinkFn<TRouteTree extends AnyRoute> = <TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = ''>(state: RouterState, dest: LinkOptions<TRouteTree, TFrom, TTo>) => LinkInfo;
+export type BuildLinkFn<TRouteTree extends AnyRoute> = <TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = ''>(dest: LinkOptions<TRouteTree, TFrom, TTo>) => LinkInfo;
 export type NavigateFn<TRouteTree extends AnyRoute> = <TRouteTree extends AnyRoute, TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = TFrom, TMaskTo extends string = ''>({ from, to, ...rest }: NavigateOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo>) => Promise<void>;
-export type MatchRouteFn<TRouteTree extends AnyRoute> = <TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TResolved = ResolveRelativePath<TFrom, NoInfer<TTo>>>(state: RouterState<TRouteTree>, location: ToOptions<TRouteTree, TFrom, TTo>, opts?: MatchRouteOptions) => false | RouteById<TRouteTree, TResolved>['types']['allParams'];
+export type MatchRouteFn<TRouteTree extends AnyRoute> = <TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TResolved = ResolveRelativePath<TFrom, NoInfer<TTo>>>(location: ToOptions<TRouteTree, TFrom, TTo>, opts?: MatchRouteOptions) => false | RouteById<TRouteTree, TResolved>['types']['allParams'];
 export type LoadFn = (opts?: {
     next?: ParsedLocation;
     throwOnError?: boolean;
     __dehydratedMatches?: DehydratedRouteMatch[];
 }) => Promise<void>;
+export type BuildLocationFn<TRouteTree extends AnyRoute> = (opts: BuildNextOptions) => ParsedLocation;
 export type RouterContext<TRouteTree extends AnyRoute> = {
     buildLink: BuildLinkFn<TRouteTree>;
     state: RouterState<TRouteTree>;
@@ -43,12 +37,42 @@ export type RouterContext<TRouteTree extends AnyRoute> = {
     options: RouterOptions<TRouteTree>;
     history: RouterHistory;
     load: LoadFn;
+    buildLocation: BuildLocationFn<TRouteTree>;
 };
 export declare const routerContext: React.Context<RouterContext<any>>;
-export declare function getInitialRouterState(location: ParsedLocation): RouterState<any>;
-export declare function RouterProvider<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TDehydrated extends Record<string, any> = Record<string, any>>({ router, ...rest }: RouterProps<TRouteTree, TDehydrated>): JSX.Element;
 export declare class SearchParamError extends Error {
 }
 export declare class PathParamError extends Error {
 }
+export declare function getInitialRouterState(location: ParsedLocation): RouterState<any>;
+export declare function RouterProvider<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TDehydrated extends Record<string, any> = Record<string, any>>({ router, ...rest }: RouterProps<TRouteTree, TDehydrated>): JSX.Element;
 export declare function getRouteMatch<TRouteTree extends AnyRoute>(state: RouterState<TRouteTree>, id: string): undefined | RouteMatch<TRouteTree>;
+export declare function useRouterState<TSelected = RouterState<RegisteredRouter['routeTree']>>(opts?: {
+    select: (state: RouterState<RegisteredRouter['routeTree']>) => TSelected;
+}): TSelected;
+export type RouterProps<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TDehydrated extends Record<string, any> = Record<string, any>> = Omit<RouterOptions<TRouteTree, TDehydrated>, 'context'> & {
+    router: Router<TRouteTree>;
+    context?: Partial<RouterOptions<TRouteTree, TDehydrated>['context']>;
+};
+export declare function useRouter<TRouteTree extends AnyRoute = RegisteredRouter['routeTree']>(): RouterContext<TRouteTree>;
+export interface RouteMatch<TRouteTree extends AnyRoute = AnyRoute, TRouteId extends RouteIds<TRouteTree> = ParseRoute<TRouteTree>['id']> {
+    id: string;
+    routeId: TRouteId;
+    pathname: string;
+    params: RouteById<TRouteTree, TRouteId>['types']['allParams'];
+    status: 'pending' | 'success' | 'error';
+    isFetching: boolean;
+    invalid: boolean;
+    error: unknown;
+    paramsError: unknown;
+    searchError: unknown;
+    updatedAt: number;
+    loadPromise?: Promise<void>;
+    __resolveLoadPromise?: () => void;
+    context: RouteById<TRouteTree, TRouteId>['types']['allContext'];
+    routeSearch: RouteById<TRouteTree, TRouteId>['types']['searchSchema'];
+    search: FullSearchSchema<TRouteTree> & RouteById<TRouteTree, TRouteId>['types']['fullSearchSchema'];
+    fetchedAt: number;
+    abortController: AbortController;
+}
+export type AnyRouteMatch = RouteMatch<any>;

package/build/types/fileRoute.d.ts

@@ -12,20 +12,20 @@ export type FileRoutePath<TParentRoute extends AnyRoute, TFilePath extends strin
 export declare class FileRoute<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;
     constructor(path: TFilePath);
-    createRoute: <TSearchSchema extends import("./route").AnySearchSchema = {}, TFullSearchSchema extends import("./route").AnySearchSchema = Expand<Assign<import("./route").InferFullSearchSchema<TParentRoute>, TSearchSchema>>, TParams extends Record<string, any> = (TrimLeft<TrimRight<import("./link").Split<TPath, true>[number], "_">, "_"> extends infer T ? T extends TrimLeft<TrimRight<import("./link").Split<TPath, true>[number], "_">, "_"> ? T extends `$${infer L}` ? L : never : never : never) extends never ? AnyPathParams : Record<TrimLeft<TrimRight<import("./link").Split<TPath, true>[number], "_">, "_"> extends infer T ? T extends TrimLeft<TrimRight<import("./link").Split<TPath, true>[number], "_">, "_"> ? T extends `$${infer L}` ? L : never : never : never, string>, TAllParams extends Record<string, any> = IsAny<TParentRoute["types"]["allParams"], TParams, TParentRoute["types"]["allParams"] & TParams>, TRouteContext extends RouteContext = RouteContext, TContext extends Expand<Assign<IsAny<TParentRoute["types"]["allContext"], {}, TParentRoute["types"]["allContext"]>, TRouteContext>> = Expand<Assign<IsAny<TParentRoute["types"]["allContext"], {}, TParentRoute["types"]["allContext"]>, TRouteContext>>, TRouterContext extends AnyContext = AnyContext, TChildren extends unknown = unknown, TRouteTree extends AnyRoute = AnyRoute>(options: Omit<RouteOptions<TParentRoute, string, string, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TRouteContext, TContext>, "id" | "path" | "getParentRoute"> & {
+    createRoute: <TSearchSchema extends import("./route").AnySearchSchema = {}, TFullSearchSchema extends import("./route").AnySearchSchema = Expand<Assign<import("./route").InferFullSearchSchema<TParentRoute>, TSearchSchema>>, TParams extends Record<string, any> = (TrimLeft<TrimRight<import("./link").Split<TPath, true>[number], "_">, "_"> extends infer T ? T extends TrimLeft<TrimRight<import("./link").Split<TPath, true>[number], "_">, "_"> ? T extends `$${infer L}` ? L : never : never : never) extends never ? AnyPathParams : Record<TrimLeft<TrimRight<import("./link").Split<TPath, true>[number], "_">, "_"> extends infer T ? T extends TrimLeft<TrimRight<import("./link").Split<TPath, true>[number], "_">, "_"> ? T extends `$${infer L}` ? L : never : never : never, string>, TAllParams extends Record<string, any> = IsAny<TParentRoute["types"]["allParams"], TParams, TParentRoute["types"]["allParams"] & TParams>, TRouteContext extends RouteContext = RouteContext, TContext extends Expand<Assign<IsAny<TParentRoute["types"]["allContext"], {}, TParentRoute["types"]["allContext"]>, TRouteContext>> = Expand<Assign<IsAny<TParentRoute["types"]["allContext"], {}, TParentRoute["types"]["allContext"]>, TRouteContext>>, TRouterContext extends AnyContext = AnyContext, TChildren extends unknown = unknown, TRouteTree extends AnyRoute = AnyRoute>(options: Omit<RouteOptions<TParentRoute, string, string, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TRouteContext, TContext>, "path" | "id" | "getParentRoute"> & {
         meta?: import("./route").RouteMeta | undefined;
     } & {
         caseSensitive?: boolean | undefined;
         wrapInSuspense?: boolean | undefined;
-        component?: import("./react").RouteComponent<TFullSearchSchema, TAllParams, TContext> | undefined;
-        errorComponent?: import("./react").ErrorRouteComponent<TFullSearchSchema, TAllParams, {}> | undefined;
-        pendingComponent?: import("./react").PendingRouteComponent<TFullSearchSchema, TAllParams, TContext> | undefined;
+        component?: import("./route").RouteComponent<TFullSearchSchema, TAllParams, TContext> | undefined;
+        errorComponent?: import("./route").ErrorRouteComponent<TFullSearchSchema, TAllParams, {}> | undefined;
+        pendingComponent?: import("./route").PendingRouteComponent<TFullSearchSchema, TAllParams, TContext> | undefined;
         preSearchFilters?: import("./route").SearchFilter<TFullSearchSchema, TFullSearchSchema>[] | undefined;
         postSearchFilters?: import("./route").SearchFilter<TFullSearchSchema, TFullSearchSchema>[] | undefined;
         onError?: ((err: any) => void) | undefined;
-        onEnter?: ((match: import("./RouteMatch").AnyRouteMatch) => void) | undefined;
-        onTransition?: ((match: import("./RouteMatch").AnyRouteMatch) => void) | undefined;
-        onLeave?: ((match: import("./RouteMatch").AnyRouteMatch) => void) | undefined;
+        onEnter?: ((match: import("./RouterProvider").AnyRouteMatch) => void) | undefined;
+        onTransition?: ((match: import("./RouterProvider").AnyRouteMatch) => void) | undefined;
+        onLeave?: ((match: import("./RouterProvider").AnyRouteMatch) => void) | undefined;
         reloadOnWindowFocus?: boolean | undefined;
     }) => Route<TParentRoute, TPath, TFullPath, TFilePath, TId, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TRouteContext, TContext, TRouterContext, TChildren, TRouteTree>;
 }

package/build/types/index.d.ts

@@ -1,18 +1,24 @@
 export * from '@tanstack/history';
 export { default as invariant } from 'tiny-invariant';
 export { default as warning } from 'tiny-warning';
+export * from './CatchBoundary';
+export * from './fileRoute';
+export * from './history';
+export * from './index';
+export * from './lazyRouteComponent';
 export * from './link';
+export * from './location';
+export * from './Matches';
 export * from './path';
 export * from './qss';
+export * from './redirects';
 export * from './route';
-export * from './fileRoute';
 export * from './routeInfo';
 export * from './router';
+export * from './RouterProvider';
 export * from './searchParams';
+export * from './useBlocker';
+export * from './useNavigate';
+export * from './useParams';
+export * from './useSearch';
 export * from './utils';
-export * from './react';
-export * from './history';
-export * from './RouteMatch';
-export * from './redirects';
-export * from './location';
-export * from './RouterProvider';

package/build/types/lazyRouteComponent.d.ts

@@ -0,0 +1,2 @@
+import { AsyncRouteComponent } from './route';
+export declare function lazyRouteComponent<T extends Record<string, any>, TKey extends keyof T = 'default'>(importer: () => Promise<T>, exportName?: TKey): T[TKey] extends (props: infer TProps) => any ? AsyncRouteComponent<TProps> : never;

package/build/types/link.d.ts

@@ -1,9 +1,10 @@
+import * as React from 'react';
 import { Trim } from './fileRoute';
-import { AnyRoute } from './route';
+import { LocationState, ParsedLocation } from './location';
+import { AnyRoute, ReactNode } from './route';
 import { AllParams, FullSearchSchema, RouteByPath, RouteIds, RoutePaths } from './routeInfo';
 import { RegisteredRouter } from './router';
-import { LocationState } from './location';
-import { ParsedLocation } from './location';
+import { MakeLinkOptions, MakeLinkPropsOptions } from './useNavigate';
 import { Expand, NoInfer, NonNullableUpdater, PickRequired, UnionToIntersection, Updater } from './utils';
 export type LinkInfo = {
     type: 'external';
@@ -42,6 +43,7 @@ export type RelativeToPathAutoComplete<AllPaths extends string, TFrom extends st
 export type NavigateOptions<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = TFrom, TMaskTo extends string = ''> = ToOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> & {
     replace?: boolean;
     resetScroll?: boolean;
+    startTransition?: boolean;
 };
 export type ToOptions<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = '/', TMaskTo extends string = ''> = ToSubOptions<TRouteTree, TFrom, TTo> & {
     mask?: ToMaskOptions<TRouteTree, TMaskFrom, TMaskTo>;
@@ -95,4 +97,9 @@ export type CheckIdError<TRouteTree extends AnyRoute, TInvalids> = {
     'Valid Route IDs': RouteIds<TRouteTree>;
 };
 export type ResolveRelativePath<TFrom, TTo = '.'> = 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>]>> : never : never;
+export declare function useLinkProps<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = '/', TMaskTo extends string = ''>(options: MakeLinkPropsOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo>): React.AnchorHTMLAttributes<HTMLAnchorElement>;
+export interface LinkComponent<TProps extends Record<string, any> = {}> {
+    <TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = '/', TMaskTo extends string = ''>(props: MakeLinkOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> & TProps & React.RefAttributes<HTMLAnchorElement>): ReactNode;
+}
+export declare const Link: LinkComponent;
 export {};

package/build/types/route.d.ts

@@ -1,10 +1,11 @@
-import { RoutePaths } from './routeInfo';
-import { AnyRouter } from './router';
-import { AnyRouteMatch } from './RouteMatch';
-import { Expand, IsAny, NoInfer, PickRequired, UnionToIntersection, Assign } from './utils';
+import * as React from 'react';
+import { AnyRouteMatch } from './RouterProvider';
 import { NavigateOptions, ParsePathParams, ToSubOptions } from './link';
-import { ErrorRouteComponent, PendingRouteComponent, RouteComponent } from './react';
 import { ParsedLocation } from './location';
+import { RoutePaths } from './routeInfo';
+import { AnyRouter } from './router';
+import { Assign, Expand, IsAny, NoInfer, PickRequired, UnionToIntersection } from './utils';
+import { BuildLocationFn, NavigateFn } from './RouterProvider';
 export declare const rootRouteId: "__root__";
 export type RootRouteId = typeof rootRouteId;
 export type AnyPathParams = {};
@@ -53,7 +54,8 @@ type BeforeLoadFn<TFullSearchSchema extends Record<string, any>, TParentRoute ex
     params: TAllParams;
     context: TParentRoute['types']['allContext'];
     location: ParsedLocation;
-    navigate: (opts: NavigateOptions<AnyRoute>) => Promise<void>;
+    navigate: NavigateFn<AnyRoute>;
+    buildLocation: BuildLocationFn<AnyRoute>;
 }) => Promise<TRouteContext> | TRouteContext | void;
 export type UpdatableRouteOptions<TFullSearchSchema extends Record<string, any>, TAllParams extends AnyPathParams, TAllContext extends AnyContext> = MetaOptions & {
     caseSensitive?: boolean;
@@ -183,7 +185,7 @@ export declare class Route<TParentRoute extends RouteConstraints['TParentRoute']
     } | undefined) => TSelected;
 }
 export type AnyRootRoute = RootRoute<any, any, any>;
-export declare function rootRouteWithContext<TRouterContext extends {}>(): <TSearchSchema extends Record<string, any> = {}, TRouteContext extends RouteContext = RouteContext>(options?: Omit<RouteOptions<AnyRoute, "__root__", "", TSearchSchema, TSearchSchema, {}, {}, TRouteContext, Assign<TRouterContext, TRouteContext>>, "id" | "path" | "getParentRoute" | "stringifyParams" | "parseParams" | "caseSensitive"> | undefined) => RootRoute<TSearchSchema, TRouteContext, TRouterContext>;
+export declare function rootRouteWithContext<TRouterContext extends {}>(): <TSearchSchema extends Record<string, any> = {}, TRouteContext extends RouteContext = RouteContext>(options?: Omit<RouteOptions<AnyRoute, "__root__", "", TSearchSchema, TSearchSchema, {}, {}, TRouteContext, Assign<TRouterContext, TRouteContext>>, "path" | "id" | "getParentRoute" | "stringifyParams" | "parseParams" | "caseSensitive"> | undefined) => RootRoute<TSearchSchema, TRouteContext, TRouterContext>;
 export declare class RootRoute<TSearchSchema extends Record<string, any> = {}, TRouteContext extends RouteContext = RouteContext, TRouterContext extends {} = {}> extends Route<any, // TParentRoute
 '/', // TPath
 '/', // TFullPath
@@ -226,4 +228,34 @@ export type RouteMask<TRouteTree extends AnyRoute> = {
 export declare function createRouteMask<TRouteTree extends AnyRoute, TFrom extends RoutePaths<TRouteTree>, TTo extends string>(opts: {
     routeTree: TRouteTree;
 } & ToSubOptions<TRouteTree, TFrom, TTo>): RouteMask<TRouteTree>;
+export type RouteProps<TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> = {
+    useMatch: <TSelected = TAllContext>(opts?: {
+        select?: (search: TAllContext) => TSelected;
+    }) => TSelected;
+    useRouteContext: <TSelected = TAllContext>(opts?: {
+        select?: (search: TAllContext) => TSelected;
+    }) => TSelected;
+    useSearch: <TSelected = TFullSearchSchema>(opts?: {
+        select?: (search: TFullSearchSchema) => TSelected;
+    }) => TSelected;
+    useParams: <TSelected = TAllParams>(opts?: {
+        select?: (search: TAllParams) => TSelected;
+    }) => TSelected;
+};
+export type ErrorRouteProps<TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> = {
+    error: unknown;
+    info: {
+        componentStack: string;
+    };
+} & RouteProps<TFullSearchSchema, TAllParams, TAllContext>;
+export type PendingRouteProps<TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> = RouteProps<TFullSearchSchema, TAllParams, TAllContext>;
+export type ReactNode = any;
+export type SyncRouteComponent<TProps> = ((props: TProps) => ReactNode) | React.LazyExoticComponent<(props: TProps) => ReactNode>;
+export type AsyncRouteComponent<TProps> = SyncRouteComponent<TProps> & {
+    preload?: () => Promise<void>;
+};
+export type RouteComponent<TFullSearchSchema extends Record<string, any>, TAllParams extends AnyPathParams, TAllContext extends Record<string, any>> = AsyncRouteComponent<RouteProps<TFullSearchSchema, TAllParams, TAllContext>>;
+export type ErrorRouteComponent<TFullSearchSchema extends Record<string, any>, TAllParams extends AnyPathParams, TAllContext extends Record<string, any>> = AsyncRouteComponent<ErrorRouteProps<TFullSearchSchema, TAllParams, TAllContext>>;
+export type PendingRouteComponent<TFullSearchSchema extends Record<string, any>, TAllParams extends AnyPathParams, TAllContext extends Record<string, any>> = AsyncRouteComponent<PendingRouteProps<TFullSearchSchema, TAllParams, TAllContext>>;
+export type AnyRouteComponent = RouteComponent<any, any, any>;
 export {};

package/build/types/router.d.ts

@@ -3,8 +3,8 @@ import { RouterHistory } from '@tanstack/history';
 import { AnySearchSchema, AnyRoute, AnyContext, AnyPathParams, RouteMask } from './route';
 import { FullSearchSchema } from './routeInfo';
 import { PickAsRequired, Updater, NonNullableUpdater } from './utils';
-import { ErrorRouteComponent, PendingRouteComponent, RouteComponent } from './react';
-import { RouteMatch } from './RouteMatch';
+import { ErrorRouteComponent, PendingRouteComponent, RouteComponent } from './route';
+import { RouteMatch } from './RouterProvider';
 import { ParsedLocation } from './location';
 import { LocationState } from './location';
 import { SearchSerializer, SearchParser } from './searchParams';
@@ -54,12 +54,11 @@ export interface RouterOptions<TRouteTree extends AnyRoute, TDehydrated extends
     unmaskOnReload?: boolean;
 }
 export interface RouterState<TRouteTree extends AnyRoute = AnyRoute> {
-    status: 'idle' | 'pending';
-    isFetching: boolean;
+    status: 'pending' | 'idle';
     matches: RouteMatch<TRouteTree>[];
     pendingMatches: RouteMatch<TRouteTree>[];
     location: ParsedLocation<FullSearchSchema<TRouteTree>>;
-    resolvedLocation: ParsedLocation<FullSearchSchema<TRouteTree>>;
+    resolvedLocation: undefined | ParsedLocation<FullSearchSchema<TRouteTree>>;
     lastUpdated: number;
 }
 export type ListenerFn<TEvent extends RouterEvent> = (event: TEvent) => void;
@@ -91,13 +90,13 @@ export declare const componentTypes: readonly ["component", "errorComponent", "p
 export type RouterEvents = {
     onBeforeLoad: {
         type: 'onBeforeLoad';
-        from: ParsedLocation;
+        from: undefined | ParsedLocation;
         to: ParsedLocation;
         pathChanged: boolean;
     };
     onLoad: {
         type: 'onLoad';
-        from: ParsedLocation;
+        from: undefined | ParsedLocation;
         to: ParsedLocation;
         pathChanged: boolean;
     };

package/build/types/useBlocker.d.ts

@@ -0,0 +1,8 @@
+import { ReactNode } from './route';
+export declare function useBlocker(message: string, condition?: boolean | any): void;
+export declare function Block({ message, condition, children }: PromptProps): any;
+export type PromptProps = {
+    message: string;
+    condition?: boolean | any;
+    children?: ReactNode;
+};

package/build/types/useNavigate.d.ts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import { LinkOptions, NavigateOptions } from './link';
+import { AnyRoute } from './route';
+import { RoutePaths } from './routeInfo';
+import { RegisteredRouter } from './router';
+export declare function useNavigate<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TDefaultFrom extends RoutePaths<TRouteTree> = '/'>(defaultOpts?: {
+    from?: TDefaultFrom;
+}): <TFrom extends RoutePaths<TRouteTree> = TDefaultFrom, TTo extends string = "", TMaskFrom extends RoutePaths<TRouteTree> = "/", TMaskTo extends string = "">(opts?: NavigateOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> | undefined) => Promise<void>;
+export declare function typedNavigate<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TDefaultFrom extends RoutePaths<TRouteTree> = '/'>(navigate: (opts: NavigateOptions<any>) => Promise<void>): <TFrom extends RoutePaths<TRouteTree> = TDefaultFrom, TTo extends string = "", TMaskFrom extends RoutePaths<TRouteTree> = "/", TMaskTo extends string = "">(opts?: NavigateOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> | undefined) => Promise<void>;
+export declare function Navigate<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = '/', TMaskTo extends string = ''>(props: NavigateOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo>): null;
+export type MakeLinkPropsOptions<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = '/', TMaskTo extends string = ''> = LinkPropsOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> & React.AnchorHTMLAttributes<HTMLAnchorElement>;
+export type MakeLinkOptions<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = '/', TMaskTo extends string = ''> = LinkPropsOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> & Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, 'children'> & {
+    children?: React.ReactNode | ((state: {
+        isActive: boolean;
+    }) => React.ReactNode);
+};
+export type LinkPropsOptions<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = '/', TMaskTo extends string = ''> = LinkOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> & {
+    activeProps?: React.AnchorHTMLAttributes<HTMLAnchorElement> | (() => React.AnchorHTMLAttributes<HTMLAnchorElement>);
+    inactiveProps?: React.AnchorHTMLAttributes<HTMLAnchorElement> | (() => React.AnchorHTMLAttributes<HTMLAnchorElement>);
+};

package/build/types/useParams.d.ts

@@ -0,0 +1,7 @@
+import { AnyRoute } from './route';
+import { RouteIds, RouteById, AllParams } from './routeInfo';
+import { RegisteredRouter } from './router';
+import { StrictOrFrom } from './utils';
+export declare function useParams<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>, TDefaultSelected = AllParams<TRouteTree> & RouteById<TRouteTree, TFrom>['types']['allParams'], TSelected = TDefaultSelected>(opts: StrictOrFrom<TFrom> & {
+    select?: (search: TDefaultSelected) => TSelected;
+}): TSelected;

package/build/types/useSearch.d.ts

@@ -0,0 +1,7 @@
+import { AnyRoute } from './route';
+import { RouteIds, RouteById } from './routeInfo';
+import { RegisteredRouter } from './router';
+import { StrictOrFrom } from './utils';
+export declare function useSearch<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>, TStrict extends boolean = true, TSearch = RouteById<TRouteTree, TFrom>['types']['fullSearchSchema'], TSelected = TSearch>(opts: StrictOrFrom<TFrom> & {
+    select?: (search: TSearch) => TSelected;
+}): TStrict extends true ? TSelected : TSelected | undefined;

package/build/types/utils.d.ts

@@ -1,3 +1,7 @@
+import * as React from 'react';
+import { AnyRoute } from './route';
+import { ParseRoute, RouteIds, RoutesById, RouteById } from './routeInfo';
+import { RegisteredRouter } from './router';
 export type NoInfer<T> = [T][T extends any ? 0 : never];
 export type IsAny<T, Y, N = T> = 1 extends 0 & T ? Y : N;
 export type IsAnyBoolean<T> = 1 extends 0 & T ? true : false;
@@ -46,3 +50,16 @@ export declare function replaceEqualDeep<T>(prev: any, _next: T): T;
 export declare function isPlainObject(o: any): boolean;
 export declare function partialDeepEqual(a: any, b: any): boolean;
 export declare function useStableCallback<T extends (...args: any[]) => any>(fn: T): T;
+export declare function shallow<T>(objA: T, objB: T): boolean;
+export type StrictOrFrom<TFrom> = {
+    from: TFrom;
+    strict?: true;
+} | {
+    from?: never;
+    strict: false;
+};
+export type RouteFromIdOrRoute<T, TRouteTree extends AnyRoute = RegisteredRouter['routeTree']> = T extends ParseRoute<TRouteTree> ? T : T extends RouteIds<TRouteTree> ? RoutesById<TRouteTree>[T] : T extends string ? RouteIds<TRouteTree> : never;
+export declare function useRouteContext<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>, TStrict extends boolean = true, TRouteContext = RouteById<TRouteTree, TFrom>['types']['allContext'], TSelected = TRouteContext>(opts: StrictOrFrom<TFrom> & {
+    select?: (search: TRouteContext) => TSelected;
+}): TStrict extends true ? TSelected : TSelected | undefined;
+export declare const useLayoutEffect: typeof React.useLayoutEffect;