Add fallbacks

Author: colinhacks

zod/src/__tests__/__fixtures__/data-v3.ts

@@ -1,5 +1,5 @@
 import { Field, InternalFieldName } from 'react-hook-form';
-import { z } from 'zod/v3';
+import { z } from 'zod';
 
 export const schema = z
   .object({

zod/src/__tests__/zod-v3.ts

@@ -92,6 +92,23 @@ describe('zodResolver', () => {
     await expect(promise).rejects.toThrow('custom error');
   });
 
+  it('should enforce parse params type signature', async () => {
+    const resolver = zodResolver(schema, {
+      async: true,
+      path: ['asdf', 1234],
+      errorMap(iss, ctx) {
+        iss.path;
+        iss.code;
+        iss.path;
+        ctx.data;
+        ctx.defaultError;
+        return { message: 'asdf' };
+      },
+    });
+
+    resolver;
+  });
+
   /**
    * Type inference tests
    */

zod/src/__tests__/zod-v4.ts

@@ -92,6 +92,21 @@ describe('zodResolver', () => {
     await expect(promise).rejects.toThrow('custom error');
   });
 
+  it('should enforce parse params type signature', async () => {
+    const resolver = zodResolver(schema, {
+      jitless: true,
+      reportInput: true,
+      error(iss) {
+        iss.path;
+        iss.code;
+        iss.path;
+        return { message: 'asdf' };
+      },
+    });
+
+    resolver;
+  });
+
   /**
    * Type inference tests
    */

zod/src/zod.ts

@@ -143,32 +143,73 @@ type NonRawResolverOptions = {
 interface Zod3Type<O = unknown, I = unknown> {
   _output: O;
   _input: I;
+  _def: {
+    typeName: string;
+  };
 }
+
 interface Zod4Type<O = unknown, I = unknown> {
   _zod: {
     output: O;
     input: I;
   };
 }
 
+// some type magic to make versions pre-3.25.0 still work
+type IsUnresolved<T> = PropertyKey extends keyof T ? true : false;
+type UnresolvedFallback<T, Fallback> = IsUnresolved<typeof z3> extends true
+  ? Fallback
+  : T;
+type FallbackIssue = {
+  code: string;
+  message: string;
+  path: (string | number)[];
+};
+type Zod3ParseParams = UnresolvedFallback<
+  z3.ParseParams,
+  // fallback if user is on <3.25.0
+  {
+    path?: (string | number)[];
+    errorMap?: (
+      iss: FallbackIssue,
+      ctx: {
+        defaultError: string;
+        data: any;
+      },
+    ) => { message: string };
+    async?: boolean;
+  }
+>;
+type Zod4ParseParams = UnresolvedFallback<
+  z4.ParseContext<z4.$ZodIssue>,
+  // fallback if user is on <3.25.0
+  {
+    readonly error?: (
+      iss: FallbackIssue,
+    ) => null | undefined | string | { message: string };
+    readonly reportInput?: boolean;
+    readonly jitless?: boolean;
+  }
+>;
+
 export function zodResolver<Input extends FieldValues, Context, Output>(
   schema: Zod3Type<Output, Input>,
-  schemaOptions?: Partial<z3.ParseParams>,
+  schemaOptions?: Zod3ParseParams,
   resolverOptions?: NonRawResolverOptions,
 ): Resolver<Input, Context, Output>;
 export function zodResolver<Input extends FieldValues, Context, Output>(
   schema: Zod3Type<Output, Input>,
-  schemaOptions: Partial<z3.ParseParams> | undefined,
+  schemaOptions: Zod3ParseParams | undefined,
   resolverOptions: RawResolverOptions,
 ): Resolver<Input, Context, Input>;
 export function zodResolver<Input extends FieldValues, Context, Output>(
   schema: Zod4Type<Output, Input>,
-  schemaOptions?: z4.ParseContext<z4.$ZodIssue>, // already partial
+  schemaOptions?: Zod4ParseParams, // already partial
   resolverOptions?: NonRawResolverOptions,
 ): Resolver<Input, Context, Output>;
 export function zodResolver<Input extends FieldValues, Context, Output>(
   schema: Zod4Type<Output, Input>,
-  schemaOptions?: z4.ParseContext<z4.$ZodIssue>, // already partial
+  schemaOptions?: Zod4ParseParams, // already partial
   resolverOptions?: RawResolverOptions,
 ): Resolver<Input, Context, Input>;
 /**