@zod-utils/core 0.8.0 → 1.0.0

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import * as z from 'zod';
-import { $ZodCheckLessThanDef, $ZodCheckGreaterThanDef, $ZodCheckMultipleOfDef, $ZodCheckNumberFormatDef, $ZodCheckBigIntFormatDef, $ZodCheckMaxSizeDef, $ZodCheckMinSizeDef, $ZodCheckSizeEqualsDef, $ZodCheckMaxLengthDef, $ZodCheckMinLengthDef, $ZodCheckLengthEqualsDef, $ZodCheckStringFormatDef, $ZodCheckRegexDef, $ZodCheckLowerCaseDef, $ZodCheckUpperCaseDef, $ZodCheckIncludesDef, $ZodCheckStartsWithDef, $ZodCheckEndsWithDef, $ZodCheckPropertyDef, $ZodCheckMimeTypeDef, $ZodCheckOverwriteDef } from 'zod/v4/core';
+import { util, z as z$1 } from 'zod';
+import { $InferUnionOutput, $ZodCheckLessThanDef, $ZodCheckGreaterThanDef, $ZodCheckMultipleOfDef, $ZodCheckNumberFormatDef, $ZodCheckBigIntFormatDef, $ZodCheckMaxSizeDef, $ZodCheckMinSizeDef, $ZodCheckSizeEqualsDef, $ZodCheckMaxLengthDef, $ZodCheckMinLengthDef, $ZodCheckLengthEqualsDef, $ZodCheckStringFormatDef, $ZodCheckRegexDef, $ZodCheckLowerCaseDef, $ZodCheckUpperCaseDef, $ZodCheckIncludesDef, $ZodCheckStartsWithDef, $ZodCheckEndsWithDef, $ZodCheckPropertyDef, $ZodCheckMimeTypeDef, $ZodCheckOverwriteDef } from 'zod/v4/core';
 
 /**
  * Simplifies complex TypeScript types for better IDE hover tooltips and error messages.
@@ -51,8 +52,9 @@ type Simplify<T> = {
  * This function traverses through wrapper types (like `ZodOptional`, `ZodNullable`, `ZodUnion`) to find
  * the underlying `ZodDefault` and returns its default value. If no default is found, returns `undefined`.
  *
- * **Union handling:** For union types, extracts the default from the first option. If the first option
- * has no default, returns `undefined` (defaults in other union options are not checked).
+ * **Union handling:** For union types, strips nullish types (null/undefined) first. If only one type
+ * remains after stripping, extracts the default from that type. If multiple non-nullish types remain,
+ * returns `undefined` (does not extract from any option).
  *
  * @template T - The Zod type to extract default from
  * @param field - The Zod field to extract default from
@@ -75,19 +77,19 @@ type Simplify<T> = {
  * ```
  *
  * @example
- * Union with default in first option
+ * Union with only nullish types stripped to single type
  * ```typescript
- * const field = z.union([z.string().default('hello'), z.number()]);
+ * const field = z.union([z.string().default('hello'), z.null()]);
  * const defaultValue = extractDefault(field);
- * // Result: 'hello' (extracts from first union option)
+ * // Result: 'hello' (null stripped, leaving only string)
  * ```
  *
  * @example
- * Union with default in second option
+ * Union with multiple non-nullish types
  * ```typescript
- * const field = z.union([z.string(), z.number().default(42)]);
+ * const field = z.union([z.string().default('hello'), z.number()]);
  * const defaultValue = extractDefault(field);
- * // Result: undefined (only checks first option)
+ * // Result: undefined (multiple non-nullish types - no default extracted)
  * ```
  *
  * @example
@@ -99,6 +101,7 @@ type Simplify<T> = {
  * ```
  *
  * @see {@link getSchemaDefaults} for extracting defaults from entire schemas
+ * @see {@link tryStripNullishOnly} for union nullish stripping logic
  * @since 0.1.0
  */
 declare function extractDefault<T extends z.ZodTypeAny>(field: T): z.infer<T> | undefined;
@@ -114,8 +117,8 @@ declare function extractDefault<T extends z.ZodTypeAny>(field: T): z.infer<T> |
  * **Component handling:** For form inputs without explicit defaults (like `z.string()` or `z.number()`),
  * use the `?? ''` pattern in your components: `<Input value={field.value ?? ''} />`
  *
- * @template T - The Zod object schema type
- * @param schema - The Zod object schema to extract defaults from
+ * @template TSchema - The Zod object schema type
+ * @param targetSchema - The Zod object schema to extract defaults from
  * @returns A partial object containing only fields with explicit default values
  *
  * @example
@@ -174,7 +177,21 @@ declare function extractDefault<T extends z.ZodTypeAny>(field: T): z.infer<T> |
  * @see {@link extractDefault} for extracting defaults from individual fields
  * @since 0.1.0
  */
-declare function getSchemaDefaults<T extends z.ZodObject>(schema: T): Simplify<Partial<z.infer<T>>>;
+declare function getSchemaDefaults<TSchema extends z.ZodObject | z.ZodDiscriminatedUnion, TDiscriminatorKey extends keyof z.infer<TSchema> & string, TDiscriminatorValue extends z.infer<TSchema>[TDiscriminatorKey] & util.Literal>(schema: TSchema, options?: {
+    discriminator?: {
+        key: TDiscriminatorKey;
+        value: TDiscriminatorValue;
+    };
+}): Simplify<Partial<z.infer<TSchema>>>;
+
+declare function extractFieldFromSchema<TSchema extends z$1.ZodObject | z$1.ZodDiscriminatedUnion, TName extends keyof Extract<Required<z$1.infer<TSchema>>, Record<TDiscriminatorKey, TDiscriminatorValue>>, TDiscriminatorKey extends keyof z$1.infer<TSchema> & string, TDiscriminatorValue extends z$1.infer<TSchema>[TDiscriminatorKey] & util.Literal>({ schema, fieldName, discriminator, }: {
+    schema: TSchema;
+    fieldName: TName;
+    discriminator?: {
+        key: TDiscriminatorKey;
+        value: TDiscriminatorValue;
+    };
+}): z$1.ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>> | undefined;
 
 /**
  * Type representing a Zod type that has an unwrap method
@@ -204,83 +221,53 @@ type Unwrappable = {
  */
 declare function canUnwrap(field: z.ZodTypeAny): field is z.ZodTypeAny & Unwrappable;
 /**
- * Unwraps a ZodUnion type and returns the first field and all union options.
+ * Attempts to strip nullish types from a union and return the single remaining type.
  *
- * 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.
+ * This function filters out `ZodNull` and `ZodUndefined` from union types. If exactly
+ * one type remains after filtering, it returns that unwrapped type. Otherwise, it returns
+ * `false` to indicate the union couldn't be simplified to a single type.
  *
- * @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)
+ * @param field - The Zod field to process
+ * @returns The unwrapped type if only one remains, otherwise `false`
  *
  * @example
- * Basic union unwrapping
+ * Union with only nullish types filtered - returns single type
  * ```typescript
- * const field = z.union([z.string(), z.number()]);
- * const result = unwrapUnion(field);
- * // Result: { field: z.string(), union: [z.string(), z.number()] }
+ * const field = z.union([z.string(), z.null(), z.undefined()]);
+ * const result = tryStripNullishOnly(field);
+ * // Result: z.string() (unwrapped)
  * ```
  *
  * @example
- * Union with null (filtered by default)
+ * Union with multiple non-nullish types - returns false
  * ```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()] }
+ * const field = z.union([z.string(), z.number()]);
+ * const result = tryStripNullishOnly(field);
+ * // Result: false (cannot simplify to single type)
  * ```
  *
  * @example
- * Non-union type (returns single field)
+ * Non-union type - returns false
  * ```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');
- * }
+ * const result = tryStripNullishOnly(field);
+ * // Result: false (not a union)
  * ```
  *
  * @see {@link getPrimitiveType} for unwrapping wrapper types
- * @since 0.1.0
+ * @since 0.5.0
  */
-declare function unwrapUnion<T extends z.ZodTypeAny>(field: T, options?: {
-    filterNullish?: boolean;
-}): {
-    field: z.ZodTypeAny;
-    union: z.ZodTypeAny[];
-};
+declare function tryStripNullishOnly(field: z.ZodTypeAny): z.ZodType | false;
 /**
  * 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.
  *
+ * **Union handling:** For union types, strips nullish types (null/undefined) first. If only one
+ * type remains after stripping, unwraps to that type. If multiple non-nullish types remain,
+ * returns the union as-is (does not unwrap).
+ *
  * @template T - The Zod type to unwrap
  * @param field - The Zod field to unwrap
  * @returns The unwrapped primitive Zod type
@@ -309,7 +296,24 @@ declare function unwrapUnion<T extends z.ZodTypeAny>(field: T, options?: {
  * // Result: z.number()
  * ```
  *
+ * @example
+ * Union with only nullish types stripped to single type
+ * ```typescript
+ * const field = z.union([z.string(), z.null()]);
+ * const primitive = getPrimitiveType(field);
+ * // Result: z.string() (null stripped, leaving only string)
+ * ```
+ *
+ * @example
+ * Union with multiple non-nullish types
+ * ```typescript
+ * const field = z.union([z.string(), z.number()]);
+ * const primitive = getPrimitiveType(field);
+ * // Result: z.union([z.string(), z.number()]) (returned as-is)
+ * ```
+ *
  * @see {@link canUnwrap} for checking if a field can be unwrapped
+ * @see {@link tryStripNullishOnly} for union nullish stripping logic
  * @since 0.1.0
  */
 declare const getPrimitiveType: <T extends z.ZodType>(field: T) => z.ZodTypeAny;
@@ -521,5 +525,167 @@ type ZodUnionCheck = $ZodCheckLessThanDef | $ZodCheckGreaterThanDef | $ZodCheckM
  * @since 0.4.0
  */
 declare function getFieldChecks<T extends z.ZodTypeAny>(field: T): Array<ZodUnionCheck>;
+/**
+ * Recursively extracts the exact schema type from a discriminated union based on the discriminator value.
+ *
+ * This advanced TypeScript utility type walks through a union's options tuple at compile-time,
+ * checking each schema against the discriminator field and value, and returns the exact matching
+ * schema type (not a union of all options).
+ *
+ * **How it works:**
+ * 1. Extracts the options tuple from the union using `infer Options`
+ * 2. Destructure into head (`First`) and tail (`Rest`) using tuple pattern matching
+ * 3. Checks if `First` is a ZodObject with the matching discriminator field and value
+ * 4. If match found, returns `First` (the exact schema type)
+ * 5. If no match, recursively processes `Rest` until a match is found or list is exhausted
+ *
+ * **Type narrowing magic:**
+ * - Input: `z.discriminatedUnion('type', [SchemaA, SchemaB, SchemaC])`
+ * - Discriminator value: `'a'` (matches SchemaA)
+ * - Output: `SchemaA` (exact type, not `SchemaA | SchemaB | SchemaC`)
+ *
+ * @template TSchema - The ZodUnion or ZodDiscriminatedUnion type
+ * @template TDiscriminatorKey - The discriminator field name (e.g., "type", "mode")
+ * @template TDiscriminatorValue - The specific discriminator value (e.g., "create", "edit")
+ * @returns The exact matching schema type, or `never` if no match found
+ *
+ * @example
+ * ```typescript
+ * const schema = z.discriminatedUnion('mode', [
+ *   z.object({ mode: z.literal('create'), name: z.string() }),
+ *   z.object({ mode: z.literal('edit'), id: z.number() }),
+ * ]);
+ *
+ * // Exact type: z.object({ mode: z.literal('create'), name: z.string() })
+ * type CreateSchema = ExtractZodUnionMember<typeof schema, 'mode', 'create'>;
+ * ```
+ */
+type ExtractZodUnionMember<TSchema extends z.ZodUnion | z.ZodDiscriminatedUnion, TDiscriminatorKey extends keyof z.infer<TSchema> & string, TDiscriminatorValue extends z.infer<TSchema>[TDiscriminatorKey] & util.Literal> = TSchema extends z.ZodUnion<infer Options> ? Options extends readonly [
+    infer First extends z.ZodTypeAny,
+    ...infer Rest extends z.ZodTypeAny[]
+] ? First extends z.ZodObject<infer Shape> ? TDiscriminatorKey extends keyof Shape ? Shape[TDiscriminatorKey] extends z.ZodLiteral<TDiscriminatorValue> ? First : Rest extends [] ? never : TDiscriminatorValue extends $InferUnionOutput<Rest[number]>[TDiscriminatorKey] ? ExtractZodUnionMember<z.ZodUnion<Rest>, TDiscriminatorKey, TDiscriminatorValue> : never : Rest extends [] ? never : TDiscriminatorValue extends $InferUnionOutput<Rest[number]>[TDiscriminatorKey] ? ExtractZodUnionMember<z.ZodUnion<Rest>, TDiscriminatorKey, TDiscriminatorValue> : never : never : never : never;
+/**
+ * Extracts a specific schema option from a discriminated union based on the discriminator field value.
+ *
+ * This function finds and returns the **exact matching schema** from a `ZodDiscriminatedUnion` by
+ * comparing the discriminator field value. It's used internally by {@link getSchemaDefaults} to
+ * extract defaults from the correct schema variant in a discriminated union.
+ *
+ * **Key feature:** Returns the **exact schema type**, not a union of all options, thanks to the
+ * {@link ExtractZodUnionMember} recursive type utility. This enables precise type narrowing at
+ * compile-time based on the discriminator value.
+ *
+ * **How it works:**
+ * 1. Iterates through all options in the discriminated union at runtime
+ * 2. For each option, validates it's a ZodObject and checks if the discriminator field matches
+ * 3. Returns the first matching schema with its exact type narrowed at compile-time
+ * 4. Returns `undefined` if no match found or if option is not a ZodObject
+ *
+ * @template TSchema - The ZodUnion or ZodDiscriminatedUnion schema type
+ * @template TDiscriminatorKey - The discriminator field name (string key of the inferred union type)
+ * @template TDiscriminatorValue - The specific discriminator value to match (literal type)
+ * @param params - Parameters object
+ * @param params.schema - The discriminated union schema to search
+ * @param params.discriminatorKey - The discriminator field name (e.g., "mode", "type")
+ * @param params.discriminatorValue - The discriminator value to match (e.g., "create", "edit")
+ * @returns The exact matching schema option (with precise type), or `undefined` if not found
+ *
+ * @example
+ * Basic discriminated union - create/edit mode
+ * ```typescript
+ * const userSchema = z.discriminatedUnion('mode', [
+ *   z.object({
+ *     mode: z.literal('create'),
+ *     name: z.string(),
+ *     age: z.number().optional(),
+ *   }),
+ *   z.object({
+ *     mode: z.literal('edit'),
+ *     id: z.number(),
+ *     name: z.string().optional(),
+ *   }),
+ * ]);
+ *
+ * // Extract the "create" schema
+ * const createSchema = extractDiscriminatedSchema({
+ *   schema: userSchema,
+ *   discriminatorKey: 'mode',
+ *   discriminatorValue: 'create',
+ * });
+ * // Result: z.object({ mode: z.literal('create'), name: z.string(), age: z.number().optional() })
+ *
+ * // Extract the "edit" schema
+ * const editSchema = extractDiscriminatedSchema({
+ *   schema: userSchema,
+ *   discriminatorKey: 'mode',
+ *   discriminatorValue: 'edit',
+ * });
+ * // Result: z.object({ mode: z.literal('edit'), id: z.number(), name: z.string().optional() })
+ * ```
+ *
+ * @example
+ * Type-based discrimination
+ * ```typescript
+ * const eventSchema = z.discriminatedUnion('type', [
+ *   z.object({ type: z.literal('click'), x: z.number(), y: z.number() }),
+ *   z.object({ type: z.literal('keypress'), key: z.string() }),
+ * ]);
+ *
+ * const clickSchema = extractDiscriminatedSchema({
+ *   schema: eventSchema,
+ *   discriminatorKey: 'type',
+ *   discriminatorValue: 'click',
+ * });
+ * // Result: z.object({ type: z.literal('click'), x: z.number(), y: z.number() })
+ * ```
+ *
+ * @example
+ * Invalid discriminator value
+ * ```typescript
+ * const schema = z.discriminatedUnion('mode', [
+ *   z.object({ mode: z.literal('create'), name: z.string() }),
+ * ]);
+ *
+ * const result = extractDiscriminatedSchema({
+ *   schema,
+ *   discriminatorKey: 'mode',
+ *   discriminatorValue: 'invalid', // doesn't match any option
+ * });
+ * // Result: undefined
+ * ```
+ *
+ * @example
+ * Type narrowing demonstration
+ * ```typescript
+ * const schema = z.discriminatedUnion('mode', [
+ *   z.object({ mode: z.literal('create'), name: z.string(), age: z.number() }),
+ *   z.object({ mode: z.literal('edit'), id: z.number(), bio: z.string() }),
+ * ]);
+ *
+ * const createSchema = extractDiscriminatedSchema({
+ *   schema,
+ *   discriminatorKey: 'mode',
+ *   discriminatorValue: 'create',
+ * });
+ *
+ * // Type is EXACTLY: z.object({ mode: z.literal('create'), name: z.string(), age: z.number() })
+ * // NOT: z.object({ mode: ..., ... }) | z.object({ mode: ..., ... }) | undefined
+ *
+ * if (createSchema) {
+ *   createSchema.shape.age;  // ✅ TypeScript knows 'age' exists
+ *   createSchema.shape.name; // ✅ TypeScript knows 'name' exists
+ *   // createSchema.shape.id;   // ❌ TypeScript error: 'id' doesn't exist on 'create' schema
+ * }
+ * ```
+ *
+ * @see {@link getSchemaDefaults} for usage with discriminated unions
+ * @see {@link ExtractZodUnionMember} for the type-level extraction logic
+ * @since 0.6.0
+ */
+declare const extractDiscriminatedSchema: <TSchema extends z.ZodUnion | z.ZodDiscriminatedUnion, TDiscriminatorKey extends keyof z.infer<TSchema> & string, TDiscriminatorValue extends z.infer<TSchema>[TDiscriminatorKey] & util.Literal>({ schema, key, value, }: {
+    schema: TSchema;
+    key: TDiscriminatorKey;
+    value: TDiscriminatorValue;
+}) => ExtractZodUnionMember<TSchema, TDiscriminatorKey, TDiscriminatorValue> | undefined;
 
-export { type Simplify, type ZodUnionCheck, canUnwrap, extractDefault, getFieldChecks, getPrimitiveType, getSchemaDefaults, removeDefault, requiresValidInput, unwrapUnion };
+export { type Simplify, type ZodUnionCheck, canUnwrap, extractDefault, extractDiscriminatedSchema, extractFieldFromSchema, getFieldChecks, getPrimitiveType, getSchemaDefaults, removeDefault, requiresValidInput, tryStripNullishOnly };

package/dist/index.js

@@ -22,26 +22,37 @@ function _interopNamespace(e) {
 
 var z__namespace = /*#__PURE__*/_interopNamespace(z);
 
-// src/defaults.ts
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
 function canUnwrap(field) {
   return "unwrap" in field && typeof field.unwrap === "function";
 }
-function unwrapUnion(field, options = {}) {
-  const { filterNullish = true } = options;
+function tryStripNullishOnly(field) {
   if (field instanceof z__namespace.ZodUnion) {
     const unionOptions = [...field.def.options];
-    const filteredOptions = filterNullish ? unionOptions.filter(
+    const filteredOptions = unionOptions.filter(
       (option) => !(option instanceof z__namespace.ZodNull) && !(option instanceof z__namespace.ZodUndefined)
-    ) : unionOptions;
-    return {
-      field: filteredOptions[0] || field,
-      union: filteredOptions
-    };
+    );
+    const firstOption = filteredOptions[0];
+    if (firstOption && filteredOptions.length === 1) {
+      return firstOption;
+    }
   }
-  return {
-    field,
-    union: [field]
-  };
+  return false;
 }
 var getPrimitiveType = (field) => {
   if (field instanceof z__namespace.ZodArray) {
@@ -51,7 +62,11 @@ var getPrimitiveType = (field) => {
     return getPrimitiveType(field.unwrap());
   }
   if (field instanceof z__namespace.ZodUnion) {
-    return getPrimitiveType(unwrapUnion(field).field);
+    const unwrapped = tryStripNullishOnly(field);
+    if (unwrapped !== false) {
+      return getPrimitiveType(unwrapped);
+    }
+    return field;
   }
   return field;
 };
@@ -87,6 +102,23 @@ function getFieldChecks(field) {
   const primitiveType = getPrimitiveType(field);
   return ((_a = primitiveType.def.checks) == null ? void 0 : _a.map((check) => check._zod.def)) || [];
 }
+var extractDiscriminatedSchema = ({
+  schema,
+  key,
+  value
+}) => {
+  return schema.options.find(
+    (option) => {
+      if (option instanceof z__namespace.ZodObject) {
+        const targetField = option.shape[String(key)];
+        if (!targetField) return false;
+        const parseResult = targetField.safeParse(value);
+        return parseResult.success;
+      }
+      return false;
+    }
+  );
+};
 
 // src/defaults.ts
 function extractDefault(field) {
@@ -97,30 +129,67 @@ function extractDefault(field) {
     return extractDefault(field.unwrap());
   }
   if (field instanceof z__namespace.ZodUnion) {
-    return extractDefault(unwrapUnion(field).field);
+    const unwrapped = tryStripNullishOnly(field);
+    if (unwrapped !== false) {
+      return extractDefault(unwrapped);
+    }
+    return void 0;
   }
   return void 0;
 }
-function getSchemaDefaults(schema) {
+function getSchemaDefaults(schema, options) {
+  let targetSchema;
+  if (schema instanceof z__namespace.ZodDiscriminatedUnion) {
+    if (options == null ? void 0 : options.discriminator) {
+      targetSchema = extractDiscriminatedSchema(__spreadValues({
+        schema
+      }, options.discriminator));
+    }
+  } else {
+    targetSchema = 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;
+  if (targetSchema) {
+    for (const key in targetSchema.shape) {
+      const field = targetSchema.shape[key];
+      if (!field) continue;
+      const defaultValue = extractDefault(field);
+      if (defaultValue !== void 0) {
+        defaults[key] = defaultValue;
+      }
     }
   }
   return defaults;
 }
+function extractFieldFromSchema({
+  schema,
+  fieldName,
+  discriminator
+}) {
+  let targetSchema;
+  if (schema instanceof z.z.ZodDiscriminatedUnion) {
+    if (discriminator) {
+      targetSchema = extractDiscriminatedSchema(__spreadValues({
+        schema
+      }, discriminator));
+    }
+  } else {
+    targetSchema = schema;
+  }
+  if (!targetSchema) return void 0;
+  const field = targetSchema.shape[String(fieldName)];
+  return field;
+}
 
 exports.canUnwrap = canUnwrap;
 exports.extractDefault = extractDefault;
+exports.extractDiscriminatedSchema = extractDiscriminatedSchema;
+exports.extractFieldFromSchema = extractFieldFromSchema;
 exports.getFieldChecks = getFieldChecks;
 exports.getPrimitiveType = getPrimitiveType;
 exports.getSchemaDefaults = getSchemaDefaults;
 exports.removeDefault = removeDefault;
 exports.requiresValidInput = requiresValidInput;
-exports.unwrapUnion = unwrapUnion;
+exports.tryStripNullishOnly = tryStripNullishOnly;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map