@bonlineza/luxity-lib 2.34.1 → 2.34.3

package/LuxityFooter.js

@@ -7,93 +7,70 @@
   var React__default = 'default' in React ? React['default'] : React;
   var styled__default = 'default' in styled ? styled['default'] : styled;
 
-  function _extends() {
-    _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 target;
-    };
-    return _extends.apply(this, arguments);
-  }
-
-  function _taggedTemplateLiteral(strings, raw) {
-    if (!raw) {
-      raw = strings.slice(0);
-    }
-
-    return Object.freeze(Object.defineProperties(strings, {
-      raw: {
-        value: Object.freeze(raw)
-      }
-    }));
+  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 _slicedToArray(arr, i) {
-    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
-  }
-
-  function _arrayWithHoles(arr) {
-    if (Array.isArray(arr)) return arr;
+  function _arrayWithHoles(r) {
+    if (Array.isArray(r)) return r;
   }
-
-  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;
+  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]);
       }
-    } catch (err) {
-      _d = true;
-      _e = err;
-    } finally {
+      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 (!_n && _i["return"] != null) _i["return"]();
+        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 {
-        if (_d) throw _e;
+        try {
+          if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
+        } finally {
+          if (o) throw n;
+        }
       }
+      return a;
     }
-
-    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.");
   }
+  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, {
+      raw: {
+        value: Object.freeze(t)
+      }
+    }));
+  }
+  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;
+    }
+  }
 
   var isCheckBoxInput = (element) => element.type === 'checkbox';
 
@@ -159,18 +136,50 @@
 
   var isUndefined = (val) => val === undefined;
 
-  var get = (obj, path, defaultValue) => {
-      if (!path || !isObject(obj)) {
+  var get = (object, path, defaultValue) => {
+      if (!path || !isObject(object)) {
           return defaultValue;
       }
-      const result = compact(path.split(/[,[\].]+?/)).reduce((result, key) => isNullOrUndefined(result) ? result : result[key], obj);
-      return isUndefined(result) || result === obj
-          ? isUndefined(obj[path])
+      const result = compact(path.split(/[,[\].]+?/)).reduce((result, key) => isNullOrUndefined(result) ? result : result[key], object);
+      return isUndefined(result) || result === object
+          ? isUndefined(object[path])
               ? defaultValue
-              : obj[path]
+              : object[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__') {
+              return;
+          }
+          object[key] = newValue;
+          object = object[key];
+      }
+      return object;
+  };
+
   const EVENTS = {
       BLUR: 'blur',
       FOCUS_OUT: 'focusout',
@@ -256,33 +265,6 @@
       return formValues;
   };
 
-  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;
-  }
-
   var appendErrors = (name, validateAllFieldCriteria, errors, type, message) => validateAllFieldCriteria
       ? {
           ...errors[name],
@@ -293,28 +275,6 @@
       }
       : {};
 
-  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,
@@ -329,15 +289,41 @@
           [..._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 = compact(get(errors, name));
+      const fieldArrayErrors = convertToArrayPayload(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';
@@ -629,7 +615,7 @@
       return object;
   }
 
-  function createSubject() {
+  var createSubject = () => {
       let _observers = [];
       const next = (value) => {
           for (const observer of _observers) {
@@ -655,7 +641,7 @@
           subscribe,
           unsubscribe,
       };
-  }
+  };
 
   var isPrimitive = (value) => isNullOrUndefined(value) || !isObjectType(value);
 
@@ -804,6 +790,13 @@
                   : 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 ||
@@ -865,7 +858,7 @@
       reValidateMode: VALIDATION_MODE.onChange,
       shouldFocusError: true,
   };
-  function createFormControl(props = {}, flushRootRender) {
+  function createFormControl(props = {}) {
       let _options = {
           ...defaultOptions,
           ...props,
@@ -881,7 +874,9 @@
           isValid: false,
           touchedFields: {},
           dirtyFields: {},
-          errors: {},
+          validatingFields: {},
+          errors: _options.errors || {},
+          disabled: _options.disabled || false,
       };
       let _fields = {};
       let _defaultValues = isObject(_options.defaultValues) || isObject(_options.values)
@@ -906,6 +901,7 @@
       const _proxyFormState = {
           isDirty: false,
           dirtyFields: false,
+          validatingFields: false,
           touchedFields: false,
           isValidating: false,
           isValid: false,
@@ -916,7 +912,6 @@
           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;
@@ -936,10 +931,21 @@
               }
           }
       };
-      const _updateIsValidating = (value) => _proxyFormState.isValidating &&
-          _subjects.state.next({
-              isValidating: value,
-          });
+      const _updateIsValidating = (names, isValidating) => {
+          if (_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 _updateFieldArray = (name, values = [], method, args, shouldSetValues = true, shouldUpdateFieldsAndState = true) => {
           if (args && method) {
               _state.action = true;
@@ -980,6 +986,13 @@
               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) {
@@ -998,15 +1011,18 @@
           const output = {
               name,
           };
+          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 = deepEqual(get(_defaultValues, name), fieldValue);
-              isPreviousDirty = get(_formState.dirtyFields, name);
-              isCurrentFieldPristine
+              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;
@@ -1060,9 +1076,13 @@
               };
               _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 _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 executeSchemaAndUpdateState = async (names) => {
           const { errors } = await _executeSchema(names);
           if (names) {
@@ -1087,7 +1107,14 @@
                   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, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation && !shouldOnlyCheckValid, isFieldArrayRoot);
+                      if (isPromiseFunction && _proxyFormState.validatingFields) {
+                          _updateIsValidating([name]);
+                      }
                       if (fieldError[_f.name]) {
                           context.valid = false;
                           if (shouldOnlyCheckValid) {
@@ -1101,7 +1128,7 @@
                                   : set(_formState.errors, _f.name, fieldError[_f.name])
                               : unset(_formState.errors, _f.name));
                   }
-                  fieldValue &&
+                  !isEmptyObject(fieldValue) &&
                       (await executeBuiltInValidation(fieldValue, shouldOnlyCheckValid, context));
               }
           }
@@ -1216,17 +1243,22 @@
           }
           isWatched(name, _names) && _subjects.state.next({ ..._formState });
           _subjects.values.next({
-              name,
+              name: _state.mount ? name : undefined,
               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) ||
+                      deepEqual(fieldValue, get(_formValues, name, fieldValue));
+          };
           if (field) {
               let error;
               let isValid;
@@ -1255,25 +1287,36 @@
                       values: { ..._formValues },
                   });
               if (shouldSkipValidation) {
-                  _proxyFormState.isValid && _updateValid();
+                  if (_proxyFormState.isValid) {
+                      if (props.mode === 'onBlur') {
+                          if (isBlurEvent) {
+                              _updateValid();
+                          }
+                      }
+                      else {
+                          _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]);
-                  const previousErrorLookupResult = schemaErrorLookup(_formState.errors, _fields, name);
-                  const errorLookupResult = schemaErrorLookup(errors, _fields, previousErrorLookupResult.name || name);
-                  error = errorLookupResult.error;
-                  name = errorLookupResult.name;
-                  isValid = isEmptyObject(errors);
+                  _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);
+                  }
               }
               else {
+                  _updateIsValidating([name], true);
                   error = (await validateField(field, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation))[name];
-                  isFieldValueUpdated =
-                      isNaN(fieldValue) ||
-                          fieldValue === get(_formValues, name, fieldValue);
+                  _updateIsValidating([name]);
+                  _updateIsFieldValueUpdated(fieldValue);
                   if (isFieldValueUpdated) {
                       if (error) {
                           isValid = false;
@@ -1290,11 +1333,17 @@
               }
           }
       };
+      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);
@@ -1319,17 +1368,15 @@
                   : { name }),
               ...(_options.resolver || !name ? { isValid } : {}),
               errors: _formState.errors,
-              isValidating: false,
           });
           options.shouldFocus &&
               !validationResult &&
-              focusFieldBy(_fields, (key) => key && get(_formState.errors, key), name ? fieldNames : _names.mount);
+              iterateFieldsByAction(_fields, _focusInput, name ? fieldNames : _names.mount);
           return validationResult;
       };
       const getValues = (fieldNames) => {
           const values = {
-              ..._defaultValues,
-              ...(_state.mount ? _formValues : {}),
+              ...(_state.mount ? _formValues : _defaultValues),
           };
           return isUndefined(fieldNames)
               ? values
@@ -1340,8 +1387,9 @@
       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),
+          isValidating: !!get(_formState.validatingFields, name),
+          isTouched: !!get((formState || _formState).touchedFields, name),
       });
       const clearErrors = (name) => {
           name &&
@@ -1352,7 +1400,11 @@
       };
       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,
           });
@@ -1379,6 +1431,8 @@
               !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);
@@ -1392,18 +1446,20 @@
           });
           !options.keepIsValid && _updateValid();
       };
-      const _updateDisabledField = ({ disabled, name, field, fields, }) => {
-          if (isBoolean(disabled)) {
-              const value = disabled
+      const _updateDisabledField = ({ disabled, name, field, fields, value, }) => {
+          if ((isBoolean(disabled) && _state.mount) || !!disabled) {
+              const inputValue = disabled
                   ? undefined
-                  : get(_formValues, name, getFieldValue(field ? field._f : get(fields, name)._f));
-              set(_formValues, name, value);
-              updateTouchAndDirty(name, value, false, false, true);
+                  : isUndefined(value)
+                      ? getFieldValue(field ? field._f : get(fields, name)._f)
+                      : value;
+              set(_formValues, name, inputValue);
+              updateTouchAndDirty(name, inputValue, false, false, true);
           }
       };
       const register = (name, options = {}) => {
           let field = get(_fields, name);
-          const disabledIsDefined = isBoolean(options.disabled);
+          const disabledIsDefined = isBoolean(options.disabled) || isBoolean(props.disabled);
           set(_fields, name, {
               ...(field || {}),
               _f: {
@@ -1417,15 +1473,20 @@
           if (field) {
               _updateDisabledField({
                   field,
-                  disabled: options.disabled,
+                  disabled: isBoolean(options.disabled)
+                      ? options.disabled
+                      : props.disabled,
                   name,
+                  value: options.value,
               });
           }
           else {
               updateValidAndValue(name, true, options.value);
           }
           return {
-              ...(disabledIsDefined ? { disabled: options.disabled } : {}),
+              ...(disabledIsDefined
+                  ? { disabled: options.disabled || props.disabled }
+                  : {}),
               ...(_options.progressive
                   ? {
                       required: !!options.required,
@@ -1485,8 +1546,25 @@
           };
       };
       const _focusError = () => _options.shouldFocusError &&
-          focusFieldBy(_fields, (key) => key && get(_formState.errors, key), _names.mount);
+          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);
+          }
+      };
       const handleSubmit = (onValid, onInvalid) => async (e) => {
+          let onValidError = undefined;
           if (e) {
               e.preventDefault && e.preventDefault();
               e.persist && e.persist();
@@ -1508,7 +1586,12 @@
               _subjects.state.next({
                   errors: {},
               });
-              await onValid(fieldValues, e);
+              try {
+                  await onValid(fieldValues, e);
+              }
+              catch (error) {
+                  onValidError = error;
+              }
           }
           else {
               if (onInvalid) {
@@ -1520,19 +1603,22 @@
           _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);
@@ -1540,7 +1626,7 @@
               if (!options.keepDirty) {
                   unset(_formState.dirtyFields, name);
                   _formState.isDirty = options.defaultValue
-                      ? _getDirty(name, get(_defaultValues, name))
+                      ? _getDirty(name, cloneObject(get(_defaultValues, name)))
                       : _getDirty();
               }
               if (!options.keepError) {
@@ -1553,14 +1639,13 @@
       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 = isEmptyResetValues ? _defaultValues : cloneUpdatedValues;
           if (!keepStateOptions.keepDefaultValues) {
               _defaultValues = updatedValues;
           }
           if (!keepStateOptions.keepValues) {
-              if (keepStateOptions.keepDirtyValues || shouldCaptureDirtyFields) {
+              if (keepStateOptions.keepDirtyValues) {
                   for (const fieldName of _names.mount) {
                       get(_formState.dirtyFields, fieldName)
                           ? set(values, fieldName, get(_formValues, fieldName))
@@ -1600,38 +1685,50 @@
               });
           }
           _names = {
-              mount: new Set(),
+              mount: keepStateOptions.keepDirtyValues ? _names.mount : new Set(),
               unMount: new Set(),
               array: new Set(),
               watch: new Set(),
               watchAll: false,
               focus: '',
           };
-          !_state.mount && flushRootRender();
-          _state.mount = !_proxyFormState.isValid || !!keepStateOptions.keepIsValid;
+          _state.mount =
+              !_proxyFormState.isValid ||
+                  !!keepStateOptions.keepIsValid ||
+                  !!keepStateOptions.keepDirtyValues;
           _state.watch = !!props.shouldUnregister;
           _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.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)
+                          : _formState.dirtyFields
+                      : keepStateOptions.keepDefaultValues && formValues
+                          ? getDirtyFields(_defaultValues, formValues)
+                          : keepStateOptions.keepDirty
+                              ? _formState.dirtyFields
+                              : {},
               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)
@@ -1681,8 +1778,10 @@
               _reset,
               _resetDefaultValues,
               _updateFormState,
+              _disableForm,
               _subjects,
               _proxyFormState,
+              _setErrors,
               get _fields() {
                   return _fields;
               },
@@ -1779,14 +1878,16 @@
           submitCount: 0,
           dirtyFields: {},
           touchedFields: {},
-          errors: {},
+          validatingFields: {},
+          errors: props.errors || {},
+          disabled: props.disabled || false,
           defaultValues: isFunction(props.defaultValues)
               ? undefined
               : props.defaultValues,
       });
       if (!_formControl.current) {
           _formControl.current = {
-              ...createFormControl(props, () => updateFormState((formState) => ({ ...formState }))),
+              ...createFormControl(props),
               formState,
           };
       }
@@ -1800,15 +1901,32 @@
               }
           },
       });
+      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();
@@ -1820,6 +1938,12 @@
           }
           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;
   }
@@ -1898,7 +2022,6 @@
     var action = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';
     var label = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : '';
     var value = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : '';
-
     if (track) {
       instance.event({
         category: category,
@@ -1912,12 +2035,10 @@
   var GALink = function GALink(props) {
     var gaOnClick = function gaOnClick(event) {
       Event(props.instance, props.track, 'Link', "Click on ".concat(props.href), props.label);
-
       if (typeof props.onClick === 'function') {
         props.onClick(event);
       }
     };
-
     return /*#__PURE__*/React__default.createElement("a", _extends({
       href: "/"
     }, props, {
@@ -1925,25 +2046,111 @@
     }), props.children);
   };
 
+  var _templateObject$1, _templateObject2, _templateObject3, _templateObject4, _templateObject5;
+
+  /* position relative is required for the Body element to be positioned correctly */
+  var relativeInlineStyle = styled.css(_templateObject$1 || (_templateObject$1 = _taggedTemplateLiteral(["\n  position: relative;\n"])));
+  var topMiddleBodyStyle = styled.css(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  position: absolute;\n  z-index: 1;\n  bottom: 50%;\n  left: 50%;\n  transform: translate(-50%, -50%);\n"])));
+  var getTopMiddleArrowAfterStyle = function getTopMiddleArrowAfterStyle(props) {
+    return styled.css(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  /*Bottom Arrow*/\n  top: 100%; /* At the bottom of the tooltip */\n  left: calc(50% - ", ");\n  border-width: ", ";\n  border-style: solid;\n  border-color: ", " transparent transparent transparent;\n"])), props.apexWidth, props.apexWidth, props.theme.colors.base);
+  };
+  var getBottomMiddleBodyStyle = function getBottomMiddleBodyStyle(props) {
+    return styled.css(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n  position: absolute;\n  top: 100%;\n  left: calc(50% - ", " / 2);\n"])), props.bodyWidth);
+  };
+  var getBottomMiddleArrowAfterStyle = function getBottomMiddleArrowAfterStyle(props) {
+    return styled.css(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["\n  /*Top Arrow*/\n  bottom: 100%; /* At the top of the tooltip */\n  top: initial;\n  left: 50%;\n  border-style: solid;\n  border-color: transparent transparent ", " transparent;\n"])), props.theme.colors.base);
+  };
+
+  var _templateObject$2;
+  var getBodyStyle = function getBodyStyle() {
+    var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var _props$toolTipPositio = props.toolTipPosition,
+      toolTipPosition = _props$toolTipPositio === void 0 ? '' : _props$toolTipPositio;
+    switch (toolTipPosition) {
+      case 'top':
+        return topMiddleBodyStyle;
+      case 'bottom':
+        return getBottomMiddleBodyStyle(props);
+      default:
+        return null;
+    }
+  };
+  var getAfterStyling = function getAfterStyling() {
+    var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var toolTipPosition = props.toolTipPosition;
+    switch (toolTipPosition) {
+      case 'top':
+        return getTopMiddleArrowAfterStyle(props);
+      case 'bottom':
+        return getBottomMiddleArrowAfterStyle(props);
+      default:
+        return '';
+    }
+  };
+  var Body = styled__default.span(_templateObject$2 || (_templateObject$2 = _taggedTemplateLiteral(["\n  ", ";\n  visibility: hidden;\n  opacity: 0;\n  width: ", ";\n  transition: visibility 0.3s linear, opacity 0.3s linear;\n  background-color: ", ";\n  color: white;\n  text-align: center;\n  border-radius: 5px;\n  ", "\n  &::after {\n    content: ' ';\n    position: absolute;\n    ", "\n  }\n"])), relativeInlineStyle, function (props) {
+    return props.bodyWidth;
+  }, function (props) {
+    return props.theme.colors.base || 'black';
+  }, function (props) {
+    return getBodyStyle(props);
+  }, function (props) {
+    return getAfterStyling(props);
+  });
+
+  var _templateObject$3;
+  var Container = styled__default.div(_templateObject$3 || (_templateObject$3 = _taggedTemplateLiteral(["\n  ", ";\n  cursor: pointer;\n  &:hover ", " {\n    opacity: 1;\n    visibility: visible;\n  }\n"])), relativeInlineStyle, Body);
+
+  var Tooltip = function Tooltip(_ref) {
+    var children = _ref.children,
+      toolTipText = _ref.toolTipText,
+      toolTipPosition = _ref.toolTipPosition,
+      bodyWidth = _ref.bodyWidth,
+      apexWidth = _ref.apexWidth,
+      containerClassName = _ref.containerClassName,
+      bodyClassName = _ref.bodyClassName;
+    return /*#__PURE__*/React__default.createElement(Container, {
+      className: containerClassName
+    }, children, /*#__PURE__*/React__default.createElement(Body, {
+      toolTipPosition: toolTipPosition,
+      bodyWidth: bodyWidth,
+      apexWidth: apexWidth,
+      className: bodyClassName
+    }, toolTipText));
+  };
+  Tooltip.defaultProps = {
+    children: null,
+    toolTipText: '',
+    toolTipPosition: 'top',
+    bodyWidth: '8em',
+    apexWidth: '5px',
+    containerClassName: '',
+    bodyClassName: ''
+  };
+  var Tooltip$1 = themed(Tooltip);
+
   var CurrencySelect = function CurrencySelect(_ref) {
     var currency = _ref.currency,
-        currencyOptions = _ref.currencyOptions,
-        onCurrencyChange = _ref.onCurrencyChange;
-
+      currencyOptions = _ref.currencyOptions,
+      onCurrencyChange = _ref.onCurrencyChange,
+      _ref$isCurrencySelect = _ref.isCurrencySelectionDisabled,
+      isCurrencySelectionDisabled = _ref$isCurrencySelect === void 0 ? false : _ref$isCurrencySelect,
+      _ref$tooltipContent = _ref.tooltipContent,
+      tooltipContent = _ref$tooltipContent === void 0 ? '' : _ref$tooltipContent;
     if (!currencyOptions || currencyOptions.length === 0) {
       return null;
     }
-
     var selectedOption = currencyOptions.find(function (opt) {
       return opt.value === currency;
     });
-
     if (!selectedOption) {
       return null;
     }
-
-    return /*#__PURE__*/React__default.createElement("div", {
-      className: "currency-select-container"
+    return /*#__PURE__*/React__default.createElement(Tooltip$1, {
+      toolTipText: isCurrencySelectionDisabled ? tooltipContent : '',
+      toolTipPosition: "bottom",
+      bodyWidth: "160px"
+    }, /*#__PURE__*/React__default.createElement("div", {
+      className: "currency-select-container ".concat(isCurrencySelectionDisabled ? 'disabled' : '')
     }, /*#__PURE__*/React__default.createElement("div", {
       className: "currency-flag"
     }, /*#__PURE__*/React__default.createElement("img", {
@@ -1954,51 +2161,51 @@
       onChange: function onChange(e) {
         return onCurrencyChange(e.target.value);
       },
-      className: "currency-select"
+      className: "currency-select",
+      disabled: isCurrencySelectionDisabled
     }, currencyOptions.map(function (option) {
       return /*#__PURE__*/React__default.createElement("option", {
         key: option.value,
         value: option.value
       }, option.value, " (", option.symbol, ")");
-    })));
+    }))));
   };
 
   var LuxityFooter = function LuxityFooter(_ref) {
     var _ref$showNewsletter = _ref.showNewsletter,
-        showNewsletter = _ref$showNewsletter === void 0 ? true : _ref$showNewsletter,
-        _ref$buyLinks = _ref.buyLinks,
-        buyLinks = _ref$buyLinks === void 0 ? [] : _ref$buyLinks,
-        _ref$sellLinks = _ref.sellLinks,
-        sellLinks = _ref$sellLinks === void 0 ? [] : _ref$sellLinks,
-        _ref$companyLinks = _ref.companyLinks,
-        companyLinks = _ref$companyLinks === void 0 ? [] : _ref$companyLinks,
-        _ref$storeLinks = _ref.storeLinks,
-        storeLinks = _ref$storeLinks === void 0 ? [] : _ref$storeLinks,
-        _ref$popularLinks = _ref.popularLinks,
-        popularLinks = _ref$popularLinks === void 0 ? [] : _ref$popularLinks,
-        _ref$socialLinks = _ref.socialLinks,
-        socialLinks = _ref$socialLinks === void 0 ? [] : _ref$socialLinks,
-        _ref$contactLinks = _ref.contactLinks,
-        contactLinks = _ref$contactLinks === void 0 ? [] : _ref$contactLinks,
-        visaImgSrc = _ref.visaImgSrc,
-        masterCardSrc = _ref.masterCardSrc,
-        paypalImgSrc = _ref.paypalImgSrc,
-        logoSrc = _ref.logoSrc,
-        formIconSrc = _ref.formIconSrc,
-        onSubmit = _ref.onSubmit,
-        currency = _ref.currency,
-        currencyOptions = _ref.currencyOptions,
-        onCurrencyChange = _ref.onCurrencyChange,
-        hideCurrencySelect = _ref.hideCurrencySelect;
+      showNewsletter = _ref$showNewsletter === void 0 ? true : _ref$showNewsletter,
+      _ref$buyLinks = _ref.buyLinks,
+      buyLinks = _ref$buyLinks === void 0 ? [] : _ref$buyLinks,
+      _ref$sellLinks = _ref.sellLinks,
+      sellLinks = _ref$sellLinks === void 0 ? [] : _ref$sellLinks,
+      _ref$companyLinks = _ref.companyLinks,
+      companyLinks = _ref$companyLinks === void 0 ? [] : _ref$companyLinks,
+      _ref$storeLinks = _ref.storeLinks,
+      storeLinks = _ref$storeLinks === void 0 ? [] : _ref$storeLinks,
+      _ref$popularLinks = _ref.popularLinks,
+      popularLinks = _ref$popularLinks === void 0 ? [] : _ref$popularLinks,
+      _ref$socialLinks = _ref.socialLinks,
+      socialLinks = _ref$socialLinks === void 0 ? [] : _ref$socialLinks,
+      _ref$contactLinks = _ref.contactLinks,
+      contactLinks = _ref$contactLinks === void 0 ? [] : _ref$contactLinks,
+      visaImgSrc = _ref.visaImgSrc,
+      masterCardSrc = _ref.masterCardSrc,
+      paypalImgSrc = _ref.paypalImgSrc,
+      logoSrc = _ref.logoSrc,
+      formIconSrc = _ref.formIconSrc,
+      onSubmit = _ref.onSubmit,
+      currency = _ref.currency,
+      currencyOptions = _ref.currencyOptions,
+      onCurrencyChange = _ref.onCurrencyChange,
+      isCurrencySelectionDisabled = _ref.isCurrencySelectionDisabled,
+      tooltipContent = _ref.tooltipContent;
     var currentYear = new Date().getFullYear();
-
     var _useForm = useForm(),
-        handleSubmit = _useForm.handleSubmit,
-        register = _useForm.register,
-        errors = _useForm.formState.errors,
-        reset = _useForm.reset,
-        setError = _useForm.setError;
-
+      handleSubmit = _useForm.handleSubmit,
+      register = _useForm.register,
+      errors = _useForm.formState.errors,
+      reset = _useForm.reset,
+      setError = _useForm.setError;
     var renderLinks = function renderLinks(links, title) {
       return /*#__PURE__*/React__default.createElement("div", {
         className: "footer__link-container"
@@ -2027,7 +2234,6 @@
         }), link.label));
       })));
     };
-
     var renderSocialLinks = function renderSocialLinks(links) {
       return /*#__PURE__*/React__default.createElement("div", {
         className: "footer__link-container"
@@ -2043,7 +2249,9 @@
         }, link.icon && /*#__PURE__*/React__default.createElement("img", {
           className: "footer__link-icon",
           src: link.icon,
-          alt: link.label
+          alt: link.label,
+          width: 30,
+          height: 30
         }));
       })), /*#__PURE__*/React__default.createElement("div", {
         className: "footer__links"
@@ -2062,16 +2270,13 @@
         }, link.label);
       })));
     };
-
     var AccordionSection = function AccordionSection(_ref2) {
       var title = _ref2.title,
-          links = _ref2.links;
-
+        links = _ref2.links;
       var _useState = React.useState(false),
-          _useState2 = _slicedToArray(_useState, 2),
-          isOpen = _useState2[0],
-          setIsOpen = _useState2[1];
-
+        _useState2 = _slicedToArray(_useState, 2),
+        isOpen = _useState2[0],
+        setIsOpen = _useState2[1];
       var contentRef = React.useRef(null);
       return /*#__PURE__*/React__default.createElement("div", {
         className: "border-b border-gray-200"
@@ -2097,7 +2302,6 @@
         }, link.label);
       })));
     };
-
     var submitForm = function submitForm(data) {
       onSubmit(data).then(function (res) {
         if (res.success) {
@@ -2110,7 +2314,6 @@
         }
       });
     };
-
     return /*#__PURE__*/React__default.createElement(FooterWrapper, null, showNewsletter && /*#__PURE__*/React__default.createElement("div", {
       className: "footer__newsletter-section"
     }, /*#__PURE__*/React__default.createElement("div", {
@@ -2175,10 +2378,12 @@
       className: "footer__copyright"
     }, "Copyright ", currentYear, " | Luxity (Pty) LTD | All Rights Reserved | Website Developed by B Online"))), /*#__PURE__*/React__default.createElement("div", {
       className: "footer__wrapper footer__wrapper--mobile"
-    }, !hideCurrencySelect && /*#__PURE__*/React__default.createElement(CurrencySelect, {
+    }, /*#__PURE__*/React__default.createElement(CurrencySelect, {
       currency: currency,
       currencyOptions: currencyOptions,
-      onCurrencyChange: onCurrencyChange
+      onCurrencyChange: onCurrencyChange,
+      isCurrencySelectionDisabled: isCurrencySelectionDisabled,
+      tooltipContent: tooltipContent
     }), /*#__PURE__*/React__default.createElement(AccordionSection, {
       title: "BUY",
       links: buyLinks
@@ -2200,7 +2405,6 @@
       className: "footer__copyright footer__copyright--mobile"
     }, "Copyright ", currentYear, " | Luxity (Pty) LTD | All Rights Reserved | Website Developed by B Online")));
   };
-
   var index = themed(LuxityFooter);
 
   return index;