react-hook-form 7.48.2 → 7.49.1

package/dist/index.esm.mjs

@@ -64,15 +64,15 @@ var compact = (value) => Array.isArray(value) ? value.filter(Boolean) : [];
 
 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;
 };
 
@@ -343,7 +343,7 @@ var isKey = (value) => /^\w*$/.test(value);
 
 var stringToPath = (input) => compact(input.replace(/["|']|\]/g, '').split(/\.|\[/));
 
-function set(object, path, value) {
+var set = (object, path, value) => {
     let index = -1;
     const tempPath = isKey(path) ? [path] : stringToPath(path);
     const length = tempPath.length;
@@ -364,7 +364,7 @@ function set(object, path, value) {
         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.
@@ -407,8 +407,8 @@ function useController(props) {
     const _registerProps = React.useRef(control.register(name, {
         ...props.rules,
         value,
+        ...(isBoolean(props.disabled) ? { disabled: props.disabled } : {}),
     }));
-    _registerProps.current = control.register(name, props.rules);
     React.useEffect(() => {
         const _shouldUnregisterField = control._options.shouldUnregister || shouldUnregister;
         const updateMounted = (name, value) => {
@@ -689,6 +689,9 @@ const iterateFieldsByAction = (fields, action, fieldsNames, abortEarly) => {
                 else if (_f.ref && action(_f.ref, _f.name) && !abortEarly) {
                     break;
                 }
+                else {
+                    iterateFieldsByAction(currentField, action);
+                }
             }
             else if (isObject(currentField)) {
                 iterateFieldsByAction(currentField, action);
@@ -959,9 +962,10 @@ var validateField = async (field, formValues, validateAllFieldCriteria, shouldUs
     return error;
 };
 
-function append(data, value) {
-    return [...data, ...convertToArrayPayload(value)];
-}
+var appendAt = (data, value) => [
+    ...data,
+    ...convertToArrayPayload(value),
+];
 
 var fillEmptyArray = (value) => Array.isArray(value) ? value.map(() => undefined) : undefined;
 
@@ -984,9 +988,10 @@ var moveArrayAt = (data, from, to) => {
     return data;
 };
 
-function prepend(data, value) {
-    return [...convertToArrayPayload(value), ...convertToArrayPayload(data)];
-}
+var prependAt = (data, value) => [
+    ...convertToArrayPayload(value),
+    ...convertToArrayPayload(data),
+];
 
 function removeAtIndexes(data, indexes) {
     let i = 0;
@@ -1002,7 +1007,7 @@ var removeArrayAt = (data, index) => isUndefined(index)
     : removeAtIndexes(data, convertToArrayPayload(index).sort((a, b) => a - b));
 
 var swapArrayAt = (data, indexA, indexB) => {
-    data[indexA] = [data[indexB], (data[indexB] = data[indexA])][0];
+    [data[indexA], data[indexB]] = [data[indexB], data[indexA]];
 };
 
 function baseGet(object, updatePath) {
@@ -1112,25 +1117,25 @@ function useFieldArray(props) {
         _actioned.current = true;
         control._updateFieldArray(name, updatedFieldArrayValues);
     }, [control, name]);
-    const append$1 = (value, options) => {
+    const append = (value, options) => {
         const appendValue = convertToArrayPayload(cloneObject(value));
-        const updatedFieldArrayValues = append(control._getFieldArray(name), appendValue);
+        const updatedFieldArrayValues = appendAt(control._getFieldArray(name), appendValue);
         control._names.focus = getFocusFieldName(name, updatedFieldArrayValues.length - 1, options);
-        ids.current = append(ids.current, appendValue.map(generateId));
+        ids.current = appendAt(ids.current, appendValue.map(generateId));
         updateValues(updatedFieldArrayValues);
         setFields(updatedFieldArrayValues);
-        control._updateFieldArray(name, updatedFieldArrayValues, append, {
+        control._updateFieldArray(name, updatedFieldArrayValues, appendAt, {
             argA: fillEmptyArray(value),
         });
     };
-    const prepend$1 = (value, options) => {
+    const prepend = (value, options) => {
         const prependValue = convertToArrayPayload(cloneObject(value));
-        const updatedFieldArrayValues = prepend(control._getFieldArray(name), prependValue);
+        const updatedFieldArrayValues = prependAt(control._getFieldArray(name), prependValue);
         control._names.focus = getFocusFieldName(name, 0, options);
-        ids.current = prepend(ids.current, prependValue.map(generateId));
+        ids.current = prependAt(ids.current, prependValue.map(generateId));
         updateValues(updatedFieldArrayValues);
         setFields(updatedFieldArrayValues);
-        control._updateFieldArray(name, updatedFieldArrayValues, prepend, {
+        control._updateFieldArray(name, updatedFieldArrayValues, prependAt, {
             argA: fillEmptyArray(value),
         });
     };
@@ -1261,8 +1266,8 @@ function useFieldArray(props) {
     return {
         swap: React.useCallback(swap, [updateValues, name, control]),
         move: React.useCallback(move, [updateValues, name, control]),
-        prepend: React.useCallback(prepend$1, [updateValues, name, control]),
-        append: React.useCallback(append$1, [updateValues, name, control]),
+        prepend: React.useCallback(prepend, [updateValues, name, control]),
+        append: React.useCallback(append, [updateValues, name, control]),
         remove: React.useCallback(remove, [updateValues, name, control]),
         insert: React.useCallback(insert$1, [updateValues, name, control]),
         update: React.useCallback(update, [updateValues, name, control]),
@@ -1274,7 +1279,7 @@ function useFieldArray(props) {
     };
 }
 
-function createSubject() {
+var createSubject = () => {
     let _observers = [];
     const next = (value) => {
         for (const observer of _observers) {
@@ -1300,7 +1305,7 @@ function createSubject() {
         subscribe,
         unsubscribe,
     };
-}
+};
 
 var isPrimitive = (value) => isNullOrUndefined(value) || !isObjectType(value);
 
@@ -1526,7 +1531,7 @@ function createFormControl(props = {}, flushRootRender) {
         isValid: false,
         touchedFields: {},
         dirtyFields: {},
-        errors: {},
+        errors: _options.errors || {},
         disabled: false,
     };
     let _fields = {};
@@ -1626,6 +1631,13 @@ function createFormControl(props = {}, flushRootRender) {
             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) {
@@ -1644,15 +1656,16 @@ function createFormControl(props = {}, flushRootRender) {
         const output = {
             name,
         };
+        const disabledField = get(_fields, name) && get(_fields, name)._f.disabled;
         if (!isBlurEvent || shouldDirty) {
             if (_proxyFormState.isDirty) {
                 isPreviousDirty = _formState.isDirty;
                 _formState.isDirty = output.isDirty = _getDirty();
                 shouldUpdateField = isPreviousDirty !== output.isDirty;
             }
-            const isCurrentFieldPristine = 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;
@@ -2150,8 +2163,13 @@ function createFormControl(props = {}, flushRootRender) {
     const _disableForm = (disabled) => {
         if (isBoolean(disabled)) {
             _subjects.state.next({ disabled });
-            iterateFieldsByAction(_fields, (ref) => {
-                ref.disabled = disabled;
+            iterateFieldsByAction(_fields, (ref, name) => {
+                let requiredDisabledState = disabled;
+                const currentField = get(_fields, name);
+                if (currentField && isBoolean(currentField._f.disabled)) {
+                    requiredDisabledState || (requiredDisabledState = currentField._f.disabled);
+                }
+                ref.disabled = requiredDisabledState;
             }, 0, false);
         }
     };
@@ -2355,6 +2373,7 @@ function createFormControl(props = {}, flushRootRender) {
             _disableForm,
             _subjects,
             _proxyFormState,
+            _setErrors,
             get _fields() {
                 return _fields;
             },
@@ -2451,7 +2470,7 @@ function useForm(props = {}) {
         submitCount: 0,
         dirtyFields: {},
         touchedFields: {},
-        errors: {},
+        errors: props.errors || {},
         disabled: false,
         defaultValues: isFunction(props.defaultValues)
             ? undefined
@@ -2488,11 +2507,17 @@ function useForm(props = {}) {
         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.useEffect(() => {
+        if (props.errors) {
+            control._setErrors(props.errors);
+        }
+    }, [props.errors, control]);
     React.useEffect(() => {
         if (!control._state.mount) {
             control._updateValid();