react-hook-form 7.85.0 → 7.87.0

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 export * from './controller';
 export { FieldArray } from './fieldArray';
 export * from './form';
-export type { FormStateProps, FormStateSubscribeProps, } from './formStateSubscribe';
-export { FormState, FormStateSubscribe } from './formStateSubscribe';
+export type { FormStateProps, FormStateSubscribeProps } from './formState';
+export { FormState, FormStateSubscribe } from './formState';
 export * from './logic';
 export * from './types';
 export * from './useController';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,cAAc,QAAQ,CAAC;AACvB,YAAY,EACV,cAAc,EACd,uBAAuB,GACxB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AACrE,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,cAAc,QAAQ,CAAC;AACvB,YAAY,EAAE,cAAc,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAC3E,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAC5D,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC"}

package/dist/index.esm.mjs

@@ -22,20 +22,36 @@ var getEventValue = (event) => isObject(event) && event.target
             : event.target.value
     : event;
 
+const FIELD_PATH_RE = /[.[\]'"]/;
+var stringToPath = (input) => input.split(FIELD_PATH_RE).filter(Boolean);
+
+function getNullAncestorValue(control, name) {
+    const segments = stringToPath(name);
+    let formValues = control._formValues;
+    let defaultValues = control._defaultValues;
+    for (let i = 0; i < segments.length - 1; i++) {
+        const key = segments[i];
+        formValues = formValues == null ? formValues : formValues[key];
+        defaultValues = defaultValues == null ? defaultValues : defaultValues[key];
+        if (formValues === null || defaultValues === null) {
+            return null;
+        }
+    }
+    return undefined;
+}
+
 var isNameInFieldArray = (names, name) => name
     .split('.')
     .some((part, index, arr) => !isNaN(Number(part)) && names.has(arr.slice(0, index).join('.')));
 
-var isPlainObject = (tempObject) => {
-    const prototypeCopy = tempObject.constructor && tempObject.constructor.prototype;
-    return (isObject(prototypeCopy) && prototypeCopy.hasOwnProperty('isPrototypeOf'));
-};
-
 var isWeb = typeof window !== 'undefined' &&
     typeof window.HTMLElement !== 'undefined' &&
     typeof document !== 'undefined';
 
 function cloneObject(data) {
+    if (data === null || typeof data !== 'object') {
+        return data;
+    }
     if (data instanceof Date) {
         return new Date(data);
     }
@@ -44,7 +60,7 @@ function cloneObject(data) {
         return data;
     }
     const isArray = Array.isArray(data);
-    if (!isArray && !(isObject(data) && isPlainObject(data))) {
+    if (!isArray && data.constructor !== Object) {
         return data;
     }
     const copy = isArray ? [] : Object.create(Object.getPrototypeOf(data));
@@ -88,9 +104,6 @@ var isKey = (value) => IS_KEY_RE.test(value);
 
 var isUndefined = (val) => val === undefined;
 
-const FIELD_PATH_RE = /[.[\]'"]/;
-var stringToPath = (input) => input.split(FIELD_PATH_RE).filter(Boolean);
-
 var get = (object, path, defaultValue) => {
     if (!path || !isObject(object)) {
         return defaultValue;
@@ -170,6 +183,11 @@ const useIsomorphicLayoutEffect = isWeb
     ? React.useLayoutEffect
     : React.useEffect;
 
+var isPlainObject = (tempObject) => {
+    const prototypeCopy = tempObject.constructor && tempObject.constructor.prototype;
+    return (isObject(prototypeCopy) && prototypeCopy.hasOwnProperty('isPrototypeOf'));
+};
+
 var isPrimitive = (value) => isNullOrUndefined(value) || !isObjectType(value);
 
 const isEmptyObjectWithCustomPrototype = (object, keys) => keys.length === 0 && !Array.isArray(object) && !isPlainObject(object);
@@ -226,11 +244,20 @@ function deepEqual(object1, object2, visited = new WeakMap()) {
     return true;
 }
 
-function useResyncOnReconnect() {
+function useResyncOnReconnect(getInitialValue) {
     const _connected = React.useRef(false);
+    const _initialized = React.useRef(false);
     const _prevValue = React.useRef(undefined);
+    const _renderCount = React.useRef(0);
+    _renderCount.current++;
+    if (!_initialized.current && getInitialValue) {
+        _initialized.current = true;
+        _prevValue.current = cloneObject(getInitialValue());
+    }
     const resyncIfNeeded = React.useCallback((enabled, getCurrentValue, setValue) => {
-        if (enabled && _connected.current) {
+        if (enabled &&
+            (_connected.current ||
+                (_initialized.current && _renderCount.current > 1))) {
             const currentValue = getCurrentValue();
             if (!deepEqual(_prevValue.current, currentValue)) {
                 setValue(currentValue);
@@ -279,10 +306,11 @@ function useResyncOnReconnect() {
 function useFormState(props) {
     const formControl = useFormControlContext();
     const { control = formControl, disabled, name, exact } = props || {};
-    const [formState, updateFormState] = React.useState(() => ({
+    const getCurrentFormState = () => ({
         ...control._formState,
         defaultValues: control._defaultValues,
-    }));
+    });
+    const [formState, updateFormState] = React.useState(getCurrentFormState);
     const _localProxyFormState = React.useRef({
         isDirty: false,
         isLoading: false,
@@ -293,12 +321,8 @@ function useFormState(props) {
         isValid: false,
         errors: false,
     });
-    const { resyncIfNeeded, snapshot } = useResyncOnReconnect();
+    const { resyncIfNeeded, snapshot } = useResyncOnReconnect(getCurrentFormState);
     useIsomorphicLayoutEffect(() => {
-        const getCurrentFormState = () => ({
-            ...control._formState,
-            defaultValues: control._defaultValues,
-        });
         resyncIfNeeded(!disabled, getCurrentFormState, updateFormState);
         const unsubscribe = control._subscribe({
             name,
@@ -333,7 +357,7 @@ var generateWatchOutput = (names, _names, formValues, isGlobal, defaultValue) =>
     }
     if (Array.isArray(names)) {
         return names.map((fieldName) => (isGlobal && _names.watch.add(fieldName),
-            get(formValues, fieldName)));
+            get(formValues, fieldName, get(defaultValue, fieldName))));
     }
     isGlobal && (_names.watchAll = true);
     return formValues;
@@ -364,10 +388,11 @@ function useWatch(props) {
     const _prevControl = React.useRef(control);
     const _prevName = React.useRef(name);
     _compute.current = compute;
-    const [value, updateValue] = React.useState(() => {
+    const getInitialOutput = () => {
         const defaultValue = control._getWatch(name, _defaultValue.current);
         return _compute.current ? _compute.current(defaultValue) : defaultValue;
-    });
+    };
+    const [value, updateValue] = React.useState(getInitialOutput);
     const getCurrentOutput = React.useCallback((values) => {
         const formValues = generateWatchOutput(name, control._names, values || control._formValues, false, _defaultValue.current);
         return _compute.current ? _compute.current(formValues) : formValues;
@@ -387,7 +412,7 @@ function useWatch(props) {
             }
         }
     }, [control._formValues, control._names, disabled, name]);
-    const { resyncIfNeeded, snapshot } = useResyncOnReconnect();
+    const { resyncIfNeeded, snapshot } = useResyncOnReconnect(getInitialOutput);
     const _refreshValue = React.useRef(refreshValue);
     _refreshValue.current = refreshValue;
     const _getCurrentOutput = React.useRef(getCurrentOutput);
@@ -427,17 +452,17 @@ function useWatch(props) {
     // Optimize: Check control reference first before expensive deepEqual
     const controlChanged = _prevControl.current !== control;
     const prevName = _prevName.current;
-    // Cache the computed output to avoid duplicate calls within the same render
-    // We include shouldReturnImmediate in deps to ensure proper recomputation
-    const computedOutput = React.useMemo(() => {
+    // `null`/`undefined` are valid watched values, so a boolean flag (rather
+    // than a sentinel return value) decides whether to return the freshly
+    // computed output instead of the possibly-stale state value.
+    const shouldReturnImmediate = React.useMemo(() => {
         if (disabled) {
-            return null;
+            return false;
         }
         const nameChanged = !controlChanged && !deepEqual(prevName, name);
-        const shouldReturnImmediate = controlChanged || nameChanged;
-        return shouldReturnImmediate ? getCurrentOutput() : null;
-    }, [disabled, controlChanged, name, prevName, getCurrentOutput]);
-    return computedOutput !== null ? computedOutput : value;
+        return controlChanged || nameChanged;
+    }, [disabled, controlChanged, name, prevName]);
+    return shouldReturnImmediate ? getCurrentOutput() : value;
 }
 
 /**
@@ -468,7 +493,12 @@ function useController(props) {
     const formControl = useFormControlContext();
     const { name, disabled, control = formControl, shouldUnregister, defaultValue, exact = true, } = props;
     const isArrayField = isNameInFieldArray(control._names.array, name);
-    const defaultValueMemo = React.useMemo(() => get(control._formValues, name, get(control._defaultValues, name, defaultValue)), [control, name, defaultValue]);
+    const defaultValueMemo = React.useMemo(() => {
+        const resolved = get(control._formValues, name, get(control._defaultValues, name, defaultValue));
+        return isUndefined(resolved)
+            ? getNullAncestorValue(control, name)
+            : resolved;
+    }, [control, name, defaultValue]);
     const value = useWatch({
         control,
         name,
@@ -653,16 +683,12 @@ function useController(props) {
  */
 const Controller = (props) => props.render(useController(props));
 
-var generateId = () => {
-    if (typeof crypto !== 'undefined' && crypto.randomUUID) {
-        return crypto.randomUUID();
-    }
-    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;
-        return (c == 'x' ? r : (r & 0x3) | 0x8).toString(16);
+var generateId = () => typeof crypto !== 'undefined' && crypto.randomUUID
+    ? crypto.randomUUID()
+    : 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        return (c === 'x' ? r : (r & 0x3) | 0x8).toString(16);
     });
-};
 
 var getFocusFieldName = (name, index, options = {}) => options.shouldFocus || isUndefined(options.shouldFocus)
     ? options.focusName ||
@@ -759,23 +785,25 @@ const defaultResult = {
 };
 const validResult = { value: true, isValid: true };
 var getCheckboxValue = (options) => {
-    if (Array.isArray(options)) {
-        if (options.length > 1) {
-            const values = options
-                .filter((option) => option && option.checked && !option.disabled)
-                .map((option) => option.value);
-            return { value: values, isValid: !!values.length };
-        }
-        return options[0].checked && !options[0].disabled
-            ? // @ts-expect-error expected to work in the browser
-                options[0].attributes && !isUndefined(options[0].attributes.value)
-                    ? isUndefined(options[0].value) || options[0].value === ''
-                        ? validResult
-                        : { value: options[0].value, isValid: true }
-                    : validResult
-            : defaultResult;
-    }
-    return defaultResult;
+    if (!Array.isArray(options)) {
+        return defaultResult;
+    }
+    if (options.length > 1) {
+        const values = options
+            .filter((option) => option && option.checked && !option.disabled)
+            .map((option) => option.value);
+        return { value: values, isValid: !!values.length };
+    }
+    const option = options[0];
+    if (!option || !option.checked || option.disabled) {
+        return defaultResult;
+    }
+    if (!option.attributes || !('value' in option.attributes)) {
+        return validResult;
+    }
+    return isUndefined(option.value) || option.value === ''
+        ? validResult
+        : { value: option.value, isValid: true };
 };
 
 const defaultReturn = {
@@ -993,7 +1021,8 @@ var validateField = async (field, disabledFieldNames, formValues, validateAllFie
             }
         }
     }
-    setCustomValidity(true);
+    const fieldError = error[name];
+    setCustomValidity(fieldError ? fieldError.message : true);
     return error;
 };
 
@@ -1272,8 +1301,8 @@ function useFieldArray(props) {
         setFields([...updatedFieldArrayValues]);
         control._setFieldArray(name, updatedFieldArrayValues, updateAt, {
             argA: index,
-            argB: updateValue,
-        }, true, false);
+            argB: fillEmptyArray(value),
+        });
     };
     const replace = (value) => {
         if (disabled) {
@@ -1333,10 +1362,7 @@ function useFieldArray(props) {
             }
             else {
                 const field = get(control._fields, name);
-                if (field &&
-                    field._f &&
-                    !(getValidationModes(control._options.reValidateMode).isOnSubmit &&
-                        getValidationModes(control._options.mode).isOnSubmit)) {
+                if (field && field._f) {
                     validateField(field, control._names.disabled, control._formValues, control._options.criteriaMode === VALIDATION_MODE.all, control._options.shouldUseNativeValidation, true).then((error) => !isEmptyObject(error) &&
                         control._subjects.state.next({
                             errors: updateFieldArrayRootError(control._formState.errors, error, name),
@@ -1454,12 +1480,15 @@ function useFieldArray(props) {
  */
 const FieldArray = (props) => props.render(useFieldArray(props));
 
+const isFileLike = (value) => (typeof Blob !== 'undefined' && value instanceof Blob) ||
+    (typeof File !== 'undefined' && value instanceof File);
 const flatten = (obj) => {
     const output = {};
     for (const key of Object.keys(obj)) {
         if (isObjectType(obj[key]) &&
             obj[key] !== null &&
-            !isDateObject(obj[key])) {
+            !isDateObject(obj[key]) &&
+            !isFileLike(obj[key])) {
             const nested = flatten(obj[key]);
             for (const nestedKey of Object.keys(nested)) {
                 output[`${key}.${nestedKey}`] = nested[nestedKey];
@@ -1555,10 +1584,11 @@ const useFormContext = () => React.useContext(HookFormContext);
  * }
  * ```
  */
-const FormProvider = ({ children, watch, getValues, getFieldState, setError, clearErrors, setValue, setValues, trigger, formState, resetField, reset, resetDefaultValues, handleSubmit, unregister, control, register, setFocus, subscribe, }) => {
+const FormProvider = ({ children, watch, getValues, getErrors, getFieldState, setError, clearErrors, setValue, setValues, trigger, formState, resetField, reset, resetDefaultValues, handleSubmit, unregister, control, register, setFocus, subscribe, }) => {
     const memoizedValue = React.useMemo(() => ({
         watch,
         getValues,
+        getErrors,
         getFieldState,
         setError,
         clearErrors,
@@ -1579,6 +1609,7 @@ const FormProvider = ({ children, watch, getValues, getFieldState, setError, cle
         clearErrors,
         control,
         formState,
+        getErrors,
         getFieldState,
         getValues,
         handleSubmit,
@@ -1766,6 +1797,24 @@ function extractFormValues(fieldsState, formValues) {
     return values;
 }
 
+const hasOwn = (value, key) => value !== null &&
+    isObjectType(value) &&
+    Object.prototype.hasOwnProperty.call(value, key);
+var has = (object, path) => {
+    if (!path) {
+        return false;
+    }
+    let result = object;
+    for (const key of isKey(path) ? [path] : stringToPath(path)) {
+        if (!hasOwn(result, key)) {
+            // `get` also resolves a path held as a single literal key, eg `{ 'a.b': 1 }`
+            return hasOwn(object, path);
+        }
+        result = result[key];
+    }
+    return true;
+};
+
 var isMultipleSelect = (element) => element.type === `select-multiple`;
 
 var isRadioOrCheckbox = (ref) => isRadioInput(ref) || isCheckBoxInput(ref);
@@ -1865,6 +1914,18 @@ function getDirtyFields(data, formValues, dirtyFieldsFromValues, fieldRefs) {
     return dirtyFieldsFromValues;
 }
 
+var getFieldArrayItemNames = (names, name) => {
+    const segments = name.split('.');
+    const matches = [];
+    let prefix = segments[0];
+    for (let i = 1; i < segments.length; prefix += '.' + segments[i++]) {
+        if (!isNaN(+segments[i]) && names.has(prefix)) {
+            matches.push(`${prefix}.${segments[i]}`);
+        }
+    }
+    return matches;
+};
+
 var getFieldValueAs = (value, { valueAsNumber, valueAsDate, setValueAs }) => isUndefined(value)
     ? value
     : valueAsNumber
@@ -1940,10 +2001,11 @@ var hasPromiseValidation = (fieldReference) => {
 
 var hasValidation = (options) => options.mount &&
     (options.required ||
-        options.min ||
-        options.max ||
-        options.maxLength ||
-        options.minLength ||
+        (!isUndefined(options.required) && options.required !== false) ||
+        !isUndefined(options.min) ||
+        !isUndefined(options.max) ||
+        !isUndefined(options.maxLength) ||
+        !isUndefined(options.minLength) ||
         options.pattern ||
         options.validate);
 
@@ -2147,7 +2209,7 @@ function createFormControl(props = {}) {
                 _proxyFormState.validatingFields ||
                 _proxySubscribeFormState.isValidating ||
                 _proxySubscribeFormState.validatingFields)) {
-            (names || Array.from(_names.mount)).forEach((name) => {
+            (names || _names.mount).forEach((name) => {
                 if (name) {
                     isValidating
                         ? set(_formState.validatingFields, name, isValidating)
@@ -2166,17 +2228,16 @@ function createFormControl(props = {}) {
     const _setFieldArray = (name, values = [], method, args, shouldSetValues = true, shouldUpdateFieldsAndState = true) => {
         if (args && method && !_options.disabled) {
             _state.action = true;
+            const fields = get(_fields, name);
             if (!_state.actionArrayLengths.has(name)) {
-                const preActionFields = get(_fields, name);
-                _state.actionArrayLengths.set(name, Array.isArray(preActionFields) ? preActionFields.length : 0);
+                _state.actionArrayLengths.set(name, Array.isArray(fields) ? fields.length : 0);
             }
-            if (shouldUpdateFieldsAndState && Array.isArray(get(_fields, name))) {
-                const fieldValues = method(get(_fields, name), args.argA, args.argB);
+            if (shouldUpdateFieldsAndState && Array.isArray(fields)) {
+                const fieldValues = method(fields, args.argA, args.argB);
                 shouldSetValues && set(_fields, name, fieldValues);
             }
-            if (shouldUpdateFieldsAndState &&
-                Array.isArray(get(_formState.errors, name))) {
-                const fieldArrayErrors = get(_formState.errors, name);
+            const fieldArrayErrors = get(_formState.errors, name);
+            if (shouldUpdateFieldsAndState && Array.isArray(fieldArrayErrors)) {
                 const rootError = fieldArrayErrors.root;
                 const errors = method(fieldArrayErrors, args.argA, args.argB) || fieldArrayErrors;
                 if (rootError) {
@@ -2185,11 +2246,12 @@ function createFormControl(props = {}) {
                 shouldSetValues && set(_formState.errors, name, errors);
                 unsetEmptyArray(_formState.errors, name);
             }
+            const touchedFieldsArray = get(_formState.touchedFields, name);
             if ((_proxyFormState.touchedFields ||
                 _proxySubscribeFormState.touchedFields) &&
                 shouldUpdateFieldsAndState &&
-                Array.isArray(get(_formState.touchedFields, name))) {
-                const touchedFields = method(get(_formState.touchedFields, name), args.argA, args.argB);
+                Array.isArray(touchedFieldsArray)) {
+                const touchedFields = method(touchedFieldsArray, args.argA, args.argB);
                 shouldSetValues && set(_formState.touchedFields, name, touchedFields);
             }
             if (_proxyFormState.dirtyFields || _proxySubscribeFormState.dirtyFields) {
@@ -2375,10 +2437,6 @@ function createFormControl(props = {}) {
                 errors: _formState.errors,
                 name,
             };
-            _formState = {
-                ..._formState,
-                ...updatedFormState,
-            };
             _subjects.state.next(updatedFormState);
         }
     };
@@ -2586,7 +2644,7 @@ function createFormControl(props = {}) {
         }
         for (const fieldKey in value) {
             if (!value.hasOwnProperty(fieldKey)) {
-                return;
+                continue;
             }
             const fieldValue = value[fieldKey];
             const fieldName = name + '.' + fieldKey;
@@ -2647,6 +2705,11 @@ function createFormControl(props = {}) {
                 name: _state.mount || watched ? name : undefined,
                 values,
             });
+            if (!isFieldArray) {
+                for (const itemName of getFieldArrayItemNames(_names.array, name)) {
+                    _subjects.state.next({ name: itemName, values });
+                }
+            }
         }
     };
     const setValue = (name, value, options = {}) => _setValue(name, value, options, false);
@@ -2659,10 +2722,9 @@ function createFormControl(props = {}) {
                 ..._formValues,
                 ...updatedFormValues,
             };
-            const flattenedUpdates = flatten(updatedFormValues);
             for (const fieldName of _names.mount) {
-                if (fieldName in flattenedUpdates) {
-                    _setValue(fieldName, flattenedUpdates[fieldName], options, true, true);
+                if (has(updatedFormValues, fieldName)) {
+                    _setValue(fieldName, get(updatedFormValues, fieldName), options, true, true);
                 }
             }
             _subjects.state.next({
@@ -2703,7 +2765,7 @@ function createFormControl(props = {}) {
             const shouldSkipValidation = hasNoValidationEffect ||
                 skipValidation(isBlurEvent, get(_formState.touchedFields, name), _formState.isSubmitted, _validationModeAfterSubmit, _validationModeBeforeSubmit);
             const watched = isWatched(name, _names, isBlurEvent);
-            set(_formValues, name, fieldValue);
+            set(_formValues, name, cloneObject(fieldValue));
             if (isBlurEvent) {
                 if (!target || !target.readOnly) {
                     field._f.onBlur && field._f.onBlur(event);
@@ -2835,6 +2897,12 @@ function createFormControl(props = {}) {
                 delete delayErrorCallbacks[name];
             }
         }
+        if (options.shouldTouch) {
+            for (const fieldName of name ? fieldNames : _names.mount) {
+                !_names.array.has(fieldName) &&
+                    set(_formState.touchedFields, fieldName, true);
+            }
+        }
         _subjects.state.next({
             ...(!isString(name) ||
                 ((_proxyFormState.isValid || _proxySubscribeFormState.isValid) &&
@@ -2842,6 +2910,10 @@ function createFormControl(props = {}) {
                 ? {}
                 : { name }),
             ...(_options.resolver || !name ? { isValid } : {}),
+            ...(options.shouldTouch &&
+                (_proxyFormState.touchedFields || _proxySubscribeFormState.touchedFields)
+                ? { touchedFields: _formState.touchedFields }
+                : {}),
             errors: _formState.errors,
         });
         options.shouldFocus &&
@@ -2862,13 +2934,22 @@ function createFormControl(props = {}) {
                 ? get(values, fieldNames)
                 : fieldNames.map((name) => get(values, name));
     };
-    const getFieldState = (name, formState) => ({
-        invalid: !!get((formState || _formState).errors, name),
-        isDirty: !!get((formState || _formState).dirtyFields, name),
-        error: get((formState || _formState).errors, name),
-        isValidating: !!get(_formState.validatingFields, name),
-        isTouched: !!get((formState || _formState).touchedFields, name),
-    });
+    const getErrors = (fieldNames) => isUndefined(fieldNames)
+        ? { ..._formState.errors }
+        : isString(fieldNames)
+            ? get(_formState.errors, fieldNames)
+            : fieldNames.map((name) => get(_formState.errors, name));
+    const getFieldState = (name, formState) => {
+        const targetFormState = formState || _formState;
+        const error = get(targetFormState.errors, name);
+        return {
+            invalid: !!error,
+            isDirty: !!get(targetFormState.dirtyFields, name),
+            error,
+            isValidating: !!get(_formState.validatingFields, name),
+            isTouched: !!get(targetFormState.touchedFields, name),
+        };
+    };
     const clearErrors = (name) => {
         const names = name ? convertToArrayPayload(name) : undefined;
         names === null || names === void 0 ? void 0 : names.forEach((inputName) => unset(_formState.errors, inputName));
@@ -2988,12 +3069,13 @@ function createFormControl(props = {}) {
                 !options.keepDefaultValue &&
                 unset(_defaultValues, fieldName);
         }
-        _subjects.state.next({
-            values: cloneObject(_formValues),
-        });
+        _valuesSubscriberCount &&
+            _subjects.state.next({
+                values: cloneObject(_formValues),
+            });
         _subjects.state.next({
             ..._formState,
-            ...(!options.keepDirty ? {} : { isDirty: _getDirty() }),
+            ...(options.keepDirty ? {} : { isDirty: _getDirty() }),
         });
         !options.keepIsValid && _setValid();
     };
@@ -3199,7 +3281,7 @@ function createFormControl(props = {}) {
             }
             if (!options.keepError) {
                 unset(_formState.errors, name);
-                _proxyFormState.isValid && _setValid();
+                _setValid();
             }
             _subjects.state.next({ ..._formState });
         }
@@ -3219,7 +3301,7 @@ function createFormControl(props = {}) {
                     ..._names.mount,
                     ...collectDirtyFieldNames(getDirtyFields(_defaultValues, _formValues, undefined, fieldRefs), _formState.dirtyFields),
                 ]);
-                for (const fieldName of Array.from(fieldsToCheck)) {
+                for (const fieldName of fieldsToCheck) {
                     const isDirty = get(_formState.dirtyFields, fieldName);
                     const existingValue = get(_formValues, fieldName);
                     const newValue = get(values, fieldName);
@@ -3462,6 +3544,7 @@ function createFormControl(props = {}) {
         setValue,
         setValues,
         getValues,
+        getErrors,
         reset,
         resetField,
         resetDefaultValues,