@tanstack/router-core 0.0.1-beta.174 → 0.0.1-beta.176

package/build/types/link.d.ts

@@ -0,0 +1,92 @@
+import { Trim } from './fileRoute';
+import { AnyRoute } from './route';
+import { AllParams, FullSearchSchema, RouteByPath, RouteIds, RoutePaths } from './routeInfo';
+import { ParsedLocation, LocationState } from './router';
+import { NoInfer, 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 = AnyRoute, TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = ''> = ToOptions<TRouteTree, TFrom, TTo> & {
+    replace?: boolean;
+    resetScroll?: boolean;
+};
+export type ToOptions<TRouteTree extends AnyRoute = AnyRoute, TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TResolvedTo = ResolveRelativePath<TFrom, NoInfer<TTo>>> = {
+    to?: ToPathOption<TRouteTree, TFrom, TTo>;
+    hash?: Updater<string>;
+    state?: LocationState;
+    from?: TFrom;
+} & CheckPath<TRouteTree, NoInfer<TResolvedTo>, {}> & SearchParamOptions<TRouteTree, TFrom, TResolvedTo> & PathParamOptions<TRouteTree, TFrom, TResolvedTo>;
+export type SearchParamOptions<TRouteTree extends AnyRoute, TFrom, TTo, TFromSchema = UnionToIntersection<FullSearchSchema<TRouteTree> & RouteByPath<TRouteTree, TFrom> extends never ? {} : RouteByPath<TRouteTree, TFrom>['types']['fullSearchSchema']>, TToSchema = Partial<RouteByPath<TRouteTree, TFrom>['types']['fullSearchSchema']> & Omit<RouteByPath<TRouteTree, TTo>['types']['fullSearchSchema'], keyof PickRequired<RouteByPath<TRouteTree, TFrom>['types']['fullSearchSchema']>>, TFromFullSchema = UnionToIntersection<FullSearchSchema<TRouteTree> & TFromSchema>, TToFullSchema = UnionToIntersection<FullSearchSchema<TRouteTree> & TToSchema>> = keyof PickRequired<TToSchema> extends never ? {
+    search?: true | SearchReducer<TFromFullSchema, TToFullSchema>;
+} : {
+    search: SearchReducer<TFromFullSchema, TToFullSchema>;
+};
+type SearchReducer<TFrom, TTo> = {
+    [TKey in keyof TTo]: TTo[TKey];
+} | ((current: TFrom) => TTo);
+export type PathParamOptions<TRouteTree extends AnyRoute, TFrom, TTo, TFromSchema = UnionToIntersection<RouteByPath<TRouteTree, TFrom> extends never ? {} : RouteByPath<TRouteTree, TFrom>['types']['allParams']>, TToSchema = Partial<RouteByPath<TRouteTree, TFrom>['types']['allParams']> & Omit<RouteByPath<TRouteTree, TTo>['types']['allParams'], keyof PickRequired<RouteByPath<TRouteTree, TFrom>['types']['allParams']>>, TFromFullParams = UnionToIntersection<AllParams<TRouteTree> & TFromSchema>, TToFullParams = UnionToIntersection<AllParams<TRouteTree> & TToSchema>> = keyof PickRequired<TToSchema> extends never ? {
+    params?: ParamsReducer<TFromFullParams, TToFullParams>;
+} : {
+    params: ParamsReducer<TFromFullParams, TToFullParams>;
+};
+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 = AnyRoute, TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = ''> = NavigateOptions<TRouteTree, TFrom, TTo> & {
+    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/path.d.ts

@@ -0,0 +1,16 @@
+import { AnyPathParams } from './route';
+import { MatchLocation } from './router';
+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/route.d.ts

@@ -0,0 +1,234 @@
+import { ParsePathParams } from './link';
+import { AnyRouter, RouteMatch, AnyRouteMatch } from './router';
+import { IsAny, NoInfer, PickRequired, UnionToIntersection } from './utils';
+export declare const rootRouteId: "__root__";
+export type RootRouteId = typeof rootRouteId;
+export type AnyPathParams = {};
+export type AnySearchSchema = {};
+export type AnyContext = {};
+export interface RouteMeta {
+}
+export interface RouteContext {
+}
+export interface RegisterRouteComponent<TLoader = unknown, TFullSearchSchema extends AnySearchSchema = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TRouteContext extends AnyContext = AnyContext, TAllContext extends AnyContext = AnyContext> {
+}
+export interface RegisterErrorRouteComponent<TFullSearchSchema extends AnySearchSchema = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TRouteContext extends AnyContext = AnyContext, TAllContext extends AnyContext = AnyContext> {
+}
+export interface RegisterPendingRouteComponent<TFullSearchSchema extends AnySearchSchema = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TRouteContext extends AnyContext = AnyContext, TAllContext extends AnyContext = AnyContext> {
+}
+export interface RegisterRouteProps<TLoader = unknown, TFullSearchSchema extends AnySearchSchema = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TRouteContext extends AnyContext = AnyContext, TAllContext extends AnyContext = AnyContext> {
+}
+export interface RegisterErrorRouteProps<TFullSearchSchema extends AnySearchSchema = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TRouteContext extends AnyContext = AnyContext, TAllContext extends AnyContext = AnyContext> {
+}
+export interface RegisterPendingRouteProps<TFullSearchSchema extends AnySearchSchema = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TRouteContext extends AnyContext = AnyContext, TAllContext extends AnyContext = AnyContext> {
+}
+export type RegisteredRouteComponent<TLoader = unknown, TFullSearchSchema extends AnySearchSchema = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TRouteContext extends AnyContext = AnyContext, TAllContext extends AnyContext = AnyContext> = RegisterRouteComponent<TLoader, TFullSearchSchema, TAllParams, TRouteContext, TAllContext> extends {
+    RouteComponent: infer T;
+} ? T : () => unknown;
+export type RegisteredErrorRouteComponent<TFullSearchSchema extends AnySearchSchema = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TRouteContext extends AnyContext = AnyContext, TAllContext extends AnyContext = AnyContext> = RegisterErrorRouteComponent<TFullSearchSchema, TAllParams, TRouteContext, TAllContext> extends {
+    ErrorRouteComponent: infer T;
+} ? T : () => unknown;
+export type RegisteredPendingRouteComponent<TFullSearchSchema extends AnySearchSchema = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TRouteContext extends AnyContext = AnyContext, TAllContext extends AnyContext = AnyContext> = RegisterPendingRouteComponent<TFullSearchSchema, TAllParams, TRouteContext, TAllContext> extends {
+    PendingRouteComponent: infer T;
+} ? T : () => unknown;
+export type RegisteredRouteProps<TLoader = unknown, TFullSearchSchema extends AnySearchSchema = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TRouteContext extends AnyContext = AnyContext, TAllContext extends AnyContext = AnyContext> = RegisterRouteProps<TLoader, TFullSearchSchema, TAllParams, TRouteContext, TAllContext> extends {
+    RouteProps: infer T;
+} ? T : {};
+export type RegisteredErrorRouteProps<TFullSearchSchema extends AnySearchSchema = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TRouteContext extends AnyContext = AnyContext, TAllContext extends AnyContext = AnyContext> = RegisterRouteProps<TFullSearchSchema, TAllParams, TRouteContext, TAllContext> extends {
+    ErrorRouteProps: infer T;
+} ? T : {};
+export type RegisteredPendingRouteProps<TFullSearchSchema extends AnySearchSchema = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TRouteContext extends AnyContext = AnyContext, TAllContext extends AnyContext = AnyContext> = RegisterRouteProps<TFullSearchSchema, TAllParams, TRouteContext, TAllContext> extends {
+    PendingRouteProps: infer T;
+} ? T : {};
+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 AnyRouteProps = RegisteredRouteProps<any, any, any, any, any>;
+export type RouteOptions<TParentRoute extends AnyRoute = AnyRoute, TCustomId extends string = string, TPath extends string = string, TLoader = unknown, TParentSearchSchema extends AnySearchSchema = {}, TSearchSchema extends AnySearchSchema = {}, TFullSearchSchema extends AnySearchSchema = TSearchSchema, TParams extends AnyPathParams = AnyPathParams, TAllParams extends AnyPathParams = TParams, TParentContext extends AnyContext = AnyContext, TAllParentContext extends AnyContext = AnyContext, TRouteContext extends RouteContext = RouteContext, TAllContext extends AnyContext = AnyContext> = BaseRouteOptions<TParentRoute, TCustomId, TPath, TLoader, TParentSearchSchema, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TParentContext, TAllParentContext, TRouteContext, TAllContext> & UpdatableRouteOptions<TLoader, TSearchSchema, TFullSearchSchema, TAllParams, TRouteContext, TAllContext>;
+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, TLoader = unknown, TParentSearchSchema extends AnySearchSchema = {}, TSearchSchema extends AnySearchSchema = {}, TFullSearchSchema extends AnySearchSchema = TSearchSchema, TParams extends AnyPathParams = {}, TAllParams = ParamsFallback<TPath, TParams>, TParentContext extends AnyContext = AnyContext, TAllParentContext extends AnyContext = AnyContext, TRouteContext extends RouteContext = RouteContext, TAllContext extends AnyContext = AnyContext> = RoutePathOptions<TCustomId, TPath> & {
+    layoutLimit?: string;
+    getParentRoute: () => TParentRoute;
+    validateSearch?: SearchSchemaValidator<TSearchSchema>;
+    loader?: LoaderFn<TLoader, TSearchSchema, TFullSearchSchema, TAllParams, NoInfer<TRouteContext>, TAllContext>;
+} & ([TLoader] extends [never] ? {
+    loader: 'Loaders must return a type other than never. If you are throwing a redirect() and not returning anything, return a redirect() instead.';
+} : {}) & ({
+    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;
+}) & (keyof PickRequired<RouteContext> extends never ? {
+    getContext?: GetContextFn<TParentRoute, TAllParams, TFullSearchSchema, TParentContext, TAllParentContext, TRouteContext>;
+} : {
+    getContext: GetContextFn<TParentRoute, TAllParams, TFullSearchSchema, TParentContext, TAllParentContext, TRouteContext>;
+});
+type GetContextFn<TParentRoute, TAllParams, TFullSearchSchema, TParentContext, TAllParentContext, TRouteContext> = (opts: {
+    params: TAllParams;
+    search: TFullSearchSchema;
+} & (TParentRoute extends undefined ? {
+    context?: TAllParentContext;
+    parentContext?: TParentContext;
+} : {
+    context: TAllParentContext;
+    parentContext: TParentContext;
+})) => TRouteContext;
+export type UpdatableRouteOptions<TLoader, TSearchSchema extends AnySearchSchema, TFullSearchSchema extends AnySearchSchema, TAllParams extends AnyPathParams, TRouteContext extends AnyContext, TAllContext extends AnyContext> = MetaOptions & {
+    key?: null | false | GetKeyFn<TFullSearchSchema, TAllParams>;
+    caseSensitive?: boolean;
+    wrapInSuspense?: boolean;
+    component?: RegisteredRouteComponent<TLoader, TFullSearchSchema, TAllParams, TRouteContext, TAllContext>;
+    errorComponent?: RegisteredErrorRouteComponent<TFullSearchSchema, TAllParams, TRouteContext, TAllContext>;
+    pendingComponent?: RegisteredPendingRouteComponent<TFullSearchSchema, TAllParams, TRouteContext, TAllContext>;
+    preSearchFilters?: SearchFilter<TFullSearchSchema>[];
+    postSearchFilters?: SearchFilter<TFullSearchSchema>[];
+    preloadMaxAge?: number;
+    maxAge?: number;
+    gcMaxAge?: number;
+    beforeLoad?: (opts: LoaderContext<TSearchSchema, TFullSearchSchema, TAllParams, NoInfer<TRouteContext>, TAllContext>) => Promise<void> | void;
+    onError?: (err: any) => void;
+    onEnter?: (match: AnyRouteMatch) => void;
+    onTransition?: (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 LoaderFn<TLoader = unknown, TSearchSchema extends AnySearchSchema = {}, TFullSearchSchema extends AnySearchSchema = {}, TAllParams = {}, TContext extends AnyContext = AnyContext, TAllContext extends AnyContext = AnyContext> = (match: LoaderContext<TSearchSchema, TFullSearchSchema, TAllParams, TContext, TAllContext> & {
+    parentMatchPromise?: Promise<void>;
+}) => Promise<TLoader> | TLoader;
+export type GetKeyFn<TFullSearchSchema extends AnySearchSchema = {}, TAllParams = {}> = (loaderContext: {
+    params: TAllParams;
+    search: TFullSearchSchema;
+}) => any;
+export interface LoaderContext<TSearchSchema extends AnySearchSchema = {}, TFullSearchSchema extends AnySearchSchema = {}, TAllParams = {}, TContext extends AnyContext = AnyContext, TAllContext extends AnyContext = AnyContext> {
+    params: TAllParams;
+    routeSearch: TSearchSchema;
+    search: TFullSearchSchema;
+    abortController: AbortController;
+    preload: boolean;
+    routeContext: TContext;
+    context: TAllContext;
+}
+export type UnloaderFn<TPath extends string> = (routeMatch: RouteMatch<any, Route>) => void;
+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 {
+    isRoot: true;
+    types: {
+        searchSchema: infer TSearchSchema;
+    };
+} ? TSearchSchema : TRoute extends {
+    types: {
+        fullSearchSchema: infer TFullSearchSchema;
+    };
+} ? TFullSearchSchema : {};
+export type ResolveFullSearchSchema<TParentRoute, TSearchSchema> = InferFullSearchSchema<TParentRoute> & TSearchSchema;
+export interface AnyRoute extends Route<any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any> {
+}
+export type MergeParamsFromParent<T, U> = IsAny<T, U, T & U>;
+export type UseLoaderResult<T> = T;
+export type StreamedPromise<T> = {
+    promise: Promise<T>;
+    status: 'resolved' | 'pending';
+    data: T;
+    resolve: (value: T) => void;
+};
+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;
+    TAllParentContext: AnyContext;
+    TRouteContext: RouteContext;
+    TAllContext: AnyContext;
+    TRouterContext: AnyContext;
+    TChildren: unknown;
+    TRouteTree: AnyRoute;
+};
+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>, TLoader = unknown, TSearchSchema extends RouteConstraints['TSearchSchema'] = {}, TFullSearchSchema extends RouteConstraints['TFullSearchSchema'] = ResolveFullSearchSchema<TParentRoute, TSearchSchema>, TParams extends RouteConstraints['TParams'] = Record<ParsePathParams<TPath>, string>, TAllParams extends RouteConstraints['TAllParams'] = MergeParamsFromParent<TParentRoute['types']['allParams'], TParams>, TParentContext extends RouteConstraints['TParentContext'] = TParentRoute['types']['routeContext'], TAllParentContext extends RouteConstraints['TAllParentContext'] = TParentRoute['types']['context'], TRouteContext extends RouteConstraints['TRouteContext'] = RouteContext, TAllContext extends RouteConstraints['TAllContext'] = MergeParamsFromParent<TParentRoute['types']['context'], TRouteContext>, TRouterContext extends RouteConstraints['TRouterContext'] = AnyContext, TChildren extends RouteConstraints['TChildren'] = unknown, TRouteTree extends RouteConstraints['TRouteTree'] = AnyRoute> {
+    types: {
+        parentRoute: TParentRoute;
+        path: TPath;
+        to: TrimPathRight<TFullPath>;
+        fullPath: TFullPath;
+        customId: TCustomId;
+        id: TId;
+        loader: TLoader;
+        searchSchema: TSearchSchema;
+        fullSearchSchema: TFullSearchSchema;
+        params: TParams;
+        allParams: TAllParams;
+        parentContext: TParentContext;
+        allParentContext: TAllParentContext;
+        routeContext: TRouteContext;
+        context: TAllContext;
+        children: TChildren;
+        routeTree: TRouteTree;
+        routerContext: TRouterContext;
+    };
+    isRoot: TParentRoute extends Route<any> ? true : false;
+    options: RouteOptions<TParentRoute, TCustomId, TPath, TLoader, InferFullSearchSchema<TParentRoute>, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TParentContext, TAllParentContext, TRouteContext, TAllContext> & UpdatableRouteOptions<TLoader, TSearchSchema, TFullSearchSchema, TAllParams, TRouteContext, TAllContext>;
+    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, TLoader, InferFullSearchSchema<TParentRoute>, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TParentContext, TAllParentContext, TRouteContext, TAllContext> & UpdatableRouteOptions<TLoader, TSearchSchema, TFullSearchSchema, TAllParams, TRouteContext, TAllContext>);
+    init: (opts: {
+        originalIndex: number;
+        router: AnyRouter;
+    }) => void;
+    addChildren: <TNewChildren extends AnyRoute[]>(children: TNewChildren) => Route<TParentRoute, TPath, TFullPath, TCustomId, TId, TLoader, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TParentContext, TAllParentContext, TRouteContext, TAllContext, TRouterContext, TNewChildren, TRouteTree>;
+    update: (options: UpdatableRouteOptions<TLoader, TSearchSchema, TFullSearchSchema, TAllParams, TRouteContext, TAllContext>) => this;
+    static __onInit: (route: any) => void;
+}
+export type AnyRootRoute = RootRoute<any, any, any, any>;
+export declare class RouterContext<TRouterContext extends {}> {
+    constructor();
+    createRootRoute: <TLoader = unknown, TSearchSchema extends AnySearchSchema = {}, TRouteContext extends RouteContext = RouteContext>(options?: Omit<RouteOptions<AnyRoute, "__root__", "", TLoader, TSearchSchema, TSearchSchema, TSearchSchema, {}, {}, TRouterContext, TRouterContext, TRouteContext, IsAny<TRouterContext, TRouteContext, TRouterContext & TRouteContext>>, "caseSensitive" | "id" | "path" | "getParentRoute" | "stringifyParams" | "parseParams"> | undefined) => RootRoute<TLoader, TSearchSchema, TRouteContext, TRouterContext>;
+}
+export declare class RootRoute<TLoader = unknown, TSearchSchema extends AnySearchSchema = {}, TRouteContext extends RouteContext = RouteContext, TRouterContext extends {} = {}> extends Route<any, '/', '/', string, RootRouteId, TLoader, TSearchSchema, TSearchSchema, {}, {}, TRouterContext, TRouterContext, TRouteContext, MergeParamsFromParent<TRouterContext, TRouteContext>, TRouterContext, any, any> {
+    constructor(options?: Omit<RouteOptions<AnyRoute, RootRouteId, '', TLoader, TSearchSchema, TSearchSchema, TSearchSchema, {}, {}, TRouterContext, TRouterContext, TRouteContext, MergeParamsFromParent<TRouterContext, TRouteContext>>, '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 {};

package/build/types/routeInfo.d.ts

@@ -0,0 +1,22 @@
+import { AnyRoute, Route } from './route';
+import { MergeUnion } 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, 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'] | '/';
+export type FullSearchSchema<TRouteTree extends AnyRoute> = MergeUnion<ParseRoute<TRouteTree>['types']['fullSearchSchema']> & {};
+export type AllParams<TRouteTree extends AnyRoute> = MergeUnion<ParseRoute<TRouteTree>['types']['allParams']>;

package/build/types/router.d.ts

@@ -0,0 +1,251 @@
+/// <reference types="react" />
+import { Store } from '@tanstack/store';
+import { LinkInfo, LinkOptions, NavigateOptions, ToOptions, ResolveRelativePath } from './link';
+import { Route, AnySearchSchema, AnyRoute, AnyContext, AnyPathParams, RegisteredRouteComponent, RegisteredErrorRouteComponent, RegisteredPendingRouteComponent } from './route';
+import { RoutesById, RoutesByPath, ParseRoute, FullSearchSchema, RouteById, RoutePaths, RouteIds } from './routeInfo';
+import { NoInfer, PickAsRequired, Timeout, Updater } from './utils';
+import { RouterHistory } from './history';
+declare global {
+    interface Window {
+        __TSR_DEHYDRATED__?: HydrationCtx;
+    }
+}
+export interface Register {
+}
+export type AnyRouter = Router<any, any>;
+export type RegisteredRouter = Register extends {
+    router: infer TRouter extends AnyRouter;
+} ? TRouter : AnyRouter;
+export interface LocationState {
+}
+export interface ParsedLocation<TSearchObj extends AnySearchSchema = {}> {
+    href: string;
+    pathname: string;
+    search: TSearchObj;
+    searchStr: string;
+    state: LocationState;
+    hash: string;
+    key?: string;
+}
+export interface FromLocation {
+    pathname: string;
+    search?: unknown;
+    key?: string;
+    hash?: string;
+}
+export type SearchSerializer = (searchObj: Record<string, any>) => string;
+export type SearchParser = (searchStr: string) => Record<string, any>;
+export type HydrationCtx = {
+    router: DehydratedRouter;
+    payload: Record<string, any>;
+};
+export interface RouteMatch<TRouteTree extends AnyRoute = AnyRoute, TRouteId extends RouteIds<TRouteTree> = ParseRoute<TRouteTree>['id']> {
+    id: string;
+    key?: 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;
+    maxAge: number;
+    preloadMaxAge: number;
+    loaderData: RouteById<TRouteTree, TRouteId>['types']['loader'];
+    loadPromise?: Promise<void>;
+    __resolveLoadPromise?: () => void;
+    routeContext: RouteById<TRouteTree, TRouteId>['types']['routeContext'];
+    context: RouteById<TRouteTree, TRouteId>['types']['context'];
+    routeSearch: RouteById<TRouteTree, TRouteId>['types']['searchSchema'];
+    search: FullSearchSchema<TRouteTree> & RouteById<TRouteTree, TRouteId>['types']['fullSearchSchema'];
+    fetchedAt: number;
+    abortController: AbortController;
+}
+export type AnyRouteMatch = RouteMatch<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>> {
+    history?: RouterHistory;
+    stringifySearch?: SearchSerializer;
+    parseSearch?: SearchParser;
+    defaultPreload?: false | 'intent';
+    defaultPreloadDelay?: number;
+    refetchOnWindowFocus?: boolean;
+    defaultComponent?: RegisteredRouteComponent<unknown, AnySearchSchema, AnyPathParams, AnyContext, AnyContext>;
+    defaultErrorComponent?: RegisteredErrorRouteComponent<AnySearchSchema, AnyPathParams, AnyContext, AnyContext>;
+    defaultPendingComponent?: RegisteredPendingRouteComponent<AnySearchSchema, AnyPathParams, AnyContext, AnyContext>;
+    defaultMaxAge?: number;
+    defaultGcMaxAge?: number;
+    defaultPreloadMaxAge?: number;
+    caseSensitive?: boolean;
+    routeTree?: TRouteTree;
+    basepath?: string;
+    createRoute?: (opts: {
+        route: AnyRoute;
+        router: AnyRouter;
+    }) => void;
+    context?: TRouteTree['types']['routerContext'];
+    Wrap?: React.ComponentType<{
+        children: React.ReactNode;
+        dehydratedState?: TDehydrated;
+    }>;
+    dehydrate?: () => TDehydrated;
+    hydrate?: (dehydrated: TDehydrated) => void;
+}
+export interface RouterState<TRouteTree extends AnyRoute = AnyRoute> {
+    status: 'idle' | 'pending';
+    isFetching: boolean;
+    matchesById: Record<string, RouteMatch<TRouteTree>>;
+    matchIds: string[];
+    pendingMatchIds: string[];
+    matches: RouteMatch<TRouteTree>[];
+    pendingMatches: 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?: LocationState;
+    key?: string;
+    from?: string;
+    fromCurrent?: boolean;
+    __matches?: AnyRouteMatch[];
+}
+export interface MatchLocation {
+    to?: string | number | null;
+    fuzzy?: boolean;
+    caseSensitive?: boolean;
+    from?: string;
+    fromCurrent?: boolean;
+}
+export interface MatchRouteOptions {
+    pending?: boolean;
+    caseSensitive?: boolean;
+    includeSearch?: boolean;
+    fuzzy?: boolean;
+}
+export interface DehydratedRouterState {
+    dehydratedMatches: DehydratedRouteMatch[];
+}
+export type DehydratedRouteMatch = Pick<RouteMatch, 'fetchedAt' | 'invalid' | 'maxAge' | 'preloadMaxAge' | 'id' | 'loaderData' | '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';
+        from: ParsedLocation;
+        to: ParsedLocation;
+        pathChanged: boolean;
+    };
+    onLoad: {
+        type: 'onLoad';
+        from: ParsedLocation;
+        to: 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>> {
+    #private;
+    types: {
+        RootRoute: TRouteTree;
+    };
+    options: PickAsRequired<RouterOptions<TRouteTree, TDehydrated>, 'stringifySearch' | 'parseSearch' | 'context'>;
+    history: RouterHistory;
+    basepath: string;
+    routeTree: TRouteTree;
+    routesById: RoutesById<TRouteTree>;
+    routesByPath: RoutesByPath<TRouteTree>;
+    flatRoutes: ParseRoute<TRouteTree>[];
+    navigateTimeout: undefined | Timeout;
+    nextAction: undefined | 'push' | 'replace';
+    navigationPromise: undefined | Promise<void>;
+    __store: Store<RouterState<TRouteTree>>;
+    state: RouterState<TRouteTree>;
+    dehydratedData?: TDehydrated;
+    resetNextScroll: boolean;
+    constructor(options: RouterConstructorOptions<TRouteTree, TDehydrated>);
+    subscribers: Set<RouterListener<RouterEvent>>;
+    subscribe: <TType extends keyof RouterEvents>(eventType: TType, fn: ListenerFn<RouterEvents[TType]>) => () => void;
+    reset: () => void;
+    mount: () => () => void;
+    update: (opts?: RouterOptions<any, any>) => this;
+    buildNext: (opts: BuildNextOptions) => ParsedLocation;
+    cancelMatches: () => void;
+    cancelMatch: (id: string) => void;
+    safeLoad: (opts?: {
+        next?: ParsedLocation;
+    }) => Promise<void>;
+    latestLoadPromise: Promise<void>;
+    load: (opts?: {
+        next?: ParsedLocation;
+        throwOnError?: boolean;
+        __dehydratedMatches?: DehydratedRouteMatch[];
+    }) => Promise<void>;
+    getRoute: (id: string) => Route;
+    preloadRoute: (navigateOpts?: BuildNextOptions & {
+        maxAge?: number;
+    }) => Promise<RouteMatch<TRouteTree, ParseRoute<TRouteTree>["id"]>[]>;
+    cleanMatches: () => void;
+    matchRoutes: (pathname: string, locationSearch: AnySearchSchema, opts?: {
+        throwOnError?: boolean;
+        debug?: boolean;
+    }) => RouteMatch<TRouteTree>[];
+    loadMatches: (resolvedMatches: AnyRouteMatch[], opts?: {
+        preload?: boolean;
+        maxAge?: number;
+    }) => Promise<void>;
+    reload: () => Promise<void>;
+    resolvePath: (from: string, path: string) => string;
+    navigate: <TFrom extends RoutePaths<TRouteTree> = "/", TTo extends string = "">({ from, to, search, hash, replace, params, resetScroll, }: NavigateOptions<TRouteTree, TFrom, TTo>) => Promise<void>;
+    matchRoute: <TFrom extends RoutePaths<TRouteTree> = "/", TTo extends string = "", TResolved extends string = ResolveRelativePath<TFrom, NoInfer<TTo>>>(location: ToOptions<TRouteTree, TFrom, TTo, ResolveRelativePath<TFrom, NoInfer<TTo>>>, opts?: MatchRouteOptions) => false | RouteById<TRouteTree, TResolved>["types"]["allParams"];
+    buildLink: <TFrom extends RoutePaths<TRouteTree> = "/", TTo extends string = "">({ from, to, search, params, hash, target, replace, activeOptions, preload, preloadDelay: userPreloadDelay, disabled, state, resetScroll, }: LinkOptions<TRouteTree, TFrom, TTo>) => LinkInfo;
+    dehydrate: () => DehydratedRouter;
+    hydrate: (__do_not_use_server_ctx?: HydrationCtx) => Promise<void>;
+    injectedHtml: (string | (() => Promise<string> | string))[];
+    injectHtml: (html: string | (() => Promise<string> | string)) => Promise<void>;
+    dehydrateData: <T>(key: any, getData: T | (() => T | Promise<T>)) => () => T | undefined;
+    hydrateData: <T = unknown>(key: any) => T | undefined;
+    getRouteMatch: (id: string) => undefined | RouteMatch<TRouteTree>;
+    setRouteMatch: (id: string, updater: (prev: RouteMatch<TRouteTree>) => RouteMatch<TRouteTree>) => void;
+    setRouteMatchData: (id: string, updater: (prev: any) => any, opts?: {
+        updatedAt?: number;
+        maxAge?: number;
+    }) => void;
+    invalidate: (opts?: {
+        matchId?: string;
+        reload?: boolean;
+    }) => Promise<void>;
+}
+export type AnyRedirect = Redirect<any, any, any>;
+export type Redirect<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = ''> = NavigateOptions<TRouteTree, TFrom, TTo> & {
+    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;
+export declare class SearchParamError extends Error {
+}
+export declare class PathParamError extends Error {
+}
+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 function isMatchInvalid(match: AnyRouteMatch, opts?: {
+    preload?: boolean;
+}): boolean;

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

@@ -0,0 +1,6 @@
+import { AnyRouter, ParsedLocation } from './router';
+export type ScrollRestorationOptions = {
+    getKey?: (location: ParsedLocation) => string;
+};
+export declare function watchScrollPositions(router: AnyRouter, opts?: ScrollRestorationOptions): () => void;
+export declare function restoreScrollPositions(router: AnyRouter, opts?: ScrollRestorationOptions): void;

package/build/types/searchParams.d.ts

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