@kubb/plugin-zod 5.0.0-alpha.23 → 5.0.0-alpha.25

package/src/parser.ts

@@ -1,952 +0,0 @@
-import { stringify, toRegExpString } from '@internals/utils'
-import type { Schema, SchemaMapper } from '@kubb/plugin-oas'
-import { createParser, findSchemaKeyword, isKeyword, SchemaGenerator, type SchemaKeywordMapper, schemaKeywords } from '@kubb/plugin-oas'
-import { sortBy } from 'remeda'
-
-//TODO add zodKeywordMapper as function that returns 3 versions: v3, v4 and v4 mini, this can also be used to have the custom mapping(see object type)
-// also include shouldCoerce
-
-/**
- * Helper to build string/array length constraint checks for Zod Mini mode
- */
-function buildLengthChecks(min?: number, max?: number): string[] {
-  const checks: string[] = []
-  if (min !== undefined) checks.push(`z.minLength(${min})`)
-  if (max !== undefined) checks.push(`z.maxLength(${max})`)
-  return checks
-}
-
-const zodKeywordMapper = {
-  any: () => 'z.any()',
-  unknown: () => 'z.unknown()',
-  void: () => 'z.void()',
-  number: (coercion?: boolean, min?: number, max?: number, exclusiveMinimum?: number, exclusiveMaximum?: number, mini?: boolean) => {
-    if (mini) {
-      const checks: string[] = []
-      if (min !== undefined) checks.push(`z.minimum(${min})`)
-      if (max !== undefined) checks.push(`z.maximum(${max})`)
-      if (exclusiveMinimum !== undefined) checks.push(`z.minimum(${exclusiveMinimum}, { exclusive: true })`)
-      if (exclusiveMaximum !== undefined) checks.push(`z.maximum(${exclusiveMaximum}, { exclusive: true })`)
-      if (checks.length > 0) {
-        return `z.number().check(${checks.join(', ')})`
-      }
-      return 'z.number()'
-    }
-    return [
-      coercion ? 'z.coerce.number()' : 'z.number()',
-      min !== undefined ? `.min(${min})` : undefined,
-      max !== undefined ? `.max(${max})` : undefined,
-      exclusiveMinimum !== undefined ? `.gt(${exclusiveMinimum})` : undefined,
-      exclusiveMaximum !== undefined ? `.lt(${exclusiveMaximum})` : undefined,
-    ]
-      .filter(Boolean)
-      .join('')
-  },
-  integer: (coercion?: boolean, min?: number, max?: number, version: '3' | '4' = '3', exclusiveMinimum?: number, exclusiveMaximum?: number, mini?: boolean) => {
-    if (mini) {
-      const checks: string[] = []
-      if (min !== undefined) checks.push(`z.minimum(${min})`)
-      if (max !== undefined) checks.push(`z.maximum(${max})`)
-      if (exclusiveMinimum !== undefined) checks.push(`z.minimum(${exclusiveMinimum}, { exclusive: true })`)
-      if (exclusiveMaximum !== undefined) checks.push(`z.maximum(${exclusiveMaximum}, { exclusive: true })`)
-      if (checks.length > 0) {
-        return `z.int().check(${checks.join(', ')})`
-      }
-      return 'z.int()'
-    }
-    return [
-      coercion ? 'z.coerce.number().int()' : version === '4' ? 'z.int()' : 'z.number().int()',
-      min !== undefined ? `.min(${min})` : undefined,
-      max !== undefined ? `.max(${max})` : undefined,
-      exclusiveMinimum !== undefined ? `.gt(${exclusiveMinimum})` : undefined,
-      exclusiveMaximum !== undefined ? `.lt(${exclusiveMaximum})` : undefined,
-    ]
-      .filter(Boolean)
-      .join('')
-  },
-  bigint: (coercion?: boolean) => (coercion ? 'z.coerce.bigint()' : 'z.bigint()'),
-  interface: (value?: string, strict?: boolean) => {
-    if (strict) {
-      return `z.strictInterface({
-    ${value}
-    })`
-    }
-    return `z.interface({
-    ${value}
-    })`
-  },
-  object: (value?: string, strict?: boolean, version: '3' | '4' = '3') => {
-    if (version === '4' && strict) {
-      return `z.strictObject({
-    ${value}
-    })`
-    }
-
-    if (strict) {
-      return `z.object({
-    ${value}
-    }).strict()`
-    }
-
-    return `z.object({
-    ${value}
-    })`
-  },
-  string: (coercion?: boolean, min?: number, max?: number, mini?: boolean) => {
-    if (mini) {
-      const checks = buildLengthChecks(min, max)
-      if (checks.length > 0) {
-        return `z.string().check(${checks.join(', ')})`
-      }
-      return 'z.string()'
-    }
-    return [coercion ? 'z.coerce.string()' : 'z.string()', min !== undefined ? `.min(${min})` : undefined, max !== undefined ? `.max(${max})` : undefined]
-      .filter(Boolean)
-      .join('')
-  },
-  //support for discriminatedUnion
-  boolean: () => 'z.boolean()',
-  undefined: () => 'z.undefined()',
-  nullable: (value?: string) => {
-    if (value) {
-      return `z.nullable(${value})`
-    }
-    return '.nullable()'
-  },
-  null: () => 'z.null()',
-  nullish: (value?: string) => {
-    if (value) {
-      return `z.nullish(${value})`
-    }
-    return '.nullish()'
-  },
-  array: (items: string[] = [], min?: number, max?: number, unique?: boolean, mini?: boolean) => {
-    if (mini) {
-      const checks = buildLengthChecks(min, max)
-      if (unique) checks.push(`z.refine(items => new Set(items).size === items.length, { message: "Array entries must be unique" })`)
-      if (checks.length > 0) {
-        return `z.array(${items?.join('')}).check(${checks.join(', ')})`
-      }
-      return `z.array(${items?.join('')})`
-    }
-    return [
-      `z.array(${items?.join('')})`,
-      min !== undefined ? `.min(${min})` : undefined,
-      max !== undefined ? `.max(${max})` : undefined,
-      unique ? `.refine(items => new Set(items).size === items.length, { message: "Array entries must be unique" })` : undefined,
-    ]
-      .filter(Boolean)
-      .join('')
-  },
-  tuple: (items: string[] = []) => `z.tuple([${items?.join(', ')}])`,
-  enum: (items: string[] = []) => `z.enum([${items?.join(', ')}])`,
-  union: (items: string[] = []) => `z.union([${items?.join(', ')}])`,
-  const: (value?: string | number | boolean) => `z.literal(${value ?? ''})`,
-  /**
-   * ISO 8601
-   */
-  datetime: (offset = false, local = false, version: '3' | '4' = '3', mini?: boolean) => {
-    // Zod Mini doesn't support .datetime() method, use plain string
-    if (mini) {
-      return 'z.string()'
-    }
-
-    if (offset) {
-      return version === '4' ? `z.iso.datetime({ offset: ${offset} })` : `z.string().datetime({ offset: ${offset} })`
-    }
-
-    if (local) {
-      return version === '4' ? `z.iso.datetime({ local: ${local} })` : `z.string().datetime({ local: ${local} })`
-    }
-
-    return version === '4' ? 'z.iso.datetime()' : 'z.string().datetime()'
-  },
-  /**
-   * Type `'date'` Date
-   * Type `'string'` ISO date format (YYYY-MM-DD)
-   * @default ISO date format (YYYY-MM-DD)
-   */
-  date: (type: 'date' | 'string' = 'string', coercion?: boolean, version: '3' | '4' = '3') => {
-    if (type === 'string') {
-      return version === '4' ? 'z.iso.date()' : 'z.string().date()'
-    }
-
-    if (coercion) {
-      return 'z.coerce.date()'
-    }
-
-    return 'z.date()'
-  },
-  /**
-   * Type `'date'` Date
-   * Type `'string'` ISO time format (HH:mm:ss[.SSSSSS])
-   * @default ISO time format (HH:mm:ss[.SSSSSS])
-   */
-  time: (type: 'date' | 'string' = 'string', coercion?: boolean, version: '3' | '4' = '3') => {
-    if (type === 'string') {
-      return version === '4' ? 'z.iso.time()' : 'z.string().time()'
-    }
-
-    if (coercion) {
-      return 'z.coerce.date()'
-    }
-
-    return 'z.date()'
-  },
-  uuid: ({
-    coercion,
-    version = '3',
-    guidType = 'uuid',
-    min,
-    max,
-    mini,
-  }: {
-    coercion?: boolean
-    version?: '3' | '4'
-    guidType?: 'uuid' | 'guid'
-    min?: number
-    max?: number
-    mini?: boolean
-  } = {}) => {
-    const zodGuidType = version === '4' && guidType === 'guid' ? 'guid' : 'uuid'
-
-    if (mini) {
-      const checks = buildLengthChecks(min, max)
-      if (checks.length > 0) {
-        return `z.${zodGuidType}().check(${checks.join(', ')})`
-      }
-      return `z.${zodGuidType}()`
-    }
-
-    const zodV4UuidSchema = `z.${zodGuidType}()`
-
-    return [
-      coercion ? (version === '4' ? zodV4UuidSchema : 'z.coerce.string().uuid()') : version === '4' ? zodV4UuidSchema : 'z.string().uuid()',
-      min !== undefined ? `.min(${min})` : undefined,
-      max !== undefined ? `.max(${max})` : undefined,
-    ]
-      .filter(Boolean)
-      .join('')
-  },
-  url: (coercion?: boolean, version: '3' | '4' = '3', min?: number, max?: number, mini?: boolean) => {
-    if (mini) {
-      const checks = buildLengthChecks(min, max)
-      if (checks.length > 0) {
-        return `z.url().check(${checks.join(', ')})`
-      }
-      return 'z.url()'
-    }
-    return [
-      coercion ? (version === '4' ? 'z.url()' : 'z.coerce.string().url()') : version === '4' ? 'z.url()' : 'z.string().url()',
-      min !== undefined ? `.min(${min})` : undefined,
-      max !== undefined ? `.max(${max})` : undefined,
-    ]
-      .filter(Boolean)
-      .join('')
-  },
-  default: (value?: string | number | boolean | object, innerSchema?: string, mini?: boolean, isBigInt?: boolean) => {
-    if (mini && innerSchema) {
-      // Wrap numeric values in BigInt() for bigint types in mini mode
-      const defaultValue = isBigInt && typeof value === 'number' ? `BigInt(${value})` : typeof value === 'object' ? '{}' : (value ?? '')
-      return `z._default(${innerSchema}, ${defaultValue})`
-    }
-
-    if (typeof value === 'object') {
-      return '.default({})'
-    }
-
-    if (value === undefined) {
-      return '.default()'
-    }
-
-    if (typeof value === 'string' && !value) {
-      return `.default('')`
-    }
-
-    // Wrap numeric values in BigInt() for bigint types
-    if (isBigInt && typeof value === 'number') {
-      return `.default(BigInt(${value}))`
-    }
-
-    return `.default(${value ?? ''})`
-  },
-  and: (items: string[] = [], mini?: boolean) => {
-    // zod/mini doesn't support .and() method, so we can't use intersection types
-    // In mini mode, we try to extract and append .check() calls instead
-    if (mini && items.length > 0) {
-      // Try to extract check calls from additional items
-      const checks: string[] = []
-      for (const item of items) {
-        // Extract .check(...) from patterns like "z.string().check(...)"
-        // Need to handle nested parentheses properly
-        const checkStart = item.indexOf('.check(')
-        if (checkStart !== -1) {
-          // Find the matching closing parenthesis
-          let depth = 0
-          let i = checkStart + 7 // length of '.check('
-          let checkContent = ''
-          while (i < item.length) {
-            const char = item[i]
-            if (char === '(') depth++
-            else if (char === ')') {
-              if (depth === 0) break
-              depth--
-            }
-            checkContent += char
-            i++
-          }
-          if (checkContent) {
-            checks.push(checkContent)
-          }
-        }
-      }
-
-      if (checks.length > 0) {
-        // Append checks to the base schema
-        return `.check(${checks.join(', ')})`
-      }
-
-      // If we can't extract checks, just use the first schema (limitation)
-      return ''
-    }
-    return items?.map((item) => `.and(${item})`).join('')
-  },
-  describe: (value = '', innerSchema?: string, mini?: boolean) => {
-    if (mini) {
-      return undefined
-    }
-
-    if (innerSchema) {
-      return `z.describe(${innerSchema}, ${value})`
-    }
-    return `.describe(${value})`
-  },
-  max: undefined,
-  min: undefined,
-  optional: (value?: string) => {
-    if (value) {
-      return `z.optional(${value})`
-    }
-    return '.optional()'
-  },
-  matches: (value = '', coercion?: boolean, mini?: boolean, min?: number, max?: number) => {
-    if (mini) {
-      const checks = buildLengthChecks(min, max)
-      checks.push(`z.regex(${value})`)
-      return `z.string().check(${checks.join(', ')})`
-    }
-    return [
-      coercion ? 'z.coerce.string()' : 'z.string()',
-      min !== undefined ? `.min(${min})` : undefined,
-      max !== undefined ? `.max(${max})` : undefined,
-      `.regex(${value})`,
-    ]
-      .filter(Boolean)
-      .join('')
-  },
-  email: (coercion?: boolean, version: '3' | '4' = '3', min?: number, max?: number, mini?: boolean) => {
-    if (mini) {
-      const checks = buildLengthChecks(min, max)
-      if (checks.length > 0) {
-        return `z.email().check(${checks.join(', ')})`
-      }
-      return 'z.email()'
-    }
-    return [
-      coercion ? (version === '4' ? 'z.email()' : 'z.coerce.string().email()') : version === '4' ? 'z.email()' : 'z.string().email()',
-      min !== undefined ? `.min(${min})` : undefined,
-      max !== undefined ? `.max(${max})` : undefined,
-    ]
-      .filter(Boolean)
-      .join('')
-  },
-  firstName: undefined,
-  lastName: undefined,
-  password: undefined,
-  phone: undefined,
-  readOnly: undefined,
-  writeOnly: undefined,
-  ref: (value?: string) => {
-    if (!value) {
-      return undefined
-    }
-
-    return `z.lazy(() => ${value})`
-  },
-  blob: () => 'z.instanceof(File)',
-  deprecated: undefined,
-  example: undefined,
-  schema: undefined,
-  catchall: (value?: string, mini?: boolean) => {
-    // Zod Mini doesn't support .catchall() method
-    if (mini) {
-      return undefined
-    }
-    return value ? `.catchall(${value})` : undefined
-  },
-  name: undefined,
-  exclusiveMinimum: undefined,
-  exclusiveMaximum: undefined,
-} satisfies SchemaMapper<string | null | undefined>
-
-/**
- * @link based on https://github.com/cellular/oazapfts/blob/7ba226ebb15374e8483cc53e7532f1663179a22c/src/codegen/generate.ts#L398
- */
-
-export function sort(items?: Schema[]): Schema[] {
-  const order: string[] = [
-    schemaKeywords.string,
-    schemaKeywords.datetime,
-    schemaKeywords.date,
-    schemaKeywords.time,
-    schemaKeywords.tuple,
-    schemaKeywords.number,
-    schemaKeywords.object,
-    schemaKeywords.enum,
-    schemaKeywords.url,
-    schemaKeywords.email,
-    schemaKeywords.firstName,
-    schemaKeywords.lastName,
-    schemaKeywords.password,
-    schemaKeywords.matches,
-    schemaKeywords.uuid,
-    schemaKeywords.null,
-    schemaKeywords.min,
-    schemaKeywords.max,
-    schemaKeywords.default,
-    schemaKeywords.describe,
-    schemaKeywords.optional,
-    schemaKeywords.nullable,
-    schemaKeywords.nullish,
-  ]
-
-  if (!items) {
-    return []
-  }
-
-  return sortBy(items, [(v) => order.indexOf(v.keyword), 'asc'])
-}
-
-type MiniModifiers = {
-  hasOptional?: boolean
-  hasNullable?: boolean
-  hasNullish?: boolean
-  defaultValue?: string | number | true | object
-  isBigInt?: boolean
-}
-
-/**
- * Keywords that represent modifiers for mini mode
- * These are separated from the base schema and wrapped around it
- * Note: describe is included to filter it out, but won't be wrapped (Zod Mini doesn't support describe)
- */
-export const miniModifierKeywords = [schemaKeywords.optional, schemaKeywords.nullable, schemaKeywords.nullish, schemaKeywords.default, schemaKeywords.describe]
-
-/**
- * Extracts mini mode modifiers from a schemas array
- * This can be reused by other parsers (e.g., valibot) that need similar functionality
- * Note: describe is not included as Zod Mini doesn't support it
- */
-export function extractMiniModifiers(schemas: Schema[]): MiniModifiers {
-  const defaultSchema = schemas.find((item) => isKeyword(item, schemaKeywords.default)) as { keyword: string; args: unknown } | undefined
-  const isBigInt = schemas.some((item) => isKeyword(item, schemaKeywords.bigint))
-
-  // When paired with an enum, skip the default if the value is not a valid enum member.
-  // String default args are JSON-stringified (e.g. '"available"'), so parse them back
-  // to the raw value before comparing against enum item values.
-  let defaultValue = defaultSchema?.args as string | number | true | object | undefined
-  if (defaultValue !== undefined) {
-    const enumSchema = schemas.find((it) => isKeyword(it, schemaKeywords.enum)) as SchemaKeywordMapper['enum'] | undefined
-    if (enumSchema) {
-      let rawDefault: unknown = defaultValue
-      if (typeof rawDefault === 'string') {
-        try {
-          rawDefault = JSON.parse(rawDefault)
-        } catch {
-          // leave as-is if not valid JSON
-        }
-      }
-      const validValues = enumSchema.args.items.map((item) => item.value ?? item.name)
-      if (!validValues.includes(rawDefault as string | number | boolean)) {
-        defaultValue = undefined
-      }
-    }
-  }
-
-  return {
-    hasOptional: schemas.some((item) => isKeyword(item, schemaKeywords.optional)),
-    hasNullable: schemas.some((item) => isKeyword(item, schemaKeywords.nullable)),
-    hasNullish: schemas.some((item) => isKeyword(item, schemaKeywords.nullish)),
-    defaultValue,
-    isBigInt,
-  }
-}
-
-/**
- * Filters out modifier keywords from schemas for mini mode base schema parsing
- * This can be reused by other parsers (e.g., valibot) that need similar functionality
- */
-export function filterMiniModifiers(schemas: Schema[]): Schema[] {
-  return schemas.filter((item) => !miniModifierKeywords.some((keyword) => isKeyword(item, keyword)))
-}
-
-/**
- * Wraps an output string with Zod Mini functional modifiers
- * Order: default (innermost) -> nullable -> optional (outermost)
- * OR: default -> nullish
- * Note: describe is not supported in Zod Mini and is skipped
- */
-export function wrapWithMiniModifiers(output: string, modifiers: MiniModifiers): string {
-  let result = output
-
-  // Apply default first (innermost wrapper)
-  if (modifiers.defaultValue !== undefined) {
-    result = zodKeywordMapper.default(modifiers.defaultValue, result, true, modifiers.isBigInt)!
-  }
-
-  // Apply nullish, nullable, or optional (outer wrappers for optionality)
-  if (modifiers.hasNullish) {
-    result = zodKeywordMapper.nullish(result)!
-  } else {
-    if (modifiers.hasNullable) {
-      result = zodKeywordMapper.nullable(result)!
-    }
-    if (modifiers.hasOptional) {
-      result = zodKeywordMapper.optional(result)!
-    }
-  }
-
-  return result
-}
-
-const shouldCoerce = (coercion: ParserOptions['coercion'] | undefined, type: 'dates' | 'strings' | 'numbers'): boolean => {
-  if (coercion === undefined) {
-    return false
-  }
-  if (typeof coercion === 'boolean') {
-    return coercion
-  }
-
-  return !!coercion[type]
-}
-
-type ParserOptions = {
-  mapper?: Record<string, string>
-  coercion?: boolean | { dates?: boolean; strings?: boolean; numbers?: boolean }
-  wrapOutput?: (opts: { output: string; schema: any }) => string | undefined
-  version: '3' | '4'
-  guidType?: 'uuid' | 'guid'
-  skipLazyForRefs?: boolean
-  mini?: boolean
-}
-
-// Create the parser using createParser
-export const parse = createParser<string, ParserOptions>({
-  mapper: zodKeywordMapper,
-  handlers: {
-    union(tree, options) {
-      const { current, schema, parent, name, siblings } = tree
-
-      // zod union type needs at least 2 items
-      if (Array.isArray(current.args) && current.args.length === 1) {
-        return this.parse({ schema, parent, name, current: current.args[0] as Schema, siblings }, options)
-      }
-      if (Array.isArray(current.args) && !current.args.length) {
-        return ''
-      }
-
-      return zodKeywordMapper.union(
-        sort(current.args)
-          .map((it, _index, siblings) => this.parse({ schema, parent: current, name, current: it, siblings }, options))
-          .filter(Boolean),
-      )
-    },
-    and(tree, options) {
-      const { current, schema, name } = tree
-
-      const items = sort(current.args)
-        .filter((schema: Schema) => {
-          return ![schemaKeywords.optional, schemaKeywords.describe].includes(schema.keyword as typeof schemaKeywords.describe)
-        })
-        .map((it: Schema, _index, siblings) => this.parse({ schema, parent: current, name, current: it, siblings }, options))
-        .filter(Boolean)
-
-      return `${items.slice(0, 1)}${zodKeywordMapper.and(items.slice(1), options.mini)}`
-    },
-    array(tree, options) {
-      const { current, schema, name } = tree
-
-      return zodKeywordMapper.array(
-        sort(current.args.items)
-          .map((it, _index, siblings) => {
-            return this.parse({ schema, parent: current, name, current: it, siblings }, options)
-          })
-          .filter(Boolean),
-        current.args.min,
-        current.args.max,
-        current.args.unique,
-        options.mini,
-      )
-    },
-    enum(tree, options) {
-      const { current, schema, name } = tree
-
-      if (current.args.asConst) {
-        if (current.args.items.length === 1) {
-          const child = {
-            keyword: schemaKeywords.const,
-            args: current.args.items[0],
-          }
-          return this.parse({ schema, parent: current, name, current: child, siblings: [child] }, options)
-        }
-
-        return zodKeywordMapper.union(
-          current.args.items
-            .map((schema) => ({
-              keyword: schemaKeywords.const,
-              args: schema,
-            }))
-            .map((it, _index, siblings) => {
-              return this.parse({ schema, parent: current, name, current: it, siblings }, options)
-            })
-            .filter(Boolean),
-        )
-      }
-
-      return zodKeywordMapper.enum(
-        current.args.items.map((schema) => {
-          if (schema.format === 'boolean') {
-            return stringify(schema.value)
-          }
-
-          if (schema.format === 'number') {
-            return stringify(schema.value)
-          }
-          return stringify(schema.value)
-        }),
-      )
-    },
-    ref(tree, options) {
-      const { current } = tree
-
-      // Skip z.lazy wrapper if skipLazyForRefs is true (e.g., inside v4 getters)
-      if (options.skipLazyForRefs) {
-        return current.args?.name
-      }
-      return zodKeywordMapper.ref(current.args?.name)
-    },
-    object(tree, options) {
-      const { current, schema, name } = tree
-
-      const propertyEntries = Object.entries(current.args?.properties || {}).filter((item) => {
-        const schema = item[1]
-        return schema && typeof schema.map === 'function'
-      })
-
-      const properties = propertyEntries
-        .map(([propertyName, schemas]) => {
-          const nameSchema = schemas.find((it) => it.keyword === schemaKeywords.name) as SchemaKeywordMapper['name']
-          const isNullable = schemas.some((it) => isKeyword(it, schemaKeywords.nullable))
-          const isNullish = schemas.some((it) => isKeyword(it, schemaKeywords.nullish))
-          const isOptional = schemas.some((it) => isKeyword(it, schemaKeywords.optional))
-          const hasRef = !!SchemaGenerator.find(schemas, schemaKeywords.ref)
-
-          const mappedName = nameSchema?.args || propertyName
-
-          // custom mapper(pluginOptions)
-          // Use Object.hasOwn to avoid matching inherited properties like 'toString', 'valueOf', etc.
-          if (options.mapper && Object.hasOwn(options.mapper, mappedName)) {
-            return `"${propertyName}": ${options.mapper?.[mappedName]}`
-          }
-
-          const baseSchemaOutput = sort(schemas)
-            .filter((schema) => {
-              return !isKeyword(schema, schemaKeywords.optional) && !isKeyword(schema, schemaKeywords.nullable) && !isKeyword(schema, schemaKeywords.nullish)
-            })
-            .map((it) => {
-              // For v4 with refs, skip z.lazy wrapper since the getter provides lazy evaluation
-              const skipLazyForRefs = options.version === '4' && hasRef
-              return this.parse({ schema, parent: current, name, current: it, siblings: schemas }, { ...options, skipLazyForRefs })
-            })
-            .filter(Boolean)
-            .join('')
-
-          const objectValue = options.wrapOutput
-            ? options.wrapOutput({ output: baseSchemaOutput, schema: schema?.properties?.[propertyName] }) || baseSchemaOutput
-            : baseSchemaOutput
-
-          if (options.version === '4' && hasRef) {
-            // In mini mode, use functional wrappers instead of chainable methods
-            if (options.mini) {
-              // both optional and nullable
-              if (isNullish) {
-                return `get "${propertyName}"(){
-                return ${zodKeywordMapper.nullish(objectValue)}
-              }`
-              }
-
-              // undefined
-              if (isOptional) {
-                return `get "${propertyName}"(){
-                return ${zodKeywordMapper.optional(objectValue)}
-              }`
-              }
-
-              // null
-              if (isNullable) {
-                return `get "${propertyName}"(){
-                return ${zodKeywordMapper.nullable(objectValue)}
-              }`
-              }
-
-              return `get "${propertyName}"(){
-                return ${objectValue}
-              }`
-            }
-
-            // Non-mini mode uses chainable methods
-            // both optional and nullable
-            if (isNullish) {
-              return `get "${propertyName}"(){
-                return ${objectValue}${zodKeywordMapper.nullish()}
-              }`
-            }
-
-            // undefined
-            if (isOptional) {
-              return `get "${propertyName}"(){
-                return ${objectValue}${zodKeywordMapper.optional()}
-              }`
-            }
-
-            // null
-            if (isNullable) {
-              return `get "${propertyName}"(){
-               return ${objectValue}${zodKeywordMapper.nullable()}
-              }`
-            }
-
-            return `get "${propertyName}"(){
-                return ${objectValue}
-              }`
-          }
-
-          // both optional and nullable
-          if (isNullish && options.mini) {
-            return `"${propertyName}": ${zodKeywordMapper.nullish(objectValue)}`
-          }
-
-          if (isNullish && !options.mini) {
-            return `"${propertyName}": ${objectValue}${zodKeywordMapper.nullish()}`
-          }
-
-          // undefined
-          if (isOptional) {
-            return `"${propertyName}": ${zodKeywordMapper.optional(objectValue)}`
-          }
-
-          // null
-          if (isNullable) {
-            return `"${propertyName}": ${zodKeywordMapper.nullable(objectValue)}`
-          }
-
-          return `"${propertyName}": ${objectValue}`
-        })
-        .join(',\n')
-
-      const additionalProperties = current.args?.additionalProperties?.length
-        ? current.args.additionalProperties
-            .map((it, _index, siblings) => this.parse({ schema, parent: current, name, current: it, siblings }, options))
-            .filter(Boolean)
-            .join('')
-        : undefined
-
-      const text = [
-        zodKeywordMapper.object(properties, current.args?.strict, options.version),
-        additionalProperties ? zodKeywordMapper.catchall(additionalProperties, options.mini) : undefined,
-      ].filter(Boolean)
-
-      return text.join('')
-    },
-    tuple(tree, options) {
-      const { current, schema, name } = tree
-
-      return zodKeywordMapper.tuple(
-        current.args.items.map((it, _index, siblings) => this.parse({ schema, parent: current, name, current: it, siblings }, options)).filter(Boolean),
-      )
-    },
-    const(tree, _options) {
-      const { current } = tree
-
-      if (current.args.format === 'number' && current.args.value !== undefined) {
-        return zodKeywordMapper.const(Number(current.args.value))
-      }
-
-      if (current.args.format === 'boolean' && current.args.value !== undefined) {
-        return zodKeywordMapper.const(typeof current.args.value === 'boolean' ? current.args.value : undefined)
-      }
-      return zodKeywordMapper.const(stringify(current.args.value))
-    },
-    matches(tree, options) {
-      const { current, siblings } = tree
-
-      // Early exit: if siblings contain both matches and ref → skip matches entirely
-      const hasRef = siblings.some((it) => isKeyword(it, schemaKeywords.ref))
-      if (hasRef) {
-        return undefined // strip matches
-      }
-
-      const minSchema = findSchemaKeyword(siblings, 'min')
-      const maxSchema = findSchemaKeyword(siblings, 'max')
-
-      if (current.args) {
-        return zodKeywordMapper.matches(
-          toRegExpString(current.args, null),
-          shouldCoerce(options.coercion, 'strings'),
-          options.mini,
-          minSchema?.args,
-          maxSchema?.args,
-        )
-      }
-      return undefined
-    },
-    default(tree, options) {
-      const { current, siblings } = tree
-
-      // In mini mode, default is handled by wrapWithMiniModifiers
-      if (options.mini) {
-        return undefined
-      }
-
-      // Check if this is a bigint type by looking at siblings
-      const isBigInt = siblings.some((it) => isKeyword(it, schemaKeywords.bigint))
-
-      // When a default is paired with an enum, skip the default if the value
-      // is not one of the enum's valid values (e.g. an empty string "").
-      // Zod's .default() for an enum must receive a value that is in the enum.
-      if (current.args !== undefined) {
-        const enumSchema = siblings.find((it) => isKeyword(it, schemaKeywords.enum)) as SchemaKeywordMapper['enum'] | undefined
-        if (enumSchema) {
-          // String default args are JSON-stringified (e.g. '"available"'), so parse
-          // them back to the raw value before comparing against enum item values.
-          let rawDefault: unknown = current.args
-          if (typeof rawDefault === 'string') {
-            try {
-              rawDefault = JSON.parse(rawDefault)
-            } catch {
-              // leave as-is if not valid JSON
-            }
-          }
-          const validValues = enumSchema.args.items.map((item) => item.value ?? item.name)
-          if (!validValues.includes(rawDefault as string | number | boolean)) {
-            return undefined
-          }
-        }
-
-        return zodKeywordMapper.default(current.args, undefined, undefined, isBigInt)
-      }
-      // When args is undefined, call the mapper without arguments
-      return zodKeywordMapper.default()
-    },
-    describe(tree, options) {
-      const { current } = tree
-
-      if (current.args) {
-        return zodKeywordMapper.describe(stringify(current.args.toString()), undefined, options.mini)
-      }
-      return undefined
-    },
-    string(tree, options) {
-      const { siblings } = tree
-
-      const minSchema = findSchemaKeyword(siblings, 'min')
-      const maxSchema = findSchemaKeyword(siblings, 'max')
-
-      return zodKeywordMapper.string(shouldCoerce(options.coercion, 'strings'), minSchema?.args, maxSchema?.args, options.mini)
-    },
-    uuid(tree, options) {
-      const { siblings } = tree
-
-      const minSchema = findSchemaKeyword(siblings, 'min')
-      const maxSchema = findSchemaKeyword(siblings, 'max')
-
-      return zodKeywordMapper.uuid({
-        coercion: shouldCoerce(options.coercion, 'strings'),
-        version: options.version,
-        guidType: options.guidType,
-        min: minSchema?.args,
-        max: maxSchema?.args,
-        mini: options.mini,
-      })
-    },
-    email(tree, options) {
-      const { siblings } = tree
-
-      const minSchema = findSchemaKeyword(siblings, 'min')
-      const maxSchema = findSchemaKeyword(siblings, 'max')
-
-      return zodKeywordMapper.email(shouldCoerce(options.coercion, 'strings'), options.version, minSchema?.args, maxSchema?.args, options.mini)
-    },
-    url(tree, options) {
-      const { siblings } = tree
-
-      const minSchema = findSchemaKeyword(siblings, 'min')
-      const maxSchema = findSchemaKeyword(siblings, 'max')
-
-      return zodKeywordMapper.url(shouldCoerce(options.coercion, 'strings'), options.version, minSchema?.args, maxSchema?.args, options.mini)
-    },
-    number(tree, options) {
-      const { siblings } = tree
-
-      const minSchema = findSchemaKeyword(siblings, 'min')
-      const maxSchema = findSchemaKeyword(siblings, 'max')
-      const exclusiveMinimumSchema = findSchemaKeyword(siblings, 'exclusiveMinimum')
-      const exclusiveMaximumSchema = findSchemaKeyword(siblings, 'exclusiveMaximum')
-
-      return zodKeywordMapper.number(
-        shouldCoerce(options.coercion, 'numbers'),
-        minSchema?.args,
-        maxSchema?.args,
-        exclusiveMinimumSchema?.args,
-        exclusiveMaximumSchema?.args,
-        options.mini,
-      )
-    },
-    integer(tree, options) {
-      const { siblings } = tree
-
-      const minSchema = findSchemaKeyword(siblings, 'min')
-      const maxSchema = findSchemaKeyword(siblings, 'max')
-      const exclusiveMinimumSchema = findSchemaKeyword(siblings, 'exclusiveMinimum')
-      const exclusiveMaximumSchema = findSchemaKeyword(siblings, 'exclusiveMaximum')
-
-      return zodKeywordMapper.integer(
-        shouldCoerce(options.coercion, 'numbers'),
-        minSchema?.args,
-        maxSchema?.args,
-        options.version,
-        exclusiveMinimumSchema?.args,
-        exclusiveMaximumSchema?.args,
-        options.mini,
-      )
-    },
-    bigint(_tree, options) {
-      return zodKeywordMapper.bigint(shouldCoerce(options.coercion, 'numbers'))
-    },
-    datetime(tree, options) {
-      const { current } = tree
-
-      return zodKeywordMapper.datetime(current.args.offset, current.args.local, options.version, options.mini)
-    },
-    date(tree, options) {
-      const { current } = tree
-
-      return zodKeywordMapper.date(current.args.type, shouldCoerce(options.coercion, 'dates'), options.version)
-    },
-    time(tree, options) {
-      const { current } = tree
-
-      return zodKeywordMapper.time(current.args.type, shouldCoerce(options.coercion, 'dates'), options.version)
-    },
-  },
-})