@gorgo/medusa-integration 0.2.0 → 0.3.0-beta.1

package/.medusa/server/src/admin/index.js

@@ -320,55 +320,45 @@ const IntegrationFieldValue = ({
   return /* @__PURE__ */ jsxRuntime.jsx(ui.Text, { size: "small", leading: "compact", children: String(value) });
 };
 var isCheckBoxInput = (element) => element.type === "checkbox";
+var isFileInput = (element) => element.type === "file";
 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 getEventValue = (event) => isObject(event) && event.target ? isCheckBoxInput(event.target) ? event.target.checked : event.target.value : event;
-var getNodeParentName = (name) => name.substring(0, name.search(/\.\d+(\.|$)/)) || name;
-var isNameInFieldArray = (names, name) => names.has(getNodeParentName(name));
+var getEventValue = (event) => isObject(event) && event.target ? isCheckBoxInput(event.target) ? event.target.checked : isFileInput(event.target) ? event.target.files : event.target.value : event;
+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) {
-  let copy;
-  const isArray = Array.isArray(data);
   if (data instanceof Date) {
-    copy = new Date(data);
-  } else if (data instanceof Set) {
-    copy = new Set(data);
-  } else if (!(isWeb && (data instanceof Blob || data instanceof FileList)) && (isArray || isObject(data))) {
-    copy = isArray ? [] : {};
-    if (!isArray && !isPlainObject(data)) {
-      copy = data;
-    } else {
-      for (const key in data) {
-        if (data.hasOwnProperty(key)) {
-          copy[key] = cloneObject(data[key]);
-        }
-      }
-    }
-  } else {
+    return new Date(data);
+  }
+  const isFileListInstance = typeof FileList !== "undefined" && data instanceof FileList;
+  if (isWeb && (data instanceof Blob || isFileListInstance)) {
     return data;
   }
+  const isArray = Array.isArray(data);
+  if (!isArray && !(isObject(data) && isPlainObject(data))) {
+    return data;
+  }
+  const copy = isArray ? [] : Object.create(Object.getPrototypeOf(data));
+  for (const key in data) {
+    if (Object.prototype.hasOwnProperty.call(data, key)) {
+      copy[key] = cloneObject(data[key]);
+    }
+  }
   return copy;
 }
-var compact = (value) => Array.isArray(value) ? value.filter(Boolean) : [];
-var isUndefined = (val) => val === void 0;
-var get = (object, path, defaultValue) => {
-  if (!path || !isObject(object)) {
-    return defaultValue;
-  }
-  const result = compact(path.split(/[,[\].]+?/)).reduce((result2, key) => isNullOrUndefined(result2) ? result2 : result2[key], object);
-  return isUndefined(result) || result === object ? isUndefined(object[path]) ? defaultValue : object[path] : result;
-};
-var isBoolean = (value) => typeof value === "boolean";
 const EVENTS = {
   BLUR: "blur",
   FOCUS_OUT: "focusout",
-  CHANGE: "change"
+  CHANGE: "change",
+  SUBMIT: "submit",
+  TRIGGER: "trigger",
+  VALID: "valid"
 };
 const VALIDATION_MODE = {
   onBlur: "onBlur",
@@ -386,12 +376,52 @@ const INPUT_VALIDATION_RULES = {
   required: "required",
   validate: "validate"
 };
-const HookFormContext = React__default.default.createContext(null);
-const useFormContext = () => React__default.default.useContext(HookFormContext);
+const ROOT_ERROR_TYPE = "root";
+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;
+  }
+  const paths = isKey(path) ? [path] : stringToPath(path);
+  if (paths.some((key) => PROTOTYPE_KEYWORDS.includes(key))) {
+    return defaultValue;
+  }
+  const result = paths.reduce((result2, key) => {
+    return isNullOrUndefined(result2) ? void 0 : result2[key];
+  }, object);
+  return isUndefined(result) || result === object ? isUndefined(object[path]) ? defaultValue : object[path] : result;
+};
+var isBoolean = (value) => typeof value === "boolean";
+var isFunction = (value) => typeof value === "function";
+var set = (object, path, value) => {
+  let index = -1;
+  const tempPath = isKey(path) ? [path] : stringToPath(path);
+  const length = tempPath.length;
+  const lastIndex = length - 1;
+  while (++index < length) {
+    const key = tempPath[index];
+    let newValue = value;
+    if (index !== lastIndex) {
+      const objValue = object[key];
+      newValue = isObject(objValue) || Array.isArray(objValue) ? objValue : !isNaN(+tempPath[index + 1]) ? [] : {};
+    }
+    if (PROTOTYPE_KEYWORDS.includes(key)) {
+      return;
+    }
+    object[key] = newValue;
+    object = object[key];
+  }
+};
+const HookFormControlContext = React__default.default.createContext(null);
+HookFormControlContext.displayName = "HookFormControlContext";
+const useFormControlContext = () => React__default.default.useContext(HookFormControlContext);
 var getProxyFormState = (formState, control, localProxyFormState, isRoot = true) => {
-  const result = {
-    defaultValues: control._defaultValues
-  };
+  const result = {};
   for (const key in formState) {
     Object.defineProperty(result, key, {
       get: () => {
@@ -406,58 +436,40 @@ var getProxyFormState = (formState, control, localProxyFormState, isRoot = true)
   }
   return result;
 };
-var isEmptyObject = (value) => isObject(value) && !Object.keys(value).length;
-var shouldRenderFormState = (formStateData, _proxyFormState, updateFormState, isRoot) => {
-  updateFormState(formStateData);
-  const { name, ...formState } = formStateData;
-  return isEmptyObject(formState) || Object.keys(formState).length >= Object.keys(_proxyFormState).length || Object.keys(formState).find((key) => _proxyFormState[key] === (!isRoot || VALIDATION_MODE.all));
-};
-var convertToArrayPayload = (value) => Array.isArray(value) ? value : [value];
-var shouldSubscribeByName = (name, signalName, exact) => !name || !signalName || name === signalName || convertToArrayPayload(name).some((currentName) => currentName && (exact ? currentName === signalName : currentName.startsWith(signalName) || signalName.startsWith(currentName)));
-function useSubscribe(props) {
-  const _props = React__default.default.useRef(props);
-  _props.current = props;
-  React__default.default.useEffect(() => {
-    const subscription = !props.disabled && _props.current.subject && _props.current.subject.subscribe({
-      next: _props.current.next
-    });
-    return () => {
-      subscription && subscription.unsubscribe();
-    };
-  }, [props.disabled]);
-}
+const useIsomorphicLayoutEffect = isWeb ? React__default.default.useLayoutEffect : React__default.default.useEffect;
 function useFormState(props) {
-  const methods = useFormContext();
-  const { control = methods.control, disabled, name, exact } = props || {};
-  const [formState, updateFormState] = React__default.default.useState(control._formState);
-  const _mounted = React__default.default.useRef(true);
+  const formControl = useFormControlContext();
+  const { control = formControl, disabled, name, exact } = props || {};
+  const [formState, updateFormState] = React__default.default.useState(() => ({
+    ...control._formState,
+    defaultValues: control._defaultValues
+  }));
   const _localProxyFormState = React__default.default.useRef({
     isDirty: false,
     isLoading: false,
     dirtyFields: false,
     touchedFields: false,
+    validatingFields: false,
     isValidating: false,
     isValid: false,
     errors: false
   });
-  const _name = React__default.default.useRef(name);
-  _name.current = name;
-  useSubscribe({
-    disabled,
-    next: (value) => _mounted.current && shouldSubscribeByName(_name.current, value.name, exact) && shouldRenderFormState(value, _localProxyFormState.current, control._updateFormState) && updateFormState({
-      ...control._formState,
-      ...value
-    }),
-    subject: control._subjects.state
-  });
+  useIsomorphicLayoutEffect(() => control._subscribe({
+    name,
+    formState: _localProxyFormState.current,
+    exact,
+    callback: (formState2) => {
+      !disabled && updateFormState({
+        ...control._formState,
+        ...formState2,
+        defaultValues: control._defaultValues
+      });
+    }
+  }), [name, disabled, exact]);
   React__default.default.useEffect(() => {
-    _mounted.current = true;
-    _localProxyFormState.current.isValid && control._updateValid(true);
-    return () => {
-      _mounted.current = false;
-    };
+    _localProxyFormState.current.isValid && control._setValid(true);
   }, [control]);
-  return getProxyFormState(formState, control, _localProxyFormState.current, false);
+  return React__default.default.useMemo(() => getProxyFormState(formState, control, _localProxyFormState.current, false), [formState, control]);
 }
 var isString = (value) => typeof value === "string";
 var generateWatchOutput = (names, _names, formValues, isGlobal, defaultValue) => {
@@ -471,152 +483,250 @@ var generateWatchOutput = (names, _names, formValues, isGlobal, defaultValue) =>
   isGlobal && (_names.watchAll = true);
   return formValues;
 };
-function useWatch(props) {
-  const methods = useFormContext();
-  const { control = methods.control, name, defaultValue, disabled, exact } = props || {};
-  const _name = React__default.default.useRef(name);
-  _name.current = name;
-  useSubscribe({
-    disabled,
-    subject: control._subjects.values,
-    next: (formState) => {
-      if (shouldSubscribeByName(_name.current, formState.name, exact)) {
-        updateValue(cloneObject(generateWatchOutput(_name.current, control._names, formState.values || control._formValues, false, defaultValue)));
+var isPrimitive = (value) => isNullOrUndefined(value) || !isObjectType(value);
+const isEmptyObjectWithCustomPrototype = (object, keys) => keys.length === 0 && !Array.isArray(object) && !isPlainObject(object);
+function deepEqual(object1, object2, visited = /* @__PURE__ */ new WeakMap()) {
+  if (object1 === object2) {
+    return true;
+  }
+  if (isPrimitive(object1) || isPrimitive(object2)) {
+    return Object.is(object1, object2);
+  }
+  if (isDateObject(object1) && isDateObject(object2)) {
+    return Object.is(object1.getTime(), object2.getTime());
+  }
+  const keys1 = Object.keys(object1);
+  const keys2 = Object.keys(object2);
+  if (keys1.length !== keys2.length) {
+    return false;
+  }
+  if (isEmptyObjectWithCustomPrototype(object1, keys1) || isEmptyObjectWithCustomPrototype(object2, keys2)) {
+    return Object.is(object1, object2);
+  }
+  if (!keys1.length && Array.isArray(object1) !== Array.isArray(object2)) {
+    return false;
+  }
+  const visitedPairs = visited.get(object1);
+  if (visitedPairs && visitedPairs.has(object2)) {
+    return true;
+  }
+  if (visitedPairs) {
+    visitedPairs.add(object2);
+  } else {
+    const ws = /* @__PURE__ */ new WeakSet();
+    ws.add(object2);
+    visited.set(object1, ws);
+  }
+  for (const key of keys1) {
+    const val1 = object1[key];
+    if (!(key in object2)) {
+      return false;
+    }
+    if (key !== "ref") {
+      const val2 = object2[key];
+      if (isDateObject(val1) && isDateObject(val2) || (isObject(val1) || Array.isArray(val1)) && (isObject(val2) || Array.isArray(val2)) ? !deepEqual(val1, val2, visited) : !Object.is(val1, val2)) {
+        return false;
       }
     }
+  }
+  return true;
+}
+function useWatch(props) {
+  const formControl = useFormControlContext();
+  const { control = formControl, name, defaultValue, disabled, exact, compute } = props || {};
+  const _defaultValue = React__default.default.useRef(defaultValue);
+  const _compute = React__default.default.useRef(compute);
+  const _computeFormValues = React__default.default.useRef(void 0);
+  const _prevControl = React__default.default.useRef(control);
+  const _prevName = React__default.default.useRef(name);
+  _compute.current = compute;
+  const [value, updateValue] = React__default.default.useState(() => {
+    const defaultValue2 = control._getWatch(name, _defaultValue.current);
+    return _compute.current ? _compute.current(defaultValue2) : defaultValue2;
   });
-  const [value, updateValue] = React__default.default.useState(control._getWatch(name, defaultValue));
+  const getCurrentOutput = React__default.default.useCallback((values) => {
+    const formValues = generateWatchOutput(name, control._names, values || control._formValues, false, _defaultValue.current);
+    return _compute.current ? _compute.current(formValues) : formValues;
+  }, [control._formValues, control._names, name]);
+  const refreshValue = React__default.default.useCallback((values) => {
+    if (!disabled) {
+      const formValues = generateWatchOutput(name, control._names, values || control._formValues, false, _defaultValue.current);
+      if (_compute.current) {
+        const computedFormValues = _compute.current(formValues);
+        if (!deepEqual(computedFormValues, _computeFormValues.current)) {
+          updateValue(computedFormValues);
+          _computeFormValues.current = computedFormValues;
+        }
+      } else {
+        updateValue(formValues);
+      }
+    }
+  }, [control._formValues, control._names, disabled, name]);
+  useIsomorphicLayoutEffect(() => {
+    if (_prevControl.current !== control || !deepEqual(_prevName.current, name)) {
+      _prevControl.current = control;
+      _prevName.current = name;
+      refreshValue();
+    }
+    return control._subscribe({
+      name,
+      formState: {
+        values: true
+      },
+      exact,
+      callback: (formState) => {
+        refreshValue(formState.values);
+      }
+    });
+  }, [control, exact, name, refreshValue]);
   React__default.default.useEffect(() => control._removeUnmounted());
-  return value;
+  const controlChanged = _prevControl.current !== control;
+  const prevName = _prevName.current;
+  const computedOutput = React__default.default.useMemo(() => {
+    if (disabled) {
+      return null;
+    }
+    const nameChanged = !controlChanged && !deepEqual(prevName, name);
+    const shouldReturnImmediate = controlChanged || nameChanged;
+    return shouldReturnImmediate ? getCurrentOutput() : null;
+  }, [disabled, controlChanged, name, prevName, getCurrentOutput]);
+  return computedOutput !== null ? computedOutput : value;
 }
-var isKey = (value) => /^\w*$/.test(value);
-var stringToPath = (input) => compact(input.replace(/["|']|\]/g, "").split(/\.|\[/));
-var set = (object, path, value) => {
-  let index = -1;
-  const tempPath = isKey(path) ? [path] : stringToPath(path);
-  const length = tempPath.length;
-  const lastIndex = length - 1;
-  while (++index < length) {
-    const key = tempPath[index];
-    let newValue = value;
-    if (index !== lastIndex) {
-      const objValue = object[key];
-      newValue = isObject(objValue) || Array.isArray(objValue) ? objValue : !isNaN(+tempPath[index + 1]) ? [] : {};
-    }
-    object[key] = newValue;
-    object = object[key];
-  }
-  return object;
-};
 function useController(props) {
-  const methods = useFormContext();
-  const { name, disabled, control = methods.control, shouldUnregister } = props;
+  const formControl = useFormControlContext();
+  const { name, disabled, control = formControl, shouldUnregister, defaultValue, exact = true } = props;
   const isArrayField = isNameInFieldArray(control._names.array, name);
+  const defaultValueMemo = React__default.default.useMemo(() => get(control._formValues, name, get(control._defaultValues, name, defaultValue)), [control, name, defaultValue]);
   const value = useWatch({
     control,
     name,
-    defaultValue: get(control._formValues, name, get(control._defaultValues, name, props.defaultValue)),
-    exact: true
+    defaultValue: defaultValueMemo,
+    exact
   });
   const formState = useFormState({
     control,
-    name
+    name,
+    exact
   });
+  const _props = React__default.default.useRef(props);
+  const _proxyRef = React__default.default.useRef(null);
   const _registerProps = React__default.default.useRef(control.register(name, {
     ...props.rules,
     value,
     ...isBoolean(props.disabled) ? { disabled: props.disabled } : {}
   }));
+  _props.current = props;
+  const fieldState = React__default.default.useMemo(() => Object.defineProperties({}, {
+    invalid: {
+      enumerable: true,
+      get: () => !!get(formState.errors, name)
+    },
+    isDirty: {
+      enumerable: true,
+      get: () => !!get(formState.dirtyFields, name)
+    },
+    isTouched: {
+      enumerable: true,
+      get: () => !!get(formState.touchedFields, name)
+    },
+    isValidating: {
+      enumerable: true,
+      get: () => !!get(formState.validatingFields, name)
+    },
+    error: {
+      enumerable: true,
+      get: () => get(formState.errors, name)
+    }
+  }), [formState, name]);
+  const onChange = React__default.default.useCallback((event) => {
+    const value2 = getEventValue(event);
+    if (!get(control._fields, name)) {
+      _registerProps.current = control.register(name, {
+        ..._props.current.rules,
+        value: value2
+      });
+    }
+    return _registerProps.current.onChange({
+      target: {
+        value: getEventValue(event),
+        name
+      },
+      type: EVENTS.CHANGE
+    });
+  }, [name, control]);
+  const onBlur = React__default.default.useCallback(() => _registerProps.current.onBlur({
+    target: {
+      value: get(control._formValues, name),
+      name
+    },
+    type: EVENTS.BLUR
+  }), [name, control._formValues]);
+  const ref = React__default.default.useCallback((elm) => {
+    if (elm) {
+      _proxyRef.current = {
+        focus: () => isFunction(elm.focus) && elm.focus(),
+        select: () => isFunction(elm.select) && elm.select(),
+        setCustomValidity: (message) => isFunction(elm.setCustomValidity) && elm.setCustomValidity(message),
+        reportValidity: () => isFunction(elm.reportValidity) && elm.reportValidity()
+      };
+    }
+    const field2 = get(control._fields, name);
+    if (field2 && field2._f && elm) {
+      field2._f.ref = _proxyRef.current;
+    }
+  }, [control._fields, name]);
+  const field = React__default.default.useMemo(() => ({
+    name,
+    value,
+    ...isBoolean(disabled) || formState.disabled ? { disabled: formState.disabled || disabled } : {},
+    onChange,
+    onBlur,
+    ref
+  }), [name, disabled, formState.disabled, onChange, onBlur, ref, value]);
   React__default.default.useEffect(() => {
     const _shouldUnregisterField = control._options.shouldUnregister || shouldUnregister;
+    _registerProps.current = control.register(name, {
+      ..._props.current.rules,
+      ...isBoolean(_props.current.disabled) ? { disabled: _props.current.disabled } : {}
+    });
     const updateMounted = (name2, value2) => {
-      const field = get(control._fields, name2);
-      if (field) {
-        field._f.mount = value2;
+      const field2 = get(control._fields, name2);
+      if (field2 && field2._f) {
+        field2._f.mount = value2;
       }
     };
     updateMounted(name, true);
     if (_shouldUnregisterField) {
-      const value2 = cloneObject(get(control._options.defaultValues, name));
+      const value2 = cloneObject(get(shouldUnregister ? control._defaultValues : control._options.values || control._defaultValues, name, get(control._options.defaultValues, name, _props.current.defaultValue)));
       set(control._defaultValues, name, value2);
       if (isUndefined(get(control._formValues, name))) {
         set(control._formValues, name, value2);
       }
     }
+    !isArrayField && control.register(name);
+    if (_proxyRef.current) {
+      const field2 = get(control._fields, name);
+      if (field2 && field2._f) {
+        field2._f.ref = _proxyRef.current;
+      }
+    }
     return () => {
       (isArrayField ? _shouldUnregisterField && !control._state.action : _shouldUnregisterField) ? control.unregister(name) : updateMounted(name, false);
     };
   }, [name, control, isArrayField, shouldUnregister]);
   React__default.default.useEffect(() => {
-    if (get(control._fields, name)) {
-      control._updateDisabledField({
-        disabled,
-        fields: control._fields,
-        name,
-        value: get(control._fields, name)._f.value
-      });
-    }
+    control._setDisabledField({
+      disabled,
+      name
+    });
   }, [disabled, name, control]);
-  return {
-    field: {
-      name,
-      value,
-      ...isBoolean(disabled) || isBoolean(formState.disabled) ? { disabled: formState.disabled || disabled } : {},
-      onChange: React__default.default.useCallback((event) => _registerProps.current.onChange({
-        target: {
-          value: getEventValue(event),
-          name
-        },
-        type: EVENTS.CHANGE
-      }), [name]),
-      onBlur: React__default.default.useCallback(() => _registerProps.current.onBlur({
-        target: {
-          value: get(control._formValues, name),
-          name
-        },
-        type: EVENTS.BLUR
-      }), [name, control]),
-      ref: (elm) => {
-        const field = get(control._fields, name);
-        if (field && elm) {
-          field._f.ref = {
-            focus: () => elm.focus(),
-            select: () => elm.select(),
-            setCustomValidity: (message) => elm.setCustomValidity(message),
-            reportValidity: () => elm.reportValidity()
-          };
-        }
-      }
-    },
+  return React__default.default.useMemo(() => ({
+    field,
     formState,
-    fieldState: Object.defineProperties({}, {
-      invalid: {
-        enumerable: true,
-        get: () => !!get(formState.errors, name)
-      },
-      isDirty: {
-        enumerable: true,
-        get: () => !!get(formState.dirtyFields, name)
-      },
-      isTouched: {
-        enumerable: true,
-        get: () => !!get(formState.touchedFields, name)
-      },
-      error: {
-        enumerable: true,
-        get: () => get(formState.errors, name)
-      }
-    })
-  };
+    fieldState
+  }), [field, formState, fieldState]);
 }
 const Controller = (props) => props.render(useController(props));
-var appendErrors = (name, validateAllFieldCriteria, errors, type, message) => validateAllFieldCriteria ? {
-  ...errors[name],
-  types: {
-    ...errors[name] && errors[name].types ? errors[name].types : {},
-    [type]: message || true
-  }
-} : {};
 var getValidationModes = (mode) => ({
   isOnSubmit: !mode || mode === VALIDATION_MODE.onSubmit,
   isOnBlur: mode === VALIDATION_MODE.onBlur,
@@ -624,7 +734,17 @@ var getValidationModes = (mode) => ({
   isOnAll: mode === VALIDATION_MODE.all,
   isOnTouch: mode === VALIDATION_MODE.onTouched
 });
-var isWatched = (name, _names, isBlurEvent) => !isBlurEvent && (_names.watchAll || _names.watch.has(name) || [..._names.watch].some((watchName) => name.startsWith(watchName) && /^\.\w+/.test(name.slice(watchName.length))));
+var isWatched = (name, _names, isBlurEvent) => {
+  if (isBlurEvent)
+    return false;
+  if (_names.watchAll || _names.watch.has(name))
+    return true;
+  for (const watchName of _names.watch) {
+    if (name.startsWith(watchName) && name.charAt(watchName.length) === ".")
+      return true;
+  }
+  return false;
+};
 const iterateFieldsByAction = (fields, action, fieldsNames, abortEarly) => {
   for (const key of fieldsNames || Object.keys(fields)) {
     const field = get(fields, key);
@@ -632,26 +752,31 @@ const iterateFieldsByAction = (fields, action, fieldsNames, abortEarly) => {
       const { _f, ...currentField } = field;
       if (_f) {
         if (_f.refs && _f.refs[0] && action(_f.refs[0], key) && !abortEarly) {
-          break;
+          return true;
         } else if (_f.ref && action(_f.ref, _f.name) && !abortEarly) {
-          break;
+          return true;
         } else {
-          iterateFieldsByAction(currentField, action);
+          if (iterateFieldsByAction(currentField, action)) {
+            break;
+          }
         }
       } else if (isObject(currentField)) {
-        iterateFieldsByAction(currentField, action);
+        if (iterateFieldsByAction(currentField, action)) {
+          break;
+        }
       }
     }
   }
+  return;
 };
 var updateFieldArrayRootError = (errors, error, name) => {
-  const fieldArrayErrors = compact(get(errors, name));
-  set(fieldArrayErrors, "root", error[name]);
+  const existingErrors = get(errors, name);
+  const fieldArrayErrors = Array.isArray(existingErrors) ? existingErrors : [];
+  set(fieldArrayErrors, ROOT_ERROR_TYPE, error[name]);
   set(errors, name, fieldArrayErrors);
   return errors;
 };
-var isFileInput = (element) => element.type === "file";
-var isFunction = (value) => typeof value === "function";
+var isEmptyObject = (value) => isObject(value) && !Object.keys(value).length;
 var isHTMLElement = (value) => {
   if (!isWeb) {
     return false;
@@ -659,9 +784,15 @@ var isHTMLElement = (value) => {
   const owner = value ? value.ownerDocument : 0;
   return value instanceof (owner && owner.defaultView ? owner.defaultView.HTMLElement : HTMLElement);
 };
-var isMessage = (value) => isString(value);
 var isRadioInput = (element) => element.type === "radio";
 var isRegex = (value) => value instanceof RegExp;
+var appendErrors = (name, validateAllFieldCriteria, errors, type, message) => validateAllFieldCriteria ? {
+  ...errors[name],
+  types: {
+    ...errors[name] && errors[name].types ? errors[name].types : {},
+    [type]: message || true
+  }
+} : {};
 const defaultResult = {
   value: false,
   isValid: false
@@ -689,10 +820,10 @@ var getRadioValue = (options) => Array.isArray(options) ? options.reduce((previo
   value: option.value
 } : previous, defaultReturn) : defaultReturn;
 function getValidateError(result, ref, type = "validate") {
-  if (isMessage(result) || Array.isArray(result) && result.every(isMessage) || isBoolean(result) && !result) {
+  if (isString(result) || Array.isArray(result) && result.every(isString) || isBoolean(result) && !result) {
     return {
       type,
-      message: isMessage(result) ? result : "",
+      message: isString(result) ? result : "",
       ref
     };
   }
@@ -701,16 +832,21 @@ var getValueAndMessage = (validationData) => isObject(validationData) && !isRege
   value: validationData,
   message: ""
 };
-var validateField = async (field, formValues, validateAllFieldCriteria, shouldUseNativeValidation, isFieldArray) => {
-  const { ref, refs, required, maxLength, minLength, min, max, pattern, validate, name, valueAsNumber, mount, disabled } = field._f;
+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 inputValue = get(formValues, name);
-  if (!mount || disabled) {
+  if (!mount || disabledFieldNames.has(name)) {
     return {};
   }
   const inputRef = refs ? refs[0] : ref;
   const setCustomValidity = (message) => {
     if (shouldUseNativeValidation && inputRef.reportValidity) {
-      inputRef.setCustomValidity(isBoolean(message) ? "" : message || "");
+      const validityMessage = isBoolean(message) ? "" : message || "";
+      if (refs) {
+        refs.forEach((ref2) => ref2.setCustomValidity(validityMessage));
+      } else {
+        inputRef.setCustomValidity(validityMessage);
+      }
       inputRef.reportValidity();
     }
   };
@@ -730,7 +866,7 @@ var validateField = async (field, formValues, validateAllFieldCriteria, shouldUs
     };
   };
   if (isFieldArray ? !Array.isArray(inputValue) || !inputValue.length : required && (!isRadioOrCheckbox2 && (isEmpty || isNullOrUndefined(inputValue)) || isBoolean(inputValue) && !inputValue || isCheckBox && !getCheckboxValue(refs).isValid || isRadio && !getRadioValue(refs).isValid)) {
-    const { value, message } = isMessage(required) ? { value: !!required, message: required } : getValueAndMessage(required);
+    const { value, message } = isString(required) ? { value: !!required, message: required } : getValueAndMessage(required);
     if (value) {
       error[name] = {
         type: INPUT_VALIDATION_RULES.required,
@@ -851,11 +987,18 @@ var validateField = async (field, formValues, validateAllFieldCriteria, shouldUs
   setCustomValidity(true);
   return error;
 };
+var convertToArrayPayload = (value) => Array.isArray(value) ? value : [value];
+var compact = (value) => Array.isArray(value) ? value.filter(Boolean) : [];
 function baseGet(object, updatePath) {
   const length = updatePath.slice(0, -1).length;
   let index = 0;
   while (index < length) {
-    object = isUndefined(object) ? index++ : object[updatePath[index++]];
+    if (isNullOrUndefined(object)) {
+      object = void 0;
+      break;
+    }
+    object = object[updatePath[index]];
+    index++;
   }
   return object;
 }
@@ -868,7 +1011,14 @@ function isEmptyArray(obj) {
   return true;
 }
 function unset(object, path) {
+  if (isString(path) && Object.prototype.hasOwnProperty.call(object, path)) {
+    delete object[path];
+    return object;
+  }
   const paths = Array.isArray(path) ? path : isKey(path) ? [path] : stringToPath(path);
+  if (paths.some((segment) => PROTOTYPE_KEYWORDS.includes(String(segment)))) {
+    return object;
+  }
   const childObject = paths.length === 1 ? object : baseGet(object, paths);
   const index = paths.length - 1;
   const key = paths[index];
@@ -880,6 +1030,22 @@ 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__default.default.createContext(null);
+HookFormContext.displayName = "HookFormContext";
 var createSubject = () => {
   let _observers = [];
   const next = (value) => {
@@ -907,32 +1073,23 @@ var createSubject = () => {
     unsubscribe
   };
 };
-var isPrimitive = (value) => isNullOrUndefined(value) || !isObjectType(value);
-function deepEqual(object1, object2) {
-  if (isPrimitive(object1) || isPrimitive(object2)) {
-    return object1 === object2;
-  }
-  if (isDateObject(object1) && isDateObject(object2)) {
-    return object1.getTime() === object2.getTime();
-  }
-  const keys1 = Object.keys(object1);
-  const keys2 = Object.keys(object2);
-  if (keys1.length !== keys2.length) {
-    return false;
-  }
-  for (const key of keys1) {
-    const val1 = object1[key];
-    if (!keys2.includes(key)) {
-      return false;
-    }
-    if (key !== "ref") {
-      const val2 = object2[key];
-      if (isDateObject(val1) && isDateObject(val2) || isObject(val1) && isObject(val2) || Array.isArray(val1) && Array.isArray(val2) ? !deepEqual(val1, val2) : val1 !== val2) {
-        return false;
+function extractFormValues(fieldsState, formValues) {
+  const values = {};
+  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;
+        }
+      } else if (fieldsState[key]) {
+        values[key] = fieldValue;
       }
     }
   }
-  return true;
+  return values;
 }
 var isMultipleSelect = (element) => element.type === `select-multiple`;
 var isRadioOrCheckbox = (ref) => isRadioInput(ref) || isCheckBoxInput(ref);
@@ -945,44 +1102,65 @@ var objectHasFunction = (data) => {
   }
   return false;
 };
-function markFieldsDirty(data, fields = {}) {
-  const isParentNodeArray = Array.isArray(data);
-  if (isObject(data) || isParentNodeArray) {
-    for (const key in data) {
-      if (Array.isArray(data[key]) || isObject(data[key]) && !objectHasFunction(data[key])) {
-        fields[key] = Array.isArray(data[key]) ? [] : {};
-        markFieldsDirty(data[key], fields[key]);
-      } else if (!isNullOrUndefined(data[key])) {
-        fields[key] = true;
+function isTraversable(value) {
+  return Array.isArray(value) || isObject(value) && !objectHasFunction(value);
+}
+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] = void 0;
+  } else {
+    delete container[key];
+  }
+}
+function markFieldsDirty(data, fields = {}, fieldRefs) {
+  for (const key in data) {
+    const value = data[key];
+    const fieldRef = fieldRefs && fieldRefs[key];
+    if (isTraversable(value) && (!Array.isArray(value) || !isRegisteredLeaf(fieldRef))) {
+      fields[key] = Array.isArray(value) ? [] : {};
+      markFieldsDirty(value, fields[key], fieldRef);
+      if (isEmptyDirtyContainer(fields[key])) {
+        clearDirtyField(fields, key);
       }
+    } else if (!isUndefined(value)) {
+      fields[key] = true;
     }
   }
   return fields;
 }
-function getDirtyFieldsFromDefaultValues(data, formValues, dirtyFieldsFromValues) {
-  const isParentNodeArray = Array.isArray(data);
-  if (isObject(data) || isParentNodeArray) {
-    for (const key in data) {
-      if (Array.isArray(data[key]) || isObject(data[key]) && !objectHasFunction(data[key])) {
-        if (isUndefined(formValues) || isPrimitive(dirtyFieldsFromValues[key])) {
-          dirtyFieldsFromValues[key] = Array.isArray(data[key]) ? markFieldsDirty(data[key], []) : { ...markFieldsDirty(data[key]) };
-        } else {
-          getDirtyFieldsFromDefaultValues(data[key], isNullOrUndefined(formValues) ? {} : formValues[key], dirtyFieldsFromValues[key]);
-        }
+function getDirtyFields(data, formValues, dirtyFieldsFromValues, fieldRefs) {
+  if (!dirtyFieldsFromValues) {
+    dirtyFieldsFromValues = markFieldsDirty(formValues, {}, fieldRefs);
+  }
+  for (const key in data) {
+    const value = data[key];
+    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) ? [] : {}, fieldRef);
       } else {
-        dirtyFieldsFromValues[key] = !deepEqual(data[key], formValues[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 {
+      dirtyFieldsFromValues[key] = true;
     }
   }
   return dirtyFieldsFromValues;
 }
-var getDirtyFields = (defaultValues, formValues) => getDirtyFieldsFromDefaultValues(defaultValues, formValues, markFieldsDirty(formValues));
 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;
-  if (_f.refs ? _f.refs.every((ref2) => ref2.disabled) : ref.disabled) {
-    return;
-  }
   if (isFileInput(ref)) {
     return ref.files;
   }
@@ -1011,6 +1189,22 @@ var getResolverOptions = (fieldsNames, _fields, criteriaMode, shouldUseNativeVal
   };
 };
 var getRuleValue = (rule) => isUndefined(rule) ? rule : isRegex(rule) ? rule.source : isObject(rule) ? isRegex(rule.value) ? rule.value.source : rule.value : rule;
+const ASYNC_FUNCTION = "AsyncFunction";
+var hasPromiseValidation = (fieldReference) => {
+  if (!fieldReference || !fieldReference.validate)
+    return false;
+  if (isFunction(fieldReference.validate)) {
+    return fieldReference.validate.constructor.name === ASYNC_FUNCTION;
+  }
+  if (isObject(fieldReference.validate)) {
+    for (const key in fieldReference.validate) {
+      if (fieldReference.validate[key].constructor.name === ASYNC_FUNCTION) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
 var hasValidation = (options) => options.mount && (options.required || options.min || options.max || options.maxLength || options.minLength || options.pattern || options.validate);
 function schemaErrorLookup(errors, _fields, name) {
   const error = get(errors, name);
@@ -1034,12 +1228,25 @@ function schemaErrorLookup(errors, _fields, name) {
         error: foundError
       };
     }
+    if (foundError && foundError.root && foundError.root.type) {
+      return {
+        name: `${fieldName}.root`,
+        error: foundError.root
+      };
+    }
     names.pop();
   }
   return {
     name
   };
 }
+var shouldRenderFormState = (formStateData, _proxyFormState, updateFormState, isRoot) => {
+  updateFormState(formStateData);
+  const { name, ...formState } = formStateData;
+  const keys = Object.keys(formState);
+  return !keys.length || isRoot && keys.length >= Object.keys(_proxyFormState).length || keys.find((key) => _proxyFormState[key] === (!isRoot || VALIDATION_MODE.all));
+};
+var shouldSubscribeByName = (name, signalName, exact) => !name || !signalName || name === signalName || convertToArrayPayload(name).some((currentName) => currentName && (exact ? currentName === signalName || currentName.startsWith(signalName + ".") : currentName.startsWith(signalName) || signalName.startsWith(currentName)));
 var skipValidation = (isBlurEvent, isTouched, isSubmitted, reValidateMode, mode) => {
   if (mode.isOnAll) {
     return false;
@@ -1058,24 +1265,38 @@ const defaultOptions = {
   reValidateMode: VALIDATION_MODE.onChange,
   shouldFocusError: true
 };
-function createFormControl(props = {}, flushRootRender) {
+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,
+  isReady: false,
+  isValidating: false,
+  isSubmitted: false,
+  isSubmitting: false,
+  isSubmitSuccessful: false,
+  isValid: false,
+  touchedFields: {},
+  dirtyFields: {},
+  validatingFields: {}
+};
+function createFormControl(props = {}) {
   let _options = {
     ...defaultOptions,
     ...props
   };
   let _formState = {
-    submitCount: 0,
-    isDirty: false,
+    ...cloneObject(DEFAULT_FORM_STATE),
     isLoading: isFunction(_options.defaultValues),
-    isValidating: false,
-    isSubmitted: false,
-    isSubmitting: false,
-    isSubmitSuccessful: false,
-    isValid: false,
-    touchedFields: {},
-    dirtyFields: {},
     errors: _options.errors || {},
-    disabled: false
+    disabled: _options.disabled || false
   };
   let _fields = {};
   let _defaultValues = isObject(_options.defaultValues) || isObject(_options.values) ? cloneObject(_options.defaultValues || _options.values) || {} : {};
@@ -1083,52 +1304,89 @@ function createFormControl(props = {}, flushRootRender) {
   let _state = {
     action: false,
     mount: false,
-    watch: false
+    watch: false,
+    keepIsValid: false
   };
   let _names = {
     mount: /* @__PURE__ */ new Set(),
+    disabled: /* @__PURE__ */ new Set(),
     unMount: /* @__PURE__ */ new Set(),
     array: /* @__PURE__ */ new Set(),
-    watch: /* @__PURE__ */ new Set()
+    watch: /* @__PURE__ */ new Set(),
+    registerName: /* @__PURE__ */ new Set()
   };
-  let delayErrorCallback;
-  let timer = 0;
-  const _proxyFormState = {
+  const delayErrorCallbacks = {};
+  const timers = {};
+  let _valuesSubscriberCount = 0;
+  let _validationModeBeforeSubmit = getValidationModes(_options.mode);
+  let _validationModeAfterSubmit = getValidationModes(_options.reValidateMode);
+  const defaultProxyFormState = {
     isDirty: false,
     dirtyFields: false,
+    validatingFields: false,
     touchedFields: false,
     isValidating: false,
     isValid: false,
     errors: false
   };
+  const _proxyFormState = {
+    ...defaultProxyFormState
+  };
+  let _proxySubscribeFormState = {
+    ..._proxyFormState
+  };
   const _subjects = {
-    values: createSubject(),
     array: createSubject(),
     state: createSubject()
   };
-  const shouldCaptureDirtyFields = props.resetOptions && props.resetOptions.keepDirtyValues;
-  const validationModeBeforeSubmit = getValidationModes(_options.mode);
-  const validationModeAfterSubmit = getValidationModes(_options.reValidateMode);
+  let _setValidCallId = 0;
   const shouldDisplayAllAssociatedErrors = _options.criteriaMode === VALIDATION_MODE.all;
-  const debounce = (callback) => (wait) => {
-    clearTimeout(timer);
-    timer = setTimeout(callback, wait);
-  };
-  const _updateValid = async (shouldUpdateValid) => {
-    if (_proxyFormState.isValid || shouldUpdateValid) {
-      const isValid = _options.resolver ? isEmptyObject((await _executeSchema()).errors) : await executeBuiltInValidation(_fields, true);
-      if (isValid !== _formState.isValid) {
+  const debounce = (name, callback) => (wait) => {
+    clearTimeout(timers[name]);
+    timers[name] = setTimeout(callback, wait);
+  };
+  const _setValid = async (shouldUpdateValid) => {
+    if (_state.keepIsValid) {
+      return;
+    }
+    if (!_options.disabled && (_proxyFormState.isValid || _proxySubscribeFormState.isValid || shouldUpdateValid)) {
+      const callId = ++_setValidCallId;
+      let isValid;
+      if (_options.resolver) {
+        isValid = isEmptyObject((await _runSchema()).errors);
+        callId === _setValidCallId && _updateIsValidating();
+      } else {
+        isValid = await executeBuiltInValidation({
+          fields: _fields,
+          onlyCheckValid: true,
+          eventType: EVENTS.VALID
+        });
+      }
+      if (callId === _setValidCallId && isValid !== _formState.isValid) {
         _subjects.state.next({
           isValid
         });
       }
     }
   };
-  const _updateIsValidating = (value) => _proxyFormState.isValidating && _subjects.state.next({
-    isValidating: value
-  });
-  const _updateFieldArray = (name, values = [], method, args, shouldSetValues = true, shouldUpdateFieldsAndState = true) => {
-    if (args && method) {
+  const _updateIsValidating = (names, isValidating) => {
+    if (!_options.disabled && (_proxyFormState.isValidating || _proxyFormState.validatingFields || _proxySubscribeFormState.isValidating || _proxySubscribeFormState.validatingFields)) {
+      (names || Array.from(_names.mount)).forEach((name) => {
+        if (name) {
+          isValidating ? set(_formState.validatingFields, name, isValidating) : unset(_formState.validatingFields, name);
+        }
+      });
+      _subjects.state.next({
+        validatingFields: _formState.validatingFields,
+        isValidating: !isEmptyObject(_formState.validatingFields)
+      });
+    }
+  };
+  const _updateDirtyFields = () => {
+    _formState.dirtyFields = getDirtyFields(_defaultValues, _formValues, void 0, _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);
@@ -1139,12 +1397,12 @@ function createFormControl(props = {}, flushRootRender) {
         shouldSetValues && set(_formState.errors, name, errors);
         unsetEmptyArray(_formState.errors, name);
       }
-      if (_proxyFormState.touchedFields && shouldUpdateFieldsAndState && Array.isArray(get(_formState.touchedFields, name))) {
+      if ((_proxyFormState.touchedFields || _proxySubscribeFormState.touchedFields) && shouldUpdateFieldsAndState && Array.isArray(get(_formState.touchedFields, name))) {
         const touchedFields = method(get(_formState.touchedFields, name), args.argA, args.argB);
         shouldSetValues && set(_formState.touchedFields, name, touchedFields);
       }
-      if (_proxyFormState.dirtyFields) {
-        _formState.dirtyFields = getDirtyFields(_defaultValues, _formValues);
+      if (_proxyFormState.dirtyFields || _proxySubscribeFormState.dirtyFields) {
+        _updateDirtyFields();
       }
       _subjects.state.next({
         name,
@@ -1159,6 +1417,7 @@ function createFormControl(props = {}, flushRootRender) {
   };
   const updateErrors = (name, error) => {
     set(_formState.errors, name, error);
+    _formState.errors = { ..._formState.errors };
     _subjects.state.next({
       errors: _formState.errors
     });
@@ -1170,12 +1429,42 @@ function createFormControl(props = {}, flushRootRender) {
       isValid: false
     });
   };
+  const hasExplicitNullIntermediate = (name) => {
+    const segments = isKey(name) ? [name] : stringToPath(name);
+    let formValues = _formValues;
+    let defaultValues = _defaultValues;
+    for (let i = 0; i < segments.length - 1; i++) {
+      const key = segments[i];
+      formValues = isNullOrUndefined(formValues) ? formValues : formValues[key];
+      defaultValues = isNullOrUndefined(defaultValues) ? defaultValues : defaultValues[key];
+      if (formValues === null && defaultValues !== null) {
+        return true;
+      }
+    }
+    return false;
+  };
   const updateValidAndValue = (name, shouldSkipSetValueAs, value, ref) => {
     const field = get(_fields, name);
     if (field) {
+      if (hasExplicitNullIntermediate(name)) {
+        return;
+      }
+      const wasUnsetInFormValues = isUndefined(get(_formValues, name));
       const defaultValue = get(_formValues, name, isUndefined(value) ? get(_defaultValues, name) : value);
       isUndefined(defaultValue) || ref && ref.defaultChecked || shouldSkipSetValueAs ? set(_formValues, name, shouldSkipSetValueAs ? defaultValue : getFieldValue(field._f)) : setFieldValue(name, defaultValue);
-      _state.mount && _updateValid();
+      if (_state.mount && !_state.action) {
+        _setValid();
+        if (wasUnsetInFormValues && _formState.isDirty && (_proxyFormState.isDirty || _proxySubscribeFormState.isDirty)) {
+          const isDirty = _getDirty();
+          if (!isDirty) {
+            _formState.isDirty = false;
+            _subjects.state.next({ ..._formState });
+          }
+        }
+        if (props.shouldUnregister && wasUnsetInFormValues && !isUndefined(get(_formValues, name)) && isWatched(name, _names)) {
+          _state.watch = true;
+        }
+      }
     }
   };
   const updateTouchAndDirty = (name, fieldValue, isBlurEvent, shouldDirty, shouldRender) => {
@@ -1184,40 +1473,46 @@ function createFormControl(props = {}, flushRootRender) {
     const output = {
       name
     };
-    const disabledField = get(_fields, name) && get(_fields, name)._f.disabled;
-    if (!isBlurEvent || shouldDirty) {
-      if (_proxyFormState.isDirty) {
-        isPreviousDirty = _formState.isDirty;
-        _formState.isDirty = output.isDirty = _getDirty();
-        shouldUpdateField = isPreviousDirty !== output.isDirty;
-      }
-      const isCurrentFieldPristine = disabledField || deepEqual(get(_defaultValues, name), fieldValue);
-      isPreviousDirty = !disabledField && get(_formState.dirtyFields, name);
-      isCurrentFieldPristine || disabledField ? unset(_formState.dirtyFields, name) : set(_formState.dirtyFields, name, true);
-      output.dirtyFields = _formState.dirtyFields;
-      shouldUpdateField = shouldUpdateField || _proxyFormState.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 && isPreviousFieldTouched !== isBlurEvent;
-      }
-    }
-    shouldUpdateField && shouldRender && _subjects.state.next(output);
+    if (!_options.disabled || shouldDirty === true) {
+      if (!isBlurEvent || shouldDirty) {
+        const isCurrentFieldPristine = deepEqual(get(_defaultValues, name), fieldValue);
+        if (_proxyFormState.isDirty || _proxySubscribeFormState.isDirty) {
+          isPreviousDirty = _formState.isDirty;
+          _formState.isDirty = output.isDirty = !isCurrentFieldPristine || _getDirty();
+          shouldUpdateField = isPreviousDirty !== output.isDirty;
+        }
+        isPreviousDirty = !!get(_formState.dirtyFields, name);
+        if (isCurrentFieldPristine !== _formState.isDirty) {
+          updateDirtyFields(_formState.dirtyFields, getDirtyFields(_defaultValues, _formValues, void 0, _fields));
+        } else {
+          isCurrentFieldPristine ? unset(_formState.dirtyFields, name) : set(_formState.dirtyFields, name, true);
+        }
+        output.dirtyFields = _formState.dirtyFields;
+        shouldUpdateField = shouldUpdateField || (_proxyFormState.dirtyFields || _proxySubscribeFormState.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 && shouldRender && _subjects.state.next(output);
+    }
     return shouldUpdateField ? output : {};
   };
   const shouldRenderByError = (name, isValid, error, fieldState) => {
     const previousFieldError = get(_formState.errors, name);
-    const shouldUpdateValid = _proxyFormState.isValid && isBoolean(isValid) && _formState.isValid !== isValid;
-    if (props.delayError && error) {
-      delayErrorCallback = debounce(() => updateErrors(name, error));
-      delayErrorCallback(props.delayError);
+    const shouldUpdateValid = (_proxyFormState.isValid || _proxySubscribeFormState.isValid) && isBoolean(isValid) && _formState.isValid !== isValid;
+    if (_options.delayError && error) {
+      delayErrorCallbacks[name] = debounce(name, () => updateErrors(name, error));
+      delayErrorCallbacks[name](_options.delayError);
     } else {
-      clearTimeout(timer);
-      delayErrorCallback = null;
+      clearTimeout(timers[name]);
+      delete delayErrorCallbacks[name];
       error ? set(_formState.errors, name, error) : unset(_formState.errors, name);
+      _formState.errors = { ..._formState.errors };
     }
     if ((error ? !deepEqual(previousFieldError, error) : previousFieldError) || !isEmptyObject(fieldState) || shouldUpdateValid) {
       const updatedFormState = {
@@ -1232,40 +1527,105 @@ function createFormControl(props = {}, flushRootRender) {
       };
       _subjects.state.next(updatedFormState);
     }
-    _updateIsValidating(false);
   };
-  const _executeSchema = async (name) => _options.resolver(_formValues, _options.context, getResolverOptions(name || _names.mount, _fields, _options.criteriaMode, _options.shouldUseNativeValidation));
+  const _runSchema = async (name) => {
+    _updateIsValidating(name, true);
+    return await _options.resolver(_formValues, _options.context, getResolverOptions(name || _names.mount, _fields, _options.criteriaMode, _options.shouldUseNativeValidation));
+  };
   const executeSchemaAndUpdateState = async (names) => {
-    const { errors } = await _executeSchema(names);
+    const { errors } = await _runSchema(names);
+    _updateIsValidating(names);
     if (names) {
       for (const name of names) {
         const error = get(errors, name);
-        error ? set(_formState.errors, name, error) : unset(_formState.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);
       }
+      _formState.errors = { ..._formState.errors };
     } else {
       _formState.errors = errors;
     }
     return errors;
   };
-  const executeBuiltInValidation = async (fields, shouldOnlyCheckValid, context = {
-    valid: true
-  }) => {
-    for (const name in fields) {
-      const field = fields[name];
+  const validateForm = async ({ name, eventType }) => {
+    if (props.validate) {
+      const result = await props.validate({
+        formValues: _formValues,
+        formState: _formState,
+        name,
+        eventType
+      });
+      if (isObject(result)) {
+        for (const key in result) {
+          const error = result[key];
+          if (error) {
+            setError(`${FORM_ERROR_TYPE}.${key}`, {
+              message: isString(error.message) ? error.message : "",
+              type: error.type || INPUT_VALIDATION_RULES.validate
+            });
+          }
+        }
+      } else if (isString(result) || !result) {
+        setError(FORM_ERROR_TYPE, {
+          message: result || "",
+          type: INPUT_VALIDATION_RULES.validate
+        });
+      } else {
+        clearErrors(FORM_ERROR_TYPE);
+      }
+      return result;
+    }
+    return true;
+  };
+  const executeBuiltInValidation = async ({ fields, onlyCheckValid, name, eventType, context = {
+    valid: true,
+    runRootValidation: false
+  } }) => {
+    if (props.validate) {
+      context.runRootValidation = true;
+      const result = await validateForm({
+        name,
+        eventType
+      });
+      if (!result) {
+        context.valid = false;
+        if (onlyCheckValid) {
+          return context.valid;
+        }
+      }
+    }
+    for (const name2 in fields) {
+      const field = fields[name2];
       if (field) {
         const { _f, ...fieldValue } = field;
         if (_f) {
           const isFieldArrayRoot = _names.array.has(_f.name);
-          const fieldError = await validateField(field, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation && !shouldOnlyCheckValid, isFieldArrayRoot);
+          const isPromiseFunction = field._f && hasPromiseValidation(field._f);
+          const shouldTrackIsValidatingState = _proxyFormState.validatingFields || _proxyFormState.isValidating || _proxySubscribeFormState.validatingFields || _proxySubscribeFormState.isValidating;
+          if (isPromiseFunction && shouldTrackIsValidatingState) {
+            _updateIsValidating([_f.name], true);
+          }
+          const fieldError = await validateField(field, _names.disabled, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation && !onlyCheckValid, isFieldArrayRoot);
+          if (isPromiseFunction && shouldTrackIsValidatingState) {
+            _updateIsValidating([_f.name]);
+          }
           if (fieldError[_f.name]) {
             context.valid = false;
-            if (shouldOnlyCheckValid) {
+            if (onlyCheckValid) {
               break;
             }
           }
-          !shouldOnlyCheckValid && (get(fieldError, _f.name) ? isFieldArrayRoot ? updateFieldArrayRootError(_formState.errors, fieldError, _f.name) : set(_formState.errors, _f.name, fieldError[_f.name]) : unset(_formState.errors, _f.name));
+          !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 (props.shouldUseNativeValidation && fieldError[_f.name]) {
+            break;
+          }
         }
-        fieldValue && await executeBuiltInValidation(fieldValue, shouldOnlyCheckValid, context);
+        !isEmptyObject(fieldValue) && await executeBuiltInValidation({
+          context,
+          onlyCheckValid,
+          fields: fieldValue,
+          name: name2,
+          eventType
+        });
       }
     }
     return context.valid;
@@ -1277,12 +1637,12 @@ function createFormControl(props = {}, flushRootRender) {
     }
     _names.unMount = /* @__PURE__ */ new Set();
   };
-  const _getDirty = (name, data) => (name && data && set(_formValues, name, data), !deepEqual(getValues(), _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) ? _defaultValues : isString(names) ? { [names]: defaultValue } : defaultValue
   }, isGlobal, defaultValue);
-  const _getFieldArray = (name) => compact(get(_state.mount ? _formValues : _defaultValues, name, props.shouldUnregister ? get(_defaultValues, name, []) : []));
-  const setFieldValue = (name, value, options = {}) => {
+  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 field = get(_fields, name);
     let fieldValue = value;
     if (field) {
@@ -1294,7 +1654,15 @@ function createFormControl(props = {}, flushRootRender) {
           [...fieldReference.ref.options].forEach((optionRef) => optionRef.selected = fieldValue.includes(optionRef.value));
         } else if (fieldReference.refs) {
           if (isCheckBoxInput(fieldReference.ref)) {
-            fieldReference.refs.length > 1 ? fieldReference.refs.forEach((checkboxRef) => (!checkboxRef.defaultChecked || !checkboxRef.disabled) && (checkboxRef.checked = Array.isArray(fieldValue) ? !!fieldValue.find((data) => data === checkboxRef.value) : fieldValue === checkboxRef.value)) : fieldReference.refs[0] && (fieldReference.refs[0].checked = !!fieldValue);
+            fieldReference.refs.forEach((checkboxRef) => {
+              if (!checkboxRef.defaultChecked || !checkboxRef.disabled) {
+                if (Array.isArray(fieldValue)) {
+                  checkboxRef.checked = !!fieldValue.find((data) => data === checkboxRef.value);
+                } else {
+                  checkboxRef.checked = fieldValue === checkboxRef.value || !!fieldValue;
+                }
+              }
+            });
           } else {
             fieldReference.refs.forEach((radioRef) => radioRef.checked = radioRef.value === fieldValue);
           }
@@ -1302,112 +1670,184 @@ function createFormControl(props = {}, flushRootRender) {
           fieldReference.ref.value = "";
         } else {
           fieldReference.ref.value = fieldValue;
-          if (!fieldReference.ref.type) {
-            _subjects.values.next({
+          if (!fieldReference.ref.type && !skipRender) {
+            _subjects.state.next({
               name,
-              values: { ..._formValues }
+              values: skipClone ? _formValues : cloneObject(_formValues)
             });
           }
         }
       }
     }
-    (options.shouldDirty || options.shouldTouch) && updateTouchAndDirty(name, fieldValue, options.shouldTouch, options.shouldDirty, true);
-    options.shouldValidate && trigger(name);
+    (options.shouldDirty || options.shouldTouch) && updateTouchAndDirty(name, fieldValue, options.shouldTouch, options.shouldDirty, !skipRender);
+    options.shouldValidate && trigger(name, {
+      delayError: options.delayError
+    });
   };
-  const setValues = (name, value, options) => {
+  const setFieldValues = (name, value, options, skipClone = false, skipRender = false) => {
     for (const fieldKey in value) {
+      if (!value.hasOwnProperty(fieldKey)) {
+        return;
+      }
       const fieldValue = value[fieldKey];
-      const fieldName = `${name}.${fieldKey}`;
+      const fieldName = name + "." + fieldKey;
       const field = get(_fields, fieldName);
-      (_names.array.has(name) || !isPrimitive(fieldValue) || field && !field._f) && !isDateObject(fieldValue) ? setValues(fieldName, fieldValue, options) : setFieldValue(fieldName, fieldValue, options);
+      (_names.array.has(name) || isObject(fieldValue) || field && !field._f) && !isDateObject(fieldValue) ? setFieldValues(fieldName, fieldValue, options, skipClone, skipRender) : setFieldValue(fieldName, fieldValue, options, skipClone, skipRender);
     }
   };
-  const setValue = (name, value, options = {}) => {
+  const _setValue = (name, value, options, skipClone, skipStateEmit = false) => {
     const field = get(_fields, name);
     const isFieldArray = _names.array.has(name);
-    const cloneValue = cloneObject(value);
-    set(_formValues, name, cloneValue);
+    const cloneValue = skipClone ? value : cloneObject(value);
+    const previousValue = get(_formValues, name);
+    const isValueUnchanged = deepEqual(previousValue, cloneValue);
+    if (!isValueUnchanged) {
+      set(_formValues, name, cloneValue);
+    }
     if (isFieldArray) {
       _subjects.array.next({
         name,
-        values: { ..._formValues }
+        values: skipClone ? _formValues : cloneObject(_formValues)
       });
-      if ((_proxyFormState.isDirty || _proxyFormState.dirtyFields) && options.shouldDirty) {
-        _subjects.state.next({
-          name,
-          dirtyFields: getDirtyFields(_defaultValues, _formValues),
-          isDirty: _getDirty(name, cloneValue)
-        });
+      if ((_proxyFormState.isDirty || _proxyFormState.dirtyFields || _proxySubscribeFormState.isDirty || _proxySubscribeFormState.dirtyFields) && options.shouldDirty) {
+        _updateDirtyFields();
+        if (!skipStateEmit) {
+          _subjects.state.next({
+            name,
+            dirtyFields: _formState.dirtyFields,
+            isDirty: _getDirty(name, cloneValue)
+          });
+        }
       }
     } else {
-      field && !field._f && !isNullOrUndefined(cloneValue) ? setValues(name, cloneValue, options) : setFieldValue(name, cloneValue, options);
+      const isEmpty = Array.isArray(cloneValue) && !cloneValue.length || isEmptyObject(cloneValue);
+      if (!field || field._f || isNullOrUndefined(cloneValue) || isEmpty) {
+        setFieldValue(name, cloneValue, options, skipClone, skipStateEmit);
+      } else {
+        setFieldValues(name, cloneValue, options, skipClone, skipStateEmit);
+      }
+    }
+    if (!isValueUnchanged && !skipStateEmit) {
+      const watched = isWatched(name, _names);
+      const values = skipClone ? _formValues : cloneObject(_formValues);
+      _subjects.state.next({
+        ...watched && _formState,
+        name: _state.mount || watched ? name : void 0,
+        values
+      });
+    }
+  };
+  const setValue = (name, value, options = {}) => _setValue(name, value, options, false);
+  const setValues = (formValues, options = {}) => {
+    const updatedFormValues = isFunction(formValues) ? formValues(_formValues) : formValues;
+    if (!deepEqual(_formValues, updatedFormValues)) {
+      _formValues = {
+        ..._formValues,
+        ...updatedFormValues
+      };
+      const flattenedUpdates = flatten(updatedFormValues);
+      for (const fieldName of _names.mount) {
+        if (fieldName in flattenedUpdates) {
+          _setValue(fieldName, flattenedUpdates[fieldName], options, true, true);
+        }
+      }
+      _subjects.state.next({
+        ..._formState,
+        name: void 0,
+        type: void 0,
+        ..._valuesSubscriberCount ? { values: _formValues } : {}
+      });
+      if (options.shouldValidate) {
+        _setValid();
+      }
     }
-    isWatched(name, _names) && _subjects.state.next({ ..._formState });
-    _subjects.values.next({
-      name,
-      values: { ..._formValues }
-    });
-    !_state.mount && flushRootRender();
   };
   const onChange = async (event) => {
+    _state.mount = true;
     const target = event.target;
     let name = target.name;
     let isFieldValueUpdated = true;
     const field = get(_fields, name);
-    const getCurrentFieldValue = () => target.type ? getFieldValue(field._f) : getEventValue(event);
     const _updateIsFieldValueUpdated = (fieldValue) => {
-      isFieldValueUpdated = Number.isNaN(fieldValue) || fieldValue === get(_formValues, name, fieldValue);
+      isFieldValueUpdated = Number.isNaN(fieldValue) || isDateObject(fieldValue) && isNaN(fieldValue.getTime()) || deepEqual(fieldValue, get(_formValues, name, fieldValue));
     };
     if (field) {
       let error;
       let isValid;
-      const fieldValue = getCurrentFieldValue();
+      const fieldValue = target.type ? getFieldValue(field._f) : getEventValue(event);
       const isBlurEvent = event.type === EVENTS.BLUR || event.type === EVENTS.FOCUS_OUT;
-      const shouldSkipValidation = !hasValidation(field._f) && !_options.resolver && !get(_formState.errors, name) && !field._f.deps || skipValidation(isBlurEvent, get(_formState.touchedFields, name), _formState.isSubmitted, validationModeAfterSubmit, validationModeBeforeSubmit);
+      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);
       if (isBlurEvent) {
-        field._f.onBlur && field._f.onBlur(event);
-        delayErrorCallback && delayErrorCallback(0);
+        if (!target || !target.readOnly) {
+          field._f.onBlur && field._f.onBlur(event);
+          const pendingDelayError = delayErrorCallbacks[name];
+          pendingDelayError && pendingDelayError(0);
+        }
       } else if (field._f.onChange) {
         field._f.onChange(event);
       }
-      const fieldState = updateTouchAndDirty(name, fieldValue, isBlurEvent, false);
+      const fieldState = updateTouchAndDirty(name, fieldValue, isBlurEvent);
       const shouldRender = !isEmptyObject(fieldState) || watched;
-      !isBlurEvent && _subjects.values.next({
+      !isBlurEvent && _subjects.state.next({
         name,
         type: event.type,
-        values: { ..._formValues }
+        ..._valuesSubscriberCount ? { values: cloneObject(_formValues) } : {}
       });
       if (shouldSkipValidation) {
-        _proxyFormState.isValid && _updateValid();
+        if ((!hasNoValidationEffect || !_formState.isValid) && (_proxyFormState.isValid || _proxySubscribeFormState.isValid)) {
+          if (_options.mode === "onBlur") {
+            if (isBlurEvent) {
+              _setValid();
+            }
+          } else if (!isBlurEvent) {
+            _setValid();
+          }
+        }
         return shouldRender && _subjects.state.next({ name, ...watched ? {} : fieldState });
       }
+      if (!_options.resolver && props.validate) {
+        await validateForm({
+          name,
+          eventType: event.type
+        });
+      }
       !isBlurEvent && watched && _subjects.state.next({ ..._formState });
-      _updateIsValidating(true);
       if (_options.resolver) {
-        const { errors } = await _executeSchema([name]);
+        const { errors } = await _runSchema([name]);
+        _updateIsValidating([name]);
         _updateIsFieldValueUpdated(fieldValue);
-        if (isFieldValueUpdated) {
-          const previousErrorLookupResult = schemaErrorLookup(_formState.errors, _fields, name);
-          const errorLookupResult = schemaErrorLookup(errors, _fields, previousErrorLookupResult.name || name);
-          error = errorLookupResult.error;
-          name = errorLookupResult.name;
-          isValid = isEmptyObject(errors);
+        if (!isFieldValueUpdated) {
+          !isEmptyObject(fieldState) && _subjects.state.next(fieldState);
+          return;
         }
+        const previousErrorLookupResult = schemaErrorLookup(_formState.errors, _fields, name);
+        const errorLookupResult = schemaErrorLookup(errors, _fields, previousErrorLookupResult.name || name);
+        error = errorLookupResult.error;
+        name = errorLookupResult.name;
+        isValid = isEmptyObject(errors);
       } else {
-        error = (await validateField(field, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation))[name];
+        _updateIsValidating([name], true);
+        error = (await validateField(field, _names.disabled, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation))[name];
+        _updateIsValidating([name]);
         _updateIsFieldValueUpdated(fieldValue);
         if (isFieldValueUpdated) {
           if (error) {
             isValid = false;
-          } else if (_proxyFormState.isValid) {
-            isValid = await executeBuiltInValidation(_fields, true);
+          } else if (_proxyFormState.isValid || _proxySubscribeFormState.isValid) {
+            isValid = await executeBuiltInValidation({
+              fields: _fields,
+              onlyCheckValid: true,
+              name,
+              eventType: event.type
+            });
           }
         }
       }
       if (isFieldValueUpdated) {
-        field._f.deps && trigger(field._f.deps);
+        field._f.deps && (!Array.isArray(field._f.deps) || field._f.deps.length > 0) && trigger(field._f.deps);
         shouldRenderByError(name, isValid, error, fieldState);
       }
     }
@@ -1423,7 +1863,6 @@ function createFormControl(props = {}, flushRootRender) {
     let isValid;
     let validationResult;
     const fieldNames = convertToArrayPayload(name);
-    _updateIsValidating(true);
     if (_options.resolver) {
       const errors = await executeSchemaAndUpdateState(isUndefined(name) ? name : fieldNames);
       isValid = isEmptyObject(errors);
@@ -1431,43 +1870,77 @@ function createFormControl(props = {}, flushRootRender) {
     } else if (name) {
       validationResult = (await Promise.all(fieldNames.map(async (fieldName) => {
         const field = get(_fields, fieldName);
-        return await executeBuiltInValidation(field && field._f ? { [fieldName]: field } : field);
+        return await executeBuiltInValidation({
+          fields: field && field._f ? { [fieldName]: field } : field,
+          eventType: EVENTS.TRIGGER
+        });
       }))).every(Boolean);
-      !(!validationResult && !_formState.isValid) && _updateValid();
+      !(!validationResult && !_formState.isValid) && _setValid();
     } else {
-      validationResult = isValid = await executeBuiltInValidation(_fields);
+      validationResult = isValid = await executeBuiltInValidation({
+        fields: _fields,
+        name,
+        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 {
+        clearTimeout(timers[name]);
+        delete delayErrorCallbacks[name];
+      }
     }
     _subjects.state.next({
-      ...!isString(name) || _proxyFormState.isValid && isValid !== _formState.isValid ? {} : { name },
+      ...!isString(name) || (_proxyFormState.isValid || _proxySubscribeFormState.isValid) && isValid !== _formState.isValid ? {} : { name },
       ..._options.resolver || !name ? { isValid } : {},
-      errors: _formState.errors,
-      isValidating: false
+      errors: _formState.errors
     });
     options.shouldFocus && !validationResult && iterateFieldsByAction(_fields, _focusInput, name ? fieldNames : _names.mount);
     return validationResult;
   };
-  const getValues = (fieldNames) => {
-    const values = {
-      ..._defaultValues,
-      ..._state.mount ? _formValues : {}
+  const getValues = (fieldNames, config2) => {
+    let values = {
+      ..._state.mount ? _formValues : _defaultValues
     };
+    if (config2) {
+      values = extractFormValues(config2.dirtyFields ? _formState.dirtyFields : _formState.touchedFields, values);
+    }
     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),
-    isTouched: !!get((formState || _formState).touchedFields, name),
-    error: get((formState || _formState).errors, name)
+    error: get((formState || _formState).errors, name),
+    isValidating: !!get(_formState.validatingFields, name),
+    isTouched: !!get((formState || _formState).touchedFields, name)
   });
   const clearErrors = (name) => {
-    name && convertToArrayPayload(name).forEach((inputName) => unset(_formState.errors, inputName));
-    _subjects.state.next({
-      errors: name ? _formState.errors : {}
-    });
+    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) => {
+        _subjects.state.next({
+          name: inputName,
+          errors: _formState.errors
+        });
+      });
+    } else {
+      _formState.errors = {};
+      _subjects.state.next({
+        errors: _formState.errors
+      });
+    }
   };
   const setError = (name, error, options) => {
     const ref = (get(_fields, name, { _f: {} })._f || {}).ref;
+    const currentError = get(_formState.errors, name) || {};
+    const { ref: currentRef, message, type, ...restOfErrorTree } = currentError;
     set(_formState.errors, name, {
+      ...restOfErrorTree,
       ...error,
       ref
     });
@@ -1478,9 +1951,72 @@ function createFormControl(props = {}, flushRootRender) {
     });
     options && options.shouldFocus && ref && ref.focus && ref.focus();
   };
-  const watch = (name, defaultValue) => isFunction(name) ? _subjects.values.subscribe({
-    next: (payload) => name(_getWatch(void 0, defaultValue), payload)
-  }) : _getWatch(name, defaultValue, true);
+  const watch = (name, defaultValue) => {
+    if (isFunction(name)) {
+      _valuesSubscriberCount++;
+      const { unsubscribe } = _subjects.state.subscribe({
+        next: (payload) => "values" in payload && name(payload.values || _getWatch(void 0, defaultValue), payload)
+      });
+      let called = false;
+      return {
+        unsubscribe: () => {
+          if (called) {
+            return;
+          }
+          called = true;
+          _valuesSubscriberCount--;
+          unsubscribe();
+        }
+      };
+    }
+    return _getWatch(name, defaultValue, true);
+  };
+  const _subscribe = (props2) => {
+    var _a;
+    const needsValues = !!((_a = props2.formState) === null || _a === void 0 ? void 0 : _a.values);
+    if (needsValues) {
+      _valuesSubscriberCount++;
+    }
+    const { unsubscribe } = _subjects.state.subscribe({
+      next: (formState) => {
+        if (shouldSubscribeByName(props2.name, formState.name, props2.exact) && shouldRenderFormState(formState, props2.formState || _proxyFormState, _setFormState, props2.reRenderRoot)) {
+          const snapshot = { ..._formValues };
+          props2.callback({
+            values: snapshot,
+            ..._formState,
+            ...formState,
+            defaultValues: _defaultValues
+          });
+        }
+      }
+    });
+    if (!needsValues) {
+      return unsubscribe;
+    }
+    let called = false;
+    return () => {
+      if (called) {
+        return;
+      }
+      called = true;
+      _valuesSubscriberCount--;
+      unsubscribe();
+    };
+  };
+  const subscribe = (props2) => {
+    _state.mount = true;
+    _proxySubscribeFormState = {
+      ..._proxySubscribeFormState,
+      ...props2.formState
+    };
+    return _subscribe({
+      ...props2,
+      formState: {
+        ...defaultProxyFormState,
+        ...props2.formState
+      }
+    });
+  };
   const unregister = (name, options = {}) => {
     for (const fieldName of name ? convertToArrayPayload(name) : _names.mount) {
       _names.mount.delete(fieldName);
@@ -1492,27 +2028,31 @@ function createFormControl(props = {}, flushRootRender) {
       !options.keepError && 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.values.next({
-      values: { ..._formValues }
+    _subjects.state.next({
+      values: cloneObject(_formValues)
     });
     _subjects.state.next({
       ..._formState,
       ...!options.keepDirty ? {} : { isDirty: _getDirty() }
     });
-    !options.keepIsValid && _updateValid();
+    !options.keepIsValid && _setValid();
   };
-  const _updateDisabledField = ({ disabled, name, field, fields, value }) => {
-    if (isBoolean(disabled)) {
-      const inputValue = disabled ? void 0 : isUndefined(value) ? getFieldValue(field ? field._f : get(fields, name)._f) : value;
-      set(_formValues, name, inputValue);
-      updateTouchAndDirty(name, inputValue, false, false, true);
+  const _setDisabledField = ({ disabled, name }) => {
+    if (isBoolean(disabled) && _state.mount || !!disabled || _names.disabled.has(name)) {
+      const wasDisabled = _names.disabled.has(name);
+      const isDisabled = !!disabled;
+      const disabledStateChanged = wasDisabled !== isDisabled;
+      disabled ? _names.disabled.add(name) : _names.disabled.delete(name);
+      disabledStateChanged && _state.mount && !_state.action && _setValid();
     }
   };
   const register = (name, options = {}) => {
     let field = get(_fields, name);
-    const disabledIsDefined = isBoolean(options.disabled);
+    const disabledIsDefined = isBoolean(options.disabled) || isBoolean(_options.disabled);
+    const shouldRevalidateRemount = !_names.registerName.has(name) && field && field._f && !field._f.mount;
     set(_fields, name, {
       ...field || {},
       _f: {
@@ -1523,17 +2063,16 @@ function createFormControl(props = {}, flushRootRender) {
       }
     });
     _names.mount.add(name);
-    if (field) {
-      _updateDisabledField({
-        field,
-        disabled: options.disabled,
+    if (field && !shouldRevalidateRemount) {
+      _setDisabledField({
+        disabled: isBoolean(options.disabled) ? options.disabled : _options.disabled,
         name
       });
     } else {
       updateValidAndValue(name, true, options.value);
     }
     return {
-      ...disabledIsDefined ? { disabled: options.disabled } : {},
+      ...disabledIsDefined ? { disabled: options.disabled || _options.disabled } : {},
       ..._options.progressive ? {
         required: !!options.required,
         min: getRuleValue(options.min),
@@ -1547,7 +2086,9 @@ function createFormControl(props = {}, flushRootRender) {
       onBlur: onChange,
       ref: (ref) => {
         if (ref) {
+          _names.registerName.add(name);
           register(name, options);
+          _names.registerName.delete(name);
           field = get(_fields, name);
           const fieldRef = isUndefined(ref.value) ? ref.querySelectorAll ? ref.querySelectorAll("input,select,textarea")[0] || ref : ref : ref;
           const radioOrCheckbox = isRadioOrCheckbox(fieldRef);
@@ -1555,18 +2096,22 @@ function createFormControl(props = {}, flushRootRender) {
           if (radioOrCheckbox ? refs.find((option) => option === fieldRef) : 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, void 0, fieldRef);
         } else {
@@ -1579,21 +2124,25 @@ function createFormControl(props = {}, flushRootRender) {
       }
     };
   };
-  const _focusError = () => _options.shouldFocusError && iterateFieldsByAction(_fields, _focusInput, _names.mount);
+  const _focusError = () => _options.shouldFocusError && !_options.shouldUseNativeValidation && iterateFieldsByAction(_fields, _focusInput, _names.mount);
   const _disableForm = (disabled) => {
     if (isBoolean(disabled)) {
       _subjects.state.next({ disabled });
       iterateFieldsByAction(_fields, (ref, name) => {
-        let requiredDisabledState = disabled;
         const currentField = get(_fields, name);
-        if (currentField && isBoolean(currentField._f.disabled)) {
-          requiredDisabledState || (requiredDisabledState = currentField._f.disabled);
+        if (currentField) {
+          ref.disabled = currentField._f.disabled || disabled;
+          if (Array.isArray(currentField._f.refs)) {
+            currentField._f.refs.forEach((inputRef) => {
+              inputRef.disabled = currentField._f.disabled || disabled;
+            });
+          }
         }
-        ref.disabled = requiredDisabledState;
       }, 0, false);
     }
   };
   const handleSubmit = (onValid, onInvalid) => async (e) => {
+    let onValidError = void 0;
     if (e) {
       e.preventDefault && e.preventDefault();
       e.persist && e.persist();
@@ -1603,18 +2152,31 @@ function createFormControl(props = {}, flushRootRender) {
       isSubmitting: true
     });
     if (_options.resolver) {
-      const { errors, values } = await _executeSchema();
+      const { errors, values } = await _runSchema();
+      _updateIsValidating();
       _formState.errors = errors;
-      fieldValues = values;
+      fieldValues = cloneObject(values);
     } else {
-      await executeBuiltInValidation(_fields);
+      await executeBuiltInValidation({
+        fields: _fields,
+        eventType: EVENTS.SUBMIT
+      });
     }
-    unset(_formState.errors, "root");
+    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: {}
       });
-      await onValid(fieldValues, e);
+      try {
+        await onValid(fieldValues, e);
+      } catch (error) {
+        onValidError = error;
+      }
     } else {
       if (onInvalid) {
         await onInvalid({ ..._formState.errors }, e);
@@ -1625,29 +2187,32 @@ function createFormControl(props = {}, flushRootRender) {
     _subjects.state.next({
       isSubmitted: true,
       isSubmitting: false,
-      isSubmitSuccessful: isEmptyObject(_formState.errors),
+      isSubmitSuccessful: isEmptyObject(_formState.errors) && !onValidError,
       submitCount: _formState.submitCount + 1,
       errors: _formState.errors
     });
+    if (onValidError) {
+      throw onValidError;
+    }
   };
   const resetField = (name, options = {}) => {
     if (get(_fields, name)) {
       if (isUndefined(options.defaultValue)) {
-        setValue(name, get(_defaultValues, name));
+        setValue(name, cloneObject(get(_defaultValues, name)));
       } else {
         setValue(name, options.defaultValue);
-        set(_defaultValues, name, options.defaultValue);
+        set(_defaultValues, name, cloneObject(options.defaultValue));
       }
       if (!options.keepTouched) {
         unset(_formState.touchedFields, name);
       }
       if (!options.keepDirty) {
         unset(_formState.dirtyFields, name);
-        _formState.isDirty = options.defaultValue ? _getDirty(name, get(_defaultValues, name)) : _getDirty();
+        _formState.isDirty = options.defaultValue ? _getDirty(name, cloneObject(get(_defaultValues, name))) : _getDirty();
       }
       if (!options.keepError) {
         unset(_formState.errors, name);
-        _proxyFormState.isValid && _updateValid();
+        _proxyFormState.isValid && _setValid();
       }
       _subjects.state.next({ ..._formState });
     }
@@ -1655,14 +2220,27 @@ function createFormControl(props = {}, flushRootRender) {
   const _reset = (formValues, keepStateOptions = {}) => {
     const updatedValues = formValues ? cloneObject(formValues) : _defaultValues;
     const cloneUpdatedValues = cloneObject(updatedValues);
-    const values = formValues && !isEmptyObject(formValues) ? cloneUpdatedValues : _defaultValues;
+    const isEmptyResetValues = isEmptyObject(formValues);
+    const values = cloneUpdatedValues;
+    const fieldRefs = _fields;
     if (!keepStateOptions.keepDefaultValues) {
       _defaultValues = updatedValues;
     }
     if (!keepStateOptions.keepValues) {
-      if (keepStateOptions.keepDirtyValues || shouldCaptureDirtyFields) {
-        for (const fieldName of _names.mount) {
-          get(_formState.dirtyFields, fieldName) ? set(values, fieldName, get(_formValues, fieldName)) : setValue(fieldName, get(values, fieldName));
+      if (keepStateOptions.keepDirtyValues) {
+        const fieldsToCheck = /* @__PURE__ */ new Set([
+          ..._names.mount,
+          ...Object.keys(getDirtyFields(_defaultValues, _formValues, void 0, fieldRefs))
+        ]);
+        for (const fieldName of Array.from(fieldsToCheck)) {
+          const isDirty = get(_formState.dirtyFields, fieldName);
+          const existingValue = get(_formValues, fieldName);
+          const newValue = get(values, fieldName);
+          if (isDirty && !isUndefined(existingValue)) {
+            set(values, fieldName, existingValue);
+          } else if (!isDirty && !isUndefined(newValue)) {
+            setValue(fieldName, newValue);
+          }
         }
       } else {
         if (isWeb && isUndefined(formValues)) {
@@ -1680,54 +2258,81 @@ function createFormControl(props = {}, flushRootRender) {
             }
           }
         }
-        _fields = {};
+        if (keepStateOptions.keepFieldsRef) {
+          for (const fieldName of _names.mount) {
+            setValue(fieldName, get(values, fieldName));
+          }
+        } else {
+          _fields = {};
+        }
+      }
+      if (_options.shouldUnregister) {
+        _formValues = keepStateOptions.keepDefaultValues ? cloneObject(_defaultValues) : {};
+        if (keepStateOptions.keepFieldsRef) {
+          for (const fieldName of _names.mount) {
+            set(_formValues, fieldName, get(values, fieldName));
+          }
+        }
+      } else {
+        _formValues = cloneObject(values);
       }
-      _formValues = props.shouldUnregister ? keepStateOptions.keepDefaultValues ? cloneObject(_defaultValues) : {} : cloneObject(values);
       _subjects.array.next({
         values: { ...values }
       });
-      _subjects.values.next({
+      _subjects.state.next({
+        name: void 0,
+        type: void 0,
         values: { ...values }
       });
     }
     _names = {
-      mount: /* @__PURE__ */ new Set(),
+      mount: keepStateOptions.keepDirtyValues ? _names.mount : /* @__PURE__ */ new Set(),
       unMount: /* @__PURE__ */ new Set(),
       array: /* @__PURE__ */ new Set(),
+      registerName: /* @__PURE__ */ new Set(),
+      disabled: /* @__PURE__ */ new Set(),
       watch: /* @__PURE__ */ new Set(),
       watchAll: false,
       focus: ""
     };
-    !_state.mount && flushRootRender();
-    _state.mount = !_proxyFormState.isValid || !!keepStateOptions.keepIsValid;
-    _state.watch = !!props.shouldUnregister;
+    _state.mount = !_proxyFormState.isValid || !!keepStateOptions.keepIsValid || !!keepStateOptions.keepDirtyValues || !_options.shouldUnregister && !isEmptyObject(values);
+    _state.watch = !!_options.shouldUnregister;
+    _state.keepIsValid = !!keepStateOptions.keepIsValid;
+    _state.action = false;
+    if (!keepStateOptions.keepErrors) {
+      _formState.errors = {};
+    }
     _subjects.state.next({
       submitCount: keepStateOptions.keepSubmitCount ? _formState.submitCount : 0,
-      isDirty: keepStateOptions.keepDirty ? _formState.isDirty : !!(keepStateOptions.keepDefaultValues && !deepEqual(formValues, _defaultValues)),
+      isDirty: isEmptyResetValues ? false : keepStateOptions.keepDirty ? _formState.isDirty : keepStateOptions.keepValues ? _getDirty() : !!(keepStateOptions.keepDefaultValues && !deepEqual(formValues, _defaultValues)),
       isSubmitted: keepStateOptions.keepIsSubmitted ? _formState.isSubmitted : false,
-      dirtyFields: keepStateOptions.keepDirtyValues ? _formState.dirtyFields : keepStateOptions.keepDefaultValues && formValues ? getDirtyFields(_defaultValues, formValues) : {},
+      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 : {},
       touchedFields: keepStateOptions.keepTouched ? _formState.touchedFields : {},
       errors: keepStateOptions.keepErrors ? _formState.errors : {},
       isSubmitSuccessful: keepStateOptions.keepIsSubmitSuccessful ? _formState.isSubmitSuccessful : false,
-      isSubmitting: false
+      isSubmitting: false,
+      defaultValues: _defaultValues
     });
   };
-  const reset = (formValues, keepStateOptions) => _reset(isFunction(formValues) ? formValues(_formValues) : formValues, keepStateOptions);
+  const reset = (formValues, keepStateOptions) => _reset(isFunction(formValues) ? formValues(_formValues) : formValues, { ..._options.resetOptions, ...keepStateOptions });
   const setFocus = (name, options = {}) => {
     const field = get(_fields, name);
     const fieldReference = field && field._f;
     if (fieldReference) {
       const fieldRef = fieldReference.refs ? fieldReference.refs[0] : fieldReference.ref;
       if (fieldRef.focus) {
-        fieldRef.focus();
-        options.shouldSelect && fieldRef.select();
+        setTimeout(() => {
+          fieldRef.focus();
+          options.shouldSelect && isFunction(fieldRef.select) && fieldRef.select();
+        });
       }
     }
   };
-  const _updateFormState = (updatedFormState) => {
+  const _setFormState = (updatedFormState) => {
+    const { name, type, values, ...formState } = updatedFormState;
     _formState = {
       ..._formState,
-      ...updatedFormState
+      ...formState
     };
   };
   const _resetDefaultValues = () => isFunction(_options.defaultValues) && _options.defaultValues().then((values) => {
@@ -1736,28 +2341,45 @@ function createFormControl(props = {}, flushRootRender) {
       isLoading: false
     });
   });
-  return {
+  const resetDefaultValues = (values, options = {}) => {
+    _defaultValues = cloneObject(values);
+    if (!options.keepDirty) {
+      const newDirtyFields = getDirtyFields(_defaultValues, _formValues, void 0, _fields);
+      _formState.dirtyFields = newDirtyFields;
+      _formState.isDirty = !isEmptyObject(newDirtyFields);
+    }
+    if (!options.keepIsValid) {
+      _setValid();
+    }
+    _subjects.state.next({
+      ..._formState,
+      defaultValues: _defaultValues
+    });
+  };
+  const methods = {
     control: {
       register,
       unregister,
       getFieldState,
       handleSubmit,
       setError,
-      _executeSchema,
+      _subscribe,
+      _runSchema,
+      _updateIsValidating,
+      _focusError,
       _getWatch,
       _getDirty,
-      _updateValid,
-      _removeUnmounted,
-      _updateFieldArray,
-      _updateDisabledField,
+      _setValid,
+      _setFieldArray,
+      _setDisabledField,
+      _setErrors,
       _getFieldArray,
       _reset,
       _resetDefaultValues,
-      _updateFormState,
+      _removeUnmounted,
       _disableForm,
       _subjects,
       _proxyFormState,
-      _setErrors,
       get _fields() {
         return _fields;
       },
@@ -1782,9 +2404,6 @@ function createFormControl(props = {}, flushRootRender) {
       get _formState() {
         return _formState;
       },
-      set _formState(value) {
-        _formState = value;
-      },
       get _options() {
         return _options;
       },
@@ -1793,58 +2412,99 @@ function createFormControl(props = {}, flushRootRender) {
           ..._options,
           ...value
         };
+        _validationModeBeforeSubmit = getValidationModes(_options.mode);
+        _validationModeAfterSubmit = getValidationModes(_options.reValidateMode);
       }
     },
+    subscribe,
     trigger,
     register,
     handleSubmit,
     watch,
     setValue,
+    setValues,
     getValues,
     reset,
     resetField,
+    resetDefaultValues,
     clearErrors,
     unregister,
     setError,
     setFocus,
     getFieldState
   };
+  return {
+    ...methods,
+    formControl: methods
+  };
 }
 function useForm(props = {}) {
-  const _formControl = React__default.default.useRef();
-  const _values = React__default.default.useRef();
-  const [formState, updateFormState] = React__default.default.useState({
-    isDirty: false,
-    isValidating: false,
+  const _formControl = React__default.default.useRef(void 0);
+  const _values = React__default.default.useRef(void 0);
+  const _formControlProp = React__default.default.useRef(props.formControl);
+  const [formState, updateFormState] = React__default.default.useState(() => ({
+    ...cloneObject(DEFAULT_FORM_STATE),
     isLoading: isFunction(props.defaultValues),
-    isSubmitted: false,
-    isSubmitting: false,
-    isSubmitSuccessful: false,
-    isValid: false,
-    submitCount: 0,
-    dirtyFields: {},
-    touchedFields: {},
     errors: props.errors || {},
-    disabled: false,
+    disabled: props.disabled || false,
     defaultValues: isFunction(props.defaultValues) ? void 0 : props.defaultValues
-  });
-  if (!_formControl.current) {
-    _formControl.current = {
-      ...createFormControl(props, () => updateFormState((formState2) => ({ ...formState2 }))),
-      formState
-    };
+  }));
+  if (!_formControl.current || props.formControl && _formControlProp.current !== props.formControl) {
+    _formControlProp.current = props.formControl;
+    if (props.formControl) {
+      _formControl.current = {
+        ...props.formControl,
+        formState
+      };
+      if (props.defaultValues && !isFunction(props.defaultValues)) {
+        props.formControl.reset(props.defaultValues, props.resetOptions);
+      }
+    } else {
+      const { formControl, ...rest } = createFormControl(props);
+      _formControl.current = {
+        ...rest,
+        formState
+      };
+    }
   }
   const control = _formControl.current.control;
   control._options = props;
-  useSubscribe({
-    subject: control._subjects.state,
-    next: (value) => {
-      if (shouldRenderFormState(value, control._proxyFormState, control._updateFormState, true)) {
-        updateFormState({ ...control._formState });
-      }
-    }
-  });
+  useIsomorphicLayoutEffect(() => {
+    const sub = control._subscribe({
+      formState: control._proxyFormState,
+      callback: () => updateFormState({
+        ...control._formState,
+        defaultValues: control._defaultValues
+      }),
+      reRenderRoot: true
+    });
+    updateFormState((data) => ({
+      ...data,
+      isReady: true
+    }));
+    control._formState.isReady = true;
+    return sub;
+  }, [control]);
   React__default.default.useEffect(() => control._disableForm(props.disabled), [control, props.disabled]);
+  React__default.default.useEffect(() => {
+    if (props.mode) {
+      control._options.mode = props.mode;
+    }
+    if (props.reValidateMode) {
+      control._options.reValidateMode = props.reValidateMode;
+    }
+  }, [control, props.mode, props.reValidateMode]);
+  React__default.default.useEffect(() => {
+    if (props.errors) {
+      control._setErrors(props.errors);
+      control._focusError();
+    }
+  }, [control, props.errors]);
+  React__default.default.useEffect(() => {
+    props.shouldUnregister && control._subjects.state.next({
+      values: control._getWatch()
+    });
+  }, [control, props.shouldUnregister]);
   React__default.default.useEffect(() => {
     if (control._proxyFormState.isDirty) {
       const isDirty = control._getDirty();
@@ -1856,22 +2516,24 @@ function useForm(props = {}) {
     }
   }, [control, formState.isDirty]);
   React__default.default.useEffect(() => {
+    var _a;
     if (props.values && !deepEqual(props.values, _values.current)) {
-      control._reset(props.values, control._options.resetOptions);
+      control._reset(props.values, {
+        keepFieldsRef: true,
+        ...control._options.resetOptions
+      });
+      if (!((_a = control._options.resetOptions) === null || _a === void 0 ? void 0 : _a.keepIsValid)) {
+        control._setValid();
+      }
       _values.current = props.values;
       updateFormState((state) => ({ ...state }));
     } else {
       control._resetDefaultValues();
     }
-  }, [props.values, control]);
-  React__default.default.useEffect(() => {
-    if (props.errors) {
-      control._setErrors(props.errors);
-    }
-  }, [props.errors, control]);
+  }, [control, props.values]);
   React__default.default.useEffect(() => {
     if (!control._state.mount) {
-      control._updateValid();
+      control._setValid();
       control._state.mount = true;
     }
     if (control._state.watch) {
@@ -1880,7 +2542,7 @@ function useForm(props = {}) {
     }
     control._removeUnmounted();
   });
-  _formControl.current.formState = getProxyFormState(formState, control);
+  _formControl.current.formState = React__default.default.useMemo(() => getProxyFormState(formState, control), [control, formState]);
   return _formControl.current;
 }
 const jsonToText = (v) => v == null || v === "" ? "" : JSON.stringify(v, null, 2);