@tanstack/router-core 0.0.1-beta.2 → 0.0.1-beta.200

package/build/types/link.d.ts

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

package/build/types/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,261 @@
+import { RoutePaths } from './routeInfo';
+import { AnyRouter, AnyRouteMatch } from './router';
+import { DeepMerge, DeepMergeAll, Expand, IsAny, NoInfer, PickRequired, UnionToIntersection } from './utils';
+import { ParsePathParams, ToSubOptions } from './link';
+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 Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> {
+}
+export interface RegisterErrorRouteComponent<TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> {
+}
+export interface RegisterPendingRouteComponent<TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> {
+}
+export interface RegisterRouteProps<TLoader = unknown, TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> {
+}
+export interface RegisterErrorRouteProps<TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> {
+}
+export interface RegisterPendingRouteProps<TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> {
+}
+export type RegisteredRouteComponent<TLoader = unknown, TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> = RegisterRouteComponent<TLoader, TFullSearchSchema, TAllParams, TAllContext> extends {
+    RouteComponent: infer T;
+} ? T : () => unknown;
+export type RegisteredErrorRouteComponent<TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> = RegisterErrorRouteComponent<TFullSearchSchema, TAllParams, TAllContext> extends {
+    ErrorRouteComponent: infer T;
+} ? T : () => unknown;
+export type RegisteredPendingRouteComponent<TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> = RegisterPendingRouteComponent<TFullSearchSchema, TAllParams, TAllContext> extends {
+    PendingRouteComponent: infer T;
+} ? T : () => unknown;
+export type RegisteredRouteProps<TLoader = unknown, TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> = RegisterRouteProps<TLoader, TFullSearchSchema, TAllParams, TAllContext> extends {
+    RouteProps: infer T;
+} ? T : {};
+export type RegisteredErrorRouteProps<TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> = RegisterRouteProps<TFullSearchSchema, TAllParams, TAllContext> extends {
+    ErrorRouteProps: infer T;
+} ? T : {};
+export type RegisteredPendingRouteProps<TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> = RegisterRouteProps<TFullSearchSchema, TAllParams, 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>;
+export type RouteOptions<TParentRoute extends AnyRoute = AnyRoute, TCustomId extends string = string, TPath extends string = string, TLoaderContext extends Record<string, any> = AnyContext, TLoader = unknown, 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> = BaseRouteOptions<TParentRoute, TCustomId, TPath, TLoaderContext, TLoader, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TRouteContext, TAllContext> & UpdatableRouteOptions<TLoader, TFullSearchSchema, TAllParams, 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, TLoaderContext extends Record<string, any> = AnyContext, TLoader = unknown, 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> = RoutePathOptions<TCustomId, TPath> & {
+    getParentRoute: () => TParentRoute;
+    validateSearch?: SearchSchemaValidator<TSearchSchema>;
+    loaderContext?: (opts: {
+        search: TFullSearchSchema;
+    }) => TLoaderContext;
+} & (keyof PickRequired<RouteContext> extends never ? {
+    beforeLoad?: BeforeLoadFn<TParentRoute, TAllParams, NoInfer<TLoaderContext>, TRouteContext>;
+} : {
+    beforeLoad: BeforeLoadFn<TParentRoute, TAllParams, NoInfer<TLoaderContext>, TRouteContext>;
+}) & {
+    loader?: LoaderFn<TLoader, TAllParams, NoInfer<TLoaderContext>, NoInfer<TAllContext>, NoInfer<TRouteContext>>;
+} & ([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;
+});
+type BeforeLoadFn<TParentRoute extends AnyRoute, TAllParams, TLoaderContext, TRouteContext> = (opts: {
+    abortController: AbortController;
+    preload: boolean;
+    params: TAllParams;
+    context: Expand<TParentRoute['types']['context'] & TLoaderContext>;
+}) => Promise<TRouteContext> | TRouteContext | void;
+export type UpdatableRouteOptions<TLoader, TFullSearchSchema extends Record<string, any>, TAllParams extends AnyPathParams, TAllContext extends Record<string, any>> = MetaOptions & {
+    caseSensitive?: boolean;
+    wrapInSuspense?: boolean;
+    component?: RegisteredRouteComponent<TLoader, TFullSearchSchema, TAllParams, TAllContext>;
+    errorComponent?: RegisteredErrorRouteComponent<TFullSearchSchema, TAllParams, TAllContext>;
+    pendingComponent?: RegisteredPendingRouteComponent<TFullSearchSchema, TAllParams, TAllContext>;
+    preSearchFilters?: SearchFilter<TFullSearchSchema>[];
+    postSearchFilters?: SearchFilter<TFullSearchSchema>[];
+    preloadMaxAge?: number;
+    maxAge?: number;
+    gcMaxAge?: number;
+    onError?: (err: any) => void;
+    onEnter?: (match: AnyRouteMatch) => void;
+    onTransition?: (match: AnyRouteMatch) => void;
+    onLeave?: (match: AnyRouteMatch) => void;
+    reloadOnWindowFocus?: boolean;
+};
+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, TAllParams = {}, TLoaderContext extends Record<string, any> = AnyContext, TAllContext extends Record<string, any> = AnyContext, TRouteContext extends Record<string, any> = AnyContext> = (match: LoaderContext<TAllParams, TLoaderContext, TAllContext, TRouteContext> & {
+    parentMatchPromise?: Promise<void>;
+}) => Promise<TLoader> | TLoader;
+export interface LoaderContext<TAllParams = {}, TLoaderContext = {}, TAllContext extends Record<string, any> = AnyContext, TRouteContext extends Record<string, any> = AnyContext> {
+    abortController: AbortController;
+    preload: boolean;
+    params: TAllParams;
+    context: Expand<DeepMergeAll<[TAllContext, TLoaderContext, TRouteContext]>>;
+}
+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<DeepMerge<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 UseLoaderResult<T> = T;
+export type StreamedPromise<T> = {
+    promise: Promise<T>;
+    status: 'resolved' | 'pending';
+    data: T;
+    resolve: (value: T) => void;
+};
+export type ResolveAllParams<TParentRoute extends AnyRoute, TParams extends AnyPathParams> = Record<never, string> extends TParentRoute['types']['allParams'] ? TParams : Expand<UnionToIntersection<TParentRoute['types']['allParams'] & TParams> & {}>;
+export type RouteConstraints = {
+    TParentRoute: AnyRoute;
+    TPath: string;
+    TFullPath: string;
+    TCustomId: string;
+    TId: string;
+    TLoaderContext: Record<string, any>;
+    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 Route<TParentRoute extends RouteConstraints['TParentRoute'] = AnyRoute, TPath extends RouteConstraints['TPath'] = '/', TFullPath extends RouteConstraints['TFullPath'] = ResolveFullPath<TParentRoute, TPath>, TCustomId extends RouteConstraints['TCustomId'] = string, TId extends RouteConstraints['TId'] = ResolveId<TParentRoute, TCustomId, TPath>, TLoaderContext extends RouteConstraints['TLoaderContext'] = {}, TLoader = unknown, TSearchSchema extends RouteConstraints['TSearchSchema'] = {}, TFullSearchSchema extends RouteConstraints['TFullSearchSchema'] = ResolveFullSearchSchema<TParentRoute, TSearchSchema>, TParams extends RouteConstraints['TParams'] = Expand<Record<ParsePathParams<TPath>, string>>, TAllParams extends RouteConstraints['TAllParams'] = ResolveAllParams<TParentRoute, TParams>, TRouteContext extends RouteConstraints['TRouteContext'] = RouteContext, TAllContext extends RouteConstraints['TAllContext'] = Expand<DeepMergeAll<[
+    IsAny<TParentRoute['types']['context'], {}>,
+    TLoaderContext,
+    TRouteContext
+]>>, TRouterContext extends RouteConstraints['TRouterContext'] = AnyContext, TChildren extends RouteConstraints['TChildren'] = unknown, TRouteTree extends RouteConstraints['TRouteTree'] = AnyRoute> {
+    types: {
+        parentRoute: TParentRoute;
+        path: TPath;
+        to: TrimPathRight<TFullPath>;
+        fullPath: TFullPath;
+        customId: TCustomId;
+        id: TId;
+        loader: TLoader;
+        searchSchema: TSearchSchema;
+        fullSearchSchema: TFullSearchSchema;
+        params: TParams;
+        allParams: TAllParams;
+        routeContext: TRouteContext;
+        context: TAllContext;
+        children: TChildren;
+        routeTree: TRouteTree;
+        routerContext: TRouterContext;
+    };
+    isRoot: TParentRoute extends Route<any> ? true : false;
+    options: RouteOptions<TParentRoute, TCustomId, TPath, TLoaderContext, TLoader, TSearchSchema, TFullSearchSchema, TParams, 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, TLoaderContext, TLoader, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TRouteContext, TAllContext> & UpdatableRouteOptions<TLoader, TFullSearchSchema, TAllParams, TAllContext>);
+    init: (opts: {
+        originalIndex: number;
+        router: AnyRouter;
+    }) => void;
+    addChildren: <TNewChildren extends AnyRoute[]>(children: TNewChildren) => Route<TParentRoute, TPath, TFullPath, TCustomId, TId, TLoaderContext, TLoader, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TRouteContext, TAllContext, TRouterContext, TNewChildren, TRouteTree>;
+    update: (options: UpdatableRouteOptions<TLoader, TFullSearchSchema, TAllParams, TAllContext>) => this;
+    static __onInit: (route: any) => void;
+}
+export type AnyRootRoute = RootRoute<any, any, any, any>;
+export declare class RouterContext<TRouterContext extends {}> {
+    constructor();
+    createRootRoute: <TLoaderContext extends Record<string, any> = AnyContext, TLoader = unknown, TSearchSchema extends Record<string, any> = {}, TRouteContext extends RouteContext = RouteContext>(options?: Omit<RouteOptions<AnyRoute, "__root__", "", TLoaderContext, TLoader, TSearchSchema, TSearchSchema, {}, {}, TRouteContext, DeepMerge<TRouterContext, DeepMerge<TLoaderContext, DeepMerge<TRouteContext, {}>>>>, "id" | "path" | "getParentRoute" | "stringifyParams" | "parseParams" | "caseSensitive"> | undefined) => RootRoute<TLoaderContext, TLoader, TSearchSchema, TRouteContext, TRouterContext>;
+}
+export declare class RootRoute<TLoaderContext extends Record<string, any> = AnyContext, TLoader = unknown, TSearchSchema extends Record<string, any> = {}, TRouteContext extends RouteContext = RouteContext, TRouterContext extends {} = {}> extends Route<any, // TParentRoute
+'/', // TPath
+'/', // TFullPath
+string, // TCustomId
+RootRouteId, // TId
+TLoaderContext, // TLoaderContext
+TLoader, // TLoader
+TSearchSchema, // TSearchSchema
+TSearchSchema, // TFullSearchSchema
+{}, // TParams
+{}, // TAllParams
+TRouteContext, // TRouteContext
+DeepMergeAll<[TRouterContext, TLoaderContext, TRouteContext]>, // TAllContext
+TRouterContext, // TRouterContext
+any, // TChildren
+any> {
+    constructor(options?: Omit<RouteOptions<AnyRoute, // TParentRoute
+    RootRouteId, // TCustomId
+    '', // TPath
+    TLoaderContext, // TLoaderContext
+    TLoader, // TLoader
+    TSearchSchema, // TSearchSchema
+    TSearchSchema, // TFullSearchSchema
+    {}, // TParams
+    {}, // TAllParams
+    TRouteContext, // TRouteContext
+    DeepMergeAll<[TRouterContext, TLoaderContext, 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 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 {};

package/build/types/routeInfo.d.ts

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