@zod-utils/react-hook-form 5.0.0 → 6.0.1

package/README.md

@@ -343,10 +343,9 @@ function FieldComponent() {
 }
 ```
 
-### `useIsRequiredField({ schema?, name?, discriminator? })`
+### `useIsRequiredField({ schema, name, discriminator? })`
 
 Hook to check if a field requires valid input (shows validation errors on submit).
-Returns `false` if schema or name is not provided, making it safe to use in conditional contexts.
 
 ```tsx
 import { useIsRequiredField } from "@zod-utils/react-hook-form";
@@ -451,18 +450,19 @@ import {
   useFieldChecks,
 
   // Form field utilities
-  toFormFieldSelector,
   flattenFieldSelector,
 
   // Type utilities
   type PartialWithNullableObjects,
   type PartialWithAllNullables,
-  type Discriminator,
+  type DiscriminatorProps,
   type DiscriminatorKey,
   type DiscriminatorValue,
-  type InferredFieldValues,
-  type ValidFieldPaths,
-  type FormFieldSelector,
+  type SchemaProps,
+  type SchemaAndDiscriminatorProps,
+  type NameProps,
+  type NameAndDiscriminatorProps,
+  type FieldSelectorProps,
 } from "@zod-utils/react-hook-form";
 ```
 
@@ -530,127 +530,6 @@ Use this when all fields need to accept `null`, not just objects/arrays.
 
 ---
 
-#### `ValidFieldPaths<TSchema, TDiscriminatorKey?, TDiscriminatorValue?, TFieldValues?, TFilterType?, TStrict?>`
-
-Type-safe field paths for React Hook Form with optional type filtering and discriminated union support.
-
-```typescript
-import type { ValidFieldPaths } from "@zod-utils/react-hook-form";
-import { z } from "zod";
-
-const schema = z.object({
-  name: z.string(),
-  age: z.number(),
-  score: z.number().optional(),
-  active: z.boolean(),
-});
-
-// Get all field paths
-type AllPaths = ValidFieldPaths<typeof schema>;
-// "name" | "age" | "score" | "active"
-
-// Filter by type - only number field paths (use TFilterType parameter)
-type NumberPaths = ValidFieldPaths<typeof schema, never, never, never, number>;
-// "age" | "score"
-
-// Only accept boolean field paths
-type BooleanPaths = ValidFieldPaths<typeof schema, never, never, never, boolean>;
-// "active"
-```
-
-**Use case - Type-safe form field components:**
-
-```tsx
-// NumberFormField only accepts paths to number fields
-function NumberFormField<
-  TSchema extends z.ZodType,
-  TPath extends ValidFieldPaths<TSchema, never, never, never, number>
->({ schema, name }: { schema: TSchema; name: TPath }) {
-  // name is guaranteed to be a path to a number field
-  return <input type="number" name={name} />;
-}
-
-// ✅ Works - 'age' is a number field
-<NumberFormField schema={schema} name="age" />
-
-// ❌ TypeScript error - 'name' is a string field, not number
-<NumberFormField schema={schema} name="name" />
-```
-
-**With discriminated unions:**
-
-```typescript
-const formSchema = z.discriminatedUnion("mode", [
-  z.object({ mode: z.literal("create"), name: z.string(), priority: z.number() }),
-  z.object({ mode: z.literal("edit"), id: z.number(), rating: z.number() }),
-]);
-
-// Number paths for 'edit' variant
-type EditNumberPaths = ValidFieldPaths<
-  typeof formSchema,
-  "mode",
-  "edit",
-  never,
-  number
->;
-// "id" | "rating"
-```
-
----
-
-#### `FormFieldSelector<TSchema, TPath, TDiscriminatorKey?, TDiscriminatorValue?, TFieldValues?, TFilterType?, TStrict?>`
-
-Type-safe field selector for React Hook Form with discriminated union support. Useful for building form field components with type-safe props.
-
-```typescript
-import type { FormFieldSelector } from "@zod-utils/react-hook-form";
-import { z } from "zod";
-
-const schema = z.object({
-  name: z.string(),
-  age: z.number(),
-});
-
-// Basic usage - no discriminator needed
-type NameSelector = FormFieldSelector<typeof schema, "name">;
-// { schema: typeof schema; name: "name" }
-
-// With discriminated union
-const formSchema = z.discriminatedUnion("mode", [
-  z.object({ mode: z.literal("create"), name: z.string() }),
-  z.object({ mode: z.literal("edit"), id: z.number() }),
-]);
-
-type CreateNameSelector = FormFieldSelector<typeof formSchema, "name", "mode", "create">;
-// { schema: typeof formSchema; name: "name"; discriminator: { key: "mode"; value: "create" } }
-```
-
----
-
-#### `toFormFieldSelector(props)`
-
-Extracts a `FormFieldSelector` from props containing schema, name, and optional discriminator. Encapsulates type assertion so callers don't need eslint-disable.
-
-```typescript
-import { toFormFieldSelector } from "@zod-utils/react-hook-form";
-
-// In a form field component
-function InputFormField<TSchema extends z.ZodType>({ schema, name, discriminator, ...inputProps }) {
-  const selectorProps = toFormFieldSelector({ schema, name, discriminator });
-  // Use selectorProps for extractFieldFromSchema, useIsRequiredField, etc.
-}
-
-// In a factory function
-function createInputFormField<TSchema extends z.ZodType>({ schema }: { schema: TSchema }) {
-  return function BoundInputFormField({ name, discriminator, ...rest }) {
-    const selectorProps = toFormFieldSelector({ schema, name, discriminator });
-    return <InputFormField {...selectorProps} {...rest} />;
-  };
-}
-```
-
----
-
 #### `flattenFieldSelector(params)`
 
 Flattens a `FieldSelector` into an array of primitive values for use in React dependency arrays.
@@ -769,65 +648,6 @@ form.register("nonexistent.field");
 
 ---
 
-## Migration Guide
-
-### Migrating to v3.0.0
-
-#### `ValidFieldPathsOfType` removed → Use `ValidFieldPaths` with type filtering
-
-The `ValidFieldPathsOfType` type has been removed and consolidated into `ValidFieldPaths` with a new `TFilterType` parameter.
-
-**Before (v2.x):**
-```typescript
-import type { ValidFieldPathsOfType } from "@zod-utils/react-hook-form";
-
-// Get number field paths
-type NumberPaths = ValidFieldPathsOfType<typeof schema, number>;
-
-// With discriminated union
-type EditNumberPaths = ValidFieldPathsOfType<typeof schema, number, "mode", "edit">;
-```
-
-**After (v3.x):**
-```typescript
-import type { ValidFieldPaths } from "@zod-utils/react-hook-form";
-
-// Get number field paths - TFilterType is now the 5th parameter
-type NumberPaths = ValidFieldPaths<typeof schema, never, never, never, number>;
-
-// With discriminated union
-type EditNumberPaths = ValidFieldPaths<typeof schema, "mode", "edit", never, number>;
-```
-
-**Parameter order change:**
-- v2.x: `ValidFieldPathsOfType<TSchema, TValueConstraint, TDiscriminatorKey, TDiscriminatorValue, TFieldValues>`
-- v3.x: `ValidFieldPaths<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFieldValues, TFilterType, TStrict>`
-
-### Migrating to v4.0.0
-
-#### `mergeFormFieldSelectorProps` renamed → Use `toFormFieldSelector`
-
-The function has been renamed and simplified to accept a single props object.
-
-**Before (v3.x):**
-```typescript
-import { mergeFormFieldSelectorProps } from "@zod-utils/react-hook-form";
-
-const selectorProps = mergeFormFieldSelectorProps(
-  { schema },
-  { name, discriminator }
-);
-```
-
-**After (v4.x):**
-```typescript
-import { toFormFieldSelector } from "@zod-utils/react-hook-form";
-
-const selectorProps = toFormFieldSelector({ schema, name, discriminator });
-```
-
----
-
 ## License
 
 MIT

package/dist/index.d.mts

@@ -1,22 +1,21 @@
-import { DiscriminatorKey, DiscriminatorValue, FieldSelector, ValidPaths, Discriminator, ExtractZodByPath, ZodUnionCheck, Simplify, InnerFieldSelector } from '@zod-utils/core';
+import { DiscriminatorKey, DiscriminatorValue, SchemaAndDiscriminatorProps, FieldSelectorProps, ZodUnionCheck, Simplify } from '@zod-utils/core';
 export * from '@zod-utils/core';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { Context, ReactNode } from 'react';
 import { z } from 'zod';
-import { SomeType } from 'zod/v4/core';
 import * as react_hook_form from 'react-hook-form';
-import { FieldValues, Path, UseFormProps } from 'react-hook-form';
+import { FieldValues, UseFormProps } from 'react-hook-form';
 import { zodResolver } from '@hookform/resolvers/zod';
 
 /**
  * Type for the FormSchemaContext with full generic support.
  * @internal
  */
-type FormSchemaContextType<TSchema extends z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>, TFilterType = unknown, TStrict extends boolean = true> = Context<Omit<FieldSelector<TSchema, ValidPaths<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>, 'name'> | null>;
+type FormSchemaContextType<TSchema extends z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>> = Context<SchemaAndDiscriminatorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue> | null>;
 /**
  * Context value type for FormSchemaContext.
  */
-type FormSchemaContextValue<TSchema extends z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>, TFilterType = unknown, TStrict extends boolean = true> = Omit<FieldSelector<TSchema, ValidPaths<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>, 'name'> | null;
+type FormSchemaContextValue<TSchema extends z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>> = SchemaAndDiscriminatorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue> | null;
 /**
  * React Context for providing Zod schema to form components.
  *
@@ -57,19 +56,7 @@ declare const FormSchemaContext: Context<{
  * }
  * ```
  */
-declare function useFormSchema<TSchema extends z.ZodType = z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema> = DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = DiscriminatorValue<TSchema, TDiscriminatorKey>, TFilterType = unknown, TStrict extends boolean = true>(_params?: TSchema extends z.ZodPipe<infer In, SomeType> ? In extends z.ZodDiscriminatedUnion ? {
-    schema: TSchema;
-    discriminator: Discriminator<TSchema, TDiscriminatorKey, TDiscriminatorValue>;
-} : {
-    schema: TSchema;
-    discriminator?: undefined;
-} : TSchema extends z.ZodDiscriminatedUnion ? {
-    schema: TSchema;
-    discriminator: Discriminator<TSchema, TDiscriminatorKey, TDiscriminatorValue>;
-} : {
-    schema: TSchema;
-    discriminator?: undefined;
-}): FormSchemaContextValue<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>;
+declare function useFormSchema<TSchema extends z.ZodType = z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema> = DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = DiscriminatorValue<TSchema, TDiscriminatorKey>>(_params?: SchemaAndDiscriminatorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue>): FormSchemaContextValue<TSchema, TDiscriminatorKey, TDiscriminatorValue>;
 /**
  * Provider component that makes Zod schema available to all child components.
  *
@@ -105,19 +92,7 @@ declare function useFormSchema<TSchema extends z.ZodType = z.ZodType, TDiscrimin
  * </FormSchemaProvider>
  * ```
  */
-declare function FormSchemaProvider<TSchema extends z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>>({ schema, discriminator, children, }: (TSchema extends z.ZodPipe<infer In, SomeType> ? In extends z.ZodDiscriminatedUnion ? {
-    schema: TSchema;
-    discriminator: Discriminator<TSchema, TDiscriminatorKey, TDiscriminatorValue>;
-} : {
-    schema: TSchema;
-    discriminator?: undefined;
-} : TSchema extends z.ZodDiscriminatedUnion ? {
-    schema: TSchema;
-    discriminator: Discriminator<TSchema, TDiscriminatorKey, TDiscriminatorValue>;
-} : {
-    schema: TSchema;
-    discriminator?: undefined;
-}) & {
+declare function FormSchemaProvider<TSchema extends z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>>({ schema, discriminator, children, }: SchemaAndDiscriminatorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue> & {
     children: ReactNode;
 }): react_jsx_runtime.JSX.Element;
 /**
@@ -125,8 +100,8 @@ declare function FormSchemaProvider<TSchema extends z.ZodType, TDiscriminatorKey
  *
  * Memoized - only recalculates when schema, name, or discriminator changes.
  *
- * @param params - Schema, name, and optional discriminator (schema and name are optional)
- * @returns true if the field requires valid input, false if it doesn't or if schema/name is not provided
+ * @param params - Schema, name, and optional discriminator
+ * @returns true if the field requires valid input, false otherwise
  *
  * @example
  * ```tsx
@@ -142,11 +117,7 @@ declare function FormSchemaProvider<TSchema extends z.ZodType, TDiscriminatorKey
  * }
  * ```
  */
-declare function useIsRequiredField<TSchema extends z.ZodType, TPath extends ValidPaths<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>, TFilterType = unknown, TStrict extends boolean = true>(params: FieldSelector<TSchema, TPath, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict> | {
-    schema?: undefined;
-    name?: undefined;
-    discriminator?: undefined;
-}): boolean;
+declare function useIsRequiredField<TSchema extends z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema> = never, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = never, TFilterType = unknown, TStrict extends boolean = true>(params: FieldSelectorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict> | undefined): boolean;
 /**
  * Determines if a field requires valid input (will show validation errors on empty/invalid input).
  *
@@ -188,7 +159,7 @@ declare function useIsRequiredField<TSchema extends z.ZodType, TPath extends Val
  * }); // true
  * ```
  */
-declare function isRequiredField<TSchema extends z.ZodType, TPath extends ValidPaths<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>, TFilterType = unknown, TStrict extends boolean = true>(params: FieldSelector<TSchema, TPath, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>): boolean;
+declare function isRequiredField<TSchema extends z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema> = never, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = never, TFilterType = unknown, TStrict extends boolean = true>(params: FieldSelectorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>): boolean;
 /**
  * React hook to extract a field's Zod schema from a parent schema.
  *
@@ -226,7 +197,7 @@ declare function isRequiredField<TSchema extends z.ZodType, TPath extends ValidP
  * // Returns z.string() schema
  * ```
  */
-declare function useExtractFieldFromSchema<TSchema extends z.ZodType, TPath extends ValidPaths<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>, TDiscriminatorKey extends DiscriminatorKey<TSchema> = never, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = never, TFilterType = unknown, TStrict extends boolean = true>(params: FieldSelector<TSchema, TPath, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>): (ExtractZodByPath<TSchema, TPath> & z.ZodType) | undefined;
+declare function useExtractFieldFromSchema<TSchema extends z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema> = never, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = never, TFilterType = unknown, TStrict extends boolean = true>(params: FieldSelectorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict> | undefined): z.ZodType | undefined;
 /**
  * Hook to get validation checks from a field's Zod schema.
  *
@@ -249,7 +220,7 @@ declare function useExtractFieldFromSchema<TSchema extends z.ZodType, TPath exte
  * }
  * ```
  */
-declare function useFieldChecks<TSchema extends z.ZodType, TPath extends ValidPaths<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>, TFilterType = unknown, TStrict extends boolean = true>(params: FieldSelector<TSchema, TPath, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>): ZodUnionCheck[];
+declare function useFieldChecks<TSchema extends z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema> = never, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = never, TFilterType = unknown, TStrict extends boolean = true>(params: FieldSelectorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict> | undefined): ZodUnionCheck[];
 
 /**
  * Helper type that adds `null` to object-type fields only (excludes arrays).
@@ -298,115 +269,6 @@ type PartialWithNullableObjects<T> = Simplify<Partial<AddNullToObjects<T>>>;
 type PartialWithAllNullables<T> = {
     [K in keyof T]?: T[K] | null;
 };
-/**
- * Infers field values from a Zod schema compatible with React Hook Form's FieldValues.
- *
- * @example
- * ```typescript
- * const schema = z.object({ name: z.string() });
- * type Values = InferredFieldValues<typeof schema>;
- * // { name: string } & FieldValues
- * ```
- */
-type InferredFieldValues<TSchema extends z.ZodType> = z.input<TSchema> & FieldValues;
-/**
- * Type-safe field paths for React Hook Form with optional filtering and discriminated union support.
- *
- * Combines `ValidPaths` from `@zod-utils/core` with React Hook Form's `Path` type
- * for full compatibility with form field APIs.
- *
- * @template TSchema - The Zod schema type
- * @template TDiscriminatorKey - The discriminator key (for discriminated unions)
- * @template TDiscriminatorValue - The discriminator value (for discriminated unions)
- * @template TFilterType - The value type to filter by (default: unknown = no filtering)
- * @template TStrict - Whether to use strict type matching (default: true)
- * @template TFieldValues - The form field values type (inferred from schema)
- *
- * @example
- * Basic usage - all field paths
- * ```typescript
- * const schema = z.object({
- *   name: z.string(),
- *   age: z.number(),
- * });
- *
- * type AllFields = ValidFieldPaths<typeof schema>;
- * // "name" | "age"
- * ```
- *
- * @example
- * Filter by type - string fields only
- * ```typescript
- * const schema = z.object({
- *   name: z.string(),
- *   age: z.number(),
- *   email: z.string().optional(),
- * });
- *
- * type StringFields = ValidFieldPaths<typeof schema, never, never, string>;
- * // "name" | "email"
- * ```
- *
- * @example
- * With discriminated union
- * ```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 CreateFields = ValidFieldPaths<typeof schema, 'mode', 'create'>;
- * // "mode" | "name"
- *
- * type EditNumberFields = ValidFieldPaths<typeof schema, 'mode', 'edit', number>;
- * // "id"
- * ```
- *
- * @see {@link ValidPaths} for the base type without react-hook-form Path intersection
- */
-type ValidFieldPaths<TSchema extends z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema> = never, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = never, TFieldValues extends InferredFieldValues<TSchema> = InferredFieldValues<TSchema>, TFilterType = unknown, TStrict extends boolean = true> = ValidPaths<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict> & Path<TFieldValues>;
-/**
- * Type-safe field selector for React Hook Form with discriminated union support.
- *
- * Returns an object type containing:
- * - `schema` - The Zod schema
- * - `name` - The field path (type-safe)
- * - `discriminator` - Required for discriminated unions, contains `key` and `value`
- *
- * @template TSchema - The Zod schema type
- * @template TPath - The field path
- * @template TDiscriminatorKey - The discriminator key (for discriminated unions)
- * @template TDiscriminatorValue - The discriminator value (for discriminated unions)
- * @template TFilterType - The value type to filter by (default: unknown = no filtering)
- * @template TStrict - Whether to use strict type matching (default: true)
- *
- * @example
- * Basic usage with regular schema
- * ```typescript
- * const schema = z.object({
- *   name: z.string(),
- *   age: z.number(),
- * });
- *
- * type NameSelector = FormFieldSelector<typeof schema, 'name'>;
- * // { schema: typeof schema; name: 'name' }
- * ```
- *
- * @example
- * With discriminated union
- * ```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 CreateNameSelector = FormFieldSelector<typeof schema, 'name', 'mode', 'create'>;
- * // { schema: typeof schema; name: 'name'; discriminator: { key: 'mode'; value: 'create' } }
- * ```
- *
- * @see {@link FieldSelector} from `@zod-utils/core` for the base type
- */
-type FormFieldSelector<TSchema extends z.ZodType, TPath extends ValidFieldPaths<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFieldValues, TFilterType, TStrict>, TDiscriminatorKey extends DiscriminatorKey<TSchema> = never, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = never, TFieldValues extends InferredFieldValues<TSchema> = InferredFieldValues<TSchema>, TFilterType = unknown, TStrict extends boolean = true> = InnerFieldSelector<TSchema, TPath, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>;
 
 /**
  * Type-safe React Hook Form wrapper with automatic Zod v4 schema validation and type transformation.
@@ -580,26 +442,6 @@ declare const useZodForm: <TInput extends FieldValues, TOutput extends FieldValu
     zodResolverOptions?: Parameters<typeof zodResolver>[1];
 } & Omit<UseFormProps<TFormInput, unknown, TOutput>, "resolver" | "defaultValues">) => react_hook_form.UseFormReturn<TFormInput, unknown, TOutput>;
 
-/**
- * Extracts a FormFieldSelector from props containing schema, name, and optional discriminator.
- * Encapsulates type assertion so callers don't need eslint-disable.
- *
- * @param props - Object containing schema, name, and optional discriminator
- * @returns Properly typed FormFieldSelector
- *
- * @example
- * ```typescript
- * const selectorProps = toFormFieldSelector<TSchema, TPath, ...>(props);
- * ```
- */
-declare function toFormFieldSelector<TSchema extends z.ZodType, TPath extends ValidFieldPaths<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFieldValues, TFilterType, TStrict>, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>, TFieldValues extends InferredFieldValues<TSchema> = InferredFieldValues<TSchema>, TFilterType = unknown, TStrict extends boolean = true>(props: {
-    schema: z.ZodType;
-    name: string;
-    discriminator?: {
-        key: string;
-        value: unknown;
-    };
-}): FormFieldSelector<TSchema, TPath, TDiscriminatorKey, TDiscriminatorValue, TFieldValues, TFilterType, TStrict>;
 /**
  * Flattens a FieldSelector into an array of primitive values for use in React dependency arrays.
  *
@@ -616,10 +458,13 @@ declare function toFormFieldSelector<TSchema extends z.ZodType, TPath extends Va
  * }, flattenFieldSelector(params));
  * ```
  */
-declare function flattenFieldSelector<TSchema extends z.ZodType, TPath extends ValidPaths<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>, TFilterType = unknown, TStrict extends boolean = true>(params: FieldSelector<TSchema, TPath, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict> | {
-    schema?: undefined;
-    name?: undefined;
-    discriminator?: undefined;
-}): any[];
+declare function flattenFieldSelector(params?: {
+    schema?: z.ZodType;
+    name?: string;
+    discriminator?: {
+        key: unknown;
+        value: unknown;
+    };
+}): unknown[];
 
-export { type FormFieldSelector, FormSchemaContext, type FormSchemaContextType, type FormSchemaContextValue, FormSchemaProvider, type InferredFieldValues, type PartialWithAllNullables, type PartialWithNullableObjects, type ValidFieldPaths, flattenFieldSelector, isRequiredField, toFormFieldSelector, useExtractFieldFromSchema, useFieldChecks, useFormSchema, useIsRequiredField, useZodForm };
+export { FormSchemaContext, type FormSchemaContextType, type FormSchemaContextValue, FormSchemaProvider, type PartialWithAllNullables, type PartialWithNullableObjects, flattenFieldSelector, isRequiredField, useExtractFieldFromSchema, useFieldChecks, useFormSchema, useIsRequiredField, useZodForm };

package/dist/index.d.ts

@@ -1,22 +1,21 @@
-import { DiscriminatorKey, DiscriminatorValue, FieldSelector, ValidPaths, Discriminator, ExtractZodByPath, ZodUnionCheck, Simplify, InnerFieldSelector } from '@zod-utils/core';
+import { DiscriminatorKey, DiscriminatorValue, SchemaAndDiscriminatorProps, FieldSelectorProps, ZodUnionCheck, Simplify } from '@zod-utils/core';
 export * from '@zod-utils/core';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { Context, ReactNode } from 'react';
 import { z } from 'zod';
-import { SomeType } from 'zod/v4/core';
 import * as react_hook_form from 'react-hook-form';
-import { FieldValues, Path, UseFormProps } from 'react-hook-form';
+import { FieldValues, UseFormProps } from 'react-hook-form';
 import { zodResolver } from '@hookform/resolvers/zod';
 
 /**
  * Type for the FormSchemaContext with full generic support.
  * @internal
  */
-type FormSchemaContextType<TSchema extends z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>, TFilterType = unknown, TStrict extends boolean = true> = Context<Omit<FieldSelector<TSchema, ValidPaths<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>, 'name'> | null>;
+type FormSchemaContextType<TSchema extends z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>> = Context<SchemaAndDiscriminatorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue> | null>;
 /**
  * Context value type for FormSchemaContext.
  */
-type FormSchemaContextValue<TSchema extends z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>, TFilterType = unknown, TStrict extends boolean = true> = Omit<FieldSelector<TSchema, ValidPaths<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>, 'name'> | null;
+type FormSchemaContextValue<TSchema extends z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>> = SchemaAndDiscriminatorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue> | null;
 /**
  * React Context for providing Zod schema to form components.
  *
@@ -57,19 +56,7 @@ declare const FormSchemaContext: Context<{
  * }
  * ```
  */
-declare function useFormSchema<TSchema extends z.ZodType = z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema> = DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = DiscriminatorValue<TSchema, TDiscriminatorKey>, TFilterType = unknown, TStrict extends boolean = true>(_params?: TSchema extends z.ZodPipe<infer In, SomeType> ? In extends z.ZodDiscriminatedUnion ? {
-    schema: TSchema;
-    discriminator: Discriminator<TSchema, TDiscriminatorKey, TDiscriminatorValue>;
-} : {
-    schema: TSchema;
-    discriminator?: undefined;
-} : TSchema extends z.ZodDiscriminatedUnion ? {
-    schema: TSchema;
-    discriminator: Discriminator<TSchema, TDiscriminatorKey, TDiscriminatorValue>;
-} : {
-    schema: TSchema;
-    discriminator?: undefined;
-}): FormSchemaContextValue<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>;
+declare function useFormSchema<TSchema extends z.ZodType = z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema> = DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = DiscriminatorValue<TSchema, TDiscriminatorKey>>(_params?: SchemaAndDiscriminatorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue>): FormSchemaContextValue<TSchema, TDiscriminatorKey, TDiscriminatorValue>;
 /**
  * Provider component that makes Zod schema available to all child components.
  *
@@ -105,19 +92,7 @@ declare function useFormSchema<TSchema extends z.ZodType = z.ZodType, TDiscrimin
  * </FormSchemaProvider>
  * ```
  */
-declare function FormSchemaProvider<TSchema extends z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>>({ schema, discriminator, children, }: (TSchema extends z.ZodPipe<infer In, SomeType> ? In extends z.ZodDiscriminatedUnion ? {
-    schema: TSchema;
-    discriminator: Discriminator<TSchema, TDiscriminatorKey, TDiscriminatorValue>;
-} : {
-    schema: TSchema;
-    discriminator?: undefined;
-} : TSchema extends z.ZodDiscriminatedUnion ? {
-    schema: TSchema;
-    discriminator: Discriminator<TSchema, TDiscriminatorKey, TDiscriminatorValue>;
-} : {
-    schema: TSchema;
-    discriminator?: undefined;
-}) & {
+declare function FormSchemaProvider<TSchema extends z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>>({ schema, discriminator, children, }: SchemaAndDiscriminatorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue> & {
     children: ReactNode;
 }): react_jsx_runtime.JSX.Element;
 /**
@@ -125,8 +100,8 @@ declare function FormSchemaProvider<TSchema extends z.ZodType, TDiscriminatorKey
  *
  * Memoized - only recalculates when schema, name, or discriminator changes.
  *
- * @param params - Schema, name, and optional discriminator (schema and name are optional)
- * @returns true if the field requires valid input, false if it doesn't or if schema/name is not provided
+ * @param params - Schema, name, and optional discriminator
+ * @returns true if the field requires valid input, false otherwise
  *
  * @example
  * ```tsx
@@ -142,11 +117,7 @@ declare function FormSchemaProvider<TSchema extends z.ZodType, TDiscriminatorKey
  * }
  * ```
  */
-declare function useIsRequiredField<TSchema extends z.ZodType, TPath extends ValidPaths<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>, TFilterType = unknown, TStrict extends boolean = true>(params: FieldSelector<TSchema, TPath, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict> | {
-    schema?: undefined;
-    name?: undefined;
-    discriminator?: undefined;
-}): boolean;
+declare function useIsRequiredField<TSchema extends z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema> = never, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = never, TFilterType = unknown, TStrict extends boolean = true>(params: FieldSelectorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict> | undefined): boolean;
 /**
  * Determines if a field requires valid input (will show validation errors on empty/invalid input).
  *
@@ -188,7 +159,7 @@ declare function useIsRequiredField<TSchema extends z.ZodType, TPath extends Val
  * }); // true
  * ```
  */
-declare function isRequiredField<TSchema extends z.ZodType, TPath extends ValidPaths<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>, TFilterType = unknown, TStrict extends boolean = true>(params: FieldSelector<TSchema, TPath, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>): boolean;
+declare function isRequiredField<TSchema extends z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema> = never, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = never, TFilterType = unknown, TStrict extends boolean = true>(params: FieldSelectorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>): boolean;
 /**
  * React hook to extract a field's Zod schema from a parent schema.
  *
@@ -226,7 +197,7 @@ declare function isRequiredField<TSchema extends z.ZodType, TPath extends ValidP
  * // Returns z.string() schema
  * ```
  */
-declare function useExtractFieldFromSchema<TSchema extends z.ZodType, TPath extends ValidPaths<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>, TDiscriminatorKey extends DiscriminatorKey<TSchema> = never, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = never, TFilterType = unknown, TStrict extends boolean = true>(params: FieldSelector<TSchema, TPath, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>): (ExtractZodByPath<TSchema, TPath> & z.ZodType) | undefined;
+declare function useExtractFieldFromSchema<TSchema extends z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema> = never, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = never, TFilterType = unknown, TStrict extends boolean = true>(params: FieldSelectorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict> | undefined): z.ZodType | undefined;
 /**
  * Hook to get validation checks from a field's Zod schema.
  *
@@ -249,7 +220,7 @@ declare function useExtractFieldFromSchema<TSchema extends z.ZodType, TPath exte
  * }
  * ```
  */
-declare function useFieldChecks<TSchema extends z.ZodType, TPath extends ValidPaths<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>, TFilterType = unknown, TStrict extends boolean = true>(params: FieldSelector<TSchema, TPath, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>): ZodUnionCheck[];
+declare function useFieldChecks<TSchema extends z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema> = never, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = never, TFilterType = unknown, TStrict extends boolean = true>(params: FieldSelectorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict> | undefined): ZodUnionCheck[];
 
 /**
  * Helper type that adds `null` to object-type fields only (excludes arrays).
@@ -298,115 +269,6 @@ type PartialWithNullableObjects<T> = Simplify<Partial<AddNullToObjects<T>>>;
 type PartialWithAllNullables<T> = {
     [K in keyof T]?: T[K] | null;
 };
-/**
- * Infers field values from a Zod schema compatible with React Hook Form's FieldValues.
- *
- * @example
- * ```typescript
- * const schema = z.object({ name: z.string() });
- * type Values = InferredFieldValues<typeof schema>;
- * // { name: string } & FieldValues
- * ```
- */
-type InferredFieldValues<TSchema extends z.ZodType> = z.input<TSchema> & FieldValues;
-/**
- * Type-safe field paths for React Hook Form with optional filtering and discriminated union support.
- *
- * Combines `ValidPaths` from `@zod-utils/core` with React Hook Form's `Path` type
- * for full compatibility with form field APIs.
- *
- * @template TSchema - The Zod schema type
- * @template TDiscriminatorKey - The discriminator key (for discriminated unions)
- * @template TDiscriminatorValue - The discriminator value (for discriminated unions)
- * @template TFilterType - The value type to filter by (default: unknown = no filtering)
- * @template TStrict - Whether to use strict type matching (default: true)
- * @template TFieldValues - The form field values type (inferred from schema)
- *
- * @example
- * Basic usage - all field paths
- * ```typescript
- * const schema = z.object({
- *   name: z.string(),
- *   age: z.number(),
- * });
- *
- * type AllFields = ValidFieldPaths<typeof schema>;
- * // "name" | "age"
- * ```
- *
- * @example
- * Filter by type - string fields only
- * ```typescript
- * const schema = z.object({
- *   name: z.string(),
- *   age: z.number(),
- *   email: z.string().optional(),
- * });
- *
- * type StringFields = ValidFieldPaths<typeof schema, never, never, string>;
- * // "name" | "email"
- * ```
- *
- * @example
- * With discriminated union
- * ```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 CreateFields = ValidFieldPaths<typeof schema, 'mode', 'create'>;
- * // "mode" | "name"
- *
- * type EditNumberFields = ValidFieldPaths<typeof schema, 'mode', 'edit', number>;
- * // "id"
- * ```
- *
- * @see {@link ValidPaths} for the base type without react-hook-form Path intersection
- */
-type ValidFieldPaths<TSchema extends z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema> = never, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = never, TFieldValues extends InferredFieldValues<TSchema> = InferredFieldValues<TSchema>, TFilterType = unknown, TStrict extends boolean = true> = ValidPaths<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict> & Path<TFieldValues>;
-/**
- * Type-safe field selector for React Hook Form with discriminated union support.
- *
- * Returns an object type containing:
- * - `schema` - The Zod schema
- * - `name` - The field path (type-safe)
- * - `discriminator` - Required for discriminated unions, contains `key` and `value`
- *
- * @template TSchema - The Zod schema type
- * @template TPath - The field path
- * @template TDiscriminatorKey - The discriminator key (for discriminated unions)
- * @template TDiscriminatorValue - The discriminator value (for discriminated unions)
- * @template TFilterType - The value type to filter by (default: unknown = no filtering)
- * @template TStrict - Whether to use strict type matching (default: true)
- *
- * @example
- * Basic usage with regular schema
- * ```typescript
- * const schema = z.object({
- *   name: z.string(),
- *   age: z.number(),
- * });
- *
- * type NameSelector = FormFieldSelector<typeof schema, 'name'>;
- * // { schema: typeof schema; name: 'name' }
- * ```
- *
- * @example
- * With discriminated union
- * ```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 CreateNameSelector = FormFieldSelector<typeof schema, 'name', 'mode', 'create'>;
- * // { schema: typeof schema; name: 'name'; discriminator: { key: 'mode'; value: 'create' } }
- * ```
- *
- * @see {@link FieldSelector} from `@zod-utils/core` for the base type
- */
-type FormFieldSelector<TSchema extends z.ZodType, TPath extends ValidFieldPaths<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFieldValues, TFilterType, TStrict>, TDiscriminatorKey extends DiscriminatorKey<TSchema> = never, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = never, TFieldValues extends InferredFieldValues<TSchema> = InferredFieldValues<TSchema>, TFilterType = unknown, TStrict extends boolean = true> = InnerFieldSelector<TSchema, TPath, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>;
 
 /**
  * Type-safe React Hook Form wrapper with automatic Zod v4 schema validation and type transformation.
@@ -580,26 +442,6 @@ declare const useZodForm: <TInput extends FieldValues, TOutput extends FieldValu
     zodResolverOptions?: Parameters<typeof zodResolver>[1];
 } & Omit<UseFormProps<TFormInput, unknown, TOutput>, "resolver" | "defaultValues">) => react_hook_form.UseFormReturn<TFormInput, unknown, TOutput>;
 
-/**
- * Extracts a FormFieldSelector from props containing schema, name, and optional discriminator.
- * Encapsulates type assertion so callers don't need eslint-disable.
- *
- * @param props - Object containing schema, name, and optional discriminator
- * @returns Properly typed FormFieldSelector
- *
- * @example
- * ```typescript
- * const selectorProps = toFormFieldSelector<TSchema, TPath, ...>(props);
- * ```
- */
-declare function toFormFieldSelector<TSchema extends z.ZodType, TPath extends ValidFieldPaths<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFieldValues, TFilterType, TStrict>, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>, TFieldValues extends InferredFieldValues<TSchema> = InferredFieldValues<TSchema>, TFilterType = unknown, TStrict extends boolean = true>(props: {
-    schema: z.ZodType;
-    name: string;
-    discriminator?: {
-        key: string;
-        value: unknown;
-    };
-}): FormFieldSelector<TSchema, TPath, TDiscriminatorKey, TDiscriminatorValue, TFieldValues, TFilterType, TStrict>;
 /**
  * Flattens a FieldSelector into an array of primitive values for use in React dependency arrays.
  *
@@ -616,10 +458,13 @@ declare function toFormFieldSelector<TSchema extends z.ZodType, TPath extends Va
  * }, flattenFieldSelector(params));
  * ```
  */
-declare function flattenFieldSelector<TSchema extends z.ZodType, TPath extends ValidPaths<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>, TFilterType = unknown, TStrict extends boolean = true>(params: FieldSelector<TSchema, TPath, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict> | {
-    schema?: undefined;
-    name?: undefined;
-    discriminator?: undefined;
-}): any[];
+declare function flattenFieldSelector(params?: {
+    schema?: z.ZodType;
+    name?: string;
+    discriminator?: {
+        key: unknown;
+        value: unknown;
+    };
+}): unknown[];
 
-export { type FormFieldSelector, FormSchemaContext, type FormSchemaContextType, type FormSchemaContextValue, FormSchemaProvider, type InferredFieldValues, type PartialWithAllNullables, type PartialWithNullableObjects, type ValidFieldPaths, flattenFieldSelector, isRequiredField, toFormFieldSelector, useExtractFieldFromSchema, useFieldChecks, useFormSchema, useIsRequiredField, useZodForm };
+export { FormSchemaContext, type FormSchemaContextType, type FormSchemaContextValue, FormSchemaProvider, type PartialWithAllNullables, type PartialWithNullableObjects, flattenFieldSelector, isRequiredField, useExtractFieldFromSchema, useFieldChecks, useFormSchema, useIsRequiredField, useZodForm };

package/dist/index.js

@@ -36,23 +36,18 @@ var __objRest = (source, exclude) => {
 };
 
 // src/utils.ts
-function toFormFieldSelector(props) {
-  const { schema, name, discriminator } = props;
-  return { schema, name, discriminator };
-}
 function flattenFieldSelector(params) {
-  const _a = params, { discriminator } = _a, rest = __objRest(_a, ["discriminator"]);
+  var _a, _b;
   return [
-    ...Object.values(rest),
-    ...discriminator ? Object.values(discriminator) : []
+    params == null ? void 0 : params.schema,
+    params == null ? void 0 : params.name,
+    (_a = params == null ? void 0 : params.discriminator) == null ? void 0 : _a.key,
+    (_b = params == null ? void 0 : params.discriminator) == null ? void 0 : _b.value
   ];
 }
 var FormSchemaContext = react.createContext(null);
 function useFormSchema(_params) {
-  return react.useContext(
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    FormSchemaContext
-  );
+  return react.useContext(FormSchemaContext);
 }
 function FormSchemaProvider({
   schema,
@@ -63,7 +58,7 @@ function FormSchemaProvider({
 }
 function useIsRequiredField(params) {
   return react.useMemo(() => {
-    if (!params.schema || !params.name) {
+    if (!params) {
       return false;
     }
     return isRequiredField(params);
@@ -77,13 +72,18 @@ function isRequiredField(params) {
   return core.requiresValidInput(field);
 }
 function useExtractFieldFromSchema(params) {
-  return react.useMemo(
-    () => core.extractFieldFromSchema(params),
-    [...flattenFieldSelector(params)]
-  );
+  return react.useMemo(() => {
+    if (!params) {
+      return void 0;
+    }
+    return core.extractFieldFromSchema(params);
+  }, [...flattenFieldSelector(params)]);
 }
 function useFieldChecks(params) {
   return react.useMemo(() => {
+    if (!params) {
+      return [];
+    }
     const field = core.extractFieldFromSchema(params);
     if (!field) return [];
     return core.getFieldChecks(field);
@@ -107,7 +107,6 @@ exports.FormSchemaContext = FormSchemaContext;
 exports.FormSchemaProvider = FormSchemaProvider;
 exports.flattenFieldSelector = flattenFieldSelector;
 exports.isRequiredField = isRequiredField;
-exports.toFormFieldSelector = toFormFieldSelector;
 exports.useExtractFieldFromSchema = useExtractFieldFromSchema;
 exports.useFieldChecks = useFieldChecks;
 exports.useFormSchema = useFormSchema;

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/utils.ts","../src/context.tsx","../src/use-zod-form.ts"],"names":["createContext","useContext","jsx","useMemo","extractFieldFromSchema","requiresValidInput","getFieldChecks","zodResolver","useForm"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyBO,SAAS,oBAgBd,KAAA,EAYA;AACA,EAAA,MAAM,EAAE,MAAA,EAAQ,IAAA,EAAM,aAAA,EAAc,GAAI,KAAA;AAExC,EAAA,OAAO,EAAE,MAAA,EAAQ,IAAA,EAAM,aAAA,EAAc;AASvC;AAkBO,SAAS,qBAcd,MAAA,EAcA;AACA,EAAA,MAAmC,aAA3B,EAAA,aAAA,EAhHV,GAgHqC,EAAA,EAAT,IAAA,GAAA,SAAA,CAAS,IAAT,CAAlB,eAAA,CAAA,CAAA;AAER,EAAA,OAAO;AAAA,IACL,GAAG,MAAA,CAAO,MAAA,CAAO,IAAI,CAAA;AAAA,IACrB,GAAI,aAAA,GAAgB,MAAA,CAAO,MAAA,CAAO,aAAa,IAAI;AAAC,GACtD;AACF;AChCO,IAAM,iBAAA,GAAoBA,oBAMvB,IAAI;AA6BP,SAAS,cAYd,OAAA,EAiCA;AACA,EAAA,OAAOC,gBAAA;AAAA;AAAA,IAEL;AAAA,GAiBF;AACF;AAqCO,SAAS,kBAAA,CAId;AAAA,EACA,MAAA;AAAA,EACA,aAAA;AAAA,EACA;AACF,CAAA,EA4BG;AACD,EAAA,uBACEC,cAAA,CAAC,kBAAkB,QAAA,EAAlB,EAA2B,OAAO,EAAE,MAAA,EAAQ,aAAA,EAAc,EACxD,QAAA,EACH,CAAA;AAEJ;AAwBO,SAAS,mBAcd,MAAA,EAcS;AAET,EAAA,OAAOC,cAAQ,MAAM;AACnB,IAAA,IAAI,CAAC,MAAA,CAAO,MAAA,IAAU,CAAC,OAAO,IAAA,EAAM;AAClC,MAAA,OAAO,KAAA;AAAA,IACT;AAEA,IAAA,OAAO,gBAAgB,MAAM,CAAA;AAAA,EAC/B,GAAG,CAAC,GAAG,oBAAA,CAAqB,MAAM,CAAC,CAAC,CAAA;AACtC;AA2CO,SAAS,gBAcd,MAAA,EAQS;AACT,EAAA,MAAM,KAAA,GAAQC,4BAOZ,MAAM,CAAA;AAER,EAAA,IAAI,CAAC,KAAA,EAAO;AACV,IAAA,OAAO,KAAA;AAAA,EACT;AAEA,EAAA,OAAOC,wBAAmB,KAAK,CAAA;AACjC;AAuCO,SAAS,0BAiBd,MAAA,EAQ4D;AAE5D,EAAA,OAAOF,aAAA;AAAA,IACL,MACEC,4BAOE,MAAM,CAAA;AAAA,IACV,CAAC,GAAG,oBAAA,CAAqB,MAAM,CAAC;AAAA,GAClC;AACF;AAwBO,SAAS,eAcd,MAAA,EAQiB;AAEjB,EAAA,OAAOD,cAAQ,MAAM;AACnB,IAAA,MAAM,KAAA,GAAQC,4BAOZ,MAAM,CAAA;AACR,IAAA,IAAI,CAAC,KAAA,EAAO,OAAO,EAAC;AACpB,IAAA,OAAOE,oBAAe,KAAK,CAAA;AAAA,EAC7B,GAAG,CAAC,GAAG,oBAAA,CAAqB,MAAM,CAAC,CAAC,CAAA;AACtC;ACnXO,IAAM,UAAA,GAAa,CAMxB,EAAA,KAWI;AAXJ,EAAA,IAAA,EAAA,GAAA,EAAA,EACA;AAAA,IAAA,MAAA;AAAA,IACA;AAAA,GAtLF,GAoLE,EAAA,EAGG,WAAA,GAAA,SAAA,CAHH,EAAA,EAGG;AAAA,IAFH,QAAA;AAAA,IACA;AAAA,GAAA,CAAA;AAUA,EAAA,MAAM,QAAA,GAAWC,eAAA,CAAY,MAAA,EAAQ,kBAAkB,CAAA;AAGvD,EAAA,OAAOC,qBAAA,CAAQ,cAAA,CAAA;AAAA,IACb;AAAA,GAAA,EACG,WAAA,CACqD,CAAA;AAC5D","file":"index.js","sourcesContent":["import type {\n  DiscriminatorKey,\n  DiscriminatorValue,\n  FieldSelector,\n  ValidPaths,\n} from '@zod-utils/core';\nimport type { z } from 'zod';\nimport type {\n  FormFieldSelector,\n  InferredFieldValues,\n  ValidFieldPaths,\n} from './types';\n\n/**\n * Extracts a FormFieldSelector from props containing schema, name, and optional discriminator.\n * Encapsulates type assertion so callers don't need eslint-disable.\n *\n * @param props - Object containing schema, name, and optional discriminator\n * @returns Properly typed FormFieldSelector\n *\n * @example\n * ```typescript\n * const selectorProps = toFormFieldSelector<TSchema, TPath, ...>(props);\n * ```\n */\nexport function toFormFieldSelector<\n  TSchema extends z.ZodType,\n  TPath extends ValidFieldPaths<\n    TSchema,\n    TDiscriminatorKey,\n    TDiscriminatorValue,\n    TFieldValues,\n    TFilterType,\n    TStrict\n  >,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema>,\n  TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>,\n  TFieldValues extends\n    InferredFieldValues<TSchema> = InferredFieldValues<TSchema>,\n  TFilterType = unknown,\n  TStrict extends boolean = true,\n>(props: {\n  schema: z.ZodType;\n  name: string;\n  discriminator?: { key: string; value: unknown };\n}): FormFieldSelector<\n  TSchema,\n  TPath,\n  TDiscriminatorKey,\n  TDiscriminatorValue,\n  TFieldValues,\n  TFilterType,\n  TStrict\n> {\n  const { schema, name, discriminator } = props;\n  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n  return { schema, name, discriminator } as FormFieldSelector<\n    TSchema,\n    TPath,\n    TDiscriminatorKey,\n    TDiscriminatorValue,\n    TFieldValues,\n    TFilterType,\n    TStrict\n  >;\n}\n\n/**\n * Flattens a FieldSelector into an array of primitive values for use in React dependency arrays.\n *\n * This is useful for `useMemo` and `useCallback` dependencies where you want to avoid\n * re-running when object references change but values stay the same.\n *\n * @param params - The FieldSelector containing schema, name, and optional discriminator\n * @returns An array of primitive values suitable for React dependency arrays\n *\n * @example\n * ```tsx\n * const memoizedValue = useMemo(() => {\n *   return extractFieldFromSchema(params);\n * }, flattenFieldSelector(params));\n * ```\n */\nexport function flattenFieldSelector<\n  TSchema extends z.ZodType,\n  TPath extends ValidPaths<\n    TSchema,\n    TDiscriminatorKey,\n    TDiscriminatorValue,\n    TFilterType,\n    TStrict\n  >,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema>,\n  TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>,\n  TFilterType = unknown,\n  TStrict extends boolean = true,\n>(\n  params:\n    | FieldSelector<\n        TSchema,\n        TPath,\n        TDiscriminatorKey,\n        TDiscriminatorValue,\n        TFilterType,\n        TStrict\n      >\n    | {\n        schema?: undefined;\n        name?: undefined;\n        discriminator?: undefined;\n      },\n) {\n  const { discriminator, ...rest } = params;\n\n  return [\n    ...Object.values(rest),\n    ...(discriminator ? Object.values(discriminator) : []),\n  ];\n}\n","'use client';\n\nimport {\n  type Discriminator,\n  type DiscriminatorKey,\n  type DiscriminatorValue,\n  type ExtractZodByPath,\n  extractFieldFromSchema,\n  type FieldSelector,\n  getFieldChecks,\n  requiresValidInput,\n  type ValidPaths,\n  type ZodUnionCheck,\n} from '@zod-utils/core';\nimport {\n  type Context,\n  createContext,\n  type ReactNode,\n  useContext,\n  useMemo,\n} from 'react';\nimport type { z } from 'zod';\nimport type { SomeType } from 'zod/v4/core';\nimport { flattenFieldSelector } from './utils';\n\n/**\n * Type for the FormSchemaContext with full generic support.\n * @internal\n */\nexport type FormSchemaContextType<\n  TSchema extends z.ZodType,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema>,\n  TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>,\n  TFilterType = unknown,\n  TStrict extends boolean = true,\n> = Context<Omit<\n  FieldSelector<\n    TSchema,\n    ValidPaths<\n      TSchema,\n      TDiscriminatorKey,\n      TDiscriminatorValue,\n      TFilterType,\n      TStrict\n    >,\n    TDiscriminatorKey,\n    TDiscriminatorValue,\n    TFilterType,\n    TStrict\n  >,\n  'name'\n> | null>;\n\n/**\n * Context value type for FormSchemaContext.\n */\nexport type FormSchemaContextValue<\n  TSchema extends z.ZodType,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema>,\n  TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>,\n  TFilterType = unknown,\n  TStrict extends boolean = true,\n> = Omit<\n  FieldSelector<\n    TSchema,\n    ValidPaths<\n      TSchema,\n      TDiscriminatorKey,\n      TDiscriminatorValue,\n      TFilterType,\n      TStrict\n    >,\n    TDiscriminatorKey,\n    TDiscriminatorValue,\n    TFilterType,\n    TStrict\n  >,\n  'name'\n> | null;\n\n/**\n * React Context for providing Zod schema to form components.\n *\n * Use with {@link FormSchemaProvider} to provide schema context, and\n * {@link useFormSchema} to consume it in child components.\n */\nexport const FormSchemaContext = createContext<{\n  schema: z.ZodType;\n  discriminator?: {\n    key: unknown;\n    value: unknown;\n  };\n} | null>(null);\n\n/**\n * Hook to access the form schema from context.\n *\n * The optional `_params` argument is used for TypeScript type inference only.\n * Pass your schema to get proper type narrowing of the context value.\n *\n * @param _params - Optional params for type inference (not used at runtime)\n * @returns The schema context value or null if not within a provider\n *\n * @example\n * ```tsx\n * // Without type params (returns generic context)\n * function MyFormField() {\n *   const context = useFormSchema();\n *   if (!context) return null;\n *\n *   const { schema, discriminator } = context;\n *   // Use schema for validation or field extraction\n * }\n *\n * // With type params (for type-safe schema access)\n * function TypedFormField() {\n *   const context = useFormSchema({ schema: mySchema });\n *   // context.schema is now typed as typeof mySchema\n * }\n * ```\n */\nexport function useFormSchema<\n  TSchema extends z.ZodType = z.ZodType,\n  TDiscriminatorKey extends\n    DiscriminatorKey<TSchema> = DiscriminatorKey<TSchema>,\n  TDiscriminatorValue extends DiscriminatorValue<\n    TSchema,\n    TDiscriminatorKey\n  > = DiscriminatorValue<TSchema, TDiscriminatorKey>,\n  TFilterType = unknown,\n  TStrict extends boolean = true,\n>(\n  // Parameter used for type inference only, not at runtime\n  _params?: TSchema extends z.ZodPipe<infer In, SomeType>\n    ? In extends z.ZodDiscriminatedUnion\n      ? {\n          schema: TSchema;\n          discriminator: Discriminator<\n            TSchema,\n            TDiscriminatorKey,\n            TDiscriminatorValue\n          >;\n        }\n      : {\n          schema: TSchema;\n          discriminator?: undefined;\n        }\n    : TSchema extends z.ZodDiscriminatedUnion\n      ? {\n          schema: TSchema;\n          discriminator: Discriminator<\n            TSchema,\n            TDiscriminatorKey,\n            TDiscriminatorValue\n          >;\n        }\n      : {\n          schema: TSchema;\n          discriminator?: undefined;\n        },\n): FormSchemaContextValue<\n  TSchema,\n  TDiscriminatorKey,\n  TDiscriminatorValue,\n  TFilterType,\n  TStrict\n> {\n  return useContext(\n    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n    FormSchemaContext as Context<Omit<\n      FieldSelector<\n        TSchema,\n        ValidPaths<\n          TSchema,\n          TDiscriminatorKey,\n          TDiscriminatorValue,\n          TFilterType,\n          TStrict\n        >,\n        TDiscriminatorKey,\n        TDiscriminatorValue,\n        TFilterType,\n        TStrict\n      >,\n      'name'\n    > | null>,\n  );\n}\n\n/**\n * Provider component that makes Zod schema available to all child components.\n *\n * Use this to wrap your form and provide schema context to nested components\n * like field labels and validation indicators.\n *\n * @example\n * Basic usage with ZodObject\n * ```tsx\n * const schema = z.object({\n *   name: z.string(),\n *   email: z.string().email().optional()\n * });\n *\n * <FormSchemaProvider schema={schema}>\n *   <YourFormComponents />\n * </FormSchemaProvider>\n * ```\n *\n * @example\n * Usage with discriminated union\n * ```tsx\n * const schema = z.discriminatedUnion('mode', [\n *   z.object({ mode: z.literal('create'), name: z.string() }),\n *   z.object({ mode: z.literal('edit'), id: z.number() })\n * ]);\n *\n * <FormSchemaProvider\n *   schema={schema}\n *   discriminator={{ key: 'mode', value: 'create' }}\n * >\n *   <YourFormComponents />\n * </FormSchemaProvider>\n * ```\n */\nexport function FormSchemaProvider<\n  TSchema extends z.ZodType,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema>,\n  TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>,\n>({\n  schema,\n  discriminator,\n  children,\n}: (TSchema extends z.ZodPipe<infer In, SomeType>\n  ? In extends z.ZodDiscriminatedUnion\n    ? {\n        schema: TSchema;\n        discriminator: Discriminator<\n          TSchema,\n          TDiscriminatorKey,\n          TDiscriminatorValue\n        >;\n      }\n    : {\n        schema: TSchema;\n        discriminator?: undefined;\n      }\n  : TSchema extends z.ZodDiscriminatedUnion\n    ? {\n        schema: TSchema;\n        discriminator: Discriminator<\n          TSchema,\n          TDiscriminatorKey,\n          TDiscriminatorValue\n        >;\n      }\n    : {\n        schema: TSchema;\n        discriminator?: undefined;\n      }) & {\n  children: ReactNode;\n}) {\n  return (\n    <FormSchemaContext.Provider value={{ schema, discriminator }}>\n      {children}\n    </FormSchemaContext.Provider>\n  );\n}\n\n/**\n * Hook to check if a field requires valid input based on the Zod schema.\n *\n * Memoized - only recalculates when schema, name, or discriminator changes.\n *\n * @param params - Schema, name, and optional discriminator (schema and name are optional)\n * @returns true if the field requires valid input, false if it doesn't or if schema/name is not provided\n *\n * @example\n * ```tsx\n * function MyFieldLabel({ name, schema }: { name: string; schema: z.ZodType }) {\n *   const isRequired = useIsRequiredField({ schema, name });\n *\n *   return (\n *     <label>\n *       {name}\n *       {isRequired && <span className=\"text-red-500\">*</span>}\n *     </label>\n *   );\n * }\n * ```\n */\nexport function useIsRequiredField<\n  TSchema extends z.ZodType,\n  TPath extends ValidPaths<\n    TSchema,\n    TDiscriminatorKey,\n    TDiscriminatorValue,\n    TFilterType,\n    TStrict\n  >,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema>,\n  TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>,\n  TFilterType = unknown,\n  TStrict extends boolean = true,\n>(\n  params:\n    | FieldSelector<\n        TSchema,\n        TPath,\n        TDiscriminatorKey,\n        TDiscriminatorValue,\n        TFilterType,\n        TStrict\n      >\n    | {\n        schema?: undefined;\n        name?: undefined;\n        discriminator?: undefined;\n      },\n): boolean {\n  // biome-ignore lint/correctness/useExhaustiveDependencies: using flattenFieldSelector for stable deps\n  return useMemo(() => {\n    if (!params.schema || !params.name) {\n      return false;\n    }\n\n    return isRequiredField(params);\n  }, [...flattenFieldSelector(params)]);\n}\n\n/**\n * Determines if a field requires valid input (will show validation errors on empty/invalid input).\n *\n * Uses `requiresValidInput` from `@zod-utils/core` which checks the underlying field after\n * removing defaults. This tells you if the field will error when user submits empty input.\n *\n * Returns false if the underlying field accepts:\n * - `undefined` (via `.optional()`)\n * - `null` (via `.nullable()`)\n * - Empty strings (plain `z.string()` without `.min(1)`)\n * - Empty arrays (plain `z.array()` without `.min(1)`)\n *\n * @param options - Schema, field name, and optional discriminator\n * @returns true if the field requires valid input, false otherwise\n *\n * @example\n * ```typescript\n * const schema = z.object({\n *   name: z.string().min(1),\n *   bio: z.string().optional(),\n * });\n *\n * isRequiredField({ schema, name: 'name' }); // true\n * isRequiredField({ schema, name: 'bio' });  // false\n * ```\n *\n * @example\n * With discriminated union\n * ```typescript\n * const schema = z.discriminatedUnion('mode', [\n *   z.object({ mode: z.literal('create'), name: z.string().min(1) }),\n *   z.object({ mode: z.literal('edit'), id: z.number() }),\n * ]);\n *\n * isRequiredField({\n *   schema,\n *   name: 'name',\n *   discriminator: { key: 'mode', value: 'create' },\n * }); // true\n * ```\n */\nexport function isRequiredField<\n  TSchema extends z.ZodType,\n  TPath extends ValidPaths<\n    TSchema,\n    TDiscriminatorKey,\n    TDiscriminatorValue,\n    TFilterType,\n    TStrict\n  >,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema>,\n  TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>,\n  TFilterType = unknown,\n  TStrict extends boolean = true,\n>(\n  params: FieldSelector<\n    TSchema,\n    TPath,\n    TDiscriminatorKey,\n    TDiscriminatorValue,\n    TFilterType,\n    TStrict\n  >,\n): boolean {\n  const field = extractFieldFromSchema<\n    TSchema,\n    TPath,\n    TDiscriminatorKey,\n    TDiscriminatorValue,\n    TFilterType,\n    TStrict\n  >(params);\n\n  if (!field) {\n    return false;\n  }\n\n  return requiresValidInput(field);\n}\n\n/**\n * React hook to extract a field's Zod schema from a parent schema.\n *\n * Memoized - only recalculates when schema, name, or discriminator changes.\n * Supports nested paths and discriminated unions.\n *\n * @param params - Schema, name, and optional discriminator\n * @returns The Zod schema for the field, or undefined if not found\n *\n * @example\n * ```tsx\n * function MyFieldInfo({ name, schema }: { name: string; schema: z.ZodType }) {\n *   const fieldSchema = useExtractFieldFromSchema({ schema, name });\n *\n *   if (!fieldSchema) return null;\n *\n *   // Use fieldSchema for custom validation or field info\n *   return <span>{fieldSchema._zod.typeName}</span>;\n * }\n * ```\n *\n * @example\n * With discriminated union\n * ```tsx\n * const schema = z.discriminatedUnion('mode', [\n *   z.object({ mode: z.literal('create'), name: z.string() }),\n *   z.object({ mode: z.literal('edit'), id: z.number() }),\n * ]);\n *\n * const fieldSchema = useExtractFieldFromSchema({\n *   schema,\n *   name: 'name',\n *   discriminator: { key: 'mode', value: 'create' },\n * });\n * // Returns z.string() schema\n * ```\n */\nexport function useExtractFieldFromSchema<\n  TSchema extends z.ZodType,\n  TPath extends ValidPaths<\n    TSchema,\n    TDiscriminatorKey,\n    TDiscriminatorValue,\n    TFilterType,\n    TStrict\n  >,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema> = never,\n  TDiscriminatorValue extends DiscriminatorValue<\n    TSchema,\n    TDiscriminatorKey\n  > = never,\n  TFilterType = unknown,\n  TStrict extends boolean = true,\n>(\n  params: FieldSelector<\n    TSchema,\n    TPath,\n    TDiscriminatorKey,\n    TDiscriminatorValue,\n    TFilterType,\n    TStrict\n  >,\n): (ExtractZodByPath<TSchema, TPath> & z.ZodType) | undefined {\n  // biome-ignore lint/correctness/useExhaustiveDependencies: using flattenFieldSelector for stable deps\n  return useMemo(\n    () =>\n      extractFieldFromSchema<\n        TSchema,\n        TPath,\n        TDiscriminatorKey,\n        TDiscriminatorValue,\n        TFilterType,\n        TStrict\n      >(params),\n    [...flattenFieldSelector(params)],\n  );\n}\n\n/**\n * Hook to get validation checks from a field's Zod schema.\n *\n * Memoized - only recalculates when schema, name, or discriminator changes.\n * Combines field extraction and check retrieval in one cached operation.\n *\n * @param params - Schema, name, and optional discriminator\n * @returns Array of validation checks (min, max, pattern, etc.) or empty array\n *\n * @example\n * ```tsx\n * function MyFieldHint({ schema, name }: { schema: z.ZodType; name: string }) {\n *   const checks = useFieldChecks({ schema, name });\n *\n *   const maxLength = checks.find(c => c.check === 'max_length');\n *   if (maxLength) {\n *     return <span>Max {maxLength.maximum} characters</span>;\n *   }\n *   return null;\n * }\n * ```\n */\nexport function useFieldChecks<\n  TSchema extends z.ZodType,\n  TPath extends ValidPaths<\n    TSchema,\n    TDiscriminatorKey,\n    TDiscriminatorValue,\n    TFilterType,\n    TStrict\n  >,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema>,\n  TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>,\n  TFilterType = unknown,\n  TStrict extends boolean = true,\n>(\n  params: FieldSelector<\n    TSchema,\n    TPath,\n    TDiscriminatorKey,\n    TDiscriminatorValue,\n    TFilterType,\n    TStrict\n  >,\n): ZodUnionCheck[] {\n  // biome-ignore lint/correctness/useExhaustiveDependencies: using flattenFieldSelector for stable deps\n  return useMemo(() => {\n    const field = extractFieldFromSchema<\n      TSchema,\n      TPath,\n      TDiscriminatorKey,\n      TDiscriminatorValue,\n      TFilterType,\n      TStrict\n    >(params);\n    if (!field) return [];\n    return getFieldChecks(field);\n  }, [...flattenFieldSelector(params)]);\n}\n","import { zodResolver } from '@hookform/resolvers/zod';\nimport { type FieldValues, type UseFormProps, useForm } from 'react-hook-form';\nimport type { z } from 'zod';\nimport type {\n  PartialWithAllNullables,\n  PartialWithNullableObjects,\n} from './types';\n\n/**\n * Type-safe React Hook Form wrapper with automatic Zod v4 schema validation and type transformation.\n *\n * This hook eliminates the TypeScript friction between React Hook Form's nullable field values\n * and Zod's strict output types. It uses a two-type schema pattern where:\n * - **Input type** (`PartialWithNullableObjects<TOutput>`): Form fields accept `null | undefined` during editing\n * - **Output type** (`TOutput`): Validated data matches exact schema type (no `null | undefined`)\n *\n * **Key Benefits:**\n * - ✅ No more \"Type 'null' is not assignable to...\" TypeScript errors\n * - ✅ Use `form.setValue()` and `form.reset()` with `null` values freely\n * - ✅ Validated output is still type-safe with exact Zod schema types\n * - ✅ Automatic zodResolver setup - no manual configuration needed\n *\n * @template TInput - The Zod schema input type (accepts nullable/undefined values during form editing)\n * @template TOutput - The Zod schema output type (extends FieldValues)\n * @template TFormInput - The form input type (defaults to PartialWithNullableObjects<TInput>)\n * @template TDefaultValues - The type of default values (inferred from usage for better type safety)\n *\n * @param options - Configuration object\n * @param options.schema - Zod schema with two-type signature `z.ZodType<TOutput, TInput>`\n * @param options.defaultValues - Default form values (shallow partial - nested objects must be complete if provided)\n * @param options.zodResolverOptions - Optional zodResolver configuration\n * @param options....formOptions - All other react-hook-form useForm options\n *\n * @returns React Hook Form instance with type-safe methods\n *\n * @example\n * Basic usage with required fields\n * ```typescript\n * import { useZodForm } from '@zod-utils/react-hook-form';\n * import { z } from 'zod';\n *\n * const schema = z.object({\n *   name: z.string().min(1), // Required field\n *   age: z.number().min(0),\n * }) satisfies z.ZodType<{ name: string; age: number }, any>;\n *\n * function MyForm() {\n *   const form = useZodForm({ schema });\n *\n *   // ✅ These work without type errors:\n *   form.setValue('name', null); // Accepts null during editing\n *   form.reset({ name: null, age: null }); // Reset with null\n *\n *   const onSubmit = (data: { name: string; age: number }) => {\n *     // ✅ data is exact type - no null | undefined\n *     console.log(data.name.toUpperCase()); // Safe to use string methods\n *   };\n *\n *   return <form onSubmit={form.handleSubmit(onSubmit)}>...</form>;\n * }\n * ```\n *\n * @example\n * With default values\n * ```typescript\n * const schema = z.object({\n *   username: z.string(),\n *   email: z.string().email(),\n *   notifications: z.boolean().default(true),\n * }) satisfies z.ZodType<{\n *   username: string;\n *   email: string;\n *   notifications: boolean;\n * }, any>;\n *\n * const form = useZodForm({\n *   schema,\n *   defaultValues: {\n *     username: '',\n *     email: '',\n *     // notifications gets default from schema\n *   },\n * });\n * ```\n *\n * @example\n * Without default values (all fields are optional during editing)\n * ```typescript\n * const schema = z.object({\n *   name: z.string().min(1),\n *   email: z.string().email(),\n *   age: z.number(),\n * }) satisfies z.ZodType<{ name: string; email: string; age: number }, any>;\n *\n * // ✅ No defaultValues needed - fields are optional during editing\n * const form = useZodForm({ schema });\n *\n * // Form fields can be set individually as user types\n * form.setValue('name', 'John');\n * form.setValue('email', 'john@example.com');\n * form.setValue('age', 25);\n *\n * // All fields must be valid on submit (per schema validation)\n * ```\n *\n * @example\n * With optional and nullable fields\n * ```typescript\n * const schema = z.object({\n *   title: z.string(),\n *   description: z.string().optional(), // Optional in output\n *   tags: z.array(z.string()).nullable(), // Nullable in output\n * }) satisfies z.ZodType<{\n *   title: string;\n *   description?: string;\n *   tags: string[] | null;\n * }, any>;\n *\n * const form = useZodForm({ schema });\n *\n * // All fields accept null/undefined during editing\n * form.setValue('title', null);\n * form.setValue('description', undefined);\n * form.setValue('tags', null);\n * ```\n *\n * @example\n * With zodResolver options\n * ```typescript\n * const form = useZodForm({\n *   schema,\n *   zodResolverOptions: {\n *     async: true, // Enable async validation\n *     errorMap: customErrorMap, // Custom error messages\n *   },\n * });\n * ```\n *\n * @example\n * Complete form example\n * ```typescript\n * const userSchema = z.object({\n *   name: z.string().min(1, 'Name is required'),\n *   email: z.string().email('Invalid email'),\n *   age: z.number().min(18, 'Must be 18+'),\n * }) satisfies z.ZodType<{ name: string; email: string; age: number }, any>;\n *\n * function UserForm() {\n *   const form = useZodForm({\n *     schema: userSchema,\n *     defaultValues: { name: '', email: '', age: null },\n *   });\n *\n *   const onSubmit = (data: { name: string; email: string; age: number }) => {\n *     // Type-safe: data has exact types, no null/undefined\n *     console.log(`${data.name} is ${data.age} years old`);\n *   };\n *\n *   return (\n *     <form onSubmit={form.handleSubmit(onSubmit)}>\n *       <input {...form.register('name')} />\n *       <input {...form.register('email')} type=\"email\" />\n *       <input {...form.register('age', { valueAsNumber: true })} type=\"number\" />\n *       <button type=\"submit\">Submit</button>\n *     </form>\n *   );\n * }\n * ```\n *\n * @see {@link PartialWithNullableObjects} for the type transformation utility\n * @see https://react-hook-form.com/docs/useform for React Hook Form documentation\n * @see https://zod.dev for Zod schema documentation\n * @since 0.1.0\n */\nexport const useZodForm = <\n  TInput extends FieldValues,\n  TOutput extends FieldValues,\n  TFormInput extends\n    PartialWithAllNullables<TInput> = PartialWithNullableObjects<TInput>,\n  TDefaultValues extends Partial<TFormInput> | undefined = undefined,\n>({\n  schema,\n  zodResolverOptions,\n  ...formOptions\n}: {\n  schema: z.ZodType<TOutput, TInput>;\n  defaultValues?: TDefaultValues;\n  zodResolverOptions?: Parameters<typeof zodResolver>[1];\n} & Omit<\n  UseFormProps<TFormInput, unknown, TOutput>,\n  'resolver' | 'defaultValues'\n>) => {\n  const resolver = zodResolver(schema, zodResolverOptions);\n\n  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n  return useForm({\n    resolver,\n    ...formOptions,\n  } as unknown as UseFormProps<TFormInput, unknown, TOutput>);\n};\n"]}
+{"version":3,"sources":["../src/utils.ts","../src/context.tsx","../src/use-zod-form.ts"],"names":["createContext","useContext","jsx","useMemo","extractFieldFromSchema","requiresValidInput","getFieldChecks","zodResolver","useForm"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkBO,SAAS,qBAAqB,MAAA,EAIlC;AAtBH,EAAA,IAAA,EAAA,EAAA,EAAA;AAuBE,EAAA,OAAO;AAAA,IACL,MAAA,IAAA,IAAA,GAAA,MAAA,GAAA,MAAA,CAAQ,MAAA;AAAA,IACR,MAAA,IAAA,IAAA,GAAA,MAAA,GAAA,MAAA,CAAQ,IAAA;AAAA,IAAA,CACR,EAAA,GAAA,MAAA,IAAA,IAAA,GAAA,MAAA,GAAA,MAAA,CAAQ,kBAAR,IAAA,GAAA,MAAA,GAAA,EAAA,CAAuB,GAAA;AAAA,IAAA,CACvB,EAAA,GAAA,MAAA,IAAA,IAAA,GAAA,MAAA,GAAA,MAAA,CAAQ,kBAAR,IAAA,GAAA,MAAA,GAAA,EAAA,CAAuB;AAAA,GACzB;AACF;AC0BO,IAAM,iBAAA,GAAoBA,oBAMvB,IAAI;AA6BP,SAAS,cAUd,OAAA,EAKyE;AAKzE,EAAA,OAAOC,iBAAW,iBAAiB,CAAA;AAKrC;AAqCO,SAAS,kBAAA,CAId;AAAA,EACA,MAAA;AAAA,EACA,aAAA;AAAA,EACA;AACF,CAAA,EAI6B;AAC3B,EAAA,uBACEC,cAAA,CAAC,kBAAkB,QAAA,EAAlB,EAA2B,OAAO,EAAE,MAAA,EAAQ,aAAA,EAAc,EACxD,QAAA,EACH,CAAA;AAEJ;AAwBO,SAAS,mBAUd,MAAA,EASS;AAET,EAAA,OAAOC,cAAQ,MAAM;AACnB,IAAA,IAAI,CAAC,MAAA,EAAQ;AACX,MAAA,OAAO,KAAA;AAAA,IACT;AACA,IAAA,OAAO,gBAAgB,MAAM,CAAA;AAAA,EAC/B,GAAG,CAAC,GAAG,oBAAA,CAAqB,MAAM,CAAC,CAAC,CAAA;AACtC;AA2CO,SAAS,gBAUd,MAAA,EAOS;AACT,EAAA,MAAM,KAAA,GAAQC,4BAAuB,MAAM,CAAA;AAE3C,EAAA,IAAI,CAAC,KAAA,EAAO;AACV,IAAA,OAAO,KAAA;AAAA,EACT;AAEA,EAAA,OAAOC,wBAAmB,KAAK,CAAA;AACjC;AAuCO,SAAS,0BAUd,MAAA,EASuB;AAEvB,EAAA,OAAOF,cAAQ,MAAM;AACnB,IAAA,IAAI,CAAC,MAAA,EAAQ;AACX,MAAA,OAAO,MAAA;AAAA,IACT;AACA,IAAA,OAAOC,4BAAuB,MAAM,CAAA;AAAA,EACtC,GAAG,CAAC,GAAG,oBAAA,CAAqB,MAAM,CAAC,CAAC,CAAA;AACtC;AAwBO,SAAS,eAUd,MAAA,EASiB;AAEjB,EAAA,OAAOD,cAAQ,MAAM;AACnB,IAAA,IAAI,CAAC,MAAA,EAAQ;AACX,MAAA,OAAO,EAAC;AAAA,IACV;AAEA,IAAA,MAAM,KAAA,GAAQC,4BAAuB,MAAM,CAAA;AAC3C,IAAA,IAAI,CAAC,KAAA,EAAO,OAAO,EAAC;AACpB,IAAA,OAAOE,oBAAe,KAAK,CAAA;AAAA,EAC7B,GAAG,CAAC,GAAG,oBAAA,CAAqB,MAAM,CAAC,CAAC,CAAA;AACtC;AC3OO,IAAM,UAAA,GAAa,CAMxB,EAAA,KAWI;AAXJ,EAAA,IAAA,EAAA,GAAA,EAAA,EACA;AAAA,IAAA,MAAA;AAAA,IACA;AAAA,GAtLF,GAoLE,EAAA,EAGG,WAAA,GAAA,SAAA,CAHH,EAAA,EAGG;AAAA,IAFH,QAAA;AAAA,IACA;AAAA,GAAA,CAAA;AAUA,EAAA,MAAM,QAAA,GAAWC,eAAA,CAAY,MAAA,EAAQ,kBAAkB,CAAA;AAGvD,EAAA,OAAOC,qBAAA,CAAQ,cAAA,CAAA;AAAA,IACb;AAAA,GAAA,EACG,WAAA,CACqD,CAAA;AAC5D","file":"index.js","sourcesContent":["import type { z } from 'zod';\n\n/**\n * Flattens a FieldSelector into an array of primitive values for use in React dependency arrays.\n *\n * This is useful for `useMemo` and `useCallback` dependencies where you want to avoid\n * re-running when object references change but values stay the same.\n *\n * @param params - The FieldSelector containing schema, name, and optional discriminator\n * @returns An array of primitive values suitable for React dependency arrays\n *\n * @example\n * ```tsx\n * const memoizedValue = useMemo(() => {\n *   return extractFieldFromSchema(params);\n * }, flattenFieldSelector(params));\n * ```\n */\nexport function flattenFieldSelector(params?: {\n  schema?: z.ZodType;\n  name?: string;\n  discriminator?: { key: unknown; value: unknown };\n}) {\n  return [\n    params?.schema,\n    params?.name,\n    params?.discriminator?.key,\n    params?.discriminator?.value,\n  ];\n}\n","'use client';\n\nimport {\n  type DiscriminatorKey,\n  type DiscriminatorValue,\n  extractFieldFromSchema,\n  type FieldSelectorProps,\n  getFieldChecks,\n  requiresValidInput,\n  type SchemaAndDiscriminatorProps,\n  type ZodUnionCheck,\n} from '@zod-utils/core';\nimport {\n  type Context,\n  createContext,\n  type ReactNode,\n  useContext,\n  useMemo,\n} from 'react';\nimport type { z } from 'zod';\nimport { flattenFieldSelector } from './utils';\n\n/**\n * Type for the FormSchemaContext with full generic support.\n * @internal\n */\nexport type FormSchemaContextType<\n  TSchema extends z.ZodType,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema>,\n  TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>,\n> = Context<SchemaAndDiscriminatorProps<\n  TSchema,\n  TDiscriminatorKey,\n  TDiscriminatorValue\n> | null>;\n\n/**\n * Context value type for FormSchemaContext.\n */\nexport type FormSchemaContextValue<\n  TSchema extends z.ZodType,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema>,\n  TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>,\n> = SchemaAndDiscriminatorProps<\n  TSchema,\n  TDiscriminatorKey,\n  TDiscriminatorValue\n> | null;\n\n/**\n * React Context for providing Zod schema to form components.\n *\n * Use with {@link FormSchemaProvider} to provide schema context, and\n * {@link useFormSchema} to consume it in child components.\n */\nexport const FormSchemaContext = createContext<{\n  schema: z.ZodType;\n  discriminator?: {\n    key: unknown;\n    value: unknown;\n  };\n} | null>(null);\n\n/**\n * Hook to access the form schema from context.\n *\n * The optional `_params` argument is used for TypeScript type inference only.\n * Pass your schema to get proper type narrowing of the context value.\n *\n * @param _params - Optional params for type inference (not used at runtime)\n * @returns The schema context value or null if not within a provider\n *\n * @example\n * ```tsx\n * // Without type params (returns generic context)\n * function MyFormField() {\n *   const context = useFormSchema();\n *   if (!context) return null;\n *\n *   const { schema, discriminator } = context;\n *   // Use schema for validation or field extraction\n * }\n *\n * // With type params (for type-safe schema access)\n * function TypedFormField() {\n *   const context = useFormSchema({ schema: mySchema });\n *   // context.schema is now typed as typeof mySchema\n * }\n * ```\n */\nexport function useFormSchema<\n  TSchema extends z.ZodType = z.ZodType,\n  TDiscriminatorKey extends\n    DiscriminatorKey<TSchema> = DiscriminatorKey<TSchema>,\n  TDiscriminatorValue extends DiscriminatorValue<\n    TSchema,\n    TDiscriminatorKey\n  > = DiscriminatorValue<TSchema, TDiscriminatorKey>,\n>(\n  // Parameter used for type inference only, not at runtime\n  _params?: SchemaAndDiscriminatorProps<\n    TSchema,\n    TDiscriminatorKey,\n    TDiscriminatorValue\n  >,\n): FormSchemaContextValue<TSchema, TDiscriminatorKey, TDiscriminatorValue> {\n  // Type assertion is necessary because React context is created with a generic type,\n  // but we want to return a narrower type based on the generic parameters.\n  // The caller is responsible for ensuring type safety via the _params argument.\n  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n  return useContext(FormSchemaContext) as FormSchemaContextValue<\n    TSchema,\n    TDiscriminatorKey,\n    TDiscriminatorValue\n  >;\n}\n\n/**\n * Provider component that makes Zod schema available to all child components.\n *\n * Use this to wrap your form and provide schema context to nested components\n * like field labels and validation indicators.\n *\n * @example\n * Basic usage with ZodObject\n * ```tsx\n * const schema = z.object({\n *   name: z.string(),\n *   email: z.string().email().optional()\n * });\n *\n * <FormSchemaProvider schema={schema}>\n *   <YourFormComponents />\n * </FormSchemaProvider>\n * ```\n *\n * @example\n * Usage with discriminated union\n * ```tsx\n * const schema = z.discriminatedUnion('mode', [\n *   z.object({ mode: z.literal('create'), name: z.string() }),\n *   z.object({ mode: z.literal('edit'), id: z.number() })\n * ]);\n *\n * <FormSchemaProvider\n *   schema={schema}\n *   discriminator={{ key: 'mode', value: 'create' }}\n * >\n *   <YourFormComponents />\n * </FormSchemaProvider>\n * ```\n */\nexport function FormSchemaProvider<\n  TSchema extends z.ZodType,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema>,\n  TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>,\n>({\n  schema,\n  discriminator,\n  children,\n}: SchemaAndDiscriminatorProps<\n  TSchema,\n  TDiscriminatorKey,\n  TDiscriminatorValue\n> & { children: ReactNode }) {\n  return (\n    <FormSchemaContext.Provider value={{ schema, discriminator }}>\n      {children}\n    </FormSchemaContext.Provider>\n  );\n}\n\n/**\n * Hook to check if a field requires valid input based on the Zod schema.\n *\n * Memoized - only recalculates when schema, name, or discriminator changes.\n *\n * @param params - Schema, name, and optional discriminator\n * @returns true if the field requires valid input, false otherwise\n *\n * @example\n * ```tsx\n * function MyFieldLabel({ name, schema }: { name: string; schema: z.ZodType }) {\n *   const isRequired = useIsRequiredField({ schema, name });\n *\n *   return (\n *     <label>\n *       {name}\n *       {isRequired && <span className=\"text-red-500\">*</span>}\n *     </label>\n *   );\n * }\n * ```\n */\nexport function useIsRequiredField<\n  TSchema extends z.ZodType,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema> = never,\n  TDiscriminatorValue extends DiscriminatorValue<\n    TSchema,\n    TDiscriminatorKey\n  > = never,\n  TFilterType = unknown,\n  TStrict extends boolean = true,\n>(\n  params:\n    | FieldSelectorProps<\n        TSchema,\n        TDiscriminatorKey,\n        TDiscriminatorValue,\n        TFilterType,\n        TStrict\n      >\n    | undefined,\n): boolean {\n  // biome-ignore lint/correctness/useExhaustiveDependencies: using flattenFieldSelector for stable deps\n  return useMemo(() => {\n    if (!params) {\n      return false;\n    }\n    return isRequiredField(params);\n  }, [...flattenFieldSelector(params)]);\n}\n\n/**\n * Determines if a field requires valid input (will show validation errors on empty/invalid input).\n *\n * Uses `requiresValidInput` from `@zod-utils/core` which checks the underlying field after\n * removing defaults. This tells you if the field will error when user submits empty input.\n *\n * Returns false if the underlying field accepts:\n * - `undefined` (via `.optional()`)\n * - `null` (via `.nullable()`)\n * - Empty strings (plain `z.string()` without `.min(1)`)\n * - Empty arrays (plain `z.array()` without `.min(1)`)\n *\n * @param options - Schema, field name, and optional discriminator\n * @returns true if the field requires valid input, false otherwise\n *\n * @example\n * ```typescript\n * const schema = z.object({\n *   name: z.string().min(1),\n *   bio: z.string().optional(),\n * });\n *\n * isRequiredField({ schema, name: 'name' }); // true\n * isRequiredField({ schema, name: 'bio' });  // false\n * ```\n *\n * @example\n * With discriminated union\n * ```typescript\n * const schema = z.discriminatedUnion('mode', [\n *   z.object({ mode: z.literal('create'), name: z.string().min(1) }),\n *   z.object({ mode: z.literal('edit'), id: z.number() }),\n * ]);\n *\n * isRequiredField({\n *   schema,\n *   name: 'name',\n *   discriminator: { key: 'mode', value: 'create' },\n * }); // true\n * ```\n */\nexport function isRequiredField<\n  TSchema extends z.ZodType,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema> = never,\n  TDiscriminatorValue extends DiscriminatorValue<\n    TSchema,\n    TDiscriminatorKey\n  > = never,\n  TFilterType = unknown,\n  TStrict extends boolean = true,\n>(\n  params: FieldSelectorProps<\n    TSchema,\n    TDiscriminatorKey,\n    TDiscriminatorValue,\n    TFilterType,\n    TStrict\n  >,\n): boolean {\n  const field = extractFieldFromSchema(params);\n\n  if (!field) {\n    return false;\n  }\n\n  return requiresValidInput(field);\n}\n\n/**\n * React hook to extract a field's Zod schema from a parent schema.\n *\n * Memoized - only recalculates when schema, name, or discriminator changes.\n * Supports nested paths and discriminated unions.\n *\n * @param params - Schema, name, and optional discriminator\n * @returns The Zod schema for the field, or undefined if not found\n *\n * @example\n * ```tsx\n * function MyFieldInfo({ name, schema }: { name: string; schema: z.ZodType }) {\n *   const fieldSchema = useExtractFieldFromSchema({ schema, name });\n *\n *   if (!fieldSchema) return null;\n *\n *   // Use fieldSchema for custom validation or field info\n *   return <span>{fieldSchema._zod.typeName}</span>;\n * }\n * ```\n *\n * @example\n * With discriminated union\n * ```tsx\n * const schema = z.discriminatedUnion('mode', [\n *   z.object({ mode: z.literal('create'), name: z.string() }),\n *   z.object({ mode: z.literal('edit'), id: z.number() }),\n * ]);\n *\n * const fieldSchema = useExtractFieldFromSchema({\n *   schema,\n *   name: 'name',\n *   discriminator: { key: 'mode', value: 'create' },\n * });\n * // Returns z.string() schema\n * ```\n */\nexport function useExtractFieldFromSchema<\n  TSchema extends z.ZodType,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema> = never,\n  TDiscriminatorValue extends DiscriminatorValue<\n    TSchema,\n    TDiscriminatorKey\n  > = never,\n  TFilterType = unknown,\n  TStrict extends boolean = true,\n>(\n  params:\n    | FieldSelectorProps<\n        TSchema,\n        TDiscriminatorKey,\n        TDiscriminatorValue,\n        TFilterType,\n        TStrict\n      >\n    | undefined,\n): z.ZodType | undefined {\n  // biome-ignore lint/correctness/useExhaustiveDependencies: using flattenFieldSelector for stable deps\n  return useMemo(() => {\n    if (!params) {\n      return undefined;\n    }\n    return extractFieldFromSchema(params);\n  }, [...flattenFieldSelector(params)]);\n}\n\n/**\n * Hook to get validation checks from a field's Zod schema.\n *\n * Memoized - only recalculates when schema, name, or discriminator changes.\n * Combines field extraction and check retrieval in one cached operation.\n *\n * @param params - Schema, name, and optional discriminator\n * @returns Array of validation checks (min, max, pattern, etc.) or empty array\n *\n * @example\n * ```tsx\n * function MyFieldHint({ schema, name }: { schema: z.ZodType; name: string }) {\n *   const checks = useFieldChecks({ schema, name });\n *\n *   const maxLength = checks.find(c => c.check === 'max_length');\n *   if (maxLength) {\n *     return <span>Max {maxLength.maximum} characters</span>;\n *   }\n *   return null;\n * }\n * ```\n */\nexport function useFieldChecks<\n  TSchema extends z.ZodType,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema> = never,\n  TDiscriminatorValue extends DiscriminatorValue<\n    TSchema,\n    TDiscriminatorKey\n  > = never,\n  TFilterType = unknown,\n  TStrict extends boolean = true,\n>(\n  params:\n    | FieldSelectorProps<\n        TSchema,\n        TDiscriminatorKey,\n        TDiscriminatorValue,\n        TFilterType,\n        TStrict\n      >\n    | undefined,\n): ZodUnionCheck[] {\n  // biome-ignore lint/correctness/useExhaustiveDependencies: using flattenFieldSelector for stable deps\n  return useMemo(() => {\n    if (!params) {\n      return [];\n    }\n\n    const field = extractFieldFromSchema(params);\n    if (!field) return [];\n    return getFieldChecks(field);\n  }, [...flattenFieldSelector(params)]);\n}\n","import { zodResolver } from '@hookform/resolvers/zod';\nimport { type FieldValues, type UseFormProps, useForm } from 'react-hook-form';\nimport type { z } from 'zod';\nimport type {\n  PartialWithAllNullables,\n  PartialWithNullableObjects,\n} from './types';\n\n/**\n * Type-safe React Hook Form wrapper with automatic Zod v4 schema validation and type transformation.\n *\n * This hook eliminates the TypeScript friction between React Hook Form's nullable field values\n * and Zod's strict output types. It uses a two-type schema pattern where:\n * - **Input type** (`PartialWithNullableObjects<TOutput>`): Form fields accept `null | undefined` during editing\n * - **Output type** (`TOutput`): Validated data matches exact schema type (no `null | undefined`)\n *\n * **Key Benefits:**\n * - ✅ No more \"Type 'null' is not assignable to...\" TypeScript errors\n * - ✅ Use `form.setValue()` and `form.reset()` with `null` values freely\n * - ✅ Validated output is still type-safe with exact Zod schema types\n * - ✅ Automatic zodResolver setup - no manual configuration needed\n *\n * @template TInput - The Zod schema input type (accepts nullable/undefined values during form editing)\n * @template TOutput - The Zod schema output type (extends FieldValues)\n * @template TFormInput - The form input type (defaults to PartialWithNullableObjects<TInput>)\n * @template TDefaultValues - The type of default values (inferred from usage for better type safety)\n *\n * @param options - Configuration object\n * @param options.schema - Zod schema with two-type signature `z.ZodType<TOutput, TInput>`\n * @param options.defaultValues - Default form values (shallow partial - nested objects must be complete if provided)\n * @param options.zodResolverOptions - Optional zodResolver configuration\n * @param options....formOptions - All other react-hook-form useForm options\n *\n * @returns React Hook Form instance with type-safe methods\n *\n * @example\n * Basic usage with required fields\n * ```typescript\n * import { useZodForm } from '@zod-utils/react-hook-form';\n * import { z } from 'zod';\n *\n * const schema = z.object({\n *   name: z.string().min(1), // Required field\n *   age: z.number().min(0),\n * }) satisfies z.ZodType<{ name: string; age: number }, any>;\n *\n * function MyForm() {\n *   const form = useZodForm({ schema });\n *\n *   // ✅ These work without type errors:\n *   form.setValue('name', null); // Accepts null during editing\n *   form.reset({ name: null, age: null }); // Reset with null\n *\n *   const onSubmit = (data: { name: string; age: number }) => {\n *     // ✅ data is exact type - no null | undefined\n *     console.log(data.name.toUpperCase()); // Safe to use string methods\n *   };\n *\n *   return <form onSubmit={form.handleSubmit(onSubmit)}>...</form>;\n * }\n * ```\n *\n * @example\n * With default values\n * ```typescript\n * const schema = z.object({\n *   username: z.string(),\n *   email: z.string().email(),\n *   notifications: z.boolean().default(true),\n * }) satisfies z.ZodType<{\n *   username: string;\n *   email: string;\n *   notifications: boolean;\n * }, any>;\n *\n * const form = useZodForm({\n *   schema,\n *   defaultValues: {\n *     username: '',\n *     email: '',\n *     // notifications gets default from schema\n *   },\n * });\n * ```\n *\n * @example\n * Without default values (all fields are optional during editing)\n * ```typescript\n * const schema = z.object({\n *   name: z.string().min(1),\n *   email: z.string().email(),\n *   age: z.number(),\n * }) satisfies z.ZodType<{ name: string; email: string; age: number }, any>;\n *\n * // ✅ No defaultValues needed - fields are optional during editing\n * const form = useZodForm({ schema });\n *\n * // Form fields can be set individually as user types\n * form.setValue('name', 'John');\n * form.setValue('email', 'john@example.com');\n * form.setValue('age', 25);\n *\n * // All fields must be valid on submit (per schema validation)\n * ```\n *\n * @example\n * With optional and nullable fields\n * ```typescript\n * const schema = z.object({\n *   title: z.string(),\n *   description: z.string().optional(), // Optional in output\n *   tags: z.array(z.string()).nullable(), // Nullable in output\n * }) satisfies z.ZodType<{\n *   title: string;\n *   description?: string;\n *   tags: string[] | null;\n * }, any>;\n *\n * const form = useZodForm({ schema });\n *\n * // All fields accept null/undefined during editing\n * form.setValue('title', null);\n * form.setValue('description', undefined);\n * form.setValue('tags', null);\n * ```\n *\n * @example\n * With zodResolver options\n * ```typescript\n * const form = useZodForm({\n *   schema,\n *   zodResolverOptions: {\n *     async: true, // Enable async validation\n *     errorMap: customErrorMap, // Custom error messages\n *   },\n * });\n * ```\n *\n * @example\n * Complete form example\n * ```typescript\n * const userSchema = z.object({\n *   name: z.string().min(1, 'Name is required'),\n *   email: z.string().email('Invalid email'),\n *   age: z.number().min(18, 'Must be 18+'),\n * }) satisfies z.ZodType<{ name: string; email: string; age: number }, any>;\n *\n * function UserForm() {\n *   const form = useZodForm({\n *     schema: userSchema,\n *     defaultValues: { name: '', email: '', age: null },\n *   });\n *\n *   const onSubmit = (data: { name: string; email: string; age: number }) => {\n *     // Type-safe: data has exact types, no null/undefined\n *     console.log(`${data.name} is ${data.age} years old`);\n *   };\n *\n *   return (\n *     <form onSubmit={form.handleSubmit(onSubmit)}>\n *       <input {...form.register('name')} />\n *       <input {...form.register('email')} type=\"email\" />\n *       <input {...form.register('age', { valueAsNumber: true })} type=\"number\" />\n *       <button type=\"submit\">Submit</button>\n *     </form>\n *   );\n * }\n * ```\n *\n * @see {@link PartialWithNullableObjects} for the type transformation utility\n * @see https://react-hook-form.com/docs/useform for React Hook Form documentation\n * @see https://zod.dev for Zod schema documentation\n * @since 0.1.0\n */\nexport const useZodForm = <\n  TInput extends FieldValues,\n  TOutput extends FieldValues,\n  TFormInput extends\n    PartialWithAllNullables<TInput> = PartialWithNullableObjects<TInput>,\n  TDefaultValues extends Partial<TFormInput> | undefined = undefined,\n>({\n  schema,\n  zodResolverOptions,\n  ...formOptions\n}: {\n  schema: z.ZodType<TOutput, TInput>;\n  defaultValues?: TDefaultValues;\n  zodResolverOptions?: Parameters<typeof zodResolver>[1];\n} & Omit<\n  UseFormProps<TFormInput, unknown, TOutput>,\n  'resolver' | 'defaultValues'\n>) => {\n  const resolver = zodResolver(schema, zodResolverOptions);\n\n  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n  return useForm({\n    resolver,\n    ...formOptions,\n  } as unknown as UseFormProps<TFormInput, unknown, TOutput>);\n};\n"]}

package/dist/index.mjs

@@ -35,23 +35,18 @@ var __objRest = (source, exclude) => {
 };
 
 // src/utils.ts
-function toFormFieldSelector(props) {
-  const { schema, name, discriminator } = props;
-  return { schema, name, discriminator };
-}
 function flattenFieldSelector(params) {
-  const _a = params, { discriminator } = _a, rest = __objRest(_a, ["discriminator"]);
+  var _a, _b;
   return [
-    ...Object.values(rest),
-    ...discriminator ? Object.values(discriminator) : []
+    params == null ? void 0 : params.schema,
+    params == null ? void 0 : params.name,
+    (_a = params == null ? void 0 : params.discriminator) == null ? void 0 : _a.key,
+    (_b = params == null ? void 0 : params.discriminator) == null ? void 0 : _b.value
   ];
 }
 var FormSchemaContext = createContext(null);
 function useFormSchema(_params) {
-  return useContext(
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    FormSchemaContext
-  );
+  return useContext(FormSchemaContext);
 }
 function FormSchemaProvider({
   schema,
@@ -62,7 +57,7 @@ function FormSchemaProvider({
 }
 function useIsRequiredField(params) {
   return useMemo(() => {
-    if (!params.schema || !params.name) {
+    if (!params) {
       return false;
     }
     return isRequiredField(params);
@@ -76,13 +71,18 @@ function isRequiredField(params) {
   return requiresValidInput(field);
 }
 function useExtractFieldFromSchema(params) {
-  return useMemo(
-    () => extractFieldFromSchema(params),
-    [...flattenFieldSelector(params)]
-  );
+  return useMemo(() => {
+    if (!params) {
+      return void 0;
+    }
+    return extractFieldFromSchema(params);
+  }, [...flattenFieldSelector(params)]);
 }
 function useFieldChecks(params) {
   return useMemo(() => {
+    if (!params) {
+      return [];
+    }
     const field = extractFieldFromSchema(params);
     if (!field) return [];
     return getFieldChecks(field);
@@ -102,6 +102,6 @@ var useZodForm = (_a) => {
   }, formOptions));
 };
 
-export { FormSchemaContext, FormSchemaProvider, flattenFieldSelector, isRequiredField, toFormFieldSelector, useExtractFieldFromSchema, useFieldChecks, useFormSchema, useIsRequiredField, useZodForm };
+export { FormSchemaContext, FormSchemaProvider, flattenFieldSelector, isRequiredField, useExtractFieldFromSchema, useFieldChecks, useFormSchema, useIsRequiredField, useZodForm };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/utils.ts","../src/context.tsx","../src/use-zod-form.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyBO,SAAS,oBAgBd,KAAA,EAYA;AACA,EAAA,MAAM,EAAE,MAAA,EAAQ,IAAA,EAAM,aAAA,EAAc,GAAI,KAAA;AAExC,EAAA,OAAO,EAAE,MAAA,EAAQ,IAAA,EAAM,aAAA,EAAc;AASvC;AAkBO,SAAS,qBAcd,MAAA,EAcA;AACA,EAAA,MAAmC,aAA3B,EAAA,aAAA,EAhHV,GAgHqC,EAAA,EAAT,IAAA,GAAA,SAAA,CAAS,IAAT,CAAlB,eAAA,CAAA,CAAA;AAER,EAAA,OAAO;AAAA,IACL,GAAG,MAAA,CAAO,MAAA,CAAO,IAAI,CAAA;AAAA,IACrB,GAAI,aAAA,GAAgB,MAAA,CAAO,MAAA,CAAO,aAAa,IAAI;AAAC,GACtD;AACF;AChCO,IAAM,iBAAA,GAAoB,cAMvB,IAAI;AA6BP,SAAS,cAYd,OAAA,EAiCA;AACA,EAAA,OAAO,UAAA;AAAA;AAAA,IAEL;AAAA,GAiBF;AACF;AAqCO,SAAS,kBAAA,CAId;AAAA,EACA,MAAA;AAAA,EACA,aAAA;AAAA,EACA;AACF,CAAA,EA4BG;AACD,EAAA,uBACE,GAAA,CAAC,kBAAkB,QAAA,EAAlB,EAA2B,OAAO,EAAE,MAAA,EAAQ,aAAA,EAAc,EACxD,QAAA,EACH,CAAA;AAEJ;AAwBO,SAAS,mBAcd,MAAA,EAcS;AAET,EAAA,OAAO,QAAQ,MAAM;AACnB,IAAA,IAAI,CAAC,MAAA,CAAO,MAAA,IAAU,CAAC,OAAO,IAAA,EAAM;AAClC,MAAA,OAAO,KAAA;AAAA,IACT;AAEA,IAAA,OAAO,gBAAgB,MAAM,CAAA;AAAA,EAC/B,GAAG,CAAC,GAAG,oBAAA,CAAqB,MAAM,CAAC,CAAC,CAAA;AACtC;AA2CO,SAAS,gBAcd,MAAA,EAQS;AACT,EAAA,MAAM,KAAA,GAAQ,uBAOZ,MAAM,CAAA;AAER,EAAA,IAAI,CAAC,KAAA,EAAO;AACV,IAAA,OAAO,KAAA;AAAA,EACT;AAEA,EAAA,OAAO,mBAAmB,KAAK,CAAA;AACjC;AAuCO,SAAS,0BAiBd,MAAA,EAQ4D;AAE5D,EAAA,OAAO,OAAA;AAAA,IACL,MACE,uBAOE,MAAM,CAAA;AAAA,IACV,CAAC,GAAG,oBAAA,CAAqB,MAAM,CAAC;AAAA,GAClC;AACF;AAwBO,SAAS,eAcd,MAAA,EAQiB;AAEjB,EAAA,OAAO,QAAQ,MAAM;AACnB,IAAA,MAAM,KAAA,GAAQ,uBAOZ,MAAM,CAAA;AACR,IAAA,IAAI,CAAC,KAAA,EAAO,OAAO,EAAC;AACpB,IAAA,OAAO,eAAe,KAAK,CAAA;AAAA,EAC7B,GAAG,CAAC,GAAG,oBAAA,CAAqB,MAAM,CAAC,CAAC,CAAA;AACtC;ACnXO,IAAM,UAAA,GAAa,CAMxB,EAAA,KAWI;AAXJ,EAAA,IAAA,EAAA,GAAA,EAAA,EACA;AAAA,IAAA,MAAA;AAAA,IACA;AAAA,GAtLF,GAoLE,EAAA,EAGG,WAAA,GAAA,SAAA,CAHH,EAAA,EAGG;AAAA,IAFH,QAAA;AAAA,IACA;AAAA,GAAA,CAAA;AAUA,EAAA,MAAM,QAAA,GAAW,WAAA,CAAY,MAAA,EAAQ,kBAAkB,CAAA;AAGvD,EAAA,OAAO,OAAA,CAAQ,cAAA,CAAA;AAAA,IACb;AAAA,GAAA,EACG,WAAA,CACqD,CAAA;AAC5D","file":"index.mjs","sourcesContent":["import type {\n  DiscriminatorKey,\n  DiscriminatorValue,\n  FieldSelector,\n  ValidPaths,\n} from '@zod-utils/core';\nimport type { z } from 'zod';\nimport type {\n  FormFieldSelector,\n  InferredFieldValues,\n  ValidFieldPaths,\n} from './types';\n\n/**\n * Extracts a FormFieldSelector from props containing schema, name, and optional discriminator.\n * Encapsulates type assertion so callers don't need eslint-disable.\n *\n * @param props - Object containing schema, name, and optional discriminator\n * @returns Properly typed FormFieldSelector\n *\n * @example\n * ```typescript\n * const selectorProps = toFormFieldSelector<TSchema, TPath, ...>(props);\n * ```\n */\nexport function toFormFieldSelector<\n  TSchema extends z.ZodType,\n  TPath extends ValidFieldPaths<\n    TSchema,\n    TDiscriminatorKey,\n    TDiscriminatorValue,\n    TFieldValues,\n    TFilterType,\n    TStrict\n  >,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema>,\n  TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>,\n  TFieldValues extends\n    InferredFieldValues<TSchema> = InferredFieldValues<TSchema>,\n  TFilterType = unknown,\n  TStrict extends boolean = true,\n>(props: {\n  schema: z.ZodType;\n  name: string;\n  discriminator?: { key: string; value: unknown };\n}): FormFieldSelector<\n  TSchema,\n  TPath,\n  TDiscriminatorKey,\n  TDiscriminatorValue,\n  TFieldValues,\n  TFilterType,\n  TStrict\n> {\n  const { schema, name, discriminator } = props;\n  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n  return { schema, name, discriminator } as FormFieldSelector<\n    TSchema,\n    TPath,\n    TDiscriminatorKey,\n    TDiscriminatorValue,\n    TFieldValues,\n    TFilterType,\n    TStrict\n  >;\n}\n\n/**\n * Flattens a FieldSelector into an array of primitive values for use in React dependency arrays.\n *\n * This is useful for `useMemo` and `useCallback` dependencies where you want to avoid\n * re-running when object references change but values stay the same.\n *\n * @param params - The FieldSelector containing schema, name, and optional discriminator\n * @returns An array of primitive values suitable for React dependency arrays\n *\n * @example\n * ```tsx\n * const memoizedValue = useMemo(() => {\n *   return extractFieldFromSchema(params);\n * }, flattenFieldSelector(params));\n * ```\n */\nexport function flattenFieldSelector<\n  TSchema extends z.ZodType,\n  TPath extends ValidPaths<\n    TSchema,\n    TDiscriminatorKey,\n    TDiscriminatorValue,\n    TFilterType,\n    TStrict\n  >,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema>,\n  TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>,\n  TFilterType = unknown,\n  TStrict extends boolean = true,\n>(\n  params:\n    | FieldSelector<\n        TSchema,\n        TPath,\n        TDiscriminatorKey,\n        TDiscriminatorValue,\n        TFilterType,\n        TStrict\n      >\n    | {\n        schema?: undefined;\n        name?: undefined;\n        discriminator?: undefined;\n      },\n) {\n  const { discriminator, ...rest } = params;\n\n  return [\n    ...Object.values(rest),\n    ...(discriminator ? Object.values(discriminator) : []),\n  ];\n}\n","'use client';\n\nimport {\n  type Discriminator,\n  type DiscriminatorKey,\n  type DiscriminatorValue,\n  type ExtractZodByPath,\n  extractFieldFromSchema,\n  type FieldSelector,\n  getFieldChecks,\n  requiresValidInput,\n  type ValidPaths,\n  type ZodUnionCheck,\n} from '@zod-utils/core';\nimport {\n  type Context,\n  createContext,\n  type ReactNode,\n  useContext,\n  useMemo,\n} from 'react';\nimport type { z } from 'zod';\nimport type { SomeType } from 'zod/v4/core';\nimport { flattenFieldSelector } from './utils';\n\n/**\n * Type for the FormSchemaContext with full generic support.\n * @internal\n */\nexport type FormSchemaContextType<\n  TSchema extends z.ZodType,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema>,\n  TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>,\n  TFilterType = unknown,\n  TStrict extends boolean = true,\n> = Context<Omit<\n  FieldSelector<\n    TSchema,\n    ValidPaths<\n      TSchema,\n      TDiscriminatorKey,\n      TDiscriminatorValue,\n      TFilterType,\n      TStrict\n    >,\n    TDiscriminatorKey,\n    TDiscriminatorValue,\n    TFilterType,\n    TStrict\n  >,\n  'name'\n> | null>;\n\n/**\n * Context value type for FormSchemaContext.\n */\nexport type FormSchemaContextValue<\n  TSchema extends z.ZodType,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema>,\n  TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>,\n  TFilterType = unknown,\n  TStrict extends boolean = true,\n> = Omit<\n  FieldSelector<\n    TSchema,\n    ValidPaths<\n      TSchema,\n      TDiscriminatorKey,\n      TDiscriminatorValue,\n      TFilterType,\n      TStrict\n    >,\n    TDiscriminatorKey,\n    TDiscriminatorValue,\n    TFilterType,\n    TStrict\n  >,\n  'name'\n> | null;\n\n/**\n * React Context for providing Zod schema to form components.\n *\n * Use with {@link FormSchemaProvider} to provide schema context, and\n * {@link useFormSchema} to consume it in child components.\n */\nexport const FormSchemaContext = createContext<{\n  schema: z.ZodType;\n  discriminator?: {\n    key: unknown;\n    value: unknown;\n  };\n} | null>(null);\n\n/**\n * Hook to access the form schema from context.\n *\n * The optional `_params` argument is used for TypeScript type inference only.\n * Pass your schema to get proper type narrowing of the context value.\n *\n * @param _params - Optional params for type inference (not used at runtime)\n * @returns The schema context value or null if not within a provider\n *\n * @example\n * ```tsx\n * // Without type params (returns generic context)\n * function MyFormField() {\n *   const context = useFormSchema();\n *   if (!context) return null;\n *\n *   const { schema, discriminator } = context;\n *   // Use schema for validation or field extraction\n * }\n *\n * // With type params (for type-safe schema access)\n * function TypedFormField() {\n *   const context = useFormSchema({ schema: mySchema });\n *   // context.schema is now typed as typeof mySchema\n * }\n * ```\n */\nexport function useFormSchema<\n  TSchema extends z.ZodType = z.ZodType,\n  TDiscriminatorKey extends\n    DiscriminatorKey<TSchema> = DiscriminatorKey<TSchema>,\n  TDiscriminatorValue extends DiscriminatorValue<\n    TSchema,\n    TDiscriminatorKey\n  > = DiscriminatorValue<TSchema, TDiscriminatorKey>,\n  TFilterType = unknown,\n  TStrict extends boolean = true,\n>(\n  // Parameter used for type inference only, not at runtime\n  _params?: TSchema extends z.ZodPipe<infer In, SomeType>\n    ? In extends z.ZodDiscriminatedUnion\n      ? {\n          schema: TSchema;\n          discriminator: Discriminator<\n            TSchema,\n            TDiscriminatorKey,\n            TDiscriminatorValue\n          >;\n        }\n      : {\n          schema: TSchema;\n          discriminator?: undefined;\n        }\n    : TSchema extends z.ZodDiscriminatedUnion\n      ? {\n          schema: TSchema;\n          discriminator: Discriminator<\n            TSchema,\n            TDiscriminatorKey,\n            TDiscriminatorValue\n          >;\n        }\n      : {\n          schema: TSchema;\n          discriminator?: undefined;\n        },\n): FormSchemaContextValue<\n  TSchema,\n  TDiscriminatorKey,\n  TDiscriminatorValue,\n  TFilterType,\n  TStrict\n> {\n  return useContext(\n    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n    FormSchemaContext as Context<Omit<\n      FieldSelector<\n        TSchema,\n        ValidPaths<\n          TSchema,\n          TDiscriminatorKey,\n          TDiscriminatorValue,\n          TFilterType,\n          TStrict\n        >,\n        TDiscriminatorKey,\n        TDiscriminatorValue,\n        TFilterType,\n        TStrict\n      >,\n      'name'\n    > | null>,\n  );\n}\n\n/**\n * Provider component that makes Zod schema available to all child components.\n *\n * Use this to wrap your form and provide schema context to nested components\n * like field labels and validation indicators.\n *\n * @example\n * Basic usage with ZodObject\n * ```tsx\n * const schema = z.object({\n *   name: z.string(),\n *   email: z.string().email().optional()\n * });\n *\n * <FormSchemaProvider schema={schema}>\n *   <YourFormComponents />\n * </FormSchemaProvider>\n * ```\n *\n * @example\n * Usage with discriminated union\n * ```tsx\n * const schema = z.discriminatedUnion('mode', [\n *   z.object({ mode: z.literal('create'), name: z.string() }),\n *   z.object({ mode: z.literal('edit'), id: z.number() })\n * ]);\n *\n * <FormSchemaProvider\n *   schema={schema}\n *   discriminator={{ key: 'mode', value: 'create' }}\n * >\n *   <YourFormComponents />\n * </FormSchemaProvider>\n * ```\n */\nexport function FormSchemaProvider<\n  TSchema extends z.ZodType,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema>,\n  TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>,\n>({\n  schema,\n  discriminator,\n  children,\n}: (TSchema extends z.ZodPipe<infer In, SomeType>\n  ? In extends z.ZodDiscriminatedUnion\n    ? {\n        schema: TSchema;\n        discriminator: Discriminator<\n          TSchema,\n          TDiscriminatorKey,\n          TDiscriminatorValue\n        >;\n      }\n    : {\n        schema: TSchema;\n        discriminator?: undefined;\n      }\n  : TSchema extends z.ZodDiscriminatedUnion\n    ? {\n        schema: TSchema;\n        discriminator: Discriminator<\n          TSchema,\n          TDiscriminatorKey,\n          TDiscriminatorValue\n        >;\n      }\n    : {\n        schema: TSchema;\n        discriminator?: undefined;\n      }) & {\n  children: ReactNode;\n}) {\n  return (\n    <FormSchemaContext.Provider value={{ schema, discriminator }}>\n      {children}\n    </FormSchemaContext.Provider>\n  );\n}\n\n/**\n * Hook to check if a field requires valid input based on the Zod schema.\n *\n * Memoized - only recalculates when schema, name, or discriminator changes.\n *\n * @param params - Schema, name, and optional discriminator (schema and name are optional)\n * @returns true if the field requires valid input, false if it doesn't or if schema/name is not provided\n *\n * @example\n * ```tsx\n * function MyFieldLabel({ name, schema }: { name: string; schema: z.ZodType }) {\n *   const isRequired = useIsRequiredField({ schema, name });\n *\n *   return (\n *     <label>\n *       {name}\n *       {isRequired && <span className=\"text-red-500\">*</span>}\n *     </label>\n *   );\n * }\n * ```\n */\nexport function useIsRequiredField<\n  TSchema extends z.ZodType,\n  TPath extends ValidPaths<\n    TSchema,\n    TDiscriminatorKey,\n    TDiscriminatorValue,\n    TFilterType,\n    TStrict\n  >,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema>,\n  TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>,\n  TFilterType = unknown,\n  TStrict extends boolean = true,\n>(\n  params:\n    | FieldSelector<\n        TSchema,\n        TPath,\n        TDiscriminatorKey,\n        TDiscriminatorValue,\n        TFilterType,\n        TStrict\n      >\n    | {\n        schema?: undefined;\n        name?: undefined;\n        discriminator?: undefined;\n      },\n): boolean {\n  // biome-ignore lint/correctness/useExhaustiveDependencies: using flattenFieldSelector for stable deps\n  return useMemo(() => {\n    if (!params.schema || !params.name) {\n      return false;\n    }\n\n    return isRequiredField(params);\n  }, [...flattenFieldSelector(params)]);\n}\n\n/**\n * Determines if a field requires valid input (will show validation errors on empty/invalid input).\n *\n * Uses `requiresValidInput` from `@zod-utils/core` which checks the underlying field after\n * removing defaults. This tells you if the field will error when user submits empty input.\n *\n * Returns false if the underlying field accepts:\n * - `undefined` (via `.optional()`)\n * - `null` (via `.nullable()`)\n * - Empty strings (plain `z.string()` without `.min(1)`)\n * - Empty arrays (plain `z.array()` without `.min(1)`)\n *\n * @param options - Schema, field name, and optional discriminator\n * @returns true if the field requires valid input, false otherwise\n *\n * @example\n * ```typescript\n * const schema = z.object({\n *   name: z.string().min(1),\n *   bio: z.string().optional(),\n * });\n *\n * isRequiredField({ schema, name: 'name' }); // true\n * isRequiredField({ schema, name: 'bio' });  // false\n * ```\n *\n * @example\n * With discriminated union\n * ```typescript\n * const schema = z.discriminatedUnion('mode', [\n *   z.object({ mode: z.literal('create'), name: z.string().min(1) }),\n *   z.object({ mode: z.literal('edit'), id: z.number() }),\n * ]);\n *\n * isRequiredField({\n *   schema,\n *   name: 'name',\n *   discriminator: { key: 'mode', value: 'create' },\n * }); // true\n * ```\n */\nexport function isRequiredField<\n  TSchema extends z.ZodType,\n  TPath extends ValidPaths<\n    TSchema,\n    TDiscriminatorKey,\n    TDiscriminatorValue,\n    TFilterType,\n    TStrict\n  >,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema>,\n  TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>,\n  TFilterType = unknown,\n  TStrict extends boolean = true,\n>(\n  params: FieldSelector<\n    TSchema,\n    TPath,\n    TDiscriminatorKey,\n    TDiscriminatorValue,\n    TFilterType,\n    TStrict\n  >,\n): boolean {\n  const field = extractFieldFromSchema<\n    TSchema,\n    TPath,\n    TDiscriminatorKey,\n    TDiscriminatorValue,\n    TFilterType,\n    TStrict\n  >(params);\n\n  if (!field) {\n    return false;\n  }\n\n  return requiresValidInput(field);\n}\n\n/**\n * React hook to extract a field's Zod schema from a parent schema.\n *\n * Memoized - only recalculates when schema, name, or discriminator changes.\n * Supports nested paths and discriminated unions.\n *\n * @param params - Schema, name, and optional discriminator\n * @returns The Zod schema for the field, or undefined if not found\n *\n * @example\n * ```tsx\n * function MyFieldInfo({ name, schema }: { name: string; schema: z.ZodType }) {\n *   const fieldSchema = useExtractFieldFromSchema({ schema, name });\n *\n *   if (!fieldSchema) return null;\n *\n *   // Use fieldSchema for custom validation or field info\n *   return <span>{fieldSchema._zod.typeName}</span>;\n * }\n * ```\n *\n * @example\n * With discriminated union\n * ```tsx\n * const schema = z.discriminatedUnion('mode', [\n *   z.object({ mode: z.literal('create'), name: z.string() }),\n *   z.object({ mode: z.literal('edit'), id: z.number() }),\n * ]);\n *\n * const fieldSchema = useExtractFieldFromSchema({\n *   schema,\n *   name: 'name',\n *   discriminator: { key: 'mode', value: 'create' },\n * });\n * // Returns z.string() schema\n * ```\n */\nexport function useExtractFieldFromSchema<\n  TSchema extends z.ZodType,\n  TPath extends ValidPaths<\n    TSchema,\n    TDiscriminatorKey,\n    TDiscriminatorValue,\n    TFilterType,\n    TStrict\n  >,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema> = never,\n  TDiscriminatorValue extends DiscriminatorValue<\n    TSchema,\n    TDiscriminatorKey\n  > = never,\n  TFilterType = unknown,\n  TStrict extends boolean = true,\n>(\n  params: FieldSelector<\n    TSchema,\n    TPath,\n    TDiscriminatorKey,\n    TDiscriminatorValue,\n    TFilterType,\n    TStrict\n  >,\n): (ExtractZodByPath<TSchema, TPath> & z.ZodType) | undefined {\n  // biome-ignore lint/correctness/useExhaustiveDependencies: using flattenFieldSelector for stable deps\n  return useMemo(\n    () =>\n      extractFieldFromSchema<\n        TSchema,\n        TPath,\n        TDiscriminatorKey,\n        TDiscriminatorValue,\n        TFilterType,\n        TStrict\n      >(params),\n    [...flattenFieldSelector(params)],\n  );\n}\n\n/**\n * Hook to get validation checks from a field's Zod schema.\n *\n * Memoized - only recalculates when schema, name, or discriminator changes.\n * Combines field extraction and check retrieval in one cached operation.\n *\n * @param params - Schema, name, and optional discriminator\n * @returns Array of validation checks (min, max, pattern, etc.) or empty array\n *\n * @example\n * ```tsx\n * function MyFieldHint({ schema, name }: { schema: z.ZodType; name: string }) {\n *   const checks = useFieldChecks({ schema, name });\n *\n *   const maxLength = checks.find(c => c.check === 'max_length');\n *   if (maxLength) {\n *     return <span>Max {maxLength.maximum} characters</span>;\n *   }\n *   return null;\n * }\n * ```\n */\nexport function useFieldChecks<\n  TSchema extends z.ZodType,\n  TPath extends ValidPaths<\n    TSchema,\n    TDiscriminatorKey,\n    TDiscriminatorValue,\n    TFilterType,\n    TStrict\n  >,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema>,\n  TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>,\n  TFilterType = unknown,\n  TStrict extends boolean = true,\n>(\n  params: FieldSelector<\n    TSchema,\n    TPath,\n    TDiscriminatorKey,\n    TDiscriminatorValue,\n    TFilterType,\n    TStrict\n  >,\n): ZodUnionCheck[] {\n  // biome-ignore lint/correctness/useExhaustiveDependencies: using flattenFieldSelector for stable deps\n  return useMemo(() => {\n    const field = extractFieldFromSchema<\n      TSchema,\n      TPath,\n      TDiscriminatorKey,\n      TDiscriminatorValue,\n      TFilterType,\n      TStrict\n    >(params);\n    if (!field) return [];\n    return getFieldChecks(field);\n  }, [...flattenFieldSelector(params)]);\n}\n","import { zodResolver } from '@hookform/resolvers/zod';\nimport { type FieldValues, type UseFormProps, useForm } from 'react-hook-form';\nimport type { z } from 'zod';\nimport type {\n  PartialWithAllNullables,\n  PartialWithNullableObjects,\n} from './types';\n\n/**\n * Type-safe React Hook Form wrapper with automatic Zod v4 schema validation and type transformation.\n *\n * This hook eliminates the TypeScript friction between React Hook Form's nullable field values\n * and Zod's strict output types. It uses a two-type schema pattern where:\n * - **Input type** (`PartialWithNullableObjects<TOutput>`): Form fields accept `null | undefined` during editing\n * - **Output type** (`TOutput`): Validated data matches exact schema type (no `null | undefined`)\n *\n * **Key Benefits:**\n * - ✅ No more \"Type 'null' is not assignable to...\" TypeScript errors\n * - ✅ Use `form.setValue()` and `form.reset()` with `null` values freely\n * - ✅ Validated output is still type-safe with exact Zod schema types\n * - ✅ Automatic zodResolver setup - no manual configuration needed\n *\n * @template TInput - The Zod schema input type (accepts nullable/undefined values during form editing)\n * @template TOutput - The Zod schema output type (extends FieldValues)\n * @template TFormInput - The form input type (defaults to PartialWithNullableObjects<TInput>)\n * @template TDefaultValues - The type of default values (inferred from usage for better type safety)\n *\n * @param options - Configuration object\n * @param options.schema - Zod schema with two-type signature `z.ZodType<TOutput, TInput>`\n * @param options.defaultValues - Default form values (shallow partial - nested objects must be complete if provided)\n * @param options.zodResolverOptions - Optional zodResolver configuration\n * @param options....formOptions - All other react-hook-form useForm options\n *\n * @returns React Hook Form instance with type-safe methods\n *\n * @example\n * Basic usage with required fields\n * ```typescript\n * import { useZodForm } from '@zod-utils/react-hook-form';\n * import { z } from 'zod';\n *\n * const schema = z.object({\n *   name: z.string().min(1), // Required field\n *   age: z.number().min(0),\n * }) satisfies z.ZodType<{ name: string; age: number }, any>;\n *\n * function MyForm() {\n *   const form = useZodForm({ schema });\n *\n *   // ✅ These work without type errors:\n *   form.setValue('name', null); // Accepts null during editing\n *   form.reset({ name: null, age: null }); // Reset with null\n *\n *   const onSubmit = (data: { name: string; age: number }) => {\n *     // ✅ data is exact type - no null | undefined\n *     console.log(data.name.toUpperCase()); // Safe to use string methods\n *   };\n *\n *   return <form onSubmit={form.handleSubmit(onSubmit)}>...</form>;\n * }\n * ```\n *\n * @example\n * With default values\n * ```typescript\n * const schema = z.object({\n *   username: z.string(),\n *   email: z.string().email(),\n *   notifications: z.boolean().default(true),\n * }) satisfies z.ZodType<{\n *   username: string;\n *   email: string;\n *   notifications: boolean;\n * }, any>;\n *\n * const form = useZodForm({\n *   schema,\n *   defaultValues: {\n *     username: '',\n *     email: '',\n *     // notifications gets default from schema\n *   },\n * });\n * ```\n *\n * @example\n * Without default values (all fields are optional during editing)\n * ```typescript\n * const schema = z.object({\n *   name: z.string().min(1),\n *   email: z.string().email(),\n *   age: z.number(),\n * }) satisfies z.ZodType<{ name: string; email: string; age: number }, any>;\n *\n * // ✅ No defaultValues needed - fields are optional during editing\n * const form = useZodForm({ schema });\n *\n * // Form fields can be set individually as user types\n * form.setValue('name', 'John');\n * form.setValue('email', 'john@example.com');\n * form.setValue('age', 25);\n *\n * // All fields must be valid on submit (per schema validation)\n * ```\n *\n * @example\n * With optional and nullable fields\n * ```typescript\n * const schema = z.object({\n *   title: z.string(),\n *   description: z.string().optional(), // Optional in output\n *   tags: z.array(z.string()).nullable(), // Nullable in output\n * }) satisfies z.ZodType<{\n *   title: string;\n *   description?: string;\n *   tags: string[] | null;\n * }, any>;\n *\n * const form = useZodForm({ schema });\n *\n * // All fields accept null/undefined during editing\n * form.setValue('title', null);\n * form.setValue('description', undefined);\n * form.setValue('tags', null);\n * ```\n *\n * @example\n * With zodResolver options\n * ```typescript\n * const form = useZodForm({\n *   schema,\n *   zodResolverOptions: {\n *     async: true, // Enable async validation\n *     errorMap: customErrorMap, // Custom error messages\n *   },\n * });\n * ```\n *\n * @example\n * Complete form example\n * ```typescript\n * const userSchema = z.object({\n *   name: z.string().min(1, 'Name is required'),\n *   email: z.string().email('Invalid email'),\n *   age: z.number().min(18, 'Must be 18+'),\n * }) satisfies z.ZodType<{ name: string; email: string; age: number }, any>;\n *\n * function UserForm() {\n *   const form = useZodForm({\n *     schema: userSchema,\n *     defaultValues: { name: '', email: '', age: null },\n *   });\n *\n *   const onSubmit = (data: { name: string; email: string; age: number }) => {\n *     // Type-safe: data has exact types, no null/undefined\n *     console.log(`${data.name} is ${data.age} years old`);\n *   };\n *\n *   return (\n *     <form onSubmit={form.handleSubmit(onSubmit)}>\n *       <input {...form.register('name')} />\n *       <input {...form.register('email')} type=\"email\" />\n *       <input {...form.register('age', { valueAsNumber: true })} type=\"number\" />\n *       <button type=\"submit\">Submit</button>\n *     </form>\n *   );\n * }\n * ```\n *\n * @see {@link PartialWithNullableObjects} for the type transformation utility\n * @see https://react-hook-form.com/docs/useform for React Hook Form documentation\n * @see https://zod.dev for Zod schema documentation\n * @since 0.1.0\n */\nexport const useZodForm = <\n  TInput extends FieldValues,\n  TOutput extends FieldValues,\n  TFormInput extends\n    PartialWithAllNullables<TInput> = PartialWithNullableObjects<TInput>,\n  TDefaultValues extends Partial<TFormInput> | undefined = undefined,\n>({\n  schema,\n  zodResolverOptions,\n  ...formOptions\n}: {\n  schema: z.ZodType<TOutput, TInput>;\n  defaultValues?: TDefaultValues;\n  zodResolverOptions?: Parameters<typeof zodResolver>[1];\n} & Omit<\n  UseFormProps<TFormInput, unknown, TOutput>,\n  'resolver' | 'defaultValues'\n>) => {\n  const resolver = zodResolver(schema, zodResolverOptions);\n\n  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n  return useForm({\n    resolver,\n    ...formOptions,\n  } as unknown as UseFormProps<TFormInput, unknown, TOutput>);\n};\n"]}
+{"version":3,"sources":["../src/utils.ts","../src/context.tsx","../src/use-zod-form.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkBO,SAAS,qBAAqB,MAAA,EAIlC;AAtBH,EAAA,IAAA,EAAA,EAAA,EAAA;AAuBE,EAAA,OAAO;AAAA,IACL,MAAA,IAAA,IAAA,GAAA,MAAA,GAAA,MAAA,CAAQ,MAAA;AAAA,IACR,MAAA,IAAA,IAAA,GAAA,MAAA,GAAA,MAAA,CAAQ,IAAA;AAAA,IAAA,CACR,EAAA,GAAA,MAAA,IAAA,IAAA,GAAA,MAAA,GAAA,MAAA,CAAQ,kBAAR,IAAA,GAAA,MAAA,GAAA,EAAA,CAAuB,GAAA;AAAA,IAAA,CACvB,EAAA,GAAA,MAAA,IAAA,IAAA,GAAA,MAAA,GAAA,MAAA,CAAQ,kBAAR,IAAA,GAAA,MAAA,GAAA,EAAA,CAAuB;AAAA,GACzB;AACF;AC0BO,IAAM,iBAAA,GAAoB,cAMvB,IAAI;AA6BP,SAAS,cAUd,OAAA,EAKyE;AAKzE,EAAA,OAAO,WAAW,iBAAiB,CAAA;AAKrC;AAqCO,SAAS,kBAAA,CAId;AAAA,EACA,MAAA;AAAA,EACA,aAAA;AAAA,EACA;AACF,CAAA,EAI6B;AAC3B,EAAA,uBACE,GAAA,CAAC,kBAAkB,QAAA,EAAlB,EAA2B,OAAO,EAAE,MAAA,EAAQ,aAAA,EAAc,EACxD,QAAA,EACH,CAAA;AAEJ;AAwBO,SAAS,mBAUd,MAAA,EASS;AAET,EAAA,OAAO,QAAQ,MAAM;AACnB,IAAA,IAAI,CAAC,MAAA,EAAQ;AACX,MAAA,OAAO,KAAA;AAAA,IACT;AACA,IAAA,OAAO,gBAAgB,MAAM,CAAA;AAAA,EAC/B,GAAG,CAAC,GAAG,oBAAA,CAAqB,MAAM,CAAC,CAAC,CAAA;AACtC;AA2CO,SAAS,gBAUd,MAAA,EAOS;AACT,EAAA,MAAM,KAAA,GAAQ,uBAAuB,MAAM,CAAA;AAE3C,EAAA,IAAI,CAAC,KAAA,EAAO;AACV,IAAA,OAAO,KAAA;AAAA,EACT;AAEA,EAAA,OAAO,mBAAmB,KAAK,CAAA;AACjC;AAuCO,SAAS,0BAUd,MAAA,EASuB;AAEvB,EAAA,OAAO,QAAQ,MAAM;AACnB,IAAA,IAAI,CAAC,MAAA,EAAQ;AACX,MAAA,OAAO,MAAA;AAAA,IACT;AACA,IAAA,OAAO,uBAAuB,MAAM,CAAA;AAAA,EACtC,GAAG,CAAC,GAAG,oBAAA,CAAqB,MAAM,CAAC,CAAC,CAAA;AACtC;AAwBO,SAAS,eAUd,MAAA,EASiB;AAEjB,EAAA,OAAO,QAAQ,MAAM;AACnB,IAAA,IAAI,CAAC,MAAA,EAAQ;AACX,MAAA,OAAO,EAAC;AAAA,IACV;AAEA,IAAA,MAAM,KAAA,GAAQ,uBAAuB,MAAM,CAAA;AAC3C,IAAA,IAAI,CAAC,KAAA,EAAO,OAAO,EAAC;AACpB,IAAA,OAAO,eAAe,KAAK,CAAA;AAAA,EAC7B,GAAG,CAAC,GAAG,oBAAA,CAAqB,MAAM,CAAC,CAAC,CAAA;AACtC;AC3OO,IAAM,UAAA,GAAa,CAMxB,EAAA,KAWI;AAXJ,EAAA,IAAA,EAAA,GAAA,EAAA,EACA;AAAA,IAAA,MAAA;AAAA,IACA;AAAA,GAtLF,GAoLE,EAAA,EAGG,WAAA,GAAA,SAAA,CAHH,EAAA,EAGG;AAAA,IAFH,QAAA;AAAA,IACA;AAAA,GAAA,CAAA;AAUA,EAAA,MAAM,QAAA,GAAW,WAAA,CAAY,MAAA,EAAQ,kBAAkB,CAAA;AAGvD,EAAA,OAAO,OAAA,CAAQ,cAAA,CAAA;AAAA,IACb;AAAA,GAAA,EACG,WAAA,CACqD,CAAA;AAC5D","file":"index.mjs","sourcesContent":["import type { z } from 'zod';\n\n/**\n * Flattens a FieldSelector into an array of primitive values for use in React dependency arrays.\n *\n * This is useful for `useMemo` and `useCallback` dependencies where you want to avoid\n * re-running when object references change but values stay the same.\n *\n * @param params - The FieldSelector containing schema, name, and optional discriminator\n * @returns An array of primitive values suitable for React dependency arrays\n *\n * @example\n * ```tsx\n * const memoizedValue = useMemo(() => {\n *   return extractFieldFromSchema(params);\n * }, flattenFieldSelector(params));\n * ```\n */\nexport function flattenFieldSelector(params?: {\n  schema?: z.ZodType;\n  name?: string;\n  discriminator?: { key: unknown; value: unknown };\n}) {\n  return [\n    params?.schema,\n    params?.name,\n    params?.discriminator?.key,\n    params?.discriminator?.value,\n  ];\n}\n","'use client';\n\nimport {\n  type DiscriminatorKey,\n  type DiscriminatorValue,\n  extractFieldFromSchema,\n  type FieldSelectorProps,\n  getFieldChecks,\n  requiresValidInput,\n  type SchemaAndDiscriminatorProps,\n  type ZodUnionCheck,\n} from '@zod-utils/core';\nimport {\n  type Context,\n  createContext,\n  type ReactNode,\n  useContext,\n  useMemo,\n} from 'react';\nimport type { z } from 'zod';\nimport { flattenFieldSelector } from './utils';\n\n/**\n * Type for the FormSchemaContext with full generic support.\n * @internal\n */\nexport type FormSchemaContextType<\n  TSchema extends z.ZodType,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema>,\n  TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>,\n> = Context<SchemaAndDiscriminatorProps<\n  TSchema,\n  TDiscriminatorKey,\n  TDiscriminatorValue\n> | null>;\n\n/**\n * Context value type for FormSchemaContext.\n */\nexport type FormSchemaContextValue<\n  TSchema extends z.ZodType,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema>,\n  TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>,\n> = SchemaAndDiscriminatorProps<\n  TSchema,\n  TDiscriminatorKey,\n  TDiscriminatorValue\n> | null;\n\n/**\n * React Context for providing Zod schema to form components.\n *\n * Use with {@link FormSchemaProvider} to provide schema context, and\n * {@link useFormSchema} to consume it in child components.\n */\nexport const FormSchemaContext = createContext<{\n  schema: z.ZodType;\n  discriminator?: {\n    key: unknown;\n    value: unknown;\n  };\n} | null>(null);\n\n/**\n * Hook to access the form schema from context.\n *\n * The optional `_params` argument is used for TypeScript type inference only.\n * Pass your schema to get proper type narrowing of the context value.\n *\n * @param _params - Optional params for type inference (not used at runtime)\n * @returns The schema context value or null if not within a provider\n *\n * @example\n * ```tsx\n * // Without type params (returns generic context)\n * function MyFormField() {\n *   const context = useFormSchema();\n *   if (!context) return null;\n *\n *   const { schema, discriminator } = context;\n *   // Use schema for validation or field extraction\n * }\n *\n * // With type params (for type-safe schema access)\n * function TypedFormField() {\n *   const context = useFormSchema({ schema: mySchema });\n *   // context.schema is now typed as typeof mySchema\n * }\n * ```\n */\nexport function useFormSchema<\n  TSchema extends z.ZodType = z.ZodType,\n  TDiscriminatorKey extends\n    DiscriminatorKey<TSchema> = DiscriminatorKey<TSchema>,\n  TDiscriminatorValue extends DiscriminatorValue<\n    TSchema,\n    TDiscriminatorKey\n  > = DiscriminatorValue<TSchema, TDiscriminatorKey>,\n>(\n  // Parameter used for type inference only, not at runtime\n  _params?: SchemaAndDiscriminatorProps<\n    TSchema,\n    TDiscriminatorKey,\n    TDiscriminatorValue\n  >,\n): FormSchemaContextValue<TSchema, TDiscriminatorKey, TDiscriminatorValue> {\n  // Type assertion is necessary because React context is created with a generic type,\n  // but we want to return a narrower type based on the generic parameters.\n  // The caller is responsible for ensuring type safety via the _params argument.\n  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n  return useContext(FormSchemaContext) as FormSchemaContextValue<\n    TSchema,\n    TDiscriminatorKey,\n    TDiscriminatorValue\n  >;\n}\n\n/**\n * Provider component that makes Zod schema available to all child components.\n *\n * Use this to wrap your form and provide schema context to nested components\n * like field labels and validation indicators.\n *\n * @example\n * Basic usage with ZodObject\n * ```tsx\n * const schema = z.object({\n *   name: z.string(),\n *   email: z.string().email().optional()\n * });\n *\n * <FormSchemaProvider schema={schema}>\n *   <YourFormComponents />\n * </FormSchemaProvider>\n * ```\n *\n * @example\n * Usage with discriminated union\n * ```tsx\n * const schema = z.discriminatedUnion('mode', [\n *   z.object({ mode: z.literal('create'), name: z.string() }),\n *   z.object({ mode: z.literal('edit'), id: z.number() })\n * ]);\n *\n * <FormSchemaProvider\n *   schema={schema}\n *   discriminator={{ key: 'mode', value: 'create' }}\n * >\n *   <YourFormComponents />\n * </FormSchemaProvider>\n * ```\n */\nexport function FormSchemaProvider<\n  TSchema extends z.ZodType,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema>,\n  TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>,\n>({\n  schema,\n  discriminator,\n  children,\n}: SchemaAndDiscriminatorProps<\n  TSchema,\n  TDiscriminatorKey,\n  TDiscriminatorValue\n> & { children: ReactNode }) {\n  return (\n    <FormSchemaContext.Provider value={{ schema, discriminator }}>\n      {children}\n    </FormSchemaContext.Provider>\n  );\n}\n\n/**\n * Hook to check if a field requires valid input based on the Zod schema.\n *\n * Memoized - only recalculates when schema, name, or discriminator changes.\n *\n * @param params - Schema, name, and optional discriminator\n * @returns true if the field requires valid input, false otherwise\n *\n * @example\n * ```tsx\n * function MyFieldLabel({ name, schema }: { name: string; schema: z.ZodType }) {\n *   const isRequired = useIsRequiredField({ schema, name });\n *\n *   return (\n *     <label>\n *       {name}\n *       {isRequired && <span className=\"text-red-500\">*</span>}\n *     </label>\n *   );\n * }\n * ```\n */\nexport function useIsRequiredField<\n  TSchema extends z.ZodType,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema> = never,\n  TDiscriminatorValue extends DiscriminatorValue<\n    TSchema,\n    TDiscriminatorKey\n  > = never,\n  TFilterType = unknown,\n  TStrict extends boolean = true,\n>(\n  params:\n    | FieldSelectorProps<\n        TSchema,\n        TDiscriminatorKey,\n        TDiscriminatorValue,\n        TFilterType,\n        TStrict\n      >\n    | undefined,\n): boolean {\n  // biome-ignore lint/correctness/useExhaustiveDependencies: using flattenFieldSelector for stable deps\n  return useMemo(() => {\n    if (!params) {\n      return false;\n    }\n    return isRequiredField(params);\n  }, [...flattenFieldSelector(params)]);\n}\n\n/**\n * Determines if a field requires valid input (will show validation errors on empty/invalid input).\n *\n * Uses `requiresValidInput` from `@zod-utils/core` which checks the underlying field after\n * removing defaults. This tells you if the field will error when user submits empty input.\n *\n * Returns false if the underlying field accepts:\n * - `undefined` (via `.optional()`)\n * - `null` (via `.nullable()`)\n * - Empty strings (plain `z.string()` without `.min(1)`)\n * - Empty arrays (plain `z.array()` without `.min(1)`)\n *\n * @param options - Schema, field name, and optional discriminator\n * @returns true if the field requires valid input, false otherwise\n *\n * @example\n * ```typescript\n * const schema = z.object({\n *   name: z.string().min(1),\n *   bio: z.string().optional(),\n * });\n *\n * isRequiredField({ schema, name: 'name' }); // true\n * isRequiredField({ schema, name: 'bio' });  // false\n * ```\n *\n * @example\n * With discriminated union\n * ```typescript\n * const schema = z.discriminatedUnion('mode', [\n *   z.object({ mode: z.literal('create'), name: z.string().min(1) }),\n *   z.object({ mode: z.literal('edit'), id: z.number() }),\n * ]);\n *\n * isRequiredField({\n *   schema,\n *   name: 'name',\n *   discriminator: { key: 'mode', value: 'create' },\n * }); // true\n * ```\n */\nexport function isRequiredField<\n  TSchema extends z.ZodType,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema> = never,\n  TDiscriminatorValue extends DiscriminatorValue<\n    TSchema,\n    TDiscriminatorKey\n  > = never,\n  TFilterType = unknown,\n  TStrict extends boolean = true,\n>(\n  params: FieldSelectorProps<\n    TSchema,\n    TDiscriminatorKey,\n    TDiscriminatorValue,\n    TFilterType,\n    TStrict\n  >,\n): boolean {\n  const field = extractFieldFromSchema(params);\n\n  if (!field) {\n    return false;\n  }\n\n  return requiresValidInput(field);\n}\n\n/**\n * React hook to extract a field's Zod schema from a parent schema.\n *\n * Memoized - only recalculates when schema, name, or discriminator changes.\n * Supports nested paths and discriminated unions.\n *\n * @param params - Schema, name, and optional discriminator\n * @returns The Zod schema for the field, or undefined if not found\n *\n * @example\n * ```tsx\n * function MyFieldInfo({ name, schema }: { name: string; schema: z.ZodType }) {\n *   const fieldSchema = useExtractFieldFromSchema({ schema, name });\n *\n *   if (!fieldSchema) return null;\n *\n *   // Use fieldSchema for custom validation or field info\n *   return <span>{fieldSchema._zod.typeName}</span>;\n * }\n * ```\n *\n * @example\n * With discriminated union\n * ```tsx\n * const schema = z.discriminatedUnion('mode', [\n *   z.object({ mode: z.literal('create'), name: z.string() }),\n *   z.object({ mode: z.literal('edit'), id: z.number() }),\n * ]);\n *\n * const fieldSchema = useExtractFieldFromSchema({\n *   schema,\n *   name: 'name',\n *   discriminator: { key: 'mode', value: 'create' },\n * });\n * // Returns z.string() schema\n * ```\n */\nexport function useExtractFieldFromSchema<\n  TSchema extends z.ZodType,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema> = never,\n  TDiscriminatorValue extends DiscriminatorValue<\n    TSchema,\n    TDiscriminatorKey\n  > = never,\n  TFilterType = unknown,\n  TStrict extends boolean = true,\n>(\n  params:\n    | FieldSelectorProps<\n        TSchema,\n        TDiscriminatorKey,\n        TDiscriminatorValue,\n        TFilterType,\n        TStrict\n      >\n    | undefined,\n): z.ZodType | undefined {\n  // biome-ignore lint/correctness/useExhaustiveDependencies: using flattenFieldSelector for stable deps\n  return useMemo(() => {\n    if (!params) {\n      return undefined;\n    }\n    return extractFieldFromSchema(params);\n  }, [...flattenFieldSelector(params)]);\n}\n\n/**\n * Hook to get validation checks from a field's Zod schema.\n *\n * Memoized - only recalculates when schema, name, or discriminator changes.\n * Combines field extraction and check retrieval in one cached operation.\n *\n * @param params - Schema, name, and optional discriminator\n * @returns Array of validation checks (min, max, pattern, etc.) or empty array\n *\n * @example\n * ```tsx\n * function MyFieldHint({ schema, name }: { schema: z.ZodType; name: string }) {\n *   const checks = useFieldChecks({ schema, name });\n *\n *   const maxLength = checks.find(c => c.check === 'max_length');\n *   if (maxLength) {\n *     return <span>Max {maxLength.maximum} characters</span>;\n *   }\n *   return null;\n * }\n * ```\n */\nexport function useFieldChecks<\n  TSchema extends z.ZodType,\n  TDiscriminatorKey extends DiscriminatorKey<TSchema> = never,\n  TDiscriminatorValue extends DiscriminatorValue<\n    TSchema,\n    TDiscriminatorKey\n  > = never,\n  TFilterType = unknown,\n  TStrict extends boolean = true,\n>(\n  params:\n    | FieldSelectorProps<\n        TSchema,\n        TDiscriminatorKey,\n        TDiscriminatorValue,\n        TFilterType,\n        TStrict\n      >\n    | undefined,\n): ZodUnionCheck[] {\n  // biome-ignore lint/correctness/useExhaustiveDependencies: using flattenFieldSelector for stable deps\n  return useMemo(() => {\n    if (!params) {\n      return [];\n    }\n\n    const field = extractFieldFromSchema(params);\n    if (!field) return [];\n    return getFieldChecks(field);\n  }, [...flattenFieldSelector(params)]);\n}\n","import { zodResolver } from '@hookform/resolvers/zod';\nimport { type FieldValues, type UseFormProps, useForm } from 'react-hook-form';\nimport type { z } from 'zod';\nimport type {\n  PartialWithAllNullables,\n  PartialWithNullableObjects,\n} from './types';\n\n/**\n * Type-safe React Hook Form wrapper with automatic Zod v4 schema validation and type transformation.\n *\n * This hook eliminates the TypeScript friction between React Hook Form's nullable field values\n * and Zod's strict output types. It uses a two-type schema pattern where:\n * - **Input type** (`PartialWithNullableObjects<TOutput>`): Form fields accept `null | undefined` during editing\n * - **Output type** (`TOutput`): Validated data matches exact schema type (no `null | undefined`)\n *\n * **Key Benefits:**\n * - ✅ No more \"Type 'null' is not assignable to...\" TypeScript errors\n * - ✅ Use `form.setValue()` and `form.reset()` with `null` values freely\n * - ✅ Validated output is still type-safe with exact Zod schema types\n * - ✅ Automatic zodResolver setup - no manual configuration needed\n *\n * @template TInput - The Zod schema input type (accepts nullable/undefined values during form editing)\n * @template TOutput - The Zod schema output type (extends FieldValues)\n * @template TFormInput - The form input type (defaults to PartialWithNullableObjects<TInput>)\n * @template TDefaultValues - The type of default values (inferred from usage for better type safety)\n *\n * @param options - Configuration object\n * @param options.schema - Zod schema with two-type signature `z.ZodType<TOutput, TInput>`\n * @param options.defaultValues - Default form values (shallow partial - nested objects must be complete if provided)\n * @param options.zodResolverOptions - Optional zodResolver configuration\n * @param options....formOptions - All other react-hook-form useForm options\n *\n * @returns React Hook Form instance with type-safe methods\n *\n * @example\n * Basic usage with required fields\n * ```typescript\n * import { useZodForm } from '@zod-utils/react-hook-form';\n * import { z } from 'zod';\n *\n * const schema = z.object({\n *   name: z.string().min(1), // Required field\n *   age: z.number().min(0),\n * }) satisfies z.ZodType<{ name: string; age: number }, any>;\n *\n * function MyForm() {\n *   const form = useZodForm({ schema });\n *\n *   // ✅ These work without type errors:\n *   form.setValue('name', null); // Accepts null during editing\n *   form.reset({ name: null, age: null }); // Reset with null\n *\n *   const onSubmit = (data: { name: string; age: number }) => {\n *     // ✅ data is exact type - no null | undefined\n *     console.log(data.name.toUpperCase()); // Safe to use string methods\n *   };\n *\n *   return <form onSubmit={form.handleSubmit(onSubmit)}>...</form>;\n * }\n * ```\n *\n * @example\n * With default values\n * ```typescript\n * const schema = z.object({\n *   username: z.string(),\n *   email: z.string().email(),\n *   notifications: z.boolean().default(true),\n * }) satisfies z.ZodType<{\n *   username: string;\n *   email: string;\n *   notifications: boolean;\n * }, any>;\n *\n * const form = useZodForm({\n *   schema,\n *   defaultValues: {\n *     username: '',\n *     email: '',\n *     // notifications gets default from schema\n *   },\n * });\n * ```\n *\n * @example\n * Without default values (all fields are optional during editing)\n * ```typescript\n * const schema = z.object({\n *   name: z.string().min(1),\n *   email: z.string().email(),\n *   age: z.number(),\n * }) satisfies z.ZodType<{ name: string; email: string; age: number }, any>;\n *\n * // ✅ No defaultValues needed - fields are optional during editing\n * const form = useZodForm({ schema });\n *\n * // Form fields can be set individually as user types\n * form.setValue('name', 'John');\n * form.setValue('email', 'john@example.com');\n * form.setValue('age', 25);\n *\n * // All fields must be valid on submit (per schema validation)\n * ```\n *\n * @example\n * With optional and nullable fields\n * ```typescript\n * const schema = z.object({\n *   title: z.string(),\n *   description: z.string().optional(), // Optional in output\n *   tags: z.array(z.string()).nullable(), // Nullable in output\n * }) satisfies z.ZodType<{\n *   title: string;\n *   description?: string;\n *   tags: string[] | null;\n * }, any>;\n *\n * const form = useZodForm({ schema });\n *\n * // All fields accept null/undefined during editing\n * form.setValue('title', null);\n * form.setValue('description', undefined);\n * form.setValue('tags', null);\n * ```\n *\n * @example\n * With zodResolver options\n * ```typescript\n * const form = useZodForm({\n *   schema,\n *   zodResolverOptions: {\n *     async: true, // Enable async validation\n *     errorMap: customErrorMap, // Custom error messages\n *   },\n * });\n * ```\n *\n * @example\n * Complete form example\n * ```typescript\n * const userSchema = z.object({\n *   name: z.string().min(1, 'Name is required'),\n *   email: z.string().email('Invalid email'),\n *   age: z.number().min(18, 'Must be 18+'),\n * }) satisfies z.ZodType<{ name: string; email: string; age: number }, any>;\n *\n * function UserForm() {\n *   const form = useZodForm({\n *     schema: userSchema,\n *     defaultValues: { name: '', email: '', age: null },\n *   });\n *\n *   const onSubmit = (data: { name: string; email: string; age: number }) => {\n *     // Type-safe: data has exact types, no null/undefined\n *     console.log(`${data.name} is ${data.age} years old`);\n *   };\n *\n *   return (\n *     <form onSubmit={form.handleSubmit(onSubmit)}>\n *       <input {...form.register('name')} />\n *       <input {...form.register('email')} type=\"email\" />\n *       <input {...form.register('age', { valueAsNumber: true })} type=\"number\" />\n *       <button type=\"submit\">Submit</button>\n *     </form>\n *   );\n * }\n * ```\n *\n * @see {@link PartialWithNullableObjects} for the type transformation utility\n * @see https://react-hook-form.com/docs/useform for React Hook Form documentation\n * @see https://zod.dev for Zod schema documentation\n * @since 0.1.0\n */\nexport const useZodForm = <\n  TInput extends FieldValues,\n  TOutput extends FieldValues,\n  TFormInput extends\n    PartialWithAllNullables<TInput> = PartialWithNullableObjects<TInput>,\n  TDefaultValues extends Partial<TFormInput> | undefined = undefined,\n>({\n  schema,\n  zodResolverOptions,\n  ...formOptions\n}: {\n  schema: z.ZodType<TOutput, TInput>;\n  defaultValues?: TDefaultValues;\n  zodResolverOptions?: Parameters<typeof zodResolver>[1];\n} & Omit<\n  UseFormProps<TFormInput, unknown, TOutput>,\n  'resolver' | 'defaultValues'\n>) => {\n  const resolver = zodResolver(schema, zodResolverOptions);\n\n  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n  return useForm({\n    resolver,\n    ...formOptions,\n  } as unknown as UseFormProps<TFormInput, unknown, TOutput>);\n};\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zod-utils/react-hook-form",
-  "version": "5.0.0",
+  "version": "6.0.1",
   "description": "React Hook Form integration and utilities for Zod schemas",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",