type inference when using a curried generic on parseResponse

[L-Blondy]

Using a non generic curried parser there is no issue

const upfetch = up(fetch)
const curried = () => (res: Response) => res.text()

const data = await upfetch('', {
   parseResponse: curried(),
   transform: (data) => data,
   onSuccess(data) {
      // ✅ ok
      expectTypeOf(data).toEqualTypeOf<string>()
   },
}) 
// ✅ ok
expectTypeOf(data).toEqualTypeOf<string>()

When using a curried parser everything is ok...

const data = await upfetch('', {
   parseResponse: withZod(z.object({ a: z.string() })),
})
// ✅ ok
expectTypeOf(data).toEqualTypeOf<{ a: string }>()

...until either onSuccess or transform are defined

const data = await upfetch('', {
   parseResponse: withZod(z.object({ a: z.string() })),
   transform: (data) => {
      // ❌ This fails, data is `any`
      expectTypeOf(data).toEqualTypeOf<{ a: string }>()
   }
})
// ❌ This fails, data is `any`
expectTypeOf(data).toEqualTypeOf<{ a: string }>()

but it works fine when using the functional version of the fetcher options

const data = await upfetch('', () => ({
   parseResponse: withZod(z.object({ a: z.string() })),
   transform: (data) => {
      // ✅ OK
      expectTypeOf(data).toEqualTypeOf<{ a: string }>()
   }
}))
// ✅ OK
expectTypeOf(data).toEqualTypeOf<{ a: string }>()

Also fine when unwrapping the curried function

const data = await upfetch('', {
   parseResponse: (res, opts) => withZod(z.object({ a: z.string() }))(res, opts),
   transform: (data) => {
      // ✅ OK
      expectTypeOf(data).toEqualTypeOf<{ a: string }>()
   }
})
// ✅ OK
expectTypeOf(data).toEqualTypeOf<{ a: string }>()

When using a default parser the data type in the callbacks come from the default parser, not the fetcher's

const upfetch = up(fetch, () => ({
   parseResponse: () => 1
}))

const data = await upfetch('', {
   ❌ Error on `parseResponse`
   parseResponse: withZod(z.object({ a: z.string() })),
   transform: (data) => {
      // ❌ This fails, data is `number`
      expectTypeOf(data).toEqualTypeOf<{ a: string }>()
   },
   onSuccess: (data) => {
      // ❌ This fails, data is `number`
      expectTypeOf(data).toEqualTypeOf<{ a: string }>()
   }
})
// ❌ This fails, data is `any`
expectTypeOf(data).toEqualTypeOf<{ a: string }>()

Same thing with the functional options, it works fine

const upfetch = up(fetch, () => ({
   parseResponse: () => 1
}))

const data = await upfetch('', {
   parseResponse: withZod(z.object({ a: z.string() })),
   transform: (data) => {
      // ✅ OK
      expectTypeOf(data).toEqualTypeOf<{ a: string }>()
   },
   onSuccess: (data) => {
      // ✅ OK
      expectTypeOf(data).toEqualTypeOf<{ a: string }>()
   }
})
// ✅ OK
expectTypeOf(data).toEqualTypeOf<{ a: string }>()

That's quite strange...

[L-Blondy]

workaround

Until a solution is found, when using a validation adapter use the functional version of the fetcher options