@tanstack/react-router 0.0.1-beta.204 → 0.0.1-beta.205

package/build/types/RouteMatch.d.ts

@@ -0,0 +1,23 @@
+import { AnyRoute } from './route';
+import { ParseRoute, FullSearchSchema, RouteById, RouteIds } from './routeInfo';
+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;
+    meta: RouteById<TRouteTree, TRouteId>['types']['allMeta'];
+    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/RouterProvider.d.ts

@@ -0,0 +1,54 @@
+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 { AnyRoute } from './route';
+import { RouterState } from './router';
+export interface CommitLocationOptions {
+    replace?: boolean;
+    resetScroll?: boolean;
+}
+export interface MatchLocation {
+    to?: string | number | null;
+    fuzzy?: boolean;
+    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 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 LoadFn = (opts?: {
+    next?: ParsedLocation;
+    throwOnError?: boolean;
+    __dehydratedMatches?: DehydratedRouteMatch[];
+}) => Promise<void>;
+export type RouterContext<TRouteTree extends AnyRoute> = {
+    buildLink: BuildLinkFn<TRouteTree>;
+    state: RouterState<TRouteTree>;
+    navigate: NavigateFn<TRouteTree>;
+    matchRoute: MatchRouteFn<TRouteTree>;
+    routeTree: TRouteTree;
+    routesById: RoutesById<TRouteTree>;
+    options: RouterOptions<TRouteTree>;
+    history: RouterHistory;
+    load: LoadFn;
+};
+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 getRouteMatch<TRouteTree extends AnyRoute>(state: RouterState<TRouteTree>, id: string): undefined | RouteMatch<TRouteTree>;

package/build/types/awaited.d.ts

@@ -1,8 +0,0 @@
-import { DeferredPromise } from '@tanstack/router-core';
-export type AwaitOptions<T> = {
-    promise: DeferredPromise<T>;
-};
-export declare function useAwaited<T>({ promise }: AwaitOptions<T>): [T];
-export declare function Await<T>(props: AwaitOptions<T> & {
-    children: (result: T) => JSX.Element;
-}): JSX.Element;

package/build/types/fileRoute.d.ts

@@ -0,0 +1,17 @@
+import { AnyRoute, ResolveFullPath, RouteMeta, AnyContext, RouteOptions, UpdatableRouteOptions, Route, AnyPathParams, RootRouteId, TrimPathLeft, RouteConstraints } from './route';
+import { Assign, Expand, IsAny } from './utils';
+export interface FileRoutesByPath {
+}
+type Replace<S extends string, From extends string, To extends string> = S extends `${infer Start}${From}${infer Rest}` ? `${Start}${To}${Replace<Rest, From, To>}` : S;
+export type TrimLeft<T extends string, S extends string> = T extends `${S}${infer U}` ? U : T;
+export type TrimRight<T extends string, S extends string> = T extends `${infer U}${S}` ? U : T;
+export type Trim<T extends string, S extends string> = TrimLeft<TrimRight<T, S>, S>;
+export type RemoveUnderScores<T extends string> = Replace<Replace<TrimRight<TrimLeft<T, '/_'>, '_'>, '_/', '/'>, '/_', '/'>;
+export type ResolveFilePath<TParentRoute extends AnyRoute, TFilePath extends string> = TParentRoute['id'] extends RootRouteId ? TrimPathLeft<TFilePath> : Replace<TrimPathLeft<TFilePath>, TrimPathLeft<TParentRoute['types']['customId']>, ''>;
+export type FileRoutePath<TParentRoute extends AnyRoute, TFilePath extends string> = ResolveFilePath<TParentRoute, TFilePath> extends `_${infer _}` ? string : ResolveFilePath<TParentRoute, TFilePath>;
+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>, TRouteMeta extends RouteMeta = RouteMeta, TContext extends Expand<Assign<IsAny<TParentRoute["types"]["allMeta"], {}, TParentRoute["types"]["allMeta"]>, TRouteMeta>> = Expand<Assign<IsAny<TParentRoute["types"]["allMeta"], {}, TParentRoute["types"]["allMeta"]>, TRouteMeta>>, TRouterMeta extends AnyContext = AnyContext, TChildren extends unknown = unknown, TRouteTree extends AnyRoute = AnyRoute>(options: Omit<RouteOptions<TParentRoute, string, string, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TRouteMeta, TContext>, "id" | "path" | "getParentRoute"> & UpdatableRouteOptions<TFullSearchSchema, TAllParams, TContext>) => Route<TParentRoute, TPath, TFullPath, TFilePath, TId, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TRouteMeta, TContext, TRouterMeta, TChildren, TRouteTree>;
+}
+export {};

package/build/types/history.d.ts

@@ -0,0 +1,7 @@
+import { HistoryLocation } from '@tanstack/history';
+declare module '@tanstack/history' {
+    interface HistoryState {
+        __tempLocation?: HistoryLocation;
+        __tempKey?: string;
+    }
+}

package/build/types/index.d.ts

@@ -1,5 +1,18 @@
-export { useStore } from '@tanstack/react-store';
-export * from '@tanstack/router-core';
+export * from '@tanstack/history';
+export { default as invariant } from 'tiny-invariant';
+export { default as warning } from 'tiny-warning';
+export * from './link';
+export * from './path';
+export * from './qss';
+export * from './route';
+export * from './fileRoute';
+export * from './routeInfo';
+export * from './router';
+export * from './searchParams';
+export * from './utils';
 export * from './react';
-export * from './scroll-restoration';
-export * from './awaited';
+export * from './history';
+export * from './RouteMatch';
+export * from './redirects';
+export * from './location';
+export * from './RouterProvider';

package/build/types/link.d.ts

@@ -0,0 +1,98 @@
+import { Trim } from './fileRoute';
+import { AnyRoute } from './route';
+import { AllParams, FullSearchSchema, RouteByPath, RouteIds, RoutePaths } from './routeInfo';
+import { RegisteredRouter } from './router';
+import { LocationState } from './location';
+import { ParsedLocation } from './location';
+import { Expand, NoInfer, NonNullableUpdater, PickRequired, UnionToIntersection, Updater } from './utils';
+export type LinkInfo = {
+    type: 'external';
+    href: string;
+} | {
+    type: 'internal';
+    next: ParsedLocation;
+    handleFocus: (e: any) => void;
+    handleClick: (e: any) => void;
+    handleEnter: (e: any) => void;
+    handleLeave: (e: any) => void;
+    handleTouchStart: (e: any) => void;
+    isActive: boolean;
+    disabled?: boolean;
+};
+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 {
+    [K in Trim<Split<T>[number], '_'> as K extends `$${infer L}` ? L : never]: K;
+};
+export type Join<T, Delimiter extends string = '/'> = T extends [] ? '' : T extends [infer L extends string] ? L : T extends [infer L extends string, ...infer Tail extends [...string[]]] ? CleanPath<`${L}${Delimiter}${Join<Tail>}`> : never;
+export type Last<T extends any[]> = T extends [...infer _, infer L] ? L : never;
+export type RelativeToPathAutoComplete<AllPaths extends string, TFrom extends string, TTo extends string, SplitPaths extends string[] = Split<AllPaths, false>> = TTo extends `..${infer _}` ? SplitPaths extends [
+    ...Split<ResolveRelativePath<TFrom, TTo>, false>,
+    ...infer TToRest
+] ? `${CleanPath<Join<[
+    ...Split<TTo, false>,
+    ...(TToRest | (Split<ResolveRelativePath<TFrom, TTo>, false>['length'] extends 1 ? never : ['../']))
+]>>}` : never : TTo extends `./${infer RestTTo}` ? SplitPaths extends [
+    ...Split<TFrom, false>,
+    ...Split<RestTTo, false>,
+    ...infer RestPath
+] ? `${TTo}${Join<RestPath>}` : never : (TFrom extends `/` ? never : SplitPaths extends [...Split<TFrom, false>, ...infer RestPath] ? Join<RestPath> extends {
+    length: 0;
+} ? never : './' : never) | (TFrom extends `/` ? never : '../') | AllPaths;
+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;
+};
+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>;
+};
+export type ToMaskOptions<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TMaskFrom extends RoutePaths<TRouteTree> = '/', TMaskTo extends string = ''> = ToSubOptions<TRouteTree, TMaskFrom, TMaskTo> & {
+    unmaskOnReload?: boolean;
+};
+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>;
+    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 ? {
+    search?: true | SearchReducer<TFromSearch, TToSearch>;
+} : {
+    search: TFromSearchEnsured extends PickRequired<TToSearch> ? true | SearchReducer<TFromSearch, TToSearch> : SearchReducer<TFromSearch, TToSearch>;
+};
+type SearchReducer<TFrom, TTo> = TTo | ((current: TFrom) => TTo);
+export type PathParamOptions<TRouteTree extends AnyRoute, TFrom, TTo, TFromParamsEnsured = Expand<UnionToIntersection<PickRequired<RouteByPath<TRouteTree, TFrom>['types']['allParams']>>>, TFromParamsOptional = Omit<AllParams<TRouteTree>, keyof TFromParamsEnsured>, TFromParams = Expand<TFromParamsOptional & TFromParamsEnsured>, TToParams = Expand<RouteByPath<TRouteTree, TTo>['types']['allParams']>> = keyof PickRequired<TToParams> extends never ? {
+    params?: true | ParamsReducer<TFromParams, TToParams>;
+} : {
+    params: TFromParamsEnsured extends PickRequired<TToParams> ? true | ParamsReducer<TFromParams, TToParams> : ParamsReducer<TFromParams, TToParams>;
+};
+type ParamsReducer<TFrom, TTo> = TTo | ((current: TFrom) => TTo);
+export type ToPathOption<TRouteTree extends AnyRoute = AnyRoute, TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = ''> = TTo | RelativeToPathAutoComplete<RoutePaths<TRouteTree>, NoInfer<TFrom> extends string ? NoInfer<TFrom> : '', NoInfer<TTo> & string>;
+export type ToIdOption<TRouteTree extends AnyRoute = AnyRoute, TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = ''> = TTo | RelativeToPathAutoComplete<RouteIds<TRouteTree>, NoInfer<TFrom> extends string ? NoInfer<TFrom> : '', NoInfer<TTo> & string>;
+export interface ActiveOptions {
+    exact?: boolean;
+    includeHash?: boolean;
+    includeSearch?: boolean;
+}
+export type LinkOptions<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = TFrom, TMaskTo extends string = ''> = NavigateOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> & {
+    target?: HTMLAnchorElement['target'];
+    activeOptions?: ActiveOptions;
+    preload?: false | 'intent';
+    preloadDelay?: number;
+    disabled?: boolean;
+};
+export type CheckRelativePath<TRouteTree extends AnyRoute, TFrom, TTo> = TTo extends string ? TFrom extends string ? ResolveRelativePath<TFrom, TTo> extends RoutePaths<TRouteTree> ? {} : {
+    Error: `${TFrom} + ${TTo} resolves to ${ResolveRelativePath<TFrom, TTo>}, which is not a valid route path.`;
+    'Valid Route Paths': RoutePaths<TRouteTree>;
+} : {} : {};
+export type CheckPath<TRouteTree extends AnyRoute, TPath, TPass> = Exclude<TPath, RoutePaths<TRouteTree>> extends never ? TPass : CheckPathError<TRouteTree, Exclude<TPath, RoutePaths<TRouteTree>>>;
+export type CheckPathError<TRouteTree extends AnyRoute, TInvalids> = {
+    to: RoutePaths<TRouteTree>;
+};
+export type CheckId<TRouteTree extends AnyRoute, TPath, TPass> = Exclude<TPath, RouteIds<TRouteTree>> extends never ? TPass : CheckIdError<TRouteTree, Exclude<TPath, RouteIds<TRouteTree>>>;
+export type CheckIdError<TRouteTree extends AnyRoute, TInvalids> = {
+    Error: `${TInvalids extends string ? TInvalids : never} is not a valid route ID.`;
+    '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 {};

package/build/types/location.d.ts

@@ -0,0 +1,14 @@
+import { HistoryState } from '@tanstack/history';
+import { AnySearchSchema } from './route';
+export interface ParsedLocation<TSearchObj extends AnySearchSchema = {}> {
+    href: string;
+    pathname: string;
+    search: TSearchObj;
+    searchStr: string;
+    state: HistoryState;
+    hash: string;
+    maskedLocation?: ParsedLocation<TSearchObj>;
+    unmaskOnReload?: boolean;
+}
+export interface LocationState {
+}

package/build/types/path.d.ts

@@ -0,0 +1,16 @@
+import { MatchLocation } from './RouterProvider';
+import { AnyPathParams } from './route';
+export interface Segment {
+    type: 'pathname' | 'param' | 'wildcard';
+    value: string;
+}
+export declare function joinPaths(paths: (string | undefined)[]): string;
+export declare function cleanPath(path: string): string;
+export declare function trimPathLeft(path: string): string;
+export declare function trimPathRight(path: string): string;
+export declare function trimPath(path: string): string;
+export declare function resolvePath(basepath: string, base: string, to: string): string;
+export declare function parsePathname(pathname?: string): Segment[];
+export declare function interpolatePath(path: string | undefined, params: any, leaveWildcards?: boolean): string;
+export declare function matchPathname(basepath: string, currentPathname: string, matchLocation: Pick<MatchLocation, 'to' | 'fuzzy' | 'caseSensitive'>): AnyPathParams | undefined;
+export declare function matchByPath(basepath: string, from: string, matchLocation: Pick<MatchLocation, 'to' | 'caseSensitive' | 'fuzzy'>): Record<string, string> | undefined;

package/build/types/qss.d.ts

@@ -0,0 +1,2 @@
+export declare function encode(obj: any, pfx?: string): string;
+export declare function decode(str: any): {};

package/build/types/react.d.ts

@@ -1,61 +1,16 @@
 import * as React from 'react';
-import { NoInfer } from '@tanstack/react-store';
-import { MatchRouteOptions, RegisteredRouter, RouterOptions, Router, RouteMatch, RouteByPath, AnyRoute, AnyRouteProps, LinkOptions, ToOptions, ResolveRelativePath, NavigateOptions, ResolveFullPath, ResolveId, AnySearchSchema, ParsePathParams, RouteContext, AnyContext, UseLoaderResult, ResolveFullSearchSchema, RouteConstraints, RoutePaths, RoutesById, RouteIds, RouteById, ParseRoute, AllParams, AnyPathParams, Expand, ResolveAllParams, DeepMergeAll, IsAny } from '@tanstack/router-core';
-declare module '@tanstack/router-core' {
-    interface RouterOptions<TRouteTree extends AnyRoute, TDehydrated extends Record<string, any>> {
-        Wrap?: React.ComponentType<{
-            children: React.ReactNode;
-            dehydratedState?: TDehydrated;
-        }>;
-    }
-    interface RegisterRouteComponent<TLoader = unknown, TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> {
-        RouteComponent: RouteComponent<RouteProps<TLoader, TFullSearchSchema, TAllParams, TAllContext>>;
-    }
-    interface RegisterErrorRouteComponent<TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> {
-        ErrorRouteComponent: RouteComponent<ErrorRouteProps<TFullSearchSchema, TAllParams, TAllContext>>;
-    }
-    interface RegisterPendingRouteComponent<TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> {
-        PendingRouteComponent: RouteComponent<PendingRouteProps<TFullSearchSchema, TAllParams, TAllContext>>;
-    }
-    interface Route<TParentRoute extends RouteConstraints['TParentRoute'] = AnyRoute, TPath extends RouteConstraints['TPath'] = '/', TFullPath extends RouteConstraints['TFullPath'] = ResolveFullPath<TParentRoute, TPath>, TCustomId extends RouteConstraints['TCustomId'] = string, TId extends RouteConstraints['TId'] = ResolveId<TParentRoute, TCustomId, TPath>, TLoaderContext extends RouteConstraints['TLoaderContext'] = AnyContext, TLoader = unknown, TSearchSchema extends RouteConstraints['TSearchSchema'] = {}, TFullSearchSchema extends RouteConstraints['TFullSearchSchema'] = ResolveFullSearchSchema<TParentRoute, TSearchSchema>, TParams extends RouteConstraints['TParams'] = Expand<Record<ParsePathParams<TPath>, string>>, TAllParams extends RouteConstraints['TAllParams'] = ResolveAllParams<TParentRoute, TParams>, TRouteContext extends RouteConstraints['TRouteContext'] = RouteContext, TAllContext extends RouteConstraints['TAllContext'] = Expand<DeepMergeAll<[
-        IsAny<TParentRoute['types']['context'], {}>,
-        TLoaderContext,
-        TRouteContext
-    ]>>, TRouterContext extends RouteConstraints['TRouterContext'] = AnyContext, TChildren extends RouteConstraints['TChildren'] = unknown, TRouteTree extends RouteConstraints['TRouteTree'] = AnyRoute> {
-        useMatch: <TSelected = TAllContext>(opts?: {
-            select?: (search: TAllContext) => TSelected;
-        }) => TSelected;
-        useLoader: <TSelected = TLoader>(opts?: {
-            select?: (search: TLoader) => TSelected;
-        }) => UseLoaderResult<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;
-    }
-    interface RegisterRouteProps<TLoader = unknown, TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> {
-        RouteProps: RouteProps<TLoader, TFullSearchSchema, TAllParams, TAllContext>;
-    }
-    interface RegisterPendingRouteProps<TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> {
-        PendingRouteProps: PendingRouteProps<TFullSearchSchema, TAllParams, TAllContext>;
-    }
-    interface RegisterErrorRouteProps<TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> {
-        ErrorRouteProps: ErrorRouteProps;
-    }
-}
-export type RouteProps<TLoader = unknown, TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> = {
-    useLoader: <TSelected = TLoader>(opts?: {
-        select?: (search: TLoader) => TSelected;
-    }) => UseLoaderResult<TSelected>;
+import { LinkOptions, ToOptions, ResolveRelativePath, NavigateOptions } from './link';
+import { AnySearchSchema, AnyPathParams, AnyContext, AnyRoute } from './route';
+import { RoutePaths, RouteByPath, RouteIds, ParseRoute, RoutesById, RouteById, AllParams } from './routeInfo';
+import { RegisteredRouter, RouterOptions, Router, RouterState } from './router';
+import { RouteMatch } from './RouteMatch';
+import { NoInfer } from './utils';
+import { MatchRouteOptions, RouterContext } from './RouterProvider';
+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?: {
+    useRouteMeta: <TSelected = TAllContext>(opts?: {
         select?: (search: TAllContext) => TSelected;
     }) => TSelected;
     useSearch: <TSelected = TFullSearchSchema>(opts?: {
@@ -70,22 +25,17 @@ export type ErrorRouteProps<TFullSearchSchema extends Record<string, any> = AnyS
     info: {
         componentStack: string;
     };
-} & Omit<RouteProps<unknown, TFullSearchSchema, TAllParams, TAllContext>, 'useLoader'>;
-export type PendingRouteProps<TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> = Omit<RouteProps<unknown, TFullSearchSchema, TAllParams, TAllContext>, 'useLoader'>;
+} & 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>;
 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 ErrorRouteComponent = AsyncRouteComponent<ErrorRouteComponentProps>;
-export type ErrorRouteComponentProps = {
-    error: Error;
-    info: {
-        componentStack: string;
-    };
-};
-export type AnyRouteComponent = RouteComponent<AnyRouteProps>;
-export type RouteComponent<TProps> = AsyncRouteComponent<TProps>;
+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 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;
 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>);
@@ -113,17 +63,15 @@ export interface LinkComponent<TProps extends Record<string, any> = {}> {
 }
 export declare const Link: LinkComponent;
 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 declare const matchIdsContext: React.Context<string[]>;
-export declare const routerContext: React.Context<import("@tanstack/router-core").AnyRouter>;
+export declare const matchesContext: React.Context<RouteMatch<AnyRoute, any>[]>;
 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']>;
+    context?: Partial<RouterOptions<TRouteTree, TDehydrated>['meta']>;
 };
-export declare function useRouterState<TSelected = RegisteredRouter['state']>(opts?: {
-    select: (state: RegisteredRouter['state']) => TSelected;
+export declare function useRouter<TRouteTree extends AnyRoute = RegisteredRouter['routeTree']>(): RouterContext<TRouteTree>;
+export declare function useRouterState<TSelected = RouterState<RegisteredRouter['routeTree']>>(opts?: {
+    select: (state: RouterState<RegisteredRouter['routeTree']>) => TSelected;
 }): TSelected;
-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 useRouter(): RegisteredRouter;
 export declare function useMatches<T = RouteMatch[]>(opts?: {
     select?: (matches: RouteMatch[]) => T;
 }): T;
@@ -138,14 +86,8 @@ export declare function useMatch<TRouteTree extends AnyRoute = RegisteredRouter[
     select?: (match: TRouteMatchState) => TSelected;
 }): TStrict extends true ? TRouteMatchState : TRouteMatchState | undefined;
 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 useLoader<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>, TStrict extends boolean = true, TLoader = RouteById<TRouteTree, TFrom>['types']['loader'], TSelected = TLoader>(opts: StrictOrFrom<TFrom> & {
-    select?: (search: TLoader) => TSelected;
-}): TStrict extends true ? TSelected : TSelected | undefined;
-export declare function useRouterContext<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>, TStrict extends boolean = true, TContext = RouteById<TRouteTree, TFrom>['types']['context'], TSelected = TContext>(opts: StrictOrFrom<TFrom> & {
-    select?: (search: TContext) => TSelected;
-}): TStrict extends true ? TSelected : TSelected | undefined;
-export declare function useRouteContext<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>, TStrict extends boolean = true, TRouteContext = RouteById<TRouteTree, TFrom>['types']['context'], TSelected = TRouteContext>(opts: StrictOrFrom<TFrom> & {
-    select?: (search: TRouteContext) => TSelected;
+export declare function useRouteMeta<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>, TStrict extends boolean = true, TRouteMeta = RouteById<TRouteTree, TFrom>['types']['allMeta'], TSelected = TRouteMeta>(opts: StrictOrFrom<TFrom> & {
+    select?: (search: TRouteMeta) => TSelected;
 }): TStrict extends true ? TSelected : TSelected | undefined;
 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;
@@ -157,11 +99,9 @@ export declare function useNavigate<TRouteTree extends AnyRoute = RegisteredRout
     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 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 declare function Matches(): JSX.Element;
 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 Outlet(): JSX.Element | null;
-export declare function useInjectHtml(): (html: string | (() => Promise<string> | string)) => void;
-export declare function useDehydrate(): <T>(key: any, data: T | (() => T | Promise<T>)) => () => T | undefined;
-export declare function useHydrate(): <T = unknown>(key: any) => T;
 export declare function CatchBoundary(props: {
     resetKey: string;
     children: any;

package/build/types/redirects.d.ts

@@ -0,0 +1,10 @@
+import { NavigateOptions } from './link';
+import { AnyRoute } from './route';
+import { RoutePaths } from './routeInfo';
+import { RegisteredRouter } from './router';
+export type AnyRedirect = Redirect<any, any, any>;
+export type Redirect<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = TFrom, TMaskTo extends string = ''> = NavigateOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> & {
+    code?: number;
+};
+export declare function redirect<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = ''>(opts: Redirect<TRouteTree, TFrom, TTo>): Redirect<TRouteTree, TFrom, TTo>;
+export declare function isRedirect(obj: any): obj is AnyRedirect;