Merge pull request #512 from traversable/zod-default-value-fix

ahrjarrett · web-flow · commit c7be5b3394a2 · 2025-09-17T18:23:23.000-05:00
fix(zod): fixes return type for `zx.defaultValue`
diff --git a/.changeset/tired-cups-yell.md b/.changeset/tired-cups-yell.md
@@ -0,0 +1,5 @@
+---
+"@traversable/zod": patch
+---
+
+fix(zod): fixes return type for `zx.defaultValue`
diff --git a/packages/valibot/src/default-value.ts b/packages/valibot/src/default-value.ts
@@ -187,9 +187,6 @@ export type defaultValue<
  * )
  */
 
-// export function defaultValue<T extends AnyValibotSchema>(type: T): defaultValue<v.InferOutput<T>>
-// export function defaultValue<T extends AnyValibotSchema, Leaves extends Fallbacks>(type: T, options: Options<Leaves>): defaultValue<v.InferOutput<T>, Leaves[keyof Leaves]>
-// export function defaultValue<T extends AnyValibotSchema>(
 export function defaultValue<T extends AnyValibotSchema>(type: T): defaultValue<v.InferOutput<T>>
 export function defaultValue<T extends AnyValibotSchema, Leaves extends Fallbacks>(type: T, options: Options<Leaves>): defaultValue<v.InferOutput<T>, Leaves>
 export function defaultValue<T extends AnyValibotSchema>(
diff --git a/packages/zod/src/default-value.ts b/packages/zod/src/default-value.ts
@@ -1,5 +1,5 @@
 import { z } from 'zod'
-import type { Primitive } from '@traversable/registry'
+import type { Primitive, Showable } from '@traversable/registry'
 import { Array_isArray, fn, has, isPrimitive, Object_assign, Object_fromEntries, Object_keys } from '@traversable/registry'
 import { F, tagged, TypeName } from '@traversable/zod-types'
 
@@ -50,14 +50,82 @@ const ARE = (x: unknown, y: unknown) => x != null && y != null
 /** @internal */
 const CATCH_ALL = undefined
 
-export type defaultValue<T, Fallback = undefined>
-  = T extends Primitive | Atom ? T | Fallback
-  : T extends Set<any> ? Set<defaultValue<ReturnType<(ReturnType<T['values']>['return'] & {})>['value'] & {}, Fallback>>
+export type Match<T, Matchers>
+  = T extends Primitive ?
+  | Matchers[T & keyof Matchers]
+  | Matchers[`${T & Showable}` & keyof Matchers]
+  : { [K in keyof T]: Match<T[K], Matchers> }
+
+export type MatchPrimitive<
+  T,
+  TypeMap,
+  M extends MergeTypeMap<TypeMap> = MergeTypeMap<TypeMap>
+> = Match<T,
+  & { [x: string]: M['string'] }
+  & { [x: number]: M['number'] }
+  & { [x: symbol]: M['boolean'] }
+  & { [x: `${bigint}`]: M['bigint'] }
+  & {
+    true: M['boolean']
+    false: M['boolean']
+    null: M['null']
+    undefined: M['undefined']
+  }
+>
+
+export type DefaultTypeMap = {
+  never: undefined
+  any: undefined
+  unknown: undefined
+  undefined: undefined
+  null: undefined
+  boolean: undefined
+  bigint: undefined
+  number: undefined
+  string: undefined
+}
+
+export type PreserveTypeMap = {
+  never: never
+  any: any
+  unknown: unknown
+  undefined: undefined
+  null: null | undefined
+  boolean: boolean | undefined
+  bigint: bigint | undefined
+  number: number | undefined
+  string: string | undefined
+}
+
+export type AnyTypeMap = {
+  never: unknown
+  any: unknown
+  unknown: unknown
+  undefined: unknown
+  null: unknown
+  boolean: unknown
+  bigint: unknown
+  number: unknown
+  string: unknown
+}
+
+export type MergeTypeMap<T> = {
+  [K in keyof DefaultTypeMap]: K extends keyof T ? T[K] : DefaultTypeMap[K]
+}
+
+export type defaultValue<
+  T,
+  TypeMap = DefaultTypeMap,
+  M extends MergeTypeMap<TypeMap> = MergeTypeMap<TypeMap>
+> = unknown extends T ? (0 extends T & 1 ? M['any'] : M['unknown'])
+  : [T] extends [never] ? M['never']
+  : T extends Primitive ? MatchPrimitive<T, M>
+  : T extends Set<any> ? Set<defaultValue<ReturnType<(ReturnType<T['values']>['return'] & {})>['value'] & {}, TypeMap, M>>
   : T extends Map<any, any> ? Map<
-    defaultValue<({} & ReturnType<{} & ReturnType<T['entries']>['return']>['value'])[0], Fallback>,
-    defaultValue<({} & ReturnType<{} & ReturnType<T['entries']>['return']>['value'])[1], Fallback>
+    defaultValue<({} & ReturnType<{} & ReturnType<T['entries']>['return']>['value'])[0], TypeMap, M>,
+    defaultValue<({} & ReturnType<{} & ReturnType<T['entries']>['return']>['value'])[1], TypeMap, M>
   >
-  : { [K in keyof T]-?: defaultValue<T[K], Fallback> }
+  : { [K in keyof T]: defaultValue<T[K], TypeMap, M> }
 
 /** 
  * ## {@link defaultValue `zx.defaultValue`}
@@ -125,8 +193,8 @@ export type defaultValue<T, Fallback = undefined>
  * )
  */
 
-export function defaultValue<T extends z.ZodType | z.core.$ZodType>(type: T): defaultValue<z.infer<T>>
-export function defaultValue<T extends z.ZodType | z.core.$ZodType, Leaves extends Fallbacks>(type: T, options: Options<Leaves>): defaultValue<z.infer<T>, Leaves[keyof Leaves]>
+export function defaultValue<T extends z.ZodType>(type: T): defaultValue<z.infer<T>>
+export function defaultValue<T extends z.ZodType, Leaves extends Fallbacks>(type: T, options: Options<Leaves>): defaultValue<z.infer<T>, Leaves>
 export function defaultValue<T extends F.Z.Hole<Fixpoint>>(
   type: T, {
     fallbacks = defaultValue.defaults.fallbacks,
diff --git a/packages/zod/src/makeLens.ts b/packages/zod/src/makeLens.ts
@@ -1,5 +1,5 @@
 import { z } from 'zod'
-import type { Key, newtype, Showable } from '@traversable/registry'
+import type { Key, newtype, Primitive, Showable } from '@traversable/registry'
 import {
   Array_from,
   Array_isArray,
@@ -532,9 +532,23 @@ interface Proxy_tuple<T, S, KS extends (keyof any)[]> extends newtype<
   [symbol.path]: KS
 }
 
+export type Atom =
+  | globalThis.Date
+  | globalThis.RegExp
+
+export type CoalesceOptional<T, Fallback = undefined>
+  = T extends Primitive | Atom ? T | Fallback
+  : T extends Set<any> ? Set<CoalesceOptional<ReturnType<(ReturnType<T['values']>['return'] & {})>['value'] & {}, Fallback>>
+  : T extends Map<any, any> ? Map<
+    CoalesceOptional<({} & ReturnType<{} & ReturnType<T['entries']>['return']>['value'])[0], Fallback>,
+    CoalesceOptional<({} & ReturnType<{} & ReturnType<T['entries']>['return']>['value'])[1], Fallback>
+  >
+  : { [K in keyof T]-?: CoalesceOptional<T[K], Fallback> }
+
 interface Proxy_optional<T, S, KS extends (keyof any)[]> {
   [DSL.chainOptional]: Proxy<S>
-  [DSL.coalesceOptional]: Proxy<S, [defaultValue<S>], KS>
+  // [DSL.coalesceOptional]: Proxy<S, [S], KS>
+  [DSL.coalesceOptional]: Proxy<S, [CoalesceOptional<S>], KS>
   [symbol.type]: T
   [symbol.path]: KS
 }
diff --git a/packages/zod/test/default-value.test.ts b/packages/zod/test/default-value.test.ts
@@ -212,4 +212,226 @@ vi.describe('〖⛳️〗‹‹‹ ❲@traversable/zod❳', () => {
       }
     `)
   })
+
+  vi.test('〖⛳️〗› ❲zx.defaultValue❳: type-level tests', () => {
+    vi.expectTypeOf(
+      zx.defaultValue(
+        z.object({
+          firstName: z.string(),
+          lastName: z.string(),
+          age: z.number(),
+        }), {
+        fallbacks: {
+          number: 0,
+          string: '',
+        },
+      })
+    ).toEqualTypeOf<{
+      firstName: string
+      lastName: string
+      age: number
+    }>()
+
+    vi.expectTypeOf(
+      zx.defaultValue(
+        z.object({
+          firstName: z.string(),
+          lastName: z.string(),
+          age: z.number(),
+        })
+      )
+    ).toEqualTypeOf<{
+      firstName: undefined
+      lastName: undefined
+      age: undefined
+    }>()
+
+    vi.expectTypeOf(
+      zx.defaultValue(
+        z.object({
+          firstName: z.string(),
+          lastName: z.string(),
+          age: z.number(),
+        }), {
+        fallbacks: {
+          number: 0,
+        },
+      })
+    ).toEqualTypeOf<{
+      firstName: undefined
+      lastName: undefined
+      age: number
+    }>()
+
+    vi.expectTypeOf(
+      zx.defaultValue(
+        z.object({
+          firstName: z.string(),
+          lastName: z.string(),
+          age: z.number(),
+        }), {
+        fallbacks: {
+          string: {},
+        },
+      })
+    ).toEqualTypeOf<{
+      firstName: {}
+      lastName: {}
+      age: undefined
+    }>()
+
+    vi.expectTypeOf(
+      zx.defaultValue(
+        z.object({
+          firstName: z.boolean(),
+          lastName: z.string(),
+          age: z.number(),
+        }), {
+        fallbacks: {
+          boolean: {},
+        },
+      })
+    ).toEqualTypeOf<{
+      firstName: {}
+      lastName: undefined
+      age: undefined
+    }>()
+
+    vi.expectTypeOf(
+      zx.defaultValue(
+        z.set(
+          z.object({
+            firstName: z.boolean(),
+            lastName: z.string(),
+            age: z.number(),
+          })
+        ), {
+        fallbacks: {
+          boolean: {},
+        },
+      })
+    ).toEqualTypeOf<
+      Set<{
+        firstName: {}
+        lastName: undefined
+        age: undefined
+      }>
+    >()
+
+    vi.expectTypeOf(
+      zx.defaultValue(
+        z.map(
+          z.object({
+            firstName: z.string(),
+            lastName: z.string(),
+            age: z.number(),
+          }),
+          z.object({
+            street1: z.string(),
+            street2: z.optional(z.string()),
+            city: z.string(),
+            postalCode: z.optional(z.string()),
+          })
+        ), {
+        fallbacks: {
+          string: 0,
+        },
+      })
+    ).toEqualTypeOf<
+      Map<
+        {
+          firstName: number
+          lastName: number
+          age: undefined
+        },
+        {
+          street1: number
+          street2?: number
+          city: number
+          postalCode?: number
+        }
+      >
+    >()
+
+
+    vi.expectTypeOf(
+      zx.defaultValue(
+        z.tuple([
+          z.map(
+            z.object({
+              firstName: z.string(),
+              lastName: z.string(),
+              age: z.number(),
+            }),
+            z.object({
+              street1: z.string(),
+              street2: z.optional(z.string()),
+              city: z.string(),
+              postalCode: z.optional(z.string()),
+            })
+          )
+        ]), {
+        fallbacks: {
+          string: 0,
+        },
+      })
+    ).toEqualTypeOf<
+      [
+        Map<
+          {
+            firstName: number
+            lastName: number
+            age: undefined
+          },
+          {
+            street1: number
+            street2?: number
+            city: number
+            postalCode?: number
+          }
+        >
+      ]
+    >()
+
+    vi.expectTypeOf(
+      zx.defaultValue(
+        z.array(
+          z.tuple([
+            z.map(
+              z.object({
+                firstName: z.string(),
+                lastName: z.string(),
+                age: z.number(),
+              }),
+              z.object({
+                street1: z.string(),
+                street2: z.optional(z.string()),
+                city: z.string(),
+                postalCode: z.optional(z.string()),
+              })
+            )
+          ])
+        ), {
+        fallbacks: {
+          string: 0,
+        },
+      })
+    ).toEqualTypeOf<
+      Array<[
+        Map<
+          {
+            firstName: number
+            lastName: number
+            age: undefined
+          },
+          {
+            street1: number
+            street2?: number
+            city: number
+            postalCode?: number
+          }
+        >
+      ]>
+    >()
+  })
 })

-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +"@traversable/zod": patch
 +---
++
 +fix(zod): fixes return type for `zx.defaultValue`