@bonlineza/luxity-lib 2.36.1-beta.4 → 2.36.1

package/CommunicationPreferences.js

@@ -9,132 +9,169 @@
   EllipsisLoader = EllipsisLoader && Object.prototype.hasOwnProperty.call(EllipsisLoader, 'default') ? EllipsisLoader['default'] : EllipsisLoader;
   var Notifications__default = 'default' in Notifications ? Notifications['default'] : Notifications;
 
-  function _arrayLikeToArray(r, a) {
-    (null == a || a > r.length) && (a = r.length);
-    for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
-    return n;
+  function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+
+    if (Object.getOwnPropertySymbols) {
+      var symbols = Object.getOwnPropertySymbols(object);
+      enumerableOnly && (symbols = symbols.filter(function (sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      })), keys.push.apply(keys, symbols);
+    }
+
+    return keys;
   }
-  function _arrayWithHoles(r) {
-    if (Array.isArray(r)) return r;
+
+  function _objectSpread2(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = null != arguments[i] ? arguments[i] : {};
+      i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
+        _defineProperty(target, key, source[key]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+
+    return target;
   }
-  function _defineProperty(e, r, t) {
-    return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
-      value: t,
-      enumerable: !0,
-      configurable: !0,
-      writable: !0
-    }) : e[r] = t, e;
+
+  function _defineProperty(obj, key, value) {
+    if (key in obj) {
+      Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      obj[key] = value;
+    }
+
+    return obj;
   }
+
   function _extends() {
-    return _extends = Object.assign ? Object.assign.bind() : function (n) {
-      for (var e = 1; e < arguments.length; e++) {
-        var t = arguments[e];
-        for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
-      }
-      return n;
-    }, _extends.apply(null, arguments);
-  }
-  function _iterableToArrayLimit(r, l) {
-    var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
-    if (null != t) {
-      var e,
-        n,
-        i,
-        u,
-        a = [],
-        f = !0,
-        o = !1;
-      try {
-        if (i = (t = t.call(r)).next, 0 === l) {
-          if (Object(t) !== t) return;
-          f = !1;
-        } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
-      } catch (r) {
-        o = !0, n = r;
-      } finally {
-        try {
-          if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
-        } finally {
-          if (o) throw n;
+    _extends = Object.assign ? Object.assign.bind() : function (target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i];
+
+        for (var key in source) {
+          if (Object.prototype.hasOwnProperty.call(source, key)) {
+            target[key] = source[key];
+          }
         }
       }
-      return a;
-    }
-  }
-  function _nonIterableRest() {
-    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-  }
-  function ownKeys(e, r) {
-    var t = Object.keys(e);
-    if (Object.getOwnPropertySymbols) {
-      var o = Object.getOwnPropertySymbols(e);
-      r && (o = o.filter(function (r) {
-        return Object.getOwnPropertyDescriptor(e, r).enumerable;
-      })), t.push.apply(t, o);
-    }
-    return t;
+
+      return target;
+    };
+    return _extends.apply(this, arguments);
   }
-  function _objectSpread2(e) {
-    for (var r = 1; r < arguments.length; r++) {
-      var t = null != arguments[r] ? arguments[r] : {};
-      r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
-        _defineProperty(e, r, t[r]);
-      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
-        Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
-      });
+
+  function _objectWithoutPropertiesLoose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+
+    for (i = 0; i < sourceKeys.length; i++) {
+      key = sourceKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      target[key] = source[key];
     }
-    return e;
+
+    return target;
   }
-  function _objectWithoutProperties(e, t) {
-    if (null == e) return {};
-    var o,
-      r,
-      i = _objectWithoutPropertiesLoose(e, t);
+
+  function _objectWithoutProperties(source, excluded) {
+    if (source == null) return {};
+
+    var target = _objectWithoutPropertiesLoose(source, excluded);
+
+    var key, i;
+
     if (Object.getOwnPropertySymbols) {
-      var n = Object.getOwnPropertySymbols(e);
-      for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+      var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+
+      for (i = 0; i < sourceSymbolKeys.length; i++) {
+        key = sourceSymbolKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+        target[key] = source[key];
+      }
     }
-    return i;
+
+    return target;
   }
-  function _objectWithoutPropertiesLoose(r, e) {
-    if (null == r) return {};
-    var t = {};
-    for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
-      if (-1 !== e.indexOf(n)) continue;
-      t[n] = r[n];
+
+  function _taggedTemplateLiteral(strings, raw) {
+    if (!raw) {
+      raw = strings.slice(0);
     }
-    return t;
-  }
-  function _slicedToArray(r, e) {
-    return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
-  }
-  function _taggedTemplateLiteral(e, t) {
-    return t || (t = e.slice(0)), Object.freeze(Object.defineProperties(e, {
+
+    return Object.freeze(Object.defineProperties(strings, {
       raw: {
-        value: Object.freeze(t)
+        value: Object.freeze(raw)
       }
     }));
   }
-  function _toPrimitive(t, r) {
-    if ("object" != typeof t || !t) return t;
-    var e = t[Symbol.toPrimitive];
-    if (void 0 !== e) {
-      var i = e.call(t, r || "default");
-      if ("object" != typeof i) return i;
-      throw new TypeError("@@toPrimitive must return a primitive value.");
-    }
-    return ("string" === r ? String : Number)(t);
+
+  function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
   }
-  function _toPropertyKey(t) {
-    var i = _toPrimitive(t, "string");
-    return "symbol" == typeof i ? i : i + "";
+
+  function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
   }
-  function _unsupportedIterableToArray(r, a) {
-    if (r) {
-      if ("string" == typeof r) return _arrayLikeToArray(r, a);
-      var t = {}.toString.call(r).slice(8, -1);
-      return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+
+  function _iterableToArrayLimit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+
+    var _s, _e;
+
+    try {
+      for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+        _arr.push(_s.value);
+
+        if (i && _arr.length === i) break;
+      }
+    } catch (err) {
+      _d = true;
+      _e = err;
+    } finally {
+      try {
+        if (!_n && _i["return"] != null) _i["return"]();
+      } finally {
+        if (_d) throw _e;
+      }
     }
+
+    return _arr;
+  }
+
+  function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(o);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+  }
+
+  function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+
+    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+    return arr2;
+  }
+
+  function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
   }
 
   var isCheckBoxInput = (element) => element.type === 'checkbox';
@@ -171,14 +208,13 @@
   function cloneObject(data) {
       let copy;
       const isArray = Array.isArray(data);
-      const isFileListInstance = typeof FileList !== 'undefined' ? data instanceof FileList : false;
       if (data instanceof Date) {
           copy = new Date(data);
       }
       else if (data instanceof Set) {
           copy = new Set(data);
       }
-      else if (!(isWeb && (data instanceof Blob || isFileListInstance)) &&
+      else if (!(isWeb && (data instanceof Blob || data instanceof FileList)) &&
           (isArray || isObject(data))) {
           copy = isArray ? [] : {};
           if (!isArray && !isPlainObject(data)) {
@@ -202,50 +238,18 @@
 
   var isUndefined = (val) => val === undefined;
 
-  var get = (object, path, defaultValue) => {
-      if (!path || !isObject(object)) {
+  var get = (obj, path, defaultValue) => {
+      if (!path || !isObject(obj)) {
           return defaultValue;
       }
-      const result = compact(path.split(/[,[\].]+?/)).reduce((result, key) => isNullOrUndefined(result) ? result : result[key], object);
-      return isUndefined(result) || result === object
-          ? isUndefined(object[path])
+      const result = compact(path.split(/[,[\].]+?/)).reduce((result, key) => isNullOrUndefined(result) ? result : result[key], obj);
+      return isUndefined(result) || result === obj
+          ? isUndefined(obj[path])
               ? defaultValue
-              : object[path]
+              : obj[path]
           : result;
   };
 
-  var isBoolean = (value) => typeof value === 'boolean';
-
-  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])
-                          ? []
-                          : {};
-          }
-          if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
-              return;
-          }
-          object[key] = newValue;
-          object = object[key];
-      }
-      return object;
-  };
-
   const EVENTS = {
       BLUR: 'blur',
       FOCUS_OUT: 'focusout',
@@ -333,13 +337,15 @@
 
   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) ||
+  var shouldSubscribeByName = (name, signalName, exact) => exact && signalName
+      ? name === signalName ||
+          (Array.isArray(name) &&
+              name.some((currentName) => currentName && exact && currentName === signalName))
+      : !name ||
+          !signalName ||
+          name === signalName ||
+          convertToArrayPayload(name).some((currentName) => currentName &&
+              (currentName.startsWith(signalName) ||
                   signalName.startsWith(currentName)));
 
   function useSubscribe(props) {
@@ -397,7 +403,6 @@
           isLoading: false,
           dirtyFields: false,
           touchedFields: false,
-          validatingFields: false,
           isValidating: false,
           isValid: false,
           errors: false,
@@ -422,7 +427,7 @@
               _mounted.current = false;
           };
       }, [control]);
-      return React__default.useMemo(() => getProxyFormState(formState, control, _localProxyFormState.current, false), [formState, control]);
+      return getProxyFormState(formState, control, _localProxyFormState.current, false);
   }
 
   var isString = (value) => typeof value === 'string';
@@ -448,7 +453,7 @@
    *
    * @example
    * ```tsx
-   * const { control } = useForm();
+   * const { watch } = useForm();
    * const values = useWatch({
    *   name: "fieldName"
    *   control,
@@ -474,6 +479,33 @@
       return value;
   }
 
+  var isKey = (value) => /^\w*$/.test(value);
+
+  var stringToPath = (input) => compact(input.replace(/["|']|\]/g, '').split(/\.|\[/));
+
+  function 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;
+  }
+
   /**
    * Custom hook to work with controlled component, this function provide you with both form and field level state. Re-render is isolated at the hook level.
    *
@@ -511,79 +543,17 @@
       const formState = useFormState({
           control,
           name,
-          exact: true,
       });
       const _registerProps = React__default.useRef(control.register(name, {
           ...props.rules,
           value,
-          ...(isBoolean(props.disabled) ? { disabled: props.disabled } : {}),
       }));
-      const fieldState = React__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 field = React__default.useMemo(() => ({
-          name,
-          value,
-          ...(isBoolean(disabled) || formState.disabled
-              ? { disabled: formState.disabled || disabled }
-              : {}),
-          onChange: (event) => _registerProps.current.onChange({
-              target: {
-                  value: getEventValue(event),
-                  name: name,
-              },
-              type: EVENTS.CHANGE,
-          }),
-          onBlur: () => _registerProps.current.onBlur({
-              target: {
-                  value: get(control._formValues, name),
-                  name: name,
-              },
-              type: EVENTS.BLUR,
-          }),
-          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(),
-                  };
-              }
-          },
-      }), [
-          name,
-          control._formValues,
-          disabled,
-          formState.disabled,
-          value,
-          control._fields,
-      ]);
+      _registerProps.current = control.register(name, props.rules);
       React__default.useEffect(() => {
           const _shouldUnregisterField = control._options.shouldUnregister || shouldUnregister;
           const updateMounted = (name, value) => {
               const field = get(control._fields, name);
-              if (field && field._f) {
+              if (field) {
                   field._f.mount = value;
               }
           };
@@ -595,7 +565,6 @@
                   set(control._formValues, name, value);
               }
           }
-          !isArrayField && control.register(name);
           return () => {
               (isArrayField
                   ? _shouldUnregisterField && !control._state.action
@@ -611,11 +580,57 @@
               name,
           });
       }, [disabled, name, control]);
-      return React__default.useMemo(() => ({
-          field,
+      return {
+          field: {
+              name,
+              value,
+              disabled,
+              onChange: React__default.useCallback((event) => _registerProps.current.onChange({
+                  target: {
+                      value: getEventValue(event),
+                      name: name,
+                  },
+                  type: EVENTS.CHANGE,
+              }), [name]),
+              onBlur: React__default.useCallback(() => _registerProps.current.onBlur({
+                  target: {
+                      value: get(control._formValues, name),
+                      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(),
+                      };
+                  }
+              },
+          },
           formState,
-          fieldState,
-      }), [field, formState, fieldState]);
+          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),
+              },
+          }),
+      };
   }
 
   var appendErrors = (name, validateAllFieldCriteria, errors, type, message) => validateAllFieldCriteria
@@ -628,6 +643,28 @@
       }
       : {};
 
+  const focusFieldBy = (fields, callback, fieldsNames) => {
+      for (const key of fieldsNames || Object.keys(fields)) {
+          const field = get(fields, key);
+          if (field) {
+              const { _f, ...currentField } = field;
+              if (_f && callback(_f.name)) {
+                  if (_f.ref.focus) {
+                      _f.ref.focus();
+                      break;
+                  }
+                  else if (_f.refs && _f.refs[0].focus) {
+                      _f.refs[0].focus();
+                      break;
+                  }
+              }
+              else if (isObject(currentField)) {
+                  focusFieldBy(currentField, callback);
+              }
+          }
+      }
+  };
+
   var getValidationModes = (mode) => ({
       isOnSubmit: !mode || mode === VALIDATION_MODE.onSubmit,
       isOnBlur: mode === VALIDATION_MODE.onBlur,
@@ -642,41 +679,15 @@
           [..._names.watch].some((watchName) => name.startsWith(watchName) &&
               /^\.\w+/.test(name.slice(watchName.length))));
 
-  const iterateFieldsByAction = (fields, action, fieldsNames, abortEarly) => {
-      for (const key of fieldsNames || Object.keys(fields)) {
-          const field = get(fields, key);
-          if (field) {
-              const { _f, ...currentField } = field;
-              if (_f) {
-                  if (_f.refs && _f.refs[0] && action(_f.refs[0], key) && !abortEarly) {
-                      return true;
-                  }
-                  else if (_f.ref && action(_f.ref, _f.name) && !abortEarly) {
-                      return true;
-                  }
-                  else {
-                      if (iterateFieldsByAction(currentField, action)) {
-                          break;
-                      }
-                  }
-              }
-              else if (isObject(currentField)) {
-                  if (iterateFieldsByAction(currentField, action)) {
-                      break;
-                  }
-              }
-          }
-      }
-      return;
-  };
-
   var updateFieldArrayRootError = (errors, error, name) => {
-      const fieldArrayErrors = convertToArrayPayload(get(errors, name));
+      const fieldArrayErrors = compact(get(errors, name));
       set(fieldArrayErrors, 'root', error[name]);
       set(errors, name, fieldArrayErrors);
       return errors;
   };
 
+  var isBoolean = (value) => typeof value === 'boolean';
+
   var isFileInput = (element) => element.type === 'file';
 
   var isFunction = (value) => typeof value === 'function';
@@ -753,10 +764,10 @@
           message: '',
       };
 
-  var validateField = async (field, disabledFieldNames, formValues, validateAllFieldCriteria, shouldUseNativeValidation, isFieldArray) => {
-      const { ref, refs, required, maxLength, minLength, min, max, pattern, validate, name, valueAsNumber, mount, } = field._f;
+  var validateField = async (field, formValues, validateAllFieldCriteria, shouldUseNativeValidation, isFieldArray) => {
+      const { ref, refs, required, maxLength, minLength, min, max, pattern, validate, name, valueAsNumber, mount, disabled, } = field._f;
       const inputValue = get(formValues, name);
-      if (!mount || disabledFieldNames.has(name)) {
+      if (!mount || disabled) {
           return {};
       }
       const inputRef = refs ? refs[0] : ref;
@@ -968,7 +979,7 @@
       return object;
   }
 
-  var createSubject = () => {
+  function createSubject() {
       let _observers = [];
       const next = (value) => {
           for (const observer of _observers) {
@@ -994,7 +1005,7 @@
           subscribe,
           unsubscribe,
       };
-  };
+  }
 
   var isPrimitive = (value) => isNullOrUndefined(value) || !isObjectType(value);
 
@@ -1101,6 +1112,9 @@
 
   function getFieldValue(_f) {
       const ref = _f.ref;
+      if (_f.refs ? _f.refs.every((ref) => ref.disabled) : ref.disabled) {
+          return;
+      }
       if (isFileInput(ref)) {
           return ref.files;
       }
@@ -1140,14 +1154,6 @@
                   : rule.value
               : rule;
 
-  const ASYNC_FUNCTION = 'AsyncFunction';
-  var hasPromiseValidation = (fieldReference) => !!fieldReference &&
-      !!fieldReference.validate &&
-      !!((isFunction(fieldReference.validate) &&
-          fieldReference.validate.constructor.name === ASYNC_FUNCTION) ||
-          (isObject(fieldReference.validate) &&
-              Object.values(fieldReference.validate).find((validateFunction) => validateFunction.constructor.name === ASYNC_FUNCTION)));
-
   var hasValidation = (options) => options.mount &&
       (options.required ||
           options.min ||
@@ -1209,7 +1215,7 @@
       reValidateMode: VALIDATION_MODE.onChange,
       shouldFocusError: true,
   };
-  function createFormControl(props = {}) {
+  function createFormControl(props = {}, flushRootRender) {
       let _options = {
           ...defaultOptions,
           ...props,
@@ -1225,9 +1231,7 @@
           isValid: false,
           touchedFields: {},
           dirtyFields: {},
-          validatingFields: {},
-          errors: _options.errors || {},
-          disabled: _options.disabled || false,
+          errors: {},
       };
       let _fields = {};
       let _defaultValues = isObject(_options.defaultValues) || isObject(_options.values)
@@ -1243,7 +1247,6 @@
       };
       let _names = {
           mount: new Set(),
-          disabled: new Set(),
           unMount: new Set(),
           array: new Set(),
           watch: new Set(),
@@ -1253,7 +1256,6 @@
       const _proxyFormState = {
           isDirty: false,
           dirtyFields: false,
-          validatingFields: false,
           touchedFields: false,
           isValidating: false,
           isValid: false,
@@ -1264,6 +1266,7 @@
           array: createSubject(),
           state: createSubject(),
       };
+      const shouldCaptureDirtyFields = props.resetOptions && props.resetOptions.keepDirtyValues;
       const validationModeBeforeSubmit = getValidationModes(_options.mode);
       const validationModeAfterSubmit = getValidationModes(_options.reValidateMode);
       const shouldDisplayAllAssociatedErrors = _options.criteriaMode === VALIDATION_MODE.all;
@@ -1272,7 +1275,7 @@
           timer = setTimeout(callback, wait);
       };
       const _updateValid = async (shouldUpdateValid) => {
-          if (!_options.disabled && (_proxyFormState.isValid || shouldUpdateValid)) {
+          if (_proxyFormState.isValid || shouldUpdateValid) {
               const isValid = _options.resolver
                   ? isEmptyObject((await _executeSchema()).errors)
                   : await executeBuiltInValidation(_fields, true);
@@ -1283,24 +1286,12 @@
               }
           }
       };
-      const _updateIsValidating = (names, isValidating) => {
-          if (!_options.disabled &&
-              (_proxyFormState.isValidating || _proxyFormState.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 _updateIsValidating = (value) => _proxyFormState.isValidating &&
+          _subjects.state.next({
+              isValidating: value,
+          });
       const _updateFieldArray = (name, values = [], method, args, shouldSetValues = true, shouldUpdateFieldsAndState = true) => {
-          if (args && method && !_options.disabled) {
+          if (args && method) {
               _state.action = true;
               if (shouldUpdateFieldsAndState && Array.isArray(get(_fields, name))) {
                   const fieldValues = method(get(_fields, name), args.argA, args.argB);
@@ -1339,13 +1330,6 @@
               errors: _formState.errors,
           });
       };
-      const _setErrors = (errors) => {
-          _formState.errors = errors;
-          _subjects.state.next({
-              errors: _formState.errors,
-              isValid: false,
-          });
-      };
       const updateValidAndValue = (name, shouldSkipSetValueAs, value, ref) => {
           const field = get(_fields, name);
           if (field) {
@@ -1364,40 +1348,35 @@
           const output = {
               name,
           };
-          if (!_options.disabled) {
-              const disabledField = !!(get(_fields, name) &&
-                  get(_fields, name)._f &&
-                  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;
+          if (!isBlurEvent || shouldDirty) {
+              if (_proxyFormState.isDirty) {
+                  isPreviousDirty = _formState.isDirty;
+                  _formState.isDirty = output.isDirty = _getDirty();
+                  shouldUpdateField = isPreviousDirty !== output.isDirty;
+              }
+              const isCurrentFieldPristine = deepEqual(get(_defaultValues, name), fieldValue);
+              isPreviousDirty = get(_formState.dirtyFields, name);
+              isCurrentFieldPristine
+                  ? 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.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);
-                  }
+                          (_proxyFormState.touchedFields &&
+                              isPreviousFieldTouched !== isBlurEvent);
               }
-              shouldUpdateField && shouldRender && _subjects.state.next(output);
           }
+          shouldUpdateField && shouldRender && _subjects.state.next(output);
           return shouldUpdateField ? output : {};
       };
       const shouldRenderByError = (name, isValid, error, fieldState) => {
@@ -1405,9 +1384,9 @@
           const shouldUpdateValid = _proxyFormState.isValid &&
               isBoolean(isValid) &&
               _formState.isValid !== isValid;
-          if (_options.delayError && error) {
+          if (props.delayError && error) {
               delayErrorCallback = debounce(() => updateErrors(name, error));
-              delayErrorCallback(_options.delayError);
+              delayErrorCallback(props.delayError);
           }
           else {
               clearTimeout(timer);
@@ -1431,13 +1410,9 @@
               };
               _subjects.state.next(updatedFormState);
           }
+          _updateIsValidating(false);
       };
-      const _executeSchema = async (name) => {
-          _updateIsValidating(name, true);
-          const result = await _options.resolver(_formValues, _options.context, getResolverOptions(name || _names.mount, _fields, _options.criteriaMode, _options.shouldUseNativeValidation));
-          _updateIsValidating(name);
-          return result;
-      };
+      const _executeSchema = async (name) => _options.resolver(_formValues, _options.context, getResolverOptions(name || _names.mount, _fields, _options.criteriaMode, _options.shouldUseNativeValidation));
       const executeSchemaAndUpdateState = async (names) => {
           const { errors } = await _executeSchema(names);
           if (names) {
@@ -1462,14 +1437,7 @@
                   const { _f, ...fieldValue } = field;
                   if (_f) {
                       const isFieldArrayRoot = _names.array.has(_f.name);
-                      const isPromiseFunction = field._f && hasPromiseValidation(field._f);
-                      if (isPromiseFunction && _proxyFormState.validatingFields) {
-                          _updateIsValidating([name], true);
-                      }
-                      const fieldError = await validateField(field, _names.disabled, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation && !shouldOnlyCheckValid, isFieldArrayRoot);
-                      if (isPromiseFunction && _proxyFormState.validatingFields) {
-                          _updateIsValidating([name]);
-                      }
+                      const fieldError = await validateField(field, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation && !shouldOnlyCheckValid, isFieldArrayRoot);
                       if (fieldError[_f.name]) {
                           context.valid = false;
                           if (shouldOnlyCheckValid) {
@@ -1483,7 +1451,7 @@
                                   : set(_formState.errors, _f.name, fieldError[_f.name])
                               : unset(_formState.errors, _f.name));
                   }
-                  !isEmptyObject(fieldValue) &&
+                  fieldValue &&
                       (await executeBuiltInValidation(fieldValue, shouldOnlyCheckValid, context));
               }
           }
@@ -1500,9 +1468,8 @@
           }
           _names.unMount = new Set();
       };
-      const _getDirty = (name, data) => !_options.disabled &&
-          (name && data && set(_formValues, name, data),
-              !deepEqual(getValues(), _defaultValues));
+      const _getDirty = (name, data) => (name && data && set(_formValues, name, data),
+          !deepEqual(getValues(), _defaultValues));
       const _getWatch = (names, defaultValue, isGlobal) => generateWatchOutput(names, _names, {
           ...(_state.mount
               ? _formValues
@@ -1512,7 +1479,7 @@
                       ? { [names]: defaultValue }
                       : defaultValue),
       }, isGlobal, defaultValue);
-      const _getFieldArray = (name) => compact(get(_state.mount ? _formValues : _defaultValues, name, _options.shouldUnregister ? get(_defaultValues, name, []) : []));
+      const _getFieldArray = (name) => compact(get(_state.mount ? _formValues : _defaultValues, name, props.shouldUnregister ? get(_defaultValues, name, []) : []));
       const setFieldValue = (name, value, options = {}) => {
           const field = get(_fields, name);
           let fieldValue = value;
@@ -1566,7 +1533,7 @@
               const fieldName = `${name}.${fieldKey}`;
               const field = get(_fields, fieldName);
               (_names.array.has(name) ||
-                  isObject(fieldValue) ||
+                  !isPrimitive(fieldValue) ||
                   (field && !field._f)) &&
                   !isDateObject(fieldValue)
                   ? setValues(fieldName, fieldValue, options)
@@ -1599,23 +1566,17 @@
           }
           isWatched(name, _names) && _subjects.state.next({ ..._formState });
           _subjects.values.next({
-              name: _state.mount ? name : undefined,
+              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) ||
-                      (isDateObject(fieldValue) && isNaN(fieldValue.getTime())) ||
-                      deepEqual(fieldValue, get(_formValues, name, fieldValue));
-          };
           if (field) {
               let error;
               let isValid;
@@ -1644,34 +1605,25 @@
                       values: { ..._formValues },
                   });
               if (shouldSkipValidation) {
-                  if (_proxyFormState.isValid) {
-                      if (_options.mode === 'onBlur' && isBlurEvent) {
-                          _updateValid();
-                      }
-                      else if (!isBlurEvent) {
-                          _updateValid();
-                      }
-                  }
+                  _proxyFormState.isValid && _updateValid();
                   return (shouldRender &&
                       _subjects.state.next({ name, ...(watched ? {} : fieldState) }));
               }
               !isBlurEvent && watched && _subjects.state.next({ ..._formState });
+              _updateIsValidating(true);
               if (_options.resolver) {
                   const { errors } = await _executeSchema([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);
-                  }
+                  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 {
-                  _updateIsValidating([name], true);
-                  error = (await validateField(field, _names.disabled, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation))[name];
-                  _updateIsValidating([name]);
-                  _updateIsFieldValueUpdated(fieldValue);
+                  error = (await validateField(field, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation))[name];
+                  isFieldValueUpdated =
+                      isNaN(fieldValue) ||
+                          fieldValue === get(_formValues, name, fieldValue);
                   if (isFieldValueUpdated) {
                       if (error) {
                           isValid = false;
@@ -1688,17 +1640,11 @@
               }
           }
       };
-      const _focusInput = (ref, key) => {
-          if (get(_formState.errors, key) && ref.focus) {
-              ref.focus();
-              return 1;
-          }
-          return;
-      };
       const trigger = async (name, options = {}) => {
           let isValid;
           let validationResult;
           const fieldNames = convertToArrayPayload(name);
+          _updateIsValidating(true);
           if (_options.resolver) {
               const errors = await executeSchemaAndUpdateState(isUndefined(name) ? name : fieldNames);
               isValid = isEmptyObject(errors);
@@ -1723,15 +1669,17 @@
                   : { name }),
               ...(_options.resolver || !name ? { isValid } : {}),
               errors: _formState.errors,
+              isValidating: false,
           });
           options.shouldFocus &&
               !validationResult &&
-              iterateFieldsByAction(_fields, _focusInput, name ? fieldNames : _names.mount);
+              focusFieldBy(_fields, (key) => key && get(_formState.errors, key), name ? fieldNames : _names.mount);
           return validationResult;
       };
       const getValues = (fieldNames) => {
           const values = {
-              ...(_state.mount ? _formValues : _defaultValues),
+              ..._defaultValues,
+              ...(_state.mount ? _formValues : {}),
           };
           return isUndefined(fieldNames)
               ? values
@@ -1742,9 +1690,8 @@
       const getFieldState = (name, formState) => ({
           invalid: !!get((formState || _formState).errors, name),
           isDirty: !!get((formState || _formState).dirtyFields, name),
-          error: get((formState || _formState).errors, name),
-          isValidating: !!get(_formState.validatingFields, name),
           isTouched: !!get((formState || _formState).touchedFields, name),
+          error: get((formState || _formState).errors, name),
       });
       const clearErrors = (name) => {
           name &&
@@ -1755,11 +1702,7 @@
       };
       const setError = (name, error, options) => {
           const ref = (get(_fields, name, { _f: {} })._f || {}).ref;
-          const currentError = get(_formState.errors, name) || {};
-          // Don't override existing error messages elsewhere in the object tree.
-          const { ref: currentRef, message, type, ...restOfErrorTree } = currentError;
           set(_formState.errors, name, {
-              ...restOfErrorTree,
               ...error,
               ref,
           });
@@ -1786,8 +1729,6 @@
               !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);
@@ -1802,16 +1743,17 @@
           !options.keepIsValid && _updateValid();
       };
       const _updateDisabledField = ({ disabled, name, field, fields, }) => {
-          if ((isBoolean(disabled) && _state.mount) ||
-              !!disabled ||
-              _names.disabled.has(name)) {
-              disabled ? _names.disabled.add(name) : _names.disabled.delete(name);
-              updateTouchAndDirty(name, getFieldValue(field ? field._f : get(fields, name)._f), false, false, true);
+          if (isBoolean(disabled)) {
+              const value = disabled
+                  ? undefined
+                  : get(_formValues, name, getFieldValue(field ? field._f : get(fields, name)._f));
+              set(_formValues, name, value);
+              updateTouchAndDirty(name, value, false, false, true);
           }
       };
       const register = (name, options = {}) => {
           let field = get(_fields, name);
-          const disabledIsDefined = isBoolean(options.disabled) || isBoolean(_options.disabled);
+          const disabledIsDefined = isBoolean(options.disabled);
           set(_fields, name, {
               ...(field || {}),
               _f: {
@@ -1825,9 +1767,7 @@
           if (field) {
               _updateDisabledField({
                   field,
-                  disabled: isBoolean(options.disabled)
-                      ? options.disabled
-                      : _options.disabled,
+                  disabled: options.disabled,
                   name,
               });
           }
@@ -1835,9 +1775,7 @@
               updateValidAndValue(name, true, options.value);
           }
           return {
-              ...(disabledIsDefined
-                  ? { disabled: options.disabled || _options.disabled }
-                  : {}),
+              ...(disabledIsDefined ? { disabled: options.disabled } : {}),
               ...(_options.progressive
                   ? {
                       required: !!options.required,
@@ -1897,35 +1835,13 @@
           };
       };
       const _focusError = () => _options.shouldFocusError &&
-          iterateFieldsByAction(_fields, _focusInput, _names.mount);
-      const _disableForm = (disabled) => {
-          if (isBoolean(disabled)) {
-              _subjects.state.next({ disabled });
-              iterateFieldsByAction(_fields, (ref, name) => {
-                  const currentField = get(_fields, name);
-                  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;
-                          });
-                      }
-                  }
-              }, 0, false);
-          }
-      };
+          focusFieldBy(_fields, (key) => key && get(_formState.errors, key), _names.mount);
       const handleSubmit = (onValid, onInvalid) => async (e) => {
-          let onValidError = undefined;
           if (e) {
               e.preventDefault && e.preventDefault();
               e.persist && e.persist();
           }
           let fieldValues = cloneObject(_formValues);
-          if (_names.disabled.size) {
-              for (const name of _names.disabled) {
-                  set(fieldValues, name, undefined);
-              }
-          }
           _subjects.state.next({
               isSubmitting: true,
           });
@@ -1942,12 +1858,7 @@
               _subjects.state.next({
                   errors: {},
               });
-              try {
-                  await onValid(fieldValues, e);
-              }
-              catch (error) {
-                  onValidError = error;
-              }
+              await onValid(fieldValues, e);
           }
           else {
               if (onInvalid) {
@@ -1959,22 +1870,19 @@
           _subjects.state.next({
               isSubmitted: true,
               isSubmitting: false,
-              isSubmitSuccessful: isEmptyObject(_formState.errors) && !onValidError,
+              isSubmitSuccessful: isEmptyObject(_formState.errors),
               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, cloneObject(get(_defaultValues, name)));
+                  setValue(name, get(_defaultValues, name));
               }
               else {
                   setValue(name, options.defaultValue);
-                  set(_defaultValues, name, cloneObject(options.defaultValue));
+                  set(_defaultValues, name, options.defaultValue);
               }
               if (!options.keepTouched) {
                   unset(_formState.touchedFields, name);
@@ -1982,7 +1890,7 @@
               if (!options.keepDirty) {
                   unset(_formState.dirtyFields, name);
                   _formState.isDirty = options.defaultValue
-                      ? _getDirty(name, cloneObject(get(_defaultValues, name)))
+                      ? _getDirty(name, get(_defaultValues, name))
                       : _getDirty();
               }
               if (!options.keepError) {
@@ -1995,18 +1903,15 @@
       const _reset = (formValues, keepStateOptions = {}) => {
           const updatedValues = formValues ? cloneObject(formValues) : _defaultValues;
           const cloneUpdatedValues = cloneObject(updatedValues);
-          const isEmptyResetValues = isEmptyObject(formValues);
-          const values = isEmptyResetValues ? _defaultValues : cloneUpdatedValues;
+          const values = formValues && !isEmptyObject(formValues)
+              ? cloneUpdatedValues
+              : _defaultValues;
           if (!keepStateOptions.keepDefaultValues) {
               _defaultValues = updatedValues;
           }
           if (!keepStateOptions.keepValues) {
-              if (keepStateOptions.keepDirtyValues) {
-                  const fieldsToCheck = new Set([
-                      ..._names.mount,
-                      ...Object.keys(getDirtyFields(_defaultValues, _formValues)),
-                  ]);
-                  for (const fieldName of Array.from(fieldsToCheck)) {
+              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));
@@ -2032,7 +1937,7 @@
                   }
                   _fields = {};
               }
-              _formValues = _options.shouldUnregister
+              _formValues = props.shouldUnregister
                   ? keepStateOptions.keepDefaultValues
                       ? cloneObject(_defaultValues)
                       : {}
@@ -2045,51 +1950,38 @@
               });
           }
           _names = {
-              mount: keepStateOptions.keepDirtyValues ? _names.mount : new Set(),
+              mount: new Set(),
               unMount: new Set(),
               array: new Set(),
-              disabled: new Set(),
               watch: new Set(),
               watchAll: false,
               focus: '',
           };
-          _state.mount =
-              !_proxyFormState.isValid ||
-                  !!keepStateOptions.keepIsValid ||
-                  !!keepStateOptions.keepDirtyValues;
-          _state.watch = !!_options.shouldUnregister;
+          !_state.mount && flushRootRender();
+          _state.mount = !_proxyFormState.isValid || !!keepStateOptions.keepIsValid;
+          _state.watch = !!props.shouldUnregister;
           _subjects.state.next({
               submitCount: keepStateOptions.keepSubmitCount
                   ? _formState.submitCount
                   : 0,
-              isDirty: isEmptyResetValues
-                  ? false
-                  : keepStateOptions.keepDirty
-                      ? _formState.isDirty
-                      : !!(keepStateOptions.keepDefaultValues &&
-                          !deepEqual(formValues, _defaultValues)),
+              isDirty: keepStateOptions.keepDirty
+                  ? _formState.isDirty
+                  : !!(keepStateOptions.keepDefaultValues &&
+                      !deepEqual(formValues, _defaultValues)),
               isSubmitted: keepStateOptions.keepIsSubmitted
                   ? _formState.isSubmitted
                   : false,
-              dirtyFields: isEmptyResetValues
-                  ? {}
-                  : keepStateOptions.keepDirtyValues
-                      ? keepStateOptions.keepDefaultValues && _formValues
-                          ? getDirtyFields(_defaultValues, _formValues)
-                          : _formState.dirtyFields
-                      : keepStateOptions.keepDefaultValues && formValues
-                          ? getDirtyFields(_defaultValues, formValues)
-                          : keepStateOptions.keepDirty
-                              ? _formState.dirtyFields
-                              : {},
+              dirtyFields: keepStateOptions.keepDirtyValues
+                  ? _formState.dirtyFields
+                  : keepStateOptions.keepDefaultValues && formValues
+                      ? getDirtyFields(_defaultValues, formValues)
+                      : {},
               touchedFields: keepStateOptions.keepTouched
                   ? _formState.touchedFields
                   : {},
               errors: keepStateOptions.keepErrors ? _formState.errors : {},
-              isSubmitSuccessful: keepStateOptions.keepIsSubmitSuccessful
-                  ? _formState.isSubmitSuccessful
-                  : false,
               isSubmitting: false,
+              isSubmitSuccessful: false,
           });
       };
       const reset = (formValues, keepStateOptions) => _reset(isFunction(formValues)
@@ -2104,9 +1996,7 @@
                   : fieldReference.ref;
               if (fieldRef.focus) {
                   fieldRef.focus();
-                  options.shouldSelect &&
-                      isFunction(fieldRef.select) &&
-                      fieldRef.select();
+                  options.shouldSelect && fieldRef.select();
               }
           }
       };
@@ -2141,10 +2031,8 @@
               _reset,
               _resetDefaultValues,
               _updateFormState,
-              _disableForm,
               _subjects,
               _proxyFormState,
-              _setErrors,
               get _fields() {
                   return _fields;
               },
@@ -2228,8 +2116,8 @@
    * ```
    */
   function useForm(props = {}) {
-      const _formControl = React__default.useRef(undefined);
-      const _values = React__default.useRef(undefined);
+      const _formControl = React__default.useRef();
+      const _values = React__default.useRef();
       const [formState, updateFormState] = React__default.useState({
           isDirty: false,
           isValidating: false,
@@ -2241,16 +2129,14 @@
           submitCount: 0,
           dirtyFields: {},
           touchedFields: {},
-          validatingFields: {},
-          errors: props.errors || {},
-          disabled: props.disabled || false,
+          errors: {},
           defaultValues: isFunction(props.defaultValues)
               ? undefined
               : props.defaultValues,
       });
       if (!_formControl.current) {
           _formControl.current = {
-              ...createFormControl(props),
+              ...createFormControl(props, () => updateFormState((formState) => ({ ...formState }))),
               formState,
           };
       }
@@ -2264,32 +2150,15 @@
               }
           },
       });
-      React__default.useEffect(() => control._disableForm(props.disabled), [control, props.disabled]);
-      React__default.useEffect(() => {
-          if (control._proxyFormState.isDirty) {
-              const isDirty = control._getDirty();
-              if (isDirty !== formState.isDirty) {
-                  control._subjects.state.next({
-                      isDirty,
-                  });
-              }
-          }
-      }, [control, formState.isDirty]);
       React__default.useEffect(() => {
           if (props.values && !deepEqual(props.values, _values.current)) {
               control._reset(props.values, control._options.resetOptions);
               _values.current = props.values;
-              updateFormState((state) => ({ ...state }));
           }
           else {
               control._resetDefaultValues();
           }
       }, [props.values, control]);
-      React__default.useEffect(() => {
-          if (props.errors) {
-              control._setErrors(props.errors);
-          }
-      }, [props.errors, control]);
       React__default.useEffect(() => {
           if (!control._state.mount) {
               control._updateValid();
@@ -2301,12 +2170,6 @@
           }
           control._removeUnmounted();
       });
-      React__default.useEffect(() => {
-          props.shouldUnregister &&
-              control._subjects.values.next({
-                  values: control._getWatch(),
-              });
-      }, [props.shouldUnregister, control]);
       _formControl.current.formState = getProxyFormState(formState, control);
       return _formControl.current;
   }
@@ -2399,27 +2262,31 @@
   });
 
   var _excluded = ["ref"];
+
   var _templateObject$5, _templateObject2;
   var OptionsRow = styled__default.div(_templateObject$5 || (_templateObject$5 = _taggedTemplateLiteral(["\n  display: flex;\n  flex-wrap: nowrap;\n  flex-direction: row;\n"])));
   var Options = styled__default.div(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  display: flex;\n  flex-wrap: nowrap;\n  flex-direction: row;\n  flex-basis: 60%;\n"])));
+
   var CommunicationPreferenceOptionsRenderer = function CommunicationPreferenceOptionsRenderer(_ref) {
     var control = _ref.control,
-      name = _ref.name,
-      isDisabled = _ref.isDisabled,
-      options = _ref.options,
-      defaultValue = _ref.defaultValue,
-      setValue = _ref.setValue;
+        name = _ref.name,
+        isDisabled = _ref.isDisabled,
+        options = _ref.options,
+        defaultValue = _ref.defaultValue,
+        setValue = _ref.setValue;
+
     var _useController = useController({
-        name: name,
-        control: control,
-        defaultValue: defaultValue
-      }),
-      _useController$field = _useController.field,
-      ref = _useController$field.ref,
-      inputProps = _objectWithoutProperties(_useController$field, _excluded),
-      _useController$fieldS = _useController.fieldState,
-      invalid = _useController$fieldS.invalid,
-      error = _useController$fieldS.error;
+      name: name,
+      control: control,
+      defaultValue: defaultValue
+    }),
+        _useController$field = _useController.field,
+        ref = _useController$field.ref,
+        inputProps = _objectWithoutProperties(_useController$field, _excluded),
+        _useController$fieldS = _useController.fieldState,
+        invalid = _useController$fieldS.invalid,
+        error = _useController$fieldS.error;
+
     React.useEffect(function () {
       if (defaultValue) {
         setValue(name, defaultValue);
@@ -2449,15 +2316,16 @@
     return props.theme.colors.primary;
   });
   var SectionHeading = styled__default.div(_templateObject2$1 || (_templateObject2$1 = _taggedTemplateLiteral(["\n  padding: 5px 10px;\n"])));
+
   var CommunicationPreferenceSection = function CommunicationPreferenceSection(_ref) {
     var section_heading = _ref.section_heading,
-      description = _ref.description,
-      control = _ref.control,
-      name = _ref.name,
-      isDisabled = _ref.isDisabled,
-      options = _ref.options,
-      defaultValue = _ref.defaultValue,
-      setValue = _ref.setValue;
+        description = _ref.description,
+        control = _ref.control,
+        name = _ref.name,
+        isDisabled = _ref.isDisabled,
+        options = _ref.options,
+        defaultValue = _ref.defaultValue,
+        setValue = _ref.setValue;
     return /*#__PURE__*/React__default.createElement(SectionContainer, null, /*#__PURE__*/React__default.createElement(SectionHeading, null, section_heading), /*#__PURE__*/React__default.createElement(CommunicationPreferenceOptionsRenderer, {
       description: description,
       control: control,
@@ -2468,6 +2336,7 @@
       setValue: setValue
     }));
   };
+
   var CommunicationPreferenceSection$1 = themed(CommunicationPreferenceSection);
 
   var defaultNotifyTime = 5000;
@@ -2513,25 +2382,30 @@
     success: false,
     failed: false
   };
+
   var CommunicationPreferences = function CommunicationPreferences(_ref) {
     var header = _ref.header,
-      requestInstance = _ref.requestInstance,
-      updateNotificationsApi = _ref.updateNotificationsApi,
-      preferenceData = _ref.preferenceData,
-      btnClassName = _ref.btnClassName;
+        requestInstance = _ref.requestInstance,
+        updateNotificationsApi = _ref.updateNotificationsApi,
+        preferenceData = _ref.preferenceData,
+        btnClassName = _ref.btnClassName;
+
     var _useForm = useForm(),
-      handleSubmit = _useForm.handleSubmit,
-      control = _useForm.control,
-      setValue = _useForm.setValue;
+        handleSubmit = _useForm.handleSubmit,
+        control = _useForm.control,
+        setValue = _useForm.setValue;
+
     var _useState = React.useState(_objectSpread2({}, BaseRequest)),
-      _useState2 = _slicedToArray(_useState, 2),
-      requestState = _useState2[0],
-      setRequestState = _useState2[1];
+        _useState2 = _slicedToArray(_useState, 2),
+        requestState = _useState2[0],
+        setRequestState = _useState2[1];
+
     var _useState3 = React.useState(false),
-      _useState4 = _slicedToArray(_useState3, 2),
-      isEditing = _useState4[0],
-      setIsEditing = _useState4[1];
-    //
+        _useState4 = _slicedToArray(_useState3, 2),
+        isEditing = _useState4[0],
+        setIsEditing = _useState4[1]; //
+
+
     var communicationOptions = [{
       label: 'WhatsApp',
       value: 'WHATSAPP'
@@ -2539,9 +2413,11 @@
       label: 'Email',
       value: 'EMAIL'
     }];
+
     var updateRequestState = function updateRequestState(obj) {
       setRequestState(_objectSpread2(_objectSpread2({}, BaseRequest), obj));
     };
+
     var onSubmit = function onSubmit(form_data) {
       updateRequestState({
         loading: true
@@ -2570,6 +2446,7 @@
         }));
       });
     };
+
     return /*#__PURE__*/React__default.createElement(React.Fragment, null, requestState.loading && /*#__PURE__*/React__default.createElement(EllipsisLoader, null), header, /*#__PURE__*/React__default.createElement(CommunicationPreferenceContainer, null, /*#__PURE__*/React__default.createElement("form", {
       onSubmit: handleSubmit(onSubmit)
     }, /*#__PURE__*/React__default.createElement(CommunicationPreferenceSection$1, {
@@ -2597,6 +2474,7 @@
       }
     }, "Edit")))));
   };
+
   var index = themed(CommunicationPreferences);
 
   return index;