@tanstack/react-router 1.81.4 → 1.81.6

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 {
@@ -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') {
@@ -1514,8 +1510,8 @@ export class Router<
       })
 
       let search = fromSearch
-      if (opts._includeValidateSearch) {
-        let validatedSearch = this.options.search?.strict ? {} : search
+      if (opts._includeValidateSearch && this.options.search?.strict) {
+        let validatedSearch = {}
         matchedRoutesResult?.matchedRoutes.forEach((route) => {
           try {
             if (route.options.validateSearch) {
@@ -1538,10 +1534,10 @@ export class Router<
         const allMiddlewares =
           matchedRoutesResult?.matchedRoutes.reduce(
             (acc, route) => {
-              let middlewares: Array<SearchMiddleware<any>> = []
+              const middlewares: Array<SearchMiddleware<any>> = []
               if ('search' in route.options) {
                 if (route.options.search?.middlewares) {
-                  middlewares = route.options.search.middlewares
+                  middlewares.push(...route.options.search.middlewares)
                 }
               }
               // TODO remove preSearchFilters and postSearchFilters in v2
@@ -1575,7 +1571,25 @@ export class Router<
                   }
                   return result
                 }
-                middlewares = [legacyMiddleware]
+                middlewares.push(legacyMiddleware)
+              }
+              if (opts._includeValidateSearch && route.options.validateSearch) {
+                const validate: SearchMiddleware<any> = ({ search, next }) => {
+                  try {
+                    const result = next(search)
+                    const validatedSearch = {
+                      ...result,
+                      ...(validateSearch(
+                        route.options.validateSearch,
+                        result,
+                      ) ?? {}),
+                    }
+                    return validatedSearch
+                  } catch (e) {
+                    // ignore errors here because they are already handled in matchRoutes
+                  }
+                }
+                middlewares.push(validate)
               }
               return acc.concat(middlewares)
             },
@@ -2542,6 +2556,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/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>