@zythum02/fello-server 0.1.54 → 0.1.55

package/out/renderer/assets/{standard-schema-CGAs4bGi.js → standard-schema-BkTVIf7N.js}

@@ -1,4 +1,4 @@
-import { am as React } from "./index-BUwXrbHW.js";
+import { ap as React } from "./index-BeEZXfJZ.js";
 var isCheckBoxInput = (element) => element.type === "checkbox";
 var isFileInput = (element) => element.type === "file";
 var isDateObject = (value) => value instanceof Date;
@@ -6,22 +6,38 @@ var isNullOrUndefined = (value) => value == null;
 const isObjectType = (value) => typeof value === "object";
 var isObject = (value) => !isNullOrUndefined(value) && !Array.isArray(value) && isObjectType(value) && !isDateObject(value);
 var getEventValue = (event) => isObject(event) && event.target ? isCheckBoxInput(event.target) ? event.target.checked : isFileInput(event.target) ? event.target.files : 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 i2 = 0; i2 < segments.length - 1; i2++) {
+    const key = segments[i2];
+    formValues = formValues == null ? formValues : formValues[key];
+    defaultValues = defaultValues == null ? defaultValues : defaultValues[key];
+    if (formValues === null || defaultValues === null) {
+      return null;
+    }
+  }
+  return void 0;
+}
 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);
   }
+  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));
@@ -61,8 +77,6 @@ const PROTOTYPE_KEYWORDS = ["__proto__", "constructor", "prototype"];
 const IS_KEY_RE = /^\w*$/;
 var isKey = (value) => IS_KEY_RE.test(value);
 var isUndefined = (val) => val === void 0;
-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;
@@ -117,51 +131,9 @@ var getProxyFormState = (formState, control, localProxyFormState, isRoot = true)
   return result;
 };
 const useIsomorphicLayoutEffect = isWeb ? React.useLayoutEffect : React.useEffect;
-function useFormState(props) {
-  const formControl = useFormControlContext();
-  const { control = formControl, disabled, name, exact } = props || {};
-  const [formState, updateFormState] = React.useState(() => ({
-    ...control._formState,
-    defaultValues: control._defaultValues
-  }));
-  const _localProxyFormState = React.useRef({
-    isDirty: false,
-    isLoading: false,
-    dirtyFields: false,
-    touchedFields: false,
-    validatingFields: false,
-    isValidating: false,
-    isValid: false,
-    errors: false
-  });
-  useIsomorphicLayoutEffect(() => control._subscribe({
-    name,
-    formState: _localProxyFormState.current,
-    exact,
-    callback: (formState2) => {
-      !disabled && updateFormState({
-        ...control._formState,
-        ...formState2,
-        defaultValues: control._defaultValues
-      });
-    }
-  }), [name, disabled, exact]);
-  React.useEffect(() => {
-    _localProxyFormState.current.isValid && control._setValid(true);
-  }, [control]);
-  return React.useMemo(() => getProxyFormState(formState, control, _localProxyFormState.current, false), [formState, control]);
-}
-var isString = (value) => typeof value === "string";
-var generateWatchOutput = (names, _names, formValues, isGlobal, defaultValue) => {
-  if (isString(names)) {
-    isGlobal && _names.watch.add(names);
-    return get(formValues, names, defaultValue);
-  }
-  if (Array.isArray(names)) {
-    return names.map((fieldName) => (isGlobal && _names.watch.add(fieldName), get(formValues, fieldName)));
-  }
-  isGlobal && (_names.watchAll = true);
-  return formValues;
+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);
@@ -211,19 +183,101 @@ function deepEqual(object1, object2, visited = /* @__PURE__ */ new WeakMap()) {
   }
   return true;
 }
+function useResyncOnReconnect(getInitialValue) {
+  const _connected = React.useRef(false);
+  const _initialized = React.useRef(false);
+  const _prevValue = React.useRef(void 0);
+  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 || _initialized.current && _renderCount.current > 1)) {
+      const currentValue = getCurrentValue();
+      if (!deepEqual(_prevValue.current, currentValue)) {
+        setValue(currentValue);
+      }
+    }
+    _connected.current = true;
+  }, []);
+  const snapshot = React.useCallback((enabled, getCurrentValue) => {
+    if (enabled) {
+      _prevValue.current = cloneObject(getCurrentValue());
+    }
+  }, []);
+  return { resyncIfNeeded, snapshot };
+}
+function useFormState(props) {
+  const formControl = useFormControlContext();
+  const { control = formControl, disabled, name, exact } = props || {};
+  const getCurrentFormState = () => ({
+    ...control._formState,
+    defaultValues: control._defaultValues
+  });
+  const [formState, updateFormState] = React.useState(getCurrentFormState);
+  const _localProxyFormState = React.useRef({
+    isDirty: false,
+    isLoading: false,
+    dirtyFields: false,
+    touchedFields: false,
+    validatingFields: false,
+    isValidating: false,
+    isValid: false,
+    errors: false
+  });
+  const { resyncIfNeeded, snapshot } = useResyncOnReconnect(getCurrentFormState);
+  useIsomorphicLayoutEffect(() => {
+    resyncIfNeeded(!disabled, getCurrentFormState, updateFormState);
+    const unsubscribe = control._subscribe({
+      name,
+      formState: _localProxyFormState.current,
+      exact,
+      callback: (formState2) => {
+        !disabled && updateFormState({
+          ...control._formState,
+          ...formState2,
+          defaultValues: control._defaultValues
+        });
+      }
+    });
+    return () => {
+      unsubscribe();
+      snapshot(!disabled, getCurrentFormState);
+    };
+  }, [control, name, disabled, exact, resyncIfNeeded, snapshot]);
+  React.useEffect(() => {
+    _localProxyFormState.current.isValid && control._setValid(true);
+  }, [control]);
+  return React.useMemo(() => getProxyFormState(formState, control, _localProxyFormState.current, false), [formState, control]);
+}
+var isString = (value) => typeof value === "string";
+var generateWatchOutput = (names, _names, formValues, isGlobal, defaultValue) => {
+  if (isString(names)) {
+    isGlobal && _names.watch.add(names);
+    return get(formValues, names, defaultValue);
+  }
+  if (Array.isArray(names)) {
+    return names.map((fieldName) => (isGlobal && _names.watch.add(fieldName), get(formValues, fieldName, get(defaultValue, fieldName))));
+  }
+  isGlobal && (_names.watchAll = true);
+  return formValues;
+};
 function useWatch(props) {
   const formControl = useFormControlContext();
   const { control = formControl, name, defaultValue, disabled, exact, compute } = props || {};
   const _defaultValue = React.useRef(defaultValue);
   const _compute = React.useRef(compute);
-  const _computeFormValues = React.useRef(void 0);
   const _prevControl = React.useRef(control);
   const _prevName = React.useRef(name);
   _compute.current = compute;
-  const [value, updateValue] = React.useState(() => {
+  const getInitialOutput = () => {
     const defaultValue2 = control._getWatch(name, _defaultValue.current);
     return _compute.current ? _compute.current(defaultValue2) : defaultValue2;
-  });
+  };
+  const [value, updateValue] = React.useState(getInitialOutput);
+  const _computeFormValues = React.useRef(value);
   const getCurrentOutput = React.useCallback((values) => {
     const formValues = generateWatchOutput(name, control._names, values || control._formValues, false, _defaultValue.current);
     return _compute.current ? _compute.current(formValues) : formValues;
@@ -242,41 +296,57 @@ function useWatch(props) {
       }
     }
   }, [control._formValues, control._names, disabled, name]);
+  const { resyncIfNeeded, snapshot } = useResyncOnReconnect(getInitialOutput);
+  const _refreshValue = React.useRef(refreshValue);
+  _refreshValue.current = refreshValue;
+  const _getCurrentOutput = React.useRef(getCurrentOutput);
+  _getCurrentOutput.current = getCurrentOutput;
   useIsomorphicLayoutEffect(() => {
     if (_prevControl.current !== control || !deepEqual(_prevName.current, name)) {
       _prevControl.current = control;
       _prevName.current = name;
-      refreshValue();
+      _refreshValue.current();
+    } else {
+      resyncIfNeeded(!disabled, () => _getCurrentOutput.current(), (currentValue) => {
+        updateValue(currentValue);
+        _computeFormValues.current = currentValue;
+      });
     }
-    return control._subscribe({
+    const unsubscribe = control._subscribe({
       name,
       formState: {
         values: true
       },
       exact,
       callback: (formState) => {
-        refreshValue(formState.values);
+        _refreshValue.current(formState.values);
       }
     });
-  }, [control, exact, name, refreshValue]);
+    return () => {
+      unsubscribe();
+      snapshot(!disabled, () => _getCurrentOutput.current());
+    };
+  }, [control, exact, name, disabled, resyncIfNeeded, snapshot]);
   React.useEffect(() => control._removeUnmounted());
   const controlChanged = _prevControl.current !== control;
   const prevName = _prevName.current;
-  const computedOutput = React.useMemo(() => {
+  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;
 }
 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,
@@ -425,7 +495,7 @@ 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)) {
     if (key === "_f") {
       continue;
@@ -434,18 +504,18 @@ const iterateFieldsByAction = (fields, action, fieldsNames, abortEarly) => {
     if (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(field, action)) {
-            break;
+            return true;
           }
         }
       } else if (isObject(field) || Array.isArray(field)) {
         if (iterateFieldsByAction(field, action)) {
-          break;
+          return true;
         }
       }
     }
@@ -482,17 +552,21 @@ 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;
+  if (!Array.isArray(options)) {
+    return defaultResult;
+  }
+  if (options.length > 1) {
+    const values = options.filter((option2) => option2 && option2.checked && !option2.disabled).map((option2) => option2.value);
+    return { value: values, isValid: !!values.length };
+  }
+  const option = options[0];
+  if (!option || !option.checked || option.disabled) {
+    return defaultResult;
   }
-  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 = {
   isValid: false,
@@ -568,7 +642,7 @@ 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)) {
         exceedMax = valueNumber > maxOutput.value;
@@ -650,7 +724,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;
           }
@@ -667,7 +743,8 @@ var validateField = async (field, disabledFieldNames, formValues, validateAllFie
       }
     }
   }
-  setCustomValidity(true);
+  const fieldError = error[name];
+  setCustomValidity(fieldError ? fieldError.message : true);
   return error;
 };
 var convertToArrayPayload = (value) => Array.isArray(value) ? value : [value];
@@ -713,20 +790,6 @@ function unset(object, path) {
   }
   return object;
 }
-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 HookFormContext = React.createContext(null);
 HookFormContext.displayName = "HookFormContext";
 var createSubject = () => {
@@ -774,6 +837,20 @@ 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)) {
+      return hasOwn(object, path);
+    }
+    result = result[key];
+  }
+  return true;
+};
 var isMultipleSelect = (element) => element.type === `select-multiple`;
 var isRadioOrCheckbox = (ref) => isRadioInput(ref) || isCheckBoxInput(ref);
 var live = (ref) => isHTMLElement(ref) && ref.isConnected;
@@ -856,6 +933,17 @@ function getDirtyFields(data, formValues, dirtyFieldsFromValues, fieldRefs) {
   }
   return dirtyFieldsFromValues;
 }
+var getFieldArrayItemNames = (names, name) => {
+  const segments = name.split(".");
+  const matches = [];
+  let prefix = segments[0];
+  for (let i2 = 1; i2 < segments.length; prefix += "." + segments[i2++]) {
+    if (!isNaN(+segments[i2]) && names.has(prefix)) {
+      matches.push(`${prefix}.${segments[i2]}`);
+    }
+  }
+  return matches;
+};
 var getFieldValueAs = (value, { valueAsNumber, valueAsDate, setValueAs }) => isUndefined(value) ? value : valueAsNumber ? value === "" ? NaN : value ? +value : value : valueAsDate && isString(value) ? new Date(value) : setValueAs ? setValueAs(value) : value;
 function getFieldValue(_f) {
   const ref = _f.ref;
@@ -903,10 +991,10 @@ var hasPromiseValidation = (fieldReference) => {
   }
   return false;
 };
-var hasValidation = (options) => options.mount && (options.required || options.min || options.max || options.maxLength || options.minLength || options.pattern || options.validate);
+var hasValidation = (options) => options.mount && (options.required || !isUndefined(options.required) && options.required !== false || !isUndefined(options.min) || !isUndefined(options.max) || !isUndefined(options.maxLength) || !isUndefined(options.minLength) || options.pattern || options.validate);
 function schemaErrorLookup(errors, _fields, name) {
   const error = get(errors, name);
-  if (error || isKey(name)) {
+  if ((error === null || error === void 0 ? void 0 : error.type) || (error === null || error === void 0 ? void 0 : error.message) || Array.isArray(error)) {
     return {
       error,
       name
@@ -956,7 +1044,10 @@ 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 === null || array === void 0 ? void 0 : array.root) && unset(ref, name);
+};
 const defaultOptions = {
   mode: VALIDATION_MODE.onSubmit,
   reValidateMode: VALIDATION_MODE.onChange,
@@ -1000,6 +1091,7 @@ function createFormControl(props = {}) {
   let _formValues = _options.shouldUnregister ? {} : cloneObject(_defaultValues);
   let _state = {
     action: false,
+    actionArrayLengths: /* @__PURE__ */ new Map(),
     mount: false,
     watch: false,
     keepIsValid: false
@@ -1032,21 +1124,35 @@ function createFormControl(props = {}) {
   let _proxySubscribeFormState = {
     ..._proxyFormState
   };
+  const _isTracked = (...keys) => keys.some((key) => _proxyFormState[key] || _proxySubscribeFormState[key]);
   const _subjects = {
     array: createSubject(),
     state: createSubject()
   };
   let _setValidCallId = 0;
-  const shouldDisplayAllAssociatedErrors = _options.criteriaMode === VALIDATION_MODE.all;
+  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) {
@@ -1067,8 +1173,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) : unset(_formState.validatingFields, name);
         }
@@ -1085,20 +1191,30 @@ function createFormControl(props = {}) {
   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);
+      if (_isTracked("touchedFields") && shouldUpdateFieldsAndState && Array.isArray(touchedFieldsArray)) {
+        const touchedFields = method(touchedFieldsArray, args.argA, args.argB);
         shouldSetValues && set(_formState.touchedFields, name, touchedFields);
       }
-      if (_proxyFormState.dirtyFields || _proxySubscribeFormState.dirtyFields) {
+      if (_isTracked("dirtyFields")) {
         _updateDirtyFields();
       }
       _subjects.state.next({
@@ -1120,6 +1236,7 @@ function createFormControl(props = {}) {
     });
   };
   const _setErrors = (errors) => {
+    Object.keys(delayErrorCallbacks).forEach(cancelDelayedError);
     _formState.errors = errors;
     _subjects.state.next({
       errors: _formState.errors,
@@ -1140,10 +1257,39 @@ 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 i2 = 0; i2 < segments.length; i2++) {
+      if (isNullOrUndefined(node)) {
+        return false;
+      }
+      const key = segments[i2];
+      path = path ? `${path}.${key}` : key;
+      if (Array.isArray(node) && +key >= node.length) {
+        return ownerDepth === -1 ? false : i2 === ownerDepth ? +key < ownerPreActionLength : true;
+      }
+      if (_state.actionArrayLengths.has(path)) {
+        ownerDepth = i2 + 1;
+        ownerPreActionLength = _state.actionArrayLengths.get(path);
+      }
+      node = node[key];
+      if (isUndefined(node) && ownerDepth !== -1 && i2 > 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));
@@ -1151,7 +1297,7 @@ function createFormControl(props = {}) {
       isUndefined(defaultValue) || ref && ref.defaultChecked || shouldSkipSetValueAs ? set(_formValues, name, shouldSkipSetValueAs ? defaultValue : getFieldValue(field._f)) : setFieldValue(name, defaultValue);
       if (_state.mount && !_state.action) {
         _setValid();
-        if (wasUnsetInFormValues && _formState.isDirty && (_proxyFormState.isDirty || _proxySubscribeFormState.isDirty)) {
+        if (wasUnsetInFormValues && _formState.isDirty && _isTracked("isDirty")) {
           const isDirty = _getDirty();
           if (!isDirty) {
             _formState.isDirty = false;
@@ -1173,7 +1319,7 @@ function createFormControl(props = {}) {
     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();
           shouldUpdateField = isPreviousDirty !== output.isDirty;
@@ -1185,14 +1331,14 @@ function createFormControl(props = {}) {
           isCurrentFieldPristine ? unset(_formState.dirtyFields, name) : set(_formState.dirtyFields, name, true);
         }
         output.dirtyFields = _formState.dirtyFields;
-        shouldUpdateField = shouldUpdateField || (_proxyFormState.dirtyFields || _proxySubscribeFormState.dirtyFields) && isPreviousDirty !== !isCurrentFieldPristine;
+        shouldUpdateField = shouldUpdateField || _isTracked("dirtyFields") && isPreviousDirty !== !isCurrentFieldPristine;
       }
       if (isBlurEvent) {
         const isPreviousFieldTouched = get(_formState.touchedFields, name);
         if (!isPreviousFieldTouched) {
           set(_formState.touchedFields, name, isBlurEvent);
           output.touchedFields = _formState.touchedFields;
-          shouldUpdateField = shouldUpdateField || (_proxyFormState.touchedFields || _proxySubscribeFormState.touchedFields) && isPreviousFieldTouched !== isBlurEvent;
+          shouldUpdateField = shouldUpdateField || _isTracked("touchedFields") && isPreviousFieldTouched !== isBlurEvent;
         }
       }
       shouldUpdateField && shouldRender && _subjects.state.next(output);
@@ -1201,13 +1347,12 @@ function createFormControl(props = {}) {
   };
   const shouldRenderByError = (name, isValid, error, fieldState) => {
     const previousFieldError = get(_formState.errors, name);
-    const shouldUpdateValid = (_proxyFormState.isValid || _proxySubscribeFormState.isValid) && isBoolean(isValid) && _formState.isValid !== isValid;
+    const shouldUpdateValid = _isTracked("isValid") && isBoolean(isValid) && _formState.isValid !== isValid;
     if (_options.delayError && error) {
       delayErrorCallbacks[name] = debounce(name, () => updateErrors(name, error));
       delayErrorCallbacks[name](_options.delayError);
     } else {
-      clearTimeout(timers[name]);
-      delete delayErrorCallbacks[name];
+      cancelDelayedError(name);
       error ? set(_formState.errors, name, error) : unset(_formState.errors, name);
       _formState.errors = { ..._formState.errors };
     }
@@ -1218,10 +1363,6 @@ function createFormControl(props = {}) {
         errors: _formState.errors,
         name
       };
-      _formState = {
-        ..._formState,
-        ...updatedFormState
-      };
       _subjects.state.next(updatedFormState);
     }
   };
@@ -1230,15 +1371,24 @@ 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);
+        cancelDelayedError(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 === null || error === void 0 ? void 0 : error.type) || (error === null || error === void 0 ? void 0 : 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;
@@ -1297,7 +1447,7 @@ 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);
           }
@@ -1311,7 +1461,10 @@ function createFormControl(props = {}) {
               break;
             }
           }
-          !onlyCheckValid && (get(fieldError, _f.name) ? isFieldArrayRoot ? updateFieldArrayRootError(_formState.errors, fieldError, _f.name) : set(_formState.errors, _f.name, fieldError[_f.name]) : unset(_formState.errors, _f.name));
+          if (!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);
+          }
           if (props.shouldUseNativeValidation && fieldError[_f.name]) {
             break;
           }
@@ -1336,10 +1489,10 @@ function createFormControl(props = {}) {
   };
   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) ? _defaultValues : isString(names) ? { [names]: defaultValue } : defaultValue
+    ..._state.mount ? _formValues : isUndefined(defaultValue) || isString(names) ? _defaultValues : 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) {
@@ -1367,7 +1520,7 @@ function createFormControl(props = {}) {
           fieldReference.ref.value = "";
         } 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)
@@ -1376,12 +1529,12 @@ function createFormControl(props = {}) {
         }
       }
     }
-    (options.shouldDirty || options.shouldTouch) && updateTouchAndDirty(name, fieldValue, options.shouldTouch, options.shouldDirty, !skipRender);
+    (options.shouldDirty || options.shouldTouch) && 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
     });
   };
-  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,
@@ -1390,12 +1543,12 @@ function createFormControl(props = {}) {
     }
     for (const fieldKey in value) {
       if (!value.hasOwnProperty(fieldKey)) {
-        return;
+        continue;
       }
       const fieldValue = value[fieldKey];
       const fieldName = name + "." + fieldKey;
       const field = get(_fields, fieldName);
-      (_names.array.has(name) || isObject(fieldValue) || field && !field._f) && !isDateObject(fieldValue) ? setFieldValues(fieldName, fieldValue, options, skipClone, skipRender) : setFieldValue(fieldName, fieldValue, options, skipClone, skipRender);
+      (_names.array.has(name) || isObject(fieldValue) || field && !field._f) && !isDateObject(fieldValue) ? setFieldValues(fieldName, fieldValue, options, skipClone, skipRender, skipValueRender) : setFieldValue(fieldName, fieldValue, options, skipClone, skipRender, skipValueRender);
     }
   };
   const _setValue = (name, value, options, skipClone, skipStateEmit = false) => {
@@ -1412,7 +1565,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({
@@ -1424,10 +1577,11 @@ function createFormControl(props = {}) {
       }
     } 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) {
@@ -1438,6 +1592,11 @@ function createFormControl(props = {}) {
         name: _state.mount || watched ? name : void 0,
         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);
@@ -1448,10 +1607,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({
@@ -1482,7 +1640,7 @@ function createFormControl(props = {}) {
       const hasNoValidationEffect = !hasValidation(field._f) && !props.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);
@@ -1500,7 +1658,7 @@ function createFormControl(props = {}) {
         ..._valuesSubscriberCount ? { values: cloneObject(_formValues) } : {}
       });
       if (shouldSkipValidation) {
-        if ((!hasNoValidationEffect || !_formState.isValid) && (_proxyFormState.isValid || _proxySubscribeFormState.isValid)) {
+        if ((!hasNoValidationEffect || !_formState.isValid) && _isTracked("isValid")) {
           if (_options.mode === "onBlur") {
             if (isBlurEvent) {
               _setValid();
@@ -1539,7 +1697,7 @@ function createFormControl(props = {}) {
         if (isFieldValueUpdated) {
           if (error) {
             isValid = false;
-          } else if (_proxyFormState.isValid || _proxySubscribeFormState.isValid) {
+          } else if (_isTracked("isValid")) {
             isValid = await executeBuiltInValidation({
               fields: _fields,
               onlyCheckValid: true,
@@ -1567,9 +1725,13 @@ 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((name2) => get(errors, name2)) : isValid;
+      if (resetCallId !== _resetCallId) {
+        return validationResult;
+      }
     } else if (name) {
       validationResult = (await Promise.all(fieldNames.map(async (fieldName) => {
         const field = get(_fields, fieldName);
@@ -1593,13 +1755,18 @@ function createFormControl(props = {}) {
         delayErrorCallbacks[name] = debounce(name, () => updateErrors(name, error));
         delayErrorCallbacks[name](_options.delayError);
       } else {
-        clearTimeout(timers[name]);
-        delete delayErrorCallbacks[name];
+        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 ? {} : { name },
+      ...!isString(name) || _isTracked("isValid") && isValid !== _formState.isValid ? {} : { name },
       ..._options.resolver || !name ? { isValid } : {},
+      ...options.shouldTouch && _isTracked("touchedFields") ? { touchedFields: _formState.touchedFields } : {},
       errors: _formState.errors
     });
     options.shouldFocus && !validationResult && iterateFieldsByAction(_fields, _focusInput, name ? fieldNames : _names.mount);
@@ -1614,24 +1781,31 @@ function createFormControl(props = {}) {
     }
     return isUndefined(fieldNames) ? values : isString(fieldNames) ? 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) : void 0;
-    names === null || names === void 0 ? void 0 : 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
         });
       });
     } else {
+      Object.keys(delayErrorCallbacks).forEach(cancelDelayedError);
       _formState.errors = {};
       _subjects.state.next({
         errors: _formState.errors
@@ -1639,9 +1813,10 @@ function createFormControl(props = {}) {
     }
   };
   const setError = (name, error, options) => {
+    cancelDelayedError(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,
@@ -1724,22 +1899,27 @@ 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 && unset(_formState.validatingFields, fieldName);
       !_options.shouldUnregister && !options.keepDefaultValue && unset(_defaultValues, fieldName);
     }
-    _subjects.state.next({
+    _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();
   };
@@ -1841,7 +2021,7 @@ function createFormControl(props = {}) {
             });
           }
         }
-      }, 0, false);
+      }, 0);
     }
   };
   const handleSubmit = (onValid, onInvalid) => async (e) => {
@@ -1856,8 +2036,13 @@ 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 {
@@ -1865,13 +2050,13 @@ function createFormControl(props = {}) {
         fields: _fields,
         eventType: EVENTS.SUBMIT
       });
+      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: {}
@@ -1902,6 +2087,7 @@ function createFormControl(props = {}) {
   };
   const resetField = (name, options = {}) => {
     if (get(_fields, name)) {
+      unset(_formState.validatingFields, name);
       if (isUndefined(options.defaultValue)) {
         setValue(name, cloneObject(get(_defaultValues, name)));
       } else {
@@ -1916,18 +2102,24 @@ function createFormControl(props = {}) {
         _formState.isDirty = options.defaultValue ? _getDirty(name, cloneObject(get(_defaultValues, name))) : _getDirty();
       }
       if (!options.keepError) {
+        cancelDelayedError(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;
     }
@@ -1937,7 +2129,7 @@ function createFormControl(props = {}) {
           ..._names.mount,
           ...collectDirtyFieldNames(getDirtyFields(_defaultValues, _formValues, void 0, 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);
@@ -2004,6 +2196,7 @@ function createFormControl(props = {}) {
     _state.watch = !!_options.shouldUnregister;
     _state.keepIsValid = !!keepStateOptions.keepIsValid;
     _state.action = false;
+    _state.actionArrayLengths.clear();
     if (!keepStateOptions.keepErrors) {
       _formState.errors = {};
     }
@@ -2011,8 +2204,9 @@ function createFormControl(props = {}) {
       submitCount: keepStateOptions.keepSubmitCount ? _formState.submitCount : 0,
       isDirty: isEmptyResetValues ? false : keepStateOptions.keepDirty ? _formState.isDirty : keepStateOptions.keepValues ? _getDirty() : !!(keepStateOptions.keepDefaultValues && !deepEqual(formValues, _defaultValues)),
       isSubmitted: keepStateOptions.keepIsSubmitted ? _formState.isSubmitted : false,
-      dirtyFields: isEmptyResetValues ? {} : keepStateOptions.keepDirtyValues ? keepStateOptions.keepDefaultValues && _formValues ? getDirtyFields(_defaultValues, _formValues, void 0, fieldRefs) : _formState.dirtyFields : keepStateOptions.keepDefaultValues && formValues ? getDirtyFields(_defaultValues, formValues, void 0, fieldRefs) : keepStateOptions.keepDirty ? _formState.dirtyFields : {},
+      dirtyFields: isEmptyResetValues ? {} : keepStateOptions.keepDirtyValues ? keepStateOptions.keepDefaultValues && _formValues ? getDirtyFields(_defaultValues, _formValues, void 0, fieldRefs) : _formState.dirtyFields : keepStateOptions.keepDefaultValues && formValues ? getDirtyFields(_defaultValues, formValues, void 0, fieldRefs) : keepStateOptions.keepDirty ? _formState.dirtyFields : keepStateOptions.keepValues ? getDirtyFields(_defaultValues, _formValues, void 0, 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 : false,
       isSubmitting: false,
@@ -2040,6 +2234,7 @@ function createFormControl(props = {}) {
       ...formState
     };
   };
+  _subjects.state.subscribe({ next: _setFormState });
   const _resetDefaultValues = () => isFunction(_options.defaultValues) && _options.defaultValues().then((values) => {
     reset(values, _options.resetOptions);
     _subjects.state.next({
@@ -2119,6 +2314,7 @@ function createFormControl(props = {}) {
         };
         _validationModeBeforeSubmit = getValidationModes(_options.mode);
         _validationModeAfterSubmit = getValidationModes(_options.reValidateMode);
+        shouldDisplayAllAssociatedErrors = _options.criteriaMode === VALIDATION_MODE.all;
       }
     },
     subscribe,
@@ -2129,6 +2325,7 @@ function createFormControl(props = {}) {
     setValue,
     setValues,
     getValues,
+    getErrors,
     reset,
     resetField,
     resetDefaultValues,
@@ -2174,8 +2371,14 @@ function useForm(props = {}) {
   }
   const control = _formControl.current.control;
   control._options = props;
+  const getCurrentFormState = () => ({
+    ...control._formState,
+    defaultValues: control._defaultValues
+  });
+  const { resyncIfNeeded, snapshot } = useResyncOnReconnect(getCurrentFormState);
   useIsomorphicLayoutEffect(() => {
-    const sub = control._subscribe({
+    resyncIfNeeded(true, getCurrentFormState, updateFormState);
+    const unsubscribe = control._subscribe({
       formState: control._proxyFormState,
       callback: () => updateFormState({
         ...control._formState,
@@ -2188,8 +2391,11 @@ function useForm(props = {}) {
       isReady: true
     }));
     control._formState.isReady = true;
-    return sub;
-  }, [control]);
+    return () => {
+      unsubscribe();
+      snapshot(true, getCurrentFormState);
+    };
+  }, [control, resyncIfNeeded, snapshot]);
   React.useEffect(() => control._disableForm(props.disabled), [control, props.disabled]);
   React.useEffect(() => {
     if (props.mode) {
@@ -2276,7 +2482,7 @@ const t = (r, t2, s2) => {
   return e.some((e2) => n$1(e2).match(`^${t2}\\.\\d+`));
 };
 function n$1(e) {
-  return e.replace(/[\[\]]/g, "");
+  return e.replace(/\[(\d+)]/g, ".$1").replace(/[[\]]/g, "");
 }
 function getDotPath(issue) {
   if (issue.path?.length) {