@tanstack/react-router 1.81.5 → 1.81.7

package/src/router.ts

@@ -42,8 +42,6 @@ import type {
   AnyContext,
   AnyRoute,
   AnyRouteWithContext,
-  AnySearchSchema,
-  AnySearchValidator,
   BeforeLoadContextOptions,
   ErrorRouteComponent,
   LoaderFnContext,
@@ -84,6 +82,7 @@ import type { AnyRedirect, ResolvedRedirect } from './redirects'
 import type { NotFoundError } from './not-found'
 import type { NavigateOptions, ResolveRelativePath, ToOptions } from './link'
 import type { RouterTransformer } from './transformer'
+import type { AnySchema, AnyValidator } from './validators'
 
 declare global {
   interface Window {
@@ -491,7 +490,7 @@ export interface RouterErrorSerializer<TSerializedError> {
 
 export interface RouterState<
   TRouteTree extends AnyRoute = AnyRoute,
-  TRouteMatch = MakeRouteMatch<TRouteTree>,
+  TRouteMatch = MakeRouteMatchUnion,
 > {
   status: 'pending' | 'idle'
   loadedAt: number
@@ -579,10 +578,7 @@ function routeNeedsPreload(route: AnyRoute) {
   return false
 }
 
-function validateSearch(
-  validateSearch: AnySearchValidator,
-  input: unknown,
-): unknown {
+function validateSearch(validateSearch: AnyValidator, input: unknown): unknown {
   if (validateSearch == null) return {}
 
   if ('~standard' in validateSearch) {
@@ -1075,7 +1071,7 @@ export class Router<
 */
   public matchRoutes(
     pathname: string,
-    locationSearch: AnySearchSchema,
+    locationSearch: AnySchema,
     opts?: MatchRoutesOpts,
   ): Array<AnyRouteMatch>
   public matchRoutes(
@@ -1085,7 +1081,7 @@ export class Router<
 
   public matchRoutes(
     pathnameOrNext: string | ParsedLocation,
-    locationSearchOrOpts?: AnySearchSchema | MatchRoutesOpts,
+    locationSearchOrOpts?: AnySchema | MatchRoutesOpts,
     opts?: MatchRoutesOpts,
   ) {
     if (typeof pathnameOrNext === 'string') {
@@ -1246,9 +1242,11 @@ export class Router<
       // pending matches that are still loading
       const existingMatch = this.getMatch(matchId)
 
-      const cause = this.state.matches.find((d) => d.id === matchId)
-        ? 'stay'
-        : 'enter'
+      const previousMatch = this.state.matches.find(
+        (d) => d.routeId === route.id,
+      )
+
+      const cause = previousMatch ? 'stay' : 'enter'
 
       let match: AnyRouteMatch
 
@@ -1256,7 +1254,12 @@ export class Router<
         match = {
           ...existingMatch,
           cause,
-          params: routeParams,
+          params: previousMatch
+            ? replaceEqualDeep(previousMatch.params, routeParams)
+            : routeParams,
+          search: previousMatch
+            ? replaceEqualDeep(previousMatch.search, preMatchSearch)
+            : replaceEqualDeep(existingMatch.search, preMatchSearch),
         }
       } else {
         const status =
@@ -1271,10 +1274,14 @@ export class Router<
           id: matchId,
           index,
           routeId: route.id,
-          params: routeParams,
+          params: previousMatch
+            ? replaceEqualDeep(previousMatch.params, routeParams)
+            : routeParams,
           pathname: joinPaths([this.basepath, interpolatedPath]),
           updatedAt: Date.now(),
-          search: {} as any,
+          search: previousMatch
+            ? replaceEqualDeep(previousMatch.search, preMatchSearch)
+            : preMatchSearch,
           searchError: undefined,
           status,
           isFetching: false,
@@ -1286,7 +1293,9 @@ export class Router<
           abortController: new AbortController(),
           fetchCount: 0,
           cause,
-          loaderDeps,
+          loaderDeps: previousMatch
+            ? replaceEqualDeep(previousMatch.loaderDeps, loaderDeps)
+            : loaderDeps,
           invalid: false,
           preload: false,
           links: route.options.links?.(),
@@ -1318,10 +1327,7 @@ export class Router<
         match.globalNotFound = globalNotFoundRouteId === route.id
       }
 
-      // Regardless of whether we're reusing an existing match or creating
-      // a new one, we need to update the match's search params
-      match.search = replaceEqualDeep(match.search, preMatchSearch)
-      // And also update the searchError if there is one
+      // update the searchError if there is one
       match.searchError = searchError
 
       const parentMatchId = parentMatch?.id
@@ -2560,6 +2566,10 @@ export class Router<
                         // to be preloaded before we resolve the match
                         await route._componentsPromise
                       } catch (err) {
+                        updateMatch(matchId, (prev) => ({
+                          ...prev,
+                          loaderPromise: undefined,
+                        }))
                         handleRedirectAndNotFound(this.getMatch(matchId)!, err)
                       }
                     }

package/src/searchParams.ts

@@ -1,5 +1,5 @@
 import { decode, encode } from './qss'
-import type { AnySearchSchema } from './route'
+import type { AnySchema } from './validators'
 
 export const defaultParseSearch = parseSearchWith(JSON.parse)
 export const defaultStringifySearch = stringifySearchWith(
@@ -8,7 +8,7 @@ export const defaultStringifySearch = stringifySearchWith(
 )
 
 export function parseSearchWith(parser: (str: string) => any) {
-  return (searchStr: string): AnySearchSchema => {
+  return (searchStr: string): AnySchema => {
     if (searchStr.substring(0, 1) === '?') {
       searchStr = searchStr.substring(1)
     }

package/src/useMatch.tsx

@@ -1,7 +1,7 @@
 import * as React from 'react'
 import invariant from 'tiny-invariant'
 import { useRouterState } from './useRouterState'
-import { matchContext } from './matchContext'
+import { dummyMatchContext, matchContext } from './matchContext'
 import type {
   StructuralSharingOption,
   ValidateSelected,
@@ -84,7 +84,9 @@ export function useMatch<
     TStructuralSharing
   >,
 ): ThrowOrOptional<UseMatchResult<TRouter, TFrom, TStrict, TSelected>, TThrow> {
-  const nearestMatchId = React.useContext(matchContext)
+  const nearestMatchId = React.useContext(
+    opts.from ? dummyMatchContext : matchContext,
+  )
 
   const matchSelection = useRouterState({
     select: (state: any) => {

package/src/utils.ts

@@ -72,12 +72,12 @@ export type NonNullableUpdater<TPrevious, TResult = TPrevious> =
   | TResult
   | ((prev: TPrevious) => TResult)
 
-export type MergeUnionObjects<TUnion> = TUnion extends MergeUnionPrimitive
+export type ExtractObjects<TUnion> = TUnion extends MergeAllPrimitive
   ? never
   : TUnion
 
-export type MergeUnionObject<TUnion> =
-  MergeUnionObjects<TUnion> extends infer TObj
+export type PartialMergeAllObject<TUnion> =
+  ExtractObjects<TUnion> extends infer TObj
     ? {
         [TKey in TObj extends any ? keyof TObj : never]?: TObj extends any
           ? TKey extends keyof TObj
@@ -87,23 +87,53 @@ export type MergeUnionObject<TUnion> =
       }
     : never
 
-export type MergeUnionPrimitive =
+export type MergeAllPrimitive =
   | ReadonlyArray<any>
   | number
   | string
   | bigint
   | boolean
   | symbol
+  | undefined
+  | null
 
-export type MergeUnionPrimitives<TUnion> = TUnion extends MergeUnionPrimitive
+export type ExtractPrimitives<TUnion> = TUnion extends MergeAllPrimitive
   ? TUnion
   : TUnion extends object
     ? never
     : TUnion
 
-export type MergeUnion<TUnion> =
-  | MergeUnionPrimitives<TUnion>
-  | MergeUnionObject<TUnion>
+export type PartialMergeAll<TUnion> =
+  | ExtractPrimitives<TUnion>
+  | PartialMergeAllObject<TUnion>
+
+/**
+ * To be added to router types
+ */
+export type UnionToIntersection<T> = (
+  T extends any ? (arg: T) => any : never
+) extends (arg: infer T) => any
+  ? T
+  : never
+
+/**
+ * Merges everything in a union into one object.
+ * This mapped type is homomorphic which means it preserves stuff! :)
+ */
+export type MergeAllObjects<
+  TUnion,
+  TIntersected = UnionToIntersection<ExtractObjects<TUnion>>,
+> = [keyof TIntersected] extends [never]
+  ? never
+  : {
+      [TKey in keyof TIntersected]: TUnion extends any
+        ? TUnion[TKey & keyof TUnion]
+        : never
+    }
+
+export type MergeAll<TUnion> =
+  | MergeAllObjects<TUnion>
+  | ExtractPrimitives<TUnion>
 
 export type Constrain<T, TConstraint, TDefault = TConstraint> =
   | (T extends TConstraint ? T : never)

package/src/validators.ts

@@ -0,0 +1,106 @@
+import type { SearchSchemaInput } from './route'
+
+export interface StandardSchemaValidatorProps<TInput, TOutput> {
+  readonly types?: StandardSchemaValidatorTypes<TInput, TOutput> | undefined
+  readonly validate: AnyStandardSchemaValidate
+}
+
+export interface StandardSchemaValidator<TInput, TOutput> {
+  readonly '~standard': StandardSchemaValidatorProps<TInput, TOutput>
+}
+
+export type AnyStandardSchemaValidator = StandardSchemaValidator<any, any>
+
+export interface StandardSchemaValidatorTypes<TInput, TOutput> {
+  readonly input: TInput
+  readonly output: TOutput
+}
+
+export interface AnyStandardSchemaValidateSuccess {
+  readonly value: any
+  readonly issues?: undefined
+}
+
+export interface AnyStandardSchemaValidateFailure {
+  readonly issues: ReadonlyArray<AnyStandardSchemaValidateIssue>
+}
+
+export interface AnyStandardSchemaValidateIssue {
+  readonly message: string
+}
+
+export interface AnyStandardSchemaValidateInput {
+  readonly value: any
+}
+
+export type AnyStandardSchemaValidate = (
+  value: unknown,
+) =>
+  | (AnyStandardSchemaValidateSuccess | AnyStandardSchemaValidateFailure)
+  | Promise<AnyStandardSchemaValidateSuccess | AnyStandardSchemaValidateFailure>
+
+export interface ValidatorObj<TInput, TOutput> {
+  parse: ValidatorFn<TInput, TOutput>
+}
+
+export type AnyValidatorObj = ValidatorObj<any, any>
+
+export interface ValidatorAdapter<TInput, TOutput> {
+  types: {
+    input: TInput
+    output: TOutput
+  }
+  parse: (input: unknown) => TOutput
+}
+
+export type AnyValidatorAdapter = ValidatorAdapter<any, any>
+
+export type AnyValidatorFn = ValidatorFn<any, any>
+
+export type ValidatorFn<TInput, TOutput> = (input: TInput) => TOutput
+
+export type Validator<TInput, TOutput> =
+  | ValidatorObj<TInput, TOutput>
+  | ValidatorFn<TInput, TOutput>
+  | ValidatorAdapter<TInput, TOutput>
+  | StandardSchemaValidator<TInput, TOutput>
+  | undefined
+
+export type AnyValidator = Validator<any, any>
+
+export type AnySchema = {}
+
+export type DefaultValidator = Validator<Record<string, unknown>, AnySchema>
+
+export type ResolveValidatorInputFn<TValidator> = TValidator extends (
+  input: infer TSchemaInput,
+) => any
+  ? TSchemaInput extends SearchSchemaInput
+    ? Omit<TSchemaInput, keyof SearchSchemaInput>
+    : ResolveValidatorOutputFn<TValidator>
+  : AnySchema
+
+export type ResolveValidatorInput<TValidator> =
+  TValidator extends AnyStandardSchemaValidator
+    ? NonNullable<TValidator['~standard']['types']>['input']
+    : TValidator extends AnyValidatorAdapter
+      ? TValidator['types']['input']
+      : TValidator extends AnyValidatorObj
+        ? ResolveValidatorInputFn<TValidator['parse']>
+        : ResolveValidatorInputFn<TValidator>
+
+export type ResolveValidatorOutputFn<TValidator> = TValidator extends (
+  ...args: any
+) => infer TSchema
+  ? TSchema
+  : AnySchema
+
+export type ResolveValidatorOutput<TValidator> = unknown extends TValidator
+  ? TValidator
+  : TValidator extends AnyStandardSchemaValidator
+    ? NonNullable<TValidator['~standard']['types']>['output']
+    : TValidator extends AnyValidatorAdapter
+      ? TValidator['types']['output']
+      : TValidator extends AnyValidatorObj
+        ? ResolveValidatorOutputFn<TValidator['parse']>
+        : ResolveValidatorOutputFn<TValidator>