@tanstack/react-router 0.0.1-beta.215 → 0.0.1-beta.217

package/build/types/RouterProvider.d.ts

@@ -76,6 +76,7 @@ export interface RouteMatch<TRouteTree extends AnyRoute = AnyRoute, TRouteId ext
     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/route.d.ts

@@ -34,6 +34,7 @@ export type ParamsFallback<TPath extends string, TParams> = unknown extends TPar
 export type BaseRouteOptions<TParentRoute extends AnyRoute = AnyRoute, TCustomId extends string = string, TPath extends string = string, 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, TLoaderData extends any = unknown> = RoutePathOptions<TCustomId, TPath> & {
     getParentRoute: () => TParentRoute;
     validateSearch?: SearchSchemaValidator<TSearchSchema>;
+    shouldReload?: boolean | ((match: LoaderFnContext<TAllParams, TFullSearchSchema, TAllContext, TRouteContext>) => any);
 } & (keyof PickRequired<RouteContext> extends never ? {
     beforeLoad?: BeforeLoadFn<TFullSearchSchema, TParentRoute, TAllParams, TRouteContext>;
 } : {
@@ -85,9 +86,7 @@ export type DefinedPathParamWarning = 'Path params cannot be redefined by child
 export type ParentParams<TParentParams> = AnyPathParams extends TParentParams ? {} : {
     [Key in keyof TParentParams]?: DefinedPathParamWarning;
 };
-export type RouteLoadFn<TAllParams = {}, TFullSearchSchema extends Record<string, any> = {}, TAllContext extends Record<string, any> = AnyContext, TRouteContext extends Record<string, any> = AnyContext, TLoaderData extends any = unknown> = (match: LoaderFnContext<TAllParams, TFullSearchSchema, TAllContext, TRouteContext> & {
-    parentMatchPromise?: Promise<void>;
-}) => Promise<TLoaderData> | TLoaderData;
+export type RouteLoadFn<TAllParams = {}, TFullSearchSchema extends Record<string, any> = {}, TAllContext extends Record<string, any> = AnyContext, TRouteContext extends Record<string, any> = AnyContext, TLoaderData extends any = unknown> = (match: LoaderFnContext<TAllParams, TFullSearchSchema, TAllContext, TRouteContext>) => Promise<TLoaderData> | TLoaderData;
 export interface LoaderFnContext<TAllParams = {}, TFullSearchSchema extends Record<string, any> = {}, TAllContext extends Record<string, any> = AnyContext, TRouteContext extends Record<string, any> = AnyContext> {
     abortController: AbortController;
     preload: boolean;
@@ -96,6 +95,8 @@ export interface LoaderFnContext<TAllParams = {}, TFullSearchSchema extends Reco
     context: Expand<Assign<TAllContext, TRouteContext>>;
     location: ParsedLocation<TFullSearchSchema>;
     navigate: (opts: NavigateOptions<AnyRoute>) => Promise<void>;
+    parentMatchPromise?: Promise<void>;
+    cause: 'enter' | 'stay';
 }
 export type SearchFilter<T, U = T> = (prev: T) => U;
 export type ResolveId<TParentRoute, TCustomId extends string, TPath extends string> = TParentRoute extends {

package/build/types/utils.d.ts

@@ -48,7 +48,7 @@ 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 declare function deepEqual(a: any, b: any, partial?: boolean): boolean;
 export declare function useStableCallback<T extends (...args: any[]) => any>(fn: T): T;
 export declare function shallow<T>(objA: T, objB: T): boolean;
 export type StrictOrFrom<TFrom> = {

package/build/umd/index.development.js

@@ -558,7 +558,7 @@
   function hasObjectPrototype(o) {
     return Object.prototype.toString.call(o) === '[object Object]';
   }
-  function partialDeepEqual(a, b) {
+  function deepEqual(a, b, partial = false) {
     if (a === b) {
       return true;
     }
@@ -566,10 +566,15 @@
       return false;
     }
     if (isPlainObject(a) && isPlainObject(b)) {
-      return !Object.keys(b).some(key => !partialDeepEqual(a[key], b[key]));
+      const aKeys = Object.keys(a);
+      const bKeys = Object.keys(b);
+      if (!partial && aKeys.length !== bKeys.length) {
+        return false;
+      }
+      return !bKeys.some(key => !(key in a) || !deepEqual(a[key], b[key], partial));
     }
     if (Array.isArray(a) && Array.isArray(b)) {
-      return !(a.length !== b.length || a.some((item, index) => !partialDeepEqual(item, b[index])));
+      return !a.some((item, index) => !deepEqual(item, b[index], partial));
     }
     return false;
   }
@@ -1356,6 +1361,7 @@
           loadPromise: Promise.resolve(),
           context: undefined,
           abortController: new AbortController(),
+          shouldReloadDeps: undefined,
           fetchedAt: 0
         };
         return routeMatch;
@@ -1687,17 +1693,8 @@
           if (match.isFetching) {
             loadPromise = getRouteMatch(state, match.id)?.loadPromise;
           } else {
-            matches[index] = match = {
-              ...match,
-              isFetching: true
-            };
-            const componentsPromise = Promise.all(componentTypes.map(async type => {
-              const component = route.options[type];
-              if (component?.preload) {
-                await component.preload();
-              }
-            }));
-            const loaderPromise = route.options.loader?.({
+            const cause = state.matches.find(d => d.id === match.id) ? 'stay' : 'enter';
+            const loaderContext = {
               params: match.params,
               search: match.search,
               preload: !!preload,
@@ -1708,9 +1705,42 @@
               navigate: opts => navigate({
                 ...opts,
                 from: match.pathname
-              })
-            });
-            loadPromise = Promise.all([componentsPromise, loaderPromise]).then(d => d[1]);
+              }),
+              cause
+            };
+
+            // Default to reloading the route all the time
+            let shouldReload = true;
+            let shouldReloadDeps = typeof route.options.shouldReload === 'function' ? route.options.shouldReload?.(loaderContext) : !!route.options.shouldReload;
+            if (typeof shouldReloadDeps === 'object') {
+              // compare the deps to see if they've changed
+              shouldReload = !deepEqual(shouldReloadDeps, match.shouldReloadDeps);
+              console.log(shouldReloadDeps, match.shouldReloadDeps, shouldReload);
+              match.shouldReloadDeps = shouldReloadDeps;
+            } else {
+              shouldReload = !!shouldReloadDeps;
+            }
+
+            // If the user doesn't want the route to reload, just
+            // resolve with the existing loader data
+
+            if (!shouldReload) {
+              loadPromise = Promise.resolve(match.loaderData);
+            } else {
+              // Otherwise, load the route
+              matches[index] = match = {
+                ...match,
+                isFetching: true
+              };
+              const componentsPromise = Promise.all(componentTypes.map(async type => {
+                const component = route.options[type];
+                if (component?.preload) {
+                  await component.preload();
+                }
+              }));
+              const loaderPromise = route.options.loader?.(loaderContext);
+              loadPromise = Promise.all([componentsPromise, loaderPromise]).then(d => d[1]);
+            }
           }
           matches[index] = match = {
             ...match,
@@ -1892,7 +1922,7 @@
       // Combine the matches based on user options
       const pathTest = activeOptions?.exact ? latestLocationRef.current.pathname === next.pathname : pathIsFuzzyEqual;
       const hashTest = activeOptions?.includeHash ? latestLocationRef.current.hash === next.hash : true;
-      const searchTest = activeOptions?.includeSearch ?? true ? partialDeepEqual(latestLocationRef.current.search, next.search) : true;
+      const searchTest = activeOptions?.includeSearch ?? true ? deepEqual(latestLocationRef.current.search, next.search, true) : true;
 
       // The final "active" test
       const isActive = pathTest && hashTest && searchTest;
@@ -2023,7 +2053,7 @@
         return false;
       }
       if (match && (opts?.includeSearch ?? true)) {
-        return partialDeepEqual(baseLocation.search, next.search) ? match : false;
+        return deepEqual(baseLocation.search, next.search, true) ? match : false;
       }
       return match;
     });
@@ -2749,6 +2779,7 @@
   exports.createMemoryHistory = createMemoryHistory;
   exports.createRouteMask = createRouteMask;
   exports.decode = decode;
+  exports.deepEqual = deepEqual;
   exports.defaultParseSearch = defaultParseSearch;
   exports.defaultStringifySearch = defaultStringifySearch;
   exports.encode = encode;
@@ -2769,7 +2800,6 @@
   exports.matchesContext = matchesContext;
   exports.parsePathname = parsePathname;
   exports.parseSearchWith = parseSearchWith;
-  exports.partialDeepEqual = partialDeepEqual;
   exports.pick = pick;
   exports.redirect = redirect;
   exports.replaceEqualDeep = replaceEqualDeep;