@tanstack/react-router 0.0.1-beta.269 → 0.0.1-beta.270

package/build/types/Matches.d.ts

@@ -13,14 +13,12 @@ export interface RouteMatch<TRouteTree extends AnyRoute = AnyRoute, TRouteId ext
     status: 'pending' | 'success' | 'error';
     isFetching: boolean;
     showPending: boolean;
-    invalid: boolean;
     error: unknown;
     paramsError: unknown;
     searchError: unknown;
     updatedAt: number;
     loadPromise?: Promise<void>;
     loaderData?: RouteById<TRouteTree, TRouteId>['types']['loaderData'];
-    __resolveLoadPromise?: () => void;
     routeContext: RouteById<TRouteTree, TRouteId>['types']['routeContext'];
     context: RouteById<TRouteTree, TRouteId>['types']['allContext'];
     search: FullSearchSchema<TRouteTree> & RouteById<TRouteTree, TRouteId>['types']['fullSearchSchema'];
@@ -41,8 +39,8 @@ export interface MatchRouteOptions {
     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 UseMatchRouteOptions<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: UseMatchRouteOptions<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;
 };
@@ -53,6 +51,9 @@ export declare function useMatch<TRouteTree extends AnyRoute = RegisteredRouter[
 export declare function useMatches<T = RouteMatch[]>(opts?: {
     select?: (matches: RouteMatch[]) => T;
 }): T;
+export declare function useParentMatches<T = RouteMatch[]>(opts?: {
+    select?: (matches: RouteMatch[]) => T;
+}): T;
 export declare function useLoaderData<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>, TStrict extends boolean = true, TRouteMatch extends RouteMatch<TRouteTree, TFrom> = RouteMatch<TRouteTree, TFrom>, TSelected = Required<TRouteMatch>['loaderData']>(opts: StrictOrFrom<TFrom> & {
     select?: (match: TRouteMatch) => TSelected;
 }): TStrict extends true ? TSelected : TSelected | undefined;

package/build/types/fileRoute.d.ts

@@ -18,16 +18,16 @@ export declare class FileRoute<TFilePath extends keyof FileRoutesByPath, TParent
     } & {
         caseSensitive?: boolean | undefined;
         wrapInSuspense?: boolean | undefined;
-        component?: import("./route").RouteComponent<TFullSearchSchema, TAllParams, TContext, TLoaderData> | undefined;
-        errorComponent?: import("./route").ErrorRouteComponent<TFullSearchSchema, TAllParams, TContext> | undefined;
-        pendingComponent?: import("./route").PendingRouteComponent<TFullSearchSchema, TAllParams, TContext> | undefined;
+        component?: import("./route").RouteComponent | undefined;
+        errorComponent?: false | import("./route").RouteComponent | null | undefined;
+        pendingComponent?: import("./route").RouteComponent | undefined;
         pendingMs?: number | undefined;
         pendingMinMs?: number | undefined;
         preSearchFilters?: import("./route").SearchFilter<TFullSearchSchema, TFullSearchSchema>[] | undefined;
         postSearchFilters?: import("./route").SearchFilter<TFullSearchSchema, TFullSearchSchema>[] | undefined;
         onError?: ((err: any) => void) | undefined;
         onEnter?: ((match: import("./Matches").AnyRouteMatch) => void) | undefined;
-        onTransition?: ((match: import("./Matches").AnyRouteMatch) => void) | undefined;
+        onStay?: ((match: import("./Matches").AnyRouteMatch) => void) | undefined;
         onLeave?: ((match: import("./Matches").AnyRouteMatch) => void) | undefined;
     }) | undefined) => Route<TParentRoute, TPath, TFullPath, TFilePath, TId, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TRouteContext, TContext, TRouterContext, TLoaderData, TChildren, TRouteTree>;
 }

package/build/types/lazyRouteComponent.d.ts

@@ -1,2 +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;
+import { RouteComponent } 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: any) => any ? RouteComponent : never;

package/build/types/link.d.ts

@@ -1,11 +1,11 @@
 import * as React from 'react';
 import { Trim } from './fileRoute';
-import { LocationState } from './location';
 import { AnyRoute, ReactNode } from './route';
 import { AllParams, FullSearchSchema, RouteByPath, RouteIds, RoutePaths } from './routeInfo';
 import { RegisteredRouter } from './router';
-import { MakeLinkOptions, MakeLinkPropsOptions } from './useNavigate';
+import { LinkProps, UseLinkPropsOptions } from './useNavigate';
 import { Expand, NoInfer, NonNullableUpdater, PickRequired, UnionToIntersection, Updater } from './utils';
+import { HistoryState } from '@tanstack/history';
 export type CleanPath<T extends string> = T extends `${infer L}//${infer R}` ? CleanPath<`${CleanPath<L>}/${CleanPath<R>}`> : T extends `${infer L}//` ? `${CleanPath<L>}/` : T extends `//${infer L}` ? `/${CleanPath<L>}` : T;
 export type Split<S, TIncludeTrailingSlash = true> = S extends unknown ? string extends S ? string[] : S extends string ? CleanPath<S> extends '' ? [] : TIncludeTrailingSlash extends true ? CleanPath<S> extends `${infer T}/` ? [...Split<T>, '/'] : CleanPath<S> extends `/${infer U}` ? Split<U> : CleanPath<S> extends `${infer T}/${infer U}` ? [...Split<T>, ...Split<U>] : [S] : CleanPath<S> extends `${infer T}/${infer U}` ? [...Split<T>, ...Split<U>] : S extends string ? [S] : never : never : never;
 export type ParsePathParams<T extends string> = keyof {
@@ -40,7 +40,7 @@ export type ToMaskOptions<TRouteTree extends AnyRoute = RegisteredRouter['routeT
 export type ToSubOptions<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TResolved = ResolveRelativePath<TFrom, NoInfer<TTo>>> = {
     to?: ToPathOption<TRouteTree, TFrom, TTo>;
     hash?: true | Updater<string>;
-    state?: true | NonNullableUpdater<LocationState>;
+    state?: true | NonNullableUpdater<HistoryState>;
     from?: TFrom;
 } & CheckPath<TRouteTree, NoInfer<TResolved>, {}> & SearchParamOptions<TRouteTree, TFrom, TTo, TResolved> & PathParamOptions<TRouteTree, TFrom, TResolved>;
 export type SearchParamOptions<TRouteTree extends AnyRoute, TFrom, TTo, TResolved = ResolveRelativePath<TFrom, NoInfer<TTo>>, TFromSearchEnsured = '/' extends TFrom ? FullSearchSchema<TRouteTree> : Expand<UnionToIntersection<PickRequired<RouteByPath<TRouteTree, TFrom>['types']['fullSearchSchema']>>>, TFromSearchOptional = Omit<AllParams<TRouteTree>, keyof TFromSearchEnsured>, TFromSearch = Expand<TFromSearchEnsured & TFromSearchOptional>, TToSearch = '' extends TTo ? FullSearchSchema<TRouteTree> : Expand<RouteByPath<TRouteTree, TResolved>['types']['fullSearchSchema']>> = keyof PickRequired<TToSearch> extends never ? {
@@ -83,9 +83,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 declare function useLinkProps<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = '/', TMaskTo extends string = ''>(options: UseLinkPropsOptions<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;
+    <TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = '/', TMaskTo extends string = ''>(props: LinkProps<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> & TProps & React.RefAttributes<HTMLAnchorElement>): ReactNode;
 }
 export declare const Link: LinkComponent;
 export {};

package/build/types/location.d.ts

@@ -10,5 +10,3 @@ export interface ParsedLocation<TSearchObj extends AnySearchSchema = {}> {
     maskedLocation?: ParsedLocation<TSearchObj>;
     unmaskOnReload?: boolean;
 }
-export interface LocationState {
-}

package/build/types/route.d.ts

@@ -29,7 +29,7 @@ export type MetaOptions = keyof PickRequired<RouteMeta> extends never ? {
 } : {
     meta: RouteMeta;
 };
-export type RouteOptions<TParentRoute extends AnyRoute = AnyRoute, TCustomId extends string = string, TPath extends string = string, TSearchSchema extends Record<string, any> = {}, TFullSearchSchema extends Record<string, any> = TSearchSchema, TParams extends AnyPathParams = AnyPathParams, TAllParams extends AnyPathParams = TParams, TRouteContext extends RouteContext = RouteContext, TAllContext extends Record<string, any> = AnyContext, TLoaderData extends any = unknown> = BaseRouteOptions<TParentRoute, TCustomId, TPath, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TRouteContext, TAllContext, TLoaderData> & UpdatableRouteOptions<NoInfer<TFullSearchSchema>, NoInfer<TAllParams>, NoInfer<TAllContext>, NoInfer<TLoaderData>>;
+export type RouteOptions<TParentRoute extends AnyRoute = AnyRoute, TCustomId extends string = string, TPath extends string = string, TSearchSchema extends Record<string, any> = {}, TFullSearchSchema extends Record<string, any> = TSearchSchema, TParams extends AnyPathParams = AnyPathParams, TAllParams extends AnyPathParams = TParams, TRouteContext extends RouteContext = RouteContext, TAllContext extends Record<string, any> = AnyContext, TLoaderData extends any = unknown> = BaseRouteOptions<TParentRoute, TCustomId, TPath, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TRouteContext, TAllContext, TLoaderData> & UpdatableRouteOptions<NoInfer<TFullSearchSchema>>;
 export type ParamsFallback<TPath extends string, TParams> = unknown extends TParams ? Record<ParsePathParams<TPath>, string> : TParams;
 export type BaseRouteOptions<TParentRoute extends AnyRoute = AnyRoute, TCustomId extends string = string, TPath extends string = string, TSearchSchema extends Record<string, any> = {}, TFullSearchSchema extends Record<string, any> = TSearchSchema, TParams extends AnyPathParams = {}, TAllParams = ParamsFallback<TPath, TParams>, TRouteContext extends RouteContext = RouteContext, TAllContext extends Record<string, any> = AnyContext, TLoaderData extends any = unknown> = RoutePathOptions<TCustomId, TPath> & {
     getParentRoute: () => TParentRoute;
@@ -63,19 +63,19 @@ type BeforeLoadFn<TFullSearchSchema extends Record<string, any>, TParentRoute ex
     buildLocation: BuildLocationFn<AnyRoute>;
     cause: 'enter' | 'stay';
 }) => Promise<TRouteContext> | TRouteContext | void;
-export type UpdatableRouteOptions<TFullSearchSchema extends Record<string, any>, TAllParams extends AnyPathParams, TAllContext extends AnyContext, TLoaderData extends any = unknown> = MetaOptions & {
+export type UpdatableRouteOptions<TFullSearchSchema extends Record<string, any>> = MetaOptions & {
     caseSensitive?: boolean;
     wrapInSuspense?: boolean;
-    component?: RouteComponent<TFullSearchSchema, TAllParams, TAllContext, TLoaderData>;
-    errorComponent?: ErrorRouteComponent<TFullSearchSchema, TAllParams, TAllContext>;
-    pendingComponent?: PendingRouteComponent<TFullSearchSchema, TAllParams, TAllContext>;
+    component?: RouteComponent;
+    errorComponent?: false | null | RouteComponent;
+    pendingComponent?: RouteComponent;
     pendingMs?: number;
     pendingMinMs?: number;
     preSearchFilters?: SearchFilter<TFullSearchSchema>[];
     postSearchFilters?: SearchFilter<TFullSearchSchema>[];
     onError?: (err: any) => void;
     onEnter?: (match: AnyRouteMatch) => void;
-    onTransition?: (match: AnyRouteMatch) => void;
+    onStay?: (match: AnyRouteMatch) => void;
     onLeave?: (match: AnyRouteMatch) => void;
 };
 export type ParseParamsOption<TPath extends string, TParams> = ParseParamsFn<TPath, TParams>;
@@ -117,12 +117,6 @@ export type ResolveFullSearchSchema<TParentRoute, TSearchSchema> = Expand<Assign
 export interface AnyRoute extends Route<any, any, any, any, any, any, any, any, any, any, any, any, any, any> {
 }
 export type MergeFromFromParent<T, U> = IsAny<T, U, T & U>;
-export type StreamedPromise<T> = {
-    promise: Promise<T>;
-    status: 'resolved' | 'pending';
-    data: T;
-    resolve: (value: T) => void;
-};
 export type ResolveAllParams<TParentRoute extends AnyRoute, TParams extends AnyPathParams> = Record<never, string> extends TParentRoute['types']['allParams'] ? TParams : Expand<UnionToIntersection<TParentRoute['types']['allParams'] & TParams> & {}>;
 export type RouteConstraints = {
     TParentRoute: AnyRoute;
@@ -198,7 +192,7 @@ export declare class Route<TParentRoute extends RouteConstraints['TParentRoute']
         originalIndex: number;
     }) => void;
     addChildren: <TNewChildren extends AnyRoute[]>(children: TNewChildren) => Route<TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TRouteContext, TAllContext, TRouterContext, TNewChildren, TRouteTree, AnyRoute>;
-    update: (options: UpdatableRouteOptions<TFullSearchSchema, TAllParams, Expand<Assign<IsAny<TParentRoute['types']['allContext'], {}>, TRouteContext>>, TLoaderData>) => this;
+    update: (options: UpdatableRouteOptions<TFullSearchSchema>) => this;
     useMatch: <TSelected = TAllContext>(opts?: {
         select?: ((search: TAllContext) => TSelected) | undefined;
     } | undefined) => TSelected;
@@ -260,40 +254,17 @@ 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, TLoaderData extends any = unknown> = {
-    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;
-    useLoaderData: <TSelected = TLoaderData>(opts?: {
-        select?: (search: TLoaderData) => 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> & {
+export type SyncRouteComponent = (() => JSX.Element) | React.LazyExoticComponent<() => JSX.Element>;
+export type RouteComponent = SyncRouteComponent & {
     preload?: () => Promise<void>;
 };
-export type RouteComponent<TFullSearchSchema extends Record<string, any>, TAllParams extends AnyPathParams, TAllContext extends Record<string, any>, TLoaderData extends any = unknown> = AsyncRouteComponent<RouteProps<TFullSearchSchema, TAllParams, TAllContext, TLoaderData>>;
-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, any>;
-export type ComponentPropsFromRoute<TRoute> = TRoute extends (() => infer T extends AnyRoute) ? ComponentPropsFromRoute<T> : TRoute extends Route<infer TParentRoute, infer TPath, infer TFullPath, infer TCustomId, infer TId, infer TSearchSchema, infer TFullSearchSchema, infer TParams, infer TAllParams, infer TRouteContext, infer TAllContext, infer TRouterContext, infer TLoaderData, infer TChildren> ? RouteProps<TFullSearchSchema, TAllParams, TAllContext, TLoaderData> : {};
 export declare class NotFoundRoute<TParentRoute extends AnyRootRoute, TSearchSchema extends RouteConstraints['TSearchSchema'] = {}, TFullSearchSchema extends RouteConstraints['TFullSearchSchema'] = ResolveFullSearchSchema<TParentRoute, TSearchSchema>, TRouteContext extends RouteConstraints['TRouteContext'] = RouteContext, TAllContext extends Expand<Assign<IsAny<TParentRoute['types']['allContext'], {}>, TRouteContext>> = Expand<Assign<IsAny<TParentRoute['types']['allContext'], {}>, TRouteContext>>, TRouterContext extends RouteConstraints['TRouterContext'] = AnyContext, TLoaderData extends any = unknown, TChildren extends RouteConstraints['TChildren'] = unknown, TRouteTree extends RouteConstraints['TRouteTree'] = AnyRoute> extends Route<TParentRoute, '/404', '/404', '404', '404', TSearchSchema, TFullSearchSchema, {}, {}, TRouteContext, TAllContext, TRouterContext, TLoaderData, TChildren, TRouteTree> {
     constructor(options: Omit<RouteOptions<TParentRoute, string, string, TSearchSchema, TFullSearchSchema, {}, {}, TRouteContext, TAllContext, TLoaderData>, 'caseSensitive' | 'parseParams' | 'stringifyParams' | 'path' | 'id'>);
 }

package/build/types/router.d.ts

@@ -1,13 +1,12 @@
 /// <reference types="react" />
-import { RouterHistory } from '@tanstack/history';
+import { HistoryState, RouterHistory } from '@tanstack/history';
 import { Store } from '@tanstack/store';
-import { AnySearchSchema, AnyRoute, AnyContext, AnyPathParams, RouteMask } from './route';
+import { AnySearchSchema, AnyRoute, AnyContext, RouteMask } from './route';
 import { FullSearchSchema, RoutesById, RoutesByPath } from './routeInfo';
 import { PickAsRequired, Updater, NonNullableUpdater, Timeout } from './utils';
-import { ErrorRouteComponent, PendingRouteComponent, RouteComponent } from './route';
+import { RouteComponent } from './route';
 import { AnyRouteMatch, RouteMatch } from './Matches';
 import { ParsedLocation } from './location';
-import { LocationState } from './location';
 import { SearchSerializer, SearchParser } from './searchParams';
 import { BuildLocationFn, CommitLocationOptions, InjectedHtmlEntry, MatchRouteFn, NavigateFn } from './RouterProvider';
 declare global {
@@ -37,9 +36,9 @@ export interface RouterOptions<TRouteTree extends AnyRoute, TDehydrated extends
     parseSearch?: SearchParser;
     defaultPreload?: false | 'intent';
     defaultPreloadDelay?: number;
-    defaultComponent?: RouteComponent<AnySearchSchema, AnyPathParams, AnyContext>;
-    defaultErrorComponent?: ErrorRouteComponent<AnySearchSchema, AnyPathParams, AnyContext>;
-    defaultPendingComponent?: PendingRouteComponent<AnySearchSchema, AnyPathParams, AnyContext>;
+    defaultComponent?: RouteComponent;
+    defaultErrorComponent?: RouteComponent;
+    defaultPendingComponent?: RouteComponent;
     defaultPendingMs?: number;
     defaultPendingMinMs?: number;
     caseSensitive?: boolean;
@@ -71,13 +70,13 @@ export interface BuildNextOptions {
     params?: true | Updater<unknown>;
     search?: true | Updater<unknown>;
     hash?: true | Updater<string>;
-    state?: true | NonNullableUpdater<LocationState>;
+    state?: true | NonNullableUpdater<HistoryState>;
     mask?: {
         to?: string | number | null;
         params?: true | Updater<unknown>;
         search?: true | Updater<unknown>;
         hash?: true | Updater<string>;
-        state?: true | NonNullableUpdater<LocationState>;
+        state?: true | NonNullableUpdater<HistoryState>;
         unmaskOnReload?: boolean;
     };
     from?: string;
@@ -85,7 +84,7 @@ export interface BuildNextOptions {
 export interface DehydratedRouterState {
     dehydratedMatches: DehydratedRouteMatch[];
 }
-export type DehydratedRouteMatch = Pick<RouteMatch, 'fetchedAt' | 'invalid' | 'id' | 'status' | 'updatedAt'>;
+export type DehydratedRouteMatch = Pick<RouteMatch, 'fetchedAt' | 'id' | 'status' | 'updatedAt'>;
 export interface DehydratedRouter {
     state: DehydratedRouterState;
 }

package/build/types/useNavigate.d.ts

@@ -6,15 +6,14 @@ 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'> & {
+export type UseLinkPropsOptions<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = '/', TMaskTo extends string = ''> = ActiveLinkOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> & React.AnchorHTMLAttributes<HTMLAnchorElement>;
+export type LinkProps<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = '/', TMaskTo extends string = ''> = ActiveLinkOptions<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> & {
+export type ActiveLinkOptions<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>);
 };