@zod-utils/core 1.2.0 → 2.0.0

package/dist/index.d.ts

@@ -77,6 +77,63 @@ type Discriminator<TSchema extends z$1.ZodType, TDiscriminatorKey extends Discri
     key: TDiscriminatorKey;
     value: TDiscriminatorValue;
 };
+type Primitive = string | number | boolean | null | undefined | symbol | bigint;
+type NonZeroDigit = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+type PathsHint<T, Prefix extends string = ''> = T extends Primitive ? never : T extends (infer E)[] ? (Prefix extends '' ? never : Prefix) | `${Prefix}.0` | PathsHint<E, `${Prefix}.0`> : T extends object ? {
+    [K in keyof T & string]: (Prefix extends '' ? K : `${Prefix}.${K}`) | PathsHint<T[K], Prefix extends '' ? K : `${Prefix}.${K}`>;
+}[keyof T & string] : never;
+type NonZeroIndex = `${NonZeroDigit}` | `${NonZeroDigit}${number}`;
+type PathsLoose<T, Prefix extends string = ''> = T extends Primitive ? never : T extends (infer E)[] ? (Prefix extends '' ? never : Prefix) | `${Prefix}.${NonZeroIndex}` | PathsLoose<E, `${Prefix}.${NonZeroIndex}`> : T extends object ? {
+    [K in keyof T & string]: (Prefix extends '' ? K : `${Prefix}.${K}`) | PathsLoose<T[K], Prefix extends '' ? K : `${Prefix}.${K}`>;
+}[keyof T & string] : never;
+/**
+ * Generates all valid dot-notation paths for a given type.
+ * Supports nested objects and arrays with numeric indices.
+ *
+ * @example
+ * ```typescript
+ * type User = { name: string; address: { city: string } };
+ * type UserPaths = Paths<User>;
+ * // "name" | "address" | "address.city"
+ * ```
+ */
+type Paths<T> = PathsHint<T> | PathsLoose<T>;
+/**
+ * Extracts fields common to all variants in a union type.
+ *
+ * Uses `Pick<T, keyof T>` to normalize union types by extracting only
+ * the keys that exist across all union members.
+ *
+ * @example
+ * ```typescript
+ * type A = { mode: 'create'; name: string };
+ * type B = { mode: 'edit'; id: number };
+ * type Common = CommonFields<A | B>;
+ * // { mode: 'create' | 'edit' }
+ * ```
+ */
+type CommonFields<T> = Pick<T, keyof T>;
+/**
+ * Generates valid dot-notation paths for fields in a discriminated union variant.
+ *
+ * Given a schema and discriminator value, extracts all possible field paths
+ * (including nested paths) for that specific variant.
+ *
+ * @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() }),
+ * ]);
+ *
+ * type CreatePaths = ValidPaths<typeof schema, 'mode', 'create'>;
+ * // "mode" | "name"
+ *
+ * type EditPaths = ValidPaths<typeof schema, 'mode', 'edit'>;
+ * // "mode" | "id"
+ * ```
+ */
+type ValidPaths<TSchema extends z$1.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>> = Paths<CommonFields<Extract<Required<z$1.input<TSchema>>, TDiscriminatorKey extends never ? z$1.input<TSchema> : TDiscriminatorValue extends never ? z$1.input<TSchema> : Simplify<Record<TDiscriminatorKey, TDiscriminatorValue>>>>>;
 
 /**
  * Extracts the default value from a Zod field, recursively unwrapping optional, nullable, and union layers.
@@ -213,11 +270,200 @@ declare function getSchemaDefaults<TSchema extends z.ZodType, TDiscriminatorKey
     discriminator?: Discriminator<TSchema, TDiscriminatorKey, TDiscriminatorValue>;
 }): Simplify<Partial<z.input<TSchema>>>;
 
-declare function extractFieldFromSchema<TSchema extends z$1.ZodType, TName extends keyof Extract<Required<z$1.input<TSchema>>, Record<TDiscriminatorKey, TDiscriminatorValue>>, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>>({ schema, fieldName, discriminator, }: {
+/**
+ * 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$1.ZodUnion | z$1.ZodDiscriminatedUnion, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends z$1.input<TSchema>[TDiscriminatorKey] & util.Literal> = TSchema extends z$1.ZodUnion<infer Options> ? Options extends readonly [
+    infer First extends z$1.ZodTypeAny,
+    ...infer Rest extends z$1.ZodTypeAny[]
+] ? First extends z$1.ZodObject<infer Shape> ? TDiscriminatorKey extends keyof Shape ? Shape[TDiscriminatorKey] extends z$1.ZodLiteral<TDiscriminatorValue> | z$1.ZodDefault<z$1.ZodLiteral<TDiscriminatorValue>> ? First : Rest extends [] ? never : TDiscriminatorValue extends $InferUnionInput<Rest[number]>[TDiscriminatorKey] ? ExtractZodUnionMember<z$1.ZodUnion<Rest>, TDiscriminatorKey, TDiscriminatorValue> : never : Rest extends [] ? never : TDiscriminatorValue extends $InferUnionInput<Rest[number]>[TDiscriminatorKey] ? ExtractZodUnionMember<z$1.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$1.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>, ReturnType extends TSchema extends z$1.ZodDiscriminatedUnion ? ExtractZodUnionMember<TSchema, TDiscriminatorKey, TDiscriminatorValue> : never>({ schema, key, value, }: {
+    schema: TSchema;
+} & Discriminator<TSchema, TDiscriminatorKey, TDiscriminatorValue>) => ReturnType;
+
+type Split<S extends string> = S extends `${infer Head}.${infer Tail}` ? [Head, ...Split<Tail>] : [S];
+type IsNumeric<S extends string> = S extends `${number}` ? true : false;
+type Unwrap<T> = T extends z$1.ZodOptional<infer U> ? Unwrap<U> : T extends z$1.ZodNullable<infer U> ? Unwrap<U> : T extends z$1.ZodDefault<infer U> ? Unwrap<U> : T;
+type NavigateZod<T, Path extends string[]> = Path extends [
+    infer First extends string,
+    ...infer Rest extends string[]
+] ? Unwrap<T> extends z$1.ZodObject<infer Shape> ? First extends keyof Shape ? Rest extends [] ? Shape[First] : NavigateZod<Shape[First], Rest> : never : Unwrap<T> extends z$1.ZodArray<infer Element> ? IsNumeric<First> extends true ? Rest extends [] ? Element : NavigateZod<Element, Rest> : never : never : T;
+type ExtractZodByPath<Schema, Path extends string> = NavigateZod<Schema, Split<Path>>;
+declare function extractFieldFromSchema<TSchema extends z$1.ZodType, TPath extends ValidPaths<TSchema, TDiscriminatorKey, TDiscriminatorValue>, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>>({ schema, name, discriminator, }: {
     schema: TSchema;
-    fieldName: TName;
+    name: TPath;
     discriminator?: Discriminator<TSchema, TDiscriminatorKey, TDiscriminatorValue>;
-}): z$1.ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>> | undefined;
+}): (ExtractZodByPath<TSchema, TPath> & z$1.ZodType) | undefined;
+/**
+ * Extends a Zod field with a transformation while preserving its metadata.
+ *
+ * This is useful when you want to add validations or transformations to a field
+ * but keep the original metadata (like translationKey) intact.
+ *
+ * @param field - The original Zod field
+ * @param transform - A function that transforms the field
+ * @returns The transformed field with preserved metadata
+ *
+ * @example
+ * ```typescript
+ * const baseField = z.string().meta({ translationKey: 'user.field.name' });
+ *
+ * // Add min/max validation while keeping the translationKey
+ * const extendedField = extendWithMeta(baseField, (f) => f.min(3).max(100));
+ * extendedField.meta(); // { translationKey: 'user.field.name' }
+ * ```
+ */
+declare function extendWithMeta<T extends z$1.ZodType, R extends z$1.ZodType>(field: T, transform: (f: T) => R): R;
 
 /**
  * Type representing a Zod type that has an unwrap method
@@ -551,165 +797,5 @@ type ZodUnionCheck = $ZodCheckLessThanDef | $ZodCheckGreaterThanDef | $ZodCheckM
  * @since 0.4.0
  */
 declare function getFieldChecks<T extends z$1.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$1.ZodUnion | z$1.ZodDiscriminatedUnion, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends z$1.input<TSchema>[TDiscriminatorKey] & util.Literal> = TSchema extends z$1.ZodUnion<infer Options> ? Options extends readonly [
-    infer First extends z$1.ZodTypeAny,
-    ...infer Rest extends z$1.ZodTypeAny[]
-] ? First extends z$1.ZodObject<infer Shape> ? TDiscriminatorKey extends keyof Shape ? Shape[TDiscriminatorKey] extends z$1.ZodLiteral<TDiscriminatorValue> | z$1.ZodDefault<z$1.ZodLiteral<TDiscriminatorValue>> ? First : Rest extends [] ? never : TDiscriminatorValue extends $InferUnionInput<Rest[number]>[TDiscriminatorKey] ? ExtractZodUnionMember<z$1.ZodUnion<Rest>, TDiscriminatorKey, TDiscriminatorValue> : never : Rest extends [] ? never : TDiscriminatorValue extends $InferUnionInput<Rest[number]>[TDiscriminatorKey] ? ExtractZodUnionMember<z$1.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$1.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>, ReturnType extends TSchema extends z$1.ZodDiscriminatedUnion ? ExtractZodUnionMember<TSchema, TDiscriminatorKey, TDiscriminatorValue> : never>({ schema, key, value, }: {
-    schema: TSchema;
-} & Discriminator<TSchema, TDiscriminatorKey, TDiscriminatorValue>) => ReturnType;
 
-export { type Discriminator, type DiscriminatorKey, type DiscriminatorValue, type Simplify, type ZodUnionCheck, canUnwrap, extractDefaultValue, extractDiscriminatedSchema, extractFieldFromSchema, getFieldChecks, getPrimitiveType, getSchemaDefaults, removeDefault, requiresValidInput, tryStripNullishOnly };
+export { type CommonFields, type Discriminator, type DiscriminatorKey, type DiscriminatorValue, type ExtractZodByPath, type Paths, type Simplify, type ValidPaths, type ZodUnionCheck, canUnwrap, extendWithMeta, extractDefaultValue, extractDiscriminatedSchema, extractFieldFromSchema, getFieldChecks, getPrimitiveType, getSchemaDefaults, removeDefault, requiresValidInput, tryStripNullishOnly };

package/dist/index.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var z2 = require('zod');
+var z3 = require('zod');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -20,7 +20,7 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var z2__namespace = /*#__PURE__*/_interopNamespace(z2);
+var z3__namespace = /*#__PURE__*/_interopNamespace(z3);
 
 var __defProp = Object.defineProperty;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
@@ -38,14 +38,32 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
+var extractDiscriminatedSchema = ({
+  schema,
+  key,
+  value
+}) => {
+  if (!(schema instanceof z3.z.ZodDiscriminatedUnion)) {
+    return void 0;
+  }
+  return schema.options.find((option) => {
+    if (option instanceof z3.z.ZodObject) {
+      const targetField = option.shape[String(key)];
+      if (!targetField) return false;
+      const parseResult = targetField.safeParse(value);
+      return parseResult.success;
+    }
+    return false;
+  });
+};
 function canUnwrap(field) {
   return "unwrap" in field && typeof field.unwrap === "function";
 }
 function tryStripNullishOnly(field) {
-  if (field instanceof z2.z.ZodUnion) {
+  if (field instanceof z3.z.ZodUnion) {
     const unionOptions = [...field.def.options];
     const filteredOptions = unionOptions.filter(
-      (option) => !(option instanceof z2.z.ZodNull) && !(option instanceof z2.z.ZodUndefined)
+      (option) => !(option instanceof z3.z.ZodNull) && !(option instanceof z3.z.ZodUndefined)
     );
     const firstOption = filteredOptions[0];
     if (firstOption && filteredOptions.length === 1) {
@@ -55,34 +73,34 @@ function tryStripNullishOnly(field) {
   return false;
 }
 var getPrimitiveType = (field) => {
-  if (field instanceof z2.z.ZodArray) {
+  if (field instanceof z3.z.ZodArray) {
     return field;
   }
   if (canUnwrap(field)) {
     return getPrimitiveType(field.unwrap());
   }
-  if (field instanceof z2.z.ZodUnion) {
+  if (field instanceof z3.z.ZodUnion) {
     const unwrapped = tryStripNullishOnly(field);
     if (unwrapped !== false) {
       return getPrimitiveType(unwrapped);
     }
     return field;
   }
-  if (field instanceof z2.z.ZodPipe && field.def.in instanceof z2.z.ZodType) {
+  if (field instanceof z3.z.ZodPipe && field.def.in instanceof z3.z.ZodType) {
     return getPrimitiveType(field.def.in);
   }
   return field;
 };
 function removeDefault(field) {
-  if (field instanceof z2.z.ZodDefault) {
+  if (field instanceof z3.z.ZodDefault) {
     return field.unwrap();
   }
-  if ("innerType" in field.def && field.def.innerType instanceof z2.z.ZodType) {
+  if ("innerType" in field.def && field.def.innerType instanceof z3.z.ZodType) {
     const inner = removeDefault(field.def.innerType);
-    if (field instanceof z2.z.ZodOptional) {
+    if (field instanceof z3.z.ZodOptional) {
       return inner.optional();
     }
-    if (field instanceof z2.z.ZodNullable) {
+    if (field instanceof z3.z.ZodNullable) {
       return inner.nullable();
     }
   }
@@ -90,7 +108,7 @@ function removeDefault(field) {
 }
 var requiresValidInput = (field) => {
   const defaultRemovedField = removeDefault(field);
-  if (!(defaultRemovedField instanceof z2.z.ZodType)) {
+  if (!(defaultRemovedField instanceof z3.z.ZodType)) {
     return false;
   }
   const undefinedResult = defaultRemovedField.safeParse(void 0).success;
@@ -105,41 +123,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
-}) => {
-  if (!(schema instanceof z2.z.ZodDiscriminatedUnion)) {
-    return void 0;
-  }
-  return schema.options.find((option) => {
-    if (option instanceof z2.z.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 extractDefaultValue(field) {
-  if (field instanceof z2__namespace.ZodDefault) {
+  if (field instanceof z3__namespace.ZodDefault) {
     return field.def.defaultValue;
   }
   if (canUnwrap(field)) {
     return extractDefaultValue(field.unwrap());
   }
-  if (field instanceof z2__namespace.ZodUnion) {
+  if (field instanceof z3__namespace.ZodUnion) {
     const unwrapped = tryStripNullishOnly(field);
     if (unwrapped !== false) {
       return extractDefaultValue(unwrapped);
     }
     return void 0;
   }
-  if (field instanceof z2__namespace.ZodPipe && field.def.in instanceof z2__namespace.ZodType) {
+  if (field instanceof z3__namespace.ZodPipe && field.def.in instanceof z3__namespace.ZodType) {
     return extractDefaultValue(field.def.in);
   }
   return void 0;
@@ -147,13 +147,13 @@ function extractDefaultValue(field) {
 function getSchemaDefaults(schema, options) {
   const primitiveSchema = getPrimitiveType(schema);
   let targetSchema;
-  if (primitiveSchema instanceof z2__namespace.ZodDiscriminatedUnion) {
+  if (primitiveSchema instanceof z3__namespace.ZodDiscriminatedUnion) {
     if (options == null ? void 0 : options.discriminator) {
       targetSchema = extractDiscriminatedSchema(__spreadValues({
         schema: primitiveSchema
       }, options.discriminator));
     }
-  } else if (primitiveSchema instanceof z2__namespace.ZodObject) {
+  } else if (primitiveSchema instanceof z3__namespace.ZodObject) {
     targetSchema = primitiveSchema;
   }
   const defaults = {};
@@ -171,26 +171,50 @@ function getSchemaDefaults(schema, options) {
 }
 function extractFieldFromSchema({
   schema,
-  fieldName,
+  name,
   discriminator
 }) {
-  let targetSchema;
+  let currentSchema;
   const primitiveSchema = getPrimitiveType(schema);
-  if (primitiveSchema instanceof z2.z.ZodDiscriminatedUnion) {
+  if (primitiveSchema instanceof z3.z.ZodDiscriminatedUnion) {
     if (discriminator) {
-      targetSchema = extractDiscriminatedSchema(__spreadValues({
+      currentSchema = extractDiscriminatedSchema(__spreadValues({
         schema: primitiveSchema
       }, discriminator));
     }
-  } else if (primitiveSchema instanceof z2.z.ZodObject) {
-    targetSchema = primitiveSchema;
+  } else if (primitiveSchema instanceof z3.z.ZodObject) {
+    currentSchema = primitiveSchema;
+  }
+  if (!currentSchema) return void 0;
+  const segments = String(name).split(".");
+  for (const segment of segments) {
+    if (!currentSchema) return void 0;
+    const unwrapped = getPrimitiveType(currentSchema);
+    if (unwrapped instanceof z3.z.ZodObject) {
+      currentSchema = unwrapped.shape[segment];
+    } else if (unwrapped instanceof z3.z.ZodArray) {
+      if (/^\d+$/.test(segment) && unwrapped.element instanceof z3.z.ZodType) {
+        currentSchema = unwrapped.element;
+      } else {
+        return void 0;
+      }
+    } else {
+      return void 0;
+    }
   }
-  if (!targetSchema) return void 0;
-  const field = targetSchema.shape[String(fieldName)];
-  return field;
+  return currentSchema;
+}
+function extendWithMeta(field, transform) {
+  const transformedField = transform(field);
+  const meta = field.meta();
+  if (!meta) {
+    return transformedField;
+  }
+  return transformedField.meta(__spreadValues({}, meta));
 }
 
 exports.canUnwrap = canUnwrap;
+exports.extendWithMeta = extendWithMeta;
 exports.extractDefaultValue = extractDefaultValue;
 exports.extractDiscriminatedSchema = extractDiscriminatedSchema;
 exports.extractFieldFromSchema = extractFieldFromSchema;