@tanstack/react-router 1.34.3 → 1.34.6

package/src/useMatch.tsx

@@ -8,17 +8,22 @@ import type { MakeRouteMatch } from './Matches'
 import type { RouteIds } from './routeInfo'
 import type { StrictOrFrom } from './utils'
 
+export type UseMatchOptions<
+  TFrom,
+  TStrict extends boolean,
+  TRouteMatch,
+  TSelected,
+> = StrictOrFrom<TFrom, TStrict> & {
+  select?: (match: TRouteMatch) => TSelected
+}
+
 export function useMatch<
   TRouteTree extends AnyRoute = RegisteredRouter['routeTree'],
   TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>,
-  TReturnIntersection extends boolean = false,
-  TRouteMatch = MakeRouteMatch<TRouteTree, TFrom, TReturnIntersection>,
+  TStrict extends boolean = true,
+  TRouteMatch = MakeRouteMatch<TRouteTree, TFrom, TStrict>,
   TSelected = TRouteMatch,
->(
-  opts: StrictOrFrom<TFrom, TReturnIntersection> & {
-    select?: (match: TRouteMatch) => TSelected
-  },
-): TSelected {
+>(opts: UseMatchOptions<TFrom, TStrict, TRouteMatch, TSelected>): TSelected {
   const nearestMatchId = React.useContext(matchContext)
 
   const matchSelection = useRouterState({

package/src/useParams.tsx

@@ -2,22 +2,26 @@ import { useMatch } from './useMatch'
 import type { AnyRoute } from './route'
 import type { AllParams, RouteById, RouteIds } from './routeInfo'
 import type { RegisteredRouter } from './router'
-import type { Expand } from './utils'
 import type { StrictOrFrom } from './utils'
 
+export type UseParamsOptions<
+  TFrom,
+  TStrict extends boolean,
+  TParams,
+  TSelected,
+> = StrictOrFrom<TFrom, TStrict> & {
+  select?: (params: TParams) => TSelected
+}
+
 export function useParams<
   TRouteTree extends AnyRoute = RegisteredRouter['routeTree'],
   TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>,
-  TReturnIntersection extends boolean = false,
-  TParams = TReturnIntersection extends false
-    ? RouteById<TRouteTree, TFrom>['types']['allParams']
-    : Expand<Partial<AllParams<TRouteTree>>>,
+  TStrict extends boolean = true,
+  TParams = TStrict extends false
+    ? AllParams<TRouteTree>
+    : RouteById<TRouteTree, TFrom>['types']['allParams'],
   TSelected = TParams,
->(
-  opts: StrictOrFrom<TFrom, TReturnIntersection> & {
-    select?: (params: TParams) => TSelected
-  },
-): TSelected {
+>(opts: UseParamsOptions<TFrom, TStrict, TParams, TSelected>): TSelected {
   return useMatch({
     ...opts,
     select: (match) => {

package/src/useRouteContext.ts

@@ -1,19 +1,29 @@
 import { useMatch } from './useMatch'
 import type { MakeRouteMatch } from './Matches'
 import type { AnyRoute } from './route'
-import type { RouteById, RouteIds } from './routeInfo'
+import type { AllContext, RouteById, RouteIds } from './routeInfo'
 import type { RegisteredRouter } from './router'
-import type { StrictOrFrom } from './utils'
+import type { Expand, StrictOrFrom } from './utils'
+
+export type UseRouteContextOptions<
+  TFrom,
+  TStrict extends boolean,
+  TRouteContext,
+  TSelected,
+> = StrictOrFrom<TFrom, TStrict> & {
+  select?: (search: TRouteContext) => TSelected
+}
 
 export function useRouteContext<
   TRouteTree extends AnyRoute = RegisteredRouter['routeTree'],
   TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>,
-  TRouteContext = RouteById<TRouteTree, TFrom>['types']['allContext'],
+  TStrict extends boolean = true,
+  TRouteContext = TStrict extends false
+    ? AllContext<TRouteTree>
+    : Expand<RouteById<TRouteTree, TFrom>['types']['allContext']>,
   TSelected = TRouteContext,
 >(
-  opts: StrictOrFrom<TFrom> & {
-    select?: (search: TRouteContext) => TSelected
-  },
+  opts: UseRouteContextOptions<TFrom, TStrict, TRouteContext, TSelected>,
 ): TSelected {
   return useMatch({
     ...(opts as any),

package/src/useSearch.tsx

@@ -5,22 +5,27 @@ import type { RegisteredRouter } from './router'
 import type { MakeRouteMatch } from './Matches'
 import type { StrictOrFrom } from './utils'
 
+export type UseSearchOptions<
+  TFrom,
+  TStrict extends boolean,
+  TSearch,
+  TSelected,
+> = StrictOrFrom<TFrom, TStrict> & {
+  select?: (search: TSearch) => TSelected
+}
+
 export function useSearch<
   TRouteTree extends AnyRoute = RegisteredRouter['routeTree'],
   TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>,
-  TReturnIntersection extends boolean = false,
-  TSearch = TReturnIntersection extends false
-    ? Exclude<
+  TStrict extends boolean = true,
+  TSearch = TStrict extends false
+    ? FullSearchSchema<TRouteTree>
+    : Exclude<
         RouteById<TRouteTree, TFrom>['types']['fullSearchSchema'],
         RootSearchSchema
-      >
-    : Partial<Omit<FullSearchSchema<TRouteTree>, keyof RootSearchSchema>>,
+      >,
   TSelected = TSearch,
->(
-  opts: StrictOrFrom<TFrom, TReturnIntersection> & {
-    select?: (search: TSearch) => TSelected
-  },
-): TSelected {
+>(opts: UseSearchOptions<TFrom, TStrict, TSearch, TSelected>): TSelected {
   return useMatch({
     ...opts,
     select: (match: MakeRouteMatch<TRouteTree, TFrom>) => {

package/src/utils.ts

@@ -69,18 +69,38 @@ export type NonNullableUpdater<TPrevious, TResult = TPrevious> =
   | TResult
   | ((prev: TPrevious) => TResult)
 
-// from https://github.com/type-challenges/type-challenges/issues/737
-type LastInUnion<T> =
-  UnionToIntersection<T extends unknown ? (x: T) => 0 : never> extends (
-    x: infer L,
-  ) => 0
-    ? L
+export type MergeUnionObjects<TUnion> = TUnion extends MergeUnionPrimitive
+  ? never
+  : TUnion
+
+export type MergeUnionObject<TUnion> =
+  MergeUnionObjects<TUnion> extends infer TObj
+    ? {
+        [TKey in TObj extends any ? keyof TObj : never]?: TObj extends any
+          ? TKey extends keyof TObj
+            ? TObj[TKey]
+            : never
+          : never
+      }
     : never
-export type UnionToTuple<T, TLast = LastInUnion<T>> = [T] extends [never]
-  ? []
-  : [...UnionToTuple<Exclude<T, TLast>>, TLast]
 
-//
+export type MergeUnionPrimitive =
+  | ReadonlyArray<any>
+  | number
+  | string
+  | bigint
+  | boolean
+  | symbol
+
+export type MergeUnionPrimitives<TUnion> = TUnion extends MergeUnionPrimitive
+  ? TUnion
+  : TUnion extends object
+    ? never
+    : TUnion
+
+export type MergeUnion<TUnion> =
+  | MergeUnionPrimitives<TUnion>
+  | MergeUnionObject<MergeUnionObjects<TUnion>>
 
 export function last<T>(arr: Array<T>) {
   return arr[arr.length - 1]
@@ -268,15 +288,17 @@ export type StringLiteral<T> = T extends string
     : T
   : never
 
-export type StrictOrFrom<TFrom, TReturnIntersection extends boolean = false> =
-  | {
-      from: StringLiteral<TFrom> | TFrom
-      strict?: true
-    }
-  | {
+export type StrictOrFrom<
+  TFrom,
+  TStrict extends boolean = true,
+> = TStrict extends false
+  ? {
       from?: never
-      strict: false
-      experimental_returnIntersection?: TReturnIntersection
+      strict: TStrict
+    }
+  : {
+      from: StringLiteral<TFrom> | TFrom
+      strict?: TStrict
     }
 
 export const useLayoutEffect =