react-hook-form 8.0.0-beta.3 → 8.0.0-beta.4

package/dist/react-server.esm.mjs

@@ -31,38 +31,37 @@ const INPUT_VALIDATION_RULES = {
     required: 'required',
     validate: 'validate',
 };
+const REGISTER_VALIDATION_RULES = [
+    INPUT_VALIDATION_RULES.required,
+    INPUT_VALIDATION_RULES.min,
+    INPUT_VALIDATION_RULES.max,
+    INPUT_VALIDATION_RULES.minLength,
+    INPUT_VALIDATION_RULES.maxLength,
+    INPUT_VALIDATION_RULES.pattern,
+    INPUT_VALIDATION_RULES.validate,
+];
+const FORM_ERROR_TYPE = 'form';
 const ROOT_ERROR_TYPE = 'root';
 const PROTOTYPE_KEYWORDS = ['__proto__', 'constructor', 'prototype'];
 
-var isDateObject = (value) => value instanceof Date;
-
-var isNullOrUndefined = (value) => value == null;
-
-const isObjectType = (value) => typeof value === 'object';
-var isObject = (value) => !isNullOrUndefined(value) &&
-    !Array.isArray(value) &&
-    isObjectType(value) &&
-    !isDateObject(value);
-
-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);
     }
+    const isBlobInstance = typeof Blob !== 'undefined' && data instanceof Blob;
     const isFileListInstance = typeof FileList !== 'undefined' && data instanceof FileList;
-    if (isWeb && (data instanceof Blob || isFileListInstance)) {
+    if (isWeb && (isBlobInstance || isFileListInstance)) {
         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));
@@ -106,6 +105,21 @@ var createSubject = () => {
     };
 };
 
+var isDateObject = (value) => value instanceof Date;
+
+var isNullOrUndefined = (value) => value == null;
+
+const isObjectType = (value) => typeof value === 'object';
+var isObject = (value) => !isNullOrUndefined(value) &&
+    !Array.isArray(value) &&
+    isObjectType(value) &&
+    !isDateObject(value);
+
+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);
@@ -163,16 +177,15 @@ function deepEqual(object1, object2, visited = new WeakMap()) {
 }
 
 function extractFormValues(fieldsState, formValues) {
-    const values = {};
+    const values = (Array.isArray(fieldsState) ? [] : {});
     for (const key in fieldsState) {
         if (fieldsState.hasOwnProperty(key)) {
             const fieldState = fieldsState[key];
             const fieldValue = formValues[key];
-            if (fieldState && isObject(fieldState) && fieldValue) {
-                const nestedFieldsState = extractFormValues(fieldState, fieldValue);
-                if (isObject(nestedFieldsState)) {
-                    values[key] = nestedFieldsState;
-                }
+            if (fieldState &&
+                (isObject(fieldState) || Array.isArray(fieldState)) &&
+                fieldValue) {
+                values[key] = extractFormValues(fieldState, fieldValue);
             }
             else if (fieldsState[key]) {
                 values[key] = fieldValue;
@@ -182,24 +195,6 @@ function extractFormValues(fieldsState, formValues) {
     return values;
 }
 
-const flatten = (obj) => {
-    const output = {};
-    for (const key of Object.keys(obj)) {
-        if (isObjectType(obj[key]) &&
-            obj[key] !== null &&
-            !isDateObject(obj[key])) {
-            const nested = flatten(obj[key]);
-            for (const nestedKey of Object.keys(nested)) {
-                output[`${key}.${nestedKey}`] = nested[nestedKey];
-            }
-        }
-        else {
-            output[key] = obj[key];
-        }
-    }
-    return output;
-};
-
 const IS_KEY_RE = /^\w*$/;
 var isKey = (value) => IS_KEY_RE.test(value);
 
@@ -226,6 +221,24 @@ var get = (object, path, defaultValue) => {
         : result;
 };
 
+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 isBoolean = (value) => typeof value === 'boolean';
 
 var isCheckBoxInput = (element) => element.type === 'checkbox';
@@ -281,7 +294,7 @@ var set = (object, path, value) => {
 };
 
 function baseGet(object, updatePath) {
-    const length = updatePath.slice(0, -1).length;
+    const length = updatePath.length - 1;
     let index = 0;
     while (index < length) {
         if (isNullOrUndefined(object)) {
@@ -328,6 +341,24 @@ function unset(object, path) {
     return object;
 }
 
+function isDirtyContainer(value) {
+    return Array.isArray(value) || isObject(value);
+}
+function collectDirtyFieldNames(dirtyTree, cachedDirtyFields, prefix = '', names = []) {
+    for (const key in dirtyTree) {
+        const path = prefix ? `${prefix}.${key}` : key;
+        const value = dirtyTree[key];
+        if (isDirtyContainer(value) &&
+            isDirtyContainer(get(cachedDirtyFields, path))) {
+            collectDirtyFieldNames(value, cachedDirtyFields, path, names);
+        }
+        else {
+            names.push(path);
+        }
+    }
+    return names;
+}
+
 var generateWatchOutput = (names, _names, formValues, isGlobal, defaultValue) => {
     if (isString(names)) {
         isGlobal && _names.watch.add(names);
@@ -335,7 +366,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;
@@ -353,12 +384,33 @@ var objectHasFunction = (data) => {
 function isTraversable(value) {
     return Array.isArray(value) || (isObject(value) && !objectHasFunction(value));
 }
-function markFieldsDirty(data, fields = {}) {
+function isRegisteredLeaf(fieldRef) {
+    return !!(fieldRef && '_f' in fieldRef);
+}
+function isEmptyDirtyContainer(value) {
+    return Array.isArray(value)
+        ? !value.some((item) => !isUndefined(item))
+        : !Object.keys(value).length;
+}
+function clearDirtyField(container, key) {
+    if (Array.isArray(container)) {
+        container[key] = undefined;
+    }
+    else {
+        delete container[key];
+    }
+}
+function markFieldsDirty(data, fields = {}, fieldRefs) {
     for (const key in data) {
         const value = data[key];
-        if (isTraversable(value)) {
+        const fieldRef = fieldRefs && fieldRefs[key];
+        if (isTraversable(value) &&
+            (!Array.isArray(value) || !isRegisteredLeaf(fieldRef))) {
             fields[key] = Array.isArray(value) ? [] : {};
-            markFieldsDirty(value, fields[key]);
+            markFieldsDirty(value, fields[key], fieldRef);
+            if (isEmptyDirtyContainer(fields[key])) {
+                clearDirtyField(fields, key);
+            }
         }
         else if (!isUndefined(value)) {
             fields[key] = true;
@@ -366,80 +418,80 @@ 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) {
+function getDirtyFields(data, formValues, dirtyFieldsFromValues, fieldRefs) {
     if (!dirtyFieldsFromValues) {
-        dirtyFieldsFromValues = markFieldsDirty(formValues);
+        dirtyFieldsFromValues = markFieldsDirty(formValues, {}, fieldRefs);
     }
     for (const key in data) {
         const value = data[key];
-        if (isTraversable(value)) {
+        const fieldRef = fieldRefs && fieldRefs[key];
+        if (isTraversable(value) &&
+            (!Array.isArray(value) || !isRegisteredLeaf(fieldRef))) {
             if (isUndefined(formValues) || isPrimitive(dirtyFieldsFromValues[key])) {
-                dirtyFieldsFromValues[key] = markFieldsDirty(value, Array.isArray(value) ? [] : {});
+                dirtyFieldsFromValues[key] = markFieldsDirty(value, Array.isArray(value) ? [] : {}, fieldRef);
             }
             else {
-                getDirtyFields(value, isNullOrUndefined(formValues) ? {} : formValues[key], dirtyFieldsFromValues[key]);
+                getDirtyFields(value, isNullOrUndefined(formValues) ? {} : formValues[key], dirtyFieldsFromValues[key], fieldRef);
+            }
+            if (isEmptyDirtyContainer(dirtyFieldsFromValues[key])) {
+                clearDirtyField(dirtyFieldsFromValues, key);
             }
         }
+        else if (deepEqual(value, formValues[key])) {
+            clearDirtyField(dirtyFieldsFromValues, key);
+        }
         else {
-            const formValue = formValues[key];
-            dirtyFieldsFromValues[key] = !deepEqual(value, formValue);
+            dirtyFieldsFromValues[key] = true;
         }
     }
-    return pruneDirtyFields(dirtyFieldsFromValues) || {};
+    return dirtyFieldsFromValues;
 }
 
 var getEventValue = (event) => isObject(event) && event.target
     ? isCheckBoxInput(event.target)
         ? event.target.checked
-        : event.target.value
+        : isFileInput(event.target)
+            ? event.target.files
+            : event.target.value
     : event;
 
+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;
+};
+
 const defaultResult = {
     value: false,
     isValid: false,
 };
 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 };
 };
 
 var getFieldValueAs = (value, { valueAsNumber, valueAsDate, setValueAs }) => isUndefined(value)
@@ -483,7 +535,7 @@ function getFieldValue(_f) {
     if (isCheckBoxInput(ref)) {
         return getCheckboxValue(_f.refs).value;
     }
-    return getFieldValueAs(isUndefined(ref.value) ? _f.ref.value : ref.value, _f);
+    return getFieldValueAs(ref.value, _f);
 }
 
 var getResolverOptions = (fieldsNames, _fields, criteriaMode, shouldUseNativeValidation) => {
@@ -540,10 +592,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);
 
@@ -563,27 +616,30 @@ var isWatched = (name, _names, isBlurEvent) => {
     return false;
 };
 
-const iterateFieldsByAction = (fields, action, fieldsNames, abortEarly) => {
+const iterateFieldsByAction = (fields, action, fieldsNames) => {
     for (const key of fieldsNames || Object.keys(fields)) {
-        const field = get(fields, key);
+        if (key === '_f') {
+            continue;
+        }
+        const field = fieldsNames ? get(fields, key) : fields[key];
         if (field) {
-            const { _f, ...currentField } = field;
+            const { _f } = field;
             if (_f) {
-                if (_f.refs && _f.refs[0] && action(_f.refs[0], key) && !abortEarly) {
+                if (_f.refs && _f.refs[0] && action(_f.refs[0], _f.name)) {
                     return true;
                 }
-                else if (_f.ref && action(_f.ref, _f.name) && !abortEarly) {
+                else if (_f.ref && action(_f.ref, _f.name)) {
                     return true;
                 }
                 else {
-                    if (iterateFieldsByAction(currentField, action)) {
-                        break;
+                    if (iterateFieldsByAction(field, action)) {
+                        return true;
                     }
                 }
             }
-            else if (isObject(currentField)) {
-                if (iterateFieldsByAction(currentField, action)) {
-                    break;
+            else if (isObject(field) || Array.isArray(field)) {
+                if (iterateFieldsByAction(field, action)) {
+                    return true;
                 }
             }
         }
@@ -593,7 +649,7 @@ const iterateFieldsByAction = (fields, action, fieldsNames, abortEarly) => {
 
 function schemaErrorLookup(errors, _fields, name) {
     const error = get(errors, name);
-    if (error || isKey(name)) {
+    if (error?.type || error?.message || Array.isArray(error)) {
         return {
             error,
             name,
@@ -628,8 +684,7 @@ function schemaErrorLookup(errors, _fields, name) {
 
 var shouldRenderFormState = (formStateData, _proxyFormState, updateFormState, isRoot) => {
     updateFormState(formStateData);
-    const { name, ...formState } = formStateData;
-    const keys = Object.keys(formState);
+    const keys = Object.keys(formStateData).filter((key) => key !== 'name');
     return (!keys.length ||
         (isRoot && keys.length >= Object.keys(_proxyFormState).length) ||
         keys.find((key) => _proxyFormState[key] ===
@@ -661,7 +716,12 @@ var skipValidation = (isBlurEvent, isTouched, isSubmitted, reValidateMode, mode)
     return true;
 };
 
-var unsetEmptyArray = (ref, name) => !compact(get(ref, name)).length && unset(ref, name);
+var unsetEmptyArray = (ref, name) => {
+    const array = get(ref, name);
+    !compact(array).length &&
+        !array?.root &&
+        unset(ref, name);
+};
 
 var updateFieldArrayRootError = (errors, error, name) => {
     const existingErrors = get(errors, name);
@@ -691,7 +751,7 @@ var getValueAndMessage = (validationData) => isObject(validationData) && !isRege
     };
 
 var validateField = async (field, disabledFieldNames, formValues, validateAllFieldCriteria, shouldUseNativeValidation, isFieldArray) => {
-    const { ref, refs, required, maxLength, minLength, min, max, pattern, validate, name, valueAsNumber, mount, } = field._f;
+    const { ref, refs, required, maxLength, minLength, min, max, pattern, validate, name, valueAsNumber, mount, _c, } = field._f;
     const inputValue = get(formValues, name);
     if (!mount || disabledFieldNames.has(name)) {
         return {};
@@ -701,7 +761,8 @@ var validateField = async (field, disabledFieldNames, formValues, validateAllFie
         if (shouldUseNativeValidation && inputRef.reportValidity) {
             const validityMessage = isBoolean(message) ? '' : message || '';
             if (refs) {
-                refs.forEach((ref) => ref.setCustomValidity(validityMessage));
+                refs.forEach((ref) => isFunction(ref.setCustomValidity) &&
+                    ref.setCustomValidity(validityMessage));
             }
             else {
                 inputRef.setCustomValidity(validityMessage);
@@ -716,7 +777,7 @@ var validateField = async (field, disabledFieldNames, formValues, validateAllFie
     const isEmpty = ((valueAsNumber || isFileInput(ref)) &&
         isUndefined(ref.value) &&
         isUndefined(inputValue)) ||
-        (isHTMLElement(ref) && ref.value === '') ||
+        (isHTMLElement(ref) && ref.value === '' && !_c) ||
         inputValue === '' ||
         (Array.isArray(inputValue) && !inputValue.length);
     const appendErrorsCurry = appendErrors.bind(null, name, validateAllFieldCriteria, error);
@@ -757,7 +818,9 @@ var validateField = async (field, disabledFieldNames, formValues, validateAllFie
         let exceedMin;
         const maxOutput = getValueAndMessage(max);
         const minOutput = getValueAndMessage(min);
-        if (!isNullOrUndefined(inputValue) && !isNaN(inputValue)) {
+        if (!isNullOrUndefined(inputValue) &&
+            !isDateObject(inputValue) &&
+            !isNaN(inputValue)) {
             const valueNumber = ref.valueAsNumber ||
                 (inputValue ? +inputValue : inputValue);
             if (!isNullOrUndefined(maxOutput.value)) {
@@ -854,7 +917,9 @@ var validateField = async (field, disabledFieldNames, formValues, validateAllFie
                         ...validateError,
                         ...appendErrorsCurry(key, validateError.message),
                     };
-                    setCustomValidity(validateError.message);
+                    if (!validateAllFieldCriteria) {
+                        setCustomValidity(validateError.message);
+                    }
                     if (validateAllFieldCriteria) {
                         error[name] = validationResult;
                     }
@@ -871,7 +936,8 @@ var validateField = async (field, disabledFieldNames, formValues, validateAllFie
             }
         }
     }
-    setCustomValidity(true);
+    const fieldError = error[name];
+    setCustomValidity(fieldError ? fieldError.message : true);
     return error;
 };
 
@@ -880,7 +946,14 @@ const defaultOptions = {
     reValidateMode: VALIDATION_MODE.onChange,
     shouldFocusError: true,
 };
-const FORM_ERROR_TYPE = 'form';
+const updateDirtyFields = (dirtyFields, nextDirtyFields) => {
+    for (const key in dirtyFields) {
+        if (!(key in nextDirtyFields)) {
+            delete dirtyFields[key];
+        }
+    }
+    Object.assign(dirtyFields, nextDirtyFields);
+};
 const DEFAULT_FORM_STATE = {
     submitCount: 0,
     isDirty: false,
@@ -914,6 +987,7 @@ function createFormControl(props = {}) {
         : cloneObject(_defaultValues);
     let _state = {
         action: false,
+        actionArrayLengths: new Map(),
         mount: false,
         watch: false,
         keepIsValid: false,
@@ -926,8 +1000,8 @@ function createFormControl(props = {}) {
         watch: new Set(),
         registerName: new Set(),
     };
-    let delayErrorCallback;
-    let timer = 0;
+    const delayErrorCallbacks = {};
+    const timers = {};
     let _valuesSubscriberCount = 0;
     let _validationModeBeforeSubmit = getValidationModes(_options.mode);
     let _validationModeAfterSubmit = getValidationModes(_options.reValidateMode);
@@ -946,27 +1020,40 @@ function createFormControl(props = {}) {
     let _proxySubscribeFormState = {
         ..._proxyFormState,
     };
+    const _isTracked = (...keys) => keys.some((key) => _proxyFormState[key] || _proxySubscribeFormState[key]);
     const _subjects = {
         array: createSubject(),
         state: createSubject(),
     };
-    const shouldDisplayAllAssociatedErrors = _options.criteriaMode === VALIDATION_MODE.all;
-    const debounce = (callback) => (wait) => {
-        clearTimeout(timer);
-        timer = setTimeout(callback, wait);
+    let _setValidCallId = 0;
+    let _resetCallId = 0;
+    let shouldDisplayAllAssociatedErrors = _options.criteriaMode === VALIDATION_MODE.all;
+    const debounce = (name, callback) => (wait) => {
+        clearTimeout(timers[name]);
+        timers[name] = setTimeout(callback, wait);
+    };
+    const cancelDelayedError = (name) => {
+        clearTimeout(timers[name]);
+        delete timers[name];
+        delete delayErrorCallbacks[name];
+    };
+    const cancelDelayedErrorTree = (name) => {
+        cancelDelayedError(name);
+        const prefix = `${name}.`;
+        for (const key of Object.keys(delayErrorCallbacks)) {
+            key.startsWith(prefix) && cancelDelayedError(key);
+        }
     };
     const _setValid = async (shouldUpdateValid) => {
         if (_state.keepIsValid) {
             return;
         }
-        if (!_options.disabled &&
-            (_proxyFormState.isValid ||
-                _proxySubscribeFormState.isValid ||
-                shouldUpdateValid)) {
+        if (!_options.disabled && (_isTracked('isValid') || shouldUpdateValid)) {
+            const callId = ++_setValidCallId;
             let isValid;
             if (_options.resolver) {
                 isValid = isEmptyObject((await _runSchema()).errors);
-                _updateIsValidating();
+                callId === _setValidCallId && _updateIsValidating();
             }
             else {
                 isValid = await executeBuiltInValidation({
@@ -975,7 +1062,7 @@ function createFormControl(props = {}) {
                     eventType: EVENTS.VALID,
                 });
             }
-            if (isValid !== _formState.isValid) {
+            if (callId === _setValidCallId && isValid !== _formState.isValid) {
                 _subjects.state.next({
                     isValid,
                 });
@@ -983,12 +1070,8 @@ function createFormControl(props = {}) {
         }
     };
     const _updateIsValidating = (names, isValidating) => {
-        if (!_options.disabled &&
-            (_proxyFormState.isValidating ||
-                _proxyFormState.validatingFields ||
-                _proxySubscribeFormState.isValidating ||
-                _proxySubscribeFormState.validatingFields)) {
-            (names || Array.from(_names.mount)).forEach((name) => {
+        if (!_options.disabled && _isTracked('isValidating', 'validatingFields')) {
+            (names || _names.mount).forEach((name) => {
                 if (name) {
                     isValidating
                         ? set(_formState.validatingFields, name, isValidating)
@@ -1002,35 +1085,50 @@ function createFormControl(props = {}) {
         }
     };
     const _updateDirtyFields = () => {
-        _formState.dirtyFields = getDirtyFields(_defaultValues, _formValues);
+        _formState.dirtyFields = getDirtyFields(_defaultValues, _formValues, undefined, _fields);
     };
     const _setFieldArray = (name, values = [], method, args, shouldSetValues = true, shouldUpdateFieldsAndState = true) => {
         if (args && method && !_options.disabled) {
             _state.action = true;
-            if (shouldUpdateFieldsAndState && Array.isArray(get(_fields, name))) {
-                const fieldValues = method(get(_fields, name), args.argA, args.argB);
+            const fields = get(_fields, name);
+            if (!_state.actionArrayLengths.has(name)) {
+                _state.actionArrayLengths.set(name, Array.isArray(fields) ? fields.length : 0);
+            }
+            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 errors = method(get(_formState.errors, name), args.argA, args.argB);
+            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) {
+                    errors.root = rootError;
+                }
                 shouldSetValues && set(_formState.errors, name, errors);
                 unsetEmptyArray(_formState.errors, name);
             }
-            if ((_proxyFormState.touchedFields ||
-                _proxySubscribeFormState.touchedFields) &&
-                shouldUpdateFieldsAndState &&
-                Array.isArray(get(_formState.touchedFields, name))) {
-                const touchedFields = method(get(_formState.touchedFields, name), args.argA, args.argB);
+            const touchedFieldsArray = get(_formState.touchedFields, name);
+            const shouldUpdateTouchedFields = shouldUpdateFieldsAndState && Array.isArray(touchedFieldsArray);
+            if (shouldUpdateTouchedFields) {
+                const touchedFields = method(touchedFieldsArray, args.argA, args.argB);
                 shouldSetValues && set(_formState.touchedFields, name, touchedFields);
             }
-            if (_proxyFormState.dirtyFields || _proxySubscribeFormState.dirtyFields) {
+            const dirtyFieldsArray = get(_formState.dirtyFields, name);
+            if (shouldUpdateFieldsAndState && Array.isArray(dirtyFieldsArray)) {
+                const dirtyFields = method(dirtyFieldsArray, args.argA, args.argB) || dirtyFieldsArray;
+                shouldSetValues && set(_formState.dirtyFields, name, dirtyFields);
+            }
+            if (_isTracked('dirtyFields')) {
                 _updateDirtyFields();
             }
             _subjects.state.next({
                 name,
                 isDirty: _getDirty(name, values),
                 dirtyFields: _formState.dirtyFields,
+                ...(shouldUpdateTouchedFields && {
+                    touchedFields: _formState.touchedFields,
+                }),
                 errors: _formState.errors,
                 isValid: _formState.isValid,
             });
@@ -1047,11 +1145,14 @@ function createFormControl(props = {}) {
         });
     };
     const _setErrors = (errors) => {
+        Object.keys(delayErrorCallbacks).forEach(cancelDelayedError);
+        const hasErrors = !isEmptyObject(errors);
         _formState.errors = errors;
         _subjects.state.next({
             errors: _formState.errors,
-            isValid: false,
+            ...(hasErrors ? { isValid: false } : {}),
         });
+        !hasErrors && _state.mount && _setValid();
     };
     const hasExplicitNullIntermediate = (name) => {
         const segments = isKey(name) ? [name] : stringToPath(name);
@@ -1069,10 +1170,46 @@ function createFormControl(props = {}) {
         }
         return false;
     };
+    const isStaleArrayField = (name) => {
+        if (!_state.actionArrayLengths.size) {
+            return false;
+        }
+        const segments = isKey(name) ? [name] : stringToPath(name);
+        let node = _formValues;
+        let path = '';
+        let ownerDepth = -1;
+        let ownerPreActionLength = 0;
+        for (let i = 0; i < segments.length; i++) {
+            if (isNullOrUndefined(node)) {
+                return false;
+            }
+            const key = segments[i];
+            path = path ? `${path}.${key}` : key;
+            if (Array.isArray(node) && +key >= node.length) {
+                return ownerDepth === -1
+                    ? false
+                    : i === ownerDepth
+                        ? +key < ownerPreActionLength
+                        : true;
+            }
+            if (_state.actionArrayLengths.has(path)) {
+                ownerDepth = i + 1;
+                ownerPreActionLength = _state.actionArrayLengths.get(path);
+            }
+            node = node[key];
+            if (isUndefined(node) &&
+                ownerDepth !== -1 &&
+                i > ownerDepth &&
+                +segments[ownerDepth] < ownerPreActionLength) {
+                return true;
+            }
+        }
+        return false;
+    };
     const updateValidAndValue = (name, shouldSkipSetValueAs, value, ref) => {
         const field = get(_fields, name);
         if (field) {
-            if (hasExplicitNullIntermediate(name)) {
+            if (hasExplicitNullIntermediate(name) || isStaleArrayField(name)) {
                 return;
             }
             const wasUnsetInFormValues = isUndefined(get(_formValues, name));
@@ -1083,10 +1220,16 @@ function createFormControl(props = {}) {
                 ? set(_formValues, name, shouldSkipSetValueAs ? defaultValue : getFieldValue(field._f))
                 : setFieldValue(name, defaultValue);
             if (_state.mount && !_state.action) {
-                _setValid();
+                if (_options.resolver &&
+                    _isTracked('isValidating', 'validatingFields')) {
+                    Promise.resolve().then(() => _setValid());
+                }
+                else {
+                    _setValid();
+                }
                 if (wasUnsetInFormValues &&
                     _formState.isDirty &&
-                    (_proxyFormState.isDirty || _proxySubscribeFormState.isDirty)) {
+                    _isTracked('isDirty')) {
                     const isDirty = _getDirty();
                     if (!isDirty) {
                         _formState.isDirty = false;
@@ -1108,10 +1251,12 @@ function createFormControl(props = {}) {
         const output = {
             name,
         };
-        if (!_options.disabled) {
+        // an explicit programmatic update (e.g. setValue with shouldDirty: true)
+        // opts into dirty tracking even when the form is disabled
+        if (!_options.disabled || shouldDirty === true) {
             if (!isBlurEvent || shouldDirty) {
                 const isCurrentFieldPristine = deepEqual(get(_defaultValues, name), fieldValue);
-                if (_proxyFormState.isDirty || _proxySubscribeFormState.isDirty) {
+                if (_isTracked('isDirty')) {
                     isPreviousDirty = _formState.isDirty;
                     _formState.isDirty = output.isDirty =
                         !isCurrentFieldPristine || _getDirty();
@@ -1119,7 +1264,7 @@ function createFormControl(props = {}) {
                 }
                 isPreviousDirty = !!get(_formState.dirtyFields, name);
                 if (isCurrentFieldPristine !== _formState.isDirty) {
-                    _formState.dirtyFields = getDirtyFields(_defaultValues, _formValues);
+                    updateDirtyFields(_formState.dirtyFields, getDirtyFields(_defaultValues, _formValues, undefined, _fields));
                 }
                 else {
                     isCurrentFieldPristine
@@ -1129,8 +1274,7 @@ function createFormControl(props = {}) {
                 output.dirtyFields = _formState.dirtyFields;
                 shouldUpdateField =
                     shouldUpdateField ||
-                        ((_proxyFormState.dirtyFields ||
-                            _proxySubscribeFormState.dirtyFields) &&
+                        (_isTracked('dirtyFields') &&
                             isPreviousDirty !== !isCurrentFieldPristine);
             }
             if (isBlurEvent) {
@@ -1140,8 +1284,7 @@ function createFormControl(props = {}) {
                     output.touchedFields = _formState.touchedFields;
                     shouldUpdateField =
                         shouldUpdateField ||
-                            ((_proxyFormState.touchedFields ||
-                                _proxySubscribeFormState.touchedFields) &&
+                            (_isTracked('touchedFields') &&
                                 isPreviousFieldTouched !== isBlurEvent);
                 }
             }
@@ -1151,16 +1294,15 @@ function createFormControl(props = {}) {
     };
     const shouldRenderByError = (name, isValid, error, fieldState) => {
         const previousFieldError = get(_formState.errors, name);
-        const shouldUpdateValid = (_proxyFormState.isValid || _proxySubscribeFormState.isValid) &&
+        const shouldUpdateValid = _isTracked('isValid') &&
             isBoolean(isValid) &&
             _formState.isValid !== isValid;
         if (_options.delayError && error) {
-            delayErrorCallback = debounce(() => updateErrors(name, error));
-            delayErrorCallback(_options.delayError);
+            delayErrorCallbacks[name] = debounce(name, () => updateErrors(name, error));
+            delayErrorCallbacks[name](_options.delayError);
         }
         else {
-            clearTimeout(timer);
-            delayErrorCallback = null;
+            cancelDelayedError(name);
             error
                 ? set(_formState.errors, name, error)
                 : unset(_formState.errors, name);
@@ -1175,10 +1317,6 @@ function createFormControl(props = {}) {
                 errors: _formState.errors,
                 name,
             };
-            _formState = {
-                ..._formState,
-                ...updatedFormState,
-            };
             _subjects.state.next(updatedFormState);
         }
     };
@@ -1187,55 +1325,76 @@ function createFormControl(props = {}) {
         return await _options.resolver(_formValues, _options.context, getResolverOptions(name || _names.mount, _fields, _options.criteriaMode, _options.shouldUseNativeValidation));
     };
     const executeSchemaAndUpdateState = async (names) => {
+        const resetCallId = _resetCallId;
         const { errors } = await _runSchema(names);
+        if (resetCallId !== _resetCallId) {
+            return errors;
+        }
         _updateIsValidating(names);
         if (names) {
             for (const name of names) {
                 const error = get(errors, name);
-                error
-                    ? _names.array.has(name) &&
-                        isObject(error) &&
-                        !Object.keys(error).some((key) => !Number.isNaN(Number(key)))
-                        ? updateFieldArrayRootError(_formState.errors, { [name]: error }, name)
-                        : set(_formState.errors, name, error)
-                    : unset(_formState.errors, name);
+                cancelDelayedErrorTree(name);
+                const isFieldArrayRootError = _names.array.has(name) &&
+                    isObject(error) &&
+                    !Object.keys(error).some((key) => !Number.isNaN(Number(key)));
+                const field = get(_fields, name);
+                const hasNestedFields = isObject(field) && Object.keys(field).some((key) => key !== '_f');
+                isFieldArrayRootError
+                    ? updateFieldArrayRootError(_formState.errors, { [name]: error }, name)
+                    : error?.type ||
+                        error?.message ||
+                        Array.isArray(error) ||
+                        (isObject(error) && hasNestedFields)
+                        ? set(_formState.errors, name, error)
+                        : unset(_formState.errors, name);
             }
             _formState.errors = { ..._formState.errors };
         }
         else {
+            Object.keys(delayErrorCallbacks).forEach(cancelDelayedError);
             _formState.errors = errors;
         }
         return errors;
     };
     const validateForm = async ({ name, eventType, }) => {
-        if (props.validate) {
-            const result = await props.validate({
+        if (_options.validate) {
+            const resetCallId = _resetCallId;
+            const result = await _options.validate({
                 formValues: _formValues,
                 formState: _formState,
                 name,
                 eventType,
             });
+            if (resetCallId !== _resetCallId) {
+                return true;
+            }
             if (isObject(result)) {
+                let isValid = true;
+                clearErrors(FORM_ERROR_TYPE);
                 for (const key in result) {
                     const error = result[key];
                     if (error) {
+                        isValid = false;
                         setError(`${FORM_ERROR_TYPE}.${key}`, {
                             message: isString(error.message) ? error.message : '',
                             type: error.type || INPUT_VALIDATION_RULES.validate,
                         });
                     }
                 }
+                return isValid;
             }
             else if (isString(result) || !result) {
                 setError(FORM_ERROR_TYPE, {
                     message: result || '',
                     type: INPUT_VALIDATION_RULES.validate,
                 });
+                return false;
             }
             else {
                 clearErrors(FORM_ERROR_TYPE);
+                return true;
             }
-            return result;
         }
         return true;
     };
@@ -1243,7 +1402,8 @@ function createFormControl(props = {}) {
         valid: true,
         runRootValidation: false,
     }, }) => {
-        if (props.validate) {
+        const resetCallId = _resetCallId;
+        if (_options.validate && !context.runRootValidation) {
             context.runRootValidation = true;
             const result = await validateForm({
                 name,
@@ -1263,14 +1423,14 @@ function createFormControl(props = {}) {
                 if (_f) {
                     const isFieldArrayRoot = _names.array.has(_f.name);
                     const isPromiseFunction = field._f && hasPromiseValidation(field._f);
-                    const shouldTrackIsValidatingState = _proxyFormState.validatingFields ||
-                        _proxyFormState.isValidating ||
-                        _proxySubscribeFormState.validatingFields ||
-                        _proxySubscribeFormState.isValidating;
+                    const shouldTrackIsValidatingState = _isTracked('isValidating', 'validatingFields');
                     if (isPromiseFunction && shouldTrackIsValidatingState) {
                         _updateIsValidating([_f.name], true);
                     }
                     const fieldError = await validateField(field, _names.disabled, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation && !onlyCheckValid, isFieldArrayRoot);
+                    if (resetCallId !== _resetCallId) {
+                        return context.valid;
+                    }
                     if (isPromiseFunction && shouldTrackIsValidatingState) {
                         _updateIsValidating([_f.name]);
                     }
@@ -1280,12 +1440,14 @@ function createFormControl(props = {}) {
                             break;
                         }
                     }
-                    !onlyCheckValid &&
-                        (get(fieldError, _f.name)
+                    if (!onlyCheckValid) {
+                        cancelDelayedError(_f.name);
+                        get(fieldError, _f.name)
                             ? isFieldArrayRoot
                                 ? updateFieldArrayRootError(_formState.errors, fieldError, _f.name)
                                 : set(_formState.errors, _f.name, fieldError[_f.name])
-                            : unset(_formState.errors, _f.name));
+                            : unset(_formState.errors, _f.name);
+                    }
                     if (props.shouldUseNativeValidation && fieldError[_f.name]) {
                         break;
                     }
@@ -1313,20 +1475,17 @@ function createFormControl(props = {}) {
         }
         _names.unMount = new Set();
     };
-    const _getDirty = (name, data) => !_options.disabled &&
-        (name && data && set(_formValues, name, data),
-            !deepEqual(_state.mount ? _formValues : _defaultValues, _defaultValues));
+    const _getDirty = (name, data) => (name && data && set(_formValues, name, data),
+        !deepEqual(_state.mount ? _formValues : _defaultValues, _defaultValues));
     const _getWatch = (names, defaultValue, isGlobal) => generateWatchOutput(names, _names, {
         ...(_state.mount
             ? _formValues
-            : isUndefined(defaultValue)
+            : isUndefined(defaultValue) || isString(names)
                 ? _defaultValues
-                : isString(names)
-                    ? { [names]: defaultValue }
-                    : defaultValue),
+                : 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, skipRender = false) => {
+    const setFieldValue = (name, value, options = {}, skipClone = false, skipRender = false, skipValueRender = false) => {
         const field = get(_fields, name);
         let fieldValue = value;
         if (field) {
@@ -1364,7 +1523,7 @@ function createFormControl(props = {}) {
                 }
                 else {
                     fieldReference.ref.value = fieldValue;
-                    if (!fieldReference.ref.type && !skipRender) {
+                    if (!fieldReference.ref.type && !skipRender && !skipValueRender) {
                         _subjects.state.next({
                             name,
                             values: skipClone ? _formValues : cloneObject(_formValues),
@@ -1374,13 +1533,36 @@ function createFormControl(props = {}) {
             }
         }
         (options.shouldDirty || options.shouldTouch) &&
-            updateTouchAndDirty(name, fieldValue, options.shouldTouch, options.shouldDirty, !skipRender);
-        options.shouldValidate && trigger(name);
+            updateTouchAndDirty(name, field &&
+                field._f &&
+                !field._f.disabled &&
+                (field._f.valueAsNumber ||
+                    field._f.valueAsDate ||
+                    field._f.setValueAs)
+                ? getFieldValueAs(value, field._f)
+                : fieldValue, options.shouldTouch, options.shouldDirty, !skipRender);
+        options.shouldValidate &&
+            trigger(name, {
+                delayError: options.delayError,
+            });
+        if (options.shouldValidate &&
+            field &&
+            field._f &&
+            field._f.deps &&
+            (!Array.isArray(field._f.deps) || field._f.deps.length > 0)) {
+            trigger(field._f.deps);
+        }
     };
-    const setFieldValues = (name, value, options, skipClone = false, skipRender = false) => {
+    const setFieldValues = (name, value, options, skipClone = false, skipRender = false, skipValueRender = false) => {
+        if (_names.array.has(name)) {
+            _subjects.array.next({
+                name,
+                values: skipClone ? _formValues : cloneObject(_formValues),
+            });
+        }
         for (const fieldKey in value) {
             if (!value.hasOwnProperty(fieldKey)) {
-                return;
+                continue;
             }
             const fieldValue = value[fieldKey];
             const fieldName = name + '.' + fieldKey;
@@ -1389,8 +1571,8 @@ function createFormControl(props = {}) {
                 isObject(fieldValue) ||
                 (field && !field._f)) &&
                 !isDateObject(fieldValue)
-                ? setFieldValues(fieldName, fieldValue, options, skipClone, skipRender)
-                : setFieldValue(fieldName, fieldValue, options, skipClone, skipRender);
+                ? setFieldValues(fieldName, fieldValue, options, skipClone, skipRender, skipValueRender)
+                : setFieldValue(fieldName, fieldValue, options, skipClone, skipRender, skipValueRender);
         }
     };
     const _setValue = (name, value, options, skipClone, skipStateEmit = false) => {
@@ -1407,11 +1589,7 @@ function createFormControl(props = {}) {
                 name,
                 values: skipClone ? _formValues : cloneObject(_formValues),
             });
-            if ((_proxyFormState.isDirty ||
-                _proxyFormState.dirtyFields ||
-                _proxySubscribeFormState.isDirty ||
-                _proxySubscribeFormState.dirtyFields) &&
-                options.shouldDirty) {
+            if (_isTracked('isDirty', 'dirtyFields') && options.shouldDirty) {
                 _updateDirtyFields();
                 if (!skipStateEmit) {
                     _subjects.state.next({
@@ -1421,15 +1599,20 @@ function createFormControl(props = {}) {
                     });
                 }
             }
+            options.shouldValidate &&
+                trigger(name, {
+                    delayError: options.delayError,
+                });
         }
         else {
             const isEmpty = (Array.isArray(cloneValue) && !cloneValue.length) ||
                 isEmptyObject(cloneValue);
+            const skipValueRender = !isValueUnchanged && !skipStateEmit;
             if (!field || field._f || isNullOrUndefined(cloneValue) || isEmpty) {
-                setFieldValue(name, cloneValue, options, skipClone, skipStateEmit);
+                setFieldValue(name, cloneValue, options, skipClone, skipStateEmit, skipValueRender);
             }
             else {
-                setFieldValues(name, cloneValue, options, skipClone, skipStateEmit);
+                setFieldValues(name, cloneValue, options, skipClone, skipStateEmit, skipValueRender);
             }
         }
         if (!isValueUnchanged && !skipStateEmit) {
@@ -1440,6 +1623,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);
@@ -1452,10 +1640,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({
@@ -1489,18 +1676,19 @@ function createFormControl(props = {}) {
                 : getEventValue(event);
             const isBlurEvent = event.type === EVENTS.BLUR || event.type === EVENTS.FOCUS_OUT;
             const hasNoValidationEffect = !hasValidation(field._f) &&
-                !props.validate &&
+                !_options.validate &&
                 !_options.resolver &&
                 !get(_formState.errors, name) &&
                 !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);
+            set(_formValues, name, cloneObject(fieldValue));
             if (isBlurEvent) {
                 if (!target || !target.readOnly) {
                     field._f.onBlur && field._f.onBlur(event);
-                    delayErrorCallback && delayErrorCallback(0);
+                    const pendingDelayError = delayErrorCallbacks[name];
+                    pendingDelayError && pendingDelayError(0);
                 }
             }
             else if (field._f.onChange) {
@@ -1518,7 +1706,7 @@ function createFormControl(props = {}) {
                 });
             if (shouldSkipValidation) {
                 if ((!hasNoValidationEffect || !_formState.isValid) &&
-                    (_proxyFormState.isValid || _proxySubscribeFormState.isValid)) {
+                    _isTracked('isValid')) {
                     if (_options.mode === 'onBlur') {
                         if (isBlurEvent) {
                             _setValid();
@@ -1531,7 +1719,7 @@ function createFormControl(props = {}) {
                 return (shouldRender &&
                     _subjects.state.next({ name, ...(watched ? {} : fieldState) }));
             }
-            if (!_options.resolver && props.validate) {
+            if (!_options.resolver && _options.validate) {
                 await validateForm({
                     name: name,
                     eventType: event.type,
@@ -1539,7 +1727,11 @@ function createFormControl(props = {}) {
             }
             !isBlurEvent && watched && _subjects.state.next({ ..._formState });
             if (_options.resolver) {
+                const resetCallId = _resetCallId;
                 const { errors } = await _runSchema([name]);
+                if (resetCallId !== _resetCallId) {
+                    return;
+                }
                 _updateIsValidating([name]);
                 _updateIsFieldValueUpdated(fieldValue);
                 if (!isFieldValueUpdated) {
@@ -1553,22 +1745,28 @@ function createFormControl(props = {}) {
                 isValid = isEmptyObject(errors);
             }
             else {
+                const resetCallId = _resetCallId;
                 _updateIsValidating([name], true);
                 error = (await validateField(field, _names.disabled, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation))[name];
+                if (resetCallId !== _resetCallId) {
+                    return;
+                }
                 _updateIsValidating([name]);
                 _updateIsFieldValueUpdated(fieldValue);
                 if (isFieldValueUpdated) {
                     if (error) {
                         isValid = false;
                     }
-                    else if (_proxyFormState.isValid ||
-                        _proxySubscribeFormState.isValid) {
+                    else if (_isTracked('isValid')) {
                         isValid = await executeBuiltInValidation({
                             fields: _fields,
                             onlyCheckValid: true,
                             name: name,
                             eventType: event.type,
                         });
+                        if (resetCallId !== _resetCallId) {
+                            return;
+                        }
                     }
                 }
             }
@@ -1592,11 +1790,15 @@ function createFormControl(props = {}) {
         let validationResult;
         const fieldNames = convertToArrayPayload(name);
         if (_options.resolver) {
+            const resetCallId = _resetCallId;
             const errors = await executeSchemaAndUpdateState(isUndefined(name) ? name : fieldNames);
             isValid = isEmptyObject(errors);
             validationResult = name
                 ? !fieldNames.some((name) => get(errors, name))
                 : isValid;
+            if (resetCallId !== _resetCallId) {
+                return validationResult;
+            }
         }
         else if (name) {
             validationResult = (await Promise.all(fieldNames.map(async (fieldName) => {
@@ -1615,13 +1817,32 @@ function createFormControl(props = {}) {
                 eventType: EVENTS.TRIGGER,
             });
         }
+        if (options.delayError && _options.delayError && isString(name)) {
+            const error = get(_formState.errors, name);
+            if (error) {
+                unset(_formState.errors, name);
+                delayErrorCallbacks[name] = debounce(name, () => updateErrors(name, error));
+                delayErrorCallbacks[name](_options.delayError);
+            }
+            else {
+                cancelDelayedError(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) &&
-                    isValid !== _formState.isValid)
+                (_isTracked('isValid') && isValid !== _formState.isValid)
                 ? {}
                 : { name }),
             ...(_options.resolver || !name ? { isValid } : {}),
+            ...(options.shouldTouch && _isTracked('touchedFields')
+                ? { touchedFields: _formState.touchedFields }
+                : {}),
             errors: _formState.errors,
         });
         options.shouldFocus &&
@@ -1642,18 +1863,28 @@ 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(targetFormState.validatingFields, name),
+            isTouched: !!get(targetFormState.touchedFields, name),
+        };
+    };
     const clearErrors = (name) => {
         const names = name ? convertToArrayPayload(name) : undefined;
-        names?.forEach((inputName) => unset(_formState.errors, inputName));
         if (names) {
             names.forEach((inputName) => {
+                cancelDelayedErrorTree(inputName);
+                unset(_formState.errors, inputName);
                 _subjects.state.next({
                     name: inputName,
                     errors: _formState.errors,
@@ -1661,15 +1892,18 @@ function createFormControl(props = {}) {
             });
         }
         else {
+            Object.keys(delayErrorCallbacks).forEach(cancelDelayedError);
+            _formState.errors = {};
             _subjects.state.next({
-                errors: {},
+                errors: _formState.errors,
             });
         }
     };
     const setError = (name, error, options) => {
+        cancelDelayedErrorTree(name);
         const ref = (get(_fields, name, { _f: {} })._f || {}).ref;
         const currentError = get(_formState.errors, name) || {};
-        const { ref: currentRef, message, type, ...restOfErrorTree } = currentError;
+        const { ref: currentRef, message, type, types, ...restOfErrorTree } = currentError;
         set(_formState.errors, name, {
             ...restOfErrorTree,
             ...error,
@@ -1753,11 +1987,15 @@ function createFormControl(props = {}) {
         for (const fieldName of name ? convertToArrayPayload(name) : _names.mount) {
             _names.mount.delete(fieldName);
             _names.array.delete(fieldName);
+            _names.disabled.delete(fieldName);
             if (!options.keepValue) {
                 unset(_fields, fieldName);
                 unset(_formValues, fieldName);
             }
-            !options.keepError && unset(_formState.errors, fieldName);
+            if (!options.keepError) {
+                cancelDelayedErrorTree(fieldName);
+                unset(_formState.errors, fieldName);
+            }
             !options.keepDirty && unset(_formState.dirtyFields, fieldName);
             !options.keepTouched && unset(_formState.touchedFields, fieldName);
             !options.keepIsValidating &&
@@ -1766,12 +2004,16 @@ 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.keepIsValidating
+                ? {}
+                : { isValidating: !isEmptyObject(_formState.validatingFields) }),
         });
         !options.keepIsValid && _setValid();
     };
@@ -1800,6 +2042,14 @@ function createFormControl(props = {}) {
             },
         });
         _names.mount.add(name);
+        if (field && field._f) {
+            const nextField = get(_fields, name);
+            for (const rule of REGISTER_VALIDATION_RULES) {
+                if (!(rule in options)) {
+                    delete nextField._f[rule];
+                }
+            }
+        }
         if (field && !shouldRevalidateRemount) {
             _setDisabledField({
                 disabled: isBoolean(options.disabled)
@@ -1846,20 +2096,23 @@ function createFormControl(props = {}) {
                         : fieldRef === field._f.ref) {
                         return;
                     }
+                    const newField = {
+                        ...field._f,
+                    };
+                    if (radioOrCheckbox) {
+                        newField.refs = [
+                            ...refs.filter(live),
+                            fieldRef,
+                            ...(Array.isArray(get(_defaultValues, name)) ? [{}] : []),
+                        ];
+                        newField.ref = { type: fieldRef.type, name };
+                    }
+                    else {
+                        newField.ref = fieldRef;
+                        delete newField.refs;
+                    }
                     set(_fields, name, {
-                        _f: {
-                            ...field._f,
-                            ...(radioOrCheckbox
-                                ? {
-                                    refs: [
-                                        ...refs.filter(live),
-                                        fieldRef,
-                                        ...(Array.isArray(get(_defaultValues, name)) ? [{}] : []),
-                                    ],
-                                    ref: { type: fieldRef.type, name },
-                                }
-                                : { ref: fieldRef }),
-                        },
+                        _f: newField,
                     });
                     updateValidAndValue(name, false, undefined, fieldRef);
                 }
@@ -1891,10 +2144,11 @@ function createFormControl(props = {}) {
                         });
                     }
                 }
-            }, 0, false);
+            }, 0);
         }
     };
     const handleSubmit = (onValid, onInvalid) => async (e) => {
+        let result = undefined;
         let onValidError = undefined;
         if (e) {
             e.preventDefault && e.preventDefault();
@@ -1906,29 +2160,38 @@ function createFormControl(props = {}) {
             isSubmitting: true,
         });
         if (_options.resolver) {
+            const resetCallId = _resetCallId;
             const { errors, values } = await _runSchema();
+            if (resetCallId !== _resetCallId) {
+                return;
+            }
             _updateIsValidating();
+            Object.keys(delayErrorCallbacks).forEach(cancelDelayedError);
             _formState.errors = errors;
             fieldValues = cloneObject(values);
         }
         else {
+            const resetCallId = _resetCallId;
             await executeBuiltInValidation({
                 fields: _fields,
                 eventType: EVENTS.SUBMIT,
             });
+            if (resetCallId !== _resetCallId) {
+                return;
+            }
+            unset(_formState.errors, ROOT_ERROR_TYPE);
         }
         if (_names.disabled.size) {
             for (const name of _names.disabled) {
                 unset(fieldValues, name);
             }
         }
-        unset(_formState.errors, ROOT_ERROR_TYPE);
         if (isEmptyObject(_formState.errors)) {
             _subjects.state.next({
                 errors: {},
             });
             try {
-                await onValid(fieldValues, e);
+                result = await onValid(fieldValues, e);
             }
             catch (error) {
                 onValidError = error;
@@ -1951,9 +2214,11 @@ function createFormControl(props = {}) {
         if (onValidError) {
             throw onValidError;
         }
+        return result;
     };
     const resetField = (name, options = {}) => {
         if (get(_fields, name)) {
+            unset(_formState.validatingFields, name);
             if (isUndefined(options.defaultValue)) {
                 setValue(name, cloneObject(get(_defaultValues, name)));
             }
@@ -1971,17 +2236,24 @@ function createFormControl(props = {}) {
                     : _getDirty();
             }
             if (!options.keepError) {
+                cancelDelayedErrorTree(name);
                 unset(_formState.errors, name);
-                _proxyFormState.isValid && _setValid();
+                _setValid();
             }
-            _subjects.state.next({ ..._formState });
+            _subjects.state.next({
+                ..._formState,
+                isValidating: !isEmptyObject(_formState.validatingFields),
+            });
         }
     };
     const _reset = (formValues, keepStateOptions = {}) => {
+        _resetCallId++;
         const updatedValues = formValues ? cloneObject(formValues) : _defaultValues;
         const cloneUpdatedValues = cloneObject(updatedValues);
         const isEmptyResetValues = isEmptyObject(formValues);
         const values = cloneUpdatedValues;
+        const fieldRefs = _fields;
+        Object.keys(delayErrorCallbacks).forEach(cancelDelayedError);
         if (!keepStateOptions.keepDefaultValues) {
             _defaultValues = updatedValues;
         }
@@ -1989,9 +2261,9 @@ function createFormControl(props = {}) {
             if (keepStateOptions.keepDirtyValues) {
                 const fieldsToCheck = new Set([
                     ..._names.mount,
-                    ...Object.keys(getDirtyFields(_defaultValues, _formValues)),
+                    ...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);
@@ -2070,6 +2342,7 @@ function createFormControl(props = {}) {
         _state.watch = !!_options.shouldUnregister;
         _state.keepIsValid = !!keepStateOptions.keepIsValid;
         _state.action = false;
+        _state.actionArrayLengths.clear();
         if (!keepStateOptions.keepErrors) {
             _formState.errors = {};
         }
@@ -2092,16 +2365,22 @@ function createFormControl(props = {}) {
                 ? {}
                 : keepStateOptions.keepDirtyValues
                     ? keepStateOptions.keepDefaultValues && _formValues
-                        ? getDirtyFields(_defaultValues, _formValues)
+                        ? getDirtyFields(_defaultValues, _formValues, undefined, fieldRefs)
                         : _formState.dirtyFields
                     : keepStateOptions.keepDefaultValues && formValues
-                        ? getDirtyFields(_defaultValues, formValues)
+                        ? getDirtyFields(_defaultValues, formValues, undefined, fieldRefs)
                         : keepStateOptions.keepDirty
                             ? _formState.dirtyFields
-                            : {},
+                            : keepStateOptions.keepValues
+                                ? getDirtyFields(_defaultValues, _formValues, undefined, fieldRefs)
+                                : {},
             touchedFields: keepStateOptions.keepTouched
                 ? _formState.touchedFields
                 : {},
+            ...(!keepStateOptions.keepIsValidating &&
+                (_formState.isValidating || !isEmptyObject(_formState.validatingFields))
+                ? { validatingFields: {}, isValidating: false }
+                : null),
             errors: keepStateOptions.keepErrors ? _formState.errors : {},
             isSubmitSuccessful: keepStateOptions.keepIsSubmitSuccessful
                 ? _formState.isSubmitSuccessful
@@ -2142,6 +2421,7 @@ function createFormControl(props = {}) {
             ...formState,
         };
     };
+    _subjects.state.subscribe({ next: _setFormState });
     const _resetDefaultValues = () => isFunction(_options.defaultValues) &&
         _options.defaultValues().then((values) => {
             reset(values, _options.resetOptions);
@@ -2152,7 +2432,7 @@ function createFormControl(props = {}) {
     const resetDefaultValues = (values, options = {}) => {
         _defaultValues = cloneObject(values);
         if (!options.keepDirty) {
-            const newDirtyFields = getDirtyFields(_defaultValues, _formValues);
+            const newDirtyFields = getDirtyFields(_defaultValues, _formValues, undefined, _fields);
             _formState.dirtyFields = newDirtyFields;
             _formState.isDirty = !isEmptyObject(newDirtyFields);
         }
@@ -2222,6 +2502,8 @@ function createFormControl(props = {}) {
                 };
                 _validationModeBeforeSubmit = getValidationModes(_options.mode);
                 _validationModeAfterSubmit = getValidationModes(_options.reValidateMode);
+                shouldDisplayAllAssociatedErrors =
+                    _options.criteriaMode === VALIDATION_MODE.all;
             },
         },
         subscribe,
@@ -2232,6 +2514,7 @@ function createFormControl(props = {}) {
         setValue,
         setValues,
         getValues,
+        getErrors,
         reset,
         resetField,
         resetDefaultValues,