react-hook-form 8.0.0-beta.0 → 8.0.0-beta.2

package/dist/index.esm.mjs

@@ -18,9 +18,15 @@ var getEventValue = (event) => isObject(event) && event.target
         : event.target.value
     : event;
 
-var getNodeParentName = (name) => name.substring(0, name.search(/\.\d+(\.|$)/)) || name;
-
-var isNameInFieldArray = (names, name) => names.has(getNodeParentName(name));
+var getFieldArrayParentNames = (names, name) => {
+    const parts = name.split('.');
+    const matches = [];
+    let prefix = parts[0];
+    for (let i = 1; i < parts.length; prefix += '.' + parts[i++]) {
+        !isNaN(+parts[i]) && names.has(prefix) && matches.push(prefix);
+    }
+    return matches;
+};
 
 var isPlainObject = (tempObject) => {
     const prototypeCopy = tempObject.constructor && tempObject.constructor.prototype;
@@ -64,7 +70,10 @@ var get = (object, path, defaultValue) => {
     if (!path || !isObject(object)) {
         return defaultValue;
     }
-    const result = (isKey(path) ? [path] : stringToPath(path)).reduce((result, key) => isNullOrUndefined(result) ? result : result[key], object);
+    const paths = isKey(path) ? [path] : stringToPath(path);
+    const result = paths.reduce((result, key) => {
+        return isNullOrUndefined(result) ? undefined : result[key];
+    }, object);
     return isUndefined(result) || result === object
         ? isUndefined(object[path])
             ? defaultValue
@@ -103,6 +112,9 @@ const EVENTS = {
     BLUR: 'blur',
     FOCUS_OUT: 'focusout',
     CHANGE: 'change',
+    SUBMIT: 'submit',
+    TRIGGER: 'trigger',
+    VALID: 'valid',
 };
 const VALIDATION_MODE = {
     onBlur: 'onBlur',
@@ -120,80 +132,22 @@ const INPUT_VALIDATION_RULES = {
     required: 'required',
     validate: 'validate',
 };
+const FORM_ERROR_TYPE = 'form';
+const ROOT_ERROR_TYPE = 'root';
 
-const HookFormContext = React.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")} />;
- * }
- * ```
+ * Separate context for `control` to prevent unnecessary rerenders.
+ * Internal hooks that only need control use this instead of full form context.
  */
-const useFormContext = () => React.useContext(HookFormContext);
+const HookFormControlContext = React.createContext(null);
+HookFormControlContext.displayName = 'HookFormControlContext';
 /**
- * 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")} />;
- * }
- * ```
+ * @internal Internal hook to access only control from context.
  */
-const FormProvider = (props) => {
-    const { children, ...data } = props;
-    return (React.createElement(HookFormContext.Provider, { value: data }, children));
-};
+const useFormControlContext = () => React.useContext(HookFormControlContext);
 
 var getProxyFormState = (formState, control, localProxyFormState, isRoot = true) => {
-    const result = {
-        ...formState,
-        defaultValues: control._defaultValues,
-    };
+    const result = {};
     for (const key in formState) {
         Object.defineProperty(result, key, {
             get: () => {
@@ -242,9 +196,12 @@ const useIsomorphicLayoutEffect = typeof window !== 'undefined' ? React.useLayou
  * ```
  */
 function useFormState(props) {
-    const methods = useFormContext();
-    const { control = methods.control, disabled, name, exact } = props || {};
-    const [formState, updateFormState] = React.useState(control._formState);
+    const formControl = useFormControlContext();
+    const { control = formControl, disabled, name, exact } = props || {};
+    const [formState, updateFormState] = React.useState(() => ({
+        ...control._formState,
+        defaultValues: control._defaultValues,
+    }));
     const _localProxyFormState = React.useRef({
         isDirty: false,
         isLoading: false,
@@ -264,6 +221,7 @@ function useFormState(props) {
                 updateFormState({
                     ...control._formState,
                     ...formState,
+                    defaultValues: control._defaultValues,
                 });
         },
     }), [name, disabled, exact]);
@@ -290,34 +248,37 @@ var generateWatchOutput = (names, _names, formValues, isGlobal, defaultValue) =>
 
 var isPrimitive = (value) => isNullOrUndefined(value) || !isObjectType(value);
 
-function deepEqual(object1, object2, _internal_visited = new WeakSet()) {
+function deepEqual(object1, object2, visited = new WeakSet()) {
+    if (object1 === object2) {
+        return true;
+    }
     if (isPrimitive(object1) || isPrimitive(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);
     if (keys1.length !== keys2.length) {
         return false;
     }
-    if (_internal_visited.has(object1) || _internal_visited.has(object2)) {
+    if (visited.has(object1) || visited.has(object2)) {
         return true;
     }
-    _internal_visited.add(object1);
-    _internal_visited.add(object2);
+    visited.add(object1);
+    visited.add(object2);
     for (const key of keys1) {
         const val1 = object1[key];
-        if (!keys2.includes(key)) {
+        if (!(key in object2)) {
             return false;
         }
         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)
+                ((isObject(val1) || Array.isArray(val1)) &&
+                    (isObject(val2) || Array.isArray(val2)))
+                ? !deepEqual(val1, val2, visited)
                 : !Object.is(val1, val2)) {
                 return false;
             }
@@ -343,8 +304,8 @@ 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.useRef(defaultValue);
     const _compute = React.useRef(compute);
     const _computeFormValues = React.useRef(undefined);
@@ -437,9 +398,10 @@ function useWatch(props) {
  * ```
  */
 function useController(props) {
-    const methods = useFormContext();
-    const { name, disabled, control = methods.control, shouldUnregister, defaultValue, exact = true, } = props;
-    const isArrayField = isNameInFieldArray(control._names.array, name);
+    const formControl = useFormControlContext();
+    const { name, disabled, control = formControl, shouldUnregister, defaultValue, exact = true, } = props;
+    const isArrayField = !!getFieldArrayParentNames(control._names.array, name)
+        .length;
     const defaultValueMemo = React.useMemo(() => get(control._formValues, name, get(control._defaultValues, name, defaultValue)), [control, name, defaultValue]);
     const value = useWatch({
         control,
@@ -453,7 +415,6 @@ function useController(props) {
         exact,
     });
     const _props = React.useRef(props);
-    const _previousNameRef = React.useRef(undefined);
     const _registerProps = React.useRef(control.register(name, {
         ...props.rules,
         value,
@@ -498,13 +459,8 @@ function useController(props) {
     }), [name, control._formValues]);
     const ref = React.useCallback((elm) => {
         const field = get(control._fields, name);
-        if (field && elm) {
-            field._f.ref = {
-                focus: () => elm.focus && elm.focus(),
-                select: () => elm.select && elm.select(),
-                setCustomValidity: (message) => elm.setCustomValidity(message),
-                reportValidity: () => elm.reportValidity(),
-            };
+        if (field && field._f && elm) {
+            field._f.ref = elm;
         }
     }, [control._fields, name]);
     const field = React.useMemo(() => ({
@@ -519,10 +475,6 @@ function useController(props) {
     }), [name, disabled, formState.disabled, onChange, onBlur, ref, value]);
     React.useEffect(() => {
         const _shouldUnregisterField = control._options.shouldUnregister || shouldUnregister;
-        const previousName = _previousNameRef.current;
-        if (previousName && previousName !== name && !isArrayField) {
-            control.unregister(previousName);
-        }
         control.register(name, {
             ..._props.current.rules,
             ...(isBoolean(_props.current.disabled)
@@ -537,14 +489,13 @@ function useController(props) {
         };
         updateMounted(name, true);
         if (_shouldUnregisterField) {
-            const value = cloneObject(get(control._options.defaultValues, name, _props.current.defaultValue));
+            const value = cloneObject(get(control._defaultValues, name, get(control._options.defaultValues, name, _props.current.defaultValue)));
             set(control._defaultValues, name, value);
             if (isUndefined(get(control._formValues, name))) {
                 set(control._formValues, name, value);
             }
         }
         !isArrayField && control.register(name);
-        _previousNameRef.current = name;
         return () => {
             (isArrayField
                 ? _shouldUnregisterField && !control._state.action
@@ -626,6 +577,112 @@ const flatten = (obj) => {
     return output;
 };
 
+const HookFormContext = React.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.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, setValues, trigger, formState, resetField, reset, handleSubmit, unregister, control, register, setFocus, subscribe, } = props;
+    const memoizedValue = React.useMemo(() => ({
+        watch,
+        getValues,
+        getFieldState,
+        setError,
+        clearErrors,
+        setValue,
+        setValues,
+        trigger,
+        formState,
+        resetField,
+        reset,
+        handleSubmit,
+        unregister,
+        control,
+        register,
+        setFocus,
+        subscribe,
+    }), [
+        clearErrors,
+        control,
+        formState,
+        getFieldState,
+        getValues,
+        handleSubmit,
+        register,
+        reset,
+        resetField,
+        setError,
+        setFocus,
+        setValue,
+        setValues,
+        subscribe,
+        trigger,
+        unregister,
+        watch,
+    ]);
+    return (React.createElement(HookFormContext.Provider, { value: memoizedValue },
+        React.createElement(HookFormControlContext.Provider, { value: memoizedValue.control }, children)));
+};
+
 const POST_REQUEST = 'post';
 /**
  * Form component to manage submission.
@@ -653,7 +710,7 @@ function Form(props) {
     const methods = useFormContext();
     const [mounted, setMounted] = React.useState(false);
     const { control = methods.control, onSubmit, children, action, method = POST_REQUEST, headers, encType, onError, render, onSuccess, validateStatus, ...rest } = props;
-    const submit = async (event) => {
+    const submit = React.useCallback(async (event) => {
         let hasError = false;
         let type = '';
         await control.handleSubmit(async (data) => {
@@ -662,8 +719,8 @@ function Form(props) {
             try {
                 formDataJson = JSON.stringify(data);
             }
-            catch (_a) { }
-            const flattenFormValues = flatten(control._formValues);
+            catch { }
+            const flattenFormValues = flatten(data);
             for (const key in flattenFormValues) {
                 formData.append(key, flattenFormValues[key]);
             }
@@ -710,15 +767,25 @@ function Form(props) {
                 }
             }
         })(event);
-        if (hasError && props.control) {
-            props.control._subjects.state.next({
+        if (hasError && control) {
+            control._subjects.state.next({
                 isSubmitSuccessful: false,
             });
-            props.control.setError('root.server', {
+            control.setError('root.server', {
                 type,
             });
         }
-    };
+    }, [
+        control,
+        onSubmit,
+        method,
+        action,
+        headers,
+        encType,
+        validateStatus,
+        onError,
+        onSuccess,
+    ]);
     React.useEffect(() => {
         setMounted(true);
     }, []);
@@ -816,7 +883,12 @@ function baseGet(object, updatePath) {
     const length = updatePath.slice(0, -1).length;
     let index = 0;
     while (index < length) {
-        object = isUndefined(object) ? index++ : object[updatePath[index++]];
+        if (isNullOrUndefined(object)) {
+            object = undefined;
+            break;
+        }
+        object = object[updatePath[index]];
+        index++;
     }
     return object;
 }
@@ -829,6 +901,10 @@ function isEmptyArray(obj) {
     return true;
 }
 function unset(object, path) {
+    if (isString(path) && Object.prototype.hasOwnProperty.call(object, path)) {
+        delete object[path];
+        return object;
+    }
     const paths = Array.isArray(path)
         ? path
         : isKey(path)
@@ -873,6 +949,29 @@ function markFieldsDirty(data, fields = {}) {
     }
     return fields;
 }
+function pruneDirtyFields(value) {
+    if (value === false) {
+        return undefined;
+    }
+    if (value === true) {
+        return true;
+    }
+    if (Array.isArray(value)) {
+        const result = value.map((value) => pruneDirtyFields(value));
+        return (result.some((value) => value !== undefined) ? result : undefined);
+    }
+    if (isObject(value)) {
+        const result = {};
+        for (const key in value) {
+            const pruned = pruneDirtyFields(value[key]);
+            if (!isUndefined(pruned)) {
+                result[key] = pruned;
+            }
+        }
+        return (Object.keys(result).length ? result : undefined);
+    }
+    return undefined;
+}
 function getDirtyFields(data, formValues, dirtyFieldsFromValues) {
     if (!dirtyFieldsFromValues) {
         dirtyFieldsFromValues = markFieldsDirty(formValues);
@@ -892,7 +991,7 @@ function getDirtyFields(data, formValues, dirtyFieldsFromValues) {
             dirtyFieldsFromValues[key] = !deepEqual(value, formValue);
         }
     }
-    return dirtyFieldsFromValues;
+    return pruneDirtyFields(dirtyFieldsFromValues) || {};
 }
 
 const defaultResult = {
@@ -1088,7 +1187,8 @@ var shouldRenderFormState = (formStateData, _proxyFormState, updateFormState, is
     updateFormState(formStateData);
     const { name, ...formState } = formStateData;
     return (isEmptyObject(formState) ||
-        Object.keys(formState).length >= Object.keys(_proxyFormState).length ||
+        (isRoot &&
+            Object.keys(formState).length >= Object.keys(_proxyFormState).length) ||
         Object.keys(formState).find((key) => _proxyFormState[key] ===
             (!isRoot || VALIDATION_MODE.all)));
 };
@@ -1122,7 +1222,7 @@ var unsetEmptyArray = (ref, name) => !compact(get(ref, name)).length && unset(re
 
 var updateFieldArrayRootError = (errors, error, name) => {
     const fieldArrayErrors = convertToArrayPayload(get(errors, name));
-    set(fieldArrayErrors, 'root', error[name]);
+    set(fieldArrayErrors, ROOT_ERROR_TYPE, error[name]);
     set(errors, name, fieldArrayErrors);
     return errors;
 };
@@ -1168,7 +1268,8 @@ var validateField = async (field, disabledFieldNames, formValues, validateAllFie
         isUndefined(inputValue)) ||
         (isHTMLElement(ref) && ref.value === '') ||
         inputValue === '' ||
-        (Array.isArray(inputValue) && !inputValue.length);
+        (Array.isArray(inputValue) && !inputValue.length) ||
+        (valueAsNumber && typeof inputValue === 'number' && isNaN(inputValue));
     const appendErrorsCurry = appendErrors.bind(null, name, validateAllFieldCriteria, error);
     const getMinMaxMessage = (exceedMax, maxLengthMessage, minLengthMessage, maxType = INPUT_VALIDATION_RULES.maxLength, minType = INPUT_VALIDATION_RULES.minLength) => {
         const message = exceedMax ? maxLengthMessage : minLengthMessage;
@@ -1330,24 +1431,27 @@ const defaultOptions = {
     reValidateMode: VALIDATION_MODE.onChange,
     shouldFocusError: true,
 };
+const DEFAULT_FORM_STATE = {
+    submitCount: 0,
+    isDirty: false,
+    isReady: false,
+    isValidating: false,
+    isSubmitted: false,
+    isSubmitting: false,
+    isSubmitSuccessful: false,
+    isValid: false,
+    touchedFields: {},
+    dirtyFields: {},
+    validatingFields: {},
+};
 function createFormControl(props = {}) {
     let _options = {
         ...defaultOptions,
         ...props,
     };
     let _formState = {
-        submitCount: 0,
-        isDirty: false,
-        isReady: false,
+        ...cloneObject(DEFAULT_FORM_STATE),
         isLoading: isFunction(_options.defaultValues),
-        isValidating: false,
-        isSubmitted: false,
-        isSubmitting: false,
-        isSubmitSuccessful: false,
-        isValid: false,
-        touchedFields: {},
-        dirtyFields: {},
-        validatingFields: {},
         errors: _options.errors || {},
         disabled: _options.disabled || false,
     };
@@ -1362,6 +1466,7 @@ function createFormControl(props = {}) {
         action: false,
         mount: false,
         watch: false,
+        keepIsValid: false,
     };
     let _names = {
         mount: new Set(),
@@ -1369,10 +1474,11 @@ function createFormControl(props = {}) {
         unMount: new Set(),
         array: new Set(),
         watch: new Set(),
+        registerName: new Set(),
     };
     let delayErrorCallback;
     let timer = 0;
-    const _proxyFormState = {
+    const defaultProxyFormState = {
         isDirty: false,
         dirtyFields: false,
         validatingFields: false,
@@ -1381,6 +1487,9 @@ function createFormControl(props = {}) {
         isValid: false,
         errors: false,
     };
+    const _proxyFormState = {
+        ...defaultProxyFormState,
+    };
     let _proxySubscribeFormState = {
         ..._proxyFormState,
     };
@@ -1394,13 +1503,25 @@ 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: _fields,
+                    onlyCheckValid: true,
+                    eventType: EVENTS.VALID,
+                });
+            }
             if (isValid !== _formState.isValid) {
                 _subjects.state.next({
                     isValid,
@@ -1427,6 +1548,9 @@ function createFormControl(props = {}) {
             });
         }
     };
+    const _updateDirtyFields = () => {
+        _formState.dirtyFields = getDirtyFields(_defaultValues, _formValues);
+    };
     const _setFieldArray = (name, values = [], method, args, shouldSetValues = true, shouldUpdateFieldsAndState = true) => {
         if (args && method && !_options.disabled) {
             _state.action = true;
@@ -1448,7 +1572,7 @@ function createFormControl(props = {}) {
                 shouldSetValues && set(_formState.touchedFields, name, touchedFields);
             }
             if (_proxyFormState.dirtyFields || _proxySubscribeFormState.dirtyFields) {
-                _formState.dirtyFields = getDirtyFields(_defaultValues, _formValues);
+                _updateDirtyFields();
             }
             _subjects.state.next({
                 name,
@@ -1475,16 +1599,53 @@ function createFormControl(props = {}) {
             isValid: false,
         });
     };
+    const hasExplicitNullIntermediate = (name) => {
+        const segments = isKey(name) ? [name] : stringToPath(name);
+        let formValues = _formValues;
+        let defaultValues = _defaultValues;
+        for (let i = 0; i < segments.length - 1; i++) {
+            const key = segments[i];
+            formValues = isNullOrUndefined(formValues) ? formValues : formValues[key];
+            defaultValues = isNullOrUndefined(defaultValues)
+                ? defaultValues
+                : defaultValues[key];
+            if (formValues === null && defaultValues !== null) {
+                return true;
+            }
+        }
+        return false;
+    };
     const updateValidAndValue = (name, shouldSkipSetValueAs, value, ref) => {
         const field = get(_fields, name);
         if (field) {
+            if (hasExplicitNullIntermediate(name)) {
+                return;
+            }
+            const wasUnsetInFormValues = isUndefined(get(_formValues, name));
             const defaultValue = get(_formValues, name, isUndefined(value) ? get(_defaultValues, name) : value);
             isUndefined(defaultValue) ||
                 (ref && ref.defaultChecked) ||
                 shouldSkipSetValueAs
                 ? set(_formValues, name, shouldSkipSetValueAs ? defaultValue : getFieldValue(field._f))
                 : setFieldValue(name, defaultValue);
-            _state.mount && !_state.action && _setValid();
+            if (_state.mount && !_state.action) {
+                _setValid();
+                // Re-registering a field after a prior unregister puts its key back
+                // into _formValues, which can flip isDirty back to false (#13397).
+                // Only run when we are currently dirty, otherwise an initial register
+                // for a field with no defaultValue would flip isDirty to true. Reset
+                // paths repopulate _formValues before re-register, so the key is
+                // present then and this branch is skipped (preserves keepDirty).
+                if (wasUnsetInFormValues &&
+                    _formState.isDirty &&
+                    (_proxyFormState.isDirty || _proxySubscribeFormState.isDirty)) {
+                    const isDirty = _getDirty();
+                    if (!isDirty) {
+                        _formState.isDirty = false;
+                        _subjects.state.next({ ..._formState });
+                    }
+                }
+            }
         }
     };
     const updateTouchAndDirty = (name, fieldValue, isBlurEvent, shouldDirty, shouldRender) => {
@@ -1502,9 +1663,14 @@ function createFormControl(props = {}) {
                 }
                 const isCurrentFieldPristine = deepEqual(get(_defaultValues, name), fieldValue);
                 isPreviousDirty = !!get(_formState.dirtyFields, name);
-                isCurrentFieldPristine
-                    ? unset(_formState.dirtyFields, name)
-                    : set(_formState.dirtyFields, name, true);
+                if (isCurrentFieldPristine !== _formState.isDirty) {
+                    _formState.dirtyFields = getDirtyFields(_defaultValues, _formValues);
+                }
+                else {
+                    isCurrentFieldPristine
+                        ? unset(_formState.dirtyFields, name)
+                        : set(_formState.dirtyFields, name, true);
+                }
                 output.dirtyFields = _formState.dirtyFields;
                 shouldUpdateField =
                     shouldUpdateField ||
@@ -1562,17 +1728,18 @@ 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;
+        return await _options.resolver(_formValues, _options.context, getResolverOptions(name || _names.mount, _fields, _options.criteriaMode, _options.shouldUseNativeValidation));
     };
     const executeSchemaAndUpdateState = async (names) => {
         const { errors } = await _runSchema(names);
+        _updateIsValidating(names);
         if (names) {
             for (const name of names) {
                 const error = get(errors, name);
                 error
-                    ? set(_formState.errors, name, error)
+                    ? _names.array.has(name) && isObject(error)
+                        ? updateFieldArrayRootError(_formState.errors, { [name]: error }, name)
+                        : set(_formState.errors, name, error)
                     : unset(_formState.errors, name);
             }
         }
@@ -1581,9 +1748,55 @@ function createFormControl(props = {}) {
         }
         return errors;
     };
-    const executeBuiltInValidation = async (fields, shouldOnlyCheckValid, context = {
+    const validateForm = async ({ name, eventType, }) => {
+        if (props.validate) {
+            const result = await props.validate({
+                formValues: _formValues,
+                formState: _formState,
+                name,
+                eventType,
+            });
+            if (isObject(result)) {
+                for (const key in result) {
+                    const error = result[key];
+                    if (error) {
+                        setError(`${FORM_ERROR_TYPE}.${key}`, {
+                            message: isString(error.message) ? error.message : '',
+                            type: error.type || INPUT_VALIDATION_RULES.validate,
+                        });
+                    }
+                }
+            }
+            else if (isString(result) || !result) {
+                setError(FORM_ERROR_TYPE, {
+                    message: result || '',
+                    type: INPUT_VALIDATION_RULES.validate,
+                });
+            }
+            else {
+                clearErrors(FORM_ERROR_TYPE);
+            }
+            return result;
+        }
+        return true;
+    };
+    const executeBuiltInValidation = async ({ fields, onlyCheckValid, name, eventType, context = {
         valid: true,
-    }) => {
+        runRootValidation: false,
+    }, }) => {
+        if (props.validate) {
+            context.runRootValidation = true;
+            const result = await validateForm({
+                name,
+                eventType,
+            });
+            if (!result) {
+                context.valid = false;
+                if (onlyCheckValid) {
+                    return context.valid;
+                }
+            }
+        }
         for (const name in fields) {
             const field = fields[name];
             if (field) {
@@ -1591,28 +1804,41 @@ function createFormControl(props = {}) {
                 if (_f) {
                     const isFieldArrayRoot = _names.array.has(_f.name);
                     const isPromiseFunction = field._f && hasPromiseValidation(field._f);
-                    if (isPromiseFunction && _proxyFormState.validatingFields) {
+                    const shouldTrackIsValidatingState = _proxyFormState.validatingFields ||
+                        _proxyFormState.isValidating ||
+                        _proxySubscribeFormState.validatingFields ||
+                        _proxySubscribeFormState.isValidating;
+                    if (isPromiseFunction && shouldTrackIsValidatingState) {
                         _updateIsValidating([_f.name], true);
                     }
-                    const fieldError = await validateField(field, _names.disabled, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation && !shouldOnlyCheckValid, isFieldArrayRoot);
-                    if (isPromiseFunction && _proxyFormState.validatingFields) {
+                    const fieldError = await validateField(field, _names.disabled, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation && !onlyCheckValid, isFieldArrayRoot);
+                    if (isPromiseFunction && shouldTrackIsValidatingState) {
                         _updateIsValidating([_f.name]);
                     }
                     if (fieldError[_f.name]) {
                         context.valid = false;
-                        if (shouldOnlyCheckValid) {
+                        if (onlyCheckValid) {
                             break;
                         }
                     }
-                    !shouldOnlyCheckValid &&
+                    !onlyCheckValid &&
                         (get(fieldError, _f.name)
                             ? isFieldArrayRoot
                                 ? updateFieldArrayRootError(_formState.errors, fieldError, _f.name)
                                 : set(_formState.errors, _f.name, fieldError[_f.name])
                             : unset(_formState.errors, _f.name));
+                    if (props.shouldUseNativeValidation && fieldError[_f.name]) {
+                        break;
+                    }
                 }
                 !isEmptyObject(fieldValue) &&
-                    (await executeBuiltInValidation(fieldValue, shouldOnlyCheckValid, context));
+                    (await executeBuiltInValidation({
+                        context,
+                        onlyCheckValid,
+                        fields: fieldValue,
+                        name: name,
+                        eventType,
+                    }));
             }
         }
         return context.valid;
@@ -1692,7 +1918,7 @@ function createFormControl(props = {}) {
             updateTouchAndDirty(name, fieldValue, options.shouldTouch, options.shouldDirty, true);
         options.shouldValidate && trigger(name);
     };
-    const setValues = (name, value, options) => {
+    const setFieldValues = (name, value, options) => {
         for (const fieldKey in value) {
             if (!value.hasOwnProperty(fieldKey)) {
                 return;
@@ -1704,7 +1930,7 @@ function createFormControl(props = {}) {
                 isObject(fieldValue) ||
                 (field && !field._f)) &&
                 !isDateObject(fieldValue)
-                ? setValues(fieldName, fieldValue, options)
+                ? setFieldValues(fieldName, fieldValue, options)
                 : setFieldValue(fieldName, fieldValue, options);
         }
     };
@@ -1712,7 +1938,11 @@ function createFormControl(props = {}) {
         const field = get(_fields, name);
         const isFieldArray = _names.array.has(name);
         const cloneValue = cloneObject(value);
-        set(_formValues, name, cloneValue);
+        const previousValue = get(_formValues, name);
+        const isValueUnchanged = deepEqual(previousValue, cloneValue);
+        if (!isValueUnchanged) {
+            set(_formValues, name, cloneValue);
+        }
         if (isFieldArray) {
             _subjects.array.next({
                 name,
@@ -1723,23 +1953,53 @@ function createFormControl(props = {}) {
                 _proxySubscribeFormState.isDirty ||
                 _proxySubscribeFormState.dirtyFields) &&
                 options.shouldDirty) {
+                _updateDirtyFields();
                 _subjects.state.next({
                     name,
-                    dirtyFields: getDirtyFields(_defaultValues, _formValues),
+                    dirtyFields: _formState.dirtyFields,
                     isDirty: _getDirty(name, cloneValue),
                 });
             }
         }
         else {
-            field && !field._f && !isNullOrUndefined(cloneValue)
-                ? setValues(name, cloneValue, options)
-                : setFieldValue(name, cloneValue, options);
+            const isEmpty = (Array.isArray(cloneValue) && !cloneValue.length) ||
+                isEmptyObject(cloneValue);
+            if (!field || field._f || isNullOrUndefined(cloneValue) || isEmpty) {
+                setFieldValue(name, cloneValue, options);
+            }
+            else {
+                setFieldValues(name, cloneValue, options);
+            }
+        }
+        if (!isValueUnchanged) {
+            const watched = isWatched(name, _names);
+            const values = cloneObject(_formValues);
+            if (!isFieldArray) {
+                for (const arrayName of getFieldArrayParentNames(_names.array, name)) {
+                    _subjects.array.next({ name: arrayName, values });
+                }
+            }
+            _subjects.state.next({
+                ...(watched && _formState),
+                name: _state.mount || watched ? name : undefined,
+                values,
+            });
+        }
+    };
+    const setValues = (formValues) => {
+        const updatedFormValues = isFunction(formValues)
+            ? formValues(_formValues)
+            : formValues;
+        if (!deepEqual(_formValues, updatedFormValues)) {
+            _formValues = {
+                ..._formValues,
+                ...updatedFormValues,
+            };
+            for (const fieldName of _names.mount) {
+                setValue(fieldName, get(updatedFormValues, fieldName));
+            }
+            _subjects.state.next({ ..._formState, values: _formValues });
         }
-        isWatched(name, _names) && _subjects.state.next({ ..._formState, name });
-        _subjects.state.next({
-            name: _state.mount ? name : undefined,
-            values: cloneObject(_formValues),
-        });
     };
     const onChange = async (event) => {
         _state.mount = true;
@@ -1763,6 +2023,7 @@ function createFormControl(props = {}) {
                 : getEventValue(event);
             const isBlurEvent = event.type === EVENTS.BLUR || event.type === EVENTS.FOCUS_OUT;
             const shouldSkipValidation = (!hasValidation(field._f) &&
+                !props.validate &&
                 !_options.resolver &&
                 !get(_formState.errors, name) &&
                 !field._f.deps) ||
@@ -1800,9 +2061,16 @@ function createFormControl(props = {}) {
                 return (shouldRender &&
                     _subjects.state.next({ name, ...(watched ? {} : fieldState) }));
             }
+            if (!_options.resolver && props.validate) {
+                await validateForm({
+                    name: name,
+                    eventType: event.type,
+                });
+            }
             !isBlurEvent && watched && _subjects.state.next({ ..._formState });
             if (_options.resolver) {
                 const { errors } = await _runSchema([name]);
+                _updateIsValidating([name]);
                 _updateIsFieldValueUpdated(fieldValue);
                 if (isFieldValueUpdated) {
                     const previousErrorLookupResult = schemaErrorLookup(_formState.errors, _fields, name);
@@ -1823,7 +2091,12 @@ function createFormControl(props = {}) {
                     }
                     else if (_proxyFormState.isValid ||
                         _proxySubscribeFormState.isValid) {
-                        isValid = await executeBuiltInValidation(_fields, true);
+                        isValid = await executeBuiltInValidation({
+                            fields: _fields,
+                            onlyCheckValid: true,
+                            name: name,
+                            eventType: event.type,
+                        });
                     }
                 }
             }
@@ -1856,12 +2129,19 @@ function createFormControl(props = {}) {
         else if (name) {
             validationResult = (await Promise.all(fieldNames.map(async (fieldName) => {
                 const field = get(_fields, fieldName);
-                return await executeBuiltInValidation(field && field._f ? { [fieldName]: field } : field);
+                return await executeBuiltInValidation({
+                    fields: field && field._f ? { [fieldName]: field } : field,
+                    eventType: EVENTS.TRIGGER,
+                });
             }))).every(Boolean);
             !(!validationResult && !_formState.isValid) && _setValid();
         }
         else {
-            validationResult = isValid = await executeBuiltInValidation(_fields);
+            validationResult = isValid = await executeBuiltInValidation({
+                fields: _fields,
+                name,
+                eventType: EVENTS.TRIGGER,
+            });
         }
         _subjects.state.next({
             ...(!isString(name) ||
@@ -1898,11 +2178,24 @@ function createFormControl(props = {}) {
         isTouched: !!get((formState || _formState).touchedFields, name),
     });
     const clearErrors = (name) => {
-        name &&
-            convertToArrayPayload(name).forEach((inputName) => unset(_formState.errors, inputName));
-        _subjects.state.next({
-            errors: name ? _formState.errors : {},
-        });
+        const names = name ? convertToArrayPayload(name) : undefined;
+        names?.forEach((inputName) => unset(_formState.errors, inputName));
+        if (names) {
+            // Emit for each cleared field with the field name so that
+            // shouldSubscribeByName can filter and avoid broad re-renders
+            names.forEach((inputName) => {
+                _subjects.state.next({
+                    name: inputName,
+                    errors: _formState.errors,
+                });
+            });
+        }
+        else {
+            // Clear all errors - emit without name to notify all subscribers
+            _subjects.state.next({
+                errors: {},
+            });
+        }
     };
     const setError = (name, error, options) => {
         const ref = (get(_fields, name, { _f: {} })._f || {}).ref;
@@ -1921,18 +2214,14 @@ function createFormControl(props = {}) {
         });
         options && options.shouldFocus && ref && ref.focus && ref.focus();
     };
-    const watch = (name, defaultValue) => isFunction(name)
-        ? _subjects.state.subscribe({
-            next: (payload) => 'values' in payload &&
-                name(_getWatch(undefined, defaultValue), payload),
-        })
-        : _getWatch(name, defaultValue, true);
+    const watch = (name, defaultValue) => _getWatch(name, defaultValue, true);
     const _subscribe = (props) => _subjects.state.subscribe({
         next: (formState) => {
             if (shouldSubscribeByName(props.name, formState.name, props.exact) &&
                 shouldRenderFormState(formState, props.formState || _proxyFormState, _setFormState, props.reRenderRoot)) {
+                const snapshot = { ..._formValues };
                 props.callback({
-                    values: { ..._formValues },
+                    values: snapshot,
                     ..._formState,
                     ...formState,
                     defaultValues: _defaultValues,
@@ -1948,7 +2237,10 @@ function createFormControl(props = {}) {
         };
         return _subscribe({
             ...props,
-            formState: _proxySubscribeFormState,
+            formState: {
+                ...defaultProxyFormState,
+                ...props.formState,
+            },
         });
     };
     const unregister = (name, options = {}) => {
@@ -1981,12 +2273,17 @@ function createFormControl(props = {}) {
         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 = {}) => {
         let field = get(_fields, name);
         const disabledIsDefined = isBoolean(options.disabled) || isBoolean(_options.disabled);
+        const shouldRevalidateRemount = !_names.registerName.has(name) && field && field._f && !field._f.mount;
         set(_fields, name, {
             ...(field || {}),
             _f: {
@@ -1997,7 +2294,7 @@ function createFormControl(props = {}) {
             },
         });
         _names.mount.add(name);
-        if (field) {
+        if (field && !shouldRevalidateRemount) {
             _setDisabledField({
                 disabled: isBoolean(options.disabled)
                     ? options.disabled
@@ -2027,7 +2324,9 @@ function createFormControl(props = {}) {
             onBlur: onChange,
             ref: (ref) => {
                 if (ref) {
+                    _names.registerName.add(name);
                     register(name, options);
+                    _names.registerName.delete(name);
                     field = get(_fields, name);
                     const fieldRef = isUndefined(ref.value)
                         ? ref.querySelectorAll
@@ -2064,13 +2363,15 @@ function createFormControl(props = {}) {
                         field._f.mount = false;
                     }
                     (_options.shouldUnregister || options.shouldUnregister) &&
-                        !(isNameInFieldArray(_names.array, name) && _state.action) &&
+                        !(getFieldArrayParentNames(_names.array, name).length &&
+                            _state.action) &&
                         _names.unMount.add(name);
                 }
             },
         };
     };
     const _focusError = () => _options.shouldFocusError &&
+        !_options.shouldUseNativeValidation &&
         iterateFieldsByAction(_fields, _focusInput, _names.mount);
     const _disableForm = (disabled) => {
         if (isBoolean(disabled)) {
@@ -2101,18 +2402,22 @@ function createFormControl(props = {}) {
         });
         if (_options.resolver) {
             const { errors, values } = await _runSchema();
+            _updateIsValidating();
             _formState.errors = errors;
             fieldValues = cloneObject(values);
         }
         else {
-            await executeBuiltInValidation(_fields);
+            await executeBuiltInValidation({
+                fields: _fields,
+                eventType: EVENTS.SUBMIT,
+            });
         }
         if (_names.disabled.size) {
             for (const name of _names.disabled) {
                 unset(fieldValues, name);
             }
         }
-        unset(_formState.errors, 'root');
+        unset(_formState.errors, ROOT_ERROR_TYPE);
         if (isEmptyObject(_formState.errors)) {
             _subjects.state.next({
                 errors: {},
@@ -2182,9 +2487,15 @@ 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 {
@@ -2230,6 +2541,7 @@ function createFormControl(props = {}) {
             mount: keepStateOptions.keepDirtyValues ? _names.mount : new Set(),
             unMount: new Set(),
             array: new Set(),
+            registerName: new Set(),
             disabled: new Set(),
             watch: new Set(),
             watchAll: false,
@@ -2241,6 +2553,7 @@ function createFormControl(props = {}) {
                 !!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
@@ -2285,7 +2598,7 @@ function createFormControl(props = {}) {
     };
     const reset = (formValues, keepStateOptions) => _reset(isFunction(formValues)
         ? formValues(_formValues)
-        : formValues, keepStateOptions);
+        : formValues, { ..._options.resetOptions, ...keepStateOptions });
     const setFocus = (name, options = {}) => {
         const field = get(_fields, name);
         const fieldReference = field && field._f;
@@ -2294,10 +2607,14 @@ function createFormControl(props = {}) {
                 ? 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();
+                });
             }
         }
     };
@@ -2323,6 +2640,7 @@ function createFormControl(props = {}) {
             setError,
             _subscribe,
             _runSchema,
+            _updateIsValidating,
             _focusError,
             _getWatch,
             _getDirty,
@@ -2377,6 +2695,7 @@ function createFormControl(props = {}) {
         handleSubmit,
         watch,
         setValue,
+        setValues,
         getValues,
         reset,
         resetField,
@@ -2398,7 +2717,7 @@ var generateId = () => {
     }
     const d = typeof performance === 'undefined' ? Date.now() : performance.now() * 1000;
     return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
-        const r = (Math.random() * 16 + d) % 16 | 0;
+        const r = ((Math.random() * 16 + d) % 16) | 0;
         return (c == 'x' ? r : (r & 0x3) | 0x8).toString(16);
     });
 };
@@ -2487,7 +2806,7 @@ var updateAt = (fieldValues, index, value) => {
  *   return (
  *     <form onSubmit={handleSubmit(data => console.log(data))}>
  *       {fields.map((item, index) => (
- *          <input key={item.id} {...register(`test.${index}.firstName`)}  />
+ *          <input key={item.key} {...register(`test.${index}.firstName`)}  />
  *       ))}
  *       <button type="button" onClick={() => append({ firstName: "bill" })}>
  *         append
@@ -2499,8 +2818,8 @@ var updateAt = (fieldValues, index, value) => {
  * ```
  */
 function useFieldArray(props) {
-    const methods = useFormContext();
-    const { control = methods.control, name, keyName = 'key', shouldUnregister, rules, } = props;
+    const formControl = useFormControlContext();
+    const { control = formControl, name, shouldUnregister, rules } = props;
     const [fields, setFields] = React.useState(control._getFieldArray(name));
     const ids = React.useRef(control._getFieldArray(name).map(generateId));
     const _actioned = React.useRef(false);
@@ -2614,12 +2933,14 @@ function useFieldArray(props) {
             control._subjects.state.next({
                 ...control._formState,
             });
+        const validationModes = getValidationModes(control._options.mode);
         if (_actioned.current &&
-            (!getValidationModes(control._options.mode).isOnSubmit ||
-                control._formState.isSubmitted) &&
-            !getValidationModes(control._options.reValidateMode).isOnSubmit) {
+            (!validationModes.isOnSubmit || control._formState.isSubmitted) &&
+            !getValidationModes(control._options.reValidateMode).isOnSubmit &&
+            !validationModes.isOnBlur) {
             if (control._options.resolver) {
                 control._runSchema([name]).then((result) => {
+                    control._updateIsValidating([name]);
                     const error = get(result.errors, name);
                     const existingError = get(control._formState.errors, name);
                     if (existingError
@@ -2671,17 +2992,24 @@ function useFieldArray(props) {
     React.useEffect(() => {
         !get(control._formValues, name) && control._setFieldArray(name);
         return () => {
+            const shouldKeepFieldArrayValues = !(control._options.shouldUnregister || shouldUnregister);
             const updateMounted = (name, value) => {
                 const field = get(control._fields, name);
                 if (field && field._f) {
                     field._f.mount = value;
                 }
             };
-            control._options.shouldUnregister || shouldUnregister
-                ? control.unregister(name)
-                : updateMounted(name, false);
+            if (_actioned.current && shouldKeepFieldArrayValues) {
+                control._subjects.state.next({
+                    name,
+                    values: cloneObject(control._formValues),
+                });
+            }
+            shouldKeepFieldArrayValues
+                ? updateMounted(name, false)
+                : control.unregister(name);
         };
-    }, [name, control, keyName, shouldUnregister]);
+    }, [name, control, shouldUnregister]);
     return {
         swap: React.useCallback(swap, [updateValues, name, control]),
         move: React.useCallback(move, [updateValues, name, control]),
@@ -2693,8 +3021,8 @@ function useFieldArray(props) {
         replace: React.useCallback(replace, [updateValues, name, control]),
         fields: React.useMemo(() => fields.map((field, index) => ({
             ...field,
-            [keyName]: ids.current[index] || generateId(),
-        })), [fields, keyName]),
+            key: ids.current[index] || generateId(),
+        })), [fields]),
     };
 }
 
@@ -2741,25 +3069,15 @@ function updateMethodsReference(_formControl) {
 function useForm(props = {}) {
     const _formControl = React.useRef(undefined);
     const _values = React.useRef(undefined);
-    const [formState, updateFormState] = React.useState({
-        isDirty: false,
-        isValidating: false,
+    const [formState, updateFormState] = React.useState(() => ({
+        ...cloneObject(DEFAULT_FORM_STATE),
         isLoading: isFunction(props.defaultValues),
-        isSubmitted: false,
-        isSubmitting: false,
-        isSubmitSuccessful: false,
-        isValid: false,
-        submitCount: 0,
-        dirtyFields: {},
-        touchedFields: {},
-        validatingFields: {},
         errors: props.errors || {},
         disabled: props.disabled || false,
-        isReady: false,
         defaultValues: isFunction(props.defaultValues)
             ? undefined
             : props.defaultValues,
-    });
+    }));
     if (!_formControl.current) {
         if (props.formControl) {
             _formControl.current = {
@@ -2783,7 +3101,10 @@ function useForm(props = {}) {
     useIsomorphicLayoutEffect(() => {
         const sub = control._subscribe({
             formState: control._proxyFormState,
-            callback: () => updateFormState({ ...control._formState }),
+            callback: () => updateFormState({
+                ...control._formState,
+                defaultValues: control._defaultValues,
+            }),
             reRenderRoot: true,
         });
         updateFormState((data) => ({
@@ -2825,14 +3146,13 @@ function useForm(props = {}) {
         }
     }, [control, formState.isDirty]);
     React.useEffect(() => {
-        var _a;
         if (props.values && !deepEqual(props.values, _values.current)) {
             updateMethodsReference(_formControl);
             control._reset(props.values, {
                 keepFieldsRef: true,
                 ...control._options.resetOptions,
             });
-            if (!((_a = control._options.resetOptions) === null || _a === void 0 ? void 0 : _a.keepIsValid)) {
+            if (!control._options.resetOptions?.keepIsValid) {
                 control._setValid();
             }
             _values.current = props.values;
@@ -2872,7 +3192,11 @@ function useForm(props = {}) {
  * Watch component that subscribes to form field changes and re-renders when watched fields update.
  *
  * @param control - The form control object from useForm
- * @param names - Array of field names to watch for changes
+ * @param name - Can be field name, array of field names, or undefined to watch the entire form
+ * @param disabled - Disable subscription
+ * @param exact - Whether to watch exact field names or not
+ * @param defaultValue - The default value to use if the field is not yet set
+ * @param compute - Function to compute derived values from watched fields
  * @param render - The function that receives watched values and returns ReactNode
  * @returns The result of calling render function with watched values
  *
@@ -2890,7 +3214,7 @@ function useForm(props = {}) {
  * />
  * ```
  */
-const Watch = ({ control, names, render, }) => render(useWatch({ control, name: names }));
+const Watch = (props) => props.render(useWatch(props));
 
 export { Controller, Form, FormProvider, FormStateSubscribe, Watch, appendErrors, createFormControl, get, set, useController, useFieldArray, useForm, useFormContext, useFormState, useWatch };
 //# sourceMappingURL=index.esm.mjs.map