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

package/build/types/CatchBoundary.d.ts

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

package/build/types/Matches.d.ts

@@ -0,0 +1,64 @@
+import * as React from 'react';
+import { ResolveRelativePath, ToOptions } from './link';
+import { AnyRoute, ReactNode } from './route';
+import { FullSearchSchema, ParseRoute, RouteById, RouteByPath, RouteIds, RoutePaths } from './routeInfo';
+import { RegisteredRouter } from './router';
+import { NoInfer, StrictOrFrom } from './utils';
+export declare const matchContext: React.Context<string | undefined>;
+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;
+    showPending: boolean;
+    error: unknown;
+    paramsError: unknown;
+    searchError: unknown;
+    updatedAt: number;
+    loadPromise?: Promise<void>;
+    loaderData?: RouteById<TRouteTree, TRouteId>['types']['loaderData'];
+    routeContext: RouteById<TRouteTree, TRouteId>['types']['routeContext'];
+    context: RouteById<TRouteTree, TRouteId>['types']['allContext'];
+    search: FullSearchSchema<TRouteTree> & RouteById<TRouteTree, TRouteId>['types']['fullSearchSchema'];
+    fetchCount: number;
+    abortController: AbortController;
+    cause: 'preload' | 'enter' | 'stay';
+    loaderDeps: RouteById<TRouteTree, TRouteId>['types']['loaderDeps'];
+    preload: boolean;
+    invalid: boolean;
+}
+export type AnyRouteMatch = RouteMatch<any, any>;
+export declare function Matches(): React.JSX.Element;
+export declare function Match({ matchId }: {
+    matchId: string;
+}): React.JSX.Element;
+export declare const Outlet: React.NamedExoticComponent<object>;
+export interface MatchRouteOptions {
+    pending?: boolean;
+    caseSensitive?: boolean;
+    includeSearch?: boolean;
+    fuzzy?: boolean;
+}
+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;
+};
+export declare function MatchRoute<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = '/', TMaskTo extends string = ''>(props: MakeMatchRouteOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo>): any;
+export declare function useMatch<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>, TStrict extends boolean = true, TRouteMatchState = RouteMatch<TRouteTree, TFrom>, TSelected = TRouteMatchState>(opts: StrictOrFrom<TFrom> & {
+    select?: (match: TRouteMatchState) => TSelected;
+}): TStrict extends true ? TSelected : TSelected | undefined;
+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 useLoaderDeps<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>['loaderDeps']>(opts: StrictOrFrom<TFrom> & {
+    select?: (match: TRouteMatch) => TSelected;
+}): TStrict extends true ? TSelected : TSelected | undefined;
+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/RouterProvider.d.ts

@@ -0,0 +1,35 @@
+import * as React from 'react';
+import { NavigateOptions, ResolveRelativePath, ToOptions } from './link';
+import { ParsedLocation } from './location';
+import { AnyRoute } from './route';
+import { RouteById, RoutePaths } from './routeInfo';
+import { RegisteredRouter, Router, RouterOptions, RouterState } from './router';
+import { NoInfer } from './utils';
+import { MatchRouteOptions } from './Matches';
+import { RouteMatch } from './Matches';
+export interface CommitLocationOptions {
+    replace?: boolean;
+    resetScroll?: boolean;
+    startTransition?: boolean;
+}
+export interface MatchLocation {
+    to?: string | number | null;
+    fuzzy?: boolean;
+    caseSensitive?: boolean;
+    from?: string;
+}
+export type NavigateFn<TRouteTree extends AnyRoute> = <TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = TFrom, TMaskTo extends string = ''>(opts: 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>>>(location: ToOptions<TRouteTree, TFrom, TTo>, opts?: MatchRouteOptions) => false | RouteById<TRouteTree, TResolved>['types']['allParams'];
+export type BuildLocationFn<TRouteTree extends AnyRoute> = (opts: ToOptions<TRouteTree>) => ParsedLocation;
+export type InjectedHtmlEntry = string | (() => Promise<string> | string);
+export declare let routerContext: React.Context<Router<any, Record<string, any>>>;
+export declare function RouterProvider<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TDehydrated extends Record<string, any> = Record<string, any>>({ router, ...rest }: RouterProps<TRouteTree, TDehydrated>): React.JSX.Element;
+export declare function getRouteMatch<TRouteTree extends AnyRoute>(state: RouterState<TRouteTree>, id: string): undefined | RouteMatch<TRouteTree>;
+export declare function useRouterState<TSelected = RouterState<RegisteredRouter['routeTree']>>(opts?: {
+    select: (state: RouterState<RegisteredRouter['routeTree']>) => TSelected;
+}): TSelected;
+export type RouterProps<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TDehydrated extends Record<string, any> = Record<string, any>> = Omit<RouterOptions<TRouteTree, TDehydrated>, 'context'> & {
+    router: Router<TRouteTree>;
+    context?: Partial<RouterOptions<TRouteTree, TDehydrated>['context']>;
+};
+export declare function useRouter<TRouteTree extends AnyRoute = RegisteredRouter['routeTree']>(): Router<TRouteTree>;

package/build/types/awaited.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { DeferredPromise } from './defer';
+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/defer.d.ts

@@ -0,0 +1,19 @@
+export type DeferredPromiseState<T> = {
+    uid: string;
+} & ({
+    status: 'pending';
+    data?: T;
+    error?: unknown;
+} | {
+    status: 'success';
+    data: T;
+} | {
+    status: 'error';
+    data?: T;
+    error: unknown;
+});
+export type DeferredPromise<T> = Promise<T> & {
+    __deferredState: DeferredPromiseState<T>;
+};
+export declare function defer<T>(_promise: Promise<T>): DeferredPromise<T>;
+export declare function isDehydratedDeferred(obj: any): boolean;

package/build/types/fileRoute.d.ts

@@ -0,0 +1,38 @@
+import { ParsePathParams } from './link';
+import { AnyRoute, ResolveFullPath, ResolveFullSearchSchema, MergeFromFromParent, RouteContext, AnyContext, RouteOptions, UpdatableRouteOptions, Route, 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 = ResolveFullSearchSchema<TParentRoute, TSearchSchema>, TParams extends Record<string, any> = Expand<Record<ParsePathParams<TPath>, string>>, TAllParams extends Record<string, any> = MergeFromFromParent<TParentRoute["types"]["allParams"], TParams>, TRouteContext extends RouteContext = RouteContext, TContext extends Expand<Assign<IsAny<TParentRoute["types"]["allContext"], {}>, TRouteContext>> = Expand<Assign<IsAny<TParentRoute["types"]["allContext"], {}>, TRouteContext>>, TRouterContext extends AnyContext = AnyContext, TLoaderDeps extends Record<string, any> = {}, TLoaderData extends unknown = unknown, TChildren extends unknown = unknown, TRouteTree extends AnyRoute = AnyRoute>(options?: (Omit<RouteOptions<TParentRoute, string, TPath, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TRouteContext, TContext, TLoaderDeps, TLoaderData>, "path" | "id" | "getParentRoute"> & {
+        meta?: import("./route").RouteMeta | undefined;
+    } & {
+        caseSensitive?: boolean | undefined;
+        wrapInSuspense?: boolean | undefined;
+        component?: import("./route").RouteComponent<any> | undefined;
+        errorComponent?: false | import("./route").ErrorRouteComponent | null | undefined;
+        pendingComponent?: import("./route").RouteComponent<any> | undefined;
+        pendingMs?: number | undefined;
+        pendingMinMs?: number | undefined;
+        staleTime?: number | undefined;
+        gcTime?: number | undefined;
+        preloadStaleTime?: number | undefined;
+        preloadGcTime?: 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;
+        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, TLoaderDeps, TLoaderData, 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,74 +1,27 @@
-/**
- * react-router
- *
- * Copyright (c) TanStack
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE.md file in the root directory of this source tree.
- *
- * @license MIT
- */
-import * as React from 'react';
-import { AnyRouteConfig, RouteConfig, AnyAllRouteInfo, AllRouteInfo, RouterState, RouteMatch, ToOptions, MatchRouteOptions, RouteInfoByPath, ResolveRelativePath, NoInfer, DefaultAllRouteInfo, AnyRouteInfo, RouteInfo, CheckId, ToIdOption, ValidFromPath, LinkOptions, RouterOptions, Router } from '@tanstack/router-core';
-export * from '@tanstack/router-core';
-
-declare module '@tanstack/router-core' {
-    interface FrameworkGenerics {
-        Element: React.ReactNode;
-        SyncOrAsyncElement: React.ReactNode | (() => Promise<any>);
-    }
-    interface Router<TRouteConfig extends AnyRouteConfig = RouteConfig, TAllRouteInfo extends AnyAllRouteInfo = AllRouteInfo<TRouteConfig>> {
-        useState: () => RouterState;
-        useRoute: <TId extends keyof TAllRouteInfo['routeInfoById']>(routeId: TId) => Route<TAllRouteInfo, TAllRouteInfo['routeInfoById'][TId]>;
-        useMatch: <TId extends keyof TAllRouteInfo['routeInfoById']>(routeId: TId) => RouteMatch<TAllRouteInfo, TAllRouteInfo['routeInfoById'][TId]>;
-        linkProps: <TTo extends string = '.'>(props: LinkPropsOptions<TAllRouteInfo, '/', TTo> & React.AnchorHTMLAttributes<HTMLAnchorElement>) => React.AnchorHTMLAttributes<HTMLAnchorElement>;
-        Link: <TTo extends string = '.'>(props: LinkPropsOptions<TAllRouteInfo, '/', TTo> & React.AnchorHTMLAttributes<HTMLAnchorElement> & Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, 'children'> & {
-            children?: React.ReactNode | ((state: {
-                isActive: boolean;
-            }) => React.ReactNode);
-        }) => JSX.Element;
-        MatchRoute: <TTo extends string = '.'>(props: ToOptions<TAllRouteInfo, '/', TTo> & MatchRouteOptions & {
-            children?: React.ReactNode | ((params: RouteInfoByPath<TAllRouteInfo, ResolveRelativePath<'/', NoInfer<TTo>>>['allParams']) => React.ReactNode);
-        }) => JSX.Element;
-    }
-    interface Route<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TRouteInfo extends AnyRouteInfo = RouteInfo> {
-        useRoute: <TTo extends string = '.', TResolved extends string = ResolveRelativePath<TRouteInfo['id'], NoInfer<TTo>>>(routeId: CheckId<TAllRouteInfo, TResolved, ToIdOption<TAllRouteInfo, TRouteInfo['id'], TTo>>) => Route<TAllRouteInfo, TAllRouteInfo['routeInfoById'][TResolved]>;
-        linkProps: <TTo extends string = '.'>(props: LinkPropsOptions<TAllRouteInfo, TRouteInfo['fullPath'], TTo> & React.AnchorHTMLAttributes<HTMLAnchorElement>) => React.AnchorHTMLAttributes<HTMLAnchorElement>;
-        Link: <TTo extends string = '.'>(props: LinkPropsOptions<TAllRouteInfo, TRouteInfo['fullPath'], TTo> & React.AnchorHTMLAttributes<HTMLAnchorElement> & Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, 'children'> & {
-            children?: React.ReactNode | ((state: {
-                isActive: boolean;
-            }) => React.ReactNode);
-        }) => JSX.Element;
-        MatchRoute: <TTo extends string = '.'>(props: ToOptions<TAllRouteInfo, TRouteInfo['fullPath'], TTo> & MatchRouteOptions & {
-            children?: React.ReactNode | ((params: RouteInfoByPath<TAllRouteInfo, ResolveRelativePath<TRouteInfo['fullPath'], NoInfer<TTo>>>['allParams']) => React.ReactNode);
-        }) => JSX.Element;
-    }
-}
-declare type LinkPropsOptions<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TFrom extends ValidFromPath<TAllRouteInfo> = '/', TTo extends string = '.'> = LinkOptions<TAllRouteInfo, TFrom, TTo> & {
-    activeProps?: React.AnchorHTMLAttributes<HTMLAnchorElement> | (() => React.AnchorHTMLAttributes<HTMLAnchorElement>);
-    inactiveProps?: React.AnchorHTMLAttributes<HTMLAnchorElement> | (() => React.AnchorHTMLAttributes<HTMLAnchorElement>);
-};
-declare type PromptProps = {
-    message: string;
-    when?: boolean | any;
-    children?: React.ReactNode;
-};
-declare type MatchesProviderProps = {
-    value: RouteMatch[];
-    children: React.ReactNode;
-};
-declare function MatchesProvider(props: MatchesProviderProps): JSX.Element;
-declare function createReactRouter<TRouteConfig extends AnyRouteConfig = RouteConfig>(opts: RouterOptions<TRouteConfig>): Router<TRouteConfig>;
-declare type RouterProps<TRouteConfig extends AnyRouteConfig = RouteConfig, TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo> = RouterOptions<TRouteConfig> & {
-    router: Router<TRouteConfig, TAllRouteInfo>;
-    children?: React.ReactNode;
-};
-declare function RouterProvider<TRouteConfig extends AnyRouteConfig = RouteConfig, TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo>({ children, router, ...rest }: RouterProps<TRouteConfig, TAllRouteInfo>): JSX.Element;
-declare function Outlet(): JSX.Element | null;
-declare function DefaultErrorBoundary({ error }: {
-    error: any;
-}): JSX.Element;
-declare function usePrompt(message: string, when: boolean | any): void;
-declare function Prompt({ message, when, children }: PromptProps): React.ReactNode;
-
-export { DefaultErrorBoundary, MatchesProvider, MatchesProviderProps, Outlet, Prompt, PromptProps, RouterProps, RouterProvider, createReactRouter, usePrompt };
+export * from '@tanstack/history';
+export { default as invariant } from 'tiny-invariant';
+export { default as warning } from 'tiny-warning';
+export * from './awaited';
+export * from './defer';
+export * from './CatchBoundary';
+export * from './fileRoute';
+export * from './history';
+export * from './index';
+export * from './lazyRouteComponent';
+export * from './link';
+export * from './location';
+export * from './Matches';
+export * from './path';
+export * from './qss';
+export * from './redirects';
+export * from './route';
+export * from './routeInfo';
+export * from './router';
+export * from './RouterProvider';
+export * from './scroll-restoration';
+export * from './searchParams';
+export * from './useBlocker';
+export * from './useNavigate';
+export * from './useParams';
+export * from './useSearch';
+export * from './utils';

package/build/types/lazyRouteComponent.d.ts

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

package/build/types/link.d.ts

@@ -0,0 +1,93 @@
+import * as React from 'react';
+import { Trim } from './fileRoute';
+import { AnyRoute, ReactNode } from './route';
+import { AllParams, FullSearchSchema, RouteByPath, RouteIds, RoutePaths } from './routeInfo';
+import { RegisteredRouter } from './router';
+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 {
+    [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;
+    startTransition?: boolean;
+};
+export type ToOptions<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = '/', TMaskTo extends string = ''> = ToSubOptions<TRouteTree, TFrom, TTo> & {
+    mask?: ToMaskOptions<TRouteTree, TMaskFrom, TMaskTo>;
+};
+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<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<PickRequired<RouteByPath<TRouteTree, TFrom>['types']['fullSearchSchema']>>, TFromSearchOptional = Omit<FullSearchSchema<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']>> = never extends TToParams ? {
+    params?: true | ParamsReducer<Partial<TFromParams>, Partial<TFromParams>>;
+} : 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 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: LinkProps<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> & TProps & React.RefAttributes<HTMLAnchorElement>): ReactNode;
+}
+export declare const Link: LinkComponent;
+export {};

package/build/types/location.d.ts

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

package/build/types/path.d.ts

@@ -0,0 +1,17 @@
+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 removeBasepath(basepath: string, pathname: string): string;
+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/redirects.d.ts

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