@tanstack/react-router 0.0.1-beta.221 → 0.0.1-beta.223

package/build/types/Matches.d.ts

@@ -1,10 +1,33 @@
 import * as React from 'react';
-import { RouteMatch } from './RouterProvider';
 import { ResolveRelativePath, ToOptions } from './link';
 import { AnyRoute, ReactNode } from './route';
-import { RouteById, RouteByPath, RouteIds, RoutePaths } from './routeInfo';
+import { FullSearchSchema, ParseRoute, RouteById, RouteByPath, RouteIds, RoutePaths } from './routeInfo';
 import { RegisteredRouter } from './router';
 import { NoInfer, StrictOrFrom } from './utils';
+export interface RouteMatch<TRouteTree extends AnyRoute = AnyRoute, TRouteId extends RouteIds<TRouteTree> = ParseRoute<TRouteTree>['id']> {
+    id: string;
+    routeId: TRouteId;
+    pathname: string;
+    params: RouteById<TRouteTree, TRouteId>['types']['allParams'];
+    status: 'pending' | 'success' | 'error';
+    isFetching: boolean;
+    invalid: boolean;
+    error: unknown;
+    paramsError: unknown;
+    searchError: unknown;
+    updatedAt: number;
+    loadPromise?: Promise<void>;
+    loaderData?: RouteById<TRouteTree, TRouteId>['types']['loaderData'];
+    __resolveLoadPromise?: () => void;
+    context: RouteById<TRouteTree, TRouteId>['types']['allContext'];
+    routeSearch: RouteById<TRouteTree, TRouteId>['types']['searchSchema'];
+    search: FullSearchSchema<TRouteTree> & RouteById<TRouteTree, TRouteId>['types']['fullSearchSchema'];
+    fetchedAt: number;
+    shouldReloadDeps: any;
+    abortController: AbortController;
+    cause: 'enter' | 'stay';
+}
+export type AnyRouteMatch = RouteMatch<any>;
 export declare function Matches(): JSX.Element;
 export declare function Match({ matches }: {
     matches: RouteMatch[];

package/build/types/RouterProvider.d.ts

@@ -3,10 +3,11 @@ import * as React from 'react';
 import { LinkInfo, LinkOptions, NavigateOptions, ResolveRelativePath, ToOptions } from './link';
 import { ParsedLocation } from './location';
 import { AnyRoute } from './route';
-import { FullSearchSchema, ParseRoute, RouteById, RouteIds, RoutePaths, RoutesById } from './routeInfo';
+import { RouteById, RoutePaths, RoutesById } from './routeInfo';
 import { BuildNextOptions, DehydratedRouteMatch, RegisteredRouter, Router, RouterOptions, RouterState } from './router';
 import { NoInfer } from './utils';
 import { MatchRouteOptions } from './Matches';
+import { RouteMatch } from './Matches';
 export interface CommitLocationOptions {
     replace?: boolean;
     resetScroll?: boolean;
@@ -62,26 +63,3 @@ export type RouterProps<TRouteTree extends AnyRoute = RegisteredRouter['routeTre
     context?: Partial<RouterOptions<TRouteTree, TDehydrated>['context']>;
 };
 export declare function useRouter<TRouteTree extends AnyRoute = RegisteredRouter['routeTree']>(): RouterContext<TRouteTree>;
-export interface RouteMatch<TRouteTree extends AnyRoute = AnyRoute, TRouteId extends RouteIds<TRouteTree> = ParseRoute<TRouteTree>['id']> {
-    id: string;
-    routeId: TRouteId;
-    pathname: string;
-    params: RouteById<TRouteTree, TRouteId>['types']['allParams'];
-    status: 'pending' | 'success' | 'error';
-    isFetching: boolean;
-    invalid: boolean;
-    error: unknown;
-    paramsError: unknown;
-    searchError: unknown;
-    updatedAt: number;
-    loadPromise?: Promise<void>;
-    loaderData?: RouteById<TRouteTree, TRouteId>['types']['loaderData'];
-    __resolveLoadPromise?: () => void;
-    context: RouteById<TRouteTree, TRouteId>['types']['allContext'];
-    routeSearch: RouteById<TRouteTree, TRouteId>['types']['searchSchema'];
-    search: FullSearchSchema<TRouteTree> & RouteById<TRouteTree, TRouteId>['types']['fullSearchSchema'];
-    fetchedAt: number;
-    shouldReloadDeps: any;
-    abortController: AbortController;
-}
-export type AnyRouteMatch = RouteMatch<any>;

package/build/types/fileRoute.d.ts

@@ -23,9 +23,9 @@ export declare class FileRoute<TFilePath extends keyof FileRoutesByPath, TParent
         preSearchFilters?: import("./route").SearchFilter<TFullSearchSchema, TFullSearchSchema>[] | undefined;
         postSearchFilters?: import("./route").SearchFilter<TFullSearchSchema, TFullSearchSchema>[] | undefined;
         onError?: ((err: any) => void) | undefined;
-        onEnter?: ((match: import("./RouterProvider").AnyRouteMatch) => void) | undefined;
-        onTransition?: ((match: import("./RouterProvider").AnyRouteMatch) => void) | undefined;
-        onLeave?: ((match: import("./RouterProvider").AnyRouteMatch) => void) | undefined;
+        onEnter?: ((match: import("./Matches").AnyRouteMatch) => void) | undefined;
+        onTransition?: ((match: import("./Matches").AnyRouteMatch) => void) | undefined;
+        onLeave?: ((match: import("./Matches").AnyRouteMatch) => void) | undefined;
         reloadOnWindowFocus?: boolean | undefined;
     }) => Route<TParentRoute, TPath, TFullPath, TFilePath, TId, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TRouteContext, TContext, TRouterContext, TLoaderData, TChildren, TRouteTree>;
 }

package/build/types/route.d.ts

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { AnyRouteMatch } from './RouterProvider';
+import { AnyRouteMatch } from './Matches';
 import { NavigateOptions, ParsePathParams, ToSubOptions } from './link';
 import { ParsedLocation } from './location';
 import { RoutePaths } from './routeInfo';
@@ -57,6 +57,7 @@ type BeforeLoadFn<TFullSearchSchema extends Record<string, any>, TParentRoute ex
     location: ParsedLocation;
     navigate: NavigateFn<AnyRoute>;
     buildLocation: BuildLocationFn<AnyRoute>;
+    cause: 'enter' | 'stay';
 }) => Promise<TRouteContext> | TRouteContext | void;
 export type UpdatableRouteOptions<TFullSearchSchema extends Record<string, any>, TAllParams extends AnyPathParams, TAllContext extends AnyContext, TLoaderData extends any = unknown> = MetaOptions & {
     caseSensitive?: boolean;

package/build/types/router.d.ts

@@ -4,7 +4,7 @@ import { AnySearchSchema, AnyRoute, AnyContext, AnyPathParams, RouteMask } from
 import { FullSearchSchema } from './routeInfo';
 import { PickAsRequired, Updater, NonNullableUpdater } from './utils';
 import { ErrorRouteComponent, PendingRouteComponent, RouteComponent } from './route';
-import { RouteMatch } from './RouterProvider';
+import { RouteMatch } from './Matches';
 import { ParsedLocation } from './location';
 import { LocationState } from './location';
 import { SearchSerializer, SearchParser } from './searchParams';

package/build/umd/index.development.js

@@ -1605,9 +1605,11 @@
         // reuse it. This is important for layout routes, which might stick
         // around between navigation actions that only change leaf routes.
         const existingMatch = getRouteMatch(state, matchId);
+        const cause = state.matches.find(d => d.id === matchId) ? 'stay' : 'enter';
         if (existingMatch) {
           return {
-            ...existingMatch
+            ...existingMatch,
+            cause
           };
         }
 
@@ -1631,7 +1633,8 @@
           context: undefined,
           abortController: new AbortController(),
           shouldReloadDeps: undefined,
-          fetchedAt: 0
+          fetchedAt: 0,
+          cause
         };
         return routeMatch;
       });
@@ -1916,7 +1919,8 @@
                 ...opts,
                 from: match.pathname
               }),
-              buildLocation
+              buildLocation,
+              cause: match.cause
             })) ?? {};
             const context = {
               ...parentContext,
@@ -1962,7 +1966,6 @@
           if (match.isFetching) {
             loadPromise = getRouteMatch(state, match.id)?.loadPromise;
           } else {
-            const cause = state.matches.find(d => d.id === match.id) ? 'stay' : 'enter';
             const loaderContext = {
               params: match.params,
               search: match.search,
@@ -1975,13 +1978,15 @@
                 ...opts,
                 from: match.pathname
               }),
-              cause
+              cause: match.cause
             };
 
             // Default to reloading the route all the time
             let shouldReload = true;
-            if (cause !== 'enter') {
-              let shouldReloadDeps = typeof route.options.shouldReload === 'function' ? route.options.shouldReload?.(loaderContext) : !!(route.options.shouldReload ?? true);
+            let shouldReloadDeps = typeof route.options.shouldReload === 'function' ? route.options.shouldReload?.(loaderContext) : !!(route.options.shouldReload ?? true);
+            if (match.cause === 'enter') {
+              match.shouldReloadDeps = shouldReloadDeps;
+            } else if (match.cause === 'stay') {
               if (typeof shouldReloadDeps === 'object') {
                 // compare the deps to see if they've changed
                 shouldReload = !deepEqual(shouldReloadDeps, match.shouldReloadDeps);