@zod-utils/core 0.1.0 → 0.4.0

package/dist/index.d.ts

@@ -1,79 +1,401 @@
 import * as z from 'zod';
 
 /**
- * Get the primitive type of a Zod field by unwrapping optional/nullable wrappers
- * @param field - The Zod field to unwrap
- * @param options - Options for unwrapping
- * @param options.unwrapArrays - If true, continues unwrapping arrays. If false (default), stops at arrays
- * @returns The unwrapped primitive type
- */
-declare const getPrimitiveType: <T extends z.ZodTypeAny>(field: T, options?: {
-    unwrapArrays?: boolean;
-}) => z.ZodTypeAny;
-/**
- * Remove default values from a Zod field
- * @param field - The Zod field to remove defaults from
- * @returns The field without defaults
- */
-declare function removeDefault(field: z.ZodType): z.ZodType;
-/**
- * Check if a Zod field is required (not optional/nullable and doesn't accept empty values)
- * @param field - The Zod field to check
- * @returns True if the field is required
+ * Simplifies complex TypeScript types for better IDE hover tooltips and error messages.
+ *
+ * This utility type flattens intersections and complex type expressions into a single,
+ * readable object type. This is especially useful when working with mapped types,
+ * conditional types, or type intersections that produce hard-to-read IDE hints.
+ *
+ * @template T - The type to simplify
+ *
+ * @example
+ * Simplifying intersection types
+ * ```typescript
+ * type A = { name: string };
+ * type B = { age: number };
+ * type C = A & B; // Shows as "A & B" in IDE
+ * type D = Simplify<A & B>; // Shows as "{ name: string; age: number }" in IDE
+ * ```
+ *
+ * @example
+ * Simplifying Partial<> results
+ * ```typescript
+ * type User = { name: string; age: number; email: string };
+ * type PartialUser = Partial<User>; // Shows as "Partial<User>" in IDE
+ * type SimplifiedPartialUser = Simplify<Partial<User>>;
+ * // Shows as "{ name?: string; age?: number; email?: string }" in IDE
+ * ```
+ *
+ * @example
+ * Usage with zod schema inference
+ * ```typescript
+ * const schema = z.object({ id: z.string() })
+ *   .merge(z.object({ name: z.string() }));
+ *
+ * type InferredType = z.infer<typeof schema>; // May show complex type
+ * type SimplifiedType = Simplify<z.infer<typeof schema>>;
+ * // Shows clear: { id: string; name: string }
+ * ```
+ *
+ * @since 0.1.0
  */
-declare const checkIfFieldIsRequired: <T extends z.ZodTypeAny>(field: T) => boolean;
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
 
 /**
- * Extract the default value from a Zod field (recursively unwraps optional/nullable)
+ * Extracts the default value from a Zod field, recursively unwrapping optional and nullable layers.
+ *
+ * This function traverses through wrapper types (like `ZodOptional`, `ZodNullable`) to find
+ * the underlying `ZodDefault` and returns its default value. If no default is found, returns `undefined`.
+ *
+ * @template T - The Zod type to extract default from
  * @param field - The Zod field to extract default from
  * @returns The default value if present, undefined otherwise
+ *
+ * @example
+ * Basic usage with default value
+ * ```typescript
+ * const field = z.string().default('hello');
+ * const defaultValue = extractDefault(field);
+ * // Result: 'hello'
+ * ```
+ *
+ * @example
+ * Unwrapping optional/nullable layers
+ * ```typescript
+ * const field = z.string().default('world').optional();
+ * const defaultValue = extractDefault(field);
+ * // Result: 'world' (unwraps optional to find default)
+ * ```
+ *
+ * @example
+ * Field without default
+ * ```typescript
+ * const field = z.string().optional();
+ * const defaultValue = extractDefault(field);
+ * // Result: undefined
+ * ```
+ *
+ * @see {@link getSchemaDefaults} for extracting defaults from entire schemas
+ * @since 0.1.0
  */
-declare function extractDefault(field: z.ZodTypeAny): any;
-/**
- * Get the unwrapped type without going through defaults
- * Useful for detecting nested objects/arrays while preserving defaults
- * @param field - The Zod field to unwrap
- * @returns The unwrapped type
- */
-declare function getUnwrappedType(field: z.ZodTypeAny): z.ZodTypeAny;
+declare function extractDefault<T extends z.ZodTypeAny>(field: T): z.infer<T> | undefined;
 /**
- * Extract all default values from a Zod object schema
- * Recursively handles nested objects and only returns fields with defaults
+ * Extracts default values from a Zod object schema while skipping fields without defaults.
+ *
+ * This function recursively traverses the schema and collects all fields that have
+ * explicit default values defined. Fields without defaults are excluded from the result.
+ *
+ * **Important:** Nested defaults are NOT extracted unless the parent object also has
+ * an explicit `.default()`. This is by design to match Zod's default value behavior.
+ *
+ * @template T - The Zod object schema type
  * @param schema - The Zod object schema to extract defaults from
- * @returns Partial object with only fields that have defaults
+ * @returns A partial object containing only fields with default values
  *
  * @example
- * ```ts
+ * Basic usage
+ * ```typescript
  * const schema = z.object({
  *   name: z.string().default('John'),
- *   age: z.number(), // no default - skipped
+ *   age: z.number(), // no default - will be skipped
+ *   email: z.string().email().optional(),
+ * });
+ *
+ * const defaults = getSchemaDefaults(schema);
+ * // Result: { name: 'John' }
+ * ```
+ *
+ * @example
+ * Nested objects with defaults
+ * ```typescript
+ * const schema = z.object({
+ *   user: z.object({
+ *     name: z.string().default('Guest')
+ *   }).default({ name: 'Guest' }), // ✅ Extracted because parent has .default()
+ *
  *   settings: z.object({
  *     theme: z.string().default('light')
- *   })
+ *   }), // ❌ NOT extracted - parent has no .default()
  * });
  *
- * getSchemaDefaults(schema);
- * // Returns: { name: 'John', settings: { theme: 'light' } }
+ * const defaults = getSchemaDefaults(schema);
+ * // Result: { user: { name: 'Guest' } }
  * ```
+ *
+ * @example
+ * Unwrapping optional/nullable fields
+ * ```typescript
+ * const schema = z.object({
+ *   title: z.string().default('Untitled').optional(),
+ *   count: z.number().default(0).nullable(),
+ * });
+ *
+ * const defaults = getSchemaDefaults(schema);
+ * // Result: { title: 'Untitled', count: 0 }
+ * ```
+ *
+ * @see {@link extractDefault} for extracting defaults from individual fields
+ * @since 0.1.0
  */
-declare function getSchemaDefaults<T extends z.ZodObject<any>>(schema: T): Partial<z.infer<T>>;
+declare function getSchemaDefaults<T extends z.ZodObject>(schema: T): Simplify<Partial<z.infer<T>>>;
 
 /**
- * Extract the element type from an array or undefined
+ * Type representing a Zod type that has an unwrap method
  */
-type PickArrayObject<TArray extends unknown[] | undefined> = NonNullable<TArray>[number];
+type Unwrappable = {
+    unwrap: () => z.ZodTypeAny;
+};
 /**
- * Simplify complex types for better IDE hints
+ * Type guard to check if a Zod field can be unwrapped (has wrapper types like optional, nullable, default).
+ *
+ * This checks whether a Zod type has an `unwrap()` method, which is present on wrapper types
+ * like `ZodOptional`, `ZodNullable`, `ZodDefault`, and others.
+ *
+ * @param field - The Zod field to check
+ * @returns True if the field has an unwrap method, false otherwise
+ *
+ * @example
+ * ```typescript
+ * const optionalField = z.string().optional();
+ * console.log(canUnwrap(optionalField)); // true
+ *
+ * const plainField = z.string();
+ * console.log(canUnwrap(plainField)); // false
+ * ```
+ *
+ * @since 0.1.0
  */
-type Simplify<T> = {
-    [K in keyof T]: T[K];
-} & {};
+declare function canUnwrap(field: z.ZodTypeAny): field is z.ZodTypeAny & Unwrappable;
 /**
- * Make all properties optional and nullable
- * Useful for form input types where fields can be empty
+ * Unwraps a ZodUnion type and returns the first field and all union options.
+ *
+ * This function extracts the individual type options from a union type.
+ * By default, it filters out `ZodNull` and `ZodUndefined` types, returning only
+ * the meaningful type options. You can disable this filtering to get all options.
+ *
+ * @template T - The Zod type to unwrap
+ * @param field - The Zod field (union or single type)
+ * @param options - Configuration options
+ * @param options.filterNullish - Whether to filter out null and undefined types (default: true)
+ * @returns Object with `field` (first option) and `union` (all options array)
+ *
+ * @example
+ * Basic union unwrapping
+ * ```typescript
+ * const field = z.union([z.string(), z.number()]);
+ * const result = unwrapUnion(field);
+ * // Result: { field: z.string(), union: [z.string(), z.number()] }
+ * ```
+ *
+ * @example
+ * Union with null (filtered by default)
+ * ```typescript
+ * const field = z.union([z.string(), z.null()]);
+ * const result = unwrapUnion(field);
+ * // Result: { field: z.string(), union: [z.string()] }
+ * ```
+ *
+ * @example
+ * Union with null (keep all options)
+ * ```typescript
+ * const field = z.union([z.string(), z.null()]);
+ * const result = unwrapUnion(field, { filterNullish: false });
+ * // Result: { field: z.string(), union: [z.string(), z.null()] }
+ * ```
+ *
+ * @example
+ * Non-union type (returns single field)
+ * ```typescript
+ * const field = z.string();
+ * const result = unwrapUnion(field);
+ * // Result: { field: z.string(), union: [z.string()] }
+ * ```
+ *
+ * @example
+ * Nullable as union
+ * ```typescript
+ * const field = z.string().nullable(); // This is z.union([z.string(), z.null()])
+ * const result = unwrapUnion(field);
+ * // Result: { field: z.string(), union: [z.string()] } (null filtered out)
+ * ```
+ *
+ * @example
+ * Using the first field for type checking
+ * ```typescript
+ * const field = z.union([z.string(), z.number()]);
+ * const { field: firstField, union } = unwrapUnion(field);
+ * if (firstField instanceof z.ZodString) {
+ *   console.log('First type is string');
+ * }
+ * ```
+ *
+ * @see {@link getPrimitiveType} for unwrapping wrapper types
+ * @since 0.1.0
  */
-type MakeOptionalAndNullable<T> = {
-    [K in keyof T]?: T[K] | null;
+declare function unwrapUnion<T extends z.ZodTypeAny>(field: T, options?: {
+    filterNullish?: boolean;
+}): {
+    field: z.ZodTypeAny;
+    union: z.ZodTypeAny[];
 };
+/**
+ * Gets the underlying primitive type of a Zod field by recursively unwrapping wrapper types.
+ *
+ * This function removes wrapper layers (optional, nullable, default) to reveal the base type.
+ * **Important:** It stops at array types without unwrapping them, treating arrays as primitives.
+ *
+ * @template T - The Zod type to unwrap
+ * @param field - The Zod field to unwrap
+ * @returns The unwrapped primitive Zod type
+ *
+ * @example
+ * Unwrapping to string primitive
+ * ```typescript
+ * const field = z.string().optional().nullable();
+ * const primitive = getPrimitiveType(field);
+ * // Result: z.string() (unwrapped all wrappers)
+ * ```
+ *
+ * @example
+ * Stopping at array type
+ * ```typescript
+ * const field = z.array(z.string()).optional();
+ * const primitive = getPrimitiveType(field);
+ * // Result: z.array(z.string()) (stops at array, doesn't unwrap it)
+ * ```
+ *
+ * @example
+ * Unwrapping defaults
+ * ```typescript
+ * const field = z.number().default(0).optional();
+ * const primitive = getPrimitiveType(field);
+ * // Result: z.number()
+ * ```
+ *
+ * @see {@link canUnwrap} for checking if a field can be unwrapped
+ * @since 0.1.0
+ */
+declare const getPrimitiveType: <T extends z.ZodType>(field: T) => z.ZodTypeAny;
+type StripZodDefault<T> = T extends z.ZodDefault<infer Inner> ? StripZodDefault<Inner> : T extends z.ZodOptional<infer Inner> ? z.ZodOptional<StripZodDefault<Inner>> : T extends z.ZodNullable<infer Inner> ? z.ZodNullable<StripZodDefault<Inner>> : T;
+/**
+ * Removes default values from a Zod field while preserving other wrapper types.
+ *
+ * This function recursively removes `ZodDefault` wrappers from a field, while maintaining
+ * `optional()` and `nullable()` wrappers. Useful for scenarios where you want to check
+ * field requirements without considering default values.
+ *
+ * @template T - The Zod type to process
+ * @param field - The Zod field to remove defaults from
+ * @returns The field without defaults but with optional/nullable preserved
+ *
+ * @example
+ * Removing simple default
+ * ```typescript
+ * const field = z.string().default('hello');
+ * const withoutDefault = removeDefault(field);
+ * // Result: z.string()
+ * ```
+ *
+ * @example
+ * Preserving optional wrapper
+ * ```typescript
+ * const field = z.string().default('hello').optional();
+ * const withoutDefault = removeDefault(field);
+ * // Result: z.string().optional()
+ * ```
+ *
+ * @example
+ * Nested defaults
+ * ```typescript
+ * const field = z.string().default('inner').nullable().default('outer');
+ * const withoutDefault = removeDefault(field);
+ * // Result: z.string().nullable()
+ * ```
+ *
+ * @see {@link requiresValidInput} for usage with requirement checking
+ * @since 0.1.0
+ */
+declare function removeDefault<T extends z.ZodType>(field: T): StripZodDefault<T>;
+/**
+ * Determines if a field will show validation errors when the user submits empty or invalid input.
+ *
+ * This is useful for form UIs to indicate which fields require valid user input (e.g., showing
+ * asterisks, validation states). The key insight: **defaults are just initial values** - they
+ * don't prevent validation errors if the user clears the field.
+ *
+ * **Real-world example:**
+ * ```typescript
+ * // Marital status field with default but validation rules
+ * const maritalStatus = z.string().min(1).default('single');
+ *
+ * // Initial: field shows "single" (from default)
+ * // User deletes the value → field is now empty string
+ * // User submits form → validation fails because .min(1) rejects empty strings
+ * // requiresValidInput(maritalStatus) → true (shows * indicator, validation error)
+ * ```
+ *
+ * **How it works:**
+ * 1. Removes `.default()` wrappers (defaults are initial values, not validation rules)
+ * 2. Tests if the underlying schema accepts empty/invalid input:
+ *    - `undefined` (via `.optional()`)
+ *    - `null` (via `.nullable()`)
+ *    - Empty string (plain `z.string()` without `.min(1)` or `.nonempty()`)
+ *    - Empty array (plain `z.array()` without `.min(1)` or `.nonempty()`)
+ * 3. Returns `true` if validation will fail, `false` if empty input is accepted
+ *
+ * @template T - The Zod type to check
+ * @param field - The Zod field to check
+ * @returns True if the field will show validation errors on empty/invalid input, false otherwise
+ *
+ * @example
+ * User name field - required, no default
+ * ```typescript
+ * const userName = z.string().min(1);
+ * requiresValidInput(userName); // true - will error if user submits empty
+ * ```
+ *
+ * @example
+ * Marital status - required WITH default
+ * ```typescript
+ * const maritalStatus = z.string().min(1).default('single');
+ * requiresValidInput(maritalStatus); // true - will error if user clears and submits
+ * ```
+ *
+ * @example
+ * Age with default - requires valid input
+ * ```typescript
+ * const age = z.number().default(0);
+ * requiresValidInput(age); // true - numbers reject empty strings
+ * ```
+ *
+ * @example
+ * Optional bio field - doesn't require input
+ * ```typescript
+ * const bio = z.string().optional();
+ * requiresValidInput(bio); // false - user can leave empty
+ * ```
+ *
+ * @example
+ * String with default but NO validation - doesn't require input
+ * ```typescript
+ * const notes = z.string().default('N/A');
+ * requiresValidInput(notes); // false - plain z.string() accepts empty strings
+ * ```
+ *
+ * @example
+ * Nullable field - doesn't require input
+ * ```typescript
+ * const middleName = z.string().nullable();
+ * requiresValidInput(middleName); // false - user can leave null
+ * ```
+ *
+ * @see {@link removeDefault} for understanding how defaults are handled
+ * @see {@link getPrimitiveType} for understanding type unwrapping
+ * @since 0.1.0
+ */
+declare const requiresValidInput: <T extends z.ZodType>(field: T) => boolean;
 
-export { type MakeOptionalAndNullable, type PickArrayObject, type Simplify, checkIfFieldIsRequired, extractDefault, getPrimitiveType, getSchemaDefaults, getUnwrappedType, removeDefault };
+export { type Simplify, canUnwrap, extractDefault, getPrimitiveType, getSchemaDefaults, removeDefault, requiresValidInput, unwrapUnion };

package/dist/index.js

@@ -22,15 +22,36 @@ function _interopNamespace(e) {
 
 var z__namespace = /*#__PURE__*/_interopNamespace(z);
 
-// src/schema.ts
-var getPrimitiveType = (field, options) => {
-  var _a;
-  const unwrapArrays = (_a = options == null ? void 0 : options.unwrapArrays) != null ? _a : false;
-  if (!unwrapArrays && field.type === "array") {
+// src/defaults.ts
+function canUnwrap(field) {
+  return "unwrap" in field && typeof field.unwrap === "function";
+}
+function unwrapUnion(field, options = {}) {
+  const { filterNullish = true } = options;
+  if (field instanceof z__namespace.ZodUnion) {
+    const unionOptions = [...field.def.options];
+    const filteredOptions = filterNullish ? unionOptions.filter(
+      (option) => !(option instanceof z__namespace.ZodNull) && !(option instanceof z__namespace.ZodUndefined)
+    ) : unionOptions;
+    return {
+      field: filteredOptions[0] || field,
+      union: filteredOptions
+    };
+  }
+  return {
+    field,
+    union: [field]
+  };
+}
+var getPrimitiveType = (field) => {
+  if (field instanceof z__namespace.ZodArray) {
     return field;
   }
-  if ("unwrap" in field && typeof field.unwrap === "function") {
-    return getPrimitiveType(field.unwrap(), options);
+  if (canUnwrap(field)) {
+    return getPrimitiveType(field.unwrap());
+  }
+  if (field instanceof z__namespace.ZodUnion) {
+    return getPrimitiveType(unwrapUnion(field).field);
   }
   return field;
 };
@@ -38,7 +59,7 @@ function removeDefault(field) {
   if (field instanceof z__namespace.ZodDefault) {
     return field.unwrap();
   }
-  if ("innerType" in field.def) {
+  if ("innerType" in field.def && field.def.innerType instanceof z__namespace.ZodType) {
     const inner = removeDefault(field.def.innerType);
     if (field instanceof z__namespace.ZodOptional) {
       return inner.optional();
@@ -49,58 +70,48 @@ function removeDefault(field) {
   }
   return field;
 }
-var checkIfFieldIsRequired = (field) => {
-  const undefinedResult = field.safeParse(void 0).success;
-  const nullResult = field.safeParse(null).success;
-  const primitiveType = getPrimitiveType(field);
-  const emptyStringResult = primitiveType.type === "string" && field.safeParse("").success;
-  const emptyArrayResult = primitiveType.type === "array" && field.safeParse([]).success;
+var requiresValidInput = (field) => {
+  const defaultRemovedField = removeDefault(field);
+  if (!(defaultRemovedField instanceof z__namespace.ZodType)) {
+    return false;
+  }
+  const undefinedResult = defaultRemovedField.safeParse(void 0).success;
+  const nullResult = defaultRemovedField.safeParse(null).success;
+  const primitiveType = getPrimitiveType(defaultRemovedField);
+  const emptyStringResult = primitiveType.type === "string" && defaultRemovedField.safeParse("").success;
+  const emptyArrayResult = primitiveType.type === "array" && defaultRemovedField.safeParse([]).success;
   return !undefinedResult && !nullResult && !emptyStringResult && !emptyArrayResult;
 };
+
+// src/defaults.ts
 function extractDefault(field) {
   if (field instanceof z__namespace.ZodDefault) {
-    const defaultValue = field._def.defaultValue;
-    return typeof defaultValue === "function" ? defaultValue() : defaultValue;
+    return field.def.defaultValue;
   }
-  if ("unwrap" in field && typeof field.unwrap === "function") {
+  if (canUnwrap(field)) {
     return extractDefault(field.unwrap());
   }
   return void 0;
 }
-function getUnwrappedType(field) {
-  if (field instanceof z__namespace.ZodDefault) {
-    return field;
-  }
-  if ("unwrap" in field && typeof field.unwrap === "function") {
-    return getUnwrappedType(field.unwrap());
-  }
-  return field;
-}
 function getSchemaDefaults(schema) {
   const defaults = {};
   for (const key in schema.shape) {
     const field = schema.shape[key];
+    if (!field) continue;
     const defaultValue = extractDefault(field);
     if (defaultValue !== void 0) {
       defaults[key] = defaultValue;
-      continue;
-    }
-    const unwrapped = getUnwrappedType(field);
-    if (unwrapped instanceof z__namespace.ZodObject) {
-      const nestedDefaults = getSchemaDefaults(unwrapped);
-      if (Object.keys(nestedDefaults).length > 0) {
-        defaults[key] = nestedDefaults;
-      }
     }
   }
   return defaults;
 }
 
-exports.checkIfFieldIsRequired = checkIfFieldIsRequired;
+exports.canUnwrap = canUnwrap;
 exports.extractDefault = extractDefault;
 exports.getPrimitiveType = getPrimitiveType;
 exports.getSchemaDefaults = getSchemaDefaults;
-exports.getUnwrappedType = getUnwrappedType;
 exports.removeDefault = removeDefault;
+exports.requiresValidInput = requiresValidInput;
+exports.unwrapUnion = unwrapUnion;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/schema.ts","../src/defaults.ts"],"names":["z","z2"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AASO,IAAM,gBAAA,GAAmB,CAC9B,KAAA,EACA,OAAA,KAGiB;AAdnB,EAAA,IAAA,EAAA;AAeE,EAAA,MAAM,YAAA,GAAA,CAAe,EAAA,GAAA,OAAA,IAAA,IAAA,GAAA,MAAA,GAAA,OAAA,CAAS,YAAA,KAAT,IAAA,GAAA,EAAA,GAAyB,KAAA;AAE9C,EAAA,IAAI,CAAC,YAAA,IAAgB,KAAA,CAAM,IAAA,KAAS,OAAA,EAAS;AAC3C,IAAA,OAAO,KAAA;AAAA,EACT;AAEA,EAAA,IAAI,QAAA,IAAY,KAAA,IAAS,OAAO,KAAA,CAAM,WAAW,UAAA,EAAY;AAC3D,IAAA,OAAO,gBAAA,CAAiB,KAAA,CAAM,MAAA,EAAO,EAAG,OAAO,CAAA;AAAA,EACjD;AAEA,EAAA,OAAO,KAAA;AACT;AAOO,SAAS,cAAc,KAAA,EAA6B;AACzD,EAAA,IAAI,iBAAmBA,YAAA,CAAA,UAAA,EAAY;AACjC,IAAA,OAAO,MAAM,MAAA,EAAO;AAAA,EACtB;AAEA,EAAA,IAAI,WAAA,IAAe,MAAM,GAAA,EAAK;AAC5B,IAAA,MAAM,KAAA,GAAQ,aAAA,CAAc,KAAA,CAAM,GAAA,CAAI,SAAsB,CAAA;AAE5D,IAAA,IAAI,iBAAmBA,YAAA,CAAA,WAAA,EAAa;AAClC,MAAA,OAAO,MAAM,QAAA,EAAS;AAAA,IACxB;AACA,IAAA,IAAI,iBAAmBA,YAAA,CAAA,WAAA,EAAa;AAClC,MAAA,OAAO,MAAM,QAAA,EAAS;AAAA,IACxB;AAAA,EACF;AAEA,EAAA,OAAO,KAAA;AACT;AAOO,IAAM,sBAAA,GAAyB,CAAyB,KAAA,KAAa;AAE1E,EAAA,MAAM,eAAA,GAAkB,KAAA,CAAM,SAAA,CAAU,MAAS,CAAA,CAAE,OAAA;AACnD,EAAA,MAAM,UAAA,GAAa,KAAA,CAAM,SAAA,CAAU,IAAI,CAAA,CAAE,OAAA;AAEzC,EAAA,MAAM,aAAA,GAAgB,iBAAiB,KAAK,CAAA;AAE5C,EAAA,MAAM,oBACJ,aAAA,CAAc,IAAA,KAAS,YAAY,KAAA,CAAM,SAAA,CAAU,EAAE,CAAA,CAAE,OAAA;AAEzD,EAAA,MAAM,gBAAA,GACJ,cAAc,IAAA,KAAS,OAAA,IAAW,MAAM,SAAA,CAAU,EAAE,CAAA,CAAE,OAAA;AAExD,EAAA,OACE,CAAC,eAAA,IAAmB,CAAC,UAAA,IAAc,CAAC,qBAAqB,CAAC,gBAAA;AAE9D;AClEO,SAAS,eAAe,KAAA,EAA0B;AACvD,EAAA,IAAI,iBAAmBC,YAAA,CAAA,UAAA,EAAY;AACjC,IAAA,MAAM,YAAA,GAAe,MAAM,IAAA,CAAK,YAAA;AAChC,IAAA,OAAO,OAAO,YAAA,KAAiB,UAAA,GAAa,YAAA,EAAa,GAAI,YAAA;AAAA,EAC/D;AAEA,EAAA,IAAI,QAAA,IAAY,KAAA,IAAS,OAAO,KAAA,CAAM,WAAW,UAAA,EAAY;AAC3D,IAAA,OAAO,cAAA,CAAe,KAAA,CAAM,MAAA,EAAQ,CAAA;AAAA,EACtC;AAEA,EAAA,OAAO,MAAA;AACT;AAQO,SAAS,iBAAiB,KAAA,EAAmC;AAClE,EAAA,IAAI,iBAAmBA,YAAA,CAAA,UAAA,EAAY;AAEjC,IAAA,OAAO,KAAA;AAAA,EACT;AAEA,EAAA,IAAI,QAAA,IAAY,KAAA,IAAS,OAAO,KAAA,CAAM,WAAW,UAAA,EAAY;AAC3D,IAAA,OAAO,gBAAA,CAAiB,KAAA,CAAM,MAAA,EAAQ,CAAA;AAAA,EACxC;AAEA,EAAA,OAAO,KAAA;AACT;AAsBO,SAAS,kBACd,MAAA,EACqB;AACrB,EAAA,MAAM,WAAgC,EAAC;AAEvC,EAAA,KAAA,MAAW,GAAA,IAAO,OAAO,KAAA,EAAO;AAC9B,IAAA,MAAM,KAAA,GAAQ,MAAA,CAAO,KAAA,CAAM,GAAG,CAAA;AAG9B,IAAA,MAAM,YAAA,GAAe,eAAe,KAAK,CAAA;AACzC,IAAA,IAAI,iBAAiB,MAAA,EAAW;AAC9B,MAAA,QAAA,CAAS,GAAG,CAAA,GAAI,YAAA;AAChB,MAAA;AAAA,IACF;AAGA,IAAA,MAAM,SAAA,GAAY,iBAAiB,KAAK,CAAA;AACxC,IAAA,IAAI,qBAAuBA,YAAA,CAAA,SAAA,EAAW;AACpC,MAAA,MAAM,cAAA,GAAiB,kBAAkB,SAAS,CAAA;AAClD,MAAA,IAAI,MAAA,CAAO,IAAA,CAAK,cAAc,CAAA,CAAE,SAAS,CAAA,EAAG;AAC1C,QAAA,QAAA,CAAS,GAAG,CAAA,GAAI,cAAA;AAAA,MAClB;AAAA,IACF;AAAA,EACF;AAEA,EAAA,OAAO,QAAA;AACT","file":"index.js","sourcesContent":["import * as z from 'zod';\n\n/**\n * Get the primitive type of a Zod field by unwrapping optional/nullable wrappers\n * @param field - The Zod field to unwrap\n * @param options - Options for unwrapping\n * @param options.unwrapArrays - If true, continues unwrapping arrays. If false (default), stops at arrays\n * @returns The unwrapped primitive type\n */\nexport const getPrimitiveType = <T extends z.ZodTypeAny>(\n  field: T,\n  options?: {\n    unwrapArrays?: boolean;\n  },\n): z.ZodTypeAny => {\n  const unwrapArrays = options?.unwrapArrays ?? false;\n\n  if (!unwrapArrays && field.type === 'array') {\n    return field;\n  }\n\n  if ('unwrap' in field && typeof field.unwrap === 'function') {\n    return getPrimitiveType(field.unwrap(), options);\n  }\n\n  return field;\n};\n\n/**\n * Remove default values from a Zod field\n * @param field - The Zod field to remove defaults from\n * @returns The field without defaults\n */\nexport function removeDefault(field: z.ZodType): z.ZodType {\n  if (field instanceof z.ZodDefault) {\n    return field.unwrap() as z.ZodType;\n  }\n\n  if ('innerType' in field.def) {\n    const inner = removeDefault(field.def.innerType as z.ZodType);\n    // Reconstruct the wrapper with the modified inner type\n    if (field instanceof z.ZodOptional) {\n      return inner.optional();\n    }\n    if (field instanceof z.ZodNullable) {\n      return inner.nullable();\n    }\n  }\n\n  return field;\n}\n\n/**\n * Check if a Zod field is required (not optional/nullable and doesn't accept empty values)\n * @param field - The Zod field to check\n * @returns True if the field is required\n */\nexport const checkIfFieldIsRequired = <T extends z.ZodTypeAny>(field: T) => {\n  // Check with defaults intact - if a field has a default, it's not required\n  const undefinedResult = field.safeParse(undefined).success;\n  const nullResult = field.safeParse(null).success;\n\n  const primitiveType = getPrimitiveType(field);\n\n  const emptyStringResult =\n    primitiveType.type === 'string' && field.safeParse('').success;\n\n  const emptyArrayResult =\n    primitiveType.type === 'array' && field.safeParse([]).success;\n\n  return (\n    !undefinedResult && !nullResult && !emptyStringResult && !emptyArrayResult\n  );\n};\n","import * as z from 'zod';\n\n/**\n * Extract the default value from a Zod field (recursively unwraps optional/nullable)\n * @param field - The Zod field to extract default from\n * @returns The default value if present, undefined otherwise\n */\nexport function extractDefault(field: z.ZodTypeAny): any {\n  if (field instanceof z.ZodDefault) {\n    const defaultValue = field._def.defaultValue;\n    return typeof defaultValue === 'function' ? defaultValue() : defaultValue;\n  }\n\n  if ('unwrap' in field && typeof field.unwrap === 'function') {\n    return extractDefault(field.unwrap());\n  }\n\n  return undefined;\n}\n\n/**\n * Get the unwrapped type without going through defaults\n * Useful for detecting nested objects/arrays while preserving defaults\n * @param field - The Zod field to unwrap\n * @returns The unwrapped type\n */\nexport function getUnwrappedType(field: z.ZodTypeAny): z.ZodTypeAny {\n  if (field instanceof z.ZodDefault) {\n    // Don't unwrap defaults - we want to preserve them\n    return field;\n  }\n\n  if ('unwrap' in field && typeof field.unwrap === 'function') {\n    return getUnwrappedType(field.unwrap());\n  }\n\n  return field;\n}\n\n/**\n * Extract all default values from a Zod object schema\n * Recursively handles nested objects and only returns fields with defaults\n * @param schema - The Zod object schema to extract defaults from\n * @returns Partial object with only fields that have defaults\n *\n * @example\n * ```ts\n * const schema = z.object({\n *   name: z.string().default('John'),\n *   age: z.number(), // no default - skipped\n *   settings: z.object({\n *     theme: z.string().default('light')\n *   })\n * });\n *\n * getSchemaDefaults(schema);\n * // Returns: { name: 'John', settings: { theme: 'light' } }\n * ```\n */\nexport function getSchemaDefaults<T extends z.ZodObject<any>>(\n  schema: T,\n): Partial<z.infer<T>> {\n  const defaults: Record<string, any> = {};\n\n  for (const key in schema.shape) {\n    const field = schema.shape[key];\n\n    // First, check if this field has an explicit default value\n    const defaultValue = extractDefault(field);\n    if (defaultValue !== undefined) {\n      defaults[key] = defaultValue;\n      continue;\n    }\n\n    // If no explicit default, check if it's a nested object with defaults\n    const unwrapped = getUnwrappedType(field);\n    if (unwrapped instanceof z.ZodObject) {\n      const nestedDefaults = getSchemaDefaults(unwrapped);\n      if (Object.keys(nestedDefaults).length > 0) {\n        defaults[key] = nestedDefaults;\n      }\n    }\n  }\n\n  return defaults as Partial<z.infer<T>>;\n}\n"]}
+{"version":3,"sources":["../src/schema.ts","../src/defaults.ts"],"names":["z","z2"],"mappings":"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","file":"index.js","sourcesContent":["import * as z from 'zod';\n\n/**\n * Type representing a Zod type that has an unwrap method\n */\ntype Unwrappable = { unwrap: () => z.ZodTypeAny };\n\n/**\n * Type guard to check if a Zod field can be unwrapped (has wrapper types like optional, nullable, default).\n *\n * This checks whether a Zod type has an `unwrap()` method, which is present on wrapper types\n * like `ZodOptional`, `ZodNullable`, `ZodDefault`, and others.\n *\n * @param field - The Zod field to check\n * @returns True if the field has an unwrap method, false otherwise\n *\n * @example\n * ```typescript\n * const optionalField = z.string().optional();\n * console.log(canUnwrap(optionalField)); // true\n *\n * const plainField = z.string();\n * console.log(canUnwrap(plainField)); // false\n * ```\n *\n * @since 0.1.0\n */\nexport function canUnwrap(\n  field: z.ZodTypeAny,\n): field is z.ZodTypeAny & Unwrappable {\n  return 'unwrap' in field && typeof field.unwrap === 'function';\n}\n\n/**\n * Unwraps a ZodUnion type and returns the first field and all union options.\n *\n * This function extracts the individual type options from a union type.\n * By default, it filters out `ZodNull` and `ZodUndefined` types, returning only\n * the meaningful type options. You can disable this filtering to get all options.\n *\n * @template T - The Zod type to unwrap\n * @param field - The Zod field (union or single type)\n * @param options - Configuration options\n * @param options.filterNullish - Whether to filter out null and undefined types (default: true)\n * @returns Object with `field` (first option) and `union` (all options array)\n *\n * @example\n * Basic union unwrapping\n * ```typescript\n * const field = z.union([z.string(), z.number()]);\n * const result = unwrapUnion(field);\n * // Result: { field: z.string(), union: [z.string(), z.number()] }\n * ```\n *\n * @example\n * Union with null (filtered by default)\n * ```typescript\n * const field = z.union([z.string(), z.null()]);\n * const result = unwrapUnion(field);\n * // Result: { field: z.string(), union: [z.string()] }\n * ```\n *\n * @example\n * Union with null (keep all options)\n * ```typescript\n * const field = z.union([z.string(), z.null()]);\n * const result = unwrapUnion(field, { filterNullish: false });\n * // Result: { field: z.string(), union: [z.string(), z.null()] }\n * ```\n *\n * @example\n * Non-union type (returns single field)\n * ```typescript\n * const field = z.string();\n * const result = unwrapUnion(field);\n * // Result: { field: z.string(), union: [z.string()] }\n * ```\n *\n * @example\n * Nullable as union\n * ```typescript\n * const field = z.string().nullable(); // This is z.union([z.string(), z.null()])\n * const result = unwrapUnion(field);\n * // Result: { field: z.string(), union: [z.string()] } (null filtered out)\n * ```\n *\n * @example\n * Using the first field for type checking\n * ```typescript\n * const field = z.union([z.string(), z.number()]);\n * const { field: firstField, union } = unwrapUnion(field);\n * if (firstField instanceof z.ZodString) {\n *   console.log('First type is string');\n * }\n * ```\n *\n * @see {@link getPrimitiveType} for unwrapping wrapper types\n * @since 0.1.0\n */\nexport function unwrapUnion<T extends z.ZodTypeAny>(\n  field: T,\n  options: { filterNullish?: boolean } = {},\n): { field: z.ZodTypeAny; union: z.ZodTypeAny[] } {\n  const { filterNullish = true } = options;\n\n  if (field instanceof z.ZodUnion) {\n    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n    const unionOptions = [...field.def.options] as z.ZodTypeAny[];\n\n    const filteredOptions = filterNullish\n      ? unionOptions.filter(\n          (option) =>\n            !(option instanceof z.ZodNull) &&\n            !(option instanceof z.ZodUndefined),\n        )\n      : unionOptions;\n\n    return {\n      field: filteredOptions[0] || field,\n      union: filteredOptions,\n    };\n  }\n\n  // If it's not a union, return the field itself\n  return {\n    field,\n    union: [field],\n  };\n}\n\n/**\n * Gets the underlying primitive type of a Zod field by recursively unwrapping wrapper types.\n *\n * This function removes wrapper layers (optional, nullable, default) to reveal the base type.\n * **Important:** It stops at array types without unwrapping them, treating arrays as primitives.\n *\n * @template T - The Zod type to unwrap\n * @param field - The Zod field to unwrap\n * @returns The unwrapped primitive Zod type\n *\n * @example\n * Unwrapping to string primitive\n * ```typescript\n * const field = z.string().optional().nullable();\n * const primitive = getPrimitiveType(field);\n * // Result: z.string() (unwrapped all wrappers)\n * ```\n *\n * @example\n * Stopping at array type\n * ```typescript\n * const field = z.array(z.string()).optional();\n * const primitive = getPrimitiveType(field);\n * // Result: z.array(z.string()) (stops at array, doesn't unwrap it)\n * ```\n *\n * @example\n * Unwrapping defaults\n * ```typescript\n * const field = z.number().default(0).optional();\n * const primitive = getPrimitiveType(field);\n * // Result: z.number()\n * ```\n *\n * @see {@link canUnwrap} for checking if a field can be unwrapped\n * @since 0.1.0\n */\nexport const getPrimitiveType = <T extends z.ZodType>(\n  field: T,\n): z.ZodTypeAny => {\n  // Stop at arrays - don't unwrap them\n  if (field instanceof z.ZodArray) {\n    return field;\n  }\n\n  if (canUnwrap(field)) {\n    return getPrimitiveType(field.unwrap());\n  }\n\n  if (field instanceof z.ZodUnion) {\n    return getPrimitiveType(unwrapUnion(field).field);\n  }\n\n  return field;\n};\n\ntype StripZodDefault<T> = T extends z.ZodDefault<infer Inner>\n  ? StripZodDefault<Inner>\n  : T extends z.ZodOptional<infer Inner>\n    ? z.ZodOptional<StripZodDefault<Inner>>\n    : T extends z.ZodNullable<infer Inner>\n      ? z.ZodNullable<StripZodDefault<Inner>>\n      : T;\n\n/**\n * Removes default values from a Zod field while preserving other wrapper types.\n *\n * This function recursively removes `ZodDefault` wrappers from a field, while maintaining\n * `optional()` and `nullable()` wrappers. Useful for scenarios where you want to check\n * field requirements without considering default values.\n *\n * @template T - The Zod type to process\n * @param field - The Zod field to remove defaults from\n * @returns The field without defaults but with optional/nullable preserved\n *\n * @example\n * Removing simple default\n * ```typescript\n * const field = z.string().default('hello');\n * const withoutDefault = removeDefault(field);\n * // Result: z.string()\n * ```\n *\n * @example\n * Preserving optional wrapper\n * ```typescript\n * const field = z.string().default('hello').optional();\n * const withoutDefault = removeDefault(field);\n * // Result: z.string().optional()\n * ```\n *\n * @example\n * Nested defaults\n * ```typescript\n * const field = z.string().default('inner').nullable().default('outer');\n * const withoutDefault = removeDefault(field);\n * // Result: z.string().nullable()\n * ```\n *\n * @see {@link requiresValidInput} for usage with requirement checking\n * @since 0.1.0\n */\nexport function removeDefault<T extends z.ZodType>(\n  field: T,\n): StripZodDefault<T> {\n  if (field instanceof z.ZodDefault) {\n    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n    return field.unwrap() as StripZodDefault<T>;\n  }\n\n  if ('innerType' in field.def && field.def.innerType instanceof z.ZodType) {\n    const inner = removeDefault(field.def.innerType);\n    // Reconstruct the wrapper with the modified inner type\n    if (field instanceof z.ZodOptional) {\n      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n      return inner.optional() as unknown as StripZodDefault<T>;\n    }\n    if (field instanceof z.ZodNullable) {\n      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n      return inner.nullable() as unknown as StripZodDefault<T>;\n    }\n  }\n\n  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n  return field as StripZodDefault<T>;\n}\n\n/**\n * Determines if a field will show validation errors when the user submits empty or invalid input.\n *\n * This is useful for form UIs to indicate which fields require valid user input (e.g., showing\n * asterisks, validation states). The key insight: **defaults are just initial values** - they\n * don't prevent validation errors if the user clears the field.\n *\n * **Real-world example:**\n * ```typescript\n * // Marital status field with default but validation rules\n * const maritalStatus = z.string().min(1).default('single');\n *\n * // Initial: field shows \"single\" (from default)\n * // User deletes the value → field is now empty string\n * // User submits form → validation fails because .min(1) rejects empty strings\n * // requiresValidInput(maritalStatus) → true (shows * indicator, validation error)\n * ```\n *\n * **How it works:**\n * 1. Removes `.default()` wrappers (defaults are initial values, not validation rules)\n * 2. Tests if the underlying schema accepts empty/invalid input:\n *    - `undefined` (via `.optional()`)\n *    - `null` (via `.nullable()`)\n *    - Empty string (plain `z.string()` without `.min(1)` or `.nonempty()`)\n *    - Empty array (plain `z.array()` without `.min(1)` or `.nonempty()`)\n * 3. Returns `true` if validation will fail, `false` if empty input is accepted\n *\n * @template T - The Zod type to check\n * @param field - The Zod field to check\n * @returns True if the field will show validation errors on empty/invalid input, false otherwise\n *\n * @example\n * User name field - required, no default\n * ```typescript\n * const userName = z.string().min(1);\n * requiresValidInput(userName); // true - will error if user submits empty\n * ```\n *\n * @example\n * Marital status - required WITH default\n * ```typescript\n * const maritalStatus = z.string().min(1).default('single');\n * requiresValidInput(maritalStatus); // true - will error if user clears and submits\n * ```\n *\n * @example\n * Age with default - requires valid input\n * ```typescript\n * const age = z.number().default(0);\n * requiresValidInput(age); // true - numbers reject empty strings\n * ```\n *\n * @example\n * Optional bio field - doesn't require input\n * ```typescript\n * const bio = z.string().optional();\n * requiresValidInput(bio); // false - user can leave empty\n * ```\n *\n * @example\n * String with default but NO validation - doesn't require input\n * ```typescript\n * const notes = z.string().default('N/A');\n * requiresValidInput(notes); // false - plain z.string() accepts empty strings\n * ```\n *\n * @example\n * Nullable field - doesn't require input\n * ```typescript\n * const middleName = z.string().nullable();\n * requiresValidInput(middleName); // false - user can leave null\n * ```\n *\n * @see {@link removeDefault} for understanding how defaults are handled\n * @see {@link getPrimitiveType} for understanding type unwrapping\n * @since 0.1.0\n */\nexport const requiresValidInput = <T extends z.ZodType>(field: T) => {\n  const defaultRemovedField = removeDefault(field);\n  if (!(defaultRemovedField instanceof z.ZodType)) {\n    return false;\n  }\n\n  const undefinedResult = defaultRemovedField.safeParse(undefined).success;\n\n  // Check if field accepts null (nullable)\n  const nullResult = defaultRemovedField.safeParse(null).success;\n\n  const primitiveType = getPrimitiveType(defaultRemovedField);\n\n  const emptyStringResult =\n    primitiveType.type === 'string' &&\n    defaultRemovedField.safeParse('').success;\n\n  const emptyArrayResult =\n    primitiveType.type === 'array' && defaultRemovedField.safeParse([]).success;\n\n  return (\n    !undefinedResult && !nullResult && !emptyStringResult && !emptyArrayResult\n  );\n};\n","import * as z from 'zod';\nimport { canUnwrap } from './schema';\nimport type { Simplify } from './types';\n\n/**\n * Extracts the default value from a Zod field, recursively unwrapping optional and nullable layers.\n *\n * This function traverses through wrapper types (like `ZodOptional`, `ZodNullable`) to find\n * the underlying `ZodDefault` and returns its default value. If no default is found, returns `undefined`.\n *\n * @template T - The Zod type to extract default from\n * @param field - The Zod field to extract default from\n * @returns The default value if present, undefined otherwise\n *\n * @example\n * Basic usage with default value\n * ```typescript\n * const field = z.string().default('hello');\n * const defaultValue = extractDefault(field);\n * // Result: 'hello'\n * ```\n *\n * @example\n * Unwrapping optional/nullable layers\n * ```typescript\n * const field = z.string().default('world').optional();\n * const defaultValue = extractDefault(field);\n * // Result: 'world' (unwraps optional to find default)\n * ```\n *\n * @example\n * Field without default\n * ```typescript\n * const field = z.string().optional();\n * const defaultValue = extractDefault(field);\n * // Result: undefined\n * ```\n *\n * @see {@link getSchemaDefaults} for extracting defaults from entire schemas\n * @since 0.1.0\n */\nexport function extractDefault<T extends z.ZodTypeAny>(\n  field: T,\n): z.infer<T> | undefined {\n  if (field instanceof z.ZodDefault) {\n    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n    return field.def.defaultValue as z.infer<T>;\n  }\n\n  if (canUnwrap(field)) {\n    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n    return extractDefault(field.unwrap()) as z.infer<T>;\n  }\n\n  return undefined;\n}\n\n/**\n * Extracts default values from a Zod object schema while skipping fields without defaults.\n *\n * This function recursively traverses the schema and collects all fields that have\n * explicit default values defined. Fields without defaults are excluded from the result.\n *\n * **Important:** Nested defaults are NOT extracted unless the parent object also has\n * an explicit `.default()`. This is by design to match Zod's default value behavior.\n *\n * @template T - The Zod object schema type\n * @param schema - The Zod object schema to extract defaults from\n * @returns A partial object containing only fields with default values\n *\n * @example\n * Basic usage\n * ```typescript\n * const schema = z.object({\n *   name: z.string().default('John'),\n *   age: z.number(), // no default - will be skipped\n *   email: z.string().email().optional(),\n * });\n *\n * const defaults = getSchemaDefaults(schema);\n * // Result: { name: 'John' }\n * ```\n *\n * @example\n * Nested objects with defaults\n * ```typescript\n * const schema = z.object({\n *   user: z.object({\n *     name: z.string().default('Guest')\n *   }).default({ name: 'Guest' }), // ✅ Extracted because parent has .default()\n *\n *   settings: z.object({\n *     theme: z.string().default('light')\n *   }), // ❌ NOT extracted - parent has no .default()\n * });\n *\n * const defaults = getSchemaDefaults(schema);\n * // Result: { user: { name: 'Guest' } }\n * ```\n *\n * @example\n * Unwrapping optional/nullable fields\n * ```typescript\n * const schema = z.object({\n *   title: z.string().default('Untitled').optional(),\n *   count: z.number().default(0).nullable(),\n * });\n *\n * const defaults = getSchemaDefaults(schema);\n * // Result: { title: 'Untitled', count: 0 }\n * ```\n *\n * @see {@link extractDefault} for extracting defaults from individual fields\n * @since 0.1.0\n */\nexport function getSchemaDefaults<T extends z.ZodObject>(\n  schema: T,\n): Simplify<Partial<z.infer<T>>> {\n  const defaults: Record<string, unknown> = {};\n\n  for (const key in schema.shape) {\n    const field = schema.shape[key];\n    if (!field) continue;\n\n    // Check if this field has an explicit default value\n    const defaultValue = extractDefault(field);\n    if (defaultValue !== undefined) {\n      defaults[key] = defaultValue;\n    }\n  }\n\n  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n  return defaults as Partial<z.infer<T>>;\n}\n"]}