@tanstack/react-router 1.90.0 → 1.91.0

package/src/router.ts

@@ -2553,37 +2553,7 @@ export class Router<
 
                         // Actually run the loader and handle the result
                         try {
-                          if (route._lazyPromise === undefined) {
-                            if (route.lazyFn) {
-                              route._lazyPromise = route
-                                .lazyFn()
-                                .then((lazyRoute) => {
-                                  // explicitly don't copy over the lazy route's id
-                                  const { id: _id, ...options } =
-                                    lazyRoute.options
-                                  Object.assign(route.options, options)
-                                })
-                            } else {
-                              route._lazyPromise = Promise.resolve()
-                            }
-                          }
-
-                          // If for some reason lazy resolves more lazy components...
-                          // We'll wait for that before pre attempt to preload any
-                          // components themselves.
-                          if (route._componentsPromise === undefined) {
-                            route._componentsPromise = route._lazyPromise.then(
-                              () =>
-                                Promise.all(
-                                  componentTypes.map(async (type) => {
-                                    const component = route.options[type]
-                                    if ((component as any)?.preload) {
-                                      await (component as any).preload()
-                                    }
-                                  }),
-                                ),
-                            )
-                          }
+                          this.loadRouteChunk(route)
 
                           updateMatch(matchId, (prev) => ({
                             ...prev,
@@ -2821,6 +2791,37 @@ export class Router<
     this.clearCache({ filter })
   }
 
+  loadRouteChunk = (route: AnyRoute) => {
+    if (route._lazyPromise === undefined) {
+      if (route.lazyFn) {
+        route._lazyPromise = route.lazyFn().then((lazyRoute) => {
+          // explicitly don't copy over the lazy route's id
+          const { id: _id, ...options } = lazyRoute.options
+          Object.assign(route.options, options)
+        })
+      } else {
+        route._lazyPromise = Promise.resolve()
+      }
+    }
+
+    // If for some reason lazy resolves more lazy components...
+    // We'll wait for that before pre attempt to preload any
+    // components themselves.
+    if (route._componentsPromise === undefined) {
+      route._componentsPromise = route._lazyPromise.then(() =>
+        Promise.all(
+          componentTypes.map(async (type) => {
+            const component = route.options[type]
+            if ((component as any)?.preload) {
+              await (component as any).preload()
+            }
+          }),
+        ),
+      )
+    }
+    return route._componentsPromise
+  }
+
   preloadRoute = async <
     TFrom extends RoutePaths<TRouteTree> | string = string,
     TTo extends string | undefined = undefined,

package/src/typePrimitives.ts

@@ -0,0 +1,168 @@
+import type {
+  FromPathOption,
+  NavigateOptions,
+  PathParamOptions,
+  SearchParamOptions,
+  ToPathOption,
+} from './link'
+import type { RouteIds } from './routeInfo'
+import type { AnyRouter, RegisteredRouter } from './router'
+import type { UseParamsOptions, UseParamsResult } from './useParams'
+import type { UseSearchOptions, UseSearchResult } from './useSearch'
+import type { Constrain, ConstrainLiteral } from './utils'
+
+export type ValidateFromPath<
+  TFrom,
+  TRouter extends AnyRouter = RegisteredRouter,
+> = FromPathOption<TRouter, TFrom>
+
+export type ValidateToPath<
+  TTo extends string | undefined,
+  TFrom extends string = string,
+  TRouter extends AnyRouter = RegisteredRouter,
+> = ToPathOption<TRouter, TFrom, TTo>
+
+export type ValidateSearch<
+  TTo extends string | undefined,
+  TFrom extends string = string,
+  TRouter extends AnyRouter = RegisteredRouter,
+> = SearchParamOptions<TRouter, TFrom, TTo>
+
+export type ValidateParams<
+  TTo extends string | undefined,
+  TFrom extends string = string,
+  TRouter extends AnyRouter = RegisteredRouter,
+> = PathParamOptions<TRouter, TFrom, TTo>
+
+/**
+ * @internal
+ */
+export type InferFrom<TOptions> = TOptions extends {
+  from: infer TFrom extends string
+}
+  ? TFrom
+  : string
+
+/**
+ * @internal
+ */
+export type InferTo<TOptions> = TOptions extends {
+  to: infer TTo extends string
+}
+  ? TTo
+  : undefined
+
+/**
+ * @internal
+ */
+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 }
+}
+  ? 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 ValidateId<
+  TId extends string,
+  TRouter extends AnyRouter = RegisteredRouter,
+> = ConstrainLiteral<TId, RouteIds<TRouter['routeTree']>>
+
+/**
+ * @internal
+ */
+export type InferStrict<TOptions> = TOptions extends {
+  strict: infer TStrict extends boolean
+}
+  ? TStrict
+  : true
+
+/**
+ * @internal
+ */
+export type InferSelected<TOptions> = TOptions extends {
+  select: (...args: Array<any>) => infer TSelected
+}
+  ? TSelected
+  : unknown
+
+/**
+ * @internal
+ */
+export type InferStructuralSharing<TOptions> = TOptions extends {
+  structuralSharing: infer TStructuralSharing
+}
+  ? TStructuralSharing
+  : unknown
+
+export type ValidateUseSearchOptions<
+  TOptions,
+  TRouter extends AnyRouter = RegisteredRouter,
+> = Constrain<
+  TOptions,
+  UseSearchOptions<
+    TRouter,
+    InferFrom<TOptions>,
+    InferStrict<TOptions>,
+    InferSelected<TOptions>,
+    InferStructuralSharing<TOptions>
+  >
+>
+
+export type ValidateUseSearchResult<
+  TOptions,
+  TRouter extends AnyRouter = RegisteredRouter,
+> = UseSearchResult<
+  TRouter,
+  InferFrom<TOptions>,
+  InferStrict<TOptions>,
+  InferSelected<TOptions>
+>
+
+export type ValidateUseParamsOptions<
+  TOptions,
+  TRouter extends AnyRouter = RegisteredRouter,
+> = Constrain<
+  TOptions,
+  UseParamsOptions<
+    TRouter,
+    InferFrom<TOptions>,
+    InferStrict<TOptions>,
+    InferSelected<TOptions>,
+    InferSelected<TOptions>
+  >
+>
+
+export type ValidateUseParamsResult<
+  TOptions,
+  TRouter extends AnyRouter = RegisteredRouter,
+> = Constrain<
+  TOptions,
+  UseParamsResult<
+    TRouter,
+    InferFrom<TOptions>,
+    InferStrict<TOptions>,
+    InferSelected<TOptions>
+  >
+>

package/src/utils.ts

@@ -111,6 +111,14 @@ export type PartialMergeAll<TUnion> =
   | ExtractPrimitives<TUnion>
   | PartialMergeAllObject<TUnion>
 
+export type Constrain<T, TConstraint, TDefault = TConstraint> =
+  | (T extends TConstraint ? T : never)
+  | TDefault
+
+export type ConstrainLiteral<T, TConstraint, TDefault = TConstraint> =
+  | (T & TConstraint)
+  | TDefault
+
 /**
  * To be added to router types
  */
@@ -139,10 +147,6 @@ export type MergeAll<TUnion> =
   | MergeAllObjects<TUnion>
   | ExtractPrimitives<TUnion>
 
-export type Constrain<T, TConstraint, TDefault = TConstraint> =
-  | (T extends TConstraint ? T : never)
-  | TDefault
-
 export type ValidateJSON<T> = ((...args: Array<any>) => any) extends T
   ? unknown extends T
     ? never
@@ -359,7 +363,7 @@ export type StrictOrFrom<
       strict: TStrict
     }
   : {
-      from: StringLiteral<Constrain<TFrom, RouteIds<TRouter['routeTree']>>>
+      from: ConstrainLiteral<TFrom, RouteIds<TRouter['routeTree']>>
       strict?: TStrict
     }