@tanstack/react-router 0.0.1-beta.235 → 0.0.1-beta.237

package/src/useParams.tsx

@@ -2,14 +2,24 @@ import { AnyRoute } from './route'
 import { RouteIds, RouteById, AllParams } from './routeInfo'
 import { RegisteredRouter } from './router'
 import { last } from './utils'
-import { useRouter } from './RouterProvider'
+import { useRouterState } from './RouterProvider'
 import { StrictOrFrom } from './utils'
 
 export function useParams<
   TRouteTree extends AnyRoute = RegisteredRouter['routeTree'],
   TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>,
+  TDefaultSelected = AllParams<TRouteTree> &
+    RouteById<TRouteTree, TFrom>['types']['allParams'],
+  TSelected = TDefaultSelected,
 >(
-  _opts: StrictOrFrom<TFrom>,
-): AllParams<TRouteTree> & RouteById<TRouteTree, TFrom>['types']['allParams'] {
-  return (last(useRouter().state.matches) as any)?.params
+  opts: StrictOrFrom<TFrom> & {
+    select?: (search: TDefaultSelected) => TSelected
+  },
+): TSelected {
+  return useRouterState({
+    select: (state: any) => {
+      const params = (last(state.matches) as any)?.params
+      return opts?.select ? opts.select(params) : params
+    },
+  })
 }

package/src/useSearch.tsx

@@ -10,8 +10,16 @@ export function useSearch<
   TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>,
   TStrict extends boolean = true,
   TSearch = RouteById<TRouteTree, TFrom>['types']['fullSearchSchema'],
+  TSelected = TSearch,
 >(
-  opts: StrictOrFrom<TFrom>,
-): TStrict extends true ? TSearch : TSearch | undefined {
-  return useMatch(opts).search
+  opts: StrictOrFrom<TFrom> & {
+    select?: (search: TSearch) => TSelected
+  },
+): TStrict extends true ? TSelected : TSelected | undefined {
+  return useMatch({
+    ...(opts as any),
+    select: (match: RouteMatch) => {
+      return opts?.select ? opts.select(match.search as TSearch) : match.search
+    },
+  })
 }

package/src/utils.ts

@@ -18,8 +18,8 @@ export type PickExtra<T, K> = {
   [TKey in keyof K as string extends TKey
     ? never
     : TKey extends keyof T
-      ? never
-      : TKey]: K[TKey]
+    ? never
+    : TKey]: K[TKey]
 }
 
 export type PickRequired<T> = {
@@ -105,15 +105,15 @@ export type ValueKeys<O> = Extract<keyof O, PropertyKey>
 export type DeepAwaited<T> = T extends Promise<infer A>
   ? DeepAwaited<A>
   : T extends Record<infer A, Promise<infer B>>
-    ? { [K in A]: DeepAwaited<B> }
-    : T
+  ? { [K in A]: DeepAwaited<B> }
+  : T
 
 export type PathParamMask<TRoutePath extends string> =
   TRoutePath extends `${infer L}/$${infer C}/${infer R}`
     ? PathParamMask<`${L}/${string}/${R}`>
     : TRoutePath extends `${infer L}/$${infer C}`
-      ? PathParamMask<`${L}/${string}`>
-      : TRoutePath
+    ? PathParamMask<`${L}/${string}`>
+    : TRoutePath
 
 export type Timeout = ReturnType<typeof setTimeout>
 
@@ -314,10 +314,10 @@ export type RouteFromIdOrRoute<
 > = T extends ParseRoute<TRouteTree>
   ? T
   : T extends RouteIds<TRouteTree>
-    ? RoutesById<TRouteTree>[T]
-    : T extends string
-      ? RouteIds<TRouteTree>
-      : never
+  ? RoutesById<TRouteTree>[T]
+  : T extends string
+  ? RouteIds<TRouteTree>
+  : never
 
 export function useRouteContext<
   TRouteTree extends AnyRoute = RegisteredRouter['routeTree'],
@@ -326,9 +326,17 @@ export function useRouteContext<
   TRouteContext = RouteById<TRouteTree, TFrom>['types']['allContext'],
   TSelected = TRouteContext,
 >(
-  opts: StrictOrFrom<TFrom>,
+  opts: StrictOrFrom<TFrom> & {
+    select?: (search: TRouteContext) => TSelected
+  },
 ): TStrict extends true ? TSelected : TSelected | undefined {
-  return useMatch(opts).context
+  return useMatch({
+    ...(opts as any),
+    select: (match: RouteMatch) =>
+      opts?.select
+        ? opts.select(match.context as TRouteContext)
+        : match.context,
+  })
 }
 
 export const useLayoutEffect =