@tanstack/react-router 1.92.13 → 1.94.0

package/dist/esm/typePrimitives.d.ts

@@ -1,4 +1,4 @@
-import { FromPathOption, NavigateOptions, PathParamOptions, SearchParamOptions, ToPathOption } from './link.js';
+import { FromPathOption, LinkComponentProps, NavigateOptions, PathParamOptions, SearchParamOptions, ToPathOption } from './link.js';
 import { RouteIds } from './routeInfo.js';
 import { AnyRouter, RegisteredRouter } from './router.js';
 import { UseParamsOptions, UseParamsResult } from './useParams.js';
@@ -27,15 +27,19 @@ export type InferMaskTo<TOptions> = TOptions extends {
     mask: {
         to: infer TTo extends string;
     };
-} ? TTo : string;
+} ? TTo : '';
 export type InferMaskFrom<TOptions> = TOptions extends {
     mask: {
         from: infer TFrom extends string;
     };
 } ? TFrom : string;
 export type ValidateNavigateOptions<TOptions, TRouter extends AnyRouter = RegisteredRouter> = Constrain<TOptions, NavigateOptions<TRouter, InferFrom<TOptions>, InferTo<TOptions>, InferMaskFrom<TOptions>, InferMaskTo<TOptions>>>;
-export type ValidateNavigateOptionsArray<TOptions extends ReadonlyArray<any>> = {
-    [K in keyof TOptions]: ValidateNavigateOptions<TOptions[K]>;
+export type ValidateNavigateOptionsArray<TOptions extends ReadonlyArray<any>, TRouter extends AnyRouter = RegisteredRouter> = {
+    [K in keyof TOptions]: ValidateNavigateOptions<TOptions[K], TRouter>;
+};
+export type ValidateLinkOptions<TOptions, TComp = 'a', TRouter extends AnyRouter = RegisteredRouter> = Constrain<TOptions, LinkComponentProps<TComp, TRouter, InferFrom<TOptions>, InferTo<TOptions>, InferMaskFrom<TOptions>, InferMaskTo<TOptions>>>;
+export type ValidateLinkOptionsArray<TOptions extends ReadonlyArray<any>, TComp = 'a', TRouter extends AnyRouter = RegisteredRouter> = {
+    [K in keyof TOptions]: ValidateLinkOptions<TOptions[K], TComp, TRouter>;
 };
 export type ValidateId<TId extends string, TRouter extends AnyRouter = RegisteredRouter> = ConstrainLiteral<TId, RouteIds<TRouter['routeTree']>>;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/react-router",
-  "version": "1.92.13",
+  "version": "1.94.0",
   "description": "Modern and scalable routing for React applications",
   "author": "Tanner Linsley",
   "license": "MIT",

package/src/link.tsx

@@ -46,6 +46,10 @@ import type {
   WithoutEmpty,
 } from './utils'
 import type { ReactNode } from 'react'
+import type {
+  ValidateLinkOptions,
+  ValidateLinkOptionsArray,
+} from './typePrimitives'
 
 export type ParsePathParams<T extends string, TAcc = never> = T &
   `${string}$${string}` extends never
@@ -1040,19 +1044,21 @@ function isCtrlEvent(e: MouseEvent) {
   return !!(e.metaKey || e.altKey || e.ctrlKey || e.shiftKey)
 }
 
+export type LinkOptionsFnOptions<
+  TOptions,
+  TComp,
+  TRouter extends AnyRouter = RegisteredRouter,
+> =
+  TOptions extends ReadonlyArray<any>
+    ? ValidateLinkOptionsArray<TOptions, TComp, TRouter>
+    : ValidateLinkOptions<TOptions, TComp, TRouter>
+
 export type LinkOptionsFn<TComp> = <
-  const TProps,
+  const TOptions,
   TRouter extends AnyRouter = RegisteredRouter,
-  TFrom extends string = string,
-  TTo extends string | undefined = undefined,
-  TMaskFrom extends string = TFrom,
-  TMaskTo extends string = '',
 >(
-  options: Constrain<
-    TProps,
-    LinkComponentProps<TComp, TRouter, TFrom, TTo, TMaskFrom, TMaskTo>
-  >,
-) => TProps
+  options: LinkOptionsFnOptions<TOptions, TComp, TRouter>,
+) => TOptions
 
 export const linkOptions: LinkOptionsFn<'a'> = (options) => {
   return options as any

package/src/router.ts

@@ -1937,7 +1937,7 @@ export class Router<
 
   latestLoadPromise: undefined | Promise<void>
 
-  load = async (): Promise<void> => {
+  load = async (opts?: { sync?: boolean }): Promise<void> => {
     this.latestLocation = this.parseLocation(this.latestLocation)
 
     let redirect: ResolvedRedirect | undefined
@@ -2000,6 +2000,7 @@ export class Router<
           })
 
           await this.loadMatches({
+            sync: opts?.sync,
             matches: pendingMatches,
             location: next,
             // eslint-disable-next-line @typescript-eslint/require-await
@@ -2188,6 +2189,7 @@ export class Router<
     preload: allPreload,
     onReady,
     updateMatch = this.updateMatch,
+    sync,
   }: {
     location: ParsedLocation
     matches: Array<AnyRouteMatch>
@@ -2198,6 +2200,7 @@ export class Router<
       updater: (match: AnyRouteMatch) => AnyRouteMatch,
     ) => void
     getMatch?: (matchId: string) => AnyRouteMatch | undefined
+    sync?: boolean
   }): Promise<Array<MakeRouteMatch>> => {
     let firstBadMatchIndex: number | undefined
     let rendered = false
@@ -2484,7 +2487,8 @@ export class Router<
                   const { loaderPromise: prevLoaderPromise } =
                     this.getMatch(matchId)!
 
-                  let loaderRunningAsync = false
+                  let loaderShouldRunAsync = false
+                  let loaderIsRunningAsync = false
 
                   if (prevLoaderPromise) {
                     await prevLoaderPromise
@@ -2665,36 +2669,50 @@ export class Router<
 
                     // If the route is successful and still fresh, just resolve
                     const { status, invalid } = this.getMatch(matchId)!
-                    loaderRunningAsync =
+                    loaderShouldRunAsync =
                       status === 'success' &&
                       (invalid || (shouldReload ?? age > staleAge))
                     if (preload && route.options.preload === false) {
                       // Do nothing
-                    } else if (loaderRunningAsync) {
+                    } else if (loaderShouldRunAsync && !sync) {
+                      loaderIsRunningAsync = true
                       ;(async () => {
                         try {
                           await runLoader()
+                          const { loaderPromise, loadPromise } =
+                            this.getMatch(matchId)!
+                          loaderPromise?.resolve()
+                          loadPromise?.resolve()
+                          updateMatch(matchId, (prev) => ({
+                            ...prev,
+                            loaderPromise: undefined,
+                          }))
                         } catch (err) {
                           if (isResolvedRedirect(err)) {
                             await this.navigate(err)
                           }
                         }
                       })()
-                    } else if (status !== 'success') {
+                    } else if (
+                      status !== 'success' ||
+                      (loaderShouldRunAsync && sync)
+                    ) {
                       await runLoader()
                     }
-
+                  }
+                  if (!loaderIsRunningAsync) {
                     const { loaderPromise, loadPromise } =
                       this.getMatch(matchId)!
-
                     loaderPromise?.resolve()
                     loadPromise?.resolve()
                   }
 
                   updateMatch(matchId, (prev) => ({
                     ...prev,
-                    isFetching: loaderRunningAsync ? prev.isFetching : false,
-                    loaderPromise: undefined,
+                    isFetching: loaderIsRunningAsync ? prev.isFetching : false,
+                    loaderPromise: loaderIsRunningAsync
+                      ? prev.loaderPromise
+                      : undefined,
                     invalid: false,
                   }))
                   return this.getMatch(matchId)!
@@ -2725,6 +2743,7 @@ export class Router<
 
   invalidate = <TRouter extends AnyRouter = typeof this>(opts?: {
     filter?: (d: MakeRouteMatchUnion<TRouter>) => boolean
+    sync?: boolean
   }) => {
     const invalidate = (d: MakeRouteMatch<TRouteTree>) => {
       if (opts?.filter?.(d as MakeRouteMatchUnion<TRouter>) ?? true) {
@@ -2746,7 +2765,7 @@ export class Router<
       pendingMatches: s.pendingMatches?.map(invalidate),
     }))
 
-    return this.load()
+    return this.load({ sync: opts?.sync })
   }
 
   resolveRedirect = (err: AnyRedirect): ResolvedRedirect => {

package/src/typePrimitives.ts

@@ -1,5 +1,6 @@
 import type {
   FromPathOption,
+  LinkComponentProps,
   NavigateOptions,
   PathParamOptions,
   SearchParamOptions,
@@ -59,7 +60,7 @@ export type InferMaskTo<TOptions> = TOptions extends {
   mask: { to: infer TTo extends string }
 }
   ? TTo
-  : string
+  : ''
 
 export type InferMaskFrom<TOptions> = TOptions extends {
   mask: { from: infer TFrom extends string }
@@ -81,8 +82,34 @@ export type ValidateNavigateOptions<
   >
 >
 
-export type ValidateNavigateOptionsArray<TOptions extends ReadonlyArray<any>> =
-  { [K in keyof TOptions]: ValidateNavigateOptions<TOptions[K]> }
+export type ValidateNavigateOptionsArray<
+  TOptions extends ReadonlyArray<any>,
+  TRouter extends AnyRouter = RegisteredRouter,
+> = { [K in keyof TOptions]: ValidateNavigateOptions<TOptions[K], TRouter> }
+
+export type ValidateLinkOptions<
+  TOptions,
+  TComp = 'a',
+  TRouter extends AnyRouter = RegisteredRouter,
+> = Constrain<
+  TOptions,
+  LinkComponentProps<
+    TComp,
+    TRouter,
+    InferFrom<TOptions>,
+    InferTo<TOptions>,
+    InferMaskFrom<TOptions>,
+    InferMaskTo<TOptions>
+  >
+>
+
+export type ValidateLinkOptionsArray<
+  TOptions extends ReadonlyArray<any>,
+  TComp = 'a',
+  TRouter extends AnyRouter = RegisteredRouter,
+> = {
+  [K in keyof TOptions]: ValidateLinkOptions<TOptions[K], TComp, TRouter>
+}
 
 export type ValidateId<
   TId extends string,