ivt 0.7.2 → 0.7.4

package/dist/chunks/{form-CChLO9RR.mjs → form-CJnoOgoH.mjs}

@@ -1,8 +1,8 @@
 import { Slot } from '@radix-ui/react-slot';
 import * as React from 'react';
 import React__default from 'react';
-import { c as cn } from './utils-BOlqGJrg.mjs';
-import { L as Label } from './label-BgC413_9.mjs';
+import { c as cn } from './utils-M7D-rn0u.mjs';
+import { L as Label } from './label-81mjh4Q4.mjs';
 
 var isCheckBoxInput = (element)=>element.type === 'checkbox';
 var isDateObject = (value1)=>value1 instanceof Date;
@@ -18,25 +18,23 @@ var isPlainObject = (tempObject)=>{
 };
 var isWeb = typeof window !== 'undefined' && typeof window.HTMLElement !== 'undefined' && typeof document !== 'undefined';
 function cloneObject(data) {
-    let copy;
-    const isArray = Array.isArray(data);
-    const isFileListInstance = typeof FileList !== 'undefined' ? data instanceof FileList : false;
     if (data instanceof Date) {
-        copy = new Date(data);
-    } else if (!(isWeb && (data instanceof Blob || isFileListInstance)) && (isArray || isObject(data))) {
-        copy = isArray ? [] : Object.create(Object.getPrototypeOf(data));
-        if (!isArray && !isPlainObject(data)) {
-            copy = data;
-        } else {
-            for(const key in data){
-                if (data.hasOwnProperty(key)) {
-                    copy[key] = cloneObject(data[key]);
-                }
-            }
-        }
-    } else {
+        return new Date(data);
+    }
+    const isFileListInstance = typeof FileList !== 'undefined' && data instanceof FileList;
+    if (isWeb && (data instanceof Blob || isFileListInstance)) {
+        return data;
+    }
+    const isArray = Array.isArray(data);
+    if (!isArray && !(isObject(data) && isPlainObject(data))) {
         return data;
     }
+    const copy = isArray ? [] : Object.create(Object.getPrototypeOf(data));
+    for(const key in data){
+        if (Object.prototype.hasOwnProperty.call(data, key)) {
+            copy[key] = cloneObject(data[key]);
+        }
+    }
     return copy;
 }
 var isKey = (value1)=>/^\w*$/.test(value1);
@@ -53,6 +51,7 @@ var get = (object, path, defaultValue)=>{
     return isUndefined(result) || result === object ? isUndefined(object[path]) ? defaultValue : object[path] : result;
 };
 var isBoolean = (value1)=>typeof value1 === 'boolean';
+var isFunction = (value1)=>typeof value1 === 'function';
 var set = (object, path, value1)=>{
     let index = -1;
     const tempPath = isKey(path) ? [
@@ -95,73 +94,14 @@ const INPUT_VALIDATION_RULES = {
     required: 'required',
     validate: 'validate'
 };
-const HookFormContext = React__default.createContext(null);
-HookFormContext.displayName = 'HookFormContext';
 /**
- * This custom hook allows you to access the form context. useFormContext is intended to be used in deeply nested structures, where it would become inconvenient to pass the context as a prop. To be used with {@link FormProvider}.
- *
- * @remarks
- * [API](https://react-hook-form.com/docs/useformcontext) • [Demo](https://codesandbox.io/s/react-hook-form-v7-form-context-ytudi)
- *
- * @returns return all useForm methods
- *
- * @example
- * ```tsx
- * function App() {
- *   const methods = useForm();
- *   const onSubmit = data => console.log(data);
- *
- *   return (
- *     <FormProvider {...methods} >
- *       <form onSubmit={methods.handleSubmit(onSubmit)}>
- *         <NestedInput />
- *         <input type="submit" />
- *       </form>
- *     </FormProvider>
- *   );
- * }
- *
- *  function NestedInput() {
- *   const { register } = useFormContext(); // retrieve all hook methods
- *   return <input {...register("test")} />;
- * }
- * ```
- */ const useFormContext = ()=>React__default.useContext(HookFormContext);
+ * Separate context for `control` to prevent unnecessary rerenders.
+ * Internal hooks that only need control use this instead of full form context.
+ */ const HookFormControlContext = React__default.createContext(null);
+HookFormControlContext.displayName = 'HookFormControlContext';
 /**
- * A provider component that propagates the `useForm` methods to all children components via [React Context](https://reactjs.org/docs/context.html) API. To be used with {@link useFormContext}.
- *
- * @remarks
- * [API](https://react-hook-form.com/docs/useformcontext) • [Demo](https://codesandbox.io/s/react-hook-form-v7-form-context-ytudi)
- *
- * @param props - all useForm methods
- *
- * @example
- * ```tsx
- * function App() {
- *   const methods = useForm();
- *   const onSubmit = data => console.log(data);
- *
- *   return (
- *     <FormProvider {...methods} >
- *       <form onSubmit={methods.handleSubmit(onSubmit)}>
- *         <NestedInput />
- *         <input type="submit" />
- *       </form>
- *     </FormProvider>
- *   );
- * }
- *
- *  function NestedInput() {
- *   const { register } = useFormContext(); // retrieve all hook methods
- *   return <input {...register("test")} />;
- * }
- * ```
- */ const FormProvider = (props)=>{
-    const { children, ...data } = props;
-    return React__default.createElement(HookFormContext.Provider, {
-        value: data
-    }, children);
-};
+ * @internal Internal hook to access only control from context.
+ */ const useFormControlContext = ()=>React__default.useContext(HookFormControlContext);
 var getProxyFormState = (formState, control, localProxyFormState, isRoot = true)=>{
     const result = {
         defaultValues: control._defaultValues
@@ -211,8 +151,8 @@ const useIsomorphicLayoutEffect = typeof window !== 'undefined' ? React__default
  * }
  * ```
  */ function useFormState(props) {
-    const methods = useFormContext();
-    const { control = methods.control, disabled, name, exact } = props || {};
+    const formControl = useFormControlContext();
+    const { control = formControl, disabled, name, exact } = props || {};
     const [formState, updateFormState] = React__default.useState(control._formState);
     const _localProxyFormState = React__default.useRef({
         isDirty: false,
@@ -264,10 +204,10 @@ var generateWatchOutput = (names, _names, formValues, isGlobal, defaultValue)=>{
 var isPrimitive = (value1)=>isNullOrUndefined(value1) || !isObjectType(value1);
 function deepEqual(object1, object2, _internal_visited = new WeakSet()) {
     if (isPrimitive(object1) || isPrimitive(object2)) {
-        return object1 === object2;
+        return Object.is(object1, object2);
     }
     if (isDateObject(object1) && isDateObject(object2)) {
-        return object1.getTime() === object2.getTime();
+        return Object.is(object1.getTime(), object2.getTime());
     }
     const keys1 = Object.keys(object1);
     const keys2 = Object.keys(object2);
@@ -286,7 +226,7 @@ function deepEqual(object1, object2, _internal_visited = new WeakSet()) {
         }
         if (key !== 'ref') {
             const val2 = object2[key];
-            if (isDateObject(val1) && isDateObject(val2) || isObject(val1) && isObject(val2) || Array.isArray(val1) && Array.isArray(val2) ? !deepEqual(val1, val2, _internal_visited) : val1 !== val2) {
+            if (isDateObject(val1) && isDateObject(val2) || isObject(val1) && isObject(val2) || Array.isArray(val1) && Array.isArray(val2) ? !deepEqual(val1, val2, _internal_visited) : !Object.is(val1, val2)) {
                 return false;
             }
         }
@@ -309,45 +249,91 @@ function deepEqual(object1, object2, _internal_visited = new WeakSet()) {
  * })
  * ```
  */ function useWatch(props) {
-    const methods = useFormContext();
-    const { control = methods.control, name, defaultValue, disabled, exact, compute } = props || {};
+    const formControl = useFormControlContext();
+    const { control = formControl, name, defaultValue, disabled, exact, compute } = props || {};
     const _defaultValue = React__default.useRef(defaultValue);
     const _compute = React__default.useRef(compute);
     const _computeFormValues = React__default.useRef(undefined);
+    const _prevControl = React__default.useRef(control);
+    const _prevName = React__default.useRef(name);
     _compute.current = compute;
-    const defaultValueMemo = React__default.useMemo(()=>control._getWatch(name, _defaultValue.current), [
-        control,
+    const [value1, updateValue] = React__default.useState(()=>{
+        const defaultValue = control._getWatch(name, _defaultValue.current);
+        return _compute.current ? _compute.current(defaultValue) : defaultValue;
+    });
+    const getCurrentOutput = React__default.useCallback((values)=>{
+        const formValues = generateWatchOutput(name, control._names, values || control._formValues, false, _defaultValue.current);
+        return _compute.current ? _compute.current(formValues) : formValues;
+    }, [
+        control._formValues,
+        control._names,
         name
     ]);
-    const [value1, updateValue] = React__default.useState(_compute.current ? _compute.current(defaultValueMemo) : defaultValueMemo);
-    useIsomorphicLayoutEffect(()=>control._subscribe({
+    const refreshValue = React__default.useCallback((values)=>{
+        if (!disabled) {
+            const formValues = generateWatchOutput(name, control._names, values || control._formValues, false, _defaultValue.current);
+            if (_compute.current) {
+                const computedFormValues = _compute.current(formValues);
+                if (!deepEqual(computedFormValues, _computeFormValues.current)) {
+                    updateValue(computedFormValues);
+                    _computeFormValues.current = computedFormValues;
+                }
+            } else {
+                updateValue(formValues);
+            }
+        }
+    }, [
+        control._formValues,
+        control._names,
+        disabled,
+        name
+    ]);
+    useIsomorphicLayoutEffect(()=>{
+        if (_prevControl.current !== control || !deepEqual(_prevName.current, name)) {
+            _prevControl.current = control;
+            _prevName.current = name;
+            refreshValue();
+        }
+        return control._subscribe({
             name,
             formState: {
                 values: true
             },
             exact,
             callback: (formState)=>{
-                if (!disabled) {
-                    const formValues = generateWatchOutput(name, control._names, formState.values || control._formValues, false, _defaultValue.current);
-                    if (_compute.current) {
-                        const computedFormValues = _compute.current(formValues);
-                        if (!deepEqual(computedFormValues, _computeFormValues.current)) {
-                            updateValue(computedFormValues);
-                            _computeFormValues.current = computedFormValues;
-                        }
-                    } else {
-                        updateValue(formValues);
-                    }
-                }
+                refreshValue(formState.values);
             }
-        }), [
+        });
+    }, [
         control,
-        disabled,
+        exact,
         name,
-        exact
+        refreshValue
     ]);
     React__default.useEffect(()=>control._removeUnmounted());
-    return value1;
+    // If name or control changed for this render, synchronously reflect the
+    // latest value so callers (like useController) see the correct value
+    // immediately on the same render.
+    // Optimize: Check control reference first before expensive deepEqual
+    const controlChanged = _prevControl.current !== control;
+    const prevName = _prevName.current;
+    // Cache the computed output to avoid duplicate calls within the same render
+    // We include shouldReturnImmediate in deps to ensure proper recomputation
+    const computedOutput = React__default.useMemo(()=>{
+        if (disabled) {
+            return null;
+        }
+        const nameChanged = !controlChanged && !deepEqual(prevName, name);
+        const shouldReturnImmediate = controlChanged || nameChanged;
+        return shouldReturnImmediate ? getCurrentOutput() : null;
+    }, [
+        disabled,
+        controlChanged,
+        name,
+        prevName,
+        getCurrentOutput
+    ]);
+    return computedOutput !== null ? computedOutput : value1;
 }
 /**
  * Custom hook to work with controlled component, this function provide you with both form and field level state. Re-render is isolated at the hook level.
@@ -373,8 +359,8 @@ function deepEqual(object1, object2, _internal_visited = new WeakSet()) {
  * }
  * ```
  */ function useController(props) {
-    const methods = useFormContext();
-    const { name, disabled, control = methods.control, shouldUnregister, defaultValue } = props;
+    const formControl = useFormControlContext();
+    const { name, disabled, control = formControl, shouldUnregister, defaultValue, exact = true } = props;
     const isArrayField = isNameInFieldArray(control._names.array, name);
     const defaultValueMemo = React__default.useMemo(()=>get(control._formValues, name, get(control._defaultValues, name, defaultValue)), [
         control,
@@ -385,12 +371,12 @@ function deepEqual(object1, object2, _internal_visited = new WeakSet()) {
         control,
         name,
         defaultValue: defaultValueMemo,
-        exact: true
+        exact
     });
     const formState = useFormState({
         control,
         name,
-        exact: true
+        exact
     });
     const _props = React__default.useRef(props);
     const _previousNameRef = React__default.useRef(undefined);
@@ -448,12 +434,12 @@ function deepEqual(object1, object2, _internal_visited = new WeakSet()) {
     ]);
     const ref = React__default.useCallback((elm)=>{
         const field = get(control._fields, name);
-        if (field && elm) {
+        if (field && field._f && elm) {
             field._f.ref = {
-                focus: ()=>elm.focus && elm.focus(),
-                select: ()=>elm.select && elm.select(),
-                setCustomValidity: (message)=>elm.setCustomValidity(message),
-                reportValidity: ()=>elm.reportValidity()
+                focus: ()=>isFunction(elm.focus) && elm.focus(),
+                select: ()=>isFunction(elm.select) && elm.select(),
+                setCustomValidity: (message)=>isFunction(elm.setCustomValidity) && elm.setCustomValidity(message),
+                reportValidity: ()=>isFunction(elm.reportValidity) && elm.reportValidity()
             };
         }
     }, [
@@ -577,6 +563,109 @@ function deepEqual(object1, object2, _internal_visited = new WeakSet()) {
  * }
  * ```
  */ const Controller = (props)=>props.render(useController(props));
+const HookFormContext = React__default.createContext(null);
+HookFormContext.displayName = 'HookFormContext';
+/**
+ * This custom hook allows you to access the form context. useFormContext is intended to be used in deeply nested structures, where it would become inconvenient to pass the context as a prop. To be used with {@link FormProvider}.
+ *
+ * @remarks
+ * [API](https://react-hook-form.com/docs/useformcontext) • [Demo](https://codesandbox.io/s/react-hook-form-v7-form-context-ytudi)
+ *
+ * @returns return all useForm methods
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const methods = useForm();
+ *   const onSubmit = data => console.log(data);
+ *
+ *   return (
+ *     <FormProvider {...methods} >
+ *       <form onSubmit={methods.handleSubmit(onSubmit)}>
+ *         <NestedInput />
+ *         <input type="submit" />
+ *       </form>
+ *     </FormProvider>
+ *   );
+ * }
+ *
+ *  function NestedInput() {
+ *   const { register } = useFormContext(); // retrieve all hook methods
+ *   return <input {...register("test")} />;
+ * }
+ * ```
+ */ const useFormContext = ()=>React__default.useContext(HookFormContext);
+/**
+ * A provider component that propagates the `useForm` methods to all children components via [React Context](https://react.dev/reference/react/useContext) API. To be used with {@link useFormContext}.
+ *
+ * @remarks
+ * [API](https://react-hook-form.com/docs/useformcontext) • [Demo](https://codesandbox.io/s/react-hook-form-v7-form-context-ytudi)
+ *
+ * @param props - all useForm methods
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const methods = useForm();
+ *   const onSubmit = data => console.log(data);
+ *
+ *   return (
+ *     <FormProvider {...methods} >
+ *       <form onSubmit={methods.handleSubmit(onSubmit)}>
+ *         <NestedInput />
+ *         <input type="submit" />
+ *       </form>
+ *     </FormProvider>
+ *   );
+ * }
+ *
+ *  function NestedInput() {
+ *   const { register } = useFormContext(); // retrieve all hook methods
+ *   return <input {...register("test")} />;
+ * }
+ * ```
+ */ const FormProvider = (props)=>{
+    const { children, watch, getValues, getFieldState, setError, clearErrors, setValue, trigger, formState, resetField, reset, handleSubmit, unregister, control, register, setFocus, subscribe } = props;
+    return React__default.createElement(HookFormContext.Provider, {
+        value: React__default.useMemo(()=>({
+                watch,
+                getValues,
+                getFieldState,
+                setError,
+                clearErrors,
+                setValue,
+                trigger,
+                formState,
+                resetField,
+                reset,
+                handleSubmit,
+                unregister,
+                control,
+                register,
+                setFocus,
+                subscribe
+            }), [
+            clearErrors,
+            control,
+            formState,
+            getFieldState,
+            getValues,
+            handleSubmit,
+            register,
+            reset,
+            resetField,
+            setError,
+            setFocus,
+            setValue,
+            subscribe,
+            trigger,
+            unregister,
+            watch
+        ])
+    }, React__default.createElement(HookFormControlContext.Provider, {
+        value: control
+    }, children));
+};
 var appendErrors = (name, validateAllFieldCriteria, errors, type, message)=>validateAllFieldCriteria ? {
         ...errors[name],
         types: {
@@ -634,7 +723,6 @@ function extractFormValues(fieldsState, formValues) {
 }
 var isEmptyObject = (value1)=>isObject(value1) && !Object.keys(value1).length;
 var isFileInput = (element)=>element.type === 'file';
-var isFunction = (value1)=>typeof value1 === 'function';
 var isHTMLElement = (value1)=>{
     if (!isWeb) {
         return false;
@@ -690,10 +778,11 @@ function isTraversable(value1) {
 }
 function markFieldsDirty(data, fields = {}) {
     for(const key in data){
-        if (isTraversable(data[key])) {
-            fields[key] = Array.isArray(data[key]) ? [] : {};
-            markFieldsDirty(data[key], fields[key]);
-        } else if (!isUndefined(data[key])) {
+        const value1 = data[key];
+        if (isTraversable(value1)) {
+            fields[key] = Array.isArray(value1) ? [] : {};
+            markFieldsDirty(value1, fields[key]);
+        } else if (!isUndefined(value1)) {
             fields[key] = true;
         }
     }
@@ -704,14 +793,16 @@ function getDirtyFields(data, formValues, dirtyFieldsFromValues) {
         dirtyFieldsFromValues = markFieldsDirty(formValues);
     }
     for(const key in data){
-        if (isTraversable(data[key])) {
+        const value1 = data[key];
+        if (isTraversable(value1)) {
             if (isUndefined(formValues) || isPrimitive(dirtyFieldsFromValues[key])) {
-                dirtyFieldsFromValues[key] = markFieldsDirty(data[key], Array.isArray(data[key]) ? [] : {});
+                dirtyFieldsFromValues[key] = markFieldsDirty(value1, Array.isArray(value1) ? [] : {});
             } else {
-                getDirtyFields(data[key], isNullOrUndefined(formValues) ? {} : formValues[key], dirtyFieldsFromValues[key]);
+                getDirtyFields(value1, isNullOrUndefined(formValues) ? {} : formValues[key], dirtyFieldsFromValues[key]);
             }
         } else {
-            dirtyFieldsFromValues[key] = !deepEqual(data[key], formValues[key]);
+            const formValue = formValues[key];
+            dirtyFieldsFromValues[key] = !deepEqual(value1, formValue);
         }
     }
     return dirtyFieldsFromValues;
@@ -1080,7 +1171,8 @@ function createFormControl(props = {}) {
     let _state = {
         action: false,
         mount: false,
-        watch: false
+        watch: false,
+        keepIsValid: false
     };
     let _names = {
         mount: new Set(),
@@ -1091,7 +1183,7 @@ function createFormControl(props = {}) {
     };
     let delayErrorCallback;
     let timer = 0;
-    const _proxyFormState = {
+    const defaultProxyFormState = {
         isDirty: false,
         dirtyFields: false,
         validatingFields: false,
@@ -1100,6 +1192,9 @@ function createFormControl(props = {}) {
         isValid: false,
         errors: false
     };
+    const _proxyFormState = {
+        ...defaultProxyFormState
+    };
     let _proxySubscribeFormState = {
         ..._proxyFormState
     };
@@ -1113,8 +1208,17 @@ function createFormControl(props = {}) {
             timer = setTimeout(callback, wait);
         };
     const _setValid = async (shouldUpdateValid)=>{
+        if (_state.keepIsValid) {
+            return;
+        }
         if (!_options.disabled && (_proxyFormState.isValid || _proxySubscribeFormState.isValid || shouldUpdateValid)) {
-            const isValid = _options.resolver ? isEmptyObject((await _runSchema()).errors) : await executeBuiltInValidation(_fields, true);
+            let isValid;
+            if (_options.resolver) {
+                isValid = isEmptyObject((await _runSchema()).errors);
+                _updateIsValidating();
+            } else {
+                isValid = await executeBuiltInValidation(_fields, true);
+            }
             if (isValid !== _formState.isValid) {
                 _subjects.state.next({
                     isValid
@@ -1183,7 +1287,7 @@ function createFormControl(props = {}) {
         if (field) {
             const defaultValue = get(_formValues, name, isUndefined(value1) ? get(_defaultValues, name) : value1);
             isUndefined(defaultValue) || ref && ref.defaultChecked || shouldSkipSetValueAs ? set(_formValues, name, shouldSkipSetValueAs ? defaultValue : getFieldValue(field._f)) : setFieldValue(name, defaultValue);
-            _state.mount && _setValid();
+            _state.mount && !_state.action && _setValid();
         }
     };
     const updateTouchAndDirty = (name, fieldValue, isBlurEvent, shouldDirty, shouldRender)=>{
@@ -1247,11 +1351,11 @@ function createFormControl(props = {}) {
     const _runSchema = async (name)=>{
         _updateIsValidating(name, true);
         const result = await _options.resolver(_formValues, _options.context, getResolverOptions(name || _names.mount, _fields, _options.criteriaMode, _options.shouldUseNativeValidation));
-        _updateIsValidating(name);
         return result;
     };
     const executeSchemaAndUpdateState = async (names)=>{
         const { errors } = await _runSchema(names);
+        _updateIsValidating(names);
         if (names) {
             for (const name of names){
                 const error = get(errors, name);
@@ -1285,7 +1389,7 @@ function createFormControl(props = {}) {
                     }
                     if (fieldError[_f.name]) {
                         context.valid = false;
-                        if (shouldOnlyCheckValid) {
+                        if (shouldOnlyCheckValid || props.shouldUseNativeValidation) {
                             break;
                         }
                     }
@@ -1383,14 +1487,18 @@ function createFormControl(props = {}) {
         } else {
             field && !field._f && !isNullOrUndefined(cloneValue) ? setValues(name, cloneValue, options) : setFieldValue(name, cloneValue, options);
         }
-        isWatched(name, _names) && _subjects.state.next({
-            ..._formState,
-            name
-        });
-        _subjects.state.next({
-            name: _state.mount ? name : undefined,
-            values: cloneObject(_formValues)
-        });
+        if (isWatched(name, _names)) {
+            _subjects.state.next({
+                ..._formState,
+                name,
+                values: cloneObject(_formValues)
+            });
+        } else {
+            _subjects.state.next({
+                name: _state.mount ? name : undefined,
+                values: cloneObject(_formValues)
+            });
+        }
     };
     const onChange = async (event)=>{
         _state.mount = true;
@@ -1448,6 +1556,9 @@ function createFormControl(props = {}) {
                 const { errors } = await _runSchema([
                     name
                 ]);
+                _updateIsValidating([
+                    name
+                ]);
                 _updateIsFieldValueUpdated(fieldValue);
                 if (isFieldValueUpdated) {
                     const previousErrorLookupResult = schemaErrorLookup(_formState.errors, _fields, name);
@@ -1583,7 +1694,10 @@ function createFormControl(props = {}) {
         };
         return _subscribe({
             ...props,
-            formState: _proxySubscribeFormState
+            formState: {
+                ...defaultProxyFormState,
+                ...props.formState
+            }
         });
     };
     const unregister = (name, options = {})=>{
@@ -1613,7 +1727,11 @@ function createFormControl(props = {}) {
     };
     const _setDisabledField = ({ disabled, name })=>{
         if (isBoolean(disabled) && _state.mount || !!disabled || _names.disabled.has(name)) {
+            const wasDisabled = _names.disabled.has(name);
+            const isDisabled = !!disabled;
+            const disabledStateChanged = wasDisabled !== isDisabled;
             disabled ? _names.disabled.add(name) : _names.disabled.delete(name);
+            disabledStateChanged && _state.mount && !_state.action && _setValid();
         }
     };
     const register = (name, options = {})=>{
@@ -1728,6 +1846,7 @@ function createFormControl(props = {}) {
             });
             if (_options.resolver) {
                 const { errors, values } = await _runSchema();
+                _updateIsValidating();
                 _formState.errors = errors;
                 fieldValues = cloneObject(values);
             } else {
@@ -1807,7 +1926,14 @@ function createFormControl(props = {}) {
                     ...Object.keys(getDirtyFields(_defaultValues, _formValues))
                 ]);
                 for (const fieldName of Array.from(fieldsToCheck)){
-                    get(_formState.dirtyFields, fieldName) ? set(values, fieldName, get(_formValues, fieldName)) : setValue(fieldName, get(values, fieldName));
+                    const isDirty = get(_formState.dirtyFields, fieldName);
+                    const existingValue = get(_formValues, fieldName);
+                    const newValue = get(values, fieldName);
+                    if (isDirty && !isUndefined(existingValue)) {
+                        set(values, fieldName, existingValue);
+                    } else if (!isDirty && !isUndefined(newValue)) {
+                        setValue(fieldName, newValue);
+                    }
                 }
             } else {
                 if (isWeb && isUndefined(formValues)) {
@@ -1854,8 +1980,16 @@ function createFormControl(props = {}) {
             watchAll: false,
             focus: ''
         };
-        _state.mount = !_proxyFormState.isValid || !!keepStateOptions.keepIsValid || !!keepStateOptions.keepDirtyValues;
+        _state.mount = !_proxyFormState.isValid || !!keepStateOptions.keepIsValid || !!keepStateOptions.keepDirtyValues || !_options.shouldUnregister && !isEmptyObject(values);
         _state.watch = !!_options.shouldUnregister;
+        _state.keepIsValid = !!keepStateOptions.keepIsValid;
+        _state.action = false;
+        // Clear errors synchronously to prevent validation errors on subsequent submissions
+        // This fixes the issue where form.reset() causes validation errors on subsequent
+        // submissions in Next.js 16 with Server Actions
+        if (!keepStateOptions.keepErrors) {
+            _formState.errors = {};
+        }
         _subjects.state.next({
             submitCount: keepStateOptions.keepSubmitCount ? _formState.submitCount : 0,
             isDirty: isEmptyResetValues ? false : keepStateOptions.keepDirty ? _formState.isDirty : !!(keepStateOptions.keepDefaultValues && !deepEqual(formValues, _defaultValues)),
@@ -1868,15 +2002,22 @@ function createFormControl(props = {}) {
             defaultValues: _defaultValues
         });
     };
-    const reset = (formValues, keepStateOptions)=>_reset(isFunction(formValues) ? formValues(_formValues) : formValues, keepStateOptions);
+    const reset = (formValues, keepStateOptions)=>_reset(isFunction(formValues) ? formValues(_formValues) : formValues, {
+            ..._options.resetOptions,
+            ...keepStateOptions
+        });
     const setFocus = (name, options = {})=>{
         const field = get(_fields, name);
         const fieldReference = field && field._f;
         if (fieldReference) {
             const fieldRef = fieldReference.refs ? fieldReference.refs[0] : fieldReference.ref;
             if (fieldRef.focus) {
-                fieldRef.focus();
-                options.shouldSelect && isFunction(fieldRef.select) && fieldRef.select();
+                // Use setTimeout to ensure focus happens after any pending state updates
+                // This fixes the issue where setFocus doesn't work immediately after setError
+                setTimeout(()=>{
+                    fieldRef.focus();
+                    options.shouldSelect && isFunction(fieldRef.select) && fieldRef.select();
+                });
             }
         }
     };
@@ -1901,6 +2042,7 @@ function createFormControl(props = {}) {
             setError,
             _subscribe,
             _runSchema,
+            _updateIsValidating,
             _focusError,
             _getWatch,
             _getDirty,
@@ -2100,11 +2242,15 @@ function createFormControl(props = {}) {
         formState.isDirty
     ]);
     React__default.useEffect(()=>{
+        var _a;
         if (props.values && !deepEqual(props.values, _values.current)) {
             control._reset(props.values, {
                 keepFieldsRef: true,
                 ...control._options.resetOptions
             });
+            if (!((_a = control._options.resetOptions) === null || _a === void 0 ? void 0 : _a.keepIsValid)) {
+                control._setValid();
+            }
             _values.current = props.values;
             updateFormState((state)=>({
                     ...state
@@ -2129,7 +2275,10 @@ function createFormControl(props = {}) {
         }
         control._removeUnmounted();
     });
-    _formControl.current.formState = getProxyFormState(formState, control);
+    _formControl.current.formState = React__default.useMemo(()=>getProxyFormState(formState, control), [
+        control,
+        formState
+    ]);
     return _formControl.current;
 }
 
@@ -2220,4 +2369,4 @@ function FormMessage({ className, ...props }) {
 }
 
 export { Form as F, FormItem as a, FormLabel as b, FormControl as c, FormDescription as d, FormMessage as e, FormField as f, get as g, appendErrors as h, useForm as i, set as s, useFormField as u };
-//# sourceMappingURL=form-CChLO9RR.mjs.map
+//# sourceMappingURL=form-CJnoOgoH.mjs.map