@tanstack/react-router 0.0.1-beta.9 → 1.0.0

package/build/types/route.d.ts

@@ -0,0 +1,283 @@
+import * as React from 'react';
+import { AnyRouteMatch } from './Matches';
+import { NavigateOptions, ParsePathParams, ToSubOptions } from './link';
+import { ParsedLocation } from './location';
+import { RouteById, RouteIds, RoutePaths } from './routeInfo';
+import { AnyRouter, RegisteredRouter } 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 = {};
+export type AnySearchSchema = {};
+export type AnyContext = {};
+export interface RouteContext {
+}
+export interface RouteMeta {
+}
+export type PreloadableObj = {
+    preload?: () => Promise<void>;
+};
+export type RoutePathOptions<TCustomId, TPath> = {
+    path: TPath;
+} | {
+    id: TCustomId;
+};
+export type RoutePathOptionsIntersection<TCustomId, TPath> = UnionToIntersection<RoutePathOptions<TCustomId, TPath>>;
+export type MetaOptions = keyof PickRequired<RouteMeta> extends never ? {
+    meta?: RouteMeta;
+} : {
+    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, TLoaderDeps extends Record<string, any> = {}, TLoaderData extends any = unknown> = BaseRouteOptions<TParentRoute, TCustomId, TPath, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TRouteContext, TAllContext, TLoaderDeps, 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, TLoaderDeps extends Record<string, any> = {}, TLoaderData extends any = unknown> = RoutePathOptions<TCustomId, TPath> & {
+    getParentRoute: () => TParentRoute;
+    validateSearch?: SearchSchemaValidator<TSearchSchema>;
+    shouldReload?: boolean | ((match: LoaderFnContext<TAllParams, TFullSearchSchema, TAllContext, TRouteContext>) => any);
+} & (keyof PickRequired<RouteContext> extends never ? {
+    beforeLoad?: BeforeLoadFn<TFullSearchSchema, TParentRoute, TAllParams, TRouteContext>;
+} : {
+    beforeLoad: BeforeLoadFn<TFullSearchSchema, TParentRoute, TAllParams, TRouteContext>;
+}) & {
+    loaderDeps?: (opts: {
+        search: TFullSearchSchema;
+    }) => TLoaderDeps;
+    loader?: RouteLoaderFn<TAllParams, NoInfer<TLoaderDeps>, NoInfer<TAllContext>, NoInfer<TRouteContext>, TLoaderData>;
+} & ({
+    parseParams?: (rawParams: IsAny<TPath, any, Record<ParsePathParams<TPath>, string>>) => TParams extends Record<ParsePathParams<TPath>, any> ? TParams : 'parseParams must return an object';
+    stringifyParams?: (params: NoInfer<ParamsFallback<TPath, TParams>>) => Record<ParsePathParams<TPath>, string>;
+} | {
+    stringifyParams?: never;
+    parseParams?: never;
+});
+type BeforeLoadFn<TFullSearchSchema extends Record<string, any>, TParentRoute extends AnyRoute, TAllParams, TRouteContext> = (opts: {
+    search: TFullSearchSchema;
+    abortController: AbortController;
+    preload: boolean;
+    params: TAllParams;
+    context: TParentRoute['types']['allContext'];
+    location: ParsedLocation;
+    navigate: NavigateFn<AnyRoute>;
+    buildLocation: BuildLocationFn<TParentRoute>;
+    cause: 'preload' | 'enter' | 'stay';
+}) => Promise<TRouteContext> | TRouteContext | void;
+export type UpdatableRouteOptions<TFullSearchSchema extends Record<string, any>> = MetaOptions & {
+    caseSensitive?: boolean;
+    wrapInSuspense?: boolean;
+    component?: RouteComponent;
+    errorComponent?: false | null | ErrorRouteComponent;
+    pendingComponent?: RouteComponent;
+    pendingMs?: number;
+    pendingMinMs?: number;
+    staleTime?: number;
+    gcTime?: number;
+    preloadStaleTime?: number;
+    preloadGcTime?: number;
+    preSearchFilters?: SearchFilter<TFullSearchSchema>[];
+    postSearchFilters?: SearchFilter<TFullSearchSchema>[];
+    onError?: (err: any) => void;
+    onEnter?: (match: AnyRouteMatch) => void;
+    onStay?: (match: AnyRouteMatch) => void;
+    onLeave?: (match: AnyRouteMatch) => void;
+};
+export type ParseParamsOption<TPath extends string, TParams> = ParseParamsFn<TPath, TParams>;
+export type ParseParamsFn<TPath extends string, TParams> = (rawParams: IsAny<TPath, any, Record<ParsePathParams<TPath>, string>>) => TParams extends Record<ParsePathParams<TPath>, any> ? TParams : 'parseParams must return an object';
+export type ParseParamsObj<TPath extends string, TParams> = {
+    parse?: ParseParamsFn<TPath, TParams>;
+};
+export type SearchSchemaValidator<TReturn> = SearchSchemaValidatorObj<TReturn> | SearchSchemaValidatorFn<TReturn>;
+export type SearchSchemaValidatorObj<TReturn> = {
+    parse?: SearchSchemaValidatorFn<TReturn>;
+};
+export type SearchSchemaValidatorFn<TReturn> = (searchObj: Record<string, unknown>) => TReturn;
+export type DefinedPathParamWarning = 'Path params cannot be redefined by child routes!';
+export type ParentParams<TParentParams> = AnyPathParams extends TParentParams ? {} : {
+    [Key in keyof TParentParams]?: DefinedPathParamWarning;
+};
+export type RouteLoaderFn<TAllParams = {}, TLoaderDeps extends Record<string, any> = {}, TAllContext extends Record<string, any> = AnyContext, TRouteContext extends Record<string, any> = AnyContext, TLoaderData extends any = unknown> = (match: LoaderFnContext<TAllParams, TLoaderDeps, TAllContext, TRouteContext>) => Promise<TLoaderData> | TLoaderData;
+export interface LoaderFnContext<TAllParams = {}, TLoaderDeps extends Record<string, any> = {}, TAllContext extends Record<string, any> = AnyContext, TRouteContext extends Record<string, any> = AnyContext> {
+    abortController: AbortController;
+    preload: boolean;
+    params: TAllParams;
+    deps: TLoaderDeps;
+    context: Expand<Assign<TAllContext, TRouteContext>>;
+    location: ParsedLocation;
+    navigate: (opts: NavigateOptions<AnyRoute>) => Promise<void>;
+    parentMatchPromise?: Promise<void>;
+    cause: 'preload' | 'enter' | 'stay';
+}
+export type SearchFilter<T, U = T> = (prev: T) => U;
+export type ResolveId<TParentRoute, TCustomId extends string, TPath extends string> = TParentRoute extends {
+    id: infer TParentId extends string;
+} ? RoutePrefix<TParentId, string extends TCustomId ? TPath : TCustomId> : RootRouteId;
+export type InferFullSearchSchema<TRoute> = TRoute extends {
+    types: {
+        fullSearchSchema: infer TFullSearchSchema;
+    };
+} ? TFullSearchSchema : {};
+export type ResolveFullSearchSchema<TParentRoute, TSearchSchema> = Expand<Assign<InferFullSearchSchema<TParentRoute>, TSearchSchema>>;
+export interface AnyRoute extends Route<any, any, 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 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;
+    TPath: string;
+    TFullPath: string;
+    TCustomId: string;
+    TId: string;
+    TSearchSchema: AnySearchSchema;
+    TFullSearchSchema: AnySearchSchema;
+    TParams: Record<string, any>;
+    TAllParams: Record<string, any>;
+    TParentContext: AnyContext;
+    TRouteContext: RouteContext;
+    TAllContext: AnyContext;
+    TRouterContext: AnyContext;
+    TChildren: unknown;
+    TRouteTree: AnyRoute;
+};
+export declare class RouteApi<TId extends RouteIds<RegisteredRouter['routeTree']>, TRoute extends AnyRoute = RouteById<RegisteredRouter['routeTree'], TId>, TFullSearchSchema extends Record<string, any> = TRoute['types']['fullSearchSchema'], TAllParams extends AnyPathParams = TRoute['types']['allParams'], TAllContext extends Record<string, any> = TRoute['types']['allContext'], TLoaderDeps extends Record<string, any> = TRoute['types']['loaderDeps'], TLoaderData extends any = TRoute['types']['loaderData']> {
+    id: TId;
+    constructor({ id }: {
+        id: TId;
+    });
+    useMatch: <TSelected = TAllContext>(opts?: {
+        select?: ((s: TAllContext) => TSelected) | undefined;
+    } | undefined) => TSelected;
+    useRouteContext: <TSelected = TAllContext>(opts?: {
+        select?: ((s: TAllContext) => TSelected) | undefined;
+    } | undefined) => TSelected;
+    useSearch: <TSelected = TFullSearchSchema>(opts?: {
+        select?: ((s: TFullSearchSchema) => TSelected) | undefined;
+    } | undefined) => TSelected;
+    useParams: <TSelected = TAllParams>(opts?: {
+        select?: ((s: TAllParams) => TSelected) | undefined;
+    } | undefined) => TSelected;
+    useLoaderDeps: <TSelected = TLoaderDeps>(opts?: {
+        select?: ((s: TLoaderDeps) => TSelected) | undefined;
+    } | undefined) => TSelected;
+    useLoaderData: <TSelected = TLoaderData>(opts?: {
+        select?: ((s: TLoaderData) => TSelected) | undefined;
+    } | undefined) => TSelected;
+}
+export declare class 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>, 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 Expand<Assign<IsAny<TParentRoute['types']['allContext'], {}>, TRouteContext>> = Expand<Assign<IsAny<TParentRoute['types']['allContext'], {}>, TRouteContext>>, TRouterContext extends RouteConstraints['TRouterContext'] = AnyContext, TLoaderDeps extends Record<string, any> = {}, TLoaderData extends any = unknown, TChildren extends RouteConstraints['TChildren'] = unknown, TRouteTree extends RouteConstraints['TRouteTree'] = AnyRoute> {
+    isRoot: TParentRoute extends Route<any> ? true : false;
+    options: RouteOptions<TParentRoute, TCustomId, TPath, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TRouteContext, TAllContext, TLoaderDeps, TLoaderData>;
+    test: Expand<Assign<IsAny<TParentRoute['types']['allContext'], {}>, TRouteContext>>;
+    parentRoute: TParentRoute;
+    id: TId;
+    path: TPath;
+    fullPath: TFullPath;
+    to: TrimPathRight<TFullPath>;
+    children?: TChildren;
+    originalIndex?: number;
+    router?: AnyRouter;
+    rank: number;
+    constructor(options: RouteOptions<TParentRoute, TCustomId, TPath, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TRouteContext, TAllContext, TLoaderDeps, TLoaderData>);
+    types: {
+        parentRoute: TParentRoute;
+        path: TPath;
+        to: TrimPathRight<TFullPath>;
+        fullPath: TFullPath;
+        customId: TCustomId;
+        id: TId;
+        searchSchema: TSearchSchema;
+        fullSearchSchema: TFullSearchSchema;
+        params: TParams;
+        allParams: TAllParams;
+        routeContext: TRouteContext;
+        allContext: TAllContext;
+        children: TChildren;
+        routeTree: TRouteTree;
+        routerContext: TRouterContext;
+        loaderData: TLoaderData;
+        loaderDeps: TLoaderDeps;
+    };
+    init: (opts: {
+        originalIndex: number;
+    }) => void;
+    addChildren: <TNewChildren extends AnyRoute[]>(children: TNewChildren) => Route<TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TRouteContext, TAllContext, TRouterContext, TLoaderDeps, TLoaderData, TNewChildren, TRouteTree>;
+    update: (options: UpdatableRouteOptions<TFullSearchSchema>) => this;
+    useMatch: <TSelected = TAllContext>(opts?: {
+        select?: ((search: TAllContext) => TSelected) | undefined;
+    } | undefined) => TSelected;
+    useRouteContext: <TSelected = TAllContext>(opts?: {
+        select?: ((search: TAllContext) => TSelected) | undefined;
+    } | undefined) => TSelected;
+    useSearch: <TSelected = TFullSearchSchema>(opts?: {
+        select?: ((search: TFullSearchSchema) => TSelected) | undefined;
+    } | undefined) => TSelected;
+    useParams: <TSelected = TAllParams>(opts?: {
+        select?: ((search: TAllParams) => TSelected) | undefined;
+    } | undefined) => TSelected;
+    useLoaderDeps: <TSelected = TLoaderDeps>(opts?: {
+        select?: ((s: TLoaderDeps) => TSelected) | undefined;
+    } | undefined) => TSelected;
+    useLoaderData: <TSelected = TLoaderData>(opts?: {
+        select?: ((search: TLoaderData) => TSelected) | undefined;
+    } | undefined) => TSelected;
+}
+export type AnyRootRoute = RootRoute<any, any, any, any>;
+export declare function rootRouteWithContext<TRouterContext extends {}>(): <TSearchSchema extends Record<string, any> = {}, TRouteContext extends RouteContext = RouteContext, TLoaderDeps extends Record<string, any> = {}, TLoaderData extends unknown = unknown>(options?: Omit<RouteOptions<AnyRoute, "__root__", "", TSearchSchema, TSearchSchema, {}, {}, TRouteContext, Assign<TRouterContext, TRouteContext>, TLoaderDeps, TLoaderData>, "path" | "id" | "getParentRoute" | "stringifyParams" | "parseParams" | "caseSensitive"> | undefined) => RootRoute<TSearchSchema, TRouteContext, TRouterContext, {}, unknown>;
+export declare class RootRoute<TSearchSchema extends Record<string, any> = {}, TRouteContext extends RouteContext = RouteContext, TRouterContext extends {} = {}, TLoaderDeps extends Record<string, any> = {}, TLoaderData extends any = unknown> extends Route<any, // TParentRoute
+'/', // TPath
+'/', // TFullPath
+string, // TCustomId
+RootRouteId, // TId
+TSearchSchema, // TSearchSchema
+TSearchSchema, // TFullSearchSchema
+{}, // TParams
+{}, // TAllParams
+TRouteContext, // TRouteContext
+Expand<Assign<TRouterContext, TRouteContext>>, // TAllContext
+TRouterContext, // TRouterContext
+TLoaderDeps, TLoaderData, any, // TChildren
+any> {
+    constructor(options?: Omit<RouteOptions<AnyRoute, // TParentRoute
+    RootRouteId, // TCustomId
+    '', // TPath
+    TSearchSchema, // TSearchSchema
+    TSearchSchema, // TFullSearchSchema
+    {}, // TParams
+    {}, // TAllParams
+    TRouteContext, // TRouteContext
+    Assign<TRouterContext, TRouteContext>, // TAllContext
+    TLoaderDeps, TLoaderData>, 'path' | 'id' | 'getParentRoute' | 'caseSensitive' | 'parseParams' | 'stringifyParams'>);
+}
+export type ResolveFullPath<TParentRoute extends AnyRoute, TPath extends string, TPrefixed = RoutePrefix<TParentRoute['fullPath'], TPath>> = TPrefixed extends RootRouteId ? '/' : TPrefixed;
+type RoutePrefix<TPrefix extends string, TPath extends string> = string extends TPath ? RootRouteId : TPath extends string ? TPrefix extends RootRouteId ? TPath extends '/' ? '/' : `/${TrimPath<TPath>}` : `${TPrefix}/${TPath}` extends '/' ? '/' : `/${TrimPathLeft<`${TrimPathRight<TPrefix>}/${TrimPath<TPath>}`>}` : never;
+export type TrimPath<T extends string> = '' extends T ? '' : TrimPathRight<TrimPathLeft<T>>;
+export type TrimPathLeft<T extends string> = T extends `${RootRouteId}/${infer U}` ? TrimPathLeft<U> : T extends `/${infer U}` ? TrimPathLeft<U> : T;
+export type TrimPathRight<T extends string> = T extends '/' ? '/' : T extends `${infer U}/` ? TrimPathRight<U> : T;
+export type RouteMask<TRouteTree extends AnyRoute> = {
+    routeTree: TRouteTree;
+    from: RoutePaths<TRouteTree>;
+    to?: any;
+    params?: any;
+    search?: any;
+    hash?: any;
+    state?: any;
+    unmaskOnReload?: boolean;
+};
+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 ErrorRouteProps = {
+    error: unknown;
+    info: {
+        componentStack: string;
+    };
+};
+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<TProps = any> = SyncRouteComponent<TProps> & AsyncRouteComponent<TProps>;
+export type ErrorRouteComponent = RouteComponent<ErrorRouteProps>;
+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, TLoaderDeps extends Record<string, any> = {}, 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, TLoaderDeps, TLoaderData, TChildren, TRouteTree> {
+    constructor(options: Omit<RouteOptions<TParentRoute, string, string, TSearchSchema, TFullSearchSchema, {}, {}, TRouteContext, TAllContext, TLoaderDeps, TLoaderData>, 'caseSensitive' | 'parseParams' | 'stringifyParams' | 'path' | 'id'>);
+}
+export {};

package/build/types/routeInfo.d.ts

@@ -0,0 +1,31 @@
+import { AnyRoute, Route } from './route';
+import { Expand, UnionToIntersection, UnionToTuple } from './utils';
+export type ParseRoute<TRouteTree extends AnyRoute> = TRouteTree | ParseRouteChildren<TRouteTree>;
+export type ParseRouteChildren<TRouteTree extends AnyRoute> = TRouteTree extends Route<any, any, any, any, any, any, any, any, any, any, any, any, any, any, infer TChildren, any> ? unknown extends TChildren ? never : TChildren extends AnyRoute[] ? {
+    [TId in TChildren[number]['id'] as string]: ParseRoute<TChildren[number]>;
+}[string] : never : never;
+export type RoutesById<TRouteTree extends AnyRoute> = {
+    [K in ParseRoute<TRouteTree> as K['id']]: K;
+};
+export type RouteById<TRouteTree extends AnyRoute, TId> = Extract<ParseRoute<TRouteTree>, {
+    id: TId;
+}>;
+export type RouteIds<TRouteTree extends AnyRoute> = ParseRoute<TRouteTree>['id'];
+export type RoutesByPath<TRouteTree extends AnyRoute> = {
+    [K in ParseRoute<TRouteTree> as K['fullPath']]: K;
+};
+export type RouteByPath<TRouteTree extends AnyRoute, TPath> = Extract<ParseRoute<TRouteTree>, {
+    fullPath: TPath;
+}>;
+export type RoutePaths<TRouteTree extends AnyRoute> = ParseRoute<TRouteTree>['fullPath'] | '/';
+type UnionizeCollisions<T, U> = {
+    [P in keyof T & keyof U]: T[P] extends U[P] ? T[P] : T[P] | U[P];
+};
+type Reducer<T, U, C = UnionizeCollisions<T, U>> = C & Omit<T, keyof C> & Omit<U, keyof C>;
+type Reduce<T extends any[], Result = unknown> = T extends [
+    infer First,
+    ...infer Rest
+] ? Reduce<Rest, Reducer<Result, First>> : Result;
+export type FullSearchSchema<TRouteTree extends AnyRoute> = Partial<Expand<Reduce<UnionToTuple<ParseRoute<TRouteTree>['types']['fullSearchSchema']>>>>;
+export type AllParams<TRouteTree extends AnyRoute> = Expand<UnionToIntersection<ParseRoute<TRouteTree>['types']['allParams']>>;
+export {};

package/build/types/router.d.ts

@@ -0,0 +1,186 @@
+/// <reference types="react" />
+import { HistoryState, RouterHistory } from '@tanstack/history';
+import { Store } from '@tanstack/store';
+import { AnySearchSchema, AnyRoute, AnyContext, RouteMask } from './route';
+import { FullSearchSchema, RoutesById, RoutesByPath } from './routeInfo';
+import { PickAsRequired, Updater, NonNullableUpdater, Timeout } from './utils';
+import { RouteComponent } from './route';
+import { AnyRouteMatch, RouteMatch } from './Matches';
+import { ParsedLocation } from './location';
+import { SearchSerializer, SearchParser } from './searchParams';
+import { BuildLocationFn, CommitLocationOptions, InjectedHtmlEntry, MatchRouteFn, NavigateFn } from './RouterProvider';
+import { ToOptions } from './link';
+declare global {
+    interface Window {
+        __TSR_DEHYDRATED__?: HydrationCtx;
+        __TSR_ROUTER_CONTEXT__?: React.Context<Router<any>>;
+    }
+}
+export interface Register {
+}
+export type AnyRouter = Router<AnyRoute, any>;
+export type RegisteredRouter = Register extends {
+    router: infer TRouter extends AnyRouter;
+} ? TRouter : AnyRouter;
+export type HydrationCtx = {
+    router: DehydratedRouter;
+    payload: Record<string, any>;
+};
+export type RouterContextOptions<TRouteTree extends AnyRoute> = AnyContext extends TRouteTree['types']['routerContext'] ? {
+    context?: TRouteTree['types']['routerContext'];
+} : {
+    context: TRouteTree['types']['routerContext'];
+};
+export interface RouterOptions<TRouteTree extends AnyRoute, TDehydrated extends Record<string, any> = Record<string, any>> {
+    history?: RouterHistory;
+    stringifySearch?: SearchSerializer;
+    parseSearch?: SearchParser;
+    defaultPreload?: false | 'intent';
+    defaultPreloadDelay?: number;
+    defaultComponent?: RouteComponent;
+    defaultErrorComponent?: RouteComponent;
+    defaultPendingComponent?: RouteComponent;
+    defaultPendingMs?: number;
+    defaultPendingMinMs?: number;
+    defaultStaleTime?: number;
+    defaultPreloadStaleTime?: number;
+    defaultPreloadGcTime?: number;
+    defaultGcTime?: number;
+    caseSensitive?: boolean;
+    routeTree?: TRouteTree;
+    basepath?: string;
+    context?: TRouteTree['types']['routerContext'];
+    dehydrate?: () => TDehydrated;
+    hydrate?: (dehydrated: TDehydrated) => void;
+    routeMasks?: RouteMask<TRouteTree>[];
+    unmaskOnReload?: boolean;
+    Wrap?: (props: {
+        children: any;
+    }) => JSX.Element;
+    InnerWrap?: (props: {
+        children: any;
+    }) => JSX.Element;
+    notFoundRoute?: AnyRoute;
+}
+export interface RouterState<TRouteTree extends AnyRoute = AnyRoute> {
+    status: 'pending' | 'idle';
+    isLoading: boolean;
+    isTransitioning: boolean;
+    matches: RouteMatch<TRouteTree>[];
+    pendingMatches?: RouteMatch<TRouteTree>[];
+    cachedMatches: RouteMatch<TRouteTree>[];
+    location: ParsedLocation<FullSearchSchema<TRouteTree>>;
+    resolvedLocation: ParsedLocation<FullSearchSchema<TRouteTree>>;
+    lastUpdated: number;
+}
+export type ListenerFn<TEvent extends RouterEvent> = (event: TEvent) => void;
+export interface BuildNextOptions {
+    to?: string | number | null;
+    params?: true | Updater<unknown>;
+    search?: true | Updater<unknown>;
+    hash?: true | Updater<string>;
+    state?: true | NonNullableUpdater<HistoryState>;
+    mask?: {
+        to?: string | number | null;
+        params?: true | Updater<unknown>;
+        search?: true | Updater<unknown>;
+        hash?: true | Updater<string>;
+        state?: true | NonNullableUpdater<HistoryState>;
+        unmaskOnReload?: boolean;
+    };
+    from?: string;
+}
+export interface DehydratedRouterState {
+    dehydratedMatches: DehydratedRouteMatch[];
+}
+export type DehydratedRouteMatch = Pick<RouteMatch, 'id' | 'status' | 'updatedAt'>;
+export interface DehydratedRouter {
+    state: DehydratedRouterState;
+}
+export type RouterConstructorOptions<TRouteTree extends AnyRoute, TDehydrated extends Record<string, any>> = Omit<RouterOptions<TRouteTree, TDehydrated>, 'context'> & RouterContextOptions<TRouteTree>;
+export declare const componentTypes: readonly ["component", "errorComponent", "pendingComponent"];
+export type RouterEvents = {
+    onBeforeLoad: {
+        type: 'onBeforeLoad';
+        fromLocation: ParsedLocation;
+        toLocation: ParsedLocation;
+        pathChanged: boolean;
+    };
+    onLoad: {
+        type: 'onLoad';
+        fromLocation: ParsedLocation;
+        toLocation: ParsedLocation;
+        pathChanged: boolean;
+    };
+    onResolved: {
+        type: 'onResolved';
+        fromLocation: ParsedLocation;
+        toLocation: ParsedLocation;
+        pathChanged: boolean;
+    };
+};
+export type RouterEvent = RouterEvents[keyof RouterEvents];
+export type RouterListener<TRouterEvent extends RouterEvent> = {
+    eventType: TRouterEvent['type'];
+    fn: ListenerFn<TRouterEvent>;
+};
+export declare class Router<TRouteTree extends AnyRoute = AnyRoute, TDehydrated extends Record<string, any> = Record<string, any>> {
+    tempLocationKey: string | undefined;
+    resetNextScroll: boolean;
+    navigateTimeout: Timeout | null;
+    latestLoadPromise: Promise<void>;
+    subscribers: Set<RouterListener<RouterEvent>>;
+    injectedHtml: InjectedHtmlEntry[];
+    dehydratedData?: TDehydrated;
+    __store: Store<RouterState<TRouteTree>>;
+    options: PickAsRequired<RouterOptions<TRouteTree, TDehydrated>, 'stringifySearch' | 'parseSearch' | 'context'>;
+    history: RouterHistory;
+    latestLocation: ParsedLocation;
+    basepath: string;
+    routeTree: TRouteTree;
+    routesById: RoutesById<TRouteTree>;
+    routesByPath: RoutesByPath<TRouteTree>;
+    flatRoutes: AnyRoute[];
+    constructor(options: RouterConstructorOptions<TRouteTree, TDehydrated>);
+    startReactTransition: (fn: () => void) => void;
+    update: (newOptions: RouterConstructorOptions<TRouteTree, TDehydrated>) => void;
+    get state(): RouterState<TRouteTree>;
+    buildRouteTree: () => void;
+    subscribe: <TType extends keyof RouterEvents>(eventType: TType, fn: ListenerFn<RouterEvents[TType]>) => () => void;
+    emit: (routerEvent: RouterEvent) => void;
+    checkLatest: (promise: Promise<void>) => undefined | Promise<void>;
+    parseLocation: (previousLocation?: ParsedLocation) => ParsedLocation<FullSearchSchema<TRouteTree>>;
+    resolvePathWithBase: (from: string, path: string) => string;
+    get looseRoutesById(): Record<string, AnyRoute>;
+    matchRoutes: <TRouteTree_1 extends AnyRoute>(pathname: string, locationSearch: AnySearchSchema, opts?: {
+        throwOnError?: boolean;
+        debug?: boolean;
+    }) => RouteMatch<TRouteTree_1, import("./routeInfo").ParseRoute<TRouteTree_1>["id"]>[];
+    cancelMatch: (id: string) => void;
+    cancelMatches: () => void;
+    buildLocation: BuildLocationFn<TRouteTree>;
+    commitLocation: ({ startTransition, ...next }: ParsedLocation & CommitLocationOptions) => Promise<void>;
+    buildAndCommitLocation: ({ replace, resetScroll, startTransition, ...rest }?: BuildNextOptions & CommitLocationOptions) => Promise<void>;
+    navigate: NavigateFn<TRouteTree>;
+    loadMatches: ({ checkLatest, matches, preload, }: {
+        checkLatest: () => Promise<void> | undefined;
+        matches: AnyRouteMatch[];
+        preload?: boolean | undefined;
+    }) => Promise<RouteMatch[]>;
+    invalidate: () => void;
+    load: () => Promise<void>;
+    cleanCache: () => void;
+    preloadRoute: (navigateOpts?: ToOptions<TRouteTree>) => Promise<RouteMatch<AnyRoute, any>[]>;
+    matchRoute: MatchRouteFn<TRouteTree>;
+    injectHtml: (html: string | (() => Promise<string> | string)) => Promise<void>;
+    dehydrateData: <T>(key: any, getData: T | (() => T | Promise<T>)) => () => T | undefined;
+    hydrateData: <T extends unknown = unknown>(key: any) => T | undefined;
+    dehydrate: () => DehydratedRouter;
+    hydrate: (__do_not_use_server_ctx?: HydrationCtx) => Promise<void>;
+}
+export declare function lazyFn<T extends Record<string, (...args: any[]) => any>, TKey extends keyof T = 'default'>(fn: () => Promise<T>, key?: TKey): (...args: Parameters<T[TKey]>) => Promise<ReturnType<T[TKey]>>;
+export declare class SearchParamError extends Error {
+}
+export declare class PathParamError extends Error {
+}
+export declare function getInitialRouterState(location: ParsedLocation): RouterState<any>;

package/build/types/scroll-restoration.d.ts

@@ -0,0 +1,18 @@
+import { ParsedLocation } from './location';
+export type ScrollRestorationOptions = {
+    getKey?: (location: ParsedLocation) => string;
+};
+export declare function useScrollRestoration(options?: ScrollRestorationOptions): void;
+export declare function ScrollRestoration(props: ScrollRestorationOptions): null;
+export declare function useElementScrollRestoration(options: ({
+    id: string;
+    getElement?: () => Element | undefined | null;
+} | {
+    id?: string;
+    getElement: () => Element | undefined | null;
+}) & {
+    getKey?: (location: ParsedLocation) => string;
+}): {
+    scrollX: number;
+    scrollY: number;
+} | undefined;

package/build/types/searchParams.d.ts

@@ -0,0 +1,7 @@
+import { AnySearchSchema } from './route';
+export declare const defaultParseSearch: (searchStr: string) => AnySearchSchema;
+export declare const defaultStringifySearch: (search: Record<string, any>) => string;
+export declare function parseSearchWith(parser: (str: string) => any): (searchStr: string) => AnySearchSchema;
+export declare function stringifySearchWith(stringify: (search: any) => string, parser?: (str: string) => any): (search: Record<string, any>) => string;
+export type SearchSerializer = (searchObj: Record<string, any>) => string;
+export type SearchParser = (searchStr: string) => Record<string, any>;

package/build/types/useBlocker.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from './route';
+import { BlockerFn } from '@tanstack/history';
+export declare function useBlocker(blockerFn: BlockerFn, condition?: boolean | any): void;
+export declare function Block({ blocker, condition, children }: PromptProps): any;
+export type PromptProps = {
+    blocker: BlockerFn;
+    condition?: boolean | any;
+    children?: ReactNode;
+};

package/build/types/useNavigate.d.ts

@@ -0,0 +1,19 @@
+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 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 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 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>);
+};

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/useStore.d.ts

@@ -0,0 +1,12 @@
+import { NonNullableUpdater } from './utils';
+export type Store<T> = {
+    getState: () => T;
+    setState: (updater: NonNullableUpdater<T>, opts?: {
+        notify?: boolean;
+    }) => void;
+    subscribe: (listener: (state: T) => void) => () => void;
+};
+export declare const createStore: <T>(createState: (setState: (nextState: T) => void, getState: () => T, api: Store<T>) => T, opts?: {
+    onUpdate?: ((nextState: T, prevState: T) => T) | undefined;
+} | undefined) => Store<T>;
+export declare function useStore<State, Slice>(store: Store<State>, selector_?: (state: State) => Slice): Slice;