@tanstack/router-core 0.0.1-beta.185 → 0.0.1-beta.187

package/build/types/history.d.ts

@@ -1,5 +1,5 @@
 export interface RouterHistory {
-    location: RouterLocation;
+    location: HistoryLocation;
     subscribe: (cb: () => void) => () => void;
     push: (path: string, state?: any) => void;
     replace: (path: string, state?: any) => void;
@@ -9,14 +9,19 @@ export interface RouterHistory {
     createHref: (href: string) => string;
     block: (blockerFn: BlockerFn) => () => void;
 }
+export interface HistoryLocation extends ParsedPath {
+    state: LocationState;
+}
 export interface ParsedPath {
     href: string;
     pathname: string;
     search: string;
     hash: string;
 }
-export interface RouterLocation extends ParsedPath {
-    state: Record<string, any>;
+export interface LocationState {
+    key: string;
+    __tempLocation?: HistoryLocation;
+    __tempKey?: string;
 }
 type BlockerFn = (retry: () => void, cancel: () => void) => void;
 export declare function createBrowserHistory(opts?: {

package/build/types/link.d.ts

@@ -1,8 +1,9 @@
 import { Trim } from './fileRoute';
+import { LocationState } from './history';
 import { AnyRoute } from './route';
-import { AllParams, FullSearchSchema, RouteByPath, RouteIds, RoutePaths } from './routeInfo';
-import { ParsedLocation, LocationState } from './router';
-import { NoInfer, PickRequired, UnionToIntersection, Updater } from './utils';
+import { AllParams, RouteByPath, RouteIds, RoutePaths } from './routeInfo';
+import { ParsedLocation } from './router';
+import { Expand, NoInfer, NonNullableUpdater, PickRequired, UnionToIntersection, Updater } from './utils';
 export type LinkInfo = {
     type: 'external';
     href: string;
@@ -37,28 +38,32 @@ export type RelativeToPathAutoComplete<AllPaths extends string, TFrom extends st
 ] ? `${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> & {
+export type NavigateOptions<TRouteTree extends AnyRoute = AnyRoute, 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 = AnyRoute, TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TResolvedTo = ResolveRelativePath<TFrom, NoInfer<TTo>>> = {
+export type ToOptions<TRouteTree extends AnyRoute = AnyRoute, 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 = AnyRoute, TMaskFrom extends RoutePaths<TRouteTree> = '/', TMaskTo extends string = ''> = ToSubOptions<TRouteTree, TMaskFrom, TMaskTo> & {
+    unmaskOnReload?: boolean;
+};
+export type ToSubOptions<TRouteTree extends AnyRoute = AnyRoute, TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TResolved = ResolveRelativePath<TFrom, NoInfer<TTo>>> = {
     to?: ToPathOption<TRouteTree, TFrom, TTo>;
-    hash?: Updater<string>;
-    state?: LocationState;
+    hash?: true | Updater<string>;
+    state?: true | NonNullableUpdater<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>;
+} & CheckPath<TRouteTree, NoInfer<TResolved>, {}> & SearchParamOptions<TRouteTree, TFrom, TResolved> & PathParamOptions<TRouteTree, TFrom, TResolved>;
+export type SearchParamOptions<TRouteTree extends AnyRoute, TFrom, TTo, TFromSearchEnsured = Expand<UnionToIntersection<PickRequired<RouteByPath<TRouteTree, TFrom>['types']['fullSearchSchema']>>>, TFromSearchOptional = Omit<AllParams<TRouteTree>, keyof TFromSearchEnsured>, TFromSearch = Expand<TFromSearchEnsured & TFromSearchOptional>, TToSearch = Expand<RouteByPath<TRouteTree, TTo>['types']['fullSearchSchema']>> = keyof PickRequired<TToSearch> extends never ? {
+    search?: true | SearchReducer<TFromSearch, TToSearch>;
 } : {
-    search: SearchReducer<TFromFullSchema, TToFullSchema>;
+    search: TFromSearchEnsured extends PickRequired<TToSearch> ? true | SearchReducer<TFromSearch, TToSearch> : SearchReducer<TFromSearch, TToSearch>;
 };
-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>;
+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: ParamsReducer<TFromFullParams, TToFullParams>;
+    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>;
@@ -68,7 +73,7 @@ export interface ActiveOptions {
     includeHash?: boolean;
     includeSearch?: boolean;
 }
-export type LinkOptions<TRouteTree extends AnyRoute = AnyRoute, TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = ''> = NavigateOptions<TRouteTree, TFrom, TTo> & {
+export type LinkOptions<TRouteTree extends AnyRoute = AnyRoute, 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';

package/build/types/route.d.ts

@@ -1,6 +1,7 @@
-import { ParsePathParams } from './link';
+import { RoutePaths } from './routeInfo';
 import { AnyRouter, RouteMatch, AnyRouteMatch } from './router';
-import { IsAny, NoInfer, PickRequired, UnionToIntersection } from './utils';
+import { 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 = {};
@@ -103,6 +104,7 @@ export type UpdatableRouteOptions<TLoader, TSearchSchema extends AnySearchSchema
     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';
@@ -152,7 +154,7 @@ export type InferFullSearchSchema<TRoute> = TRoute extends {
 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 MergeFromFromParent<T, U> = IsAny<T, U, T & U>;
 export type UseLoaderResult<T> = T;
 export type StreamedPromise<T> = {
     promise: Promise<T>;
@@ -160,6 +162,7 @@ export type StreamedPromise<T> = {
     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;
@@ -178,7 +181,7 @@ export type RouteConstraints = {
     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> {
+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'] = Expand<Record<ParsePathParams<TPath>, string>>, TAllParams extends RouteConstraints['TAllParams'] = ResolveAllParams<TParentRoute, TParams>, TParentContext extends RouteConstraints['TParentContext'] = TParentRoute['types']['routeContext'], TAllParentContext extends RouteConstraints['TAllParentContext'] = TParentRoute['types']['context'], TRouteContext extends RouteConstraints['TRouteContext'] = RouteContext, TAllContext extends RouteConstraints['TAllContext'] = MergeFromFromParent<TParentRoute['types']['context'], TRouteContext>, TRouterContext extends RouteConstraints['TRouterContext'] = AnyContext, TChildren extends RouteConstraints['TChildren'] = unknown, TRouteTree extends RouteConstraints['TRouteTree'] = AnyRoute> {
     types: {
         parentRoute: TParentRoute;
         path: TPath;
@@ -222,14 +225,27 @@ export declare class Route<TParentRoute extends RouteConstraints['TParentRoute']
 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>;
+    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>>, "id" | "path" | "getParentRoute" | "stringifyParams" | "parseParams" | "caseSensitive"> | 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 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, MergeFromFromParent<TRouterContext, TRouteContext>, TRouterContext, any, any> {
+    constructor(options?: Omit<RouteOptions<AnyRoute, RootRouteId, '', TLoader, TSearchSchema, TSearchSchema, TSearchSchema, {}, {}, TRouterContext, TRouterContext, TRouteContext, MergeFromFromParent<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 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

@@ -1,5 +1,5 @@
 import { AnyRoute, Route } from './route';
-import { MergeUnion } from './utils';
+import { 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, any, infer TChildren, any> ? unknown extends TChildren ? never : TChildren extends AnyRoute[] ? {
     [TId in TChildren[number]['id'] as string]: ParseRoute<TChildren[number]>;
@@ -18,5 +18,5 @@ export type RouteByPath<TRouteTree extends AnyRoute, TPath> = Extract<ParseRoute
     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']>;
+export type FullSearchSchema<TRouteTree extends AnyRoute> = UnionToIntersection<ParseRoute<TRouteTree>['types']['fullSearchSchema']> & {};
+export type AllParams<TRouteTree extends AnyRoute> = UnionToIntersection<ParseRoute<TRouteTree>['types']['allParams']>;

package/build/types/router.d.ts

@@ -1,10 +1,10 @@
 /// <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 { Route, AnySearchSchema, AnyRoute, AnyContext, AnyPathParams, RegisteredRouteComponent, RegisteredErrorRouteComponent, RegisteredPendingRouteComponent, RouteMask } from './route';
 import { RoutesById, RoutesByPath, ParseRoute, FullSearchSchema, RouteById, RoutePaths, RouteIds } from './routeInfo';
-import { NoInfer, PickAsRequired, Timeout, Updater } from './utils';
-import { RouterHistory } from './history';
+import { NoInfer, PickAsRequired, Timeout, Updater, NonNullableUpdater } from './utils';
+import { LocationState, RouterHistory } from './history';
 declare global {
     interface Window {
         __TSR_DEHYDRATED__?: HydrationCtx;
@@ -16,8 +16,6 @@ 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;
@@ -25,12 +23,12 @@ export interface ParsedLocation<TSearchObj extends AnySearchSchema = {}> {
     searchStr: string;
     state: LocationState;
     hash: string;
-    key?: string;
+    maskedLocation?: ParsedLocation<TSearchObj>;
+    unmaskOnReload?: boolean;
 }
 export interface FromLocation {
     pathname: string;
     search?: unknown;
-    key?: string;
     hash?: string;
 }
 export type SearchSerializer = (searchObj: Record<string, any>) => string;
@@ -76,7 +74,7 @@ export interface RouterOptions<TRouteTree extends AnyRoute, TDehydrated extends
     parseSearch?: SearchParser;
     defaultPreload?: false | 'intent';
     defaultPreloadDelay?: number;
-    refetchOnWindowFocus?: boolean;
+    reloadOnWindowFocus?: boolean;
     defaultComponent?: RegisteredRouteComponent<unknown, AnySearchSchema, AnyPathParams, AnyContext, AnyContext>;
     defaultErrorComponent?: RegisteredErrorRouteComponent<AnySearchSchema, AnyPathParams, AnyContext, AnyContext>;
     defaultPendingComponent?: RegisteredPendingRouteComponent<AnySearchSchema, AnyPathParams, AnyContext, AnyContext>;
@@ -97,6 +95,8 @@ export interface RouterOptions<TRouteTree extends AnyRoute, TDehydrated extends
     }>;
     dehydrate?: () => TDehydrated;
     hydrate?: (dehydrated: TDehydrated) => void;
+    routeMasks?: RouteMask<TRouteTree>[];
+    unmaskOnReload?: boolean;
 }
 export interface RouterState<TRouteTree extends AnyRoute = AnyRoute> {
     status: 'idle' | 'pending';
@@ -118,18 +118,26 @@ export interface BuildNextOptions {
     params?: true | Updater<unknown>;
     search?: true | Updater<unknown>;
     hash?: true | Updater<string>;
-    state?: LocationState;
-    key?: string;
+    state?: true | NonNullableUpdater<LocationState>;
+    mask?: {
+        to?: string | number | null;
+        params?: true | Updater<unknown>;
+        search?: true | Updater<unknown>;
+        hash?: true | Updater<string>;
+        state?: true | NonNullableUpdater<LocationState>;
+        unmaskOnReload?: boolean;
+    };
     from?: string;
-    fromCurrent?: boolean;
-    __matches?: AnyRouteMatch[];
+}
+export interface CommitLocationOptions {
+    replace?: boolean;
+    resetScroll?: boolean;
 }
 export interface MatchLocation {
     to?: string | number | null;
     fuzzy?: boolean;
     caseSensitive?: boolean;
     from?: string;
-    fromCurrent?: boolean;
 }
 export interface MatchRouteOptions {
     pending?: boolean;
@@ -185,13 +193,13 @@ export declare class Router<TRouteTree extends AnyRoute = AnyRoute, TDehydrated
     state: RouterState<TRouteTree>;
     dehydratedData?: TDehydrated;
     resetNextScroll: boolean;
+    tempLocationKey: string;
     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?: {
@@ -206,26 +214,27 @@ export declare class Router<TRouteTree extends AnyRoute = AnyRoute, TDehydrated
     getRoute: (id: string) => Route;
     preloadRoute: (navigateOpts?: BuildNextOptions & {
         maxAge?: number;
-    }) => Promise<RouteMatch<TRouteTree, ParseRoute<TRouteTree>["id"]>[]>;
+    }) => Promise<readonly [RouteMatch<TRouteTree, ParseRoute<TRouteTree>["id"]>, RouteMatch<TRouteTree, ParseRoute<TRouteTree>["id"]>[]]>;
     cleanMatches: () => void;
     matchRoutes: (pathname: string, locationSearch: AnySearchSchema, opts?: {
         throwOnError?: boolean;
         debug?: boolean;
     }) => RouteMatch<TRouteTree>[];
-    loadMatches: (_resolvedMatches: AnyRouteMatch[], opts?: {
+    loadMatches: (matchIds: string[], opts?: {
         preload?: boolean;
         maxAge?: number;
     }) => 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;
+    navigate: <TFrom extends RoutePaths<TRouteTree> = "/", TTo extends string = "", TMaskFrom extends RoutePaths<TRouteTree> = TFrom, TMaskTo extends string = "">({ from, to, search, hash, replace, params, resetScroll, }: NavigateOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo>) => Promise<void>;
+    matchRoute: <TRouteTree_1 extends AnyRoute = AnyRoute, TFrom extends RoutePaths<TRouteTree_1> = "/", TTo extends string = "", TResolved = ResolveRelativePath<TFrom, NoInfer<TTo>>>(location: ToOptions<TRouteTree_1, TFrom, TTo, "/", "">, opts?: MatchRouteOptions) => false | RouteById<TRouteTree_1, TResolved>["types"]["allParams"];
+    buildLink: <TFrom extends RoutePaths<TRouteTree> = "/", TTo extends string = "">({ from, to, search, params, hash, target, replace, activeOptions, preload, preloadDelay: userPreloadDelay, disabled, state, mask, resetScroll, }: LinkOptions<TRouteTree, TFrom, TTo, TFrom, "">) => 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;
+    buildLocation: (opts?: BuildNextOptions) => ParsedLocation;
     getRouteMatch: (id: string) => undefined | RouteMatch<TRouteTree>;
     setRouteMatch: (id: string, updater: (prev: RouteMatch<TRouteTree>) => RouteMatch<TRouteTree>) => void;
     setRouteMatchData: (id: string, updater: (prev: any) => any, opts?: {
@@ -235,10 +244,11 @@ export declare class Router<TRouteTree extends AnyRoute = AnyRoute, TDehydrated
     invalidate: (opts?: {
         matchId?: string;
         reload?: boolean;
+        __fromFocus?: 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> & {
+export type Redirect<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = TFrom, TMaskTo extends string = ''> = NavigateOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> & {
     code?: number;
 };
 export declare function redirect<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = ''>(opts: Redirect<TRouteTree, TFrom, TTo>): Redirect<TRouteTree, TFrom, TTo>;

package/build/types/utils.d.ts

@@ -15,15 +15,6 @@ export type Expand<T> = T extends object ? T extends infer O ? {
     [K in keyof O]: O[K];
 } : never : T;
 export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => any ? I : never;
-type Compute<T> = {
-    [K in keyof T]: T[K];
-} | never;
-type AllKeys<T> = T extends any ? keyof T : never;
-export type MergeUnion<T, Keys extends keyof T = keyof T> = Compute<{
-    [K in Keys]: T[Keys];
-} & {
-    [K in AllKeys<T>]?: T extends any ? K extends keyof T ? T[K] : never : never;
-}>;
 export type Values<O> = O[ValueKeys<O>];
 export type ValueKeys<O> = Extract<keyof O, PropertyKey>;
 export type DeepAwaited<T> = T extends Promise<infer A> ? DeepAwaited<A> : T extends Record<infer A, Promise<infer B>> ? {
@@ -32,6 +23,7 @@ export type DeepAwaited<T> = T extends Promise<infer A> ? DeepAwaited<A> : T ext
 export type PathParamMask<TRoutePath extends string> = TRoutePath extends `${infer L}/$${infer C}/${infer R}` ? PathParamMask<`${L}/${string}/${R}`> : TRoutePath extends `${infer L}/$${infer C}` ? PathParamMask<`${L}/${string}`> : TRoutePath;
 export type Timeout = ReturnType<typeof setTimeout>;
 export type Updater<TPrevious, TResult = TPrevious> = TResult | ((prev?: TPrevious) => TResult);
+export type NonNullableUpdater<TPrevious, TResult = TPrevious> = TResult | ((prev: TPrevious) => TResult);
 export type PickExtract<T, U> = {
     [K in keyof T as T[K] extends U ? K : never]: T[K];
 };
@@ -39,7 +31,7 @@ export type PickExclude<T, U> = {
     [K in keyof T as T[K] extends U ? never : K]: T[K];
 };
 export declare function last<T>(arr: T[]): T | undefined;
-export declare function functionalUpdate<TResult>(updater: Updater<TResult>, previous: TResult): TResult;
+export declare function functionalUpdate<TResult>(updater: Updater<TResult> | NonNullableUpdater<TResult>, previous: TResult): TResult;
 export declare function pick<T, K extends keyof T>(parent: T, keys: K[]): Pick<T, K>;
 /**
  * This function returns `a` if `b` is deeply equal.
@@ -50,4 +42,3 @@ export declare function pick<T, K extends keyof T>(parent: T, keys: K[]): Pick<T
 export declare function replaceEqualDeep<T>(prev: any, _next: T): T;
 export declare function isPlainObject(o: any): boolean;
 export declare function partialDeepEqual(a: any, b: any): boolean;
-export {};