@bombillazo/rhf-plus 7.62.0-plus.5 → 7.62.0-plus.7

package/dist/logic/createFormControl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createFormControl.d.ts","sourceRoot":"","sources":["../../src/logic/createFormControl.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAaV,WAAW,EACX,YAAY,EAgBZ,YAAY,EAIZ,aAAa,EAUd,MAAM,UAAU,CAAC;AAuDlB,wBAAgB,iBAAiB,CAC/B,YAAY,SAAS,WAAW,GAAG,WAAW,EAC9C,QAAQ,GAAG,GAAG,EACd,kBAAkB,GAAG,YAAY,EACjC,SAAS,SAAS,YAAY,GAAG,GAAG,EAEpC,KAAK,GAAE,YAAY,CACjB,YAAY,EACZ,QAAQ,EACR,kBAAkB,EAClB,SAAS,CACL,GACL,IAAI,CACL,aAAa,CAAC,YAAY,EAAE,QAAQ,EAAE,kBAAkB,EAAE,SAAS,CAAC,EACpE,WAAW,CACZ,GAAG;IACF,WAAW,EAAE,IAAI,CACf,aAAa,CAAC,YAAY,EAAE,QAAQ,EAAE,kBAAkB,EAAE,SAAS,CAAC,EACpE,WAAW,CACZ,CAAC;CACH,CAolDA"}
+{"version":3,"file":"createFormControl.d.ts","sourceRoot":"","sources":["../../src/logic/createFormControl.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAaV,WAAW,EACX,YAAY,EAgBZ,YAAY,EAIZ,aAAa,EAUd,MAAM,UAAU,CAAC;AAwDlB,wBAAgB,iBAAiB,CAC/B,YAAY,SAAS,WAAW,GAAG,WAAW,EAC9C,QAAQ,GAAG,GAAG,EACd,kBAAkB,GAAG,YAAY,EACjC,SAAS,SAAS,YAAY,GAAG,GAAG,EAEpC,KAAK,GAAE,YAAY,CACjB,YAAY,EACZ,QAAQ,EACR,kBAAkB,EAClB,SAAS,CACL,GACL,IAAI,CACL,aAAa,CAAC,YAAY,EAAE,QAAQ,EAAE,kBAAkB,EAAE,SAAS,CAAC,EACpE,WAAW,CACZ,GAAG;IACF,WAAW,EAAE,IAAI,CACf,aAAa,CAAC,YAAY,EAAE,QAAQ,EAAE,kBAAkB,EAAE,SAAS,CAAC,EACpE,WAAW,CACZ,CAAC;CACH,CAovDA"}

package/dist/logic/validateField.d.ts

@@ -1,4 +1,4 @@
 import type { Field, FieldValues, InternalFieldErrors, InternalNameSet } from '../types';
-declare const _default: <T extends FieldValues>(field: Field, disabledFieldNames: InternalNameSet, formValues: T, validateAllFieldCriteria: boolean, shouldUseNativeValidation?: boolean, isFieldArray?: boolean) => Promise<InternalFieldErrors>;
+declare const _default: <T extends FieldValues>(field: Field, skippedFieldNames: InternalNameSet, formValues: T, validateAllFieldCriteria: boolean, shouldUseNativeValidation?: boolean, isFieldArray?: boolean) => Promise<InternalFieldErrors>;
 export default _default;
 //# sourceMappingURL=validateField.d.ts.map

package/dist/logic/validateField.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validateField.d.ts","sourceRoot":"","sources":["../../src/logic/validateField.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,KAAK,EAEL,WAAW,EACX,mBAAmB,EACnB,eAAe,EAKhB,MAAM,UAAU,CAAC;yBAsBI,CAAC,SAAS,WAAW,EACzC,OAAO,KAAK,EACZ,oBAAoB,eAAe,EACnC,YAAY,CAAC,EACb,0BAA0B,OAAO,EACjC,4BAA4B,OAAO,EACnC,eAAe,OAAO,KACrB,OAAO,CAAC,mBAAmB,CAAC;AAP/B,wBAoQE"}
+{"version":3,"file":"validateField.d.ts","sourceRoot":"","sources":["../../src/logic/validateField.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,KAAK,EAEL,WAAW,EACX,mBAAmB,EACnB,eAAe,EAKhB,MAAM,UAAU,CAAC;yBAsBI,CAAC,SAAS,WAAW,EACzC,OAAO,KAAK,EACZ,mBAAmB,eAAe,EAClC,YAAY,CAAC,EACb,0BAA0B,OAAO,EACjC,4BAA4B,OAAO,EACnC,eAAe,OAAO,KACrB,OAAO,CAAC,mBAAmB,CAAC;AAP/B,wBAqQE"}

package/dist/react-server.esm.mjs

@@ -643,10 +643,10 @@ var getValueAndMessage = (validationData) => isObject(validationData) && !isRege
         message: '',
     };
 
-var validateField = async (field, disabledFieldNames, formValues, validateAllFieldCriteria, shouldUseNativeValidation, isFieldArray) => {
+var validateField = async (field, skippedFieldNames, formValues, validateAllFieldCriteria, shouldUseNativeValidation, isFieldArray) => {
     const { ref, refs, required, maxLength, minLength, min, max, pattern, validate, name, valueAsNumber, mount, } = field._f;
     const inputValue = get(formValues, name);
-    if (!mount || disabledFieldNames.has(name)) {
+    if (!mount || skippedFieldNames.has(name)) {
         return {};
     }
     const inputRef = refs ? refs[0] : ref;
@@ -835,6 +835,7 @@ const defaultOptions = {
     mode: VALIDATION_MODE.onSubmit,
     reValidateMode: VALIDATION_MODE.onChange,
     shouldFocusError: true,
+    shouldSkipReadOnlyValidation: false,
 };
 function createFormControl(props = {}) {
     let _options = {
@@ -845,6 +846,8 @@ function createFormControl(props = {}) {
     let _formState = {
         submitCount: 0,
         isDirty: false,
+        isDirtySinceSubmit: false,
+        hasBeenSubmitted: false,
         isReady: false,
         isLoading: _internalLoading,
         isValidating: false,
@@ -877,6 +880,7 @@ function createFormControl(props = {}) {
     let _names = {
         mount: new Set(),
         disabled: new Set(),
+        readonly: new Set(),
         unMount: new Set(),
         array: new Set(),
         watch: new Set(),
@@ -885,6 +889,8 @@ function createFormControl(props = {}) {
     let timer = 0;
     const _proxyFormState = {
         isDirty: false,
+        isDirtySinceSubmit: false,
+        hasBeenSubmitted: false,
         dirtyFields: false,
         validatingFields: false,
         touchedFields: false,
@@ -902,6 +908,8 @@ function createFormControl(props = {}) {
     };
     const shouldDisplayAllAssociatedErrors = _options.criteriaMode === VALIDATION_MODE.all;
     const id = createId(props.id);
+    // Track if form was ever submitted (persists through resets)
+    let _hasBeenSubmitted = false;
     const debounce = (callback) => (wait) => {
         clearTimeout(timer);
         timer = setTimeout(callback, wait);
@@ -1025,6 +1033,20 @@ function createFormControl(props = {}) {
                             _proxySubscribeFormState.dirtyFields) &&
                             isPreviousDirty !== !isCurrentFieldPristine);
             }
+            // Set isDirtySinceSubmit to true if form was ever submitted and a field value is being changed
+            // For change events (not blur/focus), always set if form was ever submitted
+            // shouldDirty is true for onChange events, false for blur
+            if ((_formState.isSubmitted || _hasBeenSubmitted) &&
+                !_formState.isDirtySinceSubmit &&
+                !isBlurEvent &&
+                !isFocusEvent &&
+                shouldDirty) {
+                _formState.isDirtySinceSubmit = output.isDirtySinceSubmit = true;
+                shouldUpdateField =
+                    shouldUpdateField ||
+                        !!(_proxyFormState.isDirtySinceSubmit ||
+                            _proxySubscribeFormState.isDirtySinceSubmit);
+            }
             if (isBlurEvent) {
                 const isPreviousFieldTouched = get(_formState.touchedFields, name);
                 if (!isPreviousFieldTouched) {
@@ -1126,7 +1148,12 @@ function createFormControl(props = {}) {
                     if (isPromiseFunction && _proxyFormState.validatingFields) {
                         _updateIsValidating([name], true);
                     }
-                    const fieldError = await validateField(field, _names.disabled, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation && !shouldOnlyCheckValid, isFieldArrayRoot);
+                    // Combine disabled and readonly field names for validation skipping
+                    const skipValidationFields = new Set([
+                        ..._names.disabled,
+                        ..._names.readonly,
+                    ]);
+                    const fieldError = await validateField(field, skipValidationFields, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation && !shouldOnlyCheckValid, isFieldArrayRoot);
                     if (isPromiseFunction && _proxyFormState.validatingFields) {
                         _updateIsValidating([name]);
                     }
@@ -1220,9 +1247,15 @@ function createFormControl(props = {}) {
                 }
             }
         }
-        (options.shouldDirty || options.shouldTouch) &&
+        const isSubmittedAndDirty = (_formState.isSubmitted || _hasBeenSubmitted) &&
+            !deepEqual(get(_defaultValues, name), fieldValue);
+        // If the form was submitted, track value changes for isDirtySinceSubmit
+        // only when the value actually differs from the default value,
+        // even if shouldDirty is not explicitly set
+        const shouldTrackChange = options.shouldDirty || options.shouldTouch || isSubmittedAndDirty;
+        shouldTrackChange &&
             updateTouchAndDirty(name, fieldValue, options.shouldTouch, false, // isFocusEvent - not applicable for setValue
-            options.shouldDirty, true);
+            options.shouldDirty || isSubmittedAndDirty, true);
         options.shouldValidate && trigger(name);
     };
     const setValues = (name, value, options) => {
@@ -1254,12 +1287,25 @@ function createFormControl(props = {}) {
             if ((_proxyFormState.isDirty ||
                 _proxyFormState.dirtyFields ||
                 _proxySubscribeFormState.isDirty ||
-                _proxySubscribeFormState.dirtyFields) &&
+                _proxySubscribeFormState.dirtyFields ||
+                _proxyFormState.isDirtySinceSubmit ||
+                _proxySubscribeFormState.isDirtySinceSubmit) &&
                 options.shouldDirty) {
                 _subjects.state.next({
                     name,
                     dirtyFields: getDirtyFields(_defaultValues, _formValues),
                     isDirty: _getDirty(name, cloneValue),
+                    ...((_formState.isSubmitted || _hasBeenSubmitted) &&
+                        !_formState.isDirtySinceSubmit
+                        ? { isDirtySinceSubmit: true }
+                        : {}),
+                });
+            }
+            else if ((_formState.isSubmitted || _hasBeenSubmitted) &&
+                !_formState.isDirtySinceSubmit) {
+                _subjects.state.next({
+                    name,
+                    isDirtySinceSubmit: true,
                 });
             }
         }
@@ -1313,6 +1359,36 @@ function createFormControl(props = {}) {
                 }
                 return;
             }
+            // Check if field is readonly and should skip validation (only when flag is enabled)
+            if (_options.shouldSkipReadOnlyValidation && target && target.readOnly) {
+                // Add to readonly fields set for validation skipping
+                _names.readonly.add(name);
+                // For readonly fields, we still want to update the form values
+                // but skip validation (similar to disabled fields behavior)
+                const fieldValue = target.type
+                    ? getFieldValue(field._f)
+                    : getEventValue(event);
+                const isBlurEvent = event.type === EVENTS.BLUR || event.type === EVENTS.FOCUS_OUT;
+                const isFocusEvent = event.type === EVENTS.FOCUS || event.type === EVENTS.FOCUS_IN;
+                const watched = isWatched(name, _names, isBlurEvent || isFocusEvent);
+                // Update form values but skip validation and error handling
+                set(_formValues, name, fieldValue);
+                // Update touch and dirty state
+                const fieldState = updateTouchAndDirty(name, fieldValue, isBlurEvent, isFocusEvent, !isBlurEvent);
+                const shouldRender = !isEmptyObject(fieldState) || watched;
+                !isBlurEvent &&
+                    _subjects.state.next({
+                        name,
+                        type: event.type,
+                        values: cloneObject(_formValues),
+                    });
+                return (shouldRender &&
+                    _subjects.state.next({ name, ...(watched ? {} : fieldState) }));
+            }
+            else if (_options.shouldSkipReadOnlyValidation) {
+                // Remove from readonly fields set if not readonly anymore (only when flag is enabled)
+                _names.readonly.delete(name);
+            }
             let error;
             let isValid;
             const fieldValue = target.type
@@ -1336,7 +1412,7 @@ function createFormControl(props = {}) {
             else if (field._f.onChange) {
                 field._f.onChange(event);
             }
-            const fieldState = updateTouchAndDirty(name, fieldValue, isBlurEvent, isFocusEvent);
+            const fieldState = updateTouchAndDirty(name, fieldValue, isBlurEvent, isFocusEvent, !isBlurEvent);
             const shouldRender = !isEmptyObject(fieldState) || watched;
             !isBlurEvent &&
                 _subjects.state.next({
@@ -1372,7 +1448,12 @@ function createFormControl(props = {}) {
             }
             else {
                 _updateIsValidating([name], true);
-                error = (await validateField(field, _names.disabled, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation))[name];
+                // Combine disabled and readonly field names for validation skipping
+                const skipValidationFields = new Set([
+                    ..._names.disabled,
+                    ..._names.readonly,
+                ]);
+                error = (await validateField(field, skipValidationFields, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation, false))[name];
                 _updateIsValidating([name]);
                 _updateIsFieldValueUpdated(fieldValue);
                 if (isFieldValueUpdated) {
@@ -1623,6 +1704,13 @@ function createFormControl(props = {}) {
                         },
                     });
                     updateValidAndValue(name, false, undefined, fieldRef);
+                    // Check if field is readonly and should skip validation (only when flag is enabled)
+                    if (_options.shouldSkipReadOnlyValidation &&
+                        fieldRef &&
+                        'readOnly' in fieldRef &&
+                        fieldRef.readOnly) {
+                        _names.readonly.add(name);
+                    }
                 }
                 else {
                     field = get(_fields, name, {});
@@ -1720,11 +1808,14 @@ function createFormControl(props = {}) {
             _focusError();
             setTimeout(_focusError);
         }
+        _hasBeenSubmitted = true; // Mark that form was submitted at least once
         _subjects.state.next({
             isSubmitted: true,
             isSubmitting: false,
             isSubmitSuccessful: isEmptyObject(_formState.errors) && !onValidError,
             submitCount: _formState.submitCount + 1,
+            isDirtySinceSubmit: false,
+            hasBeenSubmitted: _hasBeenSubmitted,
             errors: _formState.errors,
         });
         if (onValidError) {
@@ -1787,7 +1878,7 @@ function createFormControl(props = {}) {
                             if (isHTMLElement(fieldReference)) {
                                 const form = fieldReference.closest('form');
                                 if (form) {
-                                    form.reset();
+                                    HTMLFormElement.prototype.reset.call(form);
                                     break;
                                 }
                             }
@@ -1820,6 +1911,7 @@ function createFormControl(props = {}) {
             unMount: new Set(),
             array: new Set(),
             disabled: new Set(),
+            readonly: new Set(),
             watch: new Set(),
             watchAll: false,
             focus: '',
@@ -1839,6 +1931,8 @@ function createFormControl(props = {}) {
                     ? _formState.isDirty
                     : !!(keepStateOptions.keepDefaultValues &&
                         !deepEqual(formValues, _defaultValues)),
+            isDirtySinceSubmit: false,
+            hasBeenSubmitted: _hasBeenSubmitted, // Persist the hasBeenSubmitted flag
             isSubmitted: keepStateOptions.keepIsSubmitted
                 ? _formState.isSubmitted
                 : false,
@@ -1917,6 +2011,28 @@ function createFormControl(props = {}) {
             });
         }
     };
+    const _updateReadonlyFieldTracking = () => {
+        // Re-evaluate all registered fields and update readonly tracking
+        // based on current shouldSkipReadOnlyValidation flag and field readonly state
+        Object.keys(_fields).forEach((fieldName) => {
+            const field = get(_fields, fieldName);
+            if (field && field._f) {
+                // Get the actual DOM element reference
+                const fieldRef = field._f.refs ? field._f.refs[0] : field._f.ref;
+                if (fieldRef && 'readOnly' in fieldRef) {
+                    const isFieldReadonly = Boolean(fieldRef.readOnly);
+                    const shouldTrackAsReadonly = _options.shouldSkipReadOnlyValidation && isFieldReadonly;
+                    // Update readonly tracking set
+                    if (shouldTrackAsReadonly) {
+                        _names.readonly.add(fieldName);
+                    }
+                    else {
+                        _names.readonly.delete(fieldName);
+                    }
+                }
+            }
+        });
+    };
     const setMetadata = (metadata) => {
         let _metadata;
         if (!metadata) {
@@ -1961,6 +2077,7 @@ function createFormControl(props = {}) {
             _removeUnmounted,
             _disableForm,
             _updateIsLoading,
+            _updateReadonlyFieldTracking,
             _subjects,
             _proxyFormState,
             get _fields() {