@tanstack/router-core 0.0.1-beta.30 → 0.0.1-beta.33

package/build/types/index.d.ts

@@ -16,63 +16,6 @@ interface FrameworkGenerics {
 }
 type GetFrameworkGeneric<U> = U extends keyof FrameworkGenerics ? FrameworkGenerics[U] : any;
 
-interface RouteMatch<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TRouteInfo extends AnyRouteInfo = RouteInfo> extends Route<TAllRouteInfo, TRouteInfo> {
-    matchId: string;
-    pathname: string;
-    params: TRouteInfo['allParams'];
-    parentMatch?: RouteMatch;
-    childMatches: RouteMatch[];
-    routeSearch: TRouteInfo['searchSchema'];
-    search: TRouteInfo['fullSearchSchema'];
-    status: 'idle' | 'loading' | 'success' | 'error';
-    updatedAt?: number;
-    error?: unknown;
-    isInvalid: boolean;
-    getIsInvalid: () => boolean;
-    loaderData: TRouteInfo['loaderData'];
-    routeLoaderData: TRouteInfo['routeLoaderData'];
-    isFetching: boolean;
-    invalidAt: number;
-    __: {
-        component?: GetFrameworkGeneric<'Component'>;
-        errorComponent?: GetFrameworkGeneric<'ErrorComponent'>;
-        pendingComponent?: GetFrameworkGeneric<'Component'>;
-        loadPromise?: Promise<void>;
-        componentsPromise?: Promise<void>;
-        dataPromise?: Promise<TRouteInfo['routeLoaderData']>;
-        onExit?: void | ((matchContext: {
-            params: TRouteInfo['allParams'];
-            search: TRouteInfo['fullSearchSchema'];
-        }) => void);
-        abortController: AbortController;
-        latestId: string;
-        validate: () => void;
-        notify: () => void;
-        resolve: () => void;
-    };
-    cancel: () => void;
-    load: (loaderOpts?: {
-        preload: true;
-        maxAge: number;
-        gcMaxAge: number;
-    } | {
-        preload?: false;
-        maxAge?: never;
-        gcMaxAge?: never;
-    }) => Promise<TRouteInfo['routeLoaderData']>;
-    fetch: (opts?: {
-        maxAge?: number;
-    }) => Promise<TRouteInfo['routeLoaderData']>;
-    invalidate: () => void;
-    hasLoaders: () => boolean;
-}
-declare function createRouteMatch<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TRouteInfo extends AnyRouteInfo = RouteInfo>(router: Router<any, any, any>, route: Route<TAllRouteInfo, TRouteInfo>, opts: {
-    parentMatch?: RouteMatch<any, any>;
-    matchId: string;
-    params: TRouteInfo['allParams'];
-    pathname: string;
-}): RouteMatch<TAllRouteInfo, TRouteInfo>;
-
 type NoInfer<T> = [T][T extends any ? 0 : never];
 type IsAny<T, Y, N> = 1 extends 0 & T ? Y : N;
 type IsAnyBoolean<T> = 1 extends 0 & T ? true : false;
@@ -228,7 +171,7 @@ type Listener = (router: Router<any, any, any>) => void;
 type ListenerFn = () => void;
 interface BuildNextOptions {
     to?: string | number | null;
-    params?: true | Updater<Record<string, any>>;
+    params?: true | Updater<unknown>;
     search?: true | Updater<unknown>;
     hash?: true | Updater<string>;
     state?: LocationState;
@@ -250,14 +193,15 @@ interface MatchLocation {
     fromCurrent?: boolean;
 }
 interface MatchRouteOptions {
-    pending: boolean;
+    pending?: boolean;
     caseSensitive?: boolean;
+    fuzzy?: boolean;
 }
 interface DehydratedRouterState extends Pick<RouterState, 'status' | 'location' | 'lastUpdated' | 'location'> {
     matches: DehydratedRouteMatch[];
 }
 interface DehydratedRouter<TRouterContext = unknown> {
-    location: Router['location'];
+    location: Router['__location'];
     state: DehydratedRouterState;
     context: TRouterContext;
 }
@@ -274,7 +218,7 @@ interface Router<TRouteConfig extends AnyRouteConfig = RouteConfig, TAllRouteInf
     options: PickAsRequired<RouterOptions<TRouteConfig, TRouterContext>, 'stringifySearch' | 'parseSearch' | 'context'>;
     basepath: string;
     listeners: Listener[];
-    location: Location<TAllRouteInfo['fullSearchSchema']>;
+    __location: Location<TAllRouteInfo['fullSearchSchema']>;
     navigateTimeout?: Timeout;
     nextAction?: 'push' | 'replace';
     state: RouterState<TAllRouteInfo['fullSearchSchema']>;
@@ -333,96 +277,62 @@ interface Router<TRouteConfig extends AnyRouteConfig = RouteConfig, TAllRouteInf
 }
 declare function createRouter<TRouteConfig extends AnyRouteConfig = RouteConfig, TAllRouteInfo extends AnyAllRouteInfo = AllRouteInfo<TRouteConfig>, TRouterContext = unknown>(userOptions?: RouterOptions<TRouteConfig, TRouterContext>): Router<TRouteConfig, TAllRouteInfo, TRouterContext>;
 
-interface AnyRoute extends Route<any, any, any> {
-}
-interface Route<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TRouteInfo extends AnyRouteInfo = RouteInfo, TRouterContext = unknown> {
-    routeInfo: TRouteInfo;
-    routeId: TRouteInfo['id'];
-    routeRouteId: TRouteInfo['routeId'];
-    routePath: TRouteInfo['path'];
-    fullPath: TRouteInfo['fullPath'];
-    parentRoute?: AnyRoute;
-    childRoutes?: AnyRoute[];
-    options: RouteOptions;
-    router: Router<TAllRouteInfo['routeConfig'], TAllRouteInfo, TRouterContext>;
-    buildLink: <TTo extends string = '.'>(options: Omit<LinkOptions<TAllRouteInfo, TRouteInfo['fullPath'], TTo>, 'from'>) => LinkInfo;
-    matchRoute: <TTo extends string = '.', TResolved extends string = ResolveRelativePath<TRouteInfo['id'], TTo>>(matchLocation: CheckRelativePath<TAllRouteInfo, TRouteInfo['fullPath'], NoInfer<TTo>> & Omit<ToOptions<TAllRouteInfo, TRouteInfo['fullPath'], TTo>, 'from'>, opts?: MatchRouteOptions) => RouteInfoByPath<TAllRouteInfo, TResolved>['allParams'];
-    navigate: <TTo extends string = '.'>(options: Omit<LinkOptions<TAllRouteInfo, TRouteInfo['fullPath'], TTo>, 'from'>) => Promise<void>;
-    action: unknown extends TRouteInfo['actionResponse'] ? Action<TRouteInfo['actionPayload'], TRouteInfo['actionResponse']> | undefined : Action<TRouteInfo['actionPayload'], TRouteInfo['actionResponse']>;
-    loader: unknown extends TRouteInfo['routeLoaderData'] ? Action<LoaderContext<TRouteInfo['fullSearchSchema'], TRouteInfo['allParams']>, TRouteInfo['routeLoaderData']> | undefined : Loader<TRouteInfo['fullSearchSchema'], TRouteInfo['allParams'], TRouteInfo['routeLoaderData']>;
-}
-declare function createRoute<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TRouteInfo extends AnyRouteInfo = RouteInfo, TRouterContext = unknown>(routeConfig: RouteConfig, options: TRouteInfo['options'], parent: undefined | Route<TAllRouteInfo, any>, router: Router<TAllRouteInfo['routeConfig'], TAllRouteInfo, TRouterContext>): Route<TAllRouteInfo, TRouteInfo, TRouterContext>;
-
-interface AnyAllRouteInfo {
-    routeConfig: AnyRouteConfig;
-    routeInfo: AnyRouteInfo;
-    routeInfoById: Record<string, AnyRouteInfo>;
-    routeInfoByFullPath: Record<string, AnyRouteInfo>;
-    routeIds: any;
-    routePaths: any;
-    fullSearchSchema: Record<string, any>;
-}
-interface DefaultAllRouteInfo {
-    routeConfig: RouteConfig;
-    routeInfo: RouteInfo;
-    routeInfoById: Record<string, RouteInfo>;
-    routeInfoByFullPath: Record<string, RouteInfo>;
-    routeIds: string;
-    routePaths: string;
-    fullSearchSchema: AnySearchSchema;
-}
-interface AllRouteInfo<TRouteConfig extends AnyRouteConfig = RouteConfig> extends RoutesInfoInner<TRouteConfig, ParseRouteConfig<TRouteConfig>> {
-}
-type ParseRouteConfig<TRouteConfig = AnyRouteConfig> = TRouteConfig extends AnyRouteConfig ? RouteConfigRoute<TRouteConfig> | ParseRouteChildren<TRouteConfig> : never;
-type ParseRouteChildren<TRouteConfig> = TRouteConfig extends AnyRouteConfigWithChildren<infer TChildren> ? unknown extends TChildren ? never : TChildren extends AnyRouteConfig[] ? Values<{
-    [TId in TChildren[number]['id']]: ParseRouteChild<TChildren[number], TId>;
-}> : never : never;
-type ParseRouteChild<TRouteConfig, TId> = TRouteConfig & {
-    id: TId;
-} extends AnyRouteConfig ? ParseRouteConfig<TRouteConfig> : never;
-type RouteConfigRoute<TRouteConfig> = TRouteConfig extends RouteConfig<infer TId, infer TRouteId, infer TPath, infer TFullPath, infer TParentRouteLoaderData, infer TRouteLoaderData, infer TParentLoaderData, infer TLoaderData, infer TActionPayload, infer TActionResponse, infer TParentSearchSchema, infer TSearchSchema, infer TFullSearchSchema, infer TParentParams, infer TParams, infer TAllParams, any> ? string extends TRouteId ? never : RouteInfo<TId, TRouteId, TPath, TFullPath, TParentRouteLoaderData, TRouteLoaderData, TParentLoaderData, TLoaderData, TActionPayload, TActionResponse, TParentSearchSchema, TSearchSchema, TFullSearchSchema, TParentParams, TParams, TAllParams> : never;
-interface RoutesInfoInner<TRouteConfig extends AnyRouteConfig, TRouteInfo extends RouteInfo<string, string, any, any, any, any, any, any, any, any, any, any, any, any, any, any> = RouteInfo, TRouteInfoById = {
-    '/': TRouteInfo;
-} & {
-    [TInfo in TRouteInfo as TInfo['id']]: TInfo;
-}, TRouteInfoByFullPath = {
-    '/': TRouteInfo;
-} & {
-    [TInfo in TRouteInfo as TInfo['fullPath'] extends RootRouteId ? never : string extends TInfo['fullPath'] ? never : TInfo['fullPath']]: TInfo;
-}> {
-    routeConfig: TRouteConfig;
-    routeInfo: TRouteInfo;
-    routeInfoById: TRouteInfoById;
-    routeInfoByFullPath: TRouteInfoByFullPath;
-    routeIds: keyof TRouteInfoById;
-    routePaths: keyof TRouteInfoByFullPath;
-    fullSearchSchema: Partial<UnionToIntersection<TRouteInfo['fullSearchSchema']>>;
-}
-interface AnyRouteInfo extends RouteInfo<any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any> {
-}
-interface RouteInfo<TId extends string = string, TRouteId extends string = string, TPath extends string = string, TFullPath extends string = string, TParentRouteLoaderData extends AnyLoaderData = {}, TRouteLoaderData extends AnyLoaderData = {}, TParentLoaderData extends AnyLoaderData = {}, TLoaderData extends AnyLoaderData = {}, TActionPayload = unknown, TActionResponse = unknown, TParentSearchSchema extends {} = {}, TSearchSchema extends AnySearchSchema = {}, TFullSearchSchema extends AnySearchSchema = {}, TParentParams extends AnyPathParams = {}, TParams extends AnyPathParams = {}, TAllParams extends AnyPathParams = {}> {
-    id: TId;
-    routeId: TRouteId;
-    path: TPath;
-    fullPath: TFullPath;
-    parentRouteLoaderData: TParentRouteLoaderData;
-    routeLoaderData: TRouteLoaderData;
-    parentLoaderData: TParentLoaderData;
-    loaderData: TLoaderData;
-    actionPayload: TActionPayload;
-    actionResponse: TActionResponse;
-    searchSchema: TSearchSchema;
-    fullSearchSchema: TFullSearchSchema;
-    parentParams: TParentParams;
-    params: TParams;
-    allParams: TAllParams;
-    options: RouteOptions<TRouteId, TPath, TParentRouteLoaderData, TRouteLoaderData, TParentLoaderData, TLoaderData, TActionPayload, TActionResponse, TParentSearchSchema, TSearchSchema, TFullSearchSchema, TParentParams, TParams, TAllParams>;
+interface RouteMatch<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TRouteInfo extends AnyRouteInfo = RouteInfo> extends Route<TAllRouteInfo, TRouteInfo> {
+    matchId: string;
+    pathname: string;
+    params: TRouteInfo['allParams'];
+    parentMatch?: RouteMatch;
+    childMatches: RouteMatch[];
+    routeSearch: TRouteInfo['searchSchema'];
+    search: Expand<TAllRouteInfo['fullSearchSchema'] & TRouteInfo['fullSearchSchema']>;
+    status: 'idle' | 'loading' | 'success' | 'error';
+    updatedAt?: number;
+    error?: unknown;
+    isInvalid: boolean;
+    getIsInvalid: () => boolean;
+    loaderData: TRouteInfo['loaderData'];
+    routeLoaderData: TRouteInfo['routeLoaderData'];
+    isFetching: boolean;
+    invalidAt: number;
+    __: {
+        component?: GetFrameworkGeneric<'Component'>;
+        errorComponent?: GetFrameworkGeneric<'ErrorComponent'>;
+        pendingComponent?: GetFrameworkGeneric<'Component'>;
+        loadPromise?: Promise<void>;
+        componentsPromise?: Promise<void>;
+        dataPromise?: Promise<TRouteInfo['routeLoaderData']>;
+        onExit?: void | ((matchContext: {
+            params: TRouteInfo['allParams'];
+            search: TRouteInfo['fullSearchSchema'];
+        }) => void);
+        abortController: AbortController;
+        latestId: string;
+        validate: () => void;
+        notify: () => void;
+        resolve: () => void;
+    };
+    cancel: () => void;
+    load: (loaderOpts?: {
+        preload: true;
+        maxAge: number;
+        gcMaxAge: number;
+    } | {
+        preload?: false;
+        maxAge?: never;
+        gcMaxAge?: never;
+    }) => Promise<TRouteInfo['routeLoaderData']>;
+    fetch: (opts?: {
+        maxAge?: number;
+    }) => Promise<TRouteInfo['routeLoaderData']>;
+    invalidate: () => void;
+    hasLoaders: () => boolean;
 }
-type RoutesById<TAllRouteInfo extends AnyAllRouteInfo> = {
-    [K in keyof TAllRouteInfo['routeInfoById']]: Route<TAllRouteInfo, TAllRouteInfo['routeInfoById'][K]>;
-};
-type RouteInfoById<TAllRouteInfo extends AnyAllRouteInfo, TId> = TId extends keyof TAllRouteInfo['routeInfoById'] ? IsAny<TAllRouteInfo['routeInfoById'][TId]['id'], RouteInfo, TAllRouteInfo['routeInfoById'][TId]> : never;
-type RouteInfoByPath<TAllRouteInfo extends AnyAllRouteInfo, TPath> = TPath extends keyof TAllRouteInfo['routeInfoByFullPath'] ? IsAny<TAllRouteInfo['routeInfoByFullPath'][TPath]['id'], RouteInfo, TAllRouteInfo['routeInfoByFullPath'][TPath]> : never;
+declare function createRouteMatch<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TRouteInfo extends AnyRouteInfo = RouteInfo>(router: Router<any, any, any>, route: Route<TAllRouteInfo, TRouteInfo>, opts: {
+    parentMatch?: RouteMatch<any, any>;
+    matchId: string;
+    params: TRouteInfo['allParams'];
+    pathname: string;
+}): RouteMatch<TAllRouteInfo, TRouteInfo>;
 
 declare const rootRouteId: "__root__";
 type RootRouteId = typeof rootRouteId;
@@ -520,6 +430,100 @@ type TrimPathLeft<T extends string> = T extends `${RootRouteId}/${infer U}` ? Tr
 type TrimPathRight<T extends string> = T extends '/' ? '/' : T extends `${infer U}/` ? TrimPathRight<U> : T;
 declare const createRouteConfig: CreateRouteConfigFn<true>;
 
+interface AnyRoute extends Route<any, any, any> {
+}
+interface Route<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TRouteInfo extends AnyRouteInfo = RouteInfo, TRouterContext = unknown> {
+    routeInfo: TRouteInfo;
+    routeId: TRouteInfo['id'];
+    routeRouteId: TRouteInfo['routeId'];
+    routePath: TRouteInfo['path'];
+    fullPath: TRouteInfo['fullPath'];
+    parentRoute?: AnyRoute;
+    childRoutes?: AnyRoute[];
+    options: RouteOptions;
+    router: Router<TAllRouteInfo['routeConfig'], TAllRouteInfo, TRouterContext>;
+    buildLink: <TTo extends string = '.'>(options: Omit<LinkOptions<TAllRouteInfo, TRouteInfo['fullPath'], TTo>, 'from'>) => LinkInfo;
+    matchRoute: <TTo extends string = '.', TResolved extends string = ResolveRelativePath<TRouteInfo['id'], TTo>>(matchLocation: CheckRelativePath<TAllRouteInfo, TRouteInfo['fullPath'], NoInfer<TTo>> & Omit<ToOptions<TAllRouteInfo, TRouteInfo['fullPath'], TTo>, 'from'>, opts?: MatchRouteOptions) => RouteInfoByPath<TAllRouteInfo, TResolved>['allParams'];
+    navigate: <TTo extends string = '.'>(options: Omit<LinkOptions<TAllRouteInfo, TRouteInfo['fullPath'], TTo>, 'from'>) => Promise<void>;
+    action: unknown extends TRouteInfo['actionResponse'] ? Action<TRouteInfo['actionPayload'], TRouteInfo['actionResponse']> | undefined : Action<TRouteInfo['actionPayload'], TRouteInfo['actionResponse']>;
+    loader: unknown extends TRouteInfo['routeLoaderData'] ? Action<LoaderContext<TRouteInfo['fullSearchSchema'], TRouteInfo['allParams']>, TRouteInfo['routeLoaderData']> | undefined : Loader<TRouteInfo['fullSearchSchema'], TRouteInfo['allParams'], TRouteInfo['routeLoaderData']>;
+}
+declare function createRoute<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TRouteInfo extends AnyRouteInfo = RouteInfo, TRouterContext = unknown>(routeConfig: RouteConfig, options: TRouteInfo['options'], parent: undefined | Route<TAllRouteInfo, any>, router: Router<TAllRouteInfo['routeConfig'], TAllRouteInfo, TRouterContext>): Route<TAllRouteInfo, TRouteInfo, TRouterContext>;
+
+interface AnyAllRouteInfo {
+    routeConfig: AnyRouteConfig;
+    routeInfo: AnyRouteInfo;
+    routeInfoById: Record<string, AnyRouteInfo>;
+    routeInfoByFullPath: Record<string, AnyRouteInfo>;
+    routeIds: any;
+    routePaths: any;
+    fullSearchSchema: Record<string, any>;
+    allParams: Record<string, any>;
+}
+interface DefaultAllRouteInfo {
+    routeConfig: RouteConfig;
+    routeInfo: RouteInfo;
+    routeInfoById: Record<string, RouteInfo>;
+    routeInfoByFullPath: Record<string, RouteInfo>;
+    routeIds: string;
+    routePaths: string;
+    fullSearchSchema: AnySearchSchema;
+    allParams: AnyPathParams;
+}
+interface AllRouteInfo<TRouteConfig extends AnyRouteConfig = RouteConfig> extends RoutesInfoInner<TRouteConfig, ParseRouteConfig<TRouteConfig>> {
+}
+type ParseRouteConfig<TRouteConfig = AnyRouteConfig> = TRouteConfig extends AnyRouteConfig ? RouteConfigRoute<TRouteConfig> | ParseRouteChildren<TRouteConfig> : never;
+type ParseRouteChildren<TRouteConfig> = TRouteConfig extends AnyRouteConfigWithChildren<infer TChildren> ? unknown extends TChildren ? never : TChildren extends AnyRouteConfig[] ? Values<{
+    [TId in TChildren[number]['id']]: ParseRouteChild<TChildren[number], TId>;
+}> : never : never;
+type ParseRouteChild<TRouteConfig, TId> = TRouteConfig & {
+    id: TId;
+} extends AnyRouteConfig ? ParseRouteConfig<TRouteConfig> : never;
+type RouteConfigRoute<TRouteConfig> = TRouteConfig extends RouteConfig<infer TId, infer TRouteId, infer TPath, infer TFullPath, infer TParentRouteLoaderData, infer TRouteLoaderData, infer TParentLoaderData, infer TLoaderData, infer TActionPayload, infer TActionResponse, infer TParentSearchSchema, infer TSearchSchema, infer TFullSearchSchema, infer TParentParams, infer TParams, infer TAllParams, any> ? string extends TRouteId ? never : RouteInfo<TId, TRouteId, TPath, TFullPath, TParentRouteLoaderData, TRouteLoaderData, TParentLoaderData, TLoaderData, TActionPayload, TActionResponse, TParentSearchSchema, TSearchSchema, TFullSearchSchema, TParentParams, TParams, TAllParams> : never;
+interface RoutesInfoInner<TRouteConfig extends AnyRouteConfig, TRouteInfo extends RouteInfo<string, string, any, any, any, any, any, any, any, any, any, any, any, any, any, any> = RouteInfo, TRouteInfoById = {
+    '/': TRouteInfo;
+} & {
+    [TInfo in TRouteInfo as TInfo['id']]: TInfo;
+}, TRouteInfoByFullPath = {
+    '/': TRouteInfo;
+} & {
+    [TInfo in TRouteInfo as TInfo['fullPath'] extends RootRouteId ? never : string extends TInfo['fullPath'] ? never : TInfo['fullPath']]: TInfo;
+}> {
+    routeConfig: TRouteConfig;
+    routeInfo: TRouteInfo;
+    routeInfoById: TRouteInfoById;
+    routeInfoByFullPath: TRouteInfoByFullPath;
+    routeIds: keyof TRouteInfoById;
+    routePaths: keyof TRouteInfoByFullPath;
+    fullSearchSchema: Partial<UnionToIntersection<TRouteInfo['fullSearchSchema']>>;
+    allParams: Partial<UnionToIntersection<TRouteInfo['allParams']>>;
+}
+interface AnyRouteInfo extends RouteInfo<any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any> {
+}
+interface RouteInfo<TId extends string = string, TRouteId extends string = string, TPath extends string = string, TFullPath extends string = '/', TParentRouteLoaderData extends AnyLoaderData = {}, TRouteLoaderData extends AnyLoaderData = {}, TParentLoaderData extends AnyLoaderData = {}, TLoaderData extends AnyLoaderData = {}, TActionPayload = unknown, TActionResponse = unknown, TParentSearchSchema extends {} = {}, TSearchSchema extends AnySearchSchema = {}, TFullSearchSchema extends AnySearchSchema = {}, TParentParams extends AnyPathParams = {}, TParams extends AnyPathParams = {}, TAllParams extends AnyPathParams = {}> {
+    id: TId;
+    routeId: TRouteId;
+    path: TPath;
+    fullPath: TFullPath;
+    parentRouteLoaderData: TParentRouteLoaderData;
+    routeLoaderData: TRouteLoaderData;
+    parentLoaderData: TParentLoaderData;
+    loaderData: TLoaderData;
+    actionPayload: TActionPayload;
+    actionResponse: TActionResponse;
+    searchSchema: TSearchSchema;
+    fullSearchSchema: TFullSearchSchema;
+    parentParams: TParentParams;
+    params: TParams;
+    allParams: TAllParams;
+    options: RouteOptions<TRouteId, TPath, TParentRouteLoaderData, TRouteLoaderData, TParentLoaderData, TLoaderData, TActionPayload, TActionResponse, TParentSearchSchema, TSearchSchema, TFullSearchSchema, TParentParams, TParams, TAllParams>;
+}
+type RoutesById<TAllRouteInfo extends AnyAllRouteInfo> = {
+    [K in keyof TAllRouteInfo['routeInfoById']]: Route<TAllRouteInfo, TAllRouteInfo['routeInfoById'][K]>;
+};
+type RouteInfoById<TAllRouteInfo extends AnyAllRouteInfo, TId> = TId extends keyof TAllRouteInfo['routeInfoById'] ? IsAny<TAllRouteInfo['routeInfoById'][TId]['id'], RouteInfo, TAllRouteInfo['routeInfoById'][TId]> : never;
+type RouteInfoByPath<TAllRouteInfo extends AnyAllRouteInfo, TPath> = TPath extends keyof TAllRouteInfo['routeInfoByFullPath'] ? IsAny<TAllRouteInfo['routeInfoByFullPath'][TPath]['id'], RouteInfo, TAllRouteInfo['routeInfoByFullPath'][TPath]> : never;
+
 type LinkInfo = {
     type: 'external';
     href: string;
@@ -533,7 +537,6 @@ type LinkInfo = {
     isActive: boolean;
     disabled?: boolean;
 };
-type StartsWith<A, B> = A extends `${B extends string ? B : never}${infer _}` ? true : false;
 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;
 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;
 type ParsePathParams<T extends string> = Split<T>[number] extends infer U ? U extends `$${infer V}` ? V : never : never;
@@ -558,22 +561,18 @@ type ToOptions<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TFro
     state?: LocationState;
     from?: TFrom;
 } & CheckPath<TAllRouteInfo, NoInfer<TResolvedTo>, {}> & SearchParamOptions<TAllRouteInfo, TFrom, TResolvedTo> & PathParamOptions<TAllRouteInfo, TFrom, TResolvedTo>;
-type SearchParamOptions<TAllRouteInfo extends AnyAllRouteInfo, TFrom, TTo, TFromSchema = RouteInfoByPath<TAllRouteInfo, TFrom>['fullSearchSchema'], TToSchema = RouteInfoByPath<TAllRouteInfo, TTo>['fullSearchSchema']> = StartsWith<TFrom, TTo> extends true ? {
-    search?: SearchReducer<TFromSchema, TToSchema>;
-} : keyof PickRequired<TToSchema> extends never ? {
-    search?: SearchReducer<TFromSchema, TToSchema>;
+type SearchParamOptions<TAllRouteInfo extends AnyAllRouteInfo, TFrom, TTo, TFromSchema = Expand<UnionToIntersection<TAllRouteInfo['fullSearchSchema'] & RouteInfoByPath<TAllRouteInfo, TFrom> extends never ? {} : RouteInfoByPath<TAllRouteInfo, TFrom>['fullSearchSchema']>>, TToSchema = Partial<RouteInfoByPath<TAllRouteInfo, TFrom>['fullSearchSchema']> & Omit<RouteInfoByPath<TAllRouteInfo, TTo>['fullSearchSchema'], keyof PickRequired<RouteInfoByPath<TAllRouteInfo, TFrom>['fullSearchSchema']>>, TFromFullSchema = Expand<UnionToIntersection<TAllRouteInfo['fullSearchSchema'] & TFromSchema>>, TToFullSchema = Expand<UnionToIntersection<TAllRouteInfo['fullSearchSchema'] & TToSchema>>> = keyof PickRequired<TToSchema> extends never ? {
+    search?: true | SearchReducer<TFromFullSchema, TToFullSchema>;
 } : {
-    search: SearchReducer<TFromSchema, TToSchema>;
+    search: SearchReducer<TFromFullSchema, TToFullSchema>;
 };
 type SearchReducer<TFrom, TTo> = {
     [TKey in keyof TTo]: TTo[TKey];
 } | ((current: TFrom) => TTo);
-type PathParamOptions<TAllRouteInfo extends AnyAllRouteInfo, TFrom, TTo, TFromParams = RouteInfoByPath<TAllRouteInfo, TFrom>['allParams'], TToParams = RouteInfoByPath<TAllRouteInfo, TTo>['allParams']> = StartsWith<TFrom, TTo> extends true ? {
-    params?: ParamsReducer<TFromParams, TToParams>;
-} : AnyPathParams extends TToParams ? {
-    params?: ParamsReducer<TFromParams, Record<string, never>>;
+type PathParamOptions<TAllRouteInfo extends AnyAllRouteInfo, TFrom, TTo, TFromSchema = Expand<UnionToIntersection<RouteInfoByPath<TAllRouteInfo, TFrom> extends never ? {} : RouteInfoByPath<TAllRouteInfo, TFrom>['allParams']>>, TToSchema = Partial<RouteInfoByPath<TAllRouteInfo, TFrom>['allParams']> & Omit<RouteInfoByPath<TAllRouteInfo, TTo>['allParams'], keyof PickRequired<RouteInfoByPath<TAllRouteInfo, TFrom>['allParams']>>, TFromFullParams = Expand<UnionToIntersection<TAllRouteInfo['allParams'] & TFromSchema>>, TToFullParams = Expand<UnionToIntersection<TAllRouteInfo['allParams'] & TToSchema>>> = keyof PickRequired<TToSchema> extends never ? {
+    params?: ParamsReducer<TFromFullParams, TToFullParams>;
 } : {
-    params: ParamsReducer<TFromParams, TToParams>;
+    params: ParamsReducer<TFromFullParams, TToFullParams>;
 };
 type ParamsReducer<TFrom, TTo> = TTo | ((current: TFrom) => TTo);
 type ToPathOption<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TFrom extends ValidFromPath<TAllRouteInfo> = '/', TTo extends string = '.'> = TTo | RelativeToPathAutoComplete<TAllRouteInfo['routePaths'], NoInfer<TFrom> extends string ? NoInfer<TFrom> : '', NoInfer<TTo> & string>;

package/build/umd/index.development.js

@@ -1343,7 +1343,7 @@
         validate: () => {
           var _routeMatch$parentMat, _routeMatch$parentMat2;
           // Validate the search params and stabilize them
-          const parentSearch = (_routeMatch$parentMat = (_routeMatch$parentMat2 = routeMatch.parentMatch) == null ? void 0 : _routeMatch$parentMat2.search) != null ? _routeMatch$parentMat : router.location.search;
+          const parentSearch = (_routeMatch$parentMat = (_routeMatch$parentMat2 = routeMatch.parentMatch) == null ? void 0 : _routeMatch$parentMat2.search) != null ? _routeMatch$parentMat : router.__location.search;
           try {
             var _validator;
             const prevSearch = routeMatch.routeSearch;
@@ -1581,7 +1581,7 @@
       basepath: '',
       routeTree: undefined,
       routesById: {},
-      location: undefined,
+      __location: undefined,
       //
       resolveNavigation: () => {},
       matchCache: {},
@@ -1614,7 +1614,7 @@
       },
       dehydrate: () => {
         return {
-          location: router.location,
+          location: router.__location,
           state: _extends({}, pick(router.state, ['status', 'location', 'lastUpdated', 'location']), {
             matches: router.state.matches.map(match => pick(match, ['matchId', 'status', 'routeLoaderData', 'loaderData', 'isInvalid', 'invalidAt']))
           }),
@@ -1623,13 +1623,13 @@
       },
       hydrate: dehydratedState => {
         // Update the location
-        router.location = dehydratedState.location;
+        router.__location = dehydratedState.location;
 
         // Update the context
         router.options.context = dehydratedState.context;
 
         // Match the routes
-        const matches = router.matchRoutes(router.location.pathname, {
+        const matches = router.matchRoutes(router.__location.pathname, {
           strictParseParams: true
         });
         matches.forEach((match, index) => {
@@ -1651,14 +1651,14 @@
 
         // If the current location isn't updated, trigger a navigation
         // to the current location. Otherwise, load the current location.
-        if (next.href !== router.location.href) {
+        if (next.href !== router.__location.href) {
           router.__.commitLocation(next, true);
         }
         if (!router.state.matches.length) {
           router.load();
         }
         const unsub = router.history.listen(event => {
-          router.load(router.__.parseLocation(event.location, router.location));
+          router.load(router.__.parseLocation(event.location, router.__location));
         });
 
         // addEventListener does not exist in React Native, but window does
@@ -1682,12 +1682,12 @@
       },
       update: opts => {
         const newHistory = (opts == null ? void 0 : opts.history) !== router.history;
-        if (!router.location || newHistory) {
+        if (!router.__location || newHistory) {
           if (opts != null && opts.history) {
             router.history = opts.history;
           }
-          router.location = router.__.parseLocation(router.history.location);
-          router.state.location = router.location;
+          router.__location = router.__.parseLocation(router.history.location);
+          router.state.location = router.__location;
         }
         Object.assign(router.options, opts);
         const {
@@ -1712,28 +1712,28 @@
         router.startedLoadingAt = id;
         if (next) {
           // Ingest the new location
-          router.location = next;
+          router.__location = next;
         }
 
         // Cancel any pending matches
         router.cancelMatches();
 
         // Match the routes
-        const matches = router.matchRoutes(router.location.pathname, {
+        const matches = router.matchRoutes(router.__location.pathname, {
           strictParseParams: true
         });
         if (typeof document !== 'undefined') {
           router.state = _extends({}, router.state, {
             pending: {
               matches: matches,
-              location: router.location
+              location: router.__location
             },
             status: 'loading'
           });
         } else {
           router.state = _extends({}, router.state, {
             matches: matches,
-            location: router.location,
+            location: router.__location,
             status: 'loading'
           });
         }
@@ -1817,7 +1817,7 @@
           }
         });
         router.state = _extends({}, router.state, {
-          location: router.location,
+          location: router.__location,
           matches,
           pending: undefined,
           status: 'idle'
@@ -1846,7 +1846,7 @@
       },
       loadRoute: async function loadRoute(navigateOpts) {
         if (navigateOpts === void 0) {
-          navigateOpts = router.location;
+          navigateOpts = router.__location;
         }
         const next = router.buildNext(navigateOpts);
         const matches = router.matchRoutes(next.pathname, {
@@ -1858,7 +1858,7 @@
       preloadRoute: async function preloadRoute(navigateOpts, loaderOpts) {
         var _ref3, _ref4, _loaderOpts$maxAge, _ref5, _ref6, _loaderOpts$gcMaxAge;
         if (navigateOpts === void 0) {
-          navigateOpts = router.location;
+          navigateOpts = router.__location;
         }
         const next = router.buildNext(navigateOpts);
         const matches = router.matchRoutes(next.pathname, {
@@ -1943,14 +1943,15 @@
       },
       loadMatches: async (resolvedMatches, loaderOpts) => {
         const matchPromises = resolvedMatches.map(async match => {
+          var _search$__data;
           // Validate the match (loads search params etc)
           match.__.validate();
-          match.load(loaderOpts);
           const search = match.search;
-          if (search.__data && search.__data.matchId !== match.matchId) {
+          if ((_search$__data = search.__data) != null && _search$__data.matchId && search.__data.matchId !== match.matchId) {
             return;
           }
-          if (match.__.loadPromise) {
+          match.load(loaderOpts);
+          if (match.status !== 'success' && match.__.loadPromise) {
             // Wait for the first sign of activity from the match
             await match.__.loadPromise;
           }
@@ -2238,11 +2239,9 @@
           if (dest === void 0) {
             dest = {};
           }
-          // const resolvedFrom: Location = {
-          //   ...router.location,
-          const fromPathname = dest.fromCurrent ? router.location.pathname : (_dest$from = dest.from) != null ? _dest$from : router.location.pathname;
+          const fromPathname = dest.fromCurrent ? router.__location.pathname : (_dest$from = dest.from) != null ? _dest$from : router.__location.pathname;
           let pathname = resolvePath((_router$basepath = router.basepath) != null ? _router$basepath : '/', fromPathname, "" + ((_dest$to = dest.to) != null ? _dest$to : '.'));
-          const fromMatches = router.matchRoutes(router.location.pathname, {
+          const fromMatches = router.matchRoutes(router.__location.pathname, {
             strictParseParams: true
           });
           const toMatches = router.matchRoutes(pathname);
@@ -2256,7 +2255,7 @@
           pathname = interpolatePath(pathname, nextParams != null ? nextParams : {});
 
           // Pre filters first
-          const preFilteredSearch = (_dest$__preSearchFilt = dest.__preSearchFilters) != null && _dest$__preSearchFilt.length ? dest.__preSearchFilters.reduce((prev, next) => next(prev), router.location.search) : router.location.search;
+          const preFilteredSearch = (_dest$__preSearchFilt = dest.__preSearchFilters) != null && _dest$__preSearchFilt.length ? dest.__preSearchFilters.reduce((prev, next) => next(prev), router.__location.search) : router.__location.search;
 
           // Then the link/navigate function
           const destSearch = dest.search === true ? preFilteredSearch // Preserve resolvedFrom true
@@ -2266,15 +2265,15 @@
 
           // Then post filters
           const postFilteredSearch = (_dest$__postSearchFil = dest.__postSearchFilters) != null && _dest$__postSearchFil.length ? dest.__postSearchFilters.reduce((prev, next) => next(prev), destSearch) : destSearch;
-          const search = replaceEqualDeep(router.location.search, postFilteredSearch);
+          const search = replaceEqualDeep(router.__location.search, postFilteredSearch);
           const searchStr = router.options.stringifySearch(search);
-          let hash = dest.hash === true ? router.location.hash : functionalUpdate(dest.hash, router.location.hash);
+          let hash = dest.hash === true ? router.__location.hash : functionalUpdate(dest.hash, router.__location.hash);
           hash = hash ? "#" + hash : '';
           return {
             pathname,
             search,
             searchStr,
-            state: router.location.state,
+            state: router.__location.state,
             hash,
             href: "" + pathname + searchStr + hash,
             key: dest.key