react-hook-form 7.79.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)) {
@@ -268,6 +269,9 @@ function deepEqual(object1, object2, visited = new WeakMap()) {
         isEmptyObjectWithCustomPrototype(object2, keys2)) {
         return Object.is(object1, object2);
     }
+    if (!keys1.length && Array.isArray(object1) !== Array.isArray(object2)) {
+        return false;
+    }
     const visitedPairs = visited.get(object1);
     if (visitedPairs && visitedPairs.has(object2)) {
         return true;
@@ -276,7 +280,9 @@ function deepEqual(object1, object2, visited = new WeakMap()) {
         visitedPairs.add(object2);
     }
     else {
-        visited.set(object1, new WeakSet([object2]));
+        const ws = new WeakSet();
+        ws.add(object2);
+        visited.set(object1, ws);
     }
     for (const key of keys1) {
         const val1 = object1[key];
@@ -1132,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 ||
@@ -1148,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)) {
@@ -1219,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)));
 };
 
@@ -1470,6 +1493,7 @@ const defaultOptions = {
     reValidateMode: VALIDATION_MODE.onChange,
     shouldFocusError: true,
 };
+const FORM_ERROR_TYPE = 'form';
 const DEFAULT_FORM_STATE = {
     submitCount: 0,
     isDirty: false,
@@ -1517,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,
@@ -1670,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)) {
@@ -1685,9 +1706,6 @@ function createFormControl(props = {}) {
                         _subjects.state.next({ ..._formState });
                     }
                 }
-                // When a watched field is re-registered after being unregistered and
-                // its value is restored, trigger a deferred watch broadcast so that
-                // components using watch() re-render with the new value.
                 if (props.shouldUnregister &&
                     wasUnsetInFormValues &&
                     !isUndefined(get(_formValues, name)) &&
@@ -1705,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);
@@ -1909,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
@@ -1920,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) {
@@ -1958,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),
@@ -1968,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;
@@ -1983,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);
@@ -2007,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({
@@ -2045,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();
@@ -2070,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;
@@ -2079,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) {
@@ -2102,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();
@@ -2240,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,
@@ -2250,7 +2271,6 @@ function createFormControl(props = {}) {
             });
         }
         else {
-            // Clear all errors - emit without name to notify all subscribers
             _subjects.state.next({
                 errors: {},
             });
@@ -2259,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,
@@ -2273,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 = {
@@ -2626,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 = {};
         }
@@ -2680,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 &&
@@ -2775,6 +2823,8 @@ function createFormControl(props = {}) {
                     ..._options,
                     ...value,
                 };
+                _validationModeBeforeSubmit = getValidationModes(_options.mode);
+                _validationModeAfterSubmit = getValidationModes(_options.reValidateMode);
             },
         },
         subscribe,
@@ -2909,8 +2959,8 @@ var updateAt = (fieldValues, index, value) => {
 function useFieldArray(props) {
     const formControl = useFormControlContext();
     const { control = formControl, name, keyName = 'id', disabled, shouldUnregister, rules, } = props;
-    const [fields, setFields] = React.useState(disabled ? [] : control._getFieldArray(name));
-    const ids = React.useRef(disabled ? [] : control._getFieldArray(name).map(generateId));
+    const [fields, setFields] = React.useState(control._getFieldArray(name));
+    const ids = React.useRef(control._getFieldArray(name).map(generateId));
     const _actioned = React.useRef(false);
     if (!disabled) {
         control._names.array.add(name);
@@ -3164,8 +3214,9 @@ function useFieldArray(props) {
         ]),
         fields: React.useMemo(() => fields.map((field, index) => ({
             ...field,
+            ...(isBoolean(disabled) ? { disabled } : {}),
             [keyName]: ids.current[index] || generateId(),
-        })), [fields, keyName]),
+        })), [fields, keyName, disabled]),
     };
 }