react-hook-form 7.78.0 → 7.80.0

package/dist/index.esm.mjs

@@ -76,15 +76,16 @@ const INPUT_VALIDATION_RULES = {
     required: 'required',
     validate: 'validate',
 };
-const FORM_ERROR_TYPE = 'form';
 const ROOT_ERROR_TYPE = 'root';
 const PROTOTYPE_KEYWORDS = ['__proto__', 'constructor', 'prototype'];
 
-var isKey = (value) => /^\w*$/.test(value);
+const IS_KEY_RE = /^\w*$/;
+var isKey = (value) => IS_KEY_RE.test(value);
 
 var isUndefined = (val) => val === undefined;
 
-var stringToPath = (input) => input.split(/[.[\]'"]/g).filter(Boolean);
+const FIELD_PATH_RE = /[.[\]'"]/;
+var stringToPath = (input) => input.split(FIELD_PATH_RE).filter(Boolean);
 
 var get = (object, path, defaultValue) => {
     if (!path || !isObject(object)) {
@@ -249,7 +250,7 @@ var generateWatchOutput = (names, _names, formValues, isGlobal, defaultValue) =>
 var isPrimitive = (value) => isNullOrUndefined(value) || !isObjectType(value);
 
 const isEmptyObjectWithCustomPrototype = (object, keys) => keys.length === 0 && !Array.isArray(object) && !isPlainObject(object);
-function deepEqual(object1, object2, visited = new WeakSet()) {
+function deepEqual(object1, object2, visited = new WeakMap()) {
     if (object1 === object2) {
         return true;
     }
@@ -268,11 +269,21 @@ function deepEqual(object1, object2, visited = new WeakSet()) {
         isEmptyObjectWithCustomPrototype(object2, keys2)) {
         return Object.is(object1, object2);
     }
-    if (visited.has(object1) || visited.has(object2)) {
+    if (!keys1.length && Array.isArray(object1) !== Array.isArray(object2)) {
+        return false;
+    }
+    const visitedPairs = visited.get(object1);
+    if (visitedPairs && visitedPairs.has(object2)) {
         return true;
     }
-    visited.add(object1);
-    visited.add(object2);
+    if (visitedPairs) {
+        visitedPairs.add(object2);
+    }
+    else {
+        const ws = new WeakSet();
+        ws.add(object2);
+        visited.set(object1, ws);
+    }
     for (const key of keys1) {
         const val1 = object1[key];
         if (!(key in object2)) {
@@ -419,6 +430,7 @@ function useController(props) {
         exact,
     });
     const _props = React.useRef(props);
+    const _proxyRef = React.useRef(null);
     const _registerProps = React.useRef(control.register(name, {
         ...props.rules,
         value,
@@ -455,7 +467,7 @@ function useController(props) {
                 value,
             });
         }
-        _registerProps.current.onChange({
+        return _registerProps.current.onChange({
             target: {
                 value: getEventValue(event),
                 name: name,
@@ -471,15 +483,18 @@ function useController(props) {
         type: EVENTS.BLUR,
     }), [name, control._formValues]);
     const ref = React.useCallback((elm) => {
-        const field = get(control._fields, name);
-        if (field && field._f && elm) {
-            field._f.ref = {
+        if (elm) {
+            _proxyRef.current = {
                 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(),
             };
         }
+        const field = get(control._fields, name);
+        if (field && field._f && elm) {
+            field._f.ref = _proxyRef.current;
+        }
     }, [control._fields, name]);
     const field = React.useMemo(() => ({
         name,
@@ -516,6 +531,12 @@ function useController(props) {
             }
         }
         !isArrayField && control.register(name);
+        if (_proxyRef.current) {
+            const field = get(control._fields, name);
+            if (field && field._f) {
+                field._f.ref = _proxyRef.current;
+            }
+        }
         return () => {
             (isArrayField
                 ? _shouldUnregisterField && !control._state.action
@@ -1117,12 +1138,22 @@ var getValidationModes = (mode) => ({
 });
 
 const ASYNC_FUNCTION = 'AsyncFunction';
-var hasPromiseValidation = (fieldReference) => !!fieldReference &&
-    !!fieldReference.validate &&
-    !!((isFunction(fieldReference.validate) &&
-        fieldReference.validate.constructor.name === ASYNC_FUNCTION) ||
-        (isObject(fieldReference.validate) &&
-            Object.values(fieldReference.validate).find((validateFunction) => validateFunction.constructor.name === ASYNC_FUNCTION)));
+var hasPromiseValidation = (fieldReference) => {
+    if (!fieldReference || !fieldReference.validate)
+        return false;
+    if (isFunction(fieldReference.validate)) {
+        return fieldReference.validate.constructor.name === ASYNC_FUNCTION;
+    }
+    if (isObject(fieldReference.validate)) {
+        for (const key in fieldReference.validate) {
+            if (fieldReference.validate[key].constructor
+                .name === ASYNC_FUNCTION) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
 
 var hasValidation = (options) => options.mount &&
     (options.required ||
@@ -1133,10 +1164,17 @@ var hasValidation = (options) => options.mount &&
         options.pattern ||
         options.validate);
 
-var isWatched = (name, _names, isBlurEvent) => !isBlurEvent &&
-    (_names.watchAll ||
-        _names.watch.has(name) ||
-        [..._names.watch].some((watchName) => name.startsWith(`${watchName}.`)));
+var isWatched = (name, _names, isBlurEvent) => {
+    if (isBlurEvent)
+        return false;
+    if (_names.watchAll || _names.watch.has(name))
+        return true;
+    for (const watchName of _names.watch) {
+        if (name.startsWith(watchName) && name.charAt(watchName.length) === '.')
+            return true;
+    }
+    return false;
+};
 
 const iterateFieldsByAction = (fields, action, fieldsNames, abortEarly) => {
     for (const key of fieldsNames || Object.keys(fields)) {
@@ -1204,10 +1242,10 @@ function schemaErrorLookup(errors, _fields, name) {
 var shouldRenderFormState = (formStateData, _proxyFormState, updateFormState, isRoot) => {
     updateFormState(formStateData);
     const { name, ...formState } = formStateData;
-    return (isEmptyObject(formState) ||
-        (isRoot &&
-            Object.keys(formState).length >= Object.keys(_proxyFormState).length) ||
-        Object.keys(formState).find((key) => _proxyFormState[key] ===
+    const keys = Object.keys(formState);
+    return (!keys.length ||
+        (isRoot && keys.length >= Object.keys(_proxyFormState).length) ||
+        keys.find((key) => _proxyFormState[key] ===
             (!isRoot || VALIDATION_MODE.all)));
 };
 
@@ -1274,7 +1312,13 @@ var validateField = async (field, disabledFieldNames, formValues, validateAllFie
     const inputRef = refs ? refs[0] : ref;
     const setCustomValidity = (message) => {
         if (shouldUseNativeValidation && inputRef.reportValidity) {
-            inputRef.setCustomValidity(isBoolean(message) ? '' : message || '');
+            const validityMessage = isBoolean(message) ? '' : message || '';
+            if (refs) {
+                refs.forEach((ref) => ref.setCustomValidity(validityMessage));
+            }
+            else {
+                inputRef.setCustomValidity(validityMessage);
+            }
             inputRef.reportValidity();
         }
     };
@@ -1449,6 +1493,7 @@ const defaultOptions = {
     reValidateMode: VALIDATION_MODE.onChange,
     shouldFocusError: true,
 };
+const FORM_ERROR_TYPE = 'form';
 const DEFAULT_FORM_STATE = {
     submitCount: 0,
     isDirty: false,
@@ -1496,6 +1541,9 @@ function createFormControl(props = {}) {
     };
     let delayErrorCallback;
     let timer = 0;
+    let _valuesSubscriberCount = 0;
+    let _validationModeBeforeSubmit = getValidationModes(_options.mode);
+    let _validationModeAfterSubmit = getValidationModes(_options.reValidateMode);
     const defaultProxyFormState = {
         isDirty: false,
         dirtyFields: false,
@@ -1606,6 +1654,7 @@ function createFormControl(props = {}) {
     };
     const updateErrors = (name, error) => {
         set(_formState.errors, name, error);
+        _formState.errors = { ..._formState.errors };
         _subjects.state.next({
             errors: _formState.errors,
         });
@@ -1648,12 +1697,6 @@ function createFormControl(props = {}) {
                 : setFieldValue(name, defaultValue);
             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)) {
@@ -1663,6 +1706,12 @@ function createFormControl(props = {}) {
                         _subjects.state.next({ ..._formState });
                     }
                 }
+                if (props.shouldUnregister &&
+                    wasUnsetInFormValues &&
+                    !isUndefined(get(_formValues, name)) &&
+                    isWatched(name, _names)) {
+                    _state.watch = true;
+                }
             }
         }
     };
@@ -1674,12 +1723,13 @@ function createFormControl(props = {}) {
         };
         if (!_options.disabled) {
             if (!isBlurEvent || shouldDirty) {
+                const isCurrentFieldPristine = deepEqual(get(_defaultValues, name), fieldValue);
                 if (_proxyFormState.isDirty || _proxySubscribeFormState.isDirty) {
                     isPreviousDirty = _formState.isDirty;
-                    _formState.isDirty = output.isDirty = _getDirty();
+                    _formState.isDirty = output.isDirty =
+                        !isCurrentFieldPristine || _getDirty();
                     shouldUpdateField = isPreviousDirty !== output.isDirty;
                 }
-                const isCurrentFieldPristine = deepEqual(get(_defaultValues, name), fieldValue);
                 isPreviousDirty = !!get(_formState.dirtyFields, name);
                 if (isCurrentFieldPristine !== _formState.isDirty) {
                     _formState.dirtyFields = getDirtyFields(_defaultValues, _formValues);
@@ -1727,6 +1777,7 @@ function createFormControl(props = {}) {
             error
                 ? set(_formState.errors, name, error)
                 : unset(_formState.errors, name);
+            _formState.errors = { ..._formState.errors };
         }
         if ((error ? !deepEqual(previousFieldError, error) : previousFieldError) ||
             !isEmptyObject(fieldState) ||
@@ -1762,6 +1813,7 @@ function createFormControl(props = {}) {
                         : set(_formState.errors, name, error)
                     : unset(_formState.errors, name);
             }
+            _formState.errors = { ..._formState.errors };
         }
         else {
             _formState.errors = errors;
@@ -1876,7 +1928,7 @@ function createFormControl(props = {}) {
     };
     const _getDirty = (name, data) => !_options.disabled &&
         (name && data && set(_formValues, name, data),
-            !deepEqual(getValues(), _defaultValues));
+            !deepEqual(_state.mount ? _formValues : _defaultValues, _defaultValues));
     const _getWatch = (names, defaultValue, isGlobal) => generateWatchOutput(names, _names, {
         ...(_state.mount
             ? _formValues
@@ -1887,7 +1939,7 @@ function createFormControl(props = {}) {
                     : defaultValue),
     }, isGlobal, defaultValue);
     const _getFieldArray = (name) => compact(get(_state.mount ? _formValues : _defaultValues, name, _options.shouldUnregister ? get(_defaultValues, name, []) : []));
-    const setFieldValue = (name, value, options = {}, skipClone = false) => {
+    const setFieldValue = (name, value, options = {}, skipClone = false, skipRender = false) => {
         const field = get(_fields, name);
         let fieldValue = value;
         if (field) {
@@ -1925,7 +1977,7 @@ function createFormControl(props = {}) {
                 }
                 else {
                     fieldReference.ref.value = fieldValue;
-                    if (!fieldReference.ref.type) {
+                    if (!fieldReference.ref.type && !skipRender) {
                         _subjects.state.next({
                             name,
                             values: skipClone ? _formValues : cloneObject(_formValues),
@@ -1935,10 +1987,10 @@ function createFormControl(props = {}) {
             }
         }
         (options.shouldDirty || options.shouldTouch) &&
-            updateTouchAndDirty(name, fieldValue, options.shouldTouch, options.shouldDirty, true);
+            updateTouchAndDirty(name, fieldValue, options.shouldTouch, options.shouldDirty, !skipRender);
         options.shouldValidate && trigger(name);
     };
-    const setFieldValues = (name, value, options, skipClone = false) => {
+    const setFieldValues = (name, value, options, skipClone = false, skipRender = false) => {
         for (const fieldKey in value) {
             if (!value.hasOwnProperty(fieldKey)) {
                 return;
@@ -1950,11 +2002,11 @@ function createFormControl(props = {}) {
                 isObject(fieldValue) ||
                 (field && !field._f)) &&
                 !isDateObject(fieldValue)
-                ? setFieldValues(fieldName, fieldValue, options, skipClone)
-                : setFieldValue(fieldName, fieldValue, options, skipClone);
+                ? setFieldValues(fieldName, fieldValue, options, skipClone, skipRender)
+                : setFieldValue(fieldName, fieldValue, options, skipClone, skipRender);
         }
     };
-    const _setValue = (name, value, options, skipClone) => {
+    const _setValue = (name, value, options, skipClone, skipStateEmit = false) => {
         const field = get(_fields, name);
         const isFieldArray = _names.array.has(name);
         const cloneValue = skipClone ? value : cloneObject(value);
@@ -1974,24 +2026,26 @@ function createFormControl(props = {}) {
                 _proxySubscribeFormState.dirtyFields) &&
                 options.shouldDirty) {
                 _updateDirtyFields();
-                _subjects.state.next({
-                    name,
-                    dirtyFields: _formState.dirtyFields,
-                    isDirty: _getDirty(name, cloneValue),
-                });
+                if (!skipStateEmit) {
+                    _subjects.state.next({
+                        name,
+                        dirtyFields: _formState.dirtyFields,
+                        isDirty: _getDirty(name, cloneValue),
+                    });
+                }
             }
         }
         else {
             const isEmpty = (Array.isArray(cloneValue) && !cloneValue.length) ||
                 isEmptyObject(cloneValue);
             if (!field || field._f || isNullOrUndefined(cloneValue) || isEmpty) {
-                setFieldValue(name, cloneValue, options, skipClone);
+                setFieldValue(name, cloneValue, options, skipClone, skipStateEmit);
             }
             else {
-                setFieldValues(name, cloneValue, options, skipClone);
+                setFieldValues(name, cloneValue, options, skipClone, skipStateEmit);
             }
         }
-        if (!isValueUnchanged) {
+        if (!isValueUnchanged && !skipStateEmit) {
             const watched = isWatched(name, _names);
             const values = skipClone ? _formValues : cloneObject(_formValues);
             _subjects.state.next({
@@ -2012,13 +2066,13 @@ function createFormControl(props = {}) {
                 ...updatedFormValues,
             };
             for (const fieldName of _names.mount) {
-                _setValue(fieldName, get(updatedFormValues, fieldName), options, true);
+                _setValue(fieldName, get(updatedFormValues, fieldName), options, true, true);
             }
             _subjects.state.next({
                 ..._formState,
                 name: undefined,
                 type: undefined,
-                values: _formValues,
+                ...(_valuesSubscriberCount ? { values: _formValues } : {}),
             });
             if (options.shouldValidate) {
                 _setValid();
@@ -2037,8 +2091,6 @@ function createFormControl(props = {}) {
                     (isDateObject(fieldValue) && isNaN(fieldValue.getTime())) ||
                     deepEqual(fieldValue, get(_formValues, name, fieldValue));
         };
-        const validationModeBeforeSubmit = getValidationModes(_options.mode);
-        const validationModeAfterSubmit = getValidationModes(_options.reValidateMode);
         if (field) {
             let error;
             let isValid;
@@ -2046,12 +2098,13 @@ function createFormControl(props = {}) {
                 ? getFieldValue(field._f)
                 : getEventValue(event);
             const isBlurEvent = event.type === EVENTS.BLUR || event.type === EVENTS.FOCUS_OUT;
-            const shouldSkipValidation = (!hasValidation(field._f) &&
+            const hasNoValidationEffect = !hasValidation(field._f) &&
                 !props.validate &&
                 !_options.resolver &&
                 !get(_formState.errors, name) &&
-                !field._f.deps) ||
-                skipValidation(isBlurEvent, get(_formState.touchedFields, name), _formState.isSubmitted, validationModeAfterSubmit, validationModeBeforeSubmit);
+                !field._f.deps;
+            const shouldSkipValidation = hasNoValidationEffect ||
+                skipValidation(isBlurEvent, get(_formState.touchedFields, name), _formState.isSubmitted, _validationModeAfterSubmit, _validationModeBeforeSubmit);
             const watched = isWatched(name, _names, isBlurEvent);
             set(_formValues, name, fieldValue);
             if (isBlurEvent) {
@@ -2069,10 +2122,13 @@ function createFormControl(props = {}) {
                 _subjects.state.next({
                     name,
                     type: event.type,
-                    values: cloneObject(_formValues),
+                    ...(_valuesSubscriberCount
+                        ? { values: cloneObject(_formValues) }
+                        : {}),
                 });
             if (shouldSkipValidation) {
-                if (_proxyFormState.isValid || _proxySubscribeFormState.isValid) {
+                if ((!hasNoValidationEffect || !_formState.isValid) &&
+                    (_proxyFormState.isValid || _proxySubscribeFormState.isValid)) {
                     if (_options.mode === 'onBlur') {
                         if (isBlurEvent) {
                             _setValid();
@@ -2207,8 +2263,6 @@ function createFormControl(props = {}) {
         const names = name ? convertToArrayPayload(name) : undefined;
         names === null || names === void 0 ? void 0 : 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,
@@ -2217,7 +2271,6 @@ function createFormControl(props = {}) {
             });
         }
         else {
-            // Clear all errors - emit without name to notify all subscribers
             _subjects.state.next({
                 errors: {},
             });
@@ -2226,7 +2279,6 @@ function createFormControl(props = {}) {
     const setError = (name, error, options) => {
         const ref = (get(_fields, name, { _f: {} })._f || {}).ref;
         const currentError = get(_formState.errors, name) || {};
-        // Don't override existing error messages elsewhere in the object tree.
         const { ref: currentRef, message, type, ...restOfErrorTree } = currentError;
         set(_formState.errors, name, {
             ...restOfErrorTree,
@@ -2240,26 +2292,60 @@ 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(payload.values || _getWatch(undefined, defaultValue), payload),
-        })
-        : _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: snapshot,
-                    ..._formState,
-                    ...formState,
-                    defaultValues: _defaultValues,
-                });
+    const watch = (name, defaultValue) => {
+        if (isFunction(name)) {
+            _valuesSubscriberCount++;
+            const { unsubscribe } = _subjects.state.subscribe({
+                next: (payload) => 'values' in payload &&
+                    name(payload.values || _getWatch(undefined, defaultValue), payload),
+            });
+            let called = false;
+            return {
+                unsubscribe: () => {
+                    if (called) {
+                        return;
+                    }
+                    called = true;
+                    _valuesSubscriberCount--;
+                    unsubscribe();
+                },
+            };
+        }
+        return _getWatch(name, defaultValue, true);
+    };
+    const _subscribe = (props) => {
+        var _a;
+        const needsValues = !!((_a = props.formState) === null || _a === void 0 ? void 0 : _a.values);
+        if (needsValues) {
+            _valuesSubscriberCount++;
+        }
+        const { unsubscribe } = _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: snapshot,
+                        ..._formState,
+                        ...formState,
+                        defaultValues: _defaultValues,
+                    });
+                }
+            },
+        });
+        if (!needsValues) {
+            return unsubscribe;
+        }
+        let called = false;
+        return () => {
+            if (called) {
+                return;
             }
-        },
-    }).unsubscribe;
+            called = true;
+            _valuesSubscriberCount--;
+            unsubscribe();
+        };
+    };
     const subscribe = (props) => {
         _state.mount = true;
         _proxySubscribeFormState = {
@@ -2593,9 +2679,6 @@ function createFormControl(props = {}) {
         _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 = {};
         }
@@ -2647,8 +2730,6 @@ function createFormControl(props = {}) {
                 ? fieldReference.refs[0]
                 : fieldReference.ref;
             if (fieldRef.focus) {
-                // 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 &&
@@ -2742,6 +2823,8 @@ function createFormControl(props = {}) {
                     ..._options,
                     ...value,
                 };
+                _validationModeBeforeSubmit = getValidationModes(_options.mode);
+                _validationModeAfterSubmit = getValidationModes(_options.reValidateMode);
             },
         },
         subscribe,
@@ -2875,34 +2958,45 @@ var updateAt = (fieldValues, index, value) => {
  */
 function useFieldArray(props) {
     const formControl = useFormControlContext();
-    const { control = formControl, name, keyName = 'id', shouldUnregister, rules, } = props;
+    const { control = formControl, name, keyName = 'id', disabled, 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);
-    control._names.array.add(name);
-    React.useMemo(() => rules &&
+    if (!disabled) {
+        control._names.array.add(name);
+    }
+    React.useMemo(() => !disabled &&
+        rules &&
         fields.length >= 0 &&
-        control.register(name, rules), [control, name, fields.length, rules]);
-    useIsomorphicLayoutEffect(() => control._subjects.array.subscribe({
-        next: ({ values, name: fieldArrayName, }) => {
-            if (fieldArrayName === name || !fieldArrayName) {
-                const fieldValues = get(values, name);
-                if (Array.isArray(fieldValues)) {
-                    setFields(fieldValues);
-                    ids.current = fieldValues.map(generateId);
-                }
-                else if (!fieldArrayName) {
-                    setFields([]);
-                    ids.current = [];
+        control.register(name, rules), [control, name, fields.length, rules, disabled]);
+    useIsomorphicLayoutEffect(() => {
+        if (disabled) {
+            return;
+        }
+        return control._subjects.array.subscribe({
+            next: ({ values, name: fieldArrayName, }) => {
+                if (fieldArrayName === name || !fieldArrayName) {
+                    const fieldValues = get(values, name);
+                    if (Array.isArray(fieldValues)) {
+                        setFields(fieldValues);
+                        ids.current = fieldValues.map(generateId);
+                    }
+                    else if (!fieldArrayName) {
+                        setFields([]);
+                        ids.current = [];
+                    }
                 }
-            }
-        },
-    }).unsubscribe, [control, name]);
+            },
+        }).unsubscribe;
+    }, [control, name, disabled]);
     const updateValues = React.useCallback((updatedFieldArrayValues) => {
         _actioned.current = true;
         control._setFieldArray(name, updatedFieldArrayValues);
     }, [control, name]);
     const append = (value, options) => {
+        if (disabled) {
+            return;
+        }
         const appendValue = convertToArrayPayload(cloneObject(value));
         const updatedFieldArrayValues = appendAt(control._getFieldArray(name), appendValue);
         control._names.focus = getFocusFieldName(name, updatedFieldArrayValues.length - 1, options);
@@ -2914,6 +3008,9 @@ function useFieldArray(props) {
         });
     };
     const prepend = (value, options) => {
+        if (disabled) {
+            return;
+        }
         const prependValue = convertToArrayPayload(cloneObject(value));
         const updatedFieldArrayValues = prependAt(control._getFieldArray(name), prependValue);
         control._names.focus = getFocusFieldName(name, 0, options);
@@ -2925,6 +3022,9 @@ function useFieldArray(props) {
         });
     };
     const remove = (index) => {
+        if (disabled) {
+            return;
+        }
         const updatedFieldArrayValues = removeArrayAt(control._getFieldArray(name), index);
         ids.current = removeArrayAt(ids.current, index);
         updateValues(updatedFieldArrayValues);
@@ -2936,6 +3036,9 @@ function useFieldArray(props) {
         });
     };
     const insert$1 = (index, value, options) => {
+        if (disabled) {
+            return;
+        }
         const insertValue = convertToArrayPayload(cloneObject(value));
         const updatedFieldArrayValues = insert(control._getFieldArray(name), index, insertValue);
         control._names.focus = getFocusFieldName(name, index, options);
@@ -2948,6 +3051,9 @@ function useFieldArray(props) {
         });
     };
     const swap = (indexA, indexB) => {
+        if (disabled) {
+            return;
+        }
         const updatedFieldArrayValues = control._getFieldArray(name);
         swapArrayAt(updatedFieldArrayValues, indexA, indexB);
         swapArrayAt(ids.current, indexA, indexB);
@@ -2959,6 +3065,9 @@ function useFieldArray(props) {
         }, false);
     };
     const move = (from, to) => {
+        if (disabled) {
+            return;
+        }
         const updatedFieldArrayValues = control._getFieldArray(name);
         moveArrayAt(updatedFieldArrayValues, from, to);
         moveArrayAt(ids.current, from, to);
@@ -2970,6 +3079,9 @@ function useFieldArray(props) {
         }, false);
     };
     const update = (index, value) => {
+        if (disabled) {
+            return;
+        }
         const updateValue = cloneObject(value);
         const updatedFieldArrayValues = updateAt(control._getFieldArray(name), index, updateValue);
         ids.current = [...updatedFieldArrayValues].map((item, i) => !item || i === index ? generateId() : ids.current[i]);
@@ -2981,6 +3093,9 @@ function useFieldArray(props) {
         }, true, false);
     };
     const replace = (value) => {
+        if (disabled) {
+            return;
+        }
         const updatedFieldArrayValues = convertToArrayPayload(cloneObject(value));
         ids.current = updatedFieldArrayValues.map(generateId);
         updateValues([...updatedFieldArrayValues]);
@@ -2988,6 +3103,9 @@ function useFieldArray(props) {
         control._setFieldArray(name, [...updatedFieldArrayValues], (data) => data, {}, true, false);
     };
     React.useEffect(() => {
+        if (disabled) {
+            return;
+        }
         control._state.action = false;
         isWatched(name, control._names) &&
             control._subjects.state.next({
@@ -3048,10 +3166,15 @@ function useFieldArray(props) {
         control._names.focus = '';
         control._setValid();
         _actioned.current = false;
-    }, [fields, name, control]);
+    }, [fields, name, control, disabled]);
     React.useEffect(() => {
-        !get(control._formValues, name) && control._setFieldArray(name);
+        if (!disabled) {
+            !get(control._formValues, name) && control._setFieldArray(name);
+        }
         return () => {
+            if (disabled) {
+                return;
+            }
             const shouldKeepFieldArrayValues = !(control._options.shouldUnregister || shouldUnregister);
             const updateMounted = (name, value) => {
                 const field = get(control._fields, name);
@@ -3069,20 +3192,31 @@ function useFieldArray(props) {
                 ? updateMounted(name, false)
                 : control.unregister(name);
         };
-    }, [name, control, keyName, shouldUnregister]);
+    }, [name, control, keyName, shouldUnregister, disabled]);
     return {
-        swap: React.useCallback(swap, [updateValues, name, control]),
-        move: React.useCallback(move, [updateValues, name, control]),
-        prepend: React.useCallback(prepend, [updateValues, name, control]),
-        append: React.useCallback(append, [updateValues, name, control]),
-        remove: React.useCallback(remove, [updateValues, name, control]),
-        insert: React.useCallback(insert$1, [updateValues, name, control]),
-        update: React.useCallback(update, [updateValues, name, control]),
-        replace: React.useCallback(replace, [updateValues, name, control]),
+        swap: React.useCallback(swap, [updateValues, name, control, disabled]),
+        move: React.useCallback(move, [updateValues, name, control, disabled]),
+        prepend: React.useCallback(prepend, [
+            updateValues,
+            name,
+            control,
+            disabled,
+        ]),
+        append: React.useCallback(append, [updateValues, name, control, disabled]),
+        remove: React.useCallback(remove, [updateValues, name, control, disabled]),
+        insert: React.useCallback(insert$1, [updateValues, name, control, disabled]),
+        update: React.useCallback(update, [updateValues, name, control, disabled]),
+        replace: React.useCallback(replace, [
+            updateValues,
+            name,
+            control,
+            disabled,
+        ]),
         fields: React.useMemo(() => fields.map((field, index) => ({
             ...field,
+            ...(isBoolean(disabled) ? { disabled } : {}),
             [keyName]: ids.current[index] || generateId(),
-        })), [fields, keyName]),
+        })), [fields, keyName, disabled]),
     };
 }
 
@@ -3118,6 +3252,7 @@ function useFieldArray(props) {
 function useForm(props = {}) {
     const _formControl = React.useRef(undefined);
     const _values = React.useRef(undefined);
+    const _formControlProp = React.useRef(props.formControl);
     const [formState, updateFormState] = React.useState(() => ({
         ...cloneObject(DEFAULT_FORM_STATE),
         isLoading: isFunction(props.defaultValues),
@@ -3127,7 +3262,9 @@ function useForm(props = {}) {
             ? undefined
             : props.defaultValues,
     }));
-    if (!_formControl.current) {
+    if (!_formControl.current ||
+        (props.formControl && _formControlProp.current !== props.formControl)) {
+        _formControlProp.current = props.formControl;
         if (props.formControl) {
             _formControl.current = {
                 ...props.formControl,